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