901387d319e23aa20e7d3772d816a63826e87b3e
[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  *
178  * If INP_FD is not -1 the function simply creates an IOBUF for that
179  * file descriptor and ignorea INAME and MODE.  Note that INP_FD won't
180  * be closed if the returned IOBUF is closed.  With RESTRICTEDPERM a
181  * file will be created with mode 700 if possible.
182  */
183 int
184 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
185               iobuf_t *a)
186 {
187   int rc = 0;
188
189   *a = NULL;
190   if (inp_fd != -1)
191     {
192       char xname[64];
193
194       *a = iobuf_fdopen_nc (inp_fd, "wb");
195       if (!*a)
196         {
197           rc = gpg_error_from_syserror ();
198           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
199           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
200         }
201       else if (opt.verbose)
202         {
203           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
204           log_info (_("writing to '%s'\n"), xname);
205         }
206     }
207   else if (iobuf_is_pipe_filename (iname) && !opt.outfile)
208     {
209       *a = iobuf_create (NULL, 0);
210       if ( !*a )
211         {
212           rc = gpg_error_from_syserror ();
213           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
214         }
215       else if ( opt.verbose )
216         log_info (_("writing to stdout\n"));
217     }
218   else
219     {
220       char *buf = NULL;
221       const char *name;
222
223       if (opt.dry_run)
224         name = NAME_OF_DEV_NULL;
225       else if (opt.outfile)
226         name = opt.outfile;
227       else
228         {
229 #ifdef USE_ONLY_8DOT3
230           if (opt.mangle_dos_filenames)
231             {
232               /* It is quite common for DOS systems to have only one
233                  dot in a filename.  If we have something like this,
234                  we simple replace the suffix except in cases where
235                  the suffix is larger than 3 characters and not the
236                  same as the new one.  We don't map the filenames to
237                  8.3 because this is a duty of the file system.  */
238               char *dot;
239               const char *newsfx;
240
241               newsfx = (mode==1 ? ".asc" :
242                         mode==2 ? ".sig" : ".gpg");
243
244               buf = xmalloc (strlen(iname)+4+1);
245               strcpy (buf, iname);
246               dot = strchr (buf, '.' );
247               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
248                    && CMP_FILENAME (newsfx, dot) )
249                 strcpy (dot, newsfx);
250               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
251                 strcpy (dot, newsfx+1);
252               else
253                 strcat (buf, newsfx);
254             }
255           if (!buf)
256 #endif /* USE_ONLY_8DOT3 */
257             {
258               buf = xstrconcat (iname,
259                                 (mode==1 ? EXTSEP_S "asc" :
260                                  mode==2 ? EXTSEP_S "sig" :
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 /****************
309  * Try to open a file without the extension ".sig" or ".asc"
310  * Return NULL if such a file is not available.
311  */
312 IOBUF
313 open_sigfile( const char *iname, progress_filter_context_t *pfx )
314 {
315     IOBUF a = NULL;
316     size_t len;
317
318     if( !iobuf_is_pipe_filename (iname) ) {
319         len = strlen(iname);
320         if( len > 4 && ( !strcmp(iname + len - 4, EXTSEP_S "sig")
321                         || ( len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign") )
322                         || !strcmp(iname + len - 4, EXTSEP_S "asc")) ) {
323             char *buf;
324             buf = xstrdup(iname);
325             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
326             a = iobuf_open( buf );
327             if (a && is_secured_file (iobuf_get_fd (a)))
328               {
329                 iobuf_close (a);
330                 a = NULL;
331                 gpg_err_set_errno (EPERM);
332               }
333             if( a && opt.verbose )
334                 log_info(_("assuming signed data in '%s'\n"), buf );
335             if (a && pfx)
336               handle_progress (pfx, a, buf);
337             xfree(buf);
338         }
339     }
340     return a;
341 }
342
343 /****************
344  * Copy the option file skeleton to the given directory.
345  */
346 static void
347 copy_options_file( const char *destdir )
348 {
349     const char *datadir = gnupg_datadir ();
350     char *fname;
351     FILE *src, *dst;
352     int linefeeds=0;
353     int c;
354     mode_t oldmask;
355     int esc = 0;
356     int any_option = 0;
357
358     if( opt.dry_run )
359         return;
360
361     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
362     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
363     src = fopen( fname, "r" );
364     if (src && is_secured_file (fileno (src)))
365       {
366         fclose (src);
367         src = NULL;
368         gpg_err_set_errno (EPERM);
369       }
370     if( !src ) {
371         log_info (_("can't open '%s': %s\n"), fname, strerror(errno) );
372         xfree(fname);
373         return;
374     }
375     strcpy(stpcpy(fname, destdir), DIRSEP_S GPGEXT_GPG EXTSEP_S "conf" );
376     oldmask=umask(077);
377     if ( is_secured_filename (fname) )
378       {
379         dst = NULL;
380         gpg_err_set_errno (EPERM);
381       }
382     else
383       dst = fopen( fname, "w" );
384     umask(oldmask);
385     if( !dst ) {
386         log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
387         fclose( src );
388         xfree(fname);
389         return;
390     }
391
392     while( (c=getc(src)) != EOF ) {
393         if( linefeeds < 3 ) {
394             if( c == '\n' )
395                 linefeeds++;
396         }
397         else {
398             putc( c, dst );
399             if (c== '\n')
400                 esc = 1;
401             else if (esc == 1) {
402                 if (c == ' ' || c == '\t')
403                     ;
404                 else if (c == '#')
405                     esc = 2;
406                 else
407                     any_option = 1;
408             }
409         }
410     }
411     fclose( dst );
412     fclose( src );
413     log_info(_("new configuration file '%s' created\n"), fname );
414     if (any_option)
415         log_info (_("WARNING: options in '%s'"
416                     " are not yet active during this run\n"),
417                   fname);
418     xfree(fname);
419 }
420
421
422 void
423 try_make_homedir (const char *fname)
424 {
425   const char *defhome = standard_homedir ();
426
427   /* Create the directory only if the supplied directory name is the
428      same as the default one.  This way we avoid to create arbitrary
429      directories when a non-default home directory is used.  To cope
430      with HOME, we do compare only the suffix if we see that the
431      default homedir does start with a tilde.  */
432   if ( opt.dry_run || opt.no_homedir_creation )
433     return;
434
435   if (
436 #ifdef HAVE_W32_SYSTEM
437       ( !compare_filenames (fname, defhome) )
438 #else
439       ( *defhome == '~'
440         && (strlen(fname) >= strlen (defhome+1)
441             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
442       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
443 #endif
444       )
445     {
446       if (gnupg_mkdir (fname, "-rwx"))
447         log_fatal ( _("can't create directory '%s': %s\n"),
448                     fname, strerror(errno) );
449       else if (!opt.quiet )
450         log_info ( _("directory '%s' created\n"), fname );
451       copy_options_file( fname );
452     }
453 }