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