tools/firmware-utils/src/mktitanimg.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <libgen.h>
   5 #include "mktitanimg.h"
   6
   7
   8 struct checksumrecord
   9 {
  10                 unsigned int magic;
  11         unsigned int    chksum;     /* The checksum for the complete header.
  12  Excepting the
  13                                            checksum block */
  14 };
  15 /***************************************************************************
  16  * void print_help(void)
  17  ***************************************************************************/
  18 void print_help(void)
  19 {
  20         static char* help_page[]=
  21         {
  22                 "mknspimg version 1.0, Texas Instruments, 2004",
  23                 "Syntax:",
  24                 "        mknspimg -o outfile -i image1 image2 -a align1 align2 [-v] [-b] [-p prod_id] [-r rel_id] [-s rel_name] [-f flags]",
  25                 "Example:",
  26                 "        mknspimg -o nsp_image.bin -i kernel.bin files.img -a 0 4096",
  27                 "This generates 'nsp_image.bin' from two input files aligning first to 0 and second to 4096 bytes."
  28         };
  29
  30         int num_lines = sizeof(help_page)/sizeof(char*);
  31         int i;
  32         for(i=0; i < num_lines; i++) {
  33                 printf("%s\n", help_page[i]);
  34         }
  35 }
  36
  37 /***************************************************************************
  38  * void mknspimg_print_hdr(NSP_IMG_HDR* p_img_hdr)
  39  ***************************************************************************/
  40 void mknspimg_print_hdr(struct nsp_img_hdr *hdr)
  41 {
  42         struct nsp_img_hdr_chksum       *chksum;
  43         struct nsp_img_hdr_section_info *sect_info;
  44         struct nsp_img_hdr_sections     *section;
  45         int i;
  46
  47         printf("****************** NSP Image Summary ******************\n");
  48         printf("Magic:             0x%x\n",             hdr->head.magic);
  49         printf("Image Header Size: 0x%x bytes\n",       hdr->head.hdr_size);
  50         printf("Total Image Size:  %d bytes\n",         hdr->head.image_size);
  51         printf("Product ID:        0x%x\n",             hdr->head.prod_id);
  52         printf("Release ID:        0x%x\n",             hdr->head.rel_id);
  53         printf("Version ID:        0x%x\n",             hdr->head.version);
  54
  55         printf("Offset Info:       0x%x\n",             hdr->head.info_offset);
  56         printf("Offset Sect info:  0x%x\n",             hdr->head.sect_info_offset);
  57         printf("Offset Sections:   0x%x\n",             hdr->sect_info.sections_offset);
  58
  59         chksum=(struct nsp_img_hdr_chksum *)(hdr+hdr->head.chksum_offset);
  60         printf("Header Checksum:   0x%x\n",             chksum->hdr_chksum);
  61
  62         printf("+++ Section Information +++\n");
  63         printf("# of sections:     %u\n", hdr->sect_info.num_sects);
  64         section=&(hdr->sections);
  65         for(i = 0; i < hdr->sect_info.num_sects; i++, section++) {
  66                 printf("+++++ Section %d +++++\n", i);
  67                 printf("Total size:  %u bytes\n",       section->total_size);
  68                 printf("Raw Size:    %u bytes\n",       section->raw_size);
  69                 printf("Offset:      0x%x\n",           section->offset);
  70                 printf("Type:        0x%x\n",           section->type);
  71                 printf("Name:        %s\n",             section->name);
  72         }
  73         printf("*******************************************************\n");
  74 }
  75
  76 CMDLINE_CFG     cmd_line_cfg =
  77 {
  78         {
  79                 /*      MIN     MAX     FLAGS                                   OPTION  */
  80                 {       2,      2,      (CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },     /* '-a' align1 align2 */
  81                 {       0,      0,      CMDLINE_OPTFLAG_ALLOW },                /* '-b' bootstrap */
  82                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-c' */
  83                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-d' */
  84                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-e' */
  85                 {       1,      1,      CMDLINE_OPTFLAG_ALLOW },                /* '-f' flags */
  86                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-g' */
  87                 {       1,      1,      CMDLINE_OPTFLAG_ALLOW },                /* '-h' */
  88                 {       2,      2,      (CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },     /* '-i arg1 arg2 ' */
  89                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-j' */
  90                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-k' */
  91                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-l' */
  92                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-m' */
  93                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-n' */
  94                 {       1,      1,      (CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },     /* '-o arg' */
  95                 {       1,      1,      CMDLINE_OPTFLAG_ALLOW },                /* '-p' PROD_ID */
  96                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-q' */
  97                 {       1,      1,      CMDLINE_OPTFLAG_ALLOW },                /* '-r' REL_ID */
  98                 {       1,      1,      CMDLINE_OPTFLAG_ALLOW },                /* '-s' "Release XXX.XXX" */
  99                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-t' */
 100                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-u' */
 101                 {       0,      0,      CMDLINE_OPTFLAG_ALLOW },                /* '-v' control VERBOSE/NON-VERBOSE mode */
 102                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-w' */
 103                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-x' */
 104                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW },               /* '-y' */
 105                 {       0,      0,      !CMDLINE_OPTFLAG_ALLOW }                /* '-z' */
 106         },
 107         {       0,              0,      !CMDLINE_OPTFLAG_ALLOW },               /* global arguments */
 108 };
 109
 110 /***************************************************************************
 111  * int nsp_img_write(void* image, char* file, int padding)
 112  * Write out the image.
 113  ***************************************************************************/
 114 int main(int argc, char* argv[], char* env[])
 115 {
 116         FILE*   nsp_image       = NULL;
 117         int header_version=1;
 118         int     cmdline_err;
 119         char*   cmdline_error_msg;
 120
 121         char*   filen_kernel;
 122         char*   filen_files;
 123         char*   filen_out;
 124
 125         int     i,count;                        /* loop variables */
 126         int     num_sects = 2;                  /* We require exactly two image with -i option
 127                                                            (see CMDLINE_CFG structure above) */
 128         int     desc_count=0;
 129         int     total = 0;
 130
 131         int     header_size=0;
 132         struct nsp_img_hdr_head         *img_hdr_head;  /* Start of image header */
 133         struct nsp_img_hdr_info *img_hdr_info;
 134         struct nsp_img_hdr_section_info *img_hdr_section_info ;
 135         struct nsp_img_hdr_sections     *img_hdr_sections, *section;    /* Section pointers */
 136
 137
 138         /* Configure the command line. */
 139         cmdline_configure(&cmd_line_cfg);
 140
 141         /* Read and parse the command line. */
 142         cmdline_err = cmdline_read(argc, argv);
 143
 144         /* Check for parsing errors. */
 145         if(cmdline_err != 0) {
 146                 /* Get the parse error message */
 147                 cmdline_error_msg = cmdline_error(cmdline_err);
 148
 149                 /* Print it out */
 150                 printf("%s\n", cmdline_error_msg);
 151
 152                 /* Print our help too */
 153                 print_help();
 154                 return -1;
 155         }
 156         if(cmdline_getopt_count('h') > 0)
 157         {
 158                 header_version=atoi(argv[cmdline_getarg(cmdline_getarg_list('h'),0)]);
 159         }
 160         /* Set up arguments */
 161         filen_kernel    = argv[cmdline_getarg(cmdline_getarg_list('i'),0)];
 162         filen_files     = argv[cmdline_getarg(cmdline_getarg_list('i'),1)];
 163         filen_out       = argv[cmdline_getarg(cmdline_getarg_list('o'),0)];
 164         /* Command line arguments have been parsed. Start doing our work. */
 165
 166         /* Caculate the header size, and allocate the memory, and assign the sub pointers */
 167         header_size =   sizeof(struct nsp_img_hdr_head) +               /* This has a single section
 168                                                                    desc block already */
 169                                 (header_version==1?0:4) +
 170                                 sizeof(struct nsp_img_hdr_info) +
 171                                 sizeof(struct nsp_img_hdr_section_info) +
 172                         sizeof(struct nsp_img_hdr_sections) * num_sects ;
 173
 174         img_hdr_head = (struct nsp_img_hdr_head *)malloc(header_size);
 175         memset(img_hdr_head, 0x0, header_size);
 176         img_hdr_info = (struct nsp_img_hdr_info*)((char *)img_hdr_head + sizeof(struct nsp_img_hdr_head) + (header_version==1?0:4));
 177         img_hdr_section_info = (struct nsp_img_hdr_section_info*)((char *)img_hdr_info + sizeof(struct nsp_img_hdr_info));
 178         img_hdr_sections = (struct nsp_img_hdr_sections*)((char *)img_hdr_section_info + sizeof(struct nsp_img_hdr_section_info));
 179         section = img_hdr_sections;
 180         memset(img_hdr_head, 0xff, (void*)img_hdr_info - (void*)img_hdr_head);
 181
 182         img_hdr_head->hdr_version = header_version;
 183         img_hdr_head->hdr_size = header_size;
 184         img_hdr_head->info_offset = (void*)img_hdr_info - (void*)img_hdr_head;
 185         img_hdr_head->sect_info_offset = (void*)img_hdr_section_info - (void*)img_hdr_head;
 186
 187         img_hdr_section_info->num_sects = num_sects;
 188         img_hdr_section_info->sect_size = sizeof(struct nsp_img_hdr_sections);
 189         img_hdr_section_info->sections_offset = (void*)img_hdr_sections - (void*)img_hdr_head;
 190
 191 /*      chksum = (struct nsp_img_hdr_chksum *)
 192                         ((unsigned int)image_hdr + header_size - sizeof(struct nsp_img_hdr_chksum));*/
 193
 194         /* Open the out file */
 195         nsp_image = fopen(filen_out,"wb+");
 196         if(nsp_image==NULL) {
 197                 printf("ERROR: can't open %s for writing.\n", filen_out);
 198                 return -1;
 199         }
 200
 201         /* Skip image header. We'll come back to it after we've written out the images. */
 202         fseek(nsp_image,header_size,SEEK_SET);
 203         total = ftell(nsp_image);
 204         total = header_size;
 205         printf("total=%x\n",total);
 206         {
 207                 int align;
 208                 int     padding;
 209                 char * buf;
 210                 align = (header_version==1?0x10000:0x4000);
 211                 if(align==0) {
 212                         /* The user indicated no padding */
 213                         padding = 0;
 214                 } else {
 215                         /* Calculate number padding bytes */
 216                         if((total %align) ==0)
 217                                 padding=0;
 218                         else
 219                                 padding = align - (total % align);
 220                 }
 221                 if(padding>0)
 222                 {
 223                         buf=malloc(padding);
 224                         memset(buf, 0xff, padding);
 225                         if(fwrite((void*)buf,1,padding,nsp_image)!=padding) {
 226                                 printf("ERROR: can't write to %s.\n", filen_out);
 227                                 free(buf);
 228                                 return -1;
 229                         }
 230                         free(buf);
 231
 232                 }
 233                 total+=padding;
 234
 235
 236         }
 237         /* Write out all specified images (with -i option) */
 238         for(i=0; i < num_sects; i++) {
 239                 char*   file_name;              /* input file name */
 240                 FILE*   filep;                  /* input file pointer */
 241                 int     padding;                /* number of padding bytes to prepend */
 242                 int     align;                  /* align factor from command line */
 243                 int     result;                 /* intermediate result */
 244                 char * buf;
 245
 246                 /* Open the specified image for reading */
 247                 file_name       = argv[cmdline_getarg(cmdline_getarg_list('i'),i)];
 248                 filep           = fopen(file_name, "rb");
 249                 if(filep==NULL) {
 250                         printf("ERROR: can't open file %s for reading.\n", file_name);
 251                         return -1;
 252                 }
 253                 section->flags = ~0x00;
 254                 /* Determine file size */
 255                 fseek(filep,0,SEEK_END);
 256                 section->raw_size=ftell(filep);
 257                 fseek(filep,0,SEEK_SET);
 258                 cs_calc_sum(filep,(unsigned long *)&section->chksum,0);
 259                 fseek(filep,0,SEEK_SET);
 260
 261                 /* Retrieve the alignment constant */
 262                 /* Set image offset from the beginning of the out file */
 263                 section->offset=total;// + padding;
 264
 265                 //total += padding;
 266
 267                 /* Copy the image file into nsp_image */
 268                 count = section->raw_size;
 269                 buf=malloc(count);
 270                 result=fread(buf, 1, count, filep);
 271                 fwrite(buf, 1, result, nsp_image);
 272                 free(buf);
 273
 274                 /* HACK: This is a hack to get the names and types to the files.
 275                         TODO: Fix this to be a real method */
 276                 if(i==0){
 277                         section->type=NSP_IMG_SECTION_TYPE_KERNEL;
 278                         strncpy(section->name, "kernel", 16);
 279                 } else if(i==1){
 280                         section->type=NSP_IMG_SECTION_TYPE_FILESYSTEM_ROOT;
 281                         strncpy(section->name, "root", 16);
 282                 }
 283
 284                 /* Account for the total */
 285                 align   =  strtoul(argv[cmdline_getarg(cmdline_getarg_list('a'),i)],NULL,0);
 286                 if(i==0){
 287                         if(align==0 || (((section->raw_size+ section->offset)%align)==0))
 288                                 padding=0;
 289                         else
 290                                 padding = align - ((section->raw_size+ section->offset) % align);
 291
 292                                 section->total_size=section->raw_size + padding;
 293                 }
 294                 else{
 295                         #define EXTRA_BLOCK 0x10000
 296                         unsigned int squash_padding;
 297                         squash_padding = EXTRA_BLOCK - section->raw_size % EXTRA_BLOCK;
 298                         buf=malloc(EXTRA_BLOCK + 4);
 299                         memset(buf, 0, squash_padding);
 300                         fwrite(buf, 1, squash_padding, nsp_image);
 301                         memset(buf, 0, EXTRA_BLOCK + 4);
 302                         *((unsigned int *)buf)=0xdec0adde;
 303                         *((unsigned int *)(buf+EXTRA_BLOCK))=0xdec0adde;
 304                         fwrite(buf, 1, EXTRA_BLOCK+4, nsp_image);
 305                         free(buf);
 306
 307                         if(align==0 || (((section->raw_size + (EXTRA_BLOCK + 4 + squash_padding)) %align)==0))
 308                                 padding=0;
 309                         else
 310                                 padding = align - ((section->raw_size + (EXTRA_BLOCK + 4 + squash_padding)) % align);
 311                         section->total_size=section->raw_size + (EXTRA_BLOCK + 4 + squash_padding) + padding;
 312                 }
 313                 if(padding>0){
 314                         buf=malloc(padding);
 315                         memset(buf, 0xff, padding);
 316                         fwrite(buf, 1, padding, nsp_image);
 317                         free(buf);
 318                 }
 319                 printf("*****padding is %d\ttotal_size=%d\traw_size=%d\n",padding, section->total_size, section->raw_size);
 320
 321                 //total += section->raw_size;
 322                 total = section->total_size + section->offset;
 323                 printf("total=0x%x\n",total);
 324                 /* Close the input file */
 325                 fclose(filep);
 326
 327                 /* Move the section pointer to the next slot */
 328                 section++;
 329         }
 330
 331         /* Take care of the NSP image header fields */
 332
 333         /* head fields */
 334         img_hdr_head->magic             = NSP_IMG_MAGIC_NUMBER;
 335         img_hdr_head->boot_offset       = img_hdr_sections->offset;
 336         img_hdr_head->flags             = ~0x00;                        /* Set to all 1's */
 337
 338         if(cmdline_getopt_count('b'))
 339                 img_hdr_head->flags     &= ~(NSP_IMG_FLAG_FAILBACK_5 | NSP_IMG_FLAG_FAILBACK_1);
 340
 341         if(cmdline_getopt_count('f'))
 342                 img_hdr_head->flags     = strtoul(argv[cmdline_getarg(cmdline_getarg_list('f'),0)], 0, 16);
 343
 344 #if 0
 345         img_hdr_head->hdr_version       = 2;
 346         img_hdr_head->hdr_size  = header_size;
 347 #endif
 348
 349         if(cmdline_getopt_count('p'))
 350                 img_hdr_head->prod_id           = strtoul(argv[cmdline_getarg(cmdline_getarg_list('p'),0)], 0, 16);
 351         else
 352                 img_hdr_head->prod_id           = 0x4C575943;
 353
 354         if(cmdline_getopt_count('r'))
 355                 img_hdr_head->rel_id            = strtoul(argv[cmdline_getarg(cmdline_getarg_list('r'),0)], 0, 0);
 356         else
 357                 img_hdr_head->rel_id            = 0x10203040;
 358
 359         if(cmdline_getopt_count('s'))
 360                 img_hdr_head->version           = strtoul(argv[cmdline_getarg(cmdline_getarg_list('s'),0)], 0, 0);
 361         else
 362                 img_hdr_head->version           = 0x0b040000;
 363         img_hdr_head->image_size        = total;
 364 #if 0
 365         img_hdr_head->info_offset       = (unsigned int)(&(image_hdr->info)) -
 366                                                 (unsigned int)image_hdr;
 367         img_hdr_head->sect_info_offset= (unsigned int)(&(image_hdr->sect_info)) -
 368                                                 (unsigned int)image_hdr;
 369 #endif
 370 //      image_hdr->head.chksum_offset   = (unsigned int)chksum - (unsigned int)image_hdr;
 371         img_hdr_head->chksum_offset = 0xffffffff;
 372 //      image_hdr->head.pad1 = 0xffffffff;
 373         /* info fields */
 374         /* TODO: Fix. Do nothing yet */
 375 //      strncpy(nsp_img_hdr.id.prod_info,NSP_PRODINFO_STRING,sizeof(NSP_PRODINFO_STRING));
 376         strcpy(img_hdr_info->image_filename, (const char *)basename(filen_out));
 377         /* section fields */
 378 #if 0
 379         img_hdr_section_info->num_sects=                num_sects;
 380         img_hdr_section_info->sect_size=                sizeof(struct nsp_img_hdr_sections);
 381         img_hdr_section_info->sections_offset=  (unsigned int)(&(image_hdr->sections)) -
 382                                                 (unsigned int)image_hdr;
 383 #endif
 384
 385         /* Calculate checksum(s) */
 386 #if 0
 387         chksum->hdr_chksum = cs_calc_buf_sum((char*)image_hdr,
 388                         header_size - sizeof(struct nsp_img_hdr_chksum));
 389 #endif
 390         /* Write out the NSP header. */
 391         fseek(nsp_image,0,SEEK_SET);
 392         count = fwrite((void*)img_hdr_head, header_size, 1, nsp_image);
 393         if(count!=1) {
 394                 printf("ERROR: can't write to %s.\n", filen_out);
 395                 return -1;
 396         }
 397
 398         /* Check if -v option was specified (no arg needed) */
 399         if(cmdline_getopt_count('v') > 0)
 400         {
 401                 struct nsp_img_hdr_head head;
 402                 struct nsp_img_hdr      *hdr;
 403
 404                 /* Rewind the file back to the beginning */
 405                 fseek(nsp_image,0,SEEK_SET);
 406
 407                 /* Read header from the file */
 408                 fread((void*)&head, sizeof(struct nsp_img_hdr_head),
 409                                 1, nsp_image);
 410
 411                 /* Get memory to store the complete header */
 412                 hdr = (struct nsp_img_hdr *)malloc(head.hdr_size);
 413
 414                 /* Read header from the file */
 415                 fseek(nsp_image,0,SEEK_SET);
 416                 fread((void*)hdr, head.hdr_size, 1, nsp_image);
 417
 418                 /* Print it out */
 419                 mknspimg_print_hdr(hdr);
 420                 printf("Generated total %d bytes\n",total);
 421                 free(hdr);
 422         }
 423
 424         free(img_hdr_head);
 425
 426       {
 427           struct checksumrecord cr;
 428       cr.magic=CKSUM_MAGIC_NUMBER;
 429       cs_calc_sum(nsp_image, (unsigned long *)&cr.chksum, 0);
 430       fseek(nsp_image,0, SEEK_END);
 431       fwrite(&cr, 1, sizeof(cr), nsp_image);
 432           }
 433           {
 434                 FILE * non_web;
 435                 char fname[256];
 436                 char * img_buf;
 437                 unsigned int len;
 438                 strcpy(fname, filen_out);
 439                 strcat(fname, ".non_web");
 440                 non_web = fopen(fname,"wb+");
 441                 fseek(nsp_image, 0, SEEK_END);
 442                 len = ftell(nsp_image);
 443                 img_buf=malloc(len);
 444                 fseek(nsp_image, 0, SEEK_SET);
 445                 fread(img_buf, 1, len, nsp_image);
 446                 img_buf[0xb] = 0x17;
 447                 fwrite(img_buf, 1, len-sizeof(struct checksumrecord), non_web);
 448                 fclose(non_web);
 449                 free(img_buf);
 450           }
 451           /* Close NSP image file */
 452         fclose(nsp_image);
 453
 454         /* return result */
 455         return(0);
 456 }
 457
 458 #ifdef DMALLOC
 459 #include <dmalloc.h>
 460 #endif /* DMALLOC */
 461
 462 #define BUFLEN (1 << 16)
 463
 464 static unsigned long crctab[256] =
 465 {
 466         0x0,
 467         0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B,
 468         0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6,
 469         0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
 470         0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC,
 471         0x5BD4B01B, 0x569796C2, 0x52568B75, 0x6A1936C8, 0x6ED82B7F,
 472         0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A,
 473         0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
 474         0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58,
 475         0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033,
 476         0xA4AD16EA, 0xA06C0B5D, 0xD4326D90, 0xD0F37027, 0xDDB056FE,
 477         0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
 478         0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4,
 479         0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0,
 480         0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5,
 481         0x2AC12072, 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16,
 482         0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA, 0x7897AB07,
 483         0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C,
 484         0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1,
 485         0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
 486         0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B,
 487         0xBB60ADFC, 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698,
 488         0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D,
 489         0x94EA7B2A, 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E,
 490         0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 0xC6BCF05F,
 491         0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34,
 492         0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80,
 493         0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
 494         0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A,
 495         0x58C1663D, 0x558240E4, 0x51435D53, 0x251D3B9E, 0x21DC2629,
 496         0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C,
 497         0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
 498         0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E,
 499         0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65,
 500         0xEBA91BBC, 0xEF68060B, 0xD727BBB6, 0xD3E6A601, 0xDEA580D8,
 501         0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
 502         0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2,
 503         0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71,
 504         0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74,
 505         0x857130C3, 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640,
 506         0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C, 0x7B827D21,
 507         0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A,
 508         0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E, 0x18197087,
 509         0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
 510         0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D,
 511         0x2056CD3A, 0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE,
 512         0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB,
 513         0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18,
 514         0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, 0x89B8FD09,
 515         0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662,
 516         0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF,
 517         0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4
 518 };
 519
 520 int cs_is_tagged(FILE *fp)
 521 {
 522         char buf[8];
 523
 524         fseek(fp, -8, SEEK_END);
 525         fread(buf, 8, 1, fp);
 526         if(*(unsigned long*)buf == CKSUM_MAGIC_NUMBER)
 527                 return 1;
 528         return 0;
 529 }
 530
 531 unsigned long cs_read_sum(FILE *fp)
 532 {
 533         char buf[8];
 534
 535         fseek(fp, -8, SEEK_END);
 536         fread(buf, 8, 1, fp);
 537         return *((unsigned long*)&buf[4]);
 538 }
 539
 540 int cs_calc_sum(FILE *fp, unsigned long *res, int tagged)
 541 {
 542         unsigned char buf[BUFLEN];
 543         unsigned long crc = 0;
 544         uintmax_t length = 0;
 545         size_t bytes_read;
 546
 547         fseek(fp, 0, SEEK_SET);
 548
 549         while((bytes_read = fread(buf, 1, BUFLEN, fp)) > 0)
 550         {
 551                 unsigned char *cp = buf;
 552
 553                 if(length + bytes_read < length)
 554                         return 0;
 555
 556                 if(bytes_read != BUFLEN && tagged)
 557                         bytes_read -= 8;
 558
 559                 length += bytes_read;
 560                 while(bytes_read--)
 561                         crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
 562         }
 563
 564         if(ferror(fp))
 565                 return 0;
 566
 567         for(; length; length >>= 8)
 568                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
 569
 570         crc = ~crc & 0xFFFFFFFF;
 571
 572         *res = crc;
 573
 574         return 1;
 575 }
 576
 577 unsigned long cs_calc_buf_sum(char *buf, int size)
 578 {
 579         unsigned long crc = 0;
 580         char *cp = buf;
 581         unsigned long length = size;
 582
 583         while(size--)
 584                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
 585
 586         for(; length; length >>= 8)
 587                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
 588
 589         crc = ~crc & 0xFFFFFFFF;
 590
 591         return crc;
 592 }
 593
 594 unsigned long cs_calc_buf_sum_ds(char *buf, int buf_size, char *sign, int sign_len)
 595 {
 596         unsigned long crc = 0;
 597         char *cp = buf;
 598         unsigned long length = buf_size+sign_len;
 599
 600         while(buf_size--)
 601                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
 602
 603         cp = sign;
 604         while(sign_len--)
 605                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
 606
 607
 608         for(; length; length >>= 8)
 609                 crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
 610
 611         crc = ~crc & 0xFFFFFFFF;
 612
 613         return crc;
 614 }
 615
 616 int cs_set_sum(FILE *fp, unsigned long sum, int tagged)
 617 {
 618         unsigned long magic = CKSUM_MAGIC_NUMBER;
 619
 620         if(tagged)
 621                 fseek(fp, -8, SEEK_END);
 622         else
 623                 fseek(fp, 0, SEEK_END);
 624
 625         if(fwrite(&magic, 1, 4, fp) < 4)
 626                 return 0;
 627         if(fwrite(&sum, 1, 4, fp) < 4)
 628                 return 0;
 629
 630         return 1;
 631 }
 632
 633 void cs_get_sum(FILE *fp, unsigned long *sum)
 634 {
 635         unsigned long magic = 0;
 636
 637         fseek(fp, -8, SEEK_END);
 638
 639         fread(&magic, 4, 1, fp);
 640         fread(sum, 4, 1, fp);
 641 }
 642
 643 int cs_validate_file(char *filename)
 644 {
 645         FILE *pFile = NULL;
 646         unsigned long sum = 0, res = 0;
 647
 648         if((pFile = fopen(filename, "r")) == NULL)
 649                 return 0;
 650
 651         if(!cs_is_tagged(pFile))
 652         {
 653                 fclose(pFile);
 654                 return 0;
 655         }
 656         if(!cs_calc_sum(pFile, &sum, 1))
 657         {
 658                 fclose(pFile);
 659                 return 0;
 660         }
 661         cs_get_sum(pFile, &res);
 662         fclose(pFile);
 663
 664         if(sum != res)
 665                 return 0;
 666         return 1;
 667 }
 668
 669 /* ********* Library internal data ********* */
 670 #define CMDLINE_TRUE                    1
 671 #define CMDLINE_FALSE                   0
 672
 673 typedef enum CMDLINE_ERR
 674 {
 675         CMDLINE_ERR_OK          = 0,    /* No Error (OK) */
 676         CMDLINE_ERR_ERROR       = -1,   /* Unspecified error */
 677         CMDLINE_ERR_INVKEY      = -3,   /* Invalid option key */
 678         CMDLINE_ERR_MANYARG     = -4,   /* Too many arguments */
 679         CMDLINE_ERR_FEWARG      = -5,   /* Too few arguments */
 680         CMDLINE_ERR_ILLOPT      = -6,   /* Option not allowed (illegal option) */
 681         CMDLINE_ERR_NOMEM       = -7,   /* No memory */
 682         CMDLINE_ERR_OPTMIS      = -8    /* A mandatory option is missing */
 683 } CMDLINE_ERR;
 684
 685 /* Argument list */
 686 typedef struct CMDLINE_ARG
 687 {
 688         int                             index;          /* Index of the argument in the command line */
 689         struct CMDLINE_ARG*     p_next; /* Next node in the linked list */
 690 } CMDLINE_ARG;
 691
 692 /* Master control block for an option */
 693 typedef struct CMDLINE_ARGS
 694 {
 695         int                             argc;           /* Total count of arguments found */
 696         int                             optc;           /* Total count of options found */
 697         CMDLINE_ARG*    list;           /* Argument list */
 698 } CMDLINE_ARGS;
 699
 700 /* Master control block for all found arguments */
 701 typedef struct CMDLINE_DATA
 702 {
 703         CMDLINE_ARGS    opt_args[26];   /* Array of MCBs for each option ('a' through 'z') */
 704         CMDLINE_ARGS    glb_args;               /* Global arguments */
 705         int                             parsed;                 /* Internal flag to prevent client calls if library is not initialized */
 706 } CMDLINE_DATA;
 707
 708 /* ********* Local Data ********* */
 709 static CMDLINE_CFG cmdline_cfg;
 710 static CMDLINE_DATA cmdline_data;
 711
 712 char*   cmdline_errmsg = "CMDLINE ERROR";
 713
 714 /* ***************************************************************
 715 * Print all found command line options and their arguments
 716 ****************************************************************** */
 717 void* cmdline_getarg_list(char opt)
 718 {
 719         int index = (opt - 'a');
 720
 721         /* Check the validity of the index */
 722         if((index < 0) || (index > 25))
 723         {
 724                 /* ERROR: Wrong option */
 725                 return NULL;
 726         }
 727
 728         /* Return a pointer to the ARGS control structure */
 729         return((void*)(&cmdline_data.opt_args[index]));
 730 }
 731
 732 /* ***************************************************************
 733 * Print all found command line options and their arguments
 734 ****************************************************************** */
 735 int cmdline_getarg_count(void* list)
 736 {
 737         CMDLINE_ARGS*   p_args = (CMDLINE_ARGS*)list;
 738
 739         /* Return number of arguments for this option */
 740         return(p_args->argc);
 741 }
 742
 743 /* ***************************************************************
 744 * Print all found command line options and their arguments
 745 ****************************************************************** */
 746 int cmdline_getopt_count(char opt)
 747 {
 748         int                             index;
 749
 750         /* Calculate index value */
 751         index = opt - 'a';
 752         if(index < 0 || index > 25) return -1;
 753
 754         /* Return number of arguments for this option */
 755         return(cmdline_data.opt_args[index].optc);
 756 }
 757
 758 /* ***************************************************************
 759 * Print all found command line options and their arguments
 760 ****************************************************************** */
 761 int cmdline_getarg(void* list, int num)
 762 {
 763         int i;
 764         CMDLINE_ARGS*   p_args = (CMDLINE_ARGS*)list;
 765         CMDLINE_ARG*    p_arg;
 766
 767         /* Search the 'num' argument in the list for this option */
 768         for(i=0,p_arg=p_args->list; (p_arg!=NULL) && (i<p_args->argc); i++, p_arg=p_arg->p_next)
 769         {
 770                 /* if num matches i, we found it */
 771                 if(i==num) return(p_arg->index);
 772         }
 773         /* We did not find the specified argument or the list was empty */
 774         return -1;
 775 }
 776
 777 /* ***************************************************************
 778 * Print all found command line options and their arguments
 779 ****************************************************************** */
 780 int cmdline_configure(CMDLINE_CFG* p_cfg)
 781 {
 782         /* reset global data */
 783         memset(&cmdline_cfg,0,sizeof(cmdline_cfg));
 784         memset(&cmdline_data,0,sizeof(cmdline_data));
 785
 786         /* Copy the user's config structure */
 787         cmdline_cfg = *p_cfg;
 788         return 0;
 789 }
 790
 791 /* ***************************************************************
 792 * Print all found command line options and their arguments
 793 ****************************************************************** */
 794 char* cmdline_error(int err)
 795 {
 796         /* TODO: implement a table of error messages */
 797         return(cmdline_errmsg);
 798 }
 799
 800 /* ***************************************************************
 801 * Print all found command line options and their arguments
 802 ****************************************************************** */
 803 static void cmdline_print_args(CMDLINE_ARGS* p_arglist, char* argv[])
 804 {
 805         CMDLINE_ARG*    p_arg;
 806
 807         printf("   Number of times option was specified: %d\n", p_arglist->optc);
 808         printf("   Number of Arguments:                  %d\n", p_arglist->argc);
 809
 810         if(p_arglist->argc > 0)
 811         {
 812                 printf("   Argument List: ");
 813
 814                 for(p_arg=p_arglist->list; p_arg != NULL; p_arg=p_arg->p_next)
 815                         printf("%s ", argv[p_arg->index]);
 816         }
 817
 818         printf("\n");
 819 }
 820
 821 /* ***************************************************************
 822 * Print all found command line options and their arguments
 823 ****************************************************************** */
 824 void cmdline_print(char* argv[])
 825 {
 826         int i;
 827
 828         /* Check if the command line was parsed */
 829         if(cmdline_data.parsed != CMDLINE_TRUE)
 830         {
 831                 printf("The command line has not been parsed yet.\n");
 832                 return;
 833         }
 834
 835         /* Print out option arguments */
 836         for( i = 0; i < 26; i++ )
 837         {
 838                 /* Check if the option was specified */
 839                 if(cmdline_data.opt_args[i].optc !=0 )
 840                 {
 841                         /* Print out option name and arguments */
 842                         printf("Option: -%c\n", (char)('a'+i));
 843                         cmdline_print_args(&(cmdline_data.opt_args[i]), argv);
 844                 }
 845         }
 846
 847         /* Print out global arguments */
 848         printf("Global arguments:\n");
 849         cmdline_print_args(&(cmdline_data.glb_args), argv);
 850 }
 851
 852 /* ***************************************************************
 853 * Print configuration
 854 ****************************************************************** */
 855 void cmdline_print_cfg(void)
 856 {
 857
 858 }
 859
 860 static void cmdline_argadd(CMDLINE_ARGS* p_arglist, CMDLINE_ARG* p_arg)
 861 {
 862         CMDLINE_ARG*    p_list;
 863         CMDLINE_ARG*    p_prev=NULL;
 864
 865         /* See if we had anything in the list */
 866         if(p_arglist->argc == 0)
 867         {
 868                 /* Link the argument in */
 869                 p_arglist->list = p_arg;
 870         }
 871         else
 872         {
 873                 /* Find the tail of the list */
 874                 for(p_list=p_arglist->list; p_list != NULL; p_list=p_list->p_next)
 875                         p_prev = p_list;
 876
 877                 /* Link the argument in */
 878                 p_prev->p_next=p_arg;
 879         }
 880
 881         /* Keep track of arg number */
 882         p_arglist->argc++;
 883 }
 884
 885 /* ***************************************************************
 886 * cmdline_read()
 887 * Read and parse command line arguments
 888 ****************************************************************** */
 889 int cmdline_read(int argc, char* argv[])
 890 {
 891         int i, option=0;
 892
 893         /* Process every command line argument in argv[] array */
 894         for( i = 1; i < argc; i++ )
 895         {
 896                 /* Does the argument start with a dash? */
 897                 if( *argv[i] == '-' )
 898                 {
 899                         /* The argument must be two characters: a dash, and a letter */
 900                         if( strlen(argv[i]) != 2 )
 901                         {
 902                                 /* ERROR: option syntax (needs to be a dash and one letter) */
 903                                 return(CMDLINE_ERR_ERROR);
 904                         }
 905
 906                         /* Check validity of the option key ('a' through 'z') */
 907                         if( ((*(argv[i] + 1)) < 'a') || ((*(argv[i] + 1)) > 'z') )
 908                         {
 909                                 /* ERROR: option sysntax (invalid option key) */
 910                                 return(CMDLINE_ERR_INVKEY);
 911                         }
 912
 913                         /* Calculate the option index */
 914                         option = (*(argv[i] + 1)) - 'a';
 915                         if((option < 0) || (option > 25)) return(CMDLINE_ERR_INVKEY);
 916
 917                         /* Check to see if the option is allowed */
 918                         if( cmdline_cfg.opts[option].flags & CMDLINE_OPTFLAG_ALLOW )
 919                         {
 920                                 /* Option allowed. */
 921                                 cmdline_data.opt_args[option].optc++;
 922                                 continue;
 923                         }
 924                         else
 925                         {
 926                                 /* ERROR: Option is not allowed */
 927                                 return(CMDLINE_ERR_ILLOPT);
 928                         }
 929                 }
 930                 else
 931                 {
 932                         /* Read the arguments for the option */
 933                         CMDLINE_ARG*    p_arg;
 934
 935                         /* Allocate space for the argument node */
 936                         p_arg = (CMDLINE_ARG*)calloc(1,sizeof(CMDLINE_ARG));
 937                         if( p_arg== NULL )
 938                         {
 939                                 /* ERROR: Can't allocate memory for the argument index */
 940                                 return(CMDLINE_ERR_NOMEM);
 941                         }
 942
 943                         /* Initialize the argument */
 944                         p_arg->index    = i;
 945                         p_arg->p_next   = NULL;
 946
 947                         /* Check if we can add to the list of arguments for this option */
 948                         if( (option < 0)                                                                                                                                /* Do we have to add to the global list? */
 949                                 || (cmdline_data.opt_args[option].argc == cmdline_cfg.opts[option].max)         /* Did we reach MAX arguments? */
 950                                 )
 951                         {
 952                                 /* This option does not require arguments. Keep the argument in the global list. */
 953                                 cmdline_argadd(&(cmdline_data.glb_args), p_arg);
 954                                 continue;
 955                         }
 956                         else
 957                         {
 958                                 /* See if the current count has reached max for this option */
 959                                 if( cmdline_data.opt_args[option].argc == cmdline_cfg.opts[option].max )
 960                                 {
 961                                         /* ERROR: too many arguments for an option */
 962                                         return(CMDLINE_ERR_MANYARG);
 963                                 }
 964                                 else
 965                                 {
 966                                         /* Link the argument to the arg list of the option */
 967                                         cmdline_argadd(&(cmdline_data.opt_args[option]), p_arg);
 968                                         continue;
 969                                 }
 970                         }
 971                 }
 972         }
 973
 974         /* ****** We read the complete command line. See if what we collected matches the configuration ******* */
 975
 976         /* Check every collected option against its configuration */
 977         for( i=0; i < 26; i++ )
 978         {
 979                 /* Check if this option was allowed */
 980                 if(cmdline_cfg.opts[i].flags & CMDLINE_OPTFLAG_ALLOW)
 981                 {
 982                         /* See if it was mandatory */
 983                         if(cmdline_cfg.opts[i].flags & CMDLINE_OPTFLAG_MANDAT)
 984                         {
 985                                 /* Check if we really collected this option on the command line. */
 986                                 if(cmdline_data.opt_args[i].optc == 0)
 987                                 {
 988                                         /* ERROR: a missing mandatory option */
 989                                         return(CMDLINE_ERR_OPTMIS);
 990                                 }
 991                                 else
 992                                 {
 993                                         /* Option was there. Check how many args we got for it. */
 994                                         if(cmdline_data.opt_args[i].argc < cmdline_cfg.opts[i].min)
 995                                         {
 996                                                 /* ERROR: too few arguments for an option */
 997                                                 return(CMDLINE_ERR_FEWARG);
 998                                         }
 999                                         else
1000                                         {
1001                                                 /* This mandatory option was proper. */
1002                                                 continue;
1003                                         }
1004                                 }
1005                         }
1006                         else    /* This is non-mandatory option: */
1007                         {
1008                                 /* Check if the option was specified on the command line */
1009                                 if(cmdline_data.opt_args[i].optc == 0)
1010                                 {
1011                                         /* option wasn't specified, go to the next */
1012                                         continue;
1013                                 }
1014                                 else
1015                                 {
1016                                         /* Option was there. Check how many args we collected for it. */
1017                                         if(cmdline_data.opt_args[i].argc < cmdline_cfg.opts[i].min)
1018                                         {
1019                                                 /* ERROR: too few arguments for a non-mandatory option */
1020                                                 return(CMDLINE_ERR_FEWARG);
1021                                         }
1022                                         else
1023                                         {
1024                                                 /* This non-mandatory option was proper. */
1025                                                 continue;
1026                                         }
1027                                 }
1028                         }
1029                 }
1030                 else    /* Option was not allowed. */
1031                 {
1032                         /* We should not get here as the non-allowed options should have been
1033                         trapped eariler. */
1034                 }
1035         }
1036
1037         /* Command line was proper as far as the number of options and their arguments */
1038         cmdline_data.parsed = CMDLINE_TRUE;
1039         return(CMDLINE_ERR_OK);
1040 }