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