firmware-utils: update to version 2021-10-05

Includes following changes:

 db65821f006c cmake: fix missing install target
 3a0cfc856991 Add initial GitLab CI support
 8f47adea6f87 Add missing includes for byte swap operations
 fbafae9f8037 Convert to CMake based project

Additionaly moves source code into separate Git project repository and
converts the package build to utilize CMake.

Signed-off-by: Petr Štetiar <ynezz@true.cz>
[rmilecki: rebase, update to the latest repo git & rm -r src]
Signed-off-by: Rafał Miłecki <rafal@milecki.pl>

1 files changed, 0 insertions, 1036 deletions

diff --git a/tools/firmware-utils/src/mktitanimg.c b/tools/firmware-utils/src/mktitanimg.c
deleted file mode 100644
index 654a6bd09b..0000000000
--- a/tools/firmware-utils/src/mktitanimg.c
+++ /dev/null
@@ -1,1036 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <libgen.h>
-#include "mktitanimg.h"
-
-
-struct checksumrecord
-{
-		unsigned int magic;
-        unsigned int    chksum;     /* The checksum for the complete header.
- Excepting the
-                                           checksum block */
-};
-/***************************************************************************
- * void print_help(void)
- ***************************************************************************/
-void print_help(void)
-{
-	static char* help_page[]=
-	{
-		"mknspimg version 1.0, Texas Instruments, 2004",
-		"Syntax:",
-		"        mknspimg -o outfile -i image1 image2 -a align1 align2 [-v] [-b] [-p prod_id] [-r rel_id] [-s rel_name] [-f flags]",
-		"Example:",
-		"        mknspimg -o nsp_image.bin -i kernel.bin files.img -a 0 4096",
-		"This generates 'nsp_image.bin' from two input files aligning first to 0 and second to 4096 bytes."
-	};
-
-	int num_lines = sizeof(help_page)/sizeof(char*);
-	int i;
-	for(i=0; i < num_lines; i++) {
-		printf("%s\n", help_page[i]);
-	}
-}
-
-/***************************************************************************
- * void mknspimg_print_hdr(NSP_IMG_HDR* p_img_hdr)
- ***************************************************************************/
-void mknspimg_print_hdr(struct nsp_img_hdr *hdr)
-{
-	struct nsp_img_hdr_chksum	*chksum;
-	struct nsp_img_hdr_sections	*section;
-	int i;
-
-	printf("****************** NSP Image Summary ******************\n");
-	printf("Magic:             0x%x\n",		hdr->head.magic);
-	printf("Image Header Size: 0x%x bytes\n",	hdr->head.hdr_size);
-	printf("Total Image Size:  %d bytes\n",		hdr->head.image_size);
-	printf("Product ID:        0x%x\n",		hdr->head.prod_id);
-	printf("Release ID:        0x%x\n",		hdr->head.rel_id);
-	printf("Version ID:        0x%x\n",		hdr->head.version);
-
-	printf("Offset Info:       0x%x\n",		hdr->head.info_offset);
-	printf("Offset Sect info:  0x%x\n",		hdr->head.sect_info_offset);
-	printf("Offset Sections:   0x%x\n",		hdr->sect_info.sections_offset);
-
-	chksum=(struct nsp_img_hdr_chksum *)(hdr+hdr->head.chksum_offset);
-	printf("Header Checksum:   0x%x\n",		chksum->hdr_chksum);
-
-	printf("+++ Section Information +++\n");
-	printf("# of sections:     %u\n", hdr->sect_info.num_sects);
-	section=&(hdr->sections);
-	for(i = 0; i < hdr->sect_info.num_sects; i++, section++) {
-		printf("+++++ Section %d +++++\n", i);
-		printf("Total size:  %u bytes\n",	section->total_size);
-		printf("Raw Size:    %u bytes\n",	section->raw_size);
-		printf("Offset:      0x%x\n",		section->offset);
-		printf("Type:        0x%x\n",		section->type);
-		printf("Name:        %s\n",		section->name);
-	}
-	printf("*******************************************************\n");
-}
-
-CMDLINE_CFG	cmd_line_cfg =
-{
-	{
-		/*	MIN	MAX	FLAGS					OPTION	*/
-		{	2,	2,	(CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },	/* '-a' align1 align2 */
-		{	0,	0,	CMDLINE_OPTFLAG_ALLOW },		/* '-b' bootstrap */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-c' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-d' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-e' */
-		{	1,	1,	CMDLINE_OPTFLAG_ALLOW },		/* '-f' flags */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-g' */
-		{	1,	1,	CMDLINE_OPTFLAG_ALLOW },		/* '-h' */
-		{	2,	2,	(CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },	/* '-i arg1 arg2 ' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-j' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-k' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-l' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-m' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-n' */
-		{	1,	1,	(CMDLINE_OPTFLAG_ALLOW | CMDLINE_OPTFLAG_MANDAT) },	/* '-o arg' */
-		{	1,	1,	CMDLINE_OPTFLAG_ALLOW },		/* '-p' PROD_ID */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-q' */
-		{	1,	1,	CMDLINE_OPTFLAG_ALLOW },		/* '-r' REL_ID */
-		{	1,	1,	CMDLINE_OPTFLAG_ALLOW },		/* '-s' "Release XXX.XXX" */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-t' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-u' */
-		{	0,	0,	CMDLINE_OPTFLAG_ALLOW },		/* '-v' control VERBOSE/NON-VERBOSE mode */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-w' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-x' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW },		/* '-y' */
-		{	0,	0,	!CMDLINE_OPTFLAG_ALLOW }		/* '-z' */
-	},
-	{	0,		0,	!CMDLINE_OPTFLAG_ALLOW },		/* global arguments */
-};
-
-/***************************************************************************
- * int nsp_img_write(void* image, char* file, int padding)
- * Write out the image.
- ***************************************************************************/
-int main(int argc, char* argv[], char* env[])
-{
-	FILE*	nsp_image	= NULL;
-	int header_version=1;
-	int	cmdline_err;
-	char*	cmdline_error_msg;
-
-	char*	filen_out;
-
-	int	i,count;			/* loop variables */
-	int	num_sects = 2;			/* We require exactly two image with -i option
-							   (see CMDLINE_CFG structure above) */
-	int	total = 0;
-
-	int	header_size=0;
-	struct nsp_img_hdr_head		*img_hdr_head;	/* Start of image header */
-	struct nsp_img_hdr_info *img_hdr_info;
-	struct nsp_img_hdr_section_info *img_hdr_section_info ;
-	struct nsp_img_hdr_sections	*img_hdr_sections, *section;	/* Section pointers */
-	
-
-	/* Configure the command line. */
-	cmdline_configure(&cmd_line_cfg);
-
-	/* Read and parse the command line. */
-	cmdline_err = cmdline_read(argc, argv);
-
-	/* Check for parsing errors. */
-	if(cmdline_err != 0) {
-		/* Get the parse error message */
-		cmdline_error_msg = cmdline_error(cmdline_err);
-
-		/* Print it out */
-		printf("%s\n", cmdline_error_msg);
-
-		/* Print our help too */
-		print_help();
-		return -1;
-	}
-	if(cmdline_getopt_count('h') > 0)
-	{
-		header_version=atoi(argv[cmdline_getarg(cmdline_getarg_list('h'),0)]);
-	}
-	/* Set up arguments */
-	filen_out	= argv[cmdline_getarg(cmdline_getarg_list('o'),0)];
-	/* Command line arguments have been parsed. Start doing our work. */
-
-	/* Caculate the header size, and allocate the memory, and assign the sub pointers */
-	header_size =	sizeof(struct nsp_img_hdr_head) +		/* This has a single section
-								   desc block already */
-				(header_version==1?0:4) + 
-				sizeof(struct nsp_img_hdr_info) + 
-				sizeof(struct nsp_img_hdr_section_info) + 
-			sizeof(struct nsp_img_hdr_sections) * num_sects ;
-
-	img_hdr_head = (struct nsp_img_hdr_head *)malloc(header_size);
-	memset(img_hdr_head, 0x0, header_size);
-	img_hdr_info = (struct nsp_img_hdr_info*)((char *)img_hdr_head + sizeof(struct nsp_img_hdr_head) + (header_version==1?0:4));
-	img_hdr_section_info = (struct nsp_img_hdr_section_info*)((char *)img_hdr_info + sizeof(struct nsp_img_hdr_info));
-	img_hdr_sections = (struct nsp_img_hdr_sections*)((char *)img_hdr_section_info + sizeof(struct nsp_img_hdr_section_info));
-	section = img_hdr_sections;
-	memset(img_hdr_head, 0xff, (void*)img_hdr_info - (void*)img_hdr_head);
-	
-	img_hdr_head->hdr_version = header_version;
-	img_hdr_head->hdr_size = header_size;
-	img_hdr_head->info_offset = (void*)img_hdr_info - (void*)img_hdr_head;
-	img_hdr_head->sect_info_offset = (void*)img_hdr_section_info - (void*)img_hdr_head;
-	
-	img_hdr_section_info->num_sects = num_sects;
-	img_hdr_section_info->sect_size = sizeof(struct nsp_img_hdr_sections);
-	img_hdr_section_info->sections_offset = (void*)img_hdr_sections - (void*)img_hdr_head;
-	
-/*	chksum = (struct nsp_img_hdr_chksum *)
-			((unsigned int)image_hdr + header_size - sizeof(struct nsp_img_hdr_chksum));*/
-
-	/* Open the out file */
-	nsp_image = fopen(filen_out,"wb+");
-	if(nsp_image==NULL) {
-		printf("ERROR: can't open %s for writing.\n", filen_out);
-		return -1;
-	}
-
-	/* Skip image header. We'll come back to it after we've written out the images. */	
-	fseek(nsp_image,header_size,SEEK_SET);
-	total = ftell(nsp_image);
-	total = header_size;
-	printf("total=%x\n",total);
-	{
-		int align;
-		int	padding;
-		char * buf;
-		align = (header_version==1?0x10000:0x4000);
-		if(align==0) {
-			/* The user indicated no padding */
-			padding = 0;
-		} else {
-			/* Calculate number padding bytes */
-			if((total %align) ==0)
-				padding=0;
-			else
-				padding = align - (total % align);
-		}
-		if(padding>0)
-		{
-			buf=malloc(padding);
-			memset(buf, 0xff, padding);
-			if(fwrite((void*)buf,1,padding,nsp_image)!=padding) {
-				printf("ERROR: can't write to %s.\n", filen_out);
-				free(buf);
-				fclose(nsp_image);
-				return -1;
-			}
-			free(buf);
-			
-		}
-		total+=padding;
-		
-
-	}
-	/* Write out all specified images (with -i option) */
-	for(i=0; i < num_sects; i++) {
-		char*	file_name;		/* input file name */
-		FILE*	filep;			/* input file pointer */
-		int	padding;		/* number of padding bytes to prepend */
-		int	align;			/* align factor from command line */
-		int	result;			/* intermediate result */
-		char * buf;
-
-		/* Open the specified image for reading */
-		file_name	= argv[cmdline_getarg(cmdline_getarg_list('i'),i)];
-		filep		= fopen(file_name, "rb");
-		if(filep==NULL) {
-			printf("ERROR: can't open file %s for reading.\n", file_name);
-			return -1;
-		}
-		section->flags = ~0x00;
-		/* Determine file size */
-		fseek(filep,0,SEEK_END);
-		section->raw_size=ftell(filep);
-		fseek(filep,0,SEEK_SET);
-		cs_calc_sum(filep,(unsigned long *)&section->chksum,0);
-		fseek(filep,0,SEEK_SET);
-
-		/* Retrieve the alignment constant */
-		/* Set image offset from the beginning of the out file */
-		section->offset=total;// + padding;
-
-		//total += padding;
-
-		/* Copy the image file into nsp_image */
-		count = section->raw_size;
-		buf=malloc(count);
-		result=fread(buf, 1, count, filep);
-		fwrite(buf, 1, result, nsp_image);
-		free(buf);
-		
-		/* HACK: This is a hack to get the names and types to the files.
-			TODO: Fix this to be a real method */
-		if(i==0){
-			section->type=NSP_IMG_SECTION_TYPE_KERNEL;
-			strncpy(section->name, "kernel", 16);
-		} else if(i==1){
-			section->type=NSP_IMG_SECTION_TYPE_FILESYSTEM_ROOT;
-			strncpy(section->name, "root", 16);
-		}
-
-		/* Account for the total */
-		align	=  strtoul(argv[cmdline_getarg(cmdline_getarg_list('a'),i)],NULL,0);
-		if(i==0){
-			if(align==0 || (((section->raw_size+ section->offset)%align)==0))
-				padding=0;
-			else
-				padding = align - ((section->raw_size+ section->offset) % align);
-
-			section->total_size=section->raw_size + padding;
-		}
-		else{
-			#define EXTRA_BLOCK 0x10000
-			unsigned int squash_padding;
-			squash_padding = EXTRA_BLOCK - section->raw_size % EXTRA_BLOCK;
-			buf=malloc(EXTRA_BLOCK + 4);
-			memset(buf, 0, squash_padding);
-			fwrite(buf, 1, squash_padding, nsp_image);
-			memset(buf, 0, EXTRA_BLOCK + 4);
-			*((unsigned int *)buf)=0xdec0adde;
-			*((unsigned int *)(buf+EXTRA_BLOCK))=0xdec0adde;
-			fwrite(buf, 1, EXTRA_BLOCK+4, nsp_image);
-			free(buf);
-			
-			if(align==0 || (((section->raw_size + (EXTRA_BLOCK + 4 + squash_padding)) %align)==0))
-				padding=0;
-			else
-				padding = align - ((section->raw_size + (EXTRA_BLOCK + 4 + squash_padding)) % align);
-			section->total_size=section->raw_size + (EXTRA_BLOCK + 4 + squash_padding) + padding;
-		}
-		if(padding>0){
-			buf=malloc(padding);
-			memset(buf, 0xff, padding);
-			fwrite(buf, 1, padding, nsp_image);
-			free(buf);
-		}
-		printf("*****padding is %d\ttotal_size=%d\traw_size=%d\n",padding, section->total_size, section->raw_size);
-
-		//total += section->raw_size;
-		total = section->total_size + section->offset;
-		printf("total=0x%x\n",total);
-		/* Close the input file */
-		fclose(filep);
-
-		/* Move the section pointer to the next slot */
-		section++;
-	}
-
-	/* Take care of the NSP image header fields */
-
-	/* head fields */
-	img_hdr_head->magic		= NSP_IMG_MAGIC_NUMBER;
-	img_hdr_head->boot_offset	= img_hdr_sections->offset;
-	img_hdr_head->flags		= ~0x00;			/* Set to all 1's */
-
-	if(cmdline_getopt_count('b'))
-		img_hdr_head->flags	&= ~(NSP_IMG_FLAG_FAILBACK_5 | NSP_IMG_FLAG_FAILBACK_1);
-
-	if(cmdline_getopt_count('f'))
-		img_hdr_head->flags	= strtoul(argv[cmdline_getarg(cmdline_getarg_list('f'),0)], 0, 16);
-
-#if 0
-	img_hdr_head->hdr_version	= 2;
-	img_hdr_head->hdr_size	= header_size;
-#endif
-
-	if(cmdline_getopt_count('p'))
-		img_hdr_head->prod_id		= strtoul(argv[cmdline_getarg(cmdline_getarg_list('p'),0)], 0, 16);
-	else
-		img_hdr_head->prod_id		= 0x4C575943;
-
-	if(cmdline_getopt_count('r'))
-		img_hdr_head->rel_id		= strtoul(argv[cmdline_getarg(cmdline_getarg_list('r'),0)], 0, 0);
-	else
-		img_hdr_head->rel_id		= 0x10203040;
-
-	if(cmdline_getopt_count('s'))
-		img_hdr_head->version		= strtoul(argv[cmdline_getarg(cmdline_getarg_list('s'),0)], 0, 0);
-	else
-		img_hdr_head->version		= 0x0b040000;
-	img_hdr_head->image_size	= total;
-#if 0
-	img_hdr_head->info_offset	= (unsigned int)(&(image_hdr->info)) -
-						(unsigned int)image_hdr;
-	img_hdr_head->sect_info_offset= (unsigned int)(&(image_hdr->sect_info)) -
-						(unsigned int)image_hdr;
-#endif
-//	image_hdr->head.chksum_offset	= (unsigned int)chksum - (unsigned int)image_hdr;
-	img_hdr_head->chksum_offset = 0xffffffff;
-//	image_hdr->head.pad1 = 0xffffffff;
-	/* info fields */
-	/* TODO: Fix. Do nothing yet */
-//	strncpy(nsp_img_hdr.id.prod_info,NSP_PRODINFO_STRING,sizeof(NSP_PRODINFO_STRING));
-	strcpy(img_hdr_info->image_filename, (const char *)basename(filen_out));
-	/* section fields */
-#if 0
-	img_hdr_section_info->num_sects=		num_sects;
-	img_hdr_section_info->sect_size=		sizeof(struct nsp_img_hdr_sections);
-	img_hdr_section_info->sections_offset=	(unsigned int)(&(image_hdr->sections)) -
-						(unsigned int)image_hdr;
-#endif
-
-	/* Calculate checksum(s) */
-#if 0
-	chksum->hdr_chksum = cs_calc_buf_sum((char*)image_hdr,
-			header_size - sizeof(struct nsp_img_hdr_chksum));
-#endif
-	/* Write out the NSP header. */
-	fseek(nsp_image,0,SEEK_SET);
-	count = fwrite((void*)img_hdr_head, header_size, 1, nsp_image);
-	if(count!=1) {
-		printf("ERROR: can't write to %s.\n", filen_out);
-		return -1;
-	}
-
-	/* Check if -v option was specified (no arg needed) */
-	if(cmdline_getopt_count('v') > 0)
-	{
-		struct nsp_img_hdr_head	head;
-		struct nsp_img_hdr	*hdr;
-
-		/* Rewind the file back to the beginning */
-		fseek(nsp_image,0,SEEK_SET);
-
-		/* Read header from the file */
-		fread((void*)&head, sizeof(struct nsp_img_hdr_head),
-				1, nsp_image);
-
-		/* Get memory to store the complete header */
-		hdr = (struct nsp_img_hdr *)malloc(head.hdr_size);
-
-		/* Read header from the file */
-		fseek(nsp_image,0,SEEK_SET);
-		fread((void*)hdr, head.hdr_size, 1, nsp_image);
-
-		/* Print it out */
-		mknspimg_print_hdr(hdr);
-		printf("Generated total %d bytes\n",total);
-		free(hdr);
-	}
-
-	free(img_hdr_head);
-
-      {
-	  struct checksumrecord cr;
-      cr.magic=CKSUM_MAGIC_NUMBER;
-      cs_calc_sum(nsp_image, (unsigned long *)&cr.chksum, 0);
-      fseek(nsp_image,0, SEEK_END);
-      fwrite(&cr, 1, sizeof(cr), nsp_image);
-	  }
-	  {
-		FILE * non_web;
-		char fname[256];
-		char * img_buf;
-		unsigned int len;
-		strcpy(fname, filen_out);
-		strcat(fname, ".non_web");
-		non_web = fopen(fname,"wb+");
-		fseek(nsp_image, 0, SEEK_END);
-		len = ftell(nsp_image);
-		img_buf=malloc(len);
-		fseek(nsp_image, 0, SEEK_SET);
-		fread(img_buf, 1, len, nsp_image);
-		img_buf[0xb] = 0x17;
-		fwrite(img_buf, 1, len-sizeof(struct checksumrecord), non_web);
-		fclose(non_web);
-		free(img_buf);
-	  }
-	  /* Close NSP image file */
-	fclose(nsp_image);
-
-	/* return result */
-	return(0);
-}
-
-#ifdef DMALLOC
-#include <dmalloc.h>
-#endif /* DMALLOC */
-
-#define BUFLEN (1 << 16)
-
-static unsigned long crctab[256] =
-{
-	0x0,
-	0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B,
-	0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6,
-	0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
-	0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC,
-	0x5BD4B01B, 0x569796C2, 0x52568B75, 0x6A1936C8, 0x6ED82B7F,
-	0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A,
-	0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
-	0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58,
-	0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033,
-	0xA4AD16EA, 0xA06C0B5D, 0xD4326D90, 0xD0F37027, 0xDDB056FE,
-	0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
-	0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4,
-	0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0,
-	0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5,
-	0x2AC12072, 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16,
-	0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA, 0x7897AB07,
-	0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C,
-	0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1,
-	0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
-	0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B,
-	0xBB60ADFC, 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698,
-	0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D,
-	0x94EA7B2A, 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E,
-	0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 0xC6BCF05F,
-	0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34,
-	0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80,
-	0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
-	0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A,
-	0x58C1663D, 0x558240E4, 0x51435D53, 0x251D3B9E, 0x21DC2629,
-	0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C,
-	0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
-	0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E,
-	0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65,
-	0xEBA91BBC, 0xEF68060B, 0xD727BBB6, 0xD3E6A601, 0xDEA580D8,
-	0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
-	0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2,
-	0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71,
-	0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74,
-	0x857130C3, 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640,
-	0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C, 0x7B827D21,
-	0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A,
-	0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E, 0x18197087,
-	0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
-	0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D,
-	0x2056CD3A, 0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE,
-	0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB,
-	0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18,
-	0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, 0x89B8FD09,
-	0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662,
-	0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF,
-	0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4
-};
-
-int cs_is_tagged(FILE *fp)
-{
-	char buf[8];
-
-	fseek(fp, -8, SEEK_END);
-	fread(buf, 8, 1, fp);
-	if(*(unsigned long*)buf == CKSUM_MAGIC_NUMBER)
-		return 1;
-	return 0;
-}
-
-unsigned long cs_read_sum(FILE *fp)
-{
-	char buf[8];
-
-	fseek(fp, -8, SEEK_END);
-	fread(buf, 8, 1, fp);
-	return *((unsigned long*)&buf[4]);
-}
-
-int cs_calc_sum(FILE *fp, unsigned long *res, int tagged)
-{
-	unsigned char buf[BUFLEN];
-	unsigned long crc = 0;
-	uintmax_t length = 0;
-	size_t bytes_read;
-
-	fseek(fp, 0, SEEK_SET);
-
-	while((bytes_read = fread(buf, 1, BUFLEN, fp)) > 0)
-	{
-		unsigned char *cp = buf;
-
-		if(length + bytes_read < length)
-			return 0;
-
-		if(bytes_read != BUFLEN && tagged)
-			bytes_read -= 8;
-
-		length += bytes_read;
-		while(bytes_read--)
-			crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
-	}
-
-	if(ferror(fp))
-		return 0;
-
-	for(; length; length >>= 8)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
-
-	crc = ~crc & 0xFFFFFFFF;
-
-	*res = crc;
-
-	return 1;
-}
-
-unsigned long cs_calc_buf_sum(char *buf, int size)
-{
-	unsigned long crc = 0;
-	char *cp = buf;
-	unsigned long length = size;
-
-	while(size--)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
-
-	for(; length; length >>= 8)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
-
-	crc = ~crc & 0xFFFFFFFF;
-
-	return crc;
-}
-
-unsigned long cs_calc_buf_sum_ds(char *buf, int buf_size, char *sign, int sign_len)
-{
-	unsigned long crc = 0;
-	char *cp = buf;
-	unsigned long length = buf_size+sign_len;
-
-	while(buf_size--)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
-
-	cp = sign;
-	while(sign_len--)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ *cp++) & 0xFF];
-
-
-	for(; length; length >>= 8)
-		crc =(crc << 8) ^ crctab[((crc >> 24) ^ length) & 0xFF];
-
-	crc = ~crc & 0xFFFFFFFF;
-
-	return crc;
-}
-
-int cs_set_sum(FILE *fp, unsigned long sum, int tagged)
-{
-	unsigned long magic = CKSUM_MAGIC_NUMBER;
-
-	if(tagged)
-		fseek(fp, -8, SEEK_END);
-	else
-		fseek(fp, 0, SEEK_END);
-
-	if(fwrite(&magic, 1, 4, fp) < 4)
-		return 0;
-	if(fwrite(&sum, 1, 4, fp) < 4)
-		return 0;
-
-	return 1;
-}
-
-void cs_get_sum(FILE *fp, unsigned long *sum)
-{
-	unsigned long magic = 0;
-
-	fseek(fp, -8, SEEK_END);
-
-	fread(&magic, 4, 1, fp);
-	fread(sum, 4, 1, fp);
-}
-
-int cs_validate_file(char *filename)
-{
-	FILE *pFile = NULL;
-	unsigned long sum = 0, res = 0;
-
-	if((pFile = fopen(filename, "r")) == NULL)
-		return 0;
-
-	if(!cs_is_tagged(pFile))
-	{
-		fclose(pFile);
-		return 0;
-	}
-	if(!cs_calc_sum(pFile, &sum, 1))
-	{
-		fclose(pFile);
-		return 0;
-	}
-	cs_get_sum(pFile, &res);
-	fclose(pFile);
-
-	if(sum != res)
-		return 0;
-	return 1;
-}
-
-/* ********* Library internal data ********* */
-#define	CMDLINE_TRUE			1
-#define	CMDLINE_FALSE			0
-
-typedef	enum CMDLINE_ERR
-{
-	CMDLINE_ERR_OK		= 0,	/* No Error (OK) */
-	CMDLINE_ERR_ERROR	= -1,	/* Unspecified error */
-	CMDLINE_ERR_INVKEY	= -3,	/* Invalid option key */
-	CMDLINE_ERR_MANYARG	= -4,	/* Too many arguments */
-	CMDLINE_ERR_FEWARG	= -5,	/* Too few arguments */
-	CMDLINE_ERR_ILLOPT	= -6,	/* Option not allowed (illegal option) */
-	CMDLINE_ERR_NOMEM	= -7,	/* No memory */
-	CMDLINE_ERR_OPTMIS	= -8	/* A mandatory option is missing */
-} CMDLINE_ERR;
-
-/* Argument list */
-typedef	struct CMDLINE_ARG
-{
-	int				index;		/* Index of the argument in the command line */
-	struct CMDLINE_ARG*	p_next;	/* Next node in the linked list */
-} CMDLINE_ARG;
-
-/* Master control block for an option */
-typedef struct CMDLINE_ARGS
-{
-	int				argc;		/* Total count of arguments found */
-	int				optc;		/* Total count of options found */
-	CMDLINE_ARG*	list;		/* Argument list */
-} CMDLINE_ARGS;
-
-/* Master control block for all found arguments */
-typedef	struct CMDLINE_DATA
-{
-	CMDLINE_ARGS	opt_args[26];	/* Array of MCBs for each option ('a' through 'z') */
-	CMDLINE_ARGS	glb_args;		/* Global arguments */
-	int				parsed;			/* Internal flag to prevent client calls if library is not initialized */
-} CMDLINE_DATA;
-
-/* ********* Local Data ********* */
-static CMDLINE_CFG cmdline_cfg;
-static CMDLINE_DATA cmdline_data;
-
-char*	cmdline_errmsg = "CMDLINE ERROR";
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-void* cmdline_getarg_list(char opt)
-{
-	int index = (opt - 'a');
-
-	/* Check the validity of the index */
-	if((index < 0) || (index > 25))
-	{
-		/* ERROR: Wrong option */
-		return NULL;
-	}
-
-	/* Return a pointer to the ARGS control structure */
-	return((void*)(&cmdline_data.opt_args[index]));
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-int cmdline_getarg_count(void* list)
-{
-	CMDLINE_ARGS*	p_args = (CMDLINE_ARGS*)list;
-
-	/* Return number of arguments for this option */
-	return(p_args->argc);
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-int cmdline_getopt_count(char opt)
-{
-	int				index;
-
-	/* Calculate index value */
-	index = opt - 'a';
-	if(index < 0 || index > 25) return -1;
-
-	/* Return number of arguments for this option */
-	return(cmdline_data.opt_args[index].optc);
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-int cmdline_getarg(void* list, int num)
-{
-	int i;
-	CMDLINE_ARGS*	p_args = (CMDLINE_ARGS*)list;
-	CMDLINE_ARG*	p_arg;
-
-	/* Search the 'num' argument in the list for this option */
-	for(i=0,p_arg=p_args->list; (p_arg!=NULL) && (i<p_args->argc); i++, p_arg=p_arg->p_next)
-	{
-		/* if num matches i, we found it */
-		if(i==num) return(p_arg->index);
-	}
-	/* We did not find the specified argument or the list was empty */
-	return -1;
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-int cmdline_configure(CMDLINE_CFG* p_cfg)
-{
-	/* reset global data */
-	memset(&cmdline_cfg,0,sizeof(cmdline_cfg));
-	memset(&cmdline_data,0,sizeof(cmdline_data));
-
-	/* Copy the user's config structure */
-	cmdline_cfg = *p_cfg;
-	return 0;
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-char* cmdline_error(int err)
-{
-	/* TODO: implement a table of error messages */
-	return(cmdline_errmsg);
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-static void cmdline_print_args(CMDLINE_ARGS* p_arglist, char* argv[])
-{
-	CMDLINE_ARG*	p_arg;
-
-	printf("   Number of times option was specified: %d\n", p_arglist->optc);
-	printf("   Number of Arguments:                  %d\n", p_arglist->argc);
-
-	if(p_arglist->argc > 0)
-	{
-		printf("   Argument List: ");
-
-		for(p_arg=p_arglist->list; p_arg != NULL; p_arg=p_arg->p_next)
-			printf("%s ", argv[p_arg->index]);
-	}
-
-	printf("\n");
-}
-
-/* ***************************************************************
-* Print all found command line options and their arguments
-****************************************************************** */
-void cmdline_print(char* argv[])
-{
-	int i;
-
-	/* Check if the command line was parsed */
-	if(cmdline_data.parsed != CMDLINE_TRUE)
-	{
-		printf("The command line has not been parsed yet.\n");
-		return;
-	}
-
-	/* Print out option arguments */
-	for( i = 0; i < 26; i++ )
-	{
-		/* Check if the option was specified */
-		if(cmdline_data.opt_args[i].optc !=0 )
-		{
-			/* Print out option name and arguments */
-			printf("Option: -%c\n", (char)('a'+i));
-			cmdline_print_args(&(cmdline_data.opt_args[i]), argv);
-		}
-	}
-
-	/* Print out global arguments */
-	printf("Global arguments:\n");
-	cmdline_print_args(&(cmdline_data.glb_args), argv);
-}
-
-/* ***************************************************************
-* Print configuration
-****************************************************************** */
-void cmdline_print_cfg(void)
-{
-
-}
-
-static void cmdline_argadd(CMDLINE_ARGS* p_arglist, CMDLINE_ARG* p_arg)
-{
-	CMDLINE_ARG*	p_list;
-	CMDLINE_ARG*	p_prev=NULL;
-
-	/* See if we had anything in the list */
-	if(p_arglist->argc == 0)
-	{
-		/* Link the argument in */
-		p_arglist->list = p_arg;
-	}
-	else
-	{
-		/* Find the tail of the list */
-		for(p_list=p_arglist->list; p_list != NULL; p_list=p_list->p_next)
-			p_prev = p_list;
-
-		/* Link the argument in */
-		p_prev->p_next=p_arg;
-	}
-
-	/* Keep track of arg number */
-	p_arglist->argc++;
-}
-
-/* ***************************************************************
-* cmdline_read()
-* Read and parse command line arguments
-****************************************************************** */
-int cmdline_read(int argc, char* argv[])
-{
-	int i, option=0;
-
-	/* Process every command line argument in argv[] array */
-	for( i = 1; i < argc; i++ )
-	{
-		/* Does the argument start with a dash? */
-		if( *argv[i] == '-' )
-		{
-			/* The argument must be two characters: a dash, and a letter */
-			if( strlen(argv[i]) != 2 )
-			{
-				/* ERROR: option syntax (needs to be a dash and one letter) */
-				return(CMDLINE_ERR_ERROR);
-			}
-
-			/* Check validity of the option key ('a' through 'z') */
-			if( ((*(argv[i] + 1)) < 'a') || ((*(argv[i] + 1)) > 'z') )
-			{
-				/* ERROR: option sysntax (invalid option key) */
-				return(CMDLINE_ERR_INVKEY);
-			}
-
-			/* Calculate the option index */
-			option = (*(argv[i] + 1)) - 'a';
-			if((option < 0) || (option > 25)) return(CMDLINE_ERR_INVKEY);
-
-			/* Check to see if the option is allowed */
-			if( cmdline_cfg.opts[option].flags & CMDLINE_OPTFLAG_ALLOW )
-			{
-				/* Option allowed. */
-				cmdline_data.opt_args[option].optc++;
-				continue;
-			}
-			else
-			{
-				/* ERROR: Option is not allowed */
-				return(CMDLINE_ERR_ILLOPT);
-			}
-		}
-		else
-		{
-			/* Read the arguments for the option */
-			CMDLINE_ARG*	p_arg;
-
-			/* Allocate space for the argument node */
-			p_arg = (CMDLINE_ARG*)calloc(1,sizeof(CMDLINE_ARG));
-			if( p_arg== NULL )
-			{
-				/* ERROR: Can't allocate memory for the argument index */
-				return(CMDLINE_ERR_NOMEM);
-			}
-
-			/* Initialize the argument */
-			p_arg->index	= i;
-			p_arg->p_next	= NULL;
-
-			/* Check if we can add to the list of arguments for this option */
-			if( (option < 0)																/* Do we have to add to the global list? */
-				|| (cmdline_data.opt_args[option].argc == cmdline_cfg.opts[option].max)		/* Did we reach MAX arguments? */
-				)
-			{
-				/* This option does not require arguments. Keep the argument in the global list. */
-				cmdline_argadd(&(cmdline_data.glb_args), p_arg);
-				continue;
-			}
-			else
-			{
-				/* See if the current count has reached max for this option */
-				if( cmdline_data.opt_args[option].argc == cmdline_cfg.opts[option].max )
-				{
-					/* ERROR: too many arguments for an option */
-					return(CMDLINE_ERR_MANYARG);
-				}
-				else
-				{
-					/* Link the argument to the arg list of the option */
-					cmdline_argadd(&(cmdline_data.opt_args[option]), p_arg);
-					continue;
-				}
-			}
-		}
-	}
-
-	/* ****** We read the complete command line. See if what we collected matches the configuration ******* */
-
-	/* Check every collected option against its configuration */
-	for( i=0; i < 26; i++ )
-	{
-		/* Check if this option was allowed */
-		if(cmdline_cfg.opts[i].flags & CMDLINE_OPTFLAG_ALLOW)
-		{
-			/* See if it was mandatory */
-			if(cmdline_cfg.opts[i].flags & CMDLINE_OPTFLAG_MANDAT)
-			{
-				/* Check if we really collected this option on the command line. */
-				if(cmdline_data.opt_args[i].optc == 0)
-				{
-					/* ERROR: a missing mandatory option */
-					return(CMDLINE_ERR_OPTMIS);
-				}
-				else
-				{
-					/* Option was there. Check how many args we got for it. */
-					if(cmdline_data.opt_args[i].argc < cmdline_cfg.opts[i].min)
-					{
-						/* ERROR: too few arguments for an option */
-						return(CMDLINE_ERR_FEWARG);
-					}
-					else
-					{
-						/* This mandatory option was proper. */
-						continue;
-					}
-				}
-			}
-			else	/* This is non-mandatory option: */
-			{
-				/* Check if the option was specified on the command line */
-				if(cmdline_data.opt_args[i].optc == 0)
-				{
-					/* option wasn't specified, go to the next */
-					continue;
-				}
-				else
-				{
-					/* Option was there. Check how many args we collected for it. */
-					if(cmdline_data.opt_args[i].argc < cmdline_cfg.opts[i].min)
-					{
-						/* ERROR: too few arguments for a non-mandatory option */
-						return(CMDLINE_ERR_FEWARG);
-					}
-					else
-					{
-						/* This non-mandatory option was proper. */
-						continue;
-					}
-				}
-			}
-		}
-		else	/* Option was not allowed. */
-		{
-			/* We should not get here as the non-allowed options should have been
-			trapped eariler. */
-		}
-	}
-
-	/* Command line was proper as far as the number of options and their arguments */
-	cmdline_data.parsed = CMDLINE_TRUE;
-	return(CMDLINE_ERR_OK);
-}