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     {
 113       char *buf = xstrdup (iname);
 114       buf[n-4] = 0;
 115       return buf;
 116     }
 117   else if (n > 5 && !CMP_FILENAME(iname+n-5, EXTSEP_S "sign"))
 118     {
 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 /* Ask for an output filename; use the given one as default.  Return
 130    NULL if no file has been given or if it is not possible to ask the
 131    user.  NAME is the template len which might conatin enbedded Nuls.
 132    NAMELEN is its actual length.
 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   defname = name && namelen? make_printable_string (name, namelen, 0) : NULL;
 147
 148   s = _("Enter new filename");
 149   n = strlen(s) + (defname?strlen (defname):0) + 10;
 150   prompt = xmalloc (n);
 151   if (defname)
 152     snprintf (prompt, n-1, "%s [%s]: ", s, defname );
 153   else
 154     snprintf (prompt, n-1, "%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     {
 162       xfree (fname);
 163       fname = defname;
 164       defname = NULL;
 165     }
 166   xfree (defname);
 167   if (fname)
 168     trim_spaces (fname);
 169   return fname;
 170 }
 171
 172
 173 /*
 174  * Make an output filename for the inputfile INAME.
 175  * Returns an IOBUF and an errorcode
 176  * Mode 0 = use ".gpg"
 177  *      1 = use ".asc"
 178  *      2 = use ".sig"
 179  *      3 = use ".rev"
 180  *
 181  * If INP_FD is not -1 the function simply creates an IOBUF for that
 182  * file descriptor and ignore INAME and MODE.  Note that INP_FD won't
 183  * be closed if the returned IOBUF is closed.  With RESTRICTEDPERM a
 184  * file will be created with mode 700 if possible.
 185  */
 186 int
 187 open_outfile (int inp_fd, const char *iname, int mode, int restrictedperm,
 188               iobuf_t *a)
 189 {
 190   int rc = 0;
 191
 192   *a = NULL;
 193   if (inp_fd != -1)
 194     {
 195       char xname[64];
 196
 197       *a = iobuf_fdopen_nc (inp_fd, "wb");
 198       if (!*a)
 199         {
 200           rc = gpg_error_from_syserror ();
 201           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
 202           log_error (_("can't open '%s': %s\n"), xname, gpg_strerror (rc));
 203         }
 204       else if (opt.verbose)
 205         {
 206           snprintf (xname, sizeof xname, "[fd %d]", inp_fd);
 207           log_info (_("writing to '%s'\n"), xname);
 208         }
 209     }
 210   else if (iobuf_is_pipe_filename (iname) && !opt.outfile)
 211     {
 212       *a = iobuf_create (NULL, 0);
 213       if ( !*a )
 214         {
 215           rc = gpg_error_from_syserror ();
 216           log_error (_("can't open '%s': %s\n"), "[stdout]", strerror(errno) );
 217         }
 218       else if ( opt.verbose )
 219         log_info (_("writing to stdout\n"));
 220     }
 221   else
 222     {
 223       char *buf = NULL;
 224       const char *name;
 225
 226       if (opt.dry_run)
 227         name = NAME_OF_DEV_NULL;
 228       else if (opt.outfile)
 229         name = opt.outfile;
 230       else
 231         {
 232 #ifdef USE_ONLY_8DOT3
 233           if (opt.mangle_dos_filenames)
 234             {
 235               /* It is quite common for DOS systems to have only one
 236                  dot in a filename.  If we have something like this,
 237                  we simple replace the suffix except in cases where
 238                  the suffix is larger than 3 characters and not the
 239                  same as the new one.  We don't map the filenames to
 240                  8.3 because this is a duty of the file system.  */
 241               char *dot;
 242               const char *newsfx;
 243
 244               newsfx = (mode==1 ? ".asc" :
 245                         mode==2 ? ".sig" :
 246                         mode==3 ? ".rev" : ".gpg");
 247
 248               buf = xmalloc (strlen(iname)+4+1);
 249               strcpy (buf, iname);
 250               dot = strchr (buf, '.' );
 251               if ( dot && dot > buf && dot[1] && strlen(dot) <= 4
 252                    && CMP_FILENAME (newsfx, dot) )
 253                 strcpy (dot, newsfx);
 254               else if (dot && !dot[1]) /* Do not duplicate a dot.  */
 255                 strcpy (dot, newsfx+1);
 256               else
 257                 strcat (buf, newsfx);
 258             }
 259           if (!buf)
 260 #endif /* USE_ONLY_8DOT3 */
 261             {
 262               buf = xstrconcat (iname,
 263                                 (mode==1 ? EXTSEP_S "asc" :
 264                                  mode==2 ? EXTSEP_S "sig" :
 265                                  mode==3 ? EXTSEP_S "rev" :
 266                                  /*     */ EXTSEP_S GPGEXT_GPG),
 267                                 NULL);
 268             }
 269           name = buf;
 270         }
 271
 272       rc = 0;
 273       while ( !overwrite_filep (name) )
 274         {
 275           char *tmp = ask_outfile_name (NULL, 0);
 276           if ( !tmp || !*tmp )
 277             {
 278               xfree (tmp);
 279               rc = gpg_error (GPG_ERR_EEXIST);
 280               break;
 281             }
 282           xfree (buf);
 283           name = buf = tmp;
 284         }
 285
 286       if ( !rc )
 287         {
 288           if (is_secured_filename (name) )
 289             {
 290               *a = NULL;
 291               gpg_err_set_errno (EPERM);
 292             }
 293           else
 294             *a = iobuf_create (name, restrictedperm);
 295           if (!*a)
 296             {
 297               rc = gpg_error_from_syserror ();
 298               log_error(_("can't create '%s': %s\n"), name, strerror(errno) );
 299             }
 300           else if( opt.verbose )
 301             log_info (_("writing to '%s'\n"), name );
 302         }
 303       xfree(buf);
 304     }
 305
 306   if (*a)
 307     iobuf_ioctl (*a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
 308
 309   return rc;
 310 }
 311
 312
 313 /* Find a matching data file for the signature file SIGFILENAME and
 314    return it as a malloced string.  If no matching data file is found,
 315    return NULL.  */
 316 char *
 317 get_matching_datafile (const char *sigfilename)
 318 {
 319   char *fname = NULL;
 320   size_t len;
 321
 322   if (iobuf_is_pipe_filename (sigfilename))
 323     return NULL;
 324
 325   len = strlen (sigfilename);
 326   if (len > 4
 327       && (!strcmp (sigfilename + len - 4, EXTSEP_S "sig")
 328           || (len > 5 && !strcmp(sigfilename + len - 5, EXTSEP_S "sign"))
 329           || !strcmp(sigfilename + len - 4, EXTSEP_S "asc")))
 330     {
 331
 332       fname = xstrdup (sigfilename);
 333       fname[len-(fname[len-1]=='n'?5:4)] = 0 ;
 334       if (access (fname, R_OK ))
 335         {
 336           /* Not found or other error.  */
 337           xfree (fname);
 338           fname = NULL;
 339         }
 340     }
 341
 342   return fname;
 343 }
 344
 345
 346 /*
 347  * Try to open a file without the extension ".sig" or ".asc"
 348  * Return NULL if such a file is not available.
 349  */
 350 iobuf_t
 351 open_sigfile (const char *sigfilename, progress_filter_context_t *pfx)
 352 {
 353   iobuf_t a = NULL;
 354   char *buf;
 355
 356   buf = get_matching_datafile (sigfilename);
 357   if (buf)
 358     {
 359       a = iobuf_open (buf);
 360       if (a && is_secured_file (iobuf_get_fd (a)))
 361         {
 362           iobuf_close (a);
 363           a = NULL;
 364           gpg_err_set_errno (EPERM);
 365         }
 366       if (a)
 367         log_info (_("assuming signed data in '%s'\n"), buf);
 368       if (a && pfx)
 369         handle_progress (pfx, a, buf);
 370       xfree (buf);
 371     }
 372
 373   return a;
 374 }
 375
 376
 377 /****************
 378  * Copy the option file skeleton to the given directory.
 379  */
 380 static void
 381 copy_options_file (const char *destdir)
 382 {
 383   const char *datadir = gnupg_datadir ();
 384   char *fname;
 385   FILE *src, *dst;
 386   int linefeeds=0;
 387   int c;
 388   mode_t oldmask;
 389   int esc = 0;
 390   int any_option = 0;
 391
 392   if (opt.dry_run)
 393     return;
 394
 395   fname = xmalloc (strlen(datadir) + strlen(destdir) + 15);
 396   strcpy (stpcpy(fname, datadir), DIRSEP_S "gpg-conf" SKELEXT);
 397   src = fopen (fname, "r");
 398   if (src && is_secured_file (fileno (src)))
 399     {
 400       fclose (src);
 401       src = NULL;
 402       gpg_err_set_errno (EPERM);
 403     }
 404   if (!src)
 405     {
 406       log_info (_("can't open '%s': %s\n"), fname, strerror(errno));
 407       xfree(fname);
 408       return;
 409     }
 410   strcpy (stpcpy (fname, destdir), DIRSEP_S GPGEXT_GPG EXTSEP_S "conf");
 411
 412   oldmask = umask (077);
 413   if (is_secured_filename (fname))
 414     {
 415       dst = NULL;
 416       gpg_err_set_errno (EPERM);
 417     }
 418   else
 419     dst = fopen( fname, "w" );
 420   umask (oldmask);
 421
 422   if (!dst)
 423     {
 424       log_info (_("can't create '%s': %s\n"), fname, strerror(errno) );
 425       fclose (src);
 426       xfree (fname);
 427       return;
 428     }
 429
 430   while ((c = getc (src)) != EOF)
 431     {
 432       if (linefeeds < 3)
 433         {
 434           if (c == '\n')
 435             linefeeds++;
 436         }
 437       else
 438         {
 439           putc (c, dst);
 440           if (c== '\n')
 441             esc = 1;
 442           else if (esc == 1)
 443             {
 444               if (c == ' ' || c == '\t')
 445                 ;
 446               else if (c == '#')
 447                 esc = 2;
 448               else
 449                 any_option = 1;
 450             }
 451         }
 452     }
 453
 454   fclose (dst);
 455   fclose (src);
 456
 457   log_info (_("new configuration file '%s' created\n"), fname);
 458   if (any_option)
 459     log_info (_("WARNING: options in '%s'"
 460                 " are not yet active during this run\n"),
 461               fname);
 462   xfree (fname);
 463 }
 464
 465
 466 void
 467 try_make_homedir (const char *fname)
 468 {
 469   const char *defhome = standard_homedir ();
 470
 471   /* Create the directory only if the supplied directory name is the
 472      same as the default one.  This way we avoid to create arbitrary
 473      directories when a non-default home directory is used.  To cope
 474      with HOME, we do compare only the suffix if we see that the
 475      default homedir does start with a tilde.  */
 476   if ( opt.dry_run || opt.no_homedir_creation )
 477     return;
 478
 479   if (
 480 #ifdef HAVE_W32_SYSTEM
 481       ( !compare_filenames (fname, defhome) )
 482 #else
 483       ( *defhome == '~'
 484         && (strlen(fname) >= strlen (defhome+1)
 485             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
 486       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
 487 #endif
 488       )
 489     {
 490       if (gnupg_mkdir (fname, "-rwx"))
 491         log_fatal ( _("can't create directory '%s': %s\n"),
 492                     fname, strerror(errno) );
 493       else if (!opt.quiet )
 494         log_info ( _("directory '%s' created\n"), fname );
 495       copy_options_file( fname );
 496     }
 497 }
 498
 499
 500 /* Get and if needed create a string with the directory used to store
 501    openpgp revocations.  */
 502 char *
 503 get_openpgp_revocdir (const char *home)
 504 {
 505   char *fname;
 506   struct stat statbuf;
 507
 508   fname = make_filename (home, GNUPG_OPENPGP_REVOC_DIR, NULL);
 509   if (stat (fname, &statbuf) && errno == ENOENT)
 510     {
 511       if (gnupg_mkdir (fname, "-rwx"))
 512         log_error (_("can't create directory '%s': %s\n"),
 513                    fname, strerror (errno) );
 514       else if (!opt.quiet)
 515         log_info (_("directory '%s' created\n"), fname);
 516     }
 517   return fname;
 518 }