5 #include "mktitanimg.h"
11 unsigned int chksum
; /* The checksum for the complete header.
15 /***************************************************************************
16 * void print_help(void)
17 ***************************************************************************/
20 static char* help_page
[]=
22 "mknspimg version 1.0, Texas Instruments, 2004",
24 " mknspimg -o outfile -i image1 image2 -a align1 align2 [-v] [-b] [-p prod_id] [-r rel_id] [-s rel_name] [-f flags]",
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."
30 int num_lines
= sizeof(help_page
)/sizeof(char*);
32 for(i
=0; i
< num_lines
; i
++) {
33 printf("%s\n", help_page
[i
]);
37 /***************************************************************************
38 * void mknspimg_print_hdr(NSP_IMG_HDR* p_img_hdr)
39 ***************************************************************************/
40 void mknspimg_print_hdr(struct nsp_img_hdr
*hdr
)
42 struct nsp_img_hdr_chksum
*chksum
;
43 struct nsp_img_hdr_section_info
*sect_info
;
44 struct nsp_img_hdr_sections
*section
;
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
);
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
);
59 chksum
=(struct nsp_img_hdr_chksum
*)(hdr
+hdr
->head
.chksum_offset
);
60 printf("Header Checksum: 0x%x\n", chksum
->hdr_chksum
);
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
);
73 printf("*******************************************************\n");
76 CMDLINE_CFG cmd_line_cfg
=
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' */
107 { 0, 0, !CMDLINE_OPTFLAG_ALLOW
}, /* global arguments */
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
[])
116 FILE* nsp_image
= NULL
;
117 int header_version
=1;
119 char* cmdline_error_msg
;
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) */
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 */
138 /* Configure the command line. */
139 cmdline_configure(&cmd_line_cfg
);
141 /* Read and parse the command line. */
142 cmdline_err
= cmdline_read(argc
, argv
);
144 /* Check for parsing errors. */
145 if(cmdline_err
!= 0) {
146 /* Get the parse error message */
147 cmdline_error_msg
= cmdline_error(cmdline_err
);
150 printf("%s\n", cmdline_error_msg
);
152 /* Print our help too */
156 if(cmdline_getopt_count('h') > 0)
158 header_version
=atoi(argv
[cmdline_getarg(cmdline_getarg_list('h'),0)]);
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. */
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
;
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
);
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
;
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
;
191 /* chksum = (struct nsp_img_hdr_chksum *)
192 ((unsigned int)image_hdr + header_size - sizeof(struct nsp_img_hdr_chksum));*/
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
);
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
);
205 printf("total=%x\n",total
);
210 align
= (header_version
==1?0x10000:0x4000);
212 /* The user indicated no padding */
215 /* Calculate number padding bytes */
216 if((total
%align
) ==0)
219 padding
= align
- (total
% align
);
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
);
238 /* Write out all specified images (with -i option) */
239 for(i
=0; i
< num_sects
; i
++) {
240 char* file_name
; /* input file name */
241 FILE* filep
; /* input file pointer */
242 int padding
; /* number of padding bytes to prepend */
243 int align
; /* align factor from command line */
244 int result
; /* intermediate result */
247 /* Open the specified image for reading */
248 file_name
= argv
[cmdline_getarg(cmdline_getarg_list('i'),i
)];
249 filep
= fopen(file_name
, "rb");
251 printf("ERROR: can't open file %s for reading.\n", file_name
);
254 section
->flags
= ~0x00;
255 /* Determine file size */
256 fseek(filep
,0,SEEK_END
);
257 section
->raw_size
=ftell(filep
);
258 fseek(filep
,0,SEEK_SET
);
259 cs_calc_sum(filep
,(unsigned long *)§ion
->chksum
,0);
260 fseek(filep
,0,SEEK_SET
);
262 /* Retrieve the alignment constant */
263 /* Set image offset from the beginning of the out file */
264 section
->offset
=total
;// + padding;
268 /* Copy the image file into nsp_image */
269 count
= section
->raw_size
;
271 result
=fread(buf
, 1, count
, filep
);
272 fwrite(buf
, 1, result
, nsp_image
);
275 /* HACK: This is a hack to get the names and types to the files.
276 TODO: Fix this to be a real method */
278 section
->type
=NSP_IMG_SECTION_TYPE_KERNEL
;
279 strncpy(section
->name
, "kernel", 16);
281 section
->type
=NSP_IMG_SECTION_TYPE_FILESYSTEM_ROOT
;
282 strncpy(section
->name
, "root", 16);
285 /* Account for the total */
286 align
= strtoul(argv
[cmdline_getarg(cmdline_getarg_list('a'),i
)],NULL
,0);
288 if(align
==0 || (((section
->raw_size
+ section
->offset
)%align
)==0))
291 padding
= align
- ((section
->raw_size
+ section
->offset
) % align
);
293 section
->total_size
=section
->raw_size
+ padding
;
296 #define EXTRA_BLOCK 0x10000
297 unsigned int squash_padding
;
298 squash_padding
= EXTRA_BLOCK
- section
->raw_size
% EXTRA_BLOCK
;
299 buf
=malloc(EXTRA_BLOCK
+ 4);
300 memset(buf
, 0, squash_padding
);
301 fwrite(buf
, 1, squash_padding
, nsp_image
);
302 memset(buf
, 0, EXTRA_BLOCK
+ 4);
303 *((unsigned int *)buf
)=0xdec0adde;
304 *((unsigned int *)(buf
+EXTRA_BLOCK
))=0xdec0adde;
305 fwrite(buf
, 1, EXTRA_BLOCK
+4, nsp_image
);
308 if(align
==0 || (((section
->raw_size
+ (EXTRA_BLOCK
+ 4 + squash_padding
)) %align
)==0))
311 padding
= align
- ((section
->raw_size
+ (EXTRA_BLOCK
+ 4 + squash_padding
)) % align
);
312 section
->total_size
=section
->raw_size
+ (EXTRA_BLOCK
+ 4 + squash_padding
) + padding
;
316 memset(buf
, 0xff, padding
);
317 fwrite(buf
, 1, padding
, nsp_image
);
320 printf("*****padding is %d\ttotal_size=%d\traw_size=%d\n",padding
, section
->total_size
, section
->raw_size
);
322 //total += section->raw_size;
323 total
= section
->total_size
+ section
->offset
;
324 printf("total=0x%x\n",total
);
325 /* Close the input file */
328 /* Move the section pointer to the next slot */
332 /* Take care of the NSP image header fields */
335 img_hdr_head
->magic
= NSP_IMG_MAGIC_NUMBER
;
336 img_hdr_head
->boot_offset
= img_hdr_sections
->offset
;
337 img_hdr_head
->flags
= ~0x00; /* Set to all 1's */
339 if(cmdline_getopt_count('b'))
340 img_hdr_head
->flags
&= ~(NSP_IMG_FLAG_FAILBACK_5
| NSP_IMG_FLAG_FAILBACK_1
);
342 if(cmdline_getopt_count('f'))
343 img_hdr_head
->flags
= strtoul(argv
[cmdline_getarg(cmdline_getarg_list('f'),0)], 0, 16);
346 img_hdr_head
->hdr_version
= 2;
347 img_hdr_head
->hdr_size
= header_size
;
350 if(cmdline_getopt_count('p'))
351 img_hdr_head
->prod_id
= strtoul(argv
[cmdline_getarg(cmdline_getarg_list('p'),0)], 0, 16);
353 img_hdr_head
->prod_id
= 0x4C575943;
355 if(cmdline_getopt_count('r'))
356 img_hdr_head
->rel_id
= strtoul(argv
[cmdline_getarg(cmdline_getarg_list('r'),0)], 0, 0);
358 img_hdr_head
->rel_id
= 0x10203040;
360 if(cmdline_getopt_count('s'))
361 img_hdr_head
->version
= strtoul(argv
[cmdline_getarg(cmdline_getarg_list('s'),0)], 0, 0);
363 img_hdr_head
->version
= 0x0b040000;
364 img_hdr_head
->image_size
= total
;
366 img_hdr_head
->info_offset
= (unsigned int)(&(image_hdr
->info
)) -
367 (unsigned int)image_hdr
;
368 img_hdr_head
->sect_info_offset
= (unsigned int)(&(image_hdr
->sect_info
)) -
369 (unsigned int)image_hdr
;
371 // image_hdr->head.chksum_offset = (unsigned int)chksum - (unsigned int)image_hdr;
372 img_hdr_head
->chksum_offset
= 0xffffffff;
373 // image_hdr->head.pad1 = 0xffffffff;
375 /* TODO: Fix. Do nothing yet */
376 // strncpy(nsp_img_hdr.id.prod_info,NSP_PRODINFO_STRING,sizeof(NSP_PRODINFO_STRING));
377 strcpy(img_hdr_info
->image_filename
, (const char *)basename(filen_out
));
380 img_hdr_section_info
->num_sects
= num_sects
;
381 img_hdr_section_info
->sect_size
= sizeof(struct nsp_img_hdr_sections
);
382 img_hdr_section_info
->sections_offset
= (unsigned int)(&(image_hdr
->sections
)) -
383 (unsigned int)image_hdr
;
386 /* Calculate checksum(s) */
388 chksum
->hdr_chksum
= cs_calc_buf_sum((char*)image_hdr
,
389 header_size
- sizeof(struct nsp_img_hdr_chksum
));
391 /* Write out the NSP header. */
392 fseek(nsp_image
,0,SEEK_SET
);
393 count
= fwrite((void*)img_hdr_head
, header_size
, 1, nsp_image
);
395 printf("ERROR: can't write to %s.\n", filen_out
);
399 /* Check if -v option was specified (no arg needed) */
400 if(cmdline_getopt_count('v') > 0)
402 struct nsp_img_hdr_head head
;
403 struct nsp_img_hdr
*hdr
;
405 /* Rewind the file back to the beginning */
406 fseek(nsp_image
,0,SEEK_SET
);
408 /* Read header from the file */
409 fread((void*)&head
, sizeof(struct nsp_img_hdr_head
),
412 /* Get memory to store the complete header */
413 hdr
= (struct nsp_img_hdr
*)malloc(head
.hdr_size
);
415 /* Read header from the file */
416 fseek(nsp_image
,0,SEEK_SET
);
417 fread((void*)hdr
, head
.hdr_size
, 1, nsp_image
);
420 mknspimg_print_hdr(hdr
);
421 printf("Generated total %d bytes\n",total
);
428 struct checksumrecord cr
;
429 cr
.magic
=CKSUM_MAGIC_NUMBER
;
430 cs_calc_sum(nsp_image
, (unsigned long *)&cr
.chksum
, 0);
431 fseek(nsp_image
,0, SEEK_END
);
432 fwrite(&cr
, 1, sizeof(cr
), nsp_image
);
439 strcpy(fname
, filen_out
);
440 strcat(fname
, ".non_web");
441 non_web
= fopen(fname
,"wb+");
442 fseek(nsp_image
, 0, SEEK_END
);
443 len
= ftell(nsp_image
);
445 fseek(nsp_image
, 0, SEEK_SET
);
446 fread(img_buf
, 1, len
, nsp_image
);
448 fwrite(img_buf
, 1, len
-sizeof(struct checksumrecord
), non_web
);
452 /* Close NSP image file */
463 #define BUFLEN (1 << 16)
465 static unsigned long crctab
[256] =
468 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B,
469 0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6,
470 0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
471 0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC,
472 0x5BD4B01B, 0x569796C2, 0x52568B75, 0x6A1936C8, 0x6ED82B7F,
473 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A,
474 0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
475 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58,
476 0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033,
477 0xA4AD16EA, 0xA06C0B5D, 0xD4326D90, 0xD0F37027, 0xDDB056FE,
478 0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
479 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4,
480 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0,
481 0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5,
482 0x2AC12072, 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16,
483 0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA, 0x7897AB07,
484 0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C,
485 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1,
486 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
487 0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B,
488 0xBB60ADFC, 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698,
489 0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D,
490 0x94EA7B2A, 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E,
491 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 0xC6BCF05F,
492 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34,
493 0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80,
494 0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
495 0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A,
496 0x58C1663D, 0x558240E4, 0x51435D53, 0x251D3B9E, 0x21DC2629,
497 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C,
498 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
499 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E,
500 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65,
501 0xEBA91BBC, 0xEF68060B, 0xD727BBB6, 0xD3E6A601, 0xDEA580D8,
502 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
503 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2,
504 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71,
505 0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74,
506 0x857130C3, 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640,
507 0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C, 0x7B827D21,
508 0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A,
509 0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E, 0x18197087,
510 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
511 0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D,
512 0x2056CD3A, 0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE,
513 0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB,
514 0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18,
515 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, 0x89B8FD09,
516 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662,
517 0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF,
518 0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4
521 int cs_is_tagged(FILE *fp
)
525 fseek(fp
, -8, SEEK_END
);
526 fread(buf
, 8, 1, fp
);
527 if(*(unsigned long*)buf
== CKSUM_MAGIC_NUMBER
)
532 unsigned long cs_read_sum(FILE *fp
)
536 fseek(fp
, -8, SEEK_END
);
537 fread(buf
, 8, 1, fp
);
538 return *((unsigned long*)&buf
[4]);
541 int cs_calc_sum(FILE *fp
, unsigned long *res
, int tagged
)
543 unsigned char buf
[BUFLEN
];
544 unsigned long crc
= 0;
545 uintmax_t length
= 0;
548 fseek(fp
, 0, SEEK_SET
);
550 while((bytes_read
= fread(buf
, 1, BUFLEN
, fp
)) > 0)
552 unsigned char *cp
= buf
;
554 if(length
+ bytes_read
< length
)
557 if(bytes_read
!= BUFLEN
&& tagged
)
560 length
+= bytes_read
;
562 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ *cp
++) & 0xFF];
568 for(; length
; length
>>= 8)
569 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ length
) & 0xFF];
571 crc
= ~crc
& 0xFFFFFFFF;
578 unsigned long cs_calc_buf_sum(char *buf
, int size
)
580 unsigned long crc
= 0;
582 unsigned long length
= size
;
585 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ *cp
++) & 0xFF];
587 for(; length
; length
>>= 8)
588 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ length
) & 0xFF];
590 crc
= ~crc
& 0xFFFFFFFF;
595 unsigned long cs_calc_buf_sum_ds(char *buf
, int buf_size
, char *sign
, int sign_len
)
597 unsigned long crc
= 0;
599 unsigned long length
= buf_size
+sign_len
;
602 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ *cp
++) & 0xFF];
606 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ *cp
++) & 0xFF];
609 for(; length
; length
>>= 8)
610 crc
=(crc
<< 8) ^ crctab
[((crc
>> 24) ^ length
) & 0xFF];
612 crc
= ~crc
& 0xFFFFFFFF;
617 int cs_set_sum(FILE *fp
, unsigned long sum
, int tagged
)
619 unsigned long magic
= CKSUM_MAGIC_NUMBER
;
622 fseek(fp
, -8, SEEK_END
);
624 fseek(fp
, 0, SEEK_END
);
626 if(fwrite(&magic
, 1, 4, fp
) < 4)
628 if(fwrite(&sum
, 1, 4, fp
) < 4)
634 void cs_get_sum(FILE *fp
, unsigned long *sum
)
636 unsigned long magic
= 0;
638 fseek(fp
, -8, SEEK_END
);
640 fread(&magic
, 4, 1, fp
);
641 fread(sum
, 4, 1, fp
);
644 int cs_validate_file(char *filename
)
647 unsigned long sum
= 0, res
= 0;
649 if((pFile
= fopen(filename
, "r")) == NULL
)
652 if(!cs_is_tagged(pFile
))
657 if(!cs_calc_sum(pFile
, &sum
, 1))
662 cs_get_sum(pFile
, &res
);
670 /* ********* Library internal data ********* */
671 #define CMDLINE_TRUE 1
672 #define CMDLINE_FALSE 0
674 typedef enum CMDLINE_ERR
676 CMDLINE_ERR_OK
= 0, /* No Error (OK) */
677 CMDLINE_ERR_ERROR
= -1, /* Unspecified error */
678 CMDLINE_ERR_INVKEY
= -3, /* Invalid option key */
679 CMDLINE_ERR_MANYARG
= -4, /* Too many arguments */
680 CMDLINE_ERR_FEWARG
= -5, /* Too few arguments */
681 CMDLINE_ERR_ILLOPT
= -6, /* Option not allowed (illegal option) */
682 CMDLINE_ERR_NOMEM
= -7, /* No memory */
683 CMDLINE_ERR_OPTMIS
= -8 /* A mandatory option is missing */
687 typedef struct CMDLINE_ARG
689 int index
; /* Index of the argument in the command line */
690 struct CMDLINE_ARG
* p_next
; /* Next node in the linked list */
693 /* Master control block for an option */
694 typedef struct CMDLINE_ARGS
696 int argc
; /* Total count of arguments found */
697 int optc
; /* Total count of options found */
698 CMDLINE_ARG
* list
; /* Argument list */
701 /* Master control block for all found arguments */
702 typedef struct CMDLINE_DATA
704 CMDLINE_ARGS opt_args
[26]; /* Array of MCBs for each option ('a' through 'z') */
705 CMDLINE_ARGS glb_args
; /* Global arguments */
706 int parsed
; /* Internal flag to prevent client calls if library is not initialized */
709 /* ********* Local Data ********* */
710 static CMDLINE_CFG cmdline_cfg
;
711 static CMDLINE_DATA cmdline_data
;
713 char* cmdline_errmsg
= "CMDLINE ERROR";
715 /* ***************************************************************
716 * Print all found command line options and their arguments
717 ****************************************************************** */
718 void* cmdline_getarg_list(char opt
)
720 int index
= (opt
- 'a');
722 /* Check the validity of the index */
723 if((index
< 0) || (index
> 25))
725 /* ERROR: Wrong option */
729 /* Return a pointer to the ARGS control structure */
730 return((void*)(&cmdline_data
.opt_args
[index
]));
733 /* ***************************************************************
734 * Print all found command line options and their arguments
735 ****************************************************************** */
736 int cmdline_getarg_count(void* list
)
738 CMDLINE_ARGS
* p_args
= (CMDLINE_ARGS
*)list
;
740 /* Return number of arguments for this option */
741 return(p_args
->argc
);
744 /* ***************************************************************
745 * Print all found command line options and their arguments
746 ****************************************************************** */
747 int cmdline_getopt_count(char opt
)
751 /* Calculate index value */
753 if(index
< 0 || index
> 25) return -1;
755 /* Return number of arguments for this option */
756 return(cmdline_data
.opt_args
[index
].optc
);
759 /* ***************************************************************
760 * Print all found command line options and their arguments
761 ****************************************************************** */
762 int cmdline_getarg(void* list
, int num
)
765 CMDLINE_ARGS
* p_args
= (CMDLINE_ARGS
*)list
;
768 /* Search the 'num' argument in the list for this option */
769 for(i
=0,p_arg
=p_args
->list
; (p_arg
!=NULL
) && (i
<p_args
->argc
); i
++, p_arg
=p_arg
->p_next
)
771 /* if num matches i, we found it */
772 if(i
==num
) return(p_arg
->index
);
774 /* We did not find the specified argument or the list was empty */
778 /* ***************************************************************
779 * Print all found command line options and their arguments
780 ****************************************************************** */
781 int cmdline_configure(CMDLINE_CFG
* p_cfg
)
783 /* reset global data */
784 memset(&cmdline_cfg
,0,sizeof(cmdline_cfg
));
785 memset(&cmdline_data
,0,sizeof(cmdline_data
));
787 /* Copy the user's config structure */
788 cmdline_cfg
= *p_cfg
;
792 /* ***************************************************************
793 * Print all found command line options and their arguments
794 ****************************************************************** */
795 char* cmdline_error(int err
)
797 /* TODO: implement a table of error messages */
798 return(cmdline_errmsg
);
801 /* ***************************************************************
802 * Print all found command line options and their arguments
803 ****************************************************************** */
804 static void cmdline_print_args(CMDLINE_ARGS
* p_arglist
, char* argv
[])
808 printf(" Number of times option was specified: %d\n", p_arglist
->optc
);
809 printf(" Number of Arguments: %d\n", p_arglist
->argc
);
811 if(p_arglist
->argc
> 0)
813 printf(" Argument List: ");
815 for(p_arg
=p_arglist
->list
; p_arg
!= NULL
; p_arg
=p_arg
->p_next
)
816 printf("%s ", argv
[p_arg
->index
]);
822 /* ***************************************************************
823 * Print all found command line options and their arguments
824 ****************************************************************** */
825 void cmdline_print(char* argv
[])
829 /* Check if the command line was parsed */
830 if(cmdline_data
.parsed
!= CMDLINE_TRUE
)
832 printf("The command line has not been parsed yet.\n");
836 /* Print out option arguments */
837 for( i
= 0; i
< 26; i
++ )
839 /* Check if the option was specified */
840 if(cmdline_data
.opt_args
[i
].optc
!=0 )
842 /* Print out option name and arguments */
843 printf("Option: -%c\n", (char)('a'+i
));
844 cmdline_print_args(&(cmdline_data
.opt_args
[i
]), argv
);
848 /* Print out global arguments */
849 printf("Global arguments:\n");
850 cmdline_print_args(&(cmdline_data
.glb_args
), argv
);
853 /* ***************************************************************
854 * Print configuration
855 ****************************************************************** */
856 void cmdline_print_cfg(void)
861 static void cmdline_argadd(CMDLINE_ARGS
* p_arglist
, CMDLINE_ARG
* p_arg
)
864 CMDLINE_ARG
* p_prev
=NULL
;
866 /* See if we had anything in the list */
867 if(p_arglist
->argc
== 0)
869 /* Link the argument in */
870 p_arglist
->list
= p_arg
;
874 /* Find the tail of the list */
875 for(p_list
=p_arglist
->list
; p_list
!= NULL
; p_list
=p_list
->p_next
)
878 /* Link the argument in */
879 p_prev
->p_next
=p_arg
;
882 /* Keep track of arg number */
886 /* ***************************************************************
888 * Read and parse command line arguments
889 ****************************************************************** */
890 int cmdline_read(int argc
, char* argv
[])
894 /* Process every command line argument in argv[] array */
895 for( i
= 1; i
< argc
; i
++ )
897 /* Does the argument start with a dash? */
898 if( *argv
[i
] == '-' )
900 /* The argument must be two characters: a dash, and a letter */
901 if( strlen(argv
[i
]) != 2 )
903 /* ERROR: option syntax (needs to be a dash and one letter) */
904 return(CMDLINE_ERR_ERROR
);
907 /* Check validity of the option key ('a' through 'z') */
908 if( ((*(argv
[i
] + 1)) < 'a') || ((*(argv
[i
] + 1)) > 'z') )
910 /* ERROR: option sysntax (invalid option key) */
911 return(CMDLINE_ERR_INVKEY
);
914 /* Calculate the option index */
915 option
= (*(argv
[i
] + 1)) - 'a';
916 if((option
< 0) || (option
> 25)) return(CMDLINE_ERR_INVKEY
);
918 /* Check to see if the option is allowed */
919 if( cmdline_cfg
.opts
[option
].flags
& CMDLINE_OPTFLAG_ALLOW
)
921 /* Option allowed. */
922 cmdline_data
.opt_args
[option
].optc
++;
927 /* ERROR: Option is not allowed */
928 return(CMDLINE_ERR_ILLOPT
);
933 /* Read the arguments for the option */
936 /* Allocate space for the argument node */
937 p_arg
= (CMDLINE_ARG
*)calloc(1,sizeof(CMDLINE_ARG
));
940 /* ERROR: Can't allocate memory for the argument index */
941 return(CMDLINE_ERR_NOMEM
);
944 /* Initialize the argument */
946 p_arg
->p_next
= NULL
;
948 /* Check if we can add to the list of arguments for this option */
949 if( (option
< 0) /* Do we have to add to the global list? */
950 || (cmdline_data
.opt_args
[option
].argc
== cmdline_cfg
.opts
[option
].max
) /* Did we reach MAX arguments? */
953 /* This option does not require arguments. Keep the argument in the global list. */
954 cmdline_argadd(&(cmdline_data
.glb_args
), p_arg
);
959 /* See if the current count has reached max for this option */
960 if( cmdline_data
.opt_args
[option
].argc
== cmdline_cfg
.opts
[option
].max
)
962 /* ERROR: too many arguments for an option */
963 return(CMDLINE_ERR_MANYARG
);
967 /* Link the argument to the arg list of the option */
968 cmdline_argadd(&(cmdline_data
.opt_args
[option
]), p_arg
);
975 /* ****** We read the complete command line. See if what we collected matches the configuration ******* */
977 /* Check every collected option against its configuration */
978 for( i
=0; i
< 26; i
++ )
980 /* Check if this option was allowed */
981 if(cmdline_cfg
.opts
[i
].flags
& CMDLINE_OPTFLAG_ALLOW
)
983 /* See if it was mandatory */
984 if(cmdline_cfg
.opts
[i
].flags
& CMDLINE_OPTFLAG_MANDAT
)
986 /* Check if we really collected this option on the command line. */
987 if(cmdline_data
.opt_args
[i
].optc
== 0)
989 /* ERROR: a missing mandatory option */
990 return(CMDLINE_ERR_OPTMIS
);
994 /* Option was there. Check how many args we got for it. */
995 if(cmdline_data
.opt_args
[i
].argc
< cmdline_cfg
.opts
[i
].min
)
997 /* ERROR: too few arguments for an option */
998 return(CMDLINE_ERR_FEWARG
);
1002 /* This mandatory option was proper. */
1007 else /* This is non-mandatory option: */
1009 /* Check if the option was specified on the command line */
1010 if(cmdline_data
.opt_args
[i
].optc
== 0)
1012 /* option wasn't specified, go to the next */
1017 /* Option was there. Check how many args we collected for it. */
1018 if(cmdline_data
.opt_args
[i
].argc
< cmdline_cfg
.opts
[i
].min
)
1020 /* ERROR: too few arguments for a non-mandatory option */
1021 return(CMDLINE_ERR_FEWARG
);
1025 /* This non-mandatory option was proper. */
1031 else /* Option was not allowed. */
1033 /* We should not get here as the non-allowed options should have been
1038 /* Command line was proper as far as the number of options and their arguments */
1039 cmdline_data
.parsed
= CMDLINE_TRUE
;
1040 return(CMDLINE_ERR_OK
);