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