agent/gpg-agent.c

   1 /* gpg-agent.c  -  The GnuPG Agent
   2  *      Copyright (C) 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
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <stddef.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <assert.h>
  32 #include <time.h>
  33 #include <fcntl.h>
  34 #include <sys/stat.h>
  35 #ifndef HAVE_W32_SYSTEM
  36 #include <sys/socket.h>
  37 #include <sys/un.h>
  38 #endif /*HAVE_W32_SYSTEM*/
  39 #include <unistd.h>
  40 #include <signal.h>
  41 #include <pth.h>
  42
  43 #define JNLIB_NEED_LOG_LOGV
  44 #include "agent.h"
  45 #include <assuan.h> /* Malloc hooks */
  46
  47 #include "i18n.h"
  48 #include "sysutils.h"
  49 #ifdef HAVE_W32_SYSTEM
  50 #include "../jnlib/w32-afunix.h"
  51 #endif
  52 #include "setenv.h"
  53
  54
  55 enum cmd_and_opt_values
  56 { aNull = 0,
  57   oCsh            = 'c',
  58   oQuiet          = 'q',
  59   oSh             = 's',
  60   oVerbose        = 'v',
  61
  62   oNoVerbose = 500,
  63   aGPGConfList,
  64   aGPGConfTest,
  65   oOptions,
  66   oDebug,
  67   oDebugAll,
  68   oDebugLevel,
  69   oDebugWait,
  70   oNoGreeting,
  71   oNoOptions,
  72   oHomedir,
  73   oNoDetach,
  74   oNoGrab,
  75   oLogFile,
  76   oServer,
  77   oDaemon,
  78   oBatch,
  79
  80   oPinentryProgram,
  81   oDisplay,
  82   oTTYname,
  83   oTTYtype,
  84   oLCctype,
  85   oLCmessages,
  86   oScdaemonProgram,
  87   oDefCacheTTL,
  88   oDefCacheTTLSSH,
  89   oMaxCacheTTL,
  90   oMaxCacheTTLSSH,
  91   oUseStandardSocket,
  92   oNoUseStandardSocket,
  93
  94   oIgnoreCacheForSigning,
  95   oAllowMarkTrusted,
  96   oAllowPresetPassphrase,
  97   oKeepTTY,
  98   oKeepDISPLAY,
  99   oSSHSupport,
 100   oDisableScdaemon,
 101   oWriteEnvFile
 102 };
 103
 104
 105
 106 static ARGPARSE_OPTS opts[] = {
 107
 108   { aGPGConfList, "gpgconf-list", 256, "@" },
 109   { aGPGConfTest, "gpgconf-test", 256, "@" },
 110
 111   { 301, NULL, 0, N_("@Options:\n ") },
 112
 113   { oServer,   "server",     0, N_("run in server mode (foreground)") },
 114   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
 115   { oVerbose, "verbose",     0, N_("verbose") },
 116   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
 117   { oSh,        "sh",        0, N_("sh-style command output") },
 118   { oCsh,       "csh",       0, N_("csh-style command output") },
 119   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
 120   { oDebug,     "debug"     ,4|16, "@"},
 121   { oDebugAll, "debug-all"     ,0, "@"},
 122   { oDebugLevel, "debug-level" ,2, "@"},
 123   { oDebugWait,"debug-wait",1, "@"},
 124   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
 125   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
 126   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
 127   { oUseStandardSocket, "use-standard-socket", 0,
 128                       N_("use a standard location for the socket")},
 129   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
 130
 131   { oPinentryProgram, "pinentry-program", 2 ,
 132                                N_("|PGM|use PGM as the PIN-Entry program") },
 133   { oScdaemonProgram, "scdaemon-program", 2 ,
 134                                N_("|PGM|use PGM as the SCdaemon program") },
 135   { oDisableScdaemon, "disable-scdaemon", 0, N_("do not use the SCdaemon") },
 136
 137   { oDisplay,    "display",     2, "@" },
 138   { oTTYname,    "ttyname",     2, "@" },
 139   { oTTYtype,    "ttytype",     2, "@" },
 140   { oLCctype,    "lc-ctype",    2, "@" },
 141   { oLCmessages, "lc-messages", 2, "@" },
 142   { oKeepTTY, "keep-tty", 0,  N_("ignore requests to change the TTY")},
 143   { oKeepDISPLAY, "keep-display",
 144                           0, N_("ignore requests to change the X display")},
 145
 146   { oDefCacheTTL, "default-cache-ttl", 4,
 147                                N_("|N|expire cached PINs after N seconds")},
 148   { oDefCacheTTLSSH, "default-cache-ttl-ssh", 4, "@" },
 149   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
 150   { oMaxCacheTTLSSH, "max-cache-ttl-ssh", 4, "@" },
 151   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
 152                                N_("do not use the PIN cache when signing")},
 153   { oAllowMarkTrusted, "allow-mark-trusted", 0,
 154                              N_("allow clients to mark keys as \"trusted\"")},
 155   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
 156                              N_("allow presetting passphrase")},
 157   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
 158   { oWriteEnvFile, "write-env-file", 2|8,
 159             N_("|FILE|write environment settings also to FILE")},
 160   {0}
 161 };
 162
 163
 164 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
 165 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
 166 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
 167
 168
 169 /* flag to indicate that a shutdown was requested */
 170 static int shutdown_pending;
 171
 172
 173 /* It is possible that we are currently running under setuid permissions */
 174 static int maybe_setuid = 1;
 175
 176 /* Name of the communication socket used for native gpg-agent requests.  */
 177 static char *socket_name;
 178
 179 /* Name of the communication socket used for ssh-agent-emulation.  */
 180 static char *socket_name_ssh;
 181
 182 /* Default values for options passed to the pinentry. */
 183 static char *default_display;
 184 static char *default_ttyname;
 185 static char *default_ttytype;
 186 static char *default_lc_ctype;
 187 static char *default_lc_messages;
 188
 189 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
 190 static char *config_filename;
 191
 192 /* Helper to implement --debug-level */
 193 static const char *debug_level;
 194
 195 /* Keep track of the current log file so that we can avoid updating
 196    the log file after a SIGHUP if it didn't changed. Malloced. */
 197 static char *current_logfile;
 198
 199 /* The handle_tick() function may test whether a parent is still
 200    running.  We record the PID of the parent here or -1 if it should be
 201    watched. */
 202 static pid_t parent_pid = (pid_t)(-1);
 203
 204 \f
 205 /*
 206    Local prototypes.
 207  */
 208
 209 static char *create_socket_name (int use_standard_socket,
 210                                  char *standard_name, char *template);
 211 static int create_server_socket (int is_standard_name, const char *name);
 212 static void create_directories (void);
 213
 214 static void agent_init_default_ctrl (ctrl_t ctrl);
 215 static void agent_deinit_default_ctrl (ctrl_t ctrl);
 216
 217 static void handle_connections (int listen_fd, int listen_fd_ssh);
 218 static int check_for_running_agent (int);
 219
 220 /* Pth wrapper function definitions. */
 221 GCRY_THREAD_OPTION_PTH_IMPL;
 222
 223
 224
 225 \f
 226 /*
 227    Functions.
 228  */
 229
 230
 231 static const char *
 232 my_strusage (int level)
 233 {
 234   const char *p;
 235   switch (level)
 236     {
 237     case 11: p = "gpg-agent (GnuPG)";
 238       break;
 239     case 13: p = VERSION; break;
 240     case 17: p = PRINTABLE_OS_NAME; break;
 241     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
 242       break;
 243     case 1:
 244     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
 245       break;
 246     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
 247                     "Secret key management for GnuPG\n");
 248     break;
 249
 250     default: p = NULL;
 251     }
 252   return p;
 253 }
 254
 255
 256
 257 static void
 258 i18n_init (void)
 259 {
 260 #ifdef USE_SIMPLE_GETTEXT
 261     set_gettext_file( PACKAGE_GT );
 262 #else
 263 #ifdef ENABLE_NLS
 264     setlocale (LC_ALL, "");
 265     bindtextdomain (PACKAGE_GT, LOCALEDIR);
 266     textdomain (PACKAGE_GT);
 267 #endif
 268 #endif
 269 }
 270
 271
 272
 273 /* Used by gcry for logging */
 274 static void
 275 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
 276 {
 277   /* translate the log levels */
 278   switch (level)
 279     {
 280     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
 281     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
 282     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
 283     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
 284     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
 285     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
 286     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
 287     default:            level = JNLIB_LOG_ERROR; break;
 288     }
 289   log_logv (level, fmt, arg_ptr);
 290 }
 291
 292
 293 /* This function is called by libgcrypt if it ran out of core and
 294    there is no way to return that error to the caller.  We do our own
 295    function here to make use of our logging functions. */
 296 static int
 297 my_gcry_outofcore_handler ( void *opaque, size_t req_n, unsigned int flags)
 298 {
 299   static int been_here;  /* Used to protect against recursive calls. */
 300
 301   if (!been_here)
 302     {
 303       been_here = 1;
 304       if ( (flags & 1) )
 305         log_fatal (_("out of core in secure memory "
 306                      "while allocating %lu bytes"), (unsigned long)req_n);
 307       else
 308         log_fatal (_("out of core while allocating %lu bytes"),
 309                    (unsigned long)req_n);
 310     }
 311   return 0; /* Let libgcrypt call its own fatal error handler. */
 312 }
 313
 314
 315 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
 316    only the active debug flags are propagated to the subsystems.  With
 317    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
 318    all flags already set. Note that we don't fail here, because it is
 319    important to keep gpg-agent running even after re-reading the
 320    options due to a SIGHUP. */
 321 static void
 322 set_debug (void)
 323 {
 324   if (!debug_level)
 325     ;
 326   else if (!strcmp (debug_level, "none"))
 327     opt.debug = 0;
 328   else if (!strcmp (debug_level, "basic"))
 329     opt.debug = DBG_ASSUAN_VALUE;
 330   else if (!strcmp (debug_level, "advanced"))
 331     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
 332   else if (!strcmp (debug_level, "expert"))
 333     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
 334                  |DBG_CACHE_VALUE);
 335   else if (!strcmp (debug_level, "guru"))
 336     opt.debug = ~0;
 337   else
 338     {
 339       log_error (_("invalid debug-level `%s' given\n"), debug_level);
 340       opt.debug = 0; /* Reset debugging, so that prior debug
 341                         statements won't have an undesired effect. */
 342     }
 343
 344   if (opt.debug && !opt.verbose)
 345     opt.verbose = 1;
 346   if (opt.debug && opt.quiet)
 347     opt.quiet = 0;
 348
 349   if (opt.debug & DBG_MPI_VALUE)
 350     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
 351   if (opt.debug & DBG_CRYPTO_VALUE )
 352     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
 353   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 354 }
 355
 356
 357 /* Helper for cleanup to remove one socket with NAME.  */
 358 static void
 359 remove_socket (char *name)
 360 {
 361   if (name && *name)
 362     {
 363       char *p;
 364
 365       remove (name);
 366       p = strrchr (name, '/');
 367       if (p)
 368         {
 369           *p = 0;
 370           rmdir (name);
 371           *p = '/';
 372         }
 373       *name = 0;
 374     }
 375 }
 376
 377 static void
 378 cleanup (void)
 379 {
 380   remove_socket (socket_name);
 381   remove_socket (socket_name_ssh);
 382 }
 383
 384
 385
 386 /* Handle options which are allowed to be reset after program start.
 387    Return true when the current option in PARGS could be handled and
 388    false if not.  As a special feature, passing a value of NULL for
 389    PARGS, resets the options to the default.  REREAD should be set
 390    true if it is not the initial option parsing. */
 391 static int
 392 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
 393 {
 394   if (!pargs)
 395     { /* reset mode */
 396       opt.quiet = 0;
 397       opt.verbose = 0;
 398       opt.debug = 0;
 399       opt.no_grab = 0;
 400       opt.pinentry_program = NULL;
 401       opt.scdaemon_program = NULL;
 402       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
 403       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
 404       opt.max_cache_ttl = MAX_CACHE_TTL;
 405       opt.max_cache_ttl_ssh = MAX_CACHE_TTL;
 406       opt.ignore_cache_for_signing = 0;
 407       opt.allow_mark_trusted = 0;
 408       opt.disable_scdaemon = 0;
 409       return 1;
 410     }
 411
 412   switch (pargs->r_opt)
 413     {
 414     case oQuiet: opt.quiet = 1; break;
 415     case oVerbose: opt.verbose++; break;
 416
 417     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
 418     case oDebugAll: opt.debug = ~0; break;
 419     case oDebugLevel: debug_level = pargs->r.ret_str; break;
 420
 421     case oLogFile:
 422       if (!reread)
 423         return 0; /* not handeld */
 424       if (!current_logfile || !pargs->r.ret_str
 425           || strcmp (current_logfile, pargs->r.ret_str))
 426         {
 427           log_set_file (pargs->r.ret_str);
 428           xfree (current_logfile);
 429           current_logfile = xtrystrdup (pargs->r.ret_str);
 430         }
 431       break;
 432
 433     case oNoGrab: opt.no_grab = 1; break;
 434
 435     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
 436     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
 437     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
 438
 439     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
 440     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
 441     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
 442     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
 443
 444     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
 445
 446     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
 447
 448     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
 449
 450     default:
 451       return 0; /* not handled */
 452     }
 453
 454   return 1; /* handled */
 455 }
 456
 457
 458 int
 459 main (int argc, char **argv )
 460 {
 461   ARGPARSE_ARGS pargs;
 462   int orig_argc;
 463   int may_coredump;
 464   char **orig_argv;
 465   FILE *configfp = NULL;
 466   char *configname = NULL;
 467   const char *shell;
 468   unsigned configlineno;
 469   int parse_debug = 0;
 470   int default_config =1;
 471   int greeting = 0;
 472   int nogreeting = 0;
 473   int pipe_server = 0;
 474   int is_daemon = 0;
 475   int nodetach = 0;
 476   int csh_style = 0;
 477   char *logfile = NULL;
 478   int debug_wait = 0;
 479   int gpgconf_list = 0;
 480   int standard_socket = 0;
 481   gpg_error_t err;
 482   const char *env_file_name = NULL;
 483
 484   set_strusage (my_strusage);
 485   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 486   /* Please note that we may running SUID(ROOT), so be very CAREFUL
 487      when adding any stuff between here and the call to INIT_SECMEM()
 488      somewhere after the option parsing */
 489   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID);
 490
 491   /* Try to auto set the character set.  */
 492   set_native_charset (NULL);
 493
 494   i18n_init ();
 495
 496   /* Libgcrypt requires us to register the threading model first.
 497      Note that this will also do the pth_init. */
 498   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
 499   if (err)
 500     {
 501       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
 502                  gpg_strerror (err));
 503     }
 504
 505
 506   /* Check that the libraries are suitable.  Do it here because
 507      the option parsing may need services of the library. */
 508   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
 509     {
 510       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
 511                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
 512     }
 513
 514   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
 515   assuan_set_assuan_log_stream (log_get_stream ());
 516   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
 517   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
 518
 519   gcry_set_log_handler (my_gcry_logger, NULL);
 520   gcry_set_outofcore_handler (my_gcry_outofcore_handler, NULL);
 521   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
 522
 523   may_coredump = disable_core_dumps ();
 524
 525   /* Set default options.  */
 526   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
 527 #ifdef HAVE_W32_SYSTEM
 528   standard_socket = 1;  /* Under Windows we always use a standard
 529                            socket.  */
 530 #endif
 531
 532   shell = getenv ("SHELL");
 533   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
 534     csh_style = 1;
 535
 536   opt.homedir = default_homedir ();
 537
 538   /* Record some of the original environment strings. */
 539   opt.startup_display = getenv ("DISPLAY");
 540   if (opt.startup_display)
 541     opt.startup_display = xstrdup (opt.startup_display);
 542   opt.startup_ttyname = ttyname (0);
 543   if (opt.startup_ttyname)
 544     opt.startup_ttyname = xstrdup (opt.startup_ttyname);
 545   opt.startup_ttytype = getenv ("TERM");
 546   if (opt.startup_ttytype)
 547     opt.startup_ttytype = xstrdup (opt.startup_ttytype);
 548   /* Fixme: Better use the locale function here.  */
 549   opt.startup_lc_ctype = getenv ("LC_CTYPE");
 550   if (opt.startup_lc_ctype)
 551     opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
 552   opt.startup_lc_messages = getenv ("LC_MESSAGES");
 553   if (opt.startup_lc_messages)
 554     opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
 555
 556   /* Check whether we have a config file on the commandline */
 557   orig_argc = argc;
 558   orig_argv = argv;
 559   pargs.argc = &argc;
 560   pargs.argv = &argv;
 561   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
 562   while (arg_parse( &pargs, opts))
 563     {
 564       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
 565         parse_debug++;
 566       else if (pargs.r_opt == oOptions)
 567         { /* yes there is one, so we do not try the default one, but
 568              read the option file when it is encountered at the
 569              commandline */
 570           default_config = 0;
 571         }
 572         else if (pargs.r_opt == oNoOptions)
 573           default_config = 0; /* --no-options */
 574         else if (pargs.r_opt == oHomedir)
 575           opt.homedir = pargs.r.ret_str;
 576     }
 577
 578   /* Initialize the secure memory. */
 579   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
 580   maybe_setuid = 0;
 581
 582   /*
 583      Now we are now working under our real uid
 584   */
 585
 586   if (default_config)
 587     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
 588
 589   argc = orig_argc;
 590   argv = orig_argv;
 591   pargs.argc = &argc;
 592   pargs.argv = &argv;
 593   pargs.flags=  1;  /* do not remove the args */
 594  next_pass:
 595   if (configname)
 596     {
 597       configlineno = 0;
 598       configfp = fopen (configname, "r");
 599       if (!configfp)
 600         {
 601           if (default_config)
 602             {
 603               if( parse_debug )
 604                 log_info (_("NOTE: no default option file `%s'\n"),
 605                           configname );
 606             }
 607           else
 608             {
 609               log_error (_("option file `%s': %s\n"),
 610                          configname, strerror(errno) );
 611               exit(2);
 612             }
 613           xfree (configname);
 614           configname = NULL;
 615         }
 616       if (parse_debug && configname )
 617         log_info (_("reading options from `%s'\n"), configname );
 618       default_config = 0;
 619     }
 620
 621   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
 622     {
 623       if (parse_rereadable_options (&pargs, 0))
 624         continue; /* Already handled */
 625       switch (pargs.r_opt)
 626         {
 627         case aGPGConfList: gpgconf_list = 1; break;
 628         case aGPGConfTest: gpgconf_list = 2; break;
 629         case oBatch: opt.batch=1; break;
 630
 631         case oDebugWait: debug_wait = pargs.r.ret_int; break;
 632
 633         case oOptions:
 634           /* config files may not be nested (silently ignore them) */
 635           if (!configfp)
 636             {
 637                 xfree(configname);
 638                 configname = xstrdup(pargs.r.ret_str);
 639                 goto next_pass;
 640             }
 641           break;
 642         case oNoGreeting: nogreeting = 1; break;
 643         case oNoVerbose: opt.verbose = 0; break;
 644         case oNoOptions: break; /* no-options */
 645         case oHomedir: opt.homedir = pargs.r.ret_str; break;
 646         case oNoDetach: nodetach = 1; break;
 647         case oLogFile: logfile = pargs.r.ret_str; break;
 648         case oCsh: csh_style = 1; break;
 649         case oSh: csh_style = 0; break;
 650         case oServer: pipe_server = 1; break;
 651         case oDaemon: is_daemon = 1; break;
 652
 653         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
 654         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
 655         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
 656         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
 657         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
 658           break;
 659
 660         case oUseStandardSocket: standard_socket = 1; break;
 661         case oNoUseStandardSocket: standard_socket = 0; break;
 662
 663         case oKeepTTY: opt.keep_tty = 1; break;
 664         case oKeepDISPLAY: opt.keep_display = 1; break;
 665
 666         case oSSHSupport:  opt.ssh_support = 1; break;
 667         case oWriteEnvFile:
 668           if (pargs.r_type)
 669             env_file_name = pargs.r.ret_str;
 670           else
 671             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
 672           break;
 673
 674         default : pargs.err = configfp? 1:2; break;
 675         }
 676     }
 677   if (configfp)
 678     {
 679       fclose( configfp );
 680       configfp = NULL;
 681       /* Keep a copy of the name so that it can be read on SIGHUP. */
 682       config_filename = configname;
 683       configname = NULL;
 684       goto next_pass;
 685     }
 686   xfree (configname);
 687   configname = NULL;
 688   if (log_get_errorcount(0))
 689     exit(2);
 690   if (nogreeting )
 691     greeting = 0;
 692
 693   if (greeting)
 694     {
 695       fprintf (stderr, "%s %s; %s\n",
 696                  strusage(11), strusage(13), strusage(14) );
 697       fprintf (stderr, "%s\n", strusage(15) );
 698     }
 699 #ifdef IS_DEVELOPMENT_VERSION
 700   /* We don't want to print it here because gpg-agent is useful of its
 701      own and quite matured.  */
 702   /*log_info ("NOTE: this is a development version!\n");*/
 703 #endif
 704
 705   set_debug ();
 706
 707   if (atexit (cleanup))
 708     {
 709       log_error ("atexit failed\n");
 710       cleanup ();
 711       exit (1);
 712     }
 713
 714   initialize_module_query ();
 715   initialize_module_call_scd ();
 716
 717   /* Try to create missing directories. */
 718   create_directories ();
 719
 720   if (debug_wait && pipe_server)
 721     {
 722       log_debug ("waiting for debugger - my pid is %u .....\n",
 723                  (unsigned int)getpid());
 724       sleep (debug_wait);
 725       log_debug ("... okay\n");
 726     }
 727
 728   if (gpgconf_list == 2)
 729     agent_exit (0);
 730   if (gpgconf_list)
 731     {
 732       char *filename;
 733
 734       /* List options and default values in the GPG Conf format.  */
 735
 736       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
 737       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
 738          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
 739 #define GC_OPT_FLAG_NONE        0UL
 740       /* The RUNTIME flag for an option indicates that the option can be
 741          changed at runtime.  */
 742 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
 743       /* The DEFAULT flag for an option indicates that the option has a
 744          default value.  */
 745 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
 746       /* The DEF_DESC flag for an option indicates that the option has a
 747          default, which is described by the value of the default field.  */
 748 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
 749       /* The NO_ARG_DESC flag for an option indicates that the argument has
 750          a default, which is described by the value of the ARGDEF field.  */
 751 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
 752
 753       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
 754       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
 755               GC_OPT_FLAG_DEFAULT, filename);
 756       xfree (filename);
 757
 758       printf ("verbose:%lu:\n"
 759               "quiet:%lu:\n"
 760               "debug-level:%lu:\"none:\n"
 761               "log-file:%lu:\n",
 762               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
 763               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
 764               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
 765               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
 766       printf ("default-cache-ttl:%lu:%d:\n",
 767               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
 768       printf ("no-grab:%lu:\n",
 769               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 770       printf ("ignore-cache-for-signing:%lu:\n",
 771               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 772       printf ("allow-mark-trusted:%lu:\n",
 773               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 774       printf ("disable-scdaemon:%lu:\n",
 775               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 776
 777       agent_exit (0);
 778     }
 779
 780   /* If this has been called without any options, we merely check
 781      whether an agent is already running.  We do this here so that we
 782      don't clobber a logfile but print it directly to stderr. */
 783   if (!pipe_server && !is_daemon)
 784     {
 785       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
 786       check_for_running_agent (0);
 787       agent_exit (0);
 788     }
 789
 790 #ifdef ENABLE_NLS
 791   /* gpg-agent usually does not output any messages because it runs in
 792      the background.  For log files it is acceptable to have messages
 793      always encoded in utf-8.  We switch here to utf-8, so that
 794      commands like --help still give native messages.  It is far
 795      easier to switch only once instead of for every message and it
 796      actually helps when more then one thread is active (avoids an
 797      extra copy step). */
 798     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
 799 #endif
 800
 801   /* Now start with logging to a file if this is desired. */
 802   if (logfile)
 803     {
 804       log_set_file (logfile);
 805       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
 806                              |JNLIB_LOG_WITH_TIME
 807                              |JNLIB_LOG_WITH_PID));
 808       current_logfile = xstrdup (logfile);
 809     }
 810
 811   /* Make sure that we have a default ttyname. */
 812   if (!default_ttyname && ttyname (1))
 813     default_ttyname = xstrdup (ttyname (1));
 814   if (!default_ttytype && getenv ("TERM"))
 815     default_ttytype = xstrdup (getenv ("TERM"));
 816
 817
 818   if (pipe_server)
 819     {
 820       /* This is the simple pipe based server */
 821       ctrl_t ctrl;
 822
 823       ctrl = xtrycalloc (1, sizeof *ctrl);
 824       if (!ctrl)
 825         {
 826           log_error ("error allocating connection control data: %s\n",
 827                      strerror (errno) );
 828           agent_exit (1);
 829         }
 830       agent_init_default_ctrl (ctrl);
 831       start_command_handler (ctrl, -1, -1);
 832       agent_deinit_default_ctrl (ctrl);
 833       xfree (ctrl);
 834     }
 835   else if (!is_daemon)
 836     ; /* NOTREACHED */
 837   else
 838     { /* Regular server mode */
 839       int fd;
 840       int fd_ssh;
 841       pid_t pid;
 842
 843       /* Remove the DISPLAY variable so that a pinentry does not
 844          default to a specific display.  There is still a default
 845          display when gpg-agent was started using --display or a
 846          client requested this using an OPTION command.  Note, that we
 847          don't do this when running in reverse daemon mode (i.e. when
 848          exec the program given as arguments). */
 849 #ifndef HAVE_W32_SYSTEM
 850       if (!opt.keep_display && !argc)
 851         unsetenv ("DISPLAY");
 852 #endif
 853
 854
 855       /* Create the sockets.  */
 856       socket_name = create_socket_name (standard_socket,
 857                                         "S.gpg-agent",
 858                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
 859       if (opt.ssh_support)
 860         socket_name_ssh = create_socket_name (standard_socket,
 861                                             "S.gpg-agent.ssh",
 862                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
 863
 864       fd = create_server_socket (standard_socket, socket_name);
 865       if (opt.ssh_support)
 866         fd_ssh = create_server_socket (standard_socket, socket_name_ssh);
 867       else
 868         fd_ssh = -1;
 869
 870       /* If we are going to exec a program in the parent, we record
 871          the PID, so that the child may check whether the program is
 872          still alive. */
 873       if (argc)
 874         parent_pid = getpid ();
 875
 876       fflush (NULL);
 877 #ifdef HAVE_W32_SYSTEM
 878       pid = getpid ();
 879       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
 880 #else /*!HAVE_W32_SYSTEM*/
 881       pid = fork ();
 882       if (pid == (pid_t)-1)
 883         {
 884           log_fatal ("fork failed: %s\n", strerror (errno) );
 885           exit (1);
 886         }
 887       else if (pid)
 888         { /* We are the parent */
 889           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
 890
 891           close (fd);
 892
 893           /* Create the info string: <name>:<pid>:<protocol_version> */
 894           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
 895                         socket_name, (ulong)pid ) < 0)
 896             {
 897               log_error ("out of core\n");
 898               kill (pid, SIGTERM);
 899               exit (1);
 900             }
 901           if (opt.ssh_support)
 902             {
 903               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
 904                             socket_name_ssh) < 0)
 905                 {
 906                   log_error ("out of core\n");
 907                   kill (pid, SIGTERM);
 908                   exit (1);
 909                 }
 910               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
 911                             pid) < 0)
 912                 {
 913                   log_error ("out of core\n");
 914                   kill (pid, SIGTERM);
 915                   exit (1);
 916                 }
 917             }
 918
 919           *socket_name = 0; /* Don't let cleanup() remove the socket -
 920                                the child should do this from now on */
 921           if (opt.ssh_support)
 922             *socket_name_ssh = 0;
 923
 924           if (env_file_name)
 925             {
 926               FILE *fp;
 927
 928               fp = fopen (env_file_name, "w");
 929               if (!fp)
 930                 log_error (_("error creating `%s': %s\n"),
 931                              env_file_name, strerror (errno));
 932               else
 933                 {
 934                   fputs (infostr, fp);
 935                   putc ('\n', fp);
 936                   if (opt.ssh_support)
 937                     {
 938                       fputs (infostr_ssh_sock, fp);
 939                       putc ('\n', fp);
 940                       fputs (infostr_ssh_pid, fp);
 941                       putc ('\n', fp);
 942                     }
 943                   fclose (fp);
 944                 }
 945             }
 946
 947
 948           if (argc)
 949             { /* Run the program given on the commandline.  */
 950               if (putenv (infostr))
 951                 {
 952                   log_error ("failed to set environment: %s\n",
 953                              strerror (errno) );
 954                   kill (pid, SIGTERM );
 955                   exit (1);
 956                 }
 957               if (opt.ssh_support && putenv (infostr_ssh_sock))
 958                 {
 959                   log_error ("failed to set environment: %s\n",
 960                              strerror (errno) );
 961                   kill (pid, SIGTERM );
 962                   exit (1);
 963                 }
 964               if (opt.ssh_support && putenv (infostr_ssh_pid))
 965                 {
 966                   log_error ("failed to set environment: %s\n",
 967                              strerror (errno) );
 968                   kill (pid, SIGTERM );
 969                   exit (1);
 970                 }
 971               execvp (argv[0], argv);
 972               log_error ("failed to run the command: %s\n", strerror (errno));
 973               kill (pid, SIGTERM);
 974               exit (1);
 975             }
 976           else
 977             {
 978               /* Print the environment string, so that the caller can use
 979                  shell's eval to set it */
 980               if (csh_style)
 981                 {
 982                   *strchr (infostr, '=') = ' ';
 983                   printf ("setenv %s\n", infostr);
 984                   if (opt.ssh_support)
 985                     {
 986                       *strchr (infostr_ssh_sock, '=') = ' ';
 987                       printf ("setenv %s\n", infostr_ssh_sock);
 988                       *strchr (infostr_ssh_pid, '=') = ' ';
 989                       printf ("setenv %s\n", infostr_ssh_pid);
 990                     }
 991                 }
 992               else
 993                 {
 994                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
 995                   if (opt.ssh_support)
 996                     {
 997                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
 998                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
 999                     }
1000                 }
1001               free (infostr); /* (Note that a vanilla free is here correct.) */
1002               if (opt.ssh_support)
1003                 {
1004                   free (infostr_ssh_sock);
1005                   free (infostr_ssh_pid);
1006                 }
1007               exit (0);
1008             }
1009           /*NOTREACHED*/
1010         } /* End parent */
1011
1012       /*
1013          This is the child
1014        */
1015
1016       /* Detach from tty and put process into a new session */
1017       if (!nodetach )
1018         {
1019           int i;
1020           unsigned int oldflags;
1021
1022           /* Close stdin, stdout and stderr unless it is the log stream */
1023           for (i=0; i <= 2; i++)
1024             {
1025               if (!log_test_fd (i) && i != fd )
1026                 {
1027                   if ( ! close (i)
1028                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1029                     {
1030                       log_error ("failed to open `%s': %s\n",
1031                                  "/dev/null", strerror (errno));
1032                       cleanup ();
1033                       exit (1);
1034                     }
1035                 }
1036             }
1037           if (setsid() == -1)
1038             {
1039               log_error ("setsid() failed: %s\n", strerror(errno) );
1040               cleanup ();
1041               exit (1);
1042             }
1043
1044           log_get_prefix (&oldflags);
1045           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1046           opt.running_detached = 1;
1047         }
1048
1049       if (chdir("/"))
1050         {
1051           log_error ("chdir to / failed: %s\n", strerror (errno));
1052           exit (1);
1053         }
1054
1055       {
1056         struct sigaction sa;
1057
1058         sa.sa_handler = SIG_IGN;
1059         sigemptyset (&sa.sa_mask);
1060         sa.sa_flags = 0;
1061         sigaction (SIGPIPE, &sa, NULL);
1062       }
1063 #endif /*!HAVE_W32_SYSTEM*/
1064
1065       handle_connections (fd, opt.ssh_support ? fd_ssh : -1);
1066       close (fd);
1067     }
1068
1069   return 0;
1070 }
1071
1072 void
1073 agent_exit (int rc)
1074 {
1075   /*FIXME: update_random_seed_file();*/
1076 #if 1
1077   /* at this time a bit annoying */
1078   if (opt.debug & DBG_MEMSTAT_VALUE)
1079     {
1080       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1081       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1082     }
1083   if (opt.debug)
1084     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1085 #endif
1086   gcry_control (GCRYCTL_TERM_SECMEM );
1087   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1088   exit (rc);
1089 }
1090
1091
1092 static void
1093 agent_init_default_ctrl (ctrl_t ctrl)
1094 {
1095   ctrl->connection_fd = -1;
1096
1097   /* Note we ignore malloc errors because we can't do much about it
1098      and the request will fail anyway shortly after this
1099      initialization. */
1100   if (ctrl->display)
1101     free (ctrl->display);
1102   ctrl->display = default_display? strdup (default_display) : NULL;
1103
1104   if (ctrl->ttyname)
1105     free (ctrl->ttyname);
1106   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1107
1108   if (ctrl->ttytype)
1109     free (ctrl->ttytype);
1110   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1111
1112   if (ctrl->lc_ctype)
1113     free (ctrl->lc_ctype);
1114   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1115
1116   if (ctrl->lc_messages)
1117     free (ctrl->lc_messages);
1118   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1119 }
1120
1121
1122 static void
1123 agent_deinit_default_ctrl (ctrl_t ctrl)
1124 {
1125   if (ctrl->display)
1126     free (ctrl->display);
1127   if (ctrl->ttyname)
1128     free (ctrl->ttyname);
1129   if (ctrl->ttytype)
1130     free (ctrl->ttytype);
1131   if (ctrl->lc_ctype)
1132     free (ctrl->lc_ctype);
1133   if (ctrl->lc_messages)
1134     free (ctrl->lc_messages);
1135 }
1136
1137 /* Reread parts of the configuration.  Note, that this function is
1138    obviously not thread-safe and should only be called from the PTH
1139    signal handler.
1140
1141    Fixme: Due to the way the argument parsing works, we create a
1142    memory leak here for all string type arguments.  There is currently
1143    no clean way to tell whether the memory for the argument has been
1144    allocated or points into the process' original arguments.  Unless
1145    we have a mechanism to tell this, we need to live on with this. */
1146 static void
1147 reread_configuration (void)
1148 {
1149   ARGPARSE_ARGS pargs;
1150   FILE *fp;
1151   unsigned int configlineno = 0;
1152   int dummy;
1153
1154   if (!config_filename)
1155     return; /* No config file. */
1156
1157   fp = fopen (config_filename, "r");
1158   if (!fp)
1159     {
1160       log_error (_("option file `%s': %s\n"),
1161                  config_filename, strerror(errno) );
1162       return;
1163     }
1164
1165   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1166
1167   memset (&pargs, 0, sizeof pargs);
1168   dummy = 0;
1169   pargs.argc = &dummy;
1170   pargs.flags = 1;  /* do not remove the args */
1171   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1172     {
1173       if (pargs.r_opt < -1)
1174         pargs.err = 1; /* Print a warning. */
1175       else /* Try to parse this option - ignore unchangeable ones. */
1176         parse_rereadable_options (&pargs, 1);
1177     }
1178   fclose (fp);
1179   set_debug ();
1180 }
1181
1182
1183
1184
1185 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1186    true using STANDARD_NAME in the home directory or if given has
1187    false from the mkdir type name TEMPLATE.  In the latter case a
1188    unique name in a unique new directory will be created.  In both
1189    cases check for valid characters as well as against a maximum
1190    allowed length for a unix domain socket is done.  The function
1191    terminates the process in case of an error.  Returns: Pointer to an
1192    allcoated string with the absolute name of the socket used.  */
1193 static char *
1194 create_socket_name (int use_standard_socket,
1195                     char *standard_name, char *template)
1196 {
1197   char *name, *p;
1198
1199   if (use_standard_socket)
1200     name = make_filename (opt.homedir, standard_name, NULL);
1201   else
1202     {
1203       name = xstrdup (template);
1204       p = strrchr (name, '/');
1205       if (!p)
1206         BUG ();
1207       *p = 0;
1208       if (!mkdtemp (name))
1209         {
1210           log_error (_("can't create directory `%s': %s\n"),
1211                      name, strerror (errno));
1212           agent_exit (2);
1213         }
1214       *p = '/';
1215     }
1216
1217   if (strchr (name, PATHSEP_C))
1218     {
1219       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1220       agent_exit (2);
1221     }
1222   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1223     {
1224       log_error (_("name of socket too long\n"));
1225       agent_exit (2);
1226     }
1227   return name;
1228 }
1229
1230
1231
1232 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1233    whether a non-random socket is used.  Returns the filedescriptor or
1234    terminates the process in case of an error. */
1235 static int
1236 create_server_socket (int is_standard_name, const char *name)
1237 {
1238   struct sockaddr_un *serv_addr;
1239   socklen_t len;
1240   int fd;
1241   int rc;
1242
1243 #ifdef HAVE_W32_SYSTEM
1244   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
1245 #else
1246   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1247 #endif
1248   if (fd == -1)
1249     {
1250       log_error (_("can't create socket: %s\n"), strerror (errno));
1251       agent_exit (2);
1252     }
1253
1254   serv_addr = xmalloc (sizeof (*serv_addr));
1255   memset (serv_addr, 0, sizeof *serv_addr);
1256   serv_addr->sun_family = AF_UNIX;
1257   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1258   strcpy (serv_addr->sun_path, name);
1259   len = (offsetof (struct sockaddr_un, sun_path)
1260          + strlen (serv_addr->sun_path) + 1);
1261
1262 #ifdef HAVE_W32_SYSTEM
1263   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1264   if (is_standard_name && rc == -1 )
1265     {
1266       remove (name);
1267       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1268     }
1269 #else
1270   rc = bind (fd, (struct sockaddr*) serv_addr, len);
1271   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1272     {
1273       remove (name);
1274       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1275     }
1276 #endif
1277   if (rc == -1)
1278     {
1279       log_error (_("error binding socket to `%s': %s\n"),
1280                  serv_addr->sun_path, strerror (errno));
1281       close (fd);
1282       agent_exit (2);
1283     }
1284
1285   if (listen (fd, 5 ) == -1)
1286     {
1287       log_error (_("listen() failed: %s\n"), strerror (errno));
1288       close (fd);
1289       agent_exit (2);
1290     }
1291
1292   if (opt.verbose)
1293     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1294
1295   return fd;
1296 }
1297
1298
1299 /* Check that the directory for storing the private keys exists and
1300    create it if not.  This function won't fail as it is only a
1301    convenience function and not strictly necessary.  */
1302 static void
1303 create_private_keys_directory (const char *home)
1304 {
1305   char *fname;
1306   struct stat statbuf;
1307
1308   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1309   if (stat (fname, &statbuf) && errno == ENOENT)
1310     {
1311 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1312       if (!CreateDirectory (fname, NULL))
1313         log_error (_("can't create directory `%s': %s\n"),
1314                    fname, w32_strerror (-1) );
1315 #else
1316       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1317         log_error (_("can't create directory `%s': %s\n"),
1318                    fname, strerror (errno) );
1319 #endif
1320       else if (!opt.quiet)
1321         log_info (_("directory `%s' created\n"), fname);
1322     }
1323   xfree (fname);
1324 }
1325
1326 /* Create the directory only if the supplied directory name is the
1327    same as the default one.  This way we avoid to create arbitrary
1328    directories when a non-default home directory is used.  To cope
1329    with HOME, we compare only the suffix if we see that the default
1330    homedir does start with a tilde.  We don't stop here in case of
1331    problems because other functions will throw an error anyway.*/
1332 static void
1333 create_directories (void)
1334 {
1335   struct stat statbuf;
1336   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1337   char *home;
1338
1339   home = make_filename (opt.homedir, NULL);
1340   if ( stat (home, &statbuf) )
1341     {
1342       if (errno == ENOENT)
1343         {
1344           if ( (*defhome == '~'
1345                 && (strlen (home) >= strlen (defhome+1)
1346                     && !strcmp (home + strlen(home)
1347                                 - strlen (defhome+1), defhome+1)))
1348                || (*defhome != '~' && !strcmp (home, defhome) )
1349                )
1350             {
1351 #ifdef HAVE_W32_SYSTEM
1352               if (!CreateDirectory (home, NULL))
1353                 log_error (_("can't create directory `%s': %s\n"),
1354                            home, w32_strerror (-1) );
1355 #else
1356               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1357                 log_error (_("can't create directory `%s': %s\n"),
1358                            home, strerror (errno) );
1359 #endif
1360               else
1361                 {
1362                   if (!opt.quiet)
1363                     log_info (_("directory `%s' created\n"), home);
1364                   create_private_keys_directory (home);
1365                 }
1366             }
1367         }
1368       else
1369         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1370     }
1371   else if ( !S_ISDIR(statbuf.st_mode))
1372     {
1373       log_error (_("can't use `%s' as home directory\n"), home);
1374     }
1375   else /* exists and is a directory. */
1376     {
1377       create_private_keys_directory (home);
1378     }
1379   xfree (home);
1380 }
1381
1382
1383
1384 /* This is the worker for the ticker.  It is called every few seconds
1385    and may only do fast operations. */
1386 static void
1387 handle_tick (void)
1388 {
1389   /* Check whether the scdaemon has died and cleanup in this case. */
1390   agent_scd_check_aliveness ();
1391
1392   /* If we are running as a child of another process, check whether
1393      the parent is still alive and shutdown if not. */
1394 #ifndef HAVE_W32_SYSTEM
1395   if (parent_pid != (pid_t)(-1))
1396     {
1397       if (kill (parent_pid, 0))
1398         {
1399           shutdown_pending = 2;
1400           log_info ("parent process died - shutting down\n");
1401           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1402           cleanup ();
1403           agent_exit (0);
1404         }
1405     }
1406 #endif /*HAVE_W32_SYSTEM*/
1407 }
1408
1409
1410 static void
1411 handle_signal (int signo)
1412 {
1413   switch (signo)
1414     {
1415 #ifndef HAVE_W32_SYSTEM
1416     case SIGHUP:
1417       log_info ("SIGHUP received - "
1418                 "re-reading configuration and flushing cache\n");
1419       agent_flush_cache ();
1420       reread_configuration ();
1421       agent_reload_trustlist ();
1422       break;
1423
1424     case SIGUSR1:
1425       log_info ("SIGUSR1 received - printing internal information:\n");
1426       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1427       agent_query_dump_state ();
1428       agent_scd_dump_state ();
1429       break;
1430
1431     case SIGUSR2:
1432       if (opt.verbose)
1433         log_info ("SIGUSR2 received - checking smartcard status\n");
1434       /* Nothing to check right now.  We only increment a counter.  */
1435       bump_card_eventcounter ();
1436       break;
1437
1438     case SIGTERM:
1439       if (!shutdown_pending)
1440         log_info ("SIGTERM received - shutting down ...\n");
1441       else
1442         log_info ("SIGTERM received - still %ld running threads\n",
1443                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1444       shutdown_pending++;
1445       if (shutdown_pending > 2)
1446         {
1447           log_info ("shutdown forced\n");
1448           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1449           cleanup ();
1450           agent_exit (0);
1451         }
1452       break;
1453
1454     case SIGINT:
1455       log_info ("SIGINT received - immediate shutdown\n");
1456       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1457       cleanup ();
1458       agent_exit (0);
1459       break;
1460 #endif
1461     default:
1462       log_info ("signal %d received - no action defined\n", signo);
1463     }
1464 }
1465
1466
1467 /* This is the standard connection thread's main function.  */
1468 static void *
1469 start_connection_thread (void *arg)
1470 {
1471   ctrl_t ctrl = arg;
1472
1473   agent_init_default_ctrl (ctrl);
1474   if (opt.verbose)
1475     log_info (_("handler 0x%lx for fd %d started\n"),
1476               (long)pth_self (), ctrl->thread_startup.fd);
1477
1478   start_command_handler (ctrl, -1, ctrl->thread_startup.fd);
1479   if (opt.verbose)
1480     log_info (_("handler 0x%lx for fd %d terminated\n"),
1481               (long)pth_self (), ctrl->thread_startup.fd);
1482
1483   agent_deinit_default_ctrl (ctrl);
1484   xfree (ctrl);
1485   return NULL;
1486 }
1487
1488
1489 /* This is the ssh connection thread's main function.  */
1490 static void *
1491 start_connection_thread_ssh (void *arg)
1492 {
1493   ctrl_t ctrl = arg;
1494
1495   agent_init_default_ctrl (ctrl);
1496   if (opt.verbose)
1497     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1498               (long)pth_self (), ctrl->thread_startup.fd);
1499
1500   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1501   if (opt.verbose)
1502     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1503               (long)pth_self (), ctrl->thread_startup.fd);
1504
1505   agent_deinit_default_ctrl (ctrl);
1506   xfree (ctrl);
1507   return NULL;
1508 }
1509
1510
1511 /* Connection handler loop.  Wait for coecntion requests and spawn a
1512    thread after accepting a connection.  */
1513 static void
1514 handle_connections (int listen_fd, int listen_fd_ssh)
1515 {
1516   pth_attr_t tattr;
1517   pth_event_t ev, time_ev;
1518   sigset_t sigs;
1519   int signo;
1520   struct sockaddr_un paddr;
1521   socklen_t plen;
1522   fd_set fdset, read_fdset;
1523   int ret;
1524   int fd;
1525
1526   tattr = pth_attr_new();
1527   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1528   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1529
1530 #ifndef HAVE_W32_SYSTEM /* fixme */
1531   /* Make sure that the signals we are going to handle are not blocked
1532      and create an event object for them. */
1533   sigemptyset (&sigs );
1534   sigaddset (&sigs, SIGHUP);
1535   sigaddset (&sigs, SIGUSR1);
1536   sigaddset (&sigs, SIGUSR2);
1537   sigaddset (&sigs, SIGINT);
1538   sigaddset (&sigs, SIGTERM);
1539   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1540   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1541 #else
1542   ev = NULL;
1543 #endif
1544   time_ev = NULL;
1545
1546   FD_ZERO (&fdset);
1547   FD_SET (listen_fd, &fdset);
1548   if (listen_fd_ssh != -1)
1549     FD_SET (listen_fd_ssh, &fdset);
1550
1551   for (;;)
1552     {
1553       sigset_t oldsigs;
1554
1555       if (shutdown_pending)
1556         {
1557           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1558             break; /* ready */
1559
1560           /* Do not accept anymore connections and wait for existing
1561              connections to terminate */
1562           signo = 0;
1563           pth_wait (ev);
1564           if (pth_event_occurred (ev) && signo)
1565             handle_signal (signo);
1566           continue;
1567         }
1568
1569       /* Create a timeout event if needed. */
1570       if (!time_ev)
1571         time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
1572
1573       /* POSIX says that fd_set should be implemented as a structure,
1574          thus a simple assignment is fine to copy the entire set.  */
1575       read_fdset = fdset;
1576
1577       if (time_ev)
1578         pth_event_concat (ev, time_ev, NULL);
1579       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1580       if (time_ev)
1581         pth_event_isolate (time_ev);
1582
1583       if (ret == -1)
1584         {
1585           if (pth_event_occurred (ev)
1586               || (time_ev && pth_event_occurred (time_ev)))
1587             {
1588               if (pth_event_occurred (ev))
1589                 handle_signal (signo);
1590               if (time_ev && pth_event_occurred (time_ev))
1591                 {
1592                   pth_event_free (time_ev, PTH_FREE_ALL);
1593                   time_ev = NULL;
1594                   handle_tick ();
1595                 }
1596               continue;
1597             }
1598           log_error (_("pth_select failed: %s - waiting 1s\n"),
1599                      strerror (errno));
1600           pth_sleep (1);
1601           continue;
1602         }
1603
1604       if (pth_event_occurred (ev))
1605         {
1606           handle_signal (signo);
1607         }
1608
1609       if (time_ev && pth_event_occurred (time_ev))
1610         {
1611           pth_event_free (time_ev, PTH_FREE_ALL);
1612           time_ev = NULL;
1613           handle_tick ();
1614         }
1615
1616
1617       /* We now might create new threads and because we don't want any
1618          signals - we are handling here - to be delivered to a new
1619          thread. Thus we need to block those signals. */
1620       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1621
1622       if (FD_ISSET (listen_fd, &read_fdset))
1623         {
1624           ctrl_t ctrl;
1625
1626           plen = sizeof paddr;
1627           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1628           if (fd == -1)
1629             {
1630               log_error ("accept failed: %s\n", strerror (errno));
1631             }
1632           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1633             {
1634               log_error ("error allocating connection control data: %s\n",
1635                          strerror (errno) );
1636               close (fd);
1637             }
1638           else
1639             {
1640               char threadname[50];
1641
1642               snprintf (threadname, sizeof threadname-1,
1643                         "conn fd=%d (gpg)", fd);
1644               threadname[sizeof threadname -1] = 0;
1645               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1646               ctrl->thread_startup.fd = fd;
1647               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1648                 {
1649                   log_error ("error spawning connection handler: %s\n",
1650                              strerror (errno) );
1651                   close (fd);
1652                   xfree (ctrl);
1653                 }
1654             }
1655           fd = -1;
1656         }
1657
1658       if (listen_fd_ssh != -1 && FD_ISSET (listen_fd_ssh, &read_fdset))
1659         {
1660           ctrl_t ctrl;
1661
1662           plen = sizeof paddr;
1663           fd = pth_accept (listen_fd_ssh, (struct sockaddr *)&paddr, &plen);
1664           if (fd == -1)
1665             {
1666               log_error ("accept failed for ssh: %s\n", strerror (errno));
1667             }
1668           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1669             {
1670               log_error ("error allocating connection control data: %s\n",
1671                          strerror (errno) );
1672               close (fd);
1673             }
1674           else
1675             {
1676               char threadname[50];
1677
1678               agent_init_default_ctrl (ctrl);
1679               snprintf (threadname, sizeof threadname-1,
1680                         "conn fd=%d (ssh)", fd);
1681               threadname[sizeof threadname -1] = 0;
1682               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1683               ctrl->thread_startup.fd = fd;
1684               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
1685                 {
1686                   log_error ("error spawning ssh connection handler: %s\n",
1687                              strerror (errno) );
1688                   close (fd);
1689                   xfree (ctrl);
1690                 }
1691             }
1692           fd = -1;
1693         }
1694
1695       /* Restore the signal mask. */
1696       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1697
1698     }
1699
1700   pth_event_free (ev, PTH_FREE_ALL);
1701   if (time_ev)
1702     pth_event_free (time_ev, PTH_FREE_ALL);
1703   cleanup ();
1704   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1705 }
1706
1707
1708 /* Figure out whether an agent is available and running. Prints an
1709    error if not.  Usually started with MODE 0. */
1710 static int
1711 check_for_running_agent (int mode)
1712 {
1713   int rc;
1714   char *infostr, *p;
1715   assuan_context_t ctx;
1716   int prot, pid;
1717
1718   if (!mode)
1719     {
1720       infostr = getenv ("GPG_AGENT_INFO");
1721       if (!infostr || !*infostr)
1722         {
1723           if (!check_for_running_agent (1))
1724             return 0; /* Okay, its running on the standard socket. */
1725           log_error (_("no gpg-agent running in this session\n"));
1726           return -1;
1727         }
1728
1729       infostr = xstrdup (infostr);
1730       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1731         {
1732           xfree (infostr);
1733           if (!check_for_running_agent (1))
1734             return 0; /* Okay, its running on the standard socket. */
1735           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1736           return -1;
1737         }
1738
1739       *p++ = 0;
1740       pid = atoi (p);
1741       while (*p && *p != PATHSEP_C)
1742         p++;
1743       prot = *p? atoi (p+1) : 0;
1744       if (prot != 1)
1745         {
1746           xfree (infostr);
1747           log_error (_("gpg-agent protocol version %d is not supported\n"),
1748                      prot);
1749           if (!check_for_running_agent (1))
1750             return 0; /* Okay, its running on the standard socket. */
1751           return -1;
1752         }
1753     }
1754   else /* MODE != 0 */
1755     {
1756       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1757       pid = (pid_t)(-1);
1758     }
1759
1760
1761   rc = assuan_socket_connect (&ctx, infostr, pid);
1762   xfree (infostr);
1763   if (rc)
1764     {
1765       if (!mode && !check_for_running_agent (1))
1766         return 0; /* Okay, its running on the standard socket. */
1767
1768       if (!mode)
1769         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
1770       return -1;
1771     }
1772
1773   if (!opt.quiet)
1774     log_info ("gpg-agent running and available\n");
1775
1776   assuan_disconnect (ctx);
1777   return 0;
1778 }