2 Copyright (c) 2014, Matthias Schiffer <mschiffer@universe-factory.net>
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
8 1. Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright notice,
11 this list of conditions and the following disclaimer in the documentation
12 and/or other materials provided with the distribution.
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 Image generation tool for the TP-LINK SafeLoader as seen on
31 TP-LINK Pharos devices (CPE210/220/510/520)
45 #include <arpa/inet.h>
47 #include <sys/types.h>
53 #define ALIGN(x,a) ({ typeof(a) __a = (a); (((x) + __a - 1) & ~(__a - 1)); })
56 #define MAX_PARTITIONS 32
58 /** An image partition table entry */
59 struct image_partition_entry
{
65 /** A flash partition table entry */
66 struct flash_partition_entry
{
72 /** Firmware layout description */
76 const char *support_list
;
78 const struct flash_partition_entry partitions
[MAX_PARTITIONS
+1];
79 const char *first_sysupgrade_partition
;
80 const char *last_sysupgrade_partition
;
83 /** The content of the soft-version structure */
84 struct __attribute__((__packed__
)) soft_version
{
88 uint8_t version_major
;
89 uint8_t version_minor
;
90 uint8_t version_patch
;
100 static const uint8_t jffs2_eof_mark
[4] = {0xde, 0xad, 0xc0, 0xde};
104 Salt for the MD5 hash
106 Fortunately, TP-LINK seems to use the same salt for most devices which use
107 the new image format.
109 static const uint8_t md5_salt
[16] = {
110 0x7a, 0x2b, 0x15, 0xed,
111 0x9b, 0x98, 0x59, 0x6d,
112 0xe5, 0x04, 0xab, 0x44,
113 0xac, 0x2a, 0x9f, 0x4e,
117 /** Firmware layout table */
118 static struct device_info boards
[] = {
119 /** Firmware layout for the CPE210/220 */
122 .vendor
= "CPE510(TP-LINK|UN|N300-5):1.0\r\n",
125 "CPE210(TP-LINK|UN|N300-2):1.0\r\n"
126 "CPE210(TP-LINK|UN|N300-2):1.1\r\n"
127 "CPE210(TP-LINK|US|N300-2):1.1\r\n"
128 "CPE210(TP-LINK|EU|N300-2):1.1\r\n"
129 "CPE220(TP-LINK|UN|N300-2):1.1\r\n"
130 "CPE220(TP-LINK|US|N300-2):1.1\r\n"
131 "CPE220(TP-LINK|EU|N300-2):1.1\r\n",
132 .support_trail
= '\xff',
135 {"fs-uboot", 0x00000, 0x20000},
136 {"partition-table", 0x20000, 0x02000},
137 {"default-mac", 0x30000, 0x00020},
138 {"product-info", 0x31100, 0x00100},
139 {"signature", 0x32000, 0x00400},
140 {"os-image", 0x40000, 0x170000},
141 {"soft-version", 0x1b0000, 0x00100},
142 {"support-list", 0x1b1000, 0x00400},
143 {"file-system", 0x1c0000, 0x600000},
144 {"user-config", 0x7c0000, 0x10000},
145 {"default-config", 0x7d0000, 0x10000},
146 {"log", 0x7e0000, 0x10000},
147 {"radio", 0x7f0000, 0x10000},
151 .first_sysupgrade_partition
= "os-image",
152 .last_sysupgrade_partition
= "file-system",
155 /** Firmware layout for the CPE510/520 */
158 .vendor
= "CPE510(TP-LINK|UN|N300-5):1.0\r\n",
161 "CPE510(TP-LINK|UN|N300-5):1.0\r\n"
162 "CPE510(TP-LINK|UN|N300-5):1.1\r\n"
163 "CPE510(TP-LINK|UN|N300-5):1.1\r\n"
164 "CPE510(TP-LINK|US|N300-5):1.1\r\n"
165 "CPE510(TP-LINK|EU|N300-5):1.1\r\n"
166 "CPE520(TP-LINK|UN|N300-5):1.1\r\n"
167 "CPE520(TP-LINK|US|N300-5):1.1\r\n"
168 "CPE520(TP-LINK|EU|N300-5):1.1\r\n",
169 .support_trail
= '\xff',
172 {"fs-uboot", 0x00000, 0x20000},
173 {"partition-table", 0x20000, 0x02000},
174 {"default-mac", 0x30000, 0x00020},
175 {"product-info", 0x31100, 0x00100},
176 {"signature", 0x32000, 0x00400},
177 {"os-image", 0x40000, 0x170000},
178 {"soft-version", 0x1b0000, 0x00100},
179 {"support-list", 0x1b1000, 0x00400},
180 {"file-system", 0x1c0000, 0x600000},
181 {"user-config", 0x7c0000, 0x10000},
182 {"default-config", 0x7d0000, 0x10000},
183 {"log", 0x7e0000, 0x10000},
184 {"radio", 0x7f0000, 0x10000},
188 .first_sysupgrade_partition
= "os-image",
189 .last_sysupgrade_partition
= "file-system",
194 .vendor
= "CPE510(TP-LINK|UN|N300-5):1.0\r\n",
197 "WBS210(TP-LINK|UN|N300-2):1.20\r\n"
198 "WBS210(TP-LINK|US|N300-2):1.20\r\n"
199 "WBS210(TP-LINK|EU|N300-2):1.20\r\n",
200 .support_trail
= '\xff',
203 {"fs-uboot", 0x00000, 0x20000},
204 {"partition-table", 0x20000, 0x02000},
205 {"default-mac", 0x30000, 0x00020},
206 {"product-info", 0x31100, 0x00100},
207 {"signature", 0x32000, 0x00400},
208 {"os-image", 0x40000, 0x170000},
209 {"soft-version", 0x1b0000, 0x00100},
210 {"support-list", 0x1b1000, 0x00400},
211 {"file-system", 0x1c0000, 0x600000},
212 {"user-config", 0x7c0000, 0x10000},
213 {"default-config", 0x7d0000, 0x10000},
214 {"log", 0x7e0000, 0x10000},
215 {"radio", 0x7f0000, 0x10000},
219 .first_sysupgrade_partition
= "os-image",
220 .last_sysupgrade_partition
= "file-system",
225 .vendor
= "CPE510(TP-LINK|UN|N300-5):1.0\r\n",
228 "WBS510(TP-LINK|UN|N300-5):1.20\r\n"
229 "WBS510(TP-LINK|US|N300-5):1.20\r\n"
230 "WBS510(TP-LINK|EU|N300-5):1.20\r\n",
231 .support_trail
= '\xff',
234 {"fs-uboot", 0x00000, 0x20000},
235 {"partition-table", 0x20000, 0x02000},
236 {"default-mac", 0x30000, 0x00020},
237 {"product-info", 0x31100, 0x00100},
238 {"signature", 0x32000, 0x00400},
239 {"os-image", 0x40000, 0x170000},
240 {"soft-version", 0x1b0000, 0x00100},
241 {"support-list", 0x1b1000, 0x00400},
242 {"file-system", 0x1c0000, 0x600000},
243 {"user-config", 0x7c0000, 0x10000},
244 {"default-config", 0x7d0000, 0x10000},
245 {"log", 0x7e0000, 0x10000},
246 {"radio", 0x7f0000, 0x10000},
250 .first_sysupgrade_partition
= "os-image",
251 .last_sysupgrade_partition
= "file-system",
254 /** Firmware layout for the C2600 */
260 "{product_name:Archer C2600,product_ver:1.0.0,special_id:00000000}\r\n",
261 .support_trail
= '\x00',
264 {"SBL1", 0x00000, 0x20000},
265 {"MIBIB", 0x20000, 0x20000},
266 {"SBL2", 0x40000, 0x20000},
267 {"SBL3", 0x60000, 0x30000},
268 {"DDRCONFIG", 0x90000, 0x10000},
269 {"SSD", 0xa0000, 0x10000},
270 {"TZ", 0xb0000, 0x30000},
271 {"RPM", 0xe0000, 0x20000},
272 {"fs-uboot", 0x100000, 0x70000},
273 {"uboot-env", 0x170000, 0x40000},
274 {"radio", 0x1b0000, 0x40000},
275 {"os-image", 0x1f0000, 0x200000},
276 {"file-system", 0x3f0000, 0x1b00000},
277 {"default-mac", 0x1ef0000, 0x00200},
278 {"pin", 0x1ef0200, 0x00200},
279 {"product-info", 0x1ef0400, 0x0fc00},
280 {"partition-table", 0x1f00000, 0x10000},
281 {"soft-version", 0x1f10000, 0x10000},
282 {"support-list", 0x1f20000, 0x10000},
283 {"profile", 0x1f30000, 0x10000},
284 {"default-config", 0x1f40000, 0x10000},
285 {"user-config", 0x1f50000, 0x40000},
286 {"qos-db", 0x1f90000, 0x40000},
287 {"usb-config", 0x1fd0000, 0x10000},
288 {"log", 0x1fe0000, 0x20000},
292 .first_sysupgrade_partition
= "os-image",
293 .last_sysupgrade_partition
= "file-system"
296 /** Firmware layout for the C9 */
302 "{product_name:ArcherC9,"
304 "special_id:00000000}\n",
305 .support_trail
= '\x00',
308 {"fs-uboot", 0x00000, 0x40000},
309 {"os-image", 0x40000, 0x200000},
310 {"file-system", 0x240000, 0xc00000},
311 {"default-mac", 0xe40000, 0x00200},
312 {"pin", 0xe40200, 0x00200},
313 {"product-info", 0xe40400, 0x00200},
314 {"partition-table", 0xe50000, 0x10000},
315 {"soft-version", 0xe60000, 0x00200},
316 {"support-list", 0xe61000, 0x0f000},
317 {"profile", 0xe70000, 0x10000},
318 {"default-config", 0xe80000, 0x10000},
319 {"user-config", 0xe90000, 0x50000},
320 {"log", 0xee0000, 0x100000},
321 {"radio_bk", 0xfe0000, 0x10000},
322 {"radio", 0xff0000, 0x10000},
326 .first_sysupgrade_partition
= "os-image",
327 .last_sysupgrade_partition
= "file-system"
330 /** Firmware layout for the EAP120 */
333 .vendor
= "EAP120(TP-LINK|UN|N300-2):1.0\r\n",
336 "EAP120(TP-LINK|UN|N300-2):1.0\r\n",
337 .support_trail
= '\xff',
340 {"fs-uboot", 0x00000, 0x20000},
341 {"partition-table", 0x20000, 0x02000},
342 {"default-mac", 0x30000, 0x00020},
343 {"support-list", 0x31000, 0x00100},
344 {"product-info", 0x31100, 0x00100},
345 {"soft-version", 0x32000, 0x00100},
346 {"os-image", 0x40000, 0x180000},
347 {"file-system", 0x1c0000, 0x600000},
348 {"user-config", 0x7c0000, 0x10000},
349 {"backup-config", 0x7d0000, 0x10000},
350 {"log", 0x7e0000, 0x10000},
351 {"radio", 0x7f0000, 0x10000},
355 .first_sysupgrade_partition
= "os-image",
356 .last_sysupgrade_partition
= "file-system"
359 /** Firmware layout for the TL-WR1043 v4 */
361 .id
= "TLWR1043NDV4",
365 "{product_name:TL-WR1043ND,product_ver:4.0.0,special_id:45550000}\n",
366 .support_trail
= '\x00',
369 We use a bigger os-image partition than the stock images (and thus
370 smaller file-system), as our kernel doesn't fit in the stock firmware's
374 {"fs-uboot", 0x00000, 0x20000},
375 {"os-image", 0x20000, 0x180000},
376 {"file-system", 0x1a0000, 0xdb0000},
377 {"default-mac", 0xf50000, 0x00200},
378 {"pin", 0xf50200, 0x00200},
379 {"product-info", 0xf50400, 0x0fc00},
380 {"soft-version", 0xf60000, 0x0b000},
381 {"support-list", 0xf6b000, 0x04000},
382 {"profile", 0xf70000, 0x04000},
383 {"default-config", 0xf74000, 0x0b000},
384 {"user-config", 0xf80000, 0x40000},
385 {"partition-table", 0xfc0000, 0x10000},
386 {"log", 0xfd0000, 0x20000},
387 {"radio", 0xff0000, 0x10000},
391 .first_sysupgrade_partition
= "os-image",
392 .last_sysupgrade_partition
= "file-system"
395 /** Firmware layout for the RE450 */
401 "{product_name:RE450,product_ver:1.0.0,special_id:00000000}\r\n"
402 "{product_name:RE450,product_ver:1.0.0,special_id:55530000}\r\n"
403 "{product_name:RE450,product_ver:1.0.0,special_id:45550000}\r\n"
404 "{product_name:RE450,product_ver:1.0.0,special_id:4A500000}\r\n"
405 "{product_name:RE450,product_ver:1.0.0,special_id:43410000}\r\n"
406 "{product_name:RE450,product_ver:1.0.0,special_id:41550000}\r\n"
407 "{product_name:RE450,product_ver:1.0.0,special_id:4B520000}\r\n"
408 "{product_name:RE450,product_ver:1.0.0,special_id:55534100}\r\n",
409 .support_trail
= '\x00',
412 The flash partition table for RE450;
413 it is almost the same as the one used by the stock images,
414 576KB were moved from file-system to os-image.
417 {"fs-uboot", 0x00000, 0x20000},
418 {"os-image", 0x20000, 0x150000},
419 {"file-system", 0x170000, 0x4a0000},
420 {"partition-table", 0x600000, 0x02000},
421 {"default-mac", 0x610000, 0x00020},
422 {"pin", 0x610100, 0x00020},
423 {"product-info", 0x611100, 0x01000},
424 {"soft-version", 0x620000, 0x01000},
425 {"support-list", 0x621000, 0x01000},
426 {"profile", 0x622000, 0x08000},
427 {"user-config", 0x630000, 0x10000},
428 {"default-config", 0x640000, 0x10000},
429 {"radio", 0x7f0000, 0x10000},
433 .first_sysupgrade_partition
= "os-image",
434 .last_sysupgrade_partition
= "file-system"
440 #define error(_ret, _errno, _str, ...) \
442 fprintf(stderr, _str ": %s\n", ## __VA_ARGS__, \
449 /** Stores a uint32 as big endian */
450 static inline void put32(uint8_t *buf
, uint32_t val
) {
457 /** Allocates a new image partition */
458 static struct image_partition_entry
alloc_image_partition(const char *name
, size_t len
) {
459 struct image_partition_entry entry
= {name
, len
, malloc(len
)};
461 error(1, errno
, "malloc");
466 /** Frees an image partition */
467 static void free_image_partition(struct image_partition_entry entry
) {
471 /** Generates the partition-table partition */
472 static struct image_partition_entry
make_partition_table(const struct flash_partition_entry
*p
) {
473 struct image_partition_entry entry
= alloc_image_partition("partition-table", 0x800);
475 char *s
= (char *)entry
.data
, *end
= (char *)(s
+entry
.size
);
483 for (i
= 0; p
[i
].name
; i
++) {
485 size_t w
= snprintf(s
, len
, "partition %s base 0x%05x size 0x%05x\n", p
[i
].name
, p
[i
].base
, p
[i
].size
);
488 error(1, 0, "flash partition table overflow?");
495 memset(s
, 0xff, end
-s
);
501 /** Generates a binary-coded decimal representation of an integer in the range [0, 99] */
502 static inline uint8_t bcd(uint8_t v
) {
503 return 0x10 * (v
/10) + v
%10;
507 /** Generates the soft-version partition */
508 static struct image_partition_entry
make_soft_version(uint32_t rev
) {
509 struct image_partition_entry entry
= alloc_image_partition("soft-version", sizeof(struct soft_version
));
510 struct soft_version
*s
= (struct soft_version
*)entry
.data
;
514 if (time(&t
) == (time_t)(-1))
515 error(1, errno
, "time");
517 struct tm
*tm
= localtime(&t
);
519 s
->magic
= htonl(0x0000000c);
523 s
->version_major
= 0;
524 s
->version_minor
= 0;
525 s
->version_patch
= 0;
527 s
->year_hi
= bcd((1900+tm
->tm_year
)/100);
528 s
->year_lo
= bcd(tm
->tm_year
%100);
529 s
->month
= bcd(tm
->tm_mon
+1);
530 s
->day
= bcd(tm
->tm_mday
);
538 /** Generates the support-list partition */
539 static struct image_partition_entry
make_support_list(const struct device_info
*info
) {
540 size_t len
= strlen(info
->support_list
);
541 struct image_partition_entry entry
= alloc_image_partition("support-list", len
+ 9);
543 put32(entry
.data
, len
);
544 memset(entry
.data
+4, 0, 4);
545 memcpy(entry
.data
+8, info
->support_list
, len
);
546 entry
.data
[len
+8] = info
->support_trail
;
551 /** Creates a new image partition with an arbitrary name from a file */
552 static struct image_partition_entry
read_file(const char *part_name
, const char *filename
, bool add_jffs2_eof
) {
555 if (stat(filename
, &statbuf
) < 0)
556 error(1, errno
, "unable to stat file `%s'", filename
);
558 size_t len
= statbuf
.st_size
;
561 len
= ALIGN(len
, 0x10000) + sizeof(jffs2_eof_mark
);
563 struct image_partition_entry entry
= alloc_image_partition(part_name
, len
);
565 FILE *file
= fopen(filename
, "rb");
567 error(1, errno
, "unable to open file `%s'", filename
);
569 if (fread(entry
.data
, statbuf
.st_size
, 1, file
) != 1)
570 error(1, errno
, "unable to read file `%s'", filename
);
573 uint8_t *eof
= entry
.data
+ statbuf
.st_size
, *end
= entry
.data
+entry
.size
;
575 memset(eof
, 0xff, end
- eof
- sizeof(jffs2_eof_mark
));
576 memcpy(end
- sizeof(jffs2_eof_mark
), jffs2_eof_mark
, sizeof(jffs2_eof_mark
));
586 Copies a list of image partitions into an image buffer and generates the image partition table while doing so
588 Example image partition table:
590 fwup-ptn partition-table base 0x00800 size 0x00800
591 fwup-ptn os-image base 0x01000 size 0x113b45
592 fwup-ptn file-system base 0x114b45 size 0x1d0004
593 fwup-ptn support-list base 0x2e4b49 size 0x000d1
595 Each line of the partition table is terminated with the bytes 09 0d 0a ("\t\r\n"),
596 the end of the partition table is marked with a zero byte.
598 The firmware image must contain at least the partition-table and support-list partitions
599 to be accepted. There aren't any alignment constraints for the image partitions.
601 The partition-table partition contains the actual flash layout; partitions
602 from the image partition table are mapped to the corresponding flash partitions during
603 the firmware upgrade. The support-list partition contains a list of devices supported by
606 The base offsets in the firmware partition table are relative to the end
607 of the vendor information block, so the partition-table partition will
608 actually start at offset 0x1814 of the image.
610 I think partition-table must be the first partition in the firmware image.
612 static void put_partitions(uint8_t *buffer
, const struct flash_partition_entry
*flash_parts
, const struct image_partition_entry
*parts
) {
614 char *image_pt
= (char *)buffer
, *end
= image_pt
+ 0x800;
617 for (i
= 0; parts
[i
].name
; i
++) {
618 for (j
= 0; flash_parts
[j
].name
; j
++) {
619 if (!strcmp(flash_parts
[j
].name
, parts
[i
].name
)) {
620 if (parts
[i
].size
> flash_parts
[j
].size
)
621 error(1, 0, "%s partition too big (more than %u bytes)", flash_parts
[j
].name
, (unsigned)flash_parts
[j
].size
);
626 assert(flash_parts
[j
].name
);
628 memcpy(buffer
+ base
, parts
[i
].data
, parts
[i
].size
);
630 size_t len
= end
-image_pt
;
631 size_t w
= snprintf(image_pt
, len
, "fwup-ptn %s base 0x%05x size 0x%05x\t\r\n", parts
[i
].name
, (unsigned)base
, (unsigned)parts
[i
].size
);
634 error(1, 0, "image partition table overflow?");
638 base
+= parts
[i
].size
;
642 /** Generates and writes the image MD5 checksum */
643 static void put_md5(uint8_t *md5
, uint8_t *buffer
, unsigned int len
) {
647 MD5_Update(&ctx
, md5_salt
, (unsigned int)sizeof(md5_salt
));
648 MD5_Update(&ctx
, buffer
, len
);
649 MD5_Final(md5
, &ctx
);
654 Generates the firmware image in factory format
660 0000-0003 Image size (4 bytes, big endian)
661 0004-0013 MD5 hash (hash of a 16 byte salt and the image data starting with byte 0x14)
662 0014-0017 Vendor information length (without padding) (4 bytes, big endian)
663 0018-1013 Vendor information (4092 bytes, padded with 0xff; there seem to be older
664 (VxWorks-based) TP-LINK devices which use a smaller vendor information block)
665 1014-1813 Image partition table (2048 bytes, padded with 0xff)
666 1814-xxxx Firmware partitions
668 static void * generate_factory_image(const struct device_info
*info
, const struct image_partition_entry
*parts
, size_t *len
) {
672 for (i
= 0; parts
[i
].name
; i
++)
673 *len
+= parts
[i
].size
;
675 uint8_t *image
= malloc(*len
);
677 error(1, errno
, "malloc");
679 memset(image
, 0xff, *len
);
683 size_t vendor_len
= strlen(info
->vendor
);
684 put32(image
+0x14, vendor_len
);
685 memcpy(image
+0x18, info
->vendor
, vendor_len
);
688 put_partitions(image
+ 0x1014, info
->partitions
, parts
);
689 put_md5(image
+0x04, image
+0x14, *len
-0x14);
695 Generates the firmware image in sysupgrade format
697 This makes some assumptions about the provided flash and image partition tables and
698 should be generalized when TP-LINK starts building its safeloader into hardware with
699 different flash layouts.
701 static void * generate_sysupgrade_image(const struct device_info
*info
, const struct image_partition_entry
*image_parts
, size_t *len
) {
703 size_t flash_first_partition_index
= 0;
704 size_t flash_last_partition_index
= 0;
705 const struct flash_partition_entry
*flash_first_partition
= NULL
;
706 const struct flash_partition_entry
*flash_last_partition
= NULL
;
707 const struct image_partition_entry
*image_last_partition
= NULL
;
709 /** Find first and last partitions */
710 for (i
= 0; info
->partitions
[i
].name
; i
++) {
711 if (!strcmp(info
->partitions
[i
].name
, info
->first_sysupgrade_partition
)) {
712 flash_first_partition
= &info
->partitions
[i
];
713 flash_first_partition_index
= i
;
714 } else if (!strcmp(info
->partitions
[i
].name
, info
->last_sysupgrade_partition
)) {
715 flash_last_partition
= &info
->partitions
[i
];
716 flash_last_partition_index
= i
;
720 assert(flash_first_partition
&& flash_last_partition
);
721 assert(flash_first_partition_index
< flash_last_partition_index
);
723 /** Find last partition from image to calculate needed size */
724 for (i
= 0; image_parts
[i
].name
; i
++) {
725 if (!strcmp(image_parts
[i
].name
, info
->last_sysupgrade_partition
)) {
726 image_last_partition
= &image_parts
[i
];
731 assert(image_last_partition
);
733 *len
= flash_last_partition
->base
- flash_first_partition
->base
+ image_last_partition
->size
;
735 uint8_t *image
= malloc(*len
);
737 error(1, errno
, "malloc");
739 memset(image
, 0xff, *len
);
741 for (i
= flash_first_partition_index
; i
<= flash_last_partition_index
; i
++) {
742 for (j
= 0; image_parts
[j
].name
; j
++) {
743 if (!strcmp(info
->partitions
[i
].name
, image_parts
[j
].name
)) {
744 if (image_parts
[j
].size
> info
->partitions
[i
].size
)
745 error(1, 0, "%s partition too big (more than %u bytes)", info
->partitions
[i
].name
, (unsigned)info
->partitions
[i
].size
);
746 memcpy(image
+ info
->partitions
[i
].base
- flash_first_partition
->base
, image_parts
[j
].data
, image_parts
[j
].size
);
750 assert(image_parts
[j
].name
);
757 /** Generates an image according to a given layout and writes it to a file */
758 static void build_image(const char *output
,
759 const char *kernel_image
,
760 const char *rootfs_image
,
764 const struct device_info
*info
) {
765 struct image_partition_entry parts
[6] = {};
767 parts
[0] = make_partition_table(info
->partitions
);
768 parts
[1] = make_soft_version(rev
);
769 parts
[2] = make_support_list(info
);
770 parts
[3] = read_file("os-image", kernel_image
, false);
771 parts
[4] = read_file("file-system", rootfs_image
, add_jffs2_eof
);
776 image
= generate_sysupgrade_image(info
, parts
, &len
);
778 image
= generate_factory_image(info
, parts
, &len
);
780 FILE *file
= fopen(output
, "wb");
782 error(1, errno
, "unable to open output file");
784 if (fwrite(image
, len
, 1, file
) != 1)
785 error(1, 0, "unable to write output file");
792 for (i
= 0; parts
[i
].name
; i
++)
793 free_image_partition(parts
[i
]);
797 static void usage(const char *argv0
) {
799 "Usage: %s [OPTIONS...]\n"
802 " -B <board> create image for the board specified with <board>\n"
803 " -k <file> read kernel image from the file <file>\n"
804 " -r <file> read rootfs image from the file <file>\n"
805 " -o <file> write output to the file <file>\n"
806 " -V <rev> sets the revision number to <rev>\n"
807 " -j add jffs2 end-of-filesystem markers\n"
808 " -S create sysupgrade instead of factory image\n"
809 " -h show this help\n",
815 static const struct device_info
*find_board(const char *id
)
817 struct device_info
*board
= NULL
;
819 for (board
= boards
; board
->id
!= NULL
; board
++)
820 if (strcasecmp(id
, board
->id
) == 0)
826 int main(int argc
, char *argv
[]) {
827 const char *board
= NULL
, *kernel_image
= NULL
, *rootfs_image
= NULL
, *output
= NULL
;
828 bool add_jffs2_eof
= false, sysupgrade
= false;
830 const struct device_info
*info
;
835 c
= getopt(argc
, argv
, "B:k:r:o:V:jSh");
845 kernel_image
= optarg
;
849 rootfs_image
= optarg
;
857 sscanf(optarg
, "r%u", &rev
);
861 add_jffs2_eof
= true;
879 error(1, 0, "no board has been specified");
881 error(1, 0, "no kernel image has been specified");
883 error(1, 0, "no rootfs image has been specified");
885 error(1, 0, "no output filename has been specified");
887 info
= find_board(board
);
890 error(1, 0, "unsupported board %s", board
);
892 build_image(output
, kernel_image
, rootfs_image
, rev
, add_jffs2_eof
, sysupgrade
, info
);