libtar/libtar.c

   1 /*
   2 **  Copyright 1998-2003 University of Illinois Board of Trustees
   3 **  Copyright 1998-2003 Mark D. Roth
   4 **  All rights reserved.
   5 **
   6 **  libtar.c - demo driver program for libtar
   7 **
   8 **  Mark D. Roth <roth@uiuc.edu>
   9 **  Campus Information Technologies and Educational Services
  10 **  University of Illinois at Urbana-Champaign
  11 */
  12
  13 #include <config.h>
  14 #include <libtar.h>
  15
  16 #include <stdio.h>
  17 #include <fcntl.h>
  18 #include <errno.h>
  19 #include <sys/param.h>
  20 #include <stdlib.h>
  21
  22 #ifdef STDC_HEADERS
  23 # include <string.h>
  24 #endif
  25
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29
  30 #ifdef DEBUG
  31 # include <signal.h>
  32 #endif
  33
  34 #ifdef HAVE_LIBZ
  35 # include <zlib.h>
  36 #endif
  37
  38 #include <compat.h>
  39
  40
  41 char *progname;
  42 int verbose = 0;
  43 int use_gnu = 0;
  44
  45 #ifdef DEBUG
  46 void
  47 segv_handler(int sig)
  48 {
  49         puts("OOPS!  Caught SIGSEGV, bailing out...");
  50         fflush(stdout);
  51         fflush(stderr);
  52 }
  53 #endif
  54
  55
  56 #ifdef HAVE_LIBZ
  57
  58 int use_zlib = 0;
  59
  60 int
  61 gzopen_frontend(char *pathname, int oflags, int mode)
  62 {
  63         char *gzoflags;
  64         gzFile gzf;
  65         int fd;
  66
  67         switch (oflags & O_ACCMODE)
  68         {
  69         case O_WRONLY:
  70                 gzoflags = "wb";
  71                 break;
  72         case O_RDONLY:
  73                 gzoflags = "rb";
  74                 break;
  75         default:
  76         case O_RDWR:
  77                 errno = EINVAL;
  78                 return -1;
  79         }
  80
  81         fd = open(pathname, oflags, mode);
  82         if (fd == -1)
  83                 return -1;
  84
  85         if ((oflags & O_CREAT) && fchmod(fd, mode))
  86                 return -1;
  87
  88         gzf = gzdopen(fd, gzoflags);
  89         if (!gzf)
  90         {
  91                 errno = ENOMEM;
  92                 return -1;
  93         }
  94
  95         /* This is a bad thing to do on big-endian lp64 systems, where the
  96            size and placement of integers is different than pointers.
  97            However, to fix the problem 4 wrapper functions would be needed and
  98            an extra bit of data associating GZF with the wrapper functions.  */
  99         return (int)gzf;
 100 }
 101
 102 tartype_t gztype = { (openfunc_t) gzopen_frontend, (closefunc_t) gzclose,
 103         (readfunc_t) gzread, (writefunc_t) gzwrite
 104 };
 105
 106 #endif /* HAVE_LIBZ */
 107
 108
 109 int
 110 create(char *tarfile, char *rootdir, libtar_list_t *l)
 111 {
 112         TAR *t;
 113         char *pathname;
 114         char buf[MAXPATHLEN];
 115         libtar_listptr_t lp;
 116
 117         if (tar_open(&t, tarfile,
 118 #ifdef HAVE_LIBZ
 119                      (use_zlib ? &gztype : NULL),
 120 #else
 121                      NULL,
 122 #endif
 123                      O_WRONLY | O_CREAT, 0644,
 124                      (verbose ? TAR_VERBOSE : 0)
 125                      | (use_gnu ? TAR_GNU : 0)) == -1)
 126         {
 127                 fprintf(stderr, "tar_open(): %s\n", strerror(errno));
 128                 return -1;
 129         }
 130
 131         libtar_listptr_reset(&lp);
 132         while (libtar_list_next(l, &lp) != 0)
 133         {
 134                 pathname = (char *)libtar_listptr_data(&lp);
 135                 if (pathname[0] != '/' && rootdir != NULL)
 136                         snprintf(buf, sizeof(buf), "%s/%s", rootdir, pathname);
 137                 else
 138                         strlcpy(buf, pathname, sizeof(buf));
 139                 if (tar_append_tree(t, buf, pathname) != 0)
 140                 {
 141                         fprintf(stderr,
 142                                 "tar_append_tree(\"%s\", \"%s\"): %s\n", buf,
 143                                 pathname, strerror(errno));
 144                         tar_close(t);
 145                         return -1;
 146                 }
 147         }
 148
 149         if (tar_append_eof(t) != 0)
 150         {
 151                 fprintf(stderr, "tar_append_eof(): %s\n", strerror(errno));
 152                 tar_close(t);
 153                 return -1;
 154         }
 155
 156         if (tar_close(t) != 0)
 157         {
 158                 fprintf(stderr, "tar_close(): %s\n", strerror(errno));
 159                 return -1;
 160         }
 161
 162         return 0;
 163 }
 164
 165
 166 int
 167 list(char *tarfile)
 168 {
 169         TAR *t;
 170         int i;
 171
 172         if (tar_open(&t, tarfile,
 173 #ifdef HAVE_LIBZ
 174                      (use_zlib ? &gztype : NULL),
 175 #else
 176                      NULL,
 177 #endif
 178                      O_RDONLY, 0,
 179                      (verbose ? TAR_VERBOSE : 0)
 180                      | (use_gnu ? TAR_GNU : 0)) == -1)
 181         {
 182                 fprintf(stderr, "tar_open(): %s\n", strerror(errno));
 183                 return -1;
 184         }
 185
 186         while ((i = th_read(t)) == 0)
 187         {
 188                 th_print_long_ls(t);
 189 #ifdef DEBUG
 190                 th_print(t);
 191 #endif
 192                 if (TH_ISREG(t) && tar_skip_regfile(t) != 0)
 193                 {
 194                         fprintf(stderr, "tar_skip_regfile(): %s\n",
 195                                 strerror(errno));
 196                         return -1;
 197                 }
 198         }
 199
 200 #ifdef DEBUG
 201         printf("th_read() returned %d\n", i);
 202         printf("EOF mark encountered after %ld bytes\n",
 203 # ifdef HAVE_LIBZ
 204                (use_zlib
 205                 ? gzseek((gzFile) t->fd, 0, SEEK_CUR)
 206                 :
 207 # endif
 208                lseek(t->fd, 0, SEEK_CUR)
 209 # ifdef HAVE_LIBZ
 210                )
 211 # endif
 212                );
 213 #endif
 214
 215         if (tar_close(t) != 0)
 216         {
 217                 fprintf(stderr, "tar_close(): %s\n", strerror(errno));
 218                 return -1;
 219         }
 220
 221         return 0;
 222 }
 223
 224
 225 int
 226 extract(char *tarfile, char *rootdir)
 227 {
 228         TAR *t;
 229
 230 #ifdef DEBUG
 231         puts("opening tarfile...");
 232 #endif
 233         if (tar_open(&t, tarfile,
 234 #ifdef HAVE_LIBZ
 235                      (use_zlib ? &gztype : NULL),
 236 #else
 237                      NULL,
 238 #endif
 239                      O_RDONLY, 0,
 240                      (verbose ? TAR_VERBOSE : 0)
 241                      | (use_gnu ? TAR_GNU : 0)) == -1)
 242         {
 243                 fprintf(stderr, "tar_open(): %s\n", strerror(errno));
 244                 return -1;
 245         }
 246
 247 #ifdef DEBUG
 248         puts("extracting tarfile...");
 249 #endif
 250         if (tar_extract_all(t, rootdir) != 0)
 251         {
 252                 fprintf(stderr, "tar_extract_all(): %s\n", strerror(errno));
 253                 return -1;
 254         }
 255
 256 #ifdef DEBUG
 257         puts("closing tarfile...");
 258 #endif
 259         if (tar_close(t) != 0)
 260         {
 261                 fprintf(stderr, "tar_close(): %s\n", strerror(errno));
 262                 return -1;
 263         }
 264
 265         return 0;
 266 }
 267
 268
 269 void
 270 usage()
 271 {
 272         printf("Usage: %s [-C rootdir] [-g] [-z] -x|-t filename.tar\n",
 273                progname);
 274         printf("       %s [-C rootdir] [-g] [-z] -c filename.tar ...\n",
 275                progname);
 276         exit(-1);
 277 }
 278
 279
 280 #define MODE_LIST       1
 281 #define MODE_CREATE     2
 282 #define MODE_EXTRACT    3
 283
 284 int
 285 main(int argc, char *argv[])
 286 {
 287         char *tarfile = NULL;
 288         char *rootdir = NULL;
 289         int c;
 290         int mode = 0;
 291         libtar_list_t *l;
 292
 293         progname = basename(argv[0]);
 294
 295         while ((c = getopt(argc, argv, "cC:gtvVxz")) != -1)
 296                 switch (c)
 297                 {
 298                 case 'V':
 299                         printf("libtar %s by Mark D. Roth <roth@uiuc.edu>\n",
 300                                libtar_version);
 301                         break;
 302                 case 'C':
 303                         rootdir = strdup(optarg);
 304                         break;
 305                 case 'v':
 306                         verbose = 1;
 307                         break;
 308                 case 'g':
 309                         use_gnu = 1;
 310                         break;
 311                 case 'c':
 312                         if (mode)
 313                                 usage();
 314                         mode = MODE_CREATE;
 315                         break;
 316                 case 'x':
 317                         if (mode)
 318                                 usage();
 319                         mode = MODE_EXTRACT;
 320                         break;
 321                 case 't':
 322                         if (mode)
 323                                 usage();
 324                         mode = MODE_LIST;
 325                         break;
 326 #ifdef HAVE_LIBZ
 327                 case 'z':
 328                         use_zlib = 1;
 329                         break;
 330 #endif /* HAVE_LIBZ */
 331                 default:
 332                         usage();
 333                 }
 334
 335         if (!mode || ((argc - optind) < (mode == MODE_CREATE ? 2 : 1)))
 336         {
 337 #ifdef DEBUG
 338                 printf("argc - optind == %d\tmode == %d\n", argc - optind,
 339                        mode);
 340 #endif
 341                 usage();
 342         }
 343
 344 #ifdef DEBUG
 345         signal(SIGSEGV, segv_handler);
 346 #endif
 347
 348         switch (mode)
 349         {
 350         case MODE_EXTRACT:
 351                 return extract(argv[optind], rootdir);
 352         case MODE_CREATE:
 353                 tarfile = argv[optind];
 354                 l = libtar_list_new(LIST_QUEUE, NULL);
 355                 for (c = optind + 1; c < argc; c++)
 356                         libtar_list_add(l, argv[c]);
 357                 return create(tarfile, rootdir, l);
 358         case MODE_LIST:
 359                 return list(argv[optind]);
 360         default:
 361                 break;
 362         }
 363
 364         /* NOTREACHED */
 365         return -2;
 366 }
 367
 368