4b7fe36008fae2f96b818644c614f4f7477b7404
[gnupg.git] / g10 / openfile.c
1 /* openfile.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2009 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 #ifdef MKDIR_TAKES_ONE_ARG
60 #undef mkdir
61 #define mkdir(a,b) mkdir(a)
62 #endif
63
64 /* FIXME:  Implement opt.interactive. */
65
66 /****************
67  * Check whether FNAME exists and ask if it's okay to overwrite an
68  * existing one.
69  * Returns: True: it's okay to overwrite or the file does not exist
70  *          False: Do not overwrite
71  */
72 int
73 overwrite_filep( const char *fname )
74 {
75   if ( iobuf_is_pipe_filename (fname) )
76     return 1; /* Writing to stdout is always okay.  */
77   
78   if ( access( fname, F_OK ) )
79     return 1; /* Does not exist.  */
80   
81   if ( !compare_filenames (fname, NAME_OF_DEV_NULL) )
82     return 1; /* Does not do any harm.  */
83
84   if (opt.answer_yes)
85     return 1;
86   if (opt.answer_no || opt.batch)
87     return 0;  /* Do not overwrite.  */
88
89   tty_printf (_("File `%s' exists. "), fname);
90   if (cpr_enabled ())
91     tty_printf ("\n");
92   if (cpr_get_answer_is_yes ("openfile.overwrite.okay",
93                              _("Overwrite? (y/N) ")) )
94     return 1;
95   return 0;
96 }
97
98
99 /****************
100  * Strip known extensions from iname and return a newly allocated
101  * filename.  Return NULL if we can't do that.
102  */
103 char *
104 make_outfile_name( const char *iname )
105 {
106     size_t n;
107
108     if ( iobuf_is_pipe_filename (iname) )
109         return xstrdup("-");
110
111     n = strlen(iname);
112     if( n > 4 && (    !CMP_FILENAME(iname+n-4, EXTSEP_S "gpg")
113                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "pgp")
114                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "sig")
115                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "asc") ) ) {
116         char *buf = xstrdup( iname );
117         buf[n-4] = 0;
118         return buf;
119     }
120     else if( n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign") ) {
121         char *buf = xstrdup( iname );
122         buf[n-5] = 0;
123         return buf;
124     }
125
126     log_info(_("%s: unknown suffix\n"), iname );
127     return NULL;
128 }
129
130
131 /* Ask for an output filename; use the given one as default.  Return
132    NULL if no file has been given or if it is not possible to ask the
133    user.  NAME is the template len which might conatin enbedded Nuls.
134    NAMELEN is its actual length.
135  */
136 char *
137 ask_outfile_name( const char *name, size_t namelen )
138 {
139   size_t n;
140   const char *s;
141   char *prompt;
142   char *fname;
143   char *defname;
144
145   if ( opt.batch )
146     return NULL;
147   
148   defname = name && namelen? make_printable_string (name, namelen, 0) : NULL;
149
150   s = _("Enter new filename");
151   n = strlen(s) + (defname?strlen (defname):0) + 10;
152   prompt = xmalloc (n);
153   if (defname)
154     snprintf (prompt, n-1, "%s [%s]: ", s, defname );
155   else
156     snprintf (prompt, n-1, "%s: ", s );
157   tty_enable_completion(NULL);
158   fname = cpr_get ("openfile.askoutname", prompt );
159   cpr_kill_prompt ();
160   tty_disable_completion ();
161   xfree (prompt);
162   if ( !*fname ) 
163     {
164       xfree (fname); 
165       fname = defname;
166       defname = NULL;
167     }
168   xfree (defname);
169   if (fname)
170     trim_spaces (fname);
171   return fname;
172 }
173
174
175 /****************
176  * Make an output filename for the inputfile INAME.
177  * Returns an IOBUF and an errorcode
178  * Mode 0 = use ".gpg"
179  *      1 = use ".asc"
180  *      2 = use ".sig"
181  *
182  * If INP_FD is not -1 the function simply creates an IOBUF for that
183  * file descriptor and ignorea INAME and MODE.  Note that INP_FD won't
184  * be closed if the returned IOBUF is closed.
185  */
186 int
187 open_outfile (int inp_fd, const char *iname, int mode, iobuf_t *a)
188 {
189   int rc = 0;
190
191   *a = NULL;
192   if (inp_fd != -1)
193     {
194       char xname[64];
195       int fd2;
196       
197       fd2 = dup (inp_fd);
198       if (fd2 == -1)
199         *a = NULL;
200       else
201         *a = iobuf_fdopen (fd2, "wb");
202       if (!*a)
203         {
204           rc = gpg_error_from_syserror ();
205           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
206           log_error (_("can't open `%s': %s\n"), xname, gpg_strerror (rc));
207         }
208       else if (opt.verbose)
209         {
210           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
211           log_info (_("writing to `%s'\n"), xname);
212         }
213     }
214   else if (iobuf_is_pipe_filename (iname) && !opt.outfile) 
215     {
216       *a = iobuf_create(NULL);
217       if ( !*a )
218         {
219           rc = gpg_error_from_syserror ();
220           log_error (_("can't open `%s': %s\n"), "[stdout]", strerror(errno) );
221         }
222       else if ( opt.verbose )
223         log_info (_("writing to stdout\n"));
224     }
225   else
226     {
227       char *buf = NULL;
228       const char *name;
229     
230       if (opt.dry_run)
231         name = NAME_OF_DEV_NULL;
232       else if (opt.outfile)
233         name = opt.outfile;
234       else 
235         {
236 #ifdef USE_ONLY_8DOT3
237           if (opt.mangle_dos_filenames)
238             {
239               /* It is quite common for DOS systems to have only one
240                  dot in a filename.  If we have something like this,
241                  we simple replace the suffix except in cases where
242                  the suffix is larger than 3 characters and not the
243                  same as the new one.  We don't map the filenames to
244                  8.3 because this is a duty of the file system.  */
245               char *dot;
246               const char *newsfx;
247
248               newsfx = (mode==1 ? ".asc" :
249                         mode==2 ? ".sig" : ".gpg");
250           
251               buf = xmalloc (strlen(iname)+4+1);
252               strcpy (buf, iname);
253               dot = strchr (buf, '.' );
254               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
255                    && CMP_FILENAME (newsfx, dot) )
256                 strcpy (dot, newsfx);
257               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
258                 strcpy (dot, newsfx+1);
259               else
260                 strcat (buf, newsfx);
261             }
262           if (!buf)
263 #endif /* USE_ONLY_8DOT3 */
264             {
265               buf = xstrconcat (iname, 
266                                 (mode==1 ? EXTSEP_S "asc" :
267                                  mode==2 ? EXTSEP_S "sig" : EXTSEP_S "gpg"),
268                                 NULL);
269             }
270           name = buf;
271         }
272       
273       rc = 0;
274       while ( !overwrite_filep (name) )
275         {
276           char *tmp = ask_outfile_name (NULL, 0);
277           if ( !tmp || !*tmp )
278             {
279               xfree (tmp);
280               rc = gpg_error (GPG_ERR_EEXIST);
281               break;
282             }
283           xfree (buf);
284           name = buf = tmp;
285         }
286     
287       if ( !rc )
288         {
289           if (is_secured_filename (name) )
290             {
291               *a = NULL;
292               errno = EPERM;
293             }
294           else
295             *a = iobuf_create (name);
296           if (!*a)
297             {
298               rc = gpg_error_from_syserror ();
299               log_error(_("can't create `%s': %s\n"), name, strerror(errno) );
300             }
301           else if( opt.verbose )
302             log_info (_("writing to `%s'\n"), name );
303         }
304       xfree(buf);
305     }
306   
307   if (*a)
308     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
309
310   return rc;
311 }
312
313
314 /****************
315  * Try to open a file without the extension ".sig" or ".asc"
316  * Return NULL if such a file is not available.
317  */
318 IOBUF
319 open_sigfile( const char *iname, progress_filter_context_t *pfx )
320 {
321     IOBUF a = NULL;
322     size_t len;
323
324     if( !iobuf_is_pipe_filename (iname) ) {
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             char *buf;
330             buf = xstrdup(iname);
331             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
332             a = iobuf_open( buf );
333             if (a && is_secured_file (iobuf_get_fd (a)))
334               {
335                 iobuf_close (a);
336                 a = NULL;
337                 errno = EPERM;
338               }
339             if( a && opt.verbose )
340                 log_info(_("assuming signed data in `%s'\n"), buf );
341             if (a && pfx)
342               handle_progress (pfx, a, buf);
343             xfree(buf);
344         }
345     }
346     return a;
347 }
348
349 /****************
350  * Copy the option file skeleton to the given directory.
351  */
352 static void
353 copy_options_file( const char *destdir )
354 {
355     const char *datadir = gnupg_datadir ();
356     char *fname;
357     FILE *src, *dst;
358     int linefeeds=0;
359     int c;
360     mode_t oldmask;
361     int esc = 0;
362     int any_option = 0;
363
364     if( opt.dry_run )
365         return;
366
367     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
368     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
369     src = fopen( fname, "r" );
370     if (src && is_secured_file (fileno (src)))
371       {
372         fclose (src);
373         src = NULL;
374         errno = EPERM;
375       }
376     if( !src ) {
377         log_info (_("can't open `%s': %s\n"), fname, strerror(errno) );
378         xfree(fname);
379         return;
380     }
381     strcpy(stpcpy(fname, destdir), DIRSEP_S "gpg" EXTSEP_S "conf" );
382     oldmask=umask(077);
383     if ( is_secured_filename (fname) )
384       {
385         dst = NULL;
386         errno = EPERM;
387       }
388     else
389       dst = fopen( fname, "w" );
390     umask(oldmask);
391     if( !dst ) {
392         log_info (_("can't create `%s': %s\n"), fname, strerror(errno) );
393         fclose( src );
394         xfree(fname);
395         return;
396     }
397
398     while( (c=getc(src)) != EOF ) {
399         if( linefeeds < 3 ) {
400             if( c == '\n' )
401                 linefeeds++;
402         }
403         else {
404             putc( c, dst );
405             if (c== '\n')
406                 esc = 1;
407             else if (esc == 1) {
408                 if (c == ' ' || c == '\t')
409                     ;
410                 else if (c == '#')
411                     esc = 2;
412                 else 
413                     any_option = 1;
414             }
415         }
416     }
417     fclose( dst );
418     fclose( src );
419     log_info(_("new configuration file `%s' created\n"), fname );
420     if (any_option)
421         log_info (_("WARNING: options in `%s'"
422                     " are not yet active during this run\n"),
423                   fname);
424     xfree(fname);
425 }
426
427
428 void
429 try_make_homedir (const char *fname)
430 {
431   const char *defhome = standard_homedir ();
432
433   /* Create the directory only if the supplied directory name is the
434      same as the default one.  This way we avoid to create arbitrary
435      directories when a non-default home directory is used.  To cope
436      with HOME, we do compare only the suffix if we see that the
437      default homedir does start with a tilde.  */
438   if ( opt.dry_run || opt.no_homedir_creation )
439     return;
440
441   if (
442 #ifdef HAVE_W32_SYSTEM
443       ( !compare_filenames (fname, defhome) )
444 #else
445       ( *defhome == '~'
446         && (strlen(fname) >= strlen (defhome+1)
447             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
448       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
449 #endif
450       )
451     {
452       if ( mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR) )
453         log_fatal ( _("can't create directory `%s': %s\n"),
454                     fname, strerror(errno) );
455       else if (!opt.quiet )
456         log_info ( _("directory `%s' created\n"), fname );
457       copy_options_file( fname );
458       
459     }
460 }