agent/gpg-agent.c

   1 /* gpg-agent.c  -  The GnuPG Agent
   2  * Copyright (C) 2000-2007, 2009-2010 Free Software Foundation, Inc.
   3  * Copyright (C) 2000-2016 Werner Koch
   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 <https://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 #ifdef HAVE_W32_SYSTEM
  34 # ifndef WINVER
  35 #  define WINVER 0x0500  /* Same as in common/sysutils.c */
  36 # endif
  37 # ifdef HAVE_WINSOCK2_H
  38 #  include <winsock2.h>
  39 # endif
  40 # include <aclapi.h>
  41 # include <sddl.h>
  42 #else /*!HAVE_W32_SYSTEM*/
  43 # include <sys/socket.h>
  44 # include <sys/un.h>
  45 #endif /*!HAVE_W32_SYSTEM*/
  46 #include <unistd.h>
  47 #ifdef HAVE_SIGNAL_H
  48 # include <signal.h>
  49 #endif
  50 #include <npth.h>
  51 #ifdef HAVE_PRCTL
  52 # include <sys/prctl.h>
  53 #endif
  54
  55 #define GNUPG_COMMON_NEED_AFLOCAL
  56 #include "agent.h"
  57 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
  58
  59 #include "i18n.h"
  60 #include "sysutils.h"
  61 #include "gc-opt-flags.h"
  62 #include "exechelp.h"
  63 #include "asshelp.h"
  64 #include "../common/init.h"
  65
  66
  67 enum cmd_and_opt_values
  68 { aNull = 0,
  69   oCsh            = 'c',
  70   oQuiet          = 'q',
  71   oSh             = 's',
  72   oVerbose        = 'v',
  73
  74   oNoVerbose = 500,
  75   aGPGConfList,
  76   aGPGConfTest,
  77   aUseStandardSocketP,
  78   oOptions,
  79   oDebug,
  80   oDebugAll,
  81   oDebugLevel,
  82   oDebugWait,
  83   oDebugQuickRandom,
  84   oDebugPinentry,
  85   oNoGreeting,
  86   oNoOptions,
  87   oHomedir,
  88   oNoDetach,
  89   oNoGrab,
  90   oLogFile,
  91   oServer,
  92   oDaemon,
  93   oSupervised,
  94   oBatch,
  95
  96   oPinentryProgram,
  97   oPinentryTouchFile,
  98   oPinentryInvisibleChar,
  99   oPinentryTimeout,
 100   oDisplay,
 101   oTTYname,
 102   oTTYtype,
 103   oLCctype,
 104   oLCmessages,
 105   oXauthority,
 106   oScdaemonProgram,
 107   oDefCacheTTL,
 108   oDefCacheTTLSSH,
 109   oMaxCacheTTL,
 110   oMaxCacheTTLSSH,
 111   oEnforcePassphraseConstraints,
 112   oMinPassphraseLen,
 113   oMinPassphraseNonalpha,
 114   oCheckPassphrasePattern,
 115   oMaxPassphraseDays,
 116   oEnablePassphraseHistory,
 117   oUseStandardSocket,
 118   oNoUseStandardSocket,
 119   oExtraSocket,
 120   oBrowserSocket,
 121   oFakedSystemTime,
 122
 123   oIgnoreCacheForSigning,
 124   oAllowMarkTrusted,
 125   oNoAllowMarkTrusted,
 126   oAllowPresetPassphrase,
 127   oAllowLoopbackPinentry,
 128   oNoAllowLoopbackPinentry,
 129   oNoAllowExternalCache,
 130   oAllowEmacsPinentry,
 131   oKeepTTY,
 132   oKeepDISPLAY,
 133   oSSHSupport,
 134   oPuttySupport,
 135   oDisableScdaemon,
 136   oDisableCheckOwnSocket,
 137   oWriteEnvFile
 138 };
 139
 140
 141 #ifndef ENAMETOOLONG
 142 # define ENAMETOOLONG EINVAL
 143 #endif
 144
 145
 146 static ARGPARSE_OPTS opts[] = {
 147
 148   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
 149   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
 150   ARGPARSE_c (aUseStandardSocketP, "use-standard-socket-p", "@"),
 151
 152   ARGPARSE_group (301, N_("@Options:\n ")),
 153
 154   ARGPARSE_s_n (oDaemon,  "daemon", N_("run in daemon mode (background)")),
 155   ARGPARSE_s_n (oServer,  "server", N_("run in server mode (foreground)")),
 156 #ifndef HAVE_W32_SYSTEM
 157   ARGPARSE_s_n (oSupervised,  "supervised", N_("run in supervised mode")),
 158 #endif
 159   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
 160   ARGPARSE_s_n (oQuiet,   "quiet",     N_("be somewhat more quiet")),
 161   ARGPARSE_s_n (oSh,      "sh",        N_("sh-style command output")),
 162   ARGPARSE_s_n (oCsh,     "csh",       N_("csh-style command output")),
 163   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
 164
 165   ARGPARSE_s_s (oDebug,      "debug",       "@"),
 166   ARGPARSE_s_n (oDebugAll,   "debug-all",   "@"),
 167   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
 168   ARGPARSE_s_i (oDebugWait,"  debug-wait",  "@"),
 169   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
 170   ARGPARSE_s_n (oDebugPinentry, "debug-pinentry", "@"),
 171
 172   ARGPARSE_s_n (oNoDetach,  "no-detach", N_("do not detach from the console")),
 173   ARGPARSE_s_n (oNoGrab,    "no-grab",   N_("do not grab keyboard and mouse")),
 174   ARGPARSE_s_s (oLogFile,   "log-file",  N_("use a log file for the server")),
 175   ARGPARSE_s_s (oPinentryProgram, "pinentry-program",
 176                 /* */             N_("|PGM|use PGM as the PIN-Entry program")),
 177   ARGPARSE_s_s (oPinentryTouchFile, "pinentry-touch-file", "@"),
 178   ARGPARSE_s_s (oPinentryInvisibleChar, "pinentry-invisible-char", "@"),
 179   ARGPARSE_s_u (oPinentryTimeout, "pinentry-timeout", "@"),
 180   ARGPARSE_s_s (oScdaemonProgram, "scdaemon-program",
 181                 /* */             N_("|PGM|use PGM as the SCdaemon program") ),
 182   ARGPARSE_s_n (oDisableScdaemon, "disable-scdaemon",
 183                 /* */             N_("do not use the SCdaemon") ),
 184   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
 185
 186   ARGPARSE_s_s (oExtraSocket, "extra-socket",
 187                 /* */       N_("|NAME|accept some commands via NAME")),
 188
 189   ARGPARSE_s_s (oBrowserSocket, "browser-socket", "@"),
 190
 191   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
 192
 193   ARGPARSE_s_n (oBatch,      "batch",        "@"),
 194   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
 195
 196   ARGPARSE_s_s (oDisplay,    "display",     "@"),
 197   ARGPARSE_s_s (oTTYname,    "ttyname",     "@"),
 198   ARGPARSE_s_s (oTTYtype,    "ttytype",     "@"),
 199   ARGPARSE_s_s (oLCctype,    "lc-ctype",    "@"),
 200   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
 201   ARGPARSE_s_s (oXauthority, "xauthority",  "@"),
 202   ARGPARSE_s_n (oKeepTTY,    "keep-tty",
 203                 /* */        N_("ignore requests to change the TTY")),
 204   ARGPARSE_s_n (oKeepDISPLAY, "keep-display",
 205                 /* */        N_("ignore requests to change the X display")),
 206
 207   ARGPARSE_s_u (oDefCacheTTL,    "default-cache-ttl",
 208                                  N_("|N|expire cached PINs after N seconds")),
 209   ARGPARSE_s_u (oDefCacheTTLSSH, "default-cache-ttl-ssh", "@" ),
 210   ARGPARSE_s_u (oMaxCacheTTL,    "max-cache-ttl",         "@" ),
 211   ARGPARSE_s_u (oMaxCacheTTLSSH, "max-cache-ttl-ssh",     "@" ),
 212
 213   ARGPARSE_s_n (oEnforcePassphraseConstraints, "enforce-passphrase-constraints",
 214                 /* */                          "@"),
 215   ARGPARSE_s_u (oMinPassphraseLen,        "min-passphrase-len", "@"),
 216   ARGPARSE_s_u (oMinPassphraseNonalpha,   "min-passphrase-nonalpha", "@"),
 217   ARGPARSE_s_s (oCheckPassphrasePattern,  "check-passphrase-pattern", "@"),
 218   ARGPARSE_s_u (oMaxPassphraseDays,       "max-passphrase-days", "@"),
 219   ARGPARSE_s_n (oEnablePassphraseHistory, "enable-passphrase-history", "@"),
 220
 221   ARGPARSE_s_n (oIgnoreCacheForSigning, "ignore-cache-for-signing",
 222                 /* */    N_("do not use the PIN cache when signing")),
 223   ARGPARSE_s_n (oNoAllowExternalCache,  "no-allow-external-cache",
 224                 /* */    N_("disallow the use of an external password cache")),
 225   ARGPARSE_s_n (oNoAllowMarkTrusted, "no-allow-mark-trusted",
 226                 /* */    N_("disallow clients to mark keys as \"trusted\"")),
 227   ARGPARSE_s_n (oAllowMarkTrusted,   "allow-mark-trusted", "@"),
 228   ARGPARSE_s_n (oAllowPresetPassphrase, "allow-preset-passphrase",
 229                 /* */                    N_("allow presetting passphrase")),
 230   ARGPARSE_s_n (oNoAllowLoopbackPinentry, "no-allow-loopback-pinentry",
 231                                 N_("disallow caller to override the pinentry")),
 232   ARGPARSE_s_n (oAllowLoopbackPinentry, "allow-loopback-pinentry", "@"),
 233   ARGPARSE_s_n (oAllowEmacsPinentry,  "allow-emacs-pinentry",
 234                 /* */    N_("allow passphrase to be prompted through Emacs")),
 235
 236   ARGPARSE_s_n (oSSHSupport,   "enable-ssh-support", N_("enable ssh support")),
 237   ARGPARSE_s_n (oPuttySupport, "enable-putty-support",
 238 #ifdef HAVE_W32_SYSTEM
 239                 /* */           N_("enable putty support")
 240 #else
 241                 /* */           "@"
 242 #endif
 243                 ),
 244
 245   /* Dummy options for backward compatibility.  */
 246   ARGPARSE_o_s (oWriteEnvFile, "write-env-file", "@"),
 247   ARGPARSE_s_n (oUseStandardSocket, "use-standard-socket", "@"),
 248   ARGPARSE_s_n (oNoUseStandardSocket, "no-use-standard-socket", "@"),
 249
 250   {0} /* End of list */
 251 };
 252
 253
 254 /* The list of supported debug flags.  */
 255 static struct debug_flags_s debug_flags [] =
 256   {
 257     { DBG_MPI_VALUE    , "mpi"     },
 258     { DBG_CRYPTO_VALUE , "crypto"  },
 259     { DBG_MEMORY_VALUE , "memory"  },
 260     { DBG_CACHE_VALUE  , "cache"   },
 261     { DBG_MEMSTAT_VALUE, "memstat" },
 262     { DBG_HASHING_VALUE, "hashing" },
 263     { DBG_IPC_VALUE    , "ipc"     },
 264     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
 265   };
 266
 267
 268
 269 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
 270 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
 271 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
 272 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
 273 #define MIN_PASSPHRASE_LEN    (8)
 274 #define MIN_PASSPHRASE_NONALPHA (1)
 275 #define MAX_PASSPHRASE_DAYS   (0)
 276
 277 /* The timer tick used for housekeeping stuff.  For Windows we use a
 278    longer period as the SetWaitableTimer seems to signal earlier than
 279    the 2 seconds.  CHECK_OWN_SOCKET_INTERVAL defines how often we
 280    check our own socket in standard socket mode.  If that value is 0
 281    we don't check at all.   All values are in seconds. */
 282 #if defined(HAVE_W32CE_SYSTEM)
 283 # define TIMERTICK_INTERVAL         (60)
 284 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
 285 #elif defined(HAVE_W32_SYSTEM)
 286 # define TIMERTICK_INTERVAL          (4)
 287 # define CHECK_OWN_SOCKET_INTERVAL  (60)
 288 #else
 289 # define TIMERTICK_INTERVAL          (2)
 290 # define CHECK_OWN_SOCKET_INTERVAL  (60)
 291 #endif
 292
 293
 294 /* Flag indicating that the ssh-agent subsystem has been enabled.  */
 295 static int ssh_support;
 296
 297 #ifdef HAVE_W32_SYSTEM
 298 /* Flag indicating that support for Putty has been enabled.  */
 299 static int putty_support;
 300 /* A magic value used with WM_COPYDATA.  */
 301 #define PUTTY_IPC_MAGIC 0x804e50ba
 302 /* To avoid surprises we limit the size of the mapped IPC file to this
 303    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
 304    for the foreseeable future.  */
 305 #define PUTTY_IPC_MAXLEN 16384
 306 #endif /*HAVE_W32_SYSTEM*/
 307
 308 /* The list of open file descriptors at startup.  Note that this list
 309    has been allocated using the standard malloc.  */
 310 static int *startup_fd_list;
 311
 312 /* The signal mask at startup and a flag telling whether it is valid.  */
 313 #ifdef HAVE_SIGPROCMASK
 314 static sigset_t startup_signal_mask;
 315 static int startup_signal_mask_valid;
 316 #endif
 317
 318 /* Flag to indicate that a shutdown was requested.  */
 319 static int shutdown_pending; /* xxx threaded accesses lack locking */
 320
 321 /* Counter for the currently running own socket checks.  */
 322 static int check_own_socket_running; /* xxx threaded accesses lack locking */
 323
 324 /* Flags to indicate that check_own_socket shall not be called.  */
 325 static int disable_check_own_socket;
 326
 327 /* Flag indicating that we are in supervised mode.  */
 328 static int is_supervised;
 329
 330 /* Flag to inhibit socket removal in cleanup.  */
 331 static int inhibit_socket_removal; /* xxx threaded accesses lack locking */
 332
 333 /* It is possible that we are currently running under setuid permissions */
 334 static int maybe_setuid = 1;
 335
 336 /* Name of the communication socket used for native gpg-agent
 337    requests. The second variable is either NULL or a malloced string
 338    with the real socket name in case it has been redirected.  */
 339 static char *socket_name;
 340 static char *redir_socket_name;
 341
 342 /* Name of the optional extra socket used for native gpg-agent requests.  */
 343 static char *socket_name_extra;
 344 static char *redir_socket_name_extra;
 345
 346 /* Name of the optional browser socket used for native gpg-agent requests.  */
 347 static char *socket_name_browser;
 348 static char *redir_socket_name_browser;
 349
 350 /* Name of the communication socket used for ssh-agent-emulation.  */
 351 static char *socket_name_ssh;
 352 static char *redir_socket_name_ssh;
 353
 354 /* We need to keep track of the server's nonces (these are dummies for
 355    POSIX systems). */
 356 static assuan_sock_nonce_t socket_nonce;
 357 static assuan_sock_nonce_t socket_nonce_extra;
 358 static assuan_sock_nonce_t socket_nonce_browser;
 359 static assuan_sock_nonce_t socket_nonce_ssh;
 360
 361
 362 /* Default values for options passed to the pinentry. */
 363 static char *default_display;
 364 static char *default_ttyname;
 365 static char *default_ttytype;
 366 static char *default_lc_ctype;
 367 static char *default_lc_messages;
 368 static char *default_xauthority;
 369
 370 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
 371 static char *config_filename;
 372
 373 /* Helper to implement --debug-level */
 374 static const char *debug_level;
 375
 376 /* Keep track of the current log file so that we can avoid updating
 377    the log file after a SIGHUP if it didn't changed. Malloced. */
 378 static char *current_logfile;
 379
 380 /* The handle_tick() function may test whether a parent is still
 381    running.  We record the PID of the parent here or -1 if it should be
 382    watched. */
 383 static pid_t parent_pid = (pid_t)(-1);
 384
 385 /* Record the pid of the main thread, for easier signalling */
 386 static pid_t main_thread_pid = (pid_t)(-1);
 387
 388 /* Number of active connections.  */
 389 static int active_connections_value;
 390 static npth_mutex_t active_connections_lock;
 391
 392 /* This object is used to dispatch progress messages from Libgcrypt to
 393  * the right thread.  Given that we will have at max only a few dozen
 394  * connections at a time, using a linked list is the easiest way to
 395  * handle this. */
 396 struct progress_dispatch_s
 397 {
 398   struct progress_dispatch_s *next;
 399   /* The control object of the connection.  If this is NULL no
 400    * connection is associated with this item and it is free for reuse
 401    * by new connections.  */
 402   ctrl_t ctrl;
 403
 404   /* The thread id of (npth_self) of the connection.  */
 405   npth_t tid;
 406
 407   /* The callback set by the connection.  This is similar to the
 408    * Libgcrypt callback but with the control object passed as the
 409    * first argument.  */
 410   void (*cb)(ctrl_t ctrl,
 411              const char *what, int printchar,
 412              int current, int total);
 413 };
 414 struct progress_dispatch_s *progress_dispatch_list;
 415
 416
 417
 418 \f
 419 /*
 420    Local prototypes.
 421  */
 422
 423 static char *create_socket_name (char *standard_name, int with_homedir);
 424 static gnupg_fd_t create_server_socket (char *name, int primary, int cygwin,
 425                                         char **r_redir_name,
 426                                         assuan_sock_nonce_t *nonce);
 427 static void create_directories (void);
 428
 429 static void agent_libgcrypt_progress_cb (void *data, const char *what,
 430                                          int printchar,
 431                                          int current, int total);
 432 static void agent_init_default_ctrl (ctrl_t ctrl);
 433 static void agent_deinit_default_ctrl (ctrl_t ctrl);
 434
 435 static void handle_connections (gnupg_fd_t listen_fd,
 436                                 gnupg_fd_t listen_fd_extra,
 437                                 gnupg_fd_t listen_fd_browser,
 438                                 gnupg_fd_t listen_fd_ssh);
 439 static void check_own_socket (void);
 440 static int check_for_running_agent (int silent);
 441
 442 /* Pth wrapper function definitions. */
 443 ASSUAN_SYSTEM_NPTH_IMPL;
 444
 445 \f
 446 /*
 447    Functions.
 448  */
 449
 450 /* Allocate a string describing a library version by calling a GETFNC.
 451    This function is expected to be called only once.  GETFNC is
 452    expected to have a semantic like gcry_check_version ().  */
 453 static char *
 454 make_libversion (const char *libname, const char *(*getfnc)(const char*))
 455 {
 456   const char *s;
 457   char *result;
 458
 459   if (maybe_setuid)
 460     {
 461       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
 462       maybe_setuid = 0;
 463     }
 464   s = getfnc (NULL);
 465   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
 466   strcpy (stpcpy (stpcpy (result, libname), " "), s);
 467   return result;
 468 }
 469
 470 /* Return strings describing this program.  The case values are
 471    described in common/argparse.c:strusage.  The values here override
 472    the default values given by strusage.  */
 473 static const char *
 474 my_strusage (int level)
 475 {
 476   static char *ver_gcry;
 477   const char *p;
 478
 479   switch (level)
 480     {
 481     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
 482       break;
 483     case 13: p = VERSION; break;
 484     case 17: p = PRINTABLE_OS_NAME; break;
 485       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
 486          reporting address.  This is so that we can change the
 487          reporting address without breaking the translations.  */
 488     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 489
 490     case 20:
 491       if (!ver_gcry)
 492         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
 493       p = ver_gcry;
 494       break;
 495
 496     case 1:
 497     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
 498       break;
 499     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
 500                     "Secret key management for @GNUPG@\n");
 501     break;
 502
 503     default: p = NULL;
 504     }
 505   return p;
 506 }
 507
 508
 509
 510 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
 511    only the active debug flags are propagated to the subsystems.  With
 512    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
 513    all flags already set. Note that we don't fail here, because it is
 514    important to keep gpg-agent running even after re-reading the
 515    options due to a SIGHUP. */
 516 static void
 517 set_debug (void)
 518 {
 519   int numok = (debug_level && digitp (debug_level));
 520   int numlvl = numok? atoi (debug_level) : 0;
 521
 522   if (!debug_level)
 523     ;
 524   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
 525     opt.debug = 0;
 526   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
 527     opt.debug = DBG_IPC_VALUE;
 528   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
 529     opt.debug = DBG_IPC_VALUE;
 530   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
 531     opt.debug = (DBG_IPC_VALUE | DBG_CACHE_VALUE);
 532   else if (!strcmp (debug_level, "guru") || numok)
 533     {
 534       opt.debug = ~0;
 535       /* Unless the "guru" string has been used we don't want to allow
 536          hashing debugging.  The rationale is that people tend to
 537          select the highest debug value and would then clutter their
 538          disk with debug files which may reveal confidential data.  */
 539       if (numok)
 540         opt.debug &= ~(DBG_HASHING_VALUE);
 541     }
 542   else
 543     {
 544       log_error (_("invalid debug-level '%s' given\n"), debug_level);
 545       opt.debug = 0; /* Reset debugging, so that prior debug
 546                         statements won't have an undesired effect. */
 547     }
 548
 549   if (opt.debug && !opt.verbose)
 550     opt.verbose = 1;
 551   if (opt.debug && opt.quiet)
 552     opt.quiet = 0;
 553
 554   if (opt.debug & DBG_MPI_VALUE)
 555     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
 556   if (opt.debug & DBG_CRYPTO_VALUE )
 557     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
 558   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 559
 560   if (opt.debug)
 561     parse_debug_flag (NULL, &opt.debug, debug_flags);
 562 }
 563
 564
 565 /* Helper for cleanup to remove one socket with NAME.  REDIR_NAME is
 566    the corresponding real name if the socket has been redirected.  */
 567 static void
 568 remove_socket (char *name, char *redir_name)
 569 {
 570   if (name && *name)
 571     {
 572       if (redir_name)
 573         name = redir_name;
 574
 575       gnupg_remove (name);
 576       *name = 0;
 577     }
 578 }
 579
 580
 581 /* Discover which inherited file descriptors correspond to which
 582  * services/sockets offered by gpg-agent, using the LISTEN_FDS and
 583  * LISTEN_FDNAMES convention.  The understood labels are "ssh",
 584  * "extra", and "browser".  "std" or other labels will be interpreted
 585  * as the standard socket.
 586  *
 587  * This function is designed to log errors when the expected file
 588  * descriptors don't make sense, but to do its best to continue to
 589  * work even in the face of minor misconfigurations.
 590  *
 591  * For more information on the LISTEN_FDS convention, see
 592  * sd_listen_fds(3) on certain Linux distributions.
 593  */
 594 #ifndef HAVE_W32_SYSTEM
 595 static void
 596 map_supervised_sockets (gnupg_fd_t *r_fd,
 597                         gnupg_fd_t *r_fd_extra,
 598                         gnupg_fd_t *r_fd_browser,
 599                         gnupg_fd_t *r_fd_ssh)
 600 {
 601   struct {
 602     const char *label;
 603     int **fdaddr;
 604     char **nameaddr;
 605   } tbl[] = {
 606     { "ssh",     &r_fd_ssh,     &socket_name_ssh },
 607     { "browser", &r_fd_browser, &socket_name_browser },
 608     { "extra",   &r_fd_extra,   &socket_name_extra },
 609     { "std",     &r_fd,         &socket_name }  /* (Must be the last item.)  */
 610   };
 611   const char *envvar;
 612   char **fdnames;
 613   int nfdnames;
 614   int fd_count;
 615
 616   *r_fd = *r_fd_extra = *r_fd_browser = *r_fd_ssh = -1;
 617
 618   /* Print a warning if LISTEN_PID does not match outr pid.  */
 619   envvar = getenv ("LISTEN_PID");
 620   if (!envvar)
 621     log_error ("no LISTEN_PID environment variable found in "
 622                "--supervised mode (ignoring)\n");
 623   else if (strtoul (envvar, NULL, 10) != (unsigned long)getpid ())
 624     log_error ("environment variable LISTEN_PID (%lu) does not match"
 625                " our pid (%lu) in --supervised mode (ignoring)\n",
 626                (unsigned long)strtoul (envvar, NULL, 10),
 627                (unsigned long)getpid ());
 628
 629   /* Parse LISTEN_FDNAMES into the array FDNAMES.  */
 630   envvar = getenv ("LISTEN_FDNAMES");
 631   if (envvar)
 632     {
 633       fdnames = strtokenize (envvar, ":");
 634       if (!fdnames)
 635         {
 636           log_error ("strtokenize failed: %s\n",
 637                      gpg_strerror (gpg_error_from_syserror ()));
 638           agent_exit (1);
 639         }
 640       for (nfdnames=0; fdnames[nfdnames]; nfdnames++)
 641         ;
 642     }
 643   else
 644     {
 645       fdnames = NULL;
 646       nfdnames = 0;
 647     }
 648
 649   /* Parse LISTEN_FDS into fd_count or provide a replacement.  */
 650   envvar = getenv ("LISTEN_FDS");
 651   if (envvar)
 652     fd_count = atoi (envvar);
 653   else if (fdnames)
 654     {
 655       log_error ("no LISTEN_FDS environment variable found in --supervised"
 656                  " mode (relying on LISTEN_FDNAMES instead)\n");
 657       fd_count = nfdnames;
 658     }
 659   else
 660     {
 661       log_error ("no LISTEN_FDS or LISTEN_FDNAMES environment variables "
 662                 "found in --supervised mode"
 663                 " (assuming 1 active descriptor)\n");
 664       fd_count = 1;
 665     }
 666
 667   if (fd_count < 1)
 668     {
 669       log_error ("--supervised mode expects at least one file descriptor"
 670                  " (was told %d, carrying on as though it were 1)\n",
 671                  fd_count);
 672       fd_count = 1;
 673     }
 674
 675   /* Assign the descriptors to the return values.  */
 676   if (!fdnames)
 677     {
 678       struct stat statbuf;
 679
 680       if (fd_count != 1)
 681         log_error ("no LISTEN_FDNAMES and LISTEN_FDS (%d) != 1"
 682                    " in --supervised mode."
 683                    " (ignoring all sockets but the first one)\n",
 684                    fd_count);
 685       if (fstat (3, &statbuf) == -1 && errno ==EBADF)
 686         log_fatal ("file descriptor 3 must be valid in --supervised mode"
 687                    " if LISTEN_FDNAMES is not set\n");
 688       *r_fd = 3;
 689       socket_name = gnupg_get_socket_name (3);
 690     }
 691   else if (fd_count != nfdnames)
 692     {
 693       log_fatal ("number of items in LISTEN_FDNAMES (%d) does not match "
 694                  "LISTEN_FDS (%d) in --supervised mode\n",
 695                  nfdnames, fd_count);
 696     }
 697   else
 698     {
 699       int i, j, fd;
 700       char *name;
 701
 702       for (i = 0; i < nfdnames; i++)
 703         {
 704           for (j = 0; j < DIM (tbl); j++)
 705             {
 706               if (!strcmp (fdnames[i], tbl[j].label) || j == DIM(tbl)-1)
 707                 {
 708                   fd = 3 + i;
 709                   if (**tbl[j].fdaddr == -1)
 710                     {
 711                       name = gnupg_get_socket_name (fd);
 712                       if (name)
 713                         {
 714                           **tbl[j].fdaddr = fd;
 715                           *tbl[j].nameaddr = name;
 716                           log_info ("using fd %d for %s socket (%s)\n",
 717                                     fd, tbl[j].label, name);
 718                         }
 719                       else
 720                         {
 721                           log_error ("cannot listen on fd %d for %s socket\n",
 722                                      fd, tbl[j].label);
 723                           close (fd);
 724                         }
 725                     }
 726                   else
 727                     {
 728                       log_error ("cannot listen on more than one %s socket\n",
 729                                  tbl[j].label);
 730                       close (fd);
 731                     }
 732                   break;
 733                 }
 734             }
 735         }
 736     }
 737
 738   xfree (fdnames);
 739 }
 740 #endif /*!HAVE_W32_SYSTEM*/
 741
 742
 743 /* Cleanup code for this program.  This is either called has an atexit
 744    handler or directly.  */
 745 static void
 746 cleanup (void)
 747 {
 748   static int done;
 749
 750   if (done)
 751     return;
 752   done = 1;
 753   deinitialize_module_cache ();
 754   if (!is_supervised && !inhibit_socket_removal)
 755     {
 756       remove_socket (socket_name, redir_socket_name);
 757       if (opt.extra_socket > 1)
 758         remove_socket (socket_name_extra, redir_socket_name_extra);
 759       if (opt.browser_socket > 1)
 760         remove_socket (socket_name_browser, redir_socket_name_browser);
 761       remove_socket (socket_name_ssh, redir_socket_name_ssh);
 762     }
 763 }
 764
 765
 766
 767 /* Handle options which are allowed to be reset after program start.
 768    Return true when the current option in PARGS could be handled and
 769    false if not.  As a special feature, passing a value of NULL for
 770    PARGS, resets the options to the default.  REREAD should be set
 771    true if it is not the initial option parsing. */
 772 static int
 773 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
 774 {
 775   if (!pargs)
 776     { /* reset mode */
 777       opt.quiet = 0;
 778       opt.verbose = 0;
 779       opt.debug = 0;
 780       opt.no_grab = 0;
 781       opt.debug_pinentry = 0;
 782       opt.pinentry_program = NULL;
 783       opt.pinentry_touch_file = NULL;
 784       xfree (opt.pinentry_invisible_char);
 785       opt.pinentry_invisible_char = NULL;
 786       opt.pinentry_timeout = 0;
 787       opt.scdaemon_program = NULL;
 788       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
 789       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
 790       opt.max_cache_ttl = MAX_CACHE_TTL;
 791       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
 792       opt.enforce_passphrase_constraints = 0;
 793       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
 794       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
 795       opt.check_passphrase_pattern = NULL;
 796       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
 797       opt.enable_passphrase_history = 0;
 798       opt.ignore_cache_for_signing = 0;
 799       opt.allow_mark_trusted = 1;
 800       opt.allow_external_cache = 1;
 801       opt.allow_loopback_pinentry = 1;
 802       opt.allow_emacs_pinentry = 0;
 803       opt.disable_scdaemon = 0;
 804       disable_check_own_socket = 0;
 805       return 1;
 806     }
 807
 808   switch (pargs->r_opt)
 809     {
 810     case oQuiet: opt.quiet = 1; break;
 811     case oVerbose: opt.verbose++; break;
 812
 813     case oDebug:
 814       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
 815       break;
 816     case oDebugAll: opt.debug = ~0; break;
 817     case oDebugLevel: debug_level = pargs->r.ret_str; break;
 818     case oDebugPinentry: opt.debug_pinentry = 1; break;
 819
 820     case oLogFile:
 821       if (!reread)
 822         return 0; /* not handeld */
 823       if (!current_logfile || !pargs->r.ret_str
 824           || strcmp (current_logfile, pargs->r.ret_str))
 825         {
 826           log_set_file (pargs->r.ret_str);
 827           xfree (current_logfile);
 828           current_logfile = xtrystrdup (pargs->r.ret_str);
 829         }
 830       break;
 831
 832     case oNoGrab: opt.no_grab = 1; break;
 833
 834     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
 835     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
 836     case oPinentryInvisibleChar:
 837       xfree (opt.pinentry_invisible_char);
 838       opt.pinentry_invisible_char = xtrystrdup (pargs->r.ret_str); break;
 839       break;
 840     case oPinentryTimeout: opt.pinentry_timeout = pargs->r.ret_ulong; break;
 841     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
 842     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
 843     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
 844
 845     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
 846     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
 847     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
 848     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
 849
 850     case oEnforcePassphraseConstraints:
 851       opt.enforce_passphrase_constraints=1;
 852       break;
 853     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
 854     case oMinPassphraseNonalpha:
 855       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
 856       break;
 857     case oCheckPassphrasePattern:
 858       opt.check_passphrase_pattern = pargs->r.ret_str;
 859       break;
 860     case oMaxPassphraseDays:
 861       opt.max_passphrase_days = pargs->r.ret_ulong;
 862       break;
 863     case oEnablePassphraseHistory:
 864       opt.enable_passphrase_history = 1;
 865       break;
 866
 867     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
 868
 869     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
 870     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
 871
 872     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
 873
 874     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
 875     case oNoAllowLoopbackPinentry: opt.allow_loopback_pinentry = 0; break;
 876
 877     case oNoAllowExternalCache: opt.allow_external_cache = 0;
 878       break;
 879
 880     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
 881       break;
 882
 883     default:
 884       return 0; /* not handled */
 885     }
 886
 887   return 1; /* handled */
 888 }
 889
 890
 891 /* Fixup some options after all have been processed.  */
 892 static void
 893 finalize_rereadable_options (void)
 894 {
 895 }
 896
 897
 898 static void
 899 thread_init_once (void)
 900 {
 901   static int npth_initialized = 0;
 902
 903   if (!npth_initialized)
 904     {
 905       npth_initialized++;
 906       npth_init ();
 907     }
 908   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
 909   /* Now that we have set the syscall clamp we need to tell Libgcrypt
 910    * that it should get them from libgpg-error.  Note that Libgcrypt
 911    * has already been initialized but at that point nPth was not
 912    * initialized and thus Libgcrypt could not set its system call
 913    * clamp.  */
 914 #if GCRYPT_VERSION_NUMBER >= 0x010800 /* 1.8.0 */
 915   gcry_control (GCRYCTL_REINIT_SYSCALL_CLAMP, 0, 0);
 916 #endif
 917 }
 918
 919
 920 static void
 921 initialize_modules (void)
 922 {
 923   thread_init_once ();
 924   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
 925   initialize_module_cache ();
 926   initialize_module_call_pinentry ();
 927   initialize_module_call_scd ();
 928   initialize_module_trustlist ();
 929 }
 930
 931
 932 /* The main entry point.  */
 933 int
 934 main (int argc, char **argv )
 935 {
 936   ARGPARSE_ARGS pargs;
 937   int orig_argc;
 938   char **orig_argv;
 939   FILE *configfp = NULL;
 940   char *configname = NULL;
 941   const char *shell;
 942   unsigned configlineno;
 943   int parse_debug = 0;
 944   int default_config =1;
 945   int pipe_server = 0;
 946   int is_daemon = 0;
 947   int nodetach = 0;
 948   int csh_style = 0;
 949   char *logfile = NULL;
 950   int debug_wait = 0;
 951   int gpgconf_list = 0;
 952   gpg_error_t err;
 953   struct assuan_malloc_hooks malloc_hooks;
 954
 955   early_system_init ();
 956
 957 #if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
 958   /* Disable ptrace on Linux without sgid bit */
 959   prctl(PR_SET_DUMPABLE, 0);
 960 #endif
 961
 962   /* Before we do anything else we save the list of currently open
 963      file descriptors and the signal mask.  This info is required to
 964      do the exec call properly. */
 965   startup_fd_list = get_all_open_fds ();
 966 #ifdef HAVE_SIGPROCMASK
 967   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
 968     startup_signal_mask_valid = 1;
 969 #endif /*HAVE_SIGPROCMASK*/
 970
 971   /* Set program name etc.  */
 972   set_strusage (my_strusage);
 973   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 974   /* Please note that we may running SUID(ROOT), so be very CAREFUL
 975      when adding any stuff between here and the call to INIT_SECMEM()
 976      somewhere after the option parsing */
 977   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
 978
 979   /* Make sure that our subsystems are ready.  */
 980   i18n_init ();
 981   init_common_subsystems (&argc, &argv);
 982
 983   malloc_hooks.malloc = gcry_malloc;
 984   malloc_hooks.realloc = gcry_realloc;
 985   malloc_hooks.free = gcry_free;
 986   assuan_set_malloc_hooks (&malloc_hooks);
 987   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
 988   assuan_sock_init ();
 989   setup_libassuan_logging (&opt.debug, NULL);
 990
 991   setup_libgcrypt_logging ();
 992   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
 993   gcry_set_progress_handler (agent_libgcrypt_progress_cb, NULL);
 994
 995   disable_core_dumps ();
 996
 997   /* Set default options.  */
 998   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
 999
1000   shell = getenv ("SHELL");
1001   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
1002     csh_style = 1;
1003
1004   /* Record some of the original environment strings. */
1005   {
1006     const char *s;
1007     int idx;
1008     static const char *names[] =
1009       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
1010
1011     err = 0;
1012     opt.startup_env = session_env_new ();
1013     if (!opt.startup_env)
1014       err = gpg_error_from_syserror ();
1015     for (idx=0; !err && names[idx]; idx++)
1016       {
1017         s = getenv (names[idx]);
1018         if (s)
1019           err = session_env_setenv (opt.startup_env, names[idx], s);
1020       }
1021     if (!err)
1022       {
1023         s = gnupg_ttyname (0);
1024         if (s)
1025           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
1026       }
1027     if (err)
1028       log_fatal ("error recording startup environment: %s\n",
1029                  gpg_strerror (err));
1030
1031     /* Fixme: Better use the locale function here.  */
1032     opt.startup_lc_ctype = getenv ("LC_CTYPE");
1033     if (opt.startup_lc_ctype)
1034       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
1035     opt.startup_lc_messages = getenv ("LC_MESSAGES");
1036     if (opt.startup_lc_messages)
1037       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
1038   }
1039
1040   /* Check whether we have a config file on the commandline */
1041   orig_argc = argc;
1042   orig_argv = argv;
1043   pargs.argc = &argc;
1044   pargs.argv = &argv;
1045   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1046   while (arg_parse( &pargs, opts))
1047     {
1048       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
1049         parse_debug++;
1050       else if (pargs.r_opt == oOptions)
1051         { /* yes there is one, so we do not try the default one, but
1052              read the option file when it is encountered at the
1053              commandline */
1054           default_config = 0;
1055         }
1056         else if (pargs.r_opt == oNoOptions)
1057           default_config = 0; /* --no-options */
1058         else if (pargs.r_opt == oHomedir)
1059           gnupg_set_homedir (pargs.r.ret_str);
1060         else if (pargs.r_opt == oDebugQuickRandom)
1061           {
1062             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1063           }
1064
1065     }
1066
1067   /* Initialize the secure memory. */
1068   gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0);
1069   maybe_setuid = 0;
1070
1071   /*
1072      Now we are now working under our real uid
1073   */
1074
1075   if (default_config)
1076     configname = make_filename (gnupg_homedir (),
1077                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1078
1079   argc = orig_argc;
1080   argv = orig_argv;
1081   pargs.argc = &argc;
1082   pargs.argv = &argv;
1083   pargs.flags=  1;  /* do not remove the args */
1084  next_pass:
1085   if (configname)
1086     {
1087       configlineno = 0;
1088       configfp = fopen (configname, "r");
1089       if (!configfp)
1090         {
1091           if (default_config)
1092             {
1093               if( parse_debug )
1094                 log_info (_("Note: no default option file '%s'\n"),
1095                           configname );
1096               /* Save the default conf file name so that
1097                  reread_configuration is able to test whether the
1098                  config file has been created in the meantime.  */
1099               xfree (config_filename);
1100               config_filename = configname;
1101               configname = NULL;
1102             }
1103           else
1104             {
1105               log_error (_("option file '%s': %s\n"),
1106                          configname, strerror(errno) );
1107               exit(2);
1108             }
1109           xfree (configname);
1110           configname = NULL;
1111         }
1112       if (parse_debug && configname )
1113         log_info (_("reading options from '%s'\n"), configname );
1114       default_config = 0;
1115     }
1116
1117   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
1118     {
1119       if (parse_rereadable_options (&pargs, 0))
1120         continue; /* Already handled */
1121       switch (pargs.r_opt)
1122         {
1123         case aGPGConfList: gpgconf_list = 1; break;
1124         case aGPGConfTest: gpgconf_list = 2; break;
1125         case aUseStandardSocketP: gpgconf_list = 3; break;
1126         case oBatch: opt.batch=1; break;
1127
1128         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1129
1130         case oOptions:
1131           /* config files may not be nested (silently ignore them) */
1132           if (!configfp)
1133             {
1134                 xfree(configname);
1135                 configname = xstrdup(pargs.r.ret_str);
1136                 goto next_pass;
1137             }
1138           break;
1139         case oNoGreeting: /* Dummy option.  */ break;
1140         case oNoVerbose: opt.verbose = 0; break;
1141         case oNoOptions: break; /* no-options */
1142         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1143         case oNoDetach: nodetach = 1; break;
1144         case oLogFile: logfile = pargs.r.ret_str; break;
1145         case oCsh: csh_style = 1; break;
1146         case oSh: csh_style = 0; break;
1147         case oServer: pipe_server = 1; break;
1148         case oDaemon: is_daemon = 1; break;
1149         case oSupervised: is_supervised = 1; break;
1150
1151         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
1152         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
1153         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
1154         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
1155         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
1156           break;
1157         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
1158           break;
1159
1160         case oUseStandardSocket:
1161         case oNoUseStandardSocket:
1162           obsolete_option (configname, configlineno, "use-standard-socket");
1163           break;
1164
1165         case oFakedSystemTime:
1166           {
1167             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1168             if (faked_time == (time_t)(-1))
1169               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1170             gnupg_set_time (faked_time, 0);
1171           }
1172           break;
1173
1174         case oKeepTTY: opt.keep_tty = 1; break;
1175         case oKeepDISPLAY: opt.keep_display = 1; break;
1176
1177         case oSSHSupport:
1178           ssh_support = 1;
1179           break;
1180         case oPuttySupport:
1181 #        ifdef HAVE_W32_SYSTEM
1182           putty_support = 1;
1183 #        endif
1184           break;
1185
1186         case oExtraSocket:
1187           opt.extra_socket = 1;  /* (1 = points into argv)  */
1188           socket_name_extra = pargs.r.ret_str;
1189           break;
1190
1191         case oBrowserSocket:
1192           opt.browser_socket = 1;  /* (1 = points into argv)  */
1193           socket_name_browser = pargs.r.ret_str;
1194           break;
1195
1196         case oDebugQuickRandom:
1197           /* Only used by the first stage command line parser.  */
1198           break;
1199
1200         case oWriteEnvFile:
1201           obsolete_option (configname, configlineno, "write-env-file");
1202           break;
1203
1204         default : pargs.err = configfp? 1:2; break;
1205         }
1206     }
1207   if (configfp)
1208     {
1209       fclose( configfp );
1210       configfp = NULL;
1211       /* Keep a copy of the name so that it can be read on SIGHUP. */
1212       if (config_filename != configname)
1213         {
1214           xfree (config_filename);
1215           config_filename = configname;
1216         }
1217       configname = NULL;
1218       goto next_pass;
1219     }
1220
1221   xfree (configname);
1222   configname = NULL;
1223   if (log_get_errorcount(0))
1224     exit(2);
1225
1226   finalize_rereadable_options ();
1227
1228   /* Print a warning if an argument looks like an option.  */
1229   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1230     {
1231       int i;
1232
1233       for (i=0; i < argc; i++)
1234         if (argv[i][0] == '-' && argv[i][1] == '-')
1235           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1236     }
1237
1238 #ifdef ENABLE_NLS
1239   /* gpg-agent usually does not output any messages because it runs in
1240      the background.  For log files it is acceptable to have messages
1241      always encoded in utf-8.  We switch here to utf-8, so that
1242      commands like --help still give native messages.  It is far
1243      easier to switch only once instead of for every message and it
1244      actually helps when more then one thread is active (avoids an
1245      extra copy step). */
1246     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1247 #endif
1248
1249   if (!pipe_server && !is_daemon && !gpgconf_list && !is_supervised)
1250     {
1251      /* We have been called without any command and thus we merely
1252         check whether an agent is already running.  We do this right
1253         here so that we don't clobber a logfile with this check but
1254         print the status directly to stderr. */
1255       opt.debug = 0;
1256       set_debug ();
1257       check_for_running_agent (0);
1258       agent_exit (0);
1259     }
1260
1261   if (is_supervised)
1262     ;
1263   else if (!opt.extra_socket)
1264     opt.extra_socket = 1;
1265   else if (socket_name_extra
1266            && (!strcmp (socket_name_extra, "none")
1267                || !strcmp (socket_name_extra, "/dev/null")))
1268     {
1269       /* User requested not to create this socket.  */
1270       opt.extra_socket = 0;
1271       socket_name_extra = NULL;
1272     }
1273
1274   if (is_supervised)
1275     ;
1276   else if (!opt.browser_socket)
1277     opt.browser_socket = 1;
1278   else if (socket_name_browser
1279            && (!strcmp (socket_name_browser, "none")
1280                || !strcmp (socket_name_browser, "/dev/null")))
1281     {
1282       /* User requested not to create this socket.  */
1283       opt.browser_socket = 0;
1284       socket_name_browser = NULL;
1285     }
1286
1287   set_debug ();
1288
1289   if (atexit (cleanup))
1290     {
1291       log_error ("atexit failed\n");
1292       cleanup ();
1293       exit (1);
1294     }
1295
1296   /* Try to create missing directories. */
1297   create_directories ();
1298
1299   if (debug_wait && pipe_server)
1300     {
1301       thread_init_once ();
1302       log_debug ("waiting for debugger - my pid is %u .....\n",
1303                  (unsigned int)getpid());
1304       gnupg_sleep (debug_wait);
1305       log_debug ("... okay\n");
1306     }
1307
1308   if (gpgconf_list == 3)
1309     {
1310       /* We now use the standard socket always - return true for
1311          backward compatibility.  */
1312       agent_exit (0);
1313     }
1314   else if (gpgconf_list == 2)
1315     agent_exit (0);
1316   else if (gpgconf_list)
1317     {
1318       char *filename;
1319       char *filename_esc;
1320
1321       /* List options and default values in the GPG Conf format.  */
1322       filename = make_filename (gnupg_homedir (),
1323                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1324       filename_esc = percent_escape (filename, NULL);
1325
1326       es_printf ("%s-%s.conf:%lu:\"%s\n",
1327                  GPGCONF_NAME, GPG_AGENT_NAME,
1328                  GC_OPT_FLAG_DEFAULT, filename_esc);
1329       xfree (filename);
1330       xfree (filename_esc);
1331
1332       es_printf ("verbose:%lu:\n"
1333               "quiet:%lu:\n"
1334               "debug-level:%lu:\"none:\n"
1335               "log-file:%lu:\n",
1336               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1337               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1338               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1339               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1340       es_printf ("default-cache-ttl:%lu:%d:\n",
1341               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1342       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1343               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1344       es_printf ("max-cache-ttl:%lu:%d:\n",
1345               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1346       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1347               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1348       es_printf ("enforce-passphrase-constraints:%lu:\n",
1349               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1350       es_printf ("min-passphrase-len:%lu:%d:\n",
1351               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1352       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1353               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1354               MIN_PASSPHRASE_NONALPHA);
1355       es_printf ("check-passphrase-pattern:%lu:\n",
1356               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1357       es_printf ("max-passphrase-days:%lu:%d:\n",
1358               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1359               MAX_PASSPHRASE_DAYS);
1360       es_printf ("enable-passphrase-history:%lu:\n",
1361               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1362       es_printf ("no-grab:%lu:\n",
1363               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1364       es_printf ("ignore-cache-for-signing:%lu:\n",
1365               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1366       es_printf ("no-allow-external-cache:%lu:\n",
1367               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1368       es_printf ("no-allow-mark-trusted:%lu:\n",
1369               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1370       es_printf ("disable-scdaemon:%lu:\n",
1371               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1372       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1373 #ifdef HAVE_W32_SYSTEM
1374       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1375 #endif
1376       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1377               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1378       es_printf ("allow-emacs-pinentry:%lu:\n",
1379                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1380       es_printf ("pinentry-timeout:%lu:0:\n",
1381                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1382
1383       agent_exit (0);
1384     }
1385
1386   /* Now start with logging to a file if this is desired. */
1387   if (logfile)
1388     {
1389       log_set_file (logfile);
1390       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1391                              | GPGRT_LOG_WITH_TIME
1392                              | GPGRT_LOG_WITH_PID));
1393       current_logfile = xstrdup (logfile);
1394     }
1395
1396   /* Make sure that we have a default ttyname. */
1397   if (!default_ttyname && gnupg_ttyname (1))
1398     default_ttyname = xstrdup (gnupg_ttyname (1));
1399   if (!default_ttytype && getenv ("TERM"))
1400     default_ttytype = xstrdup (getenv ("TERM"));
1401
1402
1403   if (pipe_server)
1404     {
1405       /* This is the simple pipe based server */
1406       ctrl_t ctrl;
1407
1408       initialize_modules ();
1409
1410       ctrl = xtrycalloc (1, sizeof *ctrl);
1411       if (!ctrl)
1412         {
1413           log_error ("error allocating connection control data: %s\n",
1414                      strerror (errno) );
1415           agent_exit (1);
1416         }
1417       ctrl->session_env = session_env_new ();
1418       if (!ctrl->session_env)
1419         {
1420           log_error ("error allocating session environment block: %s\n",
1421                      strerror (errno) );
1422           xfree (ctrl);
1423           agent_exit (1);
1424         }
1425       agent_init_default_ctrl (ctrl);
1426       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1427       agent_deinit_default_ctrl (ctrl);
1428       xfree (ctrl);
1429     }
1430   else if (is_supervised)
1431     {
1432 #ifndef HAVE_W32_SYSTEM
1433       gnupg_fd_t fd, fd_extra, fd_browser, fd_ssh;
1434
1435       initialize_modules ();
1436
1437       /* when supervised and sending logs to stderr, the process
1438          supervisor should handle log entry metadata (pid, name,
1439          timestamp) */
1440       if (!logfile)
1441         log_set_prefix (NULL, 0);
1442
1443       log_info ("%s %s starting in supervised mode.\n",
1444                 strusage(11), strusage(13) );
1445
1446       /* See below in "regular server mode" on why we remove certain
1447        * envvars.  */
1448       if (!opt.keep_display)
1449         gnupg_unsetenv ("DISPLAY");
1450       gnupg_unsetenv ("INSIDE_EMACS");
1451
1452       /* Virtually create the sockets.  Note that we use -1 here
1453        * because the whole thing works only on Unix. */
1454       map_supervised_sockets (&fd, &fd_extra, &fd_browser, &fd_ssh);
1455       if (fd == -1)
1456         log_fatal ("no standard socket provided\n");
1457
1458 #ifdef HAVE_SIGPROCMASK
1459       if (startup_signal_mask_valid)
1460         {
1461           if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1462             log_error ("error restoring signal mask: %s\n",
1463                        strerror (errno));
1464         }
1465       else
1466         log_info ("no saved signal mask\n");
1467 #endif /*HAVE_SIGPROCMASK*/
1468
1469       log_info ("listening on: std=%d extra=%d browser=%d ssh=%d\n",
1470                 fd, fd_extra, fd_browser, fd_ssh);
1471       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1472 #endif /*!HAVE_W32_SYSTEM*/
1473     }
1474   else if (!is_daemon)
1475     ; /* NOTREACHED */
1476   else
1477     { /* Regular server mode */
1478       gnupg_fd_t fd;
1479       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1480       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1481       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1482 #ifndef HAVE_W32_SYSTEM
1483       pid_t pid;
1484 #endif
1485
1486       /* Remove the DISPLAY variable so that a pinentry does not
1487          default to a specific display.  There is still a default
1488          display when gpg-agent was started using --display or a
1489          client requested this using an OPTION command.  Note, that we
1490          don't do this when running in reverse daemon mode (i.e. when
1491          exec the program given as arguments). */
1492 #ifndef HAVE_W32_SYSTEM
1493       if (!opt.keep_display && !argc)
1494         gnupg_unsetenv ("DISPLAY");
1495 #endif
1496
1497       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1498          always try to interact with Emacs.  The variable is set when
1499          a client requested this using an OPTION command.  */
1500       gnupg_unsetenv ("INSIDE_EMACS");
1501
1502       /* Create the sockets.  */
1503       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1504       fd = create_server_socket (socket_name, 1, 0,
1505                                  &redir_socket_name, &socket_nonce);
1506
1507       if (opt.extra_socket)
1508         {
1509           if (socket_name_extra)
1510             socket_name_extra = create_socket_name (socket_name_extra, 0);
1511           else
1512             socket_name_extra = create_socket_name
1513               /**/                (GPG_AGENT_EXTRA_SOCK_NAME, 1);
1514           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1515           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1516                                            &redir_socket_name_extra,
1517                                            &socket_nonce_extra);
1518         }
1519
1520       if (opt.browser_socket)
1521         {
1522           if (socket_name_browser)
1523             socket_name_browser = create_socket_name (socket_name_browser, 0);
1524           else
1525             socket_name_browser= create_socket_name
1526               /**/                 (GPG_AGENT_BROWSER_SOCK_NAME, 1);
1527           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1528           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1529                                              &redir_socket_name_browser,
1530                                              &socket_nonce_browser);
1531         }
1532
1533       socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1534       fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1535                                      &redir_socket_name_ssh,
1536                                      &socket_nonce_ssh);
1537
1538       /* If we are going to exec a program in the parent, we record
1539          the PID, so that the child may check whether the program is
1540          still alive. */
1541       if (argc)
1542         parent_pid = getpid ();
1543
1544       fflush (NULL);
1545
1546 #ifdef HAVE_W32_SYSTEM
1547
1548       (void)csh_style;
1549       (void)nodetach;
1550       initialize_modules ();
1551
1552 #else /*!HAVE_W32_SYSTEM*/
1553
1554       pid = fork ();
1555       if (pid == (pid_t)-1)
1556         {
1557           log_fatal ("fork failed: %s\n", strerror (errno) );
1558           exit (1);
1559         }
1560       else if (pid)
1561         { /* We are the parent */
1562           char *infostr_ssh_sock, *infostr_ssh_valid;
1563
1564           /* Close the socket FD. */
1565           close (fd);
1566
1567           /* The signal mask might not be correct right now and thus
1568              we restore it.  That is not strictly necessary but some
1569              programs falsely assume a cleared signal mask.  */
1570
1571 #ifdef HAVE_SIGPROCMASK
1572           if (startup_signal_mask_valid)
1573             {
1574               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1575                 log_error ("error restoring signal mask: %s\n",
1576                            strerror (errno));
1577             }
1578           else
1579             log_info ("no saved signal mask\n");
1580 #endif /*HAVE_SIGPROCMASK*/
1581
1582           /* Create the SSH info string if enabled. */
1583           if (ssh_support)
1584             {
1585               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1586                             socket_name_ssh) < 0)
1587                 {
1588                   log_error ("out of core\n");
1589                   kill (pid, SIGTERM);
1590                   exit (1);
1591                 }
1592               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1593                             (unsigned long)getpid()) < 0)
1594                 {
1595                   log_error ("out of core\n");
1596                   kill (pid, SIGTERM);
1597                   exit (1);
1598                 }
1599             }
1600
1601           *socket_name = 0; /* Don't let cleanup() remove the socket -
1602                                the child should do this from now on */
1603           if (opt.extra_socket)
1604             *socket_name_extra = 0;
1605           if (opt.browser_socket)
1606             *socket_name_browser = 0;
1607           *socket_name_ssh = 0;
1608
1609           if (argc)
1610             { /* Run the program given on the commandline.  */
1611               if (ssh_support && (putenv (infostr_ssh_sock)
1612                                   || putenv (infostr_ssh_valid)))
1613                 {
1614                   log_error ("failed to set environment: %s\n",
1615                              strerror (errno) );
1616                   kill (pid, SIGTERM );
1617                   exit (1);
1618                 }
1619
1620               /* Close all the file descriptors except the standard
1621                  ones and those open at startup.  We explicitly don't
1622                  close 0,1,2 in case something went wrong collecting
1623                  them at startup.  */
1624               close_all_fds (3, startup_fd_list);
1625
1626               /* Run the command.  */
1627               execvp (argv[0], argv);
1628               log_error ("failed to run the command: %s\n", strerror (errno));
1629               kill (pid, SIGTERM);
1630               exit (1);
1631             }
1632           else
1633             {
1634               /* Print the environment string, so that the caller can use
1635                  shell's eval to set it */
1636               if (csh_style)
1637                 {
1638                   if (ssh_support)
1639                     {
1640                       *strchr (infostr_ssh_sock, '=') = ' ';
1641                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1642                     }
1643                 }
1644               else
1645                 {
1646                   if (ssh_support)
1647                     {
1648                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1649                                  infostr_ssh_sock);
1650                     }
1651                 }
1652               if (ssh_support)
1653                 {
1654                   xfree (infostr_ssh_sock);
1655                   xfree (infostr_ssh_valid);
1656                 }
1657               exit (0);
1658             }
1659           /*NOTREACHED*/
1660         } /* End parent */
1661
1662       /*
1663          This is the child
1664        */
1665
1666       initialize_modules ();
1667
1668       /* Detach from tty and put process into a new session */
1669       if (!nodetach )
1670         {
1671           int i;
1672           unsigned int oldflags;
1673
1674           /* Close stdin, stdout and stderr unless it is the log stream */
1675           for (i=0; i <= 2; i++)
1676             {
1677               if (!log_test_fd (i) && i != fd )
1678                 {
1679                   if ( ! close (i)
1680                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1681                     {
1682                       log_error ("failed to open '%s': %s\n",
1683                                  "/dev/null", strerror (errno));
1684                       cleanup ();
1685                       exit (1);
1686                     }
1687                 }
1688             }
1689           if (setsid() == -1)
1690             {
1691               log_error ("setsid() failed: %s\n", strerror(errno) );
1692               cleanup ();
1693               exit (1);
1694             }
1695
1696           log_get_prefix (&oldflags);
1697           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1698           opt.running_detached = 1;
1699         }
1700
1701       if (chdir("/"))
1702         {
1703           log_error ("chdir to / failed: %s\n", strerror (errno));
1704           exit (1);
1705         }
1706
1707       {
1708         struct sigaction sa;
1709
1710         sa.sa_handler = SIG_IGN;
1711         sigemptyset (&sa.sa_mask);
1712         sa.sa_flags = 0;
1713         sigaction (SIGPIPE, &sa, NULL);
1714       }
1715 #endif /*!HAVE_W32_SYSTEM*/
1716
1717       log_info ("%s %s started\n", strusage(11), strusage(13) );
1718       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1719       assuan_sock_close (fd);
1720     }
1721
1722   return 0;
1723 }
1724
1725
1726 /* Exit entry point.  This function should be called instead of a
1727    plain exit.  */
1728 void
1729 agent_exit (int rc)
1730 {
1731   /*FIXME: update_random_seed_file();*/
1732
1733   /* We run our cleanup handler because that may close cipher contexts
1734      stored in secure memory and thus this needs to be done before we
1735      explicitly terminate secure memory.  */
1736   cleanup ();
1737
1738 #if 1
1739   /* at this time a bit annoying */
1740   if (opt.debug & DBG_MEMSTAT_VALUE)
1741     {
1742       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1743       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1744     }
1745   if (opt.debug)
1746     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1747 #endif
1748   gcry_control (GCRYCTL_TERM_SECMEM );
1749   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1750   exit (rc);
1751 }
1752
1753
1754 /* This is our callback function for gcrypt progress messages.  It is
1755    set once at startup and dispatches progress messages to the
1756    corresponding threads of the agent.  */
1757 static void
1758 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1759                              int current, int total)
1760 {
1761   struct progress_dispatch_s *dispatch;
1762   npth_t mytid = npth_self ();
1763
1764   (void)data;
1765
1766   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1767     if (dispatch->ctrl && dispatch->tid == mytid)
1768       break;
1769   if (dispatch && dispatch->cb)
1770     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1771
1772   /* Libgcrypt < 1.8 does not know about nPth and thus when it reads
1773    * from /dev/random this will block the process.  To mitigate this
1774    * problem we take a short nap when Libgcrypt tells us that it needs
1775    * more entropy.  This way other threads have chance to run.  */
1776 #if GCRYPT_VERSION_NUMBER < 0x010800 /* 1.8.0 */
1777   if (what && !strcmp (what, "need_entropy"))
1778     npth_usleep (100000); /* 100ms */
1779 #endif
1780 }
1781
1782
1783 /* If a progress dispatcher callback has been associated with the
1784  * current connection unregister it.  */
1785 static void
1786 unregister_progress_cb (void)
1787 {
1788   struct progress_dispatch_s *dispatch;
1789   npth_t mytid = npth_self ();
1790
1791   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1792     if (dispatch->ctrl && dispatch->tid == mytid)
1793       break;
1794   if (dispatch)
1795     {
1796       dispatch->ctrl = NULL;
1797       dispatch->cb = NULL;
1798     }
1799 }
1800
1801
1802 /* Setup a progress callback CB for the current connection.  Using a
1803  * CB of NULL disables the callback.  */
1804 void
1805 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1806                                   int printchar, int current, int total),
1807                        ctrl_t ctrl)
1808 {
1809   struct progress_dispatch_s *dispatch, *firstfree;
1810   npth_t mytid = npth_self ();
1811
1812   firstfree = NULL;
1813   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1814     {
1815       if (dispatch->ctrl && dispatch->tid == mytid)
1816         break;
1817       if (!dispatch->ctrl && !firstfree)
1818         firstfree = dispatch;
1819     }
1820   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1821     {
1822       if (firstfree)
1823         {
1824           dispatch = firstfree;
1825         }
1826       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1827         {
1828           dispatch->next = progress_dispatch_list;
1829           progress_dispatch_list = dispatch;
1830         }
1831       else
1832         {
1833           log_error ("error allocating new progress dispatcher slot: %s\n",
1834                      gpg_strerror (gpg_error_from_syserror ()));
1835           return;
1836         }
1837       dispatch->ctrl = ctrl;
1838       dispatch->tid = mytid;
1839     }
1840
1841   dispatch->cb = cb;
1842 }
1843
1844
1845 /* Each thread has its own local variables conveyed by a control
1846    structure usually identified by an argument named CTRL.  This
1847    function is called immediately after allocating the control
1848    structure.  Its purpose is to setup the default values for that
1849    structure.  Note that some values may have already been set.  */
1850 static void
1851 agent_init_default_ctrl (ctrl_t ctrl)
1852 {
1853   assert (ctrl->session_env);
1854
1855   /* Note we ignore malloc errors because we can't do much about it
1856      and the request will fail anyway shortly after this
1857      initialization. */
1858   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1859   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1860   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1861   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1862   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1863
1864   if (ctrl->lc_ctype)
1865     xfree (ctrl->lc_ctype);
1866   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1867
1868   if (ctrl->lc_messages)
1869     xfree (ctrl->lc_messages);
1870   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1871                                     /**/ : NULL;
1872   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1873 }
1874
1875
1876 /* Release all resources allocated by default in the control
1877    structure.  This is the counterpart to agent_init_default_ctrl.  */
1878 static void
1879 agent_deinit_default_ctrl (ctrl_t ctrl)
1880 {
1881   unregister_progress_cb ();
1882   session_env_release (ctrl->session_env);
1883
1884   if (ctrl->lc_ctype)
1885     xfree (ctrl->lc_ctype);
1886   if (ctrl->lc_messages)
1887     xfree (ctrl->lc_messages);
1888 }
1889
1890
1891 /* Because the ssh protocol does not send us information about the
1892    current TTY setting, we use this function to use those from startup
1893    or those explicitly set.  This is also used for the restricted mode
1894    where we ignore requests to change the environment.  */
1895 gpg_error_t
1896 agent_copy_startup_env (ctrl_t ctrl)
1897 {
1898   static const char *names[] =
1899     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1900   gpg_error_t err = 0;
1901   int idx;
1902   const char *value;
1903
1904   for (idx=0; !err && names[idx]; idx++)
1905       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1906       err = session_env_setenv (ctrl->session_env, names[idx], value);
1907
1908   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1909     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1910       err = gpg_error_from_syserror ();
1911
1912   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1913     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1914       err = gpg_error_from_syserror ();
1915
1916   if (err)
1917     log_error ("error setting default session environment: %s\n",
1918                gpg_strerror (err));
1919
1920   return err;
1921 }
1922
1923
1924 /* Reread parts of the configuration.  Note, that this function is
1925    obviously not thread-safe and should only be called from the PTH
1926    signal handler.
1927
1928    Fixme: Due to the way the argument parsing works, we create a
1929    memory leak here for all string type arguments.  There is currently
1930    no clean way to tell whether the memory for the argument has been
1931    allocated or points into the process' original arguments.  Unless
1932    we have a mechanism to tell this, we need to live on with this. */
1933 static void
1934 reread_configuration (void)
1935 {
1936   ARGPARSE_ARGS pargs;
1937   FILE *fp;
1938   unsigned int configlineno = 0;
1939   int dummy;
1940
1941   if (!config_filename)
1942     return; /* No config file. */
1943
1944   fp = fopen (config_filename, "r");
1945   if (!fp)
1946     {
1947       log_info (_("option file '%s': %s\n"),
1948                 config_filename, strerror(errno) );
1949       return;
1950     }
1951
1952   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1953
1954   memset (&pargs, 0, sizeof pargs);
1955   dummy = 0;
1956   pargs.argc = &dummy;
1957   pargs.flags = 1;  /* do not remove the args */
1958   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1959     {
1960       if (pargs.r_opt < -1)
1961         pargs.err = 1; /* Print a warning. */
1962       else /* Try to parse this option - ignore unchangeable ones. */
1963         parse_rereadable_options (&pargs, 1);
1964     }
1965   fclose (fp);
1966   finalize_rereadable_options ();
1967   set_debug ();
1968 }
1969
1970
1971 /* Return the file name of the socket we are using for native
1972    requests.  */
1973 const char *
1974 get_agent_socket_name (void)
1975 {
1976   const char *s = socket_name;
1977
1978   return (s && *s)? s : NULL;
1979 }
1980
1981 /* Return the file name of the socket we are using for SSH
1982    requests.  */
1983 const char *
1984 get_agent_ssh_socket_name (void)
1985 {
1986   const char *s = socket_name_ssh;
1987
1988   return (s && *s)? s : NULL;
1989 }
1990
1991
1992 static void
1993 lock_active_connections (void)
1994 {
1995   int err;
1996
1997   err = npth_mutex_lock (&active_connections_lock);
1998   if (err)
1999     log_fatal ("failed to acquire active connection count mutex: %s\n",
2000                strerror (err));
2001 }
2002
2003 static void
2004 unlock_active_connections (void)
2005 {
2006   int err;
2007
2008   err = npth_mutex_unlock (&active_connections_lock);
2009   if (err)
2010     log_fatal ("failed to release active connection count mutex: %s\n",
2011                strerror (err));
2012 }
2013
2014 /* Return the number of active connections. */
2015 int
2016 get_agent_active_connection_count (void)
2017 {
2018   int value;
2019
2020   lock_active_connections();
2021   value = active_connections_value;
2022   unlock_active_connections();
2023   return value;
2024 }
2025
2026 /* Increment/decrement the number of active connections. */
2027 static void
2028 adjust_agent_active_connections (int delta)
2029 {
2030   lock_active_connections();
2031   active_connections_value += delta;
2032   unlock_active_connections();
2033 }
2034
2035
2036 /* Under W32, this function returns the handle of the scdaemon
2037    notification event.  Calling it the first time creates that
2038    event.  */
2039 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2040 void *
2041 get_agent_scd_notify_event (void)
2042 {
2043   static HANDLE the_event = INVALID_HANDLE_VALUE;
2044
2045   if (the_event == INVALID_HANDLE_VALUE)
2046     {
2047       HANDLE h, h2;
2048       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2049
2050       /* We need to use a manual reset event object due to the way our
2051          w32-pth wait function works: If we would use an automatic
2052          reset event we are not able to figure out which handle has
2053          been signaled because at the time we single out the signaled
2054          handles using WFSO the event has already been reset due to
2055          the WFMO.  */
2056       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2057       if (!h)
2058         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2059       else if (!DuplicateHandle (GetCurrentProcess(), h,
2060                                  GetCurrentProcess(), &h2,
2061                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2062         {
2063           log_error ("setting synchronize for scd notify event failed: %s\n",
2064                      w32_strerror (-1) );
2065           CloseHandle (h);
2066         }
2067       else
2068         {
2069           CloseHandle (h);
2070           the_event = h2;
2071         }
2072     }
2073
2074   return the_event;
2075 }
2076 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2077
2078
2079
2080 /* Create a name for the socket in the home directory as using
2081    STANDARD_NAME.  We also check for valid characters as well as
2082    against a maximum allowed length for a unix domain socket is done.
2083    The function terminates the process in case of an error.  Returns:
2084    Pointer to an allocated string with the absolute name of the socket
2085    used.  */
2086 static char *
2087 create_socket_name (char *standard_name, int with_homedir)
2088 {
2089   char *name;
2090
2091   if (with_homedir)
2092     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2093   else
2094     name = make_filename (standard_name, NULL);
2095   if (strchr (name, PATHSEP_C))
2096     {
2097       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2098       agent_exit (2);
2099     }
2100   return name;
2101 }
2102
2103
2104
2105 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2106    or terminates the process in case of an error.  Note that this
2107    function needs to be used for the regular socket first (indicated
2108    by PRIMARY) and only then for the extra and the ssh sockets.  If
2109    the socket has been redirected the name of the real socket is
2110    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2111    Cygwin compatible socket is created (Windows only). */
2112 static gnupg_fd_t
2113 create_server_socket (char *name, int primary, int cygwin,
2114                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2115 {
2116   struct sockaddr *addr;
2117   struct sockaddr_un *unaddr;
2118   socklen_t len;
2119   gnupg_fd_t fd;
2120   int rc;
2121
2122   xfree (*r_redir_name);
2123   *r_redir_name = NULL;
2124
2125   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2126   if (fd == ASSUAN_INVALID_FD)
2127     {
2128       log_error (_("can't create socket: %s\n"), strerror (errno));
2129       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2130       agent_exit (2);
2131     }
2132
2133   if (cygwin)
2134     assuan_sock_set_flag (fd, "cygwin", 1);
2135
2136   unaddr = xmalloc (sizeof *unaddr);
2137   addr = (struct sockaddr*)unaddr;
2138
2139   {
2140     int redirected;
2141
2142     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2143       {
2144         if (errno == ENAMETOOLONG)
2145           log_error (_("socket name '%s' is too long\n"), name);
2146         else
2147           log_error ("error preparing socket '%s': %s\n",
2148                      name, gpg_strerror (gpg_error_from_syserror ()));
2149         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2150         agent_exit (2);
2151       }
2152     if (redirected)
2153       {
2154         *r_redir_name = xstrdup (unaddr->sun_path);
2155         if (opt.verbose)
2156           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2157       }
2158   }
2159
2160   len = SUN_LEN (unaddr);
2161   rc = assuan_sock_bind (fd, addr, len);
2162
2163   /* Our error code mapping on W32CE returns EEXIST thus we also test
2164      for this. */
2165   if (rc == -1
2166       && (errno == EADDRINUSE
2167 #ifdef HAVE_W32_SYSTEM
2168           || errno == EEXIST
2169 #endif
2170           ))
2171     {
2172       /* Check whether a gpg-agent is already running.  We do this
2173          test only if this is the primary socket.  For secondary
2174          sockets we assume that a test for gpg-agent has already been
2175          done and reuse the requested socket.  Testing the ssh-socket
2176          is not possible because at this point, though we know the new
2177          Assuan socket, the Assuan server and thus the ssh-agent
2178          server is not yet operational; this would lead to a hang.  */
2179       if (primary && !check_for_running_agent (1))
2180         {
2181           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2182           log_set_file (NULL);
2183           log_error (_("a gpg-agent is already running - "
2184                        "not starting a new one\n"));
2185           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2186           assuan_sock_close (fd);
2187           agent_exit (2);
2188         }
2189       gnupg_remove (unaddr->sun_path);
2190       rc = assuan_sock_bind (fd, addr, len);
2191     }
2192   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2193     log_error (_("error getting nonce for the socket\n"));
2194   if (rc == -1)
2195     {
2196       /* We use gpg_strerror here because it allows us to get strings
2197          for some W32 socket error codes.  */
2198       log_error (_("error binding socket to '%s': %s\n"),
2199                  unaddr->sun_path,
2200                  gpg_strerror (gpg_error_from_syserror ()));
2201
2202       assuan_sock_close (fd);
2203       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2204       agent_exit (2);
2205     }
2206
2207   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2208     log_error (_("can't set permissions of '%s': %s\n"),
2209                unaddr->sun_path, strerror (errno));
2210
2211   if (listen (FD2INT(fd), 5 ) == -1)
2212     {
2213       log_error (_("listen() failed: %s\n"), strerror (errno));
2214       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2215       assuan_sock_close (fd);
2216       agent_exit (2);
2217     }
2218
2219   if (opt.verbose)
2220     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2221
2222   return fd;
2223 }
2224
2225
2226 /* Check that the directory for storing the private keys exists and
2227    create it if not.  This function won't fail as it is only a
2228    convenience function and not strictly necessary.  */
2229 static void
2230 create_private_keys_directory (const char *home)
2231 {
2232   char *fname;
2233   struct stat statbuf;
2234
2235   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2236   if (stat (fname, &statbuf) && errno == ENOENT)
2237     {
2238       if (gnupg_mkdir (fname, "-rwx"))
2239         log_error (_("can't create directory '%s': %s\n"),
2240                    fname, strerror (errno) );
2241       else if (!opt.quiet)
2242         log_info (_("directory '%s' created\n"), fname);
2243     }
2244   if (gnupg_chmod (fname, "-rwx"))
2245     log_error (_("can't set permissions of '%s': %s\n"),
2246                fname, strerror (errno));
2247   xfree (fname);
2248 }
2249
2250
2251 /* Create the directory only if the supplied directory name is the
2252    same as the default one.  This way we avoid to create arbitrary
2253    directories when a non-default home directory is used.  To cope
2254    with HOME, we compare only the suffix if we see that the default
2255    homedir does start with a tilde.  We don't stop here in case of
2256    problems because other functions will throw an error anyway.*/
2257 static void
2258 create_directories (void)
2259 {
2260   struct stat statbuf;
2261   const char *defhome = standard_homedir ();
2262   char *home;
2263
2264   home = make_filename (gnupg_homedir (), NULL);
2265   if ( stat (home, &statbuf) )
2266     {
2267       if (errno == ENOENT)
2268         {
2269           if (
2270 #ifdef HAVE_W32_SYSTEM
2271               ( !compare_filenames (home, defhome) )
2272 #else
2273               (*defhome == '~'
2274                 && (strlen (home) >= strlen (defhome+1)
2275                     && !strcmp (home + strlen(home)
2276                                 - strlen (defhome+1), defhome+1)))
2277                || (*defhome != '~' && !strcmp (home, defhome) )
2278 #endif
2279                )
2280             {
2281               if (gnupg_mkdir (home, "-rwx"))
2282                 log_error (_("can't create directory '%s': %s\n"),
2283                            home, strerror (errno) );
2284               else
2285                 {
2286                   if (!opt.quiet)
2287                     log_info (_("directory '%s' created\n"), home);
2288                   create_private_keys_directory (home);
2289                 }
2290             }
2291         }
2292       else
2293         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2294     }
2295   else if ( !S_ISDIR(statbuf.st_mode))
2296     {
2297       log_error (_("can't use '%s' as home directory\n"), home);
2298     }
2299   else /* exists and is a directory. */
2300     {
2301       create_private_keys_directory (home);
2302     }
2303   xfree (home);
2304 }
2305
2306
2307 static int
2308 need_tick (void)
2309 {
2310 #ifdef HAVE_W32_SYSTEM
2311   /* We do not know how to interrupt the select loop on Windows, so we
2312      always need a short tick there. */
2313   return 1;
2314 #else
2315   /* if we were invoked like "gpg-agent cmd arg1 arg2" then we need to
2316      watch our parent. */
2317   if (parent_pid != (pid_t)(-1))
2318     return 1;
2319   /* if scdaemon is running, we need to check that it's alive */
2320   if (agent_scd_check_running ())
2321     return 1;
2322   /* otherwise, nothing fine-grained to do. */
2323   return 0;
2324 #endif /*HAVE_W32_SYSTEM*/
2325 }
2326
2327
2328 /* This is the worker for the ticker.  It is called every few seconds
2329    and may only do fast operations. */
2330 static void
2331 handle_tick (void)
2332 {
2333   /* Check whether the scdaemon has died and cleanup in this case. */
2334   agent_scd_check_aliveness ();
2335
2336   /* If we are running as a child of another process, check whether
2337      the parent is still alive and shutdown if not. */
2338 #ifndef HAVE_W32_SYSTEM
2339   if (parent_pid != (pid_t)(-1))
2340     {
2341       if (kill (parent_pid, 0))
2342         {
2343           shutdown_pending = 2;
2344           log_info ("parent process died - shutting down\n");
2345           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2346           cleanup ();
2347           agent_exit (0);
2348         }
2349     }
2350 #endif /*HAVE_W32_SYSTEM*/
2351 }
2352
2353
2354 /* A global function which allows us to call the reload stuff from
2355    other places too.  This is only used when build for W32.  */
2356 void
2357 agent_sighup_action (void)
2358 {
2359   log_info ("SIGHUP received - "
2360             "re-reading configuration and flushing cache\n");
2361
2362   agent_flush_cache ();
2363   reread_configuration ();
2364   agent_reload_trustlist ();
2365   /* We flush the module name cache so that after installing a
2366      "pinentry" binary that one can be used in case the
2367      "pinentry-basic" fallback was in use.  */
2368   gnupg_module_name_flush_some ();
2369 }
2370
2371
2372 /* A helper function to handle SIGUSR2.  */
2373 static void
2374 agent_sigusr2_action (void)
2375 {
2376   if (opt.verbose)
2377     log_info ("SIGUSR2 received - updating card event counter\n");
2378   /* Nothing to check right now.  We only increment a counter.  */
2379   bump_card_eventcounter ();
2380 }
2381
2382
2383 #ifndef HAVE_W32_SYSTEM
2384 /* The signal handler for this program.  It is expected to be run in
2385    its own thread and not in the context of a signal handler.  */
2386 static void
2387 handle_signal (int signo)
2388 {
2389   switch (signo)
2390     {
2391 #ifndef HAVE_W32_SYSTEM
2392     case SIGHUP:
2393       agent_sighup_action ();
2394       break;
2395
2396     case SIGUSR1:
2397       log_info ("SIGUSR1 received - printing internal information:\n");
2398       /* Fixme: We need to see how to integrate pth dumping into our
2399          logging system.  */
2400       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2401       agent_query_dump_state ();
2402       agent_scd_dump_state ();
2403       break;
2404
2405     case SIGUSR2:
2406       agent_sigusr2_action ();
2407       break;
2408
2409       /* nothing to do here, just take an extra cycle on the select loop */
2410     case SIGCONT:
2411       break;
2412
2413     case SIGTERM:
2414       if (!shutdown_pending)
2415         log_info ("SIGTERM received - shutting down ...\n");
2416       else
2417         log_info ("SIGTERM received - still %i open connections\n",
2418                   get_agent_active_connection_count());
2419       shutdown_pending++;
2420       if (shutdown_pending > 2)
2421         {
2422           log_info ("shutdown forced\n");
2423           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2424           cleanup ();
2425           agent_exit (0);
2426         }
2427       break;
2428
2429     case SIGINT:
2430       log_info ("SIGINT received - immediate shutdown\n");
2431       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2432       cleanup ();
2433       agent_exit (0);
2434       break;
2435 #endif
2436     default:
2437       log_info ("signal %d received - no action defined\n", signo);
2438     }
2439 }
2440 #endif
2441
2442 /* Check the nonce on a new connection.  This is a NOP unless we we
2443    are using our Unix domain socket emulation under Windows.  */
2444 static int
2445 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2446 {
2447   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2448     {
2449       log_info (_("error reading nonce on fd %d: %s\n"),
2450                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2451       assuan_sock_close (ctrl->thread_startup.fd);
2452       xfree (ctrl);
2453       return -1;
2454     }
2455   else
2456     return 0;
2457 }
2458
2459
2460 #ifdef HAVE_W32_SYSTEM
2461 /* The window message processing function for Putty.  Warning: This
2462    code runs as a native Windows thread.  Use of our own functions
2463    needs to be bracket with pth_leave/pth_enter. */
2464 static LRESULT CALLBACK
2465 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2466 {
2467   int ret = 0;
2468   int w32rc;
2469   COPYDATASTRUCT *cds;
2470   const char *mapfile;
2471   HANDLE maphd;
2472   PSID mysid = NULL;
2473   PSID mapsid = NULL;
2474   void *data = NULL;
2475   PSECURITY_DESCRIPTOR psd = NULL;
2476   ctrl_t ctrl = NULL;
2477
2478   if (msg != WM_COPYDATA)
2479     {
2480       return DefWindowProc (hwnd, msg, wparam, lparam);
2481     }
2482
2483   cds = (COPYDATASTRUCT*)lparam;
2484   if (cds->dwData != PUTTY_IPC_MAGIC)
2485     return 0;  /* Ignore data with the wrong magic.  */
2486   mapfile = cds->lpData;
2487   if (!cds->cbData || mapfile[cds->cbData - 1])
2488     return 0;  /* Ignore empty and non-properly terminated strings.  */
2489
2490   if (DBG_IPC)
2491     {
2492       npth_protect ();
2493       log_debug ("ssh map file '%s'", mapfile);
2494       npth_unprotect ();
2495     }
2496
2497   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2498   if (DBG_IPC)
2499     {
2500       npth_protect ();
2501       log_debug ("ssh map handle %p\n", maphd);
2502       npth_unprotect ();
2503     }
2504
2505   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2506     return 0;
2507
2508   npth_protect ();
2509
2510   mysid = w32_get_user_sid ();
2511   if (!mysid)
2512     {
2513       log_error ("error getting my sid\n");
2514       goto leave;
2515     }
2516
2517   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2518                            OWNER_SECURITY_INFORMATION,
2519                            &mapsid, NULL, NULL, NULL,
2520                            &psd);
2521   if (w32rc)
2522     {
2523       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2524       goto leave;
2525     }
2526
2527   if (DBG_IPC)
2528     {
2529       char *sidstr;
2530
2531       if (!ConvertSidToStringSid (mysid, &sidstr))
2532         sidstr = NULL;
2533       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2534       LocalFree (sidstr);
2535       if (!ConvertSidToStringSid (mapsid, &sidstr))
2536         sidstr = NULL;
2537       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2538       LocalFree (sidstr);
2539     }
2540
2541   if (!EqualSid (mysid, mapsid))
2542     {
2543       log_error ("ssh map file has a non-matching sid\n");
2544       goto leave;
2545     }
2546
2547   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2548   if (DBG_IPC)
2549     log_debug ("ssh IPC buffer at %p\n", data);
2550   if (!data)
2551     goto leave;
2552
2553   /* log_printhex ("request:", data, 20); */
2554
2555   ctrl = xtrycalloc (1, sizeof *ctrl);
2556   if (!ctrl)
2557     {
2558       log_error ("error allocating connection control data: %s\n",
2559                  strerror (errno) );
2560       goto leave;
2561     }
2562   ctrl->session_env = session_env_new ();
2563   if (!ctrl->session_env)
2564     {
2565       log_error ("error allocating session environment block: %s\n",
2566                  strerror (errno) );
2567       goto leave;
2568     }
2569
2570   agent_init_default_ctrl (ctrl);
2571   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2572     ret = 1; /* Valid ssh message has been constructed.  */
2573   agent_deinit_default_ctrl (ctrl);
2574   /* log_printhex ("  reply:", data, 20); */
2575
2576  leave:
2577   xfree (ctrl);
2578   if (data)
2579     UnmapViewOfFile (data);
2580   xfree (mapsid);
2581   if (psd)
2582     LocalFree (psd);
2583   xfree (mysid);
2584   CloseHandle (maphd);
2585
2586   npth_unprotect ();
2587
2588   return ret;
2589 }
2590 #endif /*HAVE_W32_SYSTEM*/
2591
2592
2593 #ifdef HAVE_W32_SYSTEM
2594 /* The thread handling Putty's IPC requests.  */
2595 static void *
2596 putty_message_thread (void *arg)
2597 {
2598   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2599                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2600   HWND hwnd;
2601   MSG msg;
2602
2603   (void)arg;
2604
2605   if (opt.verbose)
2606     log_info ("putty message loop thread started\n");
2607
2608   /* The message loop runs as thread independent from our nPth system.
2609      This also means that we need to make sure that we switch back to
2610      our system before calling any no-windows function.  */
2611   npth_unprotect ();
2612
2613   /* First create a window to make sure that a message queue exists
2614      for this thread.  */
2615   if (!RegisterClass (&wndwclass))
2616     {
2617       npth_protect ();
2618       log_error ("error registering Pageant window class");
2619       return NULL;
2620     }
2621   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2622                          0, 0, 0, 0,
2623                          HWND_MESSAGE,  /* hWndParent */
2624                          NULL,          /* hWndMenu   */
2625                          NULL,          /* hInstance  */
2626                          NULL);         /* lpParm     */
2627   if (!hwnd)
2628     {
2629       npth_protect ();
2630       log_error ("error creating Pageant window");
2631       return NULL;
2632     }
2633
2634   while (GetMessage(&msg, NULL, 0, 0))
2635     {
2636       TranslateMessage(&msg);
2637       DispatchMessage(&msg);
2638     }
2639
2640   /* Back to nPth.  */
2641   npth_protect ();
2642
2643   if (opt.verbose)
2644     log_info ("putty message loop thread stopped\n");
2645   return NULL;
2646 }
2647 #endif /*HAVE_W32_SYSTEM*/
2648
2649
2650 static void *
2651 do_start_connection_thread (ctrl_t ctrl)
2652 {
2653   adjust_agent_active_connections(+1);
2654   agent_init_default_ctrl (ctrl);
2655   if (opt.verbose && !DBG_IPC)
2656     log_info (_("handler 0x%lx for fd %d started\n"),
2657               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2658
2659   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2660   if (opt.verbose && !DBG_IPC)
2661     log_info (_("handler 0x%lx for fd %d terminated\n"),
2662               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2663
2664   agent_deinit_default_ctrl (ctrl);
2665   xfree (ctrl);
2666   adjust_agent_active_connections(-1);
2667   return NULL;
2668 }
2669
2670
2671 /* This is the standard connection thread's main function.  */
2672 static void *
2673 start_connection_thread_std (void *arg)
2674 {
2675   ctrl_t ctrl = arg;
2676
2677   if (check_nonce (ctrl, &socket_nonce))
2678     {
2679       log_error ("handler 0x%lx nonce check FAILED\n",
2680                  (unsigned long) npth_self());
2681       return NULL;
2682     }
2683
2684   return do_start_connection_thread (ctrl);
2685 }
2686
2687
2688 /* This is the extra socket connection thread's main function.  */
2689 static void *
2690 start_connection_thread_extra (void *arg)
2691 {
2692   ctrl_t ctrl = arg;
2693
2694   if (check_nonce (ctrl, &socket_nonce_extra))
2695     {
2696       log_error ("handler 0x%lx nonce check FAILED\n",
2697                  (unsigned long) npth_self());
2698       return NULL;
2699     }
2700
2701   ctrl->restricted = 1;
2702   return do_start_connection_thread (ctrl);
2703 }
2704
2705
2706 /* This is the browser socket connection thread's main function.  */
2707 static void *
2708 start_connection_thread_browser (void *arg)
2709 {
2710   ctrl_t ctrl = arg;
2711
2712   if (check_nonce (ctrl, &socket_nonce_browser))
2713     {
2714       log_error ("handler 0x%lx nonce check FAILED\n",
2715                  (unsigned long) npth_self());
2716       return NULL;
2717     }
2718
2719   ctrl->restricted = 2;
2720   return do_start_connection_thread (ctrl);
2721 }
2722
2723
2724 /* This is the ssh connection thread's main function.  */
2725 static void *
2726 start_connection_thread_ssh (void *arg)
2727 {
2728   ctrl_t ctrl = arg;
2729
2730   if (check_nonce (ctrl, &socket_nonce_ssh))
2731     return NULL;
2732
2733   adjust_agent_active_connections(+1);
2734   agent_init_default_ctrl (ctrl);
2735   if (opt.verbose)
2736     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2737               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2738
2739   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2740   if (opt.verbose)
2741     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2742               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2743
2744   agent_deinit_default_ctrl (ctrl);
2745   xfree (ctrl);
2746   adjust_agent_active_connections(-1);
2747   return NULL;
2748 }
2749
2750
2751 void interrupt_main_thread_loop (void)
2752 {
2753 #ifndef HAVE_W32_SYSTEM
2754   kill (main_thread_pid, SIGCONT);
2755 #endif
2756 }
2757
2758 /* helper function for readability: test whether a given struct
2759    timespec is set to all-zeros */
2760 static inline int
2761 tv_is_set (struct timespec tv)
2762 {
2763   return tv.tv_sec || tv.tv_nsec;
2764 }
2765
2766
2767 /* Connection handler loop.  Wait for connection requests and spawn a
2768    thread after accepting a connection.  */
2769 static void
2770 handle_connections (gnupg_fd_t listen_fd,
2771                     gnupg_fd_t listen_fd_extra,
2772                     gnupg_fd_t listen_fd_browser,
2773                     gnupg_fd_t listen_fd_ssh)
2774 {
2775   gpg_error_t err;
2776   npth_attr_t tattr;
2777   struct sockaddr_un paddr;
2778   socklen_t plen;
2779   fd_set fdset, read_fdset;
2780   int ret;
2781   gnupg_fd_t fd;
2782   int nfd;
2783   int saved_errno;
2784   int idx;
2785   struct timespec abstime;
2786   struct timespec curtime;
2787   struct timespec timeout;
2788   struct timespec *select_timeout;
2789 #ifdef HAVE_W32_SYSTEM
2790   HANDLE events[2];
2791   unsigned int events_set;
2792 #endif
2793   int my_inotify_fd = -1;
2794   struct {
2795     const char *name;
2796     void *(*func) (void *arg);
2797     gnupg_fd_t l_fd;
2798   } listentbl[] = {
2799     { "std",     start_connection_thread_std   },
2800     { "extra",   start_connection_thread_extra },
2801     { "browser", start_connection_thread_browser },
2802     { "ssh",    start_connection_thread_ssh   }
2803   };
2804   struct {
2805     struct timespec interval;
2806     void (*func) (void);
2807     struct timespec next;
2808   } timertbl[] = {
2809     { { TIMERTICK_INTERVAL, 0 }, handle_tick },
2810     { { CHECK_OWN_SOCKET_INTERVAL, 0 }, check_own_socket }
2811   };
2812
2813   ret = npth_mutex_init (&active_connections_lock, NULL);
2814   if (ret)
2815     log_fatal ("error allocating active connections mutex: %s\n",
2816                strerror (ret));
2817
2818   ret = npth_attr_init(&tattr);
2819   if (ret)
2820     log_fatal ("error allocating thread attributes: %s\n",
2821                strerror (ret));
2822   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2823
2824 #ifndef HAVE_W32_SYSTEM
2825   npth_sigev_init ();
2826   npth_sigev_add (SIGHUP);
2827   npth_sigev_add (SIGUSR1);
2828   npth_sigev_add (SIGUSR2);
2829   npth_sigev_add (SIGINT);
2830   npth_sigev_add (SIGCONT);
2831   npth_sigev_add (SIGTERM);
2832   npth_sigev_fini ();
2833   main_thread_pid = getpid ();
2834 #else
2835 # ifdef HAVE_W32CE_SYSTEM
2836   /* Use a dummy event. */
2837   sigs = 0;
2838   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2839 # else
2840   events[0] = get_agent_scd_notify_event ();
2841   events[1] = INVALID_HANDLE_VALUE;
2842 # endif
2843 #endif
2844
2845
2846   if (disable_check_own_socket)
2847     my_inotify_fd = -1;
2848   else if ((err = gnupg_inotify_watch_socket (&my_inotify_fd, socket_name)))
2849     {
2850       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2851         log_info ("error enabling fast daemon termination: %s\n",
2852                   gpg_strerror (err));
2853     }
2854
2855   /* On Windows we need to fire up a separate thread to listen for
2856      requests from Putty (an SSH client), so we can replace Putty's
2857      Pageant (its ssh-agent implementation). */
2858 #ifdef HAVE_W32_SYSTEM
2859   if (putty_support)
2860     {
2861       npth_t thread;
2862
2863       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2864       if (ret)
2865         {
2866           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2867         }
2868     }
2869 #endif /*HAVE_W32_SYSTEM*/
2870
2871   /* Set a flag to tell call-scd.c that it may enable event
2872      notifications.  */
2873   opt.sigusr2_enabled = 1;
2874
2875   FD_ZERO (&fdset);
2876   FD_SET (FD2INT (listen_fd), &fdset);
2877   nfd = FD2INT (listen_fd);
2878   if (listen_fd_extra != GNUPG_INVALID_FD)
2879     {
2880       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2881       if (FD2INT (listen_fd_extra) > nfd)
2882         nfd = FD2INT (listen_fd_extra);
2883     }
2884   if (listen_fd_browser != GNUPG_INVALID_FD)
2885     {
2886       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2887       if (FD2INT (listen_fd_browser) > nfd)
2888         nfd = FD2INT (listen_fd_browser);
2889     }
2890   if (listen_fd_ssh != GNUPG_INVALID_FD)
2891     {
2892       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2893       if (FD2INT (listen_fd_ssh) > nfd)
2894         nfd = FD2INT (listen_fd_ssh);
2895     }
2896   if (my_inotify_fd != -1)
2897     {
2898       FD_SET (my_inotify_fd, &fdset);
2899       if (my_inotify_fd > nfd)
2900         nfd = my_inotify_fd;
2901     }
2902
2903   listentbl[0].l_fd = listen_fd;
2904   listentbl[1].l_fd = listen_fd_extra;
2905   listentbl[2].l_fd = listen_fd_browser;
2906   listentbl[3].l_fd = listen_fd_ssh;
2907
2908   for (;;)
2909     {
2910       /* Shutdown test.  */
2911       if (shutdown_pending)
2912         {
2913           if (get_agent_active_connection_count() == 0)
2914             break; /* ready */
2915
2916           /* Do not accept new connections but keep on running the
2917            * loop to cope with the timer events.
2918            *
2919            * Note that we do not close the listening socket because a
2920            * client trying to connect to that socket would instead
2921            * restart a new dirmngr instance - which is unlikely the
2922            * intention of a shutdown. */
2923           FD_ZERO (&fdset);
2924           nfd = -1;
2925           if (my_inotify_fd != -1)
2926             {
2927               FD_SET (my_inotify_fd, &fdset);
2928               nfd = my_inotify_fd;
2929             }
2930         }
2931
2932       /* POSIX says that fd_set should be implemented as a structure,
2933          thus a simple assignment is fine to copy the entire set.  */
2934       read_fdset = fdset;
2935
2936       /* avoid a fine-grained timer if we don't need one: */
2937       timertbl[0].interval.tv_sec = need_tick () ? TIMERTICK_INTERVAL : 0;
2938       /* avoid waking up to check sockets if we can count on inotify */
2939       timertbl[1].interval.tv_sec = (my_inotify_fd == -1) ? CHECK_OWN_SOCKET_INTERVAL : 0;
2940
2941       /* loop through all timers, fire any registered functions, and
2942          plan next timer to trigger */
2943       npth_clock_gettime (&curtime);
2944       abstime.tv_sec = abstime.tv_nsec = 0;
2945       for (idx=0; idx < DIM(timertbl); idx++)
2946         {
2947           /* schedule any unscheduled timers */
2948           if ((!tv_is_set (timertbl[idx].next)) && tv_is_set (timertbl[idx].interval))
2949             npth_timeradd (&timertbl[idx].interval, &curtime, &timertbl[idx].next);
2950           /* if a timer is due, fire it ... */
2951           if (tv_is_set (timertbl[idx].next))
2952             {
2953               if (!(npth_timercmp (&curtime, &timertbl[idx].next, <)))
2954                 {
2955                   timertbl[idx].func ();
2956                   npth_clock_gettime (&curtime);
2957                   /* ...and reschedule it, if desired: */
2958                   if (tv_is_set (timertbl[idx].interval))
2959                     npth_timeradd (&timertbl[idx].interval, &curtime, &timertbl[idx].next);
2960                   else
2961                     timertbl[idx].next.tv_sec = timertbl[idx].next.tv_nsec = 0;
2962                 }
2963             }
2964           /* accumulate next timer to come due in abstime: */
2965           if (tv_is_set (timertbl[idx].next) &&
2966               ((!tv_is_set (abstime)) ||
2967                (npth_timercmp (&abstime, &timertbl[idx].next, >))))
2968             abstime = timertbl[idx].next;
2969         }
2970       /* choose a timeout for the select loop: */
2971       if (tv_is_set (abstime))
2972         {
2973           npth_timersub (&abstime, &curtime, &timeout);
2974           select_timeout = &timeout;
2975         }
2976       else
2977           select_timeout = NULL;
2978
2979
2980 #ifndef HAVE_W32_SYSTEM
2981       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, select_timeout,
2982                           npth_sigev_sigmask ());
2983       saved_errno = errno;
2984
2985       {
2986         int signo;
2987         while (npth_sigev_get_pending (&signo))
2988           handle_signal (signo);
2989       }
2990 #else
2991       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, select_timeout,
2992                           events, &events_set);
2993       saved_errno = errno;
2994
2995       /* This is valid even if npth_eselect returns an error.  */
2996       if (events_set & 1)
2997         agent_sigusr2_action ();
2998 #endif
2999
3000       if (ret == -1 && saved_errno != EINTR)
3001         {
3002           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
3003                      strerror (saved_errno));
3004           npth_sleep (1);
3005           continue;
3006         }
3007       if (ret <= 0)
3008         /* Interrupt or timeout.  Will be handled when calculating the
3009            next timeout.  */
3010         continue;
3011
3012       if (!shutdown_pending)
3013         {
3014           ctrl_t ctrl;
3015           npth_t thread;
3016
3017           if (my_inotify_fd != -1
3018               && FD_ISSET (my_inotify_fd, &read_fdset)
3019               && gnupg_inotify_has_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
3020             {
3021               shutdown_pending = 1;
3022               log_info ("socket file has been removed - shutting down\n");
3023             }
3024
3025           for (idx=0; idx < DIM(listentbl); idx++)
3026             {
3027               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
3028                 continue;
3029               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
3030                 continue;
3031
3032               plen = sizeof paddr;
3033               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
3034                                         (struct sockaddr *)&paddr, &plen));
3035               if (fd == GNUPG_INVALID_FD)
3036                 {
3037                   log_error ("accept failed for %s: %s\n",
3038                              listentbl[idx].name, strerror (errno));
3039                 }
3040               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
3041                 {
3042                   log_error ("error allocating connection data for %s: %s\n",
3043                              listentbl[idx].name, strerror (errno) );
3044                   assuan_sock_close (fd);
3045                 }
3046               else if ( !(ctrl->session_env = session_env_new ()))
3047                 {
3048                   log_error ("error allocating session env block for %s: %s\n",
3049                              listentbl[idx].name, strerror (errno) );
3050                   xfree (ctrl);
3051                   assuan_sock_close (fd);
3052                 }
3053               else
3054                 {
3055                   ctrl->thread_startup.fd = fd;
3056                   ret = npth_create (&thread, &tattr,
3057                                      listentbl[idx].func, ctrl);
3058                   if (ret)
3059                     {
3060                       log_error ("error spawning connection handler for %s:"
3061                                  " %s\n", listentbl[idx].name, strerror (ret));
3062                       assuan_sock_close (fd);
3063                       xfree (ctrl);
3064                     }
3065                 }
3066               fd = GNUPG_INVALID_FD;
3067             }
3068         }
3069     }
3070
3071   if (my_inotify_fd != -1)
3072     close (my_inotify_fd);
3073   cleanup ();
3074   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
3075   npth_attr_destroy (&tattr);
3076 }
3077
3078
3079
3080 /* Helper for check_own_socket.  */
3081 static gpg_error_t
3082 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3083 {
3084   membuf_t *mb = opaque;
3085   put_membuf (mb, buffer, length);
3086   return 0;
3087 }
3088
3089
3090 /* The thread running the actual check.  We need to run this in a
3091    separate thread so that check_own_thread can be called from the
3092    timer tick.  */
3093 static void *
3094 check_own_socket_thread (void *arg)
3095 {
3096   int rc;
3097   char *sockname = arg;
3098   assuan_context_t ctx = NULL;
3099   membuf_t mb;
3100   char *buffer;
3101
3102   check_own_socket_running++;
3103
3104   rc = assuan_new (&ctx);
3105   if (rc)
3106     {
3107       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3108       goto leave;
3109     }
3110   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3111
3112   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3113   if (rc)
3114     {
3115       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3116       goto leave;
3117     }
3118
3119   init_membuf (&mb, 100);
3120   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3121                         NULL, NULL, NULL, NULL);
3122   put_membuf (&mb, "", 1);
3123   buffer = get_membuf (&mb, NULL);
3124   if (rc || !buffer)
3125     {
3126       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3127                  "GETINFO pid", gpg_strerror (rc));
3128       rc = 1;
3129     }
3130   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3131     {
3132       log_error ("socket is now serviced by another server\n");
3133       rc = 1;
3134     }
3135   else if (opt.verbose > 1)
3136     log_error ("socket is still served by this server\n");
3137
3138   xfree (buffer);
3139
3140  leave:
3141   xfree (sockname);
3142   if (ctx)
3143     assuan_release (ctx);
3144   if (rc)
3145     {
3146       /* We may not remove the socket as it is now in use by another
3147          server. */
3148       inhibit_socket_removal = 1;
3149       shutdown_pending = 2;
3150       log_info ("this process is useless - shutting down\n");
3151     }
3152   check_own_socket_running--;
3153   return NULL;
3154 }
3155
3156
3157 /* Check whether we are still listening on our own socket.  In case
3158    another gpg-agent process started after us has taken ownership of
3159    our socket, we would linger around without any real task.  Thus we
3160    better check once in a while whether we are really needed.  */
3161 static void
3162 check_own_socket (void)
3163 {
3164   char *sockname;
3165   npth_t thread;
3166   npth_attr_t tattr;
3167   int err;
3168
3169   if (disable_check_own_socket)
3170     return;
3171
3172   if (check_own_socket_running || shutdown_pending)
3173     return;  /* Still running or already shutting down.  */
3174
3175   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3176   if (!sockname)
3177     return; /* Out of memory.  */
3178
3179   err = npth_attr_init (&tattr);
3180   if (err)
3181     return;
3182   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3183   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3184   if (err)
3185     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3186   npth_attr_destroy (&tattr);
3187 }
3188
3189
3190
3191 /* Figure out whether an agent is available and running. Prints an
3192    error if not.  If SILENT is true, no messages are printed.
3193    Returns 0 if the agent is running. */
3194 static int
3195 check_for_running_agent (int silent)
3196 {
3197   gpg_error_t err;
3198   char *sockname;
3199   assuan_context_t ctx = NULL;
3200
3201   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3202   if (!sockname)
3203     return gpg_error_from_syserror ();
3204
3205   err = assuan_new (&ctx);
3206   if (!err)
3207     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3208   xfree (sockname);
3209   if (err)
3210     {
3211       if (!silent)
3212         log_error (_("no gpg-agent running in this session\n"));
3213
3214       if (ctx)
3215         assuan_release (ctx);
3216       return -1;
3217     }
3218
3219   if (!opt.quiet && !silent)
3220     log_info ("gpg-agent running and available\n");
3221
3222   assuan_release (ctx);
3223   return 0;
3224 }