Use gpg_err_set_errno to assign values to ERRNO.
[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 #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       
196       *a = iobuf_fdopen_nc (inp_fd, "wb");
197       if (!*a)
198         {
199           rc = gpg_error_from_syserror ();
200           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
201           log_error (_("can't open `%s': %s\n"), xname, gpg_strerror (rc));
202         }
203       else if (opt.verbose)
204         {
205           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
206           log_info (_("writing to `%s'\n"), xname);
207         }
208     }
209   else if (iobuf_is_pipe_filename (iname) && !opt.outfile) 
210     {
211       *a = iobuf_create(NULL);
212       if ( !*a )
213         {
214           rc = gpg_error_from_syserror ();
215           log_error (_("can't open `%s': %s\n"), "[stdout]", strerror(errno) );
216         }
217       else if ( opt.verbose )
218         log_info (_("writing to stdout\n"));
219     }
220   else
221     {
222       char *buf = NULL;
223       const char *name;
224     
225       if (opt.dry_run)
226         name = NAME_OF_DEV_NULL;
227       else if (opt.outfile)
228         name = opt.outfile;
229       else 
230         {
231 #ifdef USE_ONLY_8DOT3
232           if (opt.mangle_dos_filenames)
233             {
234               /* It is quite common for DOS systems to have only one
235                  dot in a filename.  If we have something like this,
236                  we simple replace the suffix except in cases where
237                  the suffix is larger than 3 characters and not the
238                  same as the new one.  We don't map the filenames to
239                  8.3 because this is a duty of the file system.  */
240               char *dot;
241               const char *newsfx;
242
243               newsfx = (mode==1 ? ".asc" :
244                         mode==2 ? ".sig" : ".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" : EXTSEP_S "gpg"),
263                                 NULL);
264             }
265           name = buf;
266         }
267       
268       rc = 0;
269       while ( !overwrite_filep (name) )
270         {
271           char *tmp = ask_outfile_name (NULL, 0);
272           if ( !tmp || !*tmp )
273             {
274               xfree (tmp);
275               rc = gpg_error (GPG_ERR_EEXIST);
276               break;
277             }
278           xfree (buf);
279           name = buf = tmp;
280         }
281     
282       if ( !rc )
283         {
284           if (is_secured_filename (name) )
285             {
286               *a = NULL;
287               gpg_err_set_errno (EPERM);
288             }
289           else
290             *a = iobuf_create (name);
291           if (!*a)
292             {
293               rc = gpg_error_from_syserror ();
294               log_error(_("can't create `%s': %s\n"), name, strerror(errno) );
295             }
296           else if( opt.verbose )
297             log_info (_("writing to `%s'\n"), name );
298         }
299       xfree(buf);
300     }
301   
302   if (*a)
303     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
304
305   return rc;
306 }
307
308
309 /****************
310  * Try to open a file without the extension ".sig" or ".asc"
311  * Return NULL if such a file is not available.
312  */
313 IOBUF
314 open_sigfile( const char *iname, progress_filter_context_t *pfx )
315 {
316     IOBUF a = NULL;
317     size_t len;
318
319     if( !iobuf_is_pipe_filename (iname) ) {
320         len = strlen(iname);
321         if( len > 4 && ( !strcmp(iname + len - 4, EXTSEP_S "sig")
322                         || ( len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign") )
323                         || !strcmp(iname + len - 4, EXTSEP_S "asc")) ) {
324             char *buf;
325             buf = xstrdup(iname);
326             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
327             a = iobuf_open( buf );
328             if (a && is_secured_file (iobuf_get_fd (a)))
329               {
330                 iobuf_close (a);
331                 a = NULL;
332                 gpg_err_set_errno (EPERM);
333               }
334             if( a && opt.verbose )
335                 log_info(_("assuming signed data in `%s'\n"), buf );
336             if (a && pfx)
337               handle_progress (pfx, a, buf);
338             xfree(buf);
339         }
340     }
341     return a;
342 }
343
344 /****************
345  * Copy the option file skeleton to the given directory.
346  */
347 static void
348 copy_options_file( const char *destdir )
349 {
350     const char *datadir = gnupg_datadir ();
351     char *fname;
352     FILE *src, *dst;
353     int linefeeds=0;
354     int c;
355     mode_t oldmask;
356     int esc = 0;
357     int any_option = 0;
358
359     if( opt.dry_run )
360         return;
361
362     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
363     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
364     src = fopen( fname, "r" );
365     if (src && is_secured_file (fileno (src)))
366       {
367         fclose (src);
368         src = NULL;
369         gpg_err_set_errno (EPERM);
370       }
371     if( !src ) {
372         log_info (_("can't open `%s': %s\n"), fname, strerror(errno) );
373         xfree(fname);
374         return;
375     }
376     strcpy(stpcpy(fname, destdir), DIRSEP_S "gpg" EXTSEP_S "conf" );
377     oldmask=umask(077);
378     if ( is_secured_filename (fname) )
379       {
380         dst = NULL;
381         gpg_err_set_errno (EPERM);
382       }
383     else
384       dst = fopen( fname, "w" );
385     umask(oldmask);
386     if( !dst ) {
387         log_info (_("can't create `%s': %s\n"), fname, strerror(errno) );
388         fclose( src );
389         xfree(fname);
390         return;
391     }
392
393     while( (c=getc(src)) != EOF ) {
394         if( linefeeds < 3 ) {
395             if( c == '\n' )
396                 linefeeds++;
397         }
398         else {
399             putc( c, dst );
400             if (c== '\n')
401                 esc = 1;
402             else if (esc == 1) {
403                 if (c == ' ' || c == '\t')
404                     ;
405                 else if (c == '#')
406                     esc = 2;
407                 else 
408                     any_option = 1;
409             }
410         }
411     }
412     fclose( dst );
413     fclose( src );
414     log_info(_("new configuration file `%s' created\n"), fname );
415     if (any_option)
416         log_info (_("WARNING: options in `%s'"
417                     " are not yet active during this run\n"),
418                   fname);
419     xfree(fname);
420 }
421
422
423 void
424 try_make_homedir (const char *fname)
425 {
426   const char *defhome = standard_homedir ();
427
428   /* Create the directory only if the supplied directory name is the
429      same as the default one.  This way we avoid to create arbitrary
430      directories when a non-default home directory is used.  To cope
431      with HOME, we do compare only the suffix if we see that the
432      default homedir does start with a tilde.  */
433   if ( opt.dry_run || opt.no_homedir_creation )
434     return;
435
436   if (
437 #ifdef HAVE_W32_SYSTEM
438       ( !compare_filenames (fname, defhome) )
439 #else
440       ( *defhome == '~'
441         && (strlen(fname) >= strlen (defhome+1)
442             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
443       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
444 #endif
445       )
446     {
447       if ( mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR) )
448         log_fatal ( _("can't create directory `%s': %s\n"),
449                     fname, strerror(errno) );
450       else if (!opt.quiet )
451         log_info ( _("directory `%s' created\n"), fname );
452       copy_options_file( fname );
453       
454     }
455 }