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 unsigned 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 int option_pwb; 190 }; 191 192 static int64_t atol16(const char *, unsigned); 193 static int64_t atol8(const char *, unsigned); 194 static int archive_read_format_cpio_bid(struct archive_read *, int); 195 static int archive_read_format_cpio_options(struct archive_read *, 196 const char *, const char *); 197 static int archive_read_format_cpio_cleanup(struct archive_read *); 198 static int archive_read_format_cpio_read_data(struct archive_read *, 199 const void **, size_t *, int64_t *); 200 static int archive_read_format_cpio_read_header(struct archive_read *, 201 struct archive_entry *); 202 static int archive_read_format_cpio_skip(struct archive_read *); 203 static int64_t be4(const unsigned char *); 204 static int find_odc_header(struct archive_read *); 205 static int find_newc_header(struct archive_read *); 206 static int header_bin_be(struct archive_read *, struct cpio *, 207 struct archive_entry *, size_t *, size_t *); 208 static int header_bin_le(struct archive_read *, struct cpio *, 209 struct archive_entry *, size_t *, size_t *); 210 static int header_newc(struct archive_read *, struct cpio *, 211 struct archive_entry *, size_t *, size_t *); 212 static int header_odc(struct archive_read *, struct cpio *, 213 struct archive_entry *, size_t *, size_t *); 214 static int header_afiol(struct archive_read *, struct cpio *, 215 struct archive_entry *, size_t *, size_t *); 216 static int is_octal(const char *, size_t); 217 static int is_hex(const char *, size_t); 218 static int64_t le4(const unsigned char *); 219 static int record_hardlink(struct archive_read *a, 220 struct cpio *cpio, struct archive_entry *entry); 221 222 int 223 archive_read_support_format_cpio(struct archive *_a) 224 { 225 struct archive_read *a = (struct archive_read *)_a; 226 struct cpio *cpio; 227 int r; 228 229 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 230 ARCHIVE_STATE_NEW, "archive_read_support_format_cpio"); 231 232 cpio = (struct cpio *)calloc(1, sizeof(*cpio)); 233 if (cpio == NULL) { 234 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data"); 235 return (ARCHIVE_FATAL); 236 } 237 cpio->magic = CPIO_MAGIC; 238 239 r = __archive_read_register_format(a, 240 cpio, 241 "cpio", 242 archive_read_format_cpio_bid, 243 archive_read_format_cpio_options, 244 archive_read_format_cpio_read_header, 245 archive_read_format_cpio_read_data, 246 archive_read_format_cpio_skip, 247 NULL, 248 archive_read_format_cpio_cleanup, 249 NULL, 250 NULL); 251 252 if (r != ARCHIVE_OK) 253 free(cpio); 254 return (ARCHIVE_OK); 255 } 256 257 258 static int 259 archive_read_format_cpio_bid(struct archive_read *a, int best_bid) 260 { 261 const unsigned char *p; 262 struct cpio *cpio; 263 int bid; 264 265 (void)best_bid; /* UNUSED */ 266 267 cpio = (struct cpio *)(a->format->data); 268 269 if ((p = __archive_read_ahead(a, 6, NULL)) == NULL) 270 return (-1); 271 272 bid = 0; 273 if (memcmp(p, "070707", 6) == 0) { 274 /* ASCII cpio archive (odc, POSIX.1) */ 275 cpio->read_header = header_odc; 276 bid += 48; 277 /* 278 * XXX TODO: More verification; Could check that only octal 279 * digits appear in appropriate header locations. XXX 280 */ 281 } else if (memcmp(p, "070727", 6) == 0) { 282 /* afio large ASCII cpio archive */ 283 cpio->read_header = header_odc; 284 bid += 48; 285 /* 286 * XXX TODO: More verification; Could check that almost hex 287 * digits appear in appropriate header locations. XXX 288 */ 289 } else if (memcmp(p, "070701", 6) == 0) { 290 /* ASCII cpio archive (SVR4 without CRC) */ 291 cpio->read_header = header_newc; 292 bid += 48; 293 /* 294 * XXX TODO: More verification; Could check that only hex 295 * digits appear in appropriate header locations. XXX 296 */ 297 } else if (memcmp(p, "070702", 6) == 0) { 298 /* ASCII cpio archive (SVR4 with CRC) */ 299 /* XXX TODO: Flag that we should check the CRC. XXX */ 300 cpio->read_header = header_newc; 301 bid += 48; 302 /* 303 * XXX TODO: More verification; Could check that only hex 304 * digits appear in appropriate header locations. XXX 305 */ 306 } else if (p[0] * 256 + p[1] == 070707) { 307 /* big-endian binary cpio archives */ 308 cpio->read_header = header_bin_be; 309 bid += 16; 310 /* Is more verification possible here? */ 311 } else if (p[0] + p[1] * 256 == 070707) { 312 /* little-endian binary cpio archives */ 313 cpio->read_header = header_bin_le; 314 bid += 16; 315 /* Is more verification possible here? */ 316 } else 317 return (ARCHIVE_WARN); 318 319 return (bid); 320 } 321 322 static int 323 archive_read_format_cpio_options(struct archive_read *a, 324 const char *key, const char *val) 325 { 326 struct cpio *cpio; 327 int ret = ARCHIVE_FAILED; 328 329 cpio = (struct cpio *)(a->format->data); 330 if (strcmp(key, "compat-2x") == 0) { 331 /* Handle filenames as libarchive 2.x */ 332 cpio->init_default_conversion = (val != NULL)?1:0; 333 return (ARCHIVE_OK); 334 } else if (strcmp(key, "hdrcharset") == 0) { 335 if (val == NULL || val[0] == 0) 336 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 337 "cpio: hdrcharset option needs a character-set name"); 338 else { 339 cpio->opt_sconv = 340 archive_string_conversion_from_charset( 341 &a->archive, val, 0); 342 if (cpio->opt_sconv != NULL) 343 ret = ARCHIVE_OK; 344 else 345 ret = ARCHIVE_FATAL; 346 } 347 return (ret); 348 } else if (strcmp(key, "pwb") == 0) { 349 if (val != NULL && val[0] != 0) 350 cpio->option_pwb = 1; 351 return (ARCHIVE_OK); 352 } 353 354 /* Note: The "warn" return is just to inform the options 355 * supervisor that we didn't handle it. It will generate 356 * a suitable error if no one used this option. */ 357 return (ARCHIVE_WARN); 358 } 359 360 static int 361 archive_read_format_cpio_read_header(struct archive_read *a, 362 struct archive_entry *entry) 363 { 364 struct cpio *cpio; 365 const void *h, *hl; 366 struct archive_string_conv *sconv; 367 size_t namelength; 368 size_t name_pad; 369 int r; 370 371 cpio = (struct cpio *)(a->format->data); 372 sconv = cpio->opt_sconv; 373 if (sconv == NULL) { 374 if (!cpio->init_default_conversion) { 375 cpio->sconv_default = 376 archive_string_default_conversion_for_read( 377 &(a->archive)); 378 cpio->init_default_conversion = 1; 379 } 380 sconv = cpio->sconv_default; 381 } 382 383 r = (cpio->read_header(a, cpio, entry, &namelength, &name_pad)); 384 385 if (r < ARCHIVE_WARN) 386 return (r); 387 388 /* Read name from buffer. */ 389 h = __archive_read_ahead(a, namelength + name_pad, NULL); 390 if (h == NULL) 391 return (ARCHIVE_FATAL); 392 if (archive_entry_copy_pathname_l(entry, 393 (const char *)h, namelength, sconv) != 0) { 394 if (errno == ENOMEM) { 395 archive_set_error(&a->archive, ENOMEM, 396 "Can't allocate memory for Pathname"); 397 return (ARCHIVE_FATAL); 398 } 399 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 400 "Pathname can't be converted from %s to current locale.", 401 archive_string_conversion_charset_name(sconv)); 402 r = ARCHIVE_WARN; 403 } 404 cpio->entry_offset = 0; 405 406 __archive_read_consume(a, namelength + name_pad); 407 408 /* If this is a symlink, read the link contents. */ 409 if (archive_entry_filetype(entry) == AE_IFLNK) { 410 if (cpio->entry_bytes_remaining > 1024 * 1024) { 411 archive_set_error(&a->archive, ENOMEM, 412 "Rejecting malformed cpio archive: symlink contents exceed 1 megabyte"); 413 return (ARCHIVE_FATAL); 414 } 415 hl = __archive_read_ahead(a, 416 (size_t)cpio->entry_bytes_remaining, NULL); 417 if (hl == NULL) 418 return (ARCHIVE_FATAL); 419 if (archive_entry_copy_symlink_l(entry, (const char *)hl, 420 (size_t)cpio->entry_bytes_remaining, sconv) != 0) { 421 if (errno == ENOMEM) { 422 archive_set_error(&a->archive, ENOMEM, 423 "Can't allocate memory for Linkname"); 424 return (ARCHIVE_FATAL); 425 } 426 archive_set_error(&a->archive, 427 ARCHIVE_ERRNO_FILE_FORMAT, 428 "Linkname can't be converted from %s to " 429 "current locale.", 430 archive_string_conversion_charset_name(sconv)); 431 r = ARCHIVE_WARN; 432 } 433 __archive_read_consume(a, cpio->entry_bytes_remaining); 434 cpio->entry_bytes_remaining = 0; 435 } 436 437 /* XXX TODO: If the full mode is 0160200, then this is a Solaris 438 * ACL description for the following entry. Read this body 439 * and parse it as a Solaris-style ACL, then read the next 440 * header. XXX */ 441 442 /* Compare name to "TRAILER!!!" to test for end-of-archive. */ 443 if (namelength == 11 && strncmp((const char *)h, "TRAILER!!!", 444 11) == 0) { 445 /* TODO: Store file location of start of block. */ 446 archive_clear_error(&a->archive); 447 return (ARCHIVE_EOF); 448 } 449 450 /* Detect and record hardlinks to previously-extracted entries. */ 451 if (record_hardlink(a, cpio, entry) != ARCHIVE_OK) { 452 return (ARCHIVE_FATAL); 453 } 454 455 return (r); 456 } 457 458 static int 459 archive_read_format_cpio_read_data(struct archive_read *a, 460 const void **buff, size_t *size, int64_t *offset) 461 { 462 ssize_t bytes_read; 463 struct cpio *cpio; 464 465 cpio = (struct cpio *)(a->format->data); 466 467 if (cpio->entry_bytes_unconsumed) { 468 __archive_read_consume(a, cpio->entry_bytes_unconsumed); 469 cpio->entry_bytes_unconsumed = 0; 470 } 471 472 if (cpio->entry_bytes_remaining > 0) { 473 *buff = __archive_read_ahead(a, 1, &bytes_read); 474 if (bytes_read <= 0) 475 return (ARCHIVE_FATAL); 476 if (bytes_read > cpio->entry_bytes_remaining) 477 bytes_read = (ssize_t)cpio->entry_bytes_remaining; 478 *size = bytes_read; 479 cpio->entry_bytes_unconsumed = bytes_read; 480 *offset = cpio->entry_offset; 481 cpio->entry_offset += bytes_read; 482 cpio->entry_bytes_remaining -= bytes_read; 483 return (ARCHIVE_OK); 484 } else { 485 if (cpio->entry_padding != 486 __archive_read_consume(a, cpio->entry_padding)) { 487 return (ARCHIVE_FATAL); 488 } 489 cpio->entry_padding = 0; 490 *buff = NULL; 491 *size = 0; 492 *offset = cpio->entry_offset; 493 return (ARCHIVE_EOF); 494 } 495 } 496 497 static int 498 archive_read_format_cpio_skip(struct archive_read *a) 499 { 500 struct cpio *cpio = (struct cpio *)(a->format->data); 501 int64_t to_skip = cpio->entry_bytes_remaining + cpio->entry_padding + 502 cpio->entry_bytes_unconsumed; 503 504 if (to_skip != __archive_read_consume(a, to_skip)) { 505 return (ARCHIVE_FATAL); 506 } 507 cpio->entry_bytes_remaining = 0; 508 cpio->entry_padding = 0; 509 cpio->entry_bytes_unconsumed = 0; 510 return (ARCHIVE_OK); 511 } 512 513 /* 514 * Skip forward to the next cpio newc header by searching for the 515 * 07070[12] string. This should be generalized and merged with 516 * find_odc_header below. 517 */ 518 static int 519 is_hex(const char *p, size_t len) 520 { 521 while (len-- > 0) { 522 if ((*p >= '0' && *p <= '9') 523 || (*p >= 'a' && *p <= 'f') 524 || (*p >= 'A' && *p <= 'F')) 525 ++p; 526 else 527 return (0); 528 } 529 return (1); 530 } 531 532 static int 533 find_newc_header(struct archive_read *a) 534 { 535 const void *h; 536 const char *p, *q; 537 size_t skip, skipped = 0; 538 ssize_t bytes; 539 540 for (;;) { 541 h = __archive_read_ahead(a, newc_header_size, &bytes); 542 if (h == NULL) 543 return (ARCHIVE_FATAL); 544 p = h; 545 q = p + bytes; 546 547 /* Try the typical case first, then go into the slow search.*/ 548 if (memcmp("07070", p, 5) == 0 549 && (p[5] == '1' || p[5] == '2') 550 && is_hex(p, newc_header_size)) 551 return (ARCHIVE_OK); 552 553 /* 554 * Scan ahead until we find something that looks 555 * like a newc header. 556 */ 557 while (p + newc_header_size <= q) { 558 switch (p[5]) { 559 case '1': 560 case '2': 561 if (memcmp("07070", p, 5) == 0 562 && is_hex(p, newc_header_size)) { 563 skip = p - (const char *)h; 564 __archive_read_consume(a, skip); 565 skipped += skip; 566 if (skipped > 0) { 567 archive_set_error(&a->archive, 568 0, 569 "Skipped %d bytes before " 570 "finding valid header", 571 (int)skipped); 572 return (ARCHIVE_WARN); 573 } 574 return (ARCHIVE_OK); 575 } 576 p += 2; 577 break; 578 case '0': 579 p++; 580 break; 581 default: 582 p += 6; 583 break; 584 } 585 } 586 skip = p - (const char *)h; 587 __archive_read_consume(a, skip); 588 skipped += skip; 589 } 590 } 591 592 static int 593 header_newc(struct archive_read *a, struct cpio *cpio, 594 struct archive_entry *entry, size_t *namelength, size_t *name_pad) 595 { 596 const void *h; 597 const char *header; 598 int r; 599 600 r = find_newc_header(a); 601 if (r < ARCHIVE_WARN) 602 return (r); 603 604 /* Read fixed-size portion of header. */ 605 h = __archive_read_ahead(a, newc_header_size, NULL); 606 if (h == NULL) 607 return (ARCHIVE_FATAL); 608 609 /* Parse out hex fields. */ 610 header = (const char *)h; 611 612 if (memcmp(header + newc_magic_offset, "070701", 6) == 0) { 613 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC; 614 a->archive.archive_format_name = "ASCII cpio (SVR4 with no CRC)"; 615 } else if (memcmp(header + newc_magic_offset, "070702", 6) == 0) { 616 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_CRC; 617 a->archive.archive_format_name = "ASCII cpio (SVR4 with CRC)"; 618 } else { 619 /* TODO: Abort here? */ 620 } 621 622 archive_entry_set_devmajor(entry, 623 (dev_t)atol16(header + newc_devmajor_offset, newc_devmajor_size)); 624 archive_entry_set_devminor(entry, 625 (dev_t)atol16(header + newc_devminor_offset, newc_devminor_size)); 626 archive_entry_set_ino(entry, atol16(header + newc_ino_offset, newc_ino_size)); 627 archive_entry_set_mode(entry, 628 (mode_t)atol16(header + newc_mode_offset, newc_mode_size)); 629 archive_entry_set_uid(entry, atol16(header + newc_uid_offset, newc_uid_size)); 630 archive_entry_set_gid(entry, atol16(header + newc_gid_offset, newc_gid_size)); 631 archive_entry_set_nlink(entry, 632 (unsigned int)atol16(header + newc_nlink_offset, newc_nlink_size)); 633 archive_entry_set_rdevmajor(entry, 634 (dev_t)atol16(header + newc_rdevmajor_offset, newc_rdevmajor_size)); 635 archive_entry_set_rdevminor(entry, 636 (dev_t)atol16(header + newc_rdevminor_offset, newc_rdevminor_size)); 637 archive_entry_set_mtime(entry, atol16(header + newc_mtime_offset, newc_mtime_size), 0); 638 *namelength = (size_t)atol16(header + newc_namesize_offset, newc_namesize_size); 639 /* Pad name to 2 more than a multiple of 4. */ 640 *name_pad = (2 - *namelength) & 3; 641 642 /* Make sure that the padded name length fits into size_t. */ 643 if (*name_pad > SIZE_MAX - *namelength) { 644 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 645 "cpio archive has invalid namelength"); 646 return (ARCHIVE_FATAL); 647 } 648 649 /* 650 * Note: entry_bytes_remaining is at least 64 bits and 651 * therefore guaranteed to be big enough for a 33-bit file 652 * size. 653 */ 654 cpio->entry_bytes_remaining = 655 atol16(header + newc_filesize_offset, newc_filesize_size); 656 archive_entry_set_size(entry, cpio->entry_bytes_remaining); 657 /* Pad file contents to a multiple of 4. */ 658 cpio->entry_padding = 3 & -cpio->entry_bytes_remaining; 659 __archive_read_consume(a, newc_header_size); 660 return (r); 661 } 662 663 /* 664 * Skip forward to the next cpio odc header by searching for the 665 * 070707 string. This is a hand-optimized search that could 666 * probably be easily generalized to handle all character-based 667 * cpio variants. 668 */ 669 static int 670 is_octal(const char *p, size_t len) 671 { 672 while (len-- > 0) { 673 if (*p < '0' || *p > '7') 674 return (0); 675 ++p; 676 } 677 return (1); 678 } 679 680 static int 681 is_afio_large(const char *h, size_t len) 682 { 683 if (len < afiol_header_size) 684 return (0); 685 if (h[afiol_ino_m_offset] != 'm' 686 || h[afiol_mtime_n_offset] != 'n' 687 || h[afiol_xsize_s_offset] != 's' 688 || h[afiol_filesize_c_offset] != ':') 689 return (0); 690 if (!is_hex(h + afiol_dev_offset, afiol_ino_m_offset - afiol_dev_offset)) 691 return (0); 692 if (!is_hex(h + afiol_mode_offset, afiol_mtime_n_offset - afiol_mode_offset)) 693 return (0); 694 if (!is_hex(h + afiol_namesize_offset, afiol_xsize_s_offset - afiol_namesize_offset)) 695 return (0); 696 if (!is_hex(h + afiol_filesize_offset, afiol_filesize_size)) 697 return (0); 698 return (1); 699 } 700 701 static int 702 find_odc_header(struct archive_read *a) 703 { 704 const void *h; 705 const char *p, *q; 706 size_t skip, skipped = 0; 707 ssize_t bytes; 708 709 for (;;) { 710 h = __archive_read_ahead(a, odc_header_size, &bytes); 711 if (h == NULL) 712 return (ARCHIVE_FATAL); 713 p = h; 714 q = p + bytes; 715 716 /* Try the typical case first, then go into the slow search.*/ 717 if (memcmp("070707", p, 6) == 0 && is_octal(p, odc_header_size)) 718 return (ARCHIVE_OK); 719 if (memcmp("070727", p, 6) == 0 && is_afio_large(p, bytes)) { 720 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE; 721 return (ARCHIVE_OK); 722 } 723 724 /* 725 * Scan ahead until we find something that looks 726 * like an odc header. 727 */ 728 while (p + odc_header_size <= q) { 729 switch (p[5]) { 730 case '7': 731 if ((memcmp("070707", p, 6) == 0 732 && is_octal(p, odc_header_size)) 733 || (memcmp("070727", p, 6) == 0 734 && is_afio_large(p, q - p))) { 735 skip = p - (const char *)h; 736 __archive_read_consume(a, skip); 737 skipped += skip; 738 if (p[4] == '2') 739 a->archive.archive_format = 740 ARCHIVE_FORMAT_CPIO_AFIO_LARGE; 741 if (skipped > 0) { 742 archive_set_error(&a->archive, 743 0, 744 "Skipped %d bytes before " 745 "finding valid header", 746 (int)skipped); 747 return (ARCHIVE_WARN); 748 } 749 return (ARCHIVE_OK); 750 } 751 p += 2; 752 break; 753 case '0': 754 p++; 755 break; 756 default: 757 p += 6; 758 break; 759 } 760 } 761 skip = p - (const char *)h; 762 __archive_read_consume(a, skip); 763 skipped += skip; 764 } 765 } 766 767 static int 768 header_odc(struct archive_read *a, struct cpio *cpio, 769 struct archive_entry *entry, size_t *namelength, size_t *name_pad) 770 { 771 const void *h; 772 int r; 773 const char *header; 774 775 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX; 776 a->archive.archive_format_name = "POSIX octet-oriented cpio"; 777 778 /* Find the start of the next header. */ 779 r = find_odc_header(a); 780 if (r < ARCHIVE_WARN) 781 return (r); 782 783 if (a->archive.archive_format == ARCHIVE_FORMAT_CPIO_AFIO_LARGE) { 784 int r2 = (header_afiol(a, cpio, entry, namelength, name_pad)); 785 if (r2 == ARCHIVE_OK) 786 return (r); 787 else 788 return (r2); 789 } 790 791 /* Read fixed-size portion of header. */ 792 h = __archive_read_ahead(a, odc_header_size, NULL); 793 if (h == NULL) 794 return (ARCHIVE_FATAL); 795 796 /* Parse out octal fields. */ 797 header = (const char *)h; 798 799 archive_entry_set_dev(entry, 800 (dev_t)atol8(header + odc_dev_offset, odc_dev_size)); 801 archive_entry_set_ino(entry, atol8(header + odc_ino_offset, odc_ino_size)); 802 archive_entry_set_mode(entry, 803 (mode_t)atol8(header + odc_mode_offset, odc_mode_size)); 804 archive_entry_set_uid(entry, atol8(header + odc_uid_offset, odc_uid_size)); 805 archive_entry_set_gid(entry, atol8(header + odc_gid_offset, odc_gid_size)); 806 archive_entry_set_nlink(entry, 807 (unsigned int)atol8(header + odc_nlink_offset, odc_nlink_size)); 808 archive_entry_set_rdev(entry, 809 (dev_t)atol8(header + odc_rdev_offset, odc_rdev_size)); 810 archive_entry_set_mtime(entry, atol8(header + odc_mtime_offset, odc_mtime_size), 0); 811 *namelength = (size_t)atol8(header + odc_namesize_offset, odc_namesize_size); 812 *name_pad = 0; /* No padding of filename. */ 813 814 /* 815 * Note: entry_bytes_remaining is at least 64 bits and 816 * therefore guaranteed to be big enough for a 33-bit file 817 * size. 818 */ 819 cpio->entry_bytes_remaining = 820 atol8(header + odc_filesize_offset, odc_filesize_size); 821 archive_entry_set_size(entry, cpio->entry_bytes_remaining); 822 cpio->entry_padding = 0; 823 __archive_read_consume(a, odc_header_size); 824 return (r); 825 } 826 827 /* 828 * NOTE: if a filename suffix is ".z", it is the file gziped by afio. 829 * it would be nice that we can show uncompressed file size and we can 830 * uncompressed file contents automatically, unfortunately we have nothing 831 * to get a uncompressed file size while reading each header. It means 832 * we also cannot uncompress file contents under our framework. 833 */ 834 static int 835 header_afiol(struct archive_read *a, struct cpio *cpio, 836 struct archive_entry *entry, size_t *namelength, size_t *name_pad) 837 { 838 const void *h; 839 const char *header; 840 841 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE; 842 a->archive.archive_format_name = "afio large ASCII"; 843 844 /* Read fixed-size portion of header. */ 845 h = __archive_read_ahead(a, afiol_header_size, NULL); 846 if (h == NULL) 847 return (ARCHIVE_FATAL); 848 849 /* Parse out octal fields. */ 850 header = (const char *)h; 851 852 archive_entry_set_dev(entry, 853 (dev_t)atol16(header + afiol_dev_offset, afiol_dev_size)); 854 archive_entry_set_ino(entry, atol16(header + afiol_ino_offset, afiol_ino_size)); 855 archive_entry_set_mode(entry, 856 (mode_t)atol8(header + afiol_mode_offset, afiol_mode_size)); 857 archive_entry_set_uid(entry, atol16(header + afiol_uid_offset, afiol_uid_size)); 858 archive_entry_set_gid(entry, atol16(header + afiol_gid_offset, afiol_gid_size)); 859 archive_entry_set_nlink(entry, 860 (unsigned int)atol16(header + afiol_nlink_offset, afiol_nlink_size)); 861 archive_entry_set_rdev(entry, 862 (dev_t)atol16(header + afiol_rdev_offset, afiol_rdev_size)); 863 archive_entry_set_mtime(entry, atol16(header + afiol_mtime_offset, afiol_mtime_size), 0); 864 *namelength = (size_t)atol16(header + afiol_namesize_offset, afiol_namesize_size); 865 *name_pad = 0; /* No padding of filename. */ 866 867 cpio->entry_bytes_remaining = 868 atol16(header + afiol_filesize_offset, afiol_filesize_size); 869 archive_entry_set_size(entry, cpio->entry_bytes_remaining); 870 cpio->entry_padding = 0; 871 __archive_read_consume(a, afiol_header_size); 872 return (ARCHIVE_OK); 873 } 874 875 876 static int 877 header_bin_le(struct archive_read *a, struct cpio *cpio, 878 struct archive_entry *entry, size_t *namelength, size_t *name_pad) 879 { 880 const void *h; 881 const unsigned char *header; 882 883 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_LE; 884 a->archive.archive_format_name = "cpio (little-endian binary)"; 885 886 /* Read fixed-size portion of header. */ 887 h = __archive_read_ahead(a, bin_header_size, NULL); 888 if (h == NULL) { 889 archive_set_error(&a->archive, 0, 890 "End of file trying to read next cpio header"); 891 return (ARCHIVE_FATAL); 892 } 893 894 /* Parse out binary fields. */ 895 header = (const unsigned char *)h; 896 897 archive_entry_set_dev(entry, header[bin_dev_offset] + header[bin_dev_offset + 1] * 256); 898 archive_entry_set_ino(entry, header[bin_ino_offset] + header[bin_ino_offset + 1] * 256); 899 archive_entry_set_mode(entry, header[bin_mode_offset] + header[bin_mode_offset + 1] * 256); 900 if (cpio->option_pwb) { 901 /* turn off random bits left over from V6 inode */ 902 archive_entry_set_mode(entry, archive_entry_mode(entry) & 067777); 903 if ((archive_entry_mode(entry) & AE_IFMT) == 0) 904 archive_entry_set_mode(entry, archive_entry_mode(entry) | AE_IFREG); 905 } 906 archive_entry_set_uid(entry, header[bin_uid_offset] + header[bin_uid_offset + 1] * 256); 907 archive_entry_set_gid(entry, header[bin_gid_offset] + header[bin_gid_offset + 1] * 256); 908 archive_entry_set_nlink(entry, header[bin_nlink_offset] + header[bin_nlink_offset + 1] * 256); 909 archive_entry_set_rdev(entry, header[bin_rdev_offset] + header[bin_rdev_offset + 1] * 256); 910 archive_entry_set_mtime(entry, le4(header + bin_mtime_offset), 0); 911 *namelength = header[bin_namesize_offset] + header[bin_namesize_offset + 1] * 256; 912 *name_pad = *namelength & 1; /* Pad to even. */ 913 914 cpio->entry_bytes_remaining = le4(header + bin_filesize_offset); 915 archive_entry_set_size(entry, cpio->entry_bytes_remaining); 916 cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */ 917 __archive_read_consume(a, bin_header_size); 918 return (ARCHIVE_OK); 919 } 920 921 static int 922 header_bin_be(struct archive_read *a, struct cpio *cpio, 923 struct archive_entry *entry, size_t *namelength, size_t *name_pad) 924 { 925 const void *h; 926 const unsigned char *header; 927 928 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_BE; 929 a->archive.archive_format_name = "cpio (big-endian binary)"; 930 931 /* Read fixed-size portion of header. */ 932 h = __archive_read_ahead(a, bin_header_size, NULL); 933 if (h == NULL) { 934 archive_set_error(&a->archive, 0, 935 "End of file trying to read next cpio header"); 936 return (ARCHIVE_FATAL); 937 } 938 939 /* Parse out binary fields. */ 940 header = (const unsigned char *)h; 941 942 archive_entry_set_dev(entry, header[bin_dev_offset] * 256 + header[bin_dev_offset + 1]); 943 archive_entry_set_ino(entry, header[bin_ino_offset] * 256 + header[bin_ino_offset + 1]); 944 archive_entry_set_mode(entry, header[bin_mode_offset] * 256 + header[bin_mode_offset + 1]); 945 if (cpio->option_pwb) { 946 /* turn off random bits left over from V6 inode */ 947 archive_entry_set_mode(entry, archive_entry_mode(entry) & 067777); 948 if ((archive_entry_mode(entry) & AE_IFMT) == 0) 949 archive_entry_set_mode(entry, archive_entry_mode(entry) | AE_IFREG); 950 } 951 archive_entry_set_uid(entry, header[bin_uid_offset] * 256 + header[bin_uid_offset + 1]); 952 archive_entry_set_gid(entry, header[bin_gid_offset] * 256 + header[bin_gid_offset + 1]); 953 archive_entry_set_nlink(entry, header[bin_nlink_offset] * 256 + header[bin_nlink_offset + 1]); 954 archive_entry_set_rdev(entry, header[bin_rdev_offset] * 256 + header[bin_rdev_offset + 1]); 955 archive_entry_set_mtime(entry, be4(header + bin_mtime_offset), 0); 956 *namelength = header[bin_namesize_offset] * 256 + header[bin_namesize_offset + 1]; 957 *name_pad = *namelength & 1; /* Pad to even. */ 958 959 cpio->entry_bytes_remaining = be4(header + bin_filesize_offset); 960 archive_entry_set_size(entry, cpio->entry_bytes_remaining); 961 cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */ 962 __archive_read_consume(a, bin_header_size); 963 return (ARCHIVE_OK); 964 } 965 966 static int 967 archive_read_format_cpio_cleanup(struct archive_read *a) 968 { 969 struct cpio *cpio; 970 971 cpio = (struct cpio *)(a->format->data); 972 /* Free inode->name map */ 973 while (cpio->links_head != NULL) { 974 struct links_entry *lp = cpio->links_head->next; 975 976 free(cpio->links_head->name); 977 free(cpio->links_head); 978 cpio->links_head = lp; 979 } 980 free(cpio); 981 (a->format->data) = NULL; 982 return (ARCHIVE_OK); 983 } 984 985 static int64_t 986 le4(const unsigned char *p) 987 { 988 return ((p[0] << 16) + (((int64_t)p[1]) << 24) + (p[2] << 0) + (p[3] << 8)); 989 } 990 991 992 static int64_t 993 be4(const unsigned char *p) 994 { 995 return ((((int64_t)p[0]) << 24) + (p[1] << 16) + (p[2] << 8) + (p[3])); 996 } 997 998 /* 999 * Note that this implementation does not (and should not!) obey 1000 * locale settings; you cannot simply substitute strtol here, since 1001 * it does obey locale. 1002 */ 1003 static int64_t 1004 atol8(const char *p, unsigned char_cnt) 1005 { 1006 int64_t l; 1007 int digit; 1008 1009 l = 0; 1010 while (char_cnt-- > 0) { 1011 if (*p >= '0' && *p <= '7') 1012 digit = *p - '0'; 1013 else 1014 return (l); 1015 p++; 1016 l <<= 3; 1017 l |= digit; 1018 } 1019 return (l); 1020 } 1021 1022 static int64_t 1023 atol16(const char *p, unsigned char_cnt) 1024 { 1025 int64_t l; 1026 int digit; 1027 1028 l = 0; 1029 while (char_cnt-- > 0) { 1030 if (*p >= 'a' && *p <= 'f') 1031 digit = *p - 'a' + 10; 1032 else if (*p >= 'A' && *p <= 'F') 1033 digit = *p - 'A' + 10; 1034 else if (*p >= '0' && *p <= '9') 1035 digit = *p - '0'; 1036 else 1037 return (l); 1038 p++; 1039 l <<= 4; 1040 l |= digit; 1041 } 1042 return (l); 1043 } 1044 1045 static int 1046 record_hardlink(struct archive_read *a, 1047 struct cpio *cpio, struct archive_entry *entry) 1048 { 1049 struct links_entry *le; 1050 dev_t dev; 1051 int64_t ino; 1052 1053 if (archive_entry_nlink(entry) <= 1) 1054 return (ARCHIVE_OK); 1055 1056 dev = archive_entry_dev(entry); 1057 ino = archive_entry_ino64(entry); 1058 1059 /* 1060 * First look in the list of multiply-linked files. If we've 1061 * already dumped it, convert this entry to a hard link entry. 1062 */ 1063 for (le = cpio->links_head; le; le = le->next) { 1064 if (le->dev == dev && le->ino == ino) { 1065 archive_entry_copy_hardlink(entry, le->name); 1066 1067 if (--le->links <= 0) { 1068 if (le->previous != NULL) 1069 le->previous->next = le->next; 1070 if (le->next != NULL) 1071 le->next->previous = le->previous; 1072 if (cpio->links_head == le) 1073 cpio->links_head = le->next; 1074 free(le->name); 1075 free(le); 1076 } 1077 1078 return (ARCHIVE_OK); 1079 } 1080 } 1081 1082 le = (struct links_entry *)malloc(sizeof(struct links_entry)); 1083 if (le == NULL) { 1084 archive_set_error(&a->archive, 1085 ENOMEM, "Out of memory adding file to list"); 1086 return (ARCHIVE_FATAL); 1087 } 1088 if (cpio->links_head != NULL) 1089 cpio->links_head->previous = le; 1090 le->next = cpio->links_head; 1091 le->previous = NULL; 1092 cpio->links_head = le; 1093 le->dev = dev; 1094 le->ino = ino; 1095 le->links = archive_entry_nlink(entry) - 1; 1096 le->name = strdup(archive_entry_pathname(entry)); 1097 if (le->name == NULL) { 1098 archive_set_error(&a->archive, 1099 ENOMEM, "Out of memory adding file to list"); 1100 return (ARCHIVE_FATAL); 1101 } 1102 1103 return (ARCHIVE_OK); 1104 } 1105