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