gpg: Re-indent two files.
[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 /*
314  * Try to open a file without the extension ".sig" or ".asc"
315  * Return NULL if such a file is not available.
316  */
317 IOBUF
318 open_sigfile( const char *iname, progress_filter_context_t *pfx )
319 {
320   IOBUF a = NULL;
321   size_t len;
322
323   if (!iobuf_is_pipe_filename (iname))
324     {
325       len = strlen(iname);
326       if( len > 4 && (!strcmp(iname + len - 4, EXTSEP_S "sig")
327                       || (len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign"))
328                       || !strcmp(iname + len - 4, EXTSEP_S "asc")))
329         {
330           char *buf;
331
332           buf = xstrdup(iname);
333           buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
334           a = iobuf_open( buf );
335           if (a && is_secured_file (iobuf_get_fd (a)))
336             {
337               iobuf_close (a);
338               a = NULL;
339               gpg_err_set_errno (EPERM);
340             }
341           if (a && opt.verbose)
342             log_info (_("assuming signed data in '%s'\n"), buf);
343           if (a && pfx)
344             handle_progress (pfx, a, buf);
345           xfree (buf);
346         }
347     }
348
349   return a;
350 }
351
352
353 /****************
354  * Copy the option file skeleton to the given directory.
355  */
356 static void
357 copy_options_file (const char *destdir)
358 {
359   const char *datadir = gnupg_datadir ();
360   char *fname;
361   FILE *src, *dst;
362   int linefeeds=0;
363   int c;
364   mode_t oldmask;
365   int esc = 0;
366   int any_option = 0;
367
368   if (opt.dry_run)
369     return;
370
371   fname = xmalloc (strlen(datadir) + strlen(destdir) + 15);
372   strcpy (stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT);
373   src = fopen (fname, "r");
374   if (src && is_secured_file (fileno (src)))
375     {
376       fclose (src);
377       src = NULL;
378       gpg_err_set_errno (EPERM);
379     }
380   if (!src)
381     {
382       log_info (_("can't open '%s': %s\n"), fname, strerror(errno));
383       xfree(fname);
384       return;
385     }
386   strcpy (stpcpy (fname, destdir), DIRSEP_S GPGEXT_GPG EXTSEP_S "conf");
387
388   oldmask = umask (077);
389   if (is_secured_filename (fname))
390     {
391       dst = NULL;
392       gpg_err_set_errno (EPERM);
393     }
394   else
395     dst = fopen( fname, "w" );
396   umask (oldmask);
397
398   if (!dst)
399     {
400       log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
401       fclose (src);
402       xfree (fname);
403       return;
404     }
405
406   while ((c = getc (src)) != EOF)
407     {
408       if (linefeeds < 3)
409         {
410           if (c == '\n')
411             linefeeds++;
412         }
413       else
414         {
415           putc (c, dst);
416           if (c== '\n')
417             esc = 1;
418           else if (esc == 1)
419             {
420               if (c == ' ' || c == '\t')
421                 ;
422               else if (c == '#')
423                 esc = 2;
424               else
425                 any_option = 1;
426             }
427         }
428     }
429
430   fclose (dst);
431   fclose (src);
432
433   log_info (_("new configuration file '%s' created\n"), fname);
434   if (any_option)
435     log_info (_("WARNING: options in '%s'"
436                 " are not yet active during this run\n"),
437               fname);
438   xfree (fname);
439 }
440
441
442 void
443 try_make_homedir (const char *fname)
444 {
445   const char *defhome = standard_homedir ();
446
447   /* Create the directory only if the supplied directory name is the
448      same as the default one.  This way we avoid to create arbitrary
449      directories when a non-default home directory is used.  To cope
450      with HOME, we do compare only the suffix if we see that the
451      default homedir does start with a tilde.  */
452   if ( opt.dry_run || opt.no_homedir_creation )
453     return;
454
455   if (
456 #ifdef HAVE_W32_SYSTEM
457       ( !compare_filenames (fname, defhome) )
458 #else
459       ( *defhome == '~'
460         && (strlen(fname) >= strlen (defhome+1)
461             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
462       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
463 #endif
464       )
465     {
466       if (gnupg_mkdir (fname, "-rwx"))
467         log_fatal ( _("can't create directory '%s': %s\n"),
468                     fname, strerror(errno) );
469       else if (!opt.quiet )
470         log_info ( _("directory '%s' created\n"), fname );
471       copy_options_file( fname );
472     }
473 }
474
475
476 /* Get and if needed create a string with the directory used to store
477    openpgp revocations.  */
478 char *
479 get_openpgp_revocdir (const char *home)
480 {
481   char *fname;
482   struct stat statbuf;
483
484   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
485   if (stat (fname, &statbuf) && errno == ENOENT)
486     {
487       if (gnupg_mkdir (fname, "-rwx"))
488         log_error (_("can't create directory '%s': %s\n"),
489                    fname, strerror (errno) );
490       else if (!opt.quiet)
491         log_info (_("directory '%s' created\n"), fname);
492     }
493   return fname;
494 }