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