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