gpg: Add dedicated error code for PGP-2 keys.
[gnupg.git] / g10 / openfile.c
1 /* openfile.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009,
3  *               2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <errno.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31
32 #include "gpg.h"
33 #include "util.h"
34 #include "ttyio.h"
35 #include "options.h"
36 #include "main.h"
37 #include "status.h"
38 #include "i18n.h"
39
40 #ifdef USE_ONLY_8DOT3
41 #define SKELEXT ".skl"
42 #else
43 #define SKELEXT EXTSEP_S "skel"
44 #endif
45
46 #ifdef HAVE_W32_SYSTEM
47 #define NAME_OF_DEV_NULL "nul"
48 #else
49 #define NAME_OF_DEV_NULL "/dev/null"
50 #endif
51
52
53 #if defined (HAVE_DRIVE_LETTERS) || defined (__riscos__)
54 #define CMP_FILENAME(a,b) ascii_strcasecmp( (a), (b) )
55 #else
56 #define CMP_FILENAME(a,b) strcmp( (a), (b) )
57 #endif
58
59
60 /* FIXME:  Implement opt.interactive. */
61
62 /*
63  * Check whether FNAME exists and ask if it's okay to overwrite an
64  * existing one.
65  * Returns: True: it's okay to overwrite or the file does not exist
66  *          False: Do not overwrite
67  */
68 int
69 overwrite_filep( const char *fname )
70 {
71   if ( iobuf_is_pipe_filename (fname) )
72     return 1; /* Writing to stdout is always okay.  */
73
74   if ( access( fname, F_OK ) )
75     return 1; /* Does not exist.  */
76
77   if ( !compare_filenames (fname, NAME_OF_DEV_NULL) )
78     return 1; /* Does not do any harm.  */
79
80   if (opt.answer_yes)
81     return 1;
82   if (opt.answer_no || opt.batch)
83     return 0;  /* Do not overwrite.  */
84
85   tty_printf (_("File '%s' exists. "), fname);
86   if (cpr_enabled ())
87     tty_printf ("\n");
88   if (cpr_get_answer_is_yes ("openfile.overwrite.okay",
89                              _("Overwrite? (y/N) ")) )
90     return 1;
91   return 0;
92 }
93
94
95 /*
96  * Strip known extensions from iname and return a newly allocated
97  * filename.  Return NULL if we can't do that.
98  */
99 char *
100 make_outfile_name (const char *iname)
101 {
102   size_t n;
103
104   if (iobuf_is_pipe_filename (iname))
105     return xstrdup ("-");
106
107   n = strlen (iname);
108   if (n > 4 && (!CMP_FILENAME(iname+n-4, EXTSEP_S GPGEXT_GPG)
109                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "pgp")
110                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "sig")
111                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "asc")))
112     {
113       char *buf = xstrdup (iname);
114       buf[n-4] = 0;
115       return buf;
116     }
117   else if (n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign"))
118     {
119       char *buf = xstrdup (iname);
120       buf[n-5] = 0;
121       return buf;
122     }
123
124   log_info (_("%s: unknown suffix\n"), iname);
125   return NULL;
126 }
127
128
129 /* Ask for an output filename; use the given one as default.  Return
130    NULL if no file has been given or if it is not possible to ask the
131    user.  NAME is the template len which might conatin enbedded Nuls.
132    NAMELEN is its actual length.
133  */
134 char *
135 ask_outfile_name( const char *name, size_t namelen )
136 {
137   size_t n;
138   const char *s;
139   char *prompt;
140   char *fname;
141   char *defname;
142
143   if ( opt.batch )
144     return NULL;
145
146   defname = name && namelen? make_printable_string (name, namelen, 0) : NULL;
147
148   s = _("Enter new filename");
149   n = strlen(s) + (defname?strlen (defname):0) + 10;
150   prompt = xmalloc (n);
151   if (defname)
152     snprintf (prompt, n-1, "%s [%s]: ", s, defname );
153   else
154     snprintf (prompt, n-1, "%s: ", s );
155   tty_enable_completion(NULL);
156   fname = cpr_get ("openfile.askoutname", prompt );
157   cpr_kill_prompt ();
158   tty_disable_completion ();
159   xfree (prompt);
160   if ( !*fname )
161     {
162       xfree (fname);
163       fname = defname;
164       defname = NULL;
165     }
166   xfree (defname);
167   if (fname)
168     trim_spaces (fname);
169   return fname;
170 }
171
172
173 /*
174  * Make an output filename for the inputfile INAME.
175  * Returns an IOBUF and an errorcode
176  * Mode 0 = use ".gpg"
177  *      1 = use ".asc"
178  *      2 = use ".sig"
179  *      3 = use ".rev"
180  *
181  * If INP_FD is not -1 the function simply creates an IOBUF for that
182  * file descriptor and ignore INAME and MODE.  Note that INP_FD won't
183  * be closed if the returned IOBUF is closed.  With RESTRICTEDPERM a
184  * file will be created with mode 700 if possible.
185  */
186 int
187 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
188               iobuf_t *a)
189 {
190   int rc = 0;
191
192   *a = NULL;
193   if (inp_fd != -1)
194     {
195       char xname[64];
196
197       *a = iobuf_fdopen_nc (inp_fd, "wb");
198       if (!*a)
199         {
200           rc = gpg_error_from_syserror ();
201           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
202           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
203         }
204       else if (opt.verbose)
205         {
206           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
207           log_info (_("writing to '%s'\n"), xname);
208         }
209     }
210   else if (iobuf_is_pipe_filename (iname) && !opt.outfile)
211     {
212       *a = iobuf_create (NULL, 0);
213       if ( !*a )
214         {
215           rc = gpg_error_from_syserror ();
216           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
217         }
218       else if ( opt.verbose )
219         log_info (_("writing to stdout\n"));
220     }
221   else
222     {
223       char *buf = NULL;
224       const char *name;
225
226       if (opt.dry_run)
227         name = NAME_OF_DEV_NULL;
228       else if (opt.outfile)
229         name = opt.outfile;
230       else
231         {
232 #ifdef USE_ONLY_8DOT3
233           if (opt.mangle_dos_filenames)
234             {
235               /* It is quite common for DOS systems to have only one
236                  dot in a filename.  If we have something like this,
237                  we simple replace the suffix except in cases where
238                  the suffix is larger than 3 characters and not the
239                  same as the new one.  We don't map the filenames to
240                  8.3 because this is a duty of the file system.  */
241               char *dot;
242               const char *newsfx;
243
244               newsfx = (mode==1 ? ".asc" :
245                         mode==2 ? ".sig" :
246                         mode==3 ? ".rev" : ".gpg");
247
248               buf = xmalloc (strlen(iname)+4+1);
249               strcpy (buf, iname);
250               dot = strchr (buf, '.' );
251               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
252                    && CMP_FILENAME (newsfx, dot) )
253                 strcpy (dot, newsfx);
254               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
255                 strcpy (dot, newsfx+1);
256               else
257                 strcat (buf, newsfx);
258             }
259           if (!buf)
260 #endif /* USE_ONLY_8DOT3 */
261             {
262               buf = xstrconcat (iname,
263                                 (mode==1 ? EXTSEP_S "asc" :
264                                  mode==2 ? EXTSEP_S "sig" :
265                                  mode==3 ? EXTSEP_S "rev" :
266                                  /*     */ EXTSEP_S GPGEXT_GPG),
267                                 NULL);
268             }
269           name = buf;
270         }
271
272       rc = 0;
273       while ( !overwrite_filep (name) )
274         {
275           char *tmp = ask_outfile_name (NULL, 0);
276           if ( !tmp || !*tmp )
277             {
278               xfree (tmp);
279               rc = gpg_error (GPG_ERR_EEXIST);
280               break;
281             }
282           xfree (buf);
283           name = buf = tmp;
284         }
285
286       if ( !rc )
287         {
288           if (is_secured_filename (name) )
289             {
290               *a = NULL;
291               gpg_err_set_errno (EPERM);
292             }
293           else
294             *a = iobuf_create (name, restrictedperm);
295           if (!*a)
296             {
297               rc = gpg_error_from_syserror ();
298               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
299             }
300           else if( opt.verbose )
301             log_info (_("writing to '%s'\n"), name );
302         }
303       xfree(buf);
304     }
305
306   if (*a)
307     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
308
309   return rc;
310 }
311
312
313 /* Find a matching data file for the signature file SIGFILENAME and
314    return it as a malloced string.  If no matching data file is found,
315    return NULL.  */
316 char *
317 get_matching_datafile (const char *sigfilename)
318 {
319   char *fname = NULL;
320   size_t len;
321
322   if (iobuf_is_pipe_filename (sigfilename))
323     return NULL;
324
325   len = strlen (sigfilename);
326   if (len > 4
327       && (!strcmp (sigfilename + len - 4, EXTSEP_S "sig")
328           || (len > 5 && !strcmp(sigfilename + len - 5, EXTSEP_S "sign"))
329           || !strcmp(sigfilename + len - 4, EXTSEP_S "asc")))
330     {
331
332       fname = xstrdup (sigfilename);
333       fname[len-(fname[len-1]=='n'?5:4)] = 0 ;
334       if (access (fname, R_OK ))
335         {
336           /* Not found or other error.  */
337           xfree (fname);
338           fname = NULL;
339         }
340     }
341
342   return fname;
343 }
344
345
346 /*
347  * Try to open a file without the extension ".sig" or ".asc"
348  * Return NULL if such a file is not available.
349  */
350 iobuf_t
351 open_sigfile (const char *sigfilename, progress_filter_context_t *pfx)
352 {
353   iobuf_t a = NULL;
354   char *buf;
355
356   buf = get_matching_datafile (sigfilename);
357   if (buf)
358     {
359       a = iobuf_open (buf);
360       if (a && is_secured_file (iobuf_get_fd (a)))
361         {
362           iobuf_close (a);
363           a = NULL;
364           gpg_err_set_errno (EPERM);
365         }
366       if (a)
367         log_info (_("assuming signed data in '%s'\n"), buf);
368       if (a && pfx)
369         handle_progress (pfx, a, buf);
370       xfree (buf);
371     }
372
373   return a;
374 }
375
376
377 /****************
378  * Copy the option file skeleton to the given directory.
379  */
380 static void
381 copy_options_file (const char *destdir)
382 {
383   const char *datadir = gnupg_datadir ();
384   char *fname;
385   FILE *src, *dst;
386   int linefeeds=0;
387   int c;
388   mode_t oldmask;
389   int esc = 0;
390   int any_option = 0;
391
392   if (opt.dry_run)
393     return;
394
395   fname = xmalloc (strlen(datadir) + strlen(destdir) + 15);
396   strcpy (stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT);
397   src = fopen (fname, "r");
398   if (src && is_secured_file (fileno (src)))
399     {
400       fclose (src);
401       src = NULL;
402       gpg_err_set_errno (EPERM);
403     }
404   if (!src)
405     {
406       log_info (_("can't open '%s': %s\n"), fname, strerror(errno));
407       xfree(fname);
408       return;
409     }
410   strcpy (stpcpy (fname, destdir), DIRSEP_S GPGEXT_GPG EXTSEP_S "conf");
411
412   oldmask = umask (077);
413   if (is_secured_filename (fname))
414     {
415       dst = NULL;
416       gpg_err_set_errno (EPERM);
417     }
418   else
419     dst = fopen( fname, "w" );
420   umask (oldmask);
421
422   if (!dst)
423     {
424       log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
425       fclose (src);
426       xfree (fname);
427       return;
428     }
429
430   while ((c = getc (src)) != EOF)
431     {
432       if (linefeeds < 3)
433         {
434           if (c == '\n')
435             linefeeds++;
436         }
437       else
438         {
439           putc (c, dst);
440           if (c== '\n')
441             esc = 1;
442           else if (esc == 1)
443             {
444               if (c == ' ' || c == '\t')
445                 ;
446               else if (c == '#')
447                 esc = 2;
448               else
449                 any_option = 1;
450             }
451         }
452     }
453
454   fclose (dst);
455   fclose (src);
456
457   log_info (_("new configuration file '%s' created\n"), fname);
458   if (any_option)
459     log_info (_("WARNING: options in '%s'"
460                 " are not yet active during this run\n"),
461               fname);
462   xfree (fname);
463 }
464
465
466 void
467 try_make_homedir (const char *fname)
468 {
469   const char *defhome = standard_homedir ();
470
471   /* Create the directory only if the supplied directory name is the
472      same as the default one.  This way we avoid to create arbitrary
473      directories when a non-default home directory is used.  To cope
474      with HOME, we do compare only the suffix if we see that the
475      default homedir does start with a tilde.  */
476   if ( opt.dry_run || opt.no_homedir_creation )
477     return;
478
479   if (
480 #ifdef HAVE_W32_SYSTEM
481       ( !compare_filenames (fname, defhome) )
482 #else
483       ( *defhome == '~'
484         && (strlen(fname) >= strlen (defhome+1)
485             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
486       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
487 #endif
488       )
489     {
490       if (gnupg_mkdir (fname, "-rwx"))
491         log_fatal ( _("can't create directory '%s': %s\n"),
492                     fname, strerror(errno) );
493       else if (!opt.quiet )
494         log_info ( _("directory '%s' created\n"), fname );
495       copy_options_file( fname );
496     }
497 }
498
499
500 /* Get and if needed create a string with the directory used to store
501    openpgp revocations.  */
502 char *
503 get_openpgp_revocdir (const char *home)
504 {
505   char *fname;
506   struct stat statbuf;
507
508   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
509   if (stat (fname, &statbuf) && errno == ENOENT)
510     {
511       if (gnupg_mkdir (fname, "-rwx"))
512         log_error (_("can't create directory '%s': %s\n"),
513                    fname, strerror (errno) );
514       else if (!opt.quiet)
515         log_info (_("directory '%s' created\n"), fname);
516     }
517   return fname;
518 }