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