tools/gpgtar: Improve error handling.
[gnupg.git] / tools / gpgtar-extract.c
1 /* gpgtar-extract.c - Extract from 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 <sys/types.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 #include <assert.h>
29
30 #include "i18n.h"
31 #include "../common/call-gpg.h"
32 #include "../common/sysutils.h"
33 #include "gpgtar.h"
34
35
36 static gpg_error_t
37 extract_regular (estream_t stream, const char *dirname,
38                  tar_header_t hdr)
39 {
40   gpg_error_t err;
41   char record[RECORDSIZE];
42   size_t n, nbytes, nwritten;
43   char *fname;
44   estream_t outfp = NULL;
45
46   fname = strconcat (dirname, "/", hdr->name, NULL);
47   if (!fname)
48     {
49       err = gpg_error_from_syserror ();
50       log_error ("error creating filename: %s\n", gpg_strerror (err));
51       goto leave;
52     }
53   else
54     err = 0;
55
56   outfp = es_fopen (fname, "wb");
57   if (!outfp)
58     {
59       err = gpg_error_from_syserror ();
60       log_error ("error creating '%s': %s\n", fname, gpg_strerror (err));
61       goto leave;
62     }
63
64   for (n=0; n < hdr->nrecords;)
65     {
66       err = read_record (stream, record);
67       if (err)
68         goto leave;
69       n++;
70       if (n < hdr->nrecords || (hdr->size && !(hdr->size % RECORDSIZE)))
71         nbytes = RECORDSIZE;
72       else
73         nbytes = (hdr->size % RECORDSIZE);
74
75       nwritten = es_fwrite (record, 1, nbytes, outfp);
76       if (nwritten != nbytes)
77         {
78           err = gpg_error_from_syserror ();
79           log_error ("error writing '%s': %s\n", fname, gpg_strerror (err));
80           goto leave;
81         }
82     }
83   /* Fixme: Set permissions etc.  */
84
85  leave:
86   if (!err && opt.verbose)
87     log_info ("extracted '%s'\n", fname);
88   es_fclose (outfp);
89   if (err && fname && outfp)
90     {
91       if (gnupg_remove (fname))
92         log_error ("error removing incomplete file '%s': %s\n",
93                    fname, gpg_strerror (gpg_error_from_syserror ()));
94     }
95   xfree (fname);
96   return err;
97 }
98
99
100 static gpg_error_t
101 extract_directory (const char *dirname, tar_header_t hdr)
102 {
103   gpg_error_t err;
104   char *fname;
105   size_t prefixlen;
106
107   prefixlen = strlen (dirname) + 1;
108   fname = strconcat (dirname, "/", hdr->name, NULL);
109   if (!fname)
110     {
111       err = gpg_error_from_syserror ();
112       log_error ("error creating filename: %s\n", gpg_strerror (err));
113       goto leave;
114     }
115   else
116     err = 0;
117
118   if (fname[strlen (fname)-1] == '/')
119     fname[strlen (fname)-1] = 0;
120
121  /* Note that we don't need to care about EEXIST because we always
122      extract into a new hierarchy.  */
123   if (gnupg_mkdir (fname, "-rwx------"))
124     {
125       err = gpg_error_from_syserror ();
126       if (gpg_err_code (err) == GPG_ERR_ENOENT)
127         {
128           /* Try to create the directory with parents but keep the
129              original error code in case of a failure.  */
130           char *p;
131           int rc = 0;
132
133           for (p = fname+prefixlen; (p = strchr (p, '/')); p++)
134             {
135               *p = 0;
136               rc = gnupg_mkdir (fname, "-rwx------");
137               *p = '/';
138               if (rc)
139                 break;
140             }
141           if (!rc && !gnupg_mkdir (fname, "-rwx------"))
142             err = 0;
143         }
144       if (err)
145         log_error ("error creating directory '%s': %s\n",
146                    fname, gpg_strerror (err));
147     }
148
149  leave:
150   if (!err && opt.verbose)
151     log_info ("created   '%s/'\n", fname);
152   xfree (fname);
153   return err;
154 }
155
156
157 static gpg_error_t
158 extract (estream_t stream, const char *dirname, tar_header_t hdr)
159 {
160   gpg_error_t err;
161   size_t n;
162
163   n = strlen (hdr->name);
164 #ifdef HAVE_DOSISH_SYSTEM
165   if (strchr (hdr->name, '\\'))
166     {
167       log_error ("filename '%s' contains a backslash - "
168                  "can't extract on this system\n", hdr->name);
169       return gpg_error (GPG_ERR_INV_NAME);
170     }
171 #endif /*HAVE_DOSISH_SYSTEM*/
172
173   if (!n
174       || strstr (hdr->name, "//")
175       || strstr (hdr->name, "/../")
176       || !strncmp (hdr->name, "../", 3)
177       || (n >= 3 && !strcmp (hdr->name+n-3, "/.." )))
178     {
179       log_error ("filename '%s' as suspicious parts - not extracting\n",
180                  hdr->name);
181       return gpg_error (GPG_ERR_INV_NAME);
182     }
183
184   if (hdr->typeflag == TF_REGULAR || hdr->typeflag == TF_UNKNOWN)
185     err = extract_regular (stream, dirname, hdr);
186   else if (hdr->typeflag == TF_DIRECTORY)
187     err = extract_directory (dirname, hdr);
188   else
189     {
190       char record[RECORDSIZE];
191
192       log_info ("unsupported file type %d for '%s' - skipped\n",
193                 (int)hdr->typeflag, hdr->name);
194       for (err = 0, n=0; !err && n < hdr->nrecords; n++)
195         err = read_record (stream, record);
196     }
197   return err;
198 }
199
200
201 /* Create a new directory to be used for extracting the tarball.
202    Returns the name of the directory which must be freed by the
203    caller.  In case of an error a diagnostic is printed and NULL
204    returned.  */
205 static char *
206 create_directory (const char *dirprefix)
207 {
208   gpg_error_t err = 0;
209   char *prefix_buffer = NULL;
210   char *dirname = NULL;
211   size_t n;
212   int idx;
213
214   /* Remove common suffixes.  */
215   n = strlen (dirprefix);
216   if (n > 4 && (!compare_filenames    (dirprefix + n - 4, EXTSEP_S GPGEXT_GPG)
217                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pgp")
218                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "asc")
219                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pem")
220                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7m")
221                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7e")))
222     {
223       prefix_buffer = xtrystrdup (dirprefix);
224       if (!prefix_buffer)
225         {
226           err = gpg_error_from_syserror ();
227           goto leave;
228         }
229       prefix_buffer[n-4] = 0;
230       dirprefix = prefix_buffer;
231     }
232
233
234
235   for (idx=1; idx < 5000; idx++)
236     {
237       xfree (dirname);
238       dirname = xtryasprintf ("%s_%d_", dirprefix, idx);
239       if (!dirname)
240         {
241           err = gpg_error_from_syserror ();
242           goto leave;
243         }
244       if (!gnupg_mkdir (dirname, "-rwx------"))
245         goto leave; /* Ready.  */
246       if (errno != EEXIST && errno != ENOTDIR)
247         {
248           err = gpg_error_from_syserror ();
249           goto leave;
250         }
251     }
252   err = gpg_error (GPG_ERR_LIMIT_REACHED);
253
254  leave:
255   if (err)
256     {
257       log_error ("error creating an extract directory: %s\n",
258                  gpg_strerror (err));
259       xfree (dirname);
260       dirname = NULL;
261     }
262   xfree (prefix_buffer);
263   return dirname;
264 }
265
266
267 \f
268 gpg_error_t
269 gpgtar_extract (const char *filename, int decrypt)
270 {
271   gpg_error_t err;
272   estream_t stream;
273   estream_t cipher_stream = NULL;
274   tar_header_t header = NULL;
275   const char *dirprefix = NULL;
276   char *dirname = NULL;
277
278   if (filename)
279     {
280       if (!strcmp (filename, "-"))
281         stream = es_stdout;
282       else
283         stream = es_fopen (filename, "rb");
284       if (!stream)
285         {
286           err = gpg_error_from_syserror ();
287           log_error ("error opening '%s': %s\n", filename, gpg_strerror (err));
288           return err;
289         }
290     }
291   else
292     stream = es_stdin;
293
294   if (stream == es_stdin)
295     es_set_binary (es_stdin);
296
297   if (decrypt)
298     {
299       cipher_stream = stream;
300       stream = es_fopenmem (0, "rwb");
301       if (! stream)
302         {
303           err = gpg_error_from_syserror ();
304           goto leave;
305         }
306       err = gpg_decrypt_stream (NULL, NULL, cipher_stream, stream);
307       if (err)
308         goto leave;
309
310       err = es_fseek (stream, 0, SEEK_SET);
311       if (err)
312         goto leave;
313     }
314
315   if (filename)
316     {
317       dirprefix = strrchr (filename, '/');
318       if (dirprefix)
319         dirprefix++;
320       else
321         dirprefix = filename;
322     }
323   else if (opt.filename)
324     {
325       dirprefix = strrchr (opt.filename, '/');
326       if (dirprefix)
327         dirprefix++;
328       else
329         dirprefix = opt.filename;
330     }
331
332   if (!dirprefix || !*dirprefix)
333     dirprefix = "GPGARCH";
334
335   dirname = create_directory (dirprefix);
336   if (!dirname)
337     {
338       err = gpg_error (GPG_ERR_GENERAL);
339       goto leave;
340     }
341
342   if (opt.verbose)
343     log_info ("extracting to '%s/'\n", dirname);
344
345   for (;;)
346     {
347       err = gpgtar_read_header (stream, &header);
348       if (err || header == NULL)
349         goto leave;
350
351       err = extract (stream, dirname, header);
352       if (err)
353         goto leave;
354       xfree (header);
355       header = NULL;
356     }
357
358
359  leave:
360   xfree (header);
361   xfree (dirname);
362   if (stream != es_stdin)
363     es_fclose (stream);
364   if (stream != cipher_stream)
365     es_fclose (cipher_stream);
366   return err;
367 }