g10/openfile.c

   1 /* openfile.c
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3  *               2005 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 2 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, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <errno.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33
  34 #include "gpg.h"
  35 #include "util.h"
  36 #include "ttyio.h"
  37 #include "options.h"
  38 #include "main.h"
  39 #include "status.h"
  40 #include "i18n.h"
  41
  42 #ifdef USE_ONLY_8DOT3
  43 #define SKELEXT ".skl"
  44 #else
  45 #define SKELEXT EXTSEP_S "skel"
  46 #endif
  47
  48 #if defined (HAVE_DRIVE_LETTERS) || defined (__riscos__)
  49 #define CMP_FILENAME(a,b) ascii_strcasecmp( (a), (b) )
  50 #else
  51 #define CMP_FILENAME(a,b) strcmp( (a), (b) )
  52 #endif
  53
  54 #ifdef MKDIR_TAKES_ONE_ARG
  55 #undef mkdir
  56 #define mkdir(a,b) mkdir(a)
  57 #endif
  58
  59 /* FIXME:  Implement opt.interactive. */
  60
  61 /****************
  62  * Check whether FNAME exists and ask if it's okay to overwrite an
  63  * existing one.
  64  * Returns: True: it's okay to overwrite or the file does not exist
  65  *          False: Do not overwrite
  66  */
  67 int
  68 overwrite_filep( const char *fname )
  69 {
  70     if( iobuf_is_pipe_filename (fname) )
  71         return 1; /* Writing to stdout is always okay */
  72
  73     if( access( fname, F_OK ) )
  74         return 1; /* does not exist */
  75
  76 #ifndef HAVE_DOSISH_SYSTEM
  77     if ( !strcmp ( fname, "/dev/null" ) )
  78         return 1; /* does not do any harm */
  79 #endif
  80
  81     /* fixme: add some backup stuff in case of overwrite */
  82     if( opt.answer_yes )
  83         return 1;
  84     if( opt.answer_no || opt.batch )
  85         return 0;  /* do not overwrite */
  86
  87     tty_printf(_("File `%s' exists. "), fname);
  88     if( cpr_enabled () )
  89         tty_printf ("\n");
  90     if( cpr_get_answer_is_yes("openfile.overwrite.okay",
  91                                _("Overwrite? (y/N) ")) )
  92         return 1;
  93     return 0;
  94 }
  95
  96
  97 /****************
  98  * Strip know extensions from iname and return a newly allocated
  99  * filename.  Return NULL if we can't do that.
 100  */
 101 char *
 102 make_outfile_name( const char *iname )
 103 {
 104     size_t n;
 105
 106     if ( iobuf_is_pipe_filename (iname) )
 107         return xstrdup("-");
 108
 109     n = strlen(iname);
 110     if( n > 4 && (    !CMP_FILENAME(iname+n-4, EXTSEP_S "gpg")
 111                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "pgp")
 112                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "sig")
 113                    || !CMP_FILENAME(iname+n-4, EXTSEP_S "asc") ) ) {
 114         char *buf = xstrdup( iname );
 115         buf[n-4] = 0;
 116         return buf;
 117     }
 118     else if( n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign") ) {
 119         char *buf = xstrdup( iname );
 120         buf[n-5] = 0;
 121         return buf;
 122     }
 123
 124     log_info(_("%s: unknown suffix\n"), iname );
 125     return NULL;
 126 }
 127
 128
 129 /****************
 130  * Ask for a outputfilename and use the given one as default.
 131  * Return NULL if no file has been given or it is not possible to
 132  * ask the user.
 133  */
 134 char *
 135 ask_outfile_name( const char *name, size_t namelen )
 136 {
 137     size_t n;
 138     const char *s;
 139     char *prompt;
 140     char *fname;
 141     char *defname;
 142
 143     if( opt.batch )
 144         return NULL;
 145
 146     s = _("Enter new filename");
 147
 148     n = strlen(s) + namelen + 10;
 149     defname = name && namelen? make_printable_string( name, namelen, 0): NULL;
 150     prompt = xmalloc(n);
 151     if( defname )
 152         sprintf(prompt, "%s [%s]: ", s, defname );
 153     else
 154         sprintf(prompt, "%s: ", s );
 155     tty_enable_completion(NULL);
 156     fname = cpr_get("openfile.askoutname", prompt );
 157     cpr_kill_prompt();
 158     tty_disable_completion();
 159     xfree(prompt);
 160     if( !*fname ) {
 161         xfree( fname ); fname = NULL;
 162         fname = defname; 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 int
 179 open_outfile( const char *iname, int mode, IOBUF *a )
 180 {
 181   int rc = 0;
 182
 183   *a = NULL;
 184   if( iobuf_is_pipe_filename (iname) && !opt.outfile ) {
 185     *a = iobuf_create(NULL);
 186     if( !*a ) {
 187       rc = gpg_error_from_errno (errno);
 188       log_error(_("can't open `%s': %s\n"), "[stdout]", strerror(errno) );
 189     }
 190     else if( opt.verbose )
 191       log_info(_("writing to stdout\n"));
 192   }
 193   else {
 194     char *buf = NULL;
 195     const char *name;
 196
 197     if( opt.dry_run )
 198       name = "/dev/null";
 199     else if( opt.outfile )
 200       name = opt.outfile;
 201     else {
 202 #ifdef USE_ONLY_8DOT3
 203       if (opt.mangle_dos_filenames)
 204         {
 205           /* It is quite common DOS system to have only one dot in a
 206            * a filename So if we have something like this, we simple
 207            * replace the suffix execpt in cases where the suffix is
 208            * larger than 3 characters and not the same as.
 209            * We should really map the filenames to 8.3 but this tends to
 210            * be more complicated and is probaly a duty of the filesystem
 211            */
 212           char *dot;
 213           const char *newsfx = mode==1 ? ".asc" :
 214                                mode==2 ? ".sig" : ".gpg";
 215
 216           buf = xmalloc(strlen(iname)+4+1);
 217           strcpy(buf,iname);
 218           dot = strchr(buf, '.' );
 219           if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
 220                                   && CMP_FILENAME(newsfx, dot) )
 221             {
 222               strcpy(dot, newsfx );
 223             }
 224           else if ( dot && !dot[1] ) /* don't duplicate a dot */
 225             strcpy( dot, newsfx+1 );
 226           else
 227             strcat ( buf, newsfx );
 228         }
 229       if (!buf)
 230 #endif /* USE_ONLY_8DOT3 */
 231         {
 232           buf = xmalloc(strlen(iname)+4+1);
 233           strcpy(stpcpy(buf,iname), mode==1 ? EXTSEP_S "asc" :
 234                                    mode==2 ? EXTSEP_S "sig" : EXTSEP_S "gpg");
 235         }
 236       name = buf;
 237     }
 238
 239     rc = 0;
 240     while( !overwrite_filep (name) )
 241       {
 242         char *tmp = ask_outfile_name (NULL, 0);
 243         if ( !tmp || !*tmp )
 244           {
 245             xfree (tmp);
 246             rc = gpg_error (GPG_ERR_EEXIST);
 247             break;
 248           }
 249         xfree (buf);
 250         name = buf = tmp;
 251       }
 252
 253     if( !rc )
 254       {
 255         if (is_secured_filename (name) )
 256           {
 257             *a = NULL;
 258             errno = EPERM;
 259           }
 260         else
 261           *a = iobuf_create( name );
 262         if( !*a )
 263           {
 264             rc = gpg_error_from_errno (errno);
 265             log_error(_("can't create `%s': %s\n"), name, strerror(errno) );
 266           }
 267         else if( opt.verbose )
 268           log_info(_("writing to `%s'\n"), name );
 269       }
 270     xfree(buf);
 271   }
 272
 273   if (*a)
 274     iobuf_ioctl (*a,3,1,NULL); /* disable fd caching */
 275
 276   return rc;
 277 }
 278
 279
 280 /****************
 281  * Try to open a file without the extension ".sig" or ".asc"
 282  * Return NULL if such a file is not available.
 283  */
 284 IOBUF
 285 open_sigfile( const char *iname, progress_filter_context_t *pfx )
 286 {
 287     IOBUF a = NULL;
 288     size_t len;
 289
 290     if( !iobuf_is_pipe_filename (iname) ) {
 291         len = strlen(iname);
 292         if( len > 4 && ( !strcmp(iname + len - 4, EXTSEP_S "sig")
 293                         || ( len > 5 && !strcmp(iname + len - 5, EXTSEP_S "sign") )
 294                         || !strcmp(iname + len - 4, EXTSEP_S "asc")) ) {
 295             char *buf;
 296             buf = xstrdup(iname);
 297             buf[len-(buf[len-1]=='n'?5:4)] = 0 ;
 298             a = iobuf_open( buf );
 299             if (a && is_secured_file (iobuf_get_fd (a)))
 300               {
 301                 iobuf_close (a);
 302                 a = NULL;
 303                 errno = EPERM;
 304               }
 305             if( a && opt.verbose )
 306                 log_info(_("assuming signed data in `%s'\n"), buf );
 307             if (a && pfx)
 308               handle_progress (pfx, a, buf);
 309             xfree(buf);
 310         }
 311     }
 312     return a;
 313 }
 314
 315 /****************
 316  * Copy the option file skeleton to the given directory.
 317  */
 318 static void
 319 copy_options_file( const char *destdir )
 320 {
 321     const char *datadir = GNUPG_DATADIR;
 322     char *fname;
 323     FILE *src, *dst;
 324     int linefeeds=0;
 325     int c;
 326     mode_t oldmask;
 327     int esc = 0;
 328     int any_option = 0;
 329
 330     if( opt.dry_run )
 331         return;
 332
 333     fname = xmalloc( strlen(datadir) + strlen(destdir) + 15 );
 334     strcpy(stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT );
 335     src = fopen( fname, "r" );
 336     if (src && is_secured_file (fileno (src)))
 337       {
 338         fclose (src);
 339         src = NULL;
 340         errno = EPERM;
 341       }
 342     if( !src ) {
 343         log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
 344         xfree(fname);
 345         return;
 346     }
 347     strcpy(stpcpy(fname, destdir), DIRSEP_S "gpg" EXTSEP_S "conf" );
 348     oldmask=umask(077);
 349     if ( is_secured_filename (fname) )
 350       {
 351         dst = NULL;
 352         errno = EPERM;
 353       }
 354     else
 355       dst = fopen( fname, "w" );
 356     umask(oldmask);
 357     if( !dst ) {
 358         log_error(_("can't create `%s': %s\n"), fname, strerror(errno) );
 359         fclose( src );
 360         xfree(fname);
 361         return;
 362     }
 363
 364     while( (c=getc(src)) != EOF ) {
 365         if( linefeeds < 3 ) {
 366             if( c == '\n' )
 367                 linefeeds++;
 368         }
 369         else {
 370             putc( c, dst );
 371             if (c== '\n')
 372                 esc = 1;
 373             else if (esc == 1) {
 374                 if (c == ' ' || c == '\t')
 375                     ;
 376                 else if (c == '#')
 377                     esc = 2;
 378                 else
 379                     any_option = 1;
 380             }
 381         }
 382     }
 383     fclose( dst );
 384     fclose( src );
 385     log_info(_("new configuration file `%s' created\n"), fname );
 386     if (any_option)
 387         log_info (_("WARNING: options in `%s'"
 388                     " are not yet active during this run\n"),
 389                   fname);
 390     xfree(fname);
 391 }
 392
 393
 394 void
 395 try_make_homedir( const char *fname )
 396 {
 397     const char *defhome = GNUPG_DEFAULT_HOMEDIR;
 398
 399     /* Create the directory only if the supplied directory name
 400      * is the same as the default one.  This way we avoid to create
 401      * arbitrary directories when a non-default homedirectory is used.
 402      * To cope with HOME, we do compare only the suffix if we see that
 403      * the default homedir does start with a tilde.
 404      */
 405     if( opt.dry_run || opt.no_homedir_creation )
 406         return;
 407
 408     if ( ( *defhome == '~'
 409            && ( strlen(fname) >= strlen (defhome+1)
 410                 && !strcmp(fname+strlen(fname)-strlen(defhome+1),
 411                            defhome+1 ) ))
 412          || ( *defhome != '~'
 413               && !compare_filenames( fname, defhome ) )
 414         ) {
 415         if( mkdir( fname, S_IRUSR|S_IWUSR|S_IXUSR ) )
 416             log_fatal( _("can't create directory `%s': %s\n"),
 417                                         fname,  strerror(errno) );
 418         else if( !opt.quiet )
 419             log_info( _("directory `%s' created\n"), fname );
 420         copy_options_file( fname );
 421 /*      log_info(_("you have to start GnuPG again, " */
 422 /*                 "so it can read the new configuration file\n") ); */
 423 /*      g10_exit(1); */
 424     }
 425 }