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