projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
tools: update gmp to 4.3.2
[openwrt.git] / tools / wrt350nv2-builder / src / wrt350nv2-builder.c
1 /*
2
3 WRT350Nv2-Builder 2.2 (previously called buildimg)
4 Copyright (C) 2008-2009 Dirk Teurlings <info@upexia.nl>
5 Copyright (C) 2009-2010 Matthias Buecher (http://www.maddes.net/)
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
21 A lot of thanks to Kaloz and juhosg from OpenWRT and Lennert Buytenhek from
22 marvell for helping me figure this one out. This code is based on bash
23 scripts wrote by Peter van Valderen so the real credit should go to him.
24
25 This program reads the provided parameter file and creates an image which can
26 be used to flash a Linksys WRT350N v2 from stock firmware.
27 The trick is to fill unused space in the bin file with random, so that the
28 resulting zip file passes the size check of the stock firmware.
29
30 The parameter file layout for an original Linksys firmware:
31 :kernel 0x001A0000 /path/to/uImage
32 :rootfs 0 /path/to/root.squashfs
33 :u-boot 0 /path/to/u-boot.bin
34 #version 0x2020
35
36 args:
37 1 wrt350nv2.par parameter file describing the image layout
38 2 wrt350nv2.img output file for linksys style image
39
40 A u-boot image inside the bin file is not necessary.
41 The version is not important.
42 The name of the bin file is not important, but still "wrt350n.bin" is used to
43 keep as close as possible to the stock firmware.
44
45 Linksys assumes that no mtd will be used to its maximum, so the last 16 bytes
46 of the mtd are abused to define the length of the next mtd content (4 bytes for
47 size + 12 pad bytes).
48
49 At the end of "rootfs" additional 16 bytes are abused for some data and a
50 highly important eRcOmM identifier, so the last 32 bytes of "rootfs" are abused.
51
52 At the end of "u-boot" 128 bytes are abused for some data, a checksum and a
53 highly important sErCoMm identifier.
54
55
56 This program uses a special GNU scanf modifier to allocate
57 sufficient memory for a strings with unknown length.
58 See http://www.kernel.org/doc/man-pages/online/pages/man3/scanf.3.html#NOTES
59
60
61 To extract everything from a Linksys style firmware image see
62 https://forum.openwrt.org/viewtopic.php?pid=92928#p92928
63
64 Changelog:
65 v2.2 - fixed checksum byte calculation for other versions than 0x2019
66 fixed rare problem with padsize
67 updated info to stock firmware 2.00.20
68 fixed typos
69 v2.1 - used "wrt350n.bin" for the created image (closer to stock)
70 added option to create the image in two separate steps (-b / -z)
71 v2.0 - complete re-write
72
73 */
74
75 // includes
76 #define _GNU_SOURCE // for GNU's basename()
77 #include <assert.h>
78 #include <errno.h> // errno
79 #include <stdarg.h>
80 #include <stdio.h> // fopen(), fread(), fclose(), etc.
81 #include <stdlib.h> // system(), etc.
82 #include <string.h> // basename(), strerror(), strdup(), etc.
83 #include <unistd.h> // optopt(), access(), etc.
84 #include <libgen.h>
85 #include <sys/wait.h> // WEXITSTATUS, etc.
86
87 // custom includes
88 #include "md5.h" // MD5 routines
89 #include "upgrade.h" // Linksys definitions from firmware 2.0.19 (unchanged up to 2.0.20)
90
91
92 // version info
93 #define VERSION "2.2"
94 char program_info[] = "WRT350Nv2-Builder v%s by Dirk Teurlings <info@upexia.nl> and Matthias Buecher (http://www.maddes.net/)\n";
95
96 // verbosity
97 #define DEBUG 1
98 #define DEBUG_LVL2 2
99 int verbosity = 0;
100
101 // mtd info
102 typedef struct {
103 char *name;
104 int offset;
105 int size;
106 char *filename;
107 long int filesize;
108 unsigned char magic[2];
109 } mtd_info;
110
111 mtd_info mtd_kernel = { "kernel", 0, 0, NULL, 0L, { 0, 0 } };
112 mtd_info mtd_rootfs = { "rootfs", 0, 0, NULL, 0L, { 0, 0 } };
113 mtd_info mtd_uboot = { "u-boot", 0, 0, NULL, 0L, { 0, 0 } };
114
115 #define ROOTFS_END_OFFSET 0x00760000
116 #define ROOTFS_MIN_OFFSET 0x00640000 // should be filled up to here, to make sure that the zip file is big enough to pass the size check of the stock firmware
117 // 2.0.17: filled up to 0x00640000
118 // 2.0.19: filled up to 0x00670000
119 // 2.0.20: filled up to 0x00670000
120
121 // rootfs statics via: hexdump -v -e '1/1 "0x%02X, "' -s 0x0075FFE0 -n 16 "wrt350n.bin" ; echo -en "\n"
122 unsigned char product_id[] = { 0x00, 0x03 }; // seems to be a fixed value
123 unsigned char protocol_id[] = { 0x00, 0x00 }; // seems to be a fixed value
124 unsigned char fw_version[] = { 0x20, 0x20 };
125 unsigned char rootfs_unknown[] = { 0x90, 0xF7 }; // seems to be a fixed value
126 unsigned char sign[] = { 0x65, 0x52, 0x63, 0x4F, 0x6D, 0x4D, 0x00, 0x00 }; // eRcOmM
127
128 // u-boot statics via: hexdump -v -e '1/1 "0x%02X, "' -s 0x007FFF80 -n 128 "wrt350n.bin" ; echo -en "\n"
129 //unsigned char sn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // (12) seems to be an unused value
130 //unsigned char pin[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // (8) seems to be an unused value
131 //unsigned char node[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // (25) seems to be an unused value
132 // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
133 //unsigned char checksum[] = { 0xE9 }; // (1) is calculated, does it belong to node?
134 unsigned char pid[] = { 0x73, 0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D, 0x00, 0x01, 0x00, 0x00, 0x59, 0x42, 0x50, 0x00, 0x01, // (70) seems to be a fixed value, except for fw version
135 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
136 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, // protocol id?
137 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // protocol id?
138 0x12, 0x34, // firmware version, same as in rootfs
139 0x00, 0x00, 0x00, 0x04,
140 0x73, 0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D }; // sErCoMm
141
142 // img statics via: hexdump -v -e '1/1 "0x%02X, "' -s 0 -n 512 "WRT350N-EU-ETSI-2.00.19.img" ; echo -en "\n" (unchanged up to 2.0.20)
143 unsigned char img_hdr[] = { 0x00, 0x01, 0x00, 0x00, 0x59, 0x42, 0x50, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
145 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
146 0x00, 0x00,
147 0x12, 0x34, // firmware version, same as in rootfs
148 0x00, 0x00, 0x00, 0x04, 0x61, 0x44, 0x6D, 0x42, 0x6C, 0x4B, 0x3D, 0x00,
149 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
150 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
151 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
152 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
153 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
154 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
155 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
156 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
157 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
158 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
159 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
160 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
161 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
162 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
163 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
164 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
165 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
166 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
167 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
168 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
169 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
170 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
172 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
173 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
175 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, // md5 checksum
176 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
177
178 unsigned char img_eof[] = { 0xFF };
179
180
181 void lprintf(int outputlevel, char *fmt, ...) {
182 va_list argp;
183 if (outputlevel <= verbosity) {
184 va_start(argp, fmt);
185 vprintf(fmt, argp);
186 va_end(argp);
187 }
188 }
189
190
191 int parse_par_file(FILE *f_par) {
192 int exitcode = 0;
193
194 char *buffer;
195 size_t buffer_size;
196 char *line;
197
198 int lineno;
199 int count;
200
201 char string1[256];
202 char string2[256];
203 int value;
204
205 mtd_info *mtd;
206 FILE *f_in;
207 int f_exitcode = 0;
208
209 // read all lines
210 buffer_size = 1000;
211 buffer = NULL;
212 lineno = 0;
213 while (!feof(f_par)) {
214 // read next line into memory
215 do {
216 // allocate memory for input line
217 if (!buffer) {
218 buffer = malloc(buffer_size);
219 }
220 if (!buffer) {
221 exitcode = 1;
222 printf("parse_par_file: can not allocate %i bytes\n", (int) buffer_size);
223 break;
224 }
225
226 line = fgets(buffer, buffer_size, f_par);
227 if (!line) {
228 exitcode = ferror(f_par);
229 if (exitcode) {
230 printf("parse_par_file: %s\n", strerror(exitcode));
231 }
232 break;
233 }
234
235 // if buffer was not completely filled, then assume that line is complete
236 count = strlen(buffer) + 1;
237 if (count-- < buffer_size) {
238 break;
239 }
240
241 // otherwise....
242
243 // reset file position to line start
244 value = fseek(f_par, -count, SEEK_CUR);
245 if (value == -1) {
246 exitcode = errno;
247 printf("parse_par_file: %s\n", strerror(exitcode));
248 break;
249 }
250
251 // double buffer size
252 free(buffer);
253 buffer = NULL;
254 buffer_size *= 2;
255 lprintf(DEBUG_LVL2, " extending buffer to %i bytes\n", buffer_size);
256 } while (1);
257 if ((!line) || (exitcode)) {
258 break;
259 }
260
261 lineno++; // increase line number
262
263 lprintf(DEBUG_LVL2, " line %i (%i) %s", lineno, count, line);
264
265 value = 0;
266 mtd = NULL;
267
268 // split line if starting with a colon
269 switch (line[0]) {
270 case ':':
271 count = sscanf(line, ":%255s %i %255s", string1, &value, string2);
272 if (count != 3) {
273 printf("line %i does not meet defined format (:<mtdname> <mtdsize> <file>)\n", lineno);
274 } else {
275 // populate mtd_info if supported mtd names
276 if (!strcmp(string1, mtd_kernel.name)) {
277 mtd = &mtd_kernel;
278 } else if (!strcmp(string1, mtd_rootfs.name)) {
279 mtd = &mtd_rootfs;
280 } else if (!strcmp(string1, mtd_uboot.name)) {
281 mtd = &mtd_uboot;
282 }
283
284 if (!mtd) {
285 printf("unknown mtd %s in line %i\n", string1, lineno);
286 } else if (mtd->filename) {
287 f_exitcode = 1;
288 printf("mtd %s in line %i multiple definitions\n", string1, lineno);
289 } else {
290 mtd->size = value;
291 mtd->filename = strdup(string2);
292
293 // Get file size
294 f_in = fopen(mtd->filename, "rb");
295 if (!f_in) {
296 f_exitcode = errno;
297 printf("input file %s: %s\n", mtd->filename, strerror(f_exitcode));
298 } else {
299 value = fread(&mtd->magic, 1, 2, f_in);
300 if (value < 2) {
301 if (ferror(f_in)) {
302 f_exitcode = ferror(f_in);
303 printf("input file %s: %s\n", mtd->filename, strerror(f_exitcode));
304 } else {
305 f_exitcode = 1;
306 printf("input file %s: smaller than two bytes, no magic code\n", mtd->filename);
307 }
308 }
309
310 value = fseek(f_in, 0, SEEK_END);
311 if (value == -1) {
312 f_exitcode = errno;
313 printf("input file %s: %s\n", mtd->filename, strerror(f_exitcode));
314 } else {
315 mtd->filesize = ftell(f_in);
316 if (mtd->filesize == -1) {
317 f_exitcode = errno;
318 printf("input file %s: %s\n", mtd->filename, strerror(f_exitcode));
319 }
320 }
321
322 fclose(f_in);
323 }
324
325 lprintf(DEBUG, "mtd %s in line %i: size=0x%08X, filesize=0x%08lX, magic=0x%02X%02X, file=%s\n", mtd->name, lineno, mtd->size, mtd->filesize, mtd->magic[0], mtd->magic[1], mtd->filename);
326 }
327 }
328 break;
329 case '#': // integer values
330 count = sscanf(line, "#%255s %i", string1, &value);
331 if (count != 2) {
332 printf("line %i does not meet defined format (#<variable name> <integer>\n", lineno);
333 } else {
334 if (!strcmp(string1, "version")) {
335 // changing version
336 fw_version[0] = 0x000000FF & ( value >> 8 );
337 fw_version[1] = 0x000000FF & value;
338 } else {
339 printf("unknown integer variable %s in line %i\n", string1, lineno);
340 }
341
342 lprintf(DEBUG, "integer variable %s in line %i: 0x%08X\n", string1, lineno, value);
343 }
344 break;
345 case '$': // strings
346 count = sscanf(line, "$%255s %255s", string1, string2);
347 if (count != 2) {
348 printf("line %i does not meet defined format (:<mtdname> <mtdsize> <file>)\n", lineno);
349 } else {
350 /*
351 if (!strcmp(string1, "something")) {
352 something = strdup(string2);
353 } else {
354 */
355 printf("unknown string variable %s in line %i\n", string1, lineno);
356 // }
357 lprintf(DEBUG, "string variable %s in line %i: %s\n", string1, lineno, string2);
358 }
359 break;
360 default:
361 break;
362 }
363 }
364 free(buffer);
365
366 if (!exitcode) {
367 exitcode = f_exitcode;
368 }
369
370 return exitcode;
371 }
372
373
374 int create_bin_file(char *bin_filename) {
375 int exitcode = 0;
376
377 unsigned char *buffer;
378
379 int i;
380 mtd_info *mtd;
381 int addsize;
382 int padsize;
383
384 char *rand_filename = "/dev/urandom";
385 FILE *f_in;
386 int size;
387
388 unsigned long int csum;
389 unsigned char checksum;
390
391 FILE *f_out;
392
393 // allocate memory for bin file
394 buffer = malloc(KERNEL_CODE_OFFSET + FLASH_SIZE);
395 if (!buffer) {
396 exitcode = 1;
397 printf("create_bin_file: can not allocate %i bytes\n", FLASH_SIZE);
398 } else {
399 // initialize with zero
400 memset(buffer, 0, KERNEL_CODE_OFFSET + FLASH_SIZE);
401 }
402
403 // add files
404 if (!exitcode) {
405 for (i = 1; i <= 3; i++) {
406 addsize = 0;
407 padsize = 0;
408
409 switch (i) {
410 case 1:
411 mtd = &mtd_kernel;
412 break;
413 case 2:
414 mtd = &mtd_rootfs;
415 addsize = mtd->filesize;
416 padsize = ROOTFS_MIN_OFFSET - mtd_kernel.size - mtd->filesize;
417 break;
418 case 3:
419 mtd = &mtd_uboot;
420 addsize = mtd->filesize;
421 break;
422 default:
423 mtd = NULL;
424 exitcode = 1;
425 printf("create_bin_file: unknown mtd %i\n", i);
426 break;
427 }
428 if (!mtd) {
429 break;
430 }
431 if (!mtd->filename) {
432 continue;
433 }
434
435 lprintf(DEBUG, "adding mtd %s file %s\n", mtd->name, mtd->filename);
436
437 // adding file size
438 if (addsize) {
439 buffer[KERNEL_CODE_OFFSET + mtd->offset - 16] = 0x000000FFL & ( addsize >> 24 );
440 buffer[KERNEL_CODE_OFFSET + mtd->offset - 15] = 0x000000FFL & ( addsize >> 16 );
441 buffer[KERNEL_CODE_OFFSET + mtd->offset - 14] = 0x000000FFL & ( addsize >> 8 );
442 buffer[KERNEL_CODE_OFFSET + mtd->offset - 13] = 0x000000FFL & addsize;
443 }
444
445 // adding file content
446 f_in = fopen(mtd->filename, "rb");
447 if (!f_in) {
448 exitcode = errno;
449 printf("input file %s: %s\n", mtd->filename, strerror(exitcode));
450 } else {
451 size = fread(&buffer[KERNEL_CODE_OFFSET + mtd->offset], mtd->filesize, 1, f_in);
452 if (size < 1) {
453 if (ferror(f_in)) {
454 exitcode = ferror(f_in);
455 printf("input file %s: %s\n", mtd->filename, strerror(exitcode));
456 } else {
457 exitcode = 1;
458 printf("input file %s: smaller than before *doh*\n", mtd->filename);
459 }
460 }
461 fclose(f_in);
462 }
463
464 // padding
465 if (padsize > 0) {
466 addsize = padsize & 0x0000FFFF; // start on next 64KB border
467 padsize -= addsize;
468 }
469 if (padsize > 0) {
470 printf("mtd %s input file %s is too small (0x%08lX), adding 0x%08X random bytes\n", mtd->name, mtd->filename, mtd->filesize, padsize);
471
472 addsize += KERNEL_CODE_OFFSET + mtd->offset + mtd->filesize; // get offset
473 lprintf(DEBUG, " padding offset 0x%08X length 0x%08X\n", addsize, padsize);
474
475 f_in = fopen(rand_filename, "rb");
476 if (!f_in) {
477 exitcode = errno;
478 printf("input file %s: %s\n", rand_filename, strerror(exitcode));
479 } else {
480 size = fread(&buffer[addsize], padsize, 1, f_in);
481 if (size < 1) {
482 if (ferror(f_in)) {
483 exitcode = ferror(f_in);
484 printf("input file %s: %s\n", rand_filename, strerror(exitcode));
485 } else {
486 exitcode = 1;
487 printf("input file %s: smaller than before *doh*\n", rand_filename);
488 }
489 }
490 }
491 fclose(f_in);
492 }
493 }
494 }
495
496 // add special contents
497 if (!exitcode) {
498 lprintf(DEBUG, "adding rootfs special data\n");
499 memcpy(&buffer[KERNEL_CODE_OFFSET + PRODUCT_ID_OFFSET], product_id, 2);
500 memcpy(&buffer[KERNEL_CODE_OFFSET + PROTOCOL_ID_OFFSET], protocol_id, 2);
501 memcpy(&buffer[KERNEL_CODE_OFFSET + FW_VERSION_OFFSET], fw_version, 2);
502 memcpy(&buffer[KERNEL_CODE_OFFSET + FW_VERSION_OFFSET + 2], rootfs_unknown, 2);
503 memcpy(&buffer[KERNEL_CODE_OFFSET + SIGN_OFFSET], sign, 8); // eRcOmM
504
505 lprintf(DEBUG, "adding u-boot special data\n");
506 // memcpy(&buffer[KERNEL_CODE_OFFSET + SN_OFF], sn, 12); // ToDo: currently zero, find out what's this for?
507 // memcpy(&buffer[KERNEL_CODE_OFFSET + PIN_OFF], pin, 8); // ToDo: currently zero, find out what's this for?
508 // memcpy(&buffer[KERNEL_CODE_OFFSET + NODE_BASE_OFF], node, 25); // ToDo: currently zero, find out what's this for?
509 memcpy(&buffer[KERNEL_CODE_OFFSET + BOOT_ADDR_BASE_OFF + PID_OFFSET], pid, 70); // sErCoMm
510 memcpy(&buffer[KERNEL_CODE_OFFSET + BOOT_ADDR_BASE_OFF + PID_OFFSET + 57], fw_version, 2);
511
512 lprintf(DEBUG, "adding checksum byte\n");
513 csum = 0;
514 for (i = 0; i < KERNEL_CODE_OFFSET + FLASH_SIZE; i++) {
515 csum += buffer[i];
516 }
517 lprintf(DEBUG_LVL2, " checksum 0x%016lX (%li)\n", csum, csum);
518
519 buffer[KERNEL_CODE_OFFSET + NODE_BASE_OFF + 25] = ~csum + 1;
520 lprintf(DEBUG, " byte 0x%02X\n", buffer[KERNEL_CODE_OFFSET + NODE_BASE_OFF + 25]);
521 }
522
523 // write bin file
524 if (!exitcode) {
525 lprintf(DEBUG, "writing file %s\n", bin_filename);
526 f_out = fopen(bin_filename, "wb");
527 if (!f_out) {
528 exitcode = errno;
529 printf("output file %s: %s\n", bin_filename, strerror(exitcode));
530 } else {
531 size = fwrite(buffer, KERNEL_CODE_OFFSET + FLASH_SIZE, 1, f_out);
532 if (size < 1) {
533 if (ferror(f_out)) {
534 exitcode = ferror(f_out);
535 printf("output file %s: %s\n", bin_filename, strerror(exitcode));
536 } else {
537 exitcode = 1;
538 printf("output file %s: unspecified write error\n", bin_filename);
539 }
540 }
541 fclose(f_out);
542 }
543 }
544
545 return exitcode;
546 }
547
548
549 int create_zip_file(char *zip_filename, char *bin_filename) {
550 int exitcode = 0;
551
552 char *buffer;
553 size_t buffer_size;
554 int count;
555
556 buffer_size = 1000;
557 buffer = NULL;
558 do {
559 // allocate memory for command line
560 if (!buffer) {
561 buffer = malloc(buffer_size);
562 }
563 if (!buffer) {
564 exitcode = 1;
565 printf("create_zip_file: can not allocate %i bytes\n", (int) buffer_size);
566 break;
567 }
568
569 // if buffer was not completely filled, then line fit in completely
570 count = snprintf(buffer, buffer_size, "zip \"%s\" \"%s\"", zip_filename, bin_filename);
571 if ((count > -1) && (count < buffer_size)) {
572 break;
573 }
574
575 // otherwise try again with more space
576 if (count > -1) { // glibc 2.1
577 buffer_size = count + 1; // precisely what is needed
578 } else { // glibc 2.0
579 buffer_size *= 2; // twice the old size
580 }
581 free(buffer);
582 buffer = NULL;
583 lprintf(DEBUG_LVL2, " extending buffer to %i bytes\n", buffer_size);
584 } while (1);
585
586 if (!exitcode) {
587 // zipping binfile
588 lprintf(DEBUG, "%s\n", buffer);
589 count = system(buffer);
590 if ((count < 0) || (WEXITSTATUS(count))) {
591 exitcode = 1;
592 printf("create_zip_file: can not execute %s bytes\n", buffer);
593 }
594 }
595
596 return exitcode;
597 }
598
599
600 int create_img_file(FILE *f_out, char *out_filename, char *zip_filename) {
601 int exitcode = 0;
602
603 md5_state_t state;
604 md5_byte_t digest[16];
605
606 int i;
607 int size;
608
609 FILE *f_in;
610 unsigned char buffer[1];
611
612 // copy firmware version
613 memcpy(&img_hdr[50], fw_version, 2);
614
615 // clear md5 checksum
616 memset(&img_hdr[480], 0, 16);
617
618 // prepare md5 checksum calculation
619 md5_init(&state);
620
621 // add img header
622 lprintf(DEBUG_LVL2, " adding img header\n");
623 for (i = 0; i < 512; i++) {
624 size = fputc(img_hdr[i], f_out);
625 if (size == EOF) {
626 exitcode = ferror(f_out);
627 printf("output file %s: %s\n", out_filename, strerror(exitcode));
628 break;
629 }
630 md5_append(&state, (const md5_byte_t *)&img_hdr[i], 1);
631 }
632
633 // adding zip file
634 if (!exitcode) {
635 lprintf(DEBUG_LVL2, " adding zip file\n");
636 f_in = fopen(zip_filename, "rb");
637 if (!f_in) {
638 exitcode = errno;
639 printf("input file %s: %s\n", zip_filename, strerror(exitcode));
640 } else {
641 while ((size = fgetc(f_in)) != EOF) {
642 buffer[0] = size;
643
644 size = fputc(buffer[0], f_out);
645 if (size == EOF) {
646 exitcode = ferror(f_out);
647 printf("output file %s: %s\n", out_filename, strerror(exitcode));
648 break;
649 }
650 md5_append(&state, (const md5_byte_t *)buffer, 1);
651 }
652 if (ferror(f_in)) {
653 exitcode = ferror(f_in);
654 printf("input file %s: %s\n", zip_filename, strerror(exitcode));
655 }
656 }
657
658 }
659
660 // add end byte
661 if (!exitcode) {
662 lprintf(DEBUG_LVL2, " adding img eof byte\n");
663 size = fputc(img_eof[0], f_out);
664 if (size == EOF) {
665 exitcode = ferror(f_out);
666 printf("output file %s: %s\n", out_filename, strerror(exitcode));
667 }
668 md5_append(&state, (const md5_byte_t *)img_eof, 1);
669 }
670
671 // append salt to md5 checksum
672 md5_append(&state, (const md5_byte_t *)"A^gU*<>?RFY@#DR&Z", 17);
673
674 // finish md5 checksum calculation
675 md5_finish(&state, digest);
676
677 // write md5 checksum into img header
678 if (!exitcode) {
679 lprintf(DEBUG_LVL2, " writing md5 checksum into img header of file\n");
680
681 size = fseek(f_out, 480, SEEK_SET);
682 if (size == -1) {
683 exitcode = errno;
684 printf("output file %s: %s\n", out_filename, strerror(exitcode));
685 } else {
686 size = fwrite(digest, 16, 1, f_out);
687 if (size < 1) {
688 if (ferror(f_out)) {
689 exitcode = ferror(f_out);
690 printf("output file %s: %s\n", out_filename, strerror(exitcode));
691 } else {
692 exitcode = 1;
693 printf("output file %s: unspecified write error\n", out_filename);
694 }
695 }
696 }
697
698 fclose(f_in);
699 }
700
701 return exitcode;
702 }
703
704
705 int main(int argc, char *argv[]) {
706 int exitcode = 0;
707
708 int help;
709 int onlybin;
710 int havezip;
711 char option;
712 char *par_filename = NULL;
713 char *img_filename = NULL;
714 char *base_filename = NULL;
715 char *bin_filename = NULL;
716 char *zip_filename = NULL;
717
718 FILE *f_par = NULL;
719 FILE *f_img = NULL;
720
721 int i;
722 mtd_info *mtd;
723 int mandatory;
724 int noupdate;
725 int sizecheck;
726 unsigned char magic[2];
727
728
729 // display program header
730 printf(program_info, VERSION);
731
732
733 // command line processing
734 // options
735 help = 0;
736 onlybin = 0;
737 havezip = 0;
738 while ((option = getopt(argc, argv, ":hbzf:v")) != -1) {
739 switch(option) {
740 case 'h':
741 help = 1;
742 break;
743 case 'b':
744 onlybin = 1;
745 break;
746 case 'z':
747 havezip = 1;
748 break;
749 case 'f':
750 sizecheck = sscanf(optarg, "%i", &i);
751 if (sizecheck != 1) {
752 printf("Firmware version of -f option not a valid integer\n");
753 exitcode = 1;
754 } else {
755 fw_version[0] = 0x000000FF & ( i >> 8 );
756 fw_version[1] = 0x000000FF & i;
757 }
758 break;
759 case 'v':
760 verbosity++;
761 break;
762 case ':': // option with missing operand
763 printf("Option -%c requires an operand\n", optopt);
764 exitcode = 1;
765 break;
766 case '?':
767 printf("Unrecognized option: -%c\n", optopt);
768 exitcode = 1;
769 break;
770 }
771 }
772
773 // files
774 for ( ; optind < argc; optind++) {
775 if (!par_filename) {
776 par_filename = argv[optind];
777
778 if (access(par_filename, R_OK)) {
779 if (havezip) {
780 printf("No read access to zip file %s\n", par_filename);
781 } else {
782 printf("No read access to parameter or zip file %s\n", par_filename);
783 }
784 exitcode = 1;
785 }
786
787 continue;
788 }
789
790 if ((!onlybin) && (!img_filename)) {
791 img_filename = argv[optind];
792
793 if (!access(img_filename, F_OK)) { // if file already exists then check write access
794 if (access(img_filename, W_OK)) {
795 printf("No write access to image file %s\n", img_filename);
796 exitcode = 1;
797 }
798 }
799
800 continue;
801 }
802
803 printf("Too many files stated\n");
804 exitcode = 1;
805 break;
806 }
807
808 // file name checks
809 if (!par_filename) {
810 if (havezip) {
811 printf("Zip file not stated\n");
812 } else {
813 printf("Parameter file not stated\n");
814 }
815 exitcode = 1;
816 } else {
817 base_filename = basename(par_filename);
818 if (!base_filename) {
819 if (havezip) {
820 printf("Zip file is a directory\n");
821 } else {
822 printf("Parameter file is a directory\n");
823 }
824 exitcode = 1;
825 }
826 }
827
828 if (!onlybin) {
829 if (!img_filename) {
830 printf("Image file not stated\n");
831 exitcode = 1;
832 } else {
833 base_filename = basename(img_filename);
834 if (!base_filename) {
835 printf("Image file is a directory\n");
836 exitcode = 1;
837 }
838 }
839 }
840
841 // check for mutually exclusive options
842 if ((onlybin) && (havezip)) {
843 printf("Option -b and -z are mutually exclusive\n");
844 exitcode = 1;
845 }
846
847 // react on option problems or help request, then exit
848 if ((exitcode) || (help)) {
849 if (help) {
850 printf("This program creates Linksys style images for the WRT350Nv2 router.\n");
851 }
852 printf(" Usage:\n\
853 %s [-h] [-b] [-z] [-f <version>] [-v] <parameter or zip file> [<image file>]\n\n\
854 Options:\n\
855 -h - Show this help\n\
856 -b - Create only bin file, no img or zip file is created\n\
857 -z - Have zip file, the img file will be directly created from it\n\
858 -f <version> - Wanted firmware version to use with -z\n\
859 Default firmware version is 0x2020 = 2.00.20.\n\
860 Note: version from parameter file will supersede this\n\
861 -v - Increase debug verbosity level\n\n\
862 Example:\n\
863 %s wrt350nv2.par wrt350nv2.img\n\n", argv[0], argv[0]);
864 return exitcode;
865 }
866
867 // handle special case when zipfile is stated
868 if (havezip) {
869 zip_filename = par_filename;
870 par_filename = NULL;
871 }
872
873 lprintf(DEBUG_LVL2, " Verbosity: %i\n", verbosity);
874 lprintf(DEBUG_LVL2, " Program: %s\n", argv[0]);
875
876 if (par_filename) {
877 lprintf(DEBUG, "Parameter file: %s\n", par_filename);
878 }
879 if (zip_filename) {
880 lprintf(DEBUG, "Zip file: %s\n", zip_filename);
881 }
882 if (img_filename) {
883 lprintf(DEBUG, "Image file: %s\n", img_filename);
884 }
885
886
887 // open files from command line
888 // parameter/zip file
889 if (par_filename) {
890 f_par = fopen(par_filename, "rt");
891 if (!f_par) {
892 exitcode = errno;
893 printf("Input file %s: %s\n", par_filename, strerror(exitcode));
894 }
895 }
896
897 // image file
898 if (img_filename) {
899 f_img = fopen(img_filename, "wb");
900 if (!f_img) {
901 exitcode = errno;
902 printf("Output file %s: %s\n", img_filename, strerror(exitcode));
903 }
904 }
905
906 if (exitcode) {
907 return exitcode;
908 }
909
910
911 // parameter file processing
912 if ((!exitcode) && (f_par)) {
913 lprintf(DEBUG, "parsing parameter file...\n");
914
915 exitcode = parse_par_file(f_par);
916
917 lprintf(DEBUG, "...done parsing file\n");
918 }
919 if (f_par) {
920 fclose(f_par);
921 }
922
923
924 // check all input data
925 if ((!exitcode) && (par_filename)) {
926 lprintf(DEBUG, "checking mtd data...\n");
927
928 for (i = 1; i <= 3; i++) {
929 mandatory = 0;
930 noupdate = 0;
931 sizecheck = 0;
932 magic[0] = 0;
933 magic[1] = 0;
934
935 switch (i) {
936 case 1:
937 mtd = &mtd_kernel;
938 mandatory = 1;
939 sizecheck = mtd_kernel.size - 16;
940 magic[0] = 0x27;
941 magic[1] = 0x05;
942 break;
943 case 2:
944 mtd = &mtd_rootfs;
945 mtd->offset = mtd_kernel.size;
946 mtd->size = ROOTFS_END_OFFSET - mtd_kernel.size;
947 mandatory = 1;
948 sizecheck = PRODUCT_ID_OFFSET - mtd_kernel.size;
949 magic[0] = 0x68;
950 magic[1] = 0x73;
951 break;
952 case 3:
953 mtd = &mtd_uboot;
954 mtd->offset = BOOT_ADDR_BASE_OFF;
955 noupdate = 1;
956 sizecheck = SN_OFF - BOOT_ADDR_BASE_OFF;
957 break;
958 default:
959 mtd = NULL;
960 exitcode = 1;
961 printf("unknown mtd check %i\n", i);
962 break;
963 }
964 if (!mtd) {
965 break;
966 }
967
968 lprintf(DEBUG_LVL2, " checking mtd %s\n", mtd->name);
969
970 // general checks
971 if ((mandatory) && (!mtd->filename)) {
972 exitcode = 1;
973 printf("mtd %s not specified correctly or at all in parameter file\n", mtd->name);
974 }
975
976 // end checks if no file data present
977 if (!mtd->filename) {
978 continue;
979 }
980
981 // not updated by stock firmware
982 if (noupdate) {
983 printf("mtd %s is specified, but will not be updated as of Linksys firmware 2.0.19\n", mtd->name);
984 }
985
986 // general magic number check
987 if (magic[0]) {
988 if ((mtd->magic[0] != magic[0]) || (mtd->magic[1] != magic[1])) {
989 exitcode = 1;
990 printf("mtd %s input file %s has wrong magic number (0x%02X%02X)\n", mtd->name, mtd->filename, mtd->magic[0], mtd->magic[1]);
991 }
992 }
993
994 // mtd specific size check
995 if (mtd == &mtd_kernel) {
996 if (mtd->filesize < 0x00050000) {
997 exitcode = 1;
998 printf("mtd %s input file %s too unrealistic small (0x%08lX)\n", mtd->name, mtd->filename, mtd->filesize);
999 }
1000 }
1001
1002 // general size check
1003 if (sizecheck) {
1004 if (sizecheck <= 0) {
1005 exitcode = 1;
1006 printf("mtd %s bad file size check (%i) due to input data\n", mtd->name, sizecheck);
1007 } else {
1008 if (mtd->filesize > sizecheck) {
1009 exitcode = 1;
1010 printf("mtd %s input file %s too big (0x%08lX)\n", mtd->name, mtd->filename, mtd->filesize);
1011 }
1012 }
1013 }
1014 }
1015 lprintf(DEBUG, "...done checking mtd data\n");
1016 }
1017
1018
1019 // bin creation in memory
1020 if ((!exitcode) && (par_filename)) {
1021 bin_filename = "wrt350n.bin";
1022
1023 lprintf(DEBUG, "creating bin file %s...\n", bin_filename);
1024
1025 exitcode = create_bin_file(bin_filename);
1026
1027 lprintf(DEBUG, "...done creating bin file\n");
1028 }
1029
1030 // zip file creation
1031 if ((!exitcode) && (!onlybin) && (!zip_filename)) {
1032 zip_filename = "wrt350n.zip";
1033
1034 lprintf(DEBUG, "creating zip file %s...\n", zip_filename);
1035
1036 exitcode = create_zip_file(zip_filename, bin_filename);
1037
1038 lprintf(DEBUG, "...done creating zip file\n");
1039 }
1040
1041
1042 // img file creation
1043 if ((!exitcode) && (f_img)) {
1044 lprintf(DEBUG, "creating img file...\n");
1045
1046 exitcode = create_img_file(f_img, img_filename, zip_filename);
1047
1048 lprintf(DEBUG, "...done creating img file\n");
1049 }
1050
1051 // clean up
1052 if (f_img) {
1053 fclose(f_img);
1054 }
1055
1056 // end program
1057 return exitcode;
1058 }
Personal OpenWRT clone
This page took 0.137793 seconds and 5 git commands to generate.