1 files changed, 140 insertions, 244 deletions

diff --git a/ar.c b/ar.c
index b1200b8ae..1c598fa16 100644
--- a/ar.c
+++ b/ar.c
@@ -4,6 +4,12 @@
  *
  * Copyright (C) 2000 by Glenn McGrath
  * Written by Glenn McGrath <bug1@netconnect.com.au> 1 June 2000
+ *              
+ * Modified 8 August 2000 by Glenn McGrath 
+ *  - now uses getopt
+ *  - moved copySubFile function to utilities.c
+ *  - creates linked list of all headers 
+ *  - easily accessable to other busybox functions  
  *
  * Based in part on BusyBox tar, Debian dpkg-deb and GNU ar.
  *
@@ -21,10 +27,8 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
- * Last modified 10 June 2000
+ * Last modified 25 August 2000
  */
-
-
 #include <stdio.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -34,287 +38,179 @@
 #include <sys/types.h>
 #include "internal.h"
 
-#define AR_BLOCK_SIZE 60
-#define AR_PRESERVE_DATE 1      /* preserve original dates */
-#define AR_VERBOSE       2      /* be verbose */
-#define AR_DISPLAY       4      /* display contents */
-#define AR_EXT_TO_FILE   8      /* extract contents of archive */
-#define AR_EXT_TO_STDOUT 16     /* extract to stdout */
+#define BLOCK_SIZE 60
+#define PRESERVE_DATE 1 /* preserve original dates */
+#define VERBOSE       2 /* be verbose */
+#define DISPLAY       4 /* display contents */
+#define EXT_TO_FILE   8 /* extract contents of archive */
+#define EXT_TO_STDOUT 16        /* extract to stdout */
 
 #define BB_DECLARE_EXTERN
 #define bb_need_io_error
 #include "messages.c"
 
-struct ArHeader {                               /* Byte Offset */
-        char ar_name[16];                       /*  0-15 */
-        char ar_date[12];                       /* 16-27 */
-        char ar_uid[6], ar_gid[6];      /* 28-39 */
-        char ar_mode[8];                        /* 40-47 */
-        char ar_size[10];                       /* 48-57 */
-        char ar_fmag[2];                        /* 58-59 */
-};
-typedef struct ArHeader ArHeader;
-
-struct ArInfo {
-        char name[17];                          /* File name */
-        time_t date;                            /* long int, No of seconds since epoch */
-        uid_t uid;                                      /* unsigned int, Numeric UID */
-        gid_t gid;                                      /* unsigned int, Numeric GID */
-        mode_t mode;                            /* unsigned int, Unix mode */
-        size_t size;                            /* int, Size of the file */
-};
-typedef struct ArInfo ArInfo;
+typedef struct rawArHeader {            /* Byte Offset */
+        char name[16];          /*  0-15 */
+        char date[12];          /* 16-27 */
+        char uid[6], gid[6];    /* 28-39 */
+        char mode[8];           /* 40-47 */
+        char size[10];          /* 48-57 */
+        char fmag[2];           /* 58-59 */
+} rawArHeader_t;
+
+typedef struct headerL {
+        char name[16];
+        size_t size;
+        uid_t uid;
+        gid_t gid;
+        mode_t mode;
+        time_t mtime;
+        off_t offset;
+        struct headerL *next;
+} headerL_t;
 
 /*
- * Display details of a file, verbosly if funct=2   
+ * populate linked list with all ar file entries and offset 
  */
-static void displayEntry(struct ArInfo *entry, int funct)
+static int parseArArchive(int srcFd, headerL_t *current)
 {
-        /* TODO convert mode to string */
-        if ((funct & AR_VERBOSE) == AR_VERBOSE)
-                printf("%i %i/%i %8i %s ", entry->mode, entry->uid, entry->gid,
-                           entry->size, timeString(entry->date));
-        printf("%s\n", entry->name);
-}
-
-/* this is from tar.c remove later*/
-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';
+        off_t lastOffset=0, thisOffset=0;
+        char arVersion[8];
+        rawArHeader_t rawArHeader;
+        
+        lseek(srcFd, 0, SEEK_SET);
+        if (fullRead(srcFd, arVersion, 8) <= 0) {
+                errorMsg("Invalid header magic\n");
+                return (FALSE);
         }
-        for (;(size > 0) && (*cp == ' '); cp++, size--);
-        if ((size > 0) && *cp)
-                return -1;
-        return val;
-}
-
-/*
- * Converts from the char based struct to a new struct with stricter types
- */
-static int processArHeader(struct ArHeader *rawHeader, struct ArInfo *header)
-{
-        int count2;
-        int count;
-        
-        /* check end of header marker is valid */
-        if ((rawHeader->ar_fmag[0]!='`') || (rawHeader->ar_fmag[1]!='\n')) 
-                return(FALSE); 
-
-        /* convert filename */ 
-        for (count = 0; count < 16; count++) {
-                /* allow spaces in filename except at the end */
-                if (rawHeader->ar_name[count] == ' ') {
-                        for (count2 = count; count2 < 16; count2++)
-                                if (!isspace(rawHeader->ar_name[count2]))
-                                        break;
-                        if (count2 >= 16)
-                                break;
-                }
-                /* GNU ar uses '/' as an end of filename marker */
-                if (rawHeader->ar_name[count] == '/')
-                        break;
-                header->name[count] = rawHeader->ar_name[count];
-        }
-        header->name[count] = '\0';
-        header->date = atoi(rawHeader->ar_date);
-        header->uid = atoi(rawHeader->ar_uid);
-        header->gid = atoi(rawHeader->ar_gid);
-        header->mode = getOctal(rawHeader->ar_mode, sizeof(rawHeader->ar_mode));
-        header->size = atoi(rawHeader->ar_size);
-        return (TRUE);
-}
-
-/*
- * Copy size bytes from current position if srcFd to current position in dstFd
- * taken from tarExtractRegularFile in tar.c, remove later
- */
-static int copySubFile(int srcFd, int dstFd, int copySize)
-{
-        int readSize, writeSize, doneSize;
-        char buffer[BUFSIZ];
-
-        while (copySize > 0) {
-                if (copySize > BUFSIZ)
-                        readSize = BUFSIZ;
-                else
-                        readSize = copySize;
-                writeSize = fullRead(srcFd, buffer, readSize);
-                if (writeSize <= 0) {
-                        errorMsg(io_error, "copySubFile", strerror(errno));
-                        return (FALSE);
-                }
-                doneSize = fullWrite(dstFd, buffer, writeSize);
-                if (doneSize <= 0) {
-                        errorMsg(io_error, "copySubFile", strerror(errno));
-                        return (FALSE);
-                }
-                copySize -= doneSize;
-        }
-        return (TRUE);
+        if (strncmp(arVersion,"!<arch>",7) != 0) {
+                errorMsg("This doesnt appear to be an ar archive\n");
+                return(FALSE);
+        }
+        while (fullRead(srcFd, (char *) &rawArHeader, 60) == 60) {
+              if ( (rawArHeader.fmag[0] == '`') &&
+                        (rawArHeader.fmag[1] == '\n')) {
+                        sscanf(rawArHeader.name, "%s", current->name);
+                        parse_mode(rawArHeader.mode, &current->mode);
+                        current->mtime = atoi(rawArHeader.date);
+                        current->uid = atoi(rawArHeader.uid);
+                        current->gid = atoi(rawArHeader.gid);
+                        current->size = (size_t) atoi(rawArHeader.size);
+                        current->offset = lseek(srcFd, 0 , SEEK_CUR);
+                        current->next = (headerL_t *) xmalloc(sizeof(headerL_t));
+                        lastOffset = lseek(srcFd, (off_t) current->size, SEEK_CUR);
+                        current = current->next;
+                }
+                else {  /* GNU ar has an extra char after data */
+                        thisOffset=lseek(srcFd, 0, SEEK_CUR);
+                        if ( (thisOffset - lastOffset) > ((off_t) 61) ) 
+                                return(FALSE);
+                        lseek(srcFd, thisOffset - 59, SEEK_SET);
+                }
+        }
+        return(FALSE);
 }
 
 /*
- * Extract the file described in ArInfo to the specified path 
- * set the new files uid, gid and mode 
+ * return the headerL_t struct for the specified filename
  */
-static int extractToFile(struct ArInfo *file, int funct, int srcFd, const char *path)
+static headerL_t *getSubFileHeader(int srcFd, const char filename[16])
 {
-        int dstFd, temp;
-        struct stat tmpStat;
-        char *pathname = NULL;
-        struct utimbuf newtime;
-        
-        if ((temp = isDirectory(path, TRUE, &tmpStat)) != TRUE) {
-                if (!createPath(path, 0777)) {
-                        fatalError("Cannot extract to specified path");
-                        return (FALSE);
-                }
-        }
-        temp = (strlen(path) + 16);
-        pathname = (char *) xmalloc(temp);
-        pathname = strcpy(pathname, path);
-        pathname = strcat(pathname, file->name);
-        dstFd = device_open(pathname, O_WRONLY | O_CREAT);
-        temp = copySubFile(srcFd, dstFd, file->size);
-        fchown(dstFd, file->uid, file->gid);
-        fchmod(dstFd, file->mode);
-        close(dstFd);
-        if ((funct&AR_PRESERVE_DATE)==AR_PRESERVE_DATE) 
-                newtime.modtime=file->date;
-        else
-                newtime.modtime=time(0);
-        newtime.actime=time(0);
-        temp = utime(pathname, &newtime);
-        return (TRUE);
+        headerL_t *list;
+        list = xmalloc(sizeof(headerL_t)); 
+
+        parseArArchive(srcFd, list);
+        while (list->next != NULL) {
+                if (strncmp(list->name, filename, strlen(filename))==0)
+                        return(list);
+                list=list->next;
+        }
+        return(NULL);
 }
 
 /*
- * Return a file descriptor for the specified file and do error checks
+ * populate linked list with all ar file entries and offset 
  */
-static int getArFd(char *filename)
+static int displayEntry(int srcFd, const char filename[16], int funct)
 {
-        int arFd;
-        char arVersion[8];
+        headerL_t *file;
 
-        arFd = open(filename, O_RDONLY);
-        if (arFd < 0) { 
-                errorMsg("Error opening '%s': %s\n", filename, strerror(errno));
-                return (FALSE);
+        if ((file = getSubFileHeader(srcFd, filename)) == NULL)
+                return(FALSE);
+        if ((funct & VERBOSE) == VERBOSE) {
+                printf("%s %d/%d %8d %s ", modeString(file->mode), file->uid, file->gid, file->size, timeString(file->mtime));
         }
-        if (fullRead(arFd, arVersion, 8) <= 0) {
-                errorMsg( "Unexpected EOF in archive\n");
-                return (FALSE);
-        }
-        if (strncmp(arVersion,"!<arch>",7) != 0) {
-                errorMsg("ar header fails check ");
-                return(FALSE);
-        }
-        return arFd;
+        printf("%s\n", file->name);
+        return(TRUE);
 }
 
-/*
- * Step through the ar file and process it one entry at a time
- * fileList[0] is the name of the ar archive
- * fileList[1] and up are filenames to extract from the archive
- * funct contains flags to specify the actions to be performed 
- */
-static int readArFile(char *fileList[16], int fileListSize, int funct)
+static int extractAr(int srcFd, int dstFd, const char filename[16])
 {
-        int arFd, status, extFileFlag, i, lastOffset=0;
-        ArHeader rawArHeader;
-        ArInfo arEntry;
-
-        /* open the ar archive */
-        arFd=getArFd(fileList[0]);
-
-        /* read the first header, then loop until ono more headers */ 
-        while ((status = fullRead(arFd, (char *) &rawArHeader, AR_BLOCK_SIZE))
-                   == AR_BLOCK_SIZE) {
-
-                /* check the header is valid, if not try reading the header
-                   agian with an offset of 1, needed as some ar archive end
-                   with a '\n' which isnt counted in specified file size */
-                if ((status=processArHeader(&rawArHeader, &arEntry))==FALSE ) {
-                        if ((i=lseek(arFd, 0, SEEK_CUR))==(lastOffset+60)) 
-                                lseek(arFd, lastOffset+1, SEEK_SET);
-                        else 
-                                return(FALSE);
-                }
-                else {  
-                        extFileFlag=0;
-                        
-                        if ((funct&AR_DISPLAY) || (funct&AR_VERBOSE))
-                                displayEntry(&arEntry, funct);
-
-                        /* check file was specified to be extracted only if 
-                           some file were specified */
-                        if ((funct&AR_EXT_TO_FILE) || (funct&AR_EXT_TO_STDOUT)){
-                                if (fileListSize==1)
-                                        extFileFlag=1;
-                                else {
-                                        for( i=1; i<=fileListSize; i++)
-                                                if ((status=(strcmp(fileList[i],arEntry.name)))==0)
-                                                        extFileFlag=1;
-                                }
-                        }
-                        if (extFileFlag==1) { 
-                                if (funct&AR_EXT_TO_FILE)
-                                        extractToFile(&arEntry, funct, arFd, "./");
-                                else    
-                                        copySubFile(arFd,fileno(stdout),arEntry.size);
-                        }
-                        else
-                                lseek(arFd, arEntry.size, SEEK_CUR);
-                        lastOffset=lseek(arFd, 0, SEEK_CUR);
-                } /* if processArHeader */
-        }  /* while */
-        return (TRUE);
+        headerL_t *file;
+ 
+        if ( (file = getSubFileHeader(srcFd, filename)) == NULL)
+                return(FALSE);
+        lseek(srcFd, file->offset, SEEK_SET);
+        if (copySubFile(srcFd, dstFd, (size_t) file->size) == TRUE)
+                return(TRUE);   
+        return(FALSE);
 }
 
 extern int ar_main(int argc, char **argv)
 {
-        int funct = 0, ret=0, i=0;
-        char *fileList[16], c, *opt_ptr;
-
-        if (argc < 2)
-                usage(ar_usage);
-
-        opt_ptr = argv[1];
-        if (*opt_ptr == '-')
-                ++opt_ptr;
-        while ((c = *opt_ptr++) != '\0') {
-                switch (c) {
+        int funct = 0, opt=0;
+        int srcFd=0, dstFd=0;
+ 
+        while ((opt = getopt(argc, argv, "ovt:p:x:")) != -1) {
+                switch (opt) {
                 case 'o':
-                        funct = funct | AR_PRESERVE_DATE;
+                        funct = funct | PRESERVE_DATE;
                         break;
                 case 'v':
-                        funct = funct | AR_VERBOSE;
+                        funct = funct | VERBOSE;
                         break;
                 case 't':
-                        funct = funct | AR_DISPLAY;
-                        break;
+                        funct = funct | DISPLAY;
                 case 'x':
-                        funct = funct | AR_EXT_TO_FILE;
-                        break;
+                        if (opt=='x') {
+                                funct = funct | EXT_TO_FILE;
+                        }
                 case 'p':
-                        funct = funct | AR_EXT_TO_STDOUT;
+                        if (opt=='p') {
+                                funct = funct | EXT_TO_STDOUT;
+                        }
+                        /* following is common to 't','x' and 'p' */
+                        if (optarg == NULL) {
+                                printf("expected a filename\n");
+                                return(FALSE);
+                        }
+                        if ( (srcFd = open(optarg, O_RDONLY)) < 0) {
+                                errorMsg("Cannot read %s\n", optarg);
+                                return (FALSE);
+                        }
                         break;
                 default:
                         usage(ar_usage);
                 }
         }
-
-        for(i=0; i<(argc-2); i++) 
-                fileList[i]=argv[i+2];
-        
-        if (funct > 3)
-                ret = readArFile(fileList, (argc-2), funct);
+ 
+        /* check options not just preserve_dates and/or verbose */  
+        if (funct < 4) {
+                usage(ar_usage);
+                return(FALSE);
+        }
         
-        return (ret);
+        /* find files to extract */
+        if (optind<argc)
+                for(; optind < argc; optind++) {
+                        if ( (funct & EXT_TO_FILE) == EXT_TO_FILE) {
+                                dstFd = open(argv[optind], O_WRONLY | O_CREAT);
+                                extractAr(srcFd, dstFd, argv[optind]);
+                        }
+                        if ( (funct & EXT_TO_STDOUT) == EXT_TO_STDOUT)  
+                                extractAr(srcFd, fileno(stdout), argv[optind]); 
+                        if ( (funct & DISPLAY) == DISPLAY)
+                                displayEntry(srcFd, argv[optind], funct);
+                }
+        return (TRUE);
 }