Some doc fixes and a fix for "make distcheck".
[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         char *buf = xstrdup( iname );
113         buf[n-4] = 0;
114         return buf;
115     }
116     else if( n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign") ) {
117         char *buf = xstrdup( iname );
118         buf[n-5] = 0;
119         return buf;
120     }
121
122     log_info(_("%s: unknown suffix\n"), iname );
123     return NULL;
124 }
125
126
127 /* Ask for an output filename; use the given one as default.  Return
128    NULL if no file has been given or if it is not possible to ask the
129    user.  NAME is the template len which might conatin enbedded Nuls.
130    NAMELEN is its actual length.
131  */
132 char *
133 ask_outfile_name( const char *name, size_t namelen )
134 {
135   size_t n;
136   const char *s;
137   char *prompt;
138   char *fname;
139   char *defname;
140
141   if ( opt.batch )
142     return NULL;
143
144   defname = name && namelen? make_printable_string (name, namelen, 0) : NULL;
145
146   s = _("Enter new filename");
147   n = strlen(s) + (defname?strlen (defname):0) + 10;
148   prompt = xmalloc (n);
149   if (defname)
150     snprintf (prompt, n-1, "%s [%s]: ", s, defname );
151   else
152     snprintf (prompt, n-1, "%s: ", s );
153   tty_enable_completion(NULL);
154   fname = cpr_get ("openfile.askoutname", prompt );
155   cpr_kill_prompt ();
156   tty_disable_completion ();
157   xfree (prompt);
158   if ( !*fname )
159     {
160       xfree (fname);
161       fname = defname;
162       defname = NULL;
163     }
164   xfree (defname);
165   if (fname)
166     trim_spaces (fname);
167   return fname;
168 }
169
170
171 /****************
172  * Make an output filename for the inputfile INAME.
173  * Returns an IOBUF and an errorcode
174  * Mode 0 = use ".gpg"
175  *      1 = use ".asc"
176  *      2 = use ".sig"
177  *      3 = use ".rev"
178  *
179  * If INP_FD is not -1 the function simply creates an IOBUF for that
180  * file descriptor and ignore INAME and MODE.  Note that INP_FD won't
181  * be closed if the returned IOBUF is closed.  With RESTRICTEDPERM a
182  * file will be created with mode 700 if possible.
183  */
184 int
185 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
186               iobuf_t *a)
187 {
188   int rc = 0;
189
190   *a = NULL;
191   if (inp_fd != -1)
192     {
193       char xname[64];
194
195       *a = iobuf_fdopen_nc (inp_fd, "wb");
196       if (!*a)
197         {
198           rc = gpg_error_from_syserror ();
199           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
200           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
201         }
202       else if (opt.verbose)
203         {
204           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
205           log_info (_("writing to '%s'\n"), xname);
206         }
207     }
208   else if (iobuf_is_pipe_filename (iname) && !opt.outfile)
209     {
210       *a = iobuf_create (NULL, 0);
211       if ( !*a )
212         {
213           rc = gpg_error_from_syserror ();
214           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
215         }
216       else if ( opt.verbose )
217         log_info (_("writing to stdout\n"));
218     }
219   else
220     {
221       char *buf = NULL;
222       const char *name;
223
224       if (opt.dry_run)
225         name = NAME_OF_DEV_NULL;
226       else if (opt.outfile)
227         name = opt.outfile;
228       else
229         {
230 #ifdef USE_ONLY_8DOT3
231           if (opt.mangle_dos_filenames)
232             {
233               /* It is quite common for DOS systems to have only one
234                  dot in a filename.  If we have something like this,
235                  we simple replace the suffix except in cases where
236                  the suffix is larger than 3 characters and not the
237                  same as the new one.  We don't map the filenames to
238                  8.3 because this is a duty of the file system.  */
239               char *dot;
240               const char *newsfx;
241
242               newsfx = (mode==1 ? ".asc" :
243                         mode==2 ? ".sig" :
244                         mode==3 ? ".rev" : ".gpg");
245
246               buf = xmalloc (strlen(iname)+4+1);
247               strcpy (buf, iname);
248               dot = strchr (buf, '.' );
249               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
250                    && CMP_FILENAME (newsfx, dot) )
251                 strcpy (dot, newsfx);
252               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
253                 strcpy (dot, newsfx+1);
254               else
255                 strcat (buf, newsfx);
256             }
257           if (!buf)
258 #endif /* USE_ONLY_8DOT3 */
259             {
260               buf = xstrconcat (iname,
261                                 (mode==1 ? EXTSEP_S "asc" :
262                                  mode==2 ? EXTSEP_S "sig" :
263                                  mode==3 ? EXTSEP_S "rev" :
264                                  /*     */ EXTSEP_S GPGEXT_GPG),
265                                 NULL);
266             }
267           name = buf;
268         }
269
270       rc = 0;
271       while ( !overwrite_filep (name) )
272         {
273           char *tmp = ask_outfile_name (NULL, 0);
274           if ( !tmp || !*tmp )
275             {
276               xfree (tmp);
277               rc = gpg_error (GPG_ERR_EEXIST);
278               break;
279             }
280           xfree (buf);
281           name = buf = tmp;
282         }
283
284       if ( !rc )
285         {
286           if (is_secured_filename (name) )
287             {
288               *a = NULL;
289               gpg_err_set_errno (EPERM);
290             }
291           else
292             *a = iobuf_create (name, restrictedperm);
293           if (!*a)
294             {
295               rc = gpg_error_from_syserror ();
296               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
297             }
298           else if( opt.verbose )
299             log_info (_("writing to '%s'\n"), name );
300         }
301       xfree(buf);
302     }
303
304   if (*a)
305     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
306
307   return rc;
308 }
309
310
311 /****************
312  * Try to open a file without the extension ".sig" or ".asc"
313  * Return NULL if such a file is not available.
314  */
315 IOBUF
316 open_sigfile( const char *iname, progress_filter_context_t *pfx )
317 {
318     IOBUF a = NULL;
319     size_t len;
320
321     if( !iobuf_is_pipe_filename (iname) ) {
322         len = strlen(iname);
323         if( len > 4 && ( !strcmp(iname + len - 4, EXTSEP_S "sig")
324                         || ( len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign") )
325                         || !strcmp(iname + len - 4, EXTSEP_S "asc")) ) {
326             char *buf;
327             buf = xstrdup(iname);
328             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
329             a = iobuf_open( buf );
330             if (a && is_secured_file (iobuf_get_fd (a)))
331               {
332                 iobuf_close (a);
333                 a = NULL;
334                 gpg_err_set_errno (EPERM);
335               }
336             if( a && opt.verbose )
337                 log_info(_("assuming signed data in '%s'\n"), buf );
338             if (a && pfx)
339               handle_progress (pfx, a, buf);
340             xfree(buf);
341         }
342     }
343     return a;
344 }
345
346 /****************
347  * Copy the option file skeleton to the given directory.
348  */
349 static void
350 copy_options_file( const char *destdir )
351 {
352     const char *datadir = gnupg_datadir ();
353     char *fname;
354     FILE *src, *dst;
355     int linefeeds=0;
356     int c;
357     mode_t oldmask;
358     int esc = 0;
359     int any_option = 0;
360
361     if( opt.dry_run )
362         return;
363
364     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
365     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
366     src = fopen( fname, "r" );
367     if (src && is_secured_file (fileno (src)))
368       {
369         fclose (src);
370         src = NULL;
371         gpg_err_set_errno (EPERM);
372       }
373     if( !src ) {
374         log_info (_("can't open '%s': %s\n"), fname, strerror(errno) );
375         xfree(fname);
376         return;
377     }
378     strcpy(stpcpy(fname, destdir), DIRSEP_S GPGEXT_GPG EXTSEP_S "conf" );
379     oldmask=umask(077);
380     if ( is_secured_filename (fname) )
381       {
382         dst = NULL;
383         gpg_err_set_errno (EPERM);
384       }
385     else
386       dst = fopen( fname, "w" );
387     umask(oldmask);
388     if( !dst ) {
389         log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
390         fclose( src );
391         xfree(fname);
392         return;
393     }
394
395     while( (c=getc(src)) != EOF ) {
396         if( linefeeds < 3 ) {
397             if( c == '\n' )
398                 linefeeds++;
399         }
400         else {
401             putc( c, dst );
402             if (c== '\n')
403                 esc = 1;
404             else if (esc == 1) {
405                 if (c == ' ' || c == '\t')
406                     ;
407                 else if (c == '#')
408                     esc = 2;
409                 else
410                     any_option = 1;
411             }
412         }
413     }
414     fclose( dst );
415     fclose( src );
416     log_info(_("new configuration file '%s' created\n"), fname );
417     if (any_option)
418         log_info (_("WARNING: options in '%s'"
419                     " are not yet active during this run\n"),
420                   fname);
421     xfree(fname);
422 }
423
424
425 void
426 try_make_homedir (const char *fname)
427 {
428   const char *defhome = standard_homedir ();
429
430   /* Create the directory only if the supplied directory name is the
431      same as the default one.  This way we avoid to create arbitrary
432      directories when a non-default home directory is used.  To cope
433      with HOME, we do compare only the suffix if we see that the
434      default homedir does start with a tilde.  */
435   if ( opt.dry_run || opt.no_homedir_creation )
436     return;
437
438   if (
439 #ifdef HAVE_W32_SYSTEM
440       ( !compare_filenames (fname, defhome) )
441 #else
442       ( *defhome == '~'
443         && (strlen(fname) >= strlen (defhome+1)
444             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
445       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
446 #endif
447       )
448     {
449       if (gnupg_mkdir (fname, "-rwx"))
450         log_fatal ( _("can't create directory '%s': %s\n"),
451                     fname, strerror(errno) );
452       else if (!opt.quiet )
453         log_info ( _("directory '%s' created\n"), fname );
454       copy_options_file( fname );
455     }
456 }
457
458
459 /* Get and if needed create a string with the directory used to store
460    openpgp revocations.  */
461 char *
462 get_openpgp_revocdir (const char *home)
463 {
464   char *fname;
465   struct stat statbuf;
466
467   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
468   if (stat (fname, &statbuf) && errno == ENOENT)
469     {
470       if (gnupg_mkdir (fname, "-rwx"))
471         log_error (_("can't create directory '%s': %s\n"),
472                    fname, strerror (errno) );
473       else if (!opt.quiet)
474         log_info (_("directory '%s' created\n"), fname);
475     }
476   return fname;
477 }