fw_builder/bundle-tools/fwpack.c

/*
    A small tool to generate Wyse WinTerm firmware upgrade/add-on images
    Copyright (C) 2005  Wilmer van der Gaast <wilmer@gaast.net>
    
    This program is free software; you can redistribute it and/or
    modify it under the terms of the second version of the GNU
    General Public License as published by the Free Software
    Foundation.
    
    !!! GPL EXCEPTION: Since this program includes bits of data from original
    WYSE images during the compilation progress, you're NOT allowed to
    distribute binaries! Distribute this program ONLY IN SOURCE FORM !!!
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include "fwstruct.h"
#include "fwhead.h"

#ifndef BYTE_ORDER
#error "Couldn't determine byte order"
#endif

#define BUFSIZE 512

struct fwfile
{
	int fd;
	u_int32_t cs;
	u_int8_t cslen;
	union
	{
		u_int8_t byte[4];
		u_int32_t val;
	} csbuf;
};

struct fwfile *fwstart( char *fn );
int fwwrite( struct fwfile *fw, void *data, int size );
int fwpad( struct fwfile *fw, int align );
u_int32_t fwcs( struct fwfile *fw );
void fwclose( struct fwfile *fw );

int pad( off_t offset, int align );
char *basename( char *fn );
void verify_offset( int fd, off_t expect );

int main( int argc, char *argv[] )
{
	struct index *idx = NULL, *idxstart = NULL;
	struct fwfile *fw = NULL;
	u_int32_t int32;
	off_t cur;
	int fd, i;
	
	printf( "fwpack - Generate WYSE Winterm firmware bundles\n\n" );
	
	structcheck();
	
	if( argc < 3 )
	{
		fprintf( stderr, "Syntax: %s <image> <bios> [<other files> <...>]\n"
		                 "\n"
		                 "First argument is the destination file. After that, specify the files to put\n"
		                 "into the image. The first file will be used as the BIOS file, after that you\n"
		                 "can put other files you want to be in the image. The original firmware files\n"
		                 "have some flags that this tool won't create, so this tool is probably not\n"
		                 "suitable to create original WinCE firmware (or add-on) images. It's mainly\n"
		                 "meant to create Linux images.\n"
		                 "\n"
		                 "Also, a file named k will automatically be used for the hardware magic section\n"
		                 "in the headers.\n"
		                 "\n"
		                 "Don't forget to read the documentation before using this tool!\n", argv[0] );
		return( 1 );
	}
	
	if( strlen( basename( argv[2] ) ) > 8 )
	{
		fprintf( stderr, "BIOS filename too long!\n" );
		return( 1 );
	}
	
	printf( "Checking all files and building index" );
	fflush( stdout );
	cur = 0x59;
	for( i = 2; i < argc; i ++ )
	{
		struct fwfile *cscalc;
		char rdbuf[BUFSIZE];
		struct stat fs;
		int n;
		
		fd = open( argv[i], O_RDONLY );
		if( fd < 0 )
		{
			perror( "open" );
			return( 1 );
		}
		if( fstat( fd, &fs ) != 0 )
		{
			perror( "fstat" );
			return( 1 );
		}
		
		if( idx == NULL )
		{
			idx = idxstart = calloc( sizeof( struct index ), 1 );
		}
		else
		{
			idx->next = calloc( sizeof( struct index ), 1 );
			idx = idx->next;
		}
		idx->idx_offset = cur;
		idx->realfile = argv[i];
		
		/* Add one byte so the filename will be ASCIIZ. */
		idx->h = calloc( 1, 1 + sizeof( struct header ) + strlen( basename( argv[i] ) ) );
		idx->h->fnlen = strlen( basename( argv[i] ) );
		idx->h->hsize = idx->h->fnlen + sizeof( struct header );
		memcpy( idx->h->fn, basename( argv[i] ), idx->h->fnlen );
		
		/* BIOS gets a special flag. */
		if( i == 2 )
			idx->h->bios_flag = 0x10000;
		else
			idx->h->bios_flag = 0x20000;
		
		/* This flag is always 1 for system files, 5 for addon files. We have only system files. */
		idx->h->sys_flag[0] = 1;
		
		/* No idea what this is for, just typing something. :-) */
		idx->h->time = fs.st_mtime;
		
		/* This is a bit of a hack, but isn't that exactly what we're doing anyway? :-) */
		cscalc = fwstart( "/dev/null" );
		while( ( n = read( fd, rdbuf, BUFSIZE ) ) > 0 )
		{
			fwwrite( cscalc, rdbuf, n );
			idx->h->fsize += n;
		}
		idx->h->checksum = fwcs( cscalc );
		fwclose( cscalc );
		
		if( i == 2 && idx->h->fsize != 0x40000 )
			printf( "\nWARNING: BIOS file isn't %d bytes long!\n", 0x40000 );
		
		/* See if this is a hardware magic code? */
		if( ( strcmp( idx->h->fn, "k" ) == 0 ) && idx->h->fsize == 20 )
		{
			lseek( fd, 0, SEEK_SET );
			if( read( fd, fhead + 0x3f, 20 ) != 20 )
			{
				perror( "read" );
				return( 1 );
			}
		}
		
		cur += idx->h->hsize;
		close( fd );
		
		printf( "." );
		fflush( stdout );
	}
	printf( " Done!\n" );
	
	printf( "Building for machine type: %02x %02x %02x %02x\n",
	        fhead[0x3f], fhead[0x40], fhead[0x41], fhead[0x42] );
	
	/* Make sure there are at least two 0-bytes to end the index */
	if( pad( cur, 4 ) < 2 )
	{
		cur += 2;
	}
	cur += pad( cur, 4 );
	
	printf( "Calculating file offsets...\n" );
	for( idx = idxstart; idx; idx = idx->next )
	{
		idx->h->offset = cur;
		cur += idx->h->fsize;
		cur += pad( cur, 4 );
	}
	
	/* Add four bytes for the checksum. */
	cur += 4;
	printf( "Expected image size: %d\n", (int) cur );
	
	printf( "Now creating image headers and index... " );
	fflush( stdout );
	fw = fwstart( argv[1] );
	if( fw == NULL )
	{
		perror( "fwstart" );
		return( 1 );
	}
	
	/* Put the name of the BIOS image in the header. */
	strncpy( fhead + 0x37, basename( argv[2] ), 8 );
	
	/* The image size. */
	int32 = cvt32( cur );
	memcpy( fhead + 0x13, &int32, 4 );
	
	/* Write the image header. */
	fwwrite( fw, fhead, sizeof( fhead ) );
	
	for( idx = idxstart; idx; idx = idx->next )
	{
		/* Save this one now, we don't want to use it in swapped byte order. */
		int size = idx->h->hsize;
		
		verify_offset( fw->fd, idx->idx_offset );
		
		cvtheader( idx->h );
		fwwrite( fw, idx->h, size );
		cvtheader( idx->h );
	}
	
	/* There should be at least two 0-bytes at the end of the index. */
	if( pad( lseek( fw->fd, 0, SEEK_CUR ), 4 ) < 2 )
	{
		u_int16_t zero = 0;
		fwwrite( fw, &zero, 2 );
	}
	
	printf( "Done!\n" );
	
	printf( "Writing the files...\n" );
	for( idx = idxstart; idx; idx = idx->next )
	{
		char rdbuf[BUFSIZE];
		int n;
		
		printf( "  %s\n", idx->h->fn );
		
		/* Since we opened this same file a few moments ago, let's assume it can't go wrong. */
		fd = open( idx->realfile, O_RDONLY );
		
		/* Try to start every file at a 4-byte boundary. */
		fwpad( fw, 4 );
		
		verify_offset( fw->fd, idx->h->offset );
		
		while( ( n = read( fd, rdbuf, BUFSIZE ) ) > 0 )
		{
			if( fwwrite( fw, rdbuf, n ) <= 0 )
			{
				perror( "fwwrite" );
				return( 1 );
			}
		}
		
		close( fd );
	}
	
	fwpad( fw, 4 );
	
	int32 = fwcs( fw );
	int32 = cvt32( int32 );
	fwwrite( fw, &int32, 4 );
	
	verify_offset( fw->fd, cur );
	
	/* This is actually not very likely to go wrong... */
	if( fwcs( fw ) == 0 )
	{
		printf( "End checksum of file is 0, good!\n" );
	}
	else
	{
		fprintf( stderr, "WARNING: The file checksum is not right!\n" );
	}
	
	fwclose( fw );
	
	return( 0 );
}

struct fwfile *fwstart( char *fn )
{
	struct fwfile *fw;
	
	/* Using calloc because it gives zeroed mem. */
	fw = calloc( 1, sizeof( struct fwfile ) );
	fw->fd = open( fn, O_RDWR | O_CREAT | O_TRUNC, 0644 );
	fw->cs = 0xfffe1000;
	
	if( fw->fd < 0 )
	{
		free( fw );
		return( NULL );
	}
	
	return( fw );
}

int fwwrite( struct fwfile *fw, void *data, int size )
{
	if( write( fw->fd, data, size ) != size )
		return( -1 );
	
	/* If the checksum buffer isn't empty, try to empty it first. */
	if( fw->cslen != 0 )
	{
		if( size < ( 4 - fw->cslen ) )
		{
			memcpy( fw->csbuf.byte + fw->cslen, data, size );
			fw->cslen += size;
			return( size );
		}
		memcpy( fw->csbuf.byte + fw->cslen, data, ( 4 - fw->cslen ) );
		fw->cs -= cvt32( fw->csbuf.val );
		data += ( 4 - fw->cslen );
		size -= ( 4 - fw->cslen );
		fw->cslen = 0;
	}
	
	while( size >= 4 )
	{
		memcpy( fw->csbuf.byte, data, 4 );
		fw->cs -= cvt32( fw->csbuf.val );
		data += 4;
		size -= 4;
	}
	
	if( size > 0 )
	{
		fw->csbuf.val = 0;
		memcpy( fw->csbuf.byte, data, size );
		fw->cslen = size;
	}
	
	return( 1 );
}

int fwpad( struct fwfile *fw, int align )
{
	int padlen;
	char *dat;
	
	padlen = pad( lseek( fw->fd, 0, SEEK_CUR ), align );
	if( padlen == 0 )
		return( 0 );
	
	dat = calloc( padlen, 1 );
	if( fwwrite( fw, dat, padlen ) < 0 )
		return( -1 );
	else
		return( padlen );
}

u_int32_t fwcs( struct fwfile *fw )
{
	if( fw->cslen != 0 )
		return( fw->cs - fw->csbuf.val );
	else
		return( fw->cs );
}

void fwclose( struct fwfile *fw )
{
	close( fw->fd );
	free( fw );
}

int pad( off_t offset, int align )
{
	return( ( align - ( offset % align ) ) % align );
}

char *basename( char *fn )
{
	char *base = fn;
	
	while( *fn )
	{
		if( fn[0] == '/' && fn[1] && fn[1] != '/' )
			base = fn + 1;
		
		fn ++;
	}
	
	return( base );
}

void verify_offset( int fd, off_t expect )
{
	off_t cur;
	
	if( ( cur = lseek( fd, 0, SEEK_CUR ) ) != expect )
	{
		fprintf( stderr, "BUG: Something went wrong! Current offset: 0x%x, expected offset: 0x%x\n",
		                 (int) cur, (int) expect );
		exit( 1 );
	}
}
1	niro	658	/*
2			A small tool to generate Wyse WinTerm firmware upgrade/add-on images
3			Copyright (C) 2005 Wilmer van der Gaast <wilmer@gaast.net>
4
5			This program is free software; you can redistribute it and/or
6			modify it under the terms of the second version of the GNU
7			General Public License as published by the Free Software
8			Foundation.
9
10			!!! GPL EXCEPTION: Since this program includes bits of data from original
11			WYSE images during the compilation progress, you're NOT allowed to
12			distribute binaries! Distribute this program ONLY IN SOURCE FORM !!!
13
14			This program is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			GNU General Public License for more details.
18
19			You should have received a copy of the GNU General Public License
20			along with this program; if not, write to the Free Software
21			Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22			*/
23
24			#include <stdio.h>
25			#include <stdlib.h>
26			#include <sys/types.h>
27			#include <sys/stat.h>
28			#include <fcntl.h>
29			#include <unistd.h>
30			#include <string.h>
31			#include <errno.h>
32
33			#include "fwstruct.h"
34			#include "fwhead.h"
35
36			#ifndef BYTE_ORDER
37			#error "Couldn't determine byte order"
38			#endif
39
40			#define BUFSIZE 512
41
42			struct fwfile
43			{
44			int fd;
45			u_int32_t cs;
46			u_int8_t cslen;
47			union
48			{
49			u_int8_t byte[4];
50			u_int32_t val;
51			} csbuf;
52			};
53
54			struct fwfile fwstart( char fn );
55			int fwwrite( struct fwfile fw, void data, int size );
56			int fwpad( struct fwfile *fw, int align );
57			u_int32_t fwcs( struct fwfile *fw );
58			void fwclose( struct fwfile *fw );
59
60			int pad( off_t offset, int align );
61			char basename( char fn );
62			void verify_offset( int fd, off_t expect );
63
64			int main( int argc, char *argv[] )
65			{
66			struct index idx = NULL, idxstart = NULL;
67			struct fwfile *fw = NULL;
68			u_int32_t int32;
69			off_t cur;
70			int fd, i;
71
72			printf( "fwpack - Generate WYSE Winterm firmware bundles\n\n" );
73
74			structcheck();
75
76			if( argc < 3 )
77			{
78			fprintf( stderr, "Syntax: %s <image> <bios> [<other files> <...>]\n"
79			"\n"
80			"First argument is the destination file. After that, specify the files to put\n"
81			"into the image. The first file will be used as the BIOS file, after that you\n"
82			"can put other files you want to be in the image. The original firmware files\n"
83			"have some flags that this tool won't create, so this tool is probably not\n"
84			"suitable to create original WinCE firmware (or add-on) images. It's mainly\n"
85			"meant to create Linux images.\n"
86			"\n"
87			"Also, a file named k will automatically be used for the hardware magic section\n"
88			"in the headers.\n"
89			"\n"
90			"Don't forget to read the documentation before using this tool!\n", argv[0] );
91			return( 1 );
92			}
93
94			if( strlen( basename( argv[2] ) ) > 8 )
95			{
96			fprintf( stderr, "BIOS filename too long!\n" );
97			return( 1 );
98			}
99
100			printf( "Checking all files and building index" );
101			fflush( stdout );
102			cur = 0x59;
103			for( i = 2; i < argc; i ++ )
104			{
105			struct fwfile *cscalc;
106			char rdbuf[BUFSIZE];
107			struct stat fs;
108			int n;
109
110			fd = open( argv[i], O_RDONLY );
111			if( fd < 0 )
112			{
113			perror( "open" );
114			return( 1 );
115			}
116			if( fstat( fd, &fs ) != 0 )
117			{
118			perror( "fstat" );
119			return( 1 );
120			}
121
122			if( idx == NULL )
123			{
124			idx = idxstart = calloc( sizeof( struct index ), 1 );
125			}
126			else
127			{
128			idx->next = calloc( sizeof( struct index ), 1 );
129			idx = idx->next;
130			}
131			idx->idx_offset = cur;
132			idx->realfile = argv[i];
133
134			/* Add one byte so the filename will be ASCIIZ. */
135			idx->h = calloc( 1, 1 + sizeof( struct header ) + strlen( basename( argv[i] ) ) );
136			idx->h->fnlen = strlen( basename( argv[i] ) );
137			idx->h->hsize = idx->h->fnlen + sizeof( struct header );
138			memcpy( idx->h->fn, basename( argv[i] ), idx->h->fnlen );
139
140			/* BIOS gets a special flag. */
141			if( i == 2 )
142			idx->h->bios_flag = 0x10000;
143			else
144			idx->h->bios_flag = 0x20000;
145
146			/* This flag is always 1 for system files, 5 for addon files. We have only system files. */
147			idx->h->sys_flag[0] = 1;
148
149			/* No idea what this is for, just typing something. :-) */
150			idx->h->time = fs.st_mtime;
151
152			/* This is a bit of a hack, but isn't that exactly what we're doing anyway? :-) */
153			cscalc = fwstart( "/dev/null" );
154			while( ( n = read( fd, rdbuf, BUFSIZE ) ) > 0 )
155			{
156			fwwrite( cscalc, rdbuf, n );
157			idx->h->fsize += n;
158			}
159			idx->h->checksum = fwcs( cscalc );
160			fwclose( cscalc );
161
162			if( i == 2 && idx->h->fsize != 0x40000 )
163			printf( "\nWARNING: BIOS file isn't %d bytes long!\n", 0x40000 );
164
165			/* See if this is a hardware magic code? */
166			if( ( strcmp( idx->h->fn, "k" ) == 0 ) && idx->h->fsize == 20 )
167			{
168			lseek( fd, 0, SEEK_SET );
169			if( read( fd, fhead + 0x3f, 20 ) != 20 )
170			{
171			perror( "read" );
172			return( 1 );
173			}
174			}
175
176			cur += idx->h->hsize;
177			close( fd );
178
179			printf( "." );
180			fflush( stdout );
181			}
182			printf( " Done!\n" );
183
184			printf( "Building for machine type: %02x %02x %02x %02x\n",
185			fhead[0x3f], fhead[0x40], fhead[0x41], fhead[0x42] );
186
187			/* Make sure there are at least two 0-bytes to end the index */
188			if( pad( cur, 4 ) < 2 )
189			{
190			cur += 2;
191			}
192			cur += pad( cur, 4 );
193
194			printf( "Calculating file offsets...\n" );
195			for( idx = idxstart; idx; idx = idx->next )
196			{
197			idx->h->offset = cur;
198			cur += idx->h->fsize;
199			cur += pad( cur, 4 );
200			}
201
202			/* Add four bytes for the checksum. */
203			cur += 4;
204			printf( "Expected image size: %d\n", (int) cur );
205
206			printf( "Now creating image headers and index... " );
207			fflush( stdout );
208			fw = fwstart( argv[1] );
209			if( fw == NULL )
210			{
211			perror( "fwstart" );
212			return( 1 );
213			}
214
215			/* Put the name of the BIOS image in the header. */
216			strncpy( fhead + 0x37, basename( argv[2] ), 8 );
217
218			/* The image size. */
219			int32 = cvt32( cur );
220			memcpy( fhead + 0x13, &int32, 4 );
221
222			/* Write the image header. */
223			fwwrite( fw, fhead, sizeof( fhead ) );
224
225			for( idx = idxstart; idx; idx = idx->next )
226			{
227			/* Save this one now, we don't want to use it in swapped byte order. */
228			int size = idx->h->hsize;
229
230			verify_offset( fw->fd, idx->idx_offset );
231
232			cvtheader( idx->h );
233			fwwrite( fw, idx->h, size );
234			cvtheader( idx->h );
235			}
236
237			/* There should be at least two 0-bytes at the end of the index. */
238			if( pad( lseek( fw->fd, 0, SEEK_CUR ), 4 ) < 2 )
239			{
240			u_int16_t zero = 0;
241			fwwrite( fw, &zero, 2 );
242			}
243
244			printf( "Done!\n" );
245
246			printf( "Writing the files...\n" );
247			for( idx = idxstart; idx; idx = idx->next )
248			{
249			char rdbuf[BUFSIZE];
250			int n;
251
252			printf( " %s\n", idx->h->fn );
253
254			/* Since we opened this same file a few moments ago, let's assume it can't go wrong. */
255			fd = open( idx->realfile, O_RDONLY );
256
257			/* Try to start every file at a 4-byte boundary. */
258			fwpad( fw, 4 );
259
260			verify_offset( fw->fd, idx->h->offset );
261
262			while( ( n = read( fd, rdbuf, BUFSIZE ) ) > 0 )
263			{
264			if( fwwrite( fw, rdbuf, n ) <= 0 )
265			{
266			perror( "fwwrite" );
267			return( 1 );
268			}
269			}
270
271			close( fd );
272			}
273
274			fwpad( fw, 4 );
275
276			int32 = fwcs( fw );
277			int32 = cvt32( int32 );
278			fwwrite( fw, &int32, 4 );
279
280			verify_offset( fw->fd, cur );
281
282			/* This is actually not very likely to go wrong... */
283			if( fwcs( fw ) == 0 )
284			{
285			printf( "End checksum of file is 0, good!\n" );
286			}
287			else
288			{
289			fprintf( stderr, "WARNING: The file checksum is not right!\n" );
290			}
291
292			fwclose( fw );
293
294			return( 0 );
295			}
296
297			struct fwfile fwstart( char fn )
298			{
299			struct fwfile *fw;
300
301			/* Using calloc because it gives zeroed mem. */
302			fw = calloc( 1, sizeof( struct fwfile ) );
303			fw->fd = open( fn, O_RDWR \| O_CREAT \| O_TRUNC, 0644 );
304			fw->cs = 0xfffe1000;
305
306			if( fw->fd < 0 )
307			{
308			free( fw );
309			return( NULL );
310			}
311
312			return( fw );
313			}
314
315			int fwwrite( struct fwfile fw, void data, int size )
316			{
317			if( write( fw->fd, data, size ) != size )
318			return( -1 );
319
320			/* If the checksum buffer isn't empty, try to empty it first. */
321			if( fw->cslen != 0 )
322			{
323			if( size < ( 4 - fw->cslen ) )
324			{
325			memcpy( fw->csbuf.byte + fw->cslen, data, size );
326			fw->cslen += size;
327			return( size );
328			}
329			memcpy( fw->csbuf.byte + fw->cslen, data, ( 4 - fw->cslen ) );
330			fw->cs -= cvt32( fw->csbuf.val );
331			data += ( 4 - fw->cslen );
332			size -= ( 4 - fw->cslen );
333			fw->cslen = 0;
334			}
335
336			while( size >= 4 )
337			{
338			memcpy( fw->csbuf.byte, data, 4 );
339			fw->cs -= cvt32( fw->csbuf.val );
340			data += 4;
341			size -= 4;
342			}
343
344			if( size > 0 )
345			{
346			fw->csbuf.val = 0;
347			memcpy( fw->csbuf.byte, data, size );
348			fw->cslen = size;
349			}
350
351			return( 1 );
352			}
353
354			int fwpad( struct fwfile *fw, int align )
355			{
356			int padlen;
357			char *dat;
358
359			padlen = pad( lseek( fw->fd, 0, SEEK_CUR ), align );
360			if( padlen == 0 )
361			return( 0 );
362
363			dat = calloc( padlen, 1 );
364			if( fwwrite( fw, dat, padlen ) < 0 )
365			return( -1 );
366			else
367			return( padlen );
368			}
369
370			u_int32_t fwcs( struct fwfile *fw )
371			{
372			if( fw->cslen != 0 )
373			return( fw->cs - fw->csbuf.val );
374			else
375			return( fw->cs );
376			}
377
378			void fwclose( struct fwfile *fw )
379			{
380			close( fw->fd );
381			free( fw );
382			}
383
384			int pad( off_t offset, int align )
385			{
386			return( ( align - ( offset % align ) ) % align );
387			}
388
389			char basename( char fn )
390			{
391			char *base = fn;
392
393			while( *fn )
394			{
395			if( fn[0] == '/' && fn[1] && fn[1] != '/' )
396			base = fn + 1;
397
398			fn ++;
399			}
400
401			return( base );
402			}
403
404			void verify_offset( int fd, off_t expect )
405			{
406			off_t cur;
407
408			if( ( cur = lseek( fd, 0, SEEK_CUR ) ) != expect )
409			{
410			fprintf( stderr, "BUG: Something went wrong! Current offset: 0x%x, expected offset: 0x%x\n",
411			(int) cur, (int) expect );
412			exit( 1 );
413			}
414			}