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