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