Root/tools/firmware-utils/src/buffalo-tag.c

1/*
2 * Copyright (C) 2009-2011 Gabor Juhos <juhosg@openwrt.org>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published
6 * by the Free Software Foundation.
7 *
8 */
9
10#include <stdio.h>
11#include <stdlib.h>
12#include <stdint.h>
13#include <string.h>
14#include <libgen.h>
15#include <getopt.h> /* for getopt() */
16#include <netinet/in.h>
17
18#include "buffalo-lib.h"
19
20#define ERR(fmt, ...) do { \
21    fflush(0); \
22    fprintf(stderr, "[%s] *** error: " fmt "\n", \
23            progname, ## __VA_ARGS__ ); \
24} while (0)
25
26static char *region_table[] = {
27    "JP", "US", "EU", "AP", "TW", "KR"
28};
29
30static char *progname;
31static char *ifname;
32static char *ofname;
33static char *product;
34static char *brand;
35static char *language;
36static char *hwver;
37static char *platform;
38static int flag;
39static char *major;
40static char *minor = "1.01";
41static int skipcrc;
42static uint32_t base1;
43static uint32_t base2;
44static char *region_code;
45static uint32_t region_mask;
46static int num_regions;
47
48void usage(int status)
49{
50    FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
51
52    fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
53    fprintf(stream,
54"\n"
55"Options:\n"
56" -a <platform> set platform to <platform>\n"
57" -b <brand> set brand to <brand>\n"
58" -c <base1>\n"
59" -d <base2>\n"
60" -f <flag> set flag to <flag>\n"
61" -i <file> read input from the file <file>\n"
62" -l <language> set language to <language>\n"
63" -m <version> set minor version to <version>\n"
64" -o <file> write output to the file <file>\n"
65" -p <product> set product to <product>\n"
66" -r <region> set image region to <region>\n"
67" valid regions: JP, US, EU, AP, TW, KR, M_\n"
68" -s skip CRC calculation\n"
69" -v <version> set major version to <version>\n"
70" -w <version> set harwdware version to <version>\n"
71" -h show this screen\n"
72    );
73
74    exit(status);
75}
76
77static int check_params(void)
78{
79
80#define CHECKSTR(_var, _name, _len) do { \
81    if ((_var) == NULL) { \
82        ERR("no %s specified", (_name)); \
83        return -1; \
84    } \
85    if ((_len) > 0 && \
86        strlen((_var)) > ((_len) - 1)) { \
87        ERR("%s is too long", (_name)); \
88        return -1; \
89    } \
90} while (0)
91
92    CHECKSTR(ifname, "input file", 0);
93    CHECKSTR(ofname, "output file", 0);
94    CHECKSTR(brand, "brand", TAG_BRAND_LEN);
95    CHECKSTR(product, "product", TAG_PRODUCT_LEN);
96    CHECKSTR(platform, "platform", TAG_PLATFORM_LEN);
97    CHECKSTR(major, "major version", TAG_VERSION_LEN);
98    CHECKSTR(minor, "minor version", TAG_VERSION_LEN);
99    CHECKSTR(language, "language", TAG_LANGUAGE_LEN);
100    CHECKSTR(hwver, "hardware version", 2);
101
102    if (num_regions == 0) {
103        ERR("no region code specified");
104        return -1;
105    }
106
107    return 0;
108
109#undef CHECKSTR
110}
111
112static int process_region(char *reg)
113{
114    int i;
115
116    if (strlen(reg) != 2) {
117        ERR("invalid region code '%s'", reg);
118        return -1;
119    }
120
121    if (strcmp(reg, "M_") == 0) {
122        region_code = reg;
123        region_mask |= ~0;
124        num_regions = 32;
125        return 0;
126    }
127
128    for (i = 0; i < ARRAY_SIZE(region_table); i++)
129        if (strcmp(reg, region_table[i]) == 0) {
130            region_code = reg;
131            region_mask |= 1 << i;
132            num_regions++;
133            return 0;
134        }
135
136    ERR("unknown region code '%s'", reg);
137    return -1;
138}
139
140static void fixup_tag(unsigned char *buf, ssize_t buflen, ssize_t datalen)
141{
142    struct buffalo_tag *tag = (struct buffalo_tag *) buf;
143
144    memset(tag, '\0', sizeof(*tag));
145
146    memcpy(tag->brand, brand, strlen(brand));
147    memcpy(tag->product, product, strlen(product));
148    memcpy(tag->platform, platform, strlen(platform));
149    memcpy(tag->ver_major, major, strlen(major));
150    memcpy(tag->ver_minor, minor, strlen(minor));
151    memcpy(tag->language, language, strlen(language));
152
153    if (num_regions > 1) {
154        tag->region_code[0] = 'M';
155        tag->region_code[1] = '_';
156        tag->region_mask = htonl(region_mask);
157    } else {
158        memcpy(tag->region_code, region_code, 2);
159    }
160
161    tag->len = htonl(buflen);
162    tag->data_len = htonl(datalen);
163    tag->base1 = htonl(base1);
164    tag->base2 = htonl(base2);
165    tag->flag = flag;
166
167    if (hwver) {
168        memcpy(tag->hwv, "hwv", 3);
169        memcpy(tag->hwv_val, hwver, strlen(hwver));
170    }
171
172    if (!skipcrc)
173        tag->crc = htonl(buffalo_crc(buf, buflen));
174}
175
176static int tag_file(void)
177{
178    unsigned char *buf;
179    ssize_t fsize;
180    ssize_t buflen;
181    int err;
182    int ret = -1;
183
184    fsize = get_file_size(ifname);
185    if (fsize < 0) {
186        ERR("unable to get size of '%s'", ifname);
187        goto out;
188    }
189
190    buflen = fsize + sizeof(struct buffalo_tag);
191    buf = malloc(buflen);
192    if (!buf) {
193        ERR("no memory for buffer\n");
194        goto out;
195    }
196
197    err = read_file_to_buf(ifname, buf + sizeof(struct buffalo_tag),
198                   fsize);
199    if (err) {
200        ERR("unable to read from file '%s'", ifname);
201        goto free_buf;
202    }
203
204    fixup_tag(buf, buflen, fsize);
205
206    err = write_buf_to_file(ofname, buf, buflen);
207    if (err) {
208        ERR("unable to write to file '%s'", ofname);
209        goto free_buf;
210    }
211
212    ret = 0;
213
214free_buf:
215    free(buf);
216out:
217    return ret;
218}
219
220int main(int argc, char *argv[])
221{
222    int res = EXIT_FAILURE;
223    int err;
224
225    progname = basename(argv[0]);
226
227    while ( 1 ) {
228        int c;
229
230        c = getopt(argc, argv, "a:b:c:d:f:hi:l:m:o:p:r:sv:w:");
231        if (c == -1)
232            break;
233
234        switch (c) {
235        case 'a':
236            platform = optarg;
237            break;
238        case 'b':
239            brand = optarg;
240            break;
241        case 'c':
242            base1 = strtoul(optarg, NULL, 16);
243            break;
244        case 'd':
245            base2 = strtoul(optarg, NULL, 16);
246            break;
247        case 'f':
248            flag = strtoul(optarg, NULL, 2);
249            break;
250        case 'i':
251            ifname = optarg;
252            break;
253        case 'l':
254            language = optarg;
255            break;
256        case 'm':
257            minor = optarg;
258            break;
259        case 'o':
260            ofname = optarg;
261            break;
262        case 'p':
263            product = optarg;
264            break;
265        case 'r':
266            err = process_region(optarg);
267            if (err)
268                goto out;
269            break;
270        case 's':
271            skipcrc = 1;
272            break;
273        case 'v':
274            major = optarg;
275            break;
276        case 'w':
277            hwver = optarg;
278            break;
279        case 'h':
280            usage(EXIT_SUCCESS);
281            break;
282        default:
283            usage(EXIT_FAILURE);
284            break;
285        }
286    }
287
288    err = check_params();
289    if (err)
290        goto out;
291
292    err = tag_file();
293    if (err)
294        goto out;
295
296    res = EXIT_SUCCESS;
297
298out:
299    return res;
300}
301

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive