gpg: Import only packets which are allowed in a keyblock.
[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 "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" : EXTSEP_S "gpg"),
259                                 NULL);
260             }
261           name = buf;
262         }
263
264       rc = 0;
265       while ( !overwrite_filep (name) )
266         {
267           char *tmp = ask_outfile_name (NULL, 0);
268           if ( !tmp || !*tmp )
269             {
270               xfree (tmp);
271               rc = gpg_error (GPG_ERR_EEXIST);
272               break;
273             }
274           xfree (buf);
275           name = buf = tmp;
276         }
277
278       if ( !rc )
279         {
280           if (is_secured_filename (name) )
281             {
282               *a = NULL;
283               gpg_err_set_errno (EPERM);
284             }
285           else
286             *a = iobuf_create (name);
287           if (!*a)
288             {
289               rc = gpg_error_from_syserror ();
290               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
291             }
292           else if( opt.verbose )
293             log_info (_("writing to '%s'\n"), name );
294         }
295       xfree(buf);
296     }
297
298   if (*a)
299     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
300
301   return rc;
302 }
303
304
305 /****************
306  * Try to open a file without the extension ".sig" or ".asc"
307  * Return NULL if such a file is not available.
308  */
309 IOBUF
310 open_sigfile( const char *iname, progress_filter_context_t *pfx )
311 {
312     IOBUF a = NULL;
313     size_t len;
314
315     if( !iobuf_is_pipe_filename (iname) ) {
316         len = strlen(iname);
317         if( len > 4 && ( !strcmp(iname + len - 4, EXTSEP_S "sig")
318                         || ( len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign") )
319                         || !strcmp(iname + len - 4, EXTSEP_S "asc")) ) {
320             char *buf;
321             buf = xstrdup(iname);
322             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
323             a = iobuf_open( buf );
324             if (a && is_secured_file (iobuf_get_fd (a)))
325               {
326                 iobuf_close (a);
327                 a = NULL;
328                 gpg_err_set_errno (EPERM);
329               }
330             if( a && opt.verbose )
331                 log_info(_("assuming signed data in '%s'\n"), buf );
332             if (a && pfx)
333               handle_progress (pfx, a, buf);
334             xfree(buf);
335         }
336     }
337     return a;
338 }
339
340 /****************
341  * Copy the option file skeleton to the given directory.
342  */
343 static void
344 copy_options_file( const char *destdir )
345 {
346     const char *datadir = gnupg_datadir ();
347     char *fname;
348     FILE *src, *dst;
349     int linefeeds=0;
350     int c;
351     mode_t oldmask;
352     int esc = 0;
353     int any_option = 0;
354
355     if( opt.dry_run )
356         return;
357
358     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
359     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
360     src = fopen( fname, "r" );
361     if (src && is_secured_file (fileno (src)))
362       {
363         fclose (src);
364         src = NULL;
365         gpg_err_set_errno (EPERM);
366       }
367     if( !src ) {
368         log_info (_("can't open '%s': %s\n"), fname, strerror(errno) );
369         xfree(fname);
370         return;
371     }
372     strcpy(stpcpy(fname, destdir), DIRSEP_S "gpg" EXTSEP_S "conf" );
373     oldmask=umask(077);
374     if ( is_secured_filename (fname) )
375       {
376         dst = NULL;
377         gpg_err_set_errno (EPERM);
378       }
379     else
380       dst = fopen( fname, "w" );
381     umask(oldmask);
382     if( !dst ) {
383         log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
384         fclose( src );
385         xfree(fname);
386         return;
387     }
388
389     while( (c=getc(src)) != EOF ) {
390         if( linefeeds < 3 ) {
391             if( c == '\n' )
392                 linefeeds++;
393         }
394         else {
395             putc( c, dst );
396             if (c== '\n')
397                 esc = 1;
398             else if (esc == 1) {
399                 if (c == ' ' || c == '\t')
400                     ;
401                 else if (c == '#')
402                     esc = 2;
403                 else
404                     any_option = 1;
405             }
406         }
407     }
408     fclose( dst );
409     fclose( src );
410     log_info(_("new configuration file '%s' created\n"), fname );
411     if (any_option)
412         log_info (_("WARNING: options in '%s'"
413                     " are not yet active during this run\n"),
414                   fname);
415     xfree(fname);
416 }
417
418
419 void
420 try_make_homedir (const char *fname)
421 {
422   const char *defhome = standard_homedir ();
423
424   /* Create the directory only if the supplied directory name is the
425      same as the default one.  This way we avoid to create arbitrary
426      directories when a non-default home directory is used.  To cope
427      with HOME, we do compare only the suffix if we see that the
428      default homedir does start with a tilde.  */
429   if ( opt.dry_run || opt.no_homedir_creation )
430     return;
431
432   if (
433 #ifdef HAVE_W32_SYSTEM
434       ( !compare_filenames (fname, defhome) )
435 #else
436       ( *defhome == '~'
437         && (strlen(fname) >= strlen (defhome+1)
438             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
439       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
440 #endif
441       )
442     {
443       if (gnupg_mkdir (fname, "-rwx"))
444         log_fatal ( _("can't create directory '%s': %s\n"),
445                     fname, strerror(errno) );
446       else if (!opt.quiet )
447         log_info ( _("directory '%s' created\n"), fname );
448       copy_options_file( fname );
449     }
450 }