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