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