gpg: Fix buglet in the check_all_keysigs function.
[gnupg.git] / tools / gpgtar.c
1 /* gpgtar.c - A simple TAR implementation mainly useful for Windows.
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 /* GnuPG comes with a shell script gpg-zip which creates archive files
21    in the same format as PGP Zip, which is actually a USTAR format.
22    That is fine and works nicely on all Unices but for Windows we
23    don't have a compatible shell and the supply of tar programs is
24    limited.  Given that we need just a few tar option and it is an
25    open question how many Unix concepts are to be mapped to Windows,
26    we might as well write our own little tar customized for use with
27    gpg.  So here we go.  */
28
29 #include <config.h>
30 #include <ctype.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36
37 #include "util.h"
38 #include "i18n.h"
39 #include "sysutils.h"
40 #include "../common/openpgpdefs.h"
41 #include "../common/init.h"
42 #include "../common/strlist.h"
43
44 #include "gpgtar.h"
45
46
47 /* Constants to identify the commands and options. */
48 enum cmd_and_opt_values
49   {
50     aNull = 0,
51     aEncrypt    = 'e',
52     aDecrypt    = 'd',
53     aSign       = 's',
54     aList       = 't',
55
56     oSymmetric  = 'c',
57     oRecipient  = 'r',
58     oUser       = 'u',
59     oOutput     = 'o',
60     oDirectory  = 'C',
61     oQuiet      = 'q',
62     oVerbose    = 'v',
63     oFilesFrom  = 'T',
64     oNoVerbose  = 500,
65
66     aSignEncrypt,
67     oGpgProgram,
68     oSkipCrypto,
69     oOpenPGP,
70     oCMS,
71     oSetFilename,
72     oNull,
73
74     /* Compatibility with gpg-zip.  */
75     oGpgArgs,
76     oTarArgs,
77
78     /* Debugging.  */
79     oDryRun,
80   };
81
82
83 /* The list of commands and options. */
84 static ARGPARSE_OPTS opts[] = {
85   ARGPARSE_group (300, N_("@Commands:\n ")),
86
87   ARGPARSE_c (aEncrypt,   "encrypt", N_("create an archive")),
88   ARGPARSE_c (aDecrypt,   "decrypt", N_("extract an archive")),
89   ARGPARSE_c (aSign,      "sign",    N_("create a signed archive")),
90   ARGPARSE_c (aList,      "list-archive", N_("list an archive")),
91
92   ARGPARSE_group (301, N_("@\nOptions:\n ")),
93
94   ARGPARSE_s_n (oSymmetric, "symmetric", N_("use symmetric encryption")),
95   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
96   ARGPARSE_s_s (oUser, "local-user",
97                 N_("|USER-ID|use USER-ID to sign or decrypt")),
98   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
99   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
100   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
101   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
102   ARGPARSE_s_n (oSkipCrypto, "skip-crypto", N_("skip the crypto processing")),
103   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
104   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
105   ARGPARSE_s_n (oOpenPGP, "openpgp", "@"),
106   ARGPARSE_s_n (oCMS, "cms", "@"),
107
108   ARGPARSE_group (302, N_("@\nTar options:\n ")),
109
110   ARGPARSE_s_s (oDirectory, "directory",
111                 N_("|DIRECTORY|extract files into DIRECTORY")),
112   ARGPARSE_s_s (oFilesFrom, "files-from",
113                 N_("|FILE|get names to create from FILE")),
114   ARGPARSE_s_n (oNull, "null", N_("-T reads null-terminated names")),
115
116   ARGPARSE_s_s (oGpgArgs, "gpg-args", "@"),
117   ARGPARSE_s_s (oTarArgs, "tar-args", "@"),
118
119   ARGPARSE_end ()
120 };
121
122
123 /* The list of commands and options for tar that we understand. */
124 static ARGPARSE_OPTS tar_opts[] = {
125   ARGPARSE_s_s (oDirectory, "directory",
126                 N_("|DIRECTORY|extract files into DIRECTORY")),
127   ARGPARSE_s_s (oFilesFrom, "files-from",
128                 N_("|FILE|get names to create from FILE")),
129   ARGPARSE_s_n (oNull, "null", N_("-T reads null-terminated names")),
130
131   ARGPARSE_end ()
132 };
133
134
135 \f
136 /* Print usage information and and provide strings for help. */
137 static const char *
138 my_strusage( int level )
139 {
140   const char *p;
141
142   switch (level)
143     {
144     case 11: p = "@GPGTAR@ (@GNUPG@)";
145       break;
146     case 13: p = VERSION; break;
147     case 17: p = PRINTABLE_OS_NAME; break;
148     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
149
150     case 1:
151     case 40:
152       p = _("Usage: gpgtar [options] [files] [directories] (-h for help)");
153       break;
154     case 41:
155       p = _("Syntax: gpgtar [options] [files] [directories]\n"
156             "Encrypt or sign files into an archive\n");
157       break;
158
159     default: p = NULL; break;
160     }
161   return p;
162 }
163
164
165 static void
166 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
167 {
168   enum cmd_and_opt_values cmd = *ret_cmd;
169
170   if (!cmd || cmd == new_cmd)
171     cmd = new_cmd;
172   else if (cmd == aSign && new_cmd == aEncrypt)
173     cmd = aSignEncrypt;
174   else if (cmd == aEncrypt && new_cmd == aSign)
175     cmd = aSignEncrypt;
176   else
177     {
178       log_error (_("conflicting commands\n"));
179       exit (2);
180     }
181
182   *ret_cmd = cmd;
183 }
184 \f
185 /* Shell-like argument splitting.
186
187    For compatibility with gpg-zip we accept arguments for GnuPG and
188    tar given as a string argument to '--gpg-args' and '--tar-args'.
189    gpg-zip was implemented as a Bourne Shell script, and therefore, we
190    need to split the string the same way the shell would.  */
191 static int
192 shell_parse_stringlist (const char *str, strlist_t *r_list)
193 {
194   strlist_t list = NULL;
195   const char *s = str;
196   char quoted = 0;
197   char arg[1024];
198   char *p = arg;
199 #define addchar(c) \
200   do { if (p - arg + 2 < sizeof arg) *p++ = (c); else return 1; } while (0)
201 #define addargument()                           \
202   do {                                          \
203     if (p > arg)                                \
204       {                                         \
205         *p = 0;                                 \
206         append_to_strlist (&list, arg);         \
207         p = arg;                                \
208       }                                         \
209   } while (0)
210
211 #define unquoted        0
212 #define singlequote     '\''
213 #define doublequote     '"'
214
215   for (; *s; s++)
216     {
217       switch (quoted)
218         {
219         case unquoted:
220           if (isspace (*s))
221             addargument ();
222           else if (*s == singlequote || *s == doublequote)
223             quoted = *s;
224           else
225             addchar (*s);
226           break;
227
228         case singlequote:
229           if (*s == singlequote)
230             quoted = unquoted;
231           else
232             addchar (*s);
233           break;
234
235         case doublequote:
236           assert (s > str || !"cannot be quoted at first char");
237           if (*s == doublequote && *(s - 1) != '\\')
238             quoted = unquoted;
239           else
240             addchar (*s);
241           break;
242
243         default:
244           assert (! "reached");
245         }
246     }
247
248   /* Append the last argument.  */
249   addargument ();
250
251 #undef doublequote
252 #undef singlequote
253 #undef unquoted
254 #undef addargument
255 #undef addchar
256   *r_list = list;
257   return 0;
258 }
259
260
261 /* Like shell_parse_stringlist, but returns an argv vector
262    instead of a strlist.  */
263 static int
264 shell_parse_argv (const char *s, int *r_argc, char ***r_argv)
265 {
266   int i;
267   strlist_t list;
268
269   if (shell_parse_stringlist (s, &list))
270     return 1;
271
272   *r_argc = strlist_length (list);
273   *r_argv = xtrycalloc (*r_argc, sizeof **r_argv);
274   if (*r_argv == NULL)
275     return 1;
276
277   for (i = 0; list; i++)
278     (*r_argv)[i] = list->d, list = list->next;
279   return 0;
280 }
281 \f
282 /* Global flags.  */
283 enum cmd_and_opt_values cmd = 0;
284 int skip_crypto = 0;
285 const char *files_from = NULL;
286 int null_names = 0;
287
288
289 /* Command line parsing.  */
290 static void
291 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
292 {
293   int no_more_options = 0;
294
295   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
296     {
297       switch (pargs->r_opt)
298         {
299         case oOutput:    opt.outfile = pargs->r.ret_str; break;
300         case oDirectory: opt.directory = pargs->r.ret_str; break;
301         case oSetFilename: opt.filename = pargs->r.ret_str; break;
302         case oQuiet:     opt.quiet = 1; break;
303         case oVerbose:   opt.verbose++; break;
304         case oNoVerbose: opt.verbose = 0; break;
305         case oFilesFrom: files_from = pargs->r.ret_str; break;
306         case oNull: null_names = 1; break;
307
308         case aList:
309         case aDecrypt:
310         case aEncrypt:
311         case aSign:
312           set_cmd (&cmd, pargs->r_opt);
313           break;
314
315         case oRecipient:
316           add_to_strlist (&opt.recipients, pargs->r.ret_str);
317           break;
318
319         case oUser:
320           opt.user = pargs->r.ret_str;
321           break;
322
323         case oSymmetric:
324           set_cmd (&cmd, aEncrypt);
325           opt.symmetric = 1;
326           break;
327
328         case oGpgProgram:
329           opt.gpg_program = pargs->r.ret_str;
330           break;
331
332         case oSkipCrypto:
333           skip_crypto = 1;
334           break;
335
336         case oOpenPGP: /* Dummy option for now.  */ break;
337         case oCMS:     /* Dummy option for now.  */ break;
338
339         case oGpgArgs:;
340           {
341             strlist_t list;
342             if (shell_parse_stringlist (pargs->r.ret_str, &list))
343               log_error ("failed to parse gpg arguments '%s'\n",
344                          pargs->r.ret_str);
345             else
346               {
347                 if (opt.gpg_arguments)
348                   strlist_last (opt.gpg_arguments)->next = list;
349                 else
350                   opt.gpg_arguments = list;
351               }
352           }
353           break;
354
355         case oTarArgs:;
356           {
357             int tar_argc;
358             char **tar_argv;
359
360             if (shell_parse_argv (pargs->r.ret_str, &tar_argc, &tar_argv))
361               log_error ("failed to parse tar arguments '%s'\n",
362                          pargs->r.ret_str);
363             else
364               {
365                 ARGPARSE_ARGS tar_args;
366                 tar_args.argc = &tar_argc;
367                 tar_args.argv = &tar_argv;
368                 tar_args.flags = ARGPARSE_FLAG_ARG0;
369                 parse_arguments (&tar_args, tar_opts);
370                 if (tar_args.err)
371                   log_error ("unsupported tar arguments '%s'\n",
372                              pargs->r.ret_str);
373                 pargs->err = tar_args.err;
374               }
375           }
376           break;
377
378         case oDryRun:
379           opt.dry_run = 1;
380           break;
381
382         default: pargs->err = 2; break;
383         }
384     }
385 }
386
387 \f
388 /* gpgtar main. */
389 int
390 main (int argc, char **argv)
391 {
392   gpg_error_t err;
393   const char *fname;
394   ARGPARSE_ARGS pargs;
395
396   assert (sizeof (struct ustar_raw_header) == 512);
397
398   gnupg_reopen_std (GPGTAR_NAME);
399   set_strusage (my_strusage);
400   log_set_prefix (GPGTAR_NAME, 1);
401
402   /* Make sure that our subsystems are ready.  */
403   i18n_init();
404   init_common_subsystems (&argc, &argv);
405
406   /* Parse the command line. */
407   pargs.argc  = &argc;
408   pargs.argv  = &argv;
409   pargs.flags = ARGPARSE_FLAG_KEEP;
410   parse_arguments (&pargs, opts);
411
412   if ((files_from && !null_names) || (!files_from && null_names))
413     log_error ("--files-from and --null may only be used in conjunction\n");
414   if (files_from && strcmp (files_from, "-"))
415     log_error ("--files-from only supports argument \"-\"\n");
416
417   if (log_get_errorcount (0))
418     exit (2);
419
420   /* Print a warning if an argument looks like an option.  */
421   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
422     {
423       int i;
424
425       for (i=0; i < argc; i++)
426         if (argv[i][0] == '-' && argv[i][1] == '-')
427           log_info (_("NOTE: '%s' is not considered an option\n"), argv[i]);
428     }
429
430   if (! opt.gpg_program)
431     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
432
433   if (opt.verbose > 1)
434     opt.debug_level = 1024;
435
436   switch (cmd)
437     {
438     case aList:
439       if (argc > 1)
440         usage (1);
441       fname = argc ? *argv : NULL;
442       if (opt.filename)
443         log_info ("note: ignoring option --set-filename\n");
444       if (files_from)
445         log_info ("note: ignoring option --files-from\n");
446       err = gpgtar_list (fname, !skip_crypto);
447       if (err && log_get_errorcount (0) == 0)
448         log_error ("listing archive failed: %s\n", gpg_strerror (err));
449       break;
450
451     case aEncrypt:
452     case aSign:
453     case aSignEncrypt:
454       if ((!argc && !null_names)
455           || (argc && null_names))
456         usage (1);
457       if (opt.filename)
458         log_info ("note: ignoring option --set-filename\n");
459       err = gpgtar_create (null_names? NULL :argv,
460                            !skip_crypto
461                            && (cmd == aEncrypt || cmd == aSignEncrypt),
462                            cmd == aSign || cmd == aSignEncrypt);
463       if (err && log_get_errorcount (0) == 0)
464         log_error ("creating archive failed: %s\n", gpg_strerror (err));
465       break;
466
467     case aDecrypt:
468       if (argc != 1)
469         usage (1);
470       if (opt.outfile)
471         log_info ("note: ignoring option --output\n");
472       if (files_from)
473         log_info ("note: ignoring option --files-from\n");
474       fname = argc ? *argv : NULL;
475       err = gpgtar_extract (fname, !skip_crypto);
476       if (err && log_get_errorcount (0) == 0)
477         log_error ("extracting archive failed: %s\n", gpg_strerror (err));
478       break;
479
480     default:
481       log_error (_("invalid command (there is no implicit command)\n"));
482       break;
483     }
484
485   return log_get_errorcount (0)? 1:0;
486 }
487
488
489 /* Read the next record from STREAM.  RECORD is a buffer provided by
490    the caller and must be at leadt of size RECORDSIZE.  The function
491    return 0 on success and and error code on failure; a diagnostic
492    printed as well.  Note that there is no need for an EOF indicator
493    because a tarball has an explicit EOF record. */
494 gpg_error_t
495 read_record (estream_t stream, void *record)
496 {
497   gpg_error_t err;
498   size_t nread;
499
500   nread = es_fread (record, 1, RECORDSIZE, stream);
501   if (nread != RECORDSIZE)
502     {
503       err = gpg_error_from_syserror ();
504       if (es_ferror (stream))
505         log_error ("error reading '%s': %s\n",
506                    es_fname_get (stream), gpg_strerror (err));
507       else
508         log_error ("error reading '%s': premature EOF "
509                    "(size of last record: %zu)\n",
510                    es_fname_get (stream), nread);
511     }
512   else
513     err = 0;
514
515   return err;
516 }
517
518
519 /* Write the RECORD of size RECORDSIZE to STREAM.  FILENAME is the
520    name of the file used for diagnostics.  */
521 gpg_error_t
522 write_record (estream_t stream, const void *record)
523 {
524   gpg_error_t err;
525   size_t nwritten;
526
527   nwritten = es_fwrite (record, 1, RECORDSIZE, stream);
528   if (nwritten != RECORDSIZE)
529     {
530       err = gpg_error_from_syserror ();
531       log_error ("error writing '%s': %s\n",
532                  es_fname_get (stream), gpg_strerror (err));
533     }
534   else
535     err = 0;
536
537   return err;
538 }
539
540
541 /* Return true if FP is an unarmored OpenPGP message.  Note that this
542    function reads a few bytes from FP but pushes them back.  */
543 #if 0
544 static int
545 openpgp_message_p (estream_t fp)
546 {
547   int ctb;
548
549   ctb = es_getc (fp);
550   if (ctb != EOF)
551     {
552       if (es_ungetc (ctb, fp))
553         log_fatal ("error ungetting first byte: %s\n",
554                    gpg_strerror (gpg_error_from_syserror ()));
555
556       if ((ctb & 0x80))
557         {
558           switch ((ctb & 0x40) ? (ctb & 0x3f) : ((ctb>>2)&0xf))
559             {
560             case PKT_MARKER:
561             case PKT_SYMKEY_ENC:
562             case PKT_ONEPASS_SIG:
563             case PKT_PUBKEY_ENC:
564             case PKT_SIGNATURE:
565             case PKT_COMMENT:
566             case PKT_OLD_COMMENT:
567             case PKT_PLAINTEXT:
568             case PKT_COMPRESSED:
569             case PKT_ENCRYPTED:
570               return 1; /* Yes, this seems to be an OpenPGP message.  */
571             default:
572               break;
573             }
574         }
575     }
576   return 0;
577 }
578 #endif