Root/tools/firmware-utils/src/mkcameofw.c

1/*
2 * Copyright (C) 2012 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 <unistd.h> /* for unlink() */
15#include <libgen.h>
16#include <getopt.h> /* for getopt() */
17#include <stdarg.h>
18#include <errno.h>
19#include <sys/stat.h>
20
21#include <arpa/inet.h>
22#include <netinet/in.h>
23
24#define MAX_MODEL_LEN 20
25#define MAX_SIGNATURE_LEN 30
26#define MAX_REGION_LEN 4
27#define MAX_VERSION_LEN 12
28
29#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
30
31struct file_info {
32    char *file_name; /* name of the file */
33    uint32_t file_size; /* length of the file */
34    uint32_t write_size;
35};
36
37struct img_header {
38    uint32_t checksum;
39    uint32_t image_size;
40    uint32_t kernel_size;
41    char model[MAX_MODEL_LEN];
42    char signature[MAX_SIGNATURE_LEN];
43    char region[MAX_REGION_LEN];
44    char version[MAX_VERSION_LEN];
45    unsigned char header_len;
46    unsigned char is_tgz;
47    unsigned char pad[4];
48} __attribute__ ((packed));
49
50/*
51 * Globals
52 */
53static char *ofname;
54static char *progname;
55
56static char *model;
57static char *signature;
58static char *region = "DEF";
59static char *version;
60static struct file_info kernel_info;
61static struct file_info rootfs_info;
62static uint32_t kernel_size;
63static uint32_t image_size;
64
65/*
66 * Message macros
67 */
68#define ERR(fmt, ...) do { \
69    fflush(0); \
70    fprintf(stderr, "[%s] *** error: " fmt "\n", \
71            progname, ## __VA_ARGS__ ); \
72} while (0)
73
74#define ERRS(fmt, ...) do { \
75    int save = errno; \
76    fflush(0); \
77    fprintf(stderr, "[%s] *** error: " fmt " (%s)\n", \
78            progname, ## __VA_ARGS__, strerror(save)); \
79} while (0)
80
81#define DBG(fmt, ...) do { \
82    fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
83} while (0)
84
85static void usage(int status)
86{
87    FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
88
89    fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
90    fprintf(stream,
91"\n"
92"Options:\n"
93" -k <file> read kernel image from the file <file>\n"
94" -M <model> set model to <model>\n"
95" -o <file> write output to the file <file>\n"
96" -r <file> read rootfs image from the file <file>\n"
97" -S <signature> set image signature to <signature>\n"
98" -R <region> set image region to <region>\n"
99" -V <version> set image version to <version>\n"
100" -I <size> set image size to <size>\n"
101" -K <size> set kernel size to <size>\n"
102" -h show this screen\n"
103    );
104
105    exit(status);
106}
107
108int
109str2u32(char *arg, uint32_t *val)
110{
111    char *err = NULL;
112    uint32_t t;
113
114    errno=0;
115    t = strtoul(arg, &err, 0);
116    if (errno || (err==arg) || ((err != NULL) && *err)) {
117        return -1;
118    }
119
120    *val = t;
121    return 0;
122}
123
124static int get_file_stat(struct file_info *fdata)
125{
126    struct stat st;
127    int res;
128
129    if (fdata->file_name == NULL)
130        return 0;
131
132    res = stat(fdata->file_name, &st);
133    if (res){
134        ERRS("stat failed on %s", fdata->file_name);
135        return res;
136    }
137
138    fdata->file_size = st.st_size;
139    fdata->write_size = fdata->file_size;
140    return 0;
141}
142
143static int read_to_buf(struct file_info *fdata, char *buf)
144{
145    FILE *f;
146    int ret = EXIT_FAILURE;
147
148    f = fopen(fdata->file_name, "r");
149    if (f == NULL) {
150        ERRS("could not open \"%s\" for reading", fdata->file_name);
151        goto out;
152    }
153
154    errno = 0;
155    fread(buf, fdata->file_size, 1, f);
156    if (errno != 0) {
157        ERRS("unable to read from file \"%s\"", fdata->file_name);
158        goto out_close;
159    }
160
161    ret = EXIT_SUCCESS;
162
163out_close:
164    fclose(f);
165out:
166    return ret;
167}
168
169static int check_options(void)
170{
171    int ret;
172
173#define CHKSTR(_name, _msg) \
174    do { \
175        if (_name == NULL) { \
176            ERR("no %s specified", _msg); \
177            return -1; \
178        } \
179    } while (0)
180
181#define CHKSTRLEN(_name, _msg) \
182    do { \
183        int field_len; \
184        CHKSTR(_name, _msg); \
185        field_len = FIELD_SIZEOF(struct img_header, _name) - 1; \
186        if (strlen(_name) > field_len) { \
187            ERR("%s is too long, max length is %d", \
188                _msg, field_len); \
189            return -1; \
190        } \
191    } while (0)
192
193    CHKSTRLEN(model, "model");
194    CHKSTRLEN(signature, "signature");
195    CHKSTRLEN(region, "region");
196    CHKSTRLEN(version, "version");
197    CHKSTR(ofname, "output file");
198    CHKSTR(kernel_info.file_name, "kernel image");
199    CHKSTR(rootfs_info.file_name, "rootfs image");
200
201    ret = get_file_stat(&kernel_info);
202    if (ret)
203        return ret;
204
205    ret = get_file_stat(&rootfs_info);
206    if (ret)
207        return ret;
208
209    if (kernel_size) {
210        /* override kernel size */
211        kernel_info.write_size = kernel_size;
212    }
213
214    if (image_size) {
215        if (image_size < kernel_info.write_size)
216            kernel_info.write_size = image_size;
217
218        /* override rootfs size */
219        rootfs_info.write_size = image_size - kernel_info.write_size;
220    }
221
222    if (kernel_info.file_size > kernel_info.write_size) {
223        ERR("kernel image is too big");
224        return -1;
225    }
226
227    if (rootfs_info.file_size > rootfs_info.write_size) {
228        ERR("rootfs image is too big");
229        return -1;
230    }
231
232    return 0;
233}
234
235static int write_fw(char *data, int len)
236{
237    FILE *f;
238    int ret = EXIT_FAILURE;
239
240    f = fopen(ofname, "w");
241    if (f == NULL) {
242        ERRS("could not open \"%s\" for writing", ofname);
243        goto out;
244    }
245
246    errno = 0;
247    fwrite(data, len, 1, f);
248    if (errno) {
249        ERRS("unable to write output file");
250        goto out_flush;
251    }
252
253    DBG("firmware file \"%s\" completed", ofname);
254
255    ret = EXIT_SUCCESS;
256
257out_flush:
258    fflush(f);
259    fclose(f);
260    if (ret != EXIT_SUCCESS) {
261        unlink(ofname);
262    }
263out:
264    return ret;
265}
266
267static uint32_t get_csum(unsigned char *p, uint32_t len)
268{
269    uint32_t csum = 0;
270
271    while (len--)
272        csum += *p++;
273
274    return csum;
275}
276
277static int build_fw(void)
278{
279    int buflen;
280    char *buf;
281    char *p;
282    uint32_t csum;
283    struct img_header *hdr;
284    int ret = EXIT_FAILURE;
285
286    buflen = sizeof(struct img_header) +
287         kernel_info.write_size + rootfs_info.write_size;
288
289    buf = malloc(buflen);
290    if (!buf) {
291        ERR("no memory for buffer\n");
292        goto out;
293    }
294
295    memset(buf, 0, buflen);
296
297    p = buf + sizeof(struct img_header);
298
299    /* read kernel data */
300    ret = read_to_buf(&kernel_info, p);
301    if (ret)
302        goto out_free_buf;
303
304    p += kernel_info.write_size;
305
306    /* read rootfs data */
307    ret = read_to_buf(&rootfs_info, p);
308    if (ret)
309        goto out_free_buf;
310
311    csum = get_csum((unsigned char *)(buf + sizeof(struct img_header)),
312            buflen - sizeof(struct img_header));
313
314    /* fill firmware header */
315    hdr = (struct img_header *) buf;
316
317    hdr->checksum = htonl(csum);
318    hdr->image_size = htonl(buflen - sizeof(struct img_header));
319    hdr->kernel_size = htonl(kernel_info.write_size);
320    hdr->header_len = sizeof(struct img_header);
321    strncpy(hdr->model, model, sizeof(hdr->model));
322    strncpy(hdr->signature, signature, sizeof(hdr->signature));
323    strncpy(hdr->version, version, sizeof(hdr->version));
324    strncpy(hdr->region, region, sizeof(hdr->region));
325
326    ret = write_fw(buf, buflen);
327    if (ret)
328        goto out_free_buf;
329
330    ret = EXIT_SUCCESS;
331
332out_free_buf:
333    free(buf);
334out:
335    return ret;
336}
337
338int main(int argc, char *argv[])
339{
340    int ret = EXIT_FAILURE;
341
342    progname = basename(argv[0]);
343
344    while (1) {
345        int c;
346
347        c = getopt(argc, argv, "M:S:V:R:k:K:I:r:o:h");
348        if (c == -1)
349            break;
350
351        switch (c) {
352        case 'M':
353            model = optarg;
354            break;
355        case 'S':
356            signature = optarg;
357            break;
358        case 'V':
359            version = optarg;
360            break;
361        case 'R':
362            region = optarg;
363            break;
364        case 'k':
365            kernel_info.file_name = optarg;
366            break;
367        case 'K':
368            if (str2u32(optarg, &kernel_size)) {
369                ERR("%s is invalid '%s'",
370                    "kernel size", optarg);
371                goto out;
372            }
373            break;
374        case 'I':
375            if (str2u32(optarg, &image_size)) {
376                ERR("%s is invalid '%s'",
377                    "image size", optarg);
378                goto out;
379            }
380            break;
381        case 'r':
382            rootfs_info.file_name = optarg;
383            break;
384        case 'o':
385            ofname = optarg;
386            break;
387        case 'h':
388            usage(EXIT_SUCCESS);
389            break;
390        default:
391            usage(EXIT_FAILURE);
392            break;
393        }
394    }
395
396    ret = check_options();
397    if (ret)
398        goto out;
399
400    ret = build_fw();
401
402out:
403    return ret;
404}
405
406

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