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