tools/firmware-utils/src/mkcasfw.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  *  Copyright (C) 2007 OpenWrt.org
   5  *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stdint.h>
  11 #include <string.h>
  12 #include <unistd.h>     /* for unlink() */
  13 #include <libgen.h>
  14 #include <getopt.h>     /* for getopt() */
  15 #include <stdarg.h>
  16 #include <errno.h>
  17 #include <sys/stat.h>
  18 #include <endian.h>     /* for __BYTE_ORDER */
  19 #if defined(__CYGWIN__)
  20 #  include <byteswap.h>
  21 #endif
  22
  23 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
  24 #  define HOST_TO_LE16(x)       (x)
  25 #  define HOST_TO_LE32(x)       (x)
  26 #  define LE16_TO_HOST(x)       (x)
  27 #  define LE32_TO_HOST(x)       (x)
  28 #else
  29 #  define HOST_TO_LE16(x)       bswap_16(x)
  30 #  define HOST_TO_LE32(x)       bswap_32(x)
  31 #  define LE16_TO_HOST(x)       bswap_16(x)
  32 #  define LE32_TO_HOST(x)       bswap_32(x)
  33 #endif
  34
  35 #define MAX_NUM_BLOCKS  2
  36 #define MAX_ARG_COUNT   32
  37 #define MAX_ARG_LEN     1024
  38 #define FILE_BUF_LEN    (16*1024)
  39 #define DEFAULT_PADC    0xFF
  40
  41 #define DEFAULT_BLOCK_ALIGN     0x10000U
  42
  43 #define CSUM_TYPE_NONE  0
  44 #define CSUM_TYPE_8     1
  45 #define CSUM_TYPE_16    2
  46 #define CSUM_TYPE_32    3
  47
  48 struct csum_state{
  49         int     size;
  50         uint32_t val;
  51         uint32_t tmp;
  52         int     odd;
  53 };
  54
  55 struct image_desc {
  56         int             need_file;
  57         char            *file_name;     /* name of the file */
  58         uint32_t        file_size;      /* length of the file */
  59
  60         uint32_t        csum;
  61         uint32_t        out_size;
  62         uint8_t         padc;
  63 };
  64
  65 struct fwhdr_nfs {
  66         uint32_t        type;
  67         uint32_t        kernel_offs;
  68         uint32_t        kernel_size;
  69         uint32_t        fs_offs;
  70         uint32_t        fs_size;
  71         uint32_t        kernel_csum;
  72         uint32_t        fs_csum;
  73         uint32_t        id;
  74 } __attribute__ ((packed));
  75
  76 struct fwhdr_cas {
  77         uint32_t        type;
  78         uint32_t        kernel_offs;
  79         uint32_t        kernel_size;
  80         uint32_t        id;
  81         uint32_t        kernel_csum;
  82         uint32_t        magic1;
  83         uint32_t        magic2;
  84         uint32_t        magic3;
  85 } __attribute__ ((packed));
  86
  87 union file_hdr {
  88         struct fwhdr_cas cas;
  89         struct fwhdr_nfs nfs;
  90 };
  91
  92 struct board_info {
  93         char            *model;
  94         char            *name;
  95         int             header_type;
  96         uint32_t        id;
  97         uint32_t        max_kernel_size;
  98         uint32_t        max_fs_size;
  99 };
 100
 101 #define HEADER_TYPE_NFS         0
 102 #define HEADER_TYPE_CAS         1
 103
 104 #define KERNEL_SIZE_CAS         (61*64*1024)
 105 #define KERNEL_SIZE_NFS         (52*64*1024)
 106 #define FS_SIZE_NFS             (9*64*1024)
 107
 108 #define CAS_MAGIC1      0x5241AA55
 109 #define CAS_MAGIC2      0x524F4741
 110 #define CAS_MAGIC3      0xD3F22D4E
 111
 112 /* Cellvision/SparkLAN products */
 113 #define MODEL_CAS_630           0x01000000
 114 #define MODEL_CAS_630W          0x01000000
 115 #define MODEL_CAS_670           0x01000000
 116 #define MODEL_CAS_670W          0x01000000
 117 #define MODEL_NFS_101U          0x01000000
 118 #define MODEL_NFS_101WU         0x01000003
 119 #define MODEL_NFS_202U          0x01000001
 120 #define MODEL_NFS_202WU         0x01000002
 121
 122 /* Corega products */
 123 #define MODEL_CG_NSADP          0x01000020 /* NFS-101U */
 124 #define MODEL_CG_NSADPCR        0x01000021 /* NFS-202U */
 125
 126 /* D-Link products */
 127 #define MODEL_DCS_950           0x01010102 /* CAS-630 */
 128 #define MODEL_DCS_950G          0x01020102 /* CAS-630W */
 129 #define MODEL_DNS_120           0x01000030 /* NFS-101U */
 130 #define MODEL_DNS_G120          0x01000032 /* NFS-101WU */
 131
 132 /* Digitus products */
 133 #define MODEL_DN_16021          MODEL_CAS_630
 134 #define MODEL_DN_16022          MODEL_CAS_630W
 135 #define MODEL_DN_16030          MODEL_CAS_670
 136 #define MODEL_DN_16031          MODEL_CAS_670W
 137 #define MODEL_DN_7013           MODEL_NFS_101U
 138
 139 /* Lobos products */
 140 #define MODEL_LB_SS01TXU        0x00000000
 141
 142 /* Neu-Fusion products */
 143
 144 /* Ovislink products */
 145 #define MODEL_MU_5000FS         0x01000040 /* NFS-101U */
 146 #define MODEL_WL_5420CAM        0x020B0101 /* CAS-630W? */
 147 #define MODEL_WL_5460CAM        0x020B0001 /* CAS-670W */
 148
 149 /* Repotec products */
 150
 151 /* Sitecom products */
 152 #define MODEL_LN_350            /* unknown */
 153 #define MODEL_LN_403            0x01020402
 154 #define MODEL_WL_401            0x01010402
 155
 156 /* Surecom products */
 157 #define MODEL_EP_4001_MM        0x01030A02 /* CAS-630 */
 158 #define MODEL_EP_4002_MM        0x01020A02 /* CAS-630W */
 159 #define MODEL_EP_4011_MM        0x01010A02 /* CAS-670 */
 160 #define MODEL_EP_4012_MM        0x01000A02 /* CAS-670W */
 161 #define MODEL_EP_9812_U         /* unknown */
 162
 163 /* Trendnet products */
 164 #define MODEL_TN_U100           0x01000081 /* NFS-101U */
 165 #define MODEL_TN_U200           0x01000082 /* NFS-202U */
 166
 167 /*
 168  * Globals
 169  */
 170 char *progname;
 171 char *ofname;
 172 int verblevel;
 173 int keep_invalid_images;
 174 int invalid_causes_error = 1;
 175 union file_hdr header;
 176
 177 struct image_desc kernel_image;
 178 struct image_desc fs_image;
 179
 180 struct board_info *board = NULL;
 181
 182 #define BOARD(m, n, i, ks, fs, h) {             \
 183                 .model = (m),                   \
 184                 .name = (n),                    \
 185                 .id = (i),                      \
 186                 .max_kernel_size = (ks),        \
 187                 .max_fs_size = (fs),            \
 188                 .header_type = (h)              \
 189         }
 190
 191 #define BOARD_CAS(m,n,i) \
 192                 BOARD(m, n, i, KERNEL_SIZE_CAS, 0, HEADER_TYPE_CAS)
 193 #define BOARD_NFS(m,n,i) \
 194                 BOARD(m, n, i, KERNEL_SIZE_NFS, FS_SIZE_NFS, HEADER_TYPE_NFS)
 195
 196 static struct board_info boards[] = {
 197         /* Cellvision/Sparklan products */
 198         BOARD_CAS("CAS-630", "Cellvision CAS-630", MODEL_CAS_630),
 199         BOARD_CAS("CAS-630W", "Cellvision CAS-630W", MODEL_CAS_630W),
 200         BOARD_CAS("CAS-670", "Cellvision CAS-670", MODEL_CAS_670),
 201         BOARD_CAS("CAS-670W", "Cellvision CAS-670W", MODEL_CAS_670W),
 202         BOARD_NFS("NFS-101U", "Cellvision NFS-101U", MODEL_NFS_101U),
 203         BOARD_NFS("NFS-101WU", "Cellvision NFS-101WU", MODEL_NFS_101WU),
 204         BOARD_NFS("NFS-202U", "Cellvision NFS-202U", MODEL_NFS_202U),
 205         BOARD_NFS("NFS-202WU", "Cellvision NFS-202WU", MODEL_NFS_202WU),
 206
 207         /* Corega products */
 208         BOARD_NFS("CG-NSADP", "Corega CG-NSADP", MODEL_CG_NSADP),
 209         BOARD_NFS("CG-NSADPCR", "Corega CG-NSADPCR", MODEL_CG_NSADPCR),
 210
 211         /* D-Link products */
 212         BOARD_CAS("DCS-950", "D-Link DCS-950", MODEL_DCS_950),
 213         BOARD_CAS("DCS-950G", "D-Link DCS-950G", MODEL_DCS_950G),
 214         BOARD_NFS("DNS-120", "D-Link DNS-120", MODEL_DNS_120),
 215         BOARD_NFS("DNS-G120", "D-Link DNS-G120", MODEL_DNS_G120),
 216
 217         /* Digitus products */
 218         BOARD_NFS("DN-7013", "Digitus DN-7013", MODEL_DN_7013),
 219
 220         /* Lobos products */
 221         BOARD_NFS("LB-SS01TXU", "Lobos LB-SS01TXU", MODEL_LB_SS01TXU),
 222
 223         /* Ovislink products */
 224         BOARD_NFS("MU-5000FS", "Ovislink MU-5000FS", MODEL_MU_5000FS),
 225         BOARD_CAS("WL-5420CAM", "Ovislink WL-5420 CAM", MODEL_WL_5420CAM),
 226         BOARD_CAS("WL-5460CAM", "Ovislink WL-5460 CAM", MODEL_WL_5460CAM),
 227
 228         /* Sitecom products */
 229         BOARD_CAS("LN-403", "Sitecom LN-403", MODEL_LN_403),
 230         BOARD_CAS("WL-401", "Sitecom WL-401", MODEL_WL_401),
 231
 232         /* Surecom products */
 233         BOARD_CAS("EP-4001-MM", "Surecom EP-4001-MM", MODEL_EP_4001_MM),
 234         BOARD_CAS("EP-4002-MM", "Surecom EP-4002-MM", MODEL_EP_4002_MM),
 235         BOARD_CAS("EP-4011-MM", "Surecom EP-4011-MM", MODEL_EP_4011_MM),
 236         BOARD_CAS("EP-4012-MM", "Surecom EP-4012-MM", MODEL_EP_4012_MM),
 237
 238         /* TrendNET products */
 239         BOARD_NFS("TN-U100", "TrendNET TN-U100", MODEL_TN_U100),
 240         BOARD_NFS("TN-U200", "TrendNET TN-U200", MODEL_TN_U200),
 241
 242         {.model = NULL}
 243 };
 244
 245 /*
 246  * Message macros
 247  */
 248 #define ERR(fmt, ...) do { \
 249         fflush(0); \
 250         fprintf(stderr, "[%s] *** error: " fmt "\n", \
 251                         progname, ## __VA_ARGS__ ); \
 252 } while (0)
 253
 254 #define ERRS(fmt, ...) do { \
 255         int save = errno; \
 256         fflush(0); \
 257         fprintf(stderr, "[%s] *** error: " fmt ": %s\n", \
 258                         progname, ## __VA_ARGS__, strerror(save)); \
 259 } while (0)
 260
 261 #define WARN(fmt, ...) do { \
 262         fprintf(stderr, "[%s] *** warning: " fmt "\n", \
 263                         progname, ## __VA_ARGS__ ); \
 264 } while (0)
 265
 266 #define DBG(lev, fmt, ...) do { \
 267         if (verblevel < lev) \
 268                 break;\
 269         fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
 270 } while (0)
 271
 272 #define ERR_FATAL               -1
 273 #define ERR_INVALID_IMAGE       -2
 274
 275 void
 276 usage(int status)
 277 {
 278         FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
 279         struct board_info *board;
 280
 281         fprintf(stream, "Usage: %s [OPTIONS...] <file>\n", progname);
 282         fprintf(stream,
 283 "\n"
 284 "Options:\n"
 285 "  -B <board>      create image for the board specified with <board>.\n"
 286 "                  valid <board> values:\n"
 287         );
 288         for (board = boards; board->model != NULL; board++){
 289                 fprintf(stream,
 290 "                  %-12s: %s\n",
 291                  board->model, board->name);
 292         };
 293         fprintf(stream,
 294 "  -d              don't throw error on invalid images\n"
 295 "  -k              keep invalid images\n"
 296 "  -K <file>       add kernel to the image\n"
 297 "  -C <file>       add custom filesystem to the image\n"
 298 "  -h              show this screen\n"
 299 "Parameters:\n"
 300 "  <file>          write output to the file <file>\n"
 301         );
 302
 303         exit(status);
 304 }
 305
 306 static inline uint32_t align(uint32_t base, uint32_t alignment)
 307 {
 308         uint32_t ret;
 309
 310         if (alignment) {
 311                 ret = (base + alignment - 1);
 312                 ret &= ~(alignment-1);
 313         } else {
 314                 ret = base;
 315         }
 316
 317         return ret;
 318 }
 319
 320 /*
 321  * argument parsing
 322  */
 323 int
 324 str2u32(char *arg, uint32_t *val)
 325 {
 326         char *err = NULL;
 327         uint32_t t;
 328
 329         errno=0;
 330         t = strtoul(arg, &err, 0);
 331         if (errno || (err==arg) || ((err != NULL) && *err)) {
 332                 return -1;
 333         }
 334
 335         *val = t;
 336         return 0;
 337 }
 338
 339
 340 int
 341 str2u16(char *arg, uint16_t *val)
 342 {
 343         char *err = NULL;
 344         uint32_t t;
 345
 346         errno=0;
 347         t = strtoul(arg, &err, 0);
 348         if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x10000)) {
 349                 return -1;
 350         }
 351
 352         *val = t & 0xFFFF;
 353         return 0;
 354 }
 355
 356 int
 357 str2u8(char *arg, uint8_t *val)
 358 {
 359         char *err = NULL;
 360         uint32_t t;
 361
 362         errno=0;
 363         t = strtoul(arg, &err, 0);
 364         if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x100)) {
 365                 return -1;
 366         }
 367
 368         *val = t & 0xFF;
 369         return 0;
 370 }
 371
 372 int
 373 parse_arg(char *arg, char *buf, char *argv[])
 374 {
 375         int res = 0;
 376         size_t argl;
 377         char *tok;
 378         char **ap = &buf;
 379         int i;
 380
 381         memset(argv, 0, MAX_ARG_COUNT * sizeof(void *));
 382
 383         if ((arg == NULL)) {
 384                 /* no arguments */
 385                 return 0;
 386         }
 387
 388         argl = strlen(arg);
 389         if (argl == 0) {
 390                 /* no arguments */
 391                 return 0;
 392         }
 393
 394         if (argl >= MAX_ARG_LEN) {
 395                 /* argument is too long */
 396                 argl = MAX_ARG_LEN-1;
 397         }
 398
 399         memcpy(buf, arg, argl);
 400         buf[argl] = '\0';
 401
 402         for (i = 0; i < MAX_ARG_COUNT; i++) {
 403                 tok = strsep(ap, ":");
 404                 if (tok == NULL) {
 405                         break;
 406                 }
 407 #if 0
 408                 else if (tok[0] == '\0') {
 409                         break;
 410                 }
 411 #endif
 412                 argv[i] = tok;
 413                 res++;
 414         }
 415
 416         return res;
 417 }
 418
 419
 420 int
 421 required_arg(char c, char *arg)
 422 {
 423         if (arg == NULL || *arg != '-')
 424                 return 0;
 425
 426         ERR("option -%c requires an argument\n", c);
 427         return ERR_FATAL;
 428 }
 429
 430
 431 int
 432 is_empty_arg(char *arg)
 433 {
 434         int ret = 1;
 435         if (arg != NULL) {
 436                 if (*arg) ret = 0;
 437         };
 438         return ret;
 439 }
 440
 441
 442 void
 443 csum8_update(uint8_t *p, uint32_t len, struct csum_state *css)
 444 {
 445         for ( ; len > 0; len --) {
 446                 css->val += *p++;
 447         }
 448 }
 449
 450
 451 uint16_t
 452 csum8_get(struct csum_state *css)
 453 {
 454         uint8_t t;
 455
 456         t = css->val;
 457         return ~t + 1;
 458 }
 459
 460
 461 void
 462 csum16_update(void *data, uint32_t len, struct csum_state *css)
 463 {
 464         uint8_t *p = data;
 465         uint16_t t;
 466
 467         if (css->odd) {
 468                 t = css->tmp + (p[0]<<8);
 469                 css->val += LE16_TO_HOST(t);
 470                 css->odd = 0;
 471                 len--;
 472                 p++;
 473         }
 474
 475         for ( ; len > 1; len -= 2, p +=2 ) {
 476                 t = p[0] + (p[1] << 8);
 477                 css->val += LE16_TO_HOST(t);
 478         }
 479
 480         if (len == 1) {
 481                 css->tmp = p[0];
 482                 css->odd = 1;
 483         }
 484 }
 485
 486
 487 uint16_t
 488 csum16_get(struct csum_state *css)
 489 {
 490         char pad = 0;
 491
 492         csum16_update(&pad, 1, css);
 493         return ~css->val + 1;
 494 }
 495
 496 void
 497 csum32_update(uint8_t *p, uint32_t len, struct csum_state *css)
 498 {
 499         uint32_t t;
 500
 501         for ( ; len > 3; len -= 4, p += 4 ) {
 502                 t = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
 503                 css->val ^= t;
 504         }
 505 }
 506
 507 uint32_t
 508 csum32_get(struct csum_state *css)
 509 {
 510         return css->val;
 511 }
 512
 513
 514 void
 515 csum_init(struct csum_state *css, int size)
 516 {
 517         css->val = 0;
 518         css->tmp = 0;
 519         css->odd = 0;
 520         css->size = size;
 521 }
 522
 523 void
 524 csum_update(void *data, uint32_t len, struct csum_state *css)
 525 {
 526         uint8_t *p = data;
 527
 528         switch (css->size) {
 529         case CSUM_TYPE_8:
 530                 csum8_update(p,len,css);
 531                 break;
 532         case CSUM_TYPE_16:
 533                 csum16_update(p,len,css);
 534                 break;
 535         case CSUM_TYPE_32:
 536                 csum32_update(p,len,css);
 537                 break;
 538         }
 539 }
 540
 541
 542 uint32_t
 543 csum_get(struct csum_state *css)
 544 {
 545         uint32_t ret;
 546
 547         switch (css->size) {
 548         case CSUM_TYPE_8:
 549                 ret = csum8_get(css);
 550                 break;
 551         case CSUM_TYPE_16:
 552                 ret = csum16_get(css);
 553                 break;
 554         case CSUM_TYPE_32:
 555                 ret = csum32_get(css);
 556                 break;
 557         default:
 558                 ERR("invalid checksum size\n");
 559                 return 0;
 560         }
 561
 562         return ret;
 563 }
 564
 565
 566 /*
 567  * routines to write data to the output file
 568  */
 569 int
 570 write_out_data(FILE *outfile, void *data, size_t len,
 571                 struct csum_state *css)
 572 {
 573         uint8_t *ptr = data;
 574
 575         errno = 0;
 576
 577         fwrite(ptr, len, 1, outfile);
 578         if (errno) {
 579                 ERRS("unable to write output file");
 580                 return ERR_FATAL;
 581         }
 582
 583         if (css) {
 584                 csum_update(ptr, len, css);
 585         }
 586
 587         return 0;
 588 }
 589
 590
 591 int
 592 write_out_padding(FILE *outfile, size_t len, uint8_t padc,
 593                  struct csum_state *css)
 594 {
 595         uint8_t buf[512];
 596         size_t buflen = sizeof(buf);
 597         int err;
 598
 599         memset(buf, padc, buflen);
 600         while (len > 0) {
 601                 if (len < buflen)
 602                         buflen = len;
 603
 604                 err = write_out_data(outfile, buf, buflen, css);
 605                 if (err)
 606                         return err;
 607
 608                 len -= buflen;
 609         }
 610
 611         return 0;
 612 }
 613
 614
 615 int
 616 image_stat_file(struct image_desc *desc)
 617 {
 618         struct stat st;
 619         int err;
 620
 621         if (desc->file_name == NULL)
 622                 return 0;
 623
 624         err = stat(desc->file_name, &st);
 625         if (err){
 626                 ERRS("stat failed on %s", desc->file_name);
 627                 return ERR_FATAL;
 628         }
 629
 630         if (st.st_size > desc->out_size) {
 631                 WARN("file %s is too big, will be truncated to %d bytes\n",
 632                         desc->file_name, desc->out_size);
 633                 desc->file_size = desc->out_size;
 634                 return ERR_INVALID_IMAGE;
 635         }
 636
 637
 638         desc->file_size = st.st_size;
 639         desc->out_size = align(desc->file_size,1);
 640         return 0;
 641 }
 642
 643
 644 int
 645 image_writeout_file(FILE *outfile, struct image_desc *desc,
 646                         struct csum_state *css)
 647 {
 648         char buf[FILE_BUF_LEN];
 649         size_t buflen = sizeof(buf);
 650         FILE *f;
 651         size_t len;
 652         int res;
 653
 654         if (desc->file_name == NULL)
 655                 return 0;
 656
 657         if (desc->file_size == 0)
 658                 return 0;
 659
 660         errno = 0;
 661         f = fopen(desc->file_name,"r");
 662         if (errno) {
 663                 ERRS("unable to open file: %s", desc->file_name);
 664                 return ERR_FATAL;
 665         }
 666
 667         len = desc->file_size;
 668         while (len > 0) {
 669                 if (len < buflen)
 670                         buflen = len;
 671
 672                 /* read data from source file */
 673                 errno = 0;
 674                 fread(buf, buflen, 1, f);
 675                 if (errno != 0) {
 676                         ERRS("unable to read from file: %s", desc->file_name);
 677                         res = ERR_FATAL;
 678                         break;
 679                 }
 680
 681                 res = write_out_data(outfile, buf, buflen, css);
 682                 if (res)
 683                         break;
 684
 685                 len -= buflen;
 686         }
 687
 688         fclose(f);
 689         return res;
 690 }
 691
 692
 693 int
 694 image_writeout(FILE *outfile, struct image_desc *desc)
 695 {
 696         int res;
 697         struct csum_state css;
 698         size_t padlen;
 699
 700         res = 0;
 701
 702         if (!desc->file_size)
 703                 return 0;
 704
 705         DBG(2, "writing image, file=%s, file_size=%d\n",
 706                 desc->file_name, desc->file_size);
 707
 708         csum_init(&css, CSUM_TYPE_32);
 709
 710         res = image_writeout_file(outfile, desc, &css);
 711         if (res)
 712                 return res;
 713
 714         /* write padding data if neccesary */
 715         padlen = desc->out_size - desc->file_size;
 716         DBG(1,"padding desc, length=%zu", padlen);
 717         res = write_out_padding(outfile, padlen, desc->padc, &css);
 718
 719         desc->csum = csum_get(&css);
 720
 721         return res;
 722 }
 723
 724
 725 int
 726 write_out_header(FILE *outfile)
 727 {
 728         union file_hdr tmp;
 729         int res;
 730
 731         errno = 0;
 732         if (fseek(outfile, 0, SEEK_SET) != 0) {
 733                 ERRS("fseek failed on output file");
 734                 return ERR_FATAL;
 735         }
 736
 737         switch (board->header_type) {
 738         case HEADER_TYPE_CAS:
 739                 tmp.cas.type = HOST_TO_LE32(header.cas.type);
 740                 tmp.cas.id = HOST_TO_LE32(header.cas.id);
 741                 tmp.cas.kernel_offs = HOST_TO_LE32(sizeof(tmp.cas));
 742                 tmp.cas.kernel_size = HOST_TO_LE32(kernel_image.out_size);
 743                 tmp.cas.kernel_csum = HOST_TO_LE32(kernel_image.csum);
 744                 tmp.cas.magic1 = HOST_TO_LE32(CAS_MAGIC1);
 745                 tmp.cas.magic2 = HOST_TO_LE32(CAS_MAGIC2);
 746                 tmp.cas.magic3 = HOST_TO_LE32(CAS_MAGIC3);
 747                 res = write_out_data(outfile, (uint8_t *)&tmp.cas,
 748                                         sizeof(tmp.cas), NULL);
 749                 break;
 750         case HEADER_TYPE_NFS:
 751                 tmp.nfs.type = HOST_TO_LE32(header.nfs.type);
 752                 tmp.nfs.id = HOST_TO_LE32(header.nfs.id);
 753                 tmp.nfs.kernel_offs = HOST_TO_LE32(sizeof(tmp.nfs));
 754                 tmp.nfs.kernel_size = HOST_TO_LE32(kernel_image.out_size);
 755                 tmp.nfs.kernel_csum = HOST_TO_LE32(kernel_image.csum);
 756                 tmp.nfs.fs_offs = HOST_TO_LE32(sizeof(tmp.nfs)
 757                                         + kernel_image.out_size);
 758                 tmp.nfs.fs_size = HOST_TO_LE32(fs_image.out_size);
 759                 tmp.nfs.fs_csum = HOST_TO_LE32(fs_image.csum);
 760                 res = write_out_data(outfile, (uint8_t *)&tmp.nfs,
 761                                         sizeof(tmp.nfs), NULL);
 762                 break;
 763         default:
 764                 ERR("invalid header type\n");
 765                 return -EINVAL;
 766         }
 767
 768         return res;
 769 }
 770
 771 int
 772 write_out_images(FILE *outfile)
 773 {
 774         int res;
 775
 776         res = image_writeout(outfile, &kernel_image);
 777         if (res)
 778                 return res;
 779
 780         res = image_writeout(outfile, &fs_image);
 781         if (res)
 782                 return res;
 783
 784         return 0;
 785 }
 786
 787
 788 struct board_info *
 789 find_board(char *model)
 790 {
 791         struct board_info *ret;
 792         struct board_info *board;
 793
 794         ret = NULL;
 795         for (board = boards; board->model != NULL; board++){
 796                 if (strcasecmp(model, board->model) == 0) {
 797                         ret = board;
 798                         break;
 799                 }
 800         };
 801
 802         return ret;
 803 }
 804
 805
 806 int
 807 parse_opt_board(char ch, char *arg)
 808 {
 809
 810         DBG(1,"parsing board option: -%c %s", ch, arg);
 811
 812         if (board != NULL) {
 813                 ERR("only one board option allowed");
 814                 return ERR_FATAL;
 815         }
 816
 817         if (required_arg(ch, arg))
 818                 return ERR_FATAL;
 819
 820         board = find_board(arg);
 821         if (board == NULL){
 822                 ERR("invalid/unknown board specified: %s", arg);
 823                 return ERR_FATAL;
 824         }
 825
 826         switch (board->header_type) {
 827         case HEADER_TYPE_CAS:
 828                 header.cas.type = HEADER_TYPE_CAS;
 829                 header.cas.id = board->id;
 830                 break;
 831         case HEADER_TYPE_NFS:
 832                 header.nfs.type = HEADER_TYPE_NFS;
 833                 header.nfs.id = board->id;
 834                 break;
 835         default:
 836                 ERR("internal error, unknown header type\n");
 837                 return ERR_FATAL;
 838         }
 839
 840         return 0;
 841 }
 842
 843
 844 int
 845 parse_opt_image(char ch, char *arg)
 846 {
 847         char buf[MAX_ARG_LEN];
 848         char *argv[MAX_ARG_COUNT];
 849         char *p;
 850         struct image_desc *desc = NULL;
 851         int i;
 852
 853         switch (ch) {
 854         case 'K':
 855                 if (kernel_image.file_name) {
 856                         WARN("only one kernel option allowed");
 857                         break;
 858                 }
 859                 desc = &kernel_image;
 860                 break;
 861         case 'F':
 862                 if (fs_image.file_name) {
 863                         WARN("only one fs option allowed");
 864                         break;
 865                 }
 866                 desc = &fs_image;
 867                 break;
 868         }
 869
 870         if (!desc)
 871                 return ERR_FATAL;
 872
 873         parse_arg(arg, buf, argv);
 874
 875         i = 0;
 876         p = argv[i++];
 877         if (!is_empty_arg(p)) {
 878                 desc->file_name = strdup(p);
 879                 if (desc->file_name == NULL) {
 880                         ERR("not enough memory");
 881                         return ERR_FATAL;
 882                 }
 883         } else {
 884                 ERR("no file specified for option %c", ch);
 885                 return ERR_FATAL;
 886         }
 887
 888         return 0;
 889 }
 890
 891
 892 int
 893 process_images(void)
 894 {
 895         int res;
 896
 897         kernel_image.out_size = board->max_kernel_size;
 898         kernel_image.padc = DEFAULT_PADC;
 899         res = image_stat_file(&kernel_image);
 900         if (res)
 901                 return res;
 902
 903         if (!fs_image.file_name)
 904                 return 0;
 905
 906         fs_image.out_size = board->max_fs_size;
 907         fs_image.padc = DEFAULT_PADC;
 908         res = image_stat_file(&fs_image);
 909         if (res)
 910                 return res;
 911
 912         return 0;
 913 }
 914
 915
 916 int
 917 main(int argc, char *argv[])
 918 {
 919         int optinvalid = 0;   /* flag for invalid option */
 920         int c;
 921         int res = ERR_FATAL;
 922
 923         FILE *outfile;
 924
 925         progname=basename(argv[0]);
 926
 927         opterr = 0;  /* could not print standard getopt error messages */
 928         while ( 1 ) {
 929                 optinvalid = 0;
 930
 931                 c = getopt(argc, argv, "B:C:dhK:r:vw:x:");
 932                 if (c == -1)
 933                         break;
 934
 935                 switch (c) {
 936                 case 'B':
 937                         optinvalid = parse_opt_board(c,optarg);
 938                         break;
 939                 case 'd':
 940                         invalid_causes_error = 0;
 941                         break;
 942                 case 'C':
 943                 case 'K':
 944                         optinvalid = parse_opt_image(c,optarg);
 945                         break;
 946                 case 'k':
 947                         keep_invalid_images = 1;
 948                         break;
 949                 case 'v':
 950                         verblevel++;
 951                         break;
 952                 case 'h':
 953                         usage(EXIT_SUCCESS);
 954                         break;
 955                 default:
 956                         optinvalid = 1;
 957                         break;
 958                 }
 959                 if (optinvalid != 0 ){
 960                         ERR("invalid option: -%c", optopt);
 961                         goto out;
 962                 }
 963         }
 964
 965         if (board == NULL) {
 966                 ERR("no board specified");
 967                 goto out;
 968         }
 969
 970         if (optind == argc) {
 971                 ERR("no output file specified");
 972                 goto out;
 973         }
 974
 975         ofname = argv[optind++];
 976
 977         if (optind < argc) {
 978                 ERR("invalid option: %s", argv[optind]);
 979                 goto out;
 980         }
 981
 982         res = process_images();
 983         if (res == ERR_FATAL)
 984                 goto out;
 985
 986         if (res == ERR_INVALID_IMAGE) {
 987                 if (invalid_causes_error)
 988                         res = ERR_FATAL;
 989
 990                 if (keep_invalid_images == 0) {
 991                         WARN("generation of invalid images \"%s\" disabled", ofname);
 992                         goto out;
 993                 }
 994
 995                 WARN("generating invalid image: \"%s\"", ofname);
 996         }
 997
 998         outfile = fopen(ofname, "w");
 999         if (outfile == NULL) {
1000                 ERRS("could not open \"%s\" for writing", ofname);
1001                 res = ERR_FATAL;
1002                 goto out;
1003         }
1004
1005         if (write_out_header(outfile) != 0) {
1006                 res = ERR_FATAL;
1007                 goto out_flush;
1008         }
1009
1010         if (write_out_images(outfile) != 0) {
1011                 res = ERR_FATAL;
1012                 goto out_flush;
1013         }
1014
1015         if (write_out_header(outfile) != 0) {
1016                 res = ERR_FATAL;
1017                 goto out_flush;
1018         }
1019
1020         DBG(1,"Image file %s completed.", ofname);
1021
1022 out_flush:
1023         fflush(outfile);
1024         fclose(outfile);
1025         if (res == ERR_FATAL) {
1026                 unlink(ofname);
1027         }
1028 out:
1029         if (res == ERR_FATAL)
1030                 return EXIT_FAILURE;
1031
1032         return EXIT_SUCCESS;
1033 }