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