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