tools/firmware-utils/src/otrx.c

   1 /*
   2  * otrx
   3  *
   4  * Copyright (C) 2015-2017 Rafał Miłecki <zajec5@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  */
  11
  12 #include <byteswap.h>
  13 #include <endian.h>
  14 #include <errno.h>
  15 #include <stdint.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <unistd.h>
  20
  21 #if !defined(__BYTE_ORDER)
  22 #error "Unknown byte order"
  23 #endif
  24
  25 #if __BYTE_ORDER == __BIG_ENDIAN
  26 #define cpu_to_le32(x)  bswap_32(x)
  27 #define le32_to_cpu(x)  bswap_32(x)
  28 #elif __BYTE_ORDER == __LITTLE_ENDIAN
  29 #define cpu_to_le32(x)  (x)
  30 #define le32_to_cpu(x)  (x)
  31 #else
  32 #error "Unsupported endianness"
  33 #endif
  34
  35 #define TRX_MAGIC                       0x30524448
  36 #define TRX_FLAGS_OFFSET                12
  37 #define TRX_MAX_PARTS                   3
  38
  39 struct trx_header {
  40         uint32_t magic;
  41         uint32_t length;
  42         uint32_t crc32;
  43         uint16_t flags;
  44         uint16_t version;
  45         uint32_t offset[3];
  46 };
  47
  48 char *trx_path;
  49 size_t trx_offset = 0;
  50 char *partition[TRX_MAX_PARTS] = {};
  51
  52 static inline size_t otrx_min(size_t x, size_t y) {
  53         return x < y ? x : y;
  54 }
  55
  56 /**************************************************
  57  * CRC32
  58  **************************************************/
  59
  60 static const uint32_t crc32_tbl[] = {
  61         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
  62         0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
  63         0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
  64         0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
  65         0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
  66         0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
  67         0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
  68         0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
  69         0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
  70         0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
  71         0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
  72         0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
  73         0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
  74         0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
  75         0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
  76         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
  77         0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
  78         0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
  79         0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
  80         0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
  81         0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
  82         0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
  83         0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
  84         0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
  85         0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
  86         0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
  87         0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
  88         0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
  89         0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
  90         0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
  91         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
  92         0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
  93         0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
  94         0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
  95         0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
  96         0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
  97         0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
  98         0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
  99         0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 100         0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 101         0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
 102         0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 103         0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
 104         0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
 105         0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 106         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
 107         0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
 108         0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 109         0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
 110         0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 111         0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 112         0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
 113         0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
 114         0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 115         0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 116         0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
 117         0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 118         0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
 119         0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
 120         0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 121         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
 122         0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
 123         0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 124         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 125 };
 126
 127 uint32_t otrx_crc32(uint32_t crc, uint8_t *buf, size_t len) {
 128         while (len) {
 129                 crc = crc32_tbl[(crc ^ *buf) & 0xff] ^ (crc >> 8);
 130                 buf++;
 131                 len--;
 132         }
 133
 134         return crc;
 135 }
 136
 137 /**************************************************
 138  * Check
 139  **************************************************/
 140
 141 static void otrx_check_parse_options(int argc, char **argv) {
 142         int c;
 143
 144         while ((c = getopt(argc, argv, "o:")) != -1) {
 145                 switch (c) {
 146                 case 'o':
 147                         trx_offset = atoi(optarg);
 148                         break;
 149                 }
 150         }
 151 }
 152
 153 static int otrx_check(int argc, char **argv) {
 154         FILE *trx;
 155         struct trx_header hdr;
 156         size_t bytes, length;
 157         uint8_t buf[1024];
 158         uint32_t crc32;
 159         int err = 0;
 160
 161         if (argc < 3) {
 162                 fprintf(stderr, "No TRX file passed\n");
 163                 err = -EINVAL;
 164                 goto out;
 165         }
 166         trx_path = argv[2];
 167
 168         optind = 3;
 169         otrx_check_parse_options(argc, argv);
 170
 171         trx = fopen(trx_path, "r");
 172         if (!trx) {
 173                 fprintf(stderr, "Couldn't open %s\n", trx_path);
 174                 err = -EACCES;
 175                 goto out;
 176         }
 177
 178         fseek(trx, trx_offset, SEEK_SET);
 179         bytes = fread(&hdr, 1, sizeof(hdr), trx);
 180         if (bytes != sizeof(hdr)) {
 181                 fprintf(stderr, "Couldn't read %s header\n", trx_path);
 182                 err =  -EIO;
 183                 goto err_close;
 184         }
 185
 186         if (le32_to_cpu(hdr.magic) != TRX_MAGIC) {
 187                 fprintf(stderr, "Invalid TRX magic: 0x%08x\n", le32_to_cpu(hdr.magic));
 188                 err =  -EINVAL;
 189                 goto err_close;
 190         }
 191
 192         length = le32_to_cpu(hdr.length);
 193         if (length < sizeof(hdr)) {
 194                 fprintf(stderr, "Length read from TRX too low (%zu B)\n", length);
 195                 err = -EINVAL;
 196                 goto err_close;
 197         }
 198
 199         crc32 = 0xffffffff;
 200         fseek(trx, trx_offset + TRX_FLAGS_OFFSET, SEEK_SET);
 201         length -= TRX_FLAGS_OFFSET;
 202         while ((bytes = fread(buf, 1, otrx_min(sizeof(buf), length), trx)) > 0) {
 203                 crc32 = otrx_crc32(crc32, buf, bytes);
 204                 length -= bytes;
 205         }
 206
 207         if (length) {
 208                 fprintf(stderr, "Couldn't read last %zd B of data from %s\n", length, trx_path);
 209                 err = -EIO;
 210                 goto err_close;
 211         }
 212
 213         if (crc32 != le32_to_cpu(hdr.crc32)) {
 214                 fprintf(stderr, "Invalid data crc32: 0x%08x instead of 0x%08x\n", crc32, le32_to_cpu(hdr.crc32));
 215                 err =  -EINVAL;
 216                 goto err_close;
 217         }
 218
 219         printf("Found a valid TRX version %d\n", le32_to_cpu(hdr.version));
 220
 221 err_close:
 222         fclose(trx);
 223 out:
 224         return err;
 225 }
 226
 227 /**************************************************
 228  * Create
 229  **************************************************/
 230
 231 static ssize_t otrx_create_append_file(FILE *trx, const char *in_path) {
 232         FILE *in;
 233         size_t bytes;
 234         ssize_t length = 0;
 235         uint8_t buf[1024];
 236
 237         in = fopen(in_path, "r");
 238         if (!in) {
 239                 fprintf(stderr, "Couldn't open %s\n", in_path);
 240                 return -EACCES;
 241         }
 242
 243         while ((bytes = fread(buf, 1, sizeof(buf), in)) > 0) {
 244                 if (fwrite(buf, 1, bytes, trx) != bytes) {
 245                         fprintf(stderr, "Couldn't write %zu B to %s\n", bytes, trx_path);
 246                         length = -EIO;
 247                         break;
 248                 }
 249                 length += bytes;
 250         }
 251
 252         fclose(in);
 253
 254         return length;
 255 }
 256
 257 static ssize_t otrx_create_append_zeros(FILE *trx, size_t length) {
 258         uint8_t *buf;
 259
 260         buf = malloc(length);
 261         if (!buf)
 262                 return -ENOMEM;
 263         memset(buf, 0, length);
 264
 265         if (fwrite(buf, 1, length, trx) != length) {
 266                 fprintf(stderr, "Couldn't write %zu B to %s\n", length, trx_path);
 267                 free(buf);
 268                 return -EIO;
 269         }
 270
 271         free(buf);
 272
 273         return length;
 274 }
 275
 276 static ssize_t otrx_create_align(FILE *trx, size_t curr_offset, size_t alignment) {
 277         if (curr_offset & (alignment - 1)) {
 278                 size_t length = alignment - (curr_offset % alignment);
 279                 return otrx_create_append_zeros(trx, length);
 280         }
 281
 282         return 0;
 283 }
 284
 285 static int otrx_create_write_hdr(FILE *trx, struct trx_header *hdr) {
 286         size_t bytes, length;
 287         uint8_t buf[1024];
 288         uint32_t crc32;
 289
 290         hdr->magic = cpu_to_le32(TRX_MAGIC);
 291         hdr->version = 1;
 292
 293         fseek(trx, 0, SEEK_SET);
 294         bytes = fwrite(hdr, 1, sizeof(struct trx_header), trx);
 295         if (bytes != sizeof(struct trx_header)) {
 296                 fprintf(stderr, "Couldn't write TRX header to %s\n", trx_path);
 297                 return -EIO;
 298         }
 299
 300         length = le32_to_cpu(hdr->length);
 301
 302         crc32 = 0xffffffff;
 303         fseek(trx, TRX_FLAGS_OFFSET, SEEK_SET);
 304         length -= TRX_FLAGS_OFFSET;
 305         while ((bytes = fread(buf, 1, otrx_min(sizeof(buf), length), trx)) > 0) {
 306                 crc32 = otrx_crc32(crc32, buf, bytes);
 307                 length -= bytes;
 308         }
 309         hdr->crc32 = cpu_to_le32(crc32);
 310
 311         fseek(trx, 0, SEEK_SET);
 312         bytes = fwrite(hdr, 1, sizeof(struct trx_header), trx);
 313         if (bytes != sizeof(struct trx_header)) {
 314                 fprintf(stderr, "Couldn't write TRX header to %s\n", trx_path);
 315                 return -EIO;
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int otrx_create(int argc, char **argv) {
 322         FILE *trx;
 323         struct trx_header hdr = {};
 324         ssize_t sbytes;
 325         size_t curr_idx = 0;
 326         size_t curr_offset = sizeof(hdr);
 327         int c;
 328         int err = 0;
 329
 330         if (argc < 3) {
 331                 fprintf(stderr, "No TRX file passed\n");
 332                 err = -EINVAL;
 333                 goto out;
 334         }
 335         trx_path = argv[2];
 336
 337         trx = fopen(trx_path, "w+");
 338         if (!trx) {
 339                 fprintf(stderr, "Couldn't open %s\n", trx_path);
 340                 err = -EACCES;
 341                 goto out;
 342         }
 343         fseek(trx, curr_offset, SEEK_SET);
 344
 345         optind = 3;
 346         while ((c = getopt(argc, argv, "f:A:a:b:")) != -1) {
 347                 switch (c) {
 348                 case 'f':
 349                         if (curr_idx >= TRX_MAX_PARTS) {
 350                                 err = -ENOSPC;
 351                                 fprintf(stderr, "Reached TRX partitions limit, no place for %s\n", optarg);
 352                                 goto err_close;
 353                         }
 354
 355                         sbytes = otrx_create_append_file(trx, optarg);
 356                         if (sbytes < 0) {
 357                                 fprintf(stderr, "Failed to append file %s\n", optarg);
 358                         } else {
 359                                 hdr.offset[curr_idx++] = curr_offset;
 360                                 curr_offset += sbytes;
 361                         }
 362
 363                         sbytes = otrx_create_align(trx, curr_offset, 4);
 364                         if (sbytes < 0)
 365                                 fprintf(stderr, "Failed to append zeros\n");
 366                         else
 367                                 curr_offset += sbytes;
 368
 369                         break;
 370                 case 'A':
 371                         sbytes = otrx_create_append_file(trx, optarg);
 372                         if (sbytes < 0) {
 373                                 fprintf(stderr, "Failed to append file %s\n", optarg);
 374                         } else {
 375                                 curr_offset += sbytes;
 376                         }
 377
 378                         sbytes = otrx_create_align(trx, curr_offset, 4);
 379                         if (sbytes < 0)
 380                                 fprintf(stderr, "Failed to append zeros\n");
 381                         else
 382                                 curr_offset += sbytes;
 383                         break;
 384                 case 'a':
 385                         sbytes = otrx_create_align(trx, curr_offset, strtol(optarg, NULL, 0));
 386                         if (sbytes < 0)
 387                                 fprintf(stderr, "Failed to append zeros\n");
 388                         else
 389                                 curr_offset += sbytes;
 390                         break;
 391                 case 'b':
 392                         sbytes = strtol(optarg, NULL, 0) - curr_offset;
 393                         if (sbytes < 0) {
 394                                 fprintf(stderr, "Current TRX length is 0x%zx, can't pad it with zeros to 0x%lx\n", curr_offset, strtol(optarg, NULL, 0));
 395                         } else {
 396                                 sbytes = otrx_create_append_zeros(trx, sbytes);
 397                                 if (sbytes < 0)
 398                                         fprintf(stderr, "Failed to append zeros\n");
 399                                 else
 400                                         curr_offset += sbytes;
 401                         }
 402                         break;
 403                 }
 404                 if (err)
 405                         break;
 406         }
 407
 408         sbytes = otrx_create_align(trx, curr_offset, 0x1000);
 409         if (sbytes < 0)
 410                 fprintf(stderr, "Failed to append zeros\n");
 411         else
 412                 curr_offset += sbytes;
 413
 414         hdr.length = curr_offset;
 415         otrx_create_write_hdr(trx, &hdr);
 416 err_close:
 417         fclose(trx);
 418 out:
 419         return err;
 420 }
 421
 422 /**************************************************
 423  * Extract
 424  **************************************************/
 425
 426 static void otrx_extract_parse_options(int argc, char **argv) {
 427         int c;
 428
 429         while ((c = getopt(argc, argv, "c:e:o:1:2:3:")) != -1) {
 430                 switch (c) {
 431                 case 'o':
 432                         trx_offset = atoi(optarg);
 433                         break;
 434                 case '1':
 435                         partition[0] = optarg;
 436                         break;
 437                 case '2':
 438                         partition[1] = optarg;
 439                         break;
 440                 case '3':
 441                         partition[2] = optarg;
 442                         break;
 443                 }
 444         }
 445 }
 446
 447 static int otrx_extract_copy(FILE *trx, size_t offset, size_t length, char *out_path) {
 448         FILE *out;
 449         size_t bytes;
 450         uint8_t *buf;
 451         int err = 0;
 452
 453         out = fopen(out_path, "w");
 454         if (!out) {
 455                 fprintf(stderr, "Couldn't open %s\n", out_path);
 456                 err = -EACCES;
 457                 goto out;
 458         }
 459
 460         buf = malloc(length);
 461         if (!buf) {
 462                 fprintf(stderr, "Couldn't alloc %zu B buffer\n", length);
 463                 err =  -ENOMEM;
 464                 goto err_close;
 465         }
 466
 467         fseek(trx, offset, SEEK_SET);
 468         bytes = fread(buf, 1, length, trx);
 469         if (bytes != length) {
 470                 fprintf(stderr, "Couldn't read %zu B of data from %s\n", length, trx_path);
 471                 err =  -ENOMEM;
 472                 goto err_free_buf;
 473         };
 474
 475         bytes = fwrite(buf, 1, length, out);
 476         if (bytes != length) {
 477                 fprintf(stderr, "Couldn't write %zu B to %s\n", length, out_path);
 478                 err =  -ENOMEM;
 479                 goto err_free_buf;
 480         }
 481
 482         printf("Extracted 0x%zx bytes into %s\n", length, out_path);
 483
 484 err_free_buf:
 485         free(buf);
 486 err_close:
 487         fclose(out);
 488 out:
 489         return err;
 490 }
 491
 492 static int otrx_extract(int argc, char **argv) {
 493         FILE *trx;
 494         struct trx_header hdr;
 495         size_t bytes;
 496         int i;
 497         int err = 0;
 498
 499         if (argc < 3) {
 500                 fprintf(stderr, "No TRX file passed\n");
 501                 err = -EINVAL;
 502                 goto out;
 503         }
 504         trx_path = argv[2];
 505
 506         optind = 3;
 507         otrx_extract_parse_options(argc, argv);
 508
 509         trx = fopen(trx_path, "r");
 510         if (!trx) {
 511                 fprintf(stderr, "Couldn't open %s\n", trx_path);
 512                 err = -EACCES;
 513                 goto out;
 514         }
 515
 516         fseek(trx, trx_offset, SEEK_SET);
 517         bytes = fread(&hdr, 1, sizeof(hdr), trx);
 518         if (bytes != sizeof(hdr)) {
 519                 fprintf(stderr, "Couldn't read %s header\n", trx_path);
 520                 err =  -EIO;
 521                 goto err_close;
 522         }
 523
 524         if (le32_to_cpu(hdr.magic) != TRX_MAGIC) {
 525                 fprintf(stderr, "Invalid TRX magic: 0x%08x\n", le32_to_cpu(hdr.magic));
 526                 err =  -EINVAL;
 527                 goto err_close;
 528         }
 529
 530         for (i = 0; i < TRX_MAX_PARTS; i++) {
 531                 size_t length;
 532
 533                 if (!partition[i])
 534                         continue;
 535                 if (!hdr.offset[i]) {
 536                         printf("TRX doesn't contain partition %d, can't extract %s\n", i + 1, partition[i]);
 537                         continue;
 538                 }
 539
 540                 if (i + 1 >= TRX_MAX_PARTS || !hdr.offset[i + 1])
 541                         length = le32_to_cpu(hdr.length) - le32_to_cpu(hdr.offset[i]);
 542                 else
 543                         length = le32_to_cpu(hdr.offset[i + 1]) - le32_to_cpu(hdr.offset[i]);
 544
 545                 otrx_extract_copy(trx, trx_offset + le32_to_cpu(hdr.offset[i]), length, partition[i]);
 546         }
 547
 548 err_close:
 549         fclose(trx);
 550 out:
 551         return err;
 552 }
 553
 554 /**************************************************
 555  * Start
 556  **************************************************/
 557
 558 static void usage() {
 559         printf("Usage:\n");
 560         printf("\n");
 561         printf("Checking TRX file:\n");
 562         printf("\totrx check <file> [options]\tcheck if file is a valid TRX\n");
 563         printf("\t-o offset\t\t\toffset of TRX data in file (default: 0)\n");
 564         printf("\n");
 565         printf("Creating new TRX file:\n");
 566         printf("\totrx create <file> [options] [partitions]\n");
 567         printf("\t-f file\t\t\t\t[partition] start new partition with content copied from file\n");
 568         printf("\t-A file\t\t\t\t[partition] append current partition with content copied from file\n");
 569         printf("\t-a alignment\t\t\t[partition] align current partition\n");
 570         printf("\t-b offset\t\t\t[partition] append zeros to partition till reaching absolute offset\n");
 571         printf("\n");
 572         printf("Extracting from TRX file:\n");
 573         printf("\totrx extract <file> [options]\textract partitions from TRX file\n");
 574         printf("\t-o offset\t\t\toffset of TRX data in file (default: 0)\n");
 575         printf("\t-1 file\t\t\t\tfile to extract 1st partition to (optional)\n");
 576         printf("\t-2 file\t\t\t\tfile to extract 2nd partition to (optional)\n");
 577         printf("\t-3 file\t\t\t\tfile to extract 3rd partition to (optional)\n");
 578 }
 579
 580 int main(int argc, char **argv) {
 581         if (argc > 1) {
 582                 if (!strcmp(argv[1], "check"))
 583                         return otrx_check(argc, argv);
 584                 else if (!strcmp(argv[1], "create"))
 585                         return otrx_create(argc, argv);
 586                 else if (!strcmp(argv[1], "extract"))
 587                         return otrx_extract(argc, argv);
 588         }
 589
 590         usage();
 591         return 0;
 592 }