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
  26 static char *region_table[] = {
  27         "JP", "US", "EU", "AP", "TW", "KR"
  28 };
  29
  30 #define MAX_INPUT_FILES 2
  31
  32 static char *progname;
  33 static char *ifname[MAX_INPUT_FILES];
  34 static ssize_t fsize[MAX_INPUT_FILES];
  35 static int num_files;
  36 static char *ofname;
  37 static char *product;
  38 static char *brand;
  39 static char *language;
  40 static char *hwver;
  41 static char *platform;
  42 static int flag;
  43 static char *major;
  44 static char *minor = "1.01";
  45 static int skipcrc;
  46 static uint32_t base1;
  47 static uint32_t base2;
  48 static char *region_code;
  49 static uint32_t region_mask;
  50 static int num_regions;
  51 static int dhp;
  52
  53 void usage(int status)
  54 {
  55         FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
  56
  57         fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
  58         fprintf(stream,
  59 "\n"
  60 "Options:\n"
  61 "  -a <platform>   set platform to <platform>\n"
  62 "  -b <brand>      set brand to <brand>\n"
  63 "  -c <base1>\n"
  64 "  -d <base2>\n"
  65 "  -f <flag>       set flag to <flag>\n"
  66 "  -i <file>       read input from the file <file>\n"
  67 "  -I <file>       read input from the file <file> for DHP series\n"
  68 "  -l <language>   set language to <language>\n"
  69 "  -m <version>    set minor version to <version>\n"
  70 "  -o <file>       write output to the file <file>\n"
  71 "  -p <product>    set product to <product>\n"
  72 "  -r <region>     set image region to <region>\n"
  73 "                  valid regions: JP, US, EU, AP, TW, KR, M_\n"
  74 "  -s              skip CRC calculation\n"
  75 "  -v <version>    set major version to <version>\n"
  76 "  -w <version>    set harwdware version to <version>\n"
  77 "  -h              show this screen\n"
  78         );
  79
  80         exit(status);
  81 }
  82
  83 static int check_params(void)
  84 {
  85
  86 #define CHECKSTR(_var, _name, _len)     do {            \
  87         if ((_var) == NULL) {                           \
  88                 ERR("no %s specified", (_name));        \
  89                 return -1;                              \
  90         }                                               \
  91         if ((_len) > 0 &&                               \
  92             strlen((_var)) > ((_len) - 1)) {            \
  93                 ERR("%s is too long", (_name));         \
  94                 return -1;                              \
  95         }                                               \
  96 } while (0)
  97
  98         if (num_files == 0)
  99                 ERR("no input files specified");
 100
 101         CHECKSTR(ofname, "output file", 0);
 102         CHECKSTR(brand, "brand", TAG_BRAND_LEN);
 103         CHECKSTR(product, "product", TAG_PRODUCT_LEN);
 104         CHECKSTR(platform, "platform", TAG_PLATFORM_LEN);
 105         CHECKSTR(major, "major version", TAG_VERSION_LEN);
 106         CHECKSTR(minor, "minor version", TAG_VERSION_LEN);
 107         CHECKSTR(language, "language", TAG_LANGUAGE_LEN);
 108
 109         if (hwver)
 110                 CHECKSTR(hwver, "hardware version", 2);
 111
 112         if (num_regions == 0) {
 113                 ERR("no region code specified");
 114                 return -1;
 115         }
 116
 117         return 0;
 118
 119 #undef CHECKSTR
 120 }
 121
 122 static int process_region(char *reg)
 123 {
 124         int i;
 125
 126         if (strlen(reg) != 2) {
 127                 ERR("invalid region code '%s'", reg);
 128                 return -1;
 129         }
 130
 131         if (strcmp(reg, "M_") == 0) {
 132                 region_code = reg;
 133                 region_mask |= ~0;
 134                 num_regions = 32;
 135                 return 0;
 136         }
 137
 138         for (i = 0; i < ARRAY_SIZE(region_table); i++)
 139                 if (strcmp(reg, region_table[i]) == 0) {
 140                         region_code = reg;
 141                         region_mask |= 1 << i;
 142                         num_regions++;
 143                         return 0;
 144                 }
 145
 146         ERR("unknown region code '%s'", reg);
 147         return -1;
 148 }
 149
 150 static int process_ifname(char *name)
 151 {
 152         if (num_files >= ARRAY_SIZE(ifname)) {
 153                 ERR("too many input files specified");
 154                 return -1;
 155         }
 156
 157         ifname[num_files++] = name;
 158         return 0;
 159 }
 160
 161 static void fixup_tag(unsigned char *buf, ssize_t buflen)
 162 {
 163         struct buffalo_tag *tag = (struct buffalo_tag *) buf;
 164
 165         memset(tag, '\0', sizeof(*tag));
 166
 167         memcpy(tag->brand, brand, strlen(brand));
 168         memcpy(tag->product, product, strlen(product));
 169         memcpy(tag->platform, platform, strlen(platform));
 170         memcpy(tag->ver_major, major, strlen(major));
 171         memcpy(tag->ver_minor, minor, strlen(minor));
 172         memcpy(tag->language, language, strlen(language));
 173
 174         if (num_regions > 1) {
 175                 tag->region_code[0] = 'M';
 176                 tag->region_code[1] = '_';
 177                 tag->region_mask = htonl(region_mask);
 178         } else {
 179                 memcpy(tag->region_code, region_code, 2);
 180         }
 181
 182         tag->len = htonl(buflen);
 183         tag->data_len = htonl(fsize[0]);
 184         tag->base1 = htonl(base1);
 185         tag->base2 = htonl(base2);
 186         tag->flag = flag;
 187
 188         if (hwver) {
 189                 memcpy(tag->hwv, "hwv", 3);
 190                 memcpy(tag->hwv_val, hwver, strlen(hwver));
 191         }
 192
 193         if (!skipcrc)
 194                 tag->crc = htonl(buffalo_crc(buf, buflen));
 195 }
 196
 197 static void fixup_tag2(unsigned char *buf, ssize_t buflen)
 198 {
 199         struct buffalo_tag2 *tag = (struct buffalo_tag2 *) buf;
 200
 201         memset(tag, '\0', sizeof(*tag));
 202
 203         memcpy(tag->brand, brand, strlen(brand));
 204         memcpy(tag->product, product, strlen(product));
 205         memcpy(tag->platform, platform, strlen(platform));
 206         memcpy(tag->ver_major, major, strlen(major));
 207         memcpy(tag->ver_minor, minor, strlen(minor));
 208         memcpy(tag->language, language, strlen(language));
 209
 210         if (num_regions > 1) {
 211                 tag->region_code[0] = 'M';
 212                 tag->region_code[1] = '_';
 213                 tag->region_mask = htonl(region_mask);
 214         } else {
 215                 memcpy(tag->region_code, region_code, 2);
 216         }
 217
 218         tag->total_len = htonl(buflen);
 219         tag->len1 = htonl(fsize[0]);
 220         tag->len2 = htonl(fsize[1]);
 221         tag->flag = flag;
 222
 223         if (hwver) {
 224                 memcpy(tag->hwv, "hwv", 3);
 225                 memcpy(tag->hwv_val, hwver, strlen(hwver));
 226         }
 227
 228         if (!skipcrc)
 229                 tag->crc = htonl(buffalo_crc(buf, buflen));
 230 }
 231
 232 static void fixup_tag3(unsigned char *buf, ssize_t totlen)
 233 {
 234         struct buffalo_tag3 *tag = (struct buffalo_tag3 *) buf;
 235
 236         memset(tag, '\0', sizeof(*tag));
 237
 238         memcpy(tag->brand, brand, strlen(brand));
 239         memcpy(tag->product, product, strlen(product));
 240         memcpy(tag->platform, platform, strlen(platform));
 241         memcpy(tag->ver_major, major, strlen(major));
 242         memcpy(tag->ver_minor, minor, strlen(minor));
 243         memcpy(tag->language, language, strlen(language));
 244
 245         if (num_regions > 1) {
 246                 tag->region_code[0] = 'M';
 247                 tag->region_code[1] = '_';
 248                 tag->region_mask = htonl(region_mask);
 249         } else {
 250                 memcpy(tag->region_code, region_code, 2);
 251         }
 252
 253         tag->total_len = htonl(totlen);
 254         tag->len1 = htonl(fsize[0]);
 255         tag->base2 = htonl(base2);
 256
 257         if (hwver) {
 258                 memcpy(tag->hwv, "hwv", 3);
 259                 memcpy(tag->hwv_val, hwver, strlen(hwver));
 260         }
 261 }
 262
 263 static int tag_file(void)
 264 {
 265         unsigned char *buf;
 266         ssize_t offset;
 267         ssize_t hdrlen;
 268         ssize_t buflen;
 269         int err;
 270         int ret = -1;
 271         int i;
 272
 273         if (dhp)
 274                 hdrlen = sizeof(struct buffalo_tag3);
 275         else if (num_files == 1)
 276                 hdrlen = sizeof(struct buffalo_tag);
 277         else
 278                 hdrlen = sizeof(struct buffalo_tag2);
 279
 280         buflen = hdrlen;
 281
 282         for (i = 0; i < num_files; i++) {
 283                 fsize[i] = get_file_size(ifname[i]);
 284                 if (fsize[i] < 0) {
 285                         ERR("unable to get size of '%s'", ifname[i]);
 286                         goto out;
 287                 }
 288                 buflen += fsize[i];
 289         }
 290
 291         buf = malloc(buflen);
 292         if (!buf) {
 293                 ERR("no memory for buffer\n");
 294                 goto out;
 295         }
 296
 297         offset = hdrlen;
 298         for (i = 0; i < num_files; i++) {
 299                 err = read_file_to_buf(ifname[i], buf + offset, fsize[i]);
 300                 if (err) {
 301                         ERR("unable to read from file '%s'", ifname[i]);
 302                         goto free_buf;
 303                 }
 304
 305                 offset += fsize[i];
 306         }
 307
 308         if (dhp)
 309                 fixup_tag3(buf, fsize[0] + 200);
 310         else if (num_files == 1)
 311                 fixup_tag(buf, buflen);
 312         else
 313                 fixup_tag2(buf, buflen);
 314
 315         err = write_buf_to_file(ofname, buf, buflen);
 316         if (err) {
 317                 ERR("unable to write to file '%s'", ofname);
 318                 goto free_buf;
 319         }
 320
 321         ret = 0;
 322
 323 free_buf:
 324         free(buf);
 325 out:
 326         return ret;
 327 }
 328
 329 int main(int argc, char *argv[])
 330 {
 331         int res = EXIT_FAILURE;
 332         int err;
 333
 334         progname = basename(argv[0]);
 335
 336         while ( 1 ) {
 337                 int c;
 338
 339                 c = getopt(argc, argv, "a:b:c:d:f:hi:l:m:o:p:r:sv:w:I:");
 340                 if (c == -1)
 341                         break;
 342
 343                 switch (c) {
 344                 case 'a':
 345                         platform = optarg;
 346                         break;
 347                 case 'b':
 348                         brand = optarg;
 349                         break;
 350                 case 'c':
 351                         base1 = strtoul(optarg, NULL, 16);
 352                         break;
 353                 case 'd':
 354                         base2 = strtoul(optarg, NULL, 16);
 355                         break;
 356                 case 'f':
 357                         flag = strtoul(optarg, NULL, 2);
 358                         break;
 359                 case 'I':
 360                         dhp = 1;
 361                         /* FALLTHROUGH */
 362                 case 'i':
 363                         err = process_ifname(optarg);
 364                         if (err)
 365                                 goto out;
 366                         break;
 367                 case 'l':
 368                         language = optarg;
 369                         break;
 370                 case 'm':
 371                         minor = optarg;
 372                         break;
 373                 case 'o':
 374                         ofname = optarg;
 375                         break;
 376                 case 'p':
 377                         product = optarg;
 378                         break;
 379                 case 'r':
 380                         err = process_region(optarg);
 381                         if (err)
 382                                 goto out;
 383                         break;
 384                 case 's':
 385                         skipcrc = 1;
 386                         break;
 387                 case 'v':
 388                         major = optarg;
 389                         break;
 390                 case 'w':
 391                         hwver = optarg;
 392                         break;
 393                 case 'h':
 394                         usage(EXIT_SUCCESS);
 395                         break;
 396                 default:
 397                         usage(EXIT_FAILURE);
 398                         break;
 399                 }
 400         }
 401
 402         err = check_params();
 403         if (err)
 404                 goto out;
 405
 406         err = tag_file();
 407         if (err)
 408                 goto out;
 409
 410         res = EXIT_SUCCESS;
 411
 412 out:
 413         return res;
 414 }