common: New functions gnupg_daemon_rootdir and gnupg_chdir.
[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   ARGPARSE_end () /* End of list */
253 };
254
255
256 /* The list of supported debug flags.  */
257 static struct debug_flags_s debug_flags [] =
258   {
259     { DBG_MPI_VALUE    , "mpi"     },
260     { DBG_CRYPTO_VALUE , "crypto"  },
261     { DBG_MEMORY_VALUE , "memory"  },
262     { DBG_CACHE_VALUE  , "cache"   },
263     { DBG_MEMSTAT_VALUE, "memstat" },
264     { DBG_HASHING_VALUE, "hashing" },
265     { DBG_IPC_VALUE    , "ipc"     },
266     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
267   };
268
269
270
271 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
272 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
273 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
274 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
275 #define MIN_PASSPHRASE_LEN    (8)
276 #define MIN_PASSPHRASE_NONALPHA (1)
277 #define MAX_PASSPHRASE_DAYS   (0)
278
279 /* The timer tick used for housekeeping stuff.  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 (gnupg_chdir (gnupg_daemon_rootdir ()))
1712         {
1713           log_error ("chdir to '%s' failed: %s\n",
1714                      gnupg_daemon_rootdir (), strerror (errno));
1715           exit (1);
1716         }
1717
1718       {
1719         struct sigaction sa;
1720
1721         sa.sa_handler = SIG_IGN;
1722         sigemptyset (&sa.sa_mask);
1723         sa.sa_flags = 0;
1724         sigaction (SIGPIPE, &sa, NULL);
1725       }
1726 #endif /*!HAVE_W32_SYSTEM*/
1727
1728       log_info ("%s %s started\n", strusage(11), strusage(13) );
1729       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1730       assuan_sock_close (fd);
1731     }
1732
1733   return 0;
1734 }
1735
1736
1737 /* Exit entry point.  This function should be called instead of a
1738    plain exit.  */
1739 void
1740 agent_exit (int rc)
1741 {
1742   /*FIXME: update_random_seed_file();*/
1743
1744   /* We run our cleanup handler because that may close cipher contexts
1745      stored in secure memory and thus this needs to be done before we
1746      explicitly terminate secure memory.  */
1747   cleanup ();
1748
1749 #if 1
1750   /* at this time a bit annoying */
1751   if (opt.debug & DBG_MEMSTAT_VALUE)
1752     {
1753       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1754       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1755     }
1756   if (opt.debug)
1757     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1758 #endif
1759   gcry_control (GCRYCTL_TERM_SECMEM );
1760   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1761   exit (rc);
1762 }
1763
1764
1765 /* This is our callback function for gcrypt progress messages.  It is
1766    set once at startup and dispatches progress messages to the
1767    corresponding threads of the agent.  */
1768 static void
1769 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1770                              int current, int total)
1771 {
1772   struct progress_dispatch_s *dispatch;
1773   npth_t mytid = npth_self ();
1774
1775   (void)data;
1776
1777   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1778     if (dispatch->ctrl && dispatch->tid == mytid)
1779       break;
1780   if (dispatch && dispatch->cb)
1781     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1782
1783   /* Libgcrypt < 1.8 does not know about nPth and thus when it reads
1784    * from /dev/random this will block the process.  To mitigate this
1785    * problem we yield the thread when Libgcrypt tells us that it needs
1786    * more entropy.  This way other threads have chance to run.  */
1787 #if GCRYPT_VERSION_NUMBER < 0x010800 /* 1.8.0 */
1788   if (what && !strcmp (what, "need_entropy"))
1789     {
1790 #if GPGRT_VERSION_NUMBER < 0x011900 /* 1.25 */
1791       /* In older gpg-error versions gpgrt_yield is buggy for use with
1792        * nPth and thus we need to resort to a sleep call.  */
1793       npth_usleep (1000); /* 1ms */
1794 #else
1795       gpgrt_yield ();
1796 #endif
1797     }
1798 #endif
1799 }
1800
1801
1802 /* If a progress dispatcher callback has been associated with the
1803  * current connection unregister it.  */
1804 static void
1805 unregister_progress_cb (void)
1806 {
1807   struct progress_dispatch_s *dispatch;
1808   npth_t mytid = npth_self ();
1809
1810   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1811     if (dispatch->ctrl && dispatch->tid == mytid)
1812       break;
1813   if (dispatch)
1814     {
1815       dispatch->ctrl = NULL;
1816       dispatch->cb = NULL;
1817     }
1818 }
1819
1820
1821 /* Setup a progress callback CB for the current connection.  Using a
1822  * CB of NULL disables the callback.  */
1823 void
1824 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1825                                   int printchar, int current, int total),
1826                        ctrl_t ctrl)
1827 {
1828   struct progress_dispatch_s *dispatch, *firstfree;
1829   npth_t mytid = npth_self ();
1830
1831   firstfree = NULL;
1832   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1833     {
1834       if (dispatch->ctrl && dispatch->tid == mytid)
1835         break;
1836       if (!dispatch->ctrl && !firstfree)
1837         firstfree = dispatch;
1838     }
1839   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1840     {
1841       if (firstfree)
1842         {
1843           dispatch = firstfree;
1844         }
1845       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1846         {
1847           dispatch->next = progress_dispatch_list;
1848           progress_dispatch_list = dispatch;
1849         }
1850       else
1851         {
1852           log_error ("error allocating new progress dispatcher slot: %s\n",
1853                      gpg_strerror (gpg_error_from_syserror ()));
1854           return;
1855         }
1856       dispatch->ctrl = ctrl;
1857       dispatch->tid = mytid;
1858     }
1859
1860   dispatch->cb = cb;
1861 }
1862
1863
1864 /* Each thread has its own local variables conveyed by a control
1865    structure usually identified by an argument named CTRL.  This
1866    function is called immediately after allocating the control
1867    structure.  Its purpose is to setup the default values for that
1868    structure.  Note that some values may have already been set.  */
1869 static void
1870 agent_init_default_ctrl (ctrl_t ctrl)
1871 {
1872   assert (ctrl->session_env);
1873
1874   /* Note we ignore malloc errors because we can't do much about it
1875      and the request will fail anyway shortly after this
1876      initialization. */
1877   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1878   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1879   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1880   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1881   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1882
1883   if (ctrl->lc_ctype)
1884     xfree (ctrl->lc_ctype);
1885   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1886
1887   if (ctrl->lc_messages)
1888     xfree (ctrl->lc_messages);
1889   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1890                                     /**/ : NULL;
1891   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1892 }
1893
1894
1895 /* Release all resources allocated by default in the control
1896    structure.  This is the counterpart to agent_init_default_ctrl.  */
1897 static void
1898 agent_deinit_default_ctrl (ctrl_t ctrl)
1899 {
1900   unregister_progress_cb ();
1901   session_env_release (ctrl->session_env);
1902
1903   if (ctrl->lc_ctype)
1904     xfree (ctrl->lc_ctype);
1905   if (ctrl->lc_messages)
1906     xfree (ctrl->lc_messages);
1907 }
1908
1909
1910 /* Because the ssh protocol does not send us information about the
1911    current TTY setting, we use this function to use those from startup
1912    or those explicitly set.  This is also used for the restricted mode
1913    where we ignore requests to change the environment.  */
1914 gpg_error_t
1915 agent_copy_startup_env (ctrl_t ctrl)
1916 {
1917   static const char *names[] =
1918     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1919   gpg_error_t err = 0;
1920   int idx;
1921   const char *value;
1922
1923   for (idx=0; !err && names[idx]; idx++)
1924     if ((value = session_env_getenv (opt.startup_env, names[idx])))
1925       err = session_env_setenv (ctrl->session_env, names[idx], value);
1926
1927   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1928     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1929       err = gpg_error_from_syserror ();
1930
1931   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1932     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1933       err = gpg_error_from_syserror ();
1934
1935   if (err)
1936     log_error ("error setting default session environment: %s\n",
1937                gpg_strerror (err));
1938
1939   return err;
1940 }
1941
1942
1943 /* Reread parts of the configuration.  Note, that this function is
1944    obviously not thread-safe and should only be called from the PTH
1945    signal handler.
1946
1947    Fixme: Due to the way the argument parsing works, we create a
1948    memory leak here for all string type arguments.  There is currently
1949    no clean way to tell whether the memory for the argument has been
1950    allocated or points into the process' original arguments.  Unless
1951    we have a mechanism to tell this, we need to live on with this. */
1952 static void
1953 reread_configuration (void)
1954 {
1955   ARGPARSE_ARGS pargs;
1956   FILE *fp;
1957   unsigned int configlineno = 0;
1958   int dummy;
1959
1960   if (!config_filename)
1961     return; /* No config file. */
1962
1963   fp = fopen (config_filename, "r");
1964   if (!fp)
1965     {
1966       log_info (_("option file '%s': %s\n"),
1967                 config_filename, strerror(errno) );
1968       return;
1969     }
1970
1971   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1972
1973   memset (&pargs, 0, sizeof pargs);
1974   dummy = 0;
1975   pargs.argc = &dummy;
1976   pargs.flags = 1;  /* do not remove the args */
1977   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1978     {
1979       if (pargs.r_opt < -1)
1980         pargs.err = 1; /* Print a warning. */
1981       else /* Try to parse this option - ignore unchangeable ones. */
1982         parse_rereadable_options (&pargs, 1);
1983     }
1984   fclose (fp);
1985   finalize_rereadable_options ();
1986   set_debug ();
1987 }
1988
1989
1990 /* Return the file name of the socket we are using for native
1991    requests.  */
1992 const char *
1993 get_agent_socket_name (void)
1994 {
1995   const char *s = socket_name;
1996
1997   return (s && *s)? s : NULL;
1998 }
1999
2000 /* Return the file name of the socket we are using for SSH
2001    requests.  */
2002 const char *
2003 get_agent_ssh_socket_name (void)
2004 {
2005   const char *s = socket_name_ssh;
2006
2007   return (s && *s)? s : NULL;
2008 }
2009
2010
2011 /* Return the number of active connections. */
2012 int
2013 get_agent_active_connection_count (void)
2014 {
2015   return active_connections;
2016 }
2017
2018
2019 /* Under W32, this function returns the handle of the scdaemon
2020    notification event.  Calling it the first time creates that
2021    event.  */
2022 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2023 void *
2024 get_agent_scd_notify_event (void)
2025 {
2026   static HANDLE the_event = INVALID_HANDLE_VALUE;
2027
2028   if (the_event == INVALID_HANDLE_VALUE)
2029     {
2030       HANDLE h, h2;
2031       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2032
2033       /* We need to use a manual reset event object due to the way our
2034          w32-pth wait function works: If we would use an automatic
2035          reset event we are not able to figure out which handle has
2036          been signaled because at the time we single out the signaled
2037          handles using WFSO the event has already been reset due to
2038          the WFMO.  */
2039       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2040       if (!h)
2041         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2042       else if (!DuplicateHandle (GetCurrentProcess(), h,
2043                                  GetCurrentProcess(), &h2,
2044                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2045         {
2046           log_error ("setting syncronize for scd notify event failed: %s\n",
2047                      w32_strerror (-1) );
2048           CloseHandle (h);
2049         }
2050       else
2051         {
2052           CloseHandle (h);
2053           the_event = h2;
2054         }
2055     }
2056
2057   return the_event;
2058 }
2059 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2060
2061
2062
2063 /* Create a name for the socket in the home directory as using
2064    STANDARD_NAME.  We also check for valid characters as well as
2065    against a maximum allowed length for a unix domain socket is done.
2066    The function terminates the process in case of an error.  Returns:
2067    Pointer to an allocated string with the absolute name of the socket
2068    used.  */
2069 static char *
2070 create_socket_name (char *standard_name, int with_homedir)
2071 {
2072   char *name;
2073
2074   if (with_homedir)
2075     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2076   else
2077     name = make_filename (standard_name, NULL);
2078   if (strchr (name, PATHSEP_C))
2079     {
2080       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2081       agent_exit (2);
2082     }
2083   return name;
2084 }
2085
2086
2087
2088 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2089    or terminates the process in case of an error.  Note that this
2090    function needs to be used for the regular socket first (indicated
2091    by PRIMARY) and only then for the extra and the ssh sockets.  If
2092    the socket has been redirected the name of the real socket is
2093    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2094    Cygwin compatible socket is created (Windows only). */
2095 static gnupg_fd_t
2096 create_server_socket (char *name, int primary, int cygwin,
2097                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2098 {
2099   struct sockaddr *addr;
2100   struct sockaddr_un *unaddr;
2101   socklen_t len;
2102   gnupg_fd_t fd;
2103   int rc;
2104
2105   xfree (*r_redir_name);
2106   *r_redir_name = NULL;
2107
2108   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2109   if (fd == ASSUAN_INVALID_FD)
2110     {
2111       log_error (_("can't create socket: %s\n"), strerror (errno));
2112       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2113       agent_exit (2);
2114     }
2115
2116   if (cygwin)
2117     assuan_sock_set_flag (fd, "cygwin", 1);
2118
2119   unaddr = xmalloc (sizeof *unaddr);
2120   addr = (struct sockaddr*)unaddr;
2121
2122   {
2123     int redirected;
2124
2125     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2126       {
2127         if (errno == ENAMETOOLONG)
2128           log_error (_("socket name '%s' is too long\n"), name);
2129         else
2130           log_error ("error preparing socket '%s': %s\n",
2131                      name, gpg_strerror (gpg_error_from_syserror ()));
2132         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2133         xfree (unaddr);
2134         agent_exit (2);
2135       }
2136     if (redirected)
2137       {
2138         *r_redir_name = xstrdup (unaddr->sun_path);
2139         if (opt.verbose)
2140           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2141       }
2142   }
2143
2144   len = SUN_LEN (unaddr);
2145   rc = assuan_sock_bind (fd, addr, len);
2146
2147   /* Our error code mapping on W32CE returns EEXIST thus we also test
2148      for this. */
2149   if (rc == -1
2150       && (errno == EADDRINUSE
2151 #ifdef HAVE_W32_SYSTEM
2152           || errno == EEXIST
2153 #endif
2154           ))
2155     {
2156       /* Check whether a gpg-agent is already running.  We do this
2157          test only if this is the primary socket.  For secondary
2158          sockets we assume that a test for gpg-agent has already been
2159          done and reuse the requested socket.  Testing the ssh-socket
2160          is not possible because at this point, though we know the new
2161          Assuan socket, the Assuan server and thus the ssh-agent
2162          server is not yet operational; this would lead to a hang.  */
2163       if (primary && !check_for_running_agent (1))
2164         {
2165           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2166           log_set_file (NULL);
2167           log_error (_("a gpg-agent is already running - "
2168                        "not starting a new one\n"));
2169           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2170           assuan_sock_close (fd);
2171           xfree (unaddr);
2172           agent_exit (2);
2173         }
2174       gnupg_remove (unaddr->sun_path);
2175       rc = assuan_sock_bind (fd, addr, len);
2176     }
2177   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2178     log_error (_("error getting nonce for the socket\n"));
2179   if (rc == -1)
2180     {
2181       /* We use gpg_strerror here because it allows us to get strings
2182          for some W32 socket error codes.  */
2183       log_error (_("error binding socket to '%s': %s\n"),
2184                  unaddr->sun_path,
2185                  gpg_strerror (gpg_error_from_syserror ()));
2186
2187       assuan_sock_close (fd);
2188       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2189       xfree (unaddr);
2190       agent_exit (2);
2191     }
2192
2193   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2194     log_error (_("can't set permissions of '%s': %s\n"),
2195                unaddr->sun_path, strerror (errno));
2196
2197   if (listen (FD2INT(fd), 5 ) == -1)
2198     {
2199       log_error (_("listen() failed: %s\n"), strerror (errno));
2200       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2201       assuan_sock_close (fd);
2202       xfree (unaddr);
2203       agent_exit (2);
2204     }
2205
2206   if (opt.verbose)
2207     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2208
2209   xfree (unaddr);
2210   return fd;
2211 }
2212
2213
2214 /* Check that the directory for storing the private keys exists and
2215    create it if not.  This function won't fail as it is only a
2216    convenience function and not strictly necessary.  */
2217 static void
2218 create_private_keys_directory (const char *home)
2219 {
2220   char *fname;
2221   struct stat statbuf;
2222
2223   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2224   if (stat (fname, &statbuf) && errno == ENOENT)
2225     {
2226       if (gnupg_mkdir (fname, "-rwx"))
2227         log_error (_("can't create directory '%s': %s\n"),
2228                    fname, strerror (errno) );
2229       else if (!opt.quiet)
2230         log_info (_("directory '%s' created\n"), fname);
2231     }
2232   if (gnupg_chmod (fname, "-rwx"))
2233     log_error (_("can't set permissions of '%s': %s\n"),
2234                fname, strerror (errno));
2235   xfree (fname);
2236 }
2237
2238
2239 /* Create the directory only if the supplied directory name is the
2240    same as the default one.  This way we avoid to create arbitrary
2241    directories when a non-default home directory is used.  To cope
2242    with HOME, we compare only the suffix if we see that the default
2243    homedir does start with a tilde.  We don't stop here in case of
2244    problems because other functions will throw an error anyway.*/
2245 static void
2246 create_directories (void)
2247 {
2248   struct stat statbuf;
2249   const char *defhome = standard_homedir ();
2250   char *home;
2251
2252   home = make_filename (gnupg_homedir (), NULL);
2253   if ( stat (home, &statbuf) )
2254     {
2255       if (errno == ENOENT)
2256         {
2257           if (
2258 #ifdef HAVE_W32_SYSTEM
2259               ( !compare_filenames (home, defhome) )
2260 #else
2261               (*defhome == '~'
2262                 && (strlen (home) >= strlen (defhome+1)
2263                     && !strcmp (home + strlen(home)
2264                                 - strlen (defhome+1), defhome+1)))
2265                || (*defhome != '~' && !strcmp (home, defhome) )
2266 #endif
2267                )
2268             {
2269               if (gnupg_mkdir (home, "-rwx"))
2270                 log_error (_("can't create directory '%s': %s\n"),
2271                            home, strerror (errno) );
2272               else
2273                 {
2274                   if (!opt.quiet)
2275                     log_info (_("directory '%s' created\n"), home);
2276                   create_private_keys_directory (home);
2277                 }
2278             }
2279         }
2280       else
2281         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2282     }
2283   else if ( !S_ISDIR(statbuf.st_mode))
2284     {
2285       log_error (_("can't use '%s' as home directory\n"), home);
2286     }
2287   else /* exists and is a directory. */
2288     {
2289       create_private_keys_directory (home);
2290     }
2291   xfree (home);
2292 }
2293
2294
2295
2296 /* This is the worker for the ticker.  It is called every few seconds
2297    and may only do fast operations. */
2298 static void
2299 handle_tick (void)
2300 {
2301   static time_t last_minute;
2302
2303   if (!last_minute)
2304     last_minute = time (NULL);
2305
2306   /* Check whether the scdaemon has died and cleanup in this case. */
2307   agent_scd_check_aliveness ();
2308
2309   /* If we are running as a child of another process, check whether
2310      the parent is still alive and shutdown if not. */
2311 #ifndef HAVE_W32_SYSTEM
2312   if (parent_pid != (pid_t)(-1))
2313     {
2314       if (kill (parent_pid, 0))
2315         {
2316           shutdown_pending = 2;
2317           log_info ("parent process died - shutting down\n");
2318           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2319           cleanup ();
2320           agent_exit (0);
2321         }
2322     }
2323 #endif /*HAVE_W32_SYSTEM*/
2324
2325   /* Code to be run from time to time.  */
2326 #if CHECK_OWN_SOCKET_INTERVAL > 0
2327   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2328     {
2329       check_own_socket ();
2330       last_minute = time (NULL);
2331     }
2332 #endif
2333
2334 }
2335
2336
2337 /* A global function which allows us to call the reload stuff from
2338    other places too.  This is only used when build for W32.  */
2339 void
2340 agent_sighup_action (void)
2341 {
2342   log_info ("SIGHUP received - "
2343             "re-reading configuration and flushing cache\n");
2344
2345   agent_flush_cache ();
2346   reread_configuration ();
2347   agent_reload_trustlist ();
2348   /* We flush the module name cache so that after installing a
2349      "pinentry" binary that one can be used in case the
2350      "pinentry-basic" fallback was in use.  */
2351   gnupg_module_name_flush_some ();
2352 }
2353
2354
2355 /* A helper function to handle SIGUSR2.  */
2356 static void
2357 agent_sigusr2_action (void)
2358 {
2359   if (opt.verbose)
2360     log_info ("SIGUSR2 received - updating card event counter\n");
2361   /* Nothing to check right now.  We only increment a counter.  */
2362   bump_card_eventcounter ();
2363 }
2364
2365
2366 #ifndef HAVE_W32_SYSTEM
2367 /* The signal handler for this program.  It is expected to be run in
2368    its own trhead and not in the context of a signal handler.  */
2369 static void
2370 handle_signal (int signo)
2371 {
2372   switch (signo)
2373     {
2374 #ifndef HAVE_W32_SYSTEM
2375     case SIGHUP:
2376       agent_sighup_action ();
2377       break;
2378
2379     case SIGUSR1:
2380       log_info ("SIGUSR1 received - printing internal information:\n");
2381       /* Fixme: We need to see how to integrate pth dumping into our
2382          logging system.  */
2383       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2384       agent_query_dump_state ();
2385       agent_scd_dump_state ();
2386       break;
2387
2388     case SIGUSR2:
2389       agent_sigusr2_action ();
2390       break;
2391
2392     case SIGTERM:
2393       if (!shutdown_pending)
2394         log_info ("SIGTERM received - shutting down ...\n");
2395       else
2396         log_info ("SIGTERM received - still %i open connections\n",
2397                   active_connections);
2398       shutdown_pending++;
2399       if (shutdown_pending > 2)
2400         {
2401           log_info ("shutdown forced\n");
2402           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2403           cleanup ();
2404           agent_exit (0);
2405         }
2406       break;
2407
2408     case SIGINT:
2409       log_info ("SIGINT received - immediate shutdown\n");
2410       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2411       cleanup ();
2412       agent_exit (0);
2413       break;
2414 #endif
2415     default:
2416       log_info ("signal %d received - no action defined\n", signo);
2417     }
2418 }
2419 #endif
2420
2421 /* Check the nonce on a new connection.  This is a NOP unless we
2422    are using our Unix domain socket emulation under Windows.  */
2423 static int
2424 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2425 {
2426   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2427     {
2428       log_info (_("error reading nonce on fd %d: %s\n"),
2429                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2430       assuan_sock_close (ctrl->thread_startup.fd);
2431       xfree (ctrl);
2432       return -1;
2433     }
2434   else
2435     return 0;
2436 }
2437
2438
2439 #ifdef HAVE_W32_SYSTEM
2440 /* The window message processing function for Putty.  Warning: This
2441    code runs as a native Windows thread.  Use of our own functions
2442    needs to be bracket with pth_leave/pth_enter. */
2443 static LRESULT CALLBACK
2444 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2445 {
2446   int ret = 0;
2447   int w32rc;
2448   COPYDATASTRUCT *cds;
2449   const char *mapfile;
2450   HANDLE maphd;
2451   PSID mysid = NULL;
2452   PSID mapsid = NULL;
2453   void *data = NULL;
2454   PSECURITY_DESCRIPTOR psd = NULL;
2455   ctrl_t ctrl = NULL;
2456
2457   if (msg != WM_COPYDATA)
2458     {
2459       return DefWindowProc (hwnd, msg, wparam, lparam);
2460     }
2461
2462   cds = (COPYDATASTRUCT*)lparam;
2463   if (cds->dwData != PUTTY_IPC_MAGIC)
2464     return 0;  /* Ignore data with the wrong magic.  */
2465   mapfile = cds->lpData;
2466   if (!cds->cbData || mapfile[cds->cbData - 1])
2467     return 0;  /* Ignore empty and non-properly terminated strings.  */
2468
2469   if (DBG_IPC)
2470     {
2471       npth_protect ();
2472       log_debug ("ssh map file '%s'", mapfile);
2473       npth_unprotect ();
2474     }
2475
2476   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2477   if (DBG_IPC)
2478     {
2479       npth_protect ();
2480       log_debug ("ssh map handle %p\n", maphd);
2481       npth_unprotect ();
2482     }
2483
2484   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2485     return 0;
2486
2487   npth_protect ();
2488
2489   mysid = w32_get_user_sid ();
2490   if (!mysid)
2491     {
2492       log_error ("error getting my sid\n");
2493       goto leave;
2494     }
2495
2496   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2497                            OWNER_SECURITY_INFORMATION,
2498                            &mapsid, NULL, NULL, NULL,
2499                            &psd);
2500   if (w32rc)
2501     {
2502       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2503       goto leave;
2504     }
2505
2506   if (DBG_IPC)
2507     {
2508       char *sidstr;
2509
2510       if (!ConvertSidToStringSid (mysid, &sidstr))
2511         sidstr = NULL;
2512       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2513       LocalFree (sidstr);
2514       if (!ConvertSidToStringSid (mapsid, &sidstr))
2515         sidstr = NULL;
2516       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2517       LocalFree (sidstr);
2518     }
2519
2520   if (!EqualSid (mysid, mapsid))
2521     {
2522       log_error ("ssh map file has a non-matching sid\n");
2523       goto leave;
2524     }
2525
2526   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2527   if (DBG_IPC)
2528     log_debug ("ssh IPC buffer at %p\n", data);
2529   if (!data)
2530     goto leave;
2531
2532   /* log_printhex ("request:", data, 20); */
2533
2534   ctrl = xtrycalloc (1, sizeof *ctrl);
2535   if (!ctrl)
2536     {
2537       log_error ("error allocating connection control data: %s\n",
2538                  strerror (errno) );
2539       goto leave;
2540     }
2541   ctrl->session_env = session_env_new ();
2542   if (!ctrl->session_env)
2543     {
2544       log_error ("error allocating session environment block: %s\n",
2545                  strerror (errno) );
2546       goto leave;
2547     }
2548
2549   agent_init_default_ctrl (ctrl);
2550   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2551     ret = 1; /* Valid ssh message has been constructed.  */
2552   agent_deinit_default_ctrl (ctrl);
2553   /* log_printhex ("  reply:", data, 20); */
2554
2555  leave:
2556   xfree (ctrl);
2557   if (data)
2558     UnmapViewOfFile (data);
2559   xfree (mapsid);
2560   if (psd)
2561     LocalFree (psd);
2562   xfree (mysid);
2563   CloseHandle (maphd);
2564
2565   npth_unprotect ();
2566
2567   return ret;
2568 }
2569 #endif /*HAVE_W32_SYSTEM*/
2570
2571
2572 #ifdef HAVE_W32_SYSTEM
2573 /* The thread handling Putty's IPC requests.  */
2574 static void *
2575 putty_message_thread (void *arg)
2576 {
2577   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2578                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2579   HWND hwnd;
2580   MSG msg;
2581
2582   (void)arg;
2583
2584   if (opt.verbose)
2585     log_info ("putty message loop thread started\n");
2586
2587   /* The message loop runs as thread independent from our nPth system.
2588      This also means that we need to make sure that we switch back to
2589      our system before calling any no-windows function.  */
2590   npth_unprotect ();
2591
2592   /* First create a window to make sure that a message queue exists
2593      for this thread.  */
2594   if (!RegisterClass (&wndwclass))
2595     {
2596       npth_protect ();
2597       log_error ("error registering Pageant window class");
2598       return NULL;
2599     }
2600   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2601                          0, 0, 0, 0,
2602                          HWND_MESSAGE,  /* hWndParent */
2603                          NULL,          /* hWndMenu   */
2604                          NULL,          /* hInstance  */
2605                          NULL);         /* lpParm     */
2606   if (!hwnd)
2607     {
2608       npth_protect ();
2609       log_error ("error creating Pageant window");
2610       return NULL;
2611     }
2612
2613   while (GetMessage(&msg, NULL, 0, 0))
2614     {
2615       TranslateMessage(&msg);
2616       DispatchMessage(&msg);
2617     }
2618
2619   /* Back to nPth.  */
2620   npth_protect ();
2621
2622   if (opt.verbose)
2623     log_info ("putty message loop thread stopped\n");
2624   return NULL;
2625 }
2626 #endif /*HAVE_W32_SYSTEM*/
2627
2628
2629 static void *
2630 do_start_connection_thread (ctrl_t ctrl)
2631 {
2632   active_connections++;
2633   agent_init_default_ctrl (ctrl);
2634   if (opt.verbose && !DBG_IPC)
2635     log_info (_("handler 0x%lx for fd %d started\n"),
2636               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2637
2638   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2639   if (opt.verbose && !DBG_IPC)
2640     log_info (_("handler 0x%lx for fd %d terminated\n"),
2641               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2642
2643   agent_deinit_default_ctrl (ctrl);
2644   xfree (ctrl);
2645   active_connections--;
2646   return NULL;
2647 }
2648
2649
2650 /* This is the standard connection thread's main function.  */
2651 static void *
2652 start_connection_thread_std (void *arg)
2653 {
2654   ctrl_t ctrl = arg;
2655
2656   if (check_nonce (ctrl, &socket_nonce))
2657     {
2658       log_error ("handler 0x%lx nonce check FAILED\n",
2659                  (unsigned long) npth_self());
2660       return NULL;
2661     }
2662
2663   return do_start_connection_thread (ctrl);
2664 }
2665
2666
2667 /* This is the extra socket connection thread's main function.  */
2668 static void *
2669 start_connection_thread_extra (void *arg)
2670 {
2671   ctrl_t ctrl = arg;
2672
2673   if (check_nonce (ctrl, &socket_nonce_extra))
2674     {
2675       log_error ("handler 0x%lx nonce check FAILED\n",
2676                  (unsigned long) npth_self());
2677       return NULL;
2678     }
2679
2680   ctrl->restricted = 1;
2681   return do_start_connection_thread (ctrl);
2682 }
2683
2684
2685 /* This is the browser socket connection thread's main function.  */
2686 static void *
2687 start_connection_thread_browser (void *arg)
2688 {
2689   ctrl_t ctrl = arg;
2690
2691   if (check_nonce (ctrl, &socket_nonce_browser))
2692     {
2693       log_error ("handler 0x%lx nonce check FAILED\n",
2694                  (unsigned long) npth_self());
2695       return NULL;
2696     }
2697
2698   ctrl->restricted = 2;
2699   return do_start_connection_thread (ctrl);
2700 }
2701
2702
2703 /* This is the ssh connection thread's main function.  */
2704 static void *
2705 start_connection_thread_ssh (void *arg)
2706 {
2707   ctrl_t ctrl = arg;
2708
2709   if (check_nonce (ctrl, &socket_nonce_ssh))
2710     return NULL;
2711
2712   active_connections++;
2713   agent_init_default_ctrl (ctrl);
2714   if (opt.verbose)
2715     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2716               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2717
2718   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2719   if (opt.verbose)
2720     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2721               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2722
2723   agent_deinit_default_ctrl (ctrl);
2724   xfree (ctrl);
2725   active_connections--;
2726   return NULL;
2727 }
2728
2729
2730 /* Connection handler loop.  Wait for connection requests and spawn a
2731    thread after accepting a connection.  */
2732 static void
2733 handle_connections (gnupg_fd_t listen_fd,
2734                     gnupg_fd_t listen_fd_extra,
2735                     gnupg_fd_t listen_fd_browser,
2736                     gnupg_fd_t listen_fd_ssh)
2737 {
2738   gpg_error_t err;
2739   npth_attr_t tattr;
2740   struct sockaddr_un paddr;
2741   socklen_t plen;
2742   fd_set fdset, read_fdset;
2743   int ret;
2744   gnupg_fd_t fd;
2745   int nfd;
2746   int saved_errno;
2747   struct timespec abstime;
2748   struct timespec curtime;
2749   struct timespec timeout;
2750 #ifdef HAVE_W32_SYSTEM
2751   HANDLE events[2];
2752   unsigned int events_set;
2753 #endif
2754   int sock_inotify_fd = -1;
2755   int home_inotify_fd = -1;
2756   struct {
2757     const char *name;
2758     void *(*func) (void *arg);
2759     gnupg_fd_t l_fd;
2760   } listentbl[] = {
2761     { "std",     start_connection_thread_std   },
2762     { "extra",   start_connection_thread_extra },
2763     { "browser", start_connection_thread_browser },
2764     { "ssh",    start_connection_thread_ssh   }
2765   };
2766
2767
2768   ret = npth_attr_init(&tattr);
2769   if (ret)
2770     log_fatal ("error allocating thread attributes: %s\n",
2771                strerror (ret));
2772   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2773
2774 #ifndef HAVE_W32_SYSTEM
2775   npth_sigev_init ();
2776   npth_sigev_add (SIGHUP);
2777   npth_sigev_add (SIGUSR1);
2778   npth_sigev_add (SIGUSR2);
2779   npth_sigev_add (SIGINT);
2780   npth_sigev_add (SIGTERM);
2781   npth_sigev_fini ();
2782 #else
2783 # ifdef HAVE_W32CE_SYSTEM
2784   /* Use a dummy event. */
2785   sigs = 0;
2786   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2787 # else
2788   events[0] = get_agent_scd_notify_event ();
2789   events[1] = INVALID_HANDLE_VALUE;
2790 # endif
2791 #endif
2792
2793   if (disable_check_own_socket)
2794     sock_inotify_fd = -1;
2795   else if ((err = gnupg_inotify_watch_socket (&sock_inotify_fd, socket_name)))
2796     {
2797       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2798         log_info ("error enabling daemon termination by socket removal: %s\n",
2799                   gpg_strerror (err));
2800     }
2801
2802   if (disable_check_own_socket)
2803     home_inotify_fd = -1;
2804   else if ((err = gnupg_inotify_watch_delete_self (&home_inotify_fd,
2805                                                    gnupg_homedir ())))
2806     {
2807       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2808         log_info ("error enabling daemon termination bu homedir removal: %s\n",
2809                   gpg_strerror (err));
2810     }
2811
2812   /* On Windows we need to fire up a separate thread to listen for
2813      requests from Putty (an SSH client), so we can replace Putty's
2814      Pageant (its ssh-agent implementation). */
2815 #ifdef HAVE_W32_SYSTEM
2816   if (putty_support)
2817     {
2818       npth_t thread;
2819
2820       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2821       if (ret)
2822         {
2823           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2824         }
2825     }
2826 #endif /*HAVE_W32_SYSTEM*/
2827
2828   /* Set a flag to tell call-scd.c that it may enable event
2829      notifications.  */
2830   opt.sigusr2_enabled = 1;
2831
2832   FD_ZERO (&fdset);
2833   FD_SET (FD2INT (listen_fd), &fdset);
2834   nfd = FD2INT (listen_fd);
2835   if (listen_fd_extra != GNUPG_INVALID_FD)
2836     {
2837       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2838       if (FD2INT (listen_fd_extra) > nfd)
2839         nfd = FD2INT (listen_fd_extra);
2840     }
2841   if (listen_fd_browser != GNUPG_INVALID_FD)
2842     {
2843       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2844       if (FD2INT (listen_fd_browser) > nfd)
2845         nfd = FD2INT (listen_fd_browser);
2846     }
2847   if (listen_fd_ssh != GNUPG_INVALID_FD)
2848     {
2849       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2850       if (FD2INT (listen_fd_ssh) > nfd)
2851         nfd = FD2INT (listen_fd_ssh);
2852     }
2853   if (sock_inotify_fd != -1)
2854     {
2855       FD_SET (sock_inotify_fd, &fdset);
2856       if (sock_inotify_fd > nfd)
2857         nfd = sock_inotify_fd;
2858     }
2859   if (home_inotify_fd != -1)
2860     {
2861       FD_SET (home_inotify_fd, &fdset);
2862       if (home_inotify_fd > nfd)
2863         nfd = home_inotify_fd;
2864     }
2865
2866   listentbl[0].l_fd = listen_fd;
2867   listentbl[1].l_fd = listen_fd_extra;
2868   listentbl[2].l_fd = listen_fd_browser;
2869   listentbl[3].l_fd = listen_fd_ssh;
2870
2871   npth_clock_gettime (&abstime);
2872   abstime.tv_sec += TIMERTICK_INTERVAL;
2873
2874   for (;;)
2875     {
2876       /* Shutdown test.  */
2877       if (shutdown_pending)
2878         {
2879           if (active_connections == 0)
2880             break; /* ready */
2881
2882           /* Do not accept new connections but keep on running the
2883            * loop to cope with the timer events.
2884            *
2885            * Note that we do not close the listening socket because a
2886            * client trying to connect to that socket would instead
2887            * restart a new dirmngr instance - which is unlikely the
2888            * intention of a shutdown. */
2889           FD_ZERO (&fdset);
2890           nfd = -1;
2891           if (sock_inotify_fd != -1)
2892             {
2893               FD_SET (sock_inotify_fd, &fdset);
2894               nfd = sock_inotify_fd;
2895             }
2896           if (home_inotify_fd != -1)
2897             {
2898               FD_SET (home_inotify_fd, &fdset);
2899               if (home_inotify_fd > nfd)
2900                 nfd = home_inotify_fd;
2901             }
2902         }
2903
2904       /* POSIX says that fd_set should be implemented as a structure,
2905          thus a simple assignment is fine to copy the entire set.  */
2906       read_fdset = fdset;
2907
2908       npth_clock_gettime (&curtime);
2909       if (!(npth_timercmp (&curtime, &abstime, <)))
2910         {
2911           /* Timeout.  */
2912           handle_tick ();
2913           npth_clock_gettime (&abstime);
2914           abstime.tv_sec += TIMERTICK_INTERVAL;
2915         }
2916       npth_timersub (&abstime, &curtime, &timeout);
2917
2918 #ifndef HAVE_W32_SYSTEM
2919       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2920                           npth_sigev_sigmask ());
2921       saved_errno = errno;
2922
2923       {
2924         int signo;
2925         while (npth_sigev_get_pending (&signo))
2926           handle_signal (signo);
2927       }
2928 #else
2929       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2930                           events, &events_set);
2931       saved_errno = errno;
2932
2933       /* This is valid even if npth_eselect returns an error.  */
2934       if (events_set & 1)
2935         agent_sigusr2_action ();
2936 #endif
2937
2938       if (ret == -1 && saved_errno != EINTR)
2939         {
2940           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2941                      strerror (saved_errno));
2942           npth_sleep (1);
2943           continue;
2944         }
2945       if (ret <= 0)
2946         /* Interrupt or timeout.  Will be handled when calculating the
2947            next timeout.  */
2948         continue;
2949
2950       if (!shutdown_pending)
2951         {
2952           int idx;
2953           ctrl_t ctrl;
2954           npth_t thread;
2955
2956           if (sock_inotify_fd != -1
2957               && FD_ISSET (sock_inotify_fd, &read_fdset)
2958               && gnupg_inotify_has_name (sock_inotify_fd, GPG_AGENT_SOCK_NAME))
2959             {
2960               shutdown_pending = 1;
2961               log_info ("socket file has been removed - shutting down\n");
2962             }
2963
2964           if (home_inotify_fd != -1
2965               && FD_ISSET (home_inotify_fd, &read_fdset))
2966             {
2967               shutdown_pending = 1;
2968               log_info ("homedir has been removed - shutting down\n");
2969             }
2970
2971           for (idx=0; idx < DIM(listentbl); idx++)
2972             {
2973               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2974                 continue;
2975               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2976                 continue;
2977
2978               plen = sizeof paddr;
2979               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2980                                         (struct sockaddr *)&paddr, &plen));
2981               if (fd == GNUPG_INVALID_FD)
2982                 {
2983                   log_error ("accept failed for %s: %s\n",
2984                              listentbl[idx].name, strerror (errno));
2985                 }
2986               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2987                 {
2988                   log_error ("error allocating connection data for %s: %s\n",
2989                              listentbl[idx].name, strerror (errno) );
2990                   assuan_sock_close (fd);
2991                 }
2992               else if ( !(ctrl->session_env = session_env_new ()))
2993                 {
2994                   log_error ("error allocating session env block for %s: %s\n",
2995                              listentbl[idx].name, strerror (errno) );
2996                   xfree (ctrl);
2997                   assuan_sock_close (fd);
2998                 }
2999               else
3000                 {
3001                   ctrl->thread_startup.fd = fd;
3002                   ret = npth_create (&thread, &tattr,
3003                                      listentbl[idx].func, ctrl);
3004                   if (ret)
3005                     {
3006                       log_error ("error spawning connection handler for %s:"
3007                                  " %s\n", listentbl[idx].name, strerror (ret));
3008                       assuan_sock_close (fd);
3009                       xfree (ctrl);
3010                     }
3011                 }
3012             }
3013         }
3014     }
3015
3016   if (sock_inotify_fd != -1)
3017     close (sock_inotify_fd);
3018   if (home_inotify_fd != -1)
3019     close (home_inotify_fd);
3020   cleanup ();
3021   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
3022   npth_attr_destroy (&tattr);
3023 }
3024
3025
3026
3027 /* Helper for check_own_socket.  */
3028 static gpg_error_t
3029 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3030 {
3031   membuf_t *mb = opaque;
3032   put_membuf (mb, buffer, length);
3033   return 0;
3034 }
3035
3036
3037 /* The thread running the actual check.  We need to run this in a
3038    separate thread so that check_own_thread can be called from the
3039    timer tick.  */
3040 static void *
3041 check_own_socket_thread (void *arg)
3042 {
3043   int rc;
3044   char *sockname = arg;
3045   assuan_context_t ctx = NULL;
3046   membuf_t mb;
3047   char *buffer;
3048
3049   check_own_socket_running++;
3050
3051   rc = assuan_new (&ctx);
3052   if (rc)
3053     {
3054       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3055       goto leave;
3056     }
3057   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3058
3059   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3060   if (rc)
3061     {
3062       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3063       goto leave;
3064     }
3065
3066   init_membuf (&mb, 100);
3067   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3068                         NULL, NULL, NULL, NULL);
3069   put_membuf (&mb, "", 1);
3070   buffer = get_membuf (&mb, NULL);
3071   if (rc || !buffer)
3072     {
3073       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3074                  "GETINFO pid", gpg_strerror (rc));
3075       rc = 1;
3076     }
3077   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3078     {
3079       log_error ("socket is now serviced by another server\n");
3080       rc = 1;
3081     }
3082   else if (opt.verbose > 1)
3083     log_error ("socket is still served by this server\n");
3084
3085   xfree (buffer);
3086
3087  leave:
3088   xfree (sockname);
3089   if (ctx)
3090     assuan_release (ctx);
3091   if (rc)
3092     {
3093       /* We may not remove the socket as it is now in use by another
3094          server. */
3095       inhibit_socket_removal = 1;
3096       shutdown_pending = 2;
3097       log_info ("this process is useless - shutting down\n");
3098     }
3099   check_own_socket_running--;
3100   return NULL;
3101 }
3102
3103
3104 /* Check whether we are still listening on our own socket.  In case
3105    another gpg-agent process started after us has taken ownership of
3106    our socket, we would linger around without any real task.  Thus we
3107    better check once in a while whether we are really needed.  */
3108 static void
3109 check_own_socket (void)
3110 {
3111   char *sockname;
3112   npth_t thread;
3113   npth_attr_t tattr;
3114   int err;
3115
3116   if (disable_check_own_socket)
3117     return;
3118
3119   if (check_own_socket_running || shutdown_pending)
3120     return;  /* Still running or already shutting down.  */
3121
3122   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3123   if (!sockname)
3124     return; /* Out of memory.  */
3125
3126   err = npth_attr_init (&tattr);
3127   if (err)
3128     return;
3129   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3130   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3131   if (err)
3132     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3133   npth_attr_destroy (&tattr);
3134 }
3135
3136
3137
3138 /* Figure out whether an agent is available and running. Prints an
3139    error if not.  If SILENT is true, no messages are printed.
3140    Returns 0 if the agent is running. */
3141 static int
3142 check_for_running_agent (int silent)
3143 {
3144   gpg_error_t err;
3145   char *sockname;
3146   assuan_context_t ctx = NULL;
3147
3148   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3149   if (!sockname)
3150     return gpg_error_from_syserror ();
3151
3152   err = assuan_new (&ctx);
3153   if (!err)
3154     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3155   xfree (sockname);
3156   if (err)
3157     {
3158       if (!silent)
3159         log_error (_("no gpg-agent running in this session\n"));
3160
3161       if (ctx)
3162         assuan_release (ctx);
3163       return -1;
3164     }
3165
3166   if (!opt.quiet && !silent)
3167     log_info ("gpg-agent running and available\n");
3168
3169   assuan_release (ctx);
3170   return 0;
3171 }