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