/* vi: set sw=4 ts=4: */
/*
- * Mini tar implementation for busybox based on code taken from sash.
+ * Mini tar implementation for busybox
*
- * Copyright (c) 1999 by David I. Bell
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
+ * Modifed to use common extraction code used by ar, cpio, dpkg-deb, dpkg
+ * Glenn McGrath <bug1@optushome.com.au>
*
- * Permission to distribute this code under the GPL has been granted.
+ * 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.)
*
- * Modified for busybox by Erik Andersen <andersee@debian.org>
- * Adjusted to grok stdin/stdout options.
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
*
- * Modified to handle device special files by Matt Porter
- * <porter@debian.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
*
*/
-
-#include "internal.h"
+#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>
-#include <utime.h>
-#include <sys/types.h>
-#include <sys/sysmacros.h>
-#include <sys/param.h> /* for PATH_MAX */
-
-
-#ifdef BB_FEATURE_TAR_CREATE
-
-static const char tar_usage[] =
- "tar -[cxtvOf] [tarFileName] [FILE] ...\n\n"
- "Create, extract, or list files from a tar file.\n\n"
- "Options:\n"
-
- "\tc=create, x=extract, t=list contents, v=verbose,\n"
- "\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
-
-#else
-
-static const char tar_usage[] =
- "tar -[xtvOf] [tarFileName] [FILE] ...\n\n"
- "Extract, or list files stored in a tar file. This\n"
- "version of tar does not support creation of tar files.\n\n"
- "Options:\n"
-
- "\tx=extract, t=list contents, v=verbose,\n"
- "\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
-
-#endif
+#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 */
-struct TarHeader
-{
- /* byte offset */
- char name[100]; /* 0 */
- char mode[8]; /* 100 */
- char uid[8]; /* 108 */
- char gid[8]; /* 116 */
- char size[12]; /* 124 */
- char mtime[12]; /* 136 */
- char chksum[8]; /* 148 */
- char typeflag; /* 156 */
- char linkname[100]; /* 157 */
- char magic[6]; /* 257 */
- char version[2]; /* 263 */
- char uname[32]; /* 265 */
- char gname[32]; /* 297 */
- char devmajor[8]; /* 329 */
- char devminor[8]; /* 337 */
- char prefix[155]; /* 345 */
- /* padding 500 */
+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;
+/*
+** 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) */
+};
-/* A few useful constants */
-#define TAR_MAGIC "ustar" /* ustar and a null */
-#define TAR_VERSION "00" /* 00 and no null */
-#define TAR_MAGIC_LEN 6
-#define TAR_VERSION_LEN 2
-#define TAR_NAME_LEN 100
-#define TAR_BLOCK_SIZE 512
+/* 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 */
+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;
-/* This struct ignores magic, non-numeric user name,
- * non-numeric group name, and the checksum, since
- * these are all ignored by BusyBox tar. */
-struct TarInfo
+/* 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)
{
- int tarFd; /* An open file descriptor for reading from the tarball */
- char * name; /* File name */
- mode_t mode; /* Unix mode, including device bits. */
- uid_t uid; /* Numeric UID */
- gid_t gid; /* Numeric GID */
- size_t size; /* Size of file */
- time_t mtime; /* Last-modified time */
- enum TarFileType type; /* Regular, directory, link, etc */
- char * linkname; /* Name for symbolic and hard links */
- dev_t device; /* Special device for mknod() */
-};
-typedef struct TarInfo TarInfo;
-
-/* Static data */
-static const unsigned long TarChecksumOffset = (const unsigned long)&(((TarHeader *)0)->chksum);
-
-
-/* Local procedures to restore files from a tar file. */
-static int readTarFile(const char* tarName, int extractFlag, int listFlag,
- int tostdoutFlag, int verboseFlag);
-static long getOctal(const char *cp, int len);
-static int parseTarHeader(struct TarHeader *rawHeader, struct TarInfo *header);
-
-#ifdef BB_FEATURE_TAR_CREATE
-/*
- * 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 void writeHeader(const char *fileName, const struct stat *statbuf);
-static void writeTarFile(int argc, char **argv);
-static void writeTarBlock(const char *buf, int len);
-static int putOctal(char *cp, int len, long value);
-
-#endif
-
+ /* 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 *tarName=NULL;
- const char *options;
- int listFlag = FALSE;
- int extractFlag = FALSE;
- int createFlag = FALSE;
- int verboseFlag = FALSE;
- int tostdoutFlag = FALSE;
-
- argc--;
- argv++;
-
- if (argc < 1)
- usage(tar_usage);
-
- /* Parse options */
- if (**argv == '-')
- options = (*argv++) + 1;
- else
- options = (*argv++);
- argc--;
-
- for (; *options; options++) {
- switch (*options) {
- case 'f':
- if (tarName != NULL)
- fatalError( "Only one 'f' option allowed\n");
-
- tarName = *argv++;
- if (tarName == NULL)
- fatalError( "Option requires an argument: No file specified\n");
- argc--;
-
- break;
-
- case 't':
- if (extractFlag == TRUE || createFlag == TRUE)
- goto flagError;
- listFlag = TRUE;
- break;
-
- case 'x':
- if (listFlag == TRUE || createFlag == TRUE)
- goto flagError;
- extractFlag = TRUE;
- break;
- case 'c':
- if (extractFlag == TRUE || listFlag == TRUE)
- goto flagError;
- createFlag = TRUE;
- break;
-
- case 'v':
- verboseFlag = TRUE;
- break;
-
- case 'O':
- tostdoutFlag = TRUE;
- break;
-
- case '-':
- usage(tar_usage);
- break;
-
- default:
- fatalError( "Unknown tar flag '%c'\n"
- "Try `tar --help' for more information\n", *options);
+ HardLinkInfo *hlInfo = NULL;
+ HardLinkInfo *hlInfoNext = NULL;
+
+ if (hlInfoHeadPtr) {
+ hlInfo = *hlInfoHeadPtr;
+ while (hlInfo) {
+ hlInfoNext = hlInfo->next;
+ free(hlInfo);
+ hlInfo = hlInfoNext;
}
+ *hlInfoHeadPtr = NULL;
}
-
- /*
- * Do the correct type of action supplying the rest of the
- * command line arguments as the list of files to process.
- */
- if (createFlag == TRUE) {
-#ifndef BB_FEATURE_TAR_CREATE
- fatalError( "This version of tar was not compiled with tar creation support.\n");
-#else
- exit(writeTarFile(argc, argv));
-#endif
- } else {
- exit(readTarFile(tarName, extractFlag, listFlag, tostdoutFlag, verboseFlag));
- }
-
- flagError:
- fatalError( "Exactly one of 'c', 'x' or 't' must be specified\n");
-}
-
-static void
-tarExtractRegularFile(TarInfo *header, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag)
-{
- return;
-}
-
-static void
-tarExtractDirectory(TarInfo *header, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag)
-{
- return;
-}
-
-static void
-tarExtractHardLink(TarInfo *header, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag)
-{
return;
}
-static void
-tarExtractSymLink(TarInfo *header, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag)
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
+static inline HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
{
- return;
+ while (hlInfo) {
+ if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
+ break;
+ hlInfo = hlInfo->next;
+ }
+ return (hlInfo);
}
-static void
-tarExtractSpecial(TarInfo *header, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag)
+/* 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)
{
- 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);
-/*
- * 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 int readTarFile(const char* tarName, int extractFlag, int listFlag,
- int tostdoutFlag, int verboseFlag)
-{
- int status, tarFd=0;
- int errorFlag=FALSE;
- TarHeader rawHeader;
- TarInfo header;
-
- /* Open the tar file for reading. */
- if (!strcmp(tarName, "-"))
- tarFd = fileno(stdin);
- else
- tarFd = open(tarName, O_RDONLY);
- if (tarFd < 0) {
- errorMsg( "Error opening '%s': %s", tarName, strerror(errno));
- return ( FALSE);
+ /* If the string is too large, suppress the leading space. */
+ tempLength = strlen(tempString) + 1;
+ if (tempLength > len) {
+ tempLength--;
+ tempString++;
}
- /* Read the tar file */
- while ( (status = fullRead(tarFd, (char*)&rawHeader, TAR_BLOCK_SIZE)) == TAR_BLOCK_SIZE ) {
- /* Now see if the header looks ok */
- if ( parseTarHeader(&rawHeader, &header) == FALSE ) {
- close( tarFd);
- if ( *(header.name) == '\0' ) {
- goto endgame;
- } else {
- errorFlag=TRUE;
- errorMsg("Bad tar header, skipping\n");
- continue;
- }
- }
- if ( *(header.name) == '\0' )
- goto endgame;
-
- if (extractFlag == FALSE) {
- if (verboseFlag == TRUE) {
- printf("%s %3d/%-d ", modeString(header.mode), header.uid, header.gid);
- if (header.type==CHRTYPE || header.type==BLKTYPE)
- printf("%4d,%4d %s ", MAJOR(header.device),
- MINOR(header.device), timeString(header.mtime));
- else
- printf("%9ld %s ", header.size, timeString(header.mtime));
- }
- printf("%s", header.name);
-
- if (header.type==LNKTYPE)
- printf(" (link to \"%s\")", hp->linkName);
- else if (header.type==SYMTYPE)
- printf(" (symlink to \"%s\")", hp->linkName);
- printf("\n");
- continue;
- }
-
- /* If we got here, we can be certain we have a legitimate
- * header to work with. So work with it. */
- switch ( header.type ) {
- case REGTYPE:
- case REGTYPE0:
- /* If the name ends in a '/' then assume it is
- * supposed to be a directory, and fall through */
- if (header.name[strlen(header.name)-1] != '/') {
- tarExtractRegularFile(&header, extractFlag, listFlag, tostdoutFlag, verboseFlag);
- break;
- }
- case DIRTYPE:
- tarExtractDirectory( &header, extractFlag, listFlag, tostdoutFlag, verboseFlag);
- break;
- case LNKTYPE:
- tarExtractHardLink( &header, extractFlag, listFlag, tostdoutFlag, verboseFlag);
- break;
- case SYMTYPE:
- tarExtractSymLink( &header, extractFlag, listFlag, tostdoutFlag, verboseFlag);
- break;
- case CHRTYPE:
- case BLKTYPE:
- case FIFOTYPE:
- tarExtractSpecial( &header, extractFlag, listFlag, tostdoutFlag, verboseFlag);
- break;
- default:
- close( tarFd);
- return( FALSE);
- }
- }
+ /* If the string is still too large, suppress the trailing null. */
+ if (tempLength > len)
+ tempLength--;
- close(tarFd);
- if (status > 0) {
- /* Bummer - we read a partial header */
- errorMsg( "Error reading '%s': %s", tarName, strerror(errno));
- return ( FALSE);
- }
- else
- return( status);
-
- /* Stuff we do when we know we are done with the file */
-endgame:
- close( tarFd);
- if ( *(header.name) == '\0' ) {
- if (errorFlag==FALSE)
- return( TRUE);
- }
- return( FALSE);
-}
+ /* If the string is still too large, fail. */
+ if (tempLength > len)
+ return FALSE;
-/*
- * 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 size)
-{
- long val = 0;
+ /* Copy the string to the field. */
+ memcpy(cp, tempString, len);
- for(;(size > 0) && (*cp == ' '); cp++, size--);
- if ((size == 0) || !isOctal(*cp))
- return -1;
- for(; (size > 0) && isOctal(*cp); size--) {
- val = val * 8 + *cp++ - '0';
- }
- for (;(size > 0) && (*cp == ' '); cp++, size--);
- if ((size > 0) && *cp)
- return -1;
- return val;
+ return TRUE;
}
-/* Parse the tar header and fill in the nice struct with the details */
-static int
-parseTarHeader(struct TarHeader *rawHeader, struct TarInfo *header)
+/* 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)
{
- int i;
- long chksum, sum;
- unsigned char *s = (unsigned char *)rawHeader;
-
- header->name = rawHeader->name;
- header->mode = getOctal(rawHeader->mode, sizeof(rawHeader->mode));
- header->uid = getOctal(rawHeader->uid, sizeof(rawHeader->uid));
- header->gid = getOctal(rawHeader->gid, sizeof(rawHeader->gid));
- header->size = getOctal(rawHeader->size, sizeof(rawHeader->size));
- header->mtime = getOctal(rawHeader->mtime, sizeof(rawHeader->mtime));
- chksum = getOctal(rawHeader->chksum, sizeof(rawHeader->chksum));
- header->type = rawHeader->typeflag;
- header->linkname = rawHeader->linkname;
- header->device = MAJOR(getOctal(rawHeader->devmajor, sizeof(rawHeader->devmajor))) |
- MINOR(getOctal(rawHeader->devminor, sizeof(rawHeader->devminor)));
-
- /* Check the checksum */
- sum = ' ' * sizeof(rawHeader->chksum);
- for ( i = TarChecksumOffset; i > 0; i-- )
- sum += *s++;
- s += sizeof(rawHeader->chksum);
- for ( i = (512 - TarChecksumOffset - sizeof(rawHeader->chksum)); i > 0; i-- )
- sum += *s++;
- if (sum == chksum )
- return ( TRUE);
- return( FALSE);
-}
-
-#if 0
- if ((header->mode < 0) || (header->uid < 0) ||
- (header->gid < 0) || (header->size < 0)) {
- errorMsg(stderr, "Bad tar header, skipping\n");
- return( FALSE);
- }
-
- badHeader = FALSE;
- skipFileFlag = FALSE;
- devFileFlag = FALSE;
+ long chksum = 0;
+ struct TarHeader header;
+ const unsigned char *cp = (const unsigned char *) &header;
+ ssize_t size = sizeof(struct TarHeader);
- /*
- * Check for the file modes.
- */
- hardLink = ((hp->typeFlag == TAR_TYPE_HARD_LINK) ||
- (hp->typeFlag == TAR_TYPE_HARD_LINK - '0'));
+ memset(&header, 0, size);
- softLink = ((hp->typeFlag == TAR_TYPE_SOFT_LINK) ||
- (hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
+ strncpy(header.name, header_name, sizeof(header.name));
- /*
- * Check for a directory.
- */
- if (outName[strlen(outName) - 1] == '/')
- mode |= S_IFDIR;
-
- /*
- * Check for absolute paths in the file.
- * If we find any, then warn the user and make them relative.
- */
- if (*outName == '/') {
- while (*outName == '/')
- outName++;
-
- if (warnedRoot == FALSE) {
- fprintf(stderr,
- "Absolute path detected, removing leading slashes\n");
- }
-
- warnedRoot = TRUE;
+ 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);
}
- /*
- * See if we want this file to be restored.
- * If not, then set up to skip it.
- */
- if (wantFileName(outName, argc, argv) == FALSE) {
- if (!hardLink && !softLink && (S_ISREG(mode) || S_ISCHR(mode)
- || S_ISBLK(mode) || S_ISSOCK(mode)
- || S_ISFIFO(mode))) {
- inHeader = (size == 0) ? TRUE : FALSE;
- dataCc = size;
- }
-
- skipFileFlag = TRUE;
+ /* 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);
- return;
+ /* 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);
}
-
- /*
- * This file is to be handled.
- * If we aren't extracting then just list information about the file.
- */
- if (extractFlag == FALSE) {
- if (verboseFlag == TRUE) {
- printf("%s %3d/%-d ", modeString(mode), uid, gid);
- if (S_ISCHR(mode) || S_ISBLK(mode))
- printf("%4d,%4d %s ", major, minor, timeString(mtime));
- else
- printf("%9ld %s ", size, timeString(mtime));
- }
- printf("%s", outName);
-
- if (hardLink)
- printf(" (link to \"%s\")", hp->linkName);
- else if (softLink)
- printf(" (symlink to \"%s\")", hp->linkName);
- else if (S_ISREG(mode) || S_ISCHR(mode) || S_ISBLK(mode) ||
- S_ISSOCK(mode) || S_ISFIFO(mode)) {
- inHeader = (size == 0) ? TRUE : FALSE;
- dataCc = size;
- }
-
- printf("\n");
-
- return;
+ /* 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) */
- /*
- * We really want to extract the file.
- */
- if (verboseFlag == TRUE)
- printf("x %s\n", outName);
+ if (tbInfo->verboseFlag) {
+ FILE *vbFd = stdout;
- if (hardLink) {
- if (link(hp->linkName, outName) < 0) {
- perror(outName);
- return;
- }
- /* Set the file time */
- utb.actime = mtime;
- utb.modtime = mtime;
- utime(outName, &utb);
- /* Set the file permissions */
- chown(outName, uid, gid);
- chmod(outName, mode);
- return;
- }
+ if (tbInfo->tarFd == fileno(stdout)) /* If the archive goes to stdout, verbose to stderr */
+ vbFd = stderr;
- if (softLink) {
-#ifdef S_ISLNK
- if (symlink(hp->linkName, outName) < 0) {
- perror(outName);
- return;
- }
- /* Try to change ownership of the symlink.
- * If libs doesn't support that, don't bother.
- * Changing the pointed-to file is the Wrong Thing(tm).
- */
-#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
- lchown(outName, uid, gid);
-#endif
-
- /* Do not change permissions or date on symlink,
- * since it changes the pointed to file instead. duh. */
-#else
- fprintf(stderr, "Cannot create symbolic links\n");
-#endif
- return;
+ fprintf(vbFd, "%s\n", header.name);
}
- /* Set the umask for this process so it doesn't
- * screw things up. */
- umask(0);
+ return (TRUE);
+}
- /*
- * If the file is a directory, then just create the path.
- */
- if (S_ISDIR(mode)) {
- if (createPath(outName, mode) == TRUE) {
- /* make the final component, just in case it was
- * omitted by createPath() (which will skip the
- * directory if it doesn't have a terminating '/')
- */
- mkdir(outName, mode);
-
- /* Set the file time */
- utb.actime = mtime;
- utb.modtime = mtime;
- utime(outName, &utb);
- /* Set the file permissions */
- chown(outName, uid, gid);
- chmod(outName, mode);
- return;
- }
- return;
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+static inline int exclude_file(const llist_t *excluded_files, const char *file)
+{
+ if (excluded_files == NULL) {
+ return 0;
}
- /*
- * There is a file to write.
- * First create the path to it if necessary with default permissions.
- */
- createPath(outName, 0777);
-
- inHeader = (size == 0) ? TRUE : FALSE;
- dataCc = size;
-
- /*
- * Start the output file.
- */
- if (tostdoutFlag == TRUE)
- outFd = fileno(stdout);
- else {
- if (S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode)) {
- devFileFlag = TRUE;
- outFd = mknod(outName, mode, makedev(major, minor));
- } else if (S_ISFIFO(mode)) {
- devFileFlag = TRUE;
- outFd = mkfifo(outName, mode);
+ while (excluded_files) {
+ if (excluded_files->data[0] == '/') {
+ if (fnmatch(excluded_files->data, file,
+ FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+ return 1;
} else {
- outFd = open(outName, O_WRONLY | O_CREAT | O_TRUNC, mode);
- }
- if (outFd < 0) {
- perror(outName);
- skipFileFlag = TRUE;
- return;
+ 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;
+ }
}
- /* Set the file time */
- utb.actime = mtime;
- utb.modtime = mtime;
- utime(outName, &utb);
- /* Set the file permissions */
- chown(outName, uid, gid);
- chmod(outName, mode);
+ excluded_files = excluded_files->link;
}
-
- /*
- * If the file is empty, then that's all we need to do.
- */
- if (size == 0 && (tostdoutFlag == FALSE) && (devFileFlag == FALSE)) {
- close(outFd);
- outFd = -1;
- }
+ return 0;
}
+#endif
-
-/*
- * Handle a data block of some specified size that was read.
- */
-static void readData(const char *cp, int count)
+static int writeFileToTarball(const char *fileName, struct stat *statbuf,
+ void *userData)
{
- /*
- * 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 == FALSE || skipFileFlag == TRUE)
- return;
+ struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData;
+ const char *header_name;
- /*
- * Write the data to the output file.
+ /*
+ ** 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.
*/
- if (fullWrite(outFd, cp, count) < 0) {
- perror(outName);
- if (tostdoutFlag == FALSE) {
- close(outFd);
- outFd = -1;
- }
- skipFileFlag = TRUE;
- return;
+ tbInfo->hlInfo = NULL;
+ if (statbuf->st_nlink > 1) {
+ tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf);
+ if (tbInfo->hlInfo == NULL)
+ addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, fileName);
}
- /*
- * Check if we are done writing to the file now.
- */
- if (dataCc <= 0 && tostdoutFlag == FALSE) {
- struct utimbuf utb;
-
- if (close(outFd))
- perror(outName);
-
- /* Set the file time */
- utb.actime = mtime;
- utb.modtime = mtime;
- utime(outName, &utb);
- /* Set the file permissions */
- chown(outName, uid, gid);
- chmod(outName, mode);
-
- outFd = -1;
+ /* It is against the rules to archive a socket */
+ if (S_ISSOCK(statbuf->st_mode)) {
+ bb_error_msg("%s: socket ignored", fileName);
+ return (TRUE);
}
-}
-
-
-/*
- * 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 argc, char **argv)
-{
- const char *pathName;
- int fileLength;
- int pathLength;
- /*
- * If there are no files in the list, then the file is wanted.
- */
- if (argc == 0)
- return TRUE;
-
- fileLength = strlen(fileName);
-
- /*
- * Check each of the test paths.
- */
- while (argc-- > 0) {
- pathName = *argv++;
-
- pathLength = strlen(pathName);
-
- if (fileLength < pathLength)
- continue;
+ /* 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);
+ }
- if (memcmp(fileName, pathName, pathLength) != 0)
- continue;
+ header_name = fileName;
+ while (header_name[0] == '/') {
+ static int alreadyWarned = FALSE;
- if ((fileLength == pathLength) || (fileName[pathLength] == '/')) {
- return TRUE;
+ if (alreadyWarned == FALSE) {
+ bb_error_msg("Removing leading '/' from member names");
+ alreadyWarned = TRUE;
}
+ header_name++;
}
- return FALSE;
-}
-
-
-/* From here to the end of the file is the tar writing stuff.
- * If you do not have BB_FEATURE_TAR_CREATE defined, this will
- * not be built.
- * */
-#ifdef BB_FEATURE_TAR_CREATE
+ if (strlen(fileName) >= NAME_SIZE) {
+ bb_error_msg(bb_msg_name_longer_than_foo, NAME_SIZE);
+ return (TRUE);
+ }
-/*
- * Write a tar file containing the specified files.
- */
-static void writeTarFile(int argc, char **argv)
-{
- struct stat statbuf;
+ if (header_name[0] == '\0')
+ return TRUE;
- /*
- * Make sure there is at least one file specified.
- */
- if (argc <= 0) {
- fprintf(stderr, "No files specified to be saved\n");
- errorFlag = TRUE;
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+ if (exclude_file(tbInfo->excludeList, header_name)) {
+ return SKIP;
}
+# endif /* CONFIG_FEATURE_TAR_EXCLUDE */
- /*
- * Create the tar file for writing.
- */
- if ((tarName == NULL) || !strcmp(tarName, "-")) {
- tostdoutFlag = TRUE;
- tarFd = fileno(stdout);
- } else
- tarFd = open(tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
-
- if (tarFd < 0) {
- perror(tarName);
- errorFlag = TRUE;
- return;
+ if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) {
+ return (FALSE);
}
- /*
- * Get the device and inode of the tar file for checking later.
- */
- if (fstat(tarFd, &statbuf) < 0) {
- perror(tarName);
- errorFlag = TRUE;
- goto done;
- }
+ /* 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;
- tarDev = statbuf.st_dev;
- tarInode = statbuf.st_ino;
+ /* 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);
+ }
- /*
- * Append each file name into the archive file.
- * Follow symbolic links for these top level file names.
- */
- while (errorFlag == FALSE && (argc-- > 0)) {
- saveFile(*argv++, FALSE);
+ /* 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);
}
- /*
- * 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 (TRUE);
}
-/*
- * 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 inline int writeTarFile(const int tar_fd, const int verboseFlag,
+ const llist_t *include, const llist_t *exclude, const int gzip)
{
- int status;
- struct stat statbuf;
-
- if (verboseFlag == TRUE)
- 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);
-
- return;
- }
-
- /*
- * Find out about the file.
- */
-#ifdef S_ISLNK
- if (seeLinks == TRUE)
- status = lstat(fileName, &statbuf);
- else
+#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
- status = stat(fileName, &statbuf);
-
- if (status < 0) {
- perror(fileName);
-
- return;
- }
-
- /*
- * 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");
-
- return;
- }
-
- /*
- * Check the type of file.
- */
- mode = statbuf.st_mode;
- if (S_ISDIR(mode)) {
- saveDirectory(fileName, &statbuf);
+ int errorFlag = FALSE;
+ ssize_t size;
+ struct TarBallInfo tbInfo;
- return;
- }
- if (S_ISREG(mode)) {
- saveRegularFile(fileName, &statbuf);
+ tbInfo.hlInfoHead = NULL;
- return;
+ /* 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");
}
- /* Some day add support for tarring these up... but not today. :) */
-// if (S_ISLNK(mode) || S_ISFIFO(mode) || S_ISBLK(mode) || S_ISCHR (mode) ) {
-// fprintf (stderr, "%s: This version of tar can't store this type of file\n", fileName);
-// }
+ fchmod(tar_fd, 0644);
+ tbInfo.tarFd = tar_fd;
+ tbInfo.verboseFlag = verboseFlag;
- /*
- * The file is a strange type of file, ignore it.
- */
- fprintf(stderr, "%s: not a directory or regular file\n", fileName);
-}
-
-
-/*
- * Save a regular file to the tar file.
- */
-static void
-saveRegularFile(const char *fileName, const struct stat *statbuf)
-{
- int sawEof;
- int fileFd;
- int cc;
- int dataCount;
- long fullDataCount;
- char data[TAR_BLOCK_SIZE * 16];
-
- /*
- * Open the file for reading.
- */
- fileFd = open(fileName, O_RDONLY);
+ /* 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 (fileFd < 0) {
- perror(fileName);
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ if (gzip) {
+ if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0) {
+ bb_perror_msg_and_die("Failed to create gzip pipe");
+ }
- return;
- }
+ signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
- /*
- * Write out the header for the file.
- */
- writeHeader(fileName, statbuf);
+# if __GNUC__
+ /* Avoid vfork clobbering */
+ (void) &include;
+ (void) &errorFlag;
+# endif
+
+ gzipPid = vfork();
- /*
- * 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;
+ if (gzipPid == 0) {
+ dup2(gzipDataPipe[0], 0);
+ close(gzipDataPipe[1]);
- 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);
+ if (tbInfo.tarFd != 1);
+ dup2(tbInfo.tarFd, 1);
- if (dataCount > fullDataCount)
- dataCount = (int) fullDataCount;
+ close(gzipStatusPipe[0]);
+ fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC); /* close on exec shows sucess */
- /*
- * Read the data from the file if we haven't seen the
- * end of file yet.
- */
- cc = 0;
+ execl("/bin/gzip", "gzip", "-f", 0);
+ vfork_exec_errno = errno;
- if (sawEof == FALSE) {
- cc = fullRead(fileFd, data, dataCount);
+ close(gzipStatusPipe[1]);
+ exit(-1);
+ } else if (gzipPid > 0) {
+ close(gzipDataPipe[0]);
+ close(gzipStatusPipe[1]);
- if (cc < 0) {
- perror(fileName);
+ while (1) {
+ char buf;
- (void) close(fileFd);
- errorFlag = TRUE;
+ int n = bb_full_read(gzipStatusPipe[0], &buf, 1);
- return;
+ 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]);
- /*
- * 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);
-
- sawEof = TRUE;
- }
+ tbInfo.tarFd = gzipDataPipe[1];
+ } else {
+ bb_perror_msg_and_die("Failed to vfork gzip process");
}
-
- /*
- * Zero fill the rest of the data if necessary.
- */
- if (cc < dataCount)
- memset(data + cc, 0, dataCount - cc);
-
- /*
- * Write the buffer to the TAR file.
- */
- writeTarBlock(data, dataCount);
-
- fullDataCount -= dataCount;
}
+#endif
- /*
- * Close the file.
- */
- if ((tostdoutFlag == FALSE) && close(fileFd) < 0)
- fprintf(stderr, "%s: close: %s\n", fileName, strerror(errno));
-}
-
-
-/*
- * 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[PATH_MAX + 1];
-
- /*
- * 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;
- }
+ tbInfo.excludeList = exclude;
- /*
- * 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 == FALSE && ((entry = readdir(dir)) != NULL)) {
- if ((strcmp(entry->d_name, ".") == 0) ||
- (strcmp(entry->d_name, "..") == 0)) {
- continue;
+ /* 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);
+ }
- /*
- * Build the full path name to the file.
- */
- strcpy(fullName, dirName);
+ /* 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 */
- if (needSlash)
- strcat(fullName, "/");
+ /* Hang up the tools, close up shop, head home */
+ close(tbInfo.tarFd);
+ if (errorFlag)
+ bb_error_msg("Error exit delayed from previous errors");
- strcat(fullName, entry->d_name);
+ freeHardLinkInfo(&tbInfo.hlInfoHead);
- /*
- * Write this file to the tar file, noticing whether or not
- * the file is a symbolic link.
- */
- saveFile(fullName, TRUE);
+#ifdef CONFIG_FEATURE_TAR_GZIP
+ if (gzip && gzipPid) {
+ if (waitpid(gzipPid, NULL, 0) == -1)
+ printf("Couldnt wait ?");
}
+#endif
- /*
- * All done, close the directory.
- */
- closedir(dir);
+ return !errorFlag;
}
+#endif /* tar_create */
-
-/*
- * 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)
+#ifdef CONFIG_FEATURE_TAR_EXCLUDE
+static llist_t *append_file_list_to_list(llist_t *list)
{
- 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));
+ 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
- cp = (const unsigned char *) &header;
- len = sizeof(header);
- checkSum = 0;
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+static char get_header_tar_Z(archive_handle_t *archive_handle)
+{
+ /* Cant lseek over pipe's */
+ archive_handle->seek = seek_by_char;
- while (len-- > 0)
- checkSum += *cp++;
+ /* 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");
+ }
- putOctal(header.checkSum, sizeof(header.checkSum), checkSum);
+ archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress);
+ archive_handle->offset = 0;
+ while (get_header_tar(archive_handle) == EXIT_SUCCESS);
- /*
- * Write the tar header.
- */
- writeTarBlock((const char *) &header, sizeof(header));
+ /* Can only do one file at a time */
+ return(EXIT_FAILURE);
}
+#endif
-
-/*
- * 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)
+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)
{
- int partialLength;
- int completeLength;
- char fullBlock[TAR_BLOCK_SIZE];
-
- /*
- * If we had a write error before, then do nothing more.
- */
- if (errorFlag == TRUE)
- 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);
+ 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();
+ }
+
+ /* Prepend '-' to the first argument if required */
+ if (argv[1][0] != '-') {
+ char *tmp;
+
+ bb_xasprintf(&tmp, "-%s", argv[1]);
+ argv[1] = tmp;
+ }
+
+ /* 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;
+ }
- errorFlag = TRUE;
+ 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++;
+ }
- return;
+ /* 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 there are no partial blocks left, we are done.
- */
- if (partialLength == 0)
- return;
+ if ((tar_handle->accept) || (tar_handle->reject)) {
+ tar_handle->filter = filter_accept_reject_list;
+ }
- /*
- * 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);
+ /* Open the tar file */
+ {
+ FILE *tar_stream;
+ int flags;
- /*
- * Write the last complete block.
- */
- if (!fullWrite(tarFd, fullBlock, TAR_BLOCK_SIZE)) {
- perror(tarName);
+#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;
+ }
- errorFlag = TRUE;
+ 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);
+ }
}
-}
-
-
-/*
- * 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;
+ if ((base_dir) && (chdir(base_dir))) {
+ bb_perror_msg_and_die("Couldnt chdir to %s", base_dir);
+ }
- sprintf(tempString, " %0*lo", len - 2, value);
+#ifdef CONFIG_FEATURE_TAR_CREATE
+ /* create an archive */
+ if (ctx_flag == CTX_CREATE) {
+ int verboseFlag = FALSE;
+ int gzipFlag = FALSE;
- tempLength = strlen(tempString) + 1;
+# 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 the string is too large, suppress the leading space.
- */
- if (tempLength > len) {
- tempLength--;
- tempString++;
+ 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 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);
+#ifdef CONFIG_FEATURE_CLEAN_UP
+ if (tar_handle->src_fd != fileno(stdin)) {
+ close(tar_handle->src_fd);
+ }
+#endif /* CONFIG_FEATURE_CLEAN_UP */
- return TRUE;
+ return(EXIT_SUCCESS);
}
-#endif
-
-/* END CODE */
-#endif
projects / oweals / busybox.git / blobdiff