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