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 #include <fcntl.h>
  27
  28 #include "i18n.h"
  29 #include "gpgtar.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 or NULL one error.  In case of an error an error
 173    message has been printed.  */
 174 static tar_header_t
 175 read_header (estream_t stream)
 176 {
 177   gpg_error_t err;
 178   char record[RECORDSIZE];
 179   int i;
 180
 181   err = read_record (stream, record);
 182   if (err)
 183     return NULL;
 184
 185   for (i=0; i < RECORDSIZE && !record[i]; i++)
 186     ;
 187   if (i == RECORDSIZE)
 188     {
 189       /* All zero header - check whether it is the first part of an
 190          end of archive mark.  */
 191       err = read_record (stream, record);
 192       if (err)
 193         return NULL;
 194
 195       for (i=0; i < RECORDSIZE && !record[i]; i++)
 196         ;
 197       if (i != RECORDSIZE)
 198         log_info ("%s: warning: skipping empty header\n",
 199                   es_fname_get (stream));
 200       else
 201         {
 202           /* End of archive - FIXME: we might want to check for garbage.  */
 203           return NULL;
 204         }
 205     }
 206
 207   return parse_header (record, es_fname_get (stream));
 208 }
 209
 210
 211 /* Skip the data records according to HEADER.  Prints an error message
 212    on error and return -1. */
 213 static int
 214 skip_data (estream_t stream, tar_header_t header)
 215 {
 216   char record[RECORDSIZE];
 217   unsigned long long n;
 218
 219   for (n=0; n < header->nrecords; n++)
 220     {
 221       if (read_record (stream, record))
 222         return -1;
 223     }
 224
 225   return 0;
 226 }
 227
 228
 229 \f
 230 static void
 231 print_header (tar_header_t header, estream_t out)
 232 {
 233   unsigned long mask;
 234   char modestr[10+1];
 235   int i;
 236
 237   *modestr = '?';
 238   switch (header->typeflag)
 239     {
 240     case TF_REGULAR:  *modestr = '-'; break;
 241     case TF_HARDLINK: *modestr = 'h'; break;
 242     case TF_SYMLINK:  *modestr = 'l'; break;
 243     case TF_CHARDEV:  *modestr = 'c'; break;
 244     case TF_BLOCKDEV: *modestr = 'b'; break;
 245     case TF_DIRECTORY:*modestr = 'd'; break;
 246     case TF_FIFO:     *modestr = 'f'; break;
 247     case TF_RESERVED: *modestr = '='; break;
 248     case TF_UNKNOWN:  break;
 249     case TF_NOTSUP:   break;
 250     }
 251   for (mask = 0400, i = 0; i < 9; i++, mask >>= 1)
 252     modestr[1+i] = (header->mode & mask)? "rwxrwxrwx"[i]:'-';
 253   if ((header->typeflag & 04000))
 254     modestr[3] = modestr[3] == 'x'? 's':'S';
 255   if ((header->typeflag & 02000))
 256     modestr[6] = modestr[6] == 'x'? 's':'S';
 257   if ((header->typeflag & 01000))
 258     modestr[9] = modestr[9] == 'x'? 't':'T';
 259   modestr[10] = 0;
 260
 261   es_fprintf (out, "%s %lu %lu/%lu %12llu %s %s\n",
 262               modestr, header->nlink, header->uid, header->gid, header->size,
 263               isotimestamp (header->mtime), header->name);
 264 }
 265
 266
 267 \f
 268 /* List the tarball FILENAME or, if FILENAME is NULL, the tarball read
 269    from stdin.  */
 270 void
 271 gpgtar_list (const char *filename)
 272 {
 273   gpg_error_t err;
 274   estream_t stream;
 275   tar_header_t header;
 276
 277   if (filename)
 278     {
 279       if (!strcmp (filename, "-"))
 280         stream = es_stdin;
 281       else
 282         stream = es_fopen (filename, "rb");
 283       if (!stream)
 284         {
 285           err = gpg_error_from_syserror ();
 286           log_error ("error opening `%s': %s\n", filename, gpg_strerror (err));
 287           return;
 288         }
 289     }
 290   else
 291     stream = es_stdin;
 292
 293 #ifdef HAVE_DOSISH_SYSTEM
 294   if (stream == es_stdin)
 295     setmode (es_fileno (es_stdin), O_BINARY);
 296 #endif
 297
 298   for (;;)
 299     {
 300       header = read_header (stream);
 301       if (!header)
 302         goto leave;
 303
 304       print_header (header, es_stdout);
 305
 306       if (skip_data (stream, header))
 307         goto leave;
 308       xfree (header);
 309       header = NULL;
 310     }
 311
 312
 313  leave:
 314   xfree (header);
 315   if (stream != es_stdin)
 316     es_fclose (stream);
 317   return;
 318 }
 319
 320 tar_header_t
 321 gpgtar_read_header (estream_t stream)
 322 {
 323   /*FIXME: Change to return an error code.  */
 324   return read_header (stream);
 325 }
 326
 327 void
 328 gpgtar_print_header (tar_header_t header, estream_t out)
 329 {
 330   if (header && out)
 331     print_header (header, out);
 332 }