Import libarchive and bsdtar. The default tar (/usr/bin/tar) can be choosen
[dragonfly.git] / contrib / libarchive / archive_read_extract.c
1 /*-
2  * Copyright (c) 2003-2004 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer
10  *    in this position and unchanged.
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: src/lib/libarchive/archive_read_extract.c,v 1.36 2004/11/05 05:16:40 kientzle Exp $");
29
30 #include <sys/types.h>
31 #ifdef HAVE_SYS_ACL_H
32 #include <sys/acl.h>
33 #endif
34 #ifdef HAVE_SYS_IOCTL_H
35 #include <sys/ioctl.h>
36 #endif
37 #include <sys/stat.h>
38 #include <sys/time.h>
39
40 #ifdef HAVE_EXT2FS_EXT2_FS_H
41 #include <ext2fs/ext2_fs.h>     /* for Linux file flags */
42 #endif
43 #include <errno.h>
44 #include <fcntl.h>
45 #include <grp.h>
46 #ifdef HAVE_LINUX_EXT2_FS_H
47 #include <linux/ext2_fs.h>      /* for Linux file flags */
48 #endif
49 #include <limits.h>
50 #include <pwd.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <unistd.h>
55
56 #include "archive.h"
57 #include "archive_string.h"
58 #include "archive_entry.h"
59 #include "archive_private.h"
60
61 struct fixup_entry {
62         struct fixup_entry      *next;
63         mode_t                   mode;
64         int64_t                  mtime;
65         int64_t                  atime;
66         unsigned long            mtime_nanos;
67         unsigned long            atime_nanos;
68         unsigned long            fflags_set;
69         int                      fixup; /* bitmask of what needs fixing */
70         char                    *name;
71 };
72
73 #define FIXUP_MODE      1
74 #define FIXUP_TIMES     2
75 #define FIXUP_FFLAGS    4
76
77 struct bucket {
78         char    *name;
79         int      hash;
80         id_t     id;
81 };
82
83 struct extract {
84         mode_t                   umask;
85         mode_t                   default_dir_mode;
86         struct archive_string    create_parent_dir;
87         struct fixup_entry      *fixup_list;
88         struct fixup_entry      *current_fixup;
89
90         struct bucket ucache[127];
91         struct bucket gcache[127];
92
93         /*
94          * Cached stat data from disk for the current entry.
95          * If this is valid, pst points to st.  Otherwise,
96          * pst is null.
97          *
98          * TODO: Have all of the stat calls use this cached data
99          * if possible.
100          */
101         struct stat              st;
102         struct stat             *pst;
103 };
104
105 /* Default mode for dirs created automatically (will be modified by umask). */
106 #define DEFAULT_DIR_MODE 0777
107 /*
108  * Mode to use for newly-created dirs during extraction; the correct
109  * mode will be set at the end of the extraction.
110  */
111 #define SECURE_DIR_MODE 0700
112
113 static void     archive_extract_cleanup(struct archive *);
114 static int      extract_block_device(struct archive *,
115                     struct archive_entry *, int);
116 static int      extract_char_device(struct archive *,
117                     struct archive_entry *, int);
118 static int      extract_device(struct archive *,
119                     struct archive_entry *, int flags, mode_t mode);
120 static int      extract_dir(struct archive *, struct archive_entry *, int);
121 static int      extract_fifo(struct archive *, struct archive_entry *, int);
122 static int      extract_file(struct archive *, struct archive_entry *, int);
123 static int      extract_hard_link(struct archive *, struct archive_entry *, int);
124 static int      extract_symlink(struct archive *, struct archive_entry *, int);
125 static unsigned int     hash(const char *);
126 static gid_t    lookup_gid(struct archive *, const char *uname, gid_t);
127 static uid_t    lookup_uid(struct archive *, const char *uname, uid_t);
128 static int      create_parent_dir(struct archive *, const char *, int flags);
129 static int      create_parent_dir_internal(struct archive *, char *,
130                     int flags);
131 static int      create_parent_dir_recursive(struct archive *, char *,
132                     int flags);
133 static int      restore_metadata(struct archive *, struct archive_entry *,
134                     int flags);
135 #ifdef HAVE_POSIX_ACL
136 static int      set_acl(struct archive *, struct archive_entry *,
137                     acl_type_t, int archive_entry_acl_type, const char *tn);
138 #endif
139 static int      set_acls(struct archive *, struct archive_entry *);
140 static int      set_fflags(struct archive *, const char *name, mode_t mode,
141                     unsigned long fflags_set, unsigned long fflags_clear);
142 static int      set_ownership(struct archive *, struct archive_entry *, int);
143 static int      set_perm(struct archive *, struct archive_entry *, int mode,
144                     int flags);
145 static int      set_time(struct archive *, struct archive_entry *, int);
146 static struct fixup_entry *sort_dir_list(struct fixup_entry *p);
147
148
149 /*
150  * Extract this entry to disk.
151  *
152  * TODO: Validate hardlinks.  According to the standards, we're
153  * supposed to check each extracted hardlink and squawk if it refers
154  * to a file that we didn't restore.  I'm not entirely convinced this
155  * is a good idea, but more importantly: Is there any way to validate
156  * hardlinks without keeping a complete list of filenames from the
157  * entire archive?? Ugh.
158  *
159  */
160 int
161 archive_read_extract(struct archive *a, struct archive_entry *entry, int flags)
162 {
163         mode_t mode;
164         struct extract *extract;
165         int ret;
166         int restore_pwd;
167
168         if (a->extract == NULL) {
169                 a->extract = malloc(sizeof(*a->extract));
170                 if (a->extract == NULL) {
171                         archive_set_error(a, ENOMEM, "Can't extract");
172                         return (ARCHIVE_FATAL);
173                 }
174                 a->cleanup_archive_extract = archive_extract_cleanup;
175                 memset(a->extract, 0, sizeof(*a->extract));
176         }
177         extract = a->extract;
178         umask(extract->umask = umask(0)); /* Read the current umask. */
179         extract->default_dir_mode = DEFAULT_DIR_MODE & ~extract->umask;
180         extract->pst = NULL;
181         extract->current_fixup = NULL;
182         restore_pwd = -1;
183
184         /*
185          * TODO: If pathname is longer than PATH_MAX, record starting
186          * directory and move to a suitable intermediate dir, which
187          * might require creating them!
188          */
189         if (strlen(archive_entry_pathname(entry)) > PATH_MAX) {
190                 restore_pwd = open(".", O_RDONLY);
191                 /* XXX chdir() to a suitable intermediate dir XXX */
192                 /* XXX Update pathname in 'entry' XXX */
193         }
194
195         if (stat(archive_entry_pathname(entry), &extract->st) == 0)
196                 extract->pst = &extract->st;
197
198         if (extract->pst != NULL &&
199             extract->pst->st_dev == a->skip_file_dev &&
200             extract->pst->st_ino == a->skip_file_ino) {
201                 archive_set_error(a, 0, "Refusing to overwrite archive");
202                 ret = ARCHIVE_WARN;
203         } else if (archive_entry_hardlink(entry) != NULL)
204                 ret = extract_hard_link(a, entry, flags);
205         else {
206                 mode = archive_entry_mode(entry);
207                 switch (mode & S_IFMT) {
208                 default:
209                         /* Fall through, as required by POSIX. */
210                 case S_IFREG:
211                         ret = extract_file(a, entry, flags);
212                         break;
213                 case S_IFLNK:   /* Symlink */
214                         ret = extract_symlink(a, entry, flags);
215                         break;
216                 case S_IFCHR:
217                         ret = extract_char_device(a, entry, flags);
218                         break;
219                 case S_IFBLK:
220                         ret = extract_block_device(a, entry, flags);
221                         break;
222                 case S_IFDIR:
223                         ret = extract_dir(a, entry, flags);
224                         break;
225                 case S_IFIFO:
226                         ret = extract_fifo(a, entry, flags);
227                         break;
228                 }
229         }
230
231         /* If we changed directory above, restore it here. */
232         if (restore_pwd >= 0)
233                 fchdir(restore_pwd);
234
235         return (ret);
236 }
237
238 /*
239  * Cleanup function for archive_extract.  Mostly, this involves processing
240  * the fixup list, which is used to address a number of problems:
241  *   * Dir permissions might prevent us from restoring a file in that
242  *     dir, so we restore the dir 0700 first, then correct the
243  *     mode at the end.
244  *   * Similarly, the act of restoring a file touches the directory
245  *     and changes the timestamp on the dir, so we have to touch-up the
246  *     timestamps at the end as well.
247  *   * Some file flags can interfere with the restore by, for example,
248  *     preventing the creation of hardlinks to those files.
249  *
250  * Note that tar/cpio do not require that archives be in a particular
251  * order; there is no way to know when the last file has been restored
252  * within a directory, so there's no way to optimize the memory usage
253  * here by fixing up the directory any earlier than the
254  * end-of-archive.
255  *
256  * XXX TODO: Directory ACLs should be restored here, for the same
257  * reason we set directory perms here. XXX
258  *
259  * Registering this function (rather than calling it explicitly by
260  * name from archive_read_finish) reduces static link pollution, since
261  * applications that don't use this API won't get this file linked in.
262  */
263 static void
264 archive_extract_cleanup(struct archive *a)
265 {
266         struct fixup_entry *next, *p;
267         struct extract *extract;
268
269         /* Sort dir list so directories are fixed up in depth-first order. */
270         extract = a->extract;
271         p = sort_dir_list(extract->fixup_list);
272
273         while (p != NULL) {
274                 extract->pst = NULL; /* Mark stat buff as out-of-date. */
275                 if (p->fixup & FIXUP_TIMES) {
276                         struct timeval times[2];
277                         times[1].tv_sec = p->mtime;
278                         times[1].tv_usec = p->mtime_nanos / 1000;
279                         times[0].tv_sec = p->atime;
280                         times[0].tv_usec = p->atime_nanos / 1000;
281                         utimes(p->name, times);
282                 }
283                 if (p->fixup & FIXUP_MODE)
284                         chmod(p->name, p->mode);
285
286                 if (p->fixup & FIXUP_FFLAGS)
287                         set_fflags(a, p->name, p->mode, p->fflags_set, 0);
288
289                 next = p->next;
290                 free(p->name);
291                 free(p);
292                 p = next;
293         }
294         extract->fixup_list = NULL;
295         archive_string_free(&extract->create_parent_dir);
296         free(a->extract);
297         a->extract = NULL;
298 }
299
300 /*
301  * Simple O(n log n) merge sort to order the fixup list.  In
302  * particular, we want to restore dir timestamps depth-first.
303  */
304 static struct fixup_entry *
305 sort_dir_list(struct fixup_entry *p)
306 {
307         struct fixup_entry *a, *b, *t;
308
309         if (p == NULL)
310                 return (NULL);
311         /* A one-item list is already sorted. */
312         if (p->next == NULL)
313                 return (p);
314
315         /* Step 1: split the list. */
316         t = p;
317         a = p->next->next;
318         while (a != NULL) {
319                 /* Step a twice, t once. */
320                 a = a->next;
321                 if (a != NULL)
322                         a = a->next;
323                 t = t->next;
324         }
325         /* Now, t is at the mid-point, so break the list here. */
326         b = t->next;
327         t->next = NULL;
328         a = p;
329
330         /* Step 2: Recursively sort the two sub-lists. */
331         a = sort_dir_list(a);
332         b = sort_dir_list(b);
333
334         /* Step 3: Merge the returned lists. */
335         /* Pick the first element for the merged list. */
336         if (strcmp(a->name, b->name) > 0) {
337                 t = p = a;
338                 a = a->next;
339         } else {
340                 t = p = b;
341                 b = b->next;
342         }
343
344         /* Always put the later element on the list first. */
345         while (a != NULL && b != NULL) {
346                 if (strcmp(a->name, b->name) > 0) {
347                         t->next = a;
348                         a = a->next;
349                 } else {
350                         t->next = b;
351                         b = b->next;
352                 }
353                 t = t->next;
354         }
355
356         /* Only one list is non-empty, so just splice it on. */
357         if (a != NULL)
358                 t->next = a;
359         if (b != NULL)
360                 t->next = b;
361
362         return (p);
363 }
364
365 /*
366  * Returns a new, initialized fixup entry.
367  */
368 static struct fixup_entry *
369 new_fixup(struct archive *a, const char *pathname)
370 {
371         struct extract *extract;
372         struct fixup_entry *fe;
373
374         extract = a->extract;
375         fe = malloc(sizeof(struct fixup_entry));
376         if (fe == NULL)
377                 return (NULL);
378         fe->next = extract->fixup_list;
379         extract->fixup_list = fe;
380         fe->fixup = 0;
381         fe->name = strdup(pathname);
382         return (fe);
383 }
384
385 /*
386  * Returns a fixup structure for the current entry.
387  */
388 static struct fixup_entry *
389 current_fixup(struct archive *a, const char *pathname)
390 {
391         struct extract *extract;
392
393         extract = a->extract;
394         if (extract->current_fixup == NULL)
395                 extract->current_fixup = new_fixup(a, pathname);
396         return (extract->current_fixup);
397 }
398
399 static int
400 extract_file(struct archive *a, struct archive_entry *entry, int flags)
401 {
402         struct extract *extract;
403         const char *name;
404         mode_t mode;
405         int fd, r, r2;
406
407         extract = a->extract;
408         name = archive_entry_pathname(entry);
409         mode = archive_entry_mode(entry) & 0777;
410         r = ARCHIVE_OK;
411
412         /*
413          * If we're not supposed to overwrite pre-existing files,
414          * use O_EXCL.  Otherwise, use O_TRUNC.
415          */
416         if (flags & (ARCHIVE_EXTRACT_UNLINK | ARCHIVE_EXTRACT_NO_OVERWRITE))
417                 fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode);
418         else
419                 fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, mode);
420
421         /* Try removing a pre-existing file. */
422         if (fd < 0 && !(flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
423                 unlink(name);
424                 fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode);
425         }
426
427         /* Might be a non-existent parent dir; try fixing that. */
428         if (fd < 0) {
429                 create_parent_dir(a, name, flags);
430                 fd = open(name, O_WRONLY | O_CREAT | O_EXCL, mode);
431         }
432         if (fd < 0) {
433                 archive_set_error(a, errno, "Can't open '%s'", name);
434                 return (ARCHIVE_WARN);
435         }
436         r = archive_read_data_into_fd(a, fd);
437         extract->pst = NULL; /* Cached stat data no longer valid. */
438         r2 = restore_metadata(a, entry, flags);
439         close(fd);
440         return (err_combine(r, r2));
441 }
442
443 static int
444 extract_dir(struct archive *a, struct archive_entry *entry, int flags)
445 {
446         struct extract *extract;
447         struct fixup_entry *fe;
448         char *path, *p;
449
450         extract = a->extract;
451         extract->pst = NULL; /* Invalidate cached stat data. */
452
453         /* Copy path to mutable storage. */
454         archive_strcpy(&(extract->create_parent_dir),
455             archive_entry_pathname(entry));
456         path = extract->create_parent_dir.s;
457
458         /* Deal with any troublesome trailing path elements. */
459         for (;;) {
460                 if (*path == '\0')
461                         return (ARCHIVE_OK);
462                 /* Locate last element; trim trailing '/'. */
463                 p = strrchr(path, '/');
464                 if (p != NULL) {
465                         if (p[1] == '\0') {
466                                 *p = '\0';
467                                 continue;
468                         }
469                         p++;
470                 } else
471                         p = path;
472                 /* Trim trailing '.'. */
473                 if (p[0] == '.' && p[1] == '\0') {
474                         p[0] = '\0';
475                         continue;
476                 }
477                 /* Just exit on trailing '..'. */
478                 if (p[0] == '.' && p[1] == '.' && p[2] == '\0')
479                         return (ARCHIVE_OK);
480                 break;
481         }
482
483         if (mkdir(path, SECURE_DIR_MODE) == 0)
484                 goto success;
485
486         if (extract->pst == NULL && stat(path, &extract->st) == 0)
487                 extract->pst = &extract->st;
488
489         if (extract->pst != NULL) {
490                 extract->pst = &extract->st;
491                 /* If dir already exists, don't reset permissions. */
492                 if (S_ISDIR(extract->pst->st_mode))
493                         return (ARCHIVE_OK);
494                 /* It exists but isn't a dir. */
495                 if ((flags & ARCHIVE_EXTRACT_UNLINK))
496                         unlink(path);
497         } else {
498                 /* Doesn't already exist; try building the parent path. */
499                 if (create_parent_dir_internal(a, path, flags) != ARCHIVE_OK)
500                         return (ARCHIVE_WARN);
501         }
502
503         /* One final attempt to create the dir. */
504         if (mkdir(path, SECURE_DIR_MODE) != 0) {
505                 archive_set_error(a, errno, "Can't create directory");
506                 return (ARCHIVE_WARN);
507         }
508
509 success:
510         /* Add this dir to the fixup list. */
511         fe = current_fixup(a, path);
512         fe->fixup |= FIXUP_MODE;
513         fe->mode = archive_entry_mode(entry);
514         if ((flags & ARCHIVE_EXTRACT_PERM) == 0)
515                 fe->mode &= ~extract->umask;
516         if (flags & ARCHIVE_EXTRACT_TIME) {
517                 fe->fixup |= FIXUP_TIMES;
518                 fe->mtime = archive_entry_mtime(entry);
519                 fe->mtime_nanos = archive_entry_mtime_nsec(entry);
520                 fe->atime = archive_entry_atime(entry);
521                 fe->atime_nanos = archive_entry_atime_nsec(entry);
522         }
523         /* For now, set the mode to SECURE_DIR_MODE. */
524         archive_entry_set_mode(entry, SECURE_DIR_MODE);
525         return (restore_metadata(a, entry, flags));
526 }
527
528
529 /*
530  * Create the parent of the specified path.  Copy the provided
531  * path into mutable storage first.
532  */
533 static int
534 create_parent_dir(struct archive *a, const char *path, int flags)
535 {
536         struct extract *extract;
537         int r;
538
539         extract = a->extract;
540
541         /* Copy path to mutable storage. */
542         archive_strcpy(&(extract->create_parent_dir), path);
543
544         r = create_parent_dir_internal(a, extract->create_parent_dir.s, flags);
545         return (r);
546 }
547
548 /*
549  * Handle remaining setup for create_parent_dir_recursive(), assuming
550  * path is already in mutable storage.
551  */
552 static int
553 create_parent_dir_internal(struct archive *a, char *path, int flags)
554 {
555         char *slash;
556         mode_t old_umask;
557         int r;
558
559         /* Remove tail element to obtain parent name. */
560         slash = strrchr(path, '/');
561         if (slash == NULL)
562                 return (ARCHIVE_OK);
563         *slash = '\0';
564         old_umask = umask(~SECURE_DIR_MODE);
565         r = create_parent_dir_recursive(a, path, flags);
566         umask(old_umask);
567         *slash = '/';
568         return (r);
569 }
570
571 /*
572  * Create the specified dir, recursing to create parents as necessary.
573  *
574  * Returns ARCHIVE_OK if the path exists when we're done here.
575  * Otherwise, returns ARCHIVE_WARN.
576  */
577 static int
578 create_parent_dir_recursive(struct archive *a, char *path, int flags)
579 {
580         struct stat st;
581         struct extract *extract;
582         struct fixup_entry *le;
583         char *slash, *base;
584         int r;
585
586         extract = a->extract;
587         r = ARCHIVE_OK;
588
589         /* Check for special names and just skip them. */
590         slash = strrchr(path, '/');
591         base = strrchr(path, '/');
592         if (slash == NULL)
593                 base = path;
594         else
595                 base = slash + 1;
596
597         if (base[0] == '\0' ||
598             (base[0] == '.' && base[1] == '\0') ||
599             (base[0] == '.' && base[1] == '.' && base[2] == '\0')) {
600                 /* Don't bother trying to create null path, '.', or '..'. */
601                 if (slash != NULL) {
602                         *slash = '\0';
603                         r = create_parent_dir_recursive(a, path, flags);
604                         *slash = '/';
605                         return (r);
606                 }
607                 return (ARCHIVE_OK);
608         }
609
610         /*
611          * Yes, this should be stat() and not lstat().  Using lstat()
612          * here loses the ability to extract through symlinks.  Also note
613          * that this should not use the extract->st cache.
614          */
615         if (stat(path, &st) == 0) {
616                 if (S_ISDIR(st.st_mode))
617                         return (ARCHIVE_OK);
618                 if ((flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
619                         archive_set_error(a, EEXIST,
620                             "Can't create directory '%s'", path);
621                         return (ARCHIVE_WARN);
622                 }
623                 if (unlink(path) != 0) {
624                         archive_set_error(a, errno,
625                             "Can't create directory '%s': "
626                             "Conflicting file cannot be removed");
627                         return (ARCHIVE_WARN);
628                 }
629         } else if (errno != ENOENT && errno != ENOTDIR) {
630                 /* Stat failed? */
631                 archive_set_error(a, errno, "Can't test directory '%s'", path);
632                 return (ARCHIVE_WARN);
633         } else if (slash != NULL) {
634                 *slash = '\0';
635                 r = create_parent_dir_recursive(a, path, flags);
636                 *slash = '/';
637                 if (r != ARCHIVE_OK)
638                         return (r);
639         }
640
641         if (mkdir(path, SECURE_DIR_MODE) == 0) {
642                 le = new_fixup(a, path);
643                 le->fixup |= FIXUP_MODE;
644                 le->mode = extract->default_dir_mode;
645                 return (ARCHIVE_OK);
646         }
647
648         /*
649          * Without the following check, a/b/../b/c/d fails at the
650          * second visit to 'b', so 'd' can't be created.  Note that we
651          * don't add it to the fixup list here, as it's already been
652          * added.
653          */
654         if (stat(path, &st) == 0 && S_ISDIR(st.st_mode))
655                 return (ARCHIVE_OK);
656
657         archive_set_error(a, errno, "Failed to create dir '%s'", path);
658         return (ARCHIVE_WARN);
659 }
660
661 static int
662 extract_hard_link(struct archive *a, struct archive_entry *entry, int flags)
663 {
664         struct extract *extract;
665         int r;
666         const char *pathname;
667         const char *linkname;
668
669         extract = a->extract;
670         pathname = archive_entry_pathname(entry);
671         linkname = archive_entry_hardlink(entry);
672
673         /* Just remove any pre-existing file with this name. */
674         if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE))
675                 unlink(pathname);
676
677         r = link(linkname, pathname);
678         extract->pst = NULL; /* Invalidate cached stat data. */
679
680         if (r != 0) {
681                 /* Might be a non-existent parent dir; try fixing that. */
682                 create_parent_dir(a, pathname, flags);
683                 r = link(linkname, pathname);
684         }
685
686         if (r != 0) {
687                 /* XXX Better error message here XXX */
688                 archive_set_error(a, errno,
689                     "Can't restore hardlink to '%s'", linkname);
690                 return (ARCHIVE_WARN);
691         }
692
693         /* Set ownership, time, permission information. */
694         r = restore_metadata(a, entry, flags);
695         return (r);
696 }
697
698 static int
699 extract_symlink(struct archive *a, struct archive_entry *entry, int flags)
700 {
701         struct extract *extract;
702         int r;
703         const char *pathname;
704         const char *linkname;
705
706         extract = a->extract;
707         pathname = archive_entry_pathname(entry);
708         linkname = archive_entry_symlink(entry);
709
710         /* Just remove any pre-existing file with this name. */
711         if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE))
712                 unlink(pathname);
713
714         r = symlink(linkname, pathname);
715         extract->pst = NULL; /* Invalidate cached stat data. */
716
717         if (r != 0) {
718                 /* Might be a non-existent parent dir; try fixing that. */
719                 create_parent_dir(a, pathname, flags);
720                 r = symlink(linkname, pathname);
721         }
722
723         if (r != 0) {
724                 /* XXX Better error message here XXX */
725                 archive_set_error(a, errno,
726                     "Can't restore symlink to '%s'", linkname);
727                 return (ARCHIVE_WARN);
728         }
729
730         r = restore_metadata(a, entry, flags);
731         return (r);
732 }
733
734 static int
735 extract_device(struct archive *a, struct archive_entry *entry,
736     int flags, mode_t mode)
737 {
738         struct extract *extract;
739         int r;
740
741         extract = a->extract;
742         /* Just remove any pre-existing file with this name. */
743         if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE))
744                 unlink(archive_entry_pathname(entry));
745
746         r = mknod(archive_entry_pathname(entry), mode,
747             archive_entry_rdev(entry));
748         extract->pst = NULL; /* Invalidate cached stat data. */
749
750         /* Might be a non-existent parent dir; try fixing that. */
751         if (r != 0 && errno == ENOENT) {
752                 create_parent_dir(a, archive_entry_pathname(entry), flags);
753                 r = mknod(archive_entry_pathname(entry), mode,
754                     archive_entry_rdev(entry));
755         }
756
757         if (r != 0) {
758                 archive_set_error(a, errno, "Can't restore device node");
759                 return (ARCHIVE_WARN);
760         }
761
762         r = restore_metadata(a, entry, flags);
763         return (r);
764 }
765
766 static int
767 extract_char_device(struct archive *a, struct archive_entry *entry, int flags)
768 {
769         mode_t mode;
770
771         mode = (archive_entry_mode(entry) & ~S_IFMT) | S_IFCHR;
772         return (extract_device(a, entry, flags, mode));
773 }
774
775 static int
776 extract_block_device(struct archive *a, struct archive_entry *entry, int flags)
777 {
778         mode_t mode;
779
780         mode = (archive_entry_mode(entry) & ~S_IFMT) | S_IFBLK;
781         return (extract_device(a, entry, flags, mode));
782 }
783
784 static int
785 extract_fifo(struct archive *a, struct archive_entry *entry, int flags)
786 {
787         struct extract *extract;
788         int r;
789
790         extract = a->extract;
791         /* Just remove any pre-existing file with this name. */
792         if (!(flags & ARCHIVE_EXTRACT_NO_OVERWRITE))
793                 unlink(archive_entry_pathname(entry));
794
795         r = mkfifo(archive_entry_pathname(entry),
796             archive_entry_mode(entry));
797         extract->pst = NULL; /* Invalidate cached stat data. */
798
799         /* Might be a non-existent parent dir; try fixing that. */
800         if (r != 0 && errno == ENOENT) {
801                 create_parent_dir(a, archive_entry_pathname(entry), flags);
802                 r = mkfifo(archive_entry_pathname(entry),
803                     archive_entry_mode(entry));
804         }
805
806         if (r != 0) {
807                 archive_set_error(a, errno, "Can't restore fifo");
808                 return (ARCHIVE_WARN);
809         }
810
811         r = restore_metadata(a, entry, flags);
812         return (r);
813 }
814
815 static int
816 restore_metadata(struct archive *a, struct archive_entry *entry, int flags)
817 {
818         int r, r2;
819
820         r = set_ownership(a, entry, flags);
821         r2 = set_time(a, entry, flags);
822         r = err_combine(r, r2);
823         r2 = set_perm(a, entry, archive_entry_mode(entry), flags);
824         return (err_combine(r, r2));
825 }
826
827 static int
828 set_ownership(struct archive *a, struct archive_entry *entry, int flags)
829 {
830         uid_t uid;
831         gid_t gid;
832
833         /* Not changed. */
834         if ((flags & ARCHIVE_EXTRACT_OWNER) == 0)
835                 return (ARCHIVE_OK);
836
837         uid = lookup_uid(a, archive_entry_uname(entry),
838             archive_entry_uid(entry));
839         gid = lookup_gid(a, archive_entry_gname(entry),
840             archive_entry_gid(entry));
841
842         /* If we know we can't change it, don't bother trying. */
843         if (a->user_uid != 0  &&  a->user_uid != uid)
844                 return (ARCHIVE_OK);
845
846 #ifdef HAVE_LCHOWN
847         if (lchown(archive_entry_pathname(entry), uid, gid))
848 #else
849         if (!S_ISLNK(archive_entry_mode(entry))
850             && chown(archive_entry_pathname(entry), uid, gid) != 0)
851 #endif
852         {
853                 archive_set_error(a, errno,
854                     "Can't set user=%d/group=%d for %s", uid, gid,
855                     archive_entry_pathname(entry));
856                 return (ARCHIVE_WARN);
857         }
858         return (ARCHIVE_OK);
859 }
860
861 static int
862 set_time(struct archive *a, struct archive_entry *entry, int flags)
863 {
864         const struct stat *st;
865         struct timeval times[2];
866
867         (void)a; /* UNUSED */
868         st = archive_entry_stat(entry);
869
870         if ((flags & ARCHIVE_EXTRACT_TIME) == 0)
871                 return (ARCHIVE_OK);
872         /* It's a waste of time to mess with dir timestamps here. */
873         if (S_ISDIR(archive_entry_mode(entry)))
874                 return (ARCHIVE_OK);
875
876         times[1].tv_sec = st->st_mtime;
877         times[1].tv_usec = ARCHIVE_STAT_MTIME_NANOS(st) / 1000;
878
879         times[0].tv_sec = st->st_atime;
880         times[0].tv_usec = ARCHIVE_STAT_ATIME_NANOS(st) / 1000;
881
882 #ifdef HAVE_LUTIMES
883         if (lutimes(archive_entry_pathname(entry), times) != 0) {
884 #else
885         if ((archive_entry_mode(entry) & S_IFMT) != S_IFLNK &&
886             utimes(archive_entry_pathname(entry), times) != 0) {
887 #endif
888                 archive_set_error(a, errno, "Can't update time for %s",
889                     archive_entry_pathname(entry));
890                 return (ARCHIVE_WARN);
891         }
892
893         /*
894          * Note: POSIX does not provide a portable way to restore ctime.
895          * (Apart from resetting the system clock, which is distasteful.)
896          * So, any restoration of ctime will necessarily be OS-specific.
897          */
898
899         /* XXX TODO: Can FreeBSD restore ctime? XXX */
900
901         return (ARCHIVE_OK);
902 }
903
904 static int
905 set_perm(struct archive *a, struct archive_entry *entry, int mode, int flags)
906 {
907         struct extract *extract;
908         struct fixup_entry *le;
909         const char *name;
910         unsigned long    set, clear;
911         int              r;
912         int              critical_flags;
913
914         extract = a->extract;
915
916         /* Obey umask unless ARCHIVE_EXTRACT_PERM. */
917         if ((flags & ARCHIVE_EXTRACT_PERM) == 0)
918                 mode &= ~extract->umask; /* Enforce umask. */
919         name = archive_entry_pathname(entry);
920
921         if (mode & (S_ISUID | S_ISGID)) {
922                 if (extract->pst == NULL && stat(name, &extract->st) != 0) {
923                         archive_set_error(a, errno, "Can't check ownership");
924                         return (ARCHIVE_WARN);
925                 }
926                 extract->pst = &extract->st;
927                 /*
928                  * TODO: Use the uid/gid looked up in set_ownership
929                  * above rather than the uid/gid stored in the entry.
930                  */
931                 if (extract->pst->st_uid != archive_entry_uid(entry))
932                         mode &= ~ S_ISUID;
933                 if (extract->pst->st_gid != archive_entry_gid(entry))
934                         mode &= ~ S_ISGID;
935         }
936
937         /*
938          * Ensure we change permissions on the object we extracted,
939          * and not any incidental symlink that might have gotten in
940          * the way.
941          */
942         if (!S_ISLNK(archive_entry_mode(entry))) {
943                 if (chmod(name, mode) != 0) {
944                         archive_set_error(a, errno, "Can't set permissions");
945                         return (ARCHIVE_WARN);
946                 }
947 #ifdef HAVE_LCHMOD
948         } else {
949                 /*
950                  * If lchmod() isn't supported, it's no big deal.
951                  * Permissions on symlinks are actually ignored on
952                  * most platforms.
953                  */
954                 if (lchmod(name, mode) != 0) {
955                         archive_set_error(a, errno, "Can't set permissions");
956                         return (ARCHIVE_WARN);
957                 }
958 #endif
959         }
960
961         if (flags & ARCHIVE_EXTRACT_ACL) {
962                 r = set_acls(a, entry);
963                 if (r != ARCHIVE_OK)
964                         return (r);
965         }
966
967         /*
968          * Make 'critical_flags' hold all file flags that can't be
969          * immediately restored.  For example, on BSD systems,
970          * SF_IMMUTABLE prevents hardlinks from being created, so
971          * should not be set until after any hardlinks are created.  To
972          * preserve some semblance of portability, this uses #ifdef
973          * extensively.  Ugly, but it works.
974          *
975          * Yes, Virginia, this does create a security race.  It's mitigated
976          * somewhat by the practice of creating dirs 0700 until the extract
977          * is done, but it would be nice if we could do more than that.
978          * People restoring critical file systems should be wary of
979          * other programs that might try to muck with files as they're
980          * being restored.
981          */
982         /* Hopefully, the compiler will optimize this mess into a constant. */
983         critical_flags = 0;
984 #ifdef SF_IMMUTABLE
985         critical_flags |= SF_IMMUTABLE;
986 #endif
987 #ifdef UF_IMMUTABLE
988         critical_flags |= UF_IMMUTABLE;
989 #endif
990 #ifdef SF_APPEND
991         critical_flags |= SF_APPEND;
992 #endif
993 #ifdef UF_APPEND
994         critical_flags |= UF_APPEND;
995 #endif
996 #ifdef EXT2_APPEND_FL
997         critical_flags |= EXT2_APPEND_FL;
998 #endif
999 #ifdef EXT2_IMMUTABLE_FL
1000         critical_flags |= EXT2_IMMUTABLE_FL;
1001 #endif
1002
1003         if (flags & ARCHIVE_EXTRACT_FFLAGS) {
1004                 archive_entry_fflags(entry, &set, &clear);
1005
1006                 /*
1007                  * The first test encourages the compiler to eliminate
1008                  * all of this if it's not necessary.
1009                  */
1010                 if ((critical_flags != 0)  &&  (set & critical_flags)) {
1011                         le = current_fixup(a, archive_entry_pathname(entry));
1012                         le->fixup |= FIXUP_FFLAGS;
1013                         le->fflags_set = set;
1014                 } else {
1015                         r = set_fflags(a, archive_entry_pathname(entry),
1016                             archive_entry_mode(entry), set, clear);
1017                         if (r != ARCHIVE_OK)
1018                                 return (r);
1019                 }
1020         }
1021         return (ARCHIVE_OK);
1022 }
1023
1024 static int
1025 set_fflags(struct archive *a, const char *name, mode_t mode,
1026     unsigned long set, unsigned long clear)
1027 {
1028         struct extract *extract;
1029         int              ret;
1030 #ifdef linux
1031         int              fd;
1032         int              err;
1033         unsigned long newflags, oldflags;
1034 #endif
1035
1036         extract = a->extract;
1037         ret = ARCHIVE_OK;
1038         if (set == 0  && clear == 0)
1039                 return (ret);
1040
1041 #ifdef HAVE_CHFLAGS
1042         (void)mode; /* UNUSED */
1043         /*
1044          * XXX Is the stat here really necessary?  Or can I just use
1045          * the 'set' flags directly?  In particular, I'm not sure
1046          * about the correct approach if we're overwriting an existing
1047          * file that already has flags on it. XXX
1048          */
1049         if (stat(name, &extract->st) == 0) {
1050                 extract->st.st_flags &= ~clear;
1051                 extract->st.st_flags |= set;
1052                 if (chflags(name, extract->st.st_flags) != 0) {
1053                         archive_set_error(a, errno,
1054                             "Failed to set file flags");
1055                         ret = ARCHIVE_WARN;
1056                 }
1057                 extract->pst = &extract->st;
1058         }
1059 #else
1060 #ifdef linux
1061         /* Linux has flags too, but no chflags syscall */
1062         /*
1063          * Linux has no define for the flags that are only settable
1064          * by the root user...
1065          */
1066 #define SF_MASK                 (EXT2_IMMUTABLE_FL|EXT2_APPEND_FL)
1067
1068         /*
1069          * XXX As above, this would be way simpler if we didn't have
1070          * to read the current flags from disk. XXX
1071          */
1072         if ((S_ISREG(mode) || S_ISDIR(mode)) &&
1073             ((fd = open(name, O_RDONLY|O_NONBLOCK)) >= 0)) {
1074                 err = 1;
1075                 if (fd >= 0 && (ioctl(fd, EXT2_IOC_GETFLAGS, &oldflags) >= 0)) {
1076                         newflags = (oldflags & ~clear) | set;
1077                         if (ioctl(fd, EXT2_IOC_SETFLAGS, &newflags) >= 0) {
1078                                 err = 0;
1079                         } else if (errno == EPERM) {
1080                                 if (ioctl(fd, EXT2_IOC_GETFLAGS, &oldflags) >= 0) {
1081                                         newflags &= ~SF_MASK;
1082                                         oldflags &= SF_MASK;
1083                                         newflags |= oldflags;
1084                                         if (ioctl(fd, EXT2_IOC_SETFLAGS, &newflags) >= 0)
1085                                                 err = 0;
1086                                 }
1087                         }
1088                 }
1089                 close(fd);
1090                 if (err) {
1091                         archive_set_error(a, errno,
1092                             "Failed to set file flags");
1093                         ret = ARCHIVE_WARN;
1094                 }
1095         }
1096 #endif /* linux */
1097 #endif /* HAVE_CHFLAGS */
1098
1099         return (ret);
1100 }
1101
1102 #ifndef HAVE_POSIX_ACL
1103 /* Default empty function body to satisfy mainline code. */
1104 static int
1105 set_acls(struct archive *a, struct archive_entry *entry)
1106 {
1107         (void)a;
1108         (void)entry;
1109
1110         return (ARCHIVE_OK);
1111 }
1112
1113 #else
1114
1115 /*
1116  * XXX TODO: What about ACL types other than ACCESS and DEFAULT?
1117  */
1118 static int
1119 set_acls(struct archive *a, struct archive_entry *entry)
1120 {
1121         int              ret;
1122
1123         ret = set_acl(a, entry, ACL_TYPE_ACCESS,
1124             ARCHIVE_ENTRY_ACL_TYPE_ACCESS, "access");
1125         if (ret != ARCHIVE_OK)
1126                 return (ret);
1127         ret = set_acl(a, entry, ACL_TYPE_DEFAULT,
1128             ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, "default");
1129         return (ret);
1130 }
1131
1132
1133 static int
1134 set_acl(struct archive *a, struct archive_entry *entry, acl_type_t acl_type,
1135     int ae_requested_type, const char *typename)
1136 {
1137         acl_t            acl;
1138         acl_entry_t      acl_entry;
1139         acl_permset_t    acl_permset;
1140         int              ret;
1141         int              ae_type, ae_permset, ae_tag, ae_id;
1142         uid_t            ae_uid;
1143         gid_t            ae_gid;
1144         const char      *ae_name;
1145         int              entries;
1146         const char      *name;
1147
1148         ret = ARCHIVE_OK;
1149         entries = archive_entry_acl_reset(entry, ae_requested_type);
1150         if (entries == 0)
1151                 return (ARCHIVE_OK);
1152         acl = acl_init(entries);
1153         while (archive_entry_acl_next(entry, ae_requested_type, &ae_type,
1154                    &ae_permset, &ae_tag, &ae_id, &ae_name) == ARCHIVE_OK) {
1155                 acl_create_entry(&acl, &acl_entry);
1156
1157                 switch (ae_tag) {
1158                 case ARCHIVE_ENTRY_ACL_USER:
1159                         acl_set_tag_type(acl_entry, ACL_USER);
1160                         ae_uid = lookup_uid(a, ae_name, ae_id);
1161                         acl_set_qualifier(acl_entry, &ae_uid);
1162                         break;
1163                 case ARCHIVE_ENTRY_ACL_GROUP:
1164                         acl_set_tag_type(acl_entry, ACL_GROUP);
1165                         ae_gid = lookup_gid(a, ae_name, ae_id);
1166                         acl_set_qualifier(acl_entry, &ae_gid);
1167                         break;
1168                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
1169                         acl_set_tag_type(acl_entry, ACL_USER_OBJ);
1170                         break;
1171                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1172                         acl_set_tag_type(acl_entry, ACL_GROUP_OBJ);
1173                         break;
1174                 case ARCHIVE_ENTRY_ACL_MASK:
1175                         acl_set_tag_type(acl_entry, ACL_MASK);
1176                         break;
1177                 case ARCHIVE_ENTRY_ACL_OTHER:
1178                         acl_set_tag_type(acl_entry, ACL_OTHER);
1179                         break;
1180                 default:
1181                         /* XXX */
1182                         break;
1183                 }
1184
1185                 acl_get_permset(acl_entry, &acl_permset);
1186                 acl_clear_perms(acl_permset);
1187                 if (ae_permset & ARCHIVE_ENTRY_ACL_EXECUTE)
1188                         acl_add_perm(acl_permset, ACL_EXECUTE);
1189                 if (ae_permset & ARCHIVE_ENTRY_ACL_WRITE)
1190                         acl_add_perm(acl_permset, ACL_WRITE);
1191                 if (ae_permset & ARCHIVE_ENTRY_ACL_READ)
1192                         acl_add_perm(acl_permset, ACL_READ);
1193         }
1194
1195         name = archive_entry_pathname(entry);
1196
1197         if (acl_set_file(name, acl_type, acl) != 0) {
1198                 archive_set_error(a, errno, "Failed to set %s acl", typename);
1199                 ret = ARCHIVE_WARN;
1200         }
1201         acl_free(acl);
1202         return (ret);
1203 }
1204 #endif
1205
1206 /*
1207  * The following routines do some basic caching of uname/gname lookups.
1208  * All such lookups go through these routines, including ACL conversions.
1209  *
1210  * TODO: Provide an API for clients to override these routines.
1211  */
1212 static gid_t
1213 lookup_gid(struct archive *a, const char *gname, gid_t gid)
1214 {
1215         struct group    *grent;
1216         struct extract *extract;
1217         int h;
1218         struct bucket *b;
1219         int cache_size;
1220
1221         extract = a->extract;
1222         cache_size = sizeof(extract->gcache) / sizeof(extract->gcache[0]);
1223
1224         /* If no gname, just use the gid provided. */
1225         if (gname == NULL || *gname == '\0')
1226                 return (gid);
1227
1228         /* Try to find gname in the cache. */
1229         h = hash(gname);
1230         b = &extract->gcache[h % cache_size ];
1231         if (b->name != NULL && b->hash == h && strcmp(gname, b->name) == 0)
1232                 return ((gid_t)b->id);
1233
1234         /* Free the cache slot for a new entry. */
1235         if (b->name != NULL)
1236                 free(b->name);
1237         b->name = strdup(gname);
1238         /* Note: If strdup fails, that's okay; we just won't cache. */
1239         b->hash = h;
1240         grent = getgrnam(gname);
1241         if (grent != NULL)
1242                 gid = grent->gr_gid;
1243         b->id = gid;
1244
1245         return (gid);
1246 }
1247
1248 static uid_t
1249 lookup_uid(struct archive *a, const char *uname, uid_t uid)
1250 {
1251         struct passwd   *pwent;
1252         struct extract *extract;
1253         int h;
1254         struct bucket *b;
1255         int cache_size;
1256
1257         extract = a->extract;
1258         cache_size = sizeof(extract->ucache) / sizeof(extract->ucache[0]);
1259
1260         /* If no uname, just use the uid provided. */
1261         if (uname == NULL || *uname == '\0')
1262                 return (uid);
1263
1264         /* Try to find uname in the cache. */
1265         h = hash(uname);
1266         b = &extract->ucache[h % cache_size ];
1267         if (b->name != NULL && b->hash == h && strcmp(uname, b->name) == 0)
1268                 return ((uid_t)b->id);
1269
1270         /* Free the cache slot for a new entry. */
1271         if (b->name != NULL)
1272                 free(b->name);
1273         b->name = strdup(uname);
1274         /* Note: If strdup fails, that's okay; we just won't cache. */
1275         b->hash = h;
1276         pwent = getpwnam(uname);
1277         if (pwent != NULL)
1278                 uid = pwent->pw_uid;
1279         b->id = uid;
1280
1281         return (uid);
1282 }
1283
1284 static unsigned int
1285 hash(const char *p)
1286 {
1287   /* A 32-bit version of Peter Weinberger's (PJW) hash algorithm,
1288      as used by ELF for hashing function names. */
1289   unsigned g,h = 0;
1290   while(*p != '\0') {
1291     h = ( h << 4 ) + *p++;
1292     if (( g = h & 0xF0000000 )) {
1293       h ^= g >> 24;
1294       h &= 0x0FFFFFFF;
1295     }
1296   }
1297   return h;
1298 }
1299
1300 void
1301 archive_read_extract_set_progress_callback(struct archive *a,
1302     void (*progress_func)(void *), void *user_data)
1303 {
1304         a->extract_progress = progress_func;
1305         a->extract_progress_user_data = user_data;
1306 }