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