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