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