Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 2 | /* |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 3 | * Mini tar implementation for busybox |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 4 | * |
Eric Andersen | aff114c | 2004-04-14 17:51:38 +0000 | [diff] [blame] | 5 | * Modified to use common extraction code used by ar, cpio, dpkg-deb, dpkg |
Denis Vlasenko | 0beaff8 | 2007-09-21 13:16:32 +0000 | [diff] [blame] | 6 | * by Glenn McGrath |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 7 | * |
Erik Andersen | 61677fe | 2000-04-13 01:18:56 +0000 | [diff] [blame] | 8 | * Note, that as of BusyBox-0.43, tar has been completely rewritten from the |
Eric Andersen | aff114c | 2004-04-14 17:51:38 +0000 | [diff] [blame] | 9 | * ground up. It still has remnants of the old code lying about, but it is |
Eric Andersen | 77d9268 | 2001-05-23 20:32:09 +0000 | [diff] [blame] | 10 | * very different now (i.e., cleaner, less global variables, etc.) |
Eric Andersen | c499601 | 1999-10-20 22:08:37 +0000 | [diff] [blame] | 11 | * |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 12 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
Eric Andersen | 96bcfd3 | 1999-11-12 01:30:18 +0000 | [diff] [blame] | 13 | * |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 14 | * Based in part in the tar implementation in sash |
| 15 | * Copyright (c) 1999 by David I. Bell |
| 16 | * Permission is granted to use, distribute, or modify this source, |
| 17 | * provided that this copyright notice remains intact. |
Denys Vlasenko | 0ef64bd | 2010-08-16 20:14:46 +0200 | [diff] [blame] | 18 | * Permission to distribute sash derived code under GPL has been granted. |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 19 | * |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 20 | * Based in part on the tar implementation from busybox-0.28 |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 21 | * Copyright (C) 1995 Bruce Perens |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 22 | * |
Denys Vlasenko | 0ef64bd | 2010-08-16 20:14:46 +0200 | [diff] [blame] | 23 | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 24 | */ |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 25 | //config:config TAR |
Denys Vlasenko | 4eed2c6 | 2017-07-18 22:01:24 +0200 | [diff] [blame] | 26 | //config: bool "tar (40 kb)" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 27 | //config: default y |
| 28 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 29 | //config: tar is an archiving program. It's commonly used with gzip to |
| 30 | //config: create compressed archives. It's probably the most widely used |
| 31 | //config: UNIX archive program. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 32 | //config: |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 33 | //config:config FEATURE_TAR_LONG_OPTIONS |
| 34 | //config: bool "Enable long options" |
| 35 | //config: default y |
| 36 | //config: depends on TAR && LONG_OPTS |
| 37 | //config: |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 38 | //config:config FEATURE_TAR_CREATE |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 39 | //config: bool "Enable -c (archive creation)" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 40 | //config: default y |
| 41 | //config: depends on TAR |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 42 | //config: |
| 43 | //config:config FEATURE_TAR_AUTODETECT |
| 44 | //config: bool "Autodetect compressed tarballs" |
| 45 | //config: default y |
| 46 | //config: depends on TAR && (FEATURE_SEAMLESS_Z || FEATURE_SEAMLESS_GZ || FEATURE_SEAMLESS_BZ2 || FEATURE_SEAMLESS_LZMA || FEATURE_SEAMLESS_XZ) |
| 47 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 48 | //config: With this option tar can automatically detect compressed |
| 49 | //config: tarballs. Currently it works only on files (not pipes etc). |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 50 | //config: |
| 51 | //config:config FEATURE_TAR_FROM |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 52 | //config: bool "Enable -X (exclude from) and -T (include from) options" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 53 | //config: default y |
| 54 | //config: depends on TAR |
| 55 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 56 | //config: If you enable this option you'll be able to specify |
| 57 | //config: a list of files to include or exclude from an archive. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 58 | //config: |
| 59 | //config:config FEATURE_TAR_OLDGNU_COMPATIBILITY |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 60 | //config: bool "Support old tar header format" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 61 | //config: default y |
| 62 | //config: depends on TAR || DPKG |
| 63 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 64 | //config: This option is required to unpack archives created in |
| 65 | //config: the old GNU format; help to kill this old format by |
| 66 | //config: repacking your ancient archives with the new format. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 67 | //config: |
| 68 | //config:config FEATURE_TAR_OLDSUN_COMPATIBILITY |
| 69 | //config: bool "Enable untarring of tarballs with checksums produced by buggy Sun tar" |
| 70 | //config: default y |
| 71 | //config: depends on TAR || DPKG |
| 72 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 73 | //config: This option is required to unpack archives created by some old |
| 74 | //config: version of Sun's tar (it was calculating checksum using signed |
| 75 | //config: arithmetic). It is said to be fixed in newer Sun tar, but "old" |
| 76 | //config: tarballs still exist. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 77 | //config: |
| 78 | //config:config FEATURE_TAR_GNU_EXTENSIONS |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 79 | //config: bool "Support GNU tar extensions (long filenames)" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 80 | //config: default y |
| 81 | //config: depends on TAR || DPKG |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 82 | //config: |
| 83 | //config:config FEATURE_TAR_TO_COMMAND |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 84 | //config: bool "Support writing to an external program (--to-command)" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 85 | //config: default y |
| 86 | //config: depends on TAR && FEATURE_TAR_LONG_OPTIONS |
| 87 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 88 | //config: If you enable this option you'll be able to instruct tar to send |
| 89 | //config: the contents of each extracted file to the standard input of an |
| 90 | //config: external program. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 91 | //config: |
| 92 | //config:config FEATURE_TAR_UNAME_GNAME |
| 93 | //config: bool "Enable use of user and group names" |
| 94 | //config: default y |
| 95 | //config: depends on TAR |
| 96 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 97 | //config: Enable use of user and group names in tar. This affects contents |
| 98 | //config: listings (-t) and preserving permissions when unpacking (-p). |
| 99 | //config: +200 bytes. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 100 | //config: |
| 101 | //config:config FEATURE_TAR_NOPRESERVE_TIME |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 102 | //config: bool "Enable -m (do not preserve time) GNU option" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 103 | //config: default y |
| 104 | //config: depends on TAR |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 105 | //config: |
| 106 | //config:config FEATURE_TAR_SELINUX |
Denys Vlasenko | f560422 | 2017-01-10 14:58:54 +0100 | [diff] [blame] | 107 | //config: bool "Support extracting SELinux labels" |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 108 | //config: default n |
| 109 | //config: depends on TAR && SELINUX |
| 110 | //config: help |
Denys Vlasenko | 72089cf | 2017-07-21 09:50:55 +0200 | [diff] [blame] | 111 | //config: With this option busybox supports restoring SELinux labels |
| 112 | //config: when extracting files from tar archives. |
Denys Vlasenko | f6beef6 | 2013-11-14 11:39:00 +0100 | [diff] [blame] | 113 | |
Denys Vlasenko | 36184a4 | 2013-11-14 09:54:24 +0100 | [diff] [blame] | 114 | //applet:IF_TAR(APPLET(tar, BB_DIR_BIN, BB_SUID_DROP)) |
Denys Vlasenko | 0c4dbd4 | 2017-09-18 16:28:43 +0200 | [diff] [blame] | 115 | |
Denys Vlasenko | 66620fa | 2013-11-14 09:53:52 +0100 | [diff] [blame] | 116 | //kbuild:lib-$(CONFIG_TAR) += tar.o |
| 117 | |
Rob Landley | 1bfca7b | 2006-09-10 03:20:37 +0000 | [diff] [blame] | 118 | #include <fnmatch.h> |
Denis Vlasenko | b6adbf1 | 2007-05-26 19:00:18 +0000 | [diff] [blame] | 119 | #include "libbb.h" |
Denys Vlasenko | e6a2f4c | 2016-04-21 16:26:30 +0200 | [diff] [blame] | 120 | #include "common_bufsiz.h" |
Denys Vlasenko | d184a72 | 2011-09-22 12:45:14 +0200 | [diff] [blame] | 121 | #include "bb_archive.h" |
Denis Vlasenko | 87cf2ee | 2008-02-13 17:06:53 +0000 | [diff] [blame] | 122 | /* FIXME: Stop using this non-standard feature */ |
| 123 | #ifndef FNM_LEADING_DIR |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 124 | # define FNM_LEADING_DIR 0 |
Denis Vlasenko | 87cf2ee | 2008-02-13 17:06:53 +0000 | [diff] [blame] | 125 | #endif |
| 126 | |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 127 | #if 0 |
| 128 | # define DBG(fmt, ...) bb_error_msg("%s: " fmt, __func__, ## __VA_ARGS__) |
| 129 | #else |
| 130 | # define DBG(...) ((void)0) |
| 131 | #endif |
| 132 | #define DBG_OPTION_PARSING 0 |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 133 | |
| 134 | |
Denis Vlasenko | 74324c8 | 2007-06-04 10:16:52 +0000 | [diff] [blame] | 135 | #define block_buf bb_common_bufsiz1 |
Denys Vlasenko | 9de2e5a | 2016-04-21 18:38:51 +0200 | [diff] [blame] | 136 | #define INIT_G() do { setup_common_bufsiz(); } while (0) |
Denis Vlasenko | 74324c8 | 2007-06-04 10:16:52 +0000 | [diff] [blame] | 137 | |
Denis Vlasenko | 431a7c9 | 2008-02-19 11:26:28 +0000 | [diff] [blame] | 138 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 139 | #if ENABLE_FEATURE_TAR_CREATE |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 140 | |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 141 | /* |
Denis Vlasenko | 4fbb584 | 2006-11-24 14:55:23 +0000 | [diff] [blame] | 142 | ** writeTarFile(), writeFileToTarball(), and writeTarHeader() are |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 143 | ** the only functions that deal with the HardLinkInfo structure. |
| 144 | ** Even these functions use the xxxHardLinkInfo() functions. |
| 145 | */ |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 146 | typedef struct HardLinkInfo { |
| 147 | struct HardLinkInfo *next; /* Next entry in list */ |
| 148 | dev_t dev; /* Device number */ |
| 149 | ino_t ino; /* Inode number */ |
| 150 | // short linkCount; /* (Hard) Link Count */ |
| 151 | char name[1]; /* Start of filename (must be last) */ |
| 152 | } HardLinkInfo; |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 153 | |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 154 | /* Some info to be carried along when creating a new tarball */ |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 155 | typedef struct TarBallInfo { |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 156 | int tarFd; /* Open-for-write file descriptor |
| 157 | * for the tarball */ |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 158 | int verboseFlag; /* Whether to print extra stuff or not */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 159 | # if ENABLE_FEATURE_TAR_FROM |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 160 | const llist_t *excludeList; /* List of files to not include */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 161 | # endif |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 162 | HardLinkInfo *hlInfoHead; /* Hard Link Tracking Information */ |
| 163 | HardLinkInfo *hlInfo; /* Hard Link Info for the current file */ |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 164 | //TODO: save only st_dev + st_ino |
| 165 | struct stat tarFileStatBuf; /* Stat info for the tarball, letting |
| 166 | * us know the inode and device that the |
| 167 | * tarball lives, so we can avoid trying |
| 168 | * to include the tarball into itself */ |
| 169 | } TarBallInfo; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 170 | |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 171 | /* A nice enum with all the possible tar file content types */ |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 172 | enum { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 173 | REGTYPE = '0', /* regular file */ |
| 174 | REGTYPE0 = '\0', /* regular file (ancient bug compat) */ |
| 175 | LNKTYPE = '1', /* hard link */ |
| 176 | SYMTYPE = '2', /* symbolic link */ |
| 177 | CHRTYPE = '3', /* character special */ |
| 178 | BLKTYPE = '4', /* block special */ |
| 179 | DIRTYPE = '5', /* directory */ |
| 180 | FIFOTYPE = '6', /* FIFO special */ |
| 181 | CONTTYPE = '7', /* reserved */ |
| 182 | GNULONGLINK = 'K', /* GNU long (>100 chars) link name */ |
| 183 | GNULONGNAME = 'L', /* GNU long (>100 chars) file name */ |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 184 | }; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 185 | |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 186 | /* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */ |
Denis Vlasenko | 7e0fbf9 | 2007-09-04 19:33:22 +0000 | [diff] [blame] | 187 | static void addHardLinkInfo(HardLinkInfo **hlInfoHeadPtr, |
Glenn L McGrath | f66de64 | 2002-11-25 23:57:27 +0000 | [diff] [blame] | 188 | struct stat *statbuf, |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 189 | const char *fileName) |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 190 | { |
| 191 | /* Note: hlInfoHeadPtr can never be NULL! */ |
| 192 | HardLinkInfo *hlInfo; |
| 193 | |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 194 | hlInfo = xmalloc(sizeof(HardLinkInfo) + strlen(fileName)); |
Glenn L McGrath | f66de64 | 2002-11-25 23:57:27 +0000 | [diff] [blame] | 195 | hlInfo->next = *hlInfoHeadPtr; |
| 196 | *hlInfoHeadPtr = hlInfo; |
| 197 | hlInfo->dev = statbuf->st_dev; |
| 198 | hlInfo->ino = statbuf->st_ino; |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 199 | // hlInfo->linkCount = statbuf->st_nlink; |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 200 | strcpy(hlInfo->name, fileName); |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 201 | } |
| 202 | |
Denis Vlasenko | 7e0fbf9 | 2007-09-04 19:33:22 +0000 | [diff] [blame] | 203 | static void freeHardLinkInfo(HardLinkInfo **hlInfoHeadPtr) |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 204 | { |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 205 | HardLinkInfo *hlInfo; |
| 206 | HardLinkInfo *hlInfoNext; |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 207 | |
| 208 | if (hlInfoHeadPtr) { |
| 209 | hlInfo = *hlInfoHeadPtr; |
| 210 | while (hlInfo) { |
| 211 | hlInfoNext = hlInfo->next; |
| 212 | free(hlInfo); |
| 213 | hlInfo = hlInfoNext; |
| 214 | } |
| 215 | *hlInfoHeadPtr = NULL; |
| 216 | } |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 217 | } |
| 218 | |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 219 | /* Might be faster (and bigger) if the dev/ino were stored in numeric order ;) */ |
| 220 | static HardLinkInfo *findHardLinkInfo(HardLinkInfo *hlInfo, struct stat *statbuf) |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 221 | { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 222 | while (hlInfo) { |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 223 | if (statbuf->st_ino == hlInfo->ino |
| 224 | && statbuf->st_dev == hlInfo->dev |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 225 | ) { |
| 226 | DBG("found hardlink:'%s'", hlInfo->name); |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 227 | break; |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 228 | } |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 229 | hlInfo = hlInfo->next; |
| 230 | } |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 231 | return hlInfo; |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 234 | /* Put an octal string into the specified buffer. |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 235 | * The number is zero padded and possibly null terminated. |
Denis Vlasenko | 87cd4a8 | 2006-11-25 23:47:32 +0000 | [diff] [blame] | 236 | * Stores low-order bits only if whole value does not fit. */ |
| 237 | static void putOctal(char *cp, int len, off_t value) |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 238 | { |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 239 | char tempBuffer[sizeof(off_t)*3 + 1]; |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 240 | char *tempString = tempBuffer; |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 241 | int width; |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 242 | |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 243 | width = sprintf(tempBuffer, "%0*"OFF_FMT"o", len, value); |
| 244 | tempString += (width - len); |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 245 | |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 246 | /* If string has leading zeroes, we can drop one */ |
| 247 | /* and field will have trailing '\0' */ |
| 248 | /* (increases chances of compat with other tars) */ |
| 249 | if (tempString[0] == '0') |
| 250 | tempString++; |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 251 | |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 252 | /* Copy the string to the field */ |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 253 | memcpy(cp, tempString, len); |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 254 | } |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 255 | #define PUT_OCTAL(a, b) putOctal((a), sizeof(a), (b)) |
| 256 | |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 257 | static void chksum_and_xwrite(int fd, struct tar_header_t* hp) |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 258 | { |
Denis Vlasenko | dcbd51d | 2007-03-03 20:06:59 +0000 | [diff] [blame] | 259 | /* POSIX says that checksum is done on unsigned bytes |
Denis Vlasenko | 940494f | 2007-03-04 18:09:50 +0000 | [diff] [blame] | 260 | * (Sun and HP-UX gets it wrong... more details in |
Denis Vlasenko | dcbd51d | 2007-03-03 20:06:59 +0000 | [diff] [blame] | 261 | * GNU tar source) */ |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 262 | const unsigned char *cp; |
| 263 | int chksum, size; |
| 264 | |
| 265 | strcpy(hp->magic, "ustar "); |
| 266 | |
| 267 | /* Calculate and store the checksum (i.e., the sum of all of the bytes of |
| 268 | * the header). The checksum field must be filled with blanks for the |
| 269 | * calculation. The checksum field is formatted differently from the |
| 270 | * other fields: it has 6 digits, a null, then a space -- rather than |
| 271 | * digits, followed by a null like the other fields... */ |
| 272 | memset(hp->chksum, ' ', sizeof(hp->chksum)); |
| 273 | cp = (const unsigned char *) hp; |
| 274 | chksum = 0; |
| 275 | size = sizeof(*hp); |
| 276 | do { chksum += *cp++; } while (--size); |
| 277 | putOctal(hp->chksum, sizeof(hp->chksum)-1, chksum); |
| 278 | |
| 279 | /* Now write the header out to disk */ |
| 280 | xwrite(fd, hp, sizeof(*hp)); |
| 281 | } |
| 282 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 283 | # if ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 284 | static void writeLongname(int fd, int type, const char *name, int dir) |
| 285 | { |
| 286 | static const struct { |
| 287 | char mode[8]; /* 100-107 */ |
| 288 | char uid[8]; /* 108-115 */ |
| 289 | char gid[8]; /* 116-123 */ |
| 290 | char size[12]; /* 124-135 */ |
| 291 | char mtime[12]; /* 136-147 */ |
| 292 | } prefilled = { |
| 293 | "0000000", |
| 294 | "0000000", |
| 295 | "0000000", |
| 296 | "00000000000", |
| 297 | "00000000000", |
| 298 | }; |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 299 | struct tar_header_t header; |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 300 | int size; |
| 301 | |
| 302 | dir = !!dir; /* normalize: 0/1 */ |
| 303 | size = strlen(name) + 1 + dir; /* GNU tar uses strlen+1 */ |
| 304 | /* + dir: account for possible '/' */ |
| 305 | |
Bernhard Reutner-Fischer | 6f0540e | 2006-12-12 11:50:44 +0000 | [diff] [blame] | 306 | memset(&header, 0, sizeof(header)); |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 307 | strcpy(header.name, "././@LongLink"); |
| 308 | memcpy(header.mode, prefilled.mode, sizeof(prefilled)); |
| 309 | PUT_OCTAL(header.size, size); |
| 310 | header.typeflag = type; |
| 311 | chksum_and_xwrite(fd, &header); |
| 312 | |
| 313 | /* Write filename[/] and pad the block. */ |
| 314 | /* dir=0: writes 'name<NUL>', pads */ |
| 315 | /* dir=1: writes 'name', writes '/<NUL>', pads */ |
| 316 | dir *= 2; |
| 317 | xwrite(fd, name, size - dir); |
| 318 | xwrite(fd, "/", dir); |
| 319 | size = (-size) & (TAR_BLOCK_SIZE-1); |
Bernhard Reutner-Fischer | 6f0540e | 2006-12-12 11:50:44 +0000 | [diff] [blame] | 320 | memset(&header, 0, size); |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 321 | xwrite(fd, &header, size); |
| 322 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 323 | # endif |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 324 | |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 325 | /* Write out a tar header for the specified file/directory/whatever */ |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 326 | static int writeTarHeader(struct TarBallInfo *tbInfo, |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 327 | const char *header_name, const char *fileName, struct stat *statbuf) |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 328 | { |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 329 | struct tar_header_t header; |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 330 | |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 331 | memset(&header, 0, sizeof(header)); |
Denys Vlasenko | 8f65b0c | 2010-07-06 18:46:02 +0200 | [diff] [blame] | 332 | |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 333 | strncpy(header.name, header_name, sizeof(header.name)); |
Erik Andersen | ecd5124 | 2000-04-08 03:08:21 +0000 | [diff] [blame] | 334 | |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 335 | /* POSIX says to mask mode with 07777. */ |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 336 | PUT_OCTAL(header.mode, statbuf->st_mode & 07777); |
| 337 | PUT_OCTAL(header.uid, statbuf->st_uid); |
| 338 | PUT_OCTAL(header.gid, statbuf->st_gid); |
Denis Vlasenko | b8a8e60 | 2006-11-24 14:59:45 +0000 | [diff] [blame] | 339 | memset(header.size, '0', sizeof(header.size)-1); /* Regular file size is handled later */ |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 340 | /* users report that files with negative st_mtime cause trouble, so: */ |
| 341 | PUT_OCTAL(header.mtime, statbuf->st_mtime >= 0 ? statbuf->st_mtime : 0); |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 342 | |
Denis Vlasenko | c50f370 | 2006-11-24 14:57:31 +0000 | [diff] [blame] | 343 | /* Enter the user and group names */ |
| 344 | safe_strncpy(header.uname, get_cached_username(statbuf->st_uid), sizeof(header.uname)); |
| 345 | safe_strncpy(header.gname, get_cached_groupname(statbuf->st_gid), sizeof(header.gname)); |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 346 | |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 347 | if (tbInfo->hlInfo) { |
| 348 | /* This is a hard link */ |
| 349 | header.typeflag = LNKTYPE; |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 350 | strncpy(header.linkname, tbInfo->hlInfo->name, |
| 351 | sizeof(header.linkname)); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 352 | # if ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 353 | /* Write out long linkname if needed */ |
| 354 | if (header.linkname[sizeof(header.linkname)-1]) |
| 355 | writeLongname(tbInfo->tarFd, GNULONGLINK, |
| 356 | tbInfo->hlInfo->name, 0); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 357 | # endif |
Eric Andersen | 3d957c8 | 2000-12-07 00:34:58 +0000 | [diff] [blame] | 358 | } else if (S_ISLNK(statbuf->st_mode)) { |
Denis Vlasenko | 6ca0444 | 2007-02-11 16:19:28 +0000 | [diff] [blame] | 359 | char *lpath = xmalloc_readlink_or_warn(fileName); |
| 360 | if (!lpath) |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 361 | return FALSE; |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 362 | header.typeflag = SYMTYPE; |
| 363 | strncpy(header.linkname, lpath, sizeof(header.linkname)); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 364 | # if ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 365 | /* Write out long linkname if needed */ |
| 366 | if (header.linkname[sizeof(header.linkname)-1]) |
| 367 | writeLongname(tbInfo->tarFd, GNULONGLINK, lpath, 0); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 368 | # else |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 369 | /* If it is larger than 100 bytes, bail out */ |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 370 | if (header.linkname[sizeof(header.linkname)-1]) { |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 371 | free(lpath); |
| 372 | bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported"); |
| 373 | return FALSE; |
| 374 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 375 | # endif |
Mark Whitley | 8a63326 | 2001-04-30 18:17:00 +0000 | [diff] [blame] | 376 | free(lpath); |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 377 | } else if (S_ISDIR(statbuf->st_mode)) { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 378 | header.typeflag = DIRTYPE; |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 379 | /* Append '/' only if there is a space for it */ |
| 380 | if (!header.name[sizeof(header.name)-1]) |
| 381 | header.name[strlen(header.name)] = '/'; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 382 | } else if (S_ISCHR(statbuf->st_mode)) { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 383 | header.typeflag = CHRTYPE; |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 384 | PUT_OCTAL(header.devmajor, major(statbuf->st_rdev)); |
| 385 | PUT_OCTAL(header.devminor, minor(statbuf->st_rdev)); |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 386 | } else if (S_ISBLK(statbuf->st_mode)) { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 387 | header.typeflag = BLKTYPE; |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 388 | PUT_OCTAL(header.devmajor, major(statbuf->st_rdev)); |
| 389 | PUT_OCTAL(header.devminor, minor(statbuf->st_rdev)); |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 390 | } else if (S_ISFIFO(statbuf->st_mode)) { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 391 | header.typeflag = FIFOTYPE; |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 392 | } else if (S_ISREG(statbuf->st_mode)) { |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 393 | /* header.size field is 12 bytes long */ |
| 394 | /* Does octal-encoded size fit? */ |
| 395 | uoff_t filesize = statbuf->st_size; |
| 396 | if (sizeof(filesize) <= 4 |
| 397 | || filesize <= (uoff_t)0777777777777LL |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 398 | ) { |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 399 | PUT_OCTAL(header.size, filesize); |
| 400 | } |
| 401 | /* Does base256-encoded size fit? |
| 402 | * It always does unless off_t is wider than 64 bits. |
| 403 | */ |
| 404 | else if (ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 405 | # if ULLONG_MAX > 0xffffffffffffffffLL /* 2^64-1 */ |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 406 | && (filesize <= 0x3fffffffffffffffffffffffLL) |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 407 | # endif |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 408 | ) { |
Denys Vlasenko | 6967578 | 2013-01-14 01:34:48 +0100 | [diff] [blame] | 409 | /* GNU tar uses "base-256 encoding" for very large numbers. |
| 410 | * Encoding is binary, with highest bit always set as a marker |
| 411 | * and sign in next-highest bit: |
| 412 | * 80 00 .. 00 - zero |
| 413 | * bf ff .. ff - largest positive number |
| 414 | * ff ff .. ff - minus 1 |
| 415 | * c0 00 .. 00 - smallest negative number |
Denys Vlasenko | 9180c60 | 2011-05-04 21:14:12 +0200 | [diff] [blame] | 416 | */ |
| 417 | char *p8 = header.size + sizeof(header.size); |
| 418 | do { |
| 419 | *--p8 = (uint8_t)filesize; |
| 420 | filesize >>= 8; |
| 421 | } while (p8 != header.size); |
| 422 | *p8 |= 0x80; |
| 423 | } else { |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 424 | bb_error_msg_and_die("can't store file '%s' " |
Denys Vlasenko | a3aa3e3 | 2009-12-11 12:36:10 +0100 | [diff] [blame] | 425 | "of size %"OFF_FMT"u, aborting", |
Denis Vlasenko | f2408e6 | 2006-11-25 14:48:09 +0000 | [diff] [blame] | 426 | fileName, statbuf->st_size); |
| 427 | } |
Denis Vlasenko | 87cd4a8 | 2006-11-25 23:47:32 +0000 | [diff] [blame] | 428 | header.typeflag = REGTYPE; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 429 | } else { |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 430 | bb_error_msg("%s: unknown file type", fileName); |
| 431 | return FALSE; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 432 | } |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 433 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 434 | # if ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 435 | /* Write out long name if needed */ |
| 436 | /* (we, like GNU tar, output long linkname *before* long name) */ |
| 437 | if (header.name[sizeof(header.name)-1]) |
| 438 | writeLongname(tbInfo->tarFd, GNULONGNAME, |
| 439 | header_name, S_ISDIR(statbuf->st_mode)); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 440 | # endif |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 441 | |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 442 | /* Now write the header out to disk */ |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 443 | chksum_and_xwrite(tbInfo->tarFd, &header); |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 444 | |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 445 | /* Now do the verbose thing (or not) */ |
Robert Griebl | f2f26e7 | 2002-07-23 22:05:47 +0000 | [diff] [blame] | 446 | if (tbInfo->verboseFlag) { |
Eric Andersen | fdd5103 | 2000-08-02 18:48:26 +0000 | [diff] [blame] | 447 | FILE *vbFd = stdout; |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 448 | |
Denis Vlasenko | ab6b446 | 2008-12-12 02:14:35 +0000 | [diff] [blame] | 449 | /* If archive goes to stdout, verbose goes to stderr */ |
| 450 | if (tbInfo->tarFd == STDOUT_FILENO) |
Eric Andersen | fdd5103 | 2000-08-02 18:48:26 +0000 | [diff] [blame] | 451 | vbFd = stderr; |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 452 | /* GNU "tar cvvf" prints "extended" listing a-la "ls -l" */ |
| 453 | /* We don't have such excesses here: for us "v" == "vv" */ |
Denis Vlasenko | 7725d0f | 2006-11-25 23:56:50 +0000 | [diff] [blame] | 454 | /* '/' is probably a GNUism */ |
| 455 | fprintf(vbFd, "%s%s\n", header_name, |
| 456 | S_ISDIR(statbuf->st_mode) ? "/" : ""); |
Eric Andersen | fdd5103 | 2000-08-02 18:48:26 +0000 | [diff] [blame] | 457 | } |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 458 | |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 459 | return TRUE; |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 460 | } |
| 461 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 462 | # if ENABLE_FEATURE_TAR_FROM |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 463 | static int exclude_file(const llist_t *excluded_files, const char *file) |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 464 | { |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 465 | while (excluded_files) { |
| 466 | if (excluded_files->data[0] == '/') { |
| 467 | if (fnmatch(excluded_files->data, file, |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 468 | FNM_PATHNAME | FNM_LEADING_DIR) == 0) |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 469 | return 1; |
| 470 | } else { |
| 471 | const char *p; |
| 472 | |
| 473 | for (p = file; p[0] != '\0'; p++) { |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 474 | if ((p == file || p[-1] == '/') |
| 475 | && p[0] != '/' |
| 476 | && fnmatch(excluded_files->data, p, |
| 477 | FNM_PATHNAME | FNM_LEADING_DIR) == 0 |
| 478 | ) { |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 479 | return 1; |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 480 | } |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 481 | } |
| 482 | } |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 483 | excluded_files = excluded_files->link; |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | return 0; |
| 487 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 488 | # else |
| 489 | # define exclude_file(excluded_files, file) 0 |
| 490 | # endif |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 491 | |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 492 | static int FAST_FUNC writeFileToTarball(const char *fileName, struct stat *statbuf, |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 493 | void *userData, int depth UNUSED_PARAM) |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 494 | { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 495 | struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData; |
Matt Kraai | e80a263 | 2000-12-19 20:45:49 +0000 | [diff] [blame] | 496 | const char *header_name; |
Rob Landley | e569553 | 2006-01-09 03:07:44 +0000 | [diff] [blame] | 497 | int inputFileFd = -1; |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 498 | |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 499 | DBG("writeFileToTarball('%s')", fileName); |
| 500 | |
Denys Vlasenko | b80acf5 | 2011-03-02 01:21:02 +0100 | [diff] [blame] | 501 | /* Strip leading '/' and such (must be before memorizing hardlink's name) */ |
| 502 | header_name = strip_unsafe_prefix(fileName); |
Matt Kraai | a1f9775 | 2000-12-19 06:24:08 +0000 | [diff] [blame] | 503 | |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 504 | if (header_name[0] == '\0') |
| 505 | return TRUE; |
| 506 | |
Denis Vlasenko | e9b3321 | 2007-09-24 19:32:53 +0000 | [diff] [blame] | 507 | /* It is against the rules to archive a socket */ |
| 508 | if (S_ISSOCK(statbuf->st_mode)) { |
| 509 | bb_error_msg("%s: socket ignored", fileName); |
| 510 | return TRUE; |
| 511 | } |
| 512 | |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 513 | /* |
| 514 | * Check to see if we are dealing with a hard link. |
| 515 | * If so - |
Denys Vlasenko | 10ad622 | 2017-04-17 16:13:32 +0200 | [diff] [blame] | 516 | * Treat the first occurrence of a given dev/inode as a file while |
| 517 | * treating any additional occurrences as hard links. This is done |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 518 | * by adding the file information to the HardLinkInfo linked list. |
| 519 | */ |
| 520 | tbInfo->hlInfo = NULL; |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 521 | if (!S_ISDIR(statbuf->st_mode) && statbuf->st_nlink > 1) { |
| 522 | DBG("'%s': st_nlink > 1", header_name); |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 523 | tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf); |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 524 | if (tbInfo->hlInfo == NULL) { |
| 525 | DBG("'%s': addHardLinkInfo", header_name); |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 526 | addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, header_name); |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 527 | } |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 528 | } |
| 529 | |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 530 | /* It is a bad idea to store the archive we are in the process of creating, |
| 531 | * so check the device and inode to be sure that this particular file isn't |
| 532 | * the new tarball */ |
Denys Vlasenko | f94c9bf | 2009-11-29 07:45:33 +0100 | [diff] [blame] | 533 | if (tbInfo->tarFileStatBuf.st_dev == statbuf->st_dev |
| 534 | && tbInfo->tarFileStatBuf.st_ino == statbuf->st_ino |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 535 | ) { |
| 536 | bb_error_msg("%s: file is the archive; skipping", fileName); |
| 537 | return TRUE; |
| 538 | } |
| 539 | |
| 540 | if (exclude_file(tbInfo->excludeList, header_name)) |
| 541 | return SKIP; |
| 542 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 543 | # if !ENABLE_FEATURE_TAR_GNU_EXTENSIONS |
Denis Vlasenko | 86e0a22 | 2007-09-24 19:07:57 +0000 | [diff] [blame] | 544 | if (strlen(header_name) >= NAME_SIZE) { |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 545 | bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported"); |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 546 | return TRUE; |
Eric Andersen | 1b1cfde | 2000-09-24 00:54:37 +0000 | [diff] [blame] | 547 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 548 | # endif |
Eric Andersen | 1b1cfde | 2000-09-24 00:54:37 +0000 | [diff] [blame] | 549 | |
Rob Landley | e569553 | 2006-01-09 03:07:44 +0000 | [diff] [blame] | 550 | /* Is this a regular file? */ |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 551 | if (tbInfo->hlInfo == NULL && S_ISREG(statbuf->st_mode)) { |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 552 | /* open the file we want to archive, and make sure all is well */ |
Denis Vlasenko | 50f7f44 | 2007-04-11 23:20:53 +0000 | [diff] [blame] | 553 | inputFileFd = open_or_warn(fileName, O_RDONLY); |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 554 | if (inputFileFd < 0) { |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 555 | return FALSE; |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 556 | } |
Rob Landley | e569553 | 2006-01-09 03:07:44 +0000 | [diff] [blame] | 557 | } |
| 558 | |
| 559 | /* Add an entry to the tarball */ |
| 560 | if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) { |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 561 | return FALSE; |
Rob Landley | e569553 | 2006-01-09 03:07:44 +0000 | [diff] [blame] | 562 | } |
| 563 | |
| 564 | /* If it was a regular file, write out the body */ |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 565 | if (inputFileFd >= 0) { |
Denis Vlasenko | 714701c | 2006-12-22 00:21:07 +0000 | [diff] [blame] | 566 | size_t readSize; |
Denis Vlasenko | 50f7f44 | 2007-04-11 23:20:53 +0000 | [diff] [blame] | 567 | /* Write the file to the archive. */ |
Denis Vlasenko | 714701c | 2006-12-22 00:21:07 +0000 | [diff] [blame] | 568 | /* We record size into header first, */ |
| 569 | /* and then write out file. If file shrinks in between, */ |
| 570 | /* tar will be corrupted. So we don't allow for that. */ |
| 571 | /* NB: GNU tar 1.16 warns and pads with zeroes */ |
| 572 | /* or even seeks back and updates header */ |
| 573 | bb_copyfd_exact_size(inputFileFd, tbInfo->tarFd, statbuf->st_size); |
| 574 | ////off_t readSize; |
| 575 | ////readSize = bb_copyfd_size(inputFileFd, tbInfo->tarFd, statbuf->st_size); |
| 576 | ////if (readSize != statbuf->st_size && readSize >= 0) { |
| 577 | //// bb_error_msg_and_die("short read from %s, aborting", fileName); |
| 578 | ////} |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 579 | |
Denis Vlasenko | 4fbb584 | 2006-11-24 14:55:23 +0000 | [diff] [blame] | 580 | /* Check that file did not grow in between? */ |
Denis Vlasenko | 714701c | 2006-12-22 00:21:07 +0000 | [diff] [blame] | 581 | /* if (safe_read(inputFileFd, 1) == 1) warn but continue? */ |
| 582 | |
Rob Landley | e569553 | 2006-01-09 03:07:44 +0000 | [diff] [blame] | 583 | close(inputFileFd); |
Glenn L McGrath | 7ffe133 | 2003-11-21 22:24:57 +0000 | [diff] [blame] | 584 | |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 585 | /* Pad the file up to the tar block size */ |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 586 | /* (a few tricks here in the name of code size) */ |
Denis Vlasenko | 714701c | 2006-12-22 00:21:07 +0000 | [diff] [blame] | 587 | readSize = (-(int)statbuf->st_size) & (TAR_BLOCK_SIZE-1); |
Denis Vlasenko | 74324c8 | 2007-06-04 10:16:52 +0000 | [diff] [blame] | 588 | memset(block_buf, 0, readSize); |
| 589 | xwrite(tbInfo->tarFd, block_buf, readSize); |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 590 | } |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 591 | |
Denis Vlasenko | 0c45bb23 | 2006-09-09 12:49:03 +0000 | [diff] [blame] | 592 | return TRUE; |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 593 | } |
| 594 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 595 | # if SEAMLESS_COMPRESSION |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 596 | /* Don't inline: vfork scares gcc and pessimizes code */ |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 597 | static void NOINLINE vfork_compressor(int tar_fd, const char *gzip) |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 598 | { |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 599 | pid_t gzipPid; |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 600 | |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 601 | // On Linux, vfork never unpauses parent early, although standard |
| 602 | // allows for that. Do we want to waste bytes checking for it? |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 603 | # define WAIT_FOR_CHILD 0 |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 604 | volatile int vfork_exec_errno = 0; |
| 605 | struct fd_pair gzipDataPipe; |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 606 | # if WAIT_FOR_CHILD |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 607 | struct fd_pair gzipStatusPipe; |
| 608 | xpiped_pair(gzipStatusPipe); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 609 | # endif |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 610 | xpiped_pair(gzipDataPipe); |
| 611 | |
| 612 | signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */ |
| 613 | |
Pascal Bellard | 926031b | 2010-07-04 15:32:38 +0200 | [diff] [blame] | 614 | gzipPid = xvfork(); |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 615 | |
| 616 | if (gzipPid == 0) { |
| 617 | /* child */ |
| 618 | /* NB: close _first_, then move fds! */ |
| 619 | close(gzipDataPipe.wr); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 620 | # if WAIT_FOR_CHILD |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 621 | close(gzipStatusPipe.rd); |
| 622 | /* gzipStatusPipe.wr will close only on exec - |
| 623 | * parent waits for this close to happen */ |
| 624 | fcntl(gzipStatusPipe.wr, F_SETFD, FD_CLOEXEC); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 625 | # endif |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 626 | xmove_fd(gzipDataPipe.rd, 0); |
| 627 | xmove_fd(tar_fd, 1); |
| 628 | /* exec gzip/bzip2 program/applet */ |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 629 | BB_EXECLP(gzip, gzip, "-f", (char *)0); |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 630 | vfork_exec_errno = errno; |
Bernhard Reutner-Fischer | 636a1f8 | 2008-05-19 09:29:47 +0000 | [diff] [blame] | 631 | _exit(EXIT_FAILURE); |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | /* parent */ |
| 635 | xmove_fd(gzipDataPipe.wr, tar_fd); |
| 636 | close(gzipDataPipe.rd); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 637 | # if WAIT_FOR_CHILD |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 638 | close(gzipStatusPipe.wr); |
| 639 | while (1) { |
| 640 | char buf; |
| 641 | int n; |
| 642 | |
| 643 | /* Wait until child execs (or fails to) */ |
| 644 | n = full_read(gzipStatusPipe.rd, &buf, 1); |
| 645 | if (n < 0 /* && errno == EAGAIN */) |
| 646 | continue; /* try it again */ |
| 647 | } |
| 648 | close(gzipStatusPipe.rd); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 649 | # endif |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 650 | if (vfork_exec_errno) { |
| 651 | errno = vfork_exec_errno; |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 652 | bb_perror_msg_and_die("can't execute '%s'", gzip); |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 653 | } |
| 654 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 655 | # endif /* SEAMLESS_COMPRESSION */ |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 656 | |
| 657 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 658 | # if !SEAMLESS_COMPRESSION |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 659 | /* Do not pass gzip flag to writeTarFile() */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 660 | #define writeTarFile(tbInfo, recurseFlags, filelist, gzip) \ |
| 661 | writeTarFile(tbInfo, recurseFlags, filelist) |
| 662 | # endif |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 663 | /* gcc 4.2.1 inlines it, making code bigger */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 664 | static NOINLINE int writeTarFile( |
| 665 | struct TarBallInfo *tbInfo, |
| 666 | int recurseFlags, |
| 667 | const llist_t *filelist, |
| 668 | const char *gzip) |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 669 | { |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 670 | int errorFlag = FALSE; |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 671 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 672 | /*tbInfo->hlInfoHead = NULL; - already is */ |
Robert Griebl | f2f26e7 | 2002-07-23 22:05:47 +0000 | [diff] [blame] | 673 | |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 674 | /* Store the stat info for the tarball's file, so |
| 675 | * can avoid including the tarball into itself.... */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 676 | xfstat(tbInfo->tarFd, &tbInfo->tarFileStatBuf, "can't stat tar file"); |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 677 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 678 | # if SEAMLESS_COMPRESSION |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 679 | if (gzip) |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 680 | vfork_compressor(tbInfo->tarFd, gzip); |
| 681 | # endif |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 682 | |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 683 | /* Read the directory/files and iterate over them one at a time */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 684 | while (filelist) { |
| 685 | if (!recursive_action(filelist->data, recurseFlags, |
| 686 | writeFileToTarball, writeFileToTarball, tbInfo, 0) |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 687 | ) { |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 688 | errorFlag = TRUE; |
Erik Andersen | 3364d78 | 2000-03-28 00:58:14 +0000 | [diff] [blame] | 689 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 690 | filelist = filelist->link; |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 691 | } |
Erik Andersen | 5661fe0 | 2000-04-05 01:00:52 +0000 | [diff] [blame] | 692 | /* Write two empty blocks to the end of the archive */ |
Denis Vlasenko | 74324c8 | 2007-06-04 10:16:52 +0000 | [diff] [blame] | 693 | memset(block_buf, 0, 2*TAR_BLOCK_SIZE); |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 694 | xwrite(tbInfo->tarFd, block_buf, 2*TAR_BLOCK_SIZE); |
Erik Andersen | 0817d13 | 2000-04-09 15:17:40 +0000 | [diff] [blame] | 695 | |
| 696 | /* To be pedantically correct, we would check if the tarball |
Eric Andersen | 3c5ee9a | 2000-11-14 22:15:48 +0000 | [diff] [blame] | 697 | * is smaller than 20 tar blocks, and pad it if it was smaller, |
Erik Andersen | 0817d13 | 2000-04-09 15:17:40 +0000 | [diff] [blame] | 698 | * but that isn't necessary for GNU tar interoperability, and |
| 699 | * so is considered a waste of space */ |
| 700 | |
Rob Landley | 1a78103 | 2005-12-16 21:33:10 +0000 | [diff] [blame] | 701 | /* Close so the child process (if any) will exit */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 702 | close(tbInfo->tarFd); |
Rob Landley | 1a78103 | 2005-12-16 21:33:10 +0000 | [diff] [blame] | 703 | |
Erik Andersen | 68a9ea4 | 2000-04-04 18:39:50 +0000 | [diff] [blame] | 704 | /* Hang up the tools, close up shop, head home */ |
Rob Landley | 1a78103 | 2005-12-16 21:33:10 +0000 | [diff] [blame] | 705 | if (ENABLE_FEATURE_CLEAN_UP) |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 706 | freeHardLinkInfo(&tbInfo->hlInfoHead); |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 707 | |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 708 | if (errorFlag) |
Denis Vlasenko | e1a0d48 | 2006-10-20 13:28:22 +0000 | [diff] [blame] | 709 | bb_error_msg("error exit delayed from previous errors"); |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 710 | |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 711 | # if SEAMLESS_COMPRESSION |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 712 | if (gzip) { |
Denis Vlasenko | c888946 | 2006-12-17 19:08:20 +0000 | [diff] [blame] | 713 | int status; |
Denis Vlasenko | 5a07a1d | 2008-04-21 21:56:07 +0000 | [diff] [blame] | 714 | if (safe_waitpid(-1, &status, 0) == -1) |
Denis Vlasenko | c888946 | 2006-12-17 19:08:20 +0000 | [diff] [blame] | 715 | bb_perror_msg("waitpid"); |
| 716 | else if (!WIFEXITED(status) || WEXITSTATUS(status)) |
| 717 | /* gzip was killed or has exited with nonzero! */ |
| 718 | errorFlag = TRUE; |
| 719 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 720 | # endif |
Denis Vlasenko | c888946 | 2006-12-17 19:08:20 +0000 | [diff] [blame] | 721 | return errorFlag; |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 722 | } |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 723 | |
Denys Vlasenko | 11775ed | 2014-12-22 19:37:05 +0100 | [diff] [blame] | 724 | #else /* !FEATURE_TAR_CREATE */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 725 | |
Denys Vlasenko | 11775ed | 2014-12-22 19:37:05 +0100 | [diff] [blame] | 726 | # define writeTarFile(...) 0 |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 727 | |
Denys Vlasenko | 11775ed | 2014-12-22 19:37:05 +0100 | [diff] [blame] | 728 | #endif |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 729 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 730 | #if ENABLE_FEATURE_TAR_FROM |
Eric Andersen | 27cb684 | 2003-06-26 09:07:59 +0000 | [diff] [blame] | 731 | static llist_t *append_file_list_to_list(llist_t *list) |
Glenn L McGrath | d642a67 | 2001-10-13 06:54:45 +0000 | [diff] [blame] | 732 | { |
Eric Andersen | 27cb684 | 2003-06-26 09:07:59 +0000 | [diff] [blame] | 733 | llist_t *newlist = NULL; |
| 734 | |
Denis Vlasenko | d50dda8 | 2008-06-15 05:40:56 +0000 | [diff] [blame] | 735 | while (list) { |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 736 | FILE *src_stream; |
| 737 | char *line; |
| 738 | |
Denys Vlasenko | 3237f5c | 2011-02-03 04:00:23 +0100 | [diff] [blame] | 739 | src_stream = xfopen_stdin(llist_pop(&list)); |
Denis Vlasenko | 8ee649a | 2008-03-26 20:04:27 +0000 | [diff] [blame] | 740 | while ((line = xmalloc_fgetline(src_stream)) != NULL) { |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 741 | /* kill trailing '/' unless the string is just "/" */ |
| 742 | char *cp = last_char_is(line, '/'); |
| 743 | if (cp > line) |
| 744 | *cp = '\0'; |
SASAKI Suguru | 73fbe9d | 2013-08-15 12:19:29 +0200 | [diff] [blame] | 745 | llist_add_to_end(&newlist, line); |
Denis Vlasenko | 314908d | 2006-09-03 14:04:33 +0000 | [diff] [blame] | 746 | } |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 747 | fclose(src_stream); |
Eric Andersen | 27cb684 | 2003-06-26 09:07:59 +0000 | [diff] [blame] | 748 | } |
| 749 | return newlist; |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 750 | } |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 751 | #endif |
Erik Andersen | 6acaa40 | 2000-03-26 14:03:20 +0000 | [diff] [blame] | 752 | |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 753 | //usage:#define tar_trivial_usage |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 754 | //usage: IF_FEATURE_TAR_CREATE("c|") "x|t [-" |
Denys Vlasenko | b5233f8 | 2011-01-31 05:35:23 +0100 | [diff] [blame] | 755 | //usage: IF_FEATURE_SEAMLESS_Z("Z") |
| 756 | //usage: IF_FEATURE_SEAMLESS_GZ("z") |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 757 | //usage: IF_FEATURE_SEAMLESS_XZ("J") |
Denys Vlasenko | b5233f8 | 2011-01-31 05:35:23 +0100 | [diff] [blame] | 758 | //usage: IF_FEATURE_SEAMLESS_BZ2("j") |
| 759 | //usage: IF_FEATURE_SEAMLESS_LZMA("a") |
| 760 | //usage: IF_FEATURE_TAR_CREATE("h") |
| 761 | //usage: IF_FEATURE_TAR_NOPRESERVE_TIME("m") |
Denys Vlasenko | 3c08437 | 2018-03-16 04:02:23 +0100 | [diff] [blame^] | 762 | //usage: "vokO] " |
Denys Vlasenko | 02e93b3 | 2017-11-10 22:14:22 +0100 | [diff] [blame] | 763 | //usage: "[-f TARFILE] [-C DIR] " |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 764 | //usage: IF_FEATURE_TAR_FROM("[-T FILE] [-X FILE] "IF_FEATURE_TAR_LONG_OPTIONS("[--exclude PATTERN]... ")) |
Denys Vlasenko | 02e93b3 | 2017-11-10 22:14:22 +0100 | [diff] [blame] | 765 | //usage: "[FILE]..." |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 766 | //usage:#define tar_full_usage "\n\n" |
| 767 | //usage: IF_FEATURE_TAR_CREATE("Create, extract, ") |
| 768 | //usage: IF_NOT_FEATURE_TAR_CREATE("Extract ") |
| 769 | //usage: "or list files from a tar file\n" |
| 770 | //usage: "\nOperation:" |
| 771 | //usage: IF_FEATURE_TAR_CREATE( |
| 772 | //usage: "\n c Create" |
| 773 | //usage: ) |
| 774 | //usage: "\n x Extract" |
| 775 | //usage: "\n t List" |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 776 | //usage: "\n -f FILE Name of TARFILE ('-' for stdin/out)" |
| 777 | //usage: "\n -C DIR Change to DIR before operation" |
| 778 | //usage: "\n -v Verbose" |
Denys Vlasenko | 3c08437 | 2018-03-16 04:02:23 +0100 | [diff] [blame^] | 779 | //usage: "\n -O Extract to stdout" |
| 780 | //usage: IF_FEATURE_TAR_NOPRESERVE_TIME( |
| 781 | //usage: "\n -m Don't restore mtime" |
| 782 | //usage: ) |
Denys Vlasenko | 1ee222e | 2018-03-16 03:55:14 +0100 | [diff] [blame] | 783 | //usage: "\n -o Don't restore user:group" |
| 784 | ///////:-p - accepted but ignored, restores mode (aliases in GNU tar: --preserve-permissions, --same-permissions) |
| 785 | //usage: "\n -k Don't replace existing files" |
Denys Vlasenko | b5233f8 | 2011-01-31 05:35:23 +0100 | [diff] [blame] | 786 | //usage: IF_FEATURE_SEAMLESS_Z( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 787 | //usage: "\n -Z (De)compress using compress" |
Denys Vlasenko | b5233f8 | 2011-01-31 05:35:23 +0100 | [diff] [blame] | 788 | //usage: ) |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 789 | //usage: IF_FEATURE_SEAMLESS_GZ( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 790 | //usage: "\n -z (De)compress using gzip" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 791 | //usage: ) |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 792 | //usage: IF_FEATURE_SEAMLESS_XZ( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 793 | //usage: "\n -J (De)compress using xz" |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 794 | //usage: ) |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 795 | //usage: IF_FEATURE_SEAMLESS_BZ2( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 796 | //usage: "\n -j (De)compress using bzip2" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 797 | //usage: ) |
| 798 | //usage: IF_FEATURE_SEAMLESS_LZMA( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 799 | //usage: "\n -a (De)compress using lzma" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 800 | //usage: ) |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 801 | //usage: IF_FEATURE_TAR_CREATE( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 802 | //usage: "\n -h Follow symlinks" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 803 | //usage: ) |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 804 | //usage: IF_FEATURE_TAR_FROM( |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 805 | //usage: "\n -T FILE File with names to include" |
| 806 | //usage: "\n -X FILE File with glob patterns to exclude" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 807 | //usage: IF_FEATURE_TAR_LONG_OPTIONS( |
Denys Vlasenko | 02e93b3 | 2017-11-10 22:14:22 +0100 | [diff] [blame] | 808 | //usage: "\n --exclude PATTERN Glob pattern to exclude" |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 809 | //usage: ) |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 810 | //usage: ) |
| 811 | //usage: |
| 812 | //usage:#define tar_example_usage |
| 813 | //usage: "$ zcat /tmp/tarball.tar.gz | tar -xf -\n" |
| 814 | //usage: "$ tar -cf /tmp/tarball.tar /usr/local\n" |
| 815 | |
| 816 | // Supported but aren't in --help: |
Natanael Copa | 0446104 | 2012-04-24 17:06:19 +0200 | [diff] [blame] | 817 | // no-recursion |
Denys Vlasenko | 52827e3 | 2010-06-26 18:21:36 +0200 | [diff] [blame] | 818 | // numeric-owner |
| 819 | // no-same-permissions |
| 820 | // overwrite |
| 821 | //IF_FEATURE_TAR_TO_COMMAND( |
| 822 | // to-command |
| 823 | //) |
| 824 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 825 | enum { |
Bernhard Reutner-Fischer | 30f3c1d | 2009-10-25 02:13:32 +0200 | [diff] [blame] | 826 | OPTBIT_KEEP_OLD = 8, |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 827 | IF_FEATURE_TAR_CREATE( OPTBIT_CREATE ,) |
| 828 | IF_FEATURE_TAR_CREATE( OPTBIT_DEREFERENCE ,) |
| 829 | IF_FEATURE_SEAMLESS_BZ2( OPTBIT_BZIP2 ,) |
| 830 | IF_FEATURE_SEAMLESS_LZMA(OPTBIT_LZMA ,) |
| 831 | IF_FEATURE_TAR_FROM( OPTBIT_INCLUDE_FROM,) |
| 832 | IF_FEATURE_TAR_FROM( OPTBIT_EXCLUDE_FROM,) |
| 833 | IF_FEATURE_SEAMLESS_GZ( OPTBIT_GZIP ,) |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 834 | IF_FEATURE_SEAMLESS_XZ( OPTBIT_XZ ,) // 16th bit |
| 835 | IF_FEATURE_SEAMLESS_Z( OPTBIT_COMPRESS ,) |
Mikhail Gusarov | 0d47833 | 2010-01-19 20:22:30 +0600 | [diff] [blame] | 836 | IF_FEATURE_TAR_NOPRESERVE_TIME(OPTBIT_NOPRESERVE_TIME,) |
Denys Vlasenko | 425ad9c | 2009-12-16 22:46:01 +0100 | [diff] [blame] | 837 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 838 | OPTBIT_STRIP_COMPONENTS, |
Natanael Copa | 0446104 | 2012-04-24 17:06:19 +0200 | [diff] [blame] | 839 | OPTBIT_NORECURSION, |
Ladislav Michl | 2b46fd4 | 2010-06-25 01:33:00 +0200 | [diff] [blame] | 840 | IF_FEATURE_TAR_TO_COMMAND(OPTBIT_2COMMAND ,) |
Denis Vlasenko | 8b814b4 | 2009-04-21 00:52:21 +0000 | [diff] [blame] | 841 | OPTBIT_NUMERIC_OWNER, |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 842 | OPTBIT_NOPRESERVE_PERM, |
Denys Vlasenko | 8a936cf | 2009-12-16 23:18:59 +0100 | [diff] [blame] | 843 | OPTBIT_OVERWRITE, |
Denys Vlasenko | 425ad9c | 2009-12-16 22:46:01 +0100 | [diff] [blame] | 844 | #endif |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 845 | OPT_TEST = 1 << 0, // t |
| 846 | OPT_EXTRACT = 1 << 1, // x |
| 847 | OPT_BASEDIR = 1 << 2, // C |
| 848 | OPT_TARNAME = 1 << 3, // f |
| 849 | OPT_2STDOUT = 1 << 4, // O |
Denys Vlasenko | 425ad9c | 2009-12-16 22:46:01 +0100 | [diff] [blame] | 850 | OPT_NOPRESERVE_OWNER = 1 << 5, // o == no-same-owner |
Bernhard Reutner-Fischer | 30f3c1d | 2009-10-25 02:13:32 +0200 | [diff] [blame] | 851 | OPT_P = 1 << 6, // p |
| 852 | OPT_VERBOSE = 1 << 7, // v |
| 853 | OPT_KEEP_OLD = 1 << 8, // k |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 854 | OPT_CREATE = IF_FEATURE_TAR_CREATE( (1 << OPTBIT_CREATE )) + 0, // c |
| 855 | OPT_DEREFERENCE = IF_FEATURE_TAR_CREATE( (1 << OPTBIT_DEREFERENCE )) + 0, // h |
| 856 | OPT_BZIP2 = IF_FEATURE_SEAMLESS_BZ2( (1 << OPTBIT_BZIP2 )) + 0, // j |
| 857 | OPT_LZMA = IF_FEATURE_SEAMLESS_LZMA((1 << OPTBIT_LZMA )) + 0, // a |
| 858 | OPT_INCLUDE_FROM = IF_FEATURE_TAR_FROM( (1 << OPTBIT_INCLUDE_FROM)) + 0, // T |
| 859 | OPT_EXCLUDE_FROM = IF_FEATURE_TAR_FROM( (1 << OPTBIT_EXCLUDE_FROM)) + 0, // X |
| 860 | OPT_GZIP = IF_FEATURE_SEAMLESS_GZ( (1 << OPTBIT_GZIP )) + 0, // z |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 861 | OPT_XZ = IF_FEATURE_SEAMLESS_XZ( (1 << OPTBIT_XZ )) + 0, // J |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 862 | OPT_COMPRESS = IF_FEATURE_SEAMLESS_Z( (1 << OPTBIT_COMPRESS )) + 0, // Z |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 863 | OPT_NOPRESERVE_TIME = IF_FEATURE_TAR_NOPRESERVE_TIME((1 << OPTBIT_NOPRESERVE_TIME)) + 0, // m |
| 864 | OPT_STRIP_COMPONENTS = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_STRIP_COMPONENTS)) + 0, // strip-components |
| 865 | OPT_NORECURSION = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_NORECURSION )) + 0, // no-recursion |
| 866 | OPT_2COMMAND = IF_FEATURE_TAR_TO_COMMAND( (1 << OPTBIT_2COMMAND )) + 0, // to-command |
| 867 | OPT_NUMERIC_OWNER = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_NUMERIC_OWNER )) + 0, // numeric-owner |
| 868 | OPT_NOPRESERVE_PERM = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_NOPRESERVE_PERM)) + 0, // no-same-permissions |
| 869 | OPT_OVERWRITE = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_OVERWRITE )) + 0, // overwrite |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 870 | |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 871 | OPT_ANY_COMPRESS = (OPT_BZIP2 | OPT_LZMA | OPT_GZIP | OPT_XZ | OPT_COMPRESS), |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 872 | }; |
| 873 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS |
Denis Vlasenko | 6ca409e | 2007-08-12 20:58:27 +0000 | [diff] [blame] | 874 | static const char tar_longopts[] ALIGN1 = |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 875 | "list\0" No_argument "t" |
| 876 | "extract\0" No_argument "x" |
| 877 | "directory\0" Required_argument "C" |
| 878 | "file\0" Required_argument "f" |
| 879 | "to-stdout\0" No_argument "O" |
Bernhard Reutner-Fischer | 30f3c1d | 2009-10-25 02:13:32 +0200 | [diff] [blame] | 880 | /* do not restore owner */ |
| 881 | /* Note: GNU tar handles 'o' as no-same-owner only on extract, |
| 882 | * on create, 'o' is --old-archive. We do not support --old-archive. */ |
| 883 | "no-same-owner\0" No_argument "o" |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 884 | "same-permissions\0" No_argument "p" |
| 885 | "verbose\0" No_argument "v" |
| 886 | "keep-old\0" No_argument "k" |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 887 | # if ENABLE_FEATURE_TAR_CREATE |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 888 | "create\0" No_argument "c" |
| 889 | "dereference\0" No_argument "h" |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 890 | # endif |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 891 | # if ENABLE_FEATURE_SEAMLESS_BZ2 |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 892 | "bzip2\0" No_argument "j" |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 893 | # endif |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 894 | # if ENABLE_FEATURE_SEAMLESS_LZMA |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 895 | "lzma\0" No_argument "a" |
Rob Landley | c1d6990 | 2006-01-20 18:28:50 +0000 | [diff] [blame] | 896 | # endif |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 897 | # if ENABLE_FEATURE_TAR_FROM |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 898 | "files-from\0" Required_argument "T" |
| 899 | "exclude-from\0" Required_argument "X" |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 900 | # endif |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 901 | # if ENABLE_FEATURE_SEAMLESS_GZ |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 902 | "gzip\0" No_argument "z" |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 903 | # endif |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 904 | # if ENABLE_FEATURE_SEAMLESS_XZ |
| 905 | "xz\0" No_argument "J" |
| 906 | # endif |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 907 | # if ENABLE_FEATURE_SEAMLESS_Z |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 908 | "compress\0" No_argument "Z" |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 909 | # endif |
Mikhail Gusarov | 0d47833 | 2010-01-19 20:22:30 +0600 | [diff] [blame] | 910 | # if ENABLE_FEATURE_TAR_NOPRESERVE_TIME |
| 911 | "touch\0" No_argument "m" |
| 912 | # endif |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 913 | "strip-components\0" Required_argument "\xf9" |
Natanael Copa | 0446104 | 2012-04-24 17:06:19 +0200 | [diff] [blame] | 914 | "no-recursion\0" No_argument "\xfa" |
Ladislav Michl | 2b46fd4 | 2010-06-25 01:33:00 +0200 | [diff] [blame] | 915 | # if ENABLE_FEATURE_TAR_TO_COMMAND |
| 916 | "to-command\0" Required_argument "\xfb" |
| 917 | # endif |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 918 | /* use numeric uid/gid from tar header, not textual */ |
Denys Vlasenko | 8a936cf | 2009-12-16 23:18:59 +0100 | [diff] [blame] | 919 | "numeric-owner\0" No_argument "\xfc" |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 920 | /* do not restore mode */ |
Denys Vlasenko | 8a936cf | 2009-12-16 23:18:59 +0100 | [diff] [blame] | 921 | "no-same-permissions\0" No_argument "\xfd" |
| 922 | /* on unpack, open with O_TRUNC and !O_EXCL */ |
| 923 | "overwrite\0" No_argument "\xfe" |
Denis Vlasenko | 30d7a34 | 2006-11-27 20:24:40 +0000 | [diff] [blame] | 924 | /* --exclude takes next bit position in option mask, */ |
Denys Vlasenko | 425ad9c | 2009-12-16 22:46:01 +0100 | [diff] [blame] | 925 | /* therefore we have to put it _after_ --no-same-permissions */ |
Denis Vlasenko | 30d7a34 | 2006-11-27 20:24:40 +0000 | [diff] [blame] | 926 | # if ENABLE_FEATURE_TAR_FROM |
Denis Vlasenko | bdc88fd | 2007-07-23 17:14:14 +0000 | [diff] [blame] | 927 | "exclude\0" Required_argument "\xff" |
Denis Vlasenko | 30d7a34 | 2006-11-27 20:24:40 +0000 | [diff] [blame] | 928 | # endif |
Denis Vlasenko | 990d0f6 | 2007-07-24 15:54:42 +0000 | [diff] [blame] | 929 | ; |
Denys Vlasenko | 036585a | 2017-08-08 16:38:18 +0200 | [diff] [blame] | 930 | # define GETOPT32 getopt32long |
| 931 | # define LONGOPTS ,tar_longopts |
| 932 | #else |
| 933 | # define GETOPT32 getopt32 |
| 934 | # define LONGOPTS |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 935 | #endif |
Glenn L McGrath | ec87d37 | 2002-11-27 07:52:22 +0000 | [diff] [blame] | 936 | |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 937 | int tar_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 938 | int tar_main(int argc UNUSED_PARAM, char **argv) |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 939 | { |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 940 | archive_handle_t *tar_handle; |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 941 | char *base_dir = NULL; |
Glenn L McGrath | f66de64 | 2002-11-25 23:57:27 +0000 | [diff] [blame] | 942 | const char *tar_filename = "-"; |
Denis Vlasenko | 67b23e6 | 2006-10-03 21:00:06 +0000 | [diff] [blame] | 943 | unsigned opt; |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 944 | int verboseFlag = 0; |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 945 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM |
"Vladimir N. Oleynik" | 84e7511 | 2005-10-15 06:32:38 +0000 | [diff] [blame] | 946 | llist_t *excludes = NULL; |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 947 | #endif |
Denys Vlasenko | 9de2e5a | 2016-04-21 18:38:51 +0200 | [diff] [blame] | 948 | INIT_G(); |
Tim Riker | c1ef7bd | 2006-01-25 00:08:53 +0000 | [diff] [blame] | 949 | |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 950 | /* Initialise default values */ |
| 951 | tar_handle = init_handle(); |
Denis Vlasenko | a60936d | 2008-06-28 05:04:09 +0000 | [diff] [blame] | 952 | tar_handle->ah_flags = ARCHIVE_CREATE_LEADING_DIRS |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 953 | | ARCHIVE_RESTORE_DATE |
| 954 | | ARCHIVE_UNLINK_OLD; |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 955 | |
Denis Vlasenko | 73d702e | 2008-10-25 09:27:35 +0000 | [diff] [blame] | 956 | /* Apparently only root's tar preserves perms (see bug 3844) */ |
Denis Vlasenko | ebad029 | 2008-10-24 23:47:38 +0000 | [diff] [blame] | 957 | if (getuid() != 0) |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 958 | tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_PERM; |
Denis Vlasenko | ebad029 | 2008-10-24 23:47:38 +0000 | [diff] [blame] | 959 | |
Denys Vlasenko | f645037 | 2009-10-25 01:32:45 +0200 | [diff] [blame] | 960 | #if ENABLE_DESKTOP |
Denys Vlasenko | 62ae323 | 2015-10-22 13:22:26 +0200 | [diff] [blame] | 961 | /* Lie to buildroot when it starts asking stupid questions. */ |
| 962 | if (argv[1] && strcmp(argv[1], "--version") == 0) { |
| 963 | // Output of 'tar --version' examples: |
| 964 | // tar (GNU tar) 1.15.1 |
| 965 | // tar (GNU tar) 1.25 |
| 966 | // bsdtar 2.8.3 - libarchive 2.8.3 |
| 967 | puts("tar (busybox) " BB_VER); |
| 968 | return 0; |
| 969 | } |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 970 | #endif |
| 971 | if (argv[1] && argv[1][0] != '-' && argv[1][0] != '\0') { |
Denys Vlasenko | f645037 | 2009-10-25 01:32:45 +0200 | [diff] [blame] | 972 | /* Compat: |
| 973 | * 1st argument without dash handles options with parameters |
| 974 | * differently from dashed one: it takes *next argv[i]* |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 975 | * as parameter even if there are more chars in 1st argument: |
Denys Vlasenko | f645037 | 2009-10-25 01:32:45 +0200 | [diff] [blame] | 976 | * "tar fx TARFILE" - "x" is not taken as f's param |
| 977 | * but is interpreted as -x option |
| 978 | * "tar -xf TARFILE" - dashed equivalent of the above |
| 979 | * "tar -fx ..." - "x" is taken as f's param |
| 980 | * getopt32 wouldn't handle 1st command correctly. |
| 981 | * Unfortunately, people do use such commands. |
| 982 | * We massage argv[1] to work around it by moving 'f' |
| 983 | * to the end of the string. |
| 984 | * More contrived "tar fCx TARFILE DIR" still fails, |
| 985 | * but such commands are much less likely to be used. |
| 986 | */ |
| 987 | char *f = strchr(argv[1], 'f'); |
| 988 | if (f) { |
| 989 | while (f[1] != '\0') { |
| 990 | *f = f[1]; |
| 991 | f++; |
| 992 | } |
| 993 | *f = 'f'; |
| 994 | } |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 995 | /* Prepend '-' to the first argument */ |
Ron Yorston | 6bafcfb | 2017-08-22 16:33:06 +0100 | [diff] [blame] | 996 | argv[1] = xasprintf("-%s", argv[1]); |
Denys Vlasenko | a07fead | 2017-11-13 01:56:51 +0100 | [diff] [blame] | 997 | } |
Denys Vlasenko | 22542ec | 2017-08-08 21:55:02 +0200 | [diff] [blame] | 998 | opt = GETOPT32(argv, "^" |
Bernhard Reutner-Fischer | 30f3c1d | 2009-10-25 02:13:32 +0200 | [diff] [blame] | 999 | "txC:f:Oopvk" |
Denys Vlasenko | 237bedd | 2016-07-06 21:58:02 +0200 | [diff] [blame] | 1000 | IF_FEATURE_TAR_CREATE( "ch" ) |
| 1001 | IF_FEATURE_SEAMLESS_BZ2( "j" ) |
| 1002 | IF_FEATURE_SEAMLESS_LZMA("a" ) |
| 1003 | IF_FEATURE_TAR_FROM( "T:*X:*") |
| 1004 | IF_FEATURE_SEAMLESS_GZ( "z" ) |
| 1005 | IF_FEATURE_SEAMLESS_XZ( "J" ) |
| 1006 | IF_FEATURE_SEAMLESS_Z( "Z" ) |
Mikhail Gusarov | 0d47833 | 2010-01-19 20:22:30 +0600 | [diff] [blame] | 1007 | IF_FEATURE_TAR_NOPRESERVE_TIME("m") |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 1008 | IF_FEATURE_TAR_LONG_OPTIONS("\xf9:") // --strip-components |
Denys Vlasenko | 22542ec | 2017-08-08 21:55:02 +0200 | [diff] [blame] | 1009 | "\0" |
| 1010 | "tt:vv:" // count -t,-v |
| 1011 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM |
| 1012 | "\xff::" // --exclude=PATTERN is a list |
| 1013 | #endif |
| 1014 | IF_FEATURE_TAR_CREATE("c:") "t:x:" // at least one of these is reqd |
| 1015 | IF_FEATURE_TAR_CREATE("c--tx:t--cx:x--ct") // mutually exclusive |
| 1016 | IF_NOT_FEATURE_TAR_CREATE("t--x:x--t") // mutually exclusive |
| 1017 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS |
| 1018 | ":\xf9+" // --strip-components=NUM |
| 1019 | #endif |
Denys Vlasenko | 036585a | 2017-08-08 16:38:18 +0200 | [diff] [blame] | 1020 | LONGOPTS |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 1021 | , &base_dir // -C dir |
| 1022 | , &tar_filename // -f filename |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 1023 | IF_FEATURE_TAR_FROM(, &(tar_handle->accept)) // T |
| 1024 | IF_FEATURE_TAR_FROM(, &(tar_handle->reject)) // X |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 1025 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS |
| 1026 | , &tar_handle->tar__strip_components // --strip-components |
| 1027 | #endif |
Ladislav Michl | 2b46fd4 | 2010-06-25 01:33:00 +0200 | [diff] [blame] | 1028 | IF_FEATURE_TAR_TO_COMMAND(, &(tar_handle->tar__to_command)) // --to-command |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 1029 | #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM |
| 1030 | , &excludes // --exclude |
| 1031 | #endif |
| 1032 | , &verboseFlag // combined count for -t and -v |
| 1033 | , &verboseFlag // combined count for -t and -v |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 1034 | ); |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 1035 | #if DBG_OPTION_PARSING |
| 1036 | bb_error_msg("opt: 0x%08x", opt); |
| 1037 | # define showopt(o) bb_error_msg("opt & %s(%x): %x", #o, o, opt & o); |
| 1038 | showopt(OPT_TEST ); |
| 1039 | showopt(OPT_EXTRACT ); |
| 1040 | showopt(OPT_BASEDIR ); |
| 1041 | showopt(OPT_TARNAME ); |
| 1042 | showopt(OPT_2STDOUT ); |
| 1043 | showopt(OPT_NOPRESERVE_OWNER); |
| 1044 | showopt(OPT_P ); |
| 1045 | showopt(OPT_VERBOSE ); |
| 1046 | showopt(OPT_KEEP_OLD ); |
| 1047 | showopt(OPT_CREATE ); |
| 1048 | showopt(OPT_DEREFERENCE ); |
| 1049 | showopt(OPT_BZIP2 ); |
| 1050 | showopt(OPT_LZMA ); |
| 1051 | showopt(OPT_INCLUDE_FROM ); |
| 1052 | showopt(OPT_EXCLUDE_FROM ); |
| 1053 | showopt(OPT_GZIP ); |
| 1054 | showopt(OPT_XZ ); |
| 1055 | showopt(OPT_COMPRESS ); |
| 1056 | showopt(OPT_NOPRESERVE_TIME ); |
| 1057 | showopt(OPT_STRIP_COMPONENTS); |
| 1058 | showopt(OPT_NORECURSION ); |
| 1059 | showopt(OPT_2COMMAND ); |
| 1060 | showopt(OPT_NUMERIC_OWNER ); |
| 1061 | showopt(OPT_NOPRESERVE_PERM ); |
| 1062 | showopt(OPT_OVERWRITE ); |
| 1063 | showopt(OPT_ANY_COMPRESS ); |
| 1064 | bb_error_msg("base_dir:'%s'", base_dir); |
| 1065 | bb_error_msg("tar_filename:'%s'", tar_filename); |
| 1066 | bb_error_msg("verboseFlag:%d", verboseFlag); |
| 1067 | bb_error_msg("tar_handle->tar__to_command:'%s'", tar_handle->tar__to_command); |
| 1068 | bb_error_msg("tar_handle->tar__strip_components:%u", tar_handle->tar__strip_components); |
| 1069 | return 0; |
| 1070 | # undef showopt |
| 1071 | #endif |
Denis Vlasenko | c450379 | 2008-04-29 02:43:23 +0000 | [diff] [blame] | 1072 | argv += optind; |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 1073 | |
Denys Vlasenko | 6c563e3 | 2015-10-22 01:07:13 +0200 | [diff] [blame] | 1074 | if (verboseFlag) |
| 1075 | tar_handle->action_header = header_verbose_list; |
| 1076 | if (verboseFlag == 1) |
| 1077 | tar_handle->action_header = header_list; |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 1078 | |
Denis Vlasenko | b596335 | 2006-11-26 01:46:59 +0000 | [diff] [blame] | 1079 | if (opt & OPT_EXTRACT) |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 1080 | tar_handle->action_data = data_extract_all; |
Tim Riker | c1ef7bd | 2006-01-25 00:08:53 +0000 | [diff] [blame] | 1081 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 1082 | if (opt & OPT_2STDOUT) |
Glenn L McGrath | 3b9fc8f | 2003-11-18 20:23:04 +0000 | [diff] [blame] | 1083 | tar_handle->action_data = data_extract_to_stdout; |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 1084 | |
Ladislav Michl | 2b46fd4 | 2010-06-25 01:33:00 +0200 | [diff] [blame] | 1085 | if (opt & OPT_2COMMAND) { |
| 1086 | putenv((char*)"TAR_FILETYPE=f"); |
| 1087 | signal(SIGPIPE, SIG_IGN); |
| 1088 | tar_handle->action_data = data_extract_to_command; |
Denys Vlasenko | 681efe2 | 2011-03-08 21:00:36 +0100 | [diff] [blame] | 1089 | IF_FEATURE_TAR_TO_COMMAND(tar_handle->tar__to_command_shell = xstrdup(get_shell_name());) |
Ladislav Michl | 2b46fd4 | 2010-06-25 01:33:00 +0200 | [diff] [blame] | 1090 | } |
| 1091 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 1092 | if (opt & OPT_KEEP_OLD) |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 1093 | tar_handle->ah_flags &= ~ARCHIVE_UNLINK_OLD; |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 1094 | |
Denis Vlasenko | 8b814b4 | 2009-04-21 00:52:21 +0000 | [diff] [blame] | 1095 | if (opt & OPT_NUMERIC_OWNER) |
| 1096 | tar_handle->ah_flags |= ARCHIVE_NUMERIC_OWNER; |
| 1097 | |
Denys Vlasenko | d57d626 | 2009-09-17 02:43:14 +0200 | [diff] [blame] | 1098 | if (opt & OPT_NOPRESERVE_OWNER) |
| 1099 | tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_OWNER; |
| 1100 | |
| 1101 | if (opt & OPT_NOPRESERVE_PERM) |
| 1102 | tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_PERM; |
| 1103 | |
Denys Vlasenko | 8a936cf | 2009-12-16 23:18:59 +0100 | [diff] [blame] | 1104 | if (opt & OPT_OVERWRITE) { |
| 1105 | tar_handle->ah_flags &= ~ARCHIVE_UNLINK_OLD; |
| 1106 | tar_handle->ah_flags |= ARCHIVE_O_TRUNC; |
| 1107 | } |
| 1108 | |
Mikhail Gusarov | 0d47833 | 2010-01-19 20:22:30 +0600 | [diff] [blame] | 1109 | if (opt & OPT_NOPRESERVE_TIME) |
| 1110 | tar_handle->ah_flags &= ~ARCHIVE_RESTORE_DATE; |
Mikhail Gusarov | 0d47833 | 2010-01-19 20:22:30 +0600 | [diff] [blame] | 1111 | |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 1112 | #if ENABLE_FEATURE_TAR_FROM |
| 1113 | tar_handle->reject = append_file_list_to_list(tar_handle->reject); |
Denys Vlasenko | 94ca694 | 2010-01-20 02:51:09 +0100 | [diff] [blame] | 1114 | # if ENABLE_FEATURE_TAR_LONG_OPTIONS |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 1115 | /* Append excludes to reject */ |
| 1116 | while (excludes) { |
| 1117 | llist_t *next = excludes->link; |
| 1118 | excludes->link = tar_handle->reject; |
| 1119 | tar_handle->reject = excludes; |
| 1120 | excludes = next; |
Glenn L McGrath | 56f16b4 | 2003-11-18 21:37:52 +0000 | [diff] [blame] | 1121 | } |
Denys Vlasenko | 94ca694 | 2010-01-20 02:51:09 +0100 | [diff] [blame] | 1122 | # endif |
Denis Vlasenko | 8c0164c | 2007-02-04 21:30:35 +0000 | [diff] [blame] | 1123 | tar_handle->accept = append_file_list_to_list(tar_handle->accept); |
| 1124 | #endif |
Glenn L McGrath | ce91c8a | 2003-12-26 14:01:37 +0000 | [diff] [blame] | 1125 | |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 1126 | /* Setup an array of filenames to work with */ |
Denys Vlasenko | 94ca694 | 2010-01-20 02:51:09 +0100 | [diff] [blame] | 1127 | /* TODO: This is the same as in ar, make a separate function? */ |
Denis Vlasenko | c450379 | 2008-04-29 02:43:23 +0000 | [diff] [blame] | 1128 | while (*argv) { |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 1129 | /* kill trailing '/' unless the string is just "/" */ |
Denis Vlasenko | c450379 | 2008-04-29 02:43:23 +0000 | [diff] [blame] | 1130 | char *cp = last_char_is(*argv, '/'); |
| 1131 | if (cp > *argv) |
Denis Vlasenko | 3feb2fc | 2006-11-24 21:55:55 +0000 | [diff] [blame] | 1132 | *cp = '\0'; |
Denis Vlasenko | c450379 | 2008-04-29 02:43:23 +0000 | [diff] [blame] | 1133 | llist_add_to_end(&tar_handle->accept, *argv); |
| 1134 | argv++; |
Glenn L McGrath | c5c1a8a | 2002-10-19 06:19:22 +0000 | [diff] [blame] | 1135 | } |
Glenn L McGrath | 98f824a | 2002-10-19 00:46:35 +0000 | [diff] [blame] | 1136 | |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 1137 | if (tar_handle->accept || tar_handle->reject) |
Glenn L McGrath | c5c1a8a | 2002-10-19 06:19:22 +0000 | [diff] [blame] | 1138 | tar_handle->filter = filter_accept_reject_list; |
Glenn L McGrath | a0ee881 | 2002-08-22 13:44:08 +0000 | [diff] [blame] | 1139 | |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1140 | /* Open the tar file */ |
| 1141 | { |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 1142 | int tar_fd = STDIN_FILENO; |
| 1143 | int flags = O_RDONLY; |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1144 | |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 1145 | if (opt & OPT_CREATE) { |
Denys Vlasenko | 94ca694 | 2010-01-20 02:51:09 +0100 | [diff] [blame] | 1146 | /* Make sure there is at least one file to tar up */ |
Rob Landley | 60fe7bf | 2005-10-16 03:54:49 +0000 | [diff] [blame] | 1147 | if (tar_handle->accept == NULL) |
| 1148 | bb_error_msg_and_die("empty archive"); |
| 1149 | |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 1150 | tar_fd = STDOUT_FILENO; |
Denis Vlasenko | 376ce1e | 2006-11-24 14:51:01 +0000 | [diff] [blame] | 1151 | /* Mimicking GNU tar 1.15.1: */ |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 1152 | flags = O_WRONLY | O_CREAT | O_TRUNC; |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1153 | } |
| 1154 | |
Denis Vlasenko | 9f73944 | 2006-12-16 23:49:13 +0000 | [diff] [blame] | 1155 | if (LONE_DASH(tar_filename)) { |
Denys Vlasenko | d43d628 | 2009-11-29 16:28:33 +0100 | [diff] [blame] | 1156 | tar_handle->src_fd = tar_fd; |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 1157 | tar_handle->seek = seek_by_read; |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1158 | } else { |
Denys Vlasenko | aef441c | 2011-02-06 20:01:11 +0100 | [diff] [blame] | 1159 | if (ENABLE_FEATURE_TAR_AUTODETECT |
| 1160 | && flags == O_RDONLY |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1161 | && !(opt & OPT_ANY_COMPRESS) |
Denys Vlasenko | aef441c | 2011-02-06 20:01:11 +0100 | [diff] [blame] | 1162 | ) { |
Denys Vlasenko | 640ce3d | 2014-02-02 02:06:38 +0100 | [diff] [blame] | 1163 | tar_handle->src_fd = open_zipped(tar_filename, /*fail_if_not_compressed:*/ 0); |
Denis Vlasenko | e9ad84d | 2008-08-05 13:10:34 +0000 | [diff] [blame] | 1164 | if (tar_handle->src_fd < 0) |
| 1165 | bb_perror_msg_and_die("can't open '%s'", tar_filename); |
| 1166 | } else { |
| 1167 | tar_handle->src_fd = xopen(tar_filename, flags); |
| 1168 | } |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1169 | } |
| 1170 | } |
| 1171 | |
Bernhard Reutner-Fischer | d9cf7ac | 2006-04-12 18:39:58 +0000 | [diff] [blame] | 1172 | if (base_dir) |
Rob Landley | 86b4d64 | 2006-08-03 17:58:17 +0000 | [diff] [blame] | 1173 | xchdir(base_dir); |
Glenn L McGrath | 91b3d46 | 2003-10-02 14:33:23 +0000 | [diff] [blame] | 1174 | |
Denys Vlasenko | 015db58 | 2016-06-19 18:15:33 +0200 | [diff] [blame] | 1175 | #if ENABLE_FEATURE_TAR_CREATE |
Denys Vlasenko | 94ca694 | 2010-01-20 02:51:09 +0100 | [diff] [blame] | 1176 | /* Create an archive */ |
Denis Vlasenko | d031ffa | 2006-11-24 21:54:44 +0000 | [diff] [blame] | 1177 | if (opt & OPT_CREATE) { |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 1178 | struct TarBallInfo *tbInfo; |
Denys Vlasenko | 015db58 | 2016-06-19 18:15:33 +0200 | [diff] [blame] | 1179 | # if SEAMLESS_COMPRESSION |
Denys Vlasenko | acb8be7 | 2014-12-11 15:33:07 +0100 | [diff] [blame] | 1180 | const char *zipMode = NULL; |
| 1181 | if (opt & OPT_COMPRESS) |
| 1182 | zipMode = "compress"; |
| 1183 | if (opt & OPT_GZIP) |
| 1184 | zipMode = "gzip"; |
| 1185 | if (opt & OPT_BZIP2) |
| 1186 | zipMode = "bzip2"; |
| 1187 | if (opt & OPT_LZMA) |
| 1188 | zipMode = "lzma"; |
| 1189 | if (opt & OPT_XZ) |
| 1190 | zipMode = "xz"; |
Denys Vlasenko | 015db58 | 2016-06-19 18:15:33 +0200 | [diff] [blame] | 1191 | # endif |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 1192 | tbInfo = xzalloc(sizeof(*tbInfo)); |
| 1193 | tbInfo->tarFd = tar_handle->src_fd; |
| 1194 | tbInfo->verboseFlag = verboseFlag; |
| 1195 | # if ENABLE_FEATURE_TAR_FROM |
| 1196 | tbInfo->excludeList = tar_handle->reject; |
| 1197 | # endif |
Denis Vlasenko | c888946 | 2006-12-17 19:08:20 +0000 | [diff] [blame] | 1198 | /* NB: writeTarFile() closes tar_handle->src_fd */ |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 1199 | return writeTarFile(tbInfo, |
Natanael Copa | 0446104 | 2012-04-24 17:06:19 +0200 | [diff] [blame] | 1200 | (opt & OPT_DEREFERENCE ? ACTION_FOLLOWLINKS : 0) |
| 1201 | | (opt & OPT_NORECURSION ? 0 : ACTION_RECURSE), |
Bernhard Reutner-Fischer | 18260d5 | 2006-04-18 14:17:49 +0000 | [diff] [blame] | 1202 | tar_handle->accept, |
Denys Vlasenko | 931cf64 | 2017-11-13 01:40:28 +0100 | [diff] [blame] | 1203 | zipMode); |
Glenn L McGrath | 98f824a | 2002-10-19 00:46:35 +0000 | [diff] [blame] | 1204 | } |
Denys Vlasenko | 015db58 | 2016-06-19 18:15:33 +0200 | [diff] [blame] | 1205 | #endif |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 1206 | |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1207 | if (opt & OPT_ANY_COMPRESS) { |
Denys Vlasenko | b4c11c1 | 2014-12-07 00:44:00 +0100 | [diff] [blame] | 1208 | USE_FOR_MMU(IF_DESKTOP(long long) int FAST_FUNC (*xformer)(transformer_state_t *xstate);) |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1209 | USE_FOR_NOMMU(const char *xformer_prog;) |
| 1210 | |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1211 | if (opt & OPT_COMPRESS) { |
| 1212 | USE_FOR_MMU(IF_FEATURE_SEAMLESS_Z(xformer = unpack_Z_stream;)) |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1213 | USE_FOR_NOMMU(xformer_prog = "uncompress";) |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1214 | } |
| 1215 | if (opt & OPT_GZIP) { |
| 1216 | USE_FOR_MMU(IF_FEATURE_SEAMLESS_GZ(xformer = unpack_gz_stream;)) |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1217 | USE_FOR_NOMMU(xformer_prog = "gunzip";) |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1218 | } |
| 1219 | if (opt & OPT_BZIP2) { |
| 1220 | USE_FOR_MMU(IF_FEATURE_SEAMLESS_BZ2(xformer = unpack_bz2_stream;)) |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1221 | USE_FOR_NOMMU(xformer_prog = "bunzip2";) |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1222 | } |
| 1223 | if (opt & OPT_LZMA) { |
| 1224 | USE_FOR_MMU(IF_FEATURE_SEAMLESS_LZMA(xformer = unpack_lzma_stream;)) |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1225 | USE_FOR_NOMMU(xformer_prog = "unlzma";) |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1226 | } |
| 1227 | if (opt & OPT_XZ) { |
| 1228 | USE_FOR_MMU(IF_FEATURE_SEAMLESS_XZ(xformer = unpack_xz_stream;)) |
Boris Reisig | dfc2473 | 2012-05-24 09:01:55 +0200 | [diff] [blame] | 1229 | USE_FOR_NOMMU(xformer_prog = "unxz";) |
Ming Liu | 978307f | 2017-06-02 10:47:23 +0200 | [diff] [blame] | 1230 | } |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1231 | |
Denys Vlasenko | b4c11c1 | 2014-12-07 00:44:00 +0100 | [diff] [blame] | 1232 | fork_transformer_with_sig(tar_handle->src_fd, xformer, xformer_prog); |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1233 | /* Can't lseek over pipes */ |
| 1234 | tar_handle->seek = seek_by_read; |
| 1235 | /*tar_handle->offset = 0; - already is */ |
| 1236 | } |
| 1237 | |
Denys Vlasenko | 0545e3b | 2013-11-19 17:17:48 +0100 | [diff] [blame] | 1238 | /* Zero processed headers (== empty file) is not a valid tarball. |
| 1239 | * We (ab)use bb_got_signal as exitcode here, |
| 1240 | * because check_errors_in_children() uses _it_ as error indicator. |
| 1241 | */ |
| 1242 | bb_got_signal = EXIT_FAILURE; |
| 1243 | |
Denys Vlasenko | 8a6a2f9 | 2012-03-06 16:27:48 +0100 | [diff] [blame] | 1244 | while (get_header_tar(tar_handle) == EXIT_SUCCESS) |
Denys Vlasenko | 0545e3b | 2013-11-19 17:17:48 +0100 | [diff] [blame] | 1245 | bb_got_signal = EXIT_SUCCESS; /* saw at least one header, good */ |
Denis Vlasenko | b8a8e60 | 2006-11-24 14:59:45 +0000 | [diff] [blame] | 1246 | |
Denys Vlasenko | a84db18 | 2018-02-20 15:57:45 +0100 | [diff] [blame] | 1247 | create_symlinks_from_list(tar_handle->symlink_placeholders); |
| 1248 | |
Denis Vlasenko | b8a8e60 | 2006-11-24 14:59:45 +0000 | [diff] [blame] | 1249 | /* Check that every file that should have been extracted was */ |
| 1250 | while (tar_handle->accept) { |
| 1251 | if (!find_list_entry(tar_handle->reject, tar_handle->accept->data) |
| 1252 | && !find_list_entry(tar_handle->passed, tar_handle->accept->data) |
| 1253 | ) { |
| 1254 | bb_error_msg_and_die("%s: not found in archive", |
| 1255 | tar_handle->accept->data); |
| 1256 | } |
| 1257 | tar_handle->accept = tar_handle->accept->link; |
| 1258 | } |
| 1259 | if (ENABLE_FEATURE_CLEAN_UP /* && tar_handle->src_fd != STDIN_FILENO */) |
Glenn L McGrath | 8132e93 | 2002-09-28 02:06:39 +0000 | [diff] [blame] | 1260 | close(tar_handle->src_fd); |
Glenn L McGrath | 7ca04f3 | 2002-09-25 02:47:48 +0000 | [diff] [blame] | 1261 | |
Denys Vlasenko | faac1d3 | 2012-03-06 16:33:42 +0100 | [diff] [blame] | 1262 | if (SEAMLESS_COMPRESSION || OPT_COMPRESS) { |
Denys Vlasenko | 0545e3b | 2013-11-19 17:17:48 +0100 | [diff] [blame] | 1263 | /* Set bb_got_signal to 1 if a child died with !0 exitcode */ |
Denys Vlasenko | faac1d3 | 2012-03-06 16:33:42 +0100 | [diff] [blame] | 1264 | check_errors_in_children(0); |
Denys Vlasenko | faac1d3 | 2012-03-06 16:33:42 +0100 | [diff] [blame] | 1265 | } |
Denys Vlasenko | 0545e3b | 2013-11-19 17:17:48 +0100 | [diff] [blame] | 1266 | |
| 1267 | return bb_got_signal; |
Glenn L McGrath | 2e772ed | 2001-10-05 02:58:48 +0000 | [diff] [blame] | 1268 | } |