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