tools/gpgtar-list.c

   1 /* gpgtar-list.c - List a TAR archive
   2  * Copyright (C) 2010 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <errno.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26
  27 #include "i18n.h"
  28 #include "gpgtar.h"
  29 #include "../common/exectool.h"
  30
  31
  32 \f
  33 static unsigned long long
  34 parse_xoctal (const void *data, size_t length, const char *filename)
  35 {
  36   const unsigned char *p = data;
  37   unsigned long long value;
  38
  39   if (!length)
  40     value = 0;
  41   else if ( (*p & 0x80))
  42     {
  43       /* Binary format.  */
  44       value = (*p++ & 0x7f);
  45       while (--length)
  46         {
  47           value <<= 8;
  48           value |= *p++;
  49         }
  50     }
  51   else
  52     {
  53       /* Octal format  */
  54       value = 0;
  55       /* Skip leading spaces and zeroes.  */
  56       for (; length && (*p == ' ' || *p == '0'); length--, p++)
  57         ;
  58       for (; length && *p; length--, p++)
  59         {
  60           if (*p >= '0' && *p <= '7')
  61             {
  62               value <<= 3;
  63               value += (*p - '0');
  64             }
  65           else
  66             {
  67               log_error ("%s: invalid octal number encountered - assuming 0\n",
  68                          filename);
  69               value = 0;
  70               break;
  71             }
  72         }
  73     }
  74   return value;
  75 }
  76
  77
  78 static tar_header_t
  79 parse_header (const void *record, const char *filename)
  80 {
  81   const struct ustar_raw_header *raw = record;
  82   size_t n, namelen, prefixlen;
  83   tar_header_t header;
  84   int use_prefix;
  85
  86   use_prefix = (!memcmp (raw->magic, "ustar", 5)
  87                 && (raw->magic[5] == ' ' || !raw->magic[5]));
  88
  89
  90   for (namelen=0; namelen < sizeof raw->name && raw->name[namelen]; namelen++)
  91     ;
  92   if (namelen == sizeof raw->name)
  93     log_info ("%s: warning: name not terminated by a nul byte\n", filename);
  94   for (n=namelen+1; n < sizeof raw->name; n++)
  95     if (raw->name[n])
  96       {
  97         log_info ("%s: warning: garbage after name\n", filename);
  98         break;
  99       }
 100
 101
 102   if (use_prefix && raw->prefix[0])
 103     {
 104       for (prefixlen=0; (prefixlen < sizeof raw->prefix
 105                          && raw->prefix[prefixlen]); prefixlen++)
 106         ;
 107       if (prefixlen == sizeof raw->prefix)
 108         log_info ("%s: warning: prefix not terminated by a nul byte\n",
 109                   filename);
 110       for (n=prefixlen+1; n < sizeof raw->prefix; n++)
 111         if (raw->prefix[n])
 112           {
 113             log_info ("%s: warning: garbage after prefix\n", filename);
 114             break;
 115           }
 116     }
 117   else
 118     prefixlen = 0;
 119
 120   header = xtrycalloc (1, sizeof *header + prefixlen + 1 + namelen);
 121   if (!header)
 122     {
 123       log_error ("%s: error allocating header: %s\n",
 124                  filename, gpg_strerror (gpg_error_from_syserror ()));
 125       return NULL;
 126     }
 127   if (prefixlen)
 128     {
 129       n = prefixlen;
 130       memcpy (header->name, raw->prefix, n);
 131       if (raw->prefix[n-1] != '/')
 132         header->name[n++] = '/';
 133     }
 134   else
 135     n = 0;
 136   memcpy (header->name+n, raw->name, namelen);
 137   header->name[n+namelen] = 0;
 138
 139   header->mode  = parse_xoctal (raw->mode, sizeof raw->mode, filename);
 140   header->uid   = parse_xoctal (raw->uid, sizeof raw->uid, filename);
 141   header->gid   = parse_xoctal (raw->gid, sizeof raw->gid, filename);
 142   header->size  = parse_xoctal (raw->size, sizeof raw->size, filename);
 143   header->mtime = parse_xoctal (raw->mtime, sizeof raw->mtime, filename);
 144   /* checksum = */
 145   switch (raw->typeflag[0])
 146     {
 147     case '0': header->typeflag = TF_REGULAR; break;
 148     case '1': header->typeflag = TF_HARDLINK; break;
 149     case '2': header->typeflag = TF_SYMLINK; break;
 150     case '3': header->typeflag = TF_CHARDEV; break;
 151     case '4': header->typeflag = TF_BLOCKDEV; break;
 152     case '5': header->typeflag = TF_DIRECTORY; break;
 153     case '6': header->typeflag = TF_FIFO; break;
 154     case '7': header->typeflag = TF_RESERVED; break;
 155     default:  header->typeflag = TF_UNKNOWN; break;
 156     }
 157
 158
 159   /* Compute the number of data records following this header.  */
 160   if (header->typeflag == TF_REGULAR || header->typeflag == TF_UNKNOWN)
 161     header->nrecords = (header->size + RECORDSIZE-1)/RECORDSIZE;
 162   else
 163     header->nrecords = 0;
 164
 165
 166   return header;
 167 }
 168
 169
 170 \f
 171 /* Read the next block, assming it is a tar header.  Returns a header
 172    object on success in R_HEADER, or an error.  If the stream is
 173    consumed, R_HEADER is set to NULL.  In case of an error an error
 174    message has been printed.  */
 175 static gpg_error_t
 176 read_header (estream_t stream, tar_header_t *r_header)
 177 {
 178   gpg_error_t err;
 179   char record[RECORDSIZE];
 180   int i;
 181
 182   err = read_record (stream, record);
 183   if (err)
 184     return err;
 185
 186   for (i=0; i < RECORDSIZE && !record[i]; i++)
 187     ;
 188   if (i == RECORDSIZE)
 189     {
 190       /* All zero header - check whether it is the first part of an
 191          end of archive mark.  */
 192       err = read_record (stream, record);
 193       if (err)
 194         return err;
 195
 196       for (i=0; i < RECORDSIZE && !record[i]; i++)
 197         ;
 198       if (i != RECORDSIZE)
 199         log_info ("%s: warning: skipping empty header\n",
 200                   es_fname_get (stream));
 201       else
 202         {
 203           /* End of archive - FIXME: we might want to check for garbage.  */
 204           *r_header = NULL;
 205           return 0;
 206         }
 207     }
 208
 209   *r_header = parse_header (record, es_fname_get (stream));
 210   return *r_header ? 0 : gpg_error_from_syserror ();
 211 }
 212
 213
 214 /* Skip the data records according to HEADER.  Prints an error message
 215    on error and return -1. */
 216 static int
 217 skip_data (estream_t stream, tar_header_t header)
 218 {
 219   char record[RECORDSIZE];
 220   unsigned long long n;
 221
 222   for (n=0; n < header->nrecords; n++)
 223     {
 224       if (read_record (stream, record))
 225         return -1;
 226     }
 227
 228   return 0;
 229 }
 230
 231
 232 \f
 233 static void
 234 print_header (tar_header_t header, estream_t out)
 235 {
 236   unsigned long mask;
 237   char modestr[10+1];
 238   int i;
 239
 240   *modestr = '?';
 241   switch (header->typeflag)
 242     {
 243     case TF_REGULAR:  *modestr = '-'; break;
 244     case TF_HARDLINK: *modestr = 'h'; break;
 245     case TF_SYMLINK:  *modestr = 'l'; break;
 246     case TF_CHARDEV:  *modestr = 'c'; break;
 247     case TF_BLOCKDEV: *modestr = 'b'; break;
 248     case TF_DIRECTORY:*modestr = 'd'; break;
 249     case TF_FIFO:     *modestr = 'f'; break;
 250     case TF_RESERVED: *modestr = '='; break;
 251     case TF_UNKNOWN:  break;
 252     case TF_NOTSUP:   break;
 253     }
 254   for (mask = 0400, i = 0; i < 9; i++, mask >>= 1)
 255     modestr[1+i] = (header->mode & mask)? "rwxrwxrwx"[i]:'-';
 256   if ((header->typeflag & 04000))
 257     modestr[3] = modestr[3] == 'x'? 's':'S';
 258   if ((header->typeflag & 02000))
 259     modestr[6] = modestr[6] == 'x'? 's':'S';
 260   if ((header->typeflag & 01000))
 261     modestr[9] = modestr[9] == 'x'? 't':'T';
 262   modestr[10] = 0;
 263
 264   es_fprintf (out, "%s %lu %lu/%lu %12llu %s %s\n",
 265               modestr, header->nlink, header->uid, header->gid, header->size,
 266               isotimestamp (header->mtime), header->name);
 267 }
 268
 269
 270 \f
 271 /* List the tarball FILENAME or, if FILENAME is NULL, the tarball read
 272    from stdin.  */
 273 gpg_error_t
 274 gpgtar_list (const char *filename, int decrypt)
 275 {
 276   gpg_error_t err;
 277   estream_t stream;
 278   estream_t cipher_stream = NULL;
 279   tar_header_t header = NULL;
 280
 281   if (filename)
 282     {
 283       if (!strcmp (filename, "-"))
 284         stream = es_stdout;
 285       else
 286         stream = es_fopen (filename, "rb");
 287       if (!stream)
 288         {
 289           err = gpg_error_from_syserror ();
 290           log_error ("error opening '%s': %s\n", filename, gpg_strerror (err));
 291           return err;
 292         }
 293     }
 294   else
 295     stream = es_stdin;
 296
 297   if (stream == es_stdin)
 298     es_set_binary (es_stdin);
 299
 300   if (decrypt)
 301     {
 302       int i;
 303       strlist_t arg;
 304       const char **argv;
 305
 306       cipher_stream = stream;
 307       stream = es_fopenmem (0, "rwb");
 308       if (! stream)
 309         {
 310           err = gpg_error_from_syserror ();
 311           goto leave;
 312         }
 313
 314       argv = xtrycalloc (strlist_length (opt.gpg_arguments) + 2,
 315                          sizeof *argv);
 316       if (argv == NULL)
 317         {
 318           err = gpg_error_from_syserror ();
 319           goto leave;
 320         }
 321       i = 0;
 322       argv[i++] = "--decrypt";
 323       for (arg = opt.gpg_arguments; arg; arg = arg->next)
 324         argv[i++] = arg->d;
 325       argv[i++] = NULL;
 326       assert (i == strlist_length (opt.gpg_arguments) + 2);
 327
 328       err = gnupg_exec_tool_stream (opt.gpg_program, argv,
 329                                     cipher_stream, stream);
 330       xfree (argv);
 331       if (err)
 332         goto leave;
 333
 334       err = es_fseek (stream, 0, SEEK_SET);
 335       if (err)
 336         goto leave;
 337     }
 338
 339   for (;;)
 340     {
 341       err = read_header (stream, &header);
 342       if (err || header == NULL)
 343         goto leave;
 344
 345       print_header (header, es_stdout);
 346
 347       if (skip_data (stream, header))
 348         goto leave;
 349       xfree (header);
 350       header = NULL;
 351     }
 352
 353
 354  leave:
 355   xfree (header);
 356   if (stream != es_stdin)
 357     es_fclose (stream);
 358   if (stream != cipher_stream)
 359     es_fclose (cipher_stream);
 360   return err;
 361 }
 362
 363 gpg_error_t
 364 gpgtar_read_header (estream_t stream, tar_header_t *r_header)
 365 {
 366   return read_header (stream, r_header);
 367 }
 368
 369 void
 370 gpgtar_print_header (tar_header_t header, estream_t out)
 371 {
 372   if (header && out)
 373     print_header (header, out);
 374 }