X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Ftar.c;h=6af16f4bd82cbbd9c0c9a4dc99424f737c501e30;hb=a17b3631fe866ba84f2be753e28b4ac5cac45341;hp=d316611846e36b9897a272b8bfff12eca069b1f4;hpb=43c8c38bbfe3d25e21f37d899184de52c6dc9c17;p=oweals%2Fbusybox.git diff --git a/archival/tar.c b/archival/tar.c index d31661184..6af16f4bd 100644 --- a/archival/tar.c +++ b/archival/tar.c @@ -6,7 +6,7 @@ * 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) 2000 by Lineo, inc. + * Copyright (C) 1999,2000,2001 by Lineo, inc. * Written by Erik Andersen , * * Based in part in the tar implementation in sash @@ -36,10 +36,6 @@ */ -#include "internal.h" -#define BB_DECLARE_EXTERN -#define bb_need_io_error -#include "messages.c" #include #include #include @@ -50,6 +46,11 @@ #include #include #include +#include +#include +#include +#include +#include "busybox.h" /* Tar file constants */ #ifndef MAJOR @@ -57,12 +58,13 @@ #define MINOR(dev) ((dev)&0xff) #endif +enum { NAME_SIZE = 100 }; /* because gcc won't let me use 'static const int' */ /* POSIX tar Header Block, from POSIX 1003.1-1990 */ struct TarHeader { /* byte offset */ - char name[100]; /* 0-99 */ + char name[NAME_SIZE]; /* 0-99 */ char mode[8]; /* 100-107 */ char uid[8]; /* 108-115 */ char gid[8]; /* 116-123 */ @@ -70,7 +72,7 @@ struct TarHeader char mtime[12]; /* 136-147 */ char chksum[8]; /* 148-155 */ char typeflag; /* 156-156 */ - char linkname[100]; /* 157-256 */ + char linkname[NAME_SIZE]; /* 157-256 */ char magic[6]; /* 257-262 */ char version[2]; /* 263-264 */ char uname[32]; /* 265-296 */ @@ -86,9 +88,9 @@ typedef struct TarHeader TarHeader; /* A few useful constants */ #define TAR_MAGIC "ustar" /* ustar and a null */ #define TAR_VERSION " " /* Be compatable with GNU tar format */ -#define TAR_MAGIC_LEN 6 -#define TAR_VERSION_LEN 2 -#define TAR_BLOCK_SIZE 512 +static const int TAR_MAGIC_LEN = 6; +static const int TAR_VERSION_LEN = 2; +static const int TAR_BLOCK_SIZE = 512; /* A nice enum with all the possible tar file content types */ enum TarFileType @@ -102,6 +104,8 @@ enum TarFileType 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; @@ -125,108 +129,174 @@ struct TarInfo typedef struct TarInfo TarInfo; /* Local procedures to restore files from a tar file. */ -static int readTarFile(const char* tarName, int extractFlag, int listFlag, +static int readTarFile(int tarFd, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag, char** extractList, char** excludeList); - - #ifdef BB_FEATURE_TAR_CREATE /* Local procedures to save files into a tar file. */ -static int writeTarFile(const char* tarName, int tostdoutFlag, - int verboseFlag, int argc, char **argv, char** excludeList); +static int writeTarFile(const char* tarName, int verboseFlag, char **argv, + char** excludeList); #endif -static struct option longopts[] = -{ -#ifdef BB_FEATURE_TAR_EXCLUDE - {"exclude",required_argument,NULL,'e'}, -#endif - {NULL,0,NULL,0} +#if defined BB_FEATURE_TAR_EXCLUDE +static struct option longopts[] = { + { "exclude", 1, NULL, 'e' }, + { NULL, 0, NULL, 0 } }; +#endif extern int tar_main(int argc, char **argv) { char** excludeList=NULL; + char** extractList=NULL; + const char *tarName="-"; #if defined BB_FEATURE_TAR_EXCLUDE int excludeListSize=0; + FILE *fileList; + char file[256]; +#endif +#if defined BB_FEATURE_TAR_GZIP + FILE *comp_file = NULL; + int unzipFlag = FALSE; #endif - const char *tarName="-"; int listFlag = FALSE; int extractFlag = FALSE; int createFlag = FALSE; int verboseFlag = FALSE; int tostdoutFlag = FALSE; + int status = FALSE; int opt; + pid_t pid; if (argc <= 1) - usage(tar_usage); + show_usage(); - /* do normal option parsing */ - while ((opt = getopt_long(argc, argv, "cxtvOf:", longopts, NULL)) != EOF) { + if (argv[1][0] != '-') { + char *tmp = xmalloc(strlen(argv[1]) + 2); + tmp[0] = '-'; + strcpy(tmp + 1, argv[1]); + argv[1] = tmp; + } + + while ( +#ifndef BB_FEATURE_TAR_EXCLUDE + (opt = getopt(argc, argv, "cxtzvOf:")) +#else + (opt = getopt_long(argc, argv, "cxtzvOf:X:", longopts, NULL)) +#endif + > 0) { switch (opt) { - case 'c': - if (extractFlag == TRUE || listFlag == TRUE) - goto flagError; - createFlag = TRUE; - break; - case 'x': - if (listFlag == TRUE || createFlag == TRUE) - goto flagError; - extractFlag = TRUE; - break; - case 't': - if (extractFlag == TRUE || createFlag == TRUE) - goto flagError; - listFlag = TRUE; - break; - case 'v': - verboseFlag = TRUE; - break; - case 'O': - tostdoutFlag = TRUE; - tarName = "-"; - break; - case 'f': - if (*tarName != '-') - fatalError( "Only one 'f' option allowed\n"); - tarName = optarg; - if (!strcmp(tarName, "-") && createFlag == TRUE) - tostdoutFlag = TRUE; - break; + case 'c': + if (extractFlag == TRUE || listFlag == TRUE) + goto flagError; + createFlag = TRUE; + break; + case 'x': + if (listFlag == TRUE || createFlag == TRUE) + goto flagError; + extractFlag = TRUE; + break; + case 't': + if (extractFlag == TRUE || createFlag == TRUE) + goto flagError; + listFlag = TRUE; + break; +#ifdef BB_FEATURE_TAR_GZIP + case 'z': + unzipFlag = TRUE; + break; +#endif + case 'v': + verboseFlag = TRUE; + break; + case 'O': + tostdoutFlag = TRUE; + break; + case 'f': + if (*tarName != '-') + error_msg_and_die( "Only one 'f' option allowed"); + tarName = optarg; + break; #if defined BB_FEATURE_TAR_EXCLUDE - case 'e': - excludeList=xrealloc( excludeList, sizeof(char**) * (excludeListSize+2)); - excludeList[excludeListSize] = optarg; - /* Remove leading "/"s */ - if (*excludeList[excludeListSize] =='/') - excludeList[excludeListSize] = (excludeList[excludeListSize])+1; + case 'e': + excludeList=xrealloc( excludeList, + sizeof(char *) * (excludeListSize+2)); + excludeList[excludeListSize] = optarg; + /* Tack a NULL onto the end of the list */ + excludeList[++excludeListSize] = NULL; + case 'X': + fileList = xfopen(optarg, "r"); + while (fgets(file, sizeof(file), fileList) != NULL) { + excludeList = xrealloc(excludeList, + sizeof(char *) * (excludeListSize+2)); + chomp(file); + excludeList[excludeListSize] = xstrdup(file); /* Tack a NULL onto the end of the list */ excludeList[++excludeListSize] = NULL; - break; + } + fclose(fileList); + break; #endif default: - usage(tar_usage); + show_usage(); } } - /* + /* * 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"); + error_msg_and_die( "This version of tar was not compiled with tar creation support."); #else - exit(writeTarFile(tarName, tostdoutFlag, verboseFlag, argc-optind, &argv[optind], excludeList)); +#ifdef BB_FEATURE_TAR_GZIP + if (unzipFlag==TRUE) + error_msg_and_die("Creation of compressed not internally support by tar, pipe to busybox gunzip"); +#endif + status = writeTarFile(tarName, verboseFlag, argv + optind, excludeList); #endif } if (listFlag == TRUE || extractFlag == TRUE) { - exit(readTarFile(tarName, extractFlag, listFlag, tostdoutFlag, verboseFlag, &argv[optind], excludeList)); + int tarFd; + if (argv[optind]) + extractList = argv + optind; + /* Open the tar file for reading. */ + if (!strcmp(tarName, "-")) + tarFd = fileno(stdin); + else + tarFd = open(tarName, O_RDONLY); + if (tarFd < 0) + perror_msg_and_die("Error opening '%s'", tarName); + +#ifdef BB_FEATURE_TAR_GZIP + /* unzip tarFd in a seperate process */ + if (unzipFlag == TRUE) { + comp_file = fdopen(tarFd, "r"); + if ((tarFd = gz_open(comp_file, &pid)) == EXIT_FAILURE) { + error_msg_and_die("Couldnt unzip file"); + } + } +#endif + status = readTarFile(tarFd, extractFlag, listFlag, tostdoutFlag, + verboseFlag, extractList, excludeList); + close(tarFd); +#ifdef BB_FEATURE_TAR_GZIP + if (unzipFlag == TRUE) { + gz_close(pid); + fclose(comp_file); + } +#endif } + if (status == TRUE) + return EXIT_SUCCESS; + else + return EXIT_FAILURE; + flagError: - fatalError( "Exactly one of 'c', 'x' or 't' must be specified\n"); + error_msg_and_die( "Exactly one of 'c', 'x' or 't' must be specified"); } static void @@ -256,10 +326,10 @@ tarExtractRegularFile(TarInfo *header, int extractFlag, int tostdoutFlag) if (extractFlag==TRUE && tostdoutFlag==FALSE) { /* Create the path to the file, just in case it isn't there... * This should not screw up path permissions or anything. */ - createPath(header->name, 0777); + create_path(header->name, 0777); if ((outFd=open(header->name, O_CREAT|O_TRUNC|O_WRONLY, header->mode & ~S_IFMT)) < 0) { - errorMsg(io_error, header->name, strerror(errno)); + error_msg(io_error, header->name, strerror(errno)); return( FALSE); } } @@ -277,9 +347,9 @@ tarExtractRegularFile(TarInfo *header, int extractFlag, int tostdoutFlag) readSize = size; writeSize = size; } - if ( (readSize = fullRead(header->tarFd, buffer, readSize)) <= 0 ) { + if ( (readSize = full_read(header->tarFd, buffer, readSize)) <= 0 ) { /* Tarball seems to have a problem */ - errorMsg("Unexpected EOF in archive\n"); + error_msg("Unexpected EOF in archive"); return( FALSE); } if ( readSize < writeSize ) @@ -288,9 +358,9 @@ tarExtractRegularFile(TarInfo *header, int extractFlag, int tostdoutFlag) /* Write out the file, if we are supposed to be doing that */ if (extractFlag==TRUE) { - if ((actualWriteSz=fullWrite(outFd, buffer, writeSize)) != writeSize ) { + if ((actualWriteSz=full_write(outFd, buffer, writeSize)) != writeSize ) { /* Output file seems to have a problem */ - errorMsg(io_error, header->name, strerror(errno)); + error_msg(io_error, header->name, strerror(errno)); return( FALSE); } } else { @@ -312,21 +382,27 @@ tarExtractRegularFile(TarInfo *header, int extractFlag, int tostdoutFlag) static int tarExtractDirectory(TarInfo *header, int extractFlag, int tostdoutFlag) { + int result; if (extractFlag==FALSE || tostdoutFlag==TRUE) return( TRUE); - if (createPath(header->name, header->mode) != TRUE) { - errorMsg("%s: Cannot mkdir: %s\n", - header->name, strerror(errno)); + if (create_path(header->name, header->mode) != TRUE) { + perror_msg("%s: Cannot mkdir", header->name); return( FALSE); } /* make the final component, just in case it was - * omitted by createPath() (which will skip the + * omitted by create_path() (which will skip the * directory if it doesn't have a terminating '/') */ - if (mkdir(header->name, header->mode) == 0) { + result = mkdir(header->name, header->mode); + /* Don't fix permissions on pre-existing directories */ + if (result == 0) { fixUpPermissions(header); + } else if (result < 0 && errno != EEXIST) { + perror_msg("%s", header->name); + return FALSE; } + return( TRUE); } @@ -337,8 +413,8 @@ tarExtractHardLink(TarInfo *header, int extractFlag, int tostdoutFlag) return( TRUE); if (link(header->linkname, header->name) < 0) { - errorMsg("%s: Cannot create hard link to '%s': %s\n", - header->name, header->linkname, strerror(errno)); + perror_msg("%s: Cannot create hard link to '%s'", header->name, + header->linkname); return( FALSE); } @@ -355,8 +431,8 @@ tarExtractSymLink(TarInfo *header, int extractFlag, int tostdoutFlag) #ifdef S_ISLNK if (symlink(header->linkname, header->name) < 0) { - errorMsg("%s: Cannot create symlink to '%s': %s\n", - header->name, header->linkname, strerror(errno)); + perror_msg("%s: Cannot create symlink to '%s'", header->name, + header->linkname); return( FALSE); } /* Try to change ownership of the symlink. @@ -370,7 +446,7 @@ tarExtractSymLink(TarInfo *header, int extractFlag, int tostdoutFlag) /* Do not change permissions or date on symlink, * since it changes the pointed to file instead. duh. */ #else - errorMsg("%s: Cannot create symlink to '%s': %s\n", + error_msg("%s: Cannot create symlink to '%s': %s", header->name, header->linkname, "symlinks not supported"); #endif @@ -385,14 +461,12 @@ tarExtractSpecial(TarInfo *header, int extractFlag, int tostdoutFlag) if (S_ISCHR(header->mode) || S_ISBLK(header->mode) || S_ISSOCK(header->mode)) { if (mknod(header->name, header->mode, makedev(header->devmajor, header->devminor)) < 0) { - errorMsg("%s: Cannot mknod: %s\n", - header->name, strerror(errno)); + perror_msg("%s: Cannot mknod", header->name); return( FALSE); } } else if (S_ISFIFO(header->mode)) { if (mkfifo(header->name, header->mode) < 0) { - errorMsg("%s: Cannot mkfifo: %s\n", - header->name, strerror(errno)); + perror_msg("%s: Cannot mkfifo", header->name); return( FALSE); } } @@ -402,26 +476,6 @@ tarExtractSpecial(TarInfo *header, int extractFlag, int tostdoutFlag) return( TRUE); } -/* 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; - - 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; -} - - /* Parse the tar header and fill in the nice struct with the details */ static int readTarHeader(struct TarHeader *rawHeader, struct TarInfo *header) @@ -439,21 +493,21 @@ readTarHeader(struct TarHeader *rawHeader, struct TarInfo *header) ++*(header->name); if (alreadyWarned == FALSE) { - errorMsg("Removing leading '/' from member names\n"); + error_msg("Removing leading '/' from member names"); alreadyWarned = TRUE; } } - 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->mode = strtol(rawHeader->mode, NULL, 8); + header->uid = strtol(rawHeader->uid, NULL, 8); + header->gid = strtol(rawHeader->gid, NULL, 8); + header->size = strtol(rawHeader->size, NULL, 8); + header->mtime = strtol(rawHeader->mtime, NULL, 8); + chksum = strtol(rawHeader->chksum, NULL, 8); header->type = rawHeader->typeflag; header->linkname = rawHeader->linkname; - header->devmajor = getOctal(rawHeader->devmajor, sizeof(rawHeader->devmajor)); - header->devminor = getOctal(rawHeader->devminor, sizeof(rawHeader->devminor)); + header->devmajor = strtol(rawHeader->devmajor, NULL, 8); + header->devminor = strtol(rawHeader->devminor, NULL, 8); /* Check the checksum */ for (i = sizeof(*rawHeader); i-- != 0;) { @@ -471,139 +525,173 @@ readTarHeader(struct TarHeader *rawHeader, struct TarInfo *header) return( FALSE); } +static int exclude_file(char **excluded_files, const char *file) +{ + int i; + + if (excluded_files == NULL) + return 0; + + for (i = 0; excluded_files[i] != NULL; i++) { + if (excluded_files[i][0] == '/') { + if (fnmatch(excluded_files[i], 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[i], p, + FNM_PATHNAME | FNM_LEADING_DIR) == 0) + return 1; + } + } + } + + return 0; +} + +static int extract_file(char **extract_files, const char *file) +{ + int i; + + if (extract_files == NULL) + return 1; + + for (i = 0; extract_files[i] != NULL; i++) { + if (fnmatch(extract_files[i], file, FNM_LEADING_DIR) == 0) + return 1; + } + + return 0; +} /* * 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, +static int readTarFile(int tarFd, int extractFlag, int listFlag, int tostdoutFlag, int verboseFlag, char** extractList, char** excludeList) { - int status, tarFd=-1; + int status; int errorFlag=FALSE; + int skipNextHeaderFlag=FALSE; TarHeader rawHeader; TarInfo header; - char** tmpList; - - /* 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\n", tarName, strerror(errno)); - return ( FALSE); - } /* Set the umask for this process so it doesn't * screw up permission setting for us later. */ umask(0); /* Read the tar file, and iterate over it one file at a time */ - while ( (status = fullRead(tarFd, (char*)&rawHeader, TAR_BLOCK_SIZE)) == TAR_BLOCK_SIZE ) { + while ( (status = full_read(tarFd, (char*)&rawHeader, TAR_BLOCK_SIZE)) == TAR_BLOCK_SIZE ) { - /* First, try to read the header */ + /* Try to read the header */ if ( readTarHeader(&rawHeader, &header) == FALSE ) { if ( *(header.name) == '\0' ) { goto endgame; } else { errorFlag=TRUE; - errorMsg("Bad tar header, skipping\n"); + error_msg("Bad tar header, skipping"); continue; } } if ( *(header.name) == '\0' ) - goto endgame; + continue; header.tarFd = tarFd; + /* Skip funky extra GNU headers that precede long files */ + if ( (header.type == GNULONGNAME) || (header.type == GNULONGLINK) ) { + skipNextHeaderFlag=TRUE; + if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE) + errorFlag = TRUE; + continue; + } + if ( skipNextHeaderFlag == TRUE ) { + skipNextHeaderFlag=FALSE; + error_msg(name_longer_than_foo, NAME_SIZE); + if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE) + errorFlag = TRUE; + continue; + } + #if defined BB_FEATURE_TAR_EXCLUDE - { - int skipFlag=FALSE; - /* Check for excluded files.... */ - for (tmpList=excludeList; tmpList && *tmpList; tmpList++) { - /* Do some extra hoop jumping for when directory names - * end in '/' but the entry in tmpList doesn't */ - if (strncmp( *tmpList, header.name, strlen(*tmpList))==0 || ( - header.name[strlen(header.name)-1]=='/' - && strncmp( *tmpList, header.name, - MIN(strlen(header.name)-1, strlen(*tmpList)))==0)) { - /* If it is a regular file, pretend to extract it with - * the extractFlag set to FALSE, so the junk in the tarball - * is properly skipped over */ - if ( header.type==REGTYPE || header.type==REGTYPE0 ) { - tarExtractRegularFile(&header, FALSE, FALSE); - } - skipFlag=TRUE; - break; - } - } + if (exclude_file(excludeList, header.name)) { /* There are not the droids you're looking for, move along */ - if (skipFlag==TRUE) - continue; + /* If it is a regular file, pretend to extract it with + * the extractFlag set to FALSE, so the junk in the tarball + * is properly skipped over */ + if ( header.type==REGTYPE || header.type==REGTYPE0 ) { + if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE) + errorFlag = TRUE; + } + continue; } #endif - if (*extractList != NULL) { - int skipFlag = TRUE; - for (tmpList = extractList; *tmpList != NULL; tmpList++) { - if (strncmp( *tmpList, header.name, strlen(*tmpList))==0 || ( - header.name[strlen(header.name)-1]=='/' - && strncmp( *tmpList, header.name, - MIN(strlen(header.name)-1, strlen(*tmpList)))==0)) { - /* If it is a regular file, pretend to extract it with - * the extractFlag set to FALSE, so the junk in the tarball - * is properly skipped over */ - skipFlag = FALSE; - break; - } - } + + if (!extract_file(extractList, header.name)) { /* There are not the droids you're looking for, move along */ - if (skipFlag == TRUE) { - if ( header.type==REGTYPE || header.type==REGTYPE0 ) - tarExtractRegularFile(&header, FALSE, FALSE); - continue; + /* If it is a regular file, pretend to extract it with + * the extractFlag set to FALSE, so the junk in the tarball + * is properly skipped over */ + if ( header.type==REGTYPE || header.type==REGTYPE0 ) { + if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE) + errorFlag = TRUE; } + continue; } - /* Special treatment if the list (-t) flag is on */ - if (verboseFlag == TRUE && extractFlag == FALSE) { - int len, len1; - char buf[35]; - struct tm *tm = localtime (&(header.mtime)); - - len=printf("%s ", modeString(header.mode)); - memset(buf, 0, 8*sizeof(char)); - my_getpwuid(buf, header.uid); - if (! *buf) - len+=printf("%d", header.uid); - else - len+=printf("%s", buf); - memset(buf, 0, 8*sizeof(char)); - my_getgrgid(buf, header.gid); - if (! *buf) - len+=printf("/%-d ", header.gid); - else - len+=printf("/%-s ", buf); - if (header.type==CHRTYPE || header.type==BLKTYPE) { - len1=snprintf(buf, sizeof(buf), "%ld,%-ld ", - header.devmajor, header.devminor); - } else { - len1=snprintf(buf, sizeof(buf), "%lu ", (long)header.size); + if (listFlag == TRUE) { + /* Special treatment if the list (-t) flag is on */ + if (verboseFlag == TRUE) { + int len, len1; + char buf[35]; + struct tm *tm = localtime (&(header.mtime)); + + len=printf("%s ", mode_string(header.mode)); + my_getpwuid(buf, header.uid); + if (! *buf) + len+=printf("%d", header.uid); + else + len+=printf("%s", buf); + my_getgrgid(buf, header.gid); + if (! *buf) + len+=printf("/%-d ", header.gid); + else + len+=printf("/%-s ", buf); + + if (header.type==CHRTYPE || header.type==BLKTYPE) { + len1=snprintf(buf, sizeof(buf), "%ld,%-ld ", + header.devmajor, header.devminor); + } else { + len1=snprintf(buf, sizeof(buf), "%lu ", (long)header.size); + } + /* Jump through some hoops to make the columns match up */ + for(;(len+len1)<31;len++) + printf(" "); + printf(buf); + + /* Use ISO 8610 time format */ + if (tm) { + printf ("%04d-%02d-%02d %02d:%02d:%02d ", + tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, + tm->tm_hour, tm->tm_min, tm->tm_sec); + } } - /* Jump through some hoops to make the columns match up */ - for(;(len+len1)<31;len++) - printf(" "); - printf(buf); - - /* Use ISO 8610 time format */ - if (tm) { - printf ("%04d-%02d-%02d %02d:%02d:%02d ", - tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, - tm->tm_hour, tm->tm_min, tm->tm_sec); + printf("%s", header.name); + if (verboseFlag == TRUE) { + if (header.type==LNKTYPE) /* If this is a link, say so */ + printf(" link to %s", header.linkname); + else if (header.type==SYMTYPE) + printf(" -> %s", header.linkname); } + printf("\n"); } + /* List contents if we are supposed to do that */ - if (verboseFlag == TRUE && listFlag != TRUE) { + if (verboseFlag == TRUE && extractFlag == TRUE) { /* Now the normal listing */ FILE *vbFd = stdout; if (tostdoutFlag == TRUE) // If the archive goes to stdout, verbose to stderr @@ -611,15 +699,6 @@ static int readTarFile(const char* tarName, int extractFlag, int listFlag, fprintf(vbFd, "%s\n", header.name); } - if (verboseFlag == TRUE && listFlag == TRUE) { - printf("%s", header.name); - if (header.type==LNKTYPE) /* If this is a link, say so */ - printf(" link to %s", header.linkname); - else if (header.type==SYMTYPE) - printf(" -> %s", header.linkname); - printf("\n"); - } - /* Remove files if we would overwrite them */ if (extractFlag == TRUE && tostdoutFlag == FALSE) unlink(header.name); @@ -631,7 +710,7 @@ static int readTarFile(const char* tarName, int extractFlag, int listFlag, 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] != '/') { + if (!last_char_is(header.name,'/')) { if (tarExtractRegularFile(&header, extractFlag, tostdoutFlag)==FALSE) errorFlag=TRUE; break; @@ -654,7 +733,15 @@ static int readTarFile(const char* tarName, int extractFlag, int listFlag, if (tarExtractSpecial( &header, extractFlag, tostdoutFlag)==FALSE) errorFlag=TRUE; break; +#if 0 + /* Handled earlier */ + case GNULONGNAME: + case GNULONGLINK: + skipNextHeaderFlag=TRUE; + break; +#endif default: + error_msg("Unknown file type '%c' in tar file", header.type); close( tarFd); return( FALSE); } @@ -662,11 +749,11 @@ static int readTarFile(const char* tarName, int extractFlag, int listFlag, close(tarFd); if (status > 0) { /* Bummer - we read a partial header */ - errorMsg( "Error reading '%s': %s\n", tarName, strerror(errno)); + perror_msg("Error reading tar file"); return ( FALSE); } else if (errorFlag==TRUE) { - errorMsg( "Error exit delayed from previous errors\n"); + error_msg( "Error exit delayed from previous errors"); return( FALSE); } else return( status); @@ -676,7 +763,7 @@ endgame: close( tarFd); if ( *(header.name) == '\0' ) { if (errorFlag==TRUE) - errorMsg( "Error exit delayed from previous errors\n"); + error_msg( "Error exit delayed from previous errors"); else return( TRUE); } @@ -686,6 +773,21 @@ endgame: #ifdef BB_FEATURE_TAR_CREATE +/* +** 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 { @@ -698,10 +800,62 @@ struct TarBallInfo to include the tarball into itself */ int verboseFlag; /* Whether to print extra stuff or not */ char** 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; +/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */ +static void +addHardLinkInfo (HardLinkInfo **hlInfoHeadPtr, dev_t dev, ino_t ino, + short linkCount, const char *name) +{ + /* Note: hlInfoHeadPtr can never be NULL! */ + HardLinkInfo *hlInfo; + + hlInfo = (HardLinkInfo *)xmalloc(sizeof(HardLinkInfo)+strlen(name)+1); + if (hlInfo) { + hlInfo->next = *hlInfoHeadPtr; + *hlInfoHeadPtr = hlInfo; + hlInfo->dev = dev; + hlInfo->ino = ino; + hlInfo->linkCount = linkCount; + strcpy(hlInfo->name, name); + } + return; +} + +static void +freeHardLinkInfo (HardLinkInfo **hlInfoHeadPtr) +{ + HardLinkInfo *hlInfo = NULL; + HardLinkInfo *hlInfoNext = NULL; + + if (hlInfoHeadPtr) { + hlInfo = *hlInfoHeadPtr; + while (hlInfo) { + hlInfoNext = hlInfo->next; + free(hlInfo); + hlInfo = hlInfoNext; + } + *hlInfoHeadPtr = NULL; + } + return; +} + +/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */ +static HardLinkInfo * +findHardLinkInfo (HardLinkInfo *hlInfo, dev_t dev, ino_t ino) +{ + while(hlInfo) { + if ((ino == hlInfo->ino) && (dev == hlInfo->dev)) + break; + hlInfo = hlInfo->next; + } + return(hlInfo); +} + /* Put an octal string into the specified buffer. * The number is zero and space padded and possibly null padded. * Returns TRUE if successful. */ @@ -738,47 +892,17 @@ static int putOctal (char *cp, int len, long value) /* Write out a tar header for the specified file/directory/whatever */ static int -writeTarHeader(struct TarBallInfo *tbInfo, const char *fileName, struct stat *statbuf) +writeTarHeader(struct TarBallInfo *tbInfo, const char *header_name, + const char *real_name, struct stat *statbuf) { long chksum=0; struct TarHeader header; -#if defined BB_FEATURE_TAR_EXCLUDE - char** tmpList; -#endif const unsigned char *cp = (const unsigned char *) &header; ssize_t size = sizeof(struct TarHeader); memset( &header, 0, size); - if (*fileName=='/') { - static int alreadyWarned=FALSE; - if (alreadyWarned==FALSE) { - errorMsg("Removing leading '/' from member names\n"); - alreadyWarned=TRUE; - } - strncpy(header.name, fileName+1, sizeof(header.name)); - } - else { - strncpy(header.name, fileName, sizeof(header.name)); - } - -#if defined BB_FEATURE_TAR_EXCLUDE - /* Check for excluded files.... */ - for (tmpList=tbInfo->excludeList; tmpList && *tmpList; tmpList++) { - /* Do some extra hoop jumping for when directory names - * end in '/' but the entry in tmpList doesn't */ - if (strncmp( *tmpList, header.name, strlen(*tmpList))==0 || ( - header.name[strlen(header.name)-1]=='/' - && strncmp( *tmpList, header.name, - MIN(strlen(header.name)-1, strlen(*tmpList)))==0)) { - /* Set the mode to something that is not a regular file, thereby - * faking out writeTarFile into thinking that nothing further need - * be done for this file. Yes, I know this is ugly, but it works. */ - statbuf->st_mode = 0; - return( TRUE); - } - } -#endif + 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); @@ -796,18 +920,17 @@ writeTarHeader(struct TarBallInfo *tbInfo, const char *fileName, struct stat *st if (! *header.uname) strcpy(header.uname, "root"); - /* WARNING/NOTICE: I break Hard Links */ - if (S_ISLNK(statbuf->st_mode)) { - int link_size=0; - char buffer[BUFSIZ]; - header.typeflag = SYMTYPE; - link_size = readlink(fileName, buffer, sizeof(buffer) - 1); - if ( link_size < 0) { - errorMsg("Error reading symlink '%s': %s\n", header.name, strerror(errno)); + 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); - } - buffer[link_size] = '\0'; - strncpy(header.linkname, buffer, sizeof(header.linkname)); + 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)); @@ -825,7 +948,7 @@ writeTarHeader(struct TarBallInfo *tbInfo, const char *fileName, struct stat *st header.typeflag = REGTYPE; putOctal(header.size, sizeof(header.size), statbuf->st_size); } else { - errorMsg("%s: Unknown file type\n", fileName); + error_msg("%s: Unknown file type", real_name); return ( FALSE); } @@ -841,8 +964,8 @@ writeTarHeader(struct TarBallInfo *tbInfo, const char *fileName, struct stat *st putOctal(header.chksum, 7, chksum); /* Now write the header out to disk */ - if ((size=fullWrite(tbInfo->tarFd, (char*)&header, sizeof(struct TarHeader))) < 0) { - errorMsg(io_error, fileName, strerror(errno)); + if ((size=full_write(tbInfo->tarFd, (char*)&header, sizeof(struct TarHeader))) < 0) { + error_msg(io_error, real_name, strerror(errno)); return ( FALSE); } /* Pad the header up to the tar block size */ @@ -864,10 +987,27 @@ writeTarHeader(struct TarBallInfo *tbInfo, const char *fileName, struct stat *st static int writeFileToTarball(const char *fileName, struct stat *statbuf, void* userData) { 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->st_dev, + statbuf->st_ino); + if (tbInfo->hlInfo == NULL) + addHardLinkInfo (&tbInfo->hlInfoHead, statbuf->st_dev, + statbuf->st_ino, statbuf->st_nlink, fileName); + } /* It is against the rules to archive a socket */ if (S_ISSOCK(statbuf->st_mode)) { - errorMsg("%s: socket ignored\n", fileName); + error_msg("%s: socket ignored", fileName); return( TRUE); } @@ -876,37 +1016,62 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf, void* * the new tarball */ if (tbInfo->statBuf.st_dev == statbuf->st_dev && tbInfo->statBuf.st_ino == statbuf->st_ino) { - errorMsg("%s: file is the archive; skipping\n", fileName); + error_msg("%s: file is the archive; skipping", fileName); return( TRUE); } - if (writeTarHeader(tbInfo, fileName, statbuf)==FALSE) { + header_name = fileName; + while (header_name[0] == '/') { + static int alreadyWarned=FALSE; + if (alreadyWarned==FALSE) { + error_msg("Removing leading '/' from member names"); + alreadyWarned=TRUE; + } + header_name++; + } + + if (strlen(fileName) >= NAME_SIZE) { + error_msg(name_longer_than_foo, NAME_SIZE); + return ( TRUE); + } + + if (header_name[0] == '\0') + return TRUE; + +#if defined BB_FEATURE_TAR_EXCLUDE + if (exclude_file(tbInfo->excludeList, header_name)) { + return SKIP; + } +#endif + + if (writeTarHeader(tbInfo, header_name, fileName, statbuf)==FALSE) { return( FALSE); } /* Now, if the file is a regular file, copy it out to the tarball */ - if (S_ISREG(statbuf->st_mode)) { + 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) { - errorMsg("%s: Cannot open: %s\n", fileName, strerror(errno)); + error_msg("%s: Cannot open: %s", fileName, strerror(errno)); return( FALSE); } /* write the file to the archive */ - while ( (size = fullRead(inputFileFd, buffer, sizeof(buffer))) > 0 ) { - if (fullWrite(tbInfo->tarFd, buffer, size) != size ) { + while ( (size = full_read(inputFileFd, buffer, sizeof(buffer))) > 0 ) { + if (full_write(tbInfo->tarFd, buffer, size) != size ) { /* Output file seems to have a problem */ - errorMsg(io_error, fileName, strerror(errno)); + error_msg(io_error, fileName, strerror(errno)); return( FALSE); } readSize+=size; } if (size == -1) { - errorMsg(io_error, fileName, strerror(errno)); + error_msg(io_error, fileName, strerror(errno)); return( FALSE); } /* Pad the file up to the tar block size */ @@ -919,41 +1084,43 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf, void* return( TRUE); } -static int writeTarFile(const char* tarName, int tostdoutFlag, - int verboseFlag, int argc, char **argv, char** excludeList) +static int writeTarFile(const char* tarName, int verboseFlag, char **argv, + char** excludeList) { int tarFd=-1; int errorFlag=FALSE; ssize_t size; struct TarBallInfo tbInfo; tbInfo.verboseFlag = verboseFlag; + tbInfo.hlInfoHead = NULL; /* Make sure there is at least one file to tar up. */ - if (argc <= 0) - fatalError("Cowardly refusing to create an empty archive\n"); + if (*argv == NULL) + error_msg_and_die("Cowardly refusing to create an empty archive"); /* Open the tar file for writing. */ - if (tostdoutFlag == TRUE) + if (!strcmp(tarName, "-")) tbInfo.tarFd = fileno(stdout); else tbInfo.tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (tbInfo.tarFd < 0) { - errorMsg( "Error opening '%s': %s\n", tarName, strerror(errno)); + perror_msg( "Error opening '%s'", tarName); + freeHardLinkInfo(&tbInfo.hlInfoHead); return ( FALSE); } tbInfo.excludeList=excludeList; /* Store the stat info for the tarball's file, so * can avoid including the tarball into itself.... */ if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0) - fatalError(io_error, tarName, strerror(errno)); + error_msg_and_die(io_error, tarName, strerror(errno)); /* Set the umask for this process so it doesn't * screw up permission setting for us later. */ umask(0); /* Read the directory/files and iterate over them one at a time */ - while (argc-- > 0) { - if (recursiveAction(*argv++, TRUE, FALSE, FALSE, + while (*argv != NULL) { + if (recursive_action(*argv++, TRUE, FALSE, FALSE, writeFileToTarball, writeFileToTarball, (void*) &tbInfo) == FALSE) { errorFlag = TRUE; @@ -965,16 +1132,18 @@ static int writeTarFile(const char* tarName, int tostdoutFlag, } /* To be pedantically correct, we would check if the tarball - * is smaller then 20 tar blocks, and pad it if it was smaller, + * 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 */ /* Hang up the tools, close up shop, head home */ close(tarFd); if (errorFlag == TRUE) { - errorMsg("Error exit delayed from previous errors\n"); + error_msg("Error exit delayed from previous errors"); + freeHardLinkInfo(&tbInfo.hlInfoHead); return(FALSE); } + freeHardLinkInfo(&tbInfo.hlInfoHead); return( TRUE); }