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