WebSVN – OpenWrt – Blame – Rev 1 – /trunk/tools/firmware-utils/src/tplink-safeloader.c

static struct image_partition_entry read_file(const char *part_name, const char *filename, bool add_jffs2_eof, struct flash_partition_entry *file_system_partition) {

1412

struct stat statbuf;

1413

1414

if (stat(filename, &statbuf) < 0)

1415

error(1, errno, "unable to stat file `%s'", filename);

1416

1417

size_t len = statbuf.st_size;

1418

1419

if (add_jffs2_eof)

1420

if (file_system_partition)

1421

len = ALIGN(len + file_system_partition->base, 0x10000) + sizeof(jffs2_eof_mark) - file_system_partition->base;

1422

else

1423

len = ALIGN(len, 0x10000) + sizeof(jffs2_eof_mark);

1424

1425

struct image_partition_entry entry = alloc_image_partition(part_name, len);

1426

1427

FILE *file = fopen(filename, "rb");

1428

if (!file)

1429

error(1, errno, "unable to open file `%s'", filename);

1430

1431

if (fread(entry.data, statbuf.st_size, 1, file) != 1)

1432

error(1, errno, "unable to read file `%s'", filename);

1433

1434

if (add_jffs2_eof) {

1435

uint8_t *eof = entry.data + statbuf.st_size, *end = entry.data+entry.size;

1436

1437

memset(eof, 0xff, end - eof - sizeof(jffs2_eof_mark));

1438

memcpy(end - sizeof(jffs2_eof_mark), jffs2_eof_mark, sizeof(jffs2_eof_mark));

}

fclose(file);

return entry;

}

/** Creates a new image partition from arbitrary data */

1447

static struct image_partition_entry put_data(const char *part_name, const char *datain, size_t len) {

1448

1449

struct image_partition_entry entry = alloc_image_partition(part_name, len);

1450

1451

memcpy(entry.data, datain, len);

return entry;

}

/**

Copies a list of image partitions into an image buffer and generates the image partition table while doing so

1458

1459

Example image partition table:

1460

1461

fwup-ptn partition-table base 0x00800 size 0x00800

1462

fwup-ptn os-image base 0x01000 size 0x113b45

1463

fwup-ptn file-system base 0x114b45 size 0x1d0004

1464

fwup-ptn support-list base 0x2e4b49 size 0x000d1

1465

1466

Each line of the partition table is terminated with the bytes 09 0d 0a ("\t\r\n"),

1467

the end of the partition table is marked with a zero byte.

1468

1469

The firmware image must contain at least the partition-table and support-list partitions

1470

to be accepted. There aren't any alignment constraints for the image partitions.

1471

1472

The partition-table partition contains the actual flash layout; partitions

1473

from the image partition table are mapped to the corresponding flash partitions during

1474

the firmware upgrade. The support-list partition contains a list of devices supported by

1475

the firmware image.

1476

1477

The base offsets in the firmware partition table are relative to the end

1478

of the vendor information block, so the partition-table partition will

1479

actually start at offset 0x1814 of the image.

1480

1481

I think partition-table must be the first partition in the firmware image.

1482

*/

1483

static void put_partitions(uint8_t *buffer, const struct flash_partition_entry *flash_parts, const struct image_partition_entry *parts) {

1484

size_t i, j;

1485

char *image_pt = (char *)buffer, *end = image_pt + 0x800;

1486

1487

size_t base = 0x800;

1488

for (i = 0; parts[i].name; i++) {

1489

for (j = 0; flash_parts[j].name; j++) {

1490

if (!strcmp(flash_parts[j].name, parts[i].name)) {

1491

if (parts[i].size > flash_parts[j].size)

1492

error(1, 0, "%s partition too big (more than %u bytes)", flash_parts[j].name, (unsigned)flash_parts[j].size);

break;

}

}

assert(flash_parts[j].name);

1498

1499

memcpy(buffer + base, parts[i].data, parts[i].size);

1500

1501

size_t len = end-image_pt;

1502

		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);

1503

1504

if (w > len-1)

1505

error(1, 0, "image partition table overflow?");

image_pt += w;

base += parts[i].size;

}

}

/** Generates and writes the image MD5 checksum */

1514

static void put_md5(uint8_t *md5, uint8_t *buffer, unsigned int len) {

MD5_CTX ctx;

MD5_Init(&ctx);

MD5_Update(&ctx, md5_salt, (unsigned int)sizeof(md5_salt));

1519

MD5_Update(&ctx, buffer, len);

1520

MD5_Final(md5, &ctx);

}

/**

Generates the firmware image in factory format

Image format:

Bytes (hex) Usage

----------- -----

0000-0003 Image size (4 bytes, big endian)

1532

0004-0013 MD5 hash (hash of a 16 byte salt and the image data starting with byte 0x14)

1533

0014-0017 Vendor information length (without padding) (4 bytes, big endian)

1534

0018-1013 Vendor information (4092 bytes, padded with 0xff; there seem to be older

1535

(VxWorks-based) TP-LINK devices which use a smaller vendor information block)

1536

1014-1813 Image partition table (2048 bytes, padded with 0xff)

1537

1814-xxxx Firmware partitions

1538

*/

1539

static void * generate_factory_image(struct device_info *info, const struct image_partition_entry *parts, size_t *len) {

*len = 0x1814;

size_t i;

for (i = 0; parts[i].name; i++)

1544

*len += parts[i].size;

1545

1546

uint8_t *image = malloc(*len);

1547

if (!image)

1548

error(1, errno, "malloc");

1549

1550

memset(image, 0xff, *len);

1551

put32(image, *len);

1552

1553

if (info->vendor) {

1554

size_t vendor_len = strlen(info->vendor);

1555

put32(image+0x14, vendor_len);

1556

memcpy(image+0x18, info->vendor, vendor_len);

1557

}

1558

1559

put_partitions(image + 0x1014, info->partitions, parts);

1560

put_md5(image+0x04, image+0x14, *len-0x14);

return image;

}

/**

Generates the firmware image in sysupgrade format

1567

1568

This makes some assumptions about the provided flash and image partition tables and

1569

should be generalized when TP-LINK starts building its safeloader into hardware with

1570

different flash layouts.

1571

*/

1572

static void * generate_sysupgrade_image(struct device_info *info, const struct image_partition_entry *image_parts, size_t *len) {

1573

size_t i, j;

1574

size_t flash_first_partition_index = 0;

1575

size_t flash_last_partition_index = 0;

1576

const struct flash_partition_entry *flash_first_partition = NULL;

1577

const struct flash_partition_entry *flash_last_partition = NULL;

1578

const struct image_partition_entry *image_last_partition = NULL;

1579

1580

/** Find first and last partitions */

1581

for (i = 0; info->partitions[i].name; i++) {

1582

if (!strcmp(info->partitions[i].name, info->first_sysupgrade_partition)) {

1583

flash_first_partition = &info->partitions[i];

1584

flash_first_partition_index = i;

1585

} else if (!strcmp(info->partitions[i].name, info->last_sysupgrade_partition)) {

1586

flash_last_partition = &info->partitions[i];

1587

flash_last_partition_index = i;

}

}

assert(flash_first_partition && flash_last_partition);

1592

assert(flash_first_partition_index < flash_last_partition_index);

1593

1594

/** Find last partition from image to calculate needed size */

1595

for (i = 0; image_parts[i].name; i++) {

1596

if (!strcmp(image_parts[i].name, info->last_sysupgrade_partition)) {

1597

image_last_partition = &image_parts[i];

break;

}

}

assert(image_last_partition);

1603

1604

*len = flash_last_partition->base - flash_first_partition->base + image_last_partition->size;

1605

1606

uint8_t *image = malloc(*len);

1607

if (!image)

1608

error(1, errno, "malloc");

1609

1610

memset(image, 0xff, *len);

1611

1612

for (i = flash_first_partition_index; i <= flash_last_partition_index; i++) {

1613

for (j = 0; image_parts[j].name; j++) {

1614

if (!strcmp(info->partitions[i].name, image_parts[j].name)) {

1615

if (image_parts[j].size > info->partitions[i].size)

1616

					error(1, 0, "%s partition too big (more than %u bytes)", info->partitions[i].name, (unsigned)info->partitions[i].size);

1617

memcpy(image + info->partitions[i].base - flash_first_partition->base, image_parts[j].data, image_parts[j].size);

break;

}

assert(image_parts[j].name);

}

}

return image;

}

/** Generates an image according to a given layout and writes it to a file */

1629

static void build_image(const char *output,

1630

const char *kernel_image,

1631

const char *rootfs_image,

1632

uint32_t rev,

1633

bool add_jffs2_eof,

1634

bool sysupgrade,

1635

struct device_info *info) {

size_t i;

struct image_partition_entry parts[7] = {};

1640

1641

struct flash_partition_entry *firmware_partition = NULL;

1642

struct flash_partition_entry *os_image_partition = NULL;

1643

struct flash_partition_entry *file_system_partition = NULL;

1644

size_t firmware_partition_index = 0;

1645

1646

for (i = 0; info->partitions[i].name; i++) {

1647

if (!strcmp(info->partitions[i].name, "firmware"))

1648

{

1649

firmware_partition = &info->partitions[i];

1650

firmware_partition_index = i;

}

}

if (firmware_partition)

1655

{

1656

os_image_partition = &info->partitions[firmware_partition_index];

1657

file_system_partition = &info->partitions[firmware_partition_index + 1];

1658

1659

struct stat kernel;

1660

if (stat(kernel_image, &kernel) < 0)

1661

error(1, errno, "unable to stat file `%s'", kernel_image);

1662

1663

if (kernel.st_size > firmware_partition->size)

1664

error(1, 0, "kernel overflowed firmware partition\n");

1665

1666

for (i = MAX_PARTITIONS-1; i >= firmware_partition_index + 1; i--)

1667

info->partitions[i+1] = info->partitions[i];

1668

1669

file_system_partition->name = "file-system";

1670

file_system_partition->base = firmware_partition->base + kernel.st_size;

1671

1672

/* Align partition start to erase blocks for factory images only */

1673

if (!sysupgrade)

1674

file_system_partition->base = ALIGN(firmware_partition->base + kernel.st_size, 0x10000);

1675

1676

file_system_partition->size = firmware_partition->size - file_system_partition->base;

1677

1678

os_image_partition->name = "os-image";

1679

os_image_partition->size = kernel.st_size;

1680

}

1681

1682

parts[0] = make_partition_table(info->partitions);

1683

if (info->soft_ver)

1684

parts[1] = make_soft_version_from_string(info->soft_ver);

1685

else

1686

parts[1] = make_soft_version(rev);

1687

1688

parts[2] = make_support_list(info);

1689

parts[3] = read_file("os-image", kernel_image, false, NULL);

1690

parts[4] = read_file("file-system", rootfs_image, add_jffs2_eof, file_system_partition);

1691

1692

/* Some devices need the extra-para partition to accept the firmware */

1693

if (strcasecmp(info->id, "ARCHER-C2-V3") == 0 ||

1694

strcasecmp(info->id, "ARCHER-C25-V1") == 0 ||

1695

strcasecmp(info->id, "ARCHER-C59-V2") == 0 ||

1696

strcasecmp(info->id, "ARCHER-C60-V2") == 0 ||

1697

strcasecmp(info->id, "TLWR1043NV5") == 0) {

1698

const char mdat[11] = {0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};

1699

parts[5] = put_data("extra-para", mdat, 11);

1700

	} else if (strcasecmp(info->id, "ARCHER-A7-V5") == 0 || strcasecmp(info->id, "ARCHER-C7-V4") == 0 || strcasecmp(info->id, "ARCHER-C7-V5") == 0) {

1701

const char mdat[11] = {0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0xca, 0x00, 0x01, 0x00, 0x00};

1702

parts[5] = put_data("extra-para", mdat, 11);

1703

} else if (strcasecmp(info->id, "ARCHER-C6-V2") == 0) {

1704

const char mdat[11] = {0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00};

1705

parts[5] = put_data("extra-para", mdat, 11);

}

size_t len;

void *image;

if (sysupgrade)

image = generate_sysupgrade_image(info, parts, &len);

1712

else

1713

image = generate_factory_image(info, parts, &len);

1714

1715

FILE *file = fopen(output, "wb");

1716

if (!file)

1717

error(1, errno, "unable to open output file");

1718

1719

if (fwrite(image, len, 1, file) != 1)

1720

error(1, 0, "unable to write output file");

fclose(file);

free(image);

for (i = 0; parts[i].name; i++)

1727

free_image_partition(parts[i]);

1728

}

1729

1730

/** Usage output */

1731

static void usage(const char *argv0) {

1732

fprintf(stderr,

1733

"Usage: %s [OPTIONS...]\n"

1734

"\n"

1735

"Options:\n"

1736

" -h show this help\n"

1737

"\n"

1738

"Create a new image:\n"

1739

" -B <board> create image for the board specified with <board>\n"

1740

" -k <file> read kernel image from the file <file>\n"

1741

" -r <file> read rootfs image from the file <file>\n"

1742

" -o <file> write output to the file <file>\n"

1743

" -V <rev> sets the revision number to <rev>\n"

1744

" -j add jffs2 end-of-filesystem markers\n"

1745

" -S create sysupgrade instead of factory image\n"

1746

"Extract an old image:\n"

1747

" -x <file> extract all oem firmware partition\n"

1748

" -d <dir> destination to extract the firmware partition\n"

1749

" -z <file> convert an oem firmware into a sysupgade file. Use -o for output file\n",

argv0

);

};

static struct device_info *find_board(const char *id)

1756

{

1757

struct device_info *board = NULL;

1758

1759

for (board = boards; board->id != NULL; board++)

1760

if (strcasecmp(id, board->id) == 0)

return board;

return NULL;

}

static int add_flash_partition(

1767

struct flash_partition_entry *part_list,

1768

size_t max_entries,

1769

const char *name,

1770

unsigned long base,

1771

unsigned long size)

1772

{

1773

int ptr;

1774

/* check if the list has a free entry */

1775

for (ptr = 0; ptr < max_entries; ptr++, part_list++) {

1776

if (part_list->name == NULL &&

1777

part_list->base == 0 &&

1778

part_list->size == 0)

break;

}

if (ptr == max_entries) {

1783

error(1, 0, "No free flash part entry available.");

1784

}

1785

1786

part_list->name = calloc(1, strlen(name) + 1);

1787

if (!part_list->name) {

1788

error(1, 0, "Unable to allocate memory");

1789

}

1790

1791

memcpy((char *)part_list->name, name, strlen(name));

1792

part_list->base = base;

1793

part_list->size = size;

return 0;

}

/** read the partition table into struct flash_partition_entry */

1799

static int read_partition_table(

1800

FILE *file, long offset,

1801

struct flash_partition_entry *entries, size_t max_entries,

int type)

{

char buf[2048];

char *ptr, *end;

const char *parthdr = NULL;

1807

const char *fwuphdr = "fwup-ptn";

1808

const char *flashhdr = "partition";

1809

1810

/* TODO: search for the partition table */

switch(type) {

case 0:

parthdr = fwuphdr;

break;

case 1:

parthdr = flashhdr;

1818

break;

1819

default:

1820

error(1, 0, "Invalid partition table");

1821

}

1822

1823

if (fseek(file, offset, SEEK_SET) < 0)

1824

error(1, errno, "Can not seek in the firmware");

1825

1826

if (fread(buf, 1, 2048, file) < 0)

1827

error(1, errno, "Can not read fwup-ptn from the firmware");

buf[2047] = '\0';

/* look for the partition header */

1832

if (memcmp(buf, parthdr, strlen(parthdr)) != 0) {

1833

fprintf(stderr, "DEBUG: can not find fwuphdr\n");

return 1;

}

ptr = buf;

end = buf + sizeof(buf);

1839

while ((ptr + strlen(parthdr)) < end &&

1840

memcmp(ptr, parthdr, strlen(parthdr)) == 0) {

char *end_part;

char *end_element;

char name[32] = { 0 };

1845

int name_len = 0;

1846

unsigned long base = 0;

1847

unsigned long size = 0;

1848

1849

end_part = memchr(ptr, '\n', (end - ptr));

1850

if (end_part == NULL) {

1851

/* in theory this should never happen, because a partition always ends with 0x09, 0x0D, 0x0A */

break;

}

for (int i = 0; i <= 4; i++) {

1856

if (end_part <= ptr)

1857

break;

1858

1859

end_element = memchr(ptr, 0x20, (end_part - ptr));

1860

if (end_element == NULL) {

1861

error(1, errno, "Ignoring the rest of the partition entries.");

break;

}

switch (i) {

/* partition header */

1867

case 0:

1868

ptr = end_element + 1;

continue;

/* name */

case 1:

name_len = (end_element - ptr) > 31 ? 31 : (end_element - ptr);

1873

strncpy(name, ptr, name_len);

1874

name[name_len] = '\0';

1875

ptr = end_element + 1;

1876

continue;

1877

1878

/* string "base" */

1879

case 2:

1880

ptr = end_element + 1;

continue;

/* actual base */

case 3:

base = strtoul(ptr, NULL, 16);

1886

ptr = end_element + 1;

1887

continue;

1888

1889

/* string "size" */

1890

case 4:

1891

ptr = end_element + 1;

1892

/* actual size. The last element doesn't have a sepeartor */

1893

size = strtoul(ptr, NULL, 16);

1894

/* the part ends with 0x09, 0x0d, 0x0a */

1895

ptr = end_part + 1;

1896

add_flash_partition(entries, max_entries, name, base, size);

continue;

}

}

}

return 0;

}

static void write_partition(

1906

FILE *input_file,

1907

size_t firmware_offset,

1908

struct flash_partition_entry *entry,

FILE *output_file)

{

char buf[4096];

size_t offset;

fseek(input_file, entry->base + firmware_offset, SEEK_SET);

1915

1916

for (offset = 0; sizeof(buf) + offset <= entry->size; offset += sizeof(buf)) {

1917

if (fread(buf, sizeof(buf), 1, input_file) < 0)

1918

error(1, errno, "Can not read partition from input_file");

1919

1920

if (fwrite(buf, sizeof(buf), 1, output_file) < 0)

1921

error(1, errno, "Can not write partition to output_file");

1922

}

1923

/* write last chunk smaller than buffer */

1924

if (offset < entry->size) {

1925

offset = entry->size - offset;

1926

if (fread(buf, offset, 1, input_file) < 0)

1927

error(1, errno, "Can not read partition from input_file");

1928

if (fwrite(buf, offset, 1, output_file) < 0)

1929

error(1, errno, "Can not write partition to output_file");

}

}

static int extract_firmware_partition(FILE *input_file, size_t firmware_offset, struct flash_partition_entry *entry, const char *output_directory)

1934

{

1935

FILE *output_file;

1936

char output[PATH_MAX];

1937

1938

snprintf(output, PATH_MAX, "%s/%s", output_directory, entry->name);

1939

output_file = fopen(output, "wb+");

1940

if (output_file == NULL) {

1941

error(1, errno, "Can not open output file %s", output);

1942

}

1943

1944

write_partition(input_file, firmware_offset, entry, output_file);

1945

1946

fclose(output_file);

return 0;

}

/** extract all partitions from the firmware file */

1952

static int extract_firmware(const char *input, const char *output_directory)

1953

{

1954

struct flash_partition_entry entries[16] = { 0 };

1955

size_t max_entries = 16;

1956

size_t firmware_offset = 0x1014;

1957

FILE *input_file;

1958

1959

struct stat statbuf;

1960

1961

/* check input file */

1962

if (stat(input, &statbuf)) {

1963

error(1, errno, "Can not read input firmware %s", input);

1964

}

1965

1966

/* check if output directory exists */

1967

if (stat(output_directory, &statbuf)) {

1968

error(1, errno, "Failed to stat output directory %s", output_directory);

1969

}

1970

1971

if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {

1972

error(1, errno, "Given output directory is not a directory %s", output_directory);

1973

}

1974

1975

input_file = fopen(input, "rb");

1976

1977

if (read_partition_table(input_file, firmware_offset, entries, 16, 0) != 0) {

1978

error(1, 0, "Error can not read the partition table (fwup-ptn)");

1979

}

1980

1981

for (int i = 0; i < max_entries; i++) {

1982

if (entries[i].name == NULL &&

1983

entries[i].base == 0 &&

1984

entries[i].size == 0)

1985

continue;

1986

1987

extract_firmware_partition(input_file, firmware_offset, &entries[i], output_directory);

}

return 0;

}

static struct flash_partition_entry *find_partition(

1994

struct flash_partition_entry *entries, size_t max_entries,

1995

const char *name, const char *error_msg)

1996

{

1997

for (int i = 0; i < max_entries; i++, entries++) {

1998

if (strcmp(entries->name, name) == 0)

return entries;

}

error(1, 0, "%s", error_msg);

return NULL;

}

static void write_ff(FILE *output_file, size_t size)

{

char buf[4096];

int offset;

memset(buf, 0xff, sizeof(buf));

2012

2013

for (offset = 0; offset + sizeof(buf) < size ; offset += sizeof(buf)) {

2014

if (fwrite(buf, sizeof(buf), 1, output_file) < 0)

2015

error(1, errno, "Can not write 0xff to output_file");

2016

}

2017

2018

/* write last chunk smaller than buffer */

2019

if (offset < size) {

2020

offset = size - offset;

2021

if (fwrite(buf, offset, 1, output_file) < 0)

2022

error(1, errno, "Can not write partition to output_file");

}

}

static void convert_firmware(const char *input, const char *output)

2027

{

2028

struct flash_partition_entry fwup[MAX_PARTITIONS] = { 0 };

2029

struct flash_partition_entry flash[MAX_PARTITIONS] = { 0 };

2030

struct flash_partition_entry *fwup_os_image = NULL, *fwup_file_system = NULL;

2031

struct flash_partition_entry *flash_os_image = NULL, *flash_file_system = NULL;

2032

struct flash_partition_entry *fwup_partition_table = NULL;

2033

size_t firmware_offset = 0x1014;

2034

FILE *input_file, *output_file;

2035

2036

struct stat statbuf;

2037

2038

/* check input file */

2039

if (stat(input, &statbuf)) {

2040

error(1, errno, "Can not read input firmware %s", input);

2041

}

2042

2043

input_file = fopen(input, "rb");

2044

if (!input_file)

2045

error(1, 0, "Can not open input firmware %s", input);

2046

2047

output_file = fopen(output, "wb");

2048

if (!output_file)

2049

error(1, 0, "Can not open output firmware %s", output);

2050

2051

if (read_partition_table(input_file, firmware_offset, fwup, MAX_PARTITIONS, 0) != 0) {

2052

error(1, 0, "Error can not read the partition table (fwup-ptn)");

2053

}

2054

2055

fwup_os_image = find_partition(fwup, MAX_PARTITIONS,

2056

"os-image", "Error can not find os-image partition (fwup)");

2057

fwup_file_system = find_partition(fwup, MAX_PARTITIONS,

2058

"file-system", "Error can not find file-system partition (fwup)");

2059

fwup_partition_table = find_partition(fwup, MAX_PARTITIONS,

2060

"partition-table", "Error can not find partition-table partition");

2061

2062

/* the flash partition table has a 0x00000004 magic haeder */

2063

if (read_partition_table(input_file, firmware_offset + fwup_partition_table->base + 4, flash, MAX_PARTITIONS, 1) != 0)

2064

error(1, 0, "Error can not read the partition table (flash)");

2065

2066

flash_os_image = find_partition(flash, MAX_PARTITIONS,

2067

"os-image", "Error can not find os-image partition (flash)");

2068

flash_file_system = find_partition(flash, MAX_PARTITIONS,

2069

"file-system", "Error can not find file-system partition (flash)");

2070

2071

/* write os_image to 0x0 */

2072

write_partition(input_file, firmware_offset, fwup_os_image, output_file);

2073

write_ff(output_file, flash_os_image->size - fwup_os_image->size);

2074

2075

/* write file-system behind os_image */

2076

fseek(output_file, flash_file_system->base - flash_os_image->base, SEEK_SET);

2077

write_partition(input_file, firmware_offset, fwup_file_system, output_file);

2078

write_ff(output_file, flash_file_system->size - fwup_file_system->size);

2079

2080

fclose(output_file);

2081

fclose(input_file);

2082

}

2083

2084

int main(int argc, char *argv[]) {

2085

const char *board = NULL, *kernel_image = NULL, *rootfs_image = NULL, *output = NULL;

2086

const char *extract_image = NULL, *output_directory = NULL, *convert_image = NULL;

2087

bool add_jffs2_eof = false, sysupgrade = false;

2088

unsigned rev = 0;

2089

struct device_info *info;

2090

set_source_date_epoch();

while (true) {

int c;

c = getopt(argc, argv, "B:k:r:o:V:jSh:x:d:z:");

if (c == -1)

break;

switch (c) {

case 'B':

board = optarg;

break;

case 'k':

kernel_image = optarg;

break;

case 'r':

rootfs_image = optarg;

break;

case 'o':

output = optarg;

break;

case 'V':

sscanf(optarg, "r%u", &rev);

break;

case 'j':

add_jffs2_eof = true;

break;

case 'S':

sysupgrade = true;

break;

case 'h':

usage(argv[0]);

return 0;

case 'd':

output_directory = optarg;

break;

case 'x':

extract_image = optarg;

break;

case 'z':

convert_image = optarg;

break;

default:

usage(argv[0]);

return 1;

}

}

if (extract_image || output_directory) {

2151

if (!extract_image)

2152

error(1, 0, "No factory/oem image given via -x <file>. Output directory is only valid with -x");

2153

if (!output_directory)

2154

error(1, 0, "Can not extract an image without output directory. Use -d <dir>");

2155

extract_firmware(extract_image, output_directory);

2156

} else if (convert_image) {

2157

if (!output)

2158

error(1, 0, "Can not convert a factory/oem image into sysupgrade image without output file. Use -o <file>");

2159

convert_firmware(convert_image, output);

2160

} else {

2161

if (!board)

2162

error(1, 0, "no board has been specified");

2163

if (!kernel_image)

2164

error(1, 0, "no kernel image has been specified");

2165

if (!rootfs_image)

2166

error(1, 0, "no rootfs image has been specified");

2167

if (!output)

2168

error(1, 0, "no output filename has been specified");

2169

2170

info = find_board(board);

2171

2172

if (info == NULL)

2173

error(1, 0, "unsupported board %s", board);

2174

2175

build_image(output, kernel_image, rootfs_image, rev, add_jffs2_eof, sysupgrade, info);

}

return 0;

}

OpenWrt – Blame information for rev 1