g10: Always save standard revocation certificate in file.
[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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <fcntl.h>
29 #include <unistd.h>
30
31 #include "gpg.h"
32 #include "../common/util.h"
33 #include "../common/ttyio.h"
34 #include "options.h"
35 #include "main.h"
36 #include "../common/status.h"
37 #include "../common/i18n.h"
38
39 #ifdef HAVE_W32_SYSTEM
40 #define NAME_OF_DEV_NULL "nul"
41 #else
42 #define NAME_OF_DEV_NULL "/dev/null"
43 #endif
44
45
46 #if defined (HAVE_DRIVE_LETTERS) || defined (__riscos__)
47 #define CMP_FILENAME(a,b) ascii_strcasecmp( (a), (b) )
48 #else
49 #define CMP_FILENAME(a,b) strcmp( (a), (b) )
50 #endif
51
52
53 /* FIXME:  Implement opt.interactive. */
54
55 /*
56  * Check whether FNAME exists and ask if it's okay to overwrite an
57  * existing one.
58  * Returns: True: it's okay to overwrite or the file does not exist
59  *          False: Do not overwrite
60  */
61 int
62 overwrite_filep( const char *fname )
63 {
64   if ( iobuf_is_pipe_filename (fname) )
65     return 1; /* Writing to stdout is always okay.  */
66
67   if ( access( fname, F_OK ) )
68     return 1; /* Does not exist.  */
69
70   if ( !compare_filenames (fname, NAME_OF_DEV_NULL) )
71     return 1; /* Does not do any harm.  */
72
73   if (opt.answer_yes)
74     return 1;
75   if (opt.answer_no || opt.batch)
76     return 0;  /* Do not overwrite.  */
77
78   tty_printf (_("File '%s' exists. "), fname);
79   if (cpr_enabled ())
80     tty_printf ("\n");
81   if (cpr_get_answer_is_yes ("openfile.overwrite.okay",
82                              _("Overwrite? (y/N) ")) )
83     return 1;
84   return 0;
85 }
86
87
88 /*
89  * Strip known extensions from iname and return a newly allocated
90  * filename.  Return NULL if we can't do that.
91  */
92 char *
93 make_outfile_name (const char *iname)
94 {
95   size_t n;
96
97   if (iobuf_is_pipe_filename (iname))
98     return xstrdup ("-");
99
100   n = strlen (iname);
101   if (n > 4 && (!CMP_FILENAME(iname+n-4, EXTSEP_S GPGEXT_GPG)
102                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "pgp")
103                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "sig")
104                 || !CMP_FILENAME(iname+n-4, EXTSEP_S "asc")))
105     {
106       char *buf = xstrdup (iname);
107       buf[n-4] = 0;
108       return buf;
109     }
110   else if (n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign"))
111     {
112       char *buf = xstrdup (iname);
113       buf[n-5] = 0;
114       return buf;
115     }
116
117   log_info (_("%s: unknown suffix\n"), iname);
118   return NULL;
119 }
120
121
122 /* Ask for an output filename; use the given one as default.  Return
123    NULL if no file has been given or if it is not possible to ask the
124    user.  NAME is the template len which might contain enbedded Nuls.
125    NAMELEN is its actual length.
126  */
127 char *
128 ask_outfile_name( const char *name, size_t namelen )
129 {
130   size_t n;
131   const char *s;
132   char *prompt;
133   char *fname;
134   char *defname;
135
136   if ( opt.batch )
137     return NULL;
138
139   defname = name && namelen? make_printable_string (name, namelen, 0) : NULL;
140
141   s = _("Enter new filename");
142   n = strlen(s) + (defname?strlen (defname):0) + 10;
143   prompt = xmalloc (n);
144   if (defname)
145     snprintf (prompt, n, "%s [%s]: ", s, defname );
146   else
147     snprintf (prompt, n, "%s: ", s );
148   tty_enable_completion(NULL);
149   fname = cpr_get ("openfile.askoutname", prompt );
150   cpr_kill_prompt ();
151   tty_disable_completion ();
152   xfree (prompt);
153   if ( !*fname )
154     {
155       xfree (fname);
156       fname = defname;
157       defname = NULL;
158     }
159   xfree (defname);
160   if (fname)
161     trim_spaces (fname);
162   return fname;
163 }
164
165
166 /*
167  * Make an output filename for the inputfile INAME.
168  * Returns an IOBUF and an errorcode
169  * Mode 0 = use ".gpg"
170  *      1 = use ".asc"
171  *      2 = use ".sig"
172  *      3 = use ".rev"
173  *
174  * If INP_FD is not -1 the function simply creates an IOBUF for that
175  * file descriptor and ignore INAME and MODE.  Note that INP_FD won't
176  * be closed if the returned IOBUF is closed.  With RESTRICTEDPERM a
177  * file will be created with mode 700 if possible.  If NO_OUTFILE is
178  * true, don't use the outfile option even if it is set.
179  */
180 int
181 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
182               iobuf_t *a, int no_outfile)
183 {
184   int rc = 0;
185   const char outfile = no_outfile ? NULL : opt.outfile;
186
187   *a = NULL;
188   if (inp_fd != -1)
189     {
190       char xname[64];
191
192       *a = iobuf_fdopen_nc (inp_fd, "wb");
193       if (!*a)
194         {
195           rc = gpg_error_from_syserror ();
196           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
197           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
198         }
199       else if (opt.verbose)
200         {
201           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
202           log_info (_("writing to '%s'\n"), xname);
203         }
204     }
205   else if (iobuf_is_pipe_filename (iname) && !outfile)
206     {
207       *a = iobuf_create (NULL, 0);
208       if ( !*a )
209         {
210           rc = gpg_error_from_syserror ();
211           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
212         }
213       else if ( opt.verbose )
214         log_info (_("writing to stdout\n"));
215     }
216   else
217     {
218       char *buf = NULL;
219       const char *name;
220
221       if (opt.dry_run)
222         name = NAME_OF_DEV_NULL;
223       else if (outfile)
224         name = outfile;
225       else
226         {
227 #ifdef USE_ONLY_8DOT3
228           if (opt.mangle_dos_filenames)
229             {
230               /* It is quite common for DOS systems to have only one
231                  dot in a filename.  If we have something like this,
232                  we simple replace the suffix except in cases where
233                  the suffix is larger than 3 characters and not the
234                  same as the new one.  We don't map the filenames to
235                  8.3 because this is a duty of the file system.  */
236               char *dot;
237               const char *newsfx;
238
239               newsfx = (mode==1 ? ".asc" :
240                         mode==2 ? ".sig" :
241                         mode==3 ? ".rev" : ".gpg");
242
243               buf = xmalloc (strlen(iname)+4+1);
244               strcpy (buf, iname);
245               dot = strchr (buf, '.' );
246               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
247                    && CMP_FILENAME (newsfx, dot) )
248                 strcpy (dot, newsfx);
249               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
250                 strcpy (dot, newsfx+1);
251               else
252                 strcat (buf, newsfx);
253             }
254           if (!buf)
255 #endif /* USE_ONLY_8DOT3 */
256             {
257               buf = xstrconcat (iname,
258                                 (mode==1 ? EXTSEP_S "asc" :
259                                  mode==2 ? EXTSEP_S "sig" :
260                                  mode==3 ? EXTSEP_S "rev" :
261                                  /*     */ EXTSEP_S GPGEXT_GPG),
262                                 NULL);
263             }
264           name = buf;
265         }
266
267       rc = 0;
268       while ( !overwrite_filep (name) )
269         {
270           char *tmp = ask_outfile_name (NULL, 0);
271           if ( !tmp || !*tmp )
272             {
273               xfree (tmp);
274               rc = gpg_error (GPG_ERR_EEXIST);
275               break;
276             }
277           xfree (buf);
278           name = buf = tmp;
279         }
280
281       if ( !rc )
282         {
283           if (is_secured_filename (name) )
284             {
285               *a = NULL;
286               gpg_err_set_errno (EPERM);
287             }
288           else
289             *a = iobuf_create (name, restrictedperm);
290           if (!*a)
291             {
292               rc = gpg_error_from_syserror ();
293               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
294             }
295           else if( opt.verbose )
296             log_info (_("writing to '%s'\n"), name );
297         }
298       xfree(buf);
299     }
300
301   if (*a)
302     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
303
304   return rc;
305 }
306
307
308 /* Find a matching data file for the signature file SIGFILENAME and
309    return it as a malloced string.  If no matching data file is found,
310    return NULL.  */
311 char *
312 get_matching_datafile (const char *sigfilename)
313 {
314   char *fname = NULL;
315   size_t len;
316
317   if (iobuf_is_pipe_filename (sigfilename))
318     return NULL;
319
320   len = strlen (sigfilename);
321   if (len > 4
322       && (!strcmp (sigfilename + len - 4, EXTSEP_S "sig")
323           || (len > 5 && !strcmp(sigfilename + len - 5, EXTSEP_S "sign"))
324           || !strcmp(sigfilename + len - 4, EXTSEP_S "asc")))
325     {
326
327       fname = xstrdup (sigfilename);
328       fname[len-(fname[len-1]=='n'?5:4)] = 0 ;
329       if (access (fname, R_OK ))
330         {
331           /* Not found or other error.  */
332           xfree (fname);
333           fname = NULL;
334         }
335     }
336
337   return fname;
338 }
339
340
341 /*
342  * Try to open a file without the extension ".sig" or ".asc"
343  * Return NULL if such a file is not available.
344  */
345 iobuf_t
346 open_sigfile (const char *sigfilename, progress_filter_context_t *pfx)
347 {
348   iobuf_t a = NULL;
349   char *buf;
350
351   buf = get_matching_datafile (sigfilename);
352   if (buf)
353     {
354       a = iobuf_open (buf);
355       if (a && is_secured_file (iobuf_get_fd (a)))
356         {
357           iobuf_close (a);
358           a = NULL;
359           gpg_err_set_errno (EPERM);
360         }
361       if (a)
362         log_info (_("assuming signed data in '%s'\n"), buf);
363       if (a && pfx)
364         handle_progress (pfx, a, buf);
365       xfree (buf);
366     }
367
368   return a;
369 }
370
371
372 void
373 try_make_homedir (const char *fname)
374 {
375   const char *defhome = standard_homedir ();
376
377   /* Create the directory only if the supplied directory name is the
378      same as the default one.  This way we avoid to create arbitrary
379      directories when a non-default home directory is used.  To cope
380      with HOME, we do compare only the suffix if we see that the
381      default homedir does start with a tilde.  */
382   if ( opt.dry_run || opt.no_homedir_creation )
383     return;
384
385   if (
386 #ifdef HAVE_W32_SYSTEM
387       ( !compare_filenames (fname, defhome) )
388 #else
389       ( *defhome == '~'
390         && (strlen(fname) >= strlen (defhome+1)
391             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
392       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
393 #endif
394       )
395     {
396       if (gnupg_mkdir (fname, "-rwx"))
397         log_fatal ( _("can't create directory '%s': %s\n"),
398                     fname, strerror(errno) );
399       else if (!opt.quiet )
400         log_info ( _("directory '%s' created\n"), fname );
401     }
402 }
403
404
405 /* Get and if needed create a string with the directory used to store
406    openpgp revocations.  */
407 char *
408 get_openpgp_revocdir (const char *home)
409 {
410   char *fname;
411   struct stat statbuf;
412
413   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
414   if (stat (fname, &statbuf) && errno == ENOENT)
415     {
416       if (gnupg_mkdir (fname, "-rwx"))
417         log_error (_("can't create directory '%s': %s\n"),
418                    fname, strerror (errno) );
419       else if (!opt.quiet)
420         log_info (_("directory '%s' created\n"), fname);
421     }
422   return fname;
423 }