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