/*- * Copyright (c) 2003-2004 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "archive_platform.h" __FBSDID("$FreeBSD$"); #include #include #ifdef HAVE_POSIX_ACL #include #endif #include #include #include #include #include #include #include #include #include #include #include #ifdef LINUX #include #include #endif #include "archive.h" #include "archive_string.h" #include "archive_entry.h" #include "archive_private.h" static void archive_extract_cleanup(struct archive *); static int archive_read_extract_block_device(struct archive *, struct archive_entry *, int); static int archive_read_extract_char_device(struct archive *, struct archive_entry *, int); static int archive_read_extract_device(struct archive *, struct archive_entry *, int flags, mode_t mode); static int archive_read_extract_dir(struct archive *, struct archive_entry *, int); static int archive_read_extract_dir_create(struct archive *, const char *name, int mode, int flags); static int archive_read_extract_fifo(struct archive *, struct archive_entry *, int); static int archive_read_extract_hard_link(struct archive *, struct archive_entry *, int); static int archive_read_extract_regular(struct archive *, struct archive_entry *, int); static int archive_read_extract_regular_open(struct archive *, const char *name, int mode, int flags); static int archive_read_extract_symbolic_link(struct archive *, struct archive_entry *, int); static gid_t lookup_gid(struct archive *, const char *uname, gid_t); static uid_t lookup_uid(struct archive *, const char *uname, uid_t); static int mkdirpath(struct archive *, const char *); static int mkdirpath_recursive(char *path); static int mksubdir(char *path); #ifdef HAVE_POSIX_ACL static int set_acl(struct archive *, struct archive_entry *, acl_type_t, int archive_entry_acl_type, const char *tn); #endif static int set_acls(struct archive *, struct archive_entry *); static int set_extended_perm(struct archive *, struct archive_entry *, int flags); static int set_fflags(struct archive *, struct archive_entry *); static int set_ownership(struct archive *, struct archive_entry *, int); static int set_perm(struct archive *, struct archive_entry *, int mode, int flags); static int set_time(struct archive *, struct archive_entry *, int); static struct archive_extract_dir_entry * sort_dir_list(struct archive_extract_dir_entry *p); struct archive_extract_dir_entry { struct archive_extract_dir_entry *next; mode_t mode; int64_t mtime; int64_t atime; unsigned long mtime_nanos; unsigned long atime_nanos; /* Note: ctime cannot be restored, so don't bother */ char *name; }; /* * Extract this entry to disk. * * TODO: Validate hardlinks. Is there any way to validate hardlinks * without keeping a complete list of filenames from the entire archive?? Ugh. * */ int archive_read_extract(struct archive *a, struct archive_entry *entry, int flags) { mode_t writable_mode; struct archive_extract_dir_entry *le; const struct stat *st; int ret; int restore_pwd; restore_pwd = -1; st = archive_entry_stat(entry); if (S_ISDIR(st->st_mode)) { /* * TODO: Does this really work under all conditions? * * E.g., root restores a dir owned by someone else? */ writable_mode = st->st_mode | 0700; /* * In order to correctly restore non-writable dirs or * dir timestamps, we need to maintain a fix-up list. */ if (st->st_mode != writable_mode || flags & ARCHIVE_EXTRACT_TIME) { le = malloc(sizeof(struct archive_extract_dir_entry)); le->next = a->archive_extract_dir_list; a->archive_extract_dir_list = le; le->mode = st->st_mode; le->mtime = st->st_mtime; le->mtime_nanos = ARCHIVE_STAT_MTIME_NANOS(st); le->atime = st->st_atime; le->atime_nanos = ARCHIVE_STAT_ATIME_NANOS(st); le->name = strdup(archive_entry_pathname(entry)); a->cleanup_archive_extract = archive_extract_cleanup; /* Make sure I can write to this directory. */ archive_entry_set_mode(entry, writable_mode); } } if (archive_entry_hardlink(entry) != NULL) return (archive_read_extract_hard_link(a, entry, flags)); /* * TODO: If pathname is longer than PATH_MAX, record starting * directory and move to a suitable intermediate dir, which * might require creating them! */ if (strlen(archive_entry_pathname(entry)) > PATH_MAX) { restore_pwd = open(".", O_RDONLY); /* XXX chdir() to a suitable intermediate dir XXX */ /* XXX Update pathname in 'entry' XXX */ } switch (st->st_mode & S_IFMT) { default: /* Fall through, as required by POSIX. */ case S_IFREG: ret = archive_read_extract_regular(a, entry, flags); break; case S_IFLNK: /* Symlink */ ret = archive_read_extract_symbolic_link(a, entry, flags); break; case S_IFCHR: ret = archive_read_extract_char_device(a, entry, flags); break; case S_IFBLK: ret = archive_read_extract_block_device(a, entry, flags); break; case S_IFDIR: ret = archive_read_extract_dir(a, entry, flags); break; case S_IFIFO: ret = archive_read_extract_fifo(a, entry, flags); break; } /* If we changed directory above, restore it here. */ if (restore_pwd >= 0) fchdir(restore_pwd); return (ret); } /* * Cleanup function for archive_extract. Free name/mode list and * restore permissions and dir timestamps. This must be done last; * otherwise, the dir permission might prevent us from restoring a * file. Similarly, the act of restoring a file touches the directory * and changes the timestamp on the dir, so we have to touch-up the * timestamps at the end as well. Note that tar/cpio do not require * that archives be in a particular order; there is no way to know * when the last file has been restored within a directory, so there's * no way to optimize the memory usage here by fixing up the directory * any earlier than the end-of-archive. * * XXX TODO: Directory ACLs should be restored here, for the same * reason we set directory perms here. XXX * * Registering this function (rather than calling it explicitly by * name from archive_read_finish) reduces static link pollution, since * applications that don't use this API won't get this file linked in. */ static void archive_extract_cleanup(struct archive *a) { struct archive_extract_dir_entry *next, *p; /* Sort dir list so directories are fixed up in depth-first order. */ p = sort_dir_list(a->archive_extract_dir_list); while (p != NULL) { struct timeval times[2]; times[1].tv_sec = p->mtime; times[1].tv_usec = p->mtime_nanos / 1000; times[0].tv_sec = p->atime; times[0].tv_usec = p->atime_nanos / 1000; chmod(p->name, p->mode); utimes(p->name, times); next = p->next; free(p->name); free(p); p = next; } a->archive_extract_dir_list = NULL; } /* * Simple O(n log n) merge sort to order the directories prior to fix-up. */ static struct archive_extract_dir_entry * sort_dir_list(struct archive_extract_dir_entry *p) { struct archive_extract_dir_entry *a, *b, *t; if (p == NULL) return NULL; /* A one-item list is already sorted. */ if (p->next == NULL) return (p); /* Step 1: split the list. */ t = p; a = p->next->next; while (a != NULL) { /* Step a twice, t once. */ a = a->next; if (a != NULL) a = a->next; t = t->next; } /* Now, t is at the mid-point, so break the list here. */ b = t->next; t->next = NULL; a = p; /* Step 2: Recursively sort the two sub-lists. */ a = sort_dir_list(a); b = sort_dir_list(b); /* Step 3: Merge the returned lists. */ /* Pick the first element for the merged list. */ if (strcmp(a->name, b->name) > 0) { t = p = a; a = a->next; } else { t = p = b; b = b->next; } /* Always put the later element on the list first. */ while (a != NULL && b != NULL) { if (strcmp(a->name, b->name) > 0) { t->next = a; a = a->next; } else { t->next = b; b = b->next; } t = t->next; } /* Only one list is non-empty, so just splice it on. */ if (a != NULL) t->next = a; if (b != NULL) t->next = b; return (p); } static int archive_read_extract_regular(struct archive *a, struct archive_entry *entry, int flags) { int fd, r; ssize_t s; r = ARCHIVE_OK; fd = archive_read_extract_regular_open(a, archive_entry_pathname(entry), archive_entry_stat(entry)->st_mode, flags); if (fd < 0) { archive_set_error(a, errno, "Can't open"); return (ARCHIVE_WARN); } s = archive_read_data_into_fd(a, fd); if (s < archive_entry_size(entry)) { /* Didn't read enough data? Complain but keep going. */ archive_set_error(a, EIO, "Archive data truncated"); r = ARCHIVE_WARN; } set_ownership(a, entry, flags); set_time(a, entry, flags); /* set_perm(a, entry, mode, flags); */ /* Handled implicitly by open.*/ set_extended_perm(a, entry, flags); close(fd); return (r); } /* * Keep trying until we either open the file or run out of tricks. */ static int archive_read_extract_regular_open(struct archive *a, const char *name, int mode, int flags) { int fd; /* * If we're not supposed to overwrite pre-existing files, * use O_EXCL. Otherwise, use O_TRUNC. */ if (flags & (ARCHIVE_EXTRACT_UNLINK | ARCHIVE_EXTRACT_NO_OVERWRITE)) fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode); else fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, mode); if (fd >= 0) return (fd); /* Try removing a pre-existing file. */ if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) { unlink(name); fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode); if (fd >= 0) return (fd); } /* Might be a non-existent parent dir; try fixing that. */ mkdirpath(a, name); fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode); if (fd >= 0) return (fd); return (-1); } static int archive_read_extract_dir(struct archive *a, struct archive_entry *entry, int flags) { int mode, ret, ret2; mode = archive_entry_stat(entry)->st_mode; if (archive_read_extract_dir_create(a, archive_entry_pathname(entry), mode, flags)) { /* Unable to create directory; just use the existing dir. */ return (ARCHIVE_WARN); } set_ownership(a, entry, flags); /* * There is no point in setting the time here. * * Note that future extracts into this directory will reset * the times, so to get correct results, the client has to * track timestamps for directories and update them at the end * of the run anyway. */ /* set_time(t, flags); */ /* * This next line may appear redundant, but it's not. If the * directory already exists, it won't get re-created by * mkdir(), so we have to manually set permissions to get * everything right. */ ret = set_perm(a, entry, mode, flags); ret2 = set_extended_perm(a, entry, flags); /* XXXX TODO: Fix this to work the right way. XXXX */ if (ret == ARCHIVE_OK) return (ret2); else return (ret); } /* * Create the directory: try until something works or we run out of magic. */ static int archive_read_extract_dir_create(struct archive *a, const char *name, int mode, int flags) { /* Don't try to create '.' */ if (name[0] == '.' && name[1] == 0) return (ARCHIVE_OK); if (mkdir(name, mode) == 0) return (ARCHIVE_OK); if (errno == ENOENT) { /* Missing parent directory. */ mkdirpath(a, name); if (mkdir(name, mode) == 0) return (ARCHIVE_OK); } if (errno != EEXIST) return (ARCHIVE_WARN); if ((flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) { archive_set_error(a, EEXIST, "Can't create directory"); return (ARCHIVE_WARN); } /* Could be a file; try unlinking. */ if (unlink(name) == 0 && mkdir(name, mode) == 0) return (ARCHIVE_OK); /* * XXX TODO: If we get here, just stat() the file on disk and * figure out what's really going on, rather than depending on * such platform vagaries as the precise return value from * unlink(). That would make the following a lot more * straightforward. XXX */ /* Unlink failed. It's okay if it failed because it's already a dir. */ /* * BSD returns EPERM for unlink on an dir, * Linux returns EISDIR */ if (errno != EPERM && errno != EISDIR) { archive_set_error(a, errno, "Couldn't create dir"); return (ARCHIVE_WARN); } /* Try removing the directory and recreating it from scratch. */ if (rmdir(name)) { /* Failure to remove a non-empty directory is not a problem. */ if (errno == ENOTEMPTY) return (ARCHIVE_OK); /* Any other failure is a problem. */ archive_set_error(a, errno, "Error attempting to remove existing directory"); return (ARCHIVE_WARN); } /* We successfully removed the directory; now recreate it. */ if (mkdir(name, mode) == 0) return (ARCHIVE_OK); archive_set_error(a, errno, "Failed to create dir"); return (ARCHIVE_WARN); } static int archive_read_extract_hard_link(struct archive *a, struct archive_entry *entry, int flags) { int r; const char *pathname; const char *linkname; pathname = archive_entry_pathname(entry); linkname = archive_entry_hardlink(entry); /* * XXX Should we suppress the unlink here unless * ARCHIVE_EXTRACT_UNLINK? That would make the * !ARCHIVE_EXTRACT_UNLINK case the same as the * ARCHIVE_EXTRACT_NO_OVERWRITE case (at least for hard * links.) XXX */ /* Just remove any pre-existing file with this name. */ if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) unlink(pathname); r = link(linkname, pathname); if (r != 0) { /* Might be a non-existent parent dir; try fixing that. */ mkdirpath(a, pathname); r = link(linkname, pathname); } if (r != 0) { /* XXX Better error message here XXX */ archive_set_error(a, errno, "Can't restore hardlink to '%s'", linkname); return (ARCHIVE_WARN); } /* Set ownership, time, permission information. */ set_ownership(a, entry, flags); set_time(a, entry, flags); set_perm(a, entry, archive_entry_stat(entry)->st_mode, flags); set_extended_perm(a, entry, flags); return (ARCHIVE_OK); } static int archive_read_extract_symbolic_link(struct archive *a, struct archive_entry *entry, int flags) { int r; const char *pathname; const char *linkname; pathname = archive_entry_pathname(entry); linkname = archive_entry_symlink(entry); /* * XXX Should we suppress the unlink here unless * ARCHIVE_EXTRACT_UNLINK? That would make the * !ARCHIVE_EXTRACT_UNLINK case the same as the * ARCHIVE_EXTRACT_NO_OVERWRITE case (at least for hard * links.) XXX */ /* Just remove any pre-existing file with this name. */ if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) unlink(pathname); r = symlink(linkname, pathname); if (r != 0) { /* Might be a non-existent parent dir; try fixing that. */ mkdirpath(a, pathname); r = symlink(linkname, pathname); } if (r != 0) { /* XXX Better error message here XXX */ archive_set_error(a, errno, "Can't restore symlink to '%s'", linkname); return (ARCHIVE_WARN); } /* Set ownership, time, permission information. */ set_ownership(a, entry, flags); set_time(a, entry, flags); set_perm(a, entry, archive_entry_stat(entry)->st_mode, flags); set_extended_perm(a, entry, flags); return (ARCHIVE_OK); } static int archive_read_extract_device(struct archive *a, struct archive_entry *entry, int flags, mode_t mode) { int r; /* * XXX Should we suppress the unlink here unless * ARCHIVE_EXTRACT_UNLINK? That would make the * !ARCHIVE_EXTRACT_UNLINK case the same as the * ARCHIVE_EXTRACT_NO_OVERWRITE case (at least for device * nodes) XXX */ /* Just remove any pre-existing file with this name. */ if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) unlink(archive_entry_pathname(entry)); r = mknod(archive_entry_pathname(entry), mode, archive_entry_stat(entry)->st_rdev); /* Might be a non-existent parent dir; try fixing that. */ if (r != 0 && errno == ENOENT) { mkdirpath(a, archive_entry_pathname(entry)); r = mknod(archive_entry_pathname(entry), mode, archive_entry_stat(entry)->st_rdev); } if (r != 0) { archive_set_error(a, errno, "Can't recreate device node"); return (ARCHIVE_WARN); } /* Set ownership, time, permission information. */ set_ownership(a, entry, flags); set_time(a, entry, flags); set_perm(a, entry, archive_entry_stat(entry)->st_mode, flags); set_extended_perm(a, entry, flags); return (ARCHIVE_OK); } static int archive_read_extract_char_device(struct archive *a, struct archive_entry *entry, int flags) { mode_t mode; mode = (archive_entry_stat(entry)->st_mode & ~S_IFMT) | S_IFCHR; return (archive_read_extract_device(a, entry, flags, mode)); } static int archive_read_extract_block_device(struct archive *a, struct archive_entry *entry, int flags) { mode_t mode; mode = (archive_entry_stat(entry)->st_mode & ~S_IFMT) | S_IFBLK; return (archive_read_extract_device(a, entry, flags, mode)); } static int archive_read_extract_fifo(struct archive *a, struct archive_entry *entry, int flags) { int r; /* * XXX Should we suppress the unlink here unless * ARCHIVE_EXTRACT_UNLINK? That would make the * !ARCHIVE_EXTRACT_UNLINK case the same as the * ARCHIVE_EXTRACT_NO_OVERWRITE case (at least for fifos.) XXX */ /* Just remove any pre-existing file with this name. */ if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) unlink(archive_entry_pathname(entry)); r = mkfifo(archive_entry_pathname(entry), archive_entry_stat(entry)->st_mode); /* Might be a non-existent parent dir; try fixing that. */ if (r != 0 && errno == ENOENT) { mkdirpath(a, archive_entry_pathname(entry)); r = mkfifo(archive_entry_pathname(entry), archive_entry_stat(entry)->st_mode); } if (r != 0) { archive_set_error(a, errno, "Can't restore fifo"); return (ARCHIVE_WARN); } /* Set ownership, time, permission information. */ set_ownership(a, entry, flags); set_time(a, entry, flags); /* Done by mkfifo. */ /* set_perm(a, entry, archive_entry_stat(entry)->st_mode, flags); */ set_extended_perm(a, entry, flags); return (ARCHIVE_OK); } /* * Returns 0 if it successfully created necessary directories. * Otherwise, returns ARCHIVE_WARN. */ static int mkdirpath(struct archive *a, const char *path) { char *p; /* Copy path to mutable storage, then call mkdirpath_recursive. */ archive_strcpy(&(a->extract_mkdirpath), path); /* Prune a trailing '/' character. */ p = a->extract_mkdirpath.s; if (p[strlen(p)-1] == '/') p[strlen(p)-1] = 0; /* Recursively try to build the path. */ return (mkdirpath_recursive(p)); } /* * For efficiency, just try creating longest path first (usually, * archives walk through directories in a reasonable order). If that * fails, prune the last element and recursively try again. */ static int mkdirpath_recursive(char *path) { char * p; int r; p = strrchr(path, '/'); if (!p) return (0); *p = 0; /* Terminate path name. */ r = mksubdir(path); /* Try building path. */ *p = '/'; /* Restore the '/' we just overwrote. */ return (r); } static int mksubdir(char *path) { int mode = 0755; if (mkdir(path, mode) == 0) return (0); if (errno == EEXIST) /* TODO: stat() here to verify it is dir */ return (0); if (mkdirpath_recursive(path)) return (ARCHIVE_WARN); if (mkdir(path, mode) == 0) return (0); return (ARCHIVE_WARN); /* Still failed. Harumph. */ } /* * Note that I only inspect entry->ae_uid and entry->ae_gid here; if * the client wants POSIX compat, they'll need to do uname/gname * lookups themselves. I don't do it here because of the potential * performance issues: if uname/gname lookup is expensive, then the * results should be aggressively cached; if they're cheap, then we * shouldn't waste memory on cache tables. * * Returns 0 if UID/GID successfully restored; ARCHIVE_WARN otherwise. */ static int set_ownership(struct archive *a, struct archive_entry *entry, int flags) { uid_t uid; gid_t gid; /* If UID/GID are already correct, return 0. */ /* TODO: Fix this; need to stat() to find on-disk GID */ if (a->user_uid == archive_entry_stat(entry)->st_uid) return (0); /* Not changed. */ if ((flags & ARCHIVE_EXTRACT_OWNER) == 0) return (ARCHIVE_WARN); uid = lookup_uid(a, archive_entry_uname(entry), archive_entry_stat(entry)->st_uid); gid = lookup_gid(a, archive_entry_gname(entry), archive_entry_stat(entry)->st_gid); /* * Root can change owner/group; owner can change group; * otherwise, bail out now. */ if (a->user_uid != 0 && a->user_uid != uid) { /* XXXX archive_set_error( XXXX ) ; XXX */ return (ARCHIVE_WARN); } if (lchown(archive_entry_pathname(entry), uid, gid)) { archive_set_error(a, errno, "Can't set user=%d/group=%d for %s", uid, gid, archive_entry_pathname(entry)); return (ARCHIVE_WARN); } return (ARCHIVE_OK); } static int set_time(struct archive *a, struct archive_entry *entry, int flags) { const struct stat *st; struct timeval times[2]; (void)a; /* UNUSED */ st = archive_entry_stat(entry); if ((flags & ARCHIVE_EXTRACT_TIME) == 0) return (ARCHIVE_OK); times[1].tv_sec = st->st_mtime; times[1].tv_usec = ARCHIVE_STAT_MTIME_NANOS(st) / 1000; times[0].tv_sec = st->st_atime; times[0].tv_usec = ARCHIVE_STAT_ATIME_NANOS(st) / 1000; #ifdef HAVE_LUTIMES if (lutimes(archive_entry_pathname(entry), times) != 0) { #else if ((archive_entry_mode(entry) & S_IFMT) != S_IFLNK && utimes(archive_entry_pathname(entry), times) != 0) { #endif archive_set_error(a, errno, "Can't update time for %s", archive_entry_pathname(entry)); return (ARCHIVE_WARN); } /* * Note: POSIX does not provide a portable way to restore ctime. * So, any restoration of ctime will necessarily be OS-specific. */ /* XXX TODO: Can FreeBSD restore ctime? XXX */ return (ARCHIVE_OK); } static int set_perm(struct archive *a, struct archive_entry *entry, int mode, int flags) { const char *name; if ((flags & ARCHIVE_EXTRACT_PERM) == 0) return (ARCHIVE_OK); name = archive_entry_pathname(entry); #ifdef HAVE_LCHMOD if (lchmod(name, mode) != 0) { #else if ((archive_entry_mode(entry) & S_IFMT) != S_IFLNK && chmod(name, mode) != 0) { #endif archive_set_error(a, errno, "Can't set permissions"); return (ARCHIVE_WARN); } return (0); } static int set_extended_perm(struct archive *a, struct archive_entry *entry, int flags) { int ret, ret2; if ((flags & ARCHIVE_EXTRACT_PERM) == 0) return (ARCHIVE_OK); ret = set_fflags(a, entry); ret2 = set_acls(a, entry); return (err_combine(ret,ret2)); } static int set_fflags(struct archive *a, struct archive_entry *entry) { const char *name; int ret; unsigned long set, clear; struct stat st; #ifdef LINUX struct stat *stp; int fd; int err; unsigned long newflags, oldflags; #endif name = archive_entry_pathname(entry); ret = ARCHIVE_OK; archive_entry_fflags(entry, &set, &clear); if (set == 0 && clear == 0) return (ret); #ifdef HAVE_CHFLAGS /* * XXX Is the stat here really necessary? Or can I just use * the 'set' flags directly? In particular, I'm not sure * about the correct approach if we're overwriting an existing * file that already has flags on it. XXX */ if (stat(name, &st) == 0) { st.st_flags &= ~clear; st.st_flags |= set; if (chflags(name, st.st_flags) != 0) { archive_set_error(a, errno, "Failed to set file flags"); ret = ARCHIVE_WARN; } } #endif /* Linux has flags too, but no chflags syscall */ #ifdef LINUX /* * Linux has no define for the flags that are only settable * by the root user... */ #define SF_MASK (EXT2_IMMUTABLE_FL|EXT2_APPEND_FL) /* * XXX As above, this would be way simpler if we didn't have * to read the current flags from disk. XXX */ stp = archive_entry_stat(entry); if ((S_ISREG(stp->st_mode) || S_ISDIR(stp->st_mode)) && ((fd = open(name, O_RDONLY|O_NONBLOCK)) >= 0)) { err = 1; if (fd >= 0 && (ioctl(fd, EXT2_IOC_GETFLAGS, &oldflags) >= 0)) { newflags = (oldflags & ~clear) | set; if (ioctl(fd, EXT2_IOC_SETFLAGS, &newflags) >= 0) { err = 0; } else if (errno == EPERM) { if (ioctl(fd, EXT2_IOC_GETFLAGS, &oldflags) >= 0) { newflags &= ~SF_MASK; oldflags &= SF_MASK; newflags |= oldflags; if (ioctl(fd, EXT2_IOC_SETFLAGS, &newflags) >= 0) err = 0; } } } close(fd); if (err) { archive_set_error(a, errno, "Failed to set file flags"); ret = ARCHIVE_WARN; } } #endif return (ret); } #ifndef HAVE_POSIX_ACL /* Default empty function body to satisfy mainline code. */ static int set_acls(struct archive *a, struct archive_entry *entry) { (void)a; (void)entry; return (ARCHIVE_OK); } #else /* * XXX TODO: What about ACL types other than ACCESS and DEFAULT? */ static int set_acls(struct archive *a, struct archive_entry *entry) { int ret; ret = set_acl(a, entry, ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, "access"); if (ret != ARCHIVE_OK) return (ret); ret = set_acl(a, entry, ACL_TYPE_DEFAULT, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, "default"); return (ret); } static int set_acl(struct archive *a, struct archive_entry *entry, acl_type_t acl_type, int ae_requested_type, const char *typename) { acl_t acl; acl_entry_t acl_entry; acl_permset_t acl_permset; int ret; int ae_type, ae_permset, ae_tag, ae_id; uid_t ae_uid; gid_t ae_gid; const char *ae_name; int entries; const char *name; ret = ARCHIVE_OK; entries = archive_entry_acl_reset(entry, ae_requested_type); if (entries == 0) return (ARCHIVE_OK); acl = acl_init(entries); while (archive_entry_acl_next(entry, ae_requested_type, &ae_type, &ae_permset, &ae_tag, &ae_id, &ae_name) == ARCHIVE_OK) { acl_create_entry(&acl, &acl_entry); switch (ae_tag) { case ARCHIVE_ENTRY_ACL_USER: acl_set_tag_type(acl_entry, ACL_USER); ae_uid = lookup_uid(a, ae_name, ae_id); acl_set_qualifier(acl_entry, &ae_uid); break; case ARCHIVE_ENTRY_ACL_GROUP: acl_set_tag_type(acl_entry, ACL_GROUP); ae_gid = lookup_gid(a, ae_name, ae_id); acl_set_qualifier(acl_entry, &ae_gid); break; case ARCHIVE_ENTRY_ACL_USER_OBJ: acl_set_tag_type(acl_entry, ACL_USER_OBJ); break; case ARCHIVE_ENTRY_ACL_GROUP_OBJ: acl_set_tag_type(acl_entry, ACL_GROUP_OBJ); break; case ARCHIVE_ENTRY_ACL_MASK: acl_set_tag_type(acl_entry, ACL_MASK); break; case ARCHIVE_ENTRY_ACL_OTHER: acl_set_tag_type(acl_entry, ACL_OTHER); break; default: /* XXX */ break; } acl_get_permset(acl_entry, &acl_permset); acl_clear_perms(acl_permset); if (ae_permset & ARCHIVE_ENTRY_ACL_EXECUTE) acl_add_perm(acl_permset, ACL_EXECUTE); if (ae_permset & ARCHIVE_ENTRY_ACL_WRITE) acl_add_perm(acl_permset, ACL_WRITE); if (ae_permset & ARCHIVE_ENTRY_ACL_READ) acl_add_perm(acl_permset, ACL_READ); } name = archive_entry_pathname(entry); if (acl_set_file(name, acl_type, acl) != 0) { archive_set_error(a, errno, "Failed to set %s acl", typename); ret = ARCHIVE_WARN; } acl_free(acl); return (ret); } #endif /* * XXX The following gid/uid lookups can be a performance bottleneck. * Some form of caching would probably be very effective, though * I have concerns about staleness. */ static gid_t lookup_gid(struct archive *a, const char *gname, gid_t gid) { struct group *grent; (void)a; /* UNUSED */ /* Look up gid from gname. */ if (gname != NULL && *gname != '\0') { grent = getgrnam(gname); if (grent != NULL) gid = grent->gr_gid; } return (gid); } static uid_t lookup_uid(struct archive *a, const char *uname, uid_t uid) { struct passwd *pwent; (void)a; /* UNUSED */ /* Look up uid from uname. */ if (uname != NULL && *uname != '\0') { pwent = getpwnam(uname); if (pwent != NULL) uid = pwent->pw_uid; } return (uid); } void archive_read_extract_set_progress_callback(struct archive *a, void (*progress_func)(void *), void *user_data) { a->extract_progress = progress_func; a->extract_progress_user_data = user_data; }