tools/firmware-utils/src/trx.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2004  Manuel Novoa III  <mjn3@codepoet.org>
   4  */
   5
   6 /* July 29, 2004
   7  *
   8  * This is a hacked replacement for the 'trx' utility used to create
   9  * wrt54g .trx firmware files.  It isn't pretty, but it does the job
  10  * for me.
  11  *
  12  * As an extension, you can specify a larger maximum length for the
  13  * .trx file using '-m'.  It will be rounded up to be a multiple of 4K.
  14  * NOTE: This space will be malloc()'d.
  15  *
  16  * August 16, 2004
  17  *
  18  * Sigh... Make it endian-neutral.
  19  *
  20  * TODO: Support '-b' option to specify offsets for each file.
  21  *
  22  * February 19, 2005 - mbm
  23  *
  24  * Add -a (align offset) and -b (absolute offset)
  25  *
  26  * March 24, 2010 - markus
  27  *
  28  * extend trx header struct for new version
  29  * assume v1 for as default
  30  * Add option -2 to allow v2 header
  31  */
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <stddef.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <unistd.h>
  40
  41 #if __BYTE_ORDER == __BIG_ENDIAN
  42 #define STORE32_LE(X)           bswap_32(X)
  43 #define LOAD32_LE(X)            bswap_32(X)
  44 #elif __BYTE_ORDER == __LITTLE_ENDIAN
  45 #define STORE32_LE(X)           (X)
  46 #define LOAD32_LE(X)            (X)
  47 #else
  48 #error unkown endianness!
  49 #endif
  50
  51 uint32_t crc32buf(char *buf, size_t len);
  52
  53 /**********************************************************************/
  54 /* from trxhdr.h */
  55
  56 #define TRX_MAGIC       0x30524448      /* "HDR0" */
  57 #define TRX_MAX_LEN     0x720000
  58 #define TRX_NO_HEADER   1               /* Do not write TRX header */
  59
  60 struct trx_header {
  61         uint32_t magic;                 /* "HDR0" */
  62         uint32_t len;                   /* Length of file including header */
  63         uint32_t crc32;                 /* 32-bit CRC from flag_version to end of file */
  64         uint32_t flag_version;  /* 0:15 flags, 16:31 version */
  65         uint32_t offsets[4];    /* Offsets of partitions from start of header */
  66 };
  67
  68 /**********************************************************************/
  69
  70 void usage(void) __attribute__ (( __noreturn__ ));
  71
  72 void usage(void)
  73 {
  74         fprintf(stderr, "Usage:\n");
  75         fprintf(stderr, " trx [-2] [-o outfile] [-m maxlen] [-a align] [-b absolute offset] [-x relative offset]\n");
  76         fprintf(stderr, "     [-f file] [-f file [-f file [-f file (v2 only)]]]\n");
  77         exit(EXIT_FAILURE);
  78 }
  79
  80 int main(int argc, char **argv)
  81 {
  82         FILE *out = stdout;
  83         FILE *in;
  84         char *ofn = NULL;
  85         char *buf;
  86         char *e;
  87         int c, i, append = 0;
  88         size_t n;
  89         ssize_t n2;
  90         uint32_t cur_len, fsmark=0, magic;
  91         unsigned long maxlen = TRX_MAX_LEN;
  92         struct trx_header *p;
  93         char trx_version = 1;
  94         unsigned char binheader[32];
  95
  96         fprintf(stderr, "mjn3's trx replacement - v0.81.1\n");
  97
  98         if (!(buf = malloc(maxlen))) {
  99                 fprintf(stderr, "malloc failed\n");
 100                 return EXIT_FAILURE;
 101         }
 102
 103         p = (struct trx_header *) buf;
 104
 105         p->magic = STORE32_LE(TRX_MAGIC);
 106         cur_len = sizeof(struct trx_header) - 4; /* assume v1 header */
 107
 108         in = NULL;
 109         i = 0;
 110
 111         while ((c = getopt(argc, argv, "-:2o:m:a:x:b:f:A:F:M:")) != -1) {
 112                 switch (c) {
 113                         case '2':
 114                                 /* take care that nothing was written to buf so far */
 115                                 if (cur_len != sizeof(struct trx_header) - 4) {
 116                                         fprintf(stderr, "-2 has to be used before any other argument!\n");
 117                                 }
 118                                 else {
 119                                         trx_version = 2;
 120                                         cur_len += 4;
 121                                 }
 122                                 break;
 123                         case 'F':
 124                                 fsmark = cur_len;
 125                         case 'A':
 126                                 append = 1;
 127                                 /* fall through */
 128                         case 'f':
 129                         case 1:
 130                                 if (!append)
 131                                         p->offsets[i++] = STORE32_LE(cur_len);
 132
 133                                 if (!(in = fopen(optarg, "r"))) {
 134                                         fprintf(stderr, "can not open \"%s\" for reading\n", optarg);
 135                                         usage();
 136                                 }
 137                                 n = fread(buf + cur_len, 1, maxlen - cur_len, in);
 138                                 if (!feof(in)) {
 139                                         fprintf(stderr, "fread failure or file \"%s\" too large\n",optarg);
 140                                         fclose(in);
 141                                         return EXIT_FAILURE;
 142                                 }
 143                                 fclose(in);
 144 #undef  ROUND
 145 #define ROUND 4
 146                                 if (n & (ROUND-1)) {
 147                                         memset(buf + cur_len + n, 0, ROUND - (n & (ROUND-1)));
 148                                         n += ROUND - (n & (ROUND-1));
 149                                 }
 150                                 cur_len += n;
 151                                 append = 0;
 152
 153                                 break;
 154                         case 'o':
 155                                 ofn = optarg;
 156                                 if (ofn && !(out = fopen(ofn, "w"))) {
 157                                         fprintf(stderr, "can not open \"%s\" for writing\n", ofn);
 158                                         usage();
 159                                 }
 160
 161                                 break;
 162                         case 'm':
 163                                 errno = 0;
 164                                 maxlen = strtoul(optarg, &e, 0);
 165                                 if (errno || (e == optarg) || *e) {
 166                                         fprintf(stderr, "illegal numeric string\n");
 167                                         usage();
 168                                 }
 169 #undef  ROUND
 170 #define ROUND 0x1000
 171                                 if (maxlen & (ROUND-1)) {
 172                                         maxlen += (ROUND - (maxlen & (ROUND-1)));
 173                                 }
 174                                 if (maxlen < ROUND) {
 175                                         fprintf(stderr, "maxlen too small (or wrapped)\n");
 176                                         usage();
 177                                 }
 178                                 if (maxlen > TRX_MAX_LEN) {
 179                                         fprintf(stderr, "WARNING: maxlen exceeds default maximum!  Beware of overwriting nvram!\n");
 180                                 }
 181                                 if (!(buf = realloc(buf,maxlen))) {
 182                                         fprintf(stderr, "realloc failed");
 183                                         return EXIT_FAILURE;
 184                                 }
 185                                 p = (struct trx_header *) buf;
 186                                 break;
 187                         case 'a':
 188                                 errno = 0;
 189                                 n = strtoul(optarg, &e, 0);
 190                                 if (errno || (e == optarg) || *e) {
 191                                         fprintf(stderr, "illegal numeric string\n");
 192                                         usage();
 193                                 }
 194                                 if (cur_len & (n-1)) {
 195                                         n = n - (cur_len & (n-1));
 196                                         memset(buf + cur_len, 0, n);
 197                                         cur_len += n;
 198                                 }
 199                                 break;
 200                         case 'b':
 201                                 errno = 0;
 202                                 n = strtoul(optarg, &e, 0);
 203                                 if (errno || (e == optarg) || *e) {
 204                                         fprintf(stderr, "illegal numeric string\n");
 205                                         usage();
 206                                 }
 207                                 if (n < cur_len) {
 208                                         fprintf(stderr, "WARNING: current length exceeds -b %d offset\n",(int) n);
 209                                 } else {
 210                                         memset(buf + cur_len, 0, n - cur_len);
 211                                         cur_len = n;
 212                                 }
 213                                 break;
 214                         case 'x':
 215                                 errno = 0;
 216                                 n2 = strtol(optarg, &e, 0);
 217                                 if (errno || (e == optarg) || *e) {
 218                                         fprintf(stderr, "illegal numeric string\n");
 219                                         usage();
 220                                 }
 221                                 if (n2 < 0) {
 222                                         if (-n2 > cur_len) {
 223                                                 fprintf(stderr, "WARNING: current length smaller then -x %d offset\n",(int) n2);
 224                                                 cur_len = 0;
 225                                         } else
 226                                                 cur_len += n2;
 227                                 } else {
 228                                         memset(buf + cur_len, 0, n2);
 229                                         cur_len += n2;
 230                                 }
 231
 232                                 break;
 233                         case 'M':
 234                                 errno = 0;
 235                                 magic = strtoul(optarg, &e, 0);
 236                                 if (errno || (e == optarg) || *e) {
 237                                         fprintf(stderr, "illegal numeric string\n");
 238                                         usage();
 239                                 }
 240                                 p->magic = STORE32_LE(magic);
 241                                 break;
 242                         default:
 243                                 usage();
 244                 }
 245         }
 246         p->flag_version = STORE32_LE((trx_version << 16));
 247
 248         if (!in) {
 249                 fprintf(stderr, "we require atleast one filename\n");
 250                 usage();
 251         }
 252
 253 #undef  ROUND
 254 #define ROUND 0x1000
 255         n = cur_len & (ROUND-1);
 256         if (n) {
 257                 memset(buf + cur_len, 0, ROUND - n);
 258                 cur_len += ROUND - n;
 259         }
 260
 261         /* for TRXv2 set bin-header Flags to 0xFF for CRC calculation like CFE does */
 262         if (trx_version == 2) {
 263                 if(cur_len - LOAD32_LE(p->offsets[3]) < sizeof(binheader)) {
 264                         fprintf(stderr, "TRXv2 binheader too small!\n");
 265                         return EXIT_FAILURE;
 266                 }
 267                 memcpy(binheader, buf + LOAD32_LE(p->offsets[3]), sizeof(binheader)); /* save header */
 268                 memset(buf + LOAD32_LE(p->offsets[3]) + 22, 0xFF, 8); /* set stable and try1-3 to 0xFF */
 269         }
 270
 271         p->crc32 = crc32buf((char *) &p->flag_version,
 272                                                 ((fsmark)?fsmark:cur_len) - offsetof(struct trx_header, flag_version));
 273         p->crc32 = STORE32_LE(p->crc32);
 274
 275         p->len = STORE32_LE((fsmark) ? fsmark : cur_len);
 276
 277         /* restore TRXv2 bin-header */
 278         if (trx_version == 2) {
 279                 memcpy(buf + LOAD32_LE(p->offsets[3]), binheader, sizeof(binheader));
 280         }
 281
 282         if (!fwrite(buf, cur_len, 1, out) || fflush(out)) {
 283                 fprintf(stderr, "fwrite failed\n");
 284                 return EXIT_FAILURE;
 285         }
 286
 287         fclose(out);
 288
 289         return EXIT_SUCCESS;
 290 }
 291
 292 /**********************************************************************/
 293 /* The following was grabbed and tweaked from the old snippets collection
 294  * of public domain C code. */
 295
 296 /**********************************************************************\
 297 |* Demonstration program to compute the 32-bit CRC used as the frame  *|
 298 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71     *|
 299 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level     *|
 300 |* protocol).  The 32-bit FCS was added via the Federal Register,     *|
 301 |* 1 June 1982, p.23798.  I presume but don't know for certain that   *|
 302 |* this polynomial is or will be included in CCITT V.41, which        *|
 303 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial.  FIPS  *|
 304 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected       *|
 305 |* errors by a factor of 10^-5 over 16-bit FCS.                       *|
 306 \**********************************************************************/
 307
 308 /* Copyright (C) 1986 Gary S. Brown.  You may use this program, or
 309    code or tables extracted from it, as desired without restriction.*/
 310
 311 /* First, the polynomial itself and its table of feedback terms.  The  */
 312 /* polynomial is                                                       */
 313 /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
 314 /* Note that we take it "backwards" and put the highest-order term in  */
 315 /* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   */
 316 /* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    */
 317 /* the MSB being 1.                                                    */
 318
 319 /* Note that the usual hardware shift register implementation, which   */
 320 /* is what we're using (we're merely optimizing it by doing eight-bit  */
 321 /* chunks at a time) shifts bits into the lowest-order term.  In our   */
 322 /* implementation, that means shifting towards the right.  Why do we   */
 323 /* do it this way?  Because the calculated CRC must be transmitted in  */
 324 /* order from highest-order term to lowest-order term.  UARTs transmit */
 325 /* characters in order from LSB to MSB.  By storing the CRC this way,  */
 326 /* we hand it to the UART in the order low-byte to high-byte; the UART */
 327 /* sends each low-bit to hight-bit; and the result is transmission bit */
 328 /* by bit from highest- to lowest-order term without requiring any bit */
 329 /* shuffling on our part.  Reception works similarly.                  */
 330
 331 /* The feedback terms table consists of 256, 32-bit entries.  Notes:   */
 332 /*                                                                     */
 333 /*  1. The table can be generated at runtime if desired; code to do so */
 334 /*     is shown later.  It might not be obvious, but the feedback      */
 335 /*     terms simply represent the results of eight shift/xor opera-    */
 336 /*     tions for all combinations of data and CRC register values.     */
 337 /*                                                                     */
 338 /*  2. The CRC accumulation logic is the same for all CRC polynomials, */
 339 /*     be they sixteen or thirty-two bits wide.  You simply choose the */
 340 /*     appropriate table.  Alternatively, because the table can be     */
 341 /*     generated at runtime, you can start by generating the table for */
 342 /*     the polynomial in question and use exactly the same "updcrc",   */
 343 /*     if your application needn't simultaneously handle two CRC       */
 344 /*     polynomials.  (Note, however, that XMODEM is strange.)          */
 345 /*                                                                     */
 346 /*  3. For 16-bit CRCs, the table entries need be only 16 bits wide;   */
 347 /*     of course, 32-bit entries work OK if the high 16 bits are zero. */
 348 /*                                                                     */
 349 /*  4. The values must be right-shifted by eight bits by the "updcrc"  */
 350 /*     logic; the shift must be unsigned (bring in zeroes).  On some   */
 351 /*     hardware you could probably optimize the shift in assembler by  */
 352 /*     using byte-swap instructions.                                   */
 353
 354 static const uint32_t crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
 355 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
 356 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
 357 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
 358 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
 359 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 360 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
 361 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
 362 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
 363 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
 364 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 365 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
 366 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
 367 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
 368 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
 369 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 370 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
 371 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
 372 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
 373 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
 374 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 375 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
 376 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
 377 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
 378 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
 379 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 380 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 381 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
 382 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 383 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
 384 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 385 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
 386 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 387 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
 388 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 389 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 390 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 391 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
 392 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 393 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
 394 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 395 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
 396 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 397 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 398 };
 399
 400 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
 401
 402 uint32_t crc32buf(char *buf, size_t len)
 403 {
 404       uint32_t crc;
 405
 406       crc = 0xFFFFFFFF;
 407
 408       for ( ; len; --len, ++buf)
 409       {
 410             crc = UPDC32(*buf, crc);
 411       }
 412
 413       return crc;
 414 }