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