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 } 1066