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