g10: Unattended key generation "Key-Grip" and "Subkey-Grip".
[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.
178  */
179 int
180 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
181               iobuf_t *a)
182 {
183   int rc = 0;
184
185   *a = NULL;
186   if (inp_fd != -1)
187     {
188       char xname[64];
189
190       *a = iobuf_fdopen_nc (inp_fd, "wb");
191       if (!*a)
192         {
193           rc = gpg_error_from_syserror ();
194           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
195           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
196         }
197       else if (opt.verbose)
198         {
199           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
200           log_info (_("writing to '%s'\n"), xname);
201         }
202     }
203   else if (iobuf_is_pipe_filename (iname) && !opt.outfile)
204     {
205       *a = iobuf_create (NULL, 0);
206       if ( !*a )
207         {
208           rc = gpg_error_from_syserror ();
209           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
210         }
211       else if ( opt.verbose )
212         log_info (_("writing to stdout\n"));
213     }
214   else
215     {
216       char *buf = NULL;
217       const char *name;
218
219       if (opt.dry_run)
220         name = NAME_OF_DEV_NULL;
221       else if (opt.outfile)
222         name = opt.outfile;
223       else
224         {
225 #ifdef USE_ONLY_8DOT3
226           if (opt.mangle_dos_filenames)
227             {
228               /* It is quite common for DOS systems to have only one
229                  dot in a filename.  If we have something like this,
230                  we simple replace the suffix except in cases where
231                  the suffix is larger than 3 characters and not the
232                  same as the new one.  We don't map the filenames to
233                  8.3 because this is a duty of the file system.  */
234               char *dot;
235               const char *newsfx;
236
237               newsfx = (mode==1 ? ".asc" :
238                         mode==2 ? ".sig" :
239                         mode==3 ? ".rev" : ".gpg");
240
241               buf = xmalloc (strlen(iname)+4+1);
242               strcpy (buf, iname);
243               dot = strchr (buf, '.' );
244               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
245                    && CMP_FILENAME (newsfx, dot) )
246                 strcpy (dot, newsfx);
247               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
248                 strcpy (dot, newsfx+1);
249               else
250                 strcat (buf, newsfx);
251             }
252           if (!buf)
253 #endif /* USE_ONLY_8DOT3 */
254             {
255               buf = xstrconcat (iname,
256                                 (mode==1 ? EXTSEP_S "asc" :
257                                  mode==2 ? EXTSEP_S "sig" :
258                                  mode==3 ? EXTSEP_S "rev" :
259                                  /*     */ EXTSEP_S GPGEXT_GPG),
260                                 NULL);
261             }
262           name = buf;
263         }
264
265       rc = 0;
266       while ( !overwrite_filep (name) )
267         {
268           char *tmp = ask_outfile_name (NULL, 0);
269           if ( !tmp || !*tmp )
270             {
271               xfree (tmp);
272               rc = gpg_error (GPG_ERR_EEXIST);
273               break;
274             }
275           xfree (buf);
276           name = buf = tmp;
277         }
278
279       if ( !rc )
280         {
281           if (is_secured_filename (name) )
282             {
283               *a = NULL;
284               gpg_err_set_errno (EPERM);
285             }
286           else
287             *a = iobuf_create (name, restrictedperm);
288           if (!*a)
289             {
290               rc = gpg_error_from_syserror ();
291               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
292             }
293           else if( opt.verbose )
294             log_info (_("writing to '%s'\n"), name );
295         }
296       xfree(buf);
297     }
298
299   if (*a)
300     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
301
302   return rc;
303 }
304
305
306 /* Find a matching data file for the signature file SIGFILENAME and
307    return it as a malloced string.  If no matching data file is found,
308    return NULL.  */
309 char *
310 get_matching_datafile (const char *sigfilename)
311 {
312   char *fname = NULL;
313   size_t len;
314
315   if (iobuf_is_pipe_filename (sigfilename))
316     return NULL;
317
318   len = strlen (sigfilename);
319   if (len > 4
320       && (!strcmp (sigfilename + len - 4, EXTSEP_S "sig")
321           || (len > 5 && !strcmp(sigfilename + len - 5, EXTSEP_S "sign"))
322           || !strcmp(sigfilename + len - 4, EXTSEP_S "asc")))
323     {
324
325       fname = xstrdup (sigfilename);
326       fname[len-(fname[len-1]=='n'?5:4)] = 0 ;
327       if (access (fname, R_OK ))
328         {
329           /* Not found or other error.  */
330           xfree (fname);
331           fname = NULL;
332         }
333     }
334
335   return fname;
336 }
337
338
339 /*
340  * Try to open a file without the extension ".sig" or ".asc"
341  * Return NULL if such a file is not available.
342  */
343 iobuf_t
344 open_sigfile (const char *sigfilename, progress_filter_context_t *pfx)
345 {
346   iobuf_t a = NULL;
347   char *buf;
348
349   buf = get_matching_datafile (sigfilename);
350   if (buf)
351     {
352       a = iobuf_open (buf);
353       if (a && is_secured_file (iobuf_get_fd (a)))
354         {
355           iobuf_close (a);
356           a = NULL;
357           gpg_err_set_errno (EPERM);
358         }
359       if (a)
360         log_info (_("assuming signed data in '%s'\n"), buf);
361       if (a && pfx)
362         handle_progress (pfx, a, buf);
363       xfree (buf);
364     }
365
366   return a;
367 }
368
369
370 void
371 try_make_homedir (const char *fname)
372 {
373   const char *defhome = standard_homedir ();
374
375   /* Create the directory only if the supplied directory name is the
376      same as the default one.  This way we avoid to create arbitrary
377      directories when a non-default home directory is used.  To cope
378      with HOME, we do compare only the suffix if we see that the
379      default homedir does start with a tilde.  */
380   if ( opt.dry_run || opt.no_homedir_creation )
381     return;
382
383   if (
384 #ifdef HAVE_W32_SYSTEM
385       ( !compare_filenames (fname, defhome) )
386 #else
387       ( *defhome == '~'
388         && (strlen(fname) >= strlen (defhome+1)
389             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
390       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
391 #endif
392       )
393     {
394       if (gnupg_mkdir (fname, "-rwx"))
395         log_fatal ( _("can't create directory '%s': %s\n"),
396                     fname, strerror(errno) );
397       else if (!opt.quiet )
398         log_info ( _("directory '%s' created\n"), fname );
399     }
400 }
401
402
403 /* Get and if needed create a string with the directory used to store
404    openpgp revocations.  */
405 char *
406 get_openpgp_revocdir (const char *home)
407 {
408   char *fname;
409   struct stat statbuf;
410
411   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
412   if (stat (fname, &statbuf) && errno == ENOENT)
413     {
414       if (gnupg_mkdir (fname, "-rwx"))
415         log_error (_("can't create directory '%s': %s\n"),
416                    fname, strerror (errno) );
417       else if (!opt.quiet)
418         log_info (_("directory '%s' created\n"), fname);
419     }
420   return fname;
421 }