contrib/libarchive/libarchive/archive_read_disk_entry_from_file.c

   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, &copyfile_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