common: Make the GPG arguments configurable in call-gpg.
[gnupg.git] / 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/call-gpg.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       cipher_stream = stream;
303       stream = es_fopenmem (0, "rwb");
304       if (! stream)
305         {
306           err = gpg_error_from_syserror ();
307           goto leave;
308         }
309       err = gpg_decrypt_stream (NULL, opt.gpg_program, NULL,
310                                 cipher_stream, stream);
311       if (err)
312         goto leave;
313
314       err = es_fseek (stream, 0, SEEK_SET);
315       if (err)
316         goto leave;
317     }
318
319   for (;;)
320     {
321       err = read_header (stream, &header);
322       if (err || header == NULL)
323         goto leave;
324
325       print_header (header, es_stdout);
326
327       if (skip_data (stream, header))
328         goto leave;
329       xfree (header);
330       header = NULL;
331     }
332
333
334  leave:
335   xfree (header);
336   if (stream != es_stdin)
337     es_fclose (stream);
338   if (stream != cipher_stream)
339     es_fclose (cipher_stream);
340   return err;
341 }
342
343 gpg_error_t
344 gpgtar_read_header (estream_t stream, tar_header_t *r_header)
345 {
346   return read_header (stream, r_header);
347 }
348
349 void
350 gpgtar_print_header (tar_header_t header, estream_t out)
351 {
352   if (header && out)
353     print_header (header, out);
354 }