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