archival/ar.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini ar implementation for busybox
   4  *
   5  * Copyright (C) 2000 by Glenn McGrath
   6  * Written by Glenn McGrath <bug1@optushome.com.au> 1 June 2000
   7  *
   8  * Based in part on BusyBox tar, Debian dpkg-deb and GNU ar.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  *
  24  */
  25 #include <fcntl.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <getopt.h>
  29 #include <unistd.h>
  30 #include "busybox.h"
  31
  32 typedef struct ar_headers_s {
  33         char *name;
  34         off_t size;
  35         uid_t uid;
  36         gid_t gid;
  37         mode_t mode;
  38         time_t mtime;
  39         off_t offset;
  40         struct ar_headers_s *next;
  41 } ar_headers_t;
  42
  43 /*
  44  * return the headerL_t struct for the filename descriptor
  45  */
  46 extern ar_headers_t get_ar_headers(int srcFd)
  47 {
  48         typedef struct raw_ar_header_s {        /* Byte Offset */
  49                 char name[16];  /*  0-15 */
  50                 char date[12];  /* 16-27 */
  51                 char uid[6];
  52                 char gid[6];    /* 28-39 */
  53                 char mode[8];   /* 40-47 */
  54                 char size[10];  /* 48-57 */
  55                 char fmag[2];   /* 58-59 */
  56         } raw_ar_header_t;
  57
  58         raw_ar_header_t raw_ar_header;
  59
  60         ar_headers_t *head, *entry;
  61         char ar_magic[8];
  62         char *long_name=NULL;
  63
  64         head = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
  65         entry = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
  66
  67         /* check ar magic */
  68         if (full_read(srcFd, ar_magic, 8) != 8) {
  69                 error_msg_and_die("cannot read magic");
  70         }
  71
  72         if (strncmp(ar_magic,"!<arch>",7) != 0) {
  73                 error_msg_and_die("invalid magic");
  74         }
  75
  76         while (full_read(srcFd, (char *) &raw_ar_header, 60)==60) {
  77                 /* check the end of header markers are valid */
  78                 if ((raw_ar_header.fmag[0]!='`') || (raw_ar_header.fmag[1]!='\n')) {
  79                         char newline;
  80                         if (raw_ar_header.fmag[1]!='`') {
  81                                 break;
  82                         }
  83                         /* some version of ar, have an extra '\n' after each entry */
  84                         read(srcFd, &newline, 1);
  85                         if (newline!='\n') {
  86                                 break;
  87                         }
  88                         /* fix up the header, we started reading 1 byte too early due to a '\n' */
  89                         memmove((char *) &raw_ar_header, (char *)&raw_ar_header+1, 59);
  90                         /* dont worry about adding the last '\n', we dont need it now */
  91                 }
  92
  93                 entry->size = (off_t) atoi(raw_ar_header.size);
  94                 /* long filenames have '/' as the first character */
  95                 if (raw_ar_header.name[0] == '/') {
  96                         if (raw_ar_header.name[1] == '/') {
  97                                 /* multiple long filenames are stored as data in one entry */
  98                                 long_name = (char *) xrealloc(long_name, entry->size);
  99                                 full_read(srcFd, long_name, entry->size);
 100                                 continue;
 101                         }
 102                         else {
 103                                 /* The number after the '/' indicates the offset in the ar data section
 104                                         (saved in variable long_name) that conatains the real filename */
 105                                 const int long_name_offset = (int) atoi((char *) &raw_ar_header.name[1]);
 106                                 entry->name = xmalloc(strlen(&long_name[long_name_offset]));
 107                                 strcpy(entry->name, &long_name[long_name_offset]);
 108                         }
 109                 }
 110                 else {
 111                         /* short filenames */
 112                         entry->name = xmalloc(16);
 113                         strncpy(entry->name, raw_ar_header.name, 16);
 114                 }
 115                 entry->name[strcspn(entry->name, " /")]='\0';
 116
 117                 /* convert the rest of the now valid char header to its typed struct */
 118                 parse_mode(raw_ar_header.mode, &entry->mode);
 119                 entry->mtime = atoi(raw_ar_header.date);
 120                 entry->uid = atoi(raw_ar_header.uid);
 121                 entry->gid = atoi(raw_ar_header.gid);
 122                 entry->offset = lseek(srcFd, 0, SEEK_CUR);
 123
 124                 /* add this entries header to our combined list */
 125                 entry->next = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
 126                 *entry->next = *head;
 127                 *head = *entry;
 128                 lseek(srcFd, (off_t) entry->size, SEEK_CUR);
 129         }
 130         return(*head);
 131 }
 132
 133 extern int ar_main(int argc, char **argv)
 134 {
 135         const int preserve_date = 1;    /* preserve original dates */
 136         const int verbose = 2;          /* be verbose */
 137         const int display = 4;          /* display contents */
 138         const int extract_to_file = 8;  /* extract contents of archive */
 139         const int extract_to_stdout = 16;       /* extract to stdout */
 140
 141         int funct = 0, opt=0;
 142         int srcFd=0, dstFd=0;
 143
 144         ar_headers_t head, *extract_list=NULL;
 145
 146         extract_list = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
 147
 148         while ((opt = getopt(argc, argv, "ovtpx")) != -1) {
 149                 switch (opt) {
 150                 case 'o':
 151                         funct |= preserve_date;
 152                         break;
 153                 case 'v':
 154                         funct |= verbose;
 155                         break;
 156                 case 't':
 157                         funct |= display;
 158                         break;
 159                 case 'p':
 160                         funct |= extract_to_stdout;
 161                         break;
 162                 case 'x':
 163                         funct |= extract_to_file;
 164                         break;
 165                 default:
 166                         show_usage();
 167                 }
 168         }
 169
 170         /* check the src filename was specified */
 171         if (optind == argc)
 172                 show_usage();
 173
 174         if ( (srcFd = open(argv[optind], O_RDONLY)) < 0)
 175                 error_msg_and_die("Cannot read %s", argv[optind]);
 176
 177         optind++;
 178         head = get_ar_headers(srcFd);
 179
 180         /* find files to extract or display */
 181         /* search through argv and build extract list */
 182         for (;optind<argc; optind++) {
 183                 ar_headers_t *ar_entry;
 184                 ar_entry = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
 185                 ar_entry = &head;
 186                 while (ar_entry->next != NULL) {
 187                         if (strcmp(argv[optind], ar_entry->name) == 0) {
 188                                 ar_headers_t *tmp;
 189                                 tmp = (ar_headers_t *) xmalloc(sizeof(ar_headers_t));
 190                                 *tmp = *extract_list;
 191                                 *extract_list = *ar_entry;
 192                                 extract_list->next = tmp;
 193                                 break;
 194                         }
 195                         ar_entry=ar_entry->next;
 196                 }
 197         }
 198
 199         /* if individual files not found extract all files */
 200         if (extract_list->next==NULL) {
 201                 extract_list = &head;
 202         }
 203
 204         /* find files to extract or display */
 205         while (extract_list->next != NULL) {
 206                 if (funct & extract_to_file) {
 207                         dstFd = open(extract_list->name, O_WRONLY | O_CREAT, extract_list->mode);
 208                 }
 209                 else if (funct & extract_to_stdout) {
 210                         dstFd = fileno(stdout);
 211                 }
 212                 if ((funct & extract_to_file) || (funct & extract_to_stdout)) {
 213                         lseek(srcFd, extract_list->offset, SEEK_SET);
 214                         copy_file_chunk(srcFd, dstFd, (off_t) extract_list->size);
 215                 }
 216                 if (funct & verbose) {
 217                         printf("%s %d/%d %8d %s ", mode_string(extract_list->mode),
 218                                 extract_list->uid, extract_list->gid,
 219                                 extract_list->size, time_string(extract_list->mtime));
 220                 }
 221                 if ((funct & display) || (funct & verbose)){
 222                         printf("%s\n", extract_list->name);
 223                 }
 224                 extract_list=extract_list->next;
 225         }
 226         return EXIT_SUCCESS;
 227 }