fw_builder/bundle-tools/fwextract.c

/*
    A small tool to read/edit 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.
    
    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"

#define BUFSIZE 512

int main( int argc, char *argv[] )
{
	struct index *idx = NULL;
	int fd;
	
	structcheck();
	
	if( argc < 3 )
	{
		fprintf( stderr, "extract - Read/Edit WYSE Winterm firmware bundles\n"
		                 "\n"
		                 "Syntax: %s <file> extract - Extract all files\n"
		                 "        %s <file> list - List contents\n"
		                 "        %s <file> insert <file> <slot> - Replace <slot> in archive with <file>\n",
		                 argv[0], argv[0], argv[0] );
		return( 1 );
	}
	
	fd = open( argv[1], O_RDONLY );
	if( fd < 0 )
	{
		perror( "open" );
		return( 1 );
	}
	
	lseek( fd, 0x59, SEEK_SET );
	
	printf( "%-8s  %-8s  %-8s  %-6s  %-8s  %-8s  %-s\n",
	        "Offset", "Size", "Checksum", "SysFlg", "BiosFlag", "Time", "Filename" );
	
	while( 1 )
	{
		struct header *head;
		struct index *tmp;
		off_t offset;
		
		head = malloc( sizeof( struct header ) );
		
		offset = lseek( fd, 0, SEEK_CUR );
		if( read( fd, head, sizeof( struct header ) ) != sizeof( struct header ) )
		{
			perror( "read" );
			return( 1 );
		}
		cvtheader( head );
		
		/* End of index? */
		if( head->hsize == 0 )
			break;
		
		head = realloc( head, head->hsize + 1 );
		head->fn[head->fnlen] = 0;
		if( read( fd, head->fn, head->fnlen ) != head->fnlen )
		{
			perror( "read" );
			return( 1 );
		}
		
		printf( "%08x  %08x  %08x  %02x%02x%02x  %08x  %08x  %s\n",
		        head->offset, head->fsize, head->checksum, head->sys_flag[0],
		        head->sys_flag[1], head->sys_flag[2], head->bios_flag, head->time, head->fn );
		
		/* Remember that here the new file gets inserted at the
		   beginning of the list, so the whole list will be in
		   reversed order. The rest of the code might break if you
		   change this... */
		tmp = malloc( sizeof( struct index ) );
		tmp->h = head;
		tmp->next = idx;
		tmp->idx_offset = offset;
		idx = tmp;
	}
	
	if( strcmp( argv[2], "list" ) == 0 )
	{
		/* Do nothing */
	}
	else if( strcmp( argv[2], "insert" ) == 0 )
	{
#if BYTE_ORDER != BIG_ENDIAN
		struct index *tmp;
		struct stat src_info;
		unsigned int slot_cs, arch_cs, buf;
		int sfd, size;
		
		/* Warning: This code is "reasonably" dirty. :-) */
		
		if( argc < 5 )
		{
			fprintf( stderr, "Not enough arguments\n" );
			return( 1 );
		}
		
		/* Find the slot */
		for( tmp = idx; tmp; tmp = tmp->next )
			if( strcmp( tmp->h->fn, argv[4] ) == 0 )
				break;
		
		if( tmp == NULL )
		{
			fprintf( stderr, "Slot does not exist\n" );
			return( 1 );
		}
		
		/* Open the file to be inserted */
		if( ( sfd = open( argv[3], O_RDONLY ) ) == -1 )
		{
			perror( "open" );
			return( 1 );
		}
		
		/* Check if sizes are okay */
		fstat( sfd, &src_info );
		if( tmp->h->fsize < src_info.st_size )
		{
			fprintf( stderr, "Can't insert file, slot is too small\n" );
			return( 1 );
		}
		
		/* To recalculate the new total-checksum, get the current one
		   and "remove" the existing file from it. */
		lseek( fd, -4, SEEK_END );
		read( fd, &arch_cs, 4 );
		
		/* Note that the checksums are per-word and these things aren't
		   necessarily word-aligned, so we have to handle this correctly. */
		lseek( fd, tmp->h->offset & ~3, SEEK_SET );
		for( size = src_info.st_size + ( tmp->h->offset & 3 ); size > 0; size -= 4 )
		{
			read( fd, &buf, 4 );
			arch_cs += buf;
		}
		
		/* Also "remove" the index entry from the checksum. */
		lseek( fd, tmp->idx_offset & ~3, SEEK_SET );
		for( size = tmp->h->fsize + ( tmp->h->fsize & 3 ); size > 0; size -= 4 )
		{
			read( fd, &buf, 4 );
			arch_cs += buf;
		}
		
		/* Oh yes, we want to write now... */
		close( fd );
		if( ( fd = open( argv[1], O_RDWR ) ) < 0 )
		{
			perror( "open" );
			return( 1 );
		}
		lseek( fd, tmp->h->offset, SEEK_SET );
		
		/* We're doing this in small 4-byte blocks. This is slow, but
		   it's more convenient because of the checkum calculation. */
		slot_cs = 0xFFFE1000;
		while( 1 )
		{
			unsigned int n;
			
			buf = 0;
			n = read( sfd, &buf, 4 );
			
			if( n == 0 )
				break;
			
			slot_cs -= buf;
			// arch_cs -= buf;
			write( fd, &buf, 4 );
		}
		
		/* Write the new slot checksum */
		tmp->h->checksum = slot_cs;
		tmp->h->fsize = src_info.st_size;
		lseek( fd, tmp->idx_offset, SEEK_SET );
		write( fd, tmp->h, tmp->h->fsize );
		
		/* "Add" the new contents to the checksum */
		lseek( fd, tmp->h->offset & ~3, SEEK_SET );
		for( size = src_info.st_size + ( tmp->h->offset & 3 ); size > 0; size -= 4 )
		{
			read( fd, &buf, 4 );
			arch_cs -= buf;
		}
		
		/* Don't forget the index entry, it also changed. */
		lseek( fd, tmp->idx_offset & ~3, SEEK_SET );
		for( size = tmp->h->fsize + ( tmp->h->fsize & 3 ); size > 0; size -= 4 )
		{
			read( fd, &buf, 4 );
			arch_cs -= buf;
		}
		
		/* Write the new archive checksum */
		lseek( fd, -4, SEEK_END );
		write( fd, &arch_cs, 4 );
#else
		fprintf( stderr, "Big-endian version doesn't support inserting, sorry.\n" );
#endif
	}
	else
	{
		while( idx ) /* Default action: We're extracting */
		{
			char buf[BUFSIZE];
			int len, toread, ofd;
			
			lseek( fd, idx->h->offset, SEEK_SET );
			len = idx->h->fsize;
			
			ofd = open( idx->h->fn, O_WRONLY | O_CREAT | O_EXCL, 0644 );
			if( ofd < 0 )
			{
				if( errno == EEXIST )
				{
					printf( "Warning: File already exists: %s\n", idx->h->fn );
					idx = idx->next;
					continue;
				}
				else
				{
					perror( "open" );
					return( 1 );
				}
			}
			
			while( len > 0 )
			{
				toread = len > BUFSIZE ? BUFSIZE : len;
				
				if( read( fd, buf, toread ) != toread )
				{
					perror( "read" );
					return( 1 );
				}
				
				if( write( ofd, buf, toread ) != toread )
				{
					perror( "write" );
					return( 1 );
				}
				
				len -= toread;
			}
			
			close( ofd );
			
			idx = idx->next;
		}
	}
	
	return( 0 );
}
1	/*
2	A small tool to read/edit 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	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18	*/
19
20	#include <stdio.h>
21	#include <stdlib.h>
22	#include <sys/types.h>
23	#include <sys/stat.h>
24	#include <fcntl.h>
25	#include <unistd.h>
26	#include <string.h>
27	#include <errno.h>
28
29	#include "fwstruct.h"
30
31	#define BUFSIZE 512
32
33	int main( int argc, char *argv[] )
34	{
35	struct index *idx = NULL;
36	int fd;
37
38	structcheck();
39
40	if( argc < 3 )
41	{
42	fprintf( stderr, "extract - Read/Edit WYSE Winterm firmware bundles\n"
43	"\n"
44	"Syntax: %s <file> extract - Extract all files\n"
45	" %s <file> list - List contents\n"
46	" %s <file> insert <file> <slot> - Replace <slot> in archive with <file>\n",
47	argv[0], argv[0], argv[0] );
48	return( 1 );
49	}
50
51	fd = open( argv[1], O_RDONLY );
52	if( fd < 0 )
53	{
54	perror( "open" );
55	return( 1 );
56	}
57
58	lseek( fd, 0x59, SEEK_SET );
59
60	printf( "%-8s %-8s %-8s %-6s %-8s %-8s %-s\n",
61	"Offset", "Size", "Checksum", "SysFlg", "BiosFlag", "Time", "Filename" );
62
63	while( 1 )
64	{
65	struct header *head;
66	struct index *tmp;
67	off_t offset;
68
69	head = malloc( sizeof( struct header ) );
70
71	offset = lseek( fd, 0, SEEK_CUR );
72	if( read( fd, head, sizeof( struct header ) ) != sizeof( struct header ) )
73	{
74	perror( "read" );
75	return( 1 );
76	}
77	cvtheader( head );
78
79	/* End of index? */
80	if( head->hsize == 0 )
81	break;
82
83	head = realloc( head, head->hsize + 1 );
84	head->fn[head->fnlen] = 0;
85	if( read( fd, head->fn, head->fnlen ) != head->fnlen )
86	{
87	perror( "read" );
88	return( 1 );
89	}
90
91	printf( "%08x %08x %08x %02x%02x%02x %08x %08x %s\n",
92	head->offset, head->fsize, head->checksum, head->sys_flag[0],
93	head->sys_flag[1], head->sys_flag[2], head->bios_flag, head->time, head->fn );
94
95	/* Remember that here the new file gets inserted at the
96	beginning of the list, so the whole list will be in
97	reversed order. The rest of the code might break if you
98	change this... */
99	tmp = malloc( sizeof( struct index ) );
100	tmp->h = head;
101	tmp->next = idx;
102	tmp->idx_offset = offset;
103	idx = tmp;
104	}
105
106	if( strcmp( argv[2], "list" ) == 0 )
107	{
108	/* Do nothing */
109	}
110	else if( strcmp( argv[2], "insert" ) == 0 )
111	{
112	#if BYTE_ORDER != BIG_ENDIAN
113	struct index *tmp;
114	struct stat src_info;
115	unsigned int slot_cs, arch_cs, buf;
116	int sfd, size;
117
118	/* Warning: This code is "reasonably" dirty. :-) */
119
120	if( argc < 5 )
121	{
122	fprintf( stderr, "Not enough arguments\n" );
123	return( 1 );
124	}
125
126	/* Find the slot */
127	for( tmp = idx; tmp; tmp = tmp->next )
128	if( strcmp( tmp->h->fn, argv[4] ) == 0 )
129	break;
130
131	if( tmp == NULL )
132	{
133	fprintf( stderr, "Slot does not exist\n" );
134	return( 1 );
135	}
136
137	/* Open the file to be inserted */
138	if( ( sfd = open( argv[3], O_RDONLY ) ) == -1 )
139	{
140	perror( "open" );
141	return( 1 );
142	}
143
144	/* Check if sizes are okay */
145	fstat( sfd, &src_info );
146	if( tmp->h->fsize < src_info.st_size )
147	{
148	fprintf( stderr, "Can't insert file, slot is too small\n" );
149	return( 1 );
150	}
151
152	/* To recalculate the new total-checksum, get the current one
153	and "remove" the existing file from it. */
154	lseek( fd, -4, SEEK_END );
155	read( fd, &arch_cs, 4 );
156
157	/* Note that the checksums are per-word and these things aren't
158	necessarily word-aligned, so we have to handle this correctly. */
159	lseek( fd, tmp->h->offset & ~3, SEEK_SET );
160	for( size = src_info.st_size + ( tmp->h->offset & 3 ); size > 0; size -= 4 )
161	{
162	read( fd, &buf, 4 );
163	arch_cs += buf;
164	}
165
166	/* Also "remove" the index entry from the checksum. */
167	lseek( fd, tmp->idx_offset & ~3, SEEK_SET );
168	for( size = tmp->h->fsize + ( tmp->h->fsize & 3 ); size > 0; size -= 4 )
169	{
170	read( fd, &buf, 4 );
171	arch_cs += buf;
172	}
173
174	/* Oh yes, we want to write now... */
175	close( fd );
176	if( ( fd = open( argv[1], O_RDWR ) ) < 0 )
177	{
178	perror( "open" );
179	return( 1 );
180	}
181	lseek( fd, tmp->h->offset, SEEK_SET );
182
183	/* We're doing this in small 4-byte blocks. This is slow, but
184	it's more convenient because of the checkum calculation. */
185	slot_cs = 0xFFFE1000;
186	while( 1 )
187	{
188	unsigned int n;
189
190	buf = 0;
191	n = read( sfd, &buf, 4 );
192
193	if( n == 0 )
194	break;
195
196	slot_cs -= buf;
197	// arch_cs -= buf;
198	write( fd, &buf, 4 );
199	}
200
201	/* Write the new slot checksum */
202	tmp->h->checksum = slot_cs;
203	tmp->h->fsize = src_info.st_size;
204	lseek( fd, tmp->idx_offset, SEEK_SET );
205	write( fd, tmp->h, tmp->h->fsize );
206
207	/* "Add" the new contents to the checksum */
208	lseek( fd, tmp->h->offset & ~3, SEEK_SET );
209	for( size = src_info.st_size + ( tmp->h->offset & 3 ); size > 0; size -= 4 )
210	{
211	read( fd, &buf, 4 );
212	arch_cs -= buf;
213	}
214
215	/* Don't forget the index entry, it also changed. */
216	lseek( fd, tmp->idx_offset & ~3, SEEK_SET );
217	for( size = tmp->h->fsize + ( tmp->h->fsize & 3 ); size > 0; size -= 4 )
218	{
219	read( fd, &buf, 4 );
220	arch_cs -= buf;
221	}
222
223	/* Write the new archive checksum */
224	lseek( fd, -4, SEEK_END );
225	write( fd, &arch_cs, 4 );
226	#else
227	fprintf( stderr, "Big-endian version doesn't support inserting, sorry.\n" );
228	#endif
229	}
230	else
231	{
232	while( idx ) /* Default action: We're extracting */
233	{
234	char buf[BUFSIZE];
235	int len, toread, ofd;
236
237	lseek( fd, idx->h->offset, SEEK_SET );
238	len = idx->h->fsize;
239
240	ofd = open( idx->h->fn, O_WRONLY \| O_CREAT \| O_EXCL, 0644 );
241	if( ofd < 0 )
242	{
243	if( errno == EEXIST )
244	{
245	printf( "Warning: File already exists: %s\n", idx->h->fn );
246	idx = idx->next;
247	continue;
248	}
249	else
250	{
251	perror( "open" );
252	return( 1 );
253	}
254	}
255
256	while( len > 0 )
257	{
258	toread = len > BUFSIZE ? BUFSIZE : len;
259
260	if( read( fd, buf, toread ) != toread )
261	{
262	perror( "read" );
263	return( 1 );
264	}
265
266	if( write( ofd, buf, toread ) != toread )
267	{
268	perror( "write" );
269	return( 1 );
270	}
271
272	len -= toread;
273	}
274
275	close( ofd );
276
277	idx = idx->next;
278	}
279	}
280
281	return( 0 );
282	}