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