agent/gpg-agent.c

   1 /* gpg-agent.c  -  The GnuPG Agent
   2  * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 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
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stddef.h>
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <assert.h>
  30 #include <time.h>
  31 #include <fcntl.h>
  32 #include <sys/stat.h>
  33 #ifndef HAVE_W32_SYSTEM
  34 # include <sys/socket.h>
  35 # include <sys/un.h>
  36 #endif /*!HAVE_W32_SYSTEM*/
  37 #include <unistd.h>
  38 #ifdef HAVE_SIGNAL_H
  39 # include <signal.h>
  40 #endif
  41 #include <pth.h>
  42
  43 #define JNLIB_NEED_LOG_LOGV
  44 #define JNLIB_NEED_AFLOCAL
  45 #include "agent.h"
  46 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
  47
  48 #include "i18n.h"
  49 #include "mkdtemp.h" /* Gnulib replacement. */
  50 #include "sysutils.h"
  51 #include "gc-opt-flags.h"
  52 #include "exechelp.h"
  53 #include "asshelp.h"
  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   aUseStandardSocketP,
  66   oOptions,
  67   oDebug,
  68   oDebugAll,
  69   oDebugLevel,
  70   oDebugWait,
  71   oNoGreeting,
  72   oNoOptions,
  73   oHomedir,
  74   oNoDetach,
  75   oNoGrab,
  76   oLogFile,
  77   oServer,
  78   oDaemon,
  79   oBatch,
  80
  81   oPinentryProgram,
  82   oPinentryTouchFile,
  83   oDisplay,
  84   oTTYname,
  85   oTTYtype,
  86   oLCctype,
  87   oLCmessages,
  88   oXauthority,
  89   oScdaemonProgram,
  90   oDefCacheTTL,
  91   oDefCacheTTLSSH,
  92   oMaxCacheTTL,
  93   oMaxCacheTTLSSH,
  94   oEnforcePassphraseConstraints,
  95   oMinPassphraseLen,
  96   oMinPassphraseNonalpha,
  97   oCheckPassphrasePattern,
  98   oMaxPassphraseDays,
  99   oEnablePassphraseHistory,
 100   oUseStandardSocket,
 101   oNoUseStandardSocket,
 102   oFakedSystemTime,
 103
 104   oIgnoreCacheForSigning,
 105   oAllowMarkTrusted,
 106   oAllowPresetPassphrase,
 107   oKeepTTY,
 108   oKeepDISPLAY,
 109   oSSHSupport,
 110   oDisableScdaemon,
 111   oWriteEnvFile
 112 };
 113
 114
 115
 116 static ARGPARSE_OPTS opts[] = {
 117
 118   { aGPGConfList, "gpgconf-list", 256, "@" },
 119   { aGPGConfTest, "gpgconf-test", 256, "@" },
 120   { aUseStandardSocketP, "use-standard-socket-p", 256, "@" },
 121
 122   { 301, NULL, 0, N_("@Options:\n ") },
 123
 124   { oServer,   "server",     0, N_("run in server mode (foreground)") },
 125   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
 126   { oVerbose, "verbose",     0, N_("verbose") },
 127   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
 128   { oSh,        "sh",        0, N_("sh-style command output") },
 129   { oCsh,       "csh",       0, N_("csh-style command output") },
 130   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
 131   { oDebug,     "debug"     ,4|16, "@"},
 132   { oDebugAll, "debug-all"     ,0, "@"},
 133   { oDebugLevel, "debug-level" ,2, "@"},
 134   { oDebugWait,"debug-wait",1, "@"},
 135   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
 136   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
 137   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
 138   { oUseStandardSocket, "use-standard-socket", 0,
 139                       N_("use a standard location for the socket")},
 140   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
 141   { oPinentryProgram, "pinentry-program", 2 ,
 142                                N_("|PGM|use PGM as the PIN-Entry program") },
 143   { oPinentryTouchFile, "pinentry-touch-file", 2 , "@" },
 144   { oScdaemonProgram, "scdaemon-program", 2 ,
 145                                N_("|PGM|use PGM as the SCdaemon program") },
 146   { oDisableScdaemon, "disable-scdaemon", 0, N_("do not use the SCdaemon") },
 147   { oFakedSystemTime, "faked-system-time", 2, "@" }, /* (epoch time) */
 148
 149   { oBatch,      "batch",       0, "@" },
 150   { oHomedir,    "homedir",     2, "@"},
 151
 152   { oDisplay,    "display",     2, "@" },
 153   { oTTYname,    "ttyname",     2, "@" },
 154   { oTTYtype,    "ttytype",     2, "@" },
 155   { oLCctype,    "lc-ctype",    2, "@" },
 156   { oLCmessages, "lc-messages", 2, "@" },
 157   { oXauthority, "xauthority",  2, "@" },
 158   { oKeepTTY,    "keep-tty",    0,  N_("ignore requests to change the TTY")},
 159   { oKeepDISPLAY, "keep-display",
 160                           0, N_("ignore requests to change the X display")},
 161
 162   { oDefCacheTTL, "default-cache-ttl", 4,
 163                                N_("|N|expire cached PINs after N seconds")},
 164   { oDefCacheTTLSSH, "default-cache-ttl-ssh", 4, "@" },
 165   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
 166   { oMaxCacheTTLSSH, "max-cache-ttl-ssh", 4, "@" },
 167
 168   { oEnforcePassphraseConstraints, "enforce-passphrase-constraints", 0, "@"},
 169   { oMinPassphraseLen, "min-passphrase-len", 4, "@" },
 170   { oMinPassphraseNonalpha, "min-passphrase-nonalpha", 4, "@" },
 171   { oCheckPassphrasePattern, "check-passphrase-pattern", 2, "@" },
 172   { oMaxPassphraseDays, "max-passphrase-days", 4, "@" },
 173   { oEnablePassphraseHistory, "enable-passphrase-history", 0, "@" },
 174
 175   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
 176                                N_("do not use the PIN cache when signing")},
 177   { oAllowMarkTrusted, "allow-mark-trusted", 0,
 178                              N_("allow clients to mark keys as \"trusted\"")},
 179   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
 180                              N_("allow presetting passphrase")},
 181   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
 182   { oWriteEnvFile, "write-env-file", 2|8,
 183             N_("|FILE|write environment settings also to FILE")},
 184   {0}
 185 };
 186
 187
 188 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
 189 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
 190 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
 191 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
 192 #define MIN_PASSPHRASE_LEN    (8)
 193 #define MIN_PASSPHRASE_NONALPHA (1)
 194 #define MAX_PASSPHRASE_DAYS   (0)
 195
 196 /* The timer tick used for housekeeping stuff.  For Windows we use a
 197    longer period as the SetWaitableTimer seems to signal earlier than
 198    the 2 seconds.  */
 199 #ifdef HAVE_W32_SYSTEM
 200 #define TIMERTICK_INTERVAL    (4)
 201 #else
 202 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
 203 #endif
 204
 205
 206 /* The list of open file descriptors at startup.  Note that this list
 207    has been allocated using the standard malloc.  */
 208 static int *startup_fd_list;
 209
 210 /* The signal mask at startup and a flag telling whether it is valid.  */
 211 #ifdef HAVE_SIGPROCMASK
 212 static sigset_t startup_signal_mask;
 213 static int startup_signal_mask_valid;
 214 #endif
 215
 216 /* Flag to indicate that a shutdown was requested.  */
 217 static int shutdown_pending;
 218
 219 /* Counter for the currently running own socket checks.  */
 220 static int check_own_socket_running;
 221
 222 /* It is possible that we are currently running under setuid permissions */
 223 static int maybe_setuid = 1;
 224
 225 /* Name of the communication socket used for native gpg-agent requests.  */
 226 static char *socket_name;
 227
 228 /* Name of the communication socket used for ssh-agent-emulation.  */
 229 static char *socket_name_ssh;
 230
 231 /* We need to keep track of the server's nonces (these are dummies for
 232    POSIX systems). */
 233 static assuan_sock_nonce_t socket_nonce;
 234 static assuan_sock_nonce_t socket_nonce_ssh;
 235
 236
 237 /* Default values for options passed to the pinentry. */
 238 static char *default_display;
 239 static char *default_ttyname;
 240 static char *default_ttytype;
 241 static char *default_lc_ctype;
 242 static char *default_lc_messages;
 243 static char *default_xauthority;
 244
 245 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
 246 static char *config_filename;
 247
 248 /* Helper to implement --debug-level */
 249 static const char *debug_level;
 250
 251 /* Keep track of the current log file so that we can avoid updating
 252    the log file after a SIGHUP if it didn't changed. Malloced. */
 253 static char *current_logfile;
 254
 255 /* The handle_tick() function may test whether a parent is still
 256    running.  We record the PID of the parent here or -1 if it should be
 257    watched. */
 258 static pid_t parent_pid = (pid_t)(-1);
 259
 260 \f
 261 /*
 262    Local prototypes.
 263  */
 264
 265 static char *create_socket_name (char *standard_name, char *template);
 266 static gnupg_fd_t create_server_socket (char *name, int is_ssh,
 267                                         assuan_sock_nonce_t *nonce);
 268 static void create_directories (void);
 269
 270 static void agent_init_default_ctrl (ctrl_t ctrl);
 271 static void agent_deinit_default_ctrl (ctrl_t ctrl);
 272
 273 static void handle_connections (gnupg_fd_t listen_fd,
 274                                 gnupg_fd_t listen_fd_ssh);
 275 static void check_own_socket (void);
 276 static int check_for_running_agent (int silent, int mode);
 277
 278 /* Pth wrapper function definitions. */
 279 ASSUAN_SYSTEM_PTH_IMPL;
 280
 281 GCRY_THREAD_OPTION_PTH_IMPL;
 282 static int fixed_gcry_pth_init (void)
 283 {
 284   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
 285 }
 286
 287
 288 #ifndef PTH_HAVE_PTH_THREAD_ID
 289 static unsigned long pth_thread_id (void)
 290 {
 291   return (unsigned long)pth_self ();
 292 }
 293 #endif
 294
 295
 296 \f
 297 /*
 298    Functions.
 299  */
 300
 301 static char *
 302 make_libversion (const char *libname, const char *(*getfnc)(const char*))
 303 {
 304   const char *s;
 305   char *result;
 306
 307   if (maybe_setuid)
 308     {
 309       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
 310       maybe_setuid = 0;
 311     }
 312   s = getfnc (NULL);
 313   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
 314   strcpy (stpcpy (stpcpy (result, libname), " "), s);
 315   return result;
 316 }
 317
 318
 319 static const char *
 320 my_strusage (int level)
 321 {
 322   static char *ver_gcry;
 323   const char *p;
 324
 325   switch (level)
 326     {
 327     case 11: p = "gpg-agent (GnuPG)";
 328       break;
 329     case 13: p = VERSION; break;
 330     case 17: p = PRINTABLE_OS_NAME; break;
 331       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
 332          reporting address.  This is so that we can change the
 333          reporting address without breaking the translations.  */
 334     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 335
 336     case 20:
 337       if (!ver_gcry)
 338         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
 339       p = ver_gcry;
 340       break;
 341
 342     case 1:
 343     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
 344       break;
 345     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
 346                     "Secret key management for GnuPG\n");
 347     break;
 348
 349     default: p = NULL;
 350     }
 351   return p;
 352 }
 353
 354
 355
 356 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
 357    only the active debug flags are propagated to the subsystems.  With
 358    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
 359    all flags already set. Note that we don't fail here, because it is
 360    important to keep gpg-agent running even after re-reading the
 361    options due to a SIGHUP. */
 362 static void
 363 set_debug (void)
 364 {
 365   int numok = (debug_level && digitp (debug_level));
 366   int numlvl = numok? atoi (debug_level) : 0;
 367
 368   if (!debug_level)
 369     ;
 370   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
 371     opt.debug = 0;
 372   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
 373     opt.debug = DBG_ASSUAN_VALUE;
 374   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
 375     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
 376   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
 377     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
 378                  |DBG_CACHE_VALUE);
 379   else if (!strcmp (debug_level, "guru") || numok)
 380     {
 381       opt.debug = ~0;
 382       /* Unless the "guru" string has been used we don't want to allow
 383          hashing debugging.  The rationale is that people tend to
 384          select the highest debug value and would then clutter their
 385          disk with debug files which may reveal confidential data.  */
 386       if (numok)
 387         opt.debug &= ~(DBG_HASHING_VALUE);
 388     }
 389   else
 390     {
 391       log_error (_("invalid debug-level `%s' given\n"), debug_level);
 392       opt.debug = 0; /* Reset debugging, so that prior debug
 393                         statements won't have an undesired effect. */
 394     }
 395
 396   if (opt.debug && !opt.verbose)
 397     opt.verbose = 1;
 398   if (opt.debug && opt.quiet)
 399     opt.quiet = 0;
 400
 401   if (opt.debug & DBG_MPI_VALUE)
 402     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
 403   if (opt.debug & DBG_CRYPTO_VALUE )
 404     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
 405   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 406
 407   if (opt.debug)
 408     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s\n",
 409               (opt.debug & DBG_COMMAND_VALUE)? " command":"",
 410               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",
 411               (opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",
 412               (opt.debug & DBG_MEMORY_VALUE )? " memory":"",
 413               (opt.debug & DBG_CACHE_VALUE  )? " cache":"",
 414               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"",
 415               (opt.debug & DBG_HASHING_VALUE)? " hashing":"",
 416               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
 417 }
 418
 419
 420 /* Helper for cleanup to remove one socket with NAME.  */
 421 static void
 422 remove_socket (char *name)
 423 {
 424   if (name && *name)
 425     {
 426       char *p;
 427
 428       gnupg_remove (name);
 429       p = strrchr (name, '/');
 430       if (p)
 431         {
 432           *p = 0;
 433           rmdir (name);
 434           *p = '/';
 435         }
 436       *name = 0;
 437     }
 438 }
 439
 440 static void
 441 cleanup (void)
 442 {
 443   static int done;
 444
 445   if (done)
 446     return;
 447   done = 1;
 448   deinitialize_module_cache ();
 449   remove_socket (socket_name);
 450   remove_socket (socket_name_ssh);
 451 }
 452
 453
 454
 455 /* Handle options which are allowed to be reset after program start.
 456    Return true when the current option in PARGS could be handled and
 457    false if not.  As a special feature, passing a value of NULL for
 458    PARGS, resets the options to the default.  REREAD should be set
 459    true if it is not the initial option parsing. */
 460 static int
 461 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
 462 {
 463   if (!pargs)
 464     { /* reset mode */
 465       opt.quiet = 0;
 466       opt.verbose = 0;
 467       opt.debug = 0;
 468       opt.no_grab = 0;
 469       opt.pinentry_program = NULL;
 470       opt.pinentry_touch_file = NULL;
 471       opt.scdaemon_program = NULL;
 472       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
 473       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
 474       opt.max_cache_ttl = MAX_CACHE_TTL;
 475       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
 476       opt.enforce_passphrase_constraints = 0;
 477       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
 478       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
 479       opt.check_passphrase_pattern = NULL;
 480       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
 481       opt.enable_passhrase_history = 0;
 482       opt.ignore_cache_for_signing = 0;
 483       opt.allow_mark_trusted = 0;
 484       opt.disable_scdaemon = 0;
 485       return 1;
 486     }
 487
 488   switch (pargs->r_opt)
 489     {
 490     case oQuiet: opt.quiet = 1; break;
 491     case oVerbose: opt.verbose++; break;
 492
 493     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
 494     case oDebugAll: opt.debug = ~0; break;
 495     case oDebugLevel: debug_level = pargs->r.ret_str; break;
 496
 497     case oLogFile:
 498       if (!reread)
 499         return 0; /* not handeld */
 500       if (!current_logfile || !pargs->r.ret_str
 501           || strcmp (current_logfile, pargs->r.ret_str))
 502         {
 503           log_set_file (pargs->r.ret_str);
 504           xfree (current_logfile);
 505           current_logfile = xtrystrdup (pargs->r.ret_str);
 506         }
 507       break;
 508
 509     case oNoGrab: opt.no_grab = 1; break;
 510
 511     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
 512     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
 513     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
 514     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
 515
 516     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
 517     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
 518     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
 519     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
 520
 521     case oEnforcePassphraseConstraints:
 522       opt.enforce_passphrase_constraints=1;
 523       break;
 524     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
 525     case oMinPassphraseNonalpha:
 526       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
 527       break;
 528     case oCheckPassphrasePattern:
 529       opt.check_passphrase_pattern = pargs->r.ret_str;
 530       break;
 531     case oMaxPassphraseDays:
 532       opt.max_passphrase_days = pargs->r.ret_ulong;
 533       break;
 534     case oEnablePassphraseHistory:
 535       opt.enable_passhrase_history = 1;
 536       break;
 537
 538     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
 539
 540     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
 541
 542     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
 543
 544     default:
 545       return 0; /* not handled */
 546     }
 547
 548   return 1; /* handled */
 549 }
 550
 551
 552 /* The main entry point.  */
 553 int
 554 main (int argc, char **argv )
 555 {
 556   ARGPARSE_ARGS pargs;
 557   int orig_argc;
 558   int may_coredump;
 559   char **orig_argv;
 560   FILE *configfp = NULL;
 561   char *configname = NULL;
 562   const char *shell;
 563   unsigned configlineno;
 564   int parse_debug = 0;
 565   int default_config =1;
 566   int greeting = 0;
 567   int nogreeting = 0;
 568   int pipe_server = 0;
 569   int is_daemon = 0;
 570   int nodetach = 0;
 571   int csh_style = 0;
 572   char *logfile = NULL;
 573   int debug_wait = 0;
 574   int gpgconf_list = 0;
 575   gpg_error_t err;
 576   const char *env_file_name = NULL;
 577   struct assuan_malloc_hooks malloc_hooks;
 578
 579   /* Before we do anything else we save the list of currently open
 580      file descriptors and the signal mask.  This info is required to
 581      do the exec call properly. */
 582   startup_fd_list = get_all_open_fds ();
 583 #ifdef HAVE_SIGPROCMASK
 584   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
 585     startup_signal_mask_valid = 1;
 586 #endif /*HAVE_SIGPROCMASK*/
 587
 588   /* Set program name etc.  */
 589   set_strusage (my_strusage);
 590   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 591   /* Please note that we may running SUID(ROOT), so be very CAREFUL
 592      when adding any stuff between here and the call to INIT_SECMEM()
 593      somewhere after the option parsing */
 594   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID);
 595
 596   /* Make sure that our subsystems are ready.  */
 597   i18n_init ();
 598   init_common_subsystems (&argc, &argv);
 599
 600
 601   /* Libgcrypt requires us to register the threading model first.
 602      Note that this will also do the pth_init. */
 603   gcry_threads_pth.init = fixed_gcry_pth_init;
 604   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
 605   if (err)
 606     {
 607       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
 608                  gpg_strerror (err));
 609     }
 610
 611
 612   /* Check that the libraries are suitable.  Do it here because
 613      the option parsing may need services of the library. */
 614   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
 615     {
 616       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
 617                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
 618     }
 619
 620   malloc_hooks.malloc = gcry_malloc;
 621   malloc_hooks.realloc = gcry_realloc;
 622   malloc_hooks.free = gcry_free;
 623   assuan_set_malloc_hooks (&malloc_hooks);
 624   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
 625   assuan_set_system_hooks (ASSUAN_SYSTEM_PTH);
 626   assuan_sock_init ();
 627   setup_libassuan_logging (&opt.debug);
 628
 629   setup_libgcrypt_logging ();
 630   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
 631
 632   may_coredump = disable_core_dumps ();
 633
 634   /* Set default options.  */
 635   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
 636 #ifdef USE_STANDARD_SOCKET
 637   opt.use_standard_socket = 1;
 638 #endif
 639
 640   shell = getenv ("SHELL");
 641   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
 642     csh_style = 1;
 643
 644   opt.homedir = default_homedir ();
 645
 646   /* Record some of the original environment strings. */
 647   {
 648     const char *s;
 649     int idx;
 650     static const char *names[] =
 651       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
 652
 653     err = 0;
 654     opt.startup_env = session_env_new ();
 655     if (!opt.startup_env)
 656       err = gpg_error_from_syserror ();
 657     for (idx=0; !err && names[idx]; idx++)
 658       {
 659         s = getenv (names[idx]);
 660         if (s)
 661           err = session_env_setenv (opt.startup_env, names[idx], s);
 662       }
 663     if (!err)
 664       {
 665         s = ttyname (0);
 666         if (s)
 667           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
 668       }
 669     if (err)
 670       log_fatal ("error recording startup environment: %s\n",
 671                  gpg_strerror (err));
 672
 673     /* Fixme: Better use the locale function here.  */
 674     opt.startup_lc_ctype = getenv ("LC_CTYPE");
 675     if (opt.startup_lc_ctype)
 676       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
 677     opt.startup_lc_messages = getenv ("LC_MESSAGES");
 678     if (opt.startup_lc_messages)
 679       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
 680   }
 681
 682   /* Check whether we have a config file on the commandline */
 683   orig_argc = argc;
 684   orig_argv = argv;
 685   pargs.argc = &argc;
 686   pargs.argv = &argv;
 687   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
 688   while (arg_parse( &pargs, opts))
 689     {
 690       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
 691         parse_debug++;
 692       else if (pargs.r_opt == oOptions)
 693         { /* yes there is one, so we do not try the default one, but
 694              read the option file when it is encountered at the
 695              commandline */
 696           default_config = 0;
 697         }
 698         else if (pargs.r_opt == oNoOptions)
 699           default_config = 0; /* --no-options */
 700         else if (pargs.r_opt == oHomedir)
 701           opt.homedir = pargs.r.ret_str;
 702     }
 703
 704   /* Initialize the secure memory. */
 705   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
 706   maybe_setuid = 0;
 707
 708   /*
 709      Now we are now working under our real uid
 710   */
 711
 712   if (default_config)
 713     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
 714
 715   argc = orig_argc;
 716   argv = orig_argv;
 717   pargs.argc = &argc;
 718   pargs.argv = &argv;
 719   pargs.flags=  1;  /* do not remove the args */
 720  next_pass:
 721   if (configname)
 722     {
 723       configlineno = 0;
 724       configfp = fopen (configname, "r");
 725       if (!configfp)
 726         {
 727           if (default_config)
 728             {
 729               if( parse_debug )
 730                 log_info (_("NOTE: no default option file `%s'\n"),
 731                           configname );
 732               /* Save the default conf file name so that
 733                  reread_configuration is able to test whether the
 734                  config file has been created in the meantime.  */
 735               xfree (config_filename);
 736               config_filename = configname;
 737               configname = NULL;
 738             }
 739           else
 740             {
 741               log_error (_("option file `%s': %s\n"),
 742                          configname, strerror(errno) );
 743               exit(2);
 744             }
 745           xfree (configname);
 746           configname = NULL;
 747         }
 748       if (parse_debug && configname )
 749         log_info (_("reading options from `%s'\n"), configname );
 750       default_config = 0;
 751     }
 752
 753   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
 754     {
 755       if (parse_rereadable_options (&pargs, 0))
 756         continue; /* Already handled */
 757       switch (pargs.r_opt)
 758         {
 759         case aGPGConfList: gpgconf_list = 1; break;
 760         case aGPGConfTest: gpgconf_list = 2; break;
 761         case aUseStandardSocketP: gpgconf_list = 3; break;
 762         case oBatch: opt.batch=1; break;
 763
 764         case oDebugWait: debug_wait = pargs.r.ret_int; break;
 765
 766         case oOptions:
 767           /* config files may not be nested (silently ignore them) */
 768           if (!configfp)
 769             {
 770                 xfree(configname);
 771                 configname = xstrdup(pargs.r.ret_str);
 772                 goto next_pass;
 773             }
 774           break;
 775         case oNoGreeting: nogreeting = 1; break;
 776         case oNoVerbose: opt.verbose = 0; break;
 777         case oNoOptions: break; /* no-options */
 778         case oHomedir: opt.homedir = pargs.r.ret_str; break;
 779         case oNoDetach: nodetach = 1; break;
 780         case oLogFile: logfile = pargs.r.ret_str; break;
 781         case oCsh: csh_style = 1; break;
 782         case oSh: csh_style = 0; break;
 783         case oServer: pipe_server = 1; break;
 784         case oDaemon: is_daemon = 1; break;
 785
 786         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
 787         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
 788         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
 789         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
 790         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
 791         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
 792           break;
 793
 794         case oUseStandardSocket:   opt.use_standard_socket = 1; break;
 795         case oNoUseStandardSocket: opt.use_standard_socket = 0; break;
 796
 797         case oFakedSystemTime:
 798           {
 799             time_t faked_time = isotime2epoch (pargs.r.ret_str);
 800             if (faked_time == (time_t)(-1))
 801               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
 802             gnupg_set_time (faked_time, 0);
 803           }
 804           break;
 805
 806         case oKeepTTY: opt.keep_tty = 1; break;
 807         case oKeepDISPLAY: opt.keep_display = 1; break;
 808
 809         case oSSHSupport:  opt.ssh_support = 1; break;
 810         case oWriteEnvFile:
 811           if (pargs.r_type)
 812             env_file_name = pargs.r.ret_str;
 813           else
 814             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
 815           break;
 816
 817         default : pargs.err = configfp? 1:2; break;
 818         }
 819     }
 820   if (configfp)
 821     {
 822       fclose( configfp );
 823       configfp = NULL;
 824       /* Keep a copy of the name so that it can be read on SIGHUP. */
 825       if (config_filename != configname)
 826         {
 827           xfree (config_filename);
 828           config_filename = configname;
 829         }
 830       configname = NULL;
 831       goto next_pass;
 832     }
 833
 834   xfree (configname);
 835   configname = NULL;
 836   if (log_get_errorcount(0))
 837     exit(2);
 838   if (nogreeting )
 839     greeting = 0;
 840
 841   if (greeting)
 842     {
 843       es_fprintf (es_stderr, "%s %s; %s\n",
 844                   strusage(11), strusage(13), strusage(14) );
 845       es_fprintf (es_stderr, "%s\n", strusage(15) );
 846     }
 847 #ifdef IS_DEVELOPMENT_VERSION
 848   /* We don't want to print it here because gpg-agent is useful of its
 849      own and quite matured.  */
 850   /*log_info ("NOTE: this is a development version!\n");*/
 851 #endif
 852
 853   set_debug ();
 854
 855   if (atexit (cleanup))
 856     {
 857       log_error ("atexit failed\n");
 858       cleanup ();
 859       exit (1);
 860     }
 861
 862   initialize_module_cache ();
 863   initialize_module_call_pinentry ();
 864   initialize_module_call_scd ();
 865   initialize_module_trustlist ();
 866
 867   /* Try to create missing directories. */
 868   create_directories ();
 869
 870   if (debug_wait && pipe_server)
 871     {
 872       log_debug ("waiting for debugger - my pid is %u .....\n",
 873                  (unsigned int)getpid());
 874       gnupg_sleep (debug_wait);
 875       log_debug ("... okay\n");
 876     }
 877
 878   if (gpgconf_list == 3)
 879     {
 880       if (opt.use_standard_socket && !opt.quiet)
 881         log_info ("configured to use the standard socket\n");
 882       agent_exit (!opt.use_standard_socket);
 883     }
 884   else if (gpgconf_list == 2)
 885     agent_exit (0);
 886   else if (gpgconf_list)
 887     {
 888       char *filename;
 889       char *filename_esc;
 890
 891       /* List options and default values in the GPG Conf format.  */
 892       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
 893       filename_esc = percent_escape (filename, NULL);
 894
 895       es_printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
 896               GC_OPT_FLAG_DEFAULT, filename_esc);
 897       xfree (filename);
 898       xfree (filename_esc);
 899
 900       es_printf ("verbose:%lu:\n"
 901               "quiet:%lu:\n"
 902               "debug-level:%lu:\"none:\n"
 903               "log-file:%lu:\n",
 904               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
 905               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
 906               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
 907               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
 908       es_printf ("default-cache-ttl:%lu:%d:\n",
 909               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
 910       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
 911               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
 912       es_printf ("max-cache-ttl:%lu:%d:\n",
 913               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
 914       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
 915               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
 916       es_printf ("enforce-passphrase-constraints:%lu:\n",
 917               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 918       es_printf ("min-passphrase-len:%lu:%d:\n",
 919               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
 920       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
 921               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
 922               MIN_PASSPHRASE_NONALPHA);
 923       es_printf ("check-passphrase-pattern:%lu:\n",
 924               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
 925       es_printf ("max-passphrase-days:%lu:%d:\n",
 926               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
 927               MAX_PASSPHRASE_DAYS);
 928       es_printf ("enable-passphrase-history:%lu:\n",
 929               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 930       es_printf ("no-grab:%lu:\n",
 931               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 932       es_printf ("ignore-cache-for-signing:%lu:\n",
 933               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 934       es_printf ("allow-mark-trusted:%lu:\n",
 935               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 936       es_printf ("disable-scdaemon:%lu:\n",
 937               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
 938
 939       agent_exit (0);
 940     }
 941
 942   /* If this has been called without any options, we merely check
 943      whether an agent is already running.  We do this here so that we
 944      don't clobber a logfile but print it directly to stderr. */
 945   if (!pipe_server && !is_daemon)
 946     {
 947       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
 948       check_for_running_agent (0, 0);
 949       agent_exit (0);
 950     }
 951
 952 #ifdef ENABLE_NLS
 953   /* gpg-agent usually does not output any messages because it runs in
 954      the background.  For log files it is acceptable to have messages
 955      always encoded in utf-8.  We switch here to utf-8, so that
 956      commands like --help still give native messages.  It is far
 957      easier to switch only once instead of for every message and it
 958      actually helps when more then one thread is active (avoids an
 959      extra copy step). */
 960     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
 961 #endif
 962
 963   /* Now start with logging to a file if this is desired. */
 964   if (logfile)
 965     {
 966       log_set_file (logfile);
 967       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
 968                              |JNLIB_LOG_WITH_TIME
 969                              |JNLIB_LOG_WITH_PID));
 970       current_logfile = xstrdup (logfile);
 971     }
 972
 973   /* Make sure that we have a default ttyname. */
 974   if (!default_ttyname && ttyname (1))
 975     default_ttyname = xstrdup (ttyname (1));
 976   if (!default_ttytype && getenv ("TERM"))
 977     default_ttytype = xstrdup (getenv ("TERM"));
 978
 979
 980   if (pipe_server)
 981     {
 982       /* This is the simple pipe based server */
 983       ctrl_t ctrl;
 984
 985       ctrl = xtrycalloc (1, sizeof *ctrl);
 986       if (!ctrl)
 987         {
 988           log_error ("error allocating connection control data: %s\n",
 989                      strerror (errno) );
 990           agent_exit (1);
 991         }
 992       ctrl->session_env = session_env_new ();
 993       if (!ctrl->session_env)
 994         {
 995           log_error ("error allocating session environment block: %s\n",
 996                      strerror (errno) );
 997           xfree (ctrl);
 998           agent_exit (1);
 999         }
1000       agent_init_default_ctrl (ctrl);
1001       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1002       agent_deinit_default_ctrl (ctrl);
1003       xfree (ctrl);
1004     }
1005   else if (!is_daemon)
1006     ; /* NOTREACHED */
1007   else
1008     { /* Regular server mode */
1009       gnupg_fd_t fd;
1010       gnupg_fd_t fd_ssh;
1011       pid_t pid;
1012
1013       /* Remove the DISPLAY variable so that a pinentry does not
1014          default to a specific display.  There is still a default
1015          display when gpg-agent was started using --display or a
1016          client requested this using an OPTION command.  Note, that we
1017          don't do this when running in reverse daemon mode (i.e. when
1018          exec the program given as arguments). */
1019 #ifndef HAVE_W32_SYSTEM
1020       if (!opt.keep_display && !argc)
1021         gnupg_unsetenv ("DISPLAY");
1022 #endif
1023
1024
1025       /* Create the sockets.  */
1026       socket_name = create_socket_name
1027         ("S.gpg-agent", "/tmp/gpg-XXXXXX/S.gpg-agent");
1028       if (opt.ssh_support)
1029         socket_name_ssh = create_socket_name
1030           ("S.gpg-agent.ssh", "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
1031
1032       fd = create_server_socket (socket_name, 0, &socket_nonce);
1033       if (opt.ssh_support)
1034         fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1035       else
1036         fd_ssh = GNUPG_INVALID_FD;
1037
1038       /* If we are going to exec a program in the parent, we record
1039          the PID, so that the child may check whether the program is
1040          still alive. */
1041       if (argc)
1042         parent_pid = getpid ();
1043
1044       fflush (NULL);
1045 #ifdef HAVE_W32_SYSTEM
1046       pid = getpid ();
1047       es_printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
1048 #else /*!HAVE_W32_SYSTEM*/
1049       pid = fork ();
1050       if (pid == (pid_t)-1)
1051         {
1052           log_fatal ("fork failed: %s\n", strerror (errno) );
1053           exit (1);
1054         }
1055       else if (pid)
1056         { /* We are the parent */
1057           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
1058
1059           /* Close the socket FD. */
1060           close (fd);
1061
1062           /* Note that we used a standard fork so that Pth runs in
1063              both the parent and the child.  The pth_fork would
1064              terminate Pth in the child but that is not the way we
1065              want it.  Thus we use a plain fork and terminate Pth here
1066              in the parent.  The pth_kill may or may not work reliable
1067              but it should not harm to call it.  Because Pth fiddles
1068              with the signal mask the signal mask might not be correct
1069              right now and thus we restore it.  That is not strictly
1070              necessary but some programs falsely assume a cleared
1071              signal mask.  */
1072           if ( !pth_kill () )
1073             log_error ("pth_kill failed in forked process\n");
1074
1075 #ifdef HAVE_SIGPROCMASK
1076           if (startup_signal_mask_valid)
1077             {
1078               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1079                 log_error ("error restoring signal mask: %s\n",
1080                            strerror (errno));
1081             }
1082           else
1083             log_info ("no saved signal mask\n");
1084 #endif /*HAVE_SIGPROCMASK*/
1085
1086           /* Create the info string: <name>:<pid>:<protocol_version> */
1087           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
1088                         socket_name, (ulong)pid ) < 0)
1089             {
1090               log_error ("out of core\n");
1091               kill (pid, SIGTERM);
1092               exit (1);
1093             }
1094           if (opt.ssh_support)
1095             {
1096               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1097                             socket_name_ssh) < 0)
1098                 {
1099                   log_error ("out of core\n");
1100                   kill (pid, SIGTERM);
1101                   exit (1);
1102                 }
1103               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
1104                             pid) < 0)
1105                 {
1106                   log_error ("out of core\n");
1107                   kill (pid, SIGTERM);
1108                   exit (1);
1109                 }
1110             }
1111
1112           *socket_name = 0; /* Don't let cleanup() remove the socket -
1113                                the child should do this from now on */
1114           if (opt.ssh_support)
1115             *socket_name_ssh = 0;
1116
1117           if (env_file_name)
1118             {
1119               estream_t fp;
1120
1121               fp = es_fopen (env_file_name, "w,mode=-rw");
1122               if (!fp)
1123                 log_error (_("error creating `%s': %s\n"),
1124                              env_file_name, strerror (errno));
1125               else
1126                 {
1127                   es_fputs (infostr, fp);
1128                   es_putc ('\n', fp);
1129                   if (opt.ssh_support)
1130                     {
1131                       es_fputs (infostr_ssh_sock, fp);
1132                       es_putc ('\n', fp);
1133                       es_fputs (infostr_ssh_pid, fp);
1134                       es_putc ('\n', fp);
1135                     }
1136                   es_fclose (fp);
1137                 }
1138             }
1139
1140
1141           if (argc)
1142             { /* Run the program given on the commandline.  */
1143               if (putenv (infostr))
1144                 {
1145                   log_error ("failed to set environment: %s\n",
1146                              strerror (errno) );
1147                   kill (pid, SIGTERM );
1148                   exit (1);
1149                 }
1150               if (opt.ssh_support && putenv (infostr_ssh_sock))
1151                 {
1152                   log_error ("failed to set environment: %s\n",
1153                              strerror (errno) );
1154                   kill (pid, SIGTERM );
1155                   exit (1);
1156                 }
1157               if (opt.ssh_support && putenv (infostr_ssh_pid))
1158                 {
1159                   log_error ("failed to set environment: %s\n",
1160                              strerror (errno) );
1161                   kill (pid, SIGTERM );
1162                   exit (1);
1163                 }
1164
1165               /* Close all the file descriptors except the standard
1166                  ones and those open at startup.  We explicitly don't
1167                  close 0,1,2 in case something went wrong collecting
1168                  them at startup.  */
1169               close_all_fds (3, startup_fd_list);
1170
1171               /* Run the command.  */
1172               execvp (argv[0], argv);
1173               log_error ("failed to run the command: %s\n", strerror (errno));
1174               kill (pid, SIGTERM);
1175               exit (1);
1176             }
1177           else
1178             {
1179               /* Print the environment string, so that the caller can use
1180                  shell's eval to set it */
1181               if (csh_style)
1182                 {
1183                   *strchr (infostr, '=') = ' ';
1184                   es_printf ("setenv %s\n", infostr);
1185                   if (opt.ssh_support)
1186                     {
1187                       *strchr (infostr_ssh_sock, '=') = ' ';
1188                       es_printf ("setenv %s\n", infostr_ssh_sock);
1189                       *strchr (infostr_ssh_pid, '=') = ' ';
1190                       es_printf ("setenv %s\n", infostr_ssh_pid);
1191                     }
1192                 }
1193               else
1194                 {
1195                   es_printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1196                   if (opt.ssh_support)
1197                     {
1198                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1199                                  infostr_ssh_sock);
1200                       es_printf ("%s; export SSH_AGENT_PID;\n",
1201                                  infostr_ssh_pid);
1202                     }
1203                 }
1204               xfree (infostr);
1205               if (opt.ssh_support)
1206                 {
1207                   xfree (infostr_ssh_sock);
1208                   xfree (infostr_ssh_pid);
1209                 }
1210               exit (0);
1211             }
1212           /*NOTREACHED*/
1213         } /* End parent */
1214
1215       /*
1216          This is the child
1217        */
1218
1219       /* Detach from tty and put process into a new session */
1220       if (!nodetach )
1221         {
1222           int i;
1223           unsigned int oldflags;
1224
1225           /* Close stdin, stdout and stderr unless it is the log stream */
1226           for (i=0; i <= 2; i++)
1227             {
1228               if (!log_test_fd (i) && i != fd )
1229                 {
1230                   if ( ! close (i)
1231                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1232                     {
1233                       log_error ("failed to open `%s': %s\n",
1234                                  "/dev/null", strerror (errno));
1235                       cleanup ();
1236                       exit (1);
1237                     }
1238                 }
1239             }
1240           if (setsid() == -1)
1241             {
1242               log_error ("setsid() failed: %s\n", strerror(errno) );
1243               cleanup ();
1244               exit (1);
1245             }
1246
1247           log_get_prefix (&oldflags);
1248           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1249           opt.running_detached = 1;
1250         }
1251
1252       if (chdir("/"))
1253         {
1254           log_error ("chdir to / failed: %s\n", strerror (errno));
1255           exit (1);
1256         }
1257
1258       {
1259         struct sigaction sa;
1260
1261         sa.sa_handler = SIG_IGN;
1262         sigemptyset (&sa.sa_mask);
1263         sa.sa_flags = 0;
1264         sigaction (SIGPIPE, &sa, NULL);
1265       }
1266 #endif /*!HAVE_W32_SYSTEM*/
1267
1268       log_info ("%s %s started\n", strusage(11), strusage(13) );
1269       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1270       assuan_sock_close (fd);
1271     }
1272
1273   return 0;
1274 }
1275
1276
1277 void
1278 agent_exit (int rc)
1279 {
1280   /*FIXME: update_random_seed_file();*/
1281
1282   /* We run our cleanup handler because that may close cipher contexts
1283      stored in secure memory and thus this needs to be done before we
1284      explicitly terminate secure memory.  */
1285   cleanup ();
1286
1287 #if 1
1288   /* at this time a bit annoying */
1289   if (opt.debug & DBG_MEMSTAT_VALUE)
1290     {
1291       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1292       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1293     }
1294   if (opt.debug)
1295     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1296 #endif
1297   gcry_control (GCRYCTL_TERM_SECMEM );
1298   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1299   exit (rc);
1300 }
1301
1302
1303 static void
1304 agent_init_default_ctrl (ctrl_t ctrl)
1305 {
1306   /* Note we ignore malloc errors because we can't do much about it
1307      and the request will fail anyway shortly after this
1308      initialization. */
1309   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1310   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1311   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1312   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1313   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1314
1315   if (ctrl->lc_ctype)
1316     xfree (ctrl->lc_ctype);
1317   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1318
1319   if (ctrl->lc_messages)
1320     xfree (ctrl->lc_messages);
1321   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1322                                     /**/ : NULL;
1323
1324 }
1325
1326
1327 static void
1328 agent_deinit_default_ctrl (ctrl_t ctrl)
1329 {
1330   session_env_release (ctrl->session_env);
1331
1332   if (ctrl->lc_ctype)
1333     xfree (ctrl->lc_ctype);
1334   if (ctrl->lc_messages)
1335     xfree (ctrl->lc_messages);
1336 }
1337
1338
1339 /* Reread parts of the configuration.  Note, that this function is
1340    obviously not thread-safe and should only be called from the PTH
1341    signal handler.
1342
1343    Fixme: Due to the way the argument parsing works, we create a
1344    memory leak here for all string type arguments.  There is currently
1345    no clean way to tell whether the memory for the argument has been
1346    allocated or points into the process' original arguments.  Unless
1347    we have a mechanism to tell this, we need to live on with this. */
1348 static void
1349 reread_configuration (void)
1350 {
1351   ARGPARSE_ARGS pargs;
1352   FILE *fp;
1353   unsigned int configlineno = 0;
1354   int dummy;
1355
1356   if (!config_filename)
1357     return; /* No config file. */
1358
1359   fp = fopen (config_filename, "r");
1360   if (!fp)
1361     {
1362       log_info (_("option file `%s': %s\n"),
1363                 config_filename, strerror(errno) );
1364       return;
1365     }
1366
1367   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1368
1369   memset (&pargs, 0, sizeof pargs);
1370   dummy = 0;
1371   pargs.argc = &dummy;
1372   pargs.flags = 1;  /* do not remove the args */
1373   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1374     {
1375       if (pargs.r_opt < -1)
1376         pargs.err = 1; /* Print a warning. */
1377       else /* Try to parse this option - ignore unchangeable ones. */
1378         parse_rereadable_options (&pargs, 1);
1379     }
1380   fclose (fp);
1381   set_debug ();
1382 }
1383
1384
1385 /* Return the file name of the socket we are using for native
1386    requests.  */
1387 const char *
1388 get_agent_socket_name (void)
1389 {
1390   const char *s = socket_name;
1391
1392   return (s && *s)? s : NULL;
1393 }
1394
1395 /* Return the file name of the socket we are using for SSH
1396    requests.  */
1397 const char *
1398 get_agent_ssh_socket_name (void)
1399 {
1400   const char *s = socket_name_ssh;
1401
1402   return (s && *s)? s : NULL;
1403 }
1404
1405
1406 /* Under W32, this function returns the handle of the scdaemon
1407    notification event.  Calling it the first time creates that
1408    event.  */
1409 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1410 void *
1411 get_agent_scd_notify_event (void)
1412 {
1413   static HANDLE the_event;
1414
1415   if (!the_event)
1416     {
1417       HANDLE h, h2;
1418       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1419
1420       /* We need to use a manual reset event object due to the way our
1421          w32-pth wait function works: If we would use an automatic
1422          reset event we are not able to figure out which handle has
1423          been signaled because at the time we single out the signaled
1424          handles using WFSO the event has already been reset due to
1425          the WFMO.  */
1426       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1427       if (!h)
1428         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1429       else if (!DuplicateHandle (GetCurrentProcess(), h,
1430                                  GetCurrentProcess(), &h2,
1431                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1432         {
1433           log_error ("setting syncronize for scd notify event failed: %s\n",
1434                      w32_strerror (-1) );
1435           CloseHandle (h);
1436         }
1437       else
1438         {
1439           CloseHandle (h);
1440           the_event = h2;
1441         }
1442     }
1443
1444   log_debug  ("returning notify handle %p\n", the_event);
1445   return the_event;
1446 }
1447 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1448
1449
1450
1451 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1452    true using STANDARD_NAME in the home directory or if given as
1453    false from the mkdir type name TEMPLATE.  In the latter case a
1454    unique name in a unique new directory will be created.  In both
1455    cases check for valid characters as well as against a maximum
1456    allowed length for a unix domain socket is done.  The function
1457    terminates the process in case of an error.  Returns: Pointer to an
1458    allocated string with the absolute name of the socket used.  */
1459 static char *
1460 create_socket_name (char *standard_name, char *template)
1461 {
1462   char *name, *p;
1463
1464   if (opt.use_standard_socket)
1465     name = make_filename (opt.homedir, standard_name, NULL);
1466   else
1467     {
1468       name = xstrdup (template);
1469       p = strrchr (name, '/');
1470       if (!p)
1471         BUG ();
1472       *p = 0;
1473       if (!mkdtemp (name))
1474         {
1475           log_error (_("can't create directory `%s': %s\n"),
1476                      name, strerror (errno));
1477           agent_exit (2);
1478         }
1479       *p = '/';
1480     }
1481
1482   if (strchr (name, PATHSEP_C))
1483     {
1484       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1485       agent_exit (2);
1486     }
1487   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1488     {
1489       log_error (_("name of socket too long\n"));
1490       agent_exit (2);
1491     }
1492   return name;
1493 }
1494
1495
1496
1497 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1498    or terminates the process in case of an error.  Not that this
1499    function needs to be used for the regular socket first and only
1500    then for the ssh socket.  */
1501 static gnupg_fd_t
1502 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1503 {
1504   struct sockaddr_un *serv_addr;
1505   socklen_t len;
1506   gnupg_fd_t fd;
1507   int rc;
1508
1509   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1510   if (fd == ASSUAN_INVALID_FD)
1511     {
1512       log_error (_("can't create socket: %s\n"), strerror (errno));
1513       agent_exit (2);
1514     }
1515
1516   serv_addr = xmalloc (sizeof (*serv_addr));
1517   memset (serv_addr, 0, sizeof *serv_addr);
1518   serv_addr->sun_family = AF_UNIX;
1519   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1520     {
1521       log_error (_("socket name `%s' is too long\n"), name);
1522       agent_exit (2);
1523     }
1524   strcpy (serv_addr->sun_path, name);
1525   len = SUN_LEN (serv_addr);
1526   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1527
1528   /* Our error code mapping on W32CE returns EEXIST thus we also test
1529      for this. */
1530   if (opt.use_standard_socket && rc == -1
1531       && (errno == EADDRINUSE
1532 #ifdef HAVE_W32_SYSTEM
1533           || errno == EEXIST
1534 #endif
1535           ))
1536     {
1537       /* Check whether a gpg-agent is already running on the standard
1538          socket.  We do this test only if this is not the ssh socket.
1539          For ssh we assume that a test for gpg-agent has already been
1540          done and reuse the requested ssh socket.  Testing the
1541          ssh-socket is not possible because at this point, though we
1542          know the new Assuan socket, the Assuan server and thus the
1543          ssh-agent server is not yet operational.  This would lead to
1544          a hang.  */
1545       if (!is_ssh && !check_for_running_agent (1, 1))
1546         {
1547           log_error (_("a gpg-agent is already running - "
1548                        "not starting a new one\n"));
1549           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1550           assuan_sock_close (fd);
1551           agent_exit (2);
1552         }
1553       gnupg_remove (name);
1554       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1555     }
1556   if (rc != -1
1557       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1558     log_error (_("error getting nonce for the socket\n"));
1559   if (rc == -1)
1560     {
1561       /* We use gpg_strerror here because it allows us to get strings
1562          for some W32 socket error codes.  */
1563       log_error (_("error binding socket to `%s': %s\n"),
1564                  serv_addr->sun_path,
1565                  gpg_strerror (gpg_error_from_errno (errno)));
1566
1567       assuan_sock_close (fd);
1568       if (opt.use_standard_socket)
1569         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1570       agent_exit (2);
1571     }
1572
1573   if (listen (FD2INT(fd), 5 ) == -1)
1574     {
1575       log_error (_("listen() failed: %s\n"), strerror (errno));
1576       assuan_sock_close (fd);
1577       agent_exit (2);
1578     }
1579
1580   if (opt.verbose)
1581     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1582
1583   return fd;
1584 }
1585
1586
1587 /* Check that the directory for storing the private keys exists and
1588    create it if not.  This function won't fail as it is only a
1589    convenience function and not strictly necessary.  */
1590 static void
1591 create_private_keys_directory (const char *home)
1592 {
1593   char *fname;
1594   struct stat statbuf;
1595
1596   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1597   if (stat (fname, &statbuf) && errno == ENOENT)
1598     {
1599       if (gnupg_mkdir (fname, "-rwx"))
1600         log_error (_("can't create directory `%s': %s\n"),
1601                    fname, strerror (errno) );
1602       else if (!opt.quiet)
1603         log_info (_("directory `%s' created\n"), fname);
1604     }
1605   xfree (fname);
1606 }
1607
1608 /* Create the directory only if the supplied directory name is the
1609    same as the default one.  This way we avoid to create arbitrary
1610    directories when a non-default home directory is used.  To cope
1611    with HOME, we compare only the suffix if we see that the default
1612    homedir does start with a tilde.  We don't stop here in case of
1613    problems because other functions will throw an error anyway.*/
1614 static void
1615 create_directories (void)
1616 {
1617   struct stat statbuf;
1618   const char *defhome = standard_homedir ();
1619   char *home;
1620
1621   home = make_filename (opt.homedir, NULL);
1622   if ( stat (home, &statbuf) )
1623     {
1624       if (errno == ENOENT)
1625         {
1626           if (
1627 #ifdef HAVE_W32_SYSTEM
1628               ( !compare_filenames (home, defhome) )
1629 #else
1630               (*defhome == '~'
1631                 && (strlen (home) >= strlen (defhome+1)
1632                     && !strcmp (home + strlen(home)
1633                                 - strlen (defhome+1), defhome+1)))
1634                || (*defhome != '~' && !strcmp (home, defhome) )
1635 #endif
1636                )
1637             {
1638               if (gnupg_mkdir (home, "-rwx"))
1639                 log_error (_("can't create directory `%s': %s\n"),
1640                            home, strerror (errno) );
1641               else
1642                 {
1643                   if (!opt.quiet)
1644                     log_info (_("directory `%s' created\n"), home);
1645                   create_private_keys_directory (home);
1646                 }
1647             }
1648         }
1649       else
1650         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1651     }
1652   else if ( !S_ISDIR(statbuf.st_mode))
1653     {
1654       log_error (_("can't use `%s' as home directory\n"), home);
1655     }
1656   else /* exists and is a directory. */
1657     {
1658       create_private_keys_directory (home);
1659     }
1660   xfree (home);
1661 }
1662
1663
1664
1665 /* This is the worker for the ticker.  It is called every few seconds
1666    and may only do fast operations. */
1667 static void
1668 handle_tick (void)
1669 {
1670   static time_t last_minute;
1671
1672   if (!last_minute)
1673     last_minute = time (NULL);
1674
1675   /* Check whether the scdaemon has died and cleanup in this case. */
1676   agent_scd_check_aliveness ();
1677
1678   /* If we are running as a child of another process, check whether
1679      the parent is still alive and shutdown if not. */
1680 #ifndef HAVE_W32_SYSTEM
1681   if (parent_pid != (pid_t)(-1))
1682     {
1683       if (kill (parent_pid, 0))
1684         {
1685           shutdown_pending = 2;
1686           log_info ("parent process died - shutting down\n");
1687           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1688           cleanup ();
1689           agent_exit (0);
1690         }
1691     }
1692 #endif /*HAVE_W32_SYSTEM*/
1693
1694   /* Code to be run every minute.  */
1695   if (last_minute + 60 <= time (NULL))
1696     {
1697       check_own_socket ();
1698       last_minute = time (NULL);
1699     }
1700
1701 }
1702
1703
1704 /* A global function which allows us to call the reload stuff from
1705    other places too.  This is only used when build for W32.  */
1706 void
1707 agent_sighup_action (void)
1708 {
1709   log_info ("SIGHUP received - "
1710             "re-reading configuration and flushing cache\n");
1711   agent_flush_cache ();
1712   reread_configuration ();
1713   agent_reload_trustlist ();
1714 }
1715
1716
1717 static void
1718 agent_sigusr2_action (void)
1719 {
1720   if (opt.verbose)
1721     log_info ("SIGUSR2 received - updating card event counter\n");
1722   /* Nothing to check right now.  We only increment a counter.  */
1723   bump_card_eventcounter ();
1724 }
1725
1726
1727 static void
1728 handle_signal (int signo)
1729 {
1730   switch (signo)
1731     {
1732 #ifndef HAVE_W32_SYSTEM
1733     case SIGHUP:
1734       agent_sighup_action ();
1735       break;
1736
1737     case SIGUSR1:
1738       log_info ("SIGUSR1 received - printing internal information:\n");
1739       /* Fixme: We need to see how to integrate pth dumping into our
1740          logging system.  */
1741       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1742       agent_query_dump_state ();
1743       agent_scd_dump_state ();
1744       break;
1745
1746     case SIGUSR2:
1747       agent_sigusr2_action ();
1748       break;
1749
1750     case SIGTERM:
1751       if (!shutdown_pending)
1752         log_info ("SIGTERM received - shutting down ...\n");
1753       else
1754         log_info ("SIGTERM received - still %ld running threads\n",
1755                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1756       shutdown_pending++;
1757       if (shutdown_pending > 2)
1758         {
1759           log_info ("shutdown forced\n");
1760           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1761           cleanup ();
1762           agent_exit (0);
1763         }
1764       break;
1765
1766     case SIGINT:
1767       log_info ("SIGINT received - immediate shutdown\n");
1768       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1769       cleanup ();
1770       agent_exit (0);
1771       break;
1772 #endif
1773     default:
1774       log_info ("signal %d received - no action defined\n", signo);
1775     }
1776 }
1777
1778
1779 /* Check the nonce on a new connection.  This is a NOP unless we we
1780    are using our Unix domain socket emulation under Windows.  */
1781 static int
1782 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1783 {
1784   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1785     {
1786       log_info (_("error reading nonce on fd %d: %s\n"),
1787                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1788       assuan_sock_close (ctrl->thread_startup.fd);
1789       xfree (ctrl);
1790       return -1;
1791     }
1792   else
1793     return 0;
1794 }
1795
1796
1797 /* This is the standard connection thread's main function.  */
1798 static void *
1799 start_connection_thread (void *arg)
1800 {
1801   ctrl_t ctrl = arg;
1802
1803   if (check_nonce (ctrl, &socket_nonce))
1804     return NULL;
1805
1806   agent_init_default_ctrl (ctrl);
1807   if (opt.verbose)
1808     log_info (_("handler 0x%lx for fd %d started\n"),
1809               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1810
1811   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1812   if (opt.verbose)
1813     log_info (_("handler 0x%lx for fd %d terminated\n"),
1814               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1815
1816   agent_deinit_default_ctrl (ctrl);
1817   xfree (ctrl);
1818   return NULL;
1819 }
1820
1821
1822 /* This is the ssh connection thread's main function.  */
1823 static void *
1824 start_connection_thread_ssh (void *arg)
1825 {
1826   ctrl_t ctrl = arg;
1827
1828   if (check_nonce (ctrl, &socket_nonce_ssh))
1829     return NULL;
1830
1831   agent_init_default_ctrl (ctrl);
1832   if (opt.verbose)
1833     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1834               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1835
1836   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1837   if (opt.verbose)
1838     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1839               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1840
1841   agent_deinit_default_ctrl (ctrl);
1842   xfree (ctrl);
1843   return NULL;
1844 }
1845
1846
1847 /* Connection handler loop.  Wait for connection requests and spawn a
1848    thread after accepting a connection.  */
1849 static void
1850 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1851 {
1852   pth_attr_t tattr;
1853   pth_event_t ev, time_ev;
1854   sigset_t sigs;
1855   int signo;
1856   struct sockaddr_un paddr;
1857   socklen_t plen;
1858   fd_set fdset, read_fdset;
1859   int ret;
1860   gnupg_fd_t fd;
1861   int nfd;
1862
1863   tattr = pth_attr_new();
1864   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1865   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1866
1867 #ifndef HAVE_W32_SYSTEM /* fixme */
1868   /* Make sure that the signals we are going to handle are not blocked
1869      and create an event object for them.  We also set the default
1870      action to ignore because we use an Pth event to get notified
1871      about signals.  This avoids that the default action is taken in
1872      case soemthing goes wrong within Pth.  The problem might also be
1873      a Pth bug.  */
1874   sigemptyset (&sigs );
1875   {
1876     static const int mysigs[] = { SIGHUP, SIGUSR1, SIGUSR2, SIGINT, SIGTERM };
1877     struct sigaction sa;
1878     int i;
1879
1880     for (i=0; i < DIM (mysigs); i++)
1881       {
1882         sigemptyset (&sa.sa_mask);
1883         sa.sa_handler = SIG_IGN;
1884         sa.sa_flags = 0;
1885         sigaction (mysigs[i], &sa, NULL);
1886
1887         sigaddset (&sigs, mysigs[i]);
1888       }
1889   }
1890
1891   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1892   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1893 #else
1894 # ifdef HAVE_W32CE_SYSTEM
1895   /* Use a dummy event. */
1896   sigs = 0;
1897   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1898 # else
1899   sigs = 0;
1900   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1901   signo = 0;
1902 # endif
1903 #endif
1904   time_ev = NULL;
1905
1906   FD_ZERO (&fdset);
1907   FD_SET (FD2INT (listen_fd), &fdset);
1908   nfd = FD2INT (listen_fd);
1909   if (listen_fd_ssh != GNUPG_INVALID_FD)
1910     {
1911       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1912       if (FD2INT (listen_fd_ssh) > nfd)
1913         nfd = FD2INT (listen_fd_ssh);
1914     }
1915
1916   for (;;)
1917     {
1918       /* Make sure that our signals are not blocked.  */
1919       pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1920
1921       /* Shutdown test.  */
1922       if (shutdown_pending)
1923         {
1924           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1925             break; /* ready */
1926
1927           /* Do not accept new connections but keep on running the
1928              loop to cope with the timer events.  */
1929           FD_ZERO (&fdset);
1930         }
1931
1932       /* Create a timeout event if needed.  To help with power saving
1933          we syncronize the ticks to the next full second.  */
1934       if (!time_ev)
1935         {
1936           pth_time_t nexttick;
1937
1938           nexttick = pth_timeout (TIMERTICK_INTERVAL, 0);
1939           if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
1940             {
1941               nexttick.tv_sec++;
1942               nexttick.tv_usec = 0;
1943             }
1944           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1945         }
1946
1947       /* POSIX says that fd_set should be implemented as a structure,
1948          thus a simple assignment is fine to copy the entire set.  */
1949       read_fdset = fdset;
1950
1951       if (time_ev)
1952         pth_event_concat (ev, time_ev, NULL);
1953       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1954       if (time_ev)
1955         pth_event_isolate (time_ev);
1956
1957       if (ret == -1)
1958         {
1959           if (pth_event_occurred (ev)
1960               || (time_ev && pth_event_occurred (time_ev)))
1961             {
1962               if (pth_event_occurred (ev))
1963                 {
1964 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1965                   agent_sigusr2_action ();
1966 #else
1967                   handle_signal (signo);
1968 #endif
1969                 }
1970               if (time_ev && pth_event_occurred (time_ev))
1971                 {
1972                   pth_event_free (time_ev, PTH_FREE_ALL);
1973                   time_ev = NULL;
1974                   handle_tick ();
1975                 }
1976               continue;
1977             }
1978           log_error (_("pth_select failed: %s - waiting 1s\n"),
1979                      strerror (errno));
1980           pth_sleep (1);
1981           continue;
1982         }
1983
1984       if (pth_event_occurred (ev))
1985         {
1986 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1987           agent_sigusr2_action ();
1988 #else
1989           handle_signal (signo);
1990 #endif
1991         }
1992
1993       if (time_ev && pth_event_occurred (time_ev))
1994         {
1995           pth_event_free (time_ev, PTH_FREE_ALL);
1996           time_ev = NULL;
1997           handle_tick ();
1998         }
1999
2000
2001       /* We now might create new threads and because we don't want any
2002          signals (as we are handling them here) to be delivered to a
2003          new thread.  Thus we need to block those signals. */
2004       pth_sigmask (SIG_BLOCK, &sigs, NULL);
2005
2006       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2007         {
2008           ctrl_t ctrl;
2009
2010           plen = sizeof paddr;
2011           fd = INT2FD (pth_accept (FD2INT(listen_fd),
2012                                    (struct sockaddr *)&paddr, &plen));
2013           if (fd == GNUPG_INVALID_FD)
2014             {
2015               log_error ("accept failed: %s\n", strerror (errno));
2016             }
2017           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2018             {
2019               log_error ("error allocating connection control data: %s\n",
2020                          strerror (errno) );
2021               assuan_sock_close (fd);
2022             }
2023           else if ( !(ctrl->session_env = session_env_new ()) )
2024             {
2025               log_error ("error allocating session environment block: %s\n",
2026                          strerror (errno) );
2027               xfree (ctrl);
2028               assuan_sock_close (fd);
2029             }
2030           else
2031             {
2032               char threadname[50];
2033
2034               snprintf (threadname, sizeof threadname-1,
2035                         "conn fd=%d (gpg)", FD2INT(fd));
2036               threadname[sizeof threadname -1] = 0;
2037               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2038               ctrl->thread_startup.fd = fd;
2039               if (!pth_spawn (tattr, start_connection_thread, ctrl))
2040                 {
2041                   log_error ("error spawning connection handler: %s\n",
2042                              strerror (errno) );
2043                   assuan_sock_close (fd);
2044                   xfree (ctrl);
2045                 }
2046             }
2047           fd = GNUPG_INVALID_FD;
2048         }
2049
2050       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD
2051           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2052         {
2053           ctrl_t ctrl;
2054
2055           plen = sizeof paddr;
2056           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
2057                                   (struct sockaddr *)&paddr, &plen));
2058           if (fd == GNUPG_INVALID_FD)
2059             {
2060               log_error ("accept failed for ssh: %s\n", strerror (errno));
2061             }
2062           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2063             {
2064               log_error ("error allocating connection control data: %s\n",
2065                          strerror (errno) );
2066               assuan_sock_close (fd);
2067             }
2068           else if ( !(ctrl->session_env = session_env_new ()) )
2069             {
2070               log_error ("error allocating session environment block: %s\n",
2071                          strerror (errno) );
2072               xfree (ctrl);
2073               assuan_sock_close (fd);
2074             }
2075           else
2076             {
2077               char threadname[50];
2078
2079               agent_init_default_ctrl (ctrl);
2080               snprintf (threadname, sizeof threadname-1,
2081                         "conn fd=%d (ssh)", FD2INT(fd));
2082               threadname[sizeof threadname -1] = 0;
2083               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2084               ctrl->thread_startup.fd = fd;
2085               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
2086                 {
2087                   log_error ("error spawning ssh connection handler: %s\n",
2088                              strerror (errno) );
2089                   assuan_sock_close (fd);
2090                   xfree (ctrl);
2091                 }
2092             }
2093           fd = GNUPG_INVALID_FD;
2094         }
2095     }
2096
2097   pth_event_free (ev, PTH_FREE_ALL);
2098   if (time_ev)
2099     pth_event_free (time_ev, PTH_FREE_ALL);
2100   cleanup ();
2101   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2102 }
2103
2104
2105
2106 /* Helper for check_own_socket.  */
2107 static gpg_error_t
2108 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2109 {
2110   membuf_t *mb = opaque;
2111   put_membuf (mb, buffer, length);
2112   return 0;
2113 }
2114
2115
2116 /* The thread running the actual check.  We need to run this in a
2117    separate thread so that check_own_thread can be called from the
2118    timer tick.  */
2119 static void *
2120 check_own_socket_thread (void *arg)
2121 {
2122   int rc;
2123   char *sockname = arg;
2124   assuan_context_t ctx = NULL;
2125   membuf_t mb;
2126   char *buffer;
2127
2128   check_own_socket_running++;
2129
2130   rc = assuan_new (&ctx);
2131   if (rc)
2132     {
2133       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2134       goto leave;
2135     }
2136
2137   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2138   if (rc)
2139     {
2140       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2141       goto leave;
2142     }
2143
2144   init_membuf (&mb, 100);
2145   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2146                         NULL, NULL, NULL, NULL);
2147   put_membuf (&mb, "", 1);
2148   buffer = get_membuf (&mb, NULL);
2149   if (rc || !buffer)
2150     {
2151       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2152                  "GETINFO pid", gpg_strerror (rc));
2153       rc = 1;
2154     }
2155   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2156     {
2157       log_error ("socket is now serviced by another server\n");
2158       rc = 1;
2159     }
2160   else if (opt.verbose > 1)
2161     log_error ("socket is still served by this server\n");
2162
2163   xfree (buffer);
2164
2165  leave:
2166   xfree (sockname);
2167   if (ctx)
2168     assuan_release (ctx);
2169   if (rc)
2170     {
2171       /* We may not remove the socket as it is now in use by another
2172          server.  Setting the name to empty does this.  */
2173       if (socket_name)
2174         *socket_name = 0;
2175       if (socket_name_ssh)
2176         *socket_name_ssh = 0;
2177       shutdown_pending = 2;
2178       log_info ("this process is useless - shutting down\n");
2179     }
2180   check_own_socket_running--;
2181   return NULL;
2182 }
2183
2184
2185 /* Check whether we are still listening on our own socket.  In case
2186    another gpg-agent process started after us has taken ownership of
2187    our socket, we woulf linger around without any real task.  Thus we
2188    better check once in a while whether we are really needed.  */
2189 static void
2190 check_own_socket (void)
2191 {
2192   char *sockname;
2193   pth_attr_t tattr;
2194
2195   if (!opt.use_standard_socket)
2196     return; /* This check makes only sense in standard socket mode.  */
2197
2198   if (check_own_socket_running || shutdown_pending)
2199     return;  /* Still running or already shutting down.  */
2200
2201   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2202   if (!sockname)
2203     return; /* Out of memory.  */
2204
2205   tattr = pth_attr_new();
2206   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
2207   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
2208   pth_attr_set (tattr, PTH_ATTR_NAME, "check-own-socket");
2209
2210   if (!pth_spawn (tattr, check_own_socket_thread, sockname))
2211       log_error ("error spawning check_own_socket_thread: %s\n",
2212                  strerror (errno) );
2213   pth_attr_destroy (tattr);
2214 }
2215
2216
2217
2218 /* Figure out whether an agent is available and running. Prints an
2219    error if not.  If SILENT is true, no messages are printed.  Usually
2220    started with MODE 0.  Returns 0 if the agent is running. */
2221 static int
2222 check_for_running_agent (int silent, int mode)
2223 {
2224   int rc;
2225   char *infostr, *p;
2226   assuan_context_t ctx = NULL;
2227   int prot, pid;
2228
2229   if (!mode)
2230     {
2231       infostr = getenv ("GPG_AGENT_INFO");
2232       if (!infostr || !*infostr)
2233         {
2234           if (!check_for_running_agent (silent, 1))
2235             return 0; /* Okay, its running on the standard socket. */
2236           if (!silent)
2237             log_error (_("no gpg-agent running in this session\n"));
2238           return -1;
2239         }
2240
2241       infostr = xstrdup (infostr);
2242       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2243         {
2244           xfree (infostr);
2245           if (!check_for_running_agent (silent, 1))
2246             return 0; /* Okay, its running on the standard socket. */
2247           if (!silent)
2248             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2249           return -1;
2250         }
2251
2252       *p++ = 0;
2253       pid = atoi (p);
2254       while (*p && *p != PATHSEP_C)
2255         p++;
2256       prot = *p? atoi (p+1) : 0;
2257       if (prot != 1)
2258         {
2259           xfree (infostr);
2260           if (!silent)
2261             log_error (_("gpg-agent protocol version %d is not supported\n"),
2262                        prot);
2263           if (!check_for_running_agent (silent, 1))
2264             return 0; /* Okay, its running on the standard socket. */
2265           return -1;
2266         }
2267     }
2268   else /* MODE != 0 */
2269     {
2270       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2271       pid = (pid_t)(-1);
2272     }
2273
2274   rc = assuan_new (&ctx);
2275   if (! rc)
2276     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2277   xfree (infostr);
2278   if (rc)
2279     {
2280       if (!mode && !check_for_running_agent (silent, 1))
2281         return 0; /* Okay, its running on the standard socket. */
2282
2283       if (!mode && !silent)
2284         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2285
2286       if (ctx)
2287         assuan_release (ctx);
2288       return -1;
2289     }
2290
2291   if (!opt.quiet && !silent)
2292     log_info ("gpg-agent running and available\n");
2293
2294   assuan_release (ctx);
2295   return 0;
2296 }