Add option --null
[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 <errno.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <assert.h>
35
36 #include "util.h"
37 #include "i18n.h"
38 #include "sysutils.h"
39 #include "../common/openpgpdefs.h"
40
41 #include "gpgtar.h"
42
43
44 /* Constants to identify the commands and options. */
45 enum cmd_and_opt_values
46   {
47     aNull = 0,
48     aEncrypt    = 'e',
49     aDecrypt    = 'd',
50     aSign       = 's',
51
52     oSymmetric  = 'c',
53     oRecipient  = 'r',
54     oUser       = 'u',
55     oOutput     = 'o',
56     oQuiet      = 'q',
57     oVerbose    = 'v',
58     oFilesFrom  = 'T',
59     oNoVerbose  = 500,
60
61     aSignEncrypt,
62     oSkipCrypto,
63     oSetFilename,
64     aList,
65     oNull
66   };
67
68
69 /* The list of commands and options. */
70 static ARGPARSE_OPTS opts[] = {
71   ARGPARSE_group (300, N_("@Commands:\n ")),
72     
73   ARGPARSE_c (aEncrypt,   "encrypt", N_("create an archive")),
74   ARGPARSE_c (aDecrypt,   "decrypt", N_("extract an archive")),
75   ARGPARSE_c (aSign,      "sign",    N_("create a signed archive")),
76   ARGPARSE_c (aList,      "list-archive", N_("list an archive")),
77
78   ARGPARSE_group (301, N_("@\nOptions:\n ")),
79
80   ARGPARSE_s_n (oSymmetric, "symmetric", N_("use symmetric encryption")),
81   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
82   ARGPARSE_s_s (oUser, "local-user",
83                 N_("|USER-ID|use USER-ID to sign or decrypt")),
84   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
85   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
86   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
87   ARGPARSE_s_n (oSkipCrypto, "skip-crypto", N_("skip the crypto processing")),
88   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
89   ARGPARSE_s_s (oFilesFrom, "files-from",
90                 N_("|FILE|get names to create from FILE")),
91   ARGPARSE_s_n (oNull, "null", N_("-T reads null-terminated names")),
92
93
94   ARGPARSE_end ()
95 };
96
97
98 \f
99 static void tar_and_encrypt (char **inpattern);
100 static void decrypt_and_untar (const char *fname);
101 static void decrypt_and_list (const char *fname);
102
103
104
105 \f
106 /* Print usage information and and provide strings for help. */
107 static const char *
108 my_strusage( int level )
109 {
110   const char *p;
111
112   switch (level)
113     {
114     case 11: p = "gpgtar (GnuPG)";
115       break;
116     case 13: p = VERSION; break;
117     case 17: p = PRINTABLE_OS_NAME; break;
118     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
119
120     case 1:
121     case 40:
122       p = _("Usage: gpgtar [options] [files] [directories] (-h for help)");
123       break;
124     case 41:
125       p = _("Syntax: gpgtar [options] [files] [directories]\n"
126             "Encrypt or sign files into an archive\n");
127       break;
128
129     default: p = NULL; break;
130     }
131   return p;
132 }
133
134
135 static void
136 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
137 {
138   enum cmd_and_opt_values cmd = *ret_cmd;
139
140   if (!cmd || cmd == new_cmd)
141     cmd = new_cmd;
142   else if (cmd == aSign && new_cmd == aEncrypt)
143     cmd = aSignEncrypt;
144   else if (cmd == aEncrypt && new_cmd == aSign)
145     cmd = aSignEncrypt;
146   else 
147     {
148       log_error (_("conflicting commands\n"));
149       exit (2);
150     }
151
152   *ret_cmd = cmd;
153 }
154
155
156 \f
157 /* gpgtar main. */
158 int
159 main (int argc, char **argv)
160 {
161   ARGPARSE_ARGS pargs;
162   const char *fname;
163   int no_more_options = 0;
164   enum cmd_and_opt_values cmd = 0;
165   int skip_crypto = 0;
166   const char *files_from = NULL;
167   int null_names = 0;
168
169   assert (sizeof (struct ustar_raw_header) == 512);
170
171   gnupg_reopen_std ("gpgtar");
172   set_strusage (my_strusage);
173   log_set_prefix ("gpgtar", 1);
174
175   /* Make sure that our subsystems are ready.  */
176   i18n_init();
177   init_common_subsystems (&argc, &argv);
178
179   /* Parse the command line. */
180   pargs.argc  = &argc;
181   pargs.argv  = &argv;
182   pargs.flags = ARGPARSE_FLAG_KEEP;
183   while (!no_more_options && optfile_parse (NULL, NULL, NULL, &pargs, opts))
184     {
185       switch (pargs.r_opt)
186         {
187         case oOutput:    opt.outfile = pargs.r.ret_str; break;
188         case oSetFilename: opt.filename = pargs.r.ret_str; break;
189         case oQuiet:     opt.quiet = 1; break;
190         case oVerbose:   opt.verbose++; break;
191         case oNoVerbose: opt.verbose = 0; break;
192         case oFilesFrom: files_from = pargs.r.ret_str; break;
193         case oNull: null_names = 1; break;
194           
195         case aList:
196         case aDecrypt:
197         case aEncrypt:
198         case aSign:
199           set_cmd (&cmd, pargs.r_opt);
200           break;
201
202         case oSymmetric:
203           set_cmd (&cmd, aEncrypt);
204           opt.symmetric = 1;
205           break;
206
207         case oSkipCrypto:
208           skip_crypto = 1;
209           break;
210
211         default: pargs.err = 2; break;
212         }
213     }
214   
215   if ((files_from && !null_names) || (!files_from && null_names))
216     log_error ("--files-from and --null may only be used in conjunction\n");
217   if (files_from && strcmp (files_from, "-"))
218     log_error ("--files-from only supports argument \"-\"\n");
219
220   if (log_get_errorcount (0))
221     exit (2);
222
223   switch (cmd)
224     {
225     case aList:
226       if (argc > 1)
227         usage (1);
228       fname = argc ? *argv : NULL;
229       if (opt.filename)
230         log_info ("note: ignoring option --set-filename\n");
231       if (files_from)
232         log_info ("note: ignoring option --files-from\n");
233       if (skip_crypto)
234         gpgtar_list (fname);
235       else
236         decrypt_and_list (fname);
237       break;
238
239     case aEncrypt:
240       if ((!argc && !null_names)
241           || (argc && null_names))
242         usage (1);
243       if (opt.filename)
244         log_info ("note: ignoring option --set-filename\n");
245       if (skip_crypto)
246         gpgtar_create (null_names? NULL :argv);
247       else
248         tar_and_encrypt (null_names? NULL : argv);
249       break;
250
251     case aDecrypt:
252       if (argc != 1)
253         usage (1);
254       if (opt.outfile)
255         log_info ("note: ignoring option --output\n");
256       if (files_from)
257         log_info ("note: ignoring option --files-from\n");
258       fname = argc ? *argv : NULL;
259       if (skip_crypto)
260         gpgtar_extract (fname);
261       else
262         decrypt_and_untar (fname);
263       break;
264
265     default:
266       log_error (_("invalid command (there is no implicit command)\n"));
267       break;
268     }
269
270   return log_get_errorcount (0)? 1:0;
271 }
272
273
274 /* Read the next record from STREAM.  RECORD is a buffer provided by
275    the caller and must be at leadt of size RECORDSIZE.  The function
276    return 0 on success and and error code on failure; a diagnostic
277    printed as well.  Note that there is no need for an EOF indicator
278    because a tarball has an explicit EOF record. */
279 gpg_error_t
280 read_record (estream_t stream, void *record)
281 {
282   gpg_error_t err;
283   size_t nread;
284
285   nread = es_fread (record, 1, RECORDSIZE, stream);
286   if (nread != RECORDSIZE)
287     {
288       err = gpg_error_from_syserror ();
289       if (es_ferror (stream))
290         log_error ("error reading `%s': %s\n",
291                    es_fname_get (stream), gpg_strerror (err));
292       else
293         log_error ("error reading `%s': premature EOF "
294                    "(size of last record: %zu)\n",
295                    es_fname_get (stream), nread);
296     }
297   else
298     err = 0;
299
300   return err;
301 }
302
303
304 /* Write the RECORD of size RECORDSIZE to STREAM.  FILENAME is the
305    name of the file used for diagnostics.  */
306 gpg_error_t
307 write_record (estream_t stream, const void *record)
308 {
309   gpg_error_t err;
310   size_t nwritten;
311
312   nwritten = es_fwrite (record, 1, RECORDSIZE, stream);
313   if (nwritten != RECORDSIZE)
314     {
315       err = gpg_error_from_syserror ();
316       log_error ("error writing `%s': %s\n",
317                  es_fname_get (stream), gpg_strerror (err));
318     }
319   else
320     err = 0;
321   
322   return err;
323 }
324
325
326 /* Return true if FP is an unarmored OpenPGP message.  Note that this
327    fucntion reads a few bytes from FP but pushes them back.  */
328 #if 0
329 static int
330 openpgp_message_p (estream_t fp)
331 {
332   int ctb;
333
334   ctb = es_getc (fp);
335   if (ctb != EOF)
336     {
337       if (es_ungetc (ctb, fp))
338         log_fatal ("error ungetting first byte: %s\n", 
339                    gpg_strerror (gpg_error_from_syserror ()));
340       
341       if ((ctb & 0x80))
342         {
343           switch ((ctb & 0x40) ? (ctb & 0x3f) : ((ctb>>2)&0xf))
344             {
345             case PKT_MARKER:
346             case PKT_SYMKEY_ENC:
347             case PKT_ONEPASS_SIG:
348             case PKT_PUBKEY_ENC:
349             case PKT_SIGNATURE:
350             case PKT_COMMENT:
351             case PKT_OLD_COMMENT:
352             case PKT_PLAINTEXT:
353             case PKT_COMPRESSED:
354             case PKT_ENCRYPTED:
355               return 1; /* Yes, this seems to be an OpenPGP message.  */
356             default:
357               break;
358             }
359         }
360     }
361   return 0;
362 }
363 #endif
364
365
366
367 \f
368 static void
369 tar_and_encrypt (char **inpattern)
370 {
371   (void)inpattern;
372   log_error ("tar_and_encrypt has not yet been implemented\n");
373 }
374
375
376 \f
377 static void
378 decrypt_and_untar (const char *fname)
379 {
380   (void)fname;
381   log_error ("decrypt_and_untar has not yet been implemented\n");
382 }
383
384
385 \f
386 static void
387 decrypt_and_list (const char *fname)
388 {
389   (void)fname;
390   log_error ("decrypt_and_list has not yet been implemented\n");
391 }