Root/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
8struct 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 ***************************************************************************/
18void 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 ***************************************************************************/
40void 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
76CMDLINE_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 ***************************************************************************/
114int 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
464static 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
520int 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
531unsigned 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
540int 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
577unsigned 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
594unsigned 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
616int 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
633void 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
643int 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
673typedef 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 */
686typedef 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 */
693typedef 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 */
701typedef 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 ********* */
709static CMDLINE_CFG cmdline_cfg;
710static CMDLINE_DATA cmdline_data;
711
712char* cmdline_errmsg = "CMDLINE ERROR";
713
714/* ***************************************************************
715* Print all found command line options and their arguments
716****************************************************************** */
717void* 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****************************************************************** */
735int 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****************************************************************** */
746int 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****************************************************************** */
761int 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****************************************************************** */
780int 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****************************************************************** */
794char* 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****************************************************************** */
803static 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****************************************************************** */
824void 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****************************************************************** */
855void cmdline_print_cfg(void)
856{
857
858}
859
860static 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****************************************************************** */
889int 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}
1041

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive