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