+/* vi: set sw=4 ts=4: */
/*
- * Copyright (c) 1999 by David I. Bell
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
+ * Mini tar implementation for busybox
*
- * The "tar" command, taken from sash.
- * This allows creation, extraction, and listing of tar files.
+ * Modifed to use common extraction code used by ar, cpio, dpkg-deb, dpkg
+ * Glenn McGrath <bug1@optushome.com.au>
+ *
+ * Note, that as of BusyBox-0.43, tar has been completely rewritten from the
+ * ground up. It still has remnents of the old code lying about, but it is
+ * very different now (i.e., cleaner, less global variables, etc.)
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * Based in part in the tar implementation in sash
+ * Copyright (c) 1999 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ * Permission to distribute sash derived code under the GPL has been granted.
+ *
+ * Based in part on the tar implementation from busybox-0.28
+ * Copyright (C) 1995 Bruce Perens
+ * This is free software under the GNU General Public License.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
- * Permission to distribute this code under the GPL has been granted.
- * Modified for busybox by Erik Andersen <andersee@debian.org>
*/
-
-#include "internal.h"
-
-#ifdef BB_TAR
-
-const char tar_usage[] =
- "Create, extract, or list files from a TAR file\n\n"
- "usage: tar -[cxtvOf] [tarFileName] [FILE] ...\n"
- "\tc=create, x=extract, t=list contents, v=verbose,\n"
- "\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
-
-
-
+#include <fcntl.h>
+#include <getopt.h>
+#include <search.h>
#include <stdio.h>
-#include <dirent.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fnmatch.h>
+#include <string.h>
#include <errno.h>
-#include <fcntl.h>
#include <signal.h>
-#include <time.h>
-
-/*
- * Tar file constants.
- */
-#define TAR_BLOCK_SIZE 512
-#define TAR_NAME_SIZE 100
-
-
-/*
- * The POSIX (and basic GNU) tar header format.
- * This structure is always embedded in a TAR_BLOCK_SIZE sized block
- * with zero padding. We only process this information minimally.
- */
-typedef struct {
- char name[TAR_NAME_SIZE];
- char mode[8];
- char uid[8];
- char gid[8];
- char size[12];
- char mtime[12];
- char checkSum[8];
- char typeFlag;
- char linkName[TAR_NAME_SIZE];
- char magic[6];
- char version[2];
- char uname[32];
- char gname[32];
- char devMajor[8];
- char devMinor[8];
- char prefix[155];
-} TarHeader;
-
-#define TAR_MAGIC "ustar"
-#define TAR_VERSION "00"
-
-#define TAR_TYPE_REGULAR '0'
-#define TAR_TYPE_HARD_LINK '1'
-#define TAR_TYPE_SOFT_LINK '2'
-
-
-/*
- * Static data.
- */
-static int listFlag;
-static int extractFlag;
-static int createFlag;
-static int verboseFlag;
-static int tostdoutFlag;
-
-static int inHeader;
-static int badHeader;
-static int errorFlag;
-static int skipFileFlag;
-static int warnedRoot;
-static int eofFlag;
-static long dataCc;
-static int outFd;
-static char outName[TAR_NAME_SIZE];
-
-
-/*
- * Static data associated with the tar file.
- */
-static const char *tarName;
-static int tarFd;
-static dev_t tarDev;
-static ino_t tarInode;
-
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include "unarchive.h"
+#include "busybox.h"
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+
+/* Tar file constants */
+# define TAR_MAGIC "ustar" /* ustar and a null */
+# define TAR_VERSION " " /* Be compatable with GNU tar format */
+
+# ifndef MAJOR
+# define MAJOR(dev) (((dev)>>8)&0xff)
+# define MINOR(dev) ((dev)&0xff)
+# endif
+
+static const int TAR_BLOCK_SIZE = 512;
+static const int TAR_MAGIC_LEN = 6;
+static const int TAR_VERSION_LEN = 2;
+
+/* POSIX tar Header Block, from POSIX 1003.1-1990 */
+enum { NAME_SIZE = 100 }; /* because gcc won't let me use 'static const int' */
+struct TarHeader { /* byte offset */
+ char name[NAME_SIZE]; /* 0-99 */
+ char mode[8]; /* 100-107 */
+ char uid[8]; /* 108-115 */
+ char gid[8]; /* 116-123 */
+ char size[12]; /* 124-135 */
+ char mtime[12]; /* 136-147 */
+ char chksum[8]; /* 148-155 */
+ char typeflag; /* 156-156 */
+ char linkname[NAME_SIZE]; /* 157-256 */
+ char magic[6]; /* 257-262 */
+ char version[2]; /* 263-264 */
+ char uname[32]; /* 265-296 */
+ char gname[32]; /* 297-328 */
+ char devmajor[8]; /* 329-336 */
+ char devminor[8]; /* 337-344 */
+ char prefix[155]; /* 345-499 */
+ char padding[12]; /* 500-512 (pad to exactly the TAR_BLOCK_SIZE) */
+};
+typedef struct TarHeader TarHeader;
/*
- * Local procedures to restore files from a tar file.
- */
-static void readTarFile (int fileCount, char **fileTable);
-static void readData (const char *cp, int count);
-static void createPath (const char *name, int mode);
-static long getOctal (const char *cp, int len);
-
-static void readHeader (const TarHeader * hp,
- int fileCount, char **fileTable);
-
-
-/*
- * Local procedures to save files into a tar file.
- */
-static void saveFile (const char *fileName, int seeLinks);
-
-static void saveRegularFile (const char *fileName,
- const struct stat *statbuf);
-
-static void saveDirectory (const char *fileName,
- const struct stat *statbuf);
-
-static int wantFileName (const char *fileName,
- int fileCount, char **fileTable);
-
-static void writeHeader (const char *fileName, const struct stat *statbuf);
-
-static void writeTarFile (int fileCount, char **fileTable);
-static void writeTarBlock (const char *buf, int len);
-static int putOctal (char *cp, int len, long value);
-
+** writeTarFile(), writeFileToTarball(), and writeTarHeader() are
+** the only functions that deal with the HardLinkInfo structure.
+** Even these functions use the xxxHardLinkInfo() functions.
+*/
+typedef struct HardLinkInfo HardLinkInfo;
+struct HardLinkInfo {
+ HardLinkInfo *next; /* Next entry in list */
+ dev_t dev; /* Device number */
+ ino_t ino; /* Inode number */
+ short linkCount; /* (Hard) Link Count */
+ char name[1]; /* Start of filename (must be last) */
+};
+
+/* Some info to be carried along when creating a new tarball */
+struct TarBallInfo {
+ char *fileName; /* File name of the tarball */
+ int tarFd; /* Open-for-write file descriptor
+ for the tarball */
+ struct stat statBuf; /* Stat info for the tarball, letting
+ us know the inode and device that the
+ tarball lives, so we can avoid trying
+ to include the tarball into itself */
+ int verboseFlag; /* Whether to print extra stuff or not */
+ const llist_t *excludeList; /* List of files to not include */
+ HardLinkInfo *hlInfoHead; /* Hard Link Tracking Information */
+ HardLinkInfo *hlInfo; /* Hard Link Info for the current file */
+};
+typedef struct TarBallInfo TarBallInfo;
+
+/* A nice enum with all the possible tar file content types */
+enum TarFileType {
+ REGTYPE = '0', /* regular file */
+ REGTYPE0 = '\0', /* regular file (ancient bug compat) */
+ LNKTYPE = '1', /* hard link */
+ SYMTYPE = '2', /* symbolic link */
+ CHRTYPE = '3', /* character special */
+ BLKTYPE = '4', /* block special */
+ DIRTYPE = '5', /* directory */
+ FIFOTYPE = '6', /* FIFO special */
+ CONTTYPE = '7', /* reserved */
+ GNULONGLINK = 'K', /* GNU long (>100 chars) link name */
+ GNULONGNAME = 'L', /* GNU long (>100 chars) file name */
+};
+typedef enum TarFileType TarFileType;
+
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
+static inline void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr,
+ struct stat *statbuf,
+ const char *name)
+{
+ /* Note: hlInfoHeadPtr can never be NULL! */
+ HardLinkInfo *hlInfo;
+
+ hlInfo = (HardLinkInfo *) xmalloc(sizeof(HardLinkInfo) + strlen(name));
+ hlInfo->next = *hlInfoHeadPtr;
+ *hlInfoHeadPtr = hlInfo;
+ hlInfo->dev = statbuf->st_dev;
+ hlInfo->ino = statbuf->st_ino;
+ hlInfo->linkCount = statbuf->st_nlink;
+ strcpy(hlInfo->name, name);
+}
-extern int tar_main (int argc, char **argv)
+static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
{
- const char *options;
-
- argc--;
- argv++;
-
- if (argc < 1) {
- fprintf (stderr, "%s", tar_usage);
- exit (FALSE);
- }
-
-
- errorFlag = FALSE;
- extractFlag = FALSE;
- createFlag = FALSE;
- listFlag = FALSE;
- verboseFlag = FALSE;
- tostdoutFlag = FALSE;
- tarName = NULL;
- tarDev = 0;
- tarInode = 0;
- tarFd = -1;
-
- /*
- * Parse the options.
- */
- options = *argv++;
- argc--;
-
- if (**argv == '-') {
- for (; *options; options++) {
- switch (*options) {
- case 'f':
- if (tarName != NULL) {
- fprintf (stderr, "Only one 'f' option allowed\n");
-
- exit (FALSE);
+ HardLinkInfo *hlInfo = NULL;
+ HardLinkInfo *hlInfoNext = NULL;
+
+ if (hlInfoHeadPtr) {
+ hlInfo = *hlInfoHeadPtr;
+ while (hlInfo) {
+ hlInfoNext = hlInfo->next;
+ free(hlInfo);
+ hlInfo = hlInfoNext;
}
-
- tarName = *argv++;
- argc--;
-
- break;
-
- case 't':
- listFlag = TRUE;
- break;
-
- case 'x':
- extractFlag = TRUE;
- break;
-
- case 'c':
- createFlag = TRUE;
- break;
-
- case 'v':
- verboseFlag = TRUE;
- break;
-
- case 'O':
- tostdoutFlag = TRUE;
- break;
-
- case '-':
- break;
-
- default:
- fprintf (stderr, "Unknown tar flag '%c'\n", *options);
-
- exit (FALSE);
- }
+ *hlInfoHeadPtr = NULL;
}
- }
-
- /*
- * Validate the options.
- */
- if (extractFlag + listFlag + createFlag != 1) {
- fprintf (stderr,
- "Exactly one of 'c', 'x' or 't' must be specified\n");
-
- exit (FALSE);
- }
-
- /*
- * Do the correct type of action supplying the rest of the
- * command line arguments as the list of files to process.
- */
- if (createFlag)
- writeTarFile (argc, argv);
- else
- readTarFile (argc, argv);
- if (errorFlag)
- fprintf (stderr, "\n");
- exit (errorFlag);
+ return;
}
-
-/*
- * Read a tar file and extract or list the specified files within it.
- * If the list is empty than all files are extracted or listed.
- */
-static void readTarFile (int fileCount, char **fileTable)
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
+static inline HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
{
- const char *cp;
- int cc;
- int inCc;
- int blockSize;
- char buf[BUF_SIZE];
-
- skipFileFlag = FALSE;
- badHeader = FALSE;
- warnedRoot = FALSE;
- eofFlag = FALSE;
- inHeader = TRUE;
- inCc = 0;
- dataCc = 0;
- outFd = -1;
- blockSize = sizeof (buf);
- cp = buf;
-
- /*
- * Open the tar file for reading.
- */
- if ((tarName == NULL) || !strcmp (tarName, "-")) {
- tarFd = STDIN;
- } else
- tarFd = open (tarName, O_RDONLY);
-
- if (tarFd < 0) {
- perror (tarName);
- errorFlag = TRUE;
- return;
- }
-
- /*
- * Read blocks from the file until an end of file header block
- * has been seen. (A real end of file from a read is an error.)
- */
- while (!eofFlag) {
- /*
- * Read the next block of data if necessary.
- * This will be a large block if possible, which we will
- * then process in the small tar blocks.
- */
- if (inCc <= 0) {
- cp = buf;
- inCc = fullRead (tarFd, buf, blockSize);
-
- if (inCc < 0) {
- perror (tarName);
- errorFlag = TRUE;
- goto done;
- }
-
- if (inCc == 0) {
- fprintf (stderr,
- "Unexpected end of file from \"%s\"", tarName);
- errorFlag = TRUE;
- goto done;
- }
+ while (hlInfo) {
+ if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
+ break;
+ hlInfo = hlInfo->next;
}
-
- /*
- * If we are expecting a header block then examine it.
- */
- if (inHeader) {
- readHeader ((const TarHeader *) cp, fileCount, fileTable);
-
- cp += TAR_BLOCK_SIZE;
- inCc -= TAR_BLOCK_SIZE;
-
- continue;
- }
-
- /*
- * We are currently handling the data for a file.
- * Process the minimum of the amount of data we have available
- * and the amount left to be processed for the file.
- */
- cc = inCc;
-
- if (cc > dataCc)
- cc = dataCc;
-
- readData (cp, cc);
-
- /*
- * If the amount left isn't an exact multiple of the tar block
- * size then round it up to the next block boundary since there
- * is padding at the end of the file.
- */
- if (cc % TAR_BLOCK_SIZE)
- cc += TAR_BLOCK_SIZE - (cc % TAR_BLOCK_SIZE);
-
- cp += cc;
- inCc -= cc;
- }
-
- done:
- /*
- * Close the tar file if needed.
- */
- if ((tarFd >= 0) && (close (tarFd) < 0))
- perror (tarName);
-
- /*
- * Close the output file if needed.
- * This is only done here on a previous error and so no
- * message is required on errors.
- */
- if (tostdoutFlag == FALSE) {
- if (outFd >= 0)
- (void) close (outFd);
- }
+ return (hlInfo);
}
-
-/*
- * Examine the header block that was just read.
- * This can specify the information for another file, or it can mark
- * the end of the tar file.
- */
-static void
-readHeader (const TarHeader * hp, int fileCount, char **fileTable)
+/* Put an octal string into the specified buffer.
+ * The number is zero and space padded and possibly null padded.
+ * Returns TRUE if successful. */
+static int putOctal(char *cp, int len, long value)
{
- int mode;
- int uid;
- int gid;
- int checkSum;
- long size;
- time_t mtime;
- const char *name;
- int cc;
- int hardLink;
- int softLink;
-
- /*
- * If the block is completely empty, then this is the end of the
- * archive file. If the name is null, then just skip this header.
- */
- name = hp->name;
-
- if (*name == '\0') {
- for (cc = TAR_BLOCK_SIZE; cc > 0; cc--) {
- if (*name++)
- return;
+ int tempLength;
+ char tempBuffer[32];
+ char *tempString = tempBuffer;
+
+ /* Create a string of the specified length with an initial space,
+ * leading zeroes and the octal number, and a trailing null. */
+ sprintf(tempString, "%0*lo", len - 1, value);
+
+ /* If the string is too large, suppress the leading space. */
+ tempLength = strlen(tempString) + 1;
+ if (tempLength > len) {
+ tempLength--;
+ tempString++;
}
- eofFlag = TRUE;
-
- return;
- }
+ /* If the string is still too large, suppress the trailing null. */
+ if (tempLength > len)
+ tempLength--;
- /*
- * There is another file in the archive to examine.
- * Extract the encoded information and check it.
- */
- mode = getOctal (hp->mode, sizeof (hp->mode));
- uid = getOctal (hp->uid, sizeof (hp->uid));
- gid = getOctal (hp->gid, sizeof (hp->gid));
- size = getOctal (hp->size, sizeof (hp->size));
- mtime = getOctal (hp->mtime, sizeof (hp->mtime));
- checkSum = getOctal (hp->checkSum, sizeof (hp->checkSum));
+ /* If the string is still too large, fail. */
+ if (tempLength > len)
+ return FALSE;
- if ((mode < 0) || (uid < 0) || (gid < 0) || (size < 0)) {
- if (!badHeader)
- fprintf (stderr, "Bad tar header, skipping\n");
+ /* Copy the string to the field. */
+ memcpy(cp, tempString, len);
- badHeader = TRUE;
+ return TRUE;
+}
- return;
- }
-
- badHeader = FALSE;
- skipFileFlag = FALSE;
-
- /*
- * Check for the file modes.
- */
- hardLink = ((hp->typeFlag == TAR_TYPE_HARD_LINK) ||
- (hp->typeFlag == TAR_TYPE_HARD_LINK - '0'));
-
- softLink = ((hp->typeFlag == TAR_TYPE_SOFT_LINK) ||
- (hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
-
- /*
- * Check for a directory or a regular file.
- */
- if (name[strlen (name) - 1] == '/')
- mode |= S_IFDIR;
- else if ((mode & S_IFMT) == 0)
- mode |= S_IFREG;
-
- /*
- * Check for absolute paths in the file.
- * If we find any, then warn the user and make them relative.
- */
- if (*name == '/') {
- while (*name == '/')
- name++;
-
- if (!warnedRoot) {
- fprintf (stderr,
- "Absolute path detected, removing leading slashes\n");
+/* Write out a tar header for the specified file/directory/whatever */
+static inline int writeTarHeader(struct TarBallInfo *tbInfo,
+ const char *header_name,
+ const char *real_name, struct stat *statbuf)
+{
+ long chksum = 0;
+ struct TarHeader header;
+ const unsigned char *cp = (const unsigned char *) &header;
+ ssize_t size = sizeof(struct TarHeader);
+
+ memset(&header, 0, size);
+
+ strncpy(header.name, header_name, sizeof(header.name));
+
+ putOctal(header.mode, sizeof(header.mode), statbuf->st_mode);
+ putOctal(header.uid, sizeof(header.uid), statbuf->st_uid);
+ putOctal(header.gid, sizeof(header.gid), statbuf->st_gid);
+ putOctal(header.size, sizeof(header.size), 0); /* Regular file size is handled later */
+ putOctal(header.mtime, sizeof(header.mtime), statbuf->st_mtime);
+ strncpy(header.magic, TAR_MAGIC TAR_VERSION,
+ TAR_MAGIC_LEN + TAR_VERSION_LEN);
+
+ /* Enter the user and group names (default to root if it fails) */
+ if (my_getpwuid(header.uname, statbuf->st_uid) == NULL)
+ strcpy(header.uname, "root");
+ if (my_getgrgid(header.gname, statbuf->st_gid) == NULL)
+ strcpy(header.gname, "root");
+
+ if (tbInfo->hlInfo) {
+ /* This is a hard link */
+ header.typeflag = LNKTYPE;
+ strncpy(header.linkname, tbInfo->hlInfo->name,
+ sizeof(header.linkname));
+ } else if (S_ISLNK(statbuf->st_mode)) {
+ char *lpath = xreadlink(real_name);
+
+ if (!lpath) /* Already printed err msg inside xreadlink() */
+ return (FALSE);
+ header.typeflag = SYMTYPE;
+ strncpy(header.linkname, lpath, sizeof(header.linkname));
+ free(lpath);
+ } else if (S_ISDIR(statbuf->st_mode)) {
+ header.typeflag = DIRTYPE;
+ strncat(header.name, "/", sizeof(header.name));
+ } else if (S_ISCHR(statbuf->st_mode)) {
+ header.typeflag = CHRTYPE;
+ putOctal(header.devmajor, sizeof(header.devmajor),
+ MAJOR(statbuf->st_rdev));
+ putOctal(header.devminor, sizeof(header.devminor),
+ MINOR(statbuf->st_rdev));
+ } else if (S_ISBLK(statbuf->st_mode)) {
+ header.typeflag = BLKTYPE;
+ putOctal(header.devmajor, sizeof(header.devmajor),
+ MAJOR(statbuf->st_rdev));
+ putOctal(header.devminor, sizeof(header.devminor),
+ MINOR(statbuf->st_rdev));
+ } else if (S_ISFIFO(statbuf->st_mode)) {
+ header.typeflag = FIFOTYPE;
+ } else if (S_ISREG(statbuf->st_mode)) {
+ header.typeflag = REGTYPE;
+ putOctal(header.size, sizeof(header.size), statbuf->st_size);
+ } else {
+ bb_error_msg("%s: Unknown file type", real_name);
+ return (FALSE);
}
- warnedRoot = TRUE;
- }
-
- /*
- * See if we want this file to be restored.
- * If not, then set up to skip it.
- */
- if (!wantFileName (name, fileCount, fileTable)) {
- if (!hardLink && !softLink && S_ISREG (mode)) {
- inHeader = (size == 0);
- dataCc = size;
+ /* Calculate and store the checksum (i.e., the sum of all of the bytes of
+ * the header). The checksum field must be filled with blanks for the
+ * calculation. The checksum field is formatted differently from the
+ * other fields: it has [6] digits, a null, then a space -- rather than
+ * digits, followed by a null like the other fields... */
+ memset(header.chksum, ' ', sizeof(header.chksum));
+ cp = (const unsigned char *) &header;
+ while (size-- > 0)
+ chksum += *cp++;
+ putOctal(header.chksum, 7, chksum);
+
+ /* Now write the header out to disk */
+ if ((size =
+ bb_full_write(tbInfo->tarFd, (char *) &header,
+ sizeof(struct TarHeader))) < 0) {
+ bb_error_msg(bb_msg_io_error, real_name);
+ return (FALSE);
}
-
- skipFileFlag = TRUE;
-
- return;
- }
-
- /*
- * This file is to be handled.
- * If we aren't extracting then just list information about the file.
- */
- if (!extractFlag) {
- if (verboseFlag) {
- printf ("%s %3d/%-d %9ld %s %s", modeString (mode),
- uid, gid, size, timeString (mtime), name);
- } else
- printf ("%s", name);
-
- if (hardLink)
- printf (" (link to \"%s\")", hp->linkName);
- else if (softLink)
- printf (" (symlink to \"%s\")", hp->linkName);
- else if (S_ISREG (mode)) {
- inHeader = (size == 0);
- dataCc = size;
+ /* Pad the header up to the tar block size */
+ for (; size < TAR_BLOCK_SIZE; size++) {
+ write(tbInfo->tarFd, "\0", 1);
}
+ /* Now do the verbose thing (or not) */
- printf ("\n");
+ if (tbInfo->verboseFlag) {
+ FILE *vbFd = stdout;
- return;
- }
+ if (tbInfo->tarFd == fileno(stdout)) /* If the archive goes to stdout, verbose to stderr */
+ vbFd = stderr;
- /*
- * We really want to extract the file.
- */
- if (verboseFlag)
- printf ("x %s\n", name);
-
- if (hardLink) {
- if (link (hp->linkName, name) < 0)
- perror (name);
-
- return;
- }
-
- if (softLink) {
-#ifdef S_ISLNK
- if (symlink (hp->linkName, name) < 0)
- perror (name);
-#else
- fprintf (stderr, "Cannot create symbolic links\n");
-#endif
- return;
- }
-
- /*
- * If the file is a directory, then just create the path.
- */
- if (S_ISDIR (mode)) {
- createPath (name, mode);
+ fprintf(vbFd, "%s\n", header.name);
+ }
- return;
- }
-
- /*
- * There is a file to write.
- * First create the path to it if necessary with a default permission.
- */
- createPath (name, 0777);
-
- inHeader = (size == 0);
- dataCc = size;
-
- /*
- * Start the output file.
- */
- if (tostdoutFlag == TRUE)
- outFd = STDOUT;
- else
- outFd = open (name, O_WRONLY | O_CREAT | O_TRUNC, mode);
-
- if (outFd < 0) {
- perror (name);
- skipFileFlag = TRUE;
- return;
- }
-
- /*
- * If the file is empty, then that's all we need to do.
- */
- if (size == 0 && tostdoutFlag == FALSE) {
- (void) close (outFd);
- outFd = -1;
- }
+ return (TRUE);
}
-
-/*
- * Handle a data block of some specified size that was read.
- */
-static void readData (const char *cp, int count)
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+static inline int exclude_file(const llist_t *excluded_files, const char *file)
{
- /*
- * Reduce the amount of data left in this file.
- * If there is no more data left, then we need to read
- * the header again.
- */
- dataCc -= count;
-
- if (dataCc <= 0)
- inHeader = TRUE;
-
- /*
- * If we aren't extracting files or this file is being
- * skipped then do nothing more.
- */
- if (!extractFlag || skipFileFlag)
- return;
-
- /*
- * Write the data to the output file.
- */
- if (fullWrite (outFd, cp, count) < 0) {
- perror (outName);
- if (tostdoutFlag == FALSE) {
- (void) close (outFd);
- outFd = -1;
+ if (excluded_files == NULL) {
+ return 0;
}
- skipFileFlag = TRUE;
- return;
- }
-
- /*
- * If the write failed, close the file and disable further
- * writes to this file.
- */
- if (dataCc <= 0 && tostdoutFlag == FALSE) {
- if (close (outFd))
- perror (outName);
-
- outFd = -1;
- }
-}
+ while (excluded_files) {
+ if (excluded_files->data[0] == '/') {
+ if (fnmatch(excluded_files->data, file,
+ FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+ return 1;
+ } else {
+ const char *p;
+
+ for (p = file; p[0] != '\0'; p++) {
+ if ((p == file || p[-1] == '/') && p[0] != '/' &&
+ fnmatch(excluded_files->data, p,
+ FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+ return 1;
+ }
+ }
+ excluded_files = excluded_files->link;
+ }
-/*
- * Write a tar file containing the specified files.
- */
-static void writeTarFile (int fileCount, char **fileTable)
-{
- struct stat statbuf;
-
- /*
- * Make sure there is at least one file specified.
- */
- if (fileCount <= 0) {
- fprintf (stderr, "No files specified to be saved\n");
- errorFlag = TRUE;
- }
-
- /*
- * Create the tar file for writing.
- */
- if ((tarName == NULL) || !strcmp (tarName, "-")) {
- tostdoutFlag = TRUE;
- tarFd = STDOUT;
- } else
- tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
-
- if (tarFd < 0) {
- perror (tarName);
- errorFlag = TRUE;
- return;
- }
-
- /*
- * Get the device and inode of the tar file for checking later.
- */
- if (fstat (tarFd, &statbuf) < 0) {
- perror (tarName);
- errorFlag = TRUE;
- goto done;
- }
-
- tarDev = statbuf.st_dev;
- tarInode = statbuf.st_ino;
-
- /*
- * Append each file name into the archive file.
- * Follow symbolic links for these top level file names.
- */
- while (!errorFlag && (fileCount-- > 0)) {
- saveFile (*fileTable++, FALSE);
- }
-
- /*
- * Now write an empty block of zeroes to end the archive.
- */
- writeTarBlock ("", 1);
-
-
- done:
- /*
- * Close the tar file and check for errors if it was opened.
- */
- if ((tostdoutFlag == FALSE) && (tarFd >= 0) && (close (tarFd) < 0))
- perror (tarName);
+ return 0;
}
+#endif
-
-/*
- * Save one file into the tar file.
- * If the file is a directory, then this will recursively save all of
- * the files and directories within the directory. The seeLinks
- * flag indicates whether or not we want to see symbolic links as
- * they really are, instead of blindly following them.
- */
-static void saveFile (const char *fileName, int seeLinks)
+static int writeFileToTarball(const char *fileName, struct stat *statbuf,
+ void *userData)
{
- int status;
- int mode;
- struct stat statbuf;
-
- if (verboseFlag)
- printf ("a %s\n", fileName);
-
- /*
- * Check that the file name will fit in the header.
- */
- if (strlen (fileName) >= TAR_NAME_SIZE) {
- fprintf (stderr, "%s: File name is too long\n", fileName);
+ struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData;
+ const char *header_name;
+
+ /*
+ ** Check to see if we are dealing with a hard link.
+ ** If so -
+ ** Treat the first occurance of a given dev/inode as a file while
+ ** treating any additional occurances as hard links. This is done
+ ** by adding the file information to the HardLinkInfo linked list.
+ */
+ tbInfo->hlInfo = NULL;
+ if (statbuf->st_nlink > 1) {
+ tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf);
+ if (tbInfo->hlInfo == NULL)
+ addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, fileName);
+ }
- return;
- }
-
- /*
- * Find out about the file.
- */
-#ifdef S_ISLNK
- if (seeLinks)
- status = lstat (fileName, &statbuf);
- else
-#endif
- status = stat (fileName, &statbuf);
+ /* It is against the rules to archive a socket */
+ if (S_ISSOCK(statbuf->st_mode)) {
+ bb_error_msg("%s: socket ignored", fileName);
+ return (TRUE);
+ }
- if (status < 0) {
- perror (fileName);
+ /* It is a bad idea to store the archive we are in the process of creating,
+ * so check the device and inode to be sure that this particular file isn't
+ * the new tarball */
+ if (tbInfo->statBuf.st_dev == statbuf->st_dev &&
+ tbInfo->statBuf.st_ino == statbuf->st_ino) {
+ bb_error_msg("%s: file is the archive; skipping", fileName);
+ return (TRUE);
+ }
- return;
- }
+ header_name = fileName;
+ while (header_name[0] == '/') {
+ static int alreadyWarned = FALSE;
- /*
- * Make sure we aren't trying to save our file into itself.
- */
- if ((statbuf.st_dev == tarDev) && (statbuf.st_ino == tarInode)) {
- fprintf (stderr, "Skipping saving of archive file itself\n");
+ if (alreadyWarned == FALSE) {
+ bb_error_msg("Removing leading '/' from member names");
+ alreadyWarned = TRUE;
+ }
+ header_name++;
+ }
- return;
- }
+ if (strlen(fileName) >= NAME_SIZE) {
+ bb_error_msg(bb_msg_name_longer_than_foo, NAME_SIZE);
+ return (TRUE);
+ }
- /*
- * Check the type of file.
- */
- mode = statbuf.st_mode;
+ if (header_name[0] == '\0')
+ return TRUE;
- if (S_ISDIR (mode)) {
- saveDirectory (fileName, &statbuf);
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+ if (exclude_file(tbInfo->excludeList, header_name)) {
+ return SKIP;
+ }
+# endif /* CONFIG_FEATURE_TAR_EXCLUDE */
- return;
- }
+ if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) {
+ return (FALSE);
+ }
- if (S_ISREG (mode)) {
- saveRegularFile (fileName, &statbuf);
+ /* Now, if the file is a regular file, copy it out to the tarball */
+ if ((tbInfo->hlInfo == NULL)
+ && (S_ISREG(statbuf->st_mode))) {
+ int inputFileFd;
+ char buffer[BUFSIZ];
+ ssize_t size = 0, readSize = 0;
+
+ /* open the file we want to archive, and make sure all is well */
+ if ((inputFileFd = open(fileName, O_RDONLY)) < 0) {
+ bb_perror_msg("%s: Cannot open", fileName);
+ return (FALSE);
+ }
- return;
- }
+ /* write the file to the archive */
+ while ((size = bb_full_read(inputFileFd, buffer, sizeof(buffer))) > 0) {
+ if (bb_full_write(tbInfo->tarFd, buffer, size) != size) {
+ /* Output file seems to have a problem */
+ bb_error_msg(bb_msg_io_error, fileName);
+ return (FALSE);
+ }
+ readSize += size;
+ }
+ if (size == -1) {
+ bb_error_msg(bb_msg_io_error, fileName);
+ return (FALSE);
+ }
+ /* Pad the file up to the tar block size */
+ for (; (readSize % TAR_BLOCK_SIZE) != 0; readSize++) {
+ write(tbInfo->tarFd, "\0", 1);
+ }
+ close(inputFileFd);
+ }
- /*
- * The file is a strange type of file, ignore it.
- */
- fprintf (stderr, "%s: not a directory or regular file\n", fileName);
+ return (TRUE);
}
-
-/*
- * Save a regular file to the tar file.
- */
-static void
-saveRegularFile (const char *fileName, const struct stat *statbuf)
+static inline int writeTarFile(const int tar_fd, const int verboseFlag,
+ const llist_t *include, const llist_t *exclude, const int gzip)
{
- int sawEof;
- int fileFd;
- int cc;
- int dataCount;
- long fullDataCount;
- char data[TAR_BLOCK_SIZE * 16];
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ int gzipDataPipe[2] = { -1, -1 };
+ int gzipStatusPipe[2] = { -1, -1 };
+ pid_t gzipPid = 0;
+ volatile int vfork_exec_errno = 0;
+#endif
- /*
- * Open the file for reading.
- */
- fileFd = open (fileName, O_RDONLY);
+ int errorFlag = FALSE;
+ ssize_t size;
+ struct TarBallInfo tbInfo;
- if (fileFd < 0) {
- perror (fileName);
+ tbInfo.hlInfoHead = NULL;
- return;
- }
-
- /*
- * Write out the header for the file.
- */
- writeHeader (fileName, statbuf);
-
- /*
- * Write the data blocks of the file.
- * We must be careful to write the amount of data that the stat
- * buffer indicated, even if the file has changed size. Otherwise
- * the tar file will be incorrect.
- */
- fullDataCount = statbuf->st_size;
- sawEof = FALSE;
-
- while (fullDataCount > 0) {
- /*
- * Get the amount to write this iteration which is
- * the minumum of the amount left to write and the
- * buffer size.
- */
- dataCount = sizeof (data);
+ /* Make sure there is at least one file to tar up. */
+ if (include == NULL) {
+ bb_error_msg_and_die("Cowardly refusing to create an empty archive");
+ }
- if (dataCount > fullDataCount)
- dataCount = (int) fullDataCount;
+ fchmod(tar_fd, 0644);
+ tbInfo.tarFd = tar_fd;
+ tbInfo.verboseFlag = verboseFlag;
- /*
- * Read the data from the file if we haven't seen the
- * end of file yet.
- */
- cc = 0;
+ /* Store the stat info for the tarball's file, so
+ * can avoid including the tarball into itself.... */
+ if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
+ bb_perror_msg_and_die("Couldnt stat tar file");
- if (!sawEof) {
- cc = fullRead (fileFd, data, dataCount);
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ if (gzip) {
+ if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0) {
+ bb_perror_msg_and_die("Failed to create gzip pipe");
+ }
- if (cc < 0) {
- perror (fileName);
+ signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
- (void) close (fileFd);
- errorFlag = TRUE;
+# if __GNUC__
+ /* Avoid vfork clobbering */
+ (void) &include;
+ (void) &errorFlag;
+# endif
+
+ gzipPid = vfork();
- return;
- }
+ if (gzipPid == 0) {
+ dup2(gzipDataPipe[0], 0);
+ close(gzipDataPipe[1]);
- /*
- * If the file ended too soon, complain and set
- * a flag so we will zero fill the rest of it.
- */
- if (cc < dataCount) {
- fprintf (stderr,
- "%s: Short read - zero filling", fileName);
+ if (tbInfo.tarFd != 1);
+ dup2(tbInfo.tarFd, 1);
- sawEof = TRUE;
- }
- }
+ close(gzipStatusPipe[0]);
+ fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC); /* close on exec shows sucess */
- /*
- * Zero fill the rest of the data if necessary.
- */
- if (cc < dataCount)
- memset (data + cc, 0, dataCount - cc);
+ execl("/bin/gzip", "gzip", "-f", 0);
+ vfork_exec_errno = errno;
- /*
- * Write the buffer to the TAR file.
- */
- writeTarBlock (data, dataCount);
+ close(gzipStatusPipe[1]);
+ exit(-1);
+ } else if (gzipPid > 0) {
+ close(gzipDataPipe[0]);
+ close(gzipStatusPipe[1]);
- fullDataCount -= dataCount;
- }
+ while (1) {
+ char buf;
- /*
- * Close the file.
- */
- if ((tostdoutFlag == FALSE) && close (fileFd) < 0)
- fprintf (stderr, "%s: close: %s\n", fileName, strerror (errno));
-}
+ int n = bb_full_read(gzipStatusPipe[0], &buf, 1);
+ if (n == 0 && vfork_exec_errno != 0) {
+ errno = vfork_exec_errno;
+ bb_perror_msg_and_die("Could not exec gzip process");
+ } else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
+ continue; /* try it again */
+ break;
+ }
+ close(gzipStatusPipe[0]);
-/*
- * Save a directory and all of its files to the tar file.
- */
-static void saveDirectory (const char *dirName, const struct stat *statbuf)
-{
- DIR *dir;
- struct dirent *entry;
- int needSlash;
- char fullName[NAME_MAX];
-
- /*
- * Construct the directory name as used in the tar file by appending
- * a slash character to it.
- */
- strcpy (fullName, dirName);
- strcat (fullName, "/");
-
- /*
- * Write out the header for the directory entry.
- */
- writeHeader (fullName, statbuf);
-
- /*
- * Open the directory.
- */
- dir = opendir (dirName);
-
- if (dir == NULL) {
- fprintf (stderr, "Cannot read directory \"%s\": %s\n",
- dirName, strerror (errno));
-
- return;
- }
-
- /*
- * See if a slash is needed.
- */
- needSlash = (*dirName && (dirName[strlen (dirName) - 1] != '/'));
-
- /*
- * Read all of the directory entries and check them,
- * except for the current and parent directory entries.
- */
- while (!errorFlag && ((entry = readdir (dir)) != NULL)) {
- if ((strcmp (entry->d_name, ".") == 0) ||
- (strcmp (entry->d_name, "..") == 0)) {
- continue;
+ tbInfo.tarFd = gzipDataPipe[1];
+ } else {
+ bb_perror_msg_and_die("Failed to vfork gzip process");
+ }
}
+#endif
- /*
- * Build the full path name to the file.
- */
- strcpy (fullName, dirName);
+ tbInfo.excludeList = exclude;
- if (needSlash)
- strcat (fullName, "/");
+ /* Read the directory/files and iterate over them one at a time */
+ while (include) {
+ if (!recursive_action(include->data, TRUE, FALSE, FALSE,
+ writeFileToTarball, writeFileToTarball,
+ (void *) &tbInfo)) {
+ errorFlag = TRUE;
+ }
+ include = include->link;
+ }
+ /* Write two empty blocks to the end of the archive */
+ for (size = 0; size < (2 * TAR_BLOCK_SIZE); size++) {
+ write(tbInfo.tarFd, "\0", 1);
+ }
- strcat (fullName, entry->d_name);
+ /* To be pedantically correct, we would check if the tarball
+ * is smaller than 20 tar blocks, and pad it if it was smaller,
+ * but that isn't necessary for GNU tar interoperability, and
+ * so is considered a waste of space */
- /*
- * Write this file to the tar file, noticing whether or not
- * the file is a symbolic link.
- */
- saveFile (fullName, TRUE);
- }
+ /* Hang up the tools, close up shop, head home */
+ close(tbInfo.tarFd);
+ if (errorFlag)
+ bb_error_msg("Error exit delayed from previous errors");
- /*
- * All done, close the directory.
- */
- closedir (dir);
-}
+ freeHardLinkInfo(&tbInfo.hlInfoHead);
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ if (gzip && gzipPid) {
+ if (waitpid(gzipPid, NULL, 0) == -1)
+ printf("Couldnt wait ?");
+ }
+#endif
-/*
- * Write a tar header for the specified file name and status.
- * It is assumed that the file name fits.
- */
-static void writeHeader (const char *fileName, const struct stat *statbuf)
-{
- long checkSum;
- const unsigned char *cp;
- int len;
- TarHeader header;
-
- /*
- * Zero the header block in preparation for filling it in.
- */
- memset ((char *) &header, 0, sizeof (header));
-
- /*
- * Fill in the header.
- */
- strcpy (header.name, fileName);
-
- strncpy (header.magic, TAR_MAGIC, sizeof (header.magic));
- strncpy (header.version, TAR_VERSION, sizeof (header.version));
-
- putOctal (header.mode, sizeof (header.mode), statbuf->st_mode & 0777);
- putOctal (header.uid, sizeof (header.uid), statbuf->st_uid);
- putOctal (header.gid, sizeof (header.gid), statbuf->st_gid);
- putOctal (header.size, sizeof (header.size), statbuf->st_size);
- putOctal (header.mtime, sizeof (header.mtime), statbuf->st_mtime);
-
- header.typeFlag = TAR_TYPE_REGULAR;
-
- /*
- * Calculate and store the checksum.
- * This is the sum of all of the bytes of the header,
- * with the checksum field itself treated as blanks.
- */
- memset (header.checkSum, ' ', sizeof (header.checkSum));
-
- cp = (const unsigned char *) &header;
- len = sizeof (header);
- checkSum = 0;
-
- while (len-- > 0)
- checkSum += *cp++;
-
- putOctal (header.checkSum, sizeof (header.checkSum), checkSum);
-
- /*
- * Write the tar header.
- */
- writeTarBlock ((const char *) &header, sizeof (header));
+ return !errorFlag;
}
+#endif /* tar_create */
-
-/*
- * Write data to one or more blocks of the tar file.
- * The data is always padded out to a multiple of TAR_BLOCK_SIZE.
- * The errorFlag static variable is set on an error.
- */
-static void writeTarBlock (const char *buf, int len)
+#ifdef CONFIG_FEATURE_TAR_EXCLUDE
+static llist_t *append_file_list_to_list(llist_t *list)
{
- int partialLength;
- int completeLength;
- char fullBlock[TAR_BLOCK_SIZE];
-
- /*
- * If we had a write error before, then do nothing more.
- */
- if (errorFlag)
- return;
-
- /*
- * Get the amount of complete and partial blocks.
- */
- partialLength = len % TAR_BLOCK_SIZE;
- completeLength = len - partialLength;
-
- /*
- * Write all of the complete blocks.
- */
- if ((completeLength > 0) && !fullWrite (tarFd, buf, completeLength)) {
- perror (tarName);
-
- errorFlag = TRUE;
-
- return;
- }
-
- /*
- * If there are no partial blocks left, we are done.
- */
- if (partialLength == 0)
- return;
-
- /*
- * Copy the partial data into a complete block, and pad the rest
- * of it with zeroes.
- */
- memcpy (fullBlock, buf + completeLength, partialLength);
- memset (fullBlock + partialLength, 0, TAR_BLOCK_SIZE - partialLength);
-
- /*
- * Write the last complete block.
- */
- if (!fullWrite (tarFd, fullBlock, TAR_BLOCK_SIZE)) {
- perror (tarName);
-
- errorFlag = TRUE;
- }
+ FILE *src_stream;
+ llist_t *cur = list;
+ llist_t *tmp;
+ char *line;
+ llist_t *newlist = NULL;
+
+ while(cur) {
+ src_stream = bb_xfopen(cur->data, "r");
+ tmp = cur;
+ cur = cur->link;
+ free(tmp);
+ while((line = bb_get_chomped_line_from_file(src_stream)) != NULL) {
+ newlist = llist_add_to(newlist, line);
+ }
+ fclose(src_stream);
+ }
+ return newlist;
}
+#endif
-
-/*
- * Attempt to create the directories along the specified path, except for
- * the final component. The mode is given for the final directory only,
- * while all previous ones get default protections. Errors are not reported
- * here, as failures to restore files can be reported later.
- */
-static void createPath (const char *name, int mode)
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+static char get_header_tar_Z(archive_handle_t *archive_handle)
{
- char *cp;
- char *cpOld;
- char buf[TAR_NAME_SIZE];
-
- strcpy (buf, name);
-
- cp = strchr (buf, '/');
-
- while (cp) {
- cpOld = cp;
- cp = strchr (cp + 1, '/');
+ /* Cant lseek over pipe's */
+ archive_handle->seek = seek_by_char;
- *cpOld = '\0';
+ /* do the decompression, and cleanup */
+ if ((bb_xread_char(archive_handle->src_fd) != 0x1f) || (bb_xread_char(archive_handle->src_fd) != 0x9d)) {
+ bb_error_msg_and_die("Invalid magic");
+ }
- if (mkdir (buf, cp ? 0777 : mode) == 0)
- printf ("Directory \"%s\" created\n", buf);
+ archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress);
+ archive_handle->offset = 0;
+ while (get_header_tar(archive_handle) == EXIT_SUCCESS);
- *cpOld = '/';
- }
+ /* Can only do one file at a time */
+ return(EXIT_FAILURE);
}
+#endif
-
-/*
- * Read an octal value in a field of the specified width, with optional
- * spaces on both sides of the number and with an optional null character
- * at the end. Returns -1 on an illegal format.
- */
-static long getOctal (const char *cp, int len)
+static const char tar_options[]="ctxjT:X:C:f:OpvzkZ";
+
+#define CTX_CREATE 1
+#define CTX_TEST 2
+#define CTX_EXTRACT 4
+#define TAR_OPT_BZIP2 8
+#define TAR_OPT_INCLUDE 16
+#define TAR_OPT_EXCLUDE 32
+#define TAR_OPT_BASEDIR 64
+#define TAR_OPT_ARNAME 128
+#define TAR_OPT_2STDOUT 256
+#define TAR_OPT_P 512
+#define TAR_OPT_VERBOSE 1024
+#define TAR_OPT_GZIP 2048
+#define TAR_OPT_KEEP_OLD 4096
+#define TAR_OPT_UNCOMPRESS 8192
+
+int tar_main(int argc, char **argv)
{
- long val;
-
- while ((len > 0) && (*cp == ' ')) {
- cp++;
- len--;
- }
-
- if ((len == 0) || !isOctal (*cp))
- return -1;
-
- val = 0;
-
- while ((len > 0) && isOctal (*cp)) {
- val = val * 8 + *cp++ - '0';
- len--;
- }
+ char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
+ archive_handle_t *tar_handle;
+ int opt;
+ char *base_dir = NULL;
+ const char *tar_filename = "-";
+ unsigned char ctx_flag = 0;
+
+ if (argc < 2) {
+ bb_show_usage();
+ }
- while ((len > 0) && (*cp == ' ')) {
- cp++;
- len--;
- }
+ /* Prepend '-' to the first argument if required */
+ if (argv[1][0] != '-') {
+ char *tmp;
- if ((len > 0) && *cp)
- return -1;
+ bb_xasprintf(&tmp, "-%s", argv[1]);
+ argv[1] = tmp;
+ }
- return val;
-}
+ /* Initialise default values */
+ tar_handle = init_handle();
+ tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS | ARCHIVE_PRESERVE_DATE | ARCHIVE_EXTRACT_UNCONDITIONAL;
+
+ bb_opt_complementaly = "c~tx:t~cx:x~ct:X*";
+ opt = bb_getopt_ulflags(argc, argv, tar_options,
+ NULL, /* T: arg is ignored by default
+ a list is an include list */
+ &(tar_handle->reject),
+ &base_dir, /* Change to dir <optarg> */
+ &tar_filename); /* archive filename */
+ /* Check one and only one context option was given */
+ if(opt & 0x80000000UL)
+ bb_show_usage();
+ ctx_flag = opt & (CTX_CREATE | CTX_TEST | CTX_EXTRACT);
+ if(ctx_flag & CTX_TEST) {
+ if ((tar_handle->action_header == header_list) ||
+ (tar_handle->action_header == header_verbose_list)) {
+ tar_handle->action_header = header_verbose_list;
+ } else {
+ tar_handle->action_header = header_list;
+ }
+ }
+ if(ctx_flag & CTX_EXTRACT) {
+ if (tar_handle->action_data != data_extract_to_stdout)
+ tar_handle->action_data = data_extract_all;
+ }
+ if(opt & TAR_OPT_2STDOUT) {
+ /* To stdout */
+ tar_handle->action_data = data_extract_to_stdout;
+ }
+ if(opt & TAR_OPT_VERBOSE) {
+ if ((tar_handle->action_header == header_list) ||
+ (tar_handle->action_header == header_verbose_list))
+ {
+ tar_handle->action_header = header_verbose_list;
+ } else {
+ tar_handle->action_header = header_list;
+ }
+ }
+ if (opt & TAR_OPT_KEEP_OLD) {
+ tar_handle->flags &= ~ARCHIVE_EXTRACT_UNCONDITIONAL;
+ }
+ if(opt & TAR_OPT_GZIP) {
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ get_header_ptr = get_header_tar_gz;
+#else
+ bb_show_usage();
+#endif
+ }
+ if(opt & TAR_OPT_BZIP2) {
+#ifdef CONFIG_FEATURE_TAR_BZIP2
+ get_header_ptr = get_header_tar_bz2;
+#else
+ bb_show_usage();
+#endif
+ }
+ if(opt & TAR_OPT_UNCOMPRESS) {
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+ get_header_ptr = get_header_tar_Z;
+#else
+ bb_show_usage();
+#endif
+ }
+ if(opt & TAR_OPT_EXCLUDE) {
+#ifdef CONFIG_FEATURE_TAR_EXCLUDE
+ tar_handle->reject = append_file_list_to_list(tar_handle->reject);
+#else
+ bb_show_usage();
+#endif
+ }
+ /* Check if we are reading from stdin */
+ if ((argv[optind]) && (*argv[optind] == '-')) {
+ /* Default is to read from stdin, so just skip to next arg */
+ optind++;
+ }
-/*
- * Put an octal string into the specified buffer.
- * The number is zero and space padded and possibly null padded.
- * Returns TRUE if successful.
- */
-static int putOctal (char *cp, int len, long value)
-{
- int tempLength;
- char *tempString;
- char tempBuffer[32];
-
- /*
- * Create a string of the specified length with an initial space,
- * leading zeroes and the octal number, and a trailing null.
- */
- tempString = tempBuffer;
-
- sprintf (tempString, " %0*lo", len - 2, value);
-
- tempLength = strlen (tempString) + 1;
-
- /*
- * If the string is too large, suppress the leading space.
- */
- if (tempLength > len) {
- tempLength--;
- tempString++;
- }
-
- /*
- * If the string is still too large, suppress the trailing null.
- */
- if (tempLength > len)
- tempLength--;
-
- /*
- * If the string is still too large, fail.
- */
- if (tempLength > len)
- return FALSE;
-
- /*
- * Copy the string to the field.
- */
- memcpy (cp, tempString, len);
-
- return TRUE;
-}
+ /* Setup an array of filenames to work with */
+ /* TODO: This is the same as in ar, seperate function ? */
+ while (optind < argc) {
+ tar_handle->accept = llist_add_to(tar_handle->accept, argv[optind]);
+ optind++;
+ }
+ if ((tar_handle->accept) || (tar_handle->reject)) {
+ tar_handle->filter = filter_accept_reject_list;
+ }
-/*
- * See if the specified file name belongs to one of the specified list
- * of path prefixes. An empty list implies that all files are wanted.
- * Returns TRUE if the file is selected.
- */
-static int
-wantFileName (const char *fileName, int fileCount, char **fileTable)
-{
- const char *pathName;
- int fileLength;
- int pathLength;
-
- /*
- * If there are no files in the list, then the file is wanted.
- */
- if (fileCount == 0)
- return TRUE;
+ /* Open the tar file */
+ {
+ FILE *tar_stream;
+ int flags;
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+ if (ctx_flag == CTX_CREATE) {
+ tar_stream = stdout;
+ flags = O_WRONLY | O_CREAT | O_EXCL;
+ unlink(tar_filename);
+ } else
+#endif
+ {
+ tar_stream = stdin;
+ flags = O_RDONLY;
+ }
- fileLength = strlen (fileName);
+ if ((tar_filename[0] == '-') && (tar_filename[1] == '\0')) {
+ tar_handle->src_fd = fileno(tar_stream);
+ tar_handle->seek = seek_by_char;
+ } else {
+ tar_handle->src_fd = bb_xopen(tar_filename, flags);
+ }
+ }
- /*
- * Check each of the test paths.
- */
- while (fileCount-- > 0) {
- pathName = *fileTable++;
+ if ((base_dir) && (chdir(base_dir))) {
+ bb_perror_msg_and_die("Couldnt chdir to %s", base_dir);
+ }
- pathLength = strlen (pathName);
+#ifdef CONFIG_FEATURE_TAR_CREATE
+ /* create an archive */
+ if (ctx_flag == CTX_CREATE) {
+ int verboseFlag = FALSE;
+ int gzipFlag = FALSE;
- if (fileLength < pathLength)
- continue;
+# ifdef CONFIG_FEATURE_TAR_GZIP
+ if (get_header_ptr == get_header_tar_gz) {
+ gzipFlag = TRUE;
+ }
+# endif /* CONFIG_FEATURE_TAR_GZIP */
+# ifdef CONFIG_FEATURE_TAR_BZIP2
+ if (get_header_ptr == get_header_tar_bz2) {
+ bb_error_msg_and_die("Creating bzip2 compressed archives is not currently supported.");
+ }
+# endif /* CONFIG_FEATURE_TAR_BZIP2 */
- if (memcmp (fileName, pathName, pathLength) != 0)
- continue;
+ if ((tar_handle->action_header == header_list) ||
+ (tar_handle->action_header == header_verbose_list)) {
+ verboseFlag = TRUE;
+ }
+ writeTarFile(tar_handle->src_fd, verboseFlag, tar_handle->accept,
+ tar_handle->reject, gzipFlag);
+ } else
+#endif /* CONFIG_FEATURE_TAR_CREATE */
+ {
+ while (get_header_ptr(tar_handle) == EXIT_SUCCESS);
+
+ /* Ckeck that every file that should have been extracted was */
+ while (tar_handle->accept) {
+ if (find_list_entry(tar_handle->reject, tar_handle->accept->data) == NULL) {
+ if (find_list_entry(tar_handle->passed, tar_handle->accept->data) == NULL) {
+ bb_error_msg_and_die("%s: Not found in archive\n", tar_handle->accept->data);
+ }
+ }
+ tar_handle->accept = tar_handle->accept->link;
+ }
+ }
- if ((fileLength == pathLength) || (fileName[pathLength] == '/')) {
- return TRUE;
+#ifdef CONFIG_FEATURE_CLEAN_UP
+ if (tar_handle->src_fd != fileno(stdin)) {
+ close(tar_handle->src_fd);
}
- }
+#endif /* CONFIG_FEATURE_CLEAN_UP */
- return FALSE;
+ return(EXIT_SUCCESS);
}
-
-
-
-#endif
-/* END CODE */
projects / oweals / busybox.git / blobdiff