agent: Enable restricted, browser, and ssh socket by default.
[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;  /* (1 = points into r/o section)  */
1051       socket_name_extra = GPG_AGENT_EXTRA_SOCK_NAME;
1052     }
1053
1054   if (! opt.browser_socket)
1055     {
1056       opt.browser_socket = 1;  /* (1 = points into r/o section)  */
1057       socket_name_browser = GPG_AGENT_BROWSER_SOCK_NAME;
1058     }
1059
1060   set_debug ();
1061
1062   if (atexit (cleanup))
1063     {
1064       log_error ("atexit failed\n");
1065       cleanup ();
1066       exit (1);
1067     }
1068
1069   initialize_module_cache ();
1070   initialize_module_call_pinentry ();
1071   initialize_module_call_scd ();
1072   initialize_module_trustlist ();
1073
1074   /* Try to create missing directories. */
1075   create_directories ();
1076
1077   if (debug_wait && pipe_server)
1078     {
1079       log_debug ("waiting for debugger - my pid is %u .....\n",
1080                  (unsigned int)getpid());
1081       gnupg_sleep (debug_wait);
1082       log_debug ("... okay\n");
1083     }
1084
1085   if (gpgconf_list == 3)
1086     {
1087       /* We now use the standard socket always - return true for
1088          backward compatibility.  */
1089       agent_exit (0);
1090     }
1091   else if (gpgconf_list == 2)
1092     agent_exit (0);
1093   else if (gpgconf_list)
1094     {
1095       char *filename;
1096       char *filename_esc;
1097
1098       /* List options and default values in the GPG Conf format.  */
1099       filename = make_filename (gnupg_homedir (),
1100                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1101       filename_esc = percent_escape (filename, NULL);
1102
1103       es_printf ("%s-%s.conf:%lu:\"%s\n",
1104                  GPGCONF_NAME, GPG_AGENT_NAME,
1105                  GC_OPT_FLAG_DEFAULT, filename_esc);
1106       xfree (filename);
1107       xfree (filename_esc);
1108
1109       es_printf ("verbose:%lu:\n"
1110               "quiet:%lu:\n"
1111               "debug-level:%lu:\"none:\n"
1112               "log-file:%lu:\n",
1113               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1114               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1115               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1116               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1117       es_printf ("default-cache-ttl:%lu:%d:\n",
1118               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1119       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1120               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1121       es_printf ("max-cache-ttl:%lu:%d:\n",
1122               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1123       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1124               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1125       es_printf ("enforce-passphrase-constraints:%lu:\n",
1126               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1127       es_printf ("min-passphrase-len:%lu:%d:\n",
1128               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1129       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1130               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1131               MIN_PASSPHRASE_NONALPHA);
1132       es_printf ("check-passphrase-pattern:%lu:\n",
1133               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1134       es_printf ("max-passphrase-days:%lu:%d:\n",
1135               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1136               MAX_PASSPHRASE_DAYS);
1137       es_printf ("enable-passphrase-history:%lu:\n",
1138               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1139       es_printf ("no-grab:%lu:\n",
1140               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1141       es_printf ("ignore-cache-for-signing:%lu:\n",
1142               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1143       es_printf ("no-allow-external-cache:%lu:\n",
1144               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1145       es_printf ("no-allow-mark-trusted:%lu:\n",
1146               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1147       es_printf ("disable-scdaemon:%lu:\n",
1148               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1149       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1150 #ifdef HAVE_W32_SYSTEM
1151       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1152 #endif
1153       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1154               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1155       es_printf ("allow-emacs-pinentry:%lu:\n",
1156                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1157       es_printf ("pinentry-timeout:%lu:0:\n",
1158                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1159
1160       agent_exit (0);
1161     }
1162
1163   /* Now start with logging to a file if this is desired. */
1164   if (logfile)
1165     {
1166       log_set_file (logfile);
1167       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1168                              | GPGRT_LOG_WITH_TIME
1169                              | GPGRT_LOG_WITH_PID));
1170       current_logfile = xstrdup (logfile);
1171     }
1172
1173   /* Make sure that we have a default ttyname. */
1174   if (!default_ttyname && gnupg_ttyname (1))
1175     default_ttyname = xstrdup (gnupg_ttyname (1));
1176   if (!default_ttytype && getenv ("TERM"))
1177     default_ttytype = xstrdup (getenv ("TERM"));
1178
1179
1180   if (pipe_server)
1181     {
1182       /* This is the simple pipe based server */
1183       ctrl_t ctrl;
1184
1185       ctrl = xtrycalloc (1, sizeof *ctrl);
1186       if (!ctrl)
1187         {
1188           log_error ("error allocating connection control data: %s\n",
1189                      strerror (errno) );
1190           agent_exit (1);
1191         }
1192       ctrl->session_env = session_env_new ();
1193       if (!ctrl->session_env)
1194         {
1195           log_error ("error allocating session environment block: %s\n",
1196                      strerror (errno) );
1197           xfree (ctrl);
1198           agent_exit (1);
1199         }
1200       agent_init_default_ctrl (ctrl);
1201       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1202       agent_deinit_default_ctrl (ctrl);
1203       xfree (ctrl);
1204     }
1205   else if (!is_daemon)
1206     ; /* NOTREACHED */
1207   else
1208     { /* Regular server mode */
1209       gnupg_fd_t fd;
1210       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1211       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1212       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1213 #ifndef HAVE_W32_SYSTEM
1214       pid_t pid;
1215 #endif
1216
1217       /* Remove the DISPLAY variable so that a pinentry does not
1218          default to a specific display.  There is still a default
1219          display when gpg-agent was started using --display or a
1220          client requested this using an OPTION command.  Note, that we
1221          don't do this when running in reverse daemon mode (i.e. when
1222          exec the program given as arguments). */
1223 #ifndef HAVE_W32_SYSTEM
1224       if (!opt.keep_display && !argc)
1225         gnupg_unsetenv ("DISPLAY");
1226 #endif
1227
1228       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1229          always try to interact with Emacs.  The variable is set when
1230          a client requested this using an OPTION command.  */
1231       gnupg_unsetenv ("INSIDE_EMACS");
1232
1233       /* Create the sockets.  */
1234       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1235       fd = create_server_socket (socket_name, 1, 0,
1236                                  &redir_socket_name, &socket_nonce);
1237
1238       if (opt.extra_socket)
1239         {
1240           socket_name_extra = create_socket_name (socket_name_extra, 0);
1241           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1242           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1243                                            &redir_socket_name_extra,
1244                                            &socket_nonce_extra);
1245         }
1246
1247       if (opt.browser_socket)
1248         {
1249           socket_name_browser = create_socket_name (socket_name_browser, 0);
1250           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1251           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1252                                              &redir_socket_name_browser,
1253                                              &socket_nonce_browser);
1254         }
1255
1256       socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1257       fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1258                                      &redir_socket_name_ssh,
1259                                      &socket_nonce_ssh);
1260
1261       /* If we are going to exec a program in the parent, we record
1262          the PID, so that the child may check whether the program is
1263          still alive. */
1264       if (argc)
1265         parent_pid = getpid ();
1266
1267       fflush (NULL);
1268 #ifdef HAVE_W32_SYSTEM
1269       (void)csh_style;
1270       (void)nodetach;
1271 #else /*!HAVE_W32_SYSTEM*/
1272       pid = fork ();
1273       if (pid == (pid_t)-1)
1274         {
1275           log_fatal ("fork failed: %s\n", strerror (errno) );
1276           exit (1);
1277         }
1278       else if (pid)
1279         { /* We are the parent */
1280           char *infostr_ssh_sock, *infostr_ssh_valid;
1281
1282           /* Close the socket FD. */
1283           close (fd);
1284
1285           /* The signal mask might not be correct right now and thus
1286              we restore it.  That is not strictly necessary but some
1287              programs falsely assume a cleared signal mask.  */
1288
1289 #ifdef HAVE_SIGPROCMASK
1290           if (startup_signal_mask_valid)
1291             {
1292               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1293                 log_error ("error restoring signal mask: %s\n",
1294                            strerror (errno));
1295             }
1296           else
1297             log_info ("no saved signal mask\n");
1298 #endif /*HAVE_SIGPROCMASK*/
1299
1300           /* Create the SSH info string if enabled. */
1301           if (ssh_support)
1302             {
1303               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1304                             socket_name_ssh) < 0)
1305                 {
1306                   log_error ("out of core\n");
1307                   kill (pid, SIGTERM);
1308                   exit (1);
1309                 }
1310               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1311                             (unsigned long)getpid()) < 0)
1312                 {
1313                   log_error ("out of core\n");
1314                   kill (pid, SIGTERM);
1315                   exit (1);
1316                 }
1317             }
1318
1319           *socket_name = 0; /* Don't let cleanup() remove the socket -
1320                                the child should do this from now on */
1321           if (opt.extra_socket)
1322             *socket_name_extra = 0;
1323           if (opt.browser_socket)
1324             *socket_name_browser = 0;
1325           *socket_name_ssh = 0;
1326
1327           if (argc)
1328             { /* Run the program given on the commandline.  */
1329               if (ssh_support && (putenv (infostr_ssh_sock)
1330                                   || putenv (infostr_ssh_valid)))
1331                 {
1332                   log_error ("failed to set environment: %s\n",
1333                              strerror (errno) );
1334                   kill (pid, SIGTERM );
1335                   exit (1);
1336                 }
1337
1338               /* Close all the file descriptors except the standard
1339                  ones and those open at startup.  We explicitly don't
1340                  close 0,1,2 in case something went wrong collecting
1341                  them at startup.  */
1342               close_all_fds (3, startup_fd_list);
1343
1344               /* Run the command.  */
1345               execvp (argv[0], argv);
1346               log_error ("failed to run the command: %s\n", strerror (errno));
1347               kill (pid, SIGTERM);
1348               exit (1);
1349             }
1350           else
1351             {
1352               /* Print the environment string, so that the caller can use
1353                  shell's eval to set it */
1354               if (csh_style)
1355                 {
1356                   if (ssh_support)
1357                     {
1358                       *strchr (infostr_ssh_sock, '=') = ' ';
1359                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1360                     }
1361                 }
1362               else
1363                 {
1364                   if (ssh_support)
1365                     {
1366                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1367                                  infostr_ssh_sock);
1368                     }
1369                 }
1370               if (ssh_support)
1371                 {
1372                   xfree (infostr_ssh_sock);
1373                   xfree (infostr_ssh_valid);
1374                 }
1375               exit (0);
1376             }
1377           /*NOTREACHED*/
1378         } /* End parent */
1379
1380       /*
1381          This is the child
1382        */
1383
1384       /* Detach from tty and put process into a new session */
1385       if (!nodetach )
1386         {
1387           int i;
1388           unsigned int oldflags;
1389
1390           /* Close stdin, stdout and stderr unless it is the log stream */
1391           for (i=0; i <= 2; i++)
1392             {
1393               if (!log_test_fd (i) && i != fd )
1394                 {
1395                   if ( ! close (i)
1396                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1397                     {
1398                       log_error ("failed to open '%s': %s\n",
1399                                  "/dev/null", strerror (errno));
1400                       cleanup ();
1401                       exit (1);
1402                     }
1403                 }
1404             }
1405           if (setsid() == -1)
1406             {
1407               log_error ("setsid() failed: %s\n", strerror(errno) );
1408               cleanup ();
1409               exit (1);
1410             }
1411
1412           log_get_prefix (&oldflags);
1413           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1414           opt.running_detached = 1;
1415         }
1416
1417       if (chdir("/"))
1418         {
1419           log_error ("chdir to / failed: %s\n", strerror (errno));
1420           exit (1);
1421         }
1422
1423       {
1424         struct sigaction sa;
1425
1426         sa.sa_handler = SIG_IGN;
1427         sigemptyset (&sa.sa_mask);
1428         sa.sa_flags = 0;
1429         sigaction (SIGPIPE, &sa, NULL);
1430       }
1431 #endif /*!HAVE_W32_SYSTEM*/
1432
1433       log_info ("%s %s started\n", strusage(11), strusage(13) );
1434       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1435       assuan_sock_close (fd);
1436     }
1437
1438   return 0;
1439 }
1440
1441
1442 /* Exit entry point.  This function should be called instead of a
1443    plain exit.  */
1444 void
1445 agent_exit (int rc)
1446 {
1447   /*FIXME: update_random_seed_file();*/
1448
1449   /* We run our cleanup handler because that may close cipher contexts
1450      stored in secure memory and thus this needs to be done before we
1451      explicitly terminate secure memory.  */
1452   cleanup ();
1453
1454 #if 1
1455   /* at this time a bit annoying */
1456   if (opt.debug & DBG_MEMSTAT_VALUE)
1457     {
1458       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1459       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1460     }
1461   if (opt.debug)
1462     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1463 #endif
1464   gcry_control (GCRYCTL_TERM_SECMEM );
1465   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1466   exit (rc);
1467 }
1468
1469
1470 /* This is our callback function for gcrypt progress messages.  It is
1471    set once at startup and dispatches progress messages to the
1472    corresponding threads of the agent.  */
1473 static void
1474 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1475                              int current, int total)
1476 {
1477   struct progress_dispatch_s *dispatch;
1478   npth_t mytid = npth_self ();
1479
1480   (void)data;
1481
1482   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1483     if (dispatch->ctrl && dispatch->tid == mytid)
1484       break;
1485   if (dispatch && dispatch->cb)
1486     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1487 }
1488
1489
1490 /* If a progress dispatcher callback has been associated with the
1491  * current connection unregister it.  */
1492 static void
1493 unregister_progress_cb (void)
1494 {
1495   struct progress_dispatch_s *dispatch;
1496   npth_t mytid = npth_self ();
1497
1498   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1499     if (dispatch->ctrl && dispatch->tid == mytid)
1500       break;
1501   if (dispatch)
1502     {
1503       dispatch->ctrl = NULL;
1504       dispatch->cb = NULL;
1505     }
1506 }
1507
1508
1509 /* Setup a progress callback CB for the current connection.  Using a
1510  * CB of NULL disables the callback.  */
1511 void
1512 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1513                                   int printchar, int current, int total),
1514                        ctrl_t ctrl)
1515 {
1516   struct progress_dispatch_s *dispatch, *firstfree;
1517   npth_t mytid = npth_self ();
1518
1519   firstfree = NULL;
1520   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1521     {
1522       if (dispatch->ctrl && dispatch->tid == mytid)
1523         break;
1524       if (!dispatch->ctrl && !firstfree)
1525         firstfree = dispatch;
1526     }
1527   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1528     {
1529       if (firstfree)
1530         {
1531           dispatch = firstfree;
1532         }
1533       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1534         {
1535           dispatch->next = progress_dispatch_list;
1536           progress_dispatch_list = dispatch;
1537         }
1538       else
1539         {
1540           log_error ("error allocating new progress dispatcher slot: %s\n",
1541                      gpg_strerror (gpg_error_from_syserror ()));
1542           return;
1543         }
1544       dispatch->ctrl = ctrl;
1545       dispatch->tid = mytid;
1546     }
1547
1548   dispatch->cb = cb;
1549 }
1550
1551
1552 /* Each thread has its own local variables conveyed by a control
1553    structure usually identified by an argument named CTRL.  This
1554    function is called immediately after allocating the control
1555    structure.  Its purpose is to setup the default values for that
1556    structure.  Note that some values may have already been set.  */
1557 static void
1558 agent_init_default_ctrl (ctrl_t ctrl)
1559 {
1560   assert (ctrl->session_env);
1561
1562   /* Note we ignore malloc errors because we can't do much about it
1563      and the request will fail anyway shortly after this
1564      initialization. */
1565   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1566   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1567   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1568   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1569   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1570
1571   if (ctrl->lc_ctype)
1572     xfree (ctrl->lc_ctype);
1573   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1574
1575   if (ctrl->lc_messages)
1576     xfree (ctrl->lc_messages);
1577   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1578                                     /**/ : NULL;
1579   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1580 }
1581
1582
1583 /* Release all resources allocated by default in the control
1584    structure.  This is the counterpart to agent_init_default_ctrl.  */
1585 static void
1586 agent_deinit_default_ctrl (ctrl_t ctrl)
1587 {
1588   unregister_progress_cb ();
1589   session_env_release (ctrl->session_env);
1590
1591   if (ctrl->lc_ctype)
1592     xfree (ctrl->lc_ctype);
1593   if (ctrl->lc_messages)
1594     xfree (ctrl->lc_messages);
1595 }
1596
1597
1598 /* Because the ssh protocol does not send us information about the
1599    current TTY setting, we use this function to use those from startup
1600    or those explicitly set.  This is also used for the restricted mode
1601    where we ignore requests to change the environment.  */
1602 gpg_error_t
1603 agent_copy_startup_env (ctrl_t ctrl)
1604 {
1605   static const char *names[] =
1606     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1607   gpg_error_t err = 0;
1608   int idx;
1609   const char *value;
1610
1611   for (idx=0; !err && names[idx]; idx++)
1612       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1613       err = session_env_setenv (ctrl->session_env, names[idx], value);
1614
1615   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1616     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1617       err = gpg_error_from_syserror ();
1618
1619   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1620     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1621       err = gpg_error_from_syserror ();
1622
1623   if (err)
1624     log_error ("error setting default session environment: %s\n",
1625                gpg_strerror (err));
1626
1627   return err;
1628 }
1629
1630
1631 /* Reread parts of the configuration.  Note, that this function is
1632    obviously not thread-safe and should only be called from the PTH
1633    signal handler.
1634
1635    Fixme: Due to the way the argument parsing works, we create a
1636    memory leak here for all string type arguments.  There is currently
1637    no clean way to tell whether the memory for the argument has been
1638    allocated or points into the process' original arguments.  Unless
1639    we have a mechanism to tell this, we need to live on with this. */
1640 static void
1641 reread_configuration (void)
1642 {
1643   ARGPARSE_ARGS pargs;
1644   FILE *fp;
1645   unsigned int configlineno = 0;
1646   int dummy;
1647
1648   if (!config_filename)
1649     return; /* No config file. */
1650
1651   fp = fopen (config_filename, "r");
1652   if (!fp)
1653     {
1654       log_info (_("option file '%s': %s\n"),
1655                 config_filename, strerror(errno) );
1656       return;
1657     }
1658
1659   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1660
1661   memset (&pargs, 0, sizeof pargs);
1662   dummy = 0;
1663   pargs.argc = &dummy;
1664   pargs.flags = 1;  /* do not remove the args */
1665   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1666     {
1667       if (pargs.r_opt < -1)
1668         pargs.err = 1; /* Print a warning. */
1669       else /* Try to parse this option - ignore unchangeable ones. */
1670         parse_rereadable_options (&pargs, 1);
1671     }
1672   fclose (fp);
1673   finalize_rereadable_options ();
1674   set_debug ();
1675 }
1676
1677
1678 /* Return the file name of the socket we are using for native
1679    requests.  */
1680 const char *
1681 get_agent_socket_name (void)
1682 {
1683   const char *s = socket_name;
1684
1685   return (s && *s)? s : NULL;
1686 }
1687
1688 /* Return the file name of the socket we are using for SSH
1689    requests.  */
1690 const char *
1691 get_agent_ssh_socket_name (void)
1692 {
1693   const char *s = socket_name_ssh;
1694
1695   return (s && *s)? s : NULL;
1696 }
1697
1698
1699 /* Return the number of active connections. */
1700 int
1701 get_agent_active_connection_count (void)
1702 {
1703   return active_connections;
1704 }
1705
1706
1707 /* Under W32, this function returns the handle of the scdaemon
1708    notification event.  Calling it the first time creates that
1709    event.  */
1710 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1711 void *
1712 get_agent_scd_notify_event (void)
1713 {
1714   static HANDLE the_event = INVALID_HANDLE_VALUE;
1715
1716   if (the_event == INVALID_HANDLE_VALUE)
1717     {
1718       HANDLE h, h2;
1719       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1720
1721       /* We need to use a manual reset event object due to the way our
1722          w32-pth wait function works: If we would use an automatic
1723          reset event we are not able to figure out which handle has
1724          been signaled because at the time we single out the signaled
1725          handles using WFSO the event has already been reset due to
1726          the WFMO.  */
1727       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1728       if (!h)
1729         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1730       else if (!DuplicateHandle (GetCurrentProcess(), h,
1731                                  GetCurrentProcess(), &h2,
1732                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1733         {
1734           log_error ("setting syncronize for scd notify event failed: %s\n",
1735                      w32_strerror (-1) );
1736           CloseHandle (h);
1737         }
1738       else
1739         {
1740           CloseHandle (h);
1741           the_event = h2;
1742         }
1743     }
1744
1745   return the_event;
1746 }
1747 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1748
1749
1750
1751 /* Create a name for the socket in the home directory as using
1752    STANDARD_NAME.  We also check for valid characters as well as
1753    against a maximum allowed length for a unix domain socket is done.
1754    The function terminates the process in case of an error.  Returns:
1755    Pointer to an allocated string with the absolute name of the socket
1756    used.  */
1757 static char *
1758 create_socket_name (char *standard_name, int with_homedir)
1759 {
1760   char *name;
1761
1762   if (with_homedir)
1763     name = make_filename (gnupg_socketdir (), standard_name, NULL);
1764   else
1765     name = make_filename (standard_name, NULL);
1766   if (strchr (name, PATHSEP_C))
1767     {
1768       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1769       agent_exit (2);
1770     }
1771   return name;
1772 }
1773
1774
1775
1776 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1777    or terminates the process in case of an error.  Note that this
1778    function needs to be used for the regular socket first (indicated
1779    by PRIMARY) and only then for the extra and the ssh sockets.  If
1780    the socket has been redirected the name of the real socket is
1781    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
1782    Cygwin compatible socket is created (Windows only). */
1783 static gnupg_fd_t
1784 create_server_socket (char *name, int primary, int cygwin,
1785                       char **r_redir_name, assuan_sock_nonce_t *nonce)
1786 {
1787   struct sockaddr *addr;
1788   struct sockaddr_un *unaddr;
1789   socklen_t len;
1790   gnupg_fd_t fd;
1791   int rc;
1792
1793   xfree (*r_redir_name);
1794   *r_redir_name = NULL;
1795
1796   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1797   if (fd == ASSUAN_INVALID_FD)
1798     {
1799       log_error (_("can't create socket: %s\n"), strerror (errno));
1800       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1801       agent_exit (2);
1802     }
1803
1804   if (cygwin)
1805     assuan_sock_set_flag (fd, "cygwin", 1);
1806
1807   unaddr = xmalloc (sizeof *unaddr);
1808   addr = (struct sockaddr*)unaddr;
1809
1810   {
1811     int redirected;
1812
1813     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1814       {
1815         if (errno == ENAMETOOLONG)
1816           log_error (_("socket name '%s' is too long\n"), name);
1817         else
1818           log_error ("error preparing socket '%s': %s\n",
1819                      name, gpg_strerror (gpg_error_from_syserror ()));
1820         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1821         agent_exit (2);
1822       }
1823     if (redirected)
1824       {
1825         *r_redir_name = xstrdup (unaddr->sun_path);
1826         if (opt.verbose)
1827           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1828       }
1829   }
1830
1831   len = SUN_LEN (unaddr);
1832   rc = assuan_sock_bind (fd, addr, len);
1833
1834   /* Our error code mapping on W32CE returns EEXIST thus we also test
1835      for this. */
1836   if (rc == -1
1837       && (errno == EADDRINUSE
1838 #ifdef HAVE_W32_SYSTEM
1839           || errno == EEXIST
1840 #endif
1841           ))
1842     {
1843       /* Check whether a gpg-agent is already running.  We do this
1844          test only if this is the primary socket.  For secondary
1845          sockets we assume that a test for gpg-agent has already been
1846          done and reuse the requested socket.  Testing the ssh-socket
1847          is not possible because at this point, though we know the new
1848          Assuan socket, the Assuan server and thus the ssh-agent
1849          server is not yet operational; this would lead to a hang.  */
1850       if (primary && !check_for_running_agent (1))
1851         {
1852           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
1853           log_set_file (NULL);
1854           log_error (_("a gpg-agent is already running - "
1855                        "not starting a new one\n"));
1856           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1857           assuan_sock_close (fd);
1858           agent_exit (2);
1859         }
1860       gnupg_remove (unaddr->sun_path);
1861       rc = assuan_sock_bind (fd, addr, len);
1862     }
1863   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1864     log_error (_("error getting nonce for the socket\n"));
1865   if (rc == -1)
1866     {
1867       /* We use gpg_strerror here because it allows us to get strings
1868          for some W32 socket error codes.  */
1869       log_error (_("error binding socket to '%s': %s\n"),
1870                  unaddr->sun_path,
1871                  gpg_strerror (gpg_error_from_syserror ()));
1872
1873       assuan_sock_close (fd);
1874       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1875       agent_exit (2);
1876     }
1877
1878   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
1879     log_error (_("can't set permissions of '%s': %s\n"),
1880                unaddr->sun_path, strerror (errno));
1881
1882   if (listen (FD2INT(fd), 5 ) == -1)
1883     {
1884       log_error (_("listen() failed: %s\n"), strerror (errno));
1885       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1886       assuan_sock_close (fd);
1887       agent_exit (2);
1888     }
1889
1890   if (opt.verbose)
1891     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1892
1893   return fd;
1894 }
1895
1896
1897 /* Check that the directory for storing the private keys exists and
1898    create it if not.  This function won't fail as it is only a
1899    convenience function and not strictly necessary.  */
1900 static void
1901 create_private_keys_directory (const char *home)
1902 {
1903   char *fname;
1904   struct stat statbuf;
1905
1906   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1907   if (stat (fname, &statbuf) && errno == ENOENT)
1908     {
1909       if (gnupg_mkdir (fname, "-rwx"))
1910         log_error (_("can't create directory '%s': %s\n"),
1911                    fname, strerror (errno) );
1912       else if (!opt.quiet)
1913         log_info (_("directory '%s' created\n"), fname);
1914     }
1915   if (gnupg_chmod (fname, "-rwx"))
1916     log_error (_("can't set permissions of '%s': %s\n"),
1917                fname, strerror (errno));
1918   xfree (fname);
1919 }
1920
1921
1922 /* Create the directory only if the supplied directory name is the
1923    same as the default one.  This way we avoid to create arbitrary
1924    directories when a non-default home directory is used.  To cope
1925    with HOME, we compare only the suffix if we see that the default
1926    homedir does start with a tilde.  We don't stop here in case of
1927    problems because other functions will throw an error anyway.*/
1928 static void
1929 create_directories (void)
1930 {
1931   struct stat statbuf;
1932   const char *defhome = standard_homedir ();
1933   char *home;
1934
1935   home = make_filename (gnupg_homedir (), NULL);
1936   if ( stat (home, &statbuf) )
1937     {
1938       if (errno == ENOENT)
1939         {
1940           if (
1941 #ifdef HAVE_W32_SYSTEM
1942               ( !compare_filenames (home, defhome) )
1943 #else
1944               (*defhome == '~'
1945                 && (strlen (home) >= strlen (defhome+1)
1946                     && !strcmp (home + strlen(home)
1947                                 - strlen (defhome+1), defhome+1)))
1948                || (*defhome != '~' && !strcmp (home, defhome) )
1949 #endif
1950                )
1951             {
1952               if (gnupg_mkdir (home, "-rwx"))
1953                 log_error (_("can't create directory '%s': %s\n"),
1954                            home, strerror (errno) );
1955               else
1956                 {
1957                   if (!opt.quiet)
1958                     log_info (_("directory '%s' created\n"), home);
1959                   create_private_keys_directory (home);
1960                 }
1961             }
1962         }
1963       else
1964         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1965     }
1966   else if ( !S_ISDIR(statbuf.st_mode))
1967     {
1968       log_error (_("can't use '%s' as home directory\n"), home);
1969     }
1970   else /* exists and is a directory. */
1971     {
1972       create_private_keys_directory (home);
1973     }
1974   xfree (home);
1975 }
1976
1977
1978
1979 /* This is the worker for the ticker.  It is called every few seconds
1980    and may only do fast operations. */
1981 static void
1982 handle_tick (void)
1983 {
1984   static time_t last_minute;
1985
1986   if (!last_minute)
1987     last_minute = time (NULL);
1988
1989   /* Check whether the scdaemon has died and cleanup in this case. */
1990   agent_scd_check_aliveness ();
1991
1992   /* If we are running as a child of another process, check whether
1993      the parent is still alive and shutdown if not. */
1994 #ifndef HAVE_W32_SYSTEM
1995   if (parent_pid != (pid_t)(-1))
1996     {
1997       if (kill (parent_pid, 0))
1998         {
1999           shutdown_pending = 2;
2000           log_info ("parent process died - shutting down\n");
2001           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2002           cleanup ();
2003           agent_exit (0);
2004         }
2005     }
2006 #endif /*HAVE_W32_SYSTEM*/
2007
2008   /* Code to be run from time to time.  */
2009 #if CHECK_OWN_SOCKET_INTERVAL > 0
2010   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2011     {
2012       check_own_socket ();
2013       last_minute = time (NULL);
2014     }
2015 #endif
2016
2017 }
2018
2019
2020 /* A global function which allows us to call the reload stuff from
2021    other places too.  This is only used when build for W32.  */
2022 void
2023 agent_sighup_action (void)
2024 {
2025   log_info ("SIGHUP received - "
2026             "re-reading configuration and flushing cache\n");
2027
2028   agent_flush_cache ();
2029   reread_configuration ();
2030   agent_reload_trustlist ();
2031   /* We flush the module name cache so that after installing a
2032      "pinentry" binary that one can be used in case the
2033      "pinentry-basic" fallback was in use.  */
2034   gnupg_module_name_flush_some ();
2035 }
2036
2037
2038 /* A helper function to handle SIGUSR2.  */
2039 static void
2040 agent_sigusr2_action (void)
2041 {
2042   if (opt.verbose)
2043     log_info ("SIGUSR2 received - updating card event counter\n");
2044   /* Nothing to check right now.  We only increment a counter.  */
2045   bump_card_eventcounter ();
2046 }
2047
2048
2049 #ifndef HAVE_W32_SYSTEM
2050 /* The signal handler for this program.  It is expected to be run in
2051    its own trhead and not in the context of a signal handler.  */
2052 static void
2053 handle_signal (int signo)
2054 {
2055   switch (signo)
2056     {
2057 #ifndef HAVE_W32_SYSTEM
2058     case SIGHUP:
2059       agent_sighup_action ();
2060       break;
2061
2062     case SIGUSR1:
2063       log_info ("SIGUSR1 received - printing internal information:\n");
2064       /* Fixme: We need to see how to integrate pth dumping into our
2065          logging system.  */
2066       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2067       agent_query_dump_state ();
2068       agent_scd_dump_state ();
2069       break;
2070
2071     case SIGUSR2:
2072       agent_sigusr2_action ();
2073       break;
2074
2075     case SIGTERM:
2076       if (!shutdown_pending)
2077         log_info ("SIGTERM received - shutting down ...\n");
2078       else
2079         log_info ("SIGTERM received - still %i open connections\n",
2080                   active_connections);
2081       shutdown_pending++;
2082       if (shutdown_pending > 2)
2083         {
2084           log_info ("shutdown forced\n");
2085           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2086           cleanup ();
2087           agent_exit (0);
2088         }
2089       break;
2090
2091     case SIGINT:
2092       log_info ("SIGINT received - immediate shutdown\n");
2093       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2094       cleanup ();
2095       agent_exit (0);
2096       break;
2097 #endif
2098     default:
2099       log_info ("signal %d received - no action defined\n", signo);
2100     }
2101 }
2102 #endif
2103
2104 /* Check the nonce on a new connection.  This is a NOP unless we we
2105    are using our Unix domain socket emulation under Windows.  */
2106 static int
2107 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2108 {
2109   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2110     {
2111       log_info (_("error reading nonce on fd %d: %s\n"),
2112                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2113       assuan_sock_close (ctrl->thread_startup.fd);
2114       xfree (ctrl);
2115       return -1;
2116     }
2117   else
2118     return 0;
2119 }
2120
2121
2122 #ifdef HAVE_W32_SYSTEM
2123 /* The window message processing function for Putty.  Warning: This
2124    code runs as a native Windows thread.  Use of our own functions
2125    needs to be bracket with pth_leave/pth_enter. */
2126 static LRESULT CALLBACK
2127 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2128 {
2129   int ret = 0;
2130   int w32rc;
2131   COPYDATASTRUCT *cds;
2132   const char *mapfile;
2133   HANDLE maphd;
2134   PSID mysid = NULL;
2135   PSID mapsid = NULL;
2136   void *data = NULL;
2137   PSECURITY_DESCRIPTOR psd = NULL;
2138   ctrl_t ctrl = NULL;
2139
2140   if (msg != WM_COPYDATA)
2141     {
2142       return DefWindowProc (hwnd, msg, wparam, lparam);
2143     }
2144
2145   cds = (COPYDATASTRUCT*)lparam;
2146   if (cds->dwData != PUTTY_IPC_MAGIC)
2147     return 0;  /* Ignore data with the wrong magic.  */
2148   mapfile = cds->lpData;
2149   if (!cds->cbData || mapfile[cds->cbData - 1])
2150     return 0;  /* Ignore empty and non-properly terminated strings.  */
2151
2152   if (DBG_IPC)
2153     {
2154       npth_protect ();
2155       log_debug ("ssh map file '%s'", mapfile);
2156       npth_unprotect ();
2157     }
2158
2159   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2160   if (DBG_IPC)
2161     {
2162       npth_protect ();
2163       log_debug ("ssh map handle %p\n", maphd);
2164       npth_unprotect ();
2165     }
2166
2167   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2168     return 0;
2169
2170   npth_protect ();
2171
2172   mysid = w32_get_user_sid ();
2173   if (!mysid)
2174     {
2175       log_error ("error getting my sid\n");
2176       goto leave;
2177     }
2178
2179   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2180                            OWNER_SECURITY_INFORMATION,
2181                            &mapsid, NULL, NULL, NULL,
2182                            &psd);
2183   if (w32rc)
2184     {
2185       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2186       goto leave;
2187     }
2188
2189   if (DBG_IPC)
2190     {
2191       char *sidstr;
2192
2193       if (!ConvertSidToStringSid (mysid, &sidstr))
2194         sidstr = NULL;
2195       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2196       LocalFree (sidstr);
2197       if (!ConvertSidToStringSid (mapsid, &sidstr))
2198         sidstr = NULL;
2199       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2200       LocalFree (sidstr);
2201     }
2202
2203   if (!EqualSid (mysid, mapsid))
2204     {
2205       log_error ("ssh map file has a non-matching sid\n");
2206       goto leave;
2207     }
2208
2209   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2210   if (DBG_IPC)
2211     log_debug ("ssh IPC buffer at %p\n", data);
2212   if (!data)
2213     goto leave;
2214
2215   /* log_printhex ("request:", data, 20); */
2216
2217   ctrl = xtrycalloc (1, sizeof *ctrl);
2218   if (!ctrl)
2219     {
2220       log_error ("error allocating connection control data: %s\n",
2221                  strerror (errno) );
2222       goto leave;
2223     }
2224   ctrl->session_env = session_env_new ();
2225   if (!ctrl->session_env)
2226     {
2227       log_error ("error allocating session environment block: %s\n",
2228                  strerror (errno) );
2229       goto leave;
2230     }
2231
2232   agent_init_default_ctrl (ctrl);
2233   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2234     ret = 1; /* Valid ssh message has been constructed.  */
2235   agent_deinit_default_ctrl (ctrl);
2236   /* log_printhex ("  reply:", data, 20); */
2237
2238  leave:
2239   xfree (ctrl);
2240   if (data)
2241     UnmapViewOfFile (data);
2242   xfree (mapsid);
2243   if (psd)
2244     LocalFree (psd);
2245   xfree (mysid);
2246   CloseHandle (maphd);
2247
2248   npth_unprotect ();
2249
2250   return ret;
2251 }
2252 #endif /*HAVE_W32_SYSTEM*/
2253
2254
2255 #ifdef HAVE_W32_SYSTEM
2256 /* The thread handling Putty's IPC requests.  */
2257 static void *
2258 putty_message_thread (void *arg)
2259 {
2260   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2261                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2262   HWND hwnd;
2263   MSG msg;
2264
2265   (void)arg;
2266
2267   if (opt.verbose)
2268     log_info ("putty message loop thread started\n");
2269
2270   /* The message loop runs as thread independent from our nPth system.
2271      This also means that we need to make sure that we switch back to
2272      our system before calling any no-windows function.  */
2273   npth_unprotect ();
2274
2275   /* First create a window to make sure that a message queue exists
2276      for this thread.  */
2277   if (!RegisterClass (&wndwclass))
2278     {
2279       npth_protect ();
2280       log_error ("error registering Pageant window class");
2281       return NULL;
2282     }
2283   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2284                          0, 0, 0, 0,
2285                          HWND_MESSAGE,  /* hWndParent */
2286                          NULL,          /* hWndMenu   */
2287                          NULL,          /* hInstance  */
2288                          NULL);         /* lpParm     */
2289   if (!hwnd)
2290     {
2291       npth_protect ();
2292       log_error ("error creating Pageant window");
2293       return NULL;
2294     }
2295
2296   while (GetMessage(&msg, NULL, 0, 0))
2297     {
2298       TranslateMessage(&msg);
2299       DispatchMessage(&msg);
2300     }
2301
2302   /* Back to nPth.  */
2303   npth_protect ();
2304
2305   if (opt.verbose)
2306     log_info ("putty message loop thread stopped\n");
2307   return NULL;
2308 }
2309 #endif /*HAVE_W32_SYSTEM*/
2310
2311
2312 static void *
2313 do_start_connection_thread (ctrl_t ctrl)
2314 {
2315   active_connections++;
2316   agent_init_default_ctrl (ctrl);
2317   if (opt.verbose && !DBG_IPC)
2318     log_info (_("handler 0x%lx for fd %d started\n"),
2319               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2320
2321   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2322   if (opt.verbose && !DBG_IPC)
2323     log_info (_("handler 0x%lx for fd %d terminated\n"),
2324               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2325
2326   agent_deinit_default_ctrl (ctrl);
2327   xfree (ctrl);
2328   active_connections--;
2329   return NULL;
2330 }
2331
2332
2333 /* This is the standard connection thread's main function.  */
2334 static void *
2335 start_connection_thread_std (void *arg)
2336 {
2337   ctrl_t ctrl = arg;
2338
2339   if (check_nonce (ctrl, &socket_nonce))
2340     {
2341       log_error ("handler 0x%lx nonce check FAILED\n",
2342                  (unsigned long) npth_self());
2343       return NULL;
2344     }
2345
2346   return do_start_connection_thread (ctrl);
2347 }
2348
2349
2350 /* This is the extra socket connection thread's main function.  */
2351 static void *
2352 start_connection_thread_extra (void *arg)
2353 {
2354   ctrl_t ctrl = arg;
2355
2356   if (check_nonce (ctrl, &socket_nonce_extra))
2357     {
2358       log_error ("handler 0x%lx nonce check FAILED\n",
2359                  (unsigned long) npth_self());
2360       return NULL;
2361     }
2362
2363   ctrl->restricted = 1;
2364   return do_start_connection_thread (ctrl);
2365 }
2366
2367
2368 /* This is the browser socket connection thread's main function.  */
2369 static void *
2370 start_connection_thread_browser (void *arg)
2371 {
2372   ctrl_t ctrl = arg;
2373
2374   if (check_nonce (ctrl, &socket_nonce_browser))
2375     {
2376       log_error ("handler 0x%lx nonce check FAILED\n",
2377                  (unsigned long) npth_self());
2378       return NULL;
2379     }
2380
2381   ctrl->restricted = 2;
2382   return do_start_connection_thread (ctrl);
2383 }
2384
2385
2386 /* This is the ssh connection thread's main function.  */
2387 static void *
2388 start_connection_thread_ssh (void *arg)
2389 {
2390   ctrl_t ctrl = arg;
2391
2392   if (check_nonce (ctrl, &socket_nonce_ssh))
2393     return NULL;
2394
2395   active_connections++;
2396   agent_init_default_ctrl (ctrl);
2397   if (opt.verbose)
2398     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2399               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2400
2401   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2402   if (opt.verbose)
2403     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2404               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2405
2406   agent_deinit_default_ctrl (ctrl);
2407   xfree (ctrl);
2408   active_connections--;
2409   return NULL;
2410 }
2411
2412
2413 #ifdef HAVE_INOTIFY_INIT
2414 /* Read an inotify event and return true if it matches NAME.  */
2415 static int
2416 my_inotify_is_name (int fd, const char *name)
2417 {
2418   union {
2419     struct inotify_event ev;
2420     char _buf[sizeof (struct inotify_event) + 100 + 1];
2421   } buf;
2422   int n;
2423
2424   n = npth_read (fd, &buf, sizeof buf);
2425   if (n < sizeof (struct inotify_event))
2426     return 0;
2427   if (buf.ev.len < strlen (name)+1)
2428     return 0;
2429   if (strcmp (buf.ev.name, name))
2430     return 0; /* Not the desired file.  */
2431
2432   return 1; /* Found.  */
2433 }
2434 #endif /*HAVE_INOTIFY_INIT*/
2435
2436
2437
2438 /* Connection handler loop.  Wait for connection requests and spawn a
2439    thread after accepting a connection.  */
2440 static void
2441 handle_connections (gnupg_fd_t listen_fd,
2442                     gnupg_fd_t listen_fd_extra,
2443                     gnupg_fd_t listen_fd_browser,
2444                     gnupg_fd_t listen_fd_ssh)
2445 {
2446   npth_attr_t tattr;
2447   struct sockaddr_un paddr;
2448   socklen_t plen;
2449   fd_set fdset, read_fdset;
2450   int ret;
2451   gnupg_fd_t fd;
2452   int nfd;
2453   int saved_errno;
2454   struct timespec abstime;
2455   struct timespec curtime;
2456   struct timespec timeout;
2457 #ifdef HAVE_W32_SYSTEM
2458   HANDLE events[2];
2459   unsigned int events_set;
2460 #endif
2461 #ifdef HAVE_INOTIFY_INIT
2462   int my_inotify_fd;
2463 #endif /*HAVE_INOTIFY_INIT*/
2464   struct {
2465     const char *name;
2466     void *(*func) (void *arg);
2467     gnupg_fd_t l_fd;
2468   } listentbl[] = {
2469     { "std",     start_connection_thread_std   },
2470     { "extra",   start_connection_thread_extra },
2471     { "browser", start_connection_thread_browser },
2472     { "ssh",    start_connection_thread_ssh   }
2473   };
2474
2475
2476   ret = npth_attr_init(&tattr);
2477   if (ret)
2478     log_fatal ("error allocating thread attributes: %s\n",
2479                strerror (ret));
2480   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2481
2482 #ifndef HAVE_W32_SYSTEM
2483   npth_sigev_init ();
2484   npth_sigev_add (SIGHUP);
2485   npth_sigev_add (SIGUSR1);
2486   npth_sigev_add (SIGUSR2);
2487   npth_sigev_add (SIGINT);
2488   npth_sigev_add (SIGTERM);
2489   npth_sigev_fini ();
2490 #else
2491 # ifdef HAVE_W32CE_SYSTEM
2492   /* Use a dummy event. */
2493   sigs = 0;
2494   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2495 # else
2496   events[0] = get_agent_scd_notify_event ();
2497   events[1] = INVALID_HANDLE_VALUE;
2498 # endif
2499 #endif
2500
2501 #ifdef HAVE_INOTIFY_INIT
2502   if (disable_check_own_socket)
2503     my_inotify_fd = -1;
2504   else if ((my_inotify_fd = inotify_init ()) == -1)
2505     log_info ("error enabling fast daemon termination: %s\n",
2506               strerror (errno));
2507   else
2508     {
2509       /* We need to watch the directory for the file because there
2510        * won't be an IN_DELETE_SELF for a socket file.  */
2511       char *slash = strrchr (socket_name, '/');
2512       log_assert (slash && slash[1]);
2513       *slash = 0;
2514       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2515         {
2516           close (my_inotify_fd);
2517           my_inotify_fd = -1;
2518         }
2519       *slash = '/';
2520     }
2521 #endif /*HAVE_INOTIFY_INIT*/
2522
2523   /* On Windows we need to fire up a separate thread to listen for
2524      requests from Putty (an SSH client), so we can replace Putty's
2525      Pageant (its ssh-agent implementation). */
2526 #ifdef HAVE_W32_SYSTEM
2527   if (putty_support)
2528     {
2529       npth_t thread;
2530
2531       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2532       if (ret)
2533         {
2534           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2535         }
2536     }
2537 #endif /*HAVE_W32_SYSTEM*/
2538
2539   /* Set a flag to tell call-scd.c that it may enable event
2540      notifications.  */
2541   opt.sigusr2_enabled = 1;
2542
2543   FD_ZERO (&fdset);
2544   FD_SET (FD2INT (listen_fd), &fdset);
2545   nfd = FD2INT (listen_fd);
2546   if (listen_fd_extra != GNUPG_INVALID_FD)
2547     {
2548       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2549       if (FD2INT (listen_fd_extra) > nfd)
2550         nfd = FD2INT (listen_fd_extra);
2551     }
2552   if (listen_fd_browser != GNUPG_INVALID_FD)
2553     {
2554       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2555       if (FD2INT (listen_fd_browser) > nfd)
2556         nfd = FD2INT (listen_fd_browser);
2557     }
2558   if (listen_fd_ssh != GNUPG_INVALID_FD)
2559     {
2560       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2561       if (FD2INT (listen_fd_ssh) > nfd)
2562         nfd = FD2INT (listen_fd_ssh);
2563     }
2564 #ifdef HAVE_INOTIFY_INIT
2565   if (my_inotify_fd != -1)
2566     {
2567       FD_SET (my_inotify_fd, &fdset);
2568       if (my_inotify_fd > nfd)
2569         nfd = my_inotify_fd;
2570     }
2571 #endif /*HAVE_INOTIFY_INIT*/
2572
2573   listentbl[0].l_fd = listen_fd;
2574   listentbl[1].l_fd = listen_fd_extra;
2575   listentbl[2].l_fd = listen_fd_browser;
2576   listentbl[3].l_fd = listen_fd_ssh;
2577
2578   npth_clock_gettime (&abstime);
2579   abstime.tv_sec += TIMERTICK_INTERVAL;
2580
2581   for (;;)
2582     {
2583       /* Shutdown test.  */
2584       if (shutdown_pending)
2585         {
2586           if (active_connections == 0)
2587             break; /* ready */
2588
2589           /* Do not accept new connections but keep on running the
2590              loop to cope with the timer events.  */
2591           FD_ZERO (&fdset);
2592         }
2593
2594       /* POSIX says that fd_set should be implemented as a structure,
2595          thus a simple assignment is fine to copy the entire set.  */
2596       read_fdset = fdset;
2597
2598       npth_clock_gettime (&curtime);
2599       if (!(npth_timercmp (&curtime, &abstime, <)))
2600         {
2601           /* Timeout.  */
2602           handle_tick ();
2603           npth_clock_gettime (&abstime);
2604           abstime.tv_sec += TIMERTICK_INTERVAL;
2605         }
2606       npth_timersub (&abstime, &curtime, &timeout);
2607
2608 #ifndef HAVE_W32_SYSTEM
2609       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2610                           npth_sigev_sigmask ());
2611       saved_errno = errno;
2612
2613       {
2614         int signo;
2615         while (npth_sigev_get_pending (&signo))
2616           handle_signal (signo);
2617       }
2618 #else
2619       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2620                           events, &events_set);
2621       saved_errno = errno;
2622
2623       /* This is valid even if npth_eselect returns an error.  */
2624       if (events_set & 1)
2625         agent_sigusr2_action ();
2626 #endif
2627
2628       if (ret == -1 && saved_errno != EINTR)
2629         {
2630           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2631                      strerror (saved_errno));
2632           npth_sleep (1);
2633           continue;
2634         }
2635       if (ret <= 0)
2636         /* Interrupt or timeout.  Will be handled when calculating the
2637            next timeout.  */
2638         continue;
2639
2640       if (!shutdown_pending)
2641         {
2642           int idx;
2643           ctrl_t ctrl;
2644           npth_t thread;
2645
2646 #ifdef HAVE_INOTIFY_INIT
2647           if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2648               && my_inotify_is_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
2649             {
2650               shutdown_pending = 1;
2651               log_info ("socket file has been removed - shutting down\n");
2652             }
2653 #endif /*HAVE_INOTIFY_INIT*/
2654
2655           for (idx=0; idx < DIM(listentbl); idx++)
2656             {
2657               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2658                 continue;
2659               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2660                 continue;
2661
2662               plen = sizeof paddr;
2663               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2664                                         (struct sockaddr *)&paddr, &plen));
2665               if (fd == GNUPG_INVALID_FD)
2666                 {
2667                   log_error ("accept failed for %s: %s\n",
2668                              listentbl[idx].name, strerror (errno));
2669                 }
2670               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2671                 {
2672                   log_error ("error allocating connection data for %s: %s\n",
2673                              listentbl[idx].name, strerror (errno) );
2674                   assuan_sock_close (fd);
2675                 }
2676               else if ( !(ctrl->session_env = session_env_new ()))
2677                 {
2678                   log_error ("error allocating session env block for %s: %s\n",
2679                              listentbl[idx].name, strerror (errno) );
2680                   xfree (ctrl);
2681                   assuan_sock_close (fd);
2682                 }
2683               else
2684                 {
2685                   ctrl->thread_startup.fd = fd;
2686                   ret = npth_create (&thread, &tattr,
2687                                      listentbl[idx].func, ctrl);
2688                   if (ret)
2689                     {
2690                       log_error ("error spawning connection handler for %s:"
2691                                  " %s\n", listentbl[idx].name, strerror (ret));
2692                       assuan_sock_close (fd);
2693                       xfree (ctrl);
2694                     }
2695                 }
2696               fd = GNUPG_INVALID_FD;
2697             }
2698         }
2699     }
2700
2701 #ifdef HAVE_INOTIFY_INIT
2702   if (my_inotify_fd != -1)
2703     close (my_inotify_fd);
2704 #endif /*HAVE_INOTIFY_INIT*/
2705   cleanup ();
2706   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2707   npth_attr_destroy (&tattr);
2708 }
2709
2710
2711
2712 /* Helper for check_own_socket.  */
2713 static gpg_error_t
2714 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2715 {
2716   membuf_t *mb = opaque;
2717   put_membuf (mb, buffer, length);
2718   return 0;
2719 }
2720
2721
2722 /* The thread running the actual check.  We need to run this in a
2723    separate thread so that check_own_thread can be called from the
2724    timer tick.  */
2725 static void *
2726 check_own_socket_thread (void *arg)
2727 {
2728   int rc;
2729   char *sockname = arg;
2730   assuan_context_t ctx = NULL;
2731   membuf_t mb;
2732   char *buffer;
2733
2734   check_own_socket_running++;
2735
2736   rc = assuan_new (&ctx);
2737   if (rc)
2738     {
2739       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2740       goto leave;
2741     }
2742   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
2743
2744   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2745   if (rc)
2746     {
2747       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2748       goto leave;
2749     }
2750
2751   init_membuf (&mb, 100);
2752   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2753                         NULL, NULL, NULL, NULL);
2754   put_membuf (&mb, "", 1);
2755   buffer = get_membuf (&mb, NULL);
2756   if (rc || !buffer)
2757     {
2758       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2759                  "GETINFO pid", gpg_strerror (rc));
2760       rc = 1;
2761     }
2762   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2763     {
2764       log_error ("socket is now serviced by another server\n");
2765       rc = 1;
2766     }
2767   else if (opt.verbose > 1)
2768     log_error ("socket is still served by this server\n");
2769
2770   xfree (buffer);
2771
2772  leave:
2773   xfree (sockname);
2774   if (ctx)
2775     assuan_release (ctx);
2776   if (rc)
2777     {
2778       /* We may not remove the socket as it is now in use by another
2779          server.  Setting the name to empty does this.  */
2780       if (socket_name)
2781         *socket_name = 0;
2782       if (socket_name_ssh)
2783         *socket_name_ssh = 0;
2784       shutdown_pending = 2;
2785       log_info ("this process is useless - shutting down\n");
2786     }
2787   check_own_socket_running--;
2788   return NULL;
2789 }
2790
2791
2792 /* Check whether we are still listening on our own socket.  In case
2793    another gpg-agent process started after us has taken ownership of
2794    our socket, we would linger around without any real task.  Thus we
2795    better check once in a while whether we are really needed.  */
2796 static void
2797 check_own_socket (void)
2798 {
2799   char *sockname;
2800   npth_t thread;
2801   npth_attr_t tattr;
2802   int err;
2803
2804   if (disable_check_own_socket)
2805     return;
2806
2807   if (check_own_socket_running || shutdown_pending)
2808     return;  /* Still running or already shutting down.  */
2809
2810   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
2811   if (!sockname)
2812     return; /* Out of memory.  */
2813
2814   err = npth_attr_init (&tattr);
2815   if (err)
2816     return;
2817   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2818   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2819   if (err)
2820     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2821   npth_attr_destroy (&tattr);
2822 }
2823
2824
2825
2826 /* Figure out whether an agent is available and running. Prints an
2827    error if not.  If SILENT is true, no messages are printed.
2828    Returns 0 if the agent is running. */
2829 static int
2830 check_for_running_agent (int silent)
2831 {
2832   gpg_error_t err;
2833   char *sockname;
2834   assuan_context_t ctx = NULL;
2835
2836   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
2837   if (!sockname)
2838     return gpg_error_from_syserror ();
2839
2840   err = assuan_new (&ctx);
2841   if (!err)
2842     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2843   xfree (sockname);
2844   if (err)
2845     {
2846       if (!silent)
2847         log_error (_("no gpg-agent running in this session\n"));
2848
2849       if (ctx)
2850         assuan_release (ctx);
2851       return -1;
2852     }
2853
2854   if (!opt.quiet && !silent)
2855     log_info ("gpg-agent running and available\n");
2856
2857   assuan_release (ctx);
2858   return 0;
2859 }