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