gpg: Improve function documentation and some comments.
[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 for NAME to the given directory.
379  * Returns true if the new option file has any option.
380  */
381 static int
382 copy_options_file (const char *destdir, const char *name)
383 {
384   const char *datadir = gnupg_datadir ();
385   char *fname;
386   FILE *src, *dst;
387   int linefeeds=0;
388   int c;
389   mode_t oldmask;
390   int esc = 0;
391   int any_option = 0;
392
393   if (opt.dry_run)
394     return 0;
395
396   fname = xstrconcat (datadir, DIRSEP_S, name, "-conf", SKELEXT, NULL);
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 0;
409     }
410   xfree (fname);
411   fname = xstrconcat (destdir, DIRSEP_S, name, EXTSEP_S, "conf", NULL);
412
413   oldmask = umask (077);
414   if (is_secured_filename (fname))
415     {
416       dst = NULL;
417       gpg_err_set_errno (EPERM);
418     }
419   else
420     dst = fopen( fname, "w" );
421   umask (oldmask);
422
423   if (!dst)
424     {
425       log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
426       fclose (src);
427       xfree (fname);
428       return 0;
429     }
430
431   while ((c = getc (src)) != EOF)
432     {
433       if (linefeeds < 3)
434         {
435           if (c == '\n')
436             linefeeds++;
437         }
438       else
439         {
440           putc (c, dst);
441           if (c== '\n')
442             esc = 1;
443           else if (esc == 1)
444             {
445               if (c == ' ' || c == '\t')
446                 ;
447               else if (c == '#')
448                 esc = 2;
449               else
450                 any_option = 1;
451             }
452         }
453     }
454
455   fclose (dst);
456   fclose (src);
457
458   log_info (_("new configuration file '%s' created\n"), fname);
459   xfree (fname);
460   return any_option;
461 }
462
463
464 void
465 try_make_homedir (const char *fname)
466 {
467   const char *defhome = standard_homedir ();
468
469   /* Create the directory only if the supplied directory name is the
470      same as the default one.  This way we avoid to create arbitrary
471      directories when a non-default home directory is used.  To cope
472      with HOME, we do compare only the suffix if we see that the
473      default homedir does start with a tilde.  */
474   if ( opt.dry_run || opt.no_homedir_creation )
475     return;
476
477   if (
478 #ifdef HAVE_W32_SYSTEM
479       ( !compare_filenames (fname, defhome) )
480 #else
481       ( *defhome == '~'
482         && (strlen(fname) >= strlen (defhome+1)
483             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
484       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
485 #endif
486       )
487     {
488       if (gnupg_mkdir (fname, "-rwx"))
489         log_fatal ( _("can't create directory '%s': %s\n"),
490                     fname, strerror(errno) );
491       else if (!opt.quiet )
492         log_info ( _("directory '%s' created\n"), fname );
493
494       /* Note that we also copy a dirmngr.conf file here.  This is
495          because gpg is likely the first invoked tool and thus creates
496          the directory.  */
497       copy_options_file (fname, DIRMNGR_NAME);
498       if (copy_options_file (fname, GPG_NAME))
499         log_info (_("WARNING: options in '%s'"
500                     " are not yet active during this run\n"),
501                   fname);
502     }
503 }
504
505
506 /* Get and if needed create a string with the directory used to store
507    openpgp revocations.  */
508 char *
509 get_openpgp_revocdir (const char *home)
510 {
511   char *fname;
512   struct stat statbuf;
513
514   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
515   if (stat (fname, &statbuf) && errno == ENOENT)
516     {
517       if (gnupg_mkdir (fname, "-rwx"))
518         log_error (_("can't create directory '%s': %s\n"),
519                    fname, strerror (errno) );
520       else if (!opt.quiet)
521         log_info (_("directory '%s' created\n"), fname);
522     }
523   return fname;
524 }