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