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