1 /*- 2 * Copyright (c) 2003-2009 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_disk_entry_from_file.c 201084 2009-12-28 02:14:09Z kientzle $"); 29 30 /* This is the tree-walking code for POSIX systems. */ 31 #if !defined(_WIN32) || defined(__CYGWIN__) 32 33 #ifdef HAVE_SYS_TYPES_H 34 /* Mac OSX requires sys/types.h before sys/acl.h. */ 35 #include <sys/types.h> 36 #endif 37 #ifdef HAVE_SYS_ACL_H 38 #include <sys/acl.h> 39 #endif 40 #ifdef HAVE_SYS_EXTATTR_H 41 #include <sys/extattr.h> 42 #endif 43 #ifdef HAVE_SYS_IOCTL_H 44 #include <sys/ioctl.h> 45 #endif 46 #ifdef HAVE_SYS_PARAM_H 47 #include <sys/param.h> 48 #endif 49 #ifdef HAVE_SYS_STAT_H 50 #include <sys/stat.h> 51 #endif 52 #ifdef HAVE_SYS_XATTR_H 53 #include <sys/xattr.h> 54 #endif 55 #ifdef HAVE_SYS_EA_H 56 #include <sys/ea.h> 57 #endif 58 #ifdef HAVE_ACL_LIBACL_H 59 #include <acl/libacl.h> 60 #endif 61 #ifdef HAVE_ATTR_XATTR_H 62 #include <attr/xattr.h> 63 #endif 64 #ifdef HAVE_COPYFILE_H 65 #include <copyfile.h> 66 #endif 67 #ifdef HAVE_ERRNO_H 68 #include <errno.h> 69 #endif 70 #ifdef HAVE_FCNTL_H 71 #include <fcntl.h> 72 #endif 73 #ifdef HAVE_LIMITS_H 74 #include <limits.h> 75 #endif 76 #ifdef HAVE_LINUX_TYPES_H 77 #include <linux/types.h> 78 #endif 79 #ifdef HAVE_LINUX_FIEMAP_H 80 #include <linux/fiemap.h> 81 #endif 82 #ifdef HAVE_LINUX_FS_H 83 #include <linux/fs.h> 84 #endif 85 /* 86 * Some Linux distributions have both linux/ext2_fs.h and ext2fs/ext2_fs.h. 87 * As the include guards don't agree, the order of include is important. 88 */ 89 #ifdef HAVE_LINUX_EXT2_FS_H 90 #include <linux/ext2_fs.h> /* for Linux file flags */ 91 #endif 92 #if defined(HAVE_EXT2FS_EXT2_FS_H) && !defined(__CYGWIN__) 93 #include <ext2fs/ext2_fs.h> /* Linux file flags, broken on Cygwin */ 94 #endif 95 #ifdef HAVE_PATHS_H 96 #include <paths.h> 97 #endif 98 #ifdef HAVE_UNISTD_H 99 #include <unistd.h> 100 #endif 101 102 #include "archive.h" 103 #include "archive_entry.h" 104 #include "archive_private.h" 105 #include "archive_read_disk_private.h" 106 107 /* 108 * Linux and FreeBSD plug this obvious hole in POSIX.1e in 109 * different ways. 110 */ 111 #if HAVE_ACL_GET_PERM 112 #define ACL_GET_PERM acl_get_perm 113 #elif HAVE_ACL_GET_PERM_NP 114 #define ACL_GET_PERM acl_get_perm_np 115 #endif 116 117 static int setup_acls_posix1e(struct archive_read_disk *, 118 struct archive_entry *, int *fd); 119 static int setup_mac_metadata(struct archive_read_disk *, 120 struct archive_entry *, int *fd); 121 static int setup_xattrs(struct archive_read_disk *, 122 struct archive_entry *, int *fd); 123 static int setup_sparse(struct archive_read_disk *, 124 struct archive_entry *, int *fd); 125 126 int 127 archive_read_disk_entry_from_file(struct archive *_a, 128 struct archive_entry *entry, 129 int fd, 130 const struct stat *st) 131 { 132 struct archive_read_disk *a = (struct archive_read_disk *)_a; 133 const char *path, *name; 134 struct stat s; 135 int initial_fd = fd; 136 int r, r1; 137 138 archive_clear_error(_a); 139 path = archive_entry_sourcepath(entry); 140 if (path == NULL) 141 path = archive_entry_pathname(entry); 142 143 if (a->tree == NULL) { 144 if (st == NULL) { 145 #if HAVE_FSTAT 146 if (fd >= 0) { 147 if (fstat(fd, &s) != 0) { 148 archive_set_error(&a->archive, errno, 149 "Can't fstat"); 150 return (ARCHIVE_FAILED); 151 } 152 } else 153 #endif 154 #if HAVE_LSTAT 155 if (!a->follow_symlinks) { 156 if (lstat(path, &s) != 0) { 157 archive_set_error(&a->archive, errno, 158 "Can't lstat %s", path); 159 return (ARCHIVE_FAILED); 160 } 161 } else 162 #endif 163 if (stat(path, &s) != 0) { 164 archive_set_error(&a->archive, errno, 165 "Can't stat %s", path); 166 return (ARCHIVE_FAILED); 167 } 168 st = &s; 169 } 170 archive_entry_copy_stat(entry, st); 171 /* Lookup uname/gname */ 172 name = archive_read_disk_uname(_a, archive_entry_uid(entry)); 173 if (name != NULL) 174 archive_entry_copy_uname(entry, name); 175 name = archive_read_disk_gname(_a, archive_entry_gid(entry)); 176 if (name != NULL) 177 archive_entry_copy_gname(entry, name); 178 } 179 180 #ifdef HAVE_STRUCT_STAT_ST_FLAGS 181 /* On FreeBSD, we get flags for free with the stat. */ 182 /* TODO: Does this belong in copy_stat()? */ 183 if (st->st_flags != 0) 184 archive_entry_set_fflags(entry, st->st_flags, 0); 185 #endif 186 187 #if defined(EXT2_IOC_GETFLAGS) && defined(HAVE_WORKING_EXT2_IOC_GETFLAGS) 188 /* Linux requires an extra ioctl to pull the flags. Although 189 * this is an extra step, it has a nice side-effect: We get an 190 * open file descriptor which we can use in the subsequent lookups. */ 191 if ((S_ISREG(st->st_mode) || S_ISDIR(st->st_mode))) { 192 if (fd < 0) { 193 if (a->tree != NULL) 194 fd = a->open_on_current_dir(a->tree, path, 195 O_RDONLY | O_NONBLOCK); 196 else 197 fd = open(path, O_RDONLY | O_NONBLOCK); 198 } 199 if (fd >= 0) { 200 unsigned long stflags; 201 r = ioctl(fd, EXT2_IOC_GETFLAGS, &stflags); 202 if (r == 0 && stflags != 0) 203 archive_entry_set_fflags(entry, stflags, 0); 204 } 205 } 206 #endif 207 208 #if defined(HAVE_READLINK) || defined(HAVE_READLINKAT) 209 if (S_ISLNK(st->st_mode)) { 210 size_t linkbuffer_len = st->st_size + 1; 211 char *linkbuffer; 212 int lnklen; 213 214 linkbuffer = malloc(linkbuffer_len); 215 if (linkbuffer == NULL) { 216 archive_set_error(&a->archive, ENOMEM, 217 "Couldn't read link data"); 218 return (ARCHIVE_FAILED); 219 } 220 if (a->tree != NULL) { 221 #ifdef HAVE_READLINKAT 222 lnklen = readlinkat(a->tree_current_dir_fd(a->tree), 223 path, linkbuffer, linkbuffer_len); 224 #else 225 if (a->tree_enter_working_dir(a->tree) != 0) { 226 archive_set_error(&a->archive, errno, 227 "Couldn't read link data"); 228 free(linkbuffer); 229 return (ARCHIVE_FAILED); 230 } 231 lnklen = readlink(path, linkbuffer, linkbuffer_len); 232 #endif /* HAVE_READLINKAT */ 233 } else 234 lnklen = readlink(path, linkbuffer, linkbuffer_len); 235 if (lnklen < 0) { 236 archive_set_error(&a->archive, errno, 237 "Couldn't read link data"); 238 free(linkbuffer); 239 return (ARCHIVE_FAILED); 240 } 241 linkbuffer[lnklen] = 0; 242 archive_entry_set_symlink(entry, linkbuffer); 243 free(linkbuffer); 244 } 245 #endif /* HAVE_READLINK || HAVE_READLINKAT */ 246 247 r = setup_acls_posix1e(a, entry, &fd); 248 r1 = setup_xattrs(a, entry, &fd); 249 if (r1 < r) 250 r = r1; 251 if (a->enable_copyfile) { 252 r1 = setup_mac_metadata(a, entry, &fd); 253 if (r1 < r) 254 r = r1; 255 } 256 r1 = setup_sparse(a, entry, &fd); 257 if (r1 < r) 258 r = r1; 259 260 /* If we opened the file earlier in this function, close it. */ 261 if (initial_fd != fd) 262 close(fd); 263 return (r); 264 } 265 266 #if defined(__APPLE__) && defined(HAVE_COPYFILE_H) 267 /* 268 * The Mac OS "copyfile()" API copies the extended metadata for a 269 * file into a separate file in AppleDouble format (see RFC 1740). 270 * 271 * Mac OS tar and cpio implementations store this extended 272 * metadata as a separate entry just before the regular entry 273 * with a "._" prefix added to the filename. 274 * 275 * Note that this is currently done unconditionally; the tar program has 276 * an option to discard this information before the archive is written. 277 * 278 * TODO: If there's a failure, report it and return ARCHIVE_WARN. 279 */ 280 static int 281 setup_mac_metadata(struct archive_read_disk *a, 282 struct archive_entry *entry, int *fd) 283 { 284 int tempfd = -1; 285 int copyfile_flags = COPYFILE_NOFOLLOW | COPYFILE_ACL | COPYFILE_XATTR; 286 struct stat copyfile_stat; 287 int ret = ARCHIVE_OK; 288 void *buff; 289 int have_attrs; 290 const char *name, *tempdir, *tempfile = NULL; 291 292 (void)fd; /* UNUSED */ 293 name = archive_entry_sourcepath(entry); 294 if (name == NULL) 295 name = archive_entry_pathname(entry); 296 if (name == NULL) { 297 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 298 "Can't open file to read extended attributes: No name"); 299 return (ARCHIVE_WARN); 300 } 301 302 if (a->tree != NULL) { 303 if (a->tree_enter_working_dir(a->tree) != 0) { 304 archive_set_error(&a->archive, errno, 305 "Couldn't change dir"); 306 return (ARCHIVE_FAILED); 307 } 308 } 309 310 /* Short-circuit if there's nothing to do. */ 311 have_attrs = copyfile(name, NULL, 0, copyfile_flags | COPYFILE_CHECK); 312 if (have_attrs == -1) { 313 archive_set_error(&a->archive, errno, 314 "Could not check extended attributes"); 315 return (ARCHIVE_WARN); 316 } 317 if (have_attrs == 0) 318 return (ARCHIVE_OK); 319 320 tempdir = NULL; 321 if (issetugid() == 0) 322 tempdir = getenv("TMPDIR"); 323 if (tempdir == NULL) 324 tempdir = _PATH_TMP; 325 tempfile = tempnam(tempdir, "tar.md."); 326 327 /* XXX I wish copyfile() could pack directly to a memory 328 * buffer; that would avoid the temp file here. For that 329 * matter, it would be nice if fcopyfile() actually worked, 330 * that would reduce the many open/close races here. */ 331 if (copyfile(name, tempfile, 0, copyfile_flags | COPYFILE_PACK)) { 332 archive_set_error(&a->archive, errno, 333 "Could not pack extended attributes"); 334 ret = ARCHIVE_WARN; 335 goto cleanup; 336 } 337 tempfd = open(tempfile, O_RDONLY); 338 if (tempfd < 0) { 339 archive_set_error(&a->archive, errno, 340 "Could not open extended attribute file"); 341 ret = ARCHIVE_WARN; 342 goto cleanup; 343 } 344 if (fstat(tempfd, ©file_stat)) { 345 archive_set_error(&a->archive, errno, 346 "Could not check size of extended attributes"); 347 ret = ARCHIVE_WARN; 348 goto cleanup; 349 } 350 buff = malloc(copyfile_stat.st_size); 351 if (buff == NULL) { 352 archive_set_error(&a->archive, errno, 353 "Could not allocate memory for extended attributes"); 354 ret = ARCHIVE_WARN; 355 goto cleanup; 356 } 357 if (copyfile_stat.st_size != read(tempfd, buff, copyfile_stat.st_size)) { 358 archive_set_error(&a->archive, errno, 359 "Could not read extended attributes into memory"); 360 ret = ARCHIVE_WARN; 361 goto cleanup; 362 } 363 archive_entry_copy_mac_metadata(entry, buff, copyfile_stat.st_size); 364 365 cleanup: 366 if (tempfd >= 0) 367 close(tempfd); 368 if (tempfile != NULL) 369 unlink(tempfile); 370 return (ret); 371 } 372 373 #else 374 375 /* 376 * Stub implementation for non-Mac systems. 377 */ 378 static int 379 setup_mac_metadata(struct archive_read_disk *a, 380 struct archive_entry *entry, int *fd) 381 { 382 (void)a; /* UNUSED */ 383 (void)entry; /* UNUSED */ 384 (void)fd; /* UNUSED */ 385 return (ARCHIVE_OK); 386 } 387 #endif 388 389 390 #ifdef HAVE_POSIX_ACL 391 static void setup_acl_posix1e(struct archive_read_disk *a, 392 struct archive_entry *entry, acl_t acl, int archive_entry_acl_type); 393 394 static int 395 setup_acls_posix1e(struct archive_read_disk *a, 396 struct archive_entry *entry, int *fd) 397 { 398 const char *accpath; 399 acl_t acl; 400 401 accpath = archive_entry_sourcepath(entry); 402 if (accpath == NULL) 403 accpath = archive_entry_pathname(entry); 404 405 archive_entry_acl_clear(entry); 406 407 if (*fd < 0 && a->tree != NULL && 408 (a->follow_symlinks || archive_entry_filetype(entry) != AE_IFLNK)){ 409 *fd = a->open_on_current_dir(a->tree, accpath, 410 O_RDONLY | O_NONBLOCK); 411 if (*fd < 0) { 412 archive_set_error(&a->archive, errno, 413 "Couldn't access %s", accpath); 414 return (ARCHIVE_FAILED); 415 } 416 } 417 418 /* Retrieve access ACL from file. */ 419 if (*fd >= 0) 420 acl = acl_get_fd(*fd); 421 #if HAVE_ACL_GET_LINK_NP 422 else if (!a->follow_symlinks) 423 acl = acl_get_link_np(accpath, ACL_TYPE_ACCESS); 424 #else 425 else if ((!a->follow_symlinks) 426 && (archive_entry_filetype(entry) == AE_IFLNK)) 427 /* We can't get the ACL of a symlink, so we assume it can't 428 have one. */ 429 acl = NULL; 430 #endif 431 else 432 acl = acl_get_file(accpath, ACL_TYPE_ACCESS); 433 if (acl != NULL) { 434 setup_acl_posix1e(a, entry, acl, 435 ARCHIVE_ENTRY_ACL_TYPE_ACCESS); 436 acl_free(acl); 437 } 438 439 /* Only directories can have default ACLs. */ 440 if (S_ISDIR(archive_entry_mode(entry))) { 441 acl = acl_get_file(accpath, ACL_TYPE_DEFAULT); 442 if (acl != NULL) { 443 setup_acl_posix1e(a, entry, acl, 444 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT); 445 acl_free(acl); 446 } 447 } 448 return (ARCHIVE_OK); 449 } 450 451 /* 452 * Translate POSIX.1e ACL into libarchive internal structure. 453 */ 454 static void 455 setup_acl_posix1e(struct archive_read_disk *a, 456 struct archive_entry *entry, acl_t acl, int archive_entry_acl_type) 457 { 458 acl_tag_t acl_tag; 459 acl_entry_t acl_entry; 460 acl_permset_t acl_permset; 461 int s, ae_id, ae_tag, ae_perm; 462 const char *ae_name; 463 464 s = acl_get_entry(acl, ACL_FIRST_ENTRY, &acl_entry); 465 while (s == 1) { 466 ae_id = -1; 467 ae_name = NULL; 468 469 acl_get_tag_type(acl_entry, &acl_tag); 470 if (acl_tag == ACL_USER) { 471 ae_id = (int)*(uid_t *)acl_get_qualifier(acl_entry); 472 ae_name = archive_read_disk_uname(&a->archive, ae_id); 473 ae_tag = ARCHIVE_ENTRY_ACL_USER; 474 } else if (acl_tag == ACL_GROUP) { 475 ae_id = (int)*(gid_t *)acl_get_qualifier(acl_entry); 476 ae_name = archive_read_disk_gname(&a->archive, ae_id); 477 ae_tag = ARCHIVE_ENTRY_ACL_GROUP; 478 } else if (acl_tag == ACL_MASK) { 479 ae_tag = ARCHIVE_ENTRY_ACL_MASK; 480 } else if (acl_tag == ACL_USER_OBJ) { 481 ae_tag = ARCHIVE_ENTRY_ACL_USER_OBJ; 482 } else if (acl_tag == ACL_GROUP_OBJ) { 483 ae_tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; 484 } else if (acl_tag == ACL_OTHER) { 485 ae_tag = ARCHIVE_ENTRY_ACL_OTHER; 486 } else { 487 /* Skip types that libarchive can't support. */ 488 continue; 489 } 490 491 acl_get_permset(acl_entry, &acl_permset); 492 ae_perm = 0; 493 /* 494 * acl_get_perm() is spelled differently on different 495 * platforms; see above. 496 */ 497 if (ACL_GET_PERM(acl_permset, ACL_EXECUTE)) 498 ae_perm |= ARCHIVE_ENTRY_ACL_EXECUTE; 499 if (ACL_GET_PERM(acl_permset, ACL_READ)) 500 ae_perm |= ARCHIVE_ENTRY_ACL_READ; 501 if (ACL_GET_PERM(acl_permset, ACL_WRITE)) 502 ae_perm |= ARCHIVE_ENTRY_ACL_WRITE; 503 504 archive_entry_acl_add_entry(entry, 505 archive_entry_acl_type, ae_perm, ae_tag, 506 ae_id, ae_name); 507 508 s = acl_get_entry(acl, ACL_NEXT_ENTRY, &acl_entry); 509 } 510 } 511 #else 512 static int 513 setup_acls_posix1e(struct archive_read_disk *a, 514 struct archive_entry *entry, int *fd) 515 { 516 (void)a; /* UNUSED */ 517 (void)entry; /* UNUSED */ 518 (void)fd; /* UNUSED */ 519 return (ARCHIVE_OK); 520 } 521 #endif 522 523 #if (HAVE_FGETXATTR && HAVE_FLISTXATTR && HAVE_LISTXATTR && \ 524 HAVE_LLISTXATTR && HAVE_GETXATTR && HAVE_LGETXATTR) || \ 525 (HAVE_FGETEA && HAVE_FLISTEA && HAVE_LISTEA) 526 527 /* 528 * Linux and AIX extended attribute support. 529 * 530 * TODO: By using a stack-allocated buffer for the first 531 * call to getxattr(), we might be able to avoid the second 532 * call entirely. We only need the second call if the 533 * stack-allocated buffer is too small. But a modest buffer 534 * of 1024 bytes or so will often be big enough. Same applies 535 * to listxattr(). 536 */ 537 538 539 static int 540 setup_xattr(struct archive_read_disk *a, 541 struct archive_entry *entry, const char *name, int fd) 542 { 543 ssize_t size; 544 void *value = NULL; 545 const char *accpath; 546 547 accpath = archive_entry_sourcepath(entry); 548 if (accpath == NULL) 549 accpath = archive_entry_pathname(entry); 550 551 #if HAVE_FGETXATTR 552 if (fd >= 0) 553 size = fgetxattr(fd, name, NULL, 0); 554 else if (!a->follow_symlinks) 555 size = lgetxattr(accpath, name, NULL, 0); 556 else 557 size = getxattr(accpath, name, NULL, 0); 558 #elif HAVE_FGETEA 559 if (fd >= 0) 560 size = fgetea(fd, name, NULL, 0); 561 else if (!a->follow_symlinks) 562 size = lgetea(accpath, name, NULL, 0); 563 else 564 size = getea(accpath, name, NULL, 0); 565 #endif 566 567 if (size == -1) { 568 archive_set_error(&a->archive, errno, 569 "Couldn't query extended attribute"); 570 return (ARCHIVE_WARN); 571 } 572 573 if (size > 0 && (value = malloc(size)) == NULL) { 574 archive_set_error(&a->archive, errno, "Out of memory"); 575 return (ARCHIVE_FATAL); 576 } 577 578 #if HAVE_FGETXATTR 579 if (fd >= 0) 580 size = fgetxattr(fd, name, value, size); 581 else if (!a->follow_symlinks) 582 size = lgetxattr(accpath, name, value, size); 583 else 584 size = getxattr(accpath, name, value, size); 585 #elif HAVE_FGETEA 586 if (fd >= 0) 587 size = fgetea(fd, name, value, size); 588 else if (!a->follow_symlinks) 589 size = lgetea(accpath, name, value, size); 590 else 591 size = getea(accpath, name, value, size); 592 #endif 593 594 if (size == -1) { 595 archive_set_error(&a->archive, errno, 596 "Couldn't read extended attribute"); 597 return (ARCHIVE_WARN); 598 } 599 600 archive_entry_xattr_add_entry(entry, name, value, size); 601 602 free(value); 603 return (ARCHIVE_OK); 604 } 605 606 static int 607 setup_xattrs(struct archive_read_disk *a, 608 struct archive_entry *entry, int *fd) 609 { 610 char *list, *p; 611 const char *path; 612 ssize_t list_size; 613 614 path = archive_entry_sourcepath(entry); 615 if (path == NULL) 616 path = archive_entry_pathname(entry); 617 618 if (*fd < 0 && a->tree != NULL) { 619 if (a->follow_symlinks || 620 archive_entry_filetype(entry) != AE_IFLNK) 621 *fd = a->open_on_current_dir(a->tree, path, 622 O_RDONLY | O_NONBLOCK); 623 if (*fd < 0) { 624 if (a->tree_enter_working_dir(a->tree) != 0) { 625 archive_set_error(&a->archive, errno, 626 "Couldn't access %s", path); 627 return (ARCHIVE_FAILED); 628 } 629 } 630 } 631 632 #if HAVE_FLISTXATTR 633 if (*fd >= 0) 634 list_size = flistxattr(*fd, NULL, 0); 635 else if (!a->follow_symlinks) 636 list_size = llistxattr(path, NULL, 0); 637 else 638 list_size = listxattr(path, NULL, 0); 639 #elif HAVE_FLISTEA 640 if (*fd >= 0) 641 list_size = flistea(*fd, NULL, 0); 642 else if (!a->follow_symlinks) 643 list_size = llistea(path, NULL, 0); 644 else 645 list_size = listea(path, NULL, 0); 646 #endif 647 648 if (list_size == -1) { 649 if (errno == ENOTSUP || errno == ENOSYS) 650 return (ARCHIVE_OK); 651 archive_set_error(&a->archive, errno, 652 "Couldn't list extended attributes"); 653 return (ARCHIVE_WARN); 654 } 655 656 if (list_size == 0) 657 return (ARCHIVE_OK); 658 659 if ((list = malloc(list_size)) == NULL) { 660 archive_set_error(&a->archive, errno, "Out of memory"); 661 return (ARCHIVE_FATAL); 662 } 663 664 #if HAVE_FLISTXATTR 665 if (*fd >= 0) 666 list_size = flistxattr(*fd, list, list_size); 667 else if (!a->follow_symlinks) 668 list_size = llistxattr(path, list, list_size); 669 else 670 list_size = listxattr(path, list, list_size); 671 #elif HAVE_FLISTEA 672 if (*fd >= 0) 673 list_size = flistea(*fd, list, list_size); 674 else if (!a->follow_symlinks) 675 list_size = llistea(path, list, list_size); 676 else 677 list_size = listea(path, list, list_size); 678 #endif 679 680 if (list_size == -1) { 681 archive_set_error(&a->archive, errno, 682 "Couldn't retrieve extended attributes"); 683 free(list); 684 return (ARCHIVE_WARN); 685 } 686 687 for (p = list; (p - list) < list_size; p += strlen(p) + 1) { 688 if (strncmp(p, "system.", 7) == 0 || 689 strncmp(p, "xfsroot.", 8) == 0) 690 continue; 691 setup_xattr(a, entry, p, *fd); 692 } 693 694 free(list); 695 return (ARCHIVE_OK); 696 } 697 698 #elif HAVE_EXTATTR_GET_FILE && HAVE_EXTATTR_LIST_FILE && \ 699 HAVE_DECL_EXTATTR_NAMESPACE_USER 700 701 /* 702 * FreeBSD extattr interface. 703 */ 704 705 /* TODO: Implement this. Follow the Linux model above, but 706 * with FreeBSD-specific system calls, of course. Be careful 707 * to not include the system extattrs that hold ACLs; we handle 708 * those separately. 709 */ 710 static int 711 setup_xattr(struct archive_read_disk *a, struct archive_entry *entry, 712 int namespace, const char *name, const char *fullname, int fd); 713 714 static int 715 setup_xattr(struct archive_read_disk *a, struct archive_entry *entry, 716 int namespace, const char *name, const char *fullname, int fd) 717 { 718 ssize_t size; 719 void *value = NULL; 720 const char *accpath; 721 722 accpath = archive_entry_sourcepath(entry); 723 if (accpath == NULL) 724 accpath = archive_entry_pathname(entry); 725 726 if (fd >= 0) 727 size = extattr_get_fd(fd, namespace, name, NULL, 0); 728 else if (!a->follow_symlinks) 729 size = extattr_get_link(accpath, namespace, name, NULL, 0); 730 else 731 size = extattr_get_file(accpath, namespace, name, NULL, 0); 732 733 if (size == -1) { 734 archive_set_error(&a->archive, errno, 735 "Couldn't query extended attribute"); 736 return (ARCHIVE_WARN); 737 } 738 739 if (size > 0 && (value = malloc(size)) == NULL) { 740 archive_set_error(&a->archive, errno, "Out of memory"); 741 return (ARCHIVE_FATAL); 742 } 743 744 if (fd >= 0) 745 size = extattr_get_fd(fd, namespace, name, value, size); 746 else if (!a->follow_symlinks) 747 size = extattr_get_link(accpath, namespace, name, value, size); 748 else 749 size = extattr_get_file(accpath, namespace, name, value, size); 750 751 if (size == -1) { 752 free(value); 753 archive_set_error(&a->archive, errno, 754 "Couldn't read extended attribute"); 755 return (ARCHIVE_WARN); 756 } 757 758 archive_entry_xattr_add_entry(entry, fullname, value, size); 759 760 free(value); 761 return (ARCHIVE_OK); 762 } 763 764 static int 765 setup_xattrs(struct archive_read_disk *a, 766 struct archive_entry *entry, int *fd) 767 { 768 char buff[512]; 769 char *list, *p; 770 ssize_t list_size; 771 const char *path; 772 int namespace = EXTATTR_NAMESPACE_USER; 773 774 path = archive_entry_sourcepath(entry); 775 if (path == NULL) 776 path = archive_entry_pathname(entry); 777 778 if (*fd < 0 && a->tree != NULL) { 779 if (a->follow_symlinks || 780 archive_entry_filetype(entry) != AE_IFLNK) 781 *fd = a->open_on_current_dir(a->tree, path, 782 O_RDONLY | O_NONBLOCK); 783 if (*fd < 0) { 784 if (a->tree_enter_working_dir(a->tree) != 0) { 785 archive_set_error(&a->archive, errno, 786 "Couldn't access %s", path); 787 return (ARCHIVE_FAILED); 788 } 789 } 790 } 791 792 if (*fd >= 0) 793 list_size = extattr_list_fd(*fd, namespace, NULL, 0); 794 else if (!a->follow_symlinks) 795 list_size = extattr_list_link(path, namespace, NULL, 0); 796 else 797 list_size = extattr_list_file(path, namespace, NULL, 0); 798 799 if (list_size == -1 && errno == EOPNOTSUPP) 800 return (ARCHIVE_OK); 801 if (list_size == -1) { 802 archive_set_error(&a->archive, errno, 803 "Couldn't list extended attributes"); 804 return (ARCHIVE_WARN); 805 } 806 807 if (list_size == 0) 808 return (ARCHIVE_OK); 809 810 if ((list = malloc(list_size)) == NULL) { 811 archive_set_error(&a->archive, errno, "Out of memory"); 812 return (ARCHIVE_FATAL); 813 } 814 815 if (*fd >= 0) 816 list_size = extattr_list_fd(*fd, namespace, list, list_size); 817 else if (!a->follow_symlinks) 818 list_size = extattr_list_link(path, namespace, list, list_size); 819 else 820 list_size = extattr_list_file(path, namespace, list, list_size); 821 822 if (list_size == -1) { 823 archive_set_error(&a->archive, errno, 824 "Couldn't retrieve extended attributes"); 825 free(list); 826 return (ARCHIVE_WARN); 827 } 828 829 p = list; 830 while ((p - list) < list_size) { 831 size_t len = 255 & (int)*p; 832 char *name; 833 834 strcpy(buff, "user."); 835 name = buff + strlen(buff); 836 memcpy(name, p + 1, len); 837 name[len] = '\0'; 838 setup_xattr(a, entry, namespace, name, buff, *fd); 839 p += 1 + len; 840 } 841 842 free(list); 843 return (ARCHIVE_OK); 844 } 845 846 #else 847 848 /* 849 * Generic (stub) extended attribute support. 850 */ 851 static int 852 setup_xattrs(struct archive_read_disk *a, 853 struct archive_entry *entry, int *fd) 854 { 855 (void)a; /* UNUSED */ 856 (void)entry; /* UNUSED */ 857 (void)fd; /* UNUSED */ 858 return (ARCHIVE_OK); 859 } 860 861 #endif 862 863 #if defined(HAVE_LINUX_FIEMAP_H) 864 865 /* 866 * Linux sparse interface. 867 * 868 * The FIEMAP ioctl returns an "extent" for each physical allocation 869 * on disk. We need to process those to generate a more compact list 870 * of logical file blocks. We also need to be very careful to use 871 * FIEMAP_FLAG_SYNC here, since there are reports that Linux sometimes 872 * does not report allocations for newly-written data that hasn't 873 * been synced to disk. 874 * 875 * It's important to return a minimal sparse file list because we want 876 * to not trigger sparse file extensions if we don't have to, since 877 * not all readers support them. 878 */ 879 880 static int 881 setup_sparse(struct archive_read_disk *a, 882 struct archive_entry *entry, int *fd) 883 { 884 char buff[4096]; 885 struct fiemap *fm; 886 struct fiemap_extent *fe; 887 int64_t size; 888 int count, do_fiemap; 889 int exit_sts = ARCHIVE_OK; 890 891 if (archive_entry_filetype(entry) != AE_IFREG 892 || archive_entry_size(entry) <= 0 893 || archive_entry_hardlink(entry) != NULL) 894 return (ARCHIVE_OK); 895 896 if (*fd < 0) { 897 const char *path; 898 899 path = archive_entry_sourcepath(entry); 900 if (path == NULL) 901 path = archive_entry_pathname(entry); 902 if (a->tree != NULL) 903 *fd = a->open_on_current_dir(a->tree, path, 904 O_RDONLY | O_NONBLOCK); 905 else 906 *fd = open(path, O_RDONLY | O_NONBLOCK); 907 if (*fd < 0) { 908 archive_set_error(&a->archive, errno, 909 "Can't open `%s'", path); 910 return (ARCHIVE_FAILED); 911 } 912 } 913 914 count = (sizeof(buff) - sizeof(*fm))/sizeof(*fe); 915 fm = (struct fiemap *)buff; 916 fm->fm_start = 0; 917 fm->fm_length = ~0ULL;; 918 fm->fm_flags = FIEMAP_FLAG_SYNC; 919 fm->fm_extent_count = count; 920 do_fiemap = 1; 921 size = archive_entry_size(entry); 922 for (;;) { 923 int i, r; 924 925 r = ioctl(*fd, FS_IOC_FIEMAP, fm); 926 if (r < 0) { 927 /* When something error happens, it is better we 928 * should return ARCHIVE_OK because an earlier 929 * version(<2.6.28) cannot perfom FS_IOC_FIEMAP. */ 930 goto exit_setup_sparse; 931 } 932 if (fm->fm_mapped_extents == 0) 933 break; 934 fe = fm->fm_extents; 935 for (i = 0; i < (int)fm->fm_mapped_extents; i++, fe++) { 936 if (!(fe->fe_flags & FIEMAP_EXTENT_UNWRITTEN)) { 937 /* The fe_length of the last block does not 938 * adjust itself to its size files. */ 939 int64_t length = fe->fe_length; 940 if (fe->fe_logical + length > (uint64_t)size) 941 length -= fe->fe_logical + length - size; 942 if (fe->fe_logical == 0 && length == size) { 943 /* This is not sparse. */ 944 do_fiemap = 0; 945 break; 946 } 947 if (length > 0) 948 archive_entry_sparse_add_entry(entry, 949 fe->fe_logical, length); 950 } 951 if (fe->fe_flags & FIEMAP_EXTENT_LAST) 952 do_fiemap = 0; 953 } 954 if (do_fiemap) { 955 fe = fm->fm_extents + fm->fm_mapped_extents -1; 956 fm->fm_start = fe->fe_logical + fe->fe_length; 957 } else 958 break; 959 } 960 exit_setup_sparse: 961 return (exit_sts); 962 } 963 964 #elif defined(SEEK_HOLE) && defined(SEEK_DATA) && defined(_PC_MIN_HOLE_SIZE) 965 966 /* 967 * FreeBSD and Solaris sparse interface. 968 */ 969 970 static int 971 setup_sparse(struct archive_read_disk *a, 972 struct archive_entry *entry, int *fd) 973 { 974 int64_t size; 975 off_t initial_off; /* FreeBSD/Solaris only, so off_t okay here */ 976 off_t off_s, off_e; /* FreeBSD/Solaris only, so off_t okay here */ 977 int exit_sts = ARCHIVE_OK; 978 979 if (archive_entry_filetype(entry) != AE_IFREG 980 || archive_entry_size(entry) <= 0 981 || archive_entry_hardlink(entry) != NULL) 982 return (ARCHIVE_OK); 983 984 /* Does filesystem support the reporting of hole ? */ 985 if (*fd < 0 && a->tree != NULL) { 986 const char *path; 987 988 path = archive_entry_sourcepath(entry); 989 if (path == NULL) 990 path = archive_entry_pathname(entry); 991 *fd = a->open_on_current_dir(a->tree, path, 992 O_RDONLY | O_NONBLOCK); 993 if (*fd < 0) { 994 archive_set_error(&a->archive, errno, 995 "Can't open `%s'", path); 996 return (ARCHIVE_FAILED); 997 } 998 } 999 1000 if (*fd >= 0) { 1001 if (fpathconf(*fd, _PC_MIN_HOLE_SIZE) <= 0) 1002 return (ARCHIVE_OK); 1003 initial_off = lseek(*fd, 0, SEEK_CUR); 1004 if (initial_off != 0) 1005 lseek(*fd, 0, SEEK_SET); 1006 } else { 1007 const char *path; 1008 1009 path = archive_entry_sourcepath(entry); 1010 if (path == NULL) 1011 path = archive_entry_pathname(entry); 1012 1013 if (pathconf(path, _PC_MIN_HOLE_SIZE) <= 0) 1014 return (ARCHIVE_OK); 1015 *fd = open(path, O_RDONLY | O_NONBLOCK); 1016 if (*fd < 0) { 1017 archive_set_error(&a->archive, errno, 1018 "Can't open `%s'", path); 1019 return (ARCHIVE_FAILED); 1020 } 1021 initial_off = 0; 1022 } 1023 1024 off_s = 0; 1025 size = archive_entry_size(entry); 1026 while (off_s < size) { 1027 off_s = lseek(*fd, off_s, SEEK_DATA); 1028 if (off_s == (off_t)-1) { 1029 if (errno == ENXIO) 1030 break;/* no more hole */ 1031 archive_set_error(&a->archive, errno, 1032 "lseek(SEEK_HOLE) failed"); 1033 exit_sts = ARCHIVE_FAILED; 1034 goto exit_setup_sparse; 1035 } 1036 off_e = lseek(*fd, off_s, SEEK_HOLE); 1037 if (off_e == (off_t)-1) { 1038 if (errno == ENXIO) { 1039 off_e = lseek(*fd, 0, SEEK_END); 1040 if (off_e != (off_t)-1) 1041 break;/* no more data */ 1042 } 1043 archive_set_error(&a->archive, errno, 1044 "lseek(SEEK_DATA) failed"); 1045 exit_sts = ARCHIVE_FAILED; 1046 goto exit_setup_sparse; 1047 } 1048 if (off_s == 0 && off_e == size) 1049 break;/* This is not spase. */ 1050 archive_entry_sparse_add_entry(entry, off_s, 1051 off_e - off_s); 1052 off_s = off_e; 1053 } 1054 exit_setup_sparse: 1055 lseek(*fd, initial_off, SEEK_SET); 1056 return (exit_sts); 1057 } 1058 1059 #else 1060 1061 /* 1062 * Generic (stub) sparse support. 1063 */ 1064 static int 1065 setup_sparse(struct archive_read_disk *a, 1066 struct archive_entry *entry, int *fd) 1067 { 1068 (void)a; /* UNUSED */ 1069 (void)entry; /* UNUSED */ 1070 (void)fd; /* UNUSED */ 1071 return (ARCHIVE_OK); 1072 } 1073 1074 #endif 1075 1076 #endif /* !defined(_WIN32) || defined(__CYGWIN__) */ 1077 1078