agent,w32: Do not create a useless socket with --enable-putty-support.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000-2007, 2009-2010 Free Software Foundation, Inc.
3  * Copyright (C) 2000-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   oDisplay,
96   oTTYname,
97   oTTYtype,
98   oLCctype,
99   oLCmessages,
100   oXauthority,
101   oScdaemonProgram,
102   oDefCacheTTL,
103   oDefCacheTTLSSH,
104   oMaxCacheTTL,
105   oMaxCacheTTLSSH,
106   oEnforcePassphraseConstraints,
107   oMinPassphraseLen,
108   oMinPassphraseNonalpha,
109   oCheckPassphrasePattern,
110   oMaxPassphraseDays,
111   oEnablePassphraseHistory,
112   oUseStandardSocket,
113   oNoUseStandardSocket,
114   oExtraSocket,
115   oBrowserSocket,
116   oFakedSystemTime,
117
118   oIgnoreCacheForSigning,
119   oAllowMarkTrusted,
120   oNoAllowMarkTrusted,
121   oAllowPresetPassphrase,
122   oAllowLoopbackPinentry,
123   oNoAllowExternalCache,
124   oAllowEmacsPinentry,
125   oKeepTTY,
126   oKeepDISPLAY,
127   oSSHSupport,
128   oPuttySupport,
129   oDisableScdaemon,
130   oDisableCheckOwnSocket,
131   oWriteEnvFile
132 };
133
134
135 #ifndef ENAMETOOLONG
136 # define ENAMETOOLONG EINVAL
137 #endif
138
139
140 static ARGPARSE_OPTS opts[] = {
141
142   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
143   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
144   ARGPARSE_c (aUseStandardSocketP, "use-standard-socket-p", "@"),
145
146   ARGPARSE_group (301, N_("@Options:\n ")),
147
148   ARGPARSE_s_n (oDaemon,  "daemon", N_("run in daemon mode (background)")),
149   ARGPARSE_s_n (oServer,  "server", N_("run in server mode (foreground)")),
150   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
151   ARGPARSE_s_n (oQuiet,   "quiet",     N_("be somewhat more quiet")),
152   ARGPARSE_s_n (oSh,      "sh",        N_("sh-style command output")),
153   ARGPARSE_s_n (oCsh,     "csh",       N_("csh-style command output")),
154   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
155
156   ARGPARSE_s_s (oDebug,      "debug",       "@"),
157   ARGPARSE_s_n (oDebugAll,   "debug-all",   "@"),
158   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
159   ARGPARSE_s_i (oDebugWait,"  debug-wait",  "@"),
160   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
161   ARGPARSE_s_n (oDebugPinentry, "debug-pinentry", "@"),
162
163   ARGPARSE_s_n (oNoDetach,  "no-detach", N_("do not detach from the console")),
164   ARGPARSE_s_n (oNoGrab,    "no-grab",   N_("do not grab keyboard and mouse")),
165   ARGPARSE_s_s (oLogFile,   "log-file",  N_("use a log file for the server")),
166   ARGPARSE_s_s (oPinentryProgram, "pinentry-program",
167                 /* */             N_("|PGM|use PGM as the PIN-Entry program")),
168   ARGPARSE_s_s (oPinentryTouchFile, "pinentry-touch-file", "@"),
169   ARGPARSE_s_s (oScdaemonProgram, "scdaemon-program",
170                 /* */             N_("|PGM|use PGM as the SCdaemon program") ),
171   ARGPARSE_s_n (oDisableScdaemon, "disable-scdaemon",
172                 /* */             N_("do not use the SCdaemon") ),
173   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
174
175   ARGPARSE_s_s (oExtraSocket, "extra-socket",
176                 /* */       N_("|NAME|accept some commands via NAME")),
177
178   ARGPARSE_s_s (oBrowserSocket, "browser-socket", "@"),
179
180   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
181
182   ARGPARSE_s_n (oBatch,      "batch",        "@"),
183   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
184
185   ARGPARSE_s_s (oDisplay,    "display",     "@"),
186   ARGPARSE_s_s (oTTYname,    "ttyname",     "@"),
187   ARGPARSE_s_s (oTTYtype,    "ttytype",     "@"),
188   ARGPARSE_s_s (oLCctype,    "lc-ctype",    "@"),
189   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
190   ARGPARSE_s_s (oXauthority, "xauthority",  "@"),
191   ARGPARSE_s_n (oKeepTTY,    "keep-tty",
192                 /* */        N_("ignore requests to change the TTY")),
193   ARGPARSE_s_n (oKeepDISPLAY, "keep-display",
194                 /* */        N_("ignore requests to change the X display")),
195
196   ARGPARSE_s_u (oDefCacheTTL,    "default-cache-ttl",
197                                  N_("|N|expire cached PINs after N seconds")),
198   ARGPARSE_s_u (oDefCacheTTLSSH, "default-cache-ttl-ssh", "@" ),
199   ARGPARSE_s_u (oMaxCacheTTL,    "max-cache-ttl",         "@" ),
200   ARGPARSE_s_u (oMaxCacheTTLSSH, "max-cache-ttl-ssh",     "@" ),
201
202   ARGPARSE_s_n (oEnforcePassphraseConstraints, "enforce-passphrase-constraints",
203                 /* */                          "@"),
204   ARGPARSE_s_u (oMinPassphraseLen,        "min-passphrase-len", "@"),
205   ARGPARSE_s_u (oMinPassphraseNonalpha,   "min-passphrase-nonalpha", "@"),
206   ARGPARSE_s_s (oCheckPassphrasePattern,  "check-passphrase-pattern", "@"),
207   ARGPARSE_s_u (oMaxPassphraseDays,       "max-passphrase-days", "@"),
208   ARGPARSE_s_n (oEnablePassphraseHistory, "enable-passphrase-history", "@"),
209
210   ARGPARSE_s_n (oIgnoreCacheForSigning, "ignore-cache-for-signing",
211                 /* */    N_("do not use the PIN cache when signing")),
212   ARGPARSE_s_n (oNoAllowExternalCache,  "no-allow-external-cache",
213                 /* */    N_("disallow the use of an external password cache")),
214   ARGPARSE_s_n (oNoAllowMarkTrusted, "no-allow-mark-trusted",
215                 /* */    N_("disallow clients to mark keys as \"trusted\"")),
216   ARGPARSE_s_n (oAllowMarkTrusted,   "allow-mark-trusted", "@"),
217   ARGPARSE_s_n (oAllowPresetPassphrase, "allow-preset-passphrase",
218                 /* */                    N_("allow presetting passphrase")),
219   ARGPARSE_s_n (oAllowLoopbackPinentry, "allow-loopback-pinentry",
220                                    N_("allow caller to override the pinentry")),
221   ARGPARSE_s_n (oAllowEmacsPinentry,  "allow-emacs-pinentry",
222                 /* */    N_("allow passphrase to be prompted through Emacs")),
223
224   ARGPARSE_s_n (oSSHSupport,   "enable-ssh-support", N_("enable ssh support")),
225   ARGPARSE_s_n (oPuttySupport, "enable-putty-support",
226 #ifdef HAVE_W32_SYSTEM
227                 /* */           N_("enable putty support")
228 #else
229                 /* */           "@"
230 #endif
231                 ),
232
233   /* Dummy options for backward compatibility.  */
234   ARGPARSE_o_s (oWriteEnvFile, "write-env-file", "@"),
235   ARGPARSE_s_n (oUseStandardSocket, "use-standard-socket", "@"),
236   ARGPARSE_s_n (oNoUseStandardSocket, "no-use-standard-socket", "@"),
237
238   {0} /* End of list */
239 };
240
241
242 /* The list of supported debug flags.  */
243 static struct debug_flags_s debug_flags [] =
244   {
245     { DBG_COMMAND_VALUE, "command"  },
246     { DBG_MPI_VALUE    , "mpi"     },
247     { DBG_CRYPTO_VALUE , "crypto"  },
248     { DBG_MEMORY_VALUE , "memory"  },
249     { DBG_CACHE_VALUE  , "cache"   },
250     { DBG_MEMSTAT_VALUE, "memstat" },
251     { DBG_HASHING_VALUE, "hashing" },
252     { DBG_IPC_VALUE    , "ipc"     },
253     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
254   };
255
256
257
258 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
259 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
260 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
261 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
262 #define MIN_PASSPHRASE_LEN    (8)
263 #define MIN_PASSPHRASE_NONALPHA (1)
264 #define MAX_PASSPHRASE_DAYS   (0)
265
266 /* The timer tick used for housekeeping stuff.  For Windows we use a
267    longer period as the SetWaitableTimer seems to signal earlier than
268    the 2 seconds.  CHECK_OWN_SOCKET_INTERVAL defines how often we
269    check our own socket in standard socket mode.  If that value is 0
270    we don't check at all.   All values are in seconds. */
271 #if defined(HAVE_W32CE_SYSTEM)
272 # define TIMERTICK_INTERVAL         (60)
273 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
274 #elif defined(HAVE_W32_SYSTEM)
275 # define TIMERTICK_INTERVAL          (4)
276 # define CHECK_OWN_SOCKET_INTERVAL  (60)
277 #else
278 # define TIMERTICK_INTERVAL          (2)
279 # define CHECK_OWN_SOCKET_INTERVAL  (60)
280 #endif
281
282
283 /* Flag indicating that the ssh-agent subsystem has been enabled.  */
284 static int ssh_support;
285
286 #ifdef HAVE_W32_SYSTEM
287 /* Flag indicating that support for Putty has been enabled.  */
288 static int putty_support;
289 /* A magic value used with WM_COPYDATA.  */
290 #define PUTTY_IPC_MAGIC 0x804e50ba
291 /* To avoid surprises we limit the size of the mapped IPC file to this
292    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
293    for the foreseeable future.  */
294 #define PUTTY_IPC_MAXLEN 16384
295 #endif /*HAVE_W32_SYSTEM*/
296
297 /* The list of open file descriptors at startup.  Note that this list
298    has been allocated using the standard malloc.  */
299 static int *startup_fd_list;
300
301 /* The signal mask at startup and a flag telling whether it is valid.  */
302 #ifdef HAVE_SIGPROCMASK
303 static sigset_t startup_signal_mask;
304 static int startup_signal_mask_valid;
305 #endif
306
307 /* Flag to indicate that a shutdown was requested.  */
308 static int shutdown_pending;
309
310 /* Counter for the currently running own socket checks.  */
311 static int check_own_socket_running;
312
313 /* Flags to indicate that check_own_socket shall not be called.  */
314 static int disable_check_own_socket;
315
316 /* It is possible that we are currently running under setuid permissions */
317 static int maybe_setuid = 1;
318
319 /* Name of the communication socket used for native gpg-agent
320    requests. The second variable is either NULL or a malloced string
321    with the real socket name in case it has been redirected.  */
322 static char *socket_name;
323 static char *redir_socket_name;
324
325 /* Name of the optional extra socket used for native gpg-agent requests.  */
326 static char *socket_name_extra;
327 static char *redir_socket_name_extra;
328
329 /* Name of the optional browser socket used for native gpg-agent requests.  */
330 static char *socket_name_browser;
331 static char *redir_socket_name_browser;
332
333 /* Name of the communication socket used for ssh-agent-emulation.  */
334 static char *socket_name_ssh;
335 static char *redir_socket_name_ssh;
336
337 /* We need to keep track of the server's nonces (these are dummies for
338    POSIX systems). */
339 static assuan_sock_nonce_t socket_nonce;
340 static assuan_sock_nonce_t socket_nonce_extra;
341 static assuan_sock_nonce_t socket_nonce_browser;
342 static assuan_sock_nonce_t socket_nonce_ssh;
343
344
345 /* Default values for options passed to the pinentry. */
346 static char *default_display;
347 static char *default_ttyname;
348 static char *default_ttytype;
349 static char *default_lc_ctype;
350 static char *default_lc_messages;
351 static char *default_xauthority;
352
353 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
354 static char *config_filename;
355
356 /* Helper to implement --debug-level */
357 static const char *debug_level;
358
359 /* Keep track of the current log file so that we can avoid updating
360    the log file after a SIGHUP if it didn't changed. Malloced. */
361 static char *current_logfile;
362
363 /* The handle_tick() function may test whether a parent is still
364    running.  We record the PID of the parent here or -1 if it should be
365    watched. */
366 static pid_t parent_pid = (pid_t)(-1);
367
368 /* Number of active connections.  */
369 static int active_connections;
370
371 \f
372 /*
373    Local prototypes.
374  */
375
376 static char *create_socket_name (char *standard_name, int with_homedir);
377 static gnupg_fd_t create_server_socket (char *name, int primary,
378                                         char **r_redir_name,
379                                         assuan_sock_nonce_t *nonce);
380 static void create_directories (void);
381
382 static void agent_init_default_ctrl (ctrl_t ctrl);
383 static void agent_deinit_default_ctrl (ctrl_t ctrl);
384
385 static void handle_connections (gnupg_fd_t listen_fd,
386                                 gnupg_fd_t listen_fd_extra,
387                                 gnupg_fd_t listen_fd_browser,
388                                 gnupg_fd_t listen_fd_ssh);
389 static void check_own_socket (void);
390 static int check_for_running_agent (int silent);
391
392 /* Pth wrapper function definitions. */
393 ASSUAN_SYSTEM_NPTH_IMPL;
394
395 \f
396 /*
397    Functions.
398  */
399
400 /* Allocate a string describing a library version by calling a GETFNC.
401    This function is expected to be called only once.  GETFNC is
402    expected to have a semantic like gcry_check_version ().  */
403 static char *
404 make_libversion (const char *libname, const char *(*getfnc)(const char*))
405 {
406   const char *s;
407   char *result;
408
409   if (maybe_setuid)
410     {
411       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
412       maybe_setuid = 0;
413     }
414   s = getfnc (NULL);
415   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
416   strcpy (stpcpy (stpcpy (result, libname), " "), s);
417   return result;
418 }
419
420 /* Return strings describing this program.  The case values are
421    described in common/argparse.c:strusage.  The values here override
422    the default values given by strusage.  */
423 static const char *
424 my_strusage (int level)
425 {
426   static char *ver_gcry;
427   const char *p;
428
429   switch (level)
430     {
431     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
432       break;
433     case 13: p = VERSION; break;
434     case 17: p = PRINTABLE_OS_NAME; break;
435       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
436          reporting address.  This is so that we can change the
437          reporting address without breaking the translations.  */
438     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
439
440     case 20:
441       if (!ver_gcry)
442         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
443       p = ver_gcry;
444       break;
445
446     case 1:
447     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
448       break;
449     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
450                     "Secret key management for @GNUPG@\n");
451     break;
452
453     default: p = NULL;
454     }
455   return p;
456 }
457
458
459
460 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
461    only the active debug flags are propagated to the subsystems.  With
462    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
463    all flags already set. Note that we don't fail here, because it is
464    important to keep gpg-agent running even after re-reading the
465    options due to a SIGHUP. */
466 static void
467 set_debug (void)
468 {
469   int numok = (debug_level && digitp (debug_level));
470   int numlvl = numok? atoi (debug_level) : 0;
471
472   if (!debug_level)
473     ;
474   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
475     opt.debug = 0;
476   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
477     opt.debug = DBG_IPC_VALUE;
478   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
479     opt.debug = DBG_IPC_VALUE|DBG_COMMAND_VALUE;
480   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
481     opt.debug = (DBG_IPC_VALUE|DBG_COMMAND_VALUE
482                  |DBG_CACHE_VALUE);
483   else if (!strcmp (debug_level, "guru") || numok)
484     {
485       opt.debug = ~0;
486       /* Unless the "guru" string has been used we don't want to allow
487          hashing debugging.  The rationale is that people tend to
488          select the highest debug value and would then clutter their
489          disk with debug files which may reveal confidential data.  */
490       if (numok)
491         opt.debug &= ~(DBG_HASHING_VALUE);
492     }
493   else
494     {
495       log_error (_("invalid debug-level '%s' given\n"), debug_level);
496       opt.debug = 0; /* Reset debugging, so that prior debug
497                         statements won't have an undesired effect. */
498     }
499
500   if (opt.debug && !opt.verbose)
501     opt.verbose = 1;
502   if (opt.debug && opt.quiet)
503     opt.quiet = 0;
504
505   if (opt.debug & DBG_MPI_VALUE)
506     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
507   if (opt.debug & DBG_CRYPTO_VALUE )
508     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
509   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
510
511   if (opt.debug)
512     parse_debug_flag (NULL, &opt.debug, debug_flags);
513 }
514
515
516 /* Helper for cleanup to remove one socket with NAME.  REDIR_NAME is
517    the corresponding real name if the socket has been redirected.  */
518 static void
519 remove_socket (char *name, char *redir_name)
520 {
521   if (name && *name)
522     {
523       char *p;
524
525       if (redir_name)
526         name = redir_name;
527
528       gnupg_remove (name);
529       p = strrchr (name, '/');
530       if (p)
531         {
532           *p = 0;
533           rmdir (name);
534           *p = '/';
535         }
536       *name = 0;
537     }
538 }
539
540
541 /* Cleanup code for this program.  This is either called has an atexit
542    handler or directly.  */
543 static void
544 cleanup (void)
545 {
546   static int done;
547
548   if (done)
549     return;
550   done = 1;
551   deinitialize_module_cache ();
552   remove_socket (socket_name, redir_socket_name);
553   if (opt.extra_socket > 1)
554     remove_socket (socket_name_extra, redir_socket_name_extra);
555   if (opt.browser_socket > 1)
556     remove_socket (socket_name_browser, redir_socket_name_browser);
557   remove_socket (socket_name_ssh, redir_socket_name_ssh);
558 }
559
560
561
562 /* Handle options which are allowed to be reset after program start.
563    Return true when the current option in PARGS could be handled and
564    false if not.  As a special feature, passing a value of NULL for
565    PARGS, resets the options to the default.  REREAD should be set
566    true if it is not the initial option parsing. */
567 static int
568 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
569 {
570   if (!pargs)
571     { /* reset mode */
572       opt.quiet = 0;
573       opt.verbose = 0;
574       opt.debug = 0;
575       opt.no_grab = 0;
576       opt.debug_pinentry = 0;
577       opt.pinentry_program = NULL;
578       opt.pinentry_touch_file = NULL;
579       opt.scdaemon_program = NULL;
580       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
581       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
582       opt.max_cache_ttl = MAX_CACHE_TTL;
583       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
584       opt.enforce_passphrase_constraints = 0;
585       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
586       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
587       opt.check_passphrase_pattern = NULL;
588       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
589       opt.enable_passhrase_history = 0;
590       opt.ignore_cache_for_signing = 0;
591       opt.allow_mark_trusted = 1;
592       opt.allow_external_cache = 1;
593       opt.allow_emacs_pinentry = 0;
594       opt.disable_scdaemon = 0;
595       disable_check_own_socket = 0;
596       return 1;
597     }
598
599   switch (pargs->r_opt)
600     {
601     case oQuiet: opt.quiet = 1; break;
602     case oVerbose: opt.verbose++; break;
603
604     case oDebug:
605       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
606       break;
607     case oDebugAll: opt.debug = ~0; break;
608     case oDebugLevel: debug_level = pargs->r.ret_str; break;
609     case oDebugPinentry: opt.debug_pinentry = 1; break;
610
611     case oLogFile:
612       if (!reread)
613         return 0; /* not handeld */
614       if (!current_logfile || !pargs->r.ret_str
615           || strcmp (current_logfile, pargs->r.ret_str))
616         {
617           log_set_file (pargs->r.ret_str);
618           xfree (current_logfile);
619           current_logfile = xtrystrdup (pargs->r.ret_str);
620         }
621       break;
622
623     case oNoGrab: opt.no_grab = 1; break;
624
625     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
626     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
627     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
628     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
629     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
630
631     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
632     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
633     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
634     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
635
636     case oEnforcePassphraseConstraints:
637       opt.enforce_passphrase_constraints=1;
638       break;
639     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
640     case oMinPassphraseNonalpha:
641       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
642       break;
643     case oCheckPassphrasePattern:
644       opt.check_passphrase_pattern = pargs->r.ret_str;
645       break;
646     case oMaxPassphraseDays:
647       opt.max_passphrase_days = pargs->r.ret_ulong;
648       break;
649     case oEnablePassphraseHistory:
650       opt.enable_passhrase_history = 1;
651       break;
652
653     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
654
655     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
656     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
657
658     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
659
660     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
661
662     case oNoAllowExternalCache: opt.allow_external_cache = 0;
663       break;
664
665     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
666       break;
667
668     default:
669       return 0; /* not handled */
670     }
671
672   return 1; /* handled */
673 }
674
675
676 /* Fixup some options after all have been processed.  */
677 static void
678 finalize_rereadable_options (void)
679 {
680   /* It would be too surprising if the max-cache-ttl is lower than the
681      default-cache-ttl - thus we silently correct that.  */
682   if (opt.def_cache_ttl > opt.max_cache_ttl)
683     opt.max_cache_ttl = opt.def_cache_ttl;
684   if (opt.def_cache_ttl_ssh > opt.max_cache_ttl_ssh)
685     opt.max_cache_ttl_ssh = opt.def_cache_ttl_ssh;
686 }
687
688
689
690 /* The main entry point.  */
691 int
692 main (int argc, char **argv )
693 {
694   ARGPARSE_ARGS pargs;
695   int orig_argc;
696   char **orig_argv;
697   FILE *configfp = NULL;
698   char *configname = NULL;
699   const char *shell;
700   unsigned configlineno;
701   int parse_debug = 0;
702   int default_config =1;
703   int pipe_server = 0;
704   int is_daemon = 0;
705   int nodetach = 0;
706   int csh_style = 0;
707   char *logfile = NULL;
708   int debug_wait = 0;
709   int gpgconf_list = 0;
710   gpg_error_t err;
711   struct assuan_malloc_hooks malloc_hooks;
712
713   early_system_init ();
714
715   /* Before we do anything else we save the list of currently open
716      file descriptors and the signal mask.  This info is required to
717      do the exec call properly. */
718   startup_fd_list = get_all_open_fds ();
719 #ifdef HAVE_SIGPROCMASK
720   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
721     startup_signal_mask_valid = 1;
722 #endif /*HAVE_SIGPROCMASK*/
723
724   /* Set program name etc.  */
725   set_strusage (my_strusage);
726   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
727   /* Please note that we may running SUID(ROOT), so be very CAREFUL
728      when adding any stuff between here and the call to INIT_SECMEM()
729      somewhere after the option parsing */
730   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
731
732   /* Make sure that our subsystems are ready.  */
733   i18n_init ();
734   init_common_subsystems (&argc, &argv);
735
736   npth_init ();
737
738   /* Check that the libraries are suitable.  Do it here because
739      the option parsing may need services of the library. */
740   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
741     {
742       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
743                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
744     }
745
746   malloc_hooks.malloc = gcry_malloc;
747   malloc_hooks.realloc = gcry_realloc;
748   malloc_hooks.free = gcry_free;
749   assuan_set_malloc_hooks (&malloc_hooks);
750   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
751   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
752   assuan_sock_init ();
753   setup_libassuan_logging (&opt.debug);
754
755   setup_libgcrypt_logging ();
756   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
757
758   disable_core_dumps ();
759
760   /* Set default options.  */
761   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
762
763   shell = getenv ("SHELL");
764   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
765     csh_style = 1;
766
767   opt.homedir = default_homedir ();
768
769   /* Record some of the original environment strings. */
770   {
771     const char *s;
772     int idx;
773     static const char *names[] =
774       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
775
776     err = 0;
777     opt.startup_env = session_env_new ();
778     if (!opt.startup_env)
779       err = gpg_error_from_syserror ();
780     for (idx=0; !err && names[idx]; idx++)
781       {
782         s = getenv (names[idx]);
783         if (s)
784           err = session_env_setenv (opt.startup_env, names[idx], s);
785       }
786     if (!err)
787       {
788         s = gnupg_ttyname (0);
789         if (s)
790           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
791       }
792     if (err)
793       log_fatal ("error recording startup environment: %s\n",
794                  gpg_strerror (err));
795
796     /* Fixme: Better use the locale function here.  */
797     opt.startup_lc_ctype = getenv ("LC_CTYPE");
798     if (opt.startup_lc_ctype)
799       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
800     opt.startup_lc_messages = getenv ("LC_MESSAGES");
801     if (opt.startup_lc_messages)
802       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
803   }
804
805   /* Check whether we have a config file on the commandline */
806   orig_argc = argc;
807   orig_argv = argv;
808   pargs.argc = &argc;
809   pargs.argv = &argv;
810   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
811   while (arg_parse( &pargs, opts))
812     {
813       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
814         parse_debug++;
815       else if (pargs.r_opt == oOptions)
816         { /* yes there is one, so we do not try the default one, but
817              read the option file when it is encountered at the
818              commandline */
819           default_config = 0;
820         }
821         else if (pargs.r_opt == oNoOptions)
822           default_config = 0; /* --no-options */
823         else if (pargs.r_opt == oHomedir)
824           opt.homedir = pargs.r.ret_str;
825         else if (pargs.r_opt == oDebugQuickRandom)
826           {
827             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
828           }
829
830     }
831
832   /* Initialize the secure memory. */
833   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
834   maybe_setuid = 0;
835
836   /*
837      Now we are now working under our real uid
838   */
839
840   if (default_config)
841     configname = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
842                                 NULL );
843
844   argc = orig_argc;
845   argv = orig_argv;
846   pargs.argc = &argc;
847   pargs.argv = &argv;
848   pargs.flags=  1;  /* do not remove the args */
849  next_pass:
850   if (configname)
851     {
852       configlineno = 0;
853       configfp = fopen (configname, "r");
854       if (!configfp)
855         {
856           if (default_config)
857             {
858               if( parse_debug )
859                 log_info (_("Note: no default option file '%s'\n"),
860                           configname );
861               /* Save the default conf file name so that
862                  reread_configuration is able to test whether the
863                  config file has been created in the meantime.  */
864               xfree (config_filename);
865               config_filename = configname;
866               configname = NULL;
867             }
868           else
869             {
870               log_error (_("option file '%s': %s\n"),
871                          configname, strerror(errno) );
872               exit(2);
873             }
874           xfree (configname);
875           configname = NULL;
876         }
877       if (parse_debug && configname )
878         log_info (_("reading options from '%s'\n"), configname );
879       default_config = 0;
880     }
881
882   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
883     {
884       if (parse_rereadable_options (&pargs, 0))
885         continue; /* Already handled */
886       switch (pargs.r_opt)
887         {
888         case aGPGConfList: gpgconf_list = 1; break;
889         case aGPGConfTest: gpgconf_list = 2; break;
890         case aUseStandardSocketP: gpgconf_list = 3; break;
891         case oBatch: opt.batch=1; break;
892
893         case oDebugWait: debug_wait = pargs.r.ret_int; break;
894
895         case oOptions:
896           /* config files may not be nested (silently ignore them) */
897           if (!configfp)
898             {
899                 xfree(configname);
900                 configname = xstrdup(pargs.r.ret_str);
901                 goto next_pass;
902             }
903           break;
904         case oNoGreeting: /* Dummy option.  */ break;
905         case oNoVerbose: opt.verbose = 0; break;
906         case oNoOptions: break; /* no-options */
907         case oHomedir: opt.homedir = pargs.r.ret_str; break;
908         case oNoDetach: nodetach = 1; break;
909         case oLogFile: logfile = pargs.r.ret_str; break;
910         case oCsh: csh_style = 1; break;
911         case oSh: csh_style = 0; break;
912         case oServer: pipe_server = 1; break;
913         case oDaemon: is_daemon = 1; break;
914
915         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
916         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
917         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
918         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
919         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
920           break;
921         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
922           break;
923
924         case oUseStandardSocket:
925         case oNoUseStandardSocket:
926           obsolete_option (configname, configlineno, "use-standard-socket");
927           break;
928
929         case oFakedSystemTime:
930           {
931             time_t faked_time = isotime2epoch (pargs.r.ret_str);
932             if (faked_time == (time_t)(-1))
933               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
934             gnupg_set_time (faked_time, 0);
935           }
936           break;
937
938         case oKeepTTY: opt.keep_tty = 1; break;
939         case oKeepDISPLAY: opt.keep_display = 1; break;
940
941         case oSSHSupport:
942           ssh_support = 1;
943           break;
944         case oPuttySupport:
945 #        ifdef HAVE_W32_SYSTEM
946           putty_support = 1;
947 #        endif
948           break;
949
950         case oExtraSocket:
951           opt.extra_socket = 1;  /* (1 = points into argv)  */
952           socket_name_extra = pargs.r.ret_str;
953           break;
954
955         case oBrowserSocket:
956           opt.browser_socket = 1;  /* (1 = points into argv)  */
957           socket_name_browser = pargs.r.ret_str;
958           break;
959
960         case oDebugQuickRandom:
961           /* Only used by the first stage command line parser.  */
962           break;
963
964         case oWriteEnvFile:
965           obsolete_option (configname, configlineno, "write-env-file");
966           break;
967
968         default : pargs.err = configfp? 1:2; break;
969         }
970     }
971   if (configfp)
972     {
973       fclose( configfp );
974       configfp = NULL;
975       /* Keep a copy of the name so that it can be read on SIGHUP. */
976       if (config_filename != configname)
977         {
978           xfree (config_filename);
979           config_filename = configname;
980         }
981       configname = NULL;
982       goto next_pass;
983     }
984
985   xfree (configname);
986   configname = NULL;
987   if (log_get_errorcount(0))
988     exit(2);
989
990   finalize_rereadable_options ();
991
992   /* Turn the homedir into an absolute one. */
993   opt.homedir = make_absfilename (opt.homedir, NULL);
994
995   /* Print a warning if an argument looks like an option.  */
996   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
997     {
998       int i;
999
1000       for (i=0; i < argc; i++)
1001         if (argv[i][0] == '-' && argv[i][1] == '-')
1002           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1003     }
1004
1005 #ifdef ENABLE_NLS
1006   /* gpg-agent usually does not output any messages because it runs in
1007      the background.  For log files it is acceptable to have messages
1008      always encoded in utf-8.  We switch here to utf-8, so that
1009      commands like --help still give native messages.  It is far
1010      easier to switch only once instead of for every message and it
1011      actually helps when more then one thread is active (avoids an
1012      extra copy step). */
1013     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1014 #endif
1015
1016   if (!pipe_server && !is_daemon && !gpgconf_list)
1017     {
1018      /* We have been called without any options and thus we merely
1019         check whether an agent is already running.  We do this right
1020         here so that we don't clobber a logfile with this check but
1021         print the status directly to stderr. */
1022       opt.debug = 0;
1023       set_debug ();
1024       check_for_running_agent (0);
1025       agent_exit (0);
1026     }
1027
1028   set_debug ();
1029
1030   if (atexit (cleanup))
1031     {
1032       log_error ("atexit failed\n");
1033       cleanup ();
1034       exit (1);
1035     }
1036
1037   initialize_module_cache ();
1038   initialize_module_call_pinentry ();
1039   initialize_module_call_scd ();
1040   initialize_module_trustlist ();
1041
1042   /* Try to create missing directories. */
1043   create_directories ();
1044
1045   if (debug_wait && pipe_server)
1046     {
1047       log_debug ("waiting for debugger - my pid is %u .....\n",
1048                  (unsigned int)getpid());
1049       gnupg_sleep (debug_wait);
1050       log_debug ("... okay\n");
1051     }
1052
1053   if (gpgconf_list == 3)
1054     {
1055       /* We now use the standard socket always - return true for
1056          backward compatibility.  */
1057       agent_exit (0);
1058     }
1059   else if (gpgconf_list == 2)
1060     agent_exit (0);
1061   else if (gpgconf_list)
1062     {
1063       char *filename;
1064       char *filename_esc;
1065
1066       /* List options and default values in the GPG Conf format.  */
1067       filename = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
1068                                 NULL );
1069       filename_esc = percent_escape (filename, NULL);
1070
1071       es_printf ("%s-%s.conf:%lu:\"%s\n",
1072                  GPGCONF_NAME, GPG_AGENT_NAME,
1073                  GC_OPT_FLAG_DEFAULT, filename_esc);
1074       xfree (filename);
1075       xfree (filename_esc);
1076
1077       es_printf ("verbose:%lu:\n"
1078               "quiet:%lu:\n"
1079               "debug-level:%lu:\"none:\n"
1080               "log-file:%lu:\n",
1081               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1082               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1083               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1084               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1085       es_printf ("default-cache-ttl:%lu:%d:\n",
1086               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1087       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1088               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1089       es_printf ("max-cache-ttl:%lu:%d:\n",
1090               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1091       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1092               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1093       es_printf ("enforce-passphrase-constraints:%lu:\n",
1094               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1095       es_printf ("min-passphrase-len:%lu:%d:\n",
1096               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1097       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1098               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1099               MIN_PASSPHRASE_NONALPHA);
1100       es_printf ("check-passphrase-pattern:%lu:\n",
1101               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1102       es_printf ("max-passphrase-days:%lu:%d:\n",
1103               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1104               MAX_PASSPHRASE_DAYS);
1105       es_printf ("enable-passphrase-history:%lu:\n",
1106               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1107       es_printf ("no-grab:%lu:\n",
1108               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1109       es_printf ("ignore-cache-for-signing:%lu:\n",
1110               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1111       es_printf ("no-allow-external-cache:%lu:\n",
1112               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1113       es_printf ("no-allow-mark-trusted:%lu:\n",
1114               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1115       es_printf ("disable-scdaemon:%lu:\n",
1116               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1117       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1118 #ifdef HAVE_W32_SYSTEM
1119       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1120 #endif
1121       es_printf ("allow-loopback-pinentry:%lu:\n",
1122                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1123       es_printf ("allow-emacs-pinentry:%lu:\n",
1124                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1125
1126       agent_exit (0);
1127     }
1128
1129   /* Now start with logging to a file if this is desired. */
1130   if (logfile)
1131     {
1132       log_set_file (logfile);
1133       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1134                              | GPGRT_LOG_WITH_TIME
1135                              | GPGRT_LOG_WITH_PID));
1136       current_logfile = xstrdup (logfile);
1137     }
1138
1139   /* Make sure that we have a default ttyname. */
1140   if (!default_ttyname && gnupg_ttyname (1))
1141     default_ttyname = xstrdup (gnupg_ttyname (1));
1142   if (!default_ttytype && getenv ("TERM"))
1143     default_ttytype = xstrdup (getenv ("TERM"));
1144
1145
1146   if (pipe_server)
1147     {
1148       /* This is the simple pipe based server */
1149       ctrl_t ctrl;
1150
1151       ctrl = xtrycalloc (1, sizeof *ctrl);
1152       if (!ctrl)
1153         {
1154           log_error ("error allocating connection control data: %s\n",
1155                      strerror (errno) );
1156           agent_exit (1);
1157         }
1158       ctrl->session_env = session_env_new ();
1159       if (!ctrl->session_env)
1160         {
1161           log_error ("error allocating session environment block: %s\n",
1162                      strerror (errno) );
1163           xfree (ctrl);
1164           agent_exit (1);
1165         }
1166       agent_init_default_ctrl (ctrl);
1167       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1168       agent_deinit_default_ctrl (ctrl);
1169       xfree (ctrl);
1170     }
1171   else if (!is_daemon)
1172     ; /* NOTREACHED */
1173   else
1174     { /* Regular server mode */
1175       gnupg_fd_t fd;
1176       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1177       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1178       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1179       pid_t pid;
1180
1181       /* Remove the DISPLAY variable so that a pinentry does not
1182          default to a specific display.  There is still a default
1183          display when gpg-agent was started using --display or a
1184          client requested this using an OPTION command.  Note, that we
1185          don't do this when running in reverse daemon mode (i.e. when
1186          exec the program given as arguments). */
1187 #ifndef HAVE_W32_SYSTEM
1188       if (!opt.keep_display && !argc)
1189         gnupg_unsetenv ("DISPLAY");
1190 #endif
1191
1192       /* Create the sockets.  */
1193       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1194       fd = create_server_socket (socket_name, 1,
1195                                  &redir_socket_name, &socket_nonce);
1196
1197       if (opt.extra_socket)
1198         {
1199           socket_name_extra = create_socket_name (socket_name_extra, 0);
1200           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1201           fd_extra = create_server_socket (socket_name_extra, 0,
1202                                            &redir_socket_name_extra,
1203                                            &socket_nonce_extra);
1204         }
1205
1206       if (opt.browser_socket)
1207         {
1208           socket_name_browser = create_socket_name (socket_name_browser, 0);
1209           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1210           fd_browser = create_server_socket (socket_name_browser, 0,
1211                                              &redir_socket_name_browser,
1212                                              &socket_nonce_browser);
1213         }
1214
1215       if (ssh_support)
1216         {
1217           socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1218           fd_ssh = create_server_socket (socket_name_ssh, 0,
1219                                          &redir_socket_name_ssh,
1220                                          &socket_nonce_ssh);
1221         }
1222
1223       /* If we are going to exec a program in the parent, we record
1224          the PID, so that the child may check whether the program is
1225          still alive. */
1226       if (argc)
1227         parent_pid = getpid ();
1228
1229       fflush (NULL);
1230 #ifdef HAVE_W32_SYSTEM
1231       (void)csh_style;
1232       (void)nodetach;
1233       pid = getpid ();
1234 #else /*!HAVE_W32_SYSTEM*/
1235       pid = fork ();
1236       if (pid == (pid_t)-1)
1237         {
1238           log_fatal ("fork failed: %s\n", strerror (errno) );
1239           exit (1);
1240         }
1241       else if (pid)
1242         { /* We are the parent */
1243           char *infostr_ssh_sock, *infostr_ssh_valid;
1244
1245           /* Close the socket FD. */
1246           close (fd);
1247
1248           /* The signal mask might not be correct right now and thus
1249              we restore it.  That is not strictly necessary but some
1250              programs falsely assume a cleared signal mask.  */
1251
1252 #ifdef HAVE_SIGPROCMASK
1253           if (startup_signal_mask_valid)
1254             {
1255               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1256                 log_error ("error restoring signal mask: %s\n",
1257                            strerror (errno));
1258             }
1259           else
1260             log_info ("no saved signal mask\n");
1261 #endif /*HAVE_SIGPROCMASK*/
1262
1263           /* Create the SSH info string if enabled. */
1264           if (ssh_support)
1265             {
1266               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1267                             socket_name_ssh) < 0)
1268                 {
1269                   log_error ("out of core\n");
1270                   kill (pid, SIGTERM);
1271                   exit (1);
1272                 }
1273               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1274                             (unsigned long)getpid()) < 0)
1275                 {
1276                   log_error ("out of core\n");
1277                   kill (pid, SIGTERM);
1278                   exit (1);
1279                 }
1280             }
1281
1282           *socket_name = 0; /* Don't let cleanup() remove the socket -
1283                                the child should do this from now on */
1284           if (opt.extra_socket)
1285             *socket_name_extra = 0;
1286           if (opt.browser_socket)
1287             *socket_name_browser = 0;
1288           if (ssh_support)
1289             *socket_name_ssh = 0;
1290
1291           if (argc)
1292             { /* Run the program given on the commandline.  */
1293               if (ssh_support && (putenv (infostr_ssh_sock)
1294                                   || putenv (infostr_ssh_valid)))
1295                 {
1296                   log_error ("failed to set environment: %s\n",
1297                              strerror (errno) );
1298                   kill (pid, SIGTERM );
1299                   exit (1);
1300                 }
1301
1302               /* Close all the file descriptors except the standard
1303                  ones and those open at startup.  We explicitly don't
1304                  close 0,1,2 in case something went wrong collecting
1305                  them at startup.  */
1306               close_all_fds (3, startup_fd_list);
1307
1308               /* Run the command.  */
1309               execvp (argv[0], argv);
1310               log_error ("failed to run the command: %s\n", strerror (errno));
1311               kill (pid, SIGTERM);
1312               exit (1);
1313             }
1314           else
1315             {
1316               /* Print the environment string, so that the caller can use
1317                  shell's eval to set it */
1318               if (csh_style)
1319                 {
1320                   if (ssh_support)
1321                     {
1322                       *strchr (infostr_ssh_sock, '=') = ' ';
1323                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1324                     }
1325                 }
1326               else
1327                 {
1328                   if (ssh_support)
1329                     {
1330                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1331                                  infostr_ssh_sock);
1332                     }
1333                 }
1334               if (ssh_support)
1335                 {
1336                   xfree (infostr_ssh_sock);
1337                   xfree (infostr_ssh_valid);
1338                 }
1339               exit (0);
1340             }
1341           /*NOTREACHED*/
1342         } /* End parent */
1343
1344       /*
1345          This is the child
1346        */
1347
1348       /* Detach from tty and put process into a new session */
1349       if (!nodetach )
1350         {
1351           int i;
1352           unsigned int oldflags;
1353
1354           /* Close stdin, stdout and stderr unless it is the log stream */
1355           for (i=0; i <= 2; i++)
1356             {
1357               if (!log_test_fd (i) && i != fd )
1358                 {
1359                   if ( ! close (i)
1360                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1361                     {
1362                       log_error ("failed to open '%s': %s\n",
1363                                  "/dev/null", strerror (errno));
1364                       cleanup ();
1365                       exit (1);
1366                     }
1367                 }
1368             }
1369           if (setsid() == -1)
1370             {
1371               log_error ("setsid() failed: %s\n", strerror(errno) );
1372               cleanup ();
1373               exit (1);
1374             }
1375
1376           log_get_prefix (&oldflags);
1377           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1378           opt.running_detached = 1;
1379         }
1380
1381       if (chdir("/"))
1382         {
1383           log_error ("chdir to / failed: %s\n", strerror (errno));
1384           exit (1);
1385         }
1386
1387       {
1388         struct sigaction sa;
1389
1390         sa.sa_handler = SIG_IGN;
1391         sigemptyset (&sa.sa_mask);
1392         sa.sa_flags = 0;
1393         sigaction (SIGPIPE, &sa, NULL);
1394       }
1395 #endif /*!HAVE_W32_SYSTEM*/
1396
1397       log_info ("%s %s started\n", strusage(11), strusage(13) );
1398       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1399       assuan_sock_close (fd);
1400     }
1401
1402   return 0;
1403 }
1404
1405
1406 /* Exit entry point.  This function should be called instead of a
1407    plain exit.  */
1408 void
1409 agent_exit (int rc)
1410 {
1411   /*FIXME: update_random_seed_file();*/
1412
1413   /* We run our cleanup handler because that may close cipher contexts
1414      stored in secure memory and thus this needs to be done before we
1415      explicitly terminate secure memory.  */
1416   cleanup ();
1417
1418 #if 1
1419   /* at this time a bit annoying */
1420   if (opt.debug & DBG_MEMSTAT_VALUE)
1421     {
1422       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1423       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1424     }
1425   if (opt.debug)
1426     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1427 #endif
1428   gcry_control (GCRYCTL_TERM_SECMEM );
1429   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1430   exit (rc);
1431 }
1432
1433
1434 /* Each thread has its own local variables conveyed by a control
1435    structure usually identified by an argument named CTRL.  This
1436    function is called immediately after allocating the control
1437    structure.  Its purpose is to setup the default values for that
1438    structure.  Note that some values may have already been set.  */
1439 static void
1440 agent_init_default_ctrl (ctrl_t ctrl)
1441 {
1442   assert (ctrl->session_env);
1443
1444   /* Note we ignore malloc errors because we can't do much about it
1445      and the request will fail anyway shortly after this
1446      initialization. */
1447   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1448   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1449   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1450   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1451   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1452
1453   if (ctrl->lc_ctype)
1454     xfree (ctrl->lc_ctype);
1455   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1456
1457   if (ctrl->lc_messages)
1458     xfree (ctrl->lc_messages);
1459   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1460                                     /**/ : NULL;
1461   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1462 }
1463
1464
1465 /* Release all resources allocated by default in the control
1466    structure.  This is the counterpart to agent_init_default_ctrl.  */
1467 static void
1468 agent_deinit_default_ctrl (ctrl_t ctrl)
1469 {
1470   session_env_release (ctrl->session_env);
1471
1472   if (ctrl->lc_ctype)
1473     xfree (ctrl->lc_ctype);
1474   if (ctrl->lc_messages)
1475     xfree (ctrl->lc_messages);
1476 }
1477
1478
1479 /* Because the ssh protocol does not send us information about the
1480    current TTY setting, we use this function to use those from startup
1481    or those explictly set.  This is also used for the restricted mode
1482    where we ignore requests to change the environment.  */
1483 gpg_error_t
1484 agent_copy_startup_env (ctrl_t ctrl)
1485 {
1486   static const char *names[] =
1487     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1488   gpg_error_t err = 0;
1489   int idx;
1490   const char *value;
1491
1492   for (idx=0; !err && names[idx]; idx++)
1493       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1494       err = session_env_setenv (ctrl->session_env, names[idx], value);
1495
1496   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1497     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1498       err = gpg_error_from_syserror ();
1499
1500   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1501     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1502       err = gpg_error_from_syserror ();
1503
1504   if (err)
1505     log_error ("error setting default session environment: %s\n",
1506                gpg_strerror (err));
1507
1508   return err;
1509 }
1510
1511
1512 /* Reread parts of the configuration.  Note, that this function is
1513    obviously not thread-safe and should only be called from the PTH
1514    signal handler.
1515
1516    Fixme: Due to the way the argument parsing works, we create a
1517    memory leak here for all string type arguments.  There is currently
1518    no clean way to tell whether the memory for the argument has been
1519    allocated or points into the process' original arguments.  Unless
1520    we have a mechanism to tell this, we need to live on with this. */
1521 static void
1522 reread_configuration (void)
1523 {
1524   ARGPARSE_ARGS pargs;
1525   FILE *fp;
1526   unsigned int configlineno = 0;
1527   int dummy;
1528
1529   if (!config_filename)
1530     return; /* No config file. */
1531
1532   fp = fopen (config_filename, "r");
1533   if (!fp)
1534     {
1535       log_info (_("option file '%s': %s\n"),
1536                 config_filename, strerror(errno) );
1537       return;
1538     }
1539
1540   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1541
1542   memset (&pargs, 0, sizeof pargs);
1543   dummy = 0;
1544   pargs.argc = &dummy;
1545   pargs.flags = 1;  /* do not remove the args */
1546   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1547     {
1548       if (pargs.r_opt < -1)
1549         pargs.err = 1; /* Print a warning. */
1550       else /* Try to parse this option - ignore unchangeable ones. */
1551         parse_rereadable_options (&pargs, 1);
1552     }
1553   fclose (fp);
1554   finalize_rereadable_options ();
1555   set_debug ();
1556 }
1557
1558
1559 /* Return the file name of the socket we are using for native
1560    requests.  */
1561 const char *
1562 get_agent_socket_name (void)
1563 {
1564   const char *s = socket_name;
1565
1566   return (s && *s)? s : NULL;
1567 }
1568
1569 /* Return the file name of the socket we are using for SSH
1570    requests.  */
1571 const char *
1572 get_agent_ssh_socket_name (void)
1573 {
1574   const char *s = socket_name_ssh;
1575
1576   return (s && *s)? s : NULL;
1577 }
1578
1579
1580 /* Under W32, this function returns the handle of the scdaemon
1581    notification event.  Calling it the first time creates that
1582    event.  */
1583 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1584 void *
1585 get_agent_scd_notify_event (void)
1586 {
1587   static HANDLE the_event = INVALID_HANDLE_VALUE;
1588
1589   if (the_event == INVALID_HANDLE_VALUE)
1590     {
1591       HANDLE h, h2;
1592       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1593
1594       /* We need to use a manual reset event object due to the way our
1595          w32-pth wait function works: If we would use an automatic
1596          reset event we are not able to figure out which handle has
1597          been signaled because at the time we single out the signaled
1598          handles using WFSO the event has already been reset due to
1599          the WFMO.  */
1600       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1601       if (!h)
1602         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1603       else if (!DuplicateHandle (GetCurrentProcess(), h,
1604                                  GetCurrentProcess(), &h2,
1605                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1606         {
1607           log_error ("setting syncronize for scd notify event failed: %s\n",
1608                      w32_strerror (-1) );
1609           CloseHandle (h);
1610         }
1611       else
1612         {
1613           CloseHandle (h);
1614           the_event = h2;
1615         }
1616     }
1617
1618   return the_event;
1619 }
1620 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1621
1622
1623
1624 /* Create a name for the socket in the home directory as using
1625    STANDARD_NAME.  We also check for valid characters as well as
1626    against a maximum allowed length for a unix domain socket is done.
1627    The function terminates the process in case of an error.  Returns:
1628    Pointer to an allocated string with the absolute name of the socket
1629    used.  */
1630 static char *
1631 create_socket_name (char *standard_name, int with_homedir)
1632 {
1633   char *name;
1634
1635   if (with_homedir)
1636     name = make_filename (opt.homedir, standard_name, NULL);
1637   else
1638     name = make_filename (standard_name, NULL);
1639   if (strchr (name, PATHSEP_C))
1640     {
1641       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1642       agent_exit (2);
1643     }
1644   return name;
1645 }
1646
1647
1648
1649 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1650    or terminates the process in case of an error.  Note that this
1651    function needs to be used for the regular socket first (indicated
1652    by PRIMARY) and only then for the extra and the ssh sockets.  If
1653    the socket has been redirected the name of the real socket is
1654    stored as a malloced string at R_REDIR_NAME.  */
1655 static gnupg_fd_t
1656 create_server_socket (char *name, int primary,
1657                       char **r_redir_name, assuan_sock_nonce_t *nonce)
1658 {
1659   struct sockaddr *addr;
1660   struct sockaddr_un *unaddr;
1661   socklen_t len;
1662   gnupg_fd_t fd;
1663   int rc;
1664
1665   xfree (*r_redir_name);
1666   *r_redir_name = NULL;
1667
1668   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1669   if (fd == ASSUAN_INVALID_FD)
1670     {
1671       log_error (_("can't create socket: %s\n"), strerror (errno));
1672       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1673       agent_exit (2);
1674     }
1675
1676   unaddr = xmalloc (sizeof *unaddr);
1677   addr = (struct sockaddr*)unaddr;
1678
1679 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1680   {
1681     int redirected;
1682
1683     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1684       {
1685         if (errno == ENAMETOOLONG)
1686           log_error (_("socket name '%s' is too long\n"), name);
1687         else
1688           log_error ("error preparing socket '%s': %s\n",
1689                      name, gpg_strerror (gpg_error_from_syserror ()));
1690         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1691         agent_exit (2);
1692       }
1693     if (redirected)
1694       {
1695         *r_redir_name = xstrdup (unaddr->sun_path);
1696         if (opt.verbose)
1697           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1698       }
1699   }
1700 #else /* Assuan < 2.1.4 */
1701   memset (unaddr, 0, sizeof *unaddr);
1702   unaddr->sun_family = AF_UNIX;
1703   if (strlen (name) + 1 >= sizeof (unaddr->sun_path))
1704     {
1705       log_error (_("socket name '%s' is too long\n"), name);
1706       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1707       agent_exit (2);
1708     }
1709   strcpy (unaddr->sun_path, name);
1710 #endif /* Assuan < 2.1.4 */
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 }