contrib/libarchive/libarchive/archive_read_support_format_cpio.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * Copyright (c) 2010-2012 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "archive_platform.h"
  28 __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_cpio.c 201163 2009-12-29 05:50:34Z kientzle $");
  29
  30 #ifdef HAVE_ERRNO_H
  31 #include <errno.h>
  32 #endif
  33 /* #include <stdint.h> */ /* See archive_platform.h */
  34 #ifdef HAVE_STDLIB_H
  35 #include <stdlib.h>
  36 #endif
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #endif
  40
  41 #include "archive.h"
  42 #include "archive_entry.h"
  43 #include "archive_entry_locale.h"
  44 #include "archive_private.h"
  45 #include "archive_read_private.h"
  46
  47 #define bin_magic_offset 0
  48 #define bin_magic_size 2
  49 #define bin_dev_offset 2
  50 #define bin_dev_size 2
  51 #define bin_ino_offset 4
  52 #define bin_ino_size 2
  53 #define bin_mode_offset 6
  54 #define bin_mode_size 2
  55 #define bin_uid_offset 8
  56 #define bin_uid_size 2
  57 #define bin_gid_offset 10
  58 #define bin_gid_size 2
  59 #define bin_nlink_offset 12
  60 #define bin_nlink_size 2
  61 #define bin_rdev_offset 14
  62 #define bin_rdev_size 2
  63 #define bin_mtime_offset 16
  64 #define bin_mtime_size 4
  65 #define bin_namesize_offset 20
  66 #define bin_namesize_size 2
  67 #define bin_filesize_offset 22
  68 #define bin_filesize_size 4
  69 #define bin_header_size 26
  70
  71 #define odc_magic_offset 0
  72 #define odc_magic_size 6
  73 #define odc_dev_offset 6
  74 #define odc_dev_size 6
  75 #define odc_ino_offset 12
  76 #define odc_ino_size 6
  77 #define odc_mode_offset 18
  78 #define odc_mode_size 6
  79 #define odc_uid_offset 24
  80 #define odc_uid_size 6
  81 #define odc_gid_offset 30
  82 #define odc_gid_size 6
  83 #define odc_nlink_offset 36
  84 #define odc_nlink_size 6
  85 #define odc_rdev_offset 42
  86 #define odc_rdev_size 6
  87 #define odc_mtime_offset 48
  88 #define odc_mtime_size 11
  89 #define odc_namesize_offset 59
  90 #define odc_namesize_size 6
  91 #define odc_filesize_offset 65
  92 #define odc_filesize_size 11
  93 #define odc_header_size 76
  94
  95 #define newc_magic_offset 0
  96 #define newc_magic_size 6
  97 #define newc_ino_offset 6
  98 #define newc_ino_size 8
  99 #define newc_mode_offset 14
 100 #define newc_mode_size 8
 101 #define newc_uid_offset 22
 102 #define newc_uid_size 8
 103 #define newc_gid_offset 30
 104 #define newc_gid_size 8
 105 #define newc_nlink_offset 38
 106 #define newc_nlink_size 8
 107 #define newc_mtime_offset 46
 108 #define newc_mtime_size 8
 109 #define newc_filesize_offset 54
 110 #define newc_filesize_size 8
 111 #define newc_devmajor_offset 62
 112 #define newc_devmajor_size 8
 113 #define newc_devminor_offset 70
 114 #define newc_devminor_size 8
 115 #define newc_rdevmajor_offset 78
 116 #define newc_rdevmajor_size 8
 117 #define newc_rdevminor_offset 86
 118 #define newc_rdevminor_size 8
 119 #define newc_namesize_offset 94
 120 #define newc_namesize_size 8
 121 #define newc_checksum_offset 102
 122 #define newc_checksum_size 8
 123 #define newc_header_size 110
 124
 125 /*
 126  * An afio large ASCII header, which they named itself.
 127  * afio utility uses this header, if a file size is larger than 2G bytes
 128  * or inode/uid/gid is bigger than 65535(0xFFFF) or mtime is bigger than
 129  * 0x7fffffff, which we cannot record to odc header because of its limit.
 130  * If not, uses odc header.
 131  */
 132 #define afiol_magic_offset 0
 133 #define afiol_magic_size 6
 134 #define afiol_dev_offset 6
 135 #define afiol_dev_size 8        /* hex */
 136 #define afiol_ino_offset 14
 137 #define afiol_ino_size 16       /* hex */
 138 #define afiol_ino_m_offset 30   /* 'm' */
 139 #define afiol_mode_offset 31
 140 #define afiol_mode_size 6       /* oct */
 141 #define afiol_uid_offset 37
 142 #define afiol_uid_size 8        /* hex */
 143 #define afiol_gid_offset 45
 144 #define afiol_gid_size 8        /* hex */
 145 #define afiol_nlink_offset 53
 146 #define afiol_nlink_size 8      /* hex */
 147 #define afiol_rdev_offset 61
 148 #define afiol_rdev_size 8       /* hex */
 149 #define afiol_mtime_offset 69
 150 #define afiol_mtime_size 16     /* hex */
 151 #define afiol_mtime_n_offset 85 /* 'n' */
 152 #define afiol_namesize_offset 86
 153 #define afiol_namesize_size 4   /* hex */
 154 #define afiol_flag_offset 90
 155 #define afiol_flag_size 4       /* hex */
 156 #define afiol_xsize_offset 94
 157 #define afiol_xsize_size 4      /* hex */
 158 #define afiol_xsize_s_offset 98 /* 's' */
 159 #define afiol_filesize_offset 99
 160 #define afiol_filesize_size 16  /* hex */
 161 #define afiol_filesize_c_offset 115     /* ':' */
 162 #define afiol_header_size 116
 163
 164
 165 struct links_entry {
 166         struct links_entry      *next;
 167         struct links_entry      *previous;
 168         int                      links;
 169         dev_t                    dev;
 170         int64_t                  ino;
 171         char                    *name;
 172 };
 173
 174 #define CPIO_MAGIC   0x13141516
 175 struct cpio {
 176         int                       magic;
 177         int                     (*read_header)(struct archive_read *, struct cpio *,
 178                                      struct archive_entry *, size_t *, size_t *);
 179         struct links_entry       *links_head;
 180         int64_t                   entry_bytes_remaining;
 181         int64_t                   entry_bytes_unconsumed;
 182         int64_t                   entry_offset;
 183         int64_t                   entry_padding;
 184
 185         struct archive_string_conv *opt_sconv;
 186         struct archive_string_conv *sconv_default;
 187         int                       init_default_conversion;
 188 };
 189
 190 static int64_t  atol16(const char *, unsigned);
 191 static int64_t  atol8(const char *, unsigned);
 192 static int      archive_read_format_cpio_bid(struct archive_read *, int);
 193 static int      archive_read_format_cpio_options(struct archive_read *,
 194                     const char *, const char *);
 195 static int      archive_read_format_cpio_cleanup(struct archive_read *);
 196 static int      archive_read_format_cpio_read_data(struct archive_read *,
 197                     const void **, size_t *, int64_t *);
 198 static int      archive_read_format_cpio_read_header(struct archive_read *,
 199                     struct archive_entry *);
 200 static int      archive_read_format_cpio_skip(struct archive_read *);
 201 static int      be4(const unsigned char *);
 202 static int      find_odc_header(struct archive_read *);
 203 static int      find_newc_header(struct archive_read *);
 204 static int      header_bin_be(struct archive_read *, struct cpio *,
 205                     struct archive_entry *, size_t *, size_t *);
 206 static int      header_bin_le(struct archive_read *, struct cpio *,
 207                     struct archive_entry *, size_t *, size_t *);
 208 static int      header_newc(struct archive_read *, struct cpio *,
 209                     struct archive_entry *, size_t *, size_t *);
 210 static int      header_odc(struct archive_read *, struct cpio *,
 211                     struct archive_entry *, size_t *, size_t *);
 212 static int      header_afiol(struct archive_read *, struct cpio *,
 213                     struct archive_entry *, size_t *, size_t *);
 214 static int      is_octal(const char *, size_t);
 215 static int      is_hex(const char *, size_t);
 216 static int      le4(const unsigned char *);
 217 static int      record_hardlink(struct archive_read *a,
 218                     struct cpio *cpio, struct archive_entry *entry);
 219
 220 int
 221 archive_read_support_format_cpio(struct archive *_a)
 222 {
 223         struct archive_read *a = (struct archive_read *)_a;
 224         struct cpio *cpio;
 225         int r;
 226
 227         archive_check_magic(_a, ARCHIVE_READ_MAGIC,
 228             ARCHIVE_STATE_NEW, "archive_read_support_format_cpio");
 229
 230         cpio = (struct cpio *)calloc(1, sizeof(*cpio));
 231         if (cpio == NULL) {
 232                 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
 233                 return (ARCHIVE_FATAL);
 234         }
 235         cpio->magic = CPIO_MAGIC;
 236
 237         r = __archive_read_register_format(a,
 238             cpio,
 239             "cpio",
 240             archive_read_format_cpio_bid,
 241             archive_read_format_cpio_options,
 242             archive_read_format_cpio_read_header,
 243             archive_read_format_cpio_read_data,
 244             archive_read_format_cpio_skip,
 245             archive_read_format_cpio_cleanup);
 246
 247         if (r != ARCHIVE_OK)
 248                 free(cpio);
 249         return (ARCHIVE_OK);
 250 }
 251
 252
 253 static int
 254 archive_read_format_cpio_bid(struct archive_read *a, int best_bid)
 255 {
 256         const unsigned char *p;
 257         struct cpio *cpio;
 258         int bid;
 259
 260         (void)best_bid; /* UNUSED */
 261
 262         cpio = (struct cpio *)(a->format->data);
 263
 264         if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
 265                 return (-1);
 266
 267         bid = 0;
 268         if (memcmp(p, "070707", 6) == 0) {
 269                 /* ASCII cpio archive (odc, POSIX.1) */
 270                 cpio->read_header = header_odc;
 271                 bid += 48;
 272                 /*
 273                  * XXX TODO:  More verification; Could check that only octal
 274                  * digits appear in appropriate header locations. XXX
 275                  */
 276         } else if (memcmp(p, "070727", 6) == 0) {
 277                 /* afio large ASCII cpio archive */
 278                 cpio->read_header = header_odc;
 279                 bid += 48;
 280                 /*
 281                  * XXX TODO:  More verification; Could check that almost hex
 282                  * digits appear in appropriate header locations. XXX
 283                  */
 284         } else if (memcmp(p, "070701", 6) == 0) {
 285                 /* ASCII cpio archive (SVR4 without CRC) */
 286                 cpio->read_header = header_newc;
 287                 bid += 48;
 288                 /*
 289                  * XXX TODO:  More verification; Could check that only hex
 290                  * digits appear in appropriate header locations. XXX
 291                  */
 292         } else if (memcmp(p, "070702", 6) == 0) {
 293                 /* ASCII cpio archive (SVR4 with CRC) */
 294                 /* XXX TODO: Flag that we should check the CRC. XXX */
 295                 cpio->read_header = header_newc;
 296                 bid += 48;
 297                 /*
 298                  * XXX TODO:  More verification; Could check that only hex
 299                  * digits appear in appropriate header locations. XXX
 300                  */
 301         } else if (p[0] * 256 + p[1] == 070707) {
 302                 /* big-endian binary cpio archives */
 303                 cpio->read_header = header_bin_be;
 304                 bid += 16;
 305                 /* Is more verification possible here? */
 306         } else if (p[0] + p[1] * 256 == 070707) {
 307                 /* little-endian binary cpio archives */
 308                 cpio->read_header = header_bin_le;
 309                 bid += 16;
 310                 /* Is more verification possible here? */
 311         } else
 312                 return (ARCHIVE_WARN);
 313
 314         return (bid);
 315 }
 316
 317 static int
 318 archive_read_format_cpio_options(struct archive_read *a,
 319     const char *key, const char *val)
 320 {
 321         struct cpio *cpio;
 322         int ret = ARCHIVE_FAILED;
 323
 324         cpio = (struct cpio *)(a->format->data);
 325         if (strcmp(key, "compat-2x")  == 0) {
 326                 /* Handle filnames as libarchive 2.x */
 327                 cpio->init_default_conversion = (val != NULL)?1:0;
 328                 return (ARCHIVE_OK);
 329         } else if (strcmp(key, "hdrcharset")  == 0) {
 330                 if (val == NULL || val[0] == 0)
 331                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 332                             "cpio: hdrcharset option needs a character-set name");
 333                 else {
 334                         cpio->opt_sconv =
 335                             archive_string_conversion_from_charset(
 336                                 &a->archive, val, 0);
 337                         if (cpio->opt_sconv != NULL)
 338                                 ret = ARCHIVE_OK;
 339                         else
 340                                 ret = ARCHIVE_FATAL;
 341                 }
 342                 return (ret);
 343         }
 344
 345         /* Note: The "warn" return is just to inform the options
 346          * supervisor that we didn't handle it.  It will generate
 347          * a suitable error if no one used this option. */
 348         return (ARCHIVE_WARN);
 349 }
 350
 351 static int
 352 archive_read_format_cpio_read_header(struct archive_read *a,
 353     struct archive_entry *entry)
 354 {
 355         struct cpio *cpio;
 356         const void *h;
 357         struct archive_string_conv *sconv;
 358         size_t namelength;
 359         size_t name_pad;
 360         int r;
 361
 362         cpio = (struct cpio *)(a->format->data);
 363         sconv = cpio->opt_sconv;
 364         if (sconv == NULL) {
 365                 if (!cpio->init_default_conversion) {
 366                         cpio->sconv_default =
 367                             archive_string_default_conversion_for_read(
 368                               &(a->archive));
 369                         cpio->init_default_conversion = 1;
 370                 }
 371                 sconv = cpio->sconv_default;
 372         }
 373
 374         r = (cpio->read_header(a, cpio, entry, &namelength, &name_pad));
 375
 376         if (r < ARCHIVE_WARN)
 377                 return (r);
 378
 379         /* Read name from buffer. */
 380         h = __archive_read_ahead(a, namelength + name_pad, NULL);
 381         if (h == NULL)
 382             return (ARCHIVE_FATAL);
 383         if (archive_entry_copy_pathname_l(entry,
 384             (const char *)h, namelength, sconv) != 0) {
 385                 if (errno == ENOMEM) {
 386                         archive_set_error(&a->archive, ENOMEM,
 387                             "Can't allocate memory for Pathname");
 388                         return (ARCHIVE_FATAL);
 389                 }
 390                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
 391                     "Pathname can't be converted from %s to current locale.",
 392                     archive_string_conversion_charset_name(sconv));
 393                 r = ARCHIVE_WARN;
 394         }
 395         cpio->entry_offset = 0;
 396
 397         __archive_read_consume(a, namelength + name_pad);
 398
 399         /* If this is a symlink, read the link contents. */
 400         if (archive_entry_filetype(entry) == AE_IFLNK) {
 401                 h = __archive_read_ahead(a,
 402                         (size_t)cpio->entry_bytes_remaining, NULL);
 403                 if (h == NULL)
 404                         return (ARCHIVE_FATAL);
 405                 if (archive_entry_copy_symlink_l(entry, (const char *)h,
 406                     (size_t)cpio->entry_bytes_remaining, sconv) != 0) {
 407                         if (errno == ENOMEM) {
 408                                 archive_set_error(&a->archive, ENOMEM,
 409                                     "Can't allocate memory for Linkname");
 410                                 return (ARCHIVE_FATAL);
 411                         }
 412                         archive_set_error(&a->archive,
 413                             ARCHIVE_ERRNO_FILE_FORMAT,
 414                             "Linkname can't be converted from %s to "
 415                             "current locale.",
 416                             archive_string_conversion_charset_name(sconv));
 417                         r = ARCHIVE_WARN;
 418                 }
 419                 __archive_read_consume(a, cpio->entry_bytes_remaining);
 420                 cpio->entry_bytes_remaining = 0;
 421         }
 422
 423         /* XXX TODO: If the full mode is 0160200, then this is a Solaris
 424          * ACL description for the following entry.  Read this body
 425          * and parse it as a Solaris-style ACL, then read the next
 426          * header.  XXX */
 427
 428         /* Compare name to "TRAILER!!!" to test for end-of-archive. */
 429         if (namelength == 11 && strcmp((const char *)h, "TRAILER!!!") == 0) {
 430                 /* TODO: Store file location of start of block. */
 431                 archive_clear_error(&a->archive);
 432                 return (ARCHIVE_EOF);
 433         }
 434
 435         /* Detect and record hardlinks to previously-extracted entries. */
 436         if (record_hardlink(a, cpio, entry) != ARCHIVE_OK) {
 437                 return (ARCHIVE_FATAL);
 438         }
 439
 440         return (r);
 441 }
 442
 443 static int
 444 archive_read_format_cpio_read_data(struct archive_read *a,
 445     const void **buff, size_t *size, int64_t *offset)
 446 {
 447         ssize_t bytes_read;
 448         struct cpio *cpio;
 449
 450         cpio = (struct cpio *)(a->format->data);
 451
 452         if (cpio->entry_bytes_unconsumed) {
 453                 __archive_read_consume(a, cpio->entry_bytes_unconsumed);
 454                 cpio->entry_bytes_unconsumed = 0;
 455         }
 456
 457         if (cpio->entry_bytes_remaining > 0) {
 458                 *buff = __archive_read_ahead(a, 1, &bytes_read);
 459                 if (bytes_read <= 0)
 460                         return (ARCHIVE_FATAL);
 461                 if (bytes_read > cpio->entry_bytes_remaining)
 462                         bytes_read = (ssize_t)cpio->entry_bytes_remaining;
 463                 *size = bytes_read;
 464                 cpio->entry_bytes_unconsumed = bytes_read;
 465                 *offset = cpio->entry_offset;
 466                 cpio->entry_offset += bytes_read;
 467                 cpio->entry_bytes_remaining -= bytes_read;
 468                 return (ARCHIVE_OK);
 469         } else {
 470                 if (cpio->entry_padding !=
 471                         __archive_read_consume(a, cpio->entry_padding)) {
 472                         return (ARCHIVE_FATAL);
 473                 }
 474                 cpio->entry_padding = 0;
 475                 *buff = NULL;
 476                 *size = 0;
 477                 *offset = cpio->entry_offset;
 478                 return (ARCHIVE_EOF);
 479         }
 480 }
 481
 482 static int
 483 archive_read_format_cpio_skip(struct archive_read *a)
 484 {
 485         struct cpio *cpio = (struct cpio *)(a->format->data);
 486         int64_t to_skip = cpio->entry_bytes_remaining + cpio->entry_padding +
 487                 cpio->entry_bytes_unconsumed;
 488
 489         if (to_skip != __archive_read_consume(a, to_skip)) {
 490                 return (ARCHIVE_FATAL);
 491         }
 492         cpio->entry_bytes_remaining = 0;
 493         cpio->entry_padding = 0;
 494         cpio->entry_bytes_unconsumed = 0;
 495         return (ARCHIVE_OK);
 496 }
 497
 498 /*
 499  * Skip forward to the next cpio newc header by searching for the
 500  * 07070[12] string.  This should be generalized and merged with
 501  * find_odc_header below.
 502  */
 503 static int
 504 is_hex(const char *p, size_t len)
 505 {
 506         while (len-- > 0) {
 507                 if ((*p >= '0' && *p <= '9')
 508                     || (*p >= 'a' && *p <= 'f')
 509                     || (*p >= 'A' && *p <= 'F'))
 510                         ++p;
 511                 else
 512                         return (0);
 513         }
 514         return (1);
 515 }
 516
 517 static int
 518 find_newc_header(struct archive_read *a)
 519 {
 520         const void *h;
 521         const char *p, *q;
 522         size_t skip, skipped = 0;
 523         ssize_t bytes;
 524
 525         for (;;) {
 526                 h = __archive_read_ahead(a, newc_header_size, &bytes);
 527                 if (h == NULL)
 528                         return (ARCHIVE_FATAL);
 529                 p = h;
 530                 q = p + bytes;
 531
 532                 /* Try the typical case first, then go into the slow search.*/
 533                 if (memcmp("07070", p, 5) == 0
 534                     && (p[5] == '1' || p[5] == '2')
 535                     && is_hex(p, newc_header_size))
 536                         return (ARCHIVE_OK);
 537
 538                 /*
 539                  * Scan ahead until we find something that looks
 540                  * like a newc header.
 541                  */
 542                 while (p + newc_header_size <= q) {
 543                         switch (p[5]) {
 544                         case '1':
 545                         case '2':
 546                                 if (memcmp("07070", p, 5) == 0
 547                                     && is_hex(p, newc_header_size)) {
 548                                         skip = p - (const char *)h;
 549                                         __archive_read_consume(a, skip);
 550                                         skipped += skip;
 551                                         if (skipped > 0) {
 552                                                 archive_set_error(&a->archive,
 553                                                     0,
 554                                                     "Skipped %d bytes before "
 555                                                     "finding valid header",
 556                                                     (int)skipped);
 557                                                 return (ARCHIVE_WARN);
 558                                         }
 559                                         return (ARCHIVE_OK);
 560                                 }
 561                                 p += 2;
 562                                 break;
 563                         case '0':
 564                                 p++;
 565                                 break;
 566                         default:
 567                                 p += 6;
 568                                 break;
 569                         }
 570                 }
 571                 skip = p - (const char *)h;
 572                 __archive_read_consume(a, skip);
 573                 skipped += skip;
 574         }
 575 }
 576
 577 static int
 578 header_newc(struct archive_read *a, struct cpio *cpio,
 579     struct archive_entry *entry, size_t *namelength, size_t *name_pad)
 580 {
 581         const void *h;
 582         const char *header;
 583         int r;
 584
 585         r = find_newc_header(a);
 586         if (r < ARCHIVE_WARN)
 587                 return (r);
 588
 589         /* Read fixed-size portion of header. */
 590         h = __archive_read_ahead(a, newc_header_size, NULL);
 591         if (h == NULL)
 592             return (ARCHIVE_FATAL);
 593
 594         /* Parse out hex fields. */
 595         header = (const char *)h;
 596
 597         if (memcmp(header + newc_magic_offset, "070701", 6) == 0) {
 598                 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC;
 599                 a->archive.archive_format_name = "ASCII cpio (SVR4 with no CRC)";
 600         } else if (memcmp(header + newc_magic_offset, "070702", 6) == 0) {
 601                 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_CRC;
 602                 a->archive.archive_format_name = "ASCII cpio (SVR4 with CRC)";
 603         } else {
 604                 /* TODO: Abort here? */
 605         }
 606
 607         archive_entry_set_devmajor(entry,
 608                 (dev_t)atol16(header + newc_devmajor_offset, newc_devmajor_size));
 609         archive_entry_set_devminor(entry,
 610                 (dev_t)atol16(header + newc_devminor_offset, newc_devminor_size));
 611         archive_entry_set_ino(entry, atol16(header + newc_ino_offset, newc_ino_size));
 612         archive_entry_set_mode(entry,
 613                 (mode_t)atol16(header + newc_mode_offset, newc_mode_size));
 614         archive_entry_set_uid(entry, atol16(header + newc_uid_offset, newc_uid_size));
 615         archive_entry_set_gid(entry, atol16(header + newc_gid_offset, newc_gid_size));
 616         archive_entry_set_nlink(entry,
 617                 (unsigned int)atol16(header + newc_nlink_offset, newc_nlink_size));
 618         archive_entry_set_rdevmajor(entry,
 619                 (dev_t)atol16(header + newc_rdevmajor_offset, newc_rdevmajor_size));
 620         archive_entry_set_rdevminor(entry,
 621                 (dev_t)atol16(header + newc_rdevminor_offset, newc_rdevminor_size));
 622         archive_entry_set_mtime(entry, atol16(header + newc_mtime_offset, newc_mtime_size), 0);
 623         *namelength = (size_t)atol16(header + newc_namesize_offset, newc_namesize_size);
 624         /* Pad name to 2 more than a multiple of 4. */
 625         *name_pad = (2 - *namelength) & 3;
 626
 627         /*
 628          * Note: entry_bytes_remaining is at least 64 bits and
 629          * therefore guaranteed to be big enough for a 33-bit file
 630          * size.
 631          */
 632         cpio->entry_bytes_remaining =
 633             atol16(header + newc_filesize_offset, newc_filesize_size);
 634         archive_entry_set_size(entry, cpio->entry_bytes_remaining);
 635         /* Pad file contents to a multiple of 4. */
 636         cpio->entry_padding = 3 & -cpio->entry_bytes_remaining;
 637         __archive_read_consume(a, newc_header_size);
 638         return (r);
 639 }
 640
 641 /*
 642  * Skip forward to the next cpio odc header by searching for the
 643  * 070707 string.  This is a hand-optimized search that could
 644  * probably be easily generalized to handle all character-based
 645  * cpio variants.
 646  */
 647 static int
 648 is_octal(const char *p, size_t len)
 649 {
 650         while (len-- > 0) {
 651                 if (*p < '0' || *p > '7')
 652                         return (0);
 653                 ++p;
 654         }
 655         return (1);
 656 }
 657
 658 static int
 659 is_afio_large(const char *h, size_t len)
 660 {
 661         if (len < afiol_header_size)
 662                 return (0);
 663         if (h[afiol_ino_m_offset] != 'm'
 664             || h[afiol_mtime_n_offset] != 'n'
 665             || h[afiol_xsize_s_offset] != 's'
 666             || h[afiol_filesize_c_offset] != ':')
 667                 return (0);
 668         if (!is_hex(h + afiol_dev_offset, afiol_ino_m_offset - afiol_dev_offset))
 669                 return (0);
 670         if (!is_hex(h + afiol_mode_offset, afiol_mtime_n_offset - afiol_mode_offset))
 671                 return (0);
 672         if (!is_hex(h + afiol_namesize_offset, afiol_xsize_s_offset - afiol_namesize_offset))
 673                 return (0);
 674         if (!is_hex(h + afiol_filesize_offset, afiol_filesize_size))
 675                 return (0);
 676         return (1);
 677 }
 678
 679 static int
 680 find_odc_header(struct archive_read *a)
 681 {
 682         const void *h;
 683         const char *p, *q;
 684         size_t skip, skipped = 0;
 685         ssize_t bytes;
 686
 687         for (;;) {
 688                 h = __archive_read_ahead(a, odc_header_size, &bytes);
 689                 if (h == NULL)
 690                         return (ARCHIVE_FATAL);
 691                 p = h;
 692                 q = p + bytes;
 693
 694                 /* Try the typical case first, then go into the slow search.*/
 695                 if (memcmp("070707", p, 6) == 0 && is_octal(p, odc_header_size))
 696                         return (ARCHIVE_OK);
 697                 if (memcmp("070727", p, 6) == 0 && is_afio_large(p, bytes)) {
 698                         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
 699                         return (ARCHIVE_OK);
 700                 }
 701
 702                 /*
 703                  * Scan ahead until we find something that looks
 704                  * like an odc header.
 705                  */
 706                 while (p + odc_header_size <= q) {
 707                         switch (p[5]) {
 708                         case '7':
 709                                 if ((memcmp("070707", p, 6) == 0
 710                                     && is_octal(p, odc_header_size))
 711                                     || (memcmp("070727", p, 6) == 0
 712                                         && is_afio_large(p, q - p))) {
 713                                         skip = p - (const char *)h;
 714                                         __archive_read_consume(a, skip);
 715                                         skipped += skip;
 716                                         if (p[4] == '2')
 717                                                 a->archive.archive_format =
 718                                                     ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
 719                                         if (skipped > 0) {
 720                                                 archive_set_error(&a->archive,
 721                                                     0,
 722                                                     "Skipped %d bytes before "
 723                                                     "finding valid header",
 724                                                     (int)skipped);
 725                                                 return (ARCHIVE_WARN);
 726                                         }
 727                                         return (ARCHIVE_OK);
 728                                 }
 729                                 p += 2;
 730                                 break;
 731                         case '0':
 732                                 p++;
 733                                 break;
 734                         default:
 735                                 p += 6;
 736                                 break;
 737                         }
 738                 }
 739                 skip = p - (const char *)h;
 740                 __archive_read_consume(a, skip);
 741                 skipped += skip;
 742         }
 743 }
 744
 745 static int
 746 header_odc(struct archive_read *a, struct cpio *cpio,
 747     struct archive_entry *entry, size_t *namelength, size_t *name_pad)
 748 {
 749         const void *h;
 750         int r;
 751         const char *header;
 752
 753         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX;
 754         a->archive.archive_format_name = "POSIX octet-oriented cpio";
 755
 756         /* Find the start of the next header. */
 757         r = find_odc_header(a);
 758         if (r < ARCHIVE_WARN)
 759                 return (r);
 760
 761         if (a->archive.archive_format == ARCHIVE_FORMAT_CPIO_AFIO_LARGE) {
 762                 int r2 = (header_afiol(a, cpio, entry, namelength, name_pad));
 763                 if (r2 == ARCHIVE_OK)
 764                         return (r);
 765                 else
 766                         return (r2);
 767         }
 768
 769         /* Read fixed-size portion of header. */
 770         h = __archive_read_ahead(a, odc_header_size, NULL);
 771         if (h == NULL)
 772             return (ARCHIVE_FATAL);
 773
 774         /* Parse out octal fields. */
 775         header = (const char *)h;
 776
 777         archive_entry_set_dev(entry,
 778                 (dev_t)atol8(header + odc_dev_offset, odc_dev_size));
 779         archive_entry_set_ino(entry, atol8(header + odc_ino_offset, odc_ino_size));
 780         archive_entry_set_mode(entry,
 781                 (mode_t)atol8(header + odc_mode_offset, odc_mode_size));
 782         archive_entry_set_uid(entry, atol8(header + odc_uid_offset, odc_uid_size));
 783         archive_entry_set_gid(entry, atol8(header + odc_gid_offset, odc_gid_size));
 784         archive_entry_set_nlink(entry,
 785                 (unsigned int)atol8(header + odc_nlink_offset, odc_nlink_size));
 786         archive_entry_set_rdev(entry,
 787                 (dev_t)atol8(header + odc_rdev_offset, odc_rdev_size));
 788         archive_entry_set_mtime(entry, atol8(header + odc_mtime_offset, odc_mtime_size), 0);
 789         *namelength = (size_t)atol8(header + odc_namesize_offset, odc_namesize_size);
 790         *name_pad = 0; /* No padding of filename. */
 791
 792         /*
 793          * Note: entry_bytes_remaining is at least 64 bits and
 794          * therefore guaranteed to be big enough for a 33-bit file
 795          * size.
 796          */
 797         cpio->entry_bytes_remaining =
 798             atol8(header + odc_filesize_offset, odc_filesize_size);
 799         archive_entry_set_size(entry, cpio->entry_bytes_remaining);
 800         cpio->entry_padding = 0;
 801         __archive_read_consume(a, odc_header_size);
 802         return (r);
 803 }
 804
 805 /*
 806  * NOTE: if a filename suffix is ".z", it is the file gziped by afio.
 807  * it would be nice that we can show uncompressed file size and we can
 808  * uncompressed file contents automatically, unfortunately we have nothing
 809  * to get a uncompressed file size while reading each header. it means
 810  * we also cannot uncompressed file contens under the our framework.
 811  */
 812 static int
 813 header_afiol(struct archive_read *a, struct cpio *cpio,
 814     struct archive_entry *entry, size_t *namelength, size_t *name_pad)
 815 {
 816         const void *h;
 817         const char *header;
 818
 819         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
 820         a->archive.archive_format_name = "afio large ASCII";
 821
 822         /* Read fixed-size portion of header. */
 823         h = __archive_read_ahead(a, afiol_header_size, NULL);
 824         if (h == NULL)
 825             return (ARCHIVE_FATAL);
 826
 827         /* Parse out octal fields. */
 828         header = (const char *)h;
 829
 830         archive_entry_set_dev(entry,
 831                 (dev_t)atol16(header + afiol_dev_offset, afiol_dev_size));
 832         archive_entry_set_ino(entry, atol16(header + afiol_ino_offset, afiol_ino_size));
 833         archive_entry_set_mode(entry,
 834                 (mode_t)atol8(header + afiol_mode_offset, afiol_mode_size));
 835         archive_entry_set_uid(entry, atol16(header + afiol_uid_offset, afiol_uid_size));
 836         archive_entry_set_gid(entry, atol16(header + afiol_gid_offset, afiol_gid_size));
 837         archive_entry_set_nlink(entry,
 838                 (unsigned int)atol16(header + afiol_nlink_offset, afiol_nlink_size));
 839         archive_entry_set_rdev(entry,
 840                 (dev_t)atol16(header + afiol_rdev_offset, afiol_rdev_size));
 841         archive_entry_set_mtime(entry, atol16(header + afiol_mtime_offset, afiol_mtime_size), 0);
 842         *namelength = (size_t)atol16(header + afiol_namesize_offset, afiol_namesize_size);
 843         *name_pad = 0; /* No padding of filename. */
 844
 845         cpio->entry_bytes_remaining =
 846             atol16(header + afiol_filesize_offset, afiol_filesize_size);
 847         archive_entry_set_size(entry, cpio->entry_bytes_remaining);
 848         cpio->entry_padding = 0;
 849         __archive_read_consume(a, afiol_header_size);
 850         return (ARCHIVE_OK);
 851 }
 852
 853
 854 static int
 855 header_bin_le(struct archive_read *a, struct cpio *cpio,
 856     struct archive_entry *entry, size_t *namelength, size_t *name_pad)
 857 {
 858         const void *h;
 859         const unsigned char *header;
 860
 861         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_LE;
 862         a->archive.archive_format_name = "cpio (little-endian binary)";
 863
 864         /* Read fixed-size portion of header. */
 865         h = __archive_read_ahead(a, bin_header_size, NULL);
 866         if (h == NULL)
 867             return (ARCHIVE_FATAL);
 868
 869         /* Parse out binary fields. */
 870         header = (const unsigned char *)h;
 871
 872         archive_entry_set_dev(entry, header[bin_dev_offset] + header[bin_dev_offset + 1] * 256);
 873         archive_entry_set_ino(entry, header[bin_ino_offset] + header[bin_ino_offset + 1] * 256);
 874         archive_entry_set_mode(entry, header[bin_mode_offset] + header[bin_mode_offset + 1] * 256);
 875         archive_entry_set_uid(entry, header[bin_uid_offset] + header[bin_uid_offset + 1] * 256);
 876         archive_entry_set_gid(entry, header[bin_gid_offset] + header[bin_gid_offset + 1] * 256);
 877         archive_entry_set_nlink(entry, header[bin_nlink_offset] + header[bin_nlink_offset + 1] * 256);
 878         archive_entry_set_rdev(entry, header[bin_rdev_offset] + header[bin_rdev_offset + 1] * 256);
 879         archive_entry_set_mtime(entry, le4(header + bin_mtime_offset), 0);
 880         *namelength = header[bin_namesize_offset] + header[bin_namesize_offset + 1] * 256;
 881         *name_pad = *namelength & 1; /* Pad to even. */
 882
 883         cpio->entry_bytes_remaining = le4(header + bin_filesize_offset);
 884         archive_entry_set_size(entry, cpio->entry_bytes_remaining);
 885         cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
 886         __archive_read_consume(a, bin_header_size);
 887         return (ARCHIVE_OK);
 888 }
 889
 890 static int
 891 header_bin_be(struct archive_read *a, struct cpio *cpio,
 892     struct archive_entry *entry, size_t *namelength, size_t *name_pad)
 893 {
 894         const void *h;
 895         const unsigned char *header;
 896
 897         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_BE;
 898         a->archive.archive_format_name = "cpio (big-endian binary)";
 899
 900         /* Read fixed-size portion of header. */
 901         h = __archive_read_ahead(a, bin_header_size, NULL);
 902         if (h == NULL)
 903             return (ARCHIVE_FATAL);
 904
 905         /* Parse out binary fields. */
 906         header = (const unsigned char *)h;
 907
 908         archive_entry_set_dev(entry, header[bin_dev_offset] * 256 + header[bin_dev_offset + 1]);
 909         archive_entry_set_ino(entry, header[bin_ino_offset] * 256 + header[bin_ino_offset + 1]);
 910         archive_entry_set_mode(entry, header[bin_mode_offset] * 256 + header[bin_mode_offset + 1]);
 911         archive_entry_set_uid(entry, header[bin_uid_offset] * 256 + header[bin_uid_offset + 1]);
 912         archive_entry_set_gid(entry, header[bin_gid_offset] * 256 + header[bin_gid_offset + 1]);
 913         archive_entry_set_nlink(entry, header[bin_nlink_offset] * 256 + header[bin_nlink_offset + 1]);
 914         archive_entry_set_rdev(entry, header[bin_rdev_offset] * 256 + header[bin_rdev_offset + 1]);
 915         archive_entry_set_mtime(entry, be4(header + bin_mtime_offset), 0);
 916         *namelength = header[bin_namesize_offset] * 256 + header[bin_namesize_offset + 1];
 917         *name_pad = *namelength & 1; /* Pad to even. */
 918
 919         cpio->entry_bytes_remaining = be4(header + bin_filesize_offset);
 920         archive_entry_set_size(entry, cpio->entry_bytes_remaining);
 921         cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
 922             __archive_read_consume(a, bin_header_size);
 923         return (ARCHIVE_OK);
 924 }
 925
 926 static int
 927 archive_read_format_cpio_cleanup(struct archive_read *a)
 928 {
 929         struct cpio *cpio;
 930
 931         cpio = (struct cpio *)(a->format->data);
 932         /* Free inode->name map */
 933         while (cpio->links_head != NULL) {
 934                 struct links_entry *lp = cpio->links_head->next;
 935
 936                 if (cpio->links_head->name)
 937                         free(cpio->links_head->name);
 938                 free(cpio->links_head);
 939                 cpio->links_head = lp;
 940         }
 941         free(cpio);
 942         (a->format->data) = NULL;
 943         return (ARCHIVE_OK);
 944 }
 945
 946 static int
 947 le4(const unsigned char *p)
 948 {
 949         return ((p[0]<<16) + (p[1]<<24) + (p[2]<<0) + (p[3]<<8));
 950 }
 951
 952
 953 static int
 954 be4(const unsigned char *p)
 955 {
 956         return ((p[0]<<24) + (p[1]<<16) + (p[2]<<8) + (p[3]));
 957 }
 958
 959 /*
 960  * Note that this implementation does not (and should not!) obey
 961  * locale settings; you cannot simply substitute strtol here, since
 962  * it does obey locale.
 963  */
 964 static int64_t
 965 atol8(const char *p, unsigned char_cnt)
 966 {
 967         int64_t l;
 968         int digit;
 969
 970         l = 0;
 971         while (char_cnt-- > 0) {
 972                 if (*p >= '0' && *p <= '7')
 973                         digit = *p - '0';
 974                 else
 975                         return (l);
 976                 p++;
 977                 l <<= 3;
 978                 l |= digit;
 979         }
 980         return (l);
 981 }
 982
 983 static int64_t
 984 atol16(const char *p, unsigned char_cnt)
 985 {
 986         int64_t l;
 987         int digit;
 988
 989         l = 0;
 990         while (char_cnt-- > 0) {
 991                 if (*p >= 'a' && *p <= 'f')
 992                         digit = *p - 'a' + 10;
 993                 else if (*p >= 'A' && *p <= 'F')
 994                         digit = *p - 'A' + 10;
 995                 else if (*p >= '0' && *p <= '9')
 996                         digit = *p - '0';
 997                 else
 998                         return (l);
 999                 p++;
1000                 l <<= 4;
1001                 l |= digit;
1002         }
1003         return (l);
1004 }
1005
1006 static int
1007 record_hardlink(struct archive_read *a,
1008     struct cpio *cpio, struct archive_entry *entry)
1009 {
1010         struct links_entry      *le;
1011         dev_t dev;
1012         int64_t ino;
1013
1014         if (archive_entry_nlink(entry) <= 1)
1015                 return (ARCHIVE_OK);
1016
1017         dev = archive_entry_dev(entry);
1018         ino = archive_entry_ino64(entry);
1019
1020         /*
1021          * First look in the list of multiply-linked files.  If we've
1022          * already dumped it, convert this entry to a hard link entry.
1023          */
1024         for (le = cpio->links_head; le; le = le->next) {
1025                 if (le->dev == dev && le->ino == ino) {
1026                         archive_entry_copy_hardlink(entry, le->name);
1027
1028                         if (--le->links <= 0) {
1029                                 if (le->previous != NULL)
1030                                         le->previous->next = le->next;
1031                                 if (le->next != NULL)
1032                                         le->next->previous = le->previous;
1033                                 if (cpio->links_head == le)
1034                                         cpio->links_head = le->next;
1035                                 free(le->name);
1036                                 free(le);
1037                         }
1038
1039                         return (ARCHIVE_OK);
1040                 }
1041         }
1042
1043         le = (struct links_entry *)malloc(sizeof(struct links_entry));
1044         if (le == NULL) {
1045                 archive_set_error(&a->archive,
1046                     ENOMEM, "Out of memory adding file to list");
1047                 return (ARCHIVE_FATAL);
1048         }
1049         if (cpio->links_head != NULL)
1050                 cpio->links_head->previous = le;
1051         le->next = cpio->links_head;
1052         le->previous = NULL;
1053         cpio->links_head = le;
1054         le->dev = dev;
1055         le->ino = ino;
1056         le->links = archive_entry_nlink(entry) - 1;
1057         le->name = strdup(archive_entry_pathname(entry));
1058         if (le->name == NULL) {
1059                 archive_set_error(&a->archive,
1060                     ENOMEM, "Out of memory adding file to list");
1061                 return (ARCHIVE_FATAL);
1062         }
1063
1064         return (ARCHIVE_OK);
1065 }