724b55a30b83f19c84a485f387754098ba1776a6
[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_MPI_VALUE    , "mpi"     },
255     { DBG_CRYPTO_VALUE , "crypto"  },
256     { DBG_MEMORY_VALUE , "memory"  },
257     { DBG_CACHE_VALUE  , "cache"   },
258     { DBG_MEMSTAT_VALUE, "memstat" },
259     { DBG_HASHING_VALUE, "hashing" },
260     { DBG_IPC_VALUE    , "ipc"     },
261     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
262   };
263
264
265
266 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
267 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
268 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
269 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
270 #define MIN_PASSPHRASE_LEN    (8)
271 #define MIN_PASSPHRASE_NONALPHA (1)
272 #define MAX_PASSPHRASE_DAYS   (0)
273
274 /* The timer tick used for housekeeping stuff.  For Windows we use a
275    longer period as the SetWaitableTimer seems to signal earlier than
276    the 2 seconds.  CHECK_OWN_SOCKET_INTERVAL defines how often we
277    check our own socket in standard socket mode.  If that value is 0
278    we don't check at all.   All values are in seconds. */
279 #if defined(HAVE_W32CE_SYSTEM)
280 # define TIMERTICK_INTERVAL         (60)
281 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
282 #elif defined(HAVE_W32_SYSTEM)
283 # define TIMERTICK_INTERVAL          (4)
284 # define CHECK_OWN_SOCKET_INTERVAL  (60)
285 #else
286 # define TIMERTICK_INTERVAL          (2)
287 # define CHECK_OWN_SOCKET_INTERVAL  (60)
288 #endif
289
290
291 /* Flag indicating that the ssh-agent subsystem has been enabled.  */
292 static int ssh_support;
293
294 #ifdef HAVE_W32_SYSTEM
295 /* Flag indicating that support for Putty has been enabled.  */
296 static int putty_support;
297 /* A magic value used with WM_COPYDATA.  */
298 #define PUTTY_IPC_MAGIC 0x804e50ba
299 /* To avoid surprises we limit the size of the mapped IPC file to this
300    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
301    for the foreseeable future.  */
302 #define PUTTY_IPC_MAXLEN 16384
303 #endif /*HAVE_W32_SYSTEM*/
304
305 /* The list of open file descriptors at startup.  Note that this list
306  * has been allocated using the standard malloc.  */
307 #ifndef HAVE_W32_SYSTEM
308 static int *startup_fd_list;
309 #endif
310
311 /* The signal mask at startup and a flag telling whether it is valid.  */
312 #ifdef HAVE_SIGPROCMASK
313 static sigset_t startup_signal_mask;
314 static int startup_signal_mask_valid;
315 #endif
316
317 /* Flag to indicate that a shutdown was requested.  */
318 static int shutdown_pending;
319
320 /* Counter for the currently running own socket checks.  */
321 static int check_own_socket_running;
322
323 /* Flags to indicate that check_own_socket shall not be called.  */
324 static int disable_check_own_socket;
325
326 /* Flag indicating that we are in supervised mode.  */
327 static int is_supervised;
328
329 /* Flag to inhibit socket removal in cleanup.  */
330 static int inhibit_socket_removal;
331
332 /* It is possible that we are currently running under setuid permissions */
333 static int maybe_setuid = 1;
334
335 /* Name of the communication socket used for native gpg-agent
336    requests. The second variable is either NULL or a malloced string
337    with the real socket name in case it has been redirected.  */
338 static char *socket_name;
339 static char *redir_socket_name;
340
341 /* Name of the optional extra socket used for native gpg-agent requests.  */
342 static char *socket_name_extra;
343 static char *redir_socket_name_extra;
344
345 /* Name of the optional browser socket used for native gpg-agent requests.  */
346 static char *socket_name_browser;
347 static char *redir_socket_name_browser;
348
349 /* Name of the communication socket used for ssh-agent-emulation.  */
350 static char *socket_name_ssh;
351 static char *redir_socket_name_ssh;
352
353 /* We need to keep track of the server's nonces (these are dummies for
354    POSIX systems). */
355 static assuan_sock_nonce_t socket_nonce;
356 static assuan_sock_nonce_t socket_nonce_extra;
357 static assuan_sock_nonce_t socket_nonce_browser;
358 static assuan_sock_nonce_t socket_nonce_ssh;
359
360
361 /* Default values for options passed to the pinentry. */
362 static char *default_display;
363 static char *default_ttyname;
364 static char *default_ttytype;
365 static char *default_lc_ctype;
366 static char *default_lc_messages;
367 static char *default_xauthority;
368
369 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
370 static char *config_filename;
371
372 /* Helper to implement --debug-level */
373 static const char *debug_level;
374
375 /* Keep track of the current log file so that we can avoid updating
376    the log file after a SIGHUP if it didn't changed. Malloced. */
377 static char *current_logfile;
378
379 /* The handle_tick() function may test whether a parent is still
380    running.  We record the PID of the parent here or -1 if it should be
381    watched. */
382 static pid_t parent_pid = (pid_t)(-1);
383
384 /* Number of active connections.  */
385 static int active_connections;
386
387 /* This object is used to dispatch progress messages from Libgcrypt to
388  * the right thread.  Given that we will have at max only a few dozen
389  * connections at a time, using a linked list is the easiest way to
390  * handle this. */
391 struct progress_dispatch_s
392 {
393   struct progress_dispatch_s *next;
394   /* The control object of the connection.  If this is NULL no
395    * connection is associated with this item and it is free for reuse
396    * by new connections.  */
397   ctrl_t ctrl;
398
399   /* The thread id of (npth_self) of the connection.  */
400   npth_t tid;
401
402   /* The callback set by the connection.  This is similar to the
403    * Libgcrypt callback but with the control object passed as the
404    * first argument.  */
405   void (*cb)(ctrl_t ctrl,
406              const char *what, int printchar,
407              int current, int total);
408 };
409 struct progress_dispatch_s *progress_dispatch_list;
410
411
412
413 \f
414 /*
415    Local prototypes.
416  */
417
418 static char *create_socket_name (char *standard_name, int with_homedir);
419 static gnupg_fd_t create_server_socket (char *name, int primary, int cygwin,
420                                         char **r_redir_name,
421                                         assuan_sock_nonce_t *nonce);
422 static void create_directories (void);
423
424 static void agent_libgcrypt_progress_cb (void *data, const char *what,
425                                          int printchar,
426                                          int current, int total);
427 static void agent_init_default_ctrl (ctrl_t ctrl);
428 static void agent_deinit_default_ctrl (ctrl_t ctrl);
429
430 static void handle_connections (gnupg_fd_t listen_fd,
431                                 gnupg_fd_t listen_fd_extra,
432                                 gnupg_fd_t listen_fd_browser,
433                                 gnupg_fd_t listen_fd_ssh);
434 static void check_own_socket (void);
435 static int check_for_running_agent (int silent);
436
437 /* Pth wrapper function definitions. */
438 ASSUAN_SYSTEM_NPTH_IMPL;
439
440 \f
441 /*
442    Functions.
443  */
444
445 /* Allocate a string describing a library version by calling a GETFNC.
446    This function is expected to be called only once.  GETFNC is
447    expected to have a semantic like gcry_check_version ().  */
448 static char *
449 make_libversion (const char *libname, const char *(*getfnc)(const char*))
450 {
451   const char *s;
452   char *result;
453
454   if (maybe_setuid)
455     {
456       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
457       maybe_setuid = 0;
458     }
459   s = getfnc (NULL);
460   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
461   strcpy (stpcpy (stpcpy (result, libname), " "), s);
462   return result;
463 }
464
465 /* Return strings describing this program.  The case values are
466    described in common/argparse.c:strusage.  The values here override
467    the default values given by strusage.  */
468 static const char *
469 my_strusage (int level)
470 {
471   static char *ver_gcry;
472   const char *p;
473
474   switch (level)
475     {
476     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
477       break;
478     case 13: p = VERSION; break;
479     case 17: p = PRINTABLE_OS_NAME; break;
480       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
481          reporting address.  This is so that we can change the
482          reporting address without breaking the translations.  */
483     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
484
485     case 20:
486       if (!ver_gcry)
487         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
488       p = ver_gcry;
489       break;
490
491     case 1:
492     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
493       break;
494     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
495                     "Secret key management for @GNUPG@\n");
496     break;
497
498     default: p = NULL;
499     }
500   return p;
501 }
502
503
504
505 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
506    only the active debug flags are propagated to the subsystems.  With
507    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
508    all flags already set. Note that we don't fail here, because it is
509    important to keep gpg-agent running even after re-reading the
510    options due to a SIGHUP. */
511 static void
512 set_debug (void)
513 {
514   int numok = (debug_level && digitp (debug_level));
515   int numlvl = numok? atoi (debug_level) : 0;
516
517   if (!debug_level)
518     ;
519   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
520     opt.debug = 0;
521   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
522     opt.debug = DBG_IPC_VALUE;
523   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
524     opt.debug = DBG_IPC_VALUE;
525   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
526     opt.debug = (DBG_IPC_VALUE | 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.  We don't need it on Windows.  */
955 #ifndef HAVE_W32_SYSTEM
956   startup_fd_list = get_all_open_fds ();
957 #endif /*!HAVE_W32_SYSTEM*/
958 #ifdef HAVE_SIGPROCMASK
959   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
960     startup_signal_mask_valid = 1;
961 #endif /*HAVE_SIGPROCMASK*/
962
963   /* Set program name etc.  */
964   set_strusage (my_strusage);
965   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
966   /* Please note that we may running SUID(ROOT), so be very CAREFUL
967      when adding any stuff between here and the call to INIT_SECMEM()
968      somewhere after the option parsing */
969   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
970
971   /* Make sure that our subsystems are ready.  */
972   i18n_init ();
973   init_common_subsystems (&argc, &argv);
974
975   malloc_hooks.malloc = gcry_malloc;
976   malloc_hooks.realloc = gcry_realloc;
977   malloc_hooks.free = gcry_free;
978   assuan_set_malloc_hooks (&malloc_hooks);
979   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
980   assuan_sock_init ();
981   setup_libassuan_logging (&opt.debug, NULL);
982
983   setup_libgcrypt_logging ();
984   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
985   gcry_set_progress_handler (agent_libgcrypt_progress_cb, NULL);
986
987   disable_core_dumps ();
988
989   /* Set default options.  */
990   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
991
992   shell = getenv ("SHELL");
993   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
994     csh_style = 1;
995
996   /* Record some of the original environment strings. */
997   {
998     const char *s;
999     int idx;
1000     static const char *names[] =
1001       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
1002
1003     err = 0;
1004     opt.startup_env = session_env_new ();
1005     if (!opt.startup_env)
1006       err = gpg_error_from_syserror ();
1007     for (idx=0; !err && names[idx]; idx++)
1008       {
1009         s = getenv (names[idx]);
1010         if (s)
1011           err = session_env_setenv (opt.startup_env, names[idx], s);
1012       }
1013     if (!err)
1014       {
1015         s = gnupg_ttyname (0);
1016         if (s)
1017           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
1018       }
1019     if (err)
1020       log_fatal ("error recording startup environment: %s\n",
1021                  gpg_strerror (err));
1022
1023     /* Fixme: Better use the locale function here.  */
1024     opt.startup_lc_ctype = getenv ("LC_CTYPE");
1025     if (opt.startup_lc_ctype)
1026       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
1027     opt.startup_lc_messages = getenv ("LC_MESSAGES");
1028     if (opt.startup_lc_messages)
1029       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
1030   }
1031
1032   /* Check whether we have a config file on the commandline */
1033   orig_argc = argc;
1034   orig_argv = argv;
1035   pargs.argc = &argc;
1036   pargs.argv = &argv;
1037   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1038   while (arg_parse( &pargs, opts))
1039     {
1040       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
1041         parse_debug++;
1042       else if (pargs.r_opt == oOptions)
1043         { /* yes there is one, so we do not try the default one, but
1044              read the option file when it is encountered at the
1045              commandline */
1046           default_config = 0;
1047         }
1048         else if (pargs.r_opt == oNoOptions)
1049           default_config = 0; /* --no-options */
1050         else if (pargs.r_opt == oHomedir)
1051           gnupg_set_homedir (pargs.r.ret_str);
1052         else if (pargs.r_opt == oDebugQuickRandom)
1053           {
1054             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1055           }
1056
1057     }
1058
1059   /* Initialize the secure memory. */
1060   gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0);
1061   maybe_setuid = 0;
1062
1063   /*
1064      Now we are now working under our real uid
1065   */
1066
1067   if (default_config)
1068     configname = make_filename (gnupg_homedir (),
1069                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1070
1071   argc = orig_argc;
1072   argv = orig_argv;
1073   pargs.argc = &argc;
1074   pargs.argv = &argv;
1075   pargs.flags=  1;  /* do not remove the args */
1076  next_pass:
1077   if (configname)
1078     {
1079       configlineno = 0;
1080       configfp = fopen (configname, "r");
1081       if (!configfp)
1082         {
1083           if (default_config)
1084             {
1085               if( parse_debug )
1086                 log_info (_("Note: no default option file '%s'\n"),
1087                           configname );
1088               /* Save the default conf file name so that
1089                  reread_configuration is able to test whether the
1090                  config file has been created in the meantime.  */
1091               xfree (config_filename);
1092               config_filename = configname;
1093               configname = NULL;
1094             }
1095           else
1096             {
1097               log_error (_("option file '%s': %s\n"),
1098                          configname, strerror(errno) );
1099               exit(2);
1100             }
1101           xfree (configname);
1102           configname = NULL;
1103         }
1104       if (parse_debug && configname )
1105         log_info (_("reading options from '%s'\n"), configname );
1106       default_config = 0;
1107     }
1108
1109   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
1110     {
1111       if (parse_rereadable_options (&pargs, 0))
1112         continue; /* Already handled */
1113       switch (pargs.r_opt)
1114         {
1115         case aGPGConfList: gpgconf_list = 1; break;
1116         case aGPGConfTest: gpgconf_list = 2; break;
1117         case aUseStandardSocketP: gpgconf_list = 3; break;
1118         case oBatch: opt.batch=1; break;
1119
1120         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1121
1122         case oOptions:
1123           /* config files may not be nested (silently ignore them) */
1124           if (!configfp)
1125             {
1126                 xfree(configname);
1127                 configname = xstrdup(pargs.r.ret_str);
1128                 goto next_pass;
1129             }
1130           break;
1131         case oNoGreeting: /* Dummy option.  */ break;
1132         case oNoVerbose: opt.verbose = 0; break;
1133         case oNoOptions: break; /* no-options */
1134         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1135         case oNoDetach: nodetach = 1; break;
1136         case oLogFile: logfile = pargs.r.ret_str; break;
1137         case oCsh: csh_style = 1; break;
1138         case oSh: csh_style = 0; break;
1139         case oServer: pipe_server = 1; break;
1140         case oDaemon: is_daemon = 1; break;
1141         case oSupervised: is_supervised = 1; break;
1142
1143         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
1144         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
1145         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
1146         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
1147         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
1148           break;
1149         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
1150           break;
1151
1152         case oUseStandardSocket:
1153         case oNoUseStandardSocket:
1154           obsolete_option (configname, configlineno, "use-standard-socket");
1155           break;
1156
1157         case oFakedSystemTime:
1158           {
1159             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1160             if (faked_time == (time_t)(-1))
1161               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1162             gnupg_set_time (faked_time, 0);
1163           }
1164           break;
1165
1166         case oKeepTTY: opt.keep_tty = 1; break;
1167         case oKeepDISPLAY: opt.keep_display = 1; break;
1168
1169         case oSSHSupport:
1170           ssh_support = 1;
1171           break;
1172         case oPuttySupport:
1173 #        ifdef HAVE_W32_SYSTEM
1174           putty_support = 1;
1175 #        endif
1176           break;
1177
1178         case oExtraSocket:
1179           opt.extra_socket = 1;  /* (1 = points into argv)  */
1180           socket_name_extra = pargs.r.ret_str;
1181           break;
1182
1183         case oBrowserSocket:
1184           opt.browser_socket = 1;  /* (1 = points into argv)  */
1185           socket_name_browser = pargs.r.ret_str;
1186           break;
1187
1188         case oDebugQuickRandom:
1189           /* Only used by the first stage command line parser.  */
1190           break;
1191
1192         case oWriteEnvFile:
1193           obsolete_option (configname, configlineno, "write-env-file");
1194           break;
1195
1196         default : pargs.err = configfp? 1:2; break;
1197         }
1198     }
1199   if (configfp)
1200     {
1201       fclose( configfp );
1202       configfp = NULL;
1203       /* Keep a copy of the name so that it can be read on SIGHUP. */
1204       if (config_filename != configname)
1205         {
1206           xfree (config_filename);
1207           config_filename = configname;
1208         }
1209       configname = NULL;
1210       goto next_pass;
1211     }
1212
1213   xfree (configname);
1214   configname = NULL;
1215   if (log_get_errorcount(0))
1216     exit(2);
1217
1218   finalize_rereadable_options ();
1219
1220   /* Print a warning if an argument looks like an option.  */
1221   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1222     {
1223       int i;
1224
1225       for (i=0; i < argc; i++)
1226         if (argv[i][0] == '-' && argv[i][1] == '-')
1227           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1228     }
1229
1230 #ifdef ENABLE_NLS
1231   /* gpg-agent usually does not output any messages because it runs in
1232      the background.  For log files it is acceptable to have messages
1233      always encoded in utf-8.  We switch here to utf-8, so that
1234      commands like --help still give native messages.  It is far
1235      easier to switch only once instead of for every message and it
1236      actually helps when more then one thread is active (avoids an
1237      extra copy step). */
1238     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1239 #endif
1240
1241   if (!pipe_server && !is_daemon && !gpgconf_list && !is_supervised)
1242     {
1243      /* We have been called without any command and thus we merely
1244         check whether an agent is already running.  We do this right
1245         here so that we don't clobber a logfile with this check but
1246         print the status directly to stderr. */
1247       opt.debug = 0;
1248       set_debug ();
1249       check_for_running_agent (0);
1250       agent_exit (0);
1251     }
1252
1253   if (is_supervised)
1254     ;
1255   else if (!opt.extra_socket)
1256     opt.extra_socket = 1;
1257   else if (socket_name_extra
1258            && (!strcmp (socket_name_extra, "none")
1259                || !strcmp (socket_name_extra, "/dev/null")))
1260     {
1261       /* User requested not to create this socket.  */
1262       opt.extra_socket = 0;
1263       socket_name_extra = NULL;
1264     }
1265
1266   if (is_supervised)
1267     ;
1268   else if (!opt.browser_socket)
1269     opt.browser_socket = 1;
1270   else if (socket_name_browser
1271            && (!strcmp (socket_name_browser, "none")
1272                || !strcmp (socket_name_browser, "/dev/null")))
1273     {
1274       /* User requested not to create this socket.  */
1275       opt.browser_socket = 0;
1276       socket_name_browser = NULL;
1277     }
1278
1279   set_debug ();
1280
1281   if (atexit (cleanup))
1282     {
1283       log_error ("atexit failed\n");
1284       cleanup ();
1285       exit (1);
1286     }
1287
1288   /* Try to create missing directories. */
1289   create_directories ();
1290
1291   if (debug_wait && pipe_server)
1292     {
1293       thread_init_once ();
1294       log_debug ("waiting for debugger - my pid is %u .....\n",
1295                  (unsigned int)getpid());
1296       gnupg_sleep (debug_wait);
1297       log_debug ("... okay\n");
1298     }
1299
1300   if (gpgconf_list == 3)
1301     {
1302       /* We now use the standard socket always - return true for
1303          backward compatibility.  */
1304       agent_exit (0);
1305     }
1306   else if (gpgconf_list == 2)
1307     agent_exit (0);
1308   else if (gpgconf_list)
1309     {
1310       char *filename;
1311       char *filename_esc;
1312
1313       /* List options and default values in the GPG Conf format.  */
1314       filename = make_filename (gnupg_homedir (),
1315                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1316       filename_esc = percent_escape (filename, NULL);
1317
1318       es_printf ("%s-%s.conf:%lu:\"%s\n",
1319                  GPGCONF_NAME, GPG_AGENT_NAME,
1320                  GC_OPT_FLAG_DEFAULT, filename_esc);
1321       xfree (filename);
1322       xfree (filename_esc);
1323
1324       es_printf ("verbose:%lu:\n"
1325               "quiet:%lu:\n"
1326               "debug-level:%lu:\"none:\n"
1327               "log-file:%lu:\n",
1328               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1329               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1330               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1331               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1332       es_printf ("default-cache-ttl:%lu:%d:\n",
1333               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1334       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1335               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1336       es_printf ("max-cache-ttl:%lu:%d:\n",
1337               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1338       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1339               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1340       es_printf ("enforce-passphrase-constraints:%lu:\n",
1341               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1342       es_printf ("min-passphrase-len:%lu:%d:\n",
1343               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1344       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1345               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1346               MIN_PASSPHRASE_NONALPHA);
1347       es_printf ("check-passphrase-pattern:%lu:\n",
1348               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1349       es_printf ("max-passphrase-days:%lu:%d:\n",
1350               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1351               MAX_PASSPHRASE_DAYS);
1352       es_printf ("enable-passphrase-history:%lu:\n",
1353               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1354       es_printf ("no-grab:%lu:\n",
1355               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1356       es_printf ("ignore-cache-for-signing:%lu:\n",
1357               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1358       es_printf ("no-allow-external-cache:%lu:\n",
1359               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1360       es_printf ("no-allow-mark-trusted:%lu:\n",
1361               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1362       es_printf ("disable-scdaemon:%lu:\n",
1363               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1364       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1365 #ifdef HAVE_W32_SYSTEM
1366       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1367 #endif
1368       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1369               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1370       es_printf ("allow-emacs-pinentry:%lu:\n",
1371                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1372       es_printf ("pinentry-timeout:%lu:0:\n",
1373                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1374
1375       agent_exit (0);
1376     }
1377
1378   /* Now start with logging to a file if this is desired. */
1379   if (logfile)
1380     {
1381       log_set_file (logfile);
1382       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1383                              | GPGRT_LOG_WITH_TIME
1384                              | GPGRT_LOG_WITH_PID));
1385       current_logfile = xstrdup (logfile);
1386     }
1387
1388   /* Make sure that we have a default ttyname. */
1389   if (!default_ttyname && gnupg_ttyname (1))
1390     default_ttyname = xstrdup (gnupg_ttyname (1));
1391   if (!default_ttytype && getenv ("TERM"))
1392     default_ttytype = xstrdup (getenv ("TERM"));
1393
1394
1395   if (pipe_server)
1396     {
1397       /* This is the simple pipe based server */
1398       ctrl_t ctrl;
1399
1400       initialize_modules ();
1401
1402       ctrl = xtrycalloc (1, sizeof *ctrl);
1403       if (!ctrl)
1404         {
1405           log_error ("error allocating connection control data: %s\n",
1406                      strerror (errno) );
1407           agent_exit (1);
1408         }
1409       ctrl->session_env = session_env_new ();
1410       if (!ctrl->session_env)
1411         {
1412           log_error ("error allocating session environment block: %s\n",
1413                      strerror (errno) );
1414           xfree (ctrl);
1415           agent_exit (1);
1416         }
1417       agent_init_default_ctrl (ctrl);
1418       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1419       agent_deinit_default_ctrl (ctrl);
1420       xfree (ctrl);
1421     }
1422   else if (is_supervised)
1423     {
1424 #ifndef HAVE_W32_SYSTEM
1425       gnupg_fd_t fd, fd_extra, fd_browser, fd_ssh;
1426
1427       initialize_modules ();
1428
1429       /* when supervised and sending logs to stderr, the process
1430          supervisor should handle log entry metadata (pid, name,
1431          timestamp) */
1432       if (!logfile)
1433         log_set_prefix (NULL, 0);
1434
1435       log_info ("%s %s starting in supervised mode.\n",
1436                 strusage(11), strusage(13) );
1437
1438       /* See below in "regular server mode" on why we remove certain
1439        * envvars.  */
1440       if (!opt.keep_display)
1441         gnupg_unsetenv ("DISPLAY");
1442       gnupg_unsetenv ("INSIDE_EMACS");
1443
1444       /* Virtually create the sockets.  Note that we use -1 here
1445        * because the whole thing works only on Unix. */
1446       map_supervised_sockets (&fd, &fd_extra, &fd_browser, &fd_ssh);
1447       if (fd == -1)
1448         log_fatal ("no standard socket provided\n");
1449
1450 #ifdef HAVE_SIGPROCMASK
1451       if (startup_signal_mask_valid)
1452         {
1453           if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1454             log_error ("error restoring signal mask: %s\n",
1455                        strerror (errno));
1456         }
1457       else
1458         log_info ("no saved signal mask\n");
1459 #endif /*HAVE_SIGPROCMASK*/
1460
1461       log_info ("listening on: std=%d extra=%d browser=%d ssh=%d\n",
1462                 fd, fd_extra, fd_browser, fd_ssh);
1463       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1464 #endif /*!HAVE_W32_SYSTEM*/
1465     }
1466   else if (!is_daemon)
1467     ; /* NOTREACHED */
1468   else
1469     { /* Regular server mode */
1470       gnupg_fd_t fd;
1471       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1472       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1473       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1474 #ifndef HAVE_W32_SYSTEM
1475       pid_t pid;
1476 #endif
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
1538 #ifdef HAVE_W32_SYSTEM
1539
1540       (void)csh_style;
1541       (void)nodetach;
1542       initialize_modules ();
1543
1544 #else /*!HAVE_W32_SYSTEM*/
1545
1546       pid = fork ();
1547       if (pid == (pid_t)-1)
1548         {
1549           log_fatal ("fork failed: %s\n", strerror (errno) );
1550           exit (1);
1551         }
1552       else if (pid)
1553         { /* We are the parent */
1554           char *infostr_ssh_sock, *infostr_ssh_valid;
1555
1556           /* Close the socket FD. */
1557           close (fd);
1558
1559           /* The signal mask might not be correct right now and thus
1560              we restore it.  That is not strictly necessary but some
1561              programs falsely assume a cleared signal mask.  */
1562
1563 #ifdef HAVE_SIGPROCMASK
1564           if (startup_signal_mask_valid)
1565             {
1566               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1567                 log_error ("error restoring signal mask: %s\n",
1568                            strerror (errno));
1569             }
1570           else
1571             log_info ("no saved signal mask\n");
1572 #endif /*HAVE_SIGPROCMASK*/
1573
1574           /* Create the SSH info string if enabled. */
1575           if (ssh_support)
1576             {
1577               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1578                             socket_name_ssh) < 0)
1579                 {
1580                   log_error ("out of core\n");
1581                   kill (pid, SIGTERM);
1582                   exit (1);
1583                 }
1584               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1585                             (unsigned long)getpid()) < 0)
1586                 {
1587                   log_error ("out of core\n");
1588                   kill (pid, SIGTERM);
1589                   exit (1);
1590                 }
1591             }
1592
1593           *socket_name = 0; /* Don't let cleanup() remove the socket -
1594                                the child should do this from now on */
1595           if (opt.extra_socket)
1596             *socket_name_extra = 0;
1597           if (opt.browser_socket)
1598             *socket_name_browser = 0;
1599           *socket_name_ssh = 0;
1600
1601           if (argc)
1602             { /* Run the program given on the commandline.  */
1603               if (ssh_support && (putenv (infostr_ssh_sock)
1604                                   || putenv (infostr_ssh_valid)))
1605                 {
1606                   log_error ("failed to set environment: %s\n",
1607                              strerror (errno) );
1608                   kill (pid, SIGTERM );
1609                   exit (1);
1610                 }
1611
1612               /* Close all the file descriptors except the standard
1613                  ones and those open at startup.  We explicitly don't
1614                  close 0,1,2 in case something went wrong collecting
1615                  them at startup.  */
1616               close_all_fds (3, startup_fd_list);
1617
1618               /* Run the command.  */
1619               execvp (argv[0], argv);
1620               log_error ("failed to run the command: %s\n", strerror (errno));
1621               kill (pid, SIGTERM);
1622               exit (1);
1623             }
1624           else
1625             {
1626               /* Print the environment string, so that the caller can use
1627                  shell's eval to set it */
1628               if (csh_style)
1629                 {
1630                   if (ssh_support)
1631                     {
1632                       *strchr (infostr_ssh_sock, '=') = ' ';
1633                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1634                     }
1635                 }
1636               else
1637                 {
1638                   if (ssh_support)
1639                     {
1640                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1641                                  infostr_ssh_sock);
1642                     }
1643                 }
1644               if (ssh_support)
1645                 {
1646                   xfree (infostr_ssh_sock);
1647                   xfree (infostr_ssh_valid);
1648                 }
1649               exit (0);
1650             }
1651           /*NOTREACHED*/
1652         } /* End parent */
1653
1654       /*
1655          This is the child
1656        */
1657
1658       initialize_modules ();
1659
1660       /* Detach from tty and put process into a new session */
1661       if (!nodetach )
1662         {
1663           int i;
1664           unsigned int oldflags;
1665
1666           /* Close stdin, stdout and stderr unless it is the log stream */
1667           for (i=0; i <= 2; i++)
1668             {
1669               if (!log_test_fd (i) && i != fd )
1670                 {
1671                   if ( ! close (i)
1672                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1673                     {
1674                       log_error ("failed to open '%s': %s\n",
1675                                  "/dev/null", strerror (errno));
1676                       cleanup ();
1677                       exit (1);
1678                     }
1679                 }
1680             }
1681           if (setsid() == -1)
1682             {
1683               log_error ("setsid() failed: %s\n", strerror(errno) );
1684               cleanup ();
1685               exit (1);
1686             }
1687
1688           log_get_prefix (&oldflags);
1689           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1690           opt.running_detached = 1;
1691         }
1692
1693       if (chdir("/"))
1694         {
1695           log_error ("chdir to / failed: %s\n", strerror (errno));
1696           exit (1);
1697         }
1698
1699       {
1700         struct sigaction sa;
1701
1702         sa.sa_handler = SIG_IGN;
1703         sigemptyset (&sa.sa_mask);
1704         sa.sa_flags = 0;
1705         sigaction (SIGPIPE, &sa, NULL);
1706       }
1707 #endif /*!HAVE_W32_SYSTEM*/
1708
1709       log_info ("%s %s started\n", strusage(11), strusage(13) );
1710       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1711       assuan_sock_close (fd);
1712     }
1713
1714   return 0;
1715 }
1716
1717
1718 /* Exit entry point.  This function should be called instead of a
1719    plain exit.  */
1720 void
1721 agent_exit (int rc)
1722 {
1723   /*FIXME: update_random_seed_file();*/
1724
1725   /* We run our cleanup handler because that may close cipher contexts
1726      stored in secure memory and thus this needs to be done before we
1727      explicitly terminate secure memory.  */
1728   cleanup ();
1729
1730 #if 1
1731   /* at this time a bit annoying */
1732   if (opt.debug & DBG_MEMSTAT_VALUE)
1733     {
1734       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1735       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1736     }
1737   if (opt.debug)
1738     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1739 #endif
1740   gcry_control (GCRYCTL_TERM_SECMEM );
1741   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1742   exit (rc);
1743 }
1744
1745
1746 /* This is our callback function for gcrypt progress messages.  It is
1747    set once at startup and dispatches progress messages to the
1748    corresponding threads of the agent.  */
1749 static void
1750 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1751                              int current, int total)
1752 {
1753   struct progress_dispatch_s *dispatch;
1754   npth_t mytid = npth_self ();
1755
1756   (void)data;
1757
1758   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1759     if (dispatch->ctrl && dispatch->tid == mytid)
1760       break;
1761   if (dispatch && dispatch->cb)
1762     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1763
1764   /* Libgcrypt < 1.8 does not know about nPth and thus when it reads
1765    * from /dev/random this will block the process.  To mitigate this
1766    * problem we take a short nap when Libgcrypt tells us that it needs
1767    * more entropy.  This way other threads have chance to run.  */
1768 #if GCRYPT_VERSION_NUMBER < 0x010800 /* 1.8.0 */
1769   if (what && !strcmp (what, "need_entropy"))
1770     npth_usleep (100000); /* 100ms */
1771 #endif
1772 }
1773
1774
1775 /* If a progress dispatcher callback has been associated with the
1776  * current connection unregister it.  */
1777 static void
1778 unregister_progress_cb (void)
1779 {
1780   struct progress_dispatch_s *dispatch;
1781   npth_t mytid = npth_self ();
1782
1783   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1784     if (dispatch->ctrl && dispatch->tid == mytid)
1785       break;
1786   if (dispatch)
1787     {
1788       dispatch->ctrl = NULL;
1789       dispatch->cb = NULL;
1790     }
1791 }
1792
1793
1794 /* Setup a progress callback CB for the current connection.  Using a
1795  * CB of NULL disables the callback.  */
1796 void
1797 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1798                                   int printchar, int current, int total),
1799                        ctrl_t ctrl)
1800 {
1801   struct progress_dispatch_s *dispatch, *firstfree;
1802   npth_t mytid = npth_self ();
1803
1804   firstfree = NULL;
1805   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1806     {
1807       if (dispatch->ctrl && dispatch->tid == mytid)
1808         break;
1809       if (!dispatch->ctrl && !firstfree)
1810         firstfree = dispatch;
1811     }
1812   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1813     {
1814       if (firstfree)
1815         {
1816           dispatch = firstfree;
1817         }
1818       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1819         {
1820           dispatch->next = progress_dispatch_list;
1821           progress_dispatch_list = dispatch;
1822         }
1823       else
1824         {
1825           log_error ("error allocating new progress dispatcher slot: %s\n",
1826                      gpg_strerror (gpg_error_from_syserror ()));
1827           return;
1828         }
1829       dispatch->ctrl = ctrl;
1830       dispatch->tid = mytid;
1831     }
1832
1833   dispatch->cb = cb;
1834 }
1835
1836
1837 /* Each thread has its own local variables conveyed by a control
1838    structure usually identified by an argument named CTRL.  This
1839    function is called immediately after allocating the control
1840    structure.  Its purpose is to setup the default values for that
1841    structure.  Note that some values may have already been set.  */
1842 static void
1843 agent_init_default_ctrl (ctrl_t ctrl)
1844 {
1845   assert (ctrl->session_env);
1846
1847   /* Note we ignore malloc errors because we can't do much about it
1848      and the request will fail anyway shortly after this
1849      initialization. */
1850   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1851   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1852   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1853   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1854   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1855
1856   if (ctrl->lc_ctype)
1857     xfree (ctrl->lc_ctype);
1858   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1859
1860   if (ctrl->lc_messages)
1861     xfree (ctrl->lc_messages);
1862   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1863                                     /**/ : NULL;
1864   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1865 }
1866
1867
1868 /* Release all resources allocated by default in the control
1869    structure.  This is the counterpart to agent_init_default_ctrl.  */
1870 static void
1871 agent_deinit_default_ctrl (ctrl_t ctrl)
1872 {
1873   unregister_progress_cb ();
1874   session_env_release (ctrl->session_env);
1875
1876   if (ctrl->lc_ctype)
1877     xfree (ctrl->lc_ctype);
1878   if (ctrl->lc_messages)
1879     xfree (ctrl->lc_messages);
1880 }
1881
1882
1883 /* Because the ssh protocol does not send us information about the
1884    current TTY setting, we use this function to use those from startup
1885    or those explicitly set.  This is also used for the restricted mode
1886    where we ignore requests to change the environment.  */
1887 gpg_error_t
1888 agent_copy_startup_env (ctrl_t ctrl)
1889 {
1890   static const char *names[] =
1891     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1892   gpg_error_t err = 0;
1893   int idx;
1894   const char *value;
1895
1896   for (idx=0; !err && names[idx]; idx++)
1897       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1898       err = session_env_setenv (ctrl->session_env, names[idx], value);
1899
1900   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1901     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1902       err = gpg_error_from_syserror ();
1903
1904   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1905     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1906       err = gpg_error_from_syserror ();
1907
1908   if (err)
1909     log_error ("error setting default session environment: %s\n",
1910                gpg_strerror (err));
1911
1912   return err;
1913 }
1914
1915
1916 /* Reread parts of the configuration.  Note, that this function is
1917    obviously not thread-safe and should only be called from the PTH
1918    signal handler.
1919
1920    Fixme: Due to the way the argument parsing works, we create a
1921    memory leak here for all string type arguments.  There is currently
1922    no clean way to tell whether the memory for the argument has been
1923    allocated or points into the process' original arguments.  Unless
1924    we have a mechanism to tell this, we need to live on with this. */
1925 static void
1926 reread_configuration (void)
1927 {
1928   ARGPARSE_ARGS pargs;
1929   FILE *fp;
1930   unsigned int configlineno = 0;
1931   int dummy;
1932
1933   if (!config_filename)
1934     return; /* No config file. */
1935
1936   fp = fopen (config_filename, "r");
1937   if (!fp)
1938     {
1939       log_info (_("option file '%s': %s\n"),
1940                 config_filename, strerror(errno) );
1941       return;
1942     }
1943
1944   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1945
1946   memset (&pargs, 0, sizeof pargs);
1947   dummy = 0;
1948   pargs.argc = &dummy;
1949   pargs.flags = 1;  /* do not remove the args */
1950   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1951     {
1952       if (pargs.r_opt < -1)
1953         pargs.err = 1; /* Print a warning. */
1954       else /* Try to parse this option - ignore unchangeable ones. */
1955         parse_rereadable_options (&pargs, 1);
1956     }
1957   fclose (fp);
1958   finalize_rereadable_options ();
1959   set_debug ();
1960 }
1961
1962
1963 /* Return the file name of the socket we are using for native
1964    requests.  */
1965 const char *
1966 get_agent_socket_name (void)
1967 {
1968   const char *s = socket_name;
1969
1970   return (s && *s)? s : NULL;
1971 }
1972
1973 /* Return the file name of the socket we are using for SSH
1974    requests.  */
1975 const char *
1976 get_agent_ssh_socket_name (void)
1977 {
1978   const char *s = socket_name_ssh;
1979
1980   return (s && *s)? s : NULL;
1981 }
1982
1983
1984 /* Return the number of active connections. */
1985 int
1986 get_agent_active_connection_count (void)
1987 {
1988   return active_connections;
1989 }
1990
1991
1992 /* Under W32, this function returns the handle of the scdaemon
1993    notification event.  Calling it the first time creates that
1994    event.  */
1995 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1996 void *
1997 get_agent_scd_notify_event (void)
1998 {
1999   static HANDLE the_event = INVALID_HANDLE_VALUE;
2000
2001   if (the_event == INVALID_HANDLE_VALUE)
2002     {
2003       HANDLE h, h2;
2004       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2005
2006       /* We need to use a manual reset event object due to the way our
2007          w32-pth wait function works: If we would use an automatic
2008          reset event we are not able to figure out which handle has
2009          been signaled because at the time we single out the signaled
2010          handles using WFSO the event has already been reset due to
2011          the WFMO.  */
2012       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2013       if (!h)
2014         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2015       else if (!DuplicateHandle (GetCurrentProcess(), h,
2016                                  GetCurrentProcess(), &h2,
2017                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2018         {
2019           log_error ("setting syncronize for scd notify event failed: %s\n",
2020                      w32_strerror (-1) );
2021           CloseHandle (h);
2022         }
2023       else
2024         {
2025           CloseHandle (h);
2026           the_event = h2;
2027         }
2028     }
2029
2030   return the_event;
2031 }
2032 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2033
2034
2035
2036 /* Create a name for the socket in the home directory as using
2037    STANDARD_NAME.  We also check for valid characters as well as
2038    against a maximum allowed length for a unix domain socket is done.
2039    The function terminates the process in case of an error.  Returns:
2040    Pointer to an allocated string with the absolute name of the socket
2041    used.  */
2042 static char *
2043 create_socket_name (char *standard_name, int with_homedir)
2044 {
2045   char *name;
2046
2047   if (with_homedir)
2048     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2049   else
2050     name = make_filename (standard_name, NULL);
2051   if (strchr (name, PATHSEP_C))
2052     {
2053       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2054       agent_exit (2);
2055     }
2056   return name;
2057 }
2058
2059
2060
2061 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2062    or terminates the process in case of an error.  Note that this
2063    function needs to be used for the regular socket first (indicated
2064    by PRIMARY) and only then for the extra and the ssh sockets.  If
2065    the socket has been redirected the name of the real socket is
2066    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2067    Cygwin compatible socket is created (Windows only). */
2068 static gnupg_fd_t
2069 create_server_socket (char *name, int primary, int cygwin,
2070                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2071 {
2072   struct sockaddr *addr;
2073   struct sockaddr_un *unaddr;
2074   socklen_t len;
2075   gnupg_fd_t fd;
2076   int rc;
2077
2078   xfree (*r_redir_name);
2079   *r_redir_name = NULL;
2080
2081   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2082   if (fd == ASSUAN_INVALID_FD)
2083     {
2084       log_error (_("can't create socket: %s\n"), strerror (errno));
2085       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2086       agent_exit (2);
2087     }
2088
2089   if (cygwin)
2090     assuan_sock_set_flag (fd, "cygwin", 1);
2091
2092   unaddr = xmalloc (sizeof *unaddr);
2093   addr = (struct sockaddr*)unaddr;
2094
2095   {
2096     int redirected;
2097
2098     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2099       {
2100         if (errno == ENAMETOOLONG)
2101           log_error (_("socket name '%s' is too long\n"), name);
2102         else
2103           log_error ("error preparing socket '%s': %s\n",
2104                      name, gpg_strerror (gpg_error_from_syserror ()));
2105         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2106         agent_exit (2);
2107       }
2108     if (redirected)
2109       {
2110         *r_redir_name = xstrdup (unaddr->sun_path);
2111         if (opt.verbose)
2112           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2113       }
2114   }
2115
2116   len = SUN_LEN (unaddr);
2117   rc = assuan_sock_bind (fd, addr, len);
2118
2119   /* Our error code mapping on W32CE returns EEXIST thus we also test
2120      for this. */
2121   if (rc == -1
2122       && (errno == EADDRINUSE
2123 #ifdef HAVE_W32_SYSTEM
2124           || errno == EEXIST
2125 #endif
2126           ))
2127     {
2128       /* Check whether a gpg-agent is already running.  We do this
2129          test only if this is the primary socket.  For secondary
2130          sockets we assume that a test for gpg-agent has already been
2131          done and reuse the requested socket.  Testing the ssh-socket
2132          is not possible because at this point, though we know the new
2133          Assuan socket, the Assuan server and thus the ssh-agent
2134          server is not yet operational; this would lead to a hang.  */
2135       if (primary && !check_for_running_agent (1))
2136         {
2137           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2138           log_set_file (NULL);
2139           log_error (_("a gpg-agent is already running - "
2140                        "not starting a new one\n"));
2141           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2142           assuan_sock_close (fd);
2143           agent_exit (2);
2144         }
2145       gnupg_remove (unaddr->sun_path);
2146       rc = assuan_sock_bind (fd, addr, len);
2147     }
2148   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2149     log_error (_("error getting nonce for the socket\n"));
2150   if (rc == -1)
2151     {
2152       /* We use gpg_strerror here because it allows us to get strings
2153          for some W32 socket error codes.  */
2154       log_error (_("error binding socket to '%s': %s\n"),
2155                  unaddr->sun_path,
2156                  gpg_strerror (gpg_error_from_syserror ()));
2157
2158       assuan_sock_close (fd);
2159       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2160       agent_exit (2);
2161     }
2162
2163   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2164     log_error (_("can't set permissions of '%s': %s\n"),
2165                unaddr->sun_path, strerror (errno));
2166
2167   if (listen (FD2INT(fd), 5 ) == -1)
2168     {
2169       log_error (_("listen() failed: %s\n"), strerror (errno));
2170       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2171       assuan_sock_close (fd);
2172       agent_exit (2);
2173     }
2174
2175   if (opt.verbose)
2176     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2177
2178   return fd;
2179 }
2180
2181
2182 /* Check that the directory for storing the private keys exists and
2183    create it if not.  This function won't fail as it is only a
2184    convenience function and not strictly necessary.  */
2185 static void
2186 create_private_keys_directory (const char *home)
2187 {
2188   char *fname;
2189   struct stat statbuf;
2190
2191   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2192   if (stat (fname, &statbuf) && errno == ENOENT)
2193     {
2194       if (gnupg_mkdir (fname, "-rwx"))
2195         log_error (_("can't create directory '%s': %s\n"),
2196                    fname, strerror (errno) );
2197       else if (!opt.quiet)
2198         log_info (_("directory '%s' created\n"), fname);
2199     }
2200   if (gnupg_chmod (fname, "-rwx"))
2201     log_error (_("can't set permissions of '%s': %s\n"),
2202                fname, strerror (errno));
2203   xfree (fname);
2204 }
2205
2206
2207 /* Create the directory only if the supplied directory name is the
2208    same as the default one.  This way we avoid to create arbitrary
2209    directories when a non-default home directory is used.  To cope
2210    with HOME, we compare only the suffix if we see that the default
2211    homedir does start with a tilde.  We don't stop here in case of
2212    problems because other functions will throw an error anyway.*/
2213 static void
2214 create_directories (void)
2215 {
2216   struct stat statbuf;
2217   const char *defhome = standard_homedir ();
2218   char *home;
2219
2220   home = make_filename (gnupg_homedir (), NULL);
2221   if ( stat (home, &statbuf) )
2222     {
2223       if (errno == ENOENT)
2224         {
2225           if (
2226 #ifdef HAVE_W32_SYSTEM
2227               ( !compare_filenames (home, defhome) )
2228 #else
2229               (*defhome == '~'
2230                 && (strlen (home) >= strlen (defhome+1)
2231                     && !strcmp (home + strlen(home)
2232                                 - strlen (defhome+1), defhome+1)))
2233                || (*defhome != '~' && !strcmp (home, defhome) )
2234 #endif
2235                )
2236             {
2237               if (gnupg_mkdir (home, "-rwx"))
2238                 log_error (_("can't create directory '%s': %s\n"),
2239                            home, strerror (errno) );
2240               else
2241                 {
2242                   if (!opt.quiet)
2243                     log_info (_("directory '%s' created\n"), home);
2244                   create_private_keys_directory (home);
2245                 }
2246             }
2247         }
2248       else
2249         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2250     }
2251   else if ( !S_ISDIR(statbuf.st_mode))
2252     {
2253       log_error (_("can't use '%s' as home directory\n"), home);
2254     }
2255   else /* exists and is a directory. */
2256     {
2257       create_private_keys_directory (home);
2258     }
2259   xfree (home);
2260 }
2261
2262
2263
2264 /* This is the worker for the ticker.  It is called every few seconds
2265    and may only do fast operations. */
2266 static void
2267 handle_tick (void)
2268 {
2269   static time_t last_minute;
2270
2271   if (!last_minute)
2272     last_minute = time (NULL);
2273
2274   /* Check whether the scdaemon has died and cleanup in this case. */
2275   agent_scd_check_aliveness ();
2276
2277   /* If we are running as a child of another process, check whether
2278      the parent is still alive and shutdown if not. */
2279 #ifndef HAVE_W32_SYSTEM
2280   if (parent_pid != (pid_t)(-1))
2281     {
2282       if (kill (parent_pid, 0))
2283         {
2284           shutdown_pending = 2;
2285           log_info ("parent process died - shutting down\n");
2286           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2287           cleanup ();
2288           agent_exit (0);
2289         }
2290     }
2291 #endif /*HAVE_W32_SYSTEM*/
2292
2293   /* Code to be run from time to time.  */
2294 #if CHECK_OWN_SOCKET_INTERVAL > 0
2295   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2296     {
2297       check_own_socket ();
2298       last_minute = time (NULL);
2299     }
2300 #endif
2301
2302 }
2303
2304
2305 /* A global function which allows us to call the reload stuff from
2306    other places too.  This is only used when build for W32.  */
2307 void
2308 agent_sighup_action (void)
2309 {
2310   log_info ("SIGHUP received - "
2311             "re-reading configuration and flushing cache\n");
2312
2313   agent_flush_cache ();
2314   reread_configuration ();
2315   agent_reload_trustlist ();
2316   /* We flush the module name cache so that after installing a
2317      "pinentry" binary that one can be used in case the
2318      "pinentry-basic" fallback was in use.  */
2319   gnupg_module_name_flush_some ();
2320 }
2321
2322
2323 /* A helper function to handle SIGUSR2.  */
2324 static void
2325 agent_sigusr2_action (void)
2326 {
2327   if (opt.verbose)
2328     log_info ("SIGUSR2 received - updating card event counter\n");
2329   /* Nothing to check right now.  We only increment a counter.  */
2330   bump_card_eventcounter ();
2331 }
2332
2333
2334 #ifndef HAVE_W32_SYSTEM
2335 /* The signal handler for this program.  It is expected to be run in
2336    its own trhead and not in the context of a signal handler.  */
2337 static void
2338 handle_signal (int signo)
2339 {
2340   switch (signo)
2341     {
2342 #ifndef HAVE_W32_SYSTEM
2343     case SIGHUP:
2344       agent_sighup_action ();
2345       break;
2346
2347     case SIGUSR1:
2348       log_info ("SIGUSR1 received - printing internal information:\n");
2349       /* Fixme: We need to see how to integrate pth dumping into our
2350          logging system.  */
2351       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2352       agent_query_dump_state ();
2353       agent_scd_dump_state ();
2354       break;
2355
2356     case SIGUSR2:
2357       agent_sigusr2_action ();
2358       break;
2359
2360     case SIGTERM:
2361       if (!shutdown_pending)
2362         log_info ("SIGTERM received - shutting down ...\n");
2363       else
2364         log_info ("SIGTERM received - still %i open connections\n",
2365                   active_connections);
2366       shutdown_pending++;
2367       if (shutdown_pending > 2)
2368         {
2369           log_info ("shutdown forced\n");
2370           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2371           cleanup ();
2372           agent_exit (0);
2373         }
2374       break;
2375
2376     case SIGINT:
2377       log_info ("SIGINT received - immediate shutdown\n");
2378       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2379       cleanup ();
2380       agent_exit (0);
2381       break;
2382 #endif
2383     default:
2384       log_info ("signal %d received - no action defined\n", signo);
2385     }
2386 }
2387 #endif
2388
2389 /* Check the nonce on a new connection.  This is a NOP unless we we
2390    are using our Unix domain socket emulation under Windows.  */
2391 static int
2392 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2393 {
2394   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2395     {
2396       log_info (_("error reading nonce on fd %d: %s\n"),
2397                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2398       assuan_sock_close (ctrl->thread_startup.fd);
2399       xfree (ctrl);
2400       return -1;
2401     }
2402   else
2403     return 0;
2404 }
2405
2406
2407 #ifdef HAVE_W32_SYSTEM
2408 /* The window message processing function for Putty.  Warning: This
2409    code runs as a native Windows thread.  Use of our own functions
2410    needs to be bracket with pth_leave/pth_enter. */
2411 static LRESULT CALLBACK
2412 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2413 {
2414   int ret = 0;
2415   int w32rc;
2416   COPYDATASTRUCT *cds;
2417   const char *mapfile;
2418   HANDLE maphd;
2419   PSID mysid = NULL;
2420   PSID mapsid = NULL;
2421   void *data = NULL;
2422   PSECURITY_DESCRIPTOR psd = NULL;
2423   ctrl_t ctrl = NULL;
2424
2425   if (msg != WM_COPYDATA)
2426     {
2427       return DefWindowProc (hwnd, msg, wparam, lparam);
2428     }
2429
2430   cds = (COPYDATASTRUCT*)lparam;
2431   if (cds->dwData != PUTTY_IPC_MAGIC)
2432     return 0;  /* Ignore data with the wrong magic.  */
2433   mapfile = cds->lpData;
2434   if (!cds->cbData || mapfile[cds->cbData - 1])
2435     return 0;  /* Ignore empty and non-properly terminated strings.  */
2436
2437   if (DBG_IPC)
2438     {
2439       npth_protect ();
2440       log_debug ("ssh map file '%s'", mapfile);
2441       npth_unprotect ();
2442     }
2443
2444   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2445   if (DBG_IPC)
2446     {
2447       npth_protect ();
2448       log_debug ("ssh map handle %p\n", maphd);
2449       npth_unprotect ();
2450     }
2451
2452   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2453     return 0;
2454
2455   npth_protect ();
2456
2457   mysid = w32_get_user_sid ();
2458   if (!mysid)
2459     {
2460       log_error ("error getting my sid\n");
2461       goto leave;
2462     }
2463
2464   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2465                            OWNER_SECURITY_INFORMATION,
2466                            &mapsid, NULL, NULL, NULL,
2467                            &psd);
2468   if (w32rc)
2469     {
2470       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2471       goto leave;
2472     }
2473
2474   if (DBG_IPC)
2475     {
2476       char *sidstr;
2477
2478       if (!ConvertSidToStringSid (mysid, &sidstr))
2479         sidstr = NULL;
2480       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2481       LocalFree (sidstr);
2482       if (!ConvertSidToStringSid (mapsid, &sidstr))
2483         sidstr = NULL;
2484       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2485       LocalFree (sidstr);
2486     }
2487
2488   if (!EqualSid (mysid, mapsid))
2489     {
2490       log_error ("ssh map file has a non-matching sid\n");
2491       goto leave;
2492     }
2493
2494   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2495   if (DBG_IPC)
2496     log_debug ("ssh IPC buffer at %p\n", data);
2497   if (!data)
2498     goto leave;
2499
2500   /* log_printhex ("request:", data, 20); */
2501
2502   ctrl = xtrycalloc (1, sizeof *ctrl);
2503   if (!ctrl)
2504     {
2505       log_error ("error allocating connection control data: %s\n",
2506                  strerror (errno) );
2507       goto leave;
2508     }
2509   ctrl->session_env = session_env_new ();
2510   if (!ctrl->session_env)
2511     {
2512       log_error ("error allocating session environment block: %s\n",
2513                  strerror (errno) );
2514       goto leave;
2515     }
2516
2517   agent_init_default_ctrl (ctrl);
2518   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2519     ret = 1; /* Valid ssh message has been constructed.  */
2520   agent_deinit_default_ctrl (ctrl);
2521   /* log_printhex ("  reply:", data, 20); */
2522
2523  leave:
2524   xfree (ctrl);
2525   if (data)
2526     UnmapViewOfFile (data);
2527   xfree (mapsid);
2528   if (psd)
2529     LocalFree (psd);
2530   xfree (mysid);
2531   CloseHandle (maphd);
2532
2533   npth_unprotect ();
2534
2535   return ret;
2536 }
2537 #endif /*HAVE_W32_SYSTEM*/
2538
2539
2540 #ifdef HAVE_W32_SYSTEM
2541 /* The thread handling Putty's IPC requests.  */
2542 static void *
2543 putty_message_thread (void *arg)
2544 {
2545   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2546                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2547   HWND hwnd;
2548   MSG msg;
2549
2550   (void)arg;
2551
2552   if (opt.verbose)
2553     log_info ("putty message loop thread started\n");
2554
2555   /* The message loop runs as thread independent from our nPth system.
2556      This also means that we need to make sure that we switch back to
2557      our system before calling any no-windows function.  */
2558   npth_unprotect ();
2559
2560   /* First create a window to make sure that a message queue exists
2561      for this thread.  */
2562   if (!RegisterClass (&wndwclass))
2563     {
2564       npth_protect ();
2565       log_error ("error registering Pageant window class");
2566       return NULL;
2567     }
2568   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2569                          0, 0, 0, 0,
2570                          HWND_MESSAGE,  /* hWndParent */
2571                          NULL,          /* hWndMenu   */
2572                          NULL,          /* hInstance  */
2573                          NULL);         /* lpParm     */
2574   if (!hwnd)
2575     {
2576       npth_protect ();
2577       log_error ("error creating Pageant window");
2578       return NULL;
2579     }
2580
2581   while (GetMessage(&msg, NULL, 0, 0))
2582     {
2583       TranslateMessage(&msg);
2584       DispatchMessage(&msg);
2585     }
2586
2587   /* Back to nPth.  */
2588   npth_protect ();
2589
2590   if (opt.verbose)
2591     log_info ("putty message loop thread stopped\n");
2592   return NULL;
2593 }
2594 #endif /*HAVE_W32_SYSTEM*/
2595
2596
2597 static void *
2598 do_start_connection_thread (ctrl_t ctrl)
2599 {
2600   active_connections++;
2601   agent_init_default_ctrl (ctrl);
2602   if (opt.verbose && !DBG_IPC)
2603     log_info (_("handler 0x%lx for fd %d started\n"),
2604               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2605
2606   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2607   if (opt.verbose && !DBG_IPC)
2608     log_info (_("handler 0x%lx for fd %d terminated\n"),
2609               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2610
2611   agent_deinit_default_ctrl (ctrl);
2612   xfree (ctrl);
2613   active_connections--;
2614   return NULL;
2615 }
2616
2617
2618 /* This is the standard connection thread's main function.  */
2619 static void *
2620 start_connection_thread_std (void *arg)
2621 {
2622   ctrl_t ctrl = arg;
2623
2624   if (check_nonce (ctrl, &socket_nonce))
2625     {
2626       log_error ("handler 0x%lx nonce check FAILED\n",
2627                  (unsigned long) npth_self());
2628       return NULL;
2629     }
2630
2631   return do_start_connection_thread (ctrl);
2632 }
2633
2634
2635 /* This is the extra socket connection thread's main function.  */
2636 static void *
2637 start_connection_thread_extra (void *arg)
2638 {
2639   ctrl_t ctrl = arg;
2640
2641   if (check_nonce (ctrl, &socket_nonce_extra))
2642     {
2643       log_error ("handler 0x%lx nonce check FAILED\n",
2644                  (unsigned long) npth_self());
2645       return NULL;
2646     }
2647
2648   ctrl->restricted = 1;
2649   return do_start_connection_thread (ctrl);
2650 }
2651
2652
2653 /* This is the browser socket connection thread's main function.  */
2654 static void *
2655 start_connection_thread_browser (void *arg)
2656 {
2657   ctrl_t ctrl = arg;
2658
2659   if (check_nonce (ctrl, &socket_nonce_browser))
2660     {
2661       log_error ("handler 0x%lx nonce check FAILED\n",
2662                  (unsigned long) npth_self());
2663       return NULL;
2664     }
2665
2666   ctrl->restricted = 2;
2667   return do_start_connection_thread (ctrl);
2668 }
2669
2670
2671 /* This is the ssh connection thread's main function.  */
2672 static void *
2673 start_connection_thread_ssh (void *arg)
2674 {
2675   ctrl_t ctrl = arg;
2676
2677   if (check_nonce (ctrl, &socket_nonce_ssh))
2678     return NULL;
2679
2680   active_connections++;
2681   agent_init_default_ctrl (ctrl);
2682   if (opt.verbose)
2683     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2684               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2685
2686   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2687   if (opt.verbose)
2688     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2689               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2690
2691   agent_deinit_default_ctrl (ctrl);
2692   xfree (ctrl);
2693   active_connections--;
2694   return NULL;
2695 }
2696
2697
2698 /* Connection handler loop.  Wait for connection requests and spawn a
2699    thread after accepting a connection.  */
2700 static void
2701 handle_connections (gnupg_fd_t listen_fd,
2702                     gnupg_fd_t listen_fd_extra,
2703                     gnupg_fd_t listen_fd_browser,
2704                     gnupg_fd_t listen_fd_ssh)
2705 {
2706   gpg_error_t err;
2707   npth_attr_t tattr;
2708   struct sockaddr_un paddr;
2709   socklen_t plen;
2710   fd_set fdset, read_fdset;
2711   int ret;
2712   gnupg_fd_t fd;
2713   int nfd;
2714   int saved_errno;
2715   struct timespec abstime;
2716   struct timespec curtime;
2717   struct timespec timeout;
2718 #ifdef HAVE_W32_SYSTEM
2719   HANDLE events[2];
2720   unsigned int events_set;
2721 #endif
2722   int my_inotify_fd = -1;
2723   struct {
2724     const char *name;
2725     void *(*func) (void *arg);
2726     gnupg_fd_t l_fd;
2727   } listentbl[] = {
2728     { "std",     start_connection_thread_std   },
2729     { "extra",   start_connection_thread_extra },
2730     { "browser", start_connection_thread_browser },
2731     { "ssh",    start_connection_thread_ssh   }
2732   };
2733
2734
2735   ret = npth_attr_init(&tattr);
2736   if (ret)
2737     log_fatal ("error allocating thread attributes: %s\n",
2738                strerror (ret));
2739   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2740
2741 #ifndef HAVE_W32_SYSTEM
2742   npth_sigev_init ();
2743   npth_sigev_add (SIGHUP);
2744   npth_sigev_add (SIGUSR1);
2745   npth_sigev_add (SIGUSR2);
2746   npth_sigev_add (SIGINT);
2747   npth_sigev_add (SIGTERM);
2748   npth_sigev_fini ();
2749 #else
2750 # ifdef HAVE_W32CE_SYSTEM
2751   /* Use a dummy event. */
2752   sigs = 0;
2753   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2754 # else
2755   events[0] = get_agent_scd_notify_event ();
2756   events[1] = INVALID_HANDLE_VALUE;
2757 # endif
2758 #endif
2759
2760   if (disable_check_own_socket)
2761     my_inotify_fd = -1;
2762   else if ((err = gnupg_inotify_watch_socket (&my_inotify_fd, socket_name)))
2763     {
2764       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2765         log_info ("error enabling fast daemon termination: %s\n",
2766                   gpg_strerror (err));
2767     }
2768
2769   /* On Windows we need to fire up a separate thread to listen for
2770      requests from Putty (an SSH client), so we can replace Putty's
2771      Pageant (its ssh-agent implementation). */
2772 #ifdef HAVE_W32_SYSTEM
2773   if (putty_support)
2774     {
2775       npth_t thread;
2776
2777       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2778       if (ret)
2779         {
2780           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2781         }
2782     }
2783 #endif /*HAVE_W32_SYSTEM*/
2784
2785   /* Set a flag to tell call-scd.c that it may enable event
2786      notifications.  */
2787   opt.sigusr2_enabled = 1;
2788
2789   FD_ZERO (&fdset);
2790   FD_SET (FD2INT (listen_fd), &fdset);
2791   nfd = FD2INT (listen_fd);
2792   if (listen_fd_extra != GNUPG_INVALID_FD)
2793     {
2794       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2795       if (FD2INT (listen_fd_extra) > nfd)
2796         nfd = FD2INT (listen_fd_extra);
2797     }
2798   if (listen_fd_browser != GNUPG_INVALID_FD)
2799     {
2800       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2801       if (FD2INT (listen_fd_browser) > nfd)
2802         nfd = FD2INT (listen_fd_browser);
2803     }
2804   if (listen_fd_ssh != GNUPG_INVALID_FD)
2805     {
2806       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2807       if (FD2INT (listen_fd_ssh) > nfd)
2808         nfd = FD2INT (listen_fd_ssh);
2809     }
2810   if (my_inotify_fd != -1)
2811     {
2812       FD_SET (my_inotify_fd, &fdset);
2813       if (my_inotify_fd > nfd)
2814         nfd = my_inotify_fd;
2815     }
2816
2817   listentbl[0].l_fd = listen_fd;
2818   listentbl[1].l_fd = listen_fd_extra;
2819   listentbl[2].l_fd = listen_fd_browser;
2820   listentbl[3].l_fd = listen_fd_ssh;
2821
2822   npth_clock_gettime (&abstime);
2823   abstime.tv_sec += TIMERTICK_INTERVAL;
2824
2825   for (;;)
2826     {
2827       /* Shutdown test.  */
2828       if (shutdown_pending)
2829         {
2830           if (active_connections == 0)
2831             break; /* ready */
2832
2833           /* Do not accept new connections but keep on running the
2834            * loop to cope with the timer events.
2835            *
2836            * Note that we do not close the listening socket because a
2837            * client trying to connect to that socket would instead
2838            * restart a new dirmngr instance - which is unlikely the
2839            * intention of a shutdown. */
2840           FD_ZERO (&fdset);
2841           nfd = -1;
2842           if (my_inotify_fd != -1)
2843             {
2844               FD_SET (my_inotify_fd, &fdset);
2845               nfd = my_inotify_fd;
2846             }
2847         }
2848
2849       /* POSIX says that fd_set should be implemented as a structure,
2850          thus a simple assignment is fine to copy the entire set.  */
2851       read_fdset = fdset;
2852
2853       npth_clock_gettime (&curtime);
2854       if (!(npth_timercmp (&curtime, &abstime, <)))
2855         {
2856           /* Timeout.  */
2857           handle_tick ();
2858           npth_clock_gettime (&abstime);
2859           abstime.tv_sec += TIMERTICK_INTERVAL;
2860         }
2861       npth_timersub (&abstime, &curtime, &timeout);
2862
2863 #ifndef HAVE_W32_SYSTEM
2864       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2865                           npth_sigev_sigmask ());
2866       saved_errno = errno;
2867
2868       {
2869         int signo;
2870         while (npth_sigev_get_pending (&signo))
2871           handle_signal (signo);
2872       }
2873 #else
2874       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2875                           events, &events_set);
2876       saved_errno = errno;
2877
2878       /* This is valid even if npth_eselect returns an error.  */
2879       if (events_set & 1)
2880         agent_sigusr2_action ();
2881 #endif
2882
2883       if (ret == -1 && saved_errno != EINTR)
2884         {
2885           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2886                      strerror (saved_errno));
2887           npth_sleep (1);
2888           continue;
2889         }
2890       if (ret <= 0)
2891         /* Interrupt or timeout.  Will be handled when calculating the
2892            next timeout.  */
2893         continue;
2894
2895       if (!shutdown_pending)
2896         {
2897           int idx;
2898           ctrl_t ctrl;
2899           npth_t thread;
2900
2901           if (my_inotify_fd != -1
2902               && FD_ISSET (my_inotify_fd, &read_fdset)
2903               && gnupg_inotify_has_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
2904             {
2905               shutdown_pending = 1;
2906               log_info ("socket file has been removed - shutting down\n");
2907             }
2908
2909           for (idx=0; idx < DIM(listentbl); idx++)
2910             {
2911               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2912                 continue;
2913               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2914                 continue;
2915
2916               plen = sizeof paddr;
2917               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2918                                         (struct sockaddr *)&paddr, &plen));
2919               if (fd == GNUPG_INVALID_FD)
2920                 {
2921                   log_error ("accept failed for %s: %s\n",
2922                              listentbl[idx].name, strerror (errno));
2923                 }
2924               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2925                 {
2926                   log_error ("error allocating connection data for %s: %s\n",
2927                              listentbl[idx].name, strerror (errno) );
2928                   assuan_sock_close (fd);
2929                 }
2930               else if ( !(ctrl->session_env = session_env_new ()))
2931                 {
2932                   log_error ("error allocating session env block for %s: %s\n",
2933                              listentbl[idx].name, strerror (errno) );
2934                   xfree (ctrl);
2935                   assuan_sock_close (fd);
2936                 }
2937               else
2938                 {
2939                   ctrl->thread_startup.fd = fd;
2940                   ret = npth_create (&thread, &tattr,
2941                                      listentbl[idx].func, ctrl);
2942                   if (ret)
2943                     {
2944                       log_error ("error spawning connection handler for %s:"
2945                                  " %s\n", listentbl[idx].name, strerror (ret));
2946                       assuan_sock_close (fd);
2947                       xfree (ctrl);
2948                     }
2949                 }
2950               fd = GNUPG_INVALID_FD;
2951             }
2952         }
2953     }
2954
2955   if (my_inotify_fd != -1)
2956     close (my_inotify_fd);
2957   cleanup ();
2958   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2959   npth_attr_destroy (&tattr);
2960 }
2961
2962
2963
2964 /* Helper for check_own_socket.  */
2965 static gpg_error_t
2966 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2967 {
2968   membuf_t *mb = opaque;
2969   put_membuf (mb, buffer, length);
2970   return 0;
2971 }
2972
2973
2974 /* The thread running the actual check.  We need to run this in a
2975    separate thread so that check_own_thread can be called from the
2976    timer tick.  */
2977 static void *
2978 check_own_socket_thread (void *arg)
2979 {
2980   int rc;
2981   char *sockname = arg;
2982   assuan_context_t ctx = NULL;
2983   membuf_t mb;
2984   char *buffer;
2985
2986   check_own_socket_running++;
2987
2988   rc = assuan_new (&ctx);
2989   if (rc)
2990     {
2991       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2992       goto leave;
2993     }
2994   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
2995
2996   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2997   if (rc)
2998     {
2999       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3000       goto leave;
3001     }
3002
3003   init_membuf (&mb, 100);
3004   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3005                         NULL, NULL, NULL, NULL);
3006   put_membuf (&mb, "", 1);
3007   buffer = get_membuf (&mb, NULL);
3008   if (rc || !buffer)
3009     {
3010       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3011                  "GETINFO pid", gpg_strerror (rc));
3012       rc = 1;
3013     }
3014   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3015     {
3016       log_error ("socket is now serviced by another server\n");
3017       rc = 1;
3018     }
3019   else if (opt.verbose > 1)
3020     log_error ("socket is still served by this server\n");
3021
3022   xfree (buffer);
3023
3024  leave:
3025   xfree (sockname);
3026   if (ctx)
3027     assuan_release (ctx);
3028   if (rc)
3029     {
3030       /* We may not remove the socket as it is now in use by another
3031          server. */
3032       inhibit_socket_removal = 1;
3033       shutdown_pending = 2;
3034       log_info ("this process is useless - shutting down\n");
3035     }
3036   check_own_socket_running--;
3037   return NULL;
3038 }
3039
3040
3041 /* Check whether we are still listening on our own socket.  In case
3042    another gpg-agent process started after us has taken ownership of
3043    our socket, we would linger around without any real task.  Thus we
3044    better check once in a while whether we are really needed.  */
3045 static void
3046 check_own_socket (void)
3047 {
3048   char *sockname;
3049   npth_t thread;
3050   npth_attr_t tattr;
3051   int err;
3052
3053   if (disable_check_own_socket)
3054     return;
3055
3056   if (check_own_socket_running || shutdown_pending)
3057     return;  /* Still running or already shutting down.  */
3058
3059   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3060   if (!sockname)
3061     return; /* Out of memory.  */
3062
3063   err = npth_attr_init (&tattr);
3064   if (err)
3065     return;
3066   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3067   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3068   if (err)
3069     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3070   npth_attr_destroy (&tattr);
3071 }
3072
3073
3074
3075 /* Figure out whether an agent is available and running. Prints an
3076    error if not.  If SILENT is true, no messages are printed.
3077    Returns 0 if the agent is running. */
3078 static int
3079 check_for_running_agent (int silent)
3080 {
3081   gpg_error_t err;
3082   char *sockname;
3083   assuan_context_t ctx = NULL;
3084
3085   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3086   if (!sockname)
3087     return gpg_error_from_syserror ();
3088
3089   err = assuan_new (&ctx);
3090   if (!err)
3091     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3092   xfree (sockname);
3093   if (err)
3094     {
3095       if (!silent)
3096         log_error (_("no gpg-agent running in this session\n"));
3097
3098       if (ctx)
3099         assuan_release (ctx);
3100       return -1;
3101     }
3102
3103   if (!opt.quiet && !silent)
3104     log_info ("gpg-agent running and available\n");
3105
3106   assuan_release (ctx);
3107   return 0;
3108 }