agent, dirmngr, scd: Fix init_common_subsystems.
[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               if (!strcmp (fdnames[i], tbl[j].label) || j == DIM(tbl)-1)
743                 {
744                   fd = 3 + i;
745                   if (**tbl[j].fdaddr == -1)
746                     {
747                       name = get_socket_name (fd);
748                       if (name)
749                         {
750                           **tbl[j].fdaddr = fd;
751                           *tbl[j].nameaddr = name;
752                           log_info ("using fd %d for %s socket (%s)\n",
753                                     fd, tbl[j].label, name);
754                         }
755                       else
756                         {
757                           log_error ("cannot listen on fd %d for %s socket\n",
758                                      fd, tbl[j].label);
759                           close (fd);
760                         }
761                     }
762                   else
763                     {
764                       log_error ("cannot listen on more than one %s socket\n",
765                                  tbl[j].label);
766                       close (fd);
767                     }
768                   break;
769                 }
770             }
771         }
772     }
773
774   xfree (fdnames);
775 }
776 #endif /*!HAVE_W32_SYSTEM*/
777
778
779 /* Cleanup code for this program.  This is either called has an atexit
780    handler or directly.  */
781 static void
782 cleanup (void)
783 {
784   static int done;
785
786   if (done)
787     return;
788   done = 1;
789   deinitialize_module_cache ();
790   if (!is_supervised && !inhibit_socket_removal)
791     {
792       remove_socket (socket_name, redir_socket_name);
793       if (opt.extra_socket > 1)
794         remove_socket (socket_name_extra, redir_socket_name_extra);
795       if (opt.browser_socket > 1)
796         remove_socket (socket_name_browser, redir_socket_name_browser);
797       remove_socket (socket_name_ssh, redir_socket_name_ssh);
798     }
799 }
800
801
802
803 /* Handle options which are allowed to be reset after program start.
804    Return true when the current option in PARGS could be handled and
805    false if not.  As a special feature, passing a value of NULL for
806    PARGS, resets the options to the default.  REREAD should be set
807    true if it is not the initial option parsing. */
808 static int
809 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
810 {
811   if (!pargs)
812     { /* reset mode */
813       opt.quiet = 0;
814       opt.verbose = 0;
815       opt.debug = 0;
816       opt.no_grab = 0;
817       opt.debug_pinentry = 0;
818       opt.pinentry_program = NULL;
819       opt.pinentry_touch_file = NULL;
820       xfree (opt.pinentry_invisible_char);
821       opt.pinentry_invisible_char = NULL;
822       opt.pinentry_timeout = 0;
823       opt.scdaemon_program = NULL;
824       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
825       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
826       opt.max_cache_ttl = MAX_CACHE_TTL;
827       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
828       opt.enforce_passphrase_constraints = 0;
829       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
830       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
831       opt.check_passphrase_pattern = NULL;
832       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
833       opt.enable_passhrase_history = 0;
834       opt.ignore_cache_for_signing = 0;
835       opt.allow_mark_trusted = 1;
836       opt.allow_external_cache = 1;
837       opt.allow_loopback_pinentry = 1;
838       opt.allow_emacs_pinentry = 0;
839       opt.disable_scdaemon = 0;
840       disable_check_own_socket = 0;
841       return 1;
842     }
843
844   switch (pargs->r_opt)
845     {
846     case oQuiet: opt.quiet = 1; break;
847     case oVerbose: opt.verbose++; break;
848
849     case oDebug:
850       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
851       break;
852     case oDebugAll: opt.debug = ~0; break;
853     case oDebugLevel: debug_level = pargs->r.ret_str; break;
854     case oDebugPinentry: opt.debug_pinentry = 1; break;
855
856     case oLogFile:
857       if (!reread)
858         return 0; /* not handeld */
859       if (!current_logfile || !pargs->r.ret_str
860           || strcmp (current_logfile, pargs->r.ret_str))
861         {
862           log_set_file (pargs->r.ret_str);
863           xfree (current_logfile);
864           current_logfile = xtrystrdup (pargs->r.ret_str);
865         }
866       break;
867
868     case oNoGrab: opt.no_grab = 1; break;
869
870     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
871     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
872     case oPinentryInvisibleChar:
873       xfree (opt.pinentry_invisible_char);
874       opt.pinentry_invisible_char = xtrystrdup (pargs->r.ret_str); break;
875       break;
876     case oPinentryTimeout: opt.pinentry_timeout = pargs->r.ret_ulong; break;
877     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
878     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
879     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
880
881     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
882     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
883     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
884     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
885
886     case oEnforcePassphraseConstraints:
887       opt.enforce_passphrase_constraints=1;
888       break;
889     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
890     case oMinPassphraseNonalpha:
891       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
892       break;
893     case oCheckPassphrasePattern:
894       opt.check_passphrase_pattern = pargs->r.ret_str;
895       break;
896     case oMaxPassphraseDays:
897       opt.max_passphrase_days = pargs->r.ret_ulong;
898       break;
899     case oEnablePassphraseHistory:
900       opt.enable_passhrase_history = 1;
901       break;
902
903     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
904
905     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
906     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
907
908     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
909
910     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
911     case oNoAllowLoopbackPinentry: opt.allow_loopback_pinentry = 0; break;
912
913     case oNoAllowExternalCache: opt.allow_external_cache = 0;
914       break;
915
916     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
917       break;
918
919     default:
920       return 0; /* not handled */
921     }
922
923   return 1; /* handled */
924 }
925
926
927 /* Fixup some options after all have been processed.  */
928 static void
929 finalize_rereadable_options (void)
930 {
931 }
932
933
934 static void
935 thread_init_once (void)
936 {
937   static int npth_initialized = 0;
938
939   if (!npth_initialized)
940     {
941       npth_initialized++;
942       npth_init ();
943     }
944   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
945 }
946
947
948 static void
949 initialize_modules (void)
950 {
951   thread_init_once ();
952   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
953   initialize_module_cache ();
954   initialize_module_call_pinentry ();
955   initialize_module_call_scd ();
956   initialize_module_trustlist ();
957 }
958
959
960 /* The main entry point.  */
961 int
962 main (int argc, char **argv )
963 {
964   ARGPARSE_ARGS pargs;
965   int orig_argc;
966   char **orig_argv;
967   FILE *configfp = NULL;
968   char *configname = NULL;
969   const char *shell;
970   unsigned configlineno;
971   int parse_debug = 0;
972   int default_config =1;
973   int pipe_server = 0;
974   int is_daemon = 0;
975   int nodetach = 0;
976   int csh_style = 0;
977   char *logfile = NULL;
978   int debug_wait = 0;
979   int gpgconf_list = 0;
980   gpg_error_t err;
981   struct assuan_malloc_hooks malloc_hooks;
982
983   early_system_init ();
984
985   /* Before we do anything else we save the list of currently open
986      file descriptors and the signal mask.  This info is required to
987      do the exec call properly. */
988   startup_fd_list = get_all_open_fds ();
989 #ifdef HAVE_SIGPROCMASK
990   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
991     startup_signal_mask_valid = 1;
992 #endif /*HAVE_SIGPROCMASK*/
993
994   /* Set program name etc.  */
995   set_strusage (my_strusage);
996   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
997   /* Please note that we may running SUID(ROOT), so be very CAREFUL
998      when adding any stuff between here and the call to INIT_SECMEM()
999      somewhere after the option parsing */
1000   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
1001
1002   /* Make sure that our subsystems are ready.  */
1003   i18n_init ();
1004   init_common_subsystems (&argc, &argv);
1005
1006   malloc_hooks.malloc = gcry_malloc;
1007   malloc_hooks.realloc = gcry_realloc;
1008   malloc_hooks.free = gcry_free;
1009   assuan_set_malloc_hooks (&malloc_hooks);
1010   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
1011   assuan_sock_init ();
1012   setup_libassuan_logging (&opt.debug, NULL);
1013
1014   setup_libgcrypt_logging ();
1015   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1016   gcry_set_progress_handler (agent_libgcrypt_progress_cb, NULL);
1017
1018   disable_core_dumps ();
1019
1020   /* Set default options.  */
1021   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
1022
1023   shell = getenv ("SHELL");
1024   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
1025     csh_style = 1;
1026
1027   /* Record some of the original environment strings. */
1028   {
1029     const char *s;
1030     int idx;
1031     static const char *names[] =
1032       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
1033
1034     err = 0;
1035     opt.startup_env = session_env_new ();
1036     if (!opt.startup_env)
1037       err = gpg_error_from_syserror ();
1038     for (idx=0; !err && names[idx]; idx++)
1039       {
1040         s = getenv (names[idx]);
1041         if (s)
1042           err = session_env_setenv (opt.startup_env, names[idx], s);
1043       }
1044     if (!err)
1045       {
1046         s = gnupg_ttyname (0);
1047         if (s)
1048           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
1049       }
1050     if (err)
1051       log_fatal ("error recording startup environment: %s\n",
1052                  gpg_strerror (err));
1053
1054     /* Fixme: Better use the locale function here.  */
1055     opt.startup_lc_ctype = getenv ("LC_CTYPE");
1056     if (opt.startup_lc_ctype)
1057       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
1058     opt.startup_lc_messages = getenv ("LC_MESSAGES");
1059     if (opt.startup_lc_messages)
1060       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
1061   }
1062
1063   /* Check whether we have a config file on the commandline */
1064   orig_argc = argc;
1065   orig_argv = argv;
1066   pargs.argc = &argc;
1067   pargs.argv = &argv;
1068   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1069   while (arg_parse( &pargs, opts))
1070     {
1071       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
1072         parse_debug++;
1073       else if (pargs.r_opt == oOptions)
1074         { /* yes there is one, so we do not try the default one, but
1075              read the option file when it is encountered at the
1076              commandline */
1077           default_config = 0;
1078         }
1079         else if (pargs.r_opt == oNoOptions)
1080           default_config = 0; /* --no-options */
1081         else if (pargs.r_opt == oHomedir)
1082           gnupg_set_homedir (pargs.r.ret_str);
1083         else if (pargs.r_opt == oDebugQuickRandom)
1084           {
1085             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1086           }
1087
1088     }
1089
1090   /* Initialize the secure memory. */
1091   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1092   maybe_setuid = 0;
1093
1094   /*
1095      Now we are now working under our real uid
1096   */
1097
1098   if (default_config)
1099     configname = make_filename (gnupg_homedir (),
1100                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1101
1102   argc = orig_argc;
1103   argv = orig_argv;
1104   pargs.argc = &argc;
1105   pargs.argv = &argv;
1106   pargs.flags=  1;  /* do not remove the args */
1107  next_pass:
1108   if (configname)
1109     {
1110       configlineno = 0;
1111       configfp = fopen (configname, "r");
1112       if (!configfp)
1113         {
1114           if (default_config)
1115             {
1116               if( parse_debug )
1117                 log_info (_("Note: no default option file '%s'\n"),
1118                           configname );
1119               /* Save the default conf file name so that
1120                  reread_configuration is able to test whether the
1121                  config file has been created in the meantime.  */
1122               xfree (config_filename);
1123               config_filename = configname;
1124               configname = NULL;
1125             }
1126           else
1127             {
1128               log_error (_("option file '%s': %s\n"),
1129                          configname, strerror(errno) );
1130               exit(2);
1131             }
1132           xfree (configname);
1133           configname = NULL;
1134         }
1135       if (parse_debug && configname )
1136         log_info (_("reading options from '%s'\n"), configname );
1137       default_config = 0;
1138     }
1139
1140   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
1141     {
1142       if (parse_rereadable_options (&pargs, 0))
1143         continue; /* Already handled */
1144       switch (pargs.r_opt)
1145         {
1146         case aGPGConfList: gpgconf_list = 1; break;
1147         case aGPGConfTest: gpgconf_list = 2; break;
1148         case aUseStandardSocketP: gpgconf_list = 3; break;
1149         case oBatch: opt.batch=1; break;
1150
1151         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1152
1153         case oOptions:
1154           /* config files may not be nested (silently ignore them) */
1155           if (!configfp)
1156             {
1157                 xfree(configname);
1158                 configname = xstrdup(pargs.r.ret_str);
1159                 goto next_pass;
1160             }
1161           break;
1162         case oNoGreeting: /* Dummy option.  */ break;
1163         case oNoVerbose: opt.verbose = 0; break;
1164         case oNoOptions: break; /* no-options */
1165         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1166         case oNoDetach: nodetach = 1; break;
1167         case oLogFile: logfile = pargs.r.ret_str; break;
1168         case oCsh: csh_style = 1; break;
1169         case oSh: csh_style = 0; break;
1170         case oServer: pipe_server = 1; break;
1171         case oDaemon: is_daemon = 1; break;
1172         case oSupervised: is_supervised = 1; break;
1173
1174         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
1175         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
1176         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
1177         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
1178         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
1179           break;
1180         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
1181           break;
1182
1183         case oUseStandardSocket:
1184         case oNoUseStandardSocket:
1185           obsolete_option (configname, configlineno, "use-standard-socket");
1186           break;
1187
1188         case oFakedSystemTime:
1189           {
1190             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1191             if (faked_time == (time_t)(-1))
1192               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1193             gnupg_set_time (faked_time, 0);
1194           }
1195           break;
1196
1197         case oKeepTTY: opt.keep_tty = 1; break;
1198         case oKeepDISPLAY: opt.keep_display = 1; break;
1199
1200         case oSSHSupport:
1201           ssh_support = 1;
1202           break;
1203         case oPuttySupport:
1204 #        ifdef HAVE_W32_SYSTEM
1205           putty_support = 1;
1206 #        endif
1207           break;
1208
1209         case oExtraSocket:
1210           opt.extra_socket = 1;  /* (1 = points into argv)  */
1211           socket_name_extra = pargs.r.ret_str;
1212           break;
1213
1214         case oBrowserSocket:
1215           opt.browser_socket = 1;  /* (1 = points into argv)  */
1216           socket_name_browser = pargs.r.ret_str;
1217           break;
1218
1219         case oDebugQuickRandom:
1220           /* Only used by the first stage command line parser.  */
1221           break;
1222
1223         case oWriteEnvFile:
1224           obsolete_option (configname, configlineno, "write-env-file");
1225           break;
1226
1227         default : pargs.err = configfp? 1:2; break;
1228         }
1229     }
1230   if (configfp)
1231     {
1232       fclose( configfp );
1233       configfp = NULL;
1234       /* Keep a copy of the name so that it can be read on SIGHUP. */
1235       if (config_filename != configname)
1236         {
1237           xfree (config_filename);
1238           config_filename = configname;
1239         }
1240       configname = NULL;
1241       goto next_pass;
1242     }
1243
1244   xfree (configname);
1245   configname = NULL;
1246   if (log_get_errorcount(0))
1247     exit(2);
1248
1249   finalize_rereadable_options ();
1250
1251   /* Print a warning if an argument looks like an option.  */
1252   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1253     {
1254       int i;
1255
1256       for (i=0; i < argc; i++)
1257         if (argv[i][0] == '-' && argv[i][1] == '-')
1258           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1259     }
1260
1261 #ifdef ENABLE_NLS
1262   /* gpg-agent usually does not output any messages because it runs in
1263      the background.  For log files it is acceptable to have messages
1264      always encoded in utf-8.  We switch here to utf-8, so that
1265      commands like --help still give native messages.  It is far
1266      easier to switch only once instead of for every message and it
1267      actually helps when more then one thread is active (avoids an
1268      extra copy step). */
1269     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1270 #endif
1271
1272   if (!pipe_server && !is_daemon && !gpgconf_list && !is_supervised)
1273     {
1274      /* We have been called without any command and thus we merely
1275         check whether an agent is already running.  We do this right
1276         here so that we don't clobber a logfile with this check but
1277         print the status directly to stderr. */
1278       opt.debug = 0;
1279       set_debug ();
1280       check_for_running_agent (0);
1281       agent_exit (0);
1282     }
1283
1284   if (is_supervised)
1285     ;
1286   else if (!opt.extra_socket)
1287     opt.extra_socket = 1;
1288   else if (socket_name_extra
1289            && (!strcmp (socket_name_extra, "none")
1290                || !strcmp (socket_name_extra, "/dev/null")))
1291     {
1292       /* User requested not to create this socket.  */
1293       opt.extra_socket = 0;
1294       socket_name_extra = NULL;
1295     }
1296
1297   if (is_supervised)
1298     ;
1299   else if (!opt.browser_socket)
1300     opt.browser_socket = 1;
1301   else if (socket_name_browser
1302            && (!strcmp (socket_name_browser, "none")
1303                || !strcmp (socket_name_browser, "/dev/null")))
1304     {
1305       /* User requested not to create this socket.  */
1306       opt.browser_socket = 0;
1307       socket_name_browser = NULL;
1308     }
1309
1310   set_debug ();
1311
1312   if (atexit (cleanup))
1313     {
1314       log_error ("atexit failed\n");
1315       cleanup ();
1316       exit (1);
1317     }
1318
1319   /* Try to create missing directories. */
1320   create_directories ();
1321
1322   if (debug_wait && pipe_server)
1323     {
1324       thread_init_once ();
1325       log_debug ("waiting for debugger - my pid is %u .....\n",
1326                  (unsigned int)getpid());
1327       gnupg_sleep (debug_wait);
1328       log_debug ("... okay\n");
1329     }
1330
1331   if (gpgconf_list == 3)
1332     {
1333       /* We now use the standard socket always - return true for
1334          backward compatibility.  */
1335       agent_exit (0);
1336     }
1337   else if (gpgconf_list == 2)
1338     agent_exit (0);
1339   else if (gpgconf_list)
1340     {
1341       char *filename;
1342       char *filename_esc;
1343
1344       /* List options and default values in the GPG Conf format.  */
1345       filename = make_filename (gnupg_homedir (),
1346                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1347       filename_esc = percent_escape (filename, NULL);
1348
1349       es_printf ("%s-%s.conf:%lu:\"%s\n",
1350                  GPGCONF_NAME, GPG_AGENT_NAME,
1351                  GC_OPT_FLAG_DEFAULT, filename_esc);
1352       xfree (filename);
1353       xfree (filename_esc);
1354
1355       es_printf ("verbose:%lu:\n"
1356               "quiet:%lu:\n"
1357               "debug-level:%lu:\"none:\n"
1358               "log-file:%lu:\n",
1359               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1360               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1361               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1362               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1363       es_printf ("default-cache-ttl:%lu:%d:\n",
1364               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1365       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1366               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1367       es_printf ("max-cache-ttl:%lu:%d:\n",
1368               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1369       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1370               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1371       es_printf ("enforce-passphrase-constraints:%lu:\n",
1372               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1373       es_printf ("min-passphrase-len:%lu:%d:\n",
1374               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1375       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1376               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1377               MIN_PASSPHRASE_NONALPHA);
1378       es_printf ("check-passphrase-pattern:%lu:\n",
1379               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1380       es_printf ("max-passphrase-days:%lu:%d:\n",
1381               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1382               MAX_PASSPHRASE_DAYS);
1383       es_printf ("enable-passphrase-history:%lu:\n",
1384               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1385       es_printf ("no-grab:%lu:\n",
1386               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1387       es_printf ("ignore-cache-for-signing:%lu:\n",
1388               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1389       es_printf ("no-allow-external-cache:%lu:\n",
1390               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1391       es_printf ("no-allow-mark-trusted:%lu:\n",
1392               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1393       es_printf ("disable-scdaemon:%lu:\n",
1394               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1395       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1396 #ifdef HAVE_W32_SYSTEM
1397       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1398 #endif
1399       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1400               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1401       es_printf ("allow-emacs-pinentry:%lu:\n",
1402                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1403       es_printf ("pinentry-timeout:%lu:0:\n",
1404                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1405
1406       agent_exit (0);
1407     }
1408
1409   /* Now start with logging to a file if this is desired. */
1410   if (logfile)
1411     {
1412       log_set_file (logfile);
1413       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1414                              | GPGRT_LOG_WITH_TIME
1415                              | GPGRT_LOG_WITH_PID));
1416       current_logfile = xstrdup (logfile);
1417     }
1418
1419   /* Make sure that we have a default ttyname. */
1420   if (!default_ttyname && gnupg_ttyname (1))
1421     default_ttyname = xstrdup (gnupg_ttyname (1));
1422   if (!default_ttytype && getenv ("TERM"))
1423     default_ttytype = xstrdup (getenv ("TERM"));
1424
1425
1426   if (pipe_server)
1427     {
1428       /* This is the simple pipe based server */
1429       ctrl_t ctrl;
1430
1431       initialize_modules ();
1432
1433       ctrl = xtrycalloc (1, sizeof *ctrl);
1434       if (!ctrl)
1435         {
1436           log_error ("error allocating connection control data: %s\n",
1437                      strerror (errno) );
1438           agent_exit (1);
1439         }
1440       ctrl->session_env = session_env_new ();
1441       if (!ctrl->session_env)
1442         {
1443           log_error ("error allocating session environment block: %s\n",
1444                      strerror (errno) );
1445           xfree (ctrl);
1446           agent_exit (1);
1447         }
1448       agent_init_default_ctrl (ctrl);
1449       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1450       agent_deinit_default_ctrl (ctrl);
1451       xfree (ctrl);
1452     }
1453   else if (is_supervised)
1454     {
1455 #ifndef HAVE_W32_SYSTEM
1456       gnupg_fd_t fd, fd_extra, fd_browser, fd_ssh;
1457
1458       initialize_modules ();
1459
1460       /* when supervised and sending logs to stderr, the process
1461          supervisor should handle log entry metadata (pid, name,
1462          timestamp) */
1463       if (!logfile)
1464         log_set_prefix (NULL, 0);
1465
1466       log_info ("%s %s starting in supervised mode.\n",
1467                 strusage(11), strusage(13) );
1468
1469       /* See below in "regular server mode" on why we remove certain
1470        * envvars.  */
1471       if (!opt.keep_display)
1472         gnupg_unsetenv ("DISPLAY");
1473       gnupg_unsetenv ("INSIDE_EMACS");
1474
1475       /* Virtually create the sockets.  Note that we use -1 here
1476        * because the whole thing works only on Unix. */
1477       map_supervised_sockets (&fd, &fd_extra, &fd_browser, &fd_ssh);
1478       if (fd == -1)
1479         log_fatal ("no standard socket provided\n");
1480
1481 #ifdef HAVE_SIGPROCMASK
1482       if (startup_signal_mask_valid)
1483         {
1484           if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1485             log_error ("error restoring signal mask: %s\n",
1486                        strerror (errno));
1487         }
1488       else
1489         log_info ("no saved signal mask\n");
1490 #endif /*HAVE_SIGPROCMASK*/
1491
1492       log_info ("listening on: std=%d extra=%d browser=%d ssh=%d\n",
1493                 fd, fd_extra, fd_browser, fd_ssh);
1494       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1495 #endif /*!HAVE_W32_SYSTEM*/
1496     }
1497   else if (!is_daemon)
1498     ; /* NOTREACHED */
1499   else
1500     { /* Regular server mode */
1501       gnupg_fd_t fd;
1502       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1503       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1504       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1505 #ifndef HAVE_W32_SYSTEM
1506       pid_t pid;
1507 #endif
1508
1509       initialize_modules ();
1510
1511       /* Remove the DISPLAY variable so that a pinentry does not
1512          default to a specific display.  There is still a default
1513          display when gpg-agent was started using --display or a
1514          client requested this using an OPTION command.  Note, that we
1515          don't do this when running in reverse daemon mode (i.e. when
1516          exec the program given as arguments). */
1517 #ifndef HAVE_W32_SYSTEM
1518       if (!opt.keep_display && !argc)
1519         gnupg_unsetenv ("DISPLAY");
1520 #endif
1521
1522       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1523          always try to interact with Emacs.  The variable is set when
1524          a client requested this using an OPTION command.  */
1525       gnupg_unsetenv ("INSIDE_EMACS");
1526
1527       /* Create the sockets.  */
1528       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1529       fd = create_server_socket (socket_name, 1, 0,
1530                                  &redir_socket_name, &socket_nonce);
1531
1532       if (opt.extra_socket)
1533         {
1534           if (socket_name_extra)
1535             socket_name_extra = create_socket_name (socket_name_extra, 0);
1536           else
1537             socket_name_extra = create_socket_name
1538               /**/                (GPG_AGENT_EXTRA_SOCK_NAME, 1);
1539           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1540           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1541                                            &redir_socket_name_extra,
1542                                            &socket_nonce_extra);
1543         }
1544
1545       if (opt.browser_socket)
1546         {
1547           if (socket_name_browser)
1548             socket_name_browser = create_socket_name (socket_name_browser, 0);
1549           else
1550             socket_name_browser= create_socket_name
1551               /**/                 (GPG_AGENT_BROWSER_SOCK_NAME, 1);
1552           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1553           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1554                                              &redir_socket_name_browser,
1555                                              &socket_nonce_browser);
1556         }
1557
1558       socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1559       fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1560                                      &redir_socket_name_ssh,
1561                                      &socket_nonce_ssh);
1562
1563       /* If we are going to exec a program in the parent, we record
1564          the PID, so that the child may check whether the program is
1565          still alive. */
1566       if (argc)
1567         parent_pid = getpid ();
1568
1569       fflush (NULL);
1570 #ifdef HAVE_W32_SYSTEM
1571       (void)csh_style;
1572       (void)nodetach;
1573 #else /*!HAVE_W32_SYSTEM*/
1574       pid = fork ();
1575       if (pid == (pid_t)-1)
1576         {
1577           log_fatal ("fork failed: %s\n", strerror (errno) );
1578           exit (1);
1579         }
1580       else if (pid)
1581         { /* We are the parent */
1582           char *infostr_ssh_sock, *infostr_ssh_valid;
1583
1584           /* Close the socket FD. */
1585           close (fd);
1586
1587           /* The signal mask might not be correct right now and thus
1588              we restore it.  That is not strictly necessary but some
1589              programs falsely assume a cleared signal mask.  */
1590
1591 #ifdef HAVE_SIGPROCMASK
1592           if (startup_signal_mask_valid)
1593             {
1594               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1595                 log_error ("error restoring signal mask: %s\n",
1596                            strerror (errno));
1597             }
1598           else
1599             log_info ("no saved signal mask\n");
1600 #endif /*HAVE_SIGPROCMASK*/
1601
1602           /* Create the SSH info string if enabled. */
1603           if (ssh_support)
1604             {
1605               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1606                             socket_name_ssh) < 0)
1607                 {
1608                   log_error ("out of core\n");
1609                   kill (pid, SIGTERM);
1610                   exit (1);
1611                 }
1612               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1613                             (unsigned long)getpid()) < 0)
1614                 {
1615                   log_error ("out of core\n");
1616                   kill (pid, SIGTERM);
1617                   exit (1);
1618                 }
1619             }
1620
1621           *socket_name = 0; /* Don't let cleanup() remove the socket -
1622                                the child should do this from now on */
1623           if (opt.extra_socket)
1624             *socket_name_extra = 0;
1625           if (opt.browser_socket)
1626             *socket_name_browser = 0;
1627           *socket_name_ssh = 0;
1628
1629           if (argc)
1630             { /* Run the program given on the commandline.  */
1631               if (ssh_support && (putenv (infostr_ssh_sock)
1632                                   || putenv (infostr_ssh_valid)))
1633                 {
1634                   log_error ("failed to set environment: %s\n",
1635                              strerror (errno) );
1636                   kill (pid, SIGTERM );
1637                   exit (1);
1638                 }
1639
1640               /* Close all the file descriptors except the standard
1641                  ones and those open at startup.  We explicitly don't
1642                  close 0,1,2 in case something went wrong collecting
1643                  them at startup.  */
1644               close_all_fds (3, startup_fd_list);
1645
1646               /* Run the command.  */
1647               execvp (argv[0], argv);
1648               log_error ("failed to run the command: %s\n", strerror (errno));
1649               kill (pid, SIGTERM);
1650               exit (1);
1651             }
1652           else
1653             {
1654               /* Print the environment string, so that the caller can use
1655                  shell's eval to set it */
1656               if (csh_style)
1657                 {
1658                   if (ssh_support)
1659                     {
1660                       *strchr (infostr_ssh_sock, '=') = ' ';
1661                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1662                     }
1663                 }
1664               else
1665                 {
1666                   if (ssh_support)
1667                     {
1668                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1669                                  infostr_ssh_sock);
1670                     }
1671                 }
1672               if (ssh_support)
1673                 {
1674                   xfree (infostr_ssh_sock);
1675                   xfree (infostr_ssh_valid);
1676                 }
1677               exit (0);
1678             }
1679           /*NOTREACHED*/
1680         } /* End parent */
1681
1682       /*
1683          This is the child
1684        */
1685
1686       initialize_modules ();
1687
1688       /* Detach from tty and put process into a new session */
1689       if (!nodetach )
1690         {
1691           int i;
1692           unsigned int oldflags;
1693
1694           /* Close stdin, stdout and stderr unless it is the log stream */
1695           for (i=0; i <= 2; i++)
1696             {
1697               if (!log_test_fd (i) && i != fd )
1698                 {
1699                   if ( ! close (i)
1700                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1701                     {
1702                       log_error ("failed to open '%s': %s\n",
1703                                  "/dev/null", strerror (errno));
1704                       cleanup ();
1705                       exit (1);
1706                     }
1707                 }
1708             }
1709           if (setsid() == -1)
1710             {
1711               log_error ("setsid() failed: %s\n", strerror(errno) );
1712               cleanup ();
1713               exit (1);
1714             }
1715
1716           log_get_prefix (&oldflags);
1717           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1718           opt.running_detached = 1;
1719         }
1720
1721       if (chdir("/"))
1722         {
1723           log_error ("chdir to / failed: %s\n", strerror (errno));
1724           exit (1);
1725         }
1726
1727       {
1728         struct sigaction sa;
1729
1730         sa.sa_handler = SIG_IGN;
1731         sigemptyset (&sa.sa_mask);
1732         sa.sa_flags = 0;
1733         sigaction (SIGPIPE, &sa, NULL);
1734       }
1735 #endif /*!HAVE_W32_SYSTEM*/
1736
1737       log_info ("%s %s started\n", strusage(11), strusage(13) );
1738       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1739       assuan_sock_close (fd);
1740     }
1741
1742   return 0;
1743 }
1744
1745
1746 /* Exit entry point.  This function should be called instead of a
1747    plain exit.  */
1748 void
1749 agent_exit (int rc)
1750 {
1751   /*FIXME: update_random_seed_file();*/
1752
1753   /* We run our cleanup handler because that may close cipher contexts
1754      stored in secure memory and thus this needs to be done before we
1755      explicitly terminate secure memory.  */
1756   cleanup ();
1757
1758 #if 1
1759   /* at this time a bit annoying */
1760   if (opt.debug & DBG_MEMSTAT_VALUE)
1761     {
1762       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1763       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1764     }
1765   if (opt.debug)
1766     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1767 #endif
1768   gcry_control (GCRYCTL_TERM_SECMEM );
1769   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1770   exit (rc);
1771 }
1772
1773
1774 /* This is our callback function for gcrypt progress messages.  It is
1775    set once at startup and dispatches progress messages to the
1776    corresponding threads of the agent.  */
1777 static void
1778 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1779                              int current, int total)
1780 {
1781   struct progress_dispatch_s *dispatch;
1782   npth_t mytid = npth_self ();
1783
1784   (void)data;
1785
1786   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1787     if (dispatch->ctrl && dispatch->tid == mytid)
1788       break;
1789   if (dispatch && dispatch->cb)
1790     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1791 }
1792
1793
1794 /* If a progress dispatcher callback has been associated with the
1795  * current connection unregister it.  */
1796 static void
1797 unregister_progress_cb (void)
1798 {
1799   struct progress_dispatch_s *dispatch;
1800   npth_t mytid = npth_self ();
1801
1802   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1803     if (dispatch->ctrl && dispatch->tid == mytid)
1804       break;
1805   if (dispatch)
1806     {
1807       dispatch->ctrl = NULL;
1808       dispatch->cb = NULL;
1809     }
1810 }
1811
1812
1813 /* Setup a progress callback CB for the current connection.  Using a
1814  * CB of NULL disables the callback.  */
1815 void
1816 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1817                                   int printchar, int current, int total),
1818                        ctrl_t ctrl)
1819 {
1820   struct progress_dispatch_s *dispatch, *firstfree;
1821   npth_t mytid = npth_self ();
1822
1823   firstfree = NULL;
1824   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1825     {
1826       if (dispatch->ctrl && dispatch->tid == mytid)
1827         break;
1828       if (!dispatch->ctrl && !firstfree)
1829         firstfree = dispatch;
1830     }
1831   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1832     {
1833       if (firstfree)
1834         {
1835           dispatch = firstfree;
1836         }
1837       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1838         {
1839           dispatch->next = progress_dispatch_list;
1840           progress_dispatch_list = dispatch;
1841         }
1842       else
1843         {
1844           log_error ("error allocating new progress dispatcher slot: %s\n",
1845                      gpg_strerror (gpg_error_from_syserror ()));
1846           return;
1847         }
1848       dispatch->ctrl = ctrl;
1849       dispatch->tid = mytid;
1850     }
1851
1852   dispatch->cb = cb;
1853 }
1854
1855
1856 /* Each thread has its own local variables conveyed by a control
1857    structure usually identified by an argument named CTRL.  This
1858    function is called immediately after allocating the control
1859    structure.  Its purpose is to setup the default values for that
1860    structure.  Note that some values may have already been set.  */
1861 static void
1862 agent_init_default_ctrl (ctrl_t ctrl)
1863 {
1864   assert (ctrl->session_env);
1865
1866   /* Note we ignore malloc errors because we can't do much about it
1867      and the request will fail anyway shortly after this
1868      initialization. */
1869   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1870   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1871   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1872   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1873   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1874
1875   if (ctrl->lc_ctype)
1876     xfree (ctrl->lc_ctype);
1877   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1878
1879   if (ctrl->lc_messages)
1880     xfree (ctrl->lc_messages);
1881   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1882                                     /**/ : NULL;
1883   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1884 }
1885
1886
1887 /* Release all resources allocated by default in the control
1888    structure.  This is the counterpart to agent_init_default_ctrl.  */
1889 static void
1890 agent_deinit_default_ctrl (ctrl_t ctrl)
1891 {
1892   unregister_progress_cb ();
1893   session_env_release (ctrl->session_env);
1894
1895   if (ctrl->lc_ctype)
1896     xfree (ctrl->lc_ctype);
1897   if (ctrl->lc_messages)
1898     xfree (ctrl->lc_messages);
1899 }
1900
1901
1902 /* Because the ssh protocol does not send us information about the
1903    current TTY setting, we use this function to use those from startup
1904    or those explicitly set.  This is also used for the restricted mode
1905    where we ignore requests to change the environment.  */
1906 gpg_error_t
1907 agent_copy_startup_env (ctrl_t ctrl)
1908 {
1909   static const char *names[] =
1910     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1911   gpg_error_t err = 0;
1912   int idx;
1913   const char *value;
1914
1915   for (idx=0; !err && names[idx]; idx++)
1916       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1917       err = session_env_setenv (ctrl->session_env, names[idx], value);
1918
1919   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1920     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1921       err = gpg_error_from_syserror ();
1922
1923   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1924     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1925       err = gpg_error_from_syserror ();
1926
1927   if (err)
1928     log_error ("error setting default session environment: %s\n",
1929                gpg_strerror (err));
1930
1931   return err;
1932 }
1933
1934
1935 /* Reread parts of the configuration.  Note, that this function is
1936    obviously not thread-safe and should only be called from the PTH
1937    signal handler.
1938
1939    Fixme: Due to the way the argument parsing works, we create a
1940    memory leak here for all string type arguments.  There is currently
1941    no clean way to tell whether the memory for the argument has been
1942    allocated or points into the process' original arguments.  Unless
1943    we have a mechanism to tell this, we need to live on with this. */
1944 static void
1945 reread_configuration (void)
1946 {
1947   ARGPARSE_ARGS pargs;
1948   FILE *fp;
1949   unsigned int configlineno = 0;
1950   int dummy;
1951
1952   if (!config_filename)
1953     return; /* No config file. */
1954
1955   fp = fopen (config_filename, "r");
1956   if (!fp)
1957     {
1958       log_info (_("option file '%s': %s\n"),
1959                 config_filename, strerror(errno) );
1960       return;
1961     }
1962
1963   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1964
1965   memset (&pargs, 0, sizeof pargs);
1966   dummy = 0;
1967   pargs.argc = &dummy;
1968   pargs.flags = 1;  /* do not remove the args */
1969   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1970     {
1971       if (pargs.r_opt < -1)
1972         pargs.err = 1; /* Print a warning. */
1973       else /* Try to parse this option - ignore unchangeable ones. */
1974         parse_rereadable_options (&pargs, 1);
1975     }
1976   fclose (fp);
1977   finalize_rereadable_options ();
1978   set_debug ();
1979 }
1980
1981
1982 /* Return the file name of the socket we are using for native
1983    requests.  */
1984 const char *
1985 get_agent_socket_name (void)
1986 {
1987   const char *s = socket_name;
1988
1989   return (s && *s)? s : NULL;
1990 }
1991
1992 /* Return the file name of the socket we are using for SSH
1993    requests.  */
1994 const char *
1995 get_agent_ssh_socket_name (void)
1996 {
1997   const char *s = socket_name_ssh;
1998
1999   return (s && *s)? s : NULL;
2000 }
2001
2002
2003 /* Return the number of active connections. */
2004 int
2005 get_agent_active_connection_count (void)
2006 {
2007   return active_connections;
2008 }
2009
2010
2011 /* Under W32, this function returns the handle of the scdaemon
2012    notification event.  Calling it the first time creates that
2013    event.  */
2014 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2015 void *
2016 get_agent_scd_notify_event (void)
2017 {
2018   static HANDLE the_event = INVALID_HANDLE_VALUE;
2019
2020   if (the_event == INVALID_HANDLE_VALUE)
2021     {
2022       HANDLE h, h2;
2023       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2024
2025       /* We need to use a manual reset event object due to the way our
2026          w32-pth wait function works: If we would use an automatic
2027          reset event we are not able to figure out which handle has
2028          been signaled because at the time we single out the signaled
2029          handles using WFSO the event has already been reset due to
2030          the WFMO.  */
2031       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2032       if (!h)
2033         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2034       else if (!DuplicateHandle (GetCurrentProcess(), h,
2035                                  GetCurrentProcess(), &h2,
2036                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2037         {
2038           log_error ("setting syncronize for scd notify event failed: %s\n",
2039                      w32_strerror (-1) );
2040           CloseHandle (h);
2041         }
2042       else
2043         {
2044           CloseHandle (h);
2045           the_event = h2;
2046         }
2047     }
2048
2049   return the_event;
2050 }
2051 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2052
2053
2054
2055 /* Create a name for the socket in the home directory as using
2056    STANDARD_NAME.  We also check for valid characters as well as
2057    against a maximum allowed length for a unix domain socket is done.
2058    The function terminates the process in case of an error.  Returns:
2059    Pointer to an allocated string with the absolute name of the socket
2060    used.  */
2061 static char *
2062 create_socket_name (char *standard_name, int with_homedir)
2063 {
2064   char *name;
2065
2066   if (with_homedir)
2067     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2068   else
2069     name = make_filename (standard_name, NULL);
2070   if (strchr (name, PATHSEP_C))
2071     {
2072       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2073       agent_exit (2);
2074     }
2075   return name;
2076 }
2077
2078
2079
2080 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2081    or terminates the process in case of an error.  Note that this
2082    function needs to be used for the regular socket first (indicated
2083    by PRIMARY) and only then for the extra and the ssh sockets.  If
2084    the socket has been redirected the name of the real socket is
2085    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2086    Cygwin compatible socket is created (Windows only). */
2087 static gnupg_fd_t
2088 create_server_socket (char *name, int primary, int cygwin,
2089                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2090 {
2091   struct sockaddr *addr;
2092   struct sockaddr_un *unaddr;
2093   socklen_t len;
2094   gnupg_fd_t fd;
2095   int rc;
2096
2097   xfree (*r_redir_name);
2098   *r_redir_name = NULL;
2099
2100   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2101   if (fd == ASSUAN_INVALID_FD)
2102     {
2103       log_error (_("can't create socket: %s\n"), strerror (errno));
2104       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2105       agent_exit (2);
2106     }
2107
2108   if (cygwin)
2109     assuan_sock_set_flag (fd, "cygwin", 1);
2110
2111   unaddr = xmalloc (sizeof *unaddr);
2112   addr = (struct sockaddr*)unaddr;
2113
2114   {
2115     int redirected;
2116
2117     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2118       {
2119         if (errno == ENAMETOOLONG)
2120           log_error (_("socket name '%s' is too long\n"), name);
2121         else
2122           log_error ("error preparing socket '%s': %s\n",
2123                      name, gpg_strerror (gpg_error_from_syserror ()));
2124         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2125         agent_exit (2);
2126       }
2127     if (redirected)
2128       {
2129         *r_redir_name = xstrdup (unaddr->sun_path);
2130         if (opt.verbose)
2131           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2132       }
2133   }
2134
2135   len = SUN_LEN (unaddr);
2136   rc = assuan_sock_bind (fd, addr, len);
2137
2138   /* Our error code mapping on W32CE returns EEXIST thus we also test
2139      for this. */
2140   if (rc == -1
2141       && (errno == EADDRINUSE
2142 #ifdef HAVE_W32_SYSTEM
2143           || errno == EEXIST
2144 #endif
2145           ))
2146     {
2147       /* Check whether a gpg-agent is already running.  We do this
2148          test only if this is the primary socket.  For secondary
2149          sockets we assume that a test for gpg-agent has already been
2150          done and reuse the requested socket.  Testing the ssh-socket
2151          is not possible because at this point, though we know the new
2152          Assuan socket, the Assuan server and thus the ssh-agent
2153          server is not yet operational; this would lead to a hang.  */
2154       if (primary && !check_for_running_agent (1))
2155         {
2156           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2157           log_set_file (NULL);
2158           log_error (_("a gpg-agent is already running - "
2159                        "not starting a new one\n"));
2160           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2161           assuan_sock_close (fd);
2162           agent_exit (2);
2163         }
2164       gnupg_remove (unaddr->sun_path);
2165       rc = assuan_sock_bind (fd, addr, len);
2166     }
2167   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2168     log_error (_("error getting nonce for the socket\n"));
2169   if (rc == -1)
2170     {
2171       /* We use gpg_strerror here because it allows us to get strings
2172          for some W32 socket error codes.  */
2173       log_error (_("error binding socket to '%s': %s\n"),
2174                  unaddr->sun_path,
2175                  gpg_strerror (gpg_error_from_syserror ()));
2176
2177       assuan_sock_close (fd);
2178       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2179       agent_exit (2);
2180     }
2181
2182   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2183     log_error (_("can't set permissions of '%s': %s\n"),
2184                unaddr->sun_path, strerror (errno));
2185
2186   if (listen (FD2INT(fd), 5 ) == -1)
2187     {
2188       log_error (_("listen() failed: %s\n"), strerror (errno));
2189       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2190       assuan_sock_close (fd);
2191       agent_exit (2);
2192     }
2193
2194   if (opt.verbose)
2195     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2196
2197   return fd;
2198 }
2199
2200
2201 /* Check that the directory for storing the private keys exists and
2202    create it if not.  This function won't fail as it is only a
2203    convenience function and not strictly necessary.  */
2204 static void
2205 create_private_keys_directory (const char *home)
2206 {
2207   char *fname;
2208   struct stat statbuf;
2209
2210   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2211   if (stat (fname, &statbuf) && errno == ENOENT)
2212     {
2213       if (gnupg_mkdir (fname, "-rwx"))
2214         log_error (_("can't create directory '%s': %s\n"),
2215                    fname, strerror (errno) );
2216       else if (!opt.quiet)
2217         log_info (_("directory '%s' created\n"), fname);
2218     }
2219   if (gnupg_chmod (fname, "-rwx"))
2220     log_error (_("can't set permissions of '%s': %s\n"),
2221                fname, strerror (errno));
2222   xfree (fname);
2223 }
2224
2225
2226 /* Create the directory only if the supplied directory name is the
2227    same as the default one.  This way we avoid to create arbitrary
2228    directories when a non-default home directory is used.  To cope
2229    with HOME, we compare only the suffix if we see that the default
2230    homedir does start with a tilde.  We don't stop here in case of
2231    problems because other functions will throw an error anyway.*/
2232 static void
2233 create_directories (void)
2234 {
2235   struct stat statbuf;
2236   const char *defhome = standard_homedir ();
2237   char *home;
2238
2239   home = make_filename (gnupg_homedir (), NULL);
2240   if ( stat (home, &statbuf) )
2241     {
2242       if (errno == ENOENT)
2243         {
2244           if (
2245 #ifdef HAVE_W32_SYSTEM
2246               ( !compare_filenames (home, defhome) )
2247 #else
2248               (*defhome == '~'
2249                 && (strlen (home) >= strlen (defhome+1)
2250                     && !strcmp (home + strlen(home)
2251                                 - strlen (defhome+1), defhome+1)))
2252                || (*defhome != '~' && !strcmp (home, defhome) )
2253 #endif
2254                )
2255             {
2256               if (gnupg_mkdir (home, "-rwx"))
2257                 log_error (_("can't create directory '%s': %s\n"),
2258                            home, strerror (errno) );
2259               else
2260                 {
2261                   if (!opt.quiet)
2262                     log_info (_("directory '%s' created\n"), home);
2263                   create_private_keys_directory (home);
2264                 }
2265             }
2266         }
2267       else
2268         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2269     }
2270   else if ( !S_ISDIR(statbuf.st_mode))
2271     {
2272       log_error (_("can't use '%s' as home directory\n"), home);
2273     }
2274   else /* exists and is a directory. */
2275     {
2276       create_private_keys_directory (home);
2277     }
2278   xfree (home);
2279 }
2280
2281
2282
2283 /* This is the worker for the ticker.  It is called every few seconds
2284    and may only do fast operations. */
2285 static void
2286 handle_tick (void)
2287 {
2288   static time_t last_minute;
2289
2290   if (!last_minute)
2291     last_minute = time (NULL);
2292
2293   /* Check whether the scdaemon has died and cleanup in this case. */
2294   agent_scd_check_aliveness ();
2295
2296   /* If we are running as a child of another process, check whether
2297      the parent is still alive and shutdown if not. */
2298 #ifndef HAVE_W32_SYSTEM
2299   if (parent_pid != (pid_t)(-1))
2300     {
2301       if (kill (parent_pid, 0))
2302         {
2303           shutdown_pending = 2;
2304           log_info ("parent process died - shutting down\n");
2305           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2306           cleanup ();
2307           agent_exit (0);
2308         }
2309     }
2310 #endif /*HAVE_W32_SYSTEM*/
2311
2312   /* Code to be run from time to time.  */
2313 #if CHECK_OWN_SOCKET_INTERVAL > 0
2314   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2315     {
2316       check_own_socket ();
2317       last_minute = time (NULL);
2318     }
2319 #endif
2320
2321 }
2322
2323
2324 /* A global function which allows us to call the reload stuff from
2325    other places too.  This is only used when build for W32.  */
2326 void
2327 agent_sighup_action (void)
2328 {
2329   log_info ("SIGHUP received - "
2330             "re-reading configuration and flushing cache\n");
2331
2332   agent_flush_cache ();
2333   reread_configuration ();
2334   agent_reload_trustlist ();
2335   /* We flush the module name cache so that after installing a
2336      "pinentry" binary that one can be used in case the
2337      "pinentry-basic" fallback was in use.  */
2338   gnupg_module_name_flush_some ();
2339 }
2340
2341
2342 /* A helper function to handle SIGUSR2.  */
2343 static void
2344 agent_sigusr2_action (void)
2345 {
2346   if (opt.verbose)
2347     log_info ("SIGUSR2 received - updating card event counter\n");
2348   /* Nothing to check right now.  We only increment a counter.  */
2349   bump_card_eventcounter ();
2350 }
2351
2352
2353 #ifndef HAVE_W32_SYSTEM
2354 /* The signal handler for this program.  It is expected to be run in
2355    its own trhead and not in the context of a signal handler.  */
2356 static void
2357 handle_signal (int signo)
2358 {
2359   switch (signo)
2360     {
2361 #ifndef HAVE_W32_SYSTEM
2362     case SIGHUP:
2363       agent_sighup_action ();
2364       break;
2365
2366     case SIGUSR1:
2367       log_info ("SIGUSR1 received - printing internal information:\n");
2368       /* Fixme: We need to see how to integrate pth dumping into our
2369          logging system.  */
2370       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2371       agent_query_dump_state ();
2372       agent_scd_dump_state ();
2373       break;
2374
2375     case SIGUSR2:
2376       agent_sigusr2_action ();
2377       break;
2378
2379     case SIGTERM:
2380       if (!shutdown_pending)
2381         log_info ("SIGTERM received - shutting down ...\n");
2382       else
2383         log_info ("SIGTERM received - still %i open connections\n",
2384                   active_connections);
2385       shutdown_pending++;
2386       if (shutdown_pending > 2)
2387         {
2388           log_info ("shutdown forced\n");
2389           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2390           cleanup ();
2391           agent_exit (0);
2392         }
2393       break;
2394
2395     case SIGINT:
2396       log_info ("SIGINT received - immediate shutdown\n");
2397       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2398       cleanup ();
2399       agent_exit (0);
2400       break;
2401 #endif
2402     default:
2403       log_info ("signal %d received - no action defined\n", signo);
2404     }
2405 }
2406 #endif
2407
2408 /* Check the nonce on a new connection.  This is a NOP unless we we
2409    are using our Unix domain socket emulation under Windows.  */
2410 static int
2411 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2412 {
2413   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2414     {
2415       log_info (_("error reading nonce on fd %d: %s\n"),
2416                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2417       assuan_sock_close (ctrl->thread_startup.fd);
2418       xfree (ctrl);
2419       return -1;
2420     }
2421   else
2422     return 0;
2423 }
2424
2425
2426 #ifdef HAVE_W32_SYSTEM
2427 /* The window message processing function for Putty.  Warning: This
2428    code runs as a native Windows thread.  Use of our own functions
2429    needs to be bracket with pth_leave/pth_enter. */
2430 static LRESULT CALLBACK
2431 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2432 {
2433   int ret = 0;
2434   int w32rc;
2435   COPYDATASTRUCT *cds;
2436   const char *mapfile;
2437   HANDLE maphd;
2438   PSID mysid = NULL;
2439   PSID mapsid = NULL;
2440   void *data = NULL;
2441   PSECURITY_DESCRIPTOR psd = NULL;
2442   ctrl_t ctrl = NULL;
2443
2444   if (msg != WM_COPYDATA)
2445     {
2446       return DefWindowProc (hwnd, msg, wparam, lparam);
2447     }
2448
2449   cds = (COPYDATASTRUCT*)lparam;
2450   if (cds->dwData != PUTTY_IPC_MAGIC)
2451     return 0;  /* Ignore data with the wrong magic.  */
2452   mapfile = cds->lpData;
2453   if (!cds->cbData || mapfile[cds->cbData - 1])
2454     return 0;  /* Ignore empty and non-properly terminated strings.  */
2455
2456   if (DBG_IPC)
2457     {
2458       npth_protect ();
2459       log_debug ("ssh map file '%s'", mapfile);
2460       npth_unprotect ();
2461     }
2462
2463   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2464   if (DBG_IPC)
2465     {
2466       npth_protect ();
2467       log_debug ("ssh map handle %p\n", maphd);
2468       npth_unprotect ();
2469     }
2470
2471   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2472     return 0;
2473
2474   npth_protect ();
2475
2476   mysid = w32_get_user_sid ();
2477   if (!mysid)
2478     {
2479       log_error ("error getting my sid\n");
2480       goto leave;
2481     }
2482
2483   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2484                            OWNER_SECURITY_INFORMATION,
2485                            &mapsid, NULL, NULL, NULL,
2486                            &psd);
2487   if (w32rc)
2488     {
2489       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2490       goto leave;
2491     }
2492
2493   if (DBG_IPC)
2494     {
2495       char *sidstr;
2496
2497       if (!ConvertSidToStringSid (mysid, &sidstr))
2498         sidstr = NULL;
2499       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2500       LocalFree (sidstr);
2501       if (!ConvertSidToStringSid (mapsid, &sidstr))
2502         sidstr = NULL;
2503       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2504       LocalFree (sidstr);
2505     }
2506
2507   if (!EqualSid (mysid, mapsid))
2508     {
2509       log_error ("ssh map file has a non-matching sid\n");
2510       goto leave;
2511     }
2512
2513   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2514   if (DBG_IPC)
2515     log_debug ("ssh IPC buffer at %p\n", data);
2516   if (!data)
2517     goto leave;
2518
2519   /* log_printhex ("request:", data, 20); */
2520
2521   ctrl = xtrycalloc (1, sizeof *ctrl);
2522   if (!ctrl)
2523     {
2524       log_error ("error allocating connection control data: %s\n",
2525                  strerror (errno) );
2526       goto leave;
2527     }
2528   ctrl->session_env = session_env_new ();
2529   if (!ctrl->session_env)
2530     {
2531       log_error ("error allocating session environment block: %s\n",
2532                  strerror (errno) );
2533       goto leave;
2534     }
2535
2536   agent_init_default_ctrl (ctrl);
2537   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2538     ret = 1; /* Valid ssh message has been constructed.  */
2539   agent_deinit_default_ctrl (ctrl);
2540   /* log_printhex ("  reply:", data, 20); */
2541
2542  leave:
2543   xfree (ctrl);
2544   if (data)
2545     UnmapViewOfFile (data);
2546   xfree (mapsid);
2547   if (psd)
2548     LocalFree (psd);
2549   xfree (mysid);
2550   CloseHandle (maphd);
2551
2552   npth_unprotect ();
2553
2554   return ret;
2555 }
2556 #endif /*HAVE_W32_SYSTEM*/
2557
2558
2559 #ifdef HAVE_W32_SYSTEM
2560 /* The thread handling Putty's IPC requests.  */
2561 static void *
2562 putty_message_thread (void *arg)
2563 {
2564   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2565                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2566   HWND hwnd;
2567   MSG msg;
2568
2569   (void)arg;
2570
2571   if (opt.verbose)
2572     log_info ("putty message loop thread started\n");
2573
2574   /* The message loop runs as thread independent from our nPth system.
2575      This also means that we need to make sure that we switch back to
2576      our system before calling any no-windows function.  */
2577   npth_unprotect ();
2578
2579   /* First create a window to make sure that a message queue exists
2580      for this thread.  */
2581   if (!RegisterClass (&wndwclass))
2582     {
2583       npth_protect ();
2584       log_error ("error registering Pageant window class");
2585       return NULL;
2586     }
2587   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2588                          0, 0, 0, 0,
2589                          HWND_MESSAGE,  /* hWndParent */
2590                          NULL,          /* hWndMenu   */
2591                          NULL,          /* hInstance  */
2592                          NULL);         /* lpParm     */
2593   if (!hwnd)
2594     {
2595       npth_protect ();
2596       log_error ("error creating Pageant window");
2597       return NULL;
2598     }
2599
2600   while (GetMessage(&msg, NULL, 0, 0))
2601     {
2602       TranslateMessage(&msg);
2603       DispatchMessage(&msg);
2604     }
2605
2606   /* Back to nPth.  */
2607   npth_protect ();
2608
2609   if (opt.verbose)
2610     log_info ("putty message loop thread stopped\n");
2611   return NULL;
2612 }
2613 #endif /*HAVE_W32_SYSTEM*/
2614
2615
2616 static void *
2617 do_start_connection_thread (ctrl_t ctrl)
2618 {
2619   active_connections++;
2620   agent_init_default_ctrl (ctrl);
2621   if (opt.verbose && !DBG_IPC)
2622     log_info (_("handler 0x%lx for fd %d started\n"),
2623               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2624
2625   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2626   if (opt.verbose && !DBG_IPC)
2627     log_info (_("handler 0x%lx for fd %d terminated\n"),
2628               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2629
2630   agent_deinit_default_ctrl (ctrl);
2631   xfree (ctrl);
2632   active_connections--;
2633   return NULL;
2634 }
2635
2636
2637 /* This is the standard connection thread's main function.  */
2638 static void *
2639 start_connection_thread_std (void *arg)
2640 {
2641   ctrl_t ctrl = arg;
2642
2643   if (check_nonce (ctrl, &socket_nonce))
2644     {
2645       log_error ("handler 0x%lx nonce check FAILED\n",
2646                  (unsigned long) npth_self());
2647       return NULL;
2648     }
2649
2650   return do_start_connection_thread (ctrl);
2651 }
2652
2653
2654 /* This is the extra socket connection thread's main function.  */
2655 static void *
2656 start_connection_thread_extra (void *arg)
2657 {
2658   ctrl_t ctrl = arg;
2659
2660   if (check_nonce (ctrl, &socket_nonce_extra))
2661     {
2662       log_error ("handler 0x%lx nonce check FAILED\n",
2663                  (unsigned long) npth_self());
2664       return NULL;
2665     }
2666
2667   ctrl->restricted = 1;
2668   return do_start_connection_thread (ctrl);
2669 }
2670
2671
2672 /* This is the browser socket connection thread's main function.  */
2673 static void *
2674 start_connection_thread_browser (void *arg)
2675 {
2676   ctrl_t ctrl = arg;
2677
2678   if (check_nonce (ctrl, &socket_nonce_browser))
2679     {
2680       log_error ("handler 0x%lx nonce check FAILED\n",
2681                  (unsigned long) npth_self());
2682       return NULL;
2683     }
2684
2685   ctrl->restricted = 2;
2686   return do_start_connection_thread (ctrl);
2687 }
2688
2689
2690 /* This is the ssh connection thread's main function.  */
2691 static void *
2692 start_connection_thread_ssh (void *arg)
2693 {
2694   ctrl_t ctrl = arg;
2695
2696   if (check_nonce (ctrl, &socket_nonce_ssh))
2697     return NULL;
2698
2699   active_connections++;
2700   agent_init_default_ctrl (ctrl);
2701   if (opt.verbose)
2702     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2703               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2704
2705   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2706   if (opt.verbose)
2707     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2708               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2709
2710   agent_deinit_default_ctrl (ctrl);
2711   xfree (ctrl);
2712   active_connections--;
2713   return NULL;
2714 }
2715
2716
2717 #ifdef HAVE_INOTIFY_INIT
2718 /* Read an inotify event and return true if it matches NAME.  */
2719 static int
2720 my_inotify_is_name (int fd, const char *name)
2721 {
2722   union {
2723     struct inotify_event ev;
2724     char _buf[sizeof (struct inotify_event) + 100 + 1];
2725   } buf;
2726   int n;
2727
2728   n = npth_read (fd, &buf, sizeof buf);
2729   if (n < sizeof (struct inotify_event))
2730     return 0;
2731   if (buf.ev.len < strlen (name)+1)
2732     return 0;
2733   if (strcmp (buf.ev.name, name))
2734     return 0; /* Not the desired file.  */
2735
2736   return 1; /* Found.  */
2737 }
2738 #endif /*HAVE_INOTIFY_INIT*/
2739
2740
2741
2742 /* Connection handler loop.  Wait for connection requests and spawn a
2743    thread after accepting a connection.  */
2744 static void
2745 handle_connections (gnupg_fd_t listen_fd,
2746                     gnupg_fd_t listen_fd_extra,
2747                     gnupg_fd_t listen_fd_browser,
2748                     gnupg_fd_t listen_fd_ssh)
2749 {
2750   npth_attr_t tattr;
2751   struct sockaddr_un paddr;
2752   socklen_t plen;
2753   fd_set fdset, read_fdset;
2754   int ret;
2755   gnupg_fd_t fd;
2756   int nfd;
2757   int saved_errno;
2758   struct timespec abstime;
2759   struct timespec curtime;
2760   struct timespec timeout;
2761 #ifdef HAVE_W32_SYSTEM
2762   HANDLE events[2];
2763   unsigned int events_set;
2764 #endif
2765 #ifdef HAVE_INOTIFY_INIT
2766   int my_inotify_fd;
2767 #endif /*HAVE_INOTIFY_INIT*/
2768   struct {
2769     const char *name;
2770     void *(*func) (void *arg);
2771     gnupg_fd_t l_fd;
2772   } listentbl[] = {
2773     { "std",     start_connection_thread_std   },
2774     { "extra",   start_connection_thread_extra },
2775     { "browser", start_connection_thread_browser },
2776     { "ssh",    start_connection_thread_ssh   }
2777   };
2778
2779
2780   ret = npth_attr_init(&tattr);
2781   if (ret)
2782     log_fatal ("error allocating thread attributes: %s\n",
2783                strerror (ret));
2784   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2785
2786 #ifndef HAVE_W32_SYSTEM
2787   npth_sigev_init ();
2788   npth_sigev_add (SIGHUP);
2789   npth_sigev_add (SIGUSR1);
2790   npth_sigev_add (SIGUSR2);
2791   npth_sigev_add (SIGINT);
2792   npth_sigev_add (SIGTERM);
2793   npth_sigev_fini ();
2794 #else
2795 # ifdef HAVE_W32CE_SYSTEM
2796   /* Use a dummy event. */
2797   sigs = 0;
2798   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2799 # else
2800   events[0] = get_agent_scd_notify_event ();
2801   events[1] = INVALID_HANDLE_VALUE;
2802 # endif
2803 #endif
2804
2805 #ifdef HAVE_INOTIFY_INIT
2806   if (disable_check_own_socket)
2807     my_inotify_fd = -1;
2808   else if ((my_inotify_fd = inotify_init ()) == -1)
2809     log_info ("error enabling fast daemon termination: %s\n",
2810               strerror (errno));
2811   else
2812     {
2813       /* We need to watch the directory for the file because there
2814        * won't be an IN_DELETE_SELF for a socket file.  */
2815       char *slash = strrchr (socket_name, '/');
2816       log_assert (slash && slash[1]);
2817       *slash = 0;
2818       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2819         {
2820           close (my_inotify_fd);
2821           my_inotify_fd = -1;
2822         }
2823       *slash = '/';
2824     }
2825 #endif /*HAVE_INOTIFY_INIT*/
2826
2827   /* On Windows we need to fire up a separate thread to listen for
2828      requests from Putty (an SSH client), so we can replace Putty's
2829      Pageant (its ssh-agent implementation). */
2830 #ifdef HAVE_W32_SYSTEM
2831   if (putty_support)
2832     {
2833       npth_t thread;
2834
2835       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2836       if (ret)
2837         {
2838           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2839         }
2840     }
2841 #endif /*HAVE_W32_SYSTEM*/
2842
2843   /* Set a flag to tell call-scd.c that it may enable event
2844      notifications.  */
2845   opt.sigusr2_enabled = 1;
2846
2847   FD_ZERO (&fdset);
2848   FD_SET (FD2INT (listen_fd), &fdset);
2849   nfd = FD2INT (listen_fd);
2850   if (listen_fd_extra != GNUPG_INVALID_FD)
2851     {
2852       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2853       if (FD2INT (listen_fd_extra) > nfd)
2854         nfd = FD2INT (listen_fd_extra);
2855     }
2856   if (listen_fd_browser != GNUPG_INVALID_FD)
2857     {
2858       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2859       if (FD2INT (listen_fd_browser) > nfd)
2860         nfd = FD2INT (listen_fd_browser);
2861     }
2862   if (listen_fd_ssh != GNUPG_INVALID_FD)
2863     {
2864       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2865       if (FD2INT (listen_fd_ssh) > nfd)
2866         nfd = FD2INT (listen_fd_ssh);
2867     }
2868 #ifdef HAVE_INOTIFY_INIT
2869   if (my_inotify_fd != -1)
2870     {
2871       FD_SET (my_inotify_fd, &fdset);
2872       if (my_inotify_fd > nfd)
2873         nfd = my_inotify_fd;
2874     }
2875 #endif /*HAVE_INOTIFY_INIT*/
2876
2877   listentbl[0].l_fd = listen_fd;
2878   listentbl[1].l_fd = listen_fd_extra;
2879   listentbl[2].l_fd = listen_fd_browser;
2880   listentbl[3].l_fd = listen_fd_ssh;
2881
2882   npth_clock_gettime (&abstime);
2883   abstime.tv_sec += TIMERTICK_INTERVAL;
2884
2885   for (;;)
2886     {
2887       /* Shutdown test.  */
2888       if (shutdown_pending)
2889         {
2890           if (active_connections == 0)
2891             break; /* ready */
2892
2893           /* Do not accept new connections but keep on running the
2894              loop to cope with the timer events.  */
2895           FD_ZERO (&fdset);
2896         }
2897
2898       /* POSIX says that fd_set should be implemented as a structure,
2899          thus a simple assignment is fine to copy the entire set.  */
2900       read_fdset = fdset;
2901
2902       npth_clock_gettime (&curtime);
2903       if (!(npth_timercmp (&curtime, &abstime, <)))
2904         {
2905           /* Timeout.  */
2906           handle_tick ();
2907           npth_clock_gettime (&abstime);
2908           abstime.tv_sec += TIMERTICK_INTERVAL;
2909         }
2910       npth_timersub (&abstime, &curtime, &timeout);
2911
2912 #ifndef HAVE_W32_SYSTEM
2913       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2914                           npth_sigev_sigmask ());
2915       saved_errno = errno;
2916
2917       {
2918         int signo;
2919         while (npth_sigev_get_pending (&signo))
2920           handle_signal (signo);
2921       }
2922 #else
2923       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2924                           events, &events_set);
2925       saved_errno = errno;
2926
2927       /* This is valid even if npth_eselect returns an error.  */
2928       if (events_set & 1)
2929         agent_sigusr2_action ();
2930 #endif
2931
2932       if (ret == -1 && saved_errno != EINTR)
2933         {
2934           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2935                      strerror (saved_errno));
2936           npth_sleep (1);
2937           continue;
2938         }
2939       if (ret <= 0)
2940         /* Interrupt or timeout.  Will be handled when calculating the
2941            next timeout.  */
2942         continue;
2943
2944       if (!shutdown_pending)
2945         {
2946           int idx;
2947           ctrl_t ctrl;
2948           npth_t thread;
2949
2950 #ifdef HAVE_INOTIFY_INIT
2951           if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2952               && my_inotify_is_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
2953             {
2954               shutdown_pending = 1;
2955               log_info ("socket file has been removed - shutting down\n");
2956             }
2957 #endif /*HAVE_INOTIFY_INIT*/
2958
2959           for (idx=0; idx < DIM(listentbl); idx++)
2960             {
2961               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2962                 continue;
2963               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2964                 continue;
2965
2966               plen = sizeof paddr;
2967               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2968                                         (struct sockaddr *)&paddr, &plen));
2969               if (fd == GNUPG_INVALID_FD)
2970                 {
2971                   log_error ("accept failed for %s: %s\n",
2972                              listentbl[idx].name, strerror (errno));
2973                 }
2974               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2975                 {
2976                   log_error ("error allocating connection data for %s: %s\n",
2977                              listentbl[idx].name, strerror (errno) );
2978                   assuan_sock_close (fd);
2979                 }
2980               else if ( !(ctrl->session_env = session_env_new ()))
2981                 {
2982                   log_error ("error allocating session env block for %s: %s\n",
2983                              listentbl[idx].name, strerror (errno) );
2984                   xfree (ctrl);
2985                   assuan_sock_close (fd);
2986                 }
2987               else
2988                 {
2989                   ctrl->thread_startup.fd = fd;
2990                   ret = npth_create (&thread, &tattr,
2991                                      listentbl[idx].func, ctrl);
2992                   if (ret)
2993                     {
2994                       log_error ("error spawning connection handler for %s:"
2995                                  " %s\n", listentbl[idx].name, strerror (ret));
2996                       assuan_sock_close (fd);
2997                       xfree (ctrl);
2998                     }
2999                 }
3000               fd = GNUPG_INVALID_FD;
3001             }
3002         }
3003     }
3004
3005 #ifdef HAVE_INOTIFY_INIT
3006   if (my_inotify_fd != -1)
3007     close (my_inotify_fd);
3008 #endif /*HAVE_INOTIFY_INIT*/
3009   cleanup ();
3010   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
3011   npth_attr_destroy (&tattr);
3012 }
3013
3014
3015
3016 /* Helper for check_own_socket.  */
3017 static gpg_error_t
3018 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3019 {
3020   membuf_t *mb = opaque;
3021   put_membuf (mb, buffer, length);
3022   return 0;
3023 }
3024
3025
3026 /* The thread running the actual check.  We need to run this in a
3027    separate thread so that check_own_thread can be called from the
3028    timer tick.  */
3029 static void *
3030 check_own_socket_thread (void *arg)
3031 {
3032   int rc;
3033   char *sockname = arg;
3034   assuan_context_t ctx = NULL;
3035   membuf_t mb;
3036   char *buffer;
3037
3038   check_own_socket_running++;
3039
3040   rc = assuan_new (&ctx);
3041   if (rc)
3042     {
3043       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3044       goto leave;
3045     }
3046   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3047
3048   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3049   if (rc)
3050     {
3051       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3052       goto leave;
3053     }
3054
3055   init_membuf (&mb, 100);
3056   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3057                         NULL, NULL, NULL, NULL);
3058   put_membuf (&mb, "", 1);
3059   buffer = get_membuf (&mb, NULL);
3060   if (rc || !buffer)
3061     {
3062       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3063                  "GETINFO pid", gpg_strerror (rc));
3064       rc = 1;
3065     }
3066   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3067     {
3068       log_error ("socket is now serviced by another server\n");
3069       rc = 1;
3070     }
3071   else if (opt.verbose > 1)
3072     log_error ("socket is still served by this server\n");
3073
3074   xfree (buffer);
3075
3076  leave:
3077   xfree (sockname);
3078   if (ctx)
3079     assuan_release (ctx);
3080   if (rc)
3081     {
3082       /* We may not remove the socket as it is now in use by another
3083          server. */
3084       inhibit_socket_removal = 1;
3085       shutdown_pending = 2;
3086       log_info ("this process is useless - shutting down\n");
3087     }
3088   check_own_socket_running--;
3089   return NULL;
3090 }
3091
3092
3093 /* Check whether we are still listening on our own socket.  In case
3094    another gpg-agent process started after us has taken ownership of
3095    our socket, we would linger around without any real task.  Thus we
3096    better check once in a while whether we are really needed.  */
3097 static void
3098 check_own_socket (void)
3099 {
3100   char *sockname;
3101   npth_t thread;
3102   npth_attr_t tattr;
3103   int err;
3104
3105   if (disable_check_own_socket)
3106     return;
3107
3108   if (check_own_socket_running || shutdown_pending)
3109     return;  /* Still running or already shutting down.  */
3110
3111   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3112   if (!sockname)
3113     return; /* Out of memory.  */
3114
3115   err = npth_attr_init (&tattr);
3116   if (err)
3117     return;
3118   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3119   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3120   if (err)
3121     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3122   npth_attr_destroy (&tattr);
3123 }
3124
3125
3126
3127 /* Figure out whether an agent is available and running. Prints an
3128    error if not.  If SILENT is true, no messages are printed.
3129    Returns 0 if the agent is running. */
3130 static int
3131 check_for_running_agent (int silent)
3132 {
3133   gpg_error_t err;
3134   char *sockname;
3135   assuan_context_t ctx = NULL;
3136
3137   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3138   if (!sockname)
3139     return gpg_error_from_syserror ();
3140
3141   err = assuan_new (&ctx);
3142   if (!err)
3143     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3144   xfree (sockname);
3145   if (err)
3146     {
3147       if (!silent)
3148         log_error (_("no gpg-agent running in this session\n"));
3149
3150       if (ctx)
3151         assuan_release (ctx);
3152       return -1;
3153     }
3154
3155   if (!opt.quiet && !silent)
3156     log_info ("gpg-agent running and available\n");
3157
3158   assuan_release (ctx);
3159   return 0;
3160 }