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 #ifndef HAVE_W32_SYSTEM
 311 static int *startup_fd_list;
 312 #endif
 313
 314 /* The signal mask at startup and a flag telling whether it is valid.  */
 315 #ifdef HAVE_SIGPROCMASK
 316 static sigset_t startup_signal_mask;
 317 static int startup_signal_mask_valid;
 318 #endif
 319
 320 /* Flag to indicate that a shutdown was requested.  */
 321 static int shutdown_pending;
 322
 323 /* Counter for the currently running own socket checks.  */
 324 static int check_own_socket_running;
 325
 326 /* Flags to indicate that check_own_socket shall not be called.  */
 327 static int disable_check_own_socket;
 328
 329 /* Flag indicating that we are in supervised mode.  */
 330 static int is_supervised;
 331
 332 /* Flag to inhibit socket removal in cleanup.  */
 333 static int inhibit_socket_removal;
 334
 335 /* It is possible that we are currently running under setuid permissions */
 336 static int maybe_setuid = 1;
 337
 338 /* Name of the communication socket used for native gpg-agent
 339    requests. The second variable is either NULL or a malloced string
 340    with the real socket name in case it has been redirected.  */
 341 static char *socket_name;
 342 static char *redir_socket_name;
 343
 344 /* Name of the optional extra socket used for native gpg-agent requests.  */
 345 static char *socket_name_extra;
 346 static char *redir_socket_name_extra;
 347
 348 /* Name of the optional browser socket used for native gpg-agent requests.  */
 349 static char *socket_name_browser;
 350 static char *redir_socket_name_browser;
 351
 352 /* Name of the communication socket used for ssh-agent protocol.  */
 353 static char *socket_name_ssh;
 354 static char *redir_socket_name_ssh;
 355
 356 /* We need to keep track of the server's nonces (these are dummies for
 357    POSIX systems). */
 358 static assuan_sock_nonce_t socket_nonce;
 359 static assuan_sock_nonce_t socket_nonce_extra;
 360 static assuan_sock_nonce_t socket_nonce_browser;
 361 static assuan_sock_nonce_t socket_nonce_ssh;
 362
 363
 364 /* Default values for options passed to the pinentry. */
 365 static char *default_display;
 366 static char *default_ttyname;
 367 static char *default_ttytype;
 368 static char *default_lc_ctype;
 369 static char *default_lc_messages;
 370 static char *default_xauthority;
 371
 372 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
 373 static char *config_filename;
 374
 375 /* Helper to implement --debug-level */
 376 static const char *debug_level;
 377
 378 /* Keep track of the current log file so that we can avoid updating
 379    the log file after a SIGHUP if it didn't changed. Malloced. */
 380 static char *current_logfile;
 381
 382 /* The handle_tick() function may test whether a parent is still
 383    running.  We record the PID of the parent here or -1 if it should be
 384    watched. */
 385 static pid_t parent_pid = (pid_t)(-1);
 386
 387 /* Number of active connections.  */
 388 static int active_connections;
 389
 390 /* This object is used to dispatch progress messages from Libgcrypt to
 391  * the right thread.  Given that we will have at max only a few dozen
 392  * connections at a time, using a linked list is the easiest way to
 393  * handle this. */
 394 struct progress_dispatch_s
 395 {
 396   struct progress_dispatch_s *next;
 397   /* The control object of the connection.  If this is NULL no
 398    * connection is associated with this item and it is free for reuse
 399    * by new connections.  */
 400   ctrl_t ctrl;
 401
 402   /* The thread id of (npth_self) of the connection.  */
 403   npth_t tid;
 404
 405   /* The callback set by the connection.  This is similar to the
 406    * Libgcrypt callback but with the control object passed as the
 407    * first argument.  */
 408   void (*cb)(ctrl_t ctrl,
 409              const char *what, int printchar,
 410              int current, int total);
 411 };
 412 struct progress_dispatch_s *progress_dispatch_list;
 413
 414
 415
 416 \f
 417 /*
 418    Local prototypes.
 419  */
 420
 421 static char *create_socket_name (char *standard_name, int with_homedir);
 422 static gnupg_fd_t create_server_socket (char *name, int primary, int cygwin,
 423                                         char **r_redir_name,
 424                                         assuan_sock_nonce_t *nonce);
 425 static void create_directories (void);
 426
 427 static void agent_libgcrypt_progress_cb (void *data, const char *what,
 428                                          int printchar,
 429                                          int current, int total);
 430 static void agent_init_default_ctrl (ctrl_t ctrl);
 431 static void agent_deinit_default_ctrl (ctrl_t ctrl);
 432
 433 static void handle_connections (gnupg_fd_t listen_fd,
 434                                 gnupg_fd_t listen_fd_extra,
 435                                 gnupg_fd_t listen_fd_browser,
 436                                 gnupg_fd_t listen_fd_ssh);
 437 static void check_own_socket (void);
 438 static int check_for_running_agent (int silent);
 439
 440 /* Pth wrapper function definitions. */
 441 ASSUAN_SYSTEM_NPTH_IMPL;
 442
 443 \f
 444 /*
 445    Functions.
 446  */
 447
 448 /* Allocate a string describing a library version by calling a GETFNC.
 449    This function is expected to be called only once.  GETFNC is
 450    expected to have a semantic like gcry_check_version ().  */
 451 static char *
 452 make_libversion (const char *libname, const char *(*getfnc)(const char*))
 453 {
 454   const char *s;
 455   char *result;
 456
 457   if (maybe_setuid)
 458     {
 459       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
 460       maybe_setuid = 0;
 461     }
 462   s = getfnc (NULL);
 463   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
 464   strcpy (stpcpy (stpcpy (result, libname), " "), s);
 465   return result;
 466 }
 467
 468 /* Return strings describing this program.  The case values are
 469    described in common/argparse.c:strusage.  The values here override
 470    the default values given by strusage.  */
 471 static const char *
 472 my_strusage (int level)
 473 {
 474   static char *ver_gcry;
 475   const char *p;
 476
 477   switch (level)
 478     {
 479     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
 480       break;
 481     case 13: p = VERSION; break;
 482     case 17: p = PRINTABLE_OS_NAME; break;
 483       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
 484          reporting address.  This is so that we can change the
 485          reporting address without breaking the translations.  */
 486     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 487
 488     case 20:
 489       if (!ver_gcry)
 490         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
 491       p = ver_gcry;
 492       break;
 493
 494     case 1:
 495     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
 496       break;
 497     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
 498                     "Secret key management for @GNUPG@\n");
 499     break;
 500
 501     default: p = NULL;
 502     }
 503   return p;
 504 }
 505
 506
 507
 508 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
 509    only the active debug flags are propagated to the subsystems.  With
 510    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
 511    all flags already set. Note that we don't fail here, because it is
 512    important to keep gpg-agent running even after re-reading the
 513    options due to a SIGHUP. */
 514 static void
 515 set_debug (void)
 516 {
 517   int numok = (debug_level && digitp (debug_level));
 518   int numlvl = numok? atoi (debug_level) : 0;
 519
 520   if (!debug_level)
 521     ;
 522   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
 523     opt.debug = 0;
 524   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
 525     opt.debug = DBG_IPC_VALUE;
 526   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
 527     opt.debug = DBG_IPC_VALUE;
 528   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
 529     opt.debug = (DBG_IPC_VALUE | DBG_CACHE_VALUE);
 530   else if (!strcmp (debug_level, "guru") || numok)
 531     {
 532       opt.debug = ~0;
 533       /* Unless the "guru" string has been used we don't want to allow
 534          hashing debugging.  The rationale is that people tend to
 535          select the highest debug value and would then clutter their
 536          disk with debug files which may reveal confidential data.  */
 537       if (numok)
 538         opt.debug &= ~(DBG_HASHING_VALUE);
 539     }
 540   else
 541     {
 542       log_error (_("invalid debug-level '%s' given\n"), debug_level);
 543       opt.debug = 0; /* Reset debugging, so that prior debug
 544                         statements won't have an undesired effect. */
 545     }
 546
 547   if (opt.debug && !opt.verbose)
 548     opt.verbose = 1;
 549   if (opt.debug && opt.quiet)
 550     opt.quiet = 0;
 551
 552   if (opt.debug & DBG_MPI_VALUE)
 553     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
 554   if (opt.debug & DBG_CRYPTO_VALUE )
 555     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
 556   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 557
 558   if (opt.debug)
 559     parse_debug_flag (NULL, &opt.debug, debug_flags);
 560 }
 561
 562
 563 /* Helper for cleanup to remove one socket with NAME.  REDIR_NAME is
 564    the corresponding real name if the socket has been redirected.  */
 565 static void
 566 remove_socket (char *name, char *redir_name)
 567 {
 568   if (name && *name)
 569     {
 570       if (redir_name)
 571         name = redir_name;
 572
 573       gnupg_remove (name);
 574       *name = 0;
 575     }
 576 }
 577
 578
 579 /* Discover which inherited file descriptors correspond to which
 580  * services/sockets offered by gpg-agent, using the LISTEN_FDS and
 581  * LISTEN_FDNAMES convention.  The understood labels are "ssh",
 582  * "extra", and "browser".  "std" or other labels will be interpreted
 583  * as the standard socket.
 584  *
 585  * This function is designed to log errors when the expected file
 586  * descriptors don't make sense, but to do its best to continue to
 587  * work even in the face of minor misconfigurations.
 588  *
 589  * For more information on the LISTEN_FDS convention, see
 590  * sd_listen_fds(3) on certain Linux distributions.
 591  */
 592 #ifndef HAVE_W32_SYSTEM
 593 static void
 594 map_supervised_sockets (gnupg_fd_t *r_fd,
 595                         gnupg_fd_t *r_fd_extra,
 596                         gnupg_fd_t *r_fd_browser,
 597                         gnupg_fd_t *r_fd_ssh)
 598 {
 599   struct {
 600     const char *label;
 601     int **fdaddr;
 602     char **nameaddr;
 603   } tbl[] = {
 604     { "ssh",     &r_fd_ssh,     &socket_name_ssh },
 605     { "browser", &r_fd_browser, &socket_name_browser },
 606     { "extra",   &r_fd_extra,   &socket_name_extra },
 607     { "std",     &r_fd,         &socket_name }  /* (Must be the last item.)  */
 608   };
 609   const char *envvar;
 610   char **fdnames;
 611   int nfdnames;
 612   int fd_count;
 613
 614   *r_fd = *r_fd_extra = *r_fd_browser = *r_fd_ssh = -1;
 615
 616   /* Print a warning if LISTEN_PID does not match outr pid.  */
 617   envvar = getenv ("LISTEN_PID");
 618   if (!envvar)
 619     log_error ("no LISTEN_PID environment variable found in "
 620                "--supervised mode (ignoring)\n");
 621   else if (strtoul (envvar, NULL, 10) != (unsigned long)getpid ())
 622     log_error ("environment variable LISTEN_PID (%lu) does not match"
 623                " our pid (%lu) in --supervised mode (ignoring)\n",
 624                (unsigned long)strtoul (envvar, NULL, 10),
 625                (unsigned long)getpid ());
 626
 627   /* Parse LISTEN_FDNAMES into the array FDNAMES.  */
 628   envvar = getenv ("LISTEN_FDNAMES");
 629   if (envvar)
 630     {
 631       fdnames = strtokenize (envvar, ":");
 632       if (!fdnames)
 633         {
 634           log_error ("strtokenize failed: %s\n",
 635                      gpg_strerror (gpg_error_from_syserror ()));
 636           agent_exit (1);
 637         }
 638       for (nfdnames=0; fdnames[nfdnames]; nfdnames++)
 639         ;
 640     }
 641   else
 642     {
 643       fdnames = NULL;
 644       nfdnames = 0;
 645     }
 646
 647   /* Parse LISTEN_FDS into fd_count or provide a replacement.  */
 648   envvar = getenv ("LISTEN_FDS");
 649   if (envvar)
 650     fd_count = atoi (envvar);
 651   else if (fdnames)
 652     {
 653       log_error ("no LISTEN_FDS environment variable found in --supervised"
 654                  " mode (relying on LISTEN_FDNAMES instead)\n");
 655       fd_count = nfdnames;
 656     }
 657   else
 658     {
 659       log_error ("no LISTEN_FDS or LISTEN_FDNAMES environment variables "
 660                 "found in --supervised mode"
 661                 " (assuming 1 active descriptor)\n");
 662       fd_count = 1;
 663     }
 664
 665   if (fd_count < 1)
 666     {
 667       log_error ("--supervised mode expects at least one file descriptor"
 668                  " (was told %d, carrying on as though it were 1)\n",
 669                  fd_count);
 670       fd_count = 1;
 671     }
 672
 673   /* Assign the descriptors to the return values.  */
 674   if (!fdnames)
 675     {
 676       struct stat statbuf;
 677
 678       if (fd_count != 1)
 679         log_error ("no LISTEN_FDNAMES and LISTEN_FDS (%d) != 1"
 680                    " in --supervised mode."
 681                    " (ignoring all sockets but the first one)\n",
 682                    fd_count);
 683       if (fstat (3, &statbuf) == -1 && errno ==EBADF)
 684         log_fatal ("file descriptor 3 must be valid in --supervised mode"
 685                    " if LISTEN_FDNAMES is not set\n");
 686       *r_fd = 3;
 687       socket_name = gnupg_get_socket_name (3);
 688     }
 689   else if (fd_count != nfdnames)
 690     {
 691       log_fatal ("number of items in LISTEN_FDNAMES (%d) does not match "
 692                  "LISTEN_FDS (%d) in --supervised mode\n",
 693                  nfdnames, fd_count);
 694     }
 695   else
 696     {
 697       int i, j, fd;
 698       char *name;
 699
 700       for (i = 0; i < nfdnames; i++)
 701         {
 702           for (j = 0; j < DIM (tbl); j++)
 703             {
 704               if (!strcmp (fdnames[i], tbl[j].label) || j == DIM(tbl)-1)
 705                 {
 706                   fd = 3 + i;
 707                   if (**tbl[j].fdaddr == -1)
 708                     {
 709                       name = gnupg_get_socket_name (fd);
 710                       if (name)
 711                         {
 712                           **tbl[j].fdaddr = fd;
 713                           *tbl[j].nameaddr = name;
 714                           log_info ("using fd %d for %s socket (%s)\n",
 715                                     fd, tbl[j].label, name);
 716                         }
 717                       else
 718                         {
 719                           log_error ("cannot listen on fd %d for %s socket\n",
 720                                      fd, tbl[j].label);
 721                           close (fd);
 722                         }
 723                     }
 724                   else
 725                     {
 726                       log_error ("cannot listen on more than one %s socket\n",
 727                                  tbl[j].label);
 728                       close (fd);
 729                     }
 730                   break;
 731                 }
 732             }
 733         }
 734     }
 735
 736   xfree (fdnames);
 737 }
 738 #endif /*!HAVE_W32_SYSTEM*/
 739
 740
 741 /* Cleanup code for this program.  This is either called has an atexit
 742    handler or directly.  */
 743 static void
 744 cleanup (void)
 745 {
 746   static int done;
 747
 748   if (done)
 749     return;
 750   done = 1;
 751   deinitialize_module_cache ();
 752   if (!is_supervised && !inhibit_socket_removal)
 753     {
 754       remove_socket (socket_name, redir_socket_name);
 755       if (opt.extra_socket > 1)
 756         remove_socket (socket_name_extra, redir_socket_name_extra);
 757       if (opt.browser_socket > 1)
 758         remove_socket (socket_name_browser, redir_socket_name_browser);
 759       remove_socket (socket_name_ssh, redir_socket_name_ssh);
 760     }
 761 }
 762
 763
 764
 765 /* Handle options which are allowed to be reset after program start.
 766    Return true when the current option in PARGS could be handled and
 767    false if not.  As a special feature, passing a value of NULL for
 768    PARGS, resets the options to the default.  REREAD should be set
 769    true if it is not the initial option parsing. */
 770 static int
 771 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
 772 {
 773   if (!pargs)
 774     { /* reset mode */
 775       opt.quiet = 0;
 776       opt.verbose = 0;
 777       opt.debug = 0;
 778       opt.no_grab = 0;
 779       opt.debug_pinentry = 0;
 780       opt.pinentry_program = NULL;
 781       opt.pinentry_touch_file = NULL;
 782       xfree (opt.pinentry_invisible_char);
 783       opt.pinentry_invisible_char = NULL;
 784       opt.pinentry_timeout = 0;
 785       opt.scdaemon_program = NULL;
 786       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
 787       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
 788       opt.max_cache_ttl = MAX_CACHE_TTL;
 789       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
 790       opt.enforce_passphrase_constraints = 0;
 791       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
 792       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
 793       opt.check_passphrase_pattern = NULL;
 794       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
 795       opt.enable_passphrase_history = 0;
 796       opt.ignore_cache_for_signing = 0;
 797       opt.allow_mark_trusted = 1;
 798       opt.allow_external_cache = 1;
 799       opt.allow_loopback_pinentry = 1;
 800       opt.allow_emacs_pinentry = 0;
 801       opt.disable_scdaemon = 0;
 802       disable_check_own_socket = 0;
 803       return 1;
 804     }
 805
 806   switch (pargs->r_opt)
 807     {
 808     case oQuiet: opt.quiet = 1; break;
 809     case oVerbose: opt.verbose++; break;
 810
 811     case oDebug:
 812       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
 813       break;
 814     case oDebugAll: opt.debug = ~0; break;
 815     case oDebugLevel: debug_level = pargs->r.ret_str; break;
 816     case oDebugPinentry: opt.debug_pinentry = 1; break;
 817
 818     case oLogFile:
 819       if (!reread)
 820         return 0; /* not handeld */
 821       if (!current_logfile || !pargs->r.ret_str
 822           || strcmp (current_logfile, pargs->r.ret_str))
 823         {
 824           log_set_file (pargs->r.ret_str);
 825           xfree (current_logfile);
 826           current_logfile = xtrystrdup (pargs->r.ret_str);
 827         }
 828       break;
 829
 830     case oNoGrab: opt.no_grab = 1; break;
 831
 832     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
 833     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
 834     case oPinentryInvisibleChar:
 835       xfree (opt.pinentry_invisible_char);
 836       opt.pinentry_invisible_char = xtrystrdup (pargs->r.ret_str); break;
 837       break;
 838     case oPinentryTimeout: opt.pinentry_timeout = pargs->r.ret_ulong; break;
 839     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
 840     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
 841     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
 842
 843     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
 844     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
 845     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
 846     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
 847
 848     case oEnforcePassphraseConstraints:
 849       opt.enforce_passphrase_constraints=1;
 850       break;
 851     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
 852     case oMinPassphraseNonalpha:
 853       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
 854       break;
 855     case oCheckPassphrasePattern:
 856       opt.check_passphrase_pattern = pargs->r.ret_str;
 857       break;
 858     case oMaxPassphraseDays:
 859       opt.max_passphrase_days = pargs->r.ret_ulong;
 860       break;
 861     case oEnablePassphraseHistory:
 862       opt.enable_passphrase_history = 1;
 863       break;
 864
 865     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
 866
 867     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
 868     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
 869
 870     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
 871
 872     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
 873     case oNoAllowLoopbackPinentry: opt.allow_loopback_pinentry = 0; break;
 874
 875     case oNoAllowExternalCache: opt.allow_external_cache = 0;
 876       break;
 877
 878     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
 879       break;
 880
 881     default:
 882       return 0; /* not handled */
 883     }
 884
 885   return 1; /* handled */
 886 }
 887
 888
 889 /* Fixup some options after all have been processed.  */
 890 static void
 891 finalize_rereadable_options (void)
 892 {
 893 }
 894
 895
 896 static void
 897 thread_init_once (void)
 898 {
 899   static int npth_initialized = 0;
 900
 901   if (!npth_initialized)
 902     {
 903       npth_initialized++;
 904       npth_init ();
 905     }
 906   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
 907   /* Now that we have set the syscall clamp we need to tell Libgcrypt
 908    * that it should get them from libgpg-error.  Note that Libgcrypt
 909    * has already been initialized but at that point nPth was not
 910    * initialized and thus Libgcrypt could not set its system call
 911    * clamp.  */
 912 #if GCRYPT_VERSION_NUMBER >= 0x010800 /* 1.8.0 */
 913   gcry_control (GCRYCTL_REINIT_SYSCALL_CLAMP, 0, 0);
 914 #endif
 915 }
 916
 917
 918 static void
 919 initialize_modules (void)
 920 {
 921   thread_init_once ();
 922   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
 923   initialize_module_cache ();
 924   initialize_module_call_pinentry ();
 925   initialize_module_call_scd ();
 926   initialize_module_trustlist ();
 927 }
 928
 929
 930 /* The main entry point.  */
 931 int
 932 main (int argc, char **argv )
 933 {
 934   ARGPARSE_ARGS pargs;
 935   int orig_argc;
 936   char **orig_argv;
 937   FILE *configfp = NULL;
 938   char *configname = NULL;
 939   const char *shell;
 940   unsigned configlineno;
 941   int parse_debug = 0;
 942   int default_config =1;
 943   int pipe_server = 0;
 944   int is_daemon = 0;
 945   int nodetach = 0;
 946   int csh_style = 0;
 947   char *logfile = NULL;
 948   int debug_wait = 0;
 949   int gpgconf_list = 0;
 950   gpg_error_t err;
 951   struct assuan_malloc_hooks malloc_hooks;
 952
 953   early_system_init ();
 954
 955 #if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
 956   /* Disable ptrace on Linux without sgid bit */
 957   prctl(PR_SET_DUMPABLE, 0);
 958 #endif
 959
 960   /* Before we do anything else we save the list of currently open
 961      file descriptors and the signal mask.  This info is required to
 962      do the exec call properly.  We don't need it on Windows.  */
 963 #ifndef HAVE_W32_SYSTEM
 964   startup_fd_list = get_all_open_fds ();
 965 #endif /*!HAVE_W32_SYSTEM*/
 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 yield the thread 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     {
1779 #if GPGRT_VERSION_NUMBER < 0x011900 /* 1.25 */
1780       /* In older gpg-error versions gpgrt_yield is buggy for use with
1781        * nPth and thus we need to resort to a sleep call.  */
1782       npth_usleep (1000); /* 1ms */
1783 #else
1784       gpgrt_yield ();
1785 #endif
1786     }
1787 #endif
1788 }
1789
1790
1791 /* If a progress dispatcher callback has been associated with the
1792  * current connection unregister it.  */
1793 static void
1794 unregister_progress_cb (void)
1795 {
1796   struct progress_dispatch_s *dispatch;
1797   npth_t mytid = npth_self ();
1798
1799   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1800     if (dispatch->ctrl && dispatch->tid == mytid)
1801       break;
1802   if (dispatch)
1803     {
1804       dispatch->ctrl = NULL;
1805       dispatch->cb = NULL;
1806     }
1807 }
1808
1809
1810 /* Setup a progress callback CB for the current connection.  Using a
1811  * CB of NULL disables the callback.  */
1812 void
1813 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1814                                   int printchar, int current, int total),
1815                        ctrl_t ctrl)
1816 {
1817   struct progress_dispatch_s *dispatch, *firstfree;
1818   npth_t mytid = npth_self ();
1819
1820   firstfree = NULL;
1821   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1822     {
1823       if (dispatch->ctrl && dispatch->tid == mytid)
1824         break;
1825       if (!dispatch->ctrl && !firstfree)
1826         firstfree = dispatch;
1827     }
1828   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1829     {
1830       if (firstfree)
1831         {
1832           dispatch = firstfree;
1833         }
1834       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1835         {
1836           dispatch->next = progress_dispatch_list;
1837           progress_dispatch_list = dispatch;
1838         }
1839       else
1840         {
1841           log_error ("error allocating new progress dispatcher slot: %s\n",
1842                      gpg_strerror (gpg_error_from_syserror ()));
1843           return;
1844         }
1845       dispatch->ctrl = ctrl;
1846       dispatch->tid = mytid;
1847     }
1848
1849   dispatch->cb = cb;
1850 }
1851
1852
1853 /* Each thread has its own local variables conveyed by a control
1854    structure usually identified by an argument named CTRL.  This
1855    function is called immediately after allocating the control
1856    structure.  Its purpose is to setup the default values for that
1857    structure.  Note that some values may have already been set.  */
1858 static void
1859 agent_init_default_ctrl (ctrl_t ctrl)
1860 {
1861   assert (ctrl->session_env);
1862
1863   /* Note we ignore malloc errors because we can't do much about it
1864      and the request will fail anyway shortly after this
1865      initialization. */
1866   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1867   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1868   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1869   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1870   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1871
1872   if (ctrl->lc_ctype)
1873     xfree (ctrl->lc_ctype);
1874   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1875
1876   if (ctrl->lc_messages)
1877     xfree (ctrl->lc_messages);
1878   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1879                                     /**/ : NULL;
1880   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1881 }
1882
1883
1884 /* Release all resources allocated by default in the control
1885    structure.  This is the counterpart to agent_init_default_ctrl.  */
1886 static void
1887 agent_deinit_default_ctrl (ctrl_t ctrl)
1888 {
1889   unregister_progress_cb ();
1890   session_env_release (ctrl->session_env);
1891
1892   if (ctrl->lc_ctype)
1893     xfree (ctrl->lc_ctype);
1894   if (ctrl->lc_messages)
1895     xfree (ctrl->lc_messages);
1896 }
1897
1898
1899 /* Because the ssh protocol does not send us information about the
1900    current TTY setting, we use this function to use those from startup
1901    or those explicitly set.  This is also used for the restricted mode
1902    where we ignore requests to change the environment.  */
1903 gpg_error_t
1904 agent_copy_startup_env (ctrl_t ctrl)
1905 {
1906   static const char *names[] =
1907     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1908   gpg_error_t err = 0;
1909   int idx;
1910   const char *value;
1911
1912   for (idx=0; !err && names[idx]; idx++)
1913       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1914       err = session_env_setenv (ctrl->session_env, names[idx], value);
1915
1916   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1917     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1918       err = gpg_error_from_syserror ();
1919
1920   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1921     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1922       err = gpg_error_from_syserror ();
1923
1924   if (err)
1925     log_error ("error setting default session environment: %s\n",
1926                gpg_strerror (err));
1927
1928   return err;
1929 }
1930
1931
1932 /* Reread parts of the configuration.  Note, that this function is
1933    obviously not thread-safe and should only be called from the PTH
1934    signal handler.
1935
1936    Fixme: Due to the way the argument parsing works, we create a
1937    memory leak here for all string type arguments.  There is currently
1938    no clean way to tell whether the memory for the argument has been
1939    allocated or points into the process' original arguments.  Unless
1940    we have a mechanism to tell this, we need to live on with this. */
1941 static void
1942 reread_configuration (void)
1943 {
1944   ARGPARSE_ARGS pargs;
1945   FILE *fp;
1946   unsigned int configlineno = 0;
1947   int dummy;
1948
1949   if (!config_filename)
1950     return; /* No config file. */
1951
1952   fp = fopen (config_filename, "r");
1953   if (!fp)
1954     {
1955       log_info (_("option file '%s': %s\n"),
1956                 config_filename, strerror(errno) );
1957       return;
1958     }
1959
1960   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1961
1962   memset (&pargs, 0, sizeof pargs);
1963   dummy = 0;
1964   pargs.argc = &dummy;
1965   pargs.flags = 1;  /* do not remove the args */
1966   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1967     {
1968       if (pargs.r_opt < -1)
1969         pargs.err = 1; /* Print a warning. */
1970       else /* Try to parse this option - ignore unchangeable ones. */
1971         parse_rereadable_options (&pargs, 1);
1972     }
1973   fclose (fp);
1974   finalize_rereadable_options ();
1975   set_debug ();
1976 }
1977
1978
1979 /* Return the file name of the socket we are using for native
1980    requests.  */
1981 const char *
1982 get_agent_socket_name (void)
1983 {
1984   const char *s = socket_name;
1985
1986   return (s && *s)? s : NULL;
1987 }
1988
1989 /* Return the file name of the socket we are using for SSH
1990    requests.  */
1991 const char *
1992 get_agent_ssh_socket_name (void)
1993 {
1994   const char *s = socket_name_ssh;
1995
1996   return (s && *s)? s : NULL;
1997 }
1998
1999
2000 /* Return the number of active connections. */
2001 int
2002 get_agent_active_connection_count (void)
2003 {
2004   return active_connections;
2005 }
2006
2007
2008 /* Under W32, this function returns the handle of the scdaemon
2009    notification event.  Calling it the first time creates that
2010    event.  */
2011 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2012 void *
2013 get_agent_scd_notify_event (void)
2014 {
2015   static HANDLE the_event = INVALID_HANDLE_VALUE;
2016
2017   if (the_event == INVALID_HANDLE_VALUE)
2018     {
2019       HANDLE h, h2;
2020       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2021
2022       /* We need to use a manual reset event object due to the way our
2023          w32-pth wait function works: If we would use an automatic
2024          reset event we are not able to figure out which handle has
2025          been signaled because at the time we single out the signaled
2026          handles using WFSO the event has already been reset due to
2027          the WFMO.  */
2028       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2029       if (!h)
2030         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2031       else if (!DuplicateHandle (GetCurrentProcess(), h,
2032                                  GetCurrentProcess(), &h2,
2033                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2034         {
2035           log_error ("setting syncronize for scd notify event failed: %s\n",
2036                      w32_strerror (-1) );
2037           CloseHandle (h);
2038         }
2039       else
2040         {
2041           CloseHandle (h);
2042           the_event = h2;
2043         }
2044     }
2045
2046   return the_event;
2047 }
2048 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2049
2050
2051
2052 /* Create a name for the socket in the home directory as using
2053    STANDARD_NAME.  We also check for valid characters as well as
2054    against a maximum allowed length for a unix domain socket is done.
2055    The function terminates the process in case of an error.  Returns:
2056    Pointer to an allocated string with the absolute name of the socket
2057    used.  */
2058 static char *
2059 create_socket_name (char *standard_name, int with_homedir)
2060 {
2061   char *name;
2062
2063   if (with_homedir)
2064     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2065   else
2066     name = make_filename (standard_name, NULL);
2067   if (strchr (name, PATHSEP_C))
2068     {
2069       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2070       agent_exit (2);
2071     }
2072   return name;
2073 }
2074
2075
2076
2077 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2078    or terminates the process in case of an error.  Note that this
2079    function needs to be used for the regular socket first (indicated
2080    by PRIMARY) and only then for the extra and the ssh sockets.  If
2081    the socket has been redirected the name of the real socket is
2082    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2083    Cygwin compatible socket is created (Windows only). */
2084 static gnupg_fd_t
2085 create_server_socket (char *name, int primary, int cygwin,
2086                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2087 {
2088   struct sockaddr *addr;
2089   struct sockaddr_un *unaddr;
2090   socklen_t len;
2091   gnupg_fd_t fd;
2092   int rc;
2093
2094   xfree (*r_redir_name);
2095   *r_redir_name = NULL;
2096
2097   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2098   if (fd == ASSUAN_INVALID_FD)
2099     {
2100       log_error (_("can't create socket: %s\n"), strerror (errno));
2101       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2102       agent_exit (2);
2103     }
2104
2105   if (cygwin)
2106     assuan_sock_set_flag (fd, "cygwin", 1);
2107
2108   unaddr = xmalloc (sizeof *unaddr);
2109   addr = (struct sockaddr*)unaddr;
2110
2111   {
2112     int redirected;
2113
2114     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2115       {
2116         if (errno == ENAMETOOLONG)
2117           log_error (_("socket name '%s' is too long\n"), name);
2118         else
2119           log_error ("error preparing socket '%s': %s\n",
2120                      name, gpg_strerror (gpg_error_from_syserror ()));
2121         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2122         agent_exit (2);
2123       }
2124     if (redirected)
2125       {
2126         *r_redir_name = xstrdup (unaddr->sun_path);
2127         if (opt.verbose)
2128           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2129       }
2130   }
2131
2132   len = SUN_LEN (unaddr);
2133   rc = assuan_sock_bind (fd, addr, len);
2134
2135   /* Our error code mapping on W32CE returns EEXIST thus we also test
2136      for this. */
2137   if (rc == -1
2138       && (errno == EADDRINUSE
2139 #ifdef HAVE_W32_SYSTEM
2140           || errno == EEXIST
2141 #endif
2142           ))
2143     {
2144       /* Check whether a gpg-agent is already running.  We do this
2145          test only if this is the primary socket.  For secondary
2146          sockets we assume that a test for gpg-agent has already been
2147          done and reuse the requested socket.  Testing the ssh-socket
2148          is not possible because at this point, though we know the new
2149          Assuan socket, the Assuan server and thus the ssh-agent
2150          server is not yet operational; this would lead to a hang.  */
2151       if (primary && !check_for_running_agent (1))
2152         {
2153           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2154           log_set_file (NULL);
2155           log_error (_("a gpg-agent is already running - "
2156                        "not starting a new one\n"));
2157           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2158           assuan_sock_close (fd);
2159           agent_exit (2);
2160         }
2161       gnupg_remove (unaddr->sun_path);
2162       rc = assuan_sock_bind (fd, addr, len);
2163     }
2164   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2165     log_error (_("error getting nonce for the socket\n"));
2166   if (rc == -1)
2167     {
2168       /* We use gpg_strerror here because it allows us to get strings
2169          for some W32 socket error codes.  */
2170       log_error (_("error binding socket to '%s': %s\n"),
2171                  unaddr->sun_path,
2172                  gpg_strerror (gpg_error_from_syserror ()));
2173
2174       assuan_sock_close (fd);
2175       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2176       agent_exit (2);
2177     }
2178
2179   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2180     log_error (_("can't set permissions of '%s': %s\n"),
2181                unaddr->sun_path, strerror (errno));
2182
2183   if (listen (FD2INT(fd), 5 ) == -1)
2184     {
2185       log_error (_("listen() failed: %s\n"), strerror (errno));
2186       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2187       assuan_sock_close (fd);
2188       agent_exit (2);
2189     }
2190
2191   if (opt.verbose)
2192     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2193
2194   return fd;
2195 }
2196
2197
2198 /* Check that the directory for storing the private keys exists and
2199    create it if not.  This function won't fail as it is only a
2200    convenience function and not strictly necessary.  */
2201 static void
2202 create_private_keys_directory (const char *home)
2203 {
2204   char *fname;
2205   struct stat statbuf;
2206
2207   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2208   if (stat (fname, &statbuf) && errno == ENOENT)
2209     {
2210       if (gnupg_mkdir (fname, "-rwx"))
2211         log_error (_("can't create directory '%s': %s\n"),
2212                    fname, strerror (errno) );
2213       else if (!opt.quiet)
2214         log_info (_("directory '%s' created\n"), fname);
2215     }
2216   if (gnupg_chmod (fname, "-rwx"))
2217     log_error (_("can't set permissions of '%s': %s\n"),
2218                fname, strerror (errno));
2219   xfree (fname);
2220 }
2221
2222
2223 /* Create the directory only if the supplied directory name is the
2224    same as the default one.  This way we avoid to create arbitrary
2225    directories when a non-default home directory is used.  To cope
2226    with HOME, we compare only the suffix if we see that the default
2227    homedir does start with a tilde.  We don't stop here in case of
2228    problems because other functions will throw an error anyway.*/
2229 static void
2230 create_directories (void)
2231 {
2232   struct stat statbuf;
2233   const char *defhome = standard_homedir ();
2234   char *home;
2235
2236   home = make_filename (gnupg_homedir (), NULL);
2237   if ( stat (home, &statbuf) )
2238     {
2239       if (errno == ENOENT)
2240         {
2241           if (
2242 #ifdef HAVE_W32_SYSTEM
2243               ( !compare_filenames (home, defhome) )
2244 #else
2245               (*defhome == '~'
2246                 && (strlen (home) >= strlen (defhome+1)
2247                     && !strcmp (home + strlen(home)
2248                                 - strlen (defhome+1), defhome+1)))
2249                || (*defhome != '~' && !strcmp (home, defhome) )
2250 #endif
2251                )
2252             {
2253               if (gnupg_mkdir (home, "-rwx"))
2254                 log_error (_("can't create directory '%s': %s\n"),
2255                            home, strerror (errno) );
2256               else
2257                 {
2258                   if (!opt.quiet)
2259                     log_info (_("directory '%s' created\n"), home);
2260                   create_private_keys_directory (home);
2261                 }
2262             }
2263         }
2264       else
2265         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2266     }
2267   else if ( !S_ISDIR(statbuf.st_mode))
2268     {
2269       log_error (_("can't use '%s' as home directory\n"), home);
2270     }
2271   else /* exists and is a directory. */
2272     {
2273       create_private_keys_directory (home);
2274     }
2275   xfree (home);
2276 }
2277
2278
2279
2280 /* This is the worker for the ticker.  It is called every few seconds
2281    and may only do fast operations. */
2282 static void
2283 handle_tick (void)
2284 {
2285   /* Check whether the scdaemon has died and cleanup in this case. */
2286   agent_scd_check_aliveness ();
2287
2288   /* If we are running as a child of another process, check whether
2289      the parent is still alive and shutdown if not. */
2290 #ifndef HAVE_W32_SYSTEM
2291   if (parent_pid != (pid_t)(-1))
2292     {
2293       if (kill (parent_pid, 0))
2294         {
2295           shutdown_pending = 2;
2296           log_info ("parent process died - shutting down\n");
2297           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2298           cleanup ();
2299           agent_exit (0);
2300         }
2301     }
2302 #endif /*HAVE_W32_SYSTEM*/
2303 }
2304
2305
2306 /* A global function which allows us to call the reload stuff from
2307    other places too.  This is only used when build for W32.  */
2308 void
2309 agent_sighup_action (void)
2310 {
2311   log_info ("SIGHUP received - "
2312             "re-reading configuration and flushing cache\n");
2313
2314   agent_flush_cache ();
2315   reread_configuration ();
2316   agent_reload_trustlist ();
2317   /* We flush the module name cache so that after installing a
2318      "pinentry" binary that one can be used in case the
2319      "pinentry-basic" fallback was in use.  */
2320   gnupg_module_name_flush_some ();
2321 }
2322
2323
2324 /* A helper function to handle SIGUSR2.  */
2325 static void
2326 agent_sigusr2_action (void)
2327 {
2328   if (opt.verbose)
2329     log_info ("SIGUSR2 received - updating card event counter\n");
2330   /* Nothing to check right now.  We only increment a counter.  */
2331   bump_card_eventcounter ();
2332 }
2333
2334
2335 #ifndef HAVE_W32_SYSTEM
2336 /* The signal handler for this program.  It is expected to be run in
2337    its own trhead and not in the context of a signal handler.  */
2338 static void
2339 handle_signal (int signo)
2340 {
2341   switch (signo)
2342     {
2343 #ifndef HAVE_W32_SYSTEM
2344     case SIGHUP:
2345       agent_sighup_action ();
2346       break;
2347
2348     case SIGUSR1:
2349       log_info ("SIGUSR1 received - printing internal information:\n");
2350       /* Fixme: We need to see how to integrate pth dumping into our
2351          logging system.  */
2352       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2353       agent_query_dump_state ();
2354       agent_scd_dump_state ();
2355       break;
2356
2357     case SIGUSR2:
2358       agent_sigusr2_action ();
2359       break;
2360
2361     case SIGTERM:
2362       if (!shutdown_pending)
2363         log_info ("SIGTERM received - shutting down ...\n");
2364       else
2365         log_info ("SIGTERM received - still %i open connections\n",
2366                   active_connections);
2367       shutdown_pending++;
2368       if (shutdown_pending > 2)
2369         {
2370           log_info ("shutdown forced\n");
2371           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2372           cleanup ();
2373           agent_exit (0);
2374         }
2375       break;
2376
2377     case SIGINT:
2378       log_info ("SIGINT received - immediate shutdown\n");
2379       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2380       cleanup ();
2381       agent_exit (0);
2382       break;
2383 #endif
2384     default:
2385       log_info ("signal %d received - no action defined\n", signo);
2386     }
2387 }
2388 #endif
2389
2390 /* Check the nonce on a new connection.  This is a NOP unless we we
2391    are using our Unix domain socket emulation under Windows.  */
2392 static int
2393 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2394 {
2395   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2396     {
2397       log_info (_("error reading nonce on fd %d: %s\n"),
2398                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2399       assuan_sock_close (ctrl->thread_startup.fd);
2400       xfree (ctrl);
2401       return -1;
2402     }
2403   else
2404     return 0;
2405 }
2406
2407
2408 #ifdef HAVE_W32_SYSTEM
2409 /* The window message processing function for Putty.  Warning: This
2410    code runs as a native Windows thread.  Use of our own functions
2411    needs to be bracket with pth_leave/pth_enter. */
2412 static LRESULT CALLBACK
2413 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2414 {
2415   int ret = 0;
2416   int w32rc;
2417   COPYDATASTRUCT *cds;
2418   const char *mapfile;
2419   HANDLE maphd;
2420   PSID mysid = NULL;
2421   PSID mapsid = NULL;
2422   void *data = NULL;
2423   PSECURITY_DESCRIPTOR psd = NULL;
2424   ctrl_t ctrl = NULL;
2425
2426   if (msg != WM_COPYDATA)
2427     {
2428       return DefWindowProc (hwnd, msg, wparam, lparam);
2429     }
2430
2431   cds = (COPYDATASTRUCT*)lparam;
2432   if (cds->dwData != PUTTY_IPC_MAGIC)
2433     return 0;  /* Ignore data with the wrong magic.  */
2434   mapfile = cds->lpData;
2435   if (!cds->cbData || mapfile[cds->cbData - 1])
2436     return 0;  /* Ignore empty and non-properly terminated strings.  */
2437
2438   if (DBG_IPC)
2439     {
2440       npth_protect ();
2441       log_debug ("ssh map file '%s'", mapfile);
2442       npth_unprotect ();
2443     }
2444
2445   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2446   if (DBG_IPC)
2447     {
2448       npth_protect ();
2449       log_debug ("ssh map handle %p\n", maphd);
2450       npth_unprotect ();
2451     }
2452
2453   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2454     return 0;
2455
2456   npth_protect ();
2457
2458   mysid = w32_get_user_sid ();
2459   if (!mysid)
2460     {
2461       log_error ("error getting my sid\n");
2462       goto leave;
2463     }
2464
2465   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2466                            OWNER_SECURITY_INFORMATION,
2467                            &mapsid, NULL, NULL, NULL,
2468                            &psd);
2469   if (w32rc)
2470     {
2471       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2472       goto leave;
2473     }
2474
2475   if (DBG_IPC)
2476     {
2477       char *sidstr;
2478
2479       if (!ConvertSidToStringSid (mysid, &sidstr))
2480         sidstr = NULL;
2481       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2482       LocalFree (sidstr);
2483       if (!ConvertSidToStringSid (mapsid, &sidstr))
2484         sidstr = NULL;
2485       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2486       LocalFree (sidstr);
2487     }
2488
2489   if (!EqualSid (mysid, mapsid))
2490     {
2491       log_error ("ssh map file has a non-matching sid\n");
2492       goto leave;
2493     }
2494
2495   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2496   if (DBG_IPC)
2497     log_debug ("ssh IPC buffer at %p\n", data);
2498   if (!data)
2499     goto leave;
2500
2501   /* log_printhex ("request:", data, 20); */
2502
2503   ctrl = xtrycalloc (1, sizeof *ctrl);
2504   if (!ctrl)
2505     {
2506       log_error ("error allocating connection control data: %s\n",
2507                  strerror (errno) );
2508       goto leave;
2509     }
2510   ctrl->session_env = session_env_new ();
2511   if (!ctrl->session_env)
2512     {
2513       log_error ("error allocating session environment block: %s\n",
2514                  strerror (errno) );
2515       goto leave;
2516     }
2517
2518   agent_init_default_ctrl (ctrl);
2519   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2520     ret = 1; /* Valid ssh message has been constructed.  */
2521   agent_deinit_default_ctrl (ctrl);
2522   /* log_printhex ("  reply:", data, 20); */
2523
2524  leave:
2525   xfree (ctrl);
2526   if (data)
2527     UnmapViewOfFile (data);
2528   xfree (mapsid);
2529   if (psd)
2530     LocalFree (psd);
2531   xfree (mysid);
2532   CloseHandle (maphd);
2533
2534   npth_unprotect ();
2535
2536   return ret;
2537 }
2538 #endif /*HAVE_W32_SYSTEM*/
2539
2540
2541 #ifdef HAVE_W32_SYSTEM
2542 /* The thread handling Putty's IPC requests.  */
2543 static void *
2544 putty_message_thread (void *arg)
2545 {
2546   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2547                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2548   HWND hwnd;
2549   MSG msg;
2550
2551   (void)arg;
2552
2553   if (opt.verbose)
2554     log_info ("putty message loop thread started\n");
2555
2556   /* The message loop runs as thread independent from our nPth system.
2557      This also means that we need to make sure that we switch back to
2558      our system before calling any no-windows function.  */
2559   npth_unprotect ();
2560
2561   /* First create a window to make sure that a message queue exists
2562      for this thread.  */
2563   if (!RegisterClass (&wndwclass))
2564     {
2565       npth_protect ();
2566       log_error ("error registering Pageant window class");
2567       return NULL;
2568     }
2569   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2570                          0, 0, 0, 0,
2571                          HWND_MESSAGE,  /* hWndParent */
2572                          NULL,          /* hWndMenu   */
2573                          NULL,          /* hInstance  */
2574                          NULL);         /* lpParm     */
2575   if (!hwnd)
2576     {
2577       npth_protect ();
2578       log_error ("error creating Pageant window");
2579       return NULL;
2580     }
2581
2582   while (GetMessage(&msg, NULL, 0, 0))
2583     {
2584       TranslateMessage(&msg);
2585       DispatchMessage(&msg);
2586     }
2587
2588   /* Back to nPth.  */
2589   npth_protect ();
2590
2591   if (opt.verbose)
2592     log_info ("putty message loop thread stopped\n");
2593   return NULL;
2594 }
2595 #endif /*HAVE_W32_SYSTEM*/
2596
2597
2598 static void *
2599 do_start_connection_thread (ctrl_t ctrl)
2600 {
2601   active_connections++;
2602   agent_init_default_ctrl (ctrl);
2603   if (opt.verbose && !DBG_IPC)
2604     log_info (_("handler 0x%lx for fd %d started\n"),
2605               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2606
2607   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2608   if (opt.verbose && !DBG_IPC)
2609     log_info (_("handler 0x%lx for fd %d terminated\n"),
2610               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2611
2612   agent_deinit_default_ctrl (ctrl);
2613   xfree (ctrl);
2614   active_connections--;
2615   return NULL;
2616 }
2617
2618
2619 /* This is the standard connection thread's main function.  */
2620 static void *
2621 start_connection_thread_std (void *arg)
2622 {
2623   ctrl_t ctrl = arg;
2624
2625   if (check_nonce (ctrl, &socket_nonce))
2626     {
2627       log_error ("handler 0x%lx nonce check FAILED\n",
2628                  (unsigned long) npth_self());
2629       return NULL;
2630     }
2631
2632   return do_start_connection_thread (ctrl);
2633 }
2634
2635
2636 /* This is the extra socket connection thread's main function.  */
2637 static void *
2638 start_connection_thread_extra (void *arg)
2639 {
2640   ctrl_t ctrl = arg;
2641
2642   if (check_nonce (ctrl, &socket_nonce_extra))
2643     {
2644       log_error ("handler 0x%lx nonce check FAILED\n",
2645                  (unsigned long) npth_self());
2646       return NULL;
2647     }
2648
2649   ctrl->restricted = 1;
2650   return do_start_connection_thread (ctrl);
2651 }
2652
2653
2654 /* This is the browser socket connection thread's main function.  */
2655 static void *
2656 start_connection_thread_browser (void *arg)
2657 {
2658   ctrl_t ctrl = arg;
2659
2660   if (check_nonce (ctrl, &socket_nonce_browser))
2661     {
2662       log_error ("handler 0x%lx nonce check FAILED\n",
2663                  (unsigned long) npth_self());
2664       return NULL;
2665     }
2666
2667   ctrl->restricted = 2;
2668   return do_start_connection_thread (ctrl);
2669 }
2670
2671
2672 /* This is the ssh connection thread's main function.  */
2673 static void *
2674 start_connection_thread_ssh (void *arg)
2675 {
2676   ctrl_t ctrl = arg;
2677
2678   if (check_nonce (ctrl, &socket_nonce_ssh))
2679     return NULL;
2680
2681   active_connections++;
2682   agent_init_default_ctrl (ctrl);
2683   if (opt.verbose)
2684     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2685               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2686
2687   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2688   if (opt.verbose)
2689     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2690               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2691
2692   agent_deinit_default_ctrl (ctrl);
2693   xfree (ctrl);
2694   active_connections--;
2695   return NULL;
2696 }
2697
2698
2699 /* helper function for readability: test whether a given struct
2700    timespec is set to all-zeros */
2701 static inline int
2702 tv_is_set (struct timespec tv)
2703 {
2704   return tv.tv_sec || tv.tv_nsec;
2705 }
2706
2707
2708 /* Connection handler loop.  Wait for connection requests and spawn a
2709    thread after accepting a connection.  */
2710 static void
2711 handle_connections (gnupg_fd_t listen_fd,
2712                     gnupg_fd_t listen_fd_extra,
2713                     gnupg_fd_t listen_fd_browser,
2714                     gnupg_fd_t listen_fd_ssh)
2715 {
2716   gpg_error_t err;
2717   npth_attr_t tattr;
2718   struct sockaddr_un paddr;
2719   socklen_t plen;
2720   fd_set fdset, read_fdset;
2721   int ret;
2722   gnupg_fd_t fd;
2723   int nfd;
2724   int saved_errno;
2725   int idx;
2726   struct timespec abstime;
2727   struct timespec curtime;
2728   struct timespec timeout;
2729   struct timespec *select_timeout;
2730 #ifdef HAVE_W32_SYSTEM
2731   HANDLE events[2];
2732   unsigned int events_set;
2733 #endif
2734   int my_inotify_fd = -1;
2735   struct {
2736     const char *name;
2737     void *(*func) (void *arg);
2738     gnupg_fd_t l_fd;
2739   } listentbl[] = {
2740     { "std",     start_connection_thread_std   },
2741     { "extra",   start_connection_thread_extra },
2742     { "browser", start_connection_thread_browser },
2743     { "ssh",    start_connection_thread_ssh   }
2744   };
2745   struct {
2746     struct timespec interval;
2747     void (*func) (void);
2748     struct timespec next;
2749   } timertbl[] = {
2750     { { TIMERTICK_INTERVAL, 0 }, handle_tick },
2751     { { CHECK_OWN_SOCKET_INTERVAL, 0 }, check_own_socket }
2752   };
2753
2754
2755   ret = npth_attr_init(&tattr);
2756   if (ret)
2757     log_fatal ("error allocating thread attributes: %s\n",
2758                strerror (ret));
2759   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2760
2761 #ifndef HAVE_W32_SYSTEM
2762   npth_sigev_init ();
2763   npth_sigev_add (SIGHUP);
2764   npth_sigev_add (SIGUSR1);
2765   npth_sigev_add (SIGUSR2);
2766   npth_sigev_add (SIGINT);
2767   npth_sigev_add (SIGTERM);
2768   npth_sigev_fini ();
2769 #else
2770 # ifdef HAVE_W32CE_SYSTEM
2771   /* Use a dummy event. */
2772   sigs = 0;
2773   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2774 # else
2775   events[0] = get_agent_scd_notify_event ();
2776   events[1] = INVALID_HANDLE_VALUE;
2777 # endif
2778 #endif
2779
2780   if (disable_check_own_socket)
2781     my_inotify_fd = -1;
2782   else if ((err = gnupg_inotify_watch_socket (&my_inotify_fd, socket_name)))
2783     {
2784       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2785         log_info ("error enabling fast daemon termination: %s\n",
2786                   gpg_strerror (err));
2787     }
2788
2789   /* On Windows we need to fire up a separate thread to listen for
2790      requests from Putty (an SSH client), so we can replace Putty's
2791      Pageant (its ssh-agent implementation). */
2792 #ifdef HAVE_W32_SYSTEM
2793   if (putty_support)
2794     {
2795       npth_t thread;
2796
2797       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2798       if (ret)
2799         {
2800           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2801         }
2802     }
2803 #endif /*HAVE_W32_SYSTEM*/
2804
2805   /* Set a flag to tell call-scd.c that it may enable event
2806      notifications.  */
2807   opt.sigusr2_enabled = 1;
2808
2809   FD_ZERO (&fdset);
2810   FD_SET (FD2INT (listen_fd), &fdset);
2811   nfd = FD2INT (listen_fd);
2812   if (listen_fd_extra != GNUPG_INVALID_FD)
2813     {
2814       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2815       if (FD2INT (listen_fd_extra) > nfd)
2816         nfd = FD2INT (listen_fd_extra);
2817     }
2818   if (listen_fd_browser != GNUPG_INVALID_FD)
2819     {
2820       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2821       if (FD2INT (listen_fd_browser) > nfd)
2822         nfd = FD2INT (listen_fd_browser);
2823     }
2824   if (listen_fd_ssh != GNUPG_INVALID_FD)
2825     {
2826       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2827       if (FD2INT (listen_fd_ssh) > nfd)
2828         nfd = FD2INT (listen_fd_ssh);
2829     }
2830   if (my_inotify_fd != -1)
2831     {
2832       FD_SET (my_inotify_fd, &fdset);
2833       if (my_inotify_fd > nfd)
2834         nfd = my_inotify_fd;
2835     }
2836
2837   listentbl[0].l_fd = listen_fd;
2838   listentbl[1].l_fd = listen_fd_extra;
2839   listentbl[2].l_fd = listen_fd_browser;
2840   listentbl[3].l_fd = listen_fd_ssh;
2841
2842   for (;;)
2843     {
2844       /* Shutdown test.  */
2845       if (shutdown_pending)
2846         {
2847           if (active_connections == 0)
2848             break; /* ready */
2849
2850           /* Do not accept new connections but keep on running the
2851            * loop to cope with the timer events.
2852            *
2853            * Note that we do not close the listening socket because a
2854            * client trying to connect to that socket would instead
2855            * restart a new dirmngr instance - which is unlikely the
2856            * intention of a shutdown. */
2857           FD_ZERO (&fdset);
2858           nfd = -1;
2859           if (my_inotify_fd != -1)
2860             {
2861               FD_SET (my_inotify_fd, &fdset);
2862               nfd = my_inotify_fd;
2863             }
2864         }
2865
2866       /* POSIX says that fd_set should be implemented as a structure,
2867          thus a simple assignment is fine to copy the entire set.  */
2868       read_fdset = fdset;
2869
2870       /* loop through all timers, fire any registered functions, and
2871          plan next timer to trigger */
2872       npth_clock_gettime (&curtime);
2873       abstime.tv_sec = abstime.tv_nsec = 0;
2874       for (idx=0; idx < DIM(timertbl); idx++)
2875         {
2876           /* schedule any unscheduled timers */
2877           if ((!tv_is_set (timertbl[idx].next)) && tv_is_set (timertbl[idx].interval))
2878             npth_timeradd (&timertbl[idx].interval, &curtime, &timertbl[idx].next);
2879           /* if a timer is due, fire it ... */
2880           if (tv_is_set (timertbl[idx].next))
2881             {
2882               if (!(npth_timercmp (&curtime, &timertbl[idx].next, <)))
2883                 {
2884                   timertbl[idx].func ();
2885                   npth_clock_gettime (&curtime);
2886                   /* ...and reschedule it, if desired: */
2887                   if (tv_is_set (timertbl[idx].interval))
2888                     npth_timeradd (&timertbl[idx].interval, &curtime, &timertbl[idx].next);
2889                   else
2890                     timertbl[idx].next.tv_sec = timertbl[idx].next.tv_nsec = 0;
2891                 }
2892             }
2893           /* accumulate next timer to come due in abstime: */
2894           if (tv_is_set (timertbl[idx].next) &&
2895               ((!tv_is_set (abstime)) ||
2896                (npth_timercmp (&abstime, &timertbl[idx].next, >))))
2897             abstime = timertbl[idx].next;
2898         }
2899       /* choose a timeout for the select loop: */
2900       if (tv_is_set (abstime))
2901         {
2902           npth_timersub (&abstime, &curtime, &timeout);
2903           select_timeout = &timeout;
2904         }
2905       else
2906           select_timeout = NULL;
2907
2908
2909 #ifndef HAVE_W32_SYSTEM
2910       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, select_timeout,
2911                           npth_sigev_sigmask ());
2912       saved_errno = errno;
2913
2914       {
2915         int signo;
2916         while (npth_sigev_get_pending (&signo))
2917           handle_signal (signo);
2918       }
2919 #else
2920       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, select_timeout,
2921                           events, &events_set);
2922       saved_errno = errno;
2923
2924       /* This is valid even if npth_eselect returns an error.  */
2925       if (events_set & 1)
2926         agent_sigusr2_action ();
2927 #endif
2928
2929       if (ret == -1 && saved_errno != EINTR)
2930         {
2931           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2932                      strerror (saved_errno));
2933           npth_sleep (1);
2934           continue;
2935         }
2936       if (ret <= 0)
2937         /* Interrupt or timeout.  Will be handled when calculating the
2938            next timeout.  */
2939         continue;
2940
2941       if (!shutdown_pending)
2942         {
2943           ctrl_t ctrl;
2944           npth_t thread;
2945
2946           if (my_inotify_fd != -1
2947               && FD_ISSET (my_inotify_fd, &read_fdset)
2948               && gnupg_inotify_has_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
2949             {
2950               shutdown_pending = 1;
2951               log_info ("socket file has been removed - shutting down\n");
2952             }
2953
2954           for (idx=0; idx < DIM(listentbl); idx++)
2955             {
2956               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2957                 continue;
2958               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2959                 continue;
2960
2961               plen = sizeof paddr;
2962               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2963                                         (struct sockaddr *)&paddr, &plen));
2964               if (fd == GNUPG_INVALID_FD)
2965                 {
2966                   log_error ("accept failed for %s: %s\n",
2967                              listentbl[idx].name, strerror (errno));
2968                 }
2969               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2970                 {
2971                   log_error ("error allocating connection data for %s: %s\n",
2972                              listentbl[idx].name, strerror (errno) );
2973                   assuan_sock_close (fd);
2974                 }
2975               else if ( !(ctrl->session_env = session_env_new ()))
2976                 {
2977                   log_error ("error allocating session env block for %s: %s\n",
2978                              listentbl[idx].name, strerror (errno) );
2979                   xfree (ctrl);
2980                   assuan_sock_close (fd);
2981                 }
2982               else
2983                 {
2984                   ctrl->thread_startup.fd = fd;
2985                   ret = npth_create (&thread, &tattr,
2986                                      listentbl[idx].func, ctrl);
2987                   if (ret)
2988                     {
2989                       log_error ("error spawning connection handler for %s:"
2990                                  " %s\n", listentbl[idx].name, strerror (ret));
2991                       assuan_sock_close (fd);
2992                       xfree (ctrl);
2993                     }
2994                 }
2995               fd = GNUPG_INVALID_FD;
2996             }
2997         }
2998     }
2999
3000   if (my_inotify_fd != -1)
3001     close (my_inotify_fd);
3002   cleanup ();
3003   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
3004   npth_attr_destroy (&tattr);
3005 }
3006
3007
3008
3009 /* Helper for check_own_socket.  */
3010 static gpg_error_t
3011 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3012 {
3013   membuf_t *mb = opaque;
3014   put_membuf (mb, buffer, length);
3015   return 0;
3016 }
3017
3018
3019 /* The thread running the actual check.  We need to run this in a
3020    separate thread so that check_own_thread can be called from the
3021    timer tick.  */
3022 static void *
3023 check_own_socket_thread (void *arg)
3024 {
3025   int rc;
3026   char *sockname = arg;
3027   assuan_context_t ctx = NULL;
3028   membuf_t mb;
3029   char *buffer;
3030
3031   check_own_socket_running++;
3032
3033   rc = assuan_new (&ctx);
3034   if (rc)
3035     {
3036       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3037       goto leave;
3038     }
3039   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3040
3041   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3042   if (rc)
3043     {
3044       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3045       goto leave;
3046     }
3047
3048   init_membuf (&mb, 100);
3049   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3050                         NULL, NULL, NULL, NULL);
3051   put_membuf (&mb, "", 1);
3052   buffer = get_membuf (&mb, NULL);
3053   if (rc || !buffer)
3054     {
3055       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3056                  "GETINFO pid", gpg_strerror (rc));
3057       rc = 1;
3058     }
3059   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3060     {
3061       log_error ("socket is now serviced by another server\n");
3062       rc = 1;
3063     }
3064   else if (opt.verbose > 1)
3065     log_error ("socket is still served by this server\n");
3066
3067   xfree (buffer);
3068
3069  leave:
3070   xfree (sockname);
3071   if (ctx)
3072     assuan_release (ctx);
3073   if (rc)
3074     {
3075       /* We may not remove the socket as it is now in use by another
3076          server. */
3077       inhibit_socket_removal = 1;
3078       shutdown_pending = 2;
3079       log_info ("this process is useless - shutting down\n");
3080     }
3081   check_own_socket_running--;
3082   return NULL;
3083 }
3084
3085
3086 /* Check whether we are still listening on our own socket.  In case
3087    another gpg-agent process started after us has taken ownership of
3088    our socket, we would linger around without any real task.  Thus we
3089    better check once in a while whether we are really needed.  */
3090 static void
3091 check_own_socket (void)
3092 {
3093   char *sockname;
3094   npth_t thread;
3095   npth_attr_t tattr;
3096   int err;
3097
3098   if (disable_check_own_socket)
3099     return;
3100
3101   if (check_own_socket_running || shutdown_pending)
3102     return;  /* Still running or already shutting down.  */
3103
3104   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3105   if (!sockname)
3106     return; /* Out of memory.  */
3107
3108   err = npth_attr_init (&tattr);
3109   if (err)
3110     return;
3111   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3112   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3113   if (err)
3114     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3115   npth_attr_destroy (&tattr);
3116 }
3117
3118
3119
3120 /* Figure out whether an agent is available and running. Prints an
3121    error if not.  If SILENT is true, no messages are printed.
3122    Returns 0 if the agent is running. */
3123 static int
3124 check_for_running_agent (int silent)
3125 {
3126   gpg_error_t err;
3127   char *sockname;
3128   assuan_context_t ctx = NULL;
3129
3130   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3131   if (!sockname)
3132     return gpg_error_from_syserror ();
3133
3134   err = assuan_new (&ctx);
3135   if (!err)
3136     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3137   xfree (sockname);
3138   if (err)
3139     {
3140       if (!silent)
3141         log_error (_("no gpg-agent running in this session\n"));
3142
3143       if (ctx)
3144         assuan_release (ctx);
3145       return -1;
3146     }
3147
3148   if (!opt.quiet && !silent)
3149     log_info ("gpg-agent running and available\n");
3150
3151   assuan_release (ctx);
3152   return 0;
3153 }