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
  31 struct 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
  37 struct 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  */
  53 static char *ofname;
  54 static char *progname;
  55
  56 static char *model;
  57 static char *signature;
  58 static char *region = "DEF";
  59 static char *version;
  60 static struct file_info kernel_info;
  61 static struct file_info rootfs_info;
  62 static uint32_t kernel_size;
  63 static 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
  85 static 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
 108 int
 109 str2u32(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
 124 static 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
 143 static 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
 163 out_close:
 164         fclose(f);
 165 out:
 166         return ret;
 167 }
 168
 169 static 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
 235 static 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
 257 out_flush:
 258         fflush(f);
 259         fclose(f);
 260         if (ret != EXIT_SUCCESS) {
 261                 unlink(ofname);
 262         }
 263 out:
 264         return ret;
 265 }
 266
 267 static 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
 277 static 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
 332 out_free_buf:
 333         free(buf);
 334 out:
 335         return ret;
 336 }
 337
 338 int 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
 402 out:
 403         return ret;
 404 }
 405