tar: handle tarfiles with (broken) checksums a-la Sun.
[platform/upstream/busybox.git] / archival / tar.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * Mini tar implementation for busybox
4  *
5  * Modified to use common extraction code used by ar, cpio, dpkg-deb, dpkg
6  *  Glenn McGrath <bug1@iinet.net.au>
7  *
8  * Note, that as of BusyBox-0.43, tar has been completely rewritten from the
9  * ground up.  It still has remnants of the old code lying about, but it is
10  * very different now (i.e., cleaner, less global variables, etc.)
11  *
12  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
13  *
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.
18  *  Permission to distribute sash derived code under the GPL has been granted.
19  *
20  * Based in part on the tar implementation from busybox-0.28
21  *  Copyright (C) 1995 Bruce Perens
22  *
23  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
24  */
25
26 #include <fnmatch.h>
27 #include <getopt.h>
28 #include "busybox.h"
29 #include "unarchive.h"
30
31 #if ENABLE_FEATURE_TAR_CREATE
32
33 /* Tar file constants  */
34
35 #define TAR_BLOCK_SIZE          512
36
37 /* POSIX tar Header Block, from POSIX 1003.1-1990  */
38 #define NAME_SIZE      100
39 #define NAME_SIZE_STR "100"
40 typedef struct TarHeader TarHeader;
41 struct TarHeader {                /* byte offset */
42         char name[NAME_SIZE];     /*   0-99 */
43         char mode[8];             /* 100-107 */
44         char uid[8];              /* 108-115 */
45         char gid[8];              /* 116-123 */
46         char size[12];            /* 124-135 */
47         char mtime[12];           /* 136-147 */
48         char chksum[8];           /* 148-155 */
49         char typeflag;            /* 156-156 */
50         char linkname[NAME_SIZE]; /* 157-256 */
51         char magic[6];            /* 257-262 */
52         char version[2];          /* 263-264 */
53         char uname[32];           /* 265-296 */
54         char gname[32];           /* 297-328 */
55         char devmajor[8];         /* 329-336 */
56         char devminor[8];         /* 337-344 */
57         char prefix[155];         /* 345-499 */
58         char padding[12];         /* 500-512 (pad to exactly the TAR_BLOCK_SIZE) */
59 };
60
61 /*
62 ** writeTarFile(), writeFileToTarball(), and writeTarHeader() are
63 ** the only functions that deal with the HardLinkInfo structure.
64 ** Even these functions use the xxxHardLinkInfo() functions.
65 */
66 typedef struct HardLinkInfo HardLinkInfo;
67 struct HardLinkInfo {
68         HardLinkInfo *next;     /* Next entry in list */
69         dev_t dev;                      /* Device number */
70         ino_t ino;                      /* Inode number */
71         short linkCount;        /* (Hard) Link Count */
72         char name[1];           /* Start of filename (must be last) */
73 };
74
75 /* Some info to be carried along when creating a new tarball */
76 typedef struct TarBallInfo TarBallInfo;
77 struct TarBallInfo {
78         int tarFd;                              /* Open-for-write file descriptor
79                                                            for the tarball */
80         struct stat statBuf;    /* Stat info for the tarball, letting
81                                                            us know the inode and device that the
82                                                            tarball lives, so we can avoid trying
83                                                            to include the tarball into itself */
84         int verboseFlag;                /* Whether to print extra stuff or not */
85         const llist_t *excludeList;     /* List of files to not include */
86         HardLinkInfo *hlInfoHead;       /* Hard Link Tracking Information */
87         HardLinkInfo *hlInfo;   /* Hard Link Info for the current file */
88 };
89
90 /* A nice enum with all the possible tar file content types */
91 enum TarFileType {
92         REGTYPE = '0',          /* regular file */
93         REGTYPE0 = '\0',        /* regular file (ancient bug compat) */
94         LNKTYPE = '1',          /* hard link */
95         SYMTYPE = '2',          /* symbolic link */
96         CHRTYPE = '3',          /* character special */
97         BLKTYPE = '4',          /* block special */
98         DIRTYPE = '5',          /* directory */
99         FIFOTYPE = '6',         /* FIFO special */
100         CONTTYPE = '7',         /* reserved */
101         GNULONGLINK = 'K',      /* GNU long (>100 chars) link name */
102         GNULONGNAME = 'L',      /* GNU long (>100 chars) file name */
103 };
104 typedef enum TarFileType TarFileType;
105
106 /* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
107 static void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr,
108                                         struct stat *statbuf,
109                                         const char *fileName)
110 {
111         /* Note: hlInfoHeadPtr can never be NULL! */
112         HardLinkInfo *hlInfo;
113
114         hlInfo = xmalloc(sizeof(HardLinkInfo) + strlen(fileName));
115         hlInfo->next = *hlInfoHeadPtr;
116         *hlInfoHeadPtr = hlInfo;
117         hlInfo->dev = statbuf->st_dev;
118         hlInfo->ino = statbuf->st_ino;
119         hlInfo->linkCount = statbuf->st_nlink;
120         strcpy(hlInfo->name, fileName);
121 }
122
123 static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
124 {
125         HardLinkInfo *hlInfo;
126         HardLinkInfo *hlInfoNext;
127
128         if (hlInfoHeadPtr) {
129                 hlInfo = *hlInfoHeadPtr;
130                 while (hlInfo) {
131                         hlInfoNext = hlInfo->next;
132                         free(hlInfo);
133                         hlInfo = hlInfoNext;
134                 }
135                 *hlInfoHeadPtr = NULL;
136         }
137         return;
138 }
139
140 /* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
141 static HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
142 {
143         while (hlInfo) {
144                 if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
145                         break;
146                 hlInfo = hlInfo->next;
147         }
148         return hlInfo;
149 }
150
151 /* Put an octal string into the specified buffer.
152  * The number is zero padded and possibly null terminated.
153  * Stores low-order bits only if whole value does not fit. */
154 static void putOctal(char *cp, int len, off_t value)
155 {
156         char tempBuffer[sizeof(off_t)*3+1];
157         char *tempString = tempBuffer;
158         int width;
159
160         width = sprintf(tempBuffer, "%0*"OFF_FMT"o", len, value);
161         tempString += (width - len);
162
163         /* If string has leading zeroes, we can drop one */
164         /* and field will have trailing '\0' */
165         /* (increases chances of compat with other tars) */
166         if (tempString[0] == '0')
167                 tempString++;
168
169         /* Copy the string to the field */
170         memcpy(cp, tempString, len);
171 }
172 #define PUT_OCTAL(a, b) putOctal((a), sizeof(a), (b))
173
174 static void chksum_and_xwrite(int fd, struct TarHeader* hp)
175 {
176         /* POSIX says that checksum is done on unsigned bytes
177          * (Sun and HP-UX fucked it up... more details in
178          * GNU tar source) */
179         const unsigned char *cp;
180         int chksum, size;
181
182         strcpy(hp->magic, "ustar  ");
183
184         /* Calculate and store the checksum (i.e., the sum of all of the bytes of
185          * the header).  The checksum field must be filled with blanks for the
186          * calculation.  The checksum field is formatted differently from the
187          * other fields: it has 6 digits, a null, then a space -- rather than
188          * digits, followed by a null like the other fields... */
189         memset(hp->chksum, ' ', sizeof(hp->chksum));
190         cp = (const unsigned char *) hp;
191         chksum = 0;
192         size = sizeof(*hp);
193         do { chksum += *cp++; } while (--size);
194         putOctal(hp->chksum, sizeof(hp->chksum)-1, chksum);
195
196         /* Now write the header out to disk */
197         xwrite(fd, hp, sizeof(*hp));
198 }
199
200 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
201 static void writeLongname(int fd, int type, const char *name, int dir)
202 {
203         static const struct {
204                 char mode[8];             /* 100-107 */
205                 char uid[8];              /* 108-115 */
206                 char gid[8];              /* 116-123 */
207                 char size[12];            /* 124-135 */
208                 char mtime[12];           /* 136-147 */
209         } prefilled = {
210                 "0000000",
211                 "0000000",
212                 "0000000",
213                 "00000000000",
214                 "00000000000",
215         };
216         struct TarHeader header;
217         int size;
218
219         dir = !!dir; /* normalize: 0/1 */
220         size = strlen(name) + 1 + dir; /* GNU tar uses strlen+1 */
221         /* + dir: account for possible '/' */
222
223         memset(&header, 0, sizeof(header));
224         strcpy(header.name, "././@LongLink");
225         memcpy(header.mode, prefilled.mode, sizeof(prefilled));
226         PUT_OCTAL(header.size, size);
227         header.typeflag = type;
228         chksum_and_xwrite(fd, &header);
229
230         /* Write filename[/] and pad the block. */
231         /* dir=0: writes 'name<NUL>', pads */
232         /* dir=1: writes 'name', writes '/<NUL>', pads */
233         dir *= 2;
234         xwrite(fd, name, size - dir);
235         xwrite(fd, "/", dir);
236         size = (-size) & (TAR_BLOCK_SIZE-1);
237         memset(&header, 0, size);
238         xwrite(fd, &header, size);
239 }
240 #endif
241
242 /* Write out a tar header for the specified file/directory/whatever */
243 void BUG_tar_header_size(void);
244 static int writeTarHeader(struct TarBallInfo *tbInfo,
245                 const char *header_name, const char *fileName, struct stat *statbuf)
246 {
247         struct TarHeader header;
248
249         if (sizeof(header) != 512)
250                 BUG_tar_header_size();
251
252         memset(&header, 0, sizeof(struct TarHeader));
253
254         strncpy(header.name, header_name, sizeof(header.name));
255
256         /* POSIX says to mask mode with 07777. */
257         PUT_OCTAL(header.mode, statbuf->st_mode & 07777);
258         PUT_OCTAL(header.uid, statbuf->st_uid);
259         PUT_OCTAL(header.gid, statbuf->st_gid);
260         memset(header.size, '0', sizeof(header.size)-1); /* Regular file size is handled later */
261         PUT_OCTAL(header.mtime, statbuf->st_mtime);
262
263         /* Enter the user and group names */
264         safe_strncpy(header.uname, get_cached_username(statbuf->st_uid), sizeof(header.uname));
265         safe_strncpy(header.gname, get_cached_groupname(statbuf->st_gid), sizeof(header.gname));
266
267         if (tbInfo->hlInfo) {
268                 /* This is a hard link */
269                 header.typeflag = LNKTYPE;
270                 strncpy(header.linkname, tbInfo->hlInfo->name,
271                                 sizeof(header.linkname));
272 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
273                 /* Write out long linkname if needed */
274                 if (header.linkname[sizeof(header.linkname)-1])
275                         writeLongname(tbInfo->tarFd, GNULONGLINK,
276                                         tbInfo->hlInfo->name, 0);
277 #endif
278         } else if (S_ISLNK(statbuf->st_mode)) {
279                 char *lpath = xmalloc_readlink_or_warn(fileName);
280                 if (!lpath)
281                         return FALSE;
282                 header.typeflag = SYMTYPE;
283                 strncpy(header.linkname, lpath, sizeof(header.linkname));
284 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
285                 /* Write out long linkname if needed */
286                 if (header.linkname[sizeof(header.linkname)-1])
287                         writeLongname(tbInfo->tarFd, GNULONGLINK, lpath, 0);
288 #else
289                 /* If it is larger than 100 bytes, bail out */
290                 if (header.linkname[sizeof(header.linkname)-1]) {
291                         free(lpath);
292                         bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
293                         return FALSE;
294                 }
295 #endif
296                 free(lpath);
297         } else if (S_ISDIR(statbuf->st_mode)) {
298                 header.typeflag = DIRTYPE;
299                 /* Append '/' only if there is a space for it */
300                 if (!header.name[sizeof(header.name)-1])
301                         header.name[strlen(header.name)] = '/';
302         } else if (S_ISCHR(statbuf->st_mode)) {
303                 header.typeflag = CHRTYPE;
304                 PUT_OCTAL(header.devmajor, major(statbuf->st_rdev));
305                 PUT_OCTAL(header.devminor, minor(statbuf->st_rdev));
306         } else if (S_ISBLK(statbuf->st_mode)) {
307                 header.typeflag = BLKTYPE;
308                 PUT_OCTAL(header.devmajor, major(statbuf->st_rdev));
309                 PUT_OCTAL(header.devminor, minor(statbuf->st_rdev));
310         } else if (S_ISFIFO(statbuf->st_mode)) {
311                 header.typeflag = FIFOTYPE;
312         } else if (S_ISREG(statbuf->st_mode)) {
313                 if (sizeof(statbuf->st_size) > 4
314                  && statbuf->st_size > (off_t)0777777777777LL
315                 ) {
316                         bb_error_msg_and_die("cannot store file '%s' "
317                                 "of size %"OFF_FMT"d, aborting",
318                                 fileName, statbuf->st_size);
319                 }
320                 header.typeflag = REGTYPE;
321                 PUT_OCTAL(header.size, statbuf->st_size);
322         } else {
323                 bb_error_msg("%s: unknown file type", fileName);
324                 return FALSE;
325         }
326
327 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
328         /* Write out long name if needed */
329         /* (we, like GNU tar, output long linkname *before* long name) */
330         if (header.name[sizeof(header.name)-1])
331                 writeLongname(tbInfo->tarFd, GNULONGNAME,
332                                 header_name, S_ISDIR(statbuf->st_mode));
333 #endif
334
335         /* Now write the header out to disk */
336         chksum_and_xwrite(tbInfo->tarFd, &header);
337
338         /* Now do the verbose thing (or not) */
339         if (tbInfo->verboseFlag) {
340                 FILE *vbFd = stdout;
341
342                 if (tbInfo->tarFd == STDOUT_FILENO)     /* If the archive goes to stdout, verbose to stderr */
343                         vbFd = stderr;
344                 /* GNU "tar cvvf" prints "extended" listing a-la "ls -l" */
345                 /* We don't have such excesses here: for us "v" == "vv" */
346                 /* '/' is probably a GNUism */
347                 fprintf(vbFd, "%s%s\n", header_name,
348                                 S_ISDIR(statbuf->st_mode) ? "/" : "");
349         }
350
351         return TRUE;
352 }
353
354 #if ENABLE_FEATURE_TAR_FROM
355 static int exclude_file(const llist_t *excluded_files, const char *file)
356 {
357         while (excluded_files) {
358                 if (excluded_files->data[0] == '/') {
359                         if (fnmatch(excluded_files->data, file,
360                                                 FNM_PATHNAME | FNM_LEADING_DIR) == 0)
361                                 return 1;
362                 } else {
363                         const char *p;
364
365                         for (p = file; p[0] != '\0'; p++) {
366                                 if ((p == file || p[-1] == '/') && p[0] != '/' &&
367                                         fnmatch(excluded_files->data, p,
368                                                         FNM_PATHNAME | FNM_LEADING_DIR) == 0)
369                                         return 1;
370                         }
371                 }
372                 excluded_files = excluded_files->link;
373         }
374
375         return 0;
376 }
377 #else
378 #define exclude_file(excluded_files, file) 0
379 #endif
380
381 static int writeFileToTarball(const char *fileName, struct stat *statbuf,
382                         void *userData, int depth ATTRIBUTE_UNUSED)
383 {
384         struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData;
385         const char *header_name;
386         int inputFileFd = -1;
387
388         /*
389          * Check to see if we are dealing with a hard link.
390          * If so -
391          * Treat the first occurance of a given dev/inode as a file while
392          * treating any additional occurances as hard links.  This is done
393          * by adding the file information to the HardLinkInfo linked list.
394          */
395         tbInfo->hlInfo = NULL;
396         if (statbuf->st_nlink > 1) {
397                 tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf);
398                 if (tbInfo->hlInfo == NULL)
399                         addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, fileName);
400         }
401
402         /* It is against the rules to archive a socket */
403         if (S_ISSOCK(statbuf->st_mode)) {
404                 bb_error_msg("%s: socket ignored", fileName);
405                 return TRUE;
406         }
407
408         /* It is a bad idea to store the archive we are in the process of creating,
409          * so check the device and inode to be sure that this particular file isn't
410          * the new tarball */
411         if (tbInfo->statBuf.st_dev == statbuf->st_dev &&
412                 tbInfo->statBuf.st_ino == statbuf->st_ino) {
413                 bb_error_msg("%s: file is the archive; skipping", fileName);
414                 return TRUE;
415         }
416
417         header_name = fileName;
418         while (header_name[0] == '/') {
419                 static int alreadyWarned = FALSE;
420
421                 if (alreadyWarned == FALSE) {
422                         bb_error_msg("removing leading '/' from member names");
423                         alreadyWarned = TRUE;
424                 }
425                 header_name++;
426         }
427
428 #if !ENABLE_FEATURE_TAR_GNU_EXTENSIONS
429         if (strlen(fileName) >= NAME_SIZE) {
430                 bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
431                 return TRUE;
432         }
433 #endif
434
435         if (header_name[0] == '\0')
436                 return TRUE;
437
438         if (exclude_file(tbInfo->excludeList, header_name))
439                 return SKIP;
440
441         /* Is this a regular file? */
442         if (tbInfo->hlInfo == NULL && S_ISREG(statbuf->st_mode)) {
443                 /* open the file we want to archive, and make sure all is well */
444                 inputFileFd = open(fileName, O_RDONLY);
445                 if (inputFileFd < 0) {
446                         bb_perror_msg("%s: cannot open", fileName);
447                         return FALSE;
448                 }
449         }
450
451         /* Add an entry to the tarball */
452         if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) {
453                 return FALSE;
454         }
455
456         /* If it was a regular file, write out the body */
457         if (inputFileFd >= 0) {
458                 size_t readSize;
459                 /* Wwrite the file to the archive. */
460                 /* We record size into header first, */
461                 /* and then write out file. If file shrinks in between, */
462                 /* tar will be corrupted. So we don't allow for that. */
463                 /* NB: GNU tar 1.16 warns and pads with zeroes */
464                 /* or even seeks back and updates header */
465                 bb_copyfd_exact_size(inputFileFd, tbInfo->tarFd, statbuf->st_size);
466                 ////off_t readSize;
467                 ////readSize = bb_copyfd_size(inputFileFd, tbInfo->tarFd, statbuf->st_size);
468                 ////if (readSize != statbuf->st_size && readSize >= 0) {
469                 ////    bb_error_msg_and_die("short read from %s, aborting", fileName);
470                 ////}
471
472                 /* Check that file did not grow in between? */
473                 /* if (safe_read(inputFileFd, 1) == 1) warn but continue? */
474
475                 close(inputFileFd);
476
477                 /* Pad the file up to the tar block size */
478                 /* (a few tricks here in the name of code size) */
479                 readSize = (-(int)statbuf->st_size) & (TAR_BLOCK_SIZE-1);
480                 memset(bb_common_bufsiz1, 0, readSize);
481                 xwrite(tbInfo->tarFd, bb_common_bufsiz1, readSize);
482         }
483
484         return TRUE;
485 }
486
487 static int writeTarFile(const int tar_fd, const int verboseFlag,
488         const unsigned long dereferenceFlag, const llist_t *include,
489         const llist_t *exclude, const int gzip)
490 {
491         pid_t gzipPid = 0;
492         int errorFlag = FALSE;
493         struct TarBallInfo tbInfo;
494
495         tbInfo.hlInfoHead = NULL;
496
497         fchmod(tar_fd, 0644);
498         tbInfo.tarFd = tar_fd;
499         tbInfo.verboseFlag = verboseFlag;
500
501         /* Store the stat info for the tarball's file, so
502          * can avoid including the tarball into itself....  */
503         if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
504                 bb_perror_msg_and_die("cannot stat tar file");
505
506         if ((ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2) && gzip) {
507                 int gzipDataPipe[2] = { -1, -1 };
508                 int gzipStatusPipe[2] = { -1, -1 };
509                 volatile int vfork_exec_errno = 0;
510                 const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
511
512                 if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0)
513                         bb_perror_msg_and_die("pipe");
514
515                 signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
516
517 #if defined(__GNUC__) && __GNUC__
518                 /* Avoid vfork clobbering */
519                 (void) &include;
520                 (void) &errorFlag;
521                 (void) &zip_exec;
522 #endif
523
524                 gzipPid = vfork();
525
526                 if (gzipPid == 0) {
527                         dup2(gzipDataPipe[0], 0);
528                         close(gzipDataPipe[1]);
529
530                         dup2(tbInfo.tarFd, 1);
531
532                         close(gzipStatusPipe[0]);
533                         fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC);  /* close on exec shows success */
534
535                         BB_EXECLP(zip_exec, zip_exec, "-f", NULL);
536                         vfork_exec_errno = errno;
537
538                         close(gzipStatusPipe[1]);
539                         exit(-1);
540                 } else if (gzipPid > 0) {
541                         close(gzipDataPipe[0]);
542                         close(gzipStatusPipe[1]);
543
544                         while (1) {
545                                 char buf;
546
547                                 int n = full_read(gzipStatusPipe[0], &buf, 1);
548
549                                 if (n == 0 && vfork_exec_errno != 0) {
550                                         errno = vfork_exec_errno;
551                                         bb_perror_msg_and_die("cannot exec %s", zip_exec);
552                                 } else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
553                                         continue;       /* try it again */
554                                 break;
555                         }
556                         close(gzipStatusPipe[0]);
557
558                         tbInfo.tarFd = gzipDataPipe[1];
559                 } else bb_perror_msg_and_die("vfork gzip");
560         }
561
562         tbInfo.excludeList = exclude;
563
564         /* Read the directory/files and iterate over them one at a time */
565         while (include) {
566                 if (!recursive_action(include->data, TRUE, dereferenceFlag,
567                                 FALSE, writeFileToTarball, writeFileToTarball, &tbInfo, 0))
568                 {
569                         errorFlag = TRUE;
570                 }
571                 include = include->link;
572         }
573         /* Write two empty blocks to the end of the archive */
574         memset(bb_common_bufsiz1, 0, 2*TAR_BLOCK_SIZE);
575         xwrite(tbInfo.tarFd, bb_common_bufsiz1, 2*TAR_BLOCK_SIZE);
576
577         /* To be pedantically correct, we would check if the tarball
578          * is smaller than 20 tar blocks, and pad it if it was smaller,
579          * but that isn't necessary for GNU tar interoperability, and
580          * so is considered a waste of space */
581
582         /* Close so the child process (if any) will exit */
583         close(tbInfo.tarFd);
584
585         /* Hang up the tools, close up shop, head home */
586         if (ENABLE_FEATURE_CLEAN_UP)
587                 freeHardLinkInfo(&tbInfo.hlInfoHead);
588
589         if (errorFlag)
590                 bb_error_msg("error exit delayed from previous errors");
591
592         if (gzipPid) {
593                 int status;
594                 if (waitpid(gzipPid, &status, 0) == -1)
595                         bb_perror_msg("waitpid");
596                 else if (!WIFEXITED(status) || WEXITSTATUS(status))
597                         /* gzip was killed or has exited with nonzero! */
598                         errorFlag = TRUE;
599         }
600         return errorFlag;
601 }
602 #else
603 int writeTarFile(const int tar_fd, const int verboseFlag,
604         const unsigned long dereferenceFlag, const llist_t *include,
605         const llist_t *exclude, const int gzip);
606 #endif /* FEATURE_TAR_CREATE */
607
608 #if ENABLE_FEATURE_TAR_FROM
609 static llist_t *append_file_list_to_list(llist_t *list)
610 {
611         FILE *src_stream;
612         llist_t *cur = list;
613         llist_t *tmp;
614         char *line;
615         llist_t *newlist = NULL;
616
617         while (cur) {
618                 src_stream = xfopen(cur->data, "r");
619                 tmp = cur;
620                 cur = cur->link;
621                 free(tmp);
622                 while ((line = xmalloc_getline(src_stream)) != NULL) {
623                         /* kill trailing '/' unless the string is just "/" */
624                         char *cp = last_char_is(line, '/');
625                         if (cp > line)
626                                 *cp = '\0';
627                         llist_add_to(&newlist, line);
628                 }
629                 fclose(src_stream);
630         }
631         return newlist;
632 }
633 #else
634 #define append_file_list_to_list(x) 0
635 #endif
636
637 #if ENABLE_FEATURE_TAR_COMPRESS
638 static char get_header_tar_Z(archive_handle_t *archive_handle)
639 {
640         /* Can't lseek over pipes */
641         archive_handle->seek = seek_by_read;
642
643         /* do the decompression, and cleanup */
644         if (xread_char(archive_handle->src_fd) != 0x1f
645          || xread_char(archive_handle->src_fd) != 0x9d
646         ) {
647                 bb_error_msg_and_die("invalid magic");
648         }
649
650         archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress);
651         archive_handle->offset = 0;
652         while (get_header_tar(archive_handle) == EXIT_SUCCESS)
653                 /* nothing */;
654
655         /* Can only do one file at a time */
656         return EXIT_FAILURE;
657 }
658 #else
659 #define get_header_tar_Z NULL
660 #endif
661
662 #ifdef CHECK_FOR_CHILD_EXITCODE
663 /* Looks like it isn't needed - tar detects malformed (truncated)
664  * archive if e.g. bunzip2 fails */
665 static int child_error;
666
667 static void handle_SIGCHLD(int status)
668 {
669         /* Actually, 'status' is a signo. We reuse it for other needs */
670
671         /* Wait for any child without blocking */
672         if (waitpid(-1, &status, WNOHANG) < 0)
673                 /* wait failed?! I'm confused... */
674                 return;
675
676         if (WIFEXITED(status) && WEXITSTATUS(status)==0)
677                 /* child exited with 0 */
678                 return;
679         /* Cannot happen?
680         if(!WIFSIGNALED(status) && !WIFEXITED(status)) return; */
681         child_error = 1;
682 }
683 #endif
684
685 enum {
686         OPTBIT_KEEP_OLD = 7,
687         USE_FEATURE_TAR_CREATE(  OPTBIT_CREATE      ,)
688         USE_FEATURE_TAR_CREATE(  OPTBIT_DEREFERENCE ,)
689         USE_FEATURE_TAR_BZIP2(   OPTBIT_BZIP2       ,)
690         USE_FEATURE_TAR_LZMA(    OPTBIT_LZMA        ,)
691         USE_FEATURE_TAR_FROM(    OPTBIT_INCLUDE_FROM,)
692         USE_FEATURE_TAR_FROM(    OPTBIT_EXCLUDE_FROM,)
693         USE_FEATURE_TAR_GZIP(    OPTBIT_GZIP        ,)
694         USE_FEATURE_TAR_COMPRESS(OPTBIT_COMPRESS    ,)
695         OPTBIT_NOPRESERVE_OWN,
696         OPTBIT_NOPRESERVE_PERM,
697         OPT_TEST         = 1 << 0, // t
698         OPT_EXTRACT      = 1 << 1, // x
699         OPT_BASEDIR      = 1 << 2, // C
700         OPT_TARNAME      = 1 << 3, // f
701         OPT_2STDOUT      = 1 << 4, // O
702         OPT_P            = 1 << 5, // p
703         OPT_VERBOSE      = 1 << 6, // v
704         OPT_KEEP_OLD     = 1 << 7, // k
705         OPT_CREATE       = USE_FEATURE_TAR_CREATE(  (1<<OPTBIT_CREATE      )) + 0, // c
706         OPT_DEREFERENCE  = USE_FEATURE_TAR_CREATE(  (1<<OPTBIT_DEREFERENCE )) + 0, // h
707         OPT_BZIP2        = USE_FEATURE_TAR_BZIP2(   (1<<OPTBIT_BZIP2       )) + 0, // j
708         OPT_LZMA         = USE_FEATURE_TAR_LZMA(    (1<<OPTBIT_LZMA        )) + 0, // a
709         OPT_INCLUDE_FROM = USE_FEATURE_TAR_FROM(    (1<<OPTBIT_INCLUDE_FROM)) + 0, // T
710         OPT_EXCLUDE_FROM = USE_FEATURE_TAR_FROM(    (1<<OPTBIT_EXCLUDE_FROM)) + 0, // X
711         OPT_GZIP         = USE_FEATURE_TAR_GZIP(    (1<<OPTBIT_GZIP        )) + 0, // z
712         OPT_COMPRESS     = USE_FEATURE_TAR_COMPRESS((1<<OPTBIT_COMPRESS    )) + 0, // Z
713         OPT_NOPRESERVE_OWN  = 1 << OPTBIT_NOPRESERVE_OWN , // no-same-owner
714         OPT_NOPRESERVE_PERM = 1 << OPTBIT_NOPRESERVE_PERM, // no-same-permissions
715 };
716 #if ENABLE_FEATURE_TAR_LONG_OPTIONS
717 static const struct option tar_long_options[] = {
718         { "list",               0,  NULL,   't' },
719         { "extract",            0,  NULL,   'x' },
720         { "directory",          1,  NULL,   'C' },
721         { "file",               1,  NULL,   'f' },
722         { "to-stdout",          0,  NULL,   'O' },
723         { "same-permissions",   0,  NULL,   'p' },
724         { "verbose",            0,  NULL,   'v' },
725         { "keep-old",           0,  NULL,   'k' },
726 # if ENABLE_FEATURE_TAR_CREATE
727         { "create",             0,  NULL,   'c' },
728         { "dereference",        0,  NULL,   'h' },
729 # endif
730 # if ENABLE_FEATURE_TAR_BZIP2
731         { "bzip2",              0,  NULL,   'j' },
732 # endif
733 # if ENABLE_FEATURE_TAR_LZMA
734         { "lzma",               0,  NULL,   'a' },
735 # endif
736 # if ENABLE_FEATURE_TAR_FROM
737         { "files-from",         1,  NULL,   'T' },
738         { "exclude-from",       1,  NULL,   'X' },
739 # endif
740 # if ENABLE_FEATURE_TAR_GZIP
741         { "gzip",               0,  NULL,   'z' },
742 # endif
743 # if ENABLE_FEATURE_TAR_COMPRESS
744         { "compress",           0,  NULL,   'Z' },
745 # endif
746         { "no-same-owner",      0,  NULL,   0xfd },
747         { "no-same-permissions",0,  NULL,   0xfe },
748         /* --exclude takes next bit position in option mask, */
749         /* therefore we have to either put it _after_ --no-same-perm */
750         /* or add OPT[BIT]_EXCLUDE before OPT[BIT]_NOPRESERVE_OWN */
751 # if ENABLE_FEATURE_TAR_FROM
752         { "exclude",            1,  NULL,   0xff },
753 # endif
754         { 0,                    0, 0, 0 }
755 };
756 #endif
757
758 int tar_main(int argc, char **argv);
759 int tar_main(int argc, char **argv)
760 {
761         char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
762         archive_handle_t *tar_handle;
763         char *base_dir = NULL;
764         const char *tar_filename = "-";
765         unsigned opt;
766         int verboseFlag = 0;
767 #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM
768         llist_t *excludes = NULL;
769 #endif
770
771         /* Initialise default values */
772         tar_handle = init_handle();
773         tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS
774                           | ARCHIVE_PRESERVE_DATE
775                           | ARCHIVE_EXTRACT_UNCONDITIONAL;
776
777         /* Prepend '-' to the first argument if required */
778         opt_complementary = "--:" // first arg is options
779                 "tt:vv:" // count -t,-v
780                 "?:" // bail out with usage instead of error return
781                 "X::T::" // cumulative lists
782 #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM
783                 "\xff::" // cumulative lists for --exclude
784 #endif
785                 USE_FEATURE_TAR_CREATE("c:") "t:x:" // at least one of these is reqd
786                 USE_FEATURE_TAR_CREATE("c--tx:t--cx:x--ct") // mutually exclusive
787                 SKIP_FEATURE_TAR_CREATE("t--x:x--t"); // mutually exclusive
788 #if ENABLE_FEATURE_TAR_LONG_OPTIONS
789         applet_long_options = tar_long_options;
790 #endif
791         opt = getopt32(argc, argv,
792                 "txC:f:Opvk"
793                 USE_FEATURE_TAR_CREATE(  "ch"  )
794                 USE_FEATURE_TAR_BZIP2(   "j"   )
795                 USE_FEATURE_TAR_LZMA(    "a"   )
796                 USE_FEATURE_TAR_FROM(    "T:X:")
797                 USE_FEATURE_TAR_GZIP(    "z"   )
798                 USE_FEATURE_TAR_COMPRESS("Z"   )
799                 , &base_dir // -C dir
800                 , &tar_filename // -f filename
801                 USE_FEATURE_TAR_FROM(, &(tar_handle->accept)) // T
802                 USE_FEATURE_TAR_FROM(, &(tar_handle->reject)) // X
803 #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM
804                 , &excludes // --exclude
805 #endif
806                 , &verboseFlag // combined count for -t and -v
807                 , &verboseFlag // combined count for -t and -v
808                 );
809
810         if (verboseFlag) tar_handle->action_header = header_verbose_list;
811         if (verboseFlag == 1) tar_handle->action_header = header_list;
812
813         if (opt & OPT_EXTRACT)
814                 tar_handle->action_data = data_extract_all;
815
816         if (opt & OPT_2STDOUT)
817                 tar_handle->action_data = data_extract_to_stdout;
818
819         if (opt & OPT_KEEP_OLD)
820                 tar_handle->flags &= ~ARCHIVE_EXTRACT_UNCONDITIONAL;
821
822         if (opt & OPT_NOPRESERVE_OWN)
823                 tar_handle->flags |= ARCHIVE_NOPRESERVE_OWN;
824
825         if (opt & OPT_NOPRESERVE_PERM)
826                 tar_handle->flags |= ARCHIVE_NOPRESERVE_PERM;
827
828         if (opt & OPT_GZIP)
829                 get_header_ptr = get_header_tar_gz;
830
831         if (opt & OPT_BZIP2)
832                 get_header_ptr = get_header_tar_bz2;
833
834         if (opt & OPT_LZMA)
835                 get_header_ptr = get_header_tar_lzma;
836
837         if (opt & OPT_COMPRESS)
838                 get_header_ptr = get_header_tar_Z;
839
840 #if ENABLE_FEATURE_TAR_FROM
841         tar_handle->reject = append_file_list_to_list(tar_handle->reject);
842 #if ENABLE_FEATURE_TAR_LONG_OPTIONS
843         /* Append excludes to reject */
844         while (excludes) {
845                 llist_t *next = excludes->link;
846                 excludes->link = tar_handle->reject;
847                 tar_handle->reject = excludes;
848                 excludes = next;
849         }
850 #endif
851         tar_handle->accept = append_file_list_to_list(tar_handle->accept);
852 #endif
853
854         /* Check if we are reading from stdin */
855         if (argv[optind] && *argv[optind] == '-') {
856                 /* Default is to read from stdin, so just skip to next arg */
857                 optind++;
858         }
859
860         /* Setup an array of filenames to work with */
861         /* TODO: This is the same as in ar, separate function ? */
862         while (optind < argc) {
863                 /* kill trailing '/' unless the string is just "/" */
864                 char *cp = last_char_is(argv[optind], '/');
865                 if (cp > argv[optind])
866                         *cp = '\0';
867                 llist_add_to(&tar_handle->accept, argv[optind]);
868                 optind++;
869         }
870         tar_handle->accept = llist_rev(tar_handle->accept);
871
872         if (tar_handle->accept || tar_handle->reject)
873                 tar_handle->filter = filter_accept_reject_list;
874
875         /* Open the tar file */
876         {
877                 FILE *tar_stream;
878                 int flags;
879
880                 if (opt & OPT_CREATE) {
881                         /* Make sure there is at least one file to tar up.  */
882                         if (tar_handle->accept == NULL)
883                                 bb_error_msg_and_die("empty archive");
884
885                         tar_stream = stdout;
886                         /* Mimicking GNU tar 1.15.1: */
887                         flags = O_WRONLY|O_CREAT|O_TRUNC;
888                 /* was doing unlink; open(O_WRONLY|O_CREAT|O_EXCL); why? */
889                 } else {
890                         tar_stream = stdin;
891                         flags = O_RDONLY;
892                 }
893
894                 if (LONE_DASH(tar_filename)) {
895                         tar_handle->src_fd = fileno(tar_stream);
896                         tar_handle->seek = seek_by_read;
897                 } else {
898                         tar_handle->src_fd = xopen(tar_filename, flags);
899                 }
900         }
901
902         if (base_dir)
903                 xchdir(base_dir);
904
905 #ifdef CHECK_FOR_CHILD_EXITCODE
906         /* We need to know whether child (gzip/bzip/etc) exits abnormally */
907         signal(SIGCHLD, handle_SIGCHLD);
908 #endif
909
910         /* create an archive */
911         if (opt & OPT_CREATE) {
912                 int zipMode = 0;
913                 if (ENABLE_FEATURE_TAR_GZIP && get_header_ptr == get_header_tar_gz)
914                         zipMode = 1;
915                 if (ENABLE_FEATURE_TAR_BZIP2 && get_header_ptr == get_header_tar_bz2)
916                         zipMode = 2;
917                 /* NB: writeTarFile() closes tar_handle->src_fd */
918                 return writeTarFile(tar_handle->src_fd, verboseFlag, opt & OPT_DEREFERENCE,
919                                 tar_handle->accept,
920                                 tar_handle->reject, zipMode);
921         }
922
923         while (get_header_ptr(tar_handle) == EXIT_SUCCESS)
924                 /* nothing */;
925
926         /* Check that every file that should have been extracted was */
927         while (tar_handle->accept) {
928                 if (!find_list_entry(tar_handle->reject, tar_handle->accept->data)
929                  && !find_list_entry(tar_handle->passed, tar_handle->accept->data)
930                 ) {
931                         bb_error_msg_and_die("%s: not found in archive",
932                                 tar_handle->accept->data);
933                 }
934                 tar_handle->accept = tar_handle->accept->link;
935         }
936         if (ENABLE_FEATURE_CLEAN_UP /* && tar_handle->src_fd != STDIN_FILENO */)
937                 close(tar_handle->src_fd);
938
939         return EXIT_SUCCESS;
940 }