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