hsist
/
freifunkist-firmware
6
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "tools: wrt400n: fix making factory images with kernel bigger than 1MB"

Browse Source 
This reverts commit 5f9b20bc7d.

The builders were failing with a segfault when generating the image

Signed-off-by: John Crispin <john@phrozen.org>
master
John Crispin 8 years ago
parent 236fcedc51
commit 920ee1f707
1 changed files with 266 additions and 197 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 463
      tools/firmware-utils/src/wrt400n.c

463
tools/firmware-utils/src/wrt400n.c
Unescape View File

@ -6,34 +6,110 @@
* from a kernel image file and root fs file
*
* Author: Sandeep Mistry
* Author: Yousong Zhou
* - remove size limit on kernel and rootfs part
*/
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "cyg_crc.h"
// Prelimiary test shows that the OEM upgrade program only checks checksum of
// the whole firmware image, ignoring specific checksums of kernel and rootfs
// part. But we are computing crc32 sums of fixed length of data here in lieu
// of read_fw utility found in OEM SDK
#define CRC_SZ_KERNEL 0x100000
#define CRC_SZ_ROOTFS 0x2fffc4
// OEM firmware has size limit on "linux" and "rootfs" partition. That's also
// the limit for factory firmware images as fwupgrade utility in the OEM system
// needs to write kernel and rootfs to those two partitions (/dev/mtd2 and
// /dev/mtd3 to be exact)
#define SZ_MAX_KERNEL (0x180000 - 0x40000)
#define SZ_MAX_ROOTFS (0x7b0000 - 0x18000)
// https://dev.openwrt.org/browser/trunk/target/linux/rdc-2.6/files/drivers/mtd/maps/rdc3210.c
static uint32_t crctab[257] =
{
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
0
};
static uint32_t crc32(uint8_t* buf, uint32_t len)
{
register int i;
uint32_t sum;
register uint32_t s0;
s0 = ~0;
for (i = 0; i < len; i++)
{
s0 = (s0 >> 8) ^ crctab[(uint8_t) (s0 & 0xFF) ^ buf[i]];
}
sum = ~s0;
return sum;
}
#define HEADERSIZE 60
#define MAGIC "GMTKRT400N"
// global variables
uint8_t kernelbuf[0x100000]; // kernel - lzma - uImage
uint8_t rootfsbuf[0x2FFFC4]; // root - squashfs
uint8_t buf[0x400000]; // buffer for image
// Header format:
@ -41,6 +117,27 @@
// GPL Tarball: http://downloads.linksysbycisco.com/downloads/WRT400N_1.0.01.19_US.tar,0.gz
// File: WRT400N_1.0.01.19_US/FW_WRT400N_1.0.01.19_US_20081229/GTK/user/include/fw_upgrade.h
//
//
// Struct:
// typedef struct
// {
// UINT32 checksum; /* CRC32 */
// UINT8 magic[11]; /* The value of GTIMG_MAGIC */
// UINT32 kernel_length; /* The length of the kernel image */
// //UINT32 kernel_entry_point; /* Kernel's entry point for RedBoot's information */
// UINT32 kernel_upgrade_flag; /* Set to 1 if we need to upgrade the kernel parition of the Flash */
// UINT32 rootfs_length; /* The length of the rootfs image */
// //UINT32 rootfs_entry_point; /* Not in use */
// UINT32 rootfs_upgrade_flag; /* Set to 1 if we need to upgrade the rootfs parition of the Flash */
//
// // Add 3 items by Vic Yu, 2006-05/10
// UINT32 kernel_checksum;
// UINT32 rootfs_checksum;
// UINT32 fw_totalsize;
// UINT32 reserved[4];
// }imghdr_t , *pLinuxFWHeader_T;
//
//
// Description
// - checksum: CRC32 of kernel and root fs, back to back
// - magic: GMTKRT400N
@ -54,214 +151,186 @@
// set to 0xFF upto 0x2FFFC4 bytes (total length)
// - fw_totalsize: total firmware image file length (header length + kernel length + root fs length)
// - reserved[4]: reserved ??? - set to all 0xFF
struct imghdr_t
{
uint32_t checksum; /* CRC32 */
uint8_t magic[12]; /* The value of GTIMG_MAGIC */
uint32_t kernel_length; /* The length of the kernel image */
//uint32_t kernel_entry_point; /* Kernel's entry point for RedBoot's information */
uint32_t kernel_upgrade_flag; /* Set to 1 if we need to upgrade the kernel parition of the Flash */
uint32_t rootfs_length; /* The length of the rootfs image */
//uint32_t rootfs_entry_point; /* Not in use */
uint32_t rootfs_upgrade_flag; /* Set to 1 if we need to upgrade the rootfs parition of the Flash */
// Add 3 items by Vic Yu, 2006-05/10
uint32_t kernel_checksum;
uint32_t rootfs_checksum;
uint32_t fw_totalsize;
uint32_t reserved[4];
};
struct file_info {
char *filename;
int filesize;
int fd;
uint32_t crc32sum;
int crc_sz;
};
int get_file_info(struct file_info *fi, uint32_t *crc32_acc)
int main(int argc, char *argv[])
{
int fd;
int filesize = 0;
uint32_t crc32sum = 0;
uint32_t _crc32_acc;
int crc_rem = fi->crc_sz;
int sz;
char buf[1024];
if (crc32_acc)
_crc32_acc = *crc32_acc;
else
_crc32_acc = 0;
fd = open(fi->filename, O_RDONLY);
if(fd < 0) {
fprintf(stderr, "error: opening '%s'\n", fi->filename);
return -1;
}
while (true) {
sz = read(fd, buf, sizeof(buf));
if (sz > 0) {
if (crc32_acc)
_crc32_acc = cyg_crc32_accumulate(_crc32_acc, buf, sz);
if (crc_rem > 0) {
if (crc_rem < sz) {
crc32sum = cyg_crc32_accumulate(crc32sum, buf, crc_rem);
crc_rem = 0;
} else {
crc32sum = cyg_crc32_accumulate(crc32sum, buf, sz);
crc_rem -= sz;
}
}
filesize += sz;
} else if (sz == 0) {
break;
} else {
fprintf(stderr, "error read '%s'", strerror(errno));
return -1;
}
}
// file descriptors ...
int kernelfd = -1;
int rootfsfd = -1;
int outfd = -1;
if (crc_rem) {
memset(buf, 0xff, sizeof(buf));
while (crc_rem > 0) {
if (crc_rem > sizeof(buf)) {
crc32sum = cyg_crc32_accumulate(crc32sum, buf, sizeof(buf));
crc_rem -= sizeof(buf);
} else {
crc32sum = cyg_crc32_accumulate(crc32sum, buf, crc_rem);
crc_rem = 0;
break;
}
}
}
char* kernelfilename = NULL;
char* rootfsfilename = NULL;
char* outputfilename = NULL;
fi->fd = fd;
fi->filesize = filesize;
fi->crc32sum = crc32sum;
if (crc32_acc)
*crc32_acc = _crc32_acc;
return 0;
}
// file sizes
uint32_t kernelsize = 0;
uint32_t rootfssize = 0;
uint32_t totalsize = 0;
int copy_file(int fromfd, int tofd)
{
int szr, szw;
int buf[4096];
// header flags
uint32_t kernelflag = 0;
uint32_t rootfsflag = 0;
if (lseek(fromfd, SEEK_SET, 0) < 0) {
fprintf(stderr, "lseek: %s\n", strerror(errno));
return -1;
}
while (true) {
szr = read(fromfd, buf, sizeof(buf));
if (szr > 0) {
szw = write(tofd, buf, szr);
if (szw != szr) {
fprintf(stderr, "copy_file: error writing %d bytes: %s\n", szr, strerror(errno));
return -1;
}
} else if (szr == 0) {
break;
} else {
fprintf(stderr, "copy_file: error reading: %s\n", strerror(errno));
return -1;
}
}
return 0;
}
// checksums
uint32_t kernelchecksum = 0;
uint32_t rootfschecksum = 0;
uint32_t crc = 0;
int main(int argc, char *argv[])
{
struct file_info kernel_fi;
struct file_info rootfs_fi;
struct file_info output_fi;
struct imghdr_t ih;
int fd, sz;
int ret = -1;
if(argc != 4) {
if(argc != 4)
{
printf("Usage:\n\t%s <kernel file> <rootfs file> <output file>\n", argv[0]);
return 1;
}
kernel_fi.crc_sz = CRC_SZ_KERNEL;
rootfs_fi.crc_sz = CRC_SZ_ROOTFS;
kernelfilename = argv[1];
rootfsfilename = argv[2];
outputfilename = argv[3];
kernel_fi.fd = -1;
rootfs_fi.fd = -1;
output_fi.fd = -1;
// Fill the kernel, rootfs, main buffer
memset(kernelbuf, 0xFF, sizeof(kernelbuf));
memset(rootfsbuf, 0xFF, sizeof(rootfsbuf));
memset(buf, 0xFF, sizeof(buf));
kernel_fi.filename = argv[1];
rootfs_fi.filename = argv[2];
output_fi.filename = argv[3];
// open the kernel ..
kernelfd = open(kernelfilename, O_RDONLY);
kernel_fi.crc32sum = 0;
rootfs_fi.crc32sum = 0;
output_fi.crc32sum = 0xffffffff;
if (get_file_info(&kernel_fi, &output_fi.crc32sum) < 0)
if(kernelfd == -1)
{
printf("Error: opening '%s'\n", kernelfilename);
goto done;
if (get_file_info(&rootfs_fi, &output_fi.crc32sum) < 0)
}
// read in the kernel ...
kernelsize = read(kernelfd, kernelbuf, sizeof(kernelbuf));
if(kernelsize == -1)
{
printf("Error: reading '%s'\n", kernelfilename);
goto done;
output_fi.crc32sum = ~output_fi.crc32sum;
}
// calculate the kernel checksum ...
kernelchecksum = cyg_crc32_accumulate(0, kernelbuf, sizeof(kernelbuf));
// print out stats
fprintf(stderr, "%s: size %d (0x%x), crc32 = 0x%x\n",
kernel_fi.filename, kernel_fi.filesize, kernel_fi.filesize, kernel_fi.crc32sum);
fprintf(stderr, "%s: size %d (0x%x), crc32 = 0x%x\n",
rootfs_fi.filename, rootfs_fi.filesize, rootfs_fi.filesize, rootfs_fi.crc32sum);
if (kernel_fi.filesize > SZ_MAX_KERNEL) {
fprintf(stderr, "%s: filesize exceeds 0x%x limit\n", SZ_MAX_KERNEL);
printf("%s: size %d (0x%x), crc32 = 0x%x\n", kernelfilename, kernelsize, kernelsize, kernelchecksum);
// open the root fs ..
rootfsfd = open(rootfsfilename, O_RDONLY);
if(rootfsfd == -1)
{
printf("Error: opening '%s'\n", rootfsfilename);
goto done;
}
if (rootfs_fi.filesize > SZ_MAX_ROOTFS) {
fprintf(stderr, "%s: filesize exceeds 0x%x limit\n", SZ_MAX_ROOTFS);
// read in the root fs ..
rootfssize = read(rootfsfd, rootfsbuf, sizeof(rootfsbuf));
if(rootfssize == -1)
{
printf("Error: reading '%s'\n", rootfsfilename);
goto done;
}
// calculate the root fs checksum ...
rootfschecksum = cyg_crc32_accumulate(0, rootfsbuf, sizeof(rootfsbuf));
// print out stats
printf("%s: size %d (0x%x), crc32 = 0x%x\n", rootfsfilename, rootfssize, rootfssize, rootfschecksum);
// now for the header ...
memset(&ih, 0xff, sizeof(ih));
strcpy(ih.magic, "GMTKRT400N");
ih.checksum = htonl(output_fi.crc32sum);
ih.kernel_length = htonl(kernel_fi.filesize);
ih.rootfs_length = htonl(rootfs_fi.filesize);
ih.kernel_upgrade_flag = htonl(0x1);
ih.rootfs_upgrade_flag = htonl(0x1);
ih.kernel_checksum = htonl(kernel_fi.crc32sum);
ih.rootfs_checksum = htonl(rootfs_fi.crc32sum);
ih.fw_totalsize = htonl(kernel_fi.filesize + rootfs_fi.filesize + sizeof(ih));
output_fi.fd = open(output_fi.filename, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
sz = write(output_fi.fd, &ih, sizeof(ih));
if (sz != sizeof(ih)) {
fprintf(stderr, "error writing imghdr to output: %s\n", strerror(errno));
goto done;
totalsize = HEADERSIZE;
// copy over kernel
memcpy(buf + totalsize, kernelbuf, kernelsize);
totalsize += kernelsize;
// copy over root fs
memcpy(buf + totalsize, rootfsbuf, rootfssize);
totalsize += rootfssize;
// calculate crc
crc = crc32(buf + HEADERSIZE, totalsize - HEADERSIZE);
// print some stats out
printf("crc = 0x%x, total size = %d (0x%x)\n", crc, totalsize, totalsize);
// copy crc into header
crc = htonl(crc);
memcpy(buf, &crc, sizeof(crc));
// copy over magic
strcpy((char *)buf + 4, MAGIC);
// copy over kernel size
kernelsize = htonl(kernelsize);
memcpy(buf + 16, &kernelsize, sizeof(kernelsize));
// copy over kernal flag
kernelflag = htonl(0x1);
memcpy(buf + 20, &kernelflag, sizeof(kernelflag));
// copy over root fs size
rootfssize = htonl(rootfssize);
memcpy(buf + 24, &rootfssize, sizeof(rootfssize));
// copy over root fs flag
rootfsflag = htonl(0x1);
memcpy(buf + 28, &rootfsflag, sizeof(rootfsflag));
// copy over kernel check sum
kernelchecksum = htonl(kernelchecksum);
memcpy(buf + 32, &kernelchecksum, sizeof(kernelchecksum));
// copy over root fs checksum
rootfschecksum = htonl(rootfschecksum);
memcpy(buf + 36, &rootfschecksum, sizeof(rootfschecksum));
// copy over total size
totalsize = htonl(totalsize);
memcpy(buf + 40, &totalsize, sizeof(totalsize));
// undo the htonl (for write)
totalsize = htonl(totalsize);
// write out the file from the buffer
outfd = open(outputfilename, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(outfd == -1)
{
printf("ERROR: opening '%s' for write\n", outputfilename);
}
if (copy_file(kernel_fi.fd, output_fi.fd)) {
fprintf(stderr, "error copying %s to %s\n", kernel_fi.filename, output_fi.filename);
goto done;
write(outfd, buf, totalsize);
done:
// close open fd's
if(kernelfd != -1)
{
close(kernelfd);
kernelfd = -1;
}
if (copy_file(rootfs_fi.fd, output_fi.fd)) {
fprintf(stderr, "error copying %s to %s\n", rootfs_fi.filename, output_fi.filename);
goto done;
if(rootfsfd != -1)
{
close(rootfsfd);
rootfsfd = -1;
}
// print some stats out
fprintf(stderr, "crc = 0x%x, total size = %d (0x%x)\n",
output_fi.crc32sum, ntohl(ih.fw_totalsize), ntohl(ih.fw_totalsize));
ret = 0;
done:
#define CLOSE_FI_FD(fi) do { \
if ((fi).fd >= 0) { \
close((fi).fd); \
} \
} while (0)
CLOSE_FI_FD(kernel_fi);
CLOSE_FI_FD(rootfs_fi);
CLOSE_FI_FD(output_fi);
return ret;
if(outfd != -1)
{
close(outfd);
outfd = -1;
}
return 0;
}

Write Preview
Loading…
Cancel
Save