common/iobuf.c: Combine iobuf_open, iobuf_create and iobuf_openrw.
[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, int cygwin,
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 }
681
682
683
684 /* The main entry point.  */
685 int
686 main (int argc, char **argv )
687 {
688   ARGPARSE_ARGS pargs;
689   int orig_argc;
690   char **orig_argv;
691   FILE *configfp = NULL;
692   char *configname = NULL;
693   const char *shell;
694   unsigned configlineno;
695   int parse_debug = 0;
696   int default_config =1;
697   int pipe_server = 0;
698   int is_daemon = 0;
699   int nodetach = 0;
700   int csh_style = 0;
701   char *logfile = NULL;
702   int debug_wait = 0;
703   int gpgconf_list = 0;
704   gpg_error_t err;
705   struct assuan_malloc_hooks malloc_hooks;
706
707   early_system_init ();
708
709   /* Before we do anything else we save the list of currently open
710      file descriptors and the signal mask.  This info is required to
711      do the exec call properly. */
712   startup_fd_list = get_all_open_fds ();
713 #ifdef HAVE_SIGPROCMASK
714   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
715     startup_signal_mask_valid = 1;
716 #endif /*HAVE_SIGPROCMASK*/
717
718   /* Set program name etc.  */
719   set_strusage (my_strusage);
720   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
721   /* Please note that we may running SUID(ROOT), so be very CAREFUL
722      when adding any stuff between here and the call to INIT_SECMEM()
723      somewhere after the option parsing */
724   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
725
726   /* Make sure that our subsystems are ready.  */
727   i18n_init ();
728   init_common_subsystems (&argc, &argv);
729
730   npth_init ();
731
732   /* Check that the libraries are suitable.  Do it here because
733      the option parsing may need services of the library. */
734   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
735     {
736       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
737                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
738     }
739
740   malloc_hooks.malloc = gcry_malloc;
741   malloc_hooks.realloc = gcry_realloc;
742   malloc_hooks.free = gcry_free;
743   assuan_set_malloc_hooks (&malloc_hooks);
744   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
745   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
746   assuan_sock_init ();
747   setup_libassuan_logging (&opt.debug);
748
749   setup_libgcrypt_logging ();
750   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
751
752   disable_core_dumps ();
753
754   /* Set default options.  */
755   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
756
757   shell = getenv ("SHELL");
758   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
759     csh_style = 1;
760
761   opt.homedir = default_homedir ();
762
763   /* Record some of the original environment strings. */
764   {
765     const char *s;
766     int idx;
767     static const char *names[] =
768       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
769
770     err = 0;
771     opt.startup_env = session_env_new ();
772     if (!opt.startup_env)
773       err = gpg_error_from_syserror ();
774     for (idx=0; !err && names[idx]; idx++)
775       {
776         s = getenv (names[idx]);
777         if (s)
778           err = session_env_setenv (opt.startup_env, names[idx], s);
779       }
780     if (!err)
781       {
782         s = gnupg_ttyname (0);
783         if (s)
784           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
785       }
786     if (err)
787       log_fatal ("error recording startup environment: %s\n",
788                  gpg_strerror (err));
789
790     /* Fixme: Better use the locale function here.  */
791     opt.startup_lc_ctype = getenv ("LC_CTYPE");
792     if (opt.startup_lc_ctype)
793       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
794     opt.startup_lc_messages = getenv ("LC_MESSAGES");
795     if (opt.startup_lc_messages)
796       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
797   }
798
799   /* Check whether we have a config file on the commandline */
800   orig_argc = argc;
801   orig_argv = argv;
802   pargs.argc = &argc;
803   pargs.argv = &argv;
804   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
805   while (arg_parse( &pargs, opts))
806     {
807       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
808         parse_debug++;
809       else if (pargs.r_opt == oOptions)
810         { /* yes there is one, so we do not try the default one, but
811              read the option file when it is encountered at the
812              commandline */
813           default_config = 0;
814         }
815         else if (pargs.r_opt == oNoOptions)
816           default_config = 0; /* --no-options */
817         else if (pargs.r_opt == oHomedir)
818           opt.homedir = pargs.r.ret_str;
819         else if (pargs.r_opt == oDebugQuickRandom)
820           {
821             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
822           }
823
824     }
825
826   /* Initialize the secure memory. */
827   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
828   maybe_setuid = 0;
829
830   /*
831      Now we are now working under our real uid
832   */
833
834   if (default_config)
835     configname = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
836                                 NULL );
837
838   argc = orig_argc;
839   argv = orig_argv;
840   pargs.argc = &argc;
841   pargs.argv = &argv;
842   pargs.flags=  1;  /* do not remove the args */
843  next_pass:
844   if (configname)
845     {
846       configlineno = 0;
847       configfp = fopen (configname, "r");
848       if (!configfp)
849         {
850           if (default_config)
851             {
852               if( parse_debug )
853                 log_info (_("Note: no default option file '%s'\n"),
854                           configname );
855               /* Save the default conf file name so that
856                  reread_configuration is able to test whether the
857                  config file has been created in the meantime.  */
858               xfree (config_filename);
859               config_filename = configname;
860               configname = NULL;
861             }
862           else
863             {
864               log_error (_("option file '%s': %s\n"),
865                          configname, strerror(errno) );
866               exit(2);
867             }
868           xfree (configname);
869           configname = NULL;
870         }
871       if (parse_debug && configname )
872         log_info (_("reading options from '%s'\n"), configname );
873       default_config = 0;
874     }
875
876   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
877     {
878       if (parse_rereadable_options (&pargs, 0))
879         continue; /* Already handled */
880       switch (pargs.r_opt)
881         {
882         case aGPGConfList: gpgconf_list = 1; break;
883         case aGPGConfTest: gpgconf_list = 2; break;
884         case aUseStandardSocketP: gpgconf_list = 3; break;
885         case oBatch: opt.batch=1; break;
886
887         case oDebugWait: debug_wait = pargs.r.ret_int; break;
888
889         case oOptions:
890           /* config files may not be nested (silently ignore them) */
891           if (!configfp)
892             {
893                 xfree(configname);
894                 configname = xstrdup(pargs.r.ret_str);
895                 goto next_pass;
896             }
897           break;
898         case oNoGreeting: /* Dummy option.  */ break;
899         case oNoVerbose: opt.verbose = 0; break;
900         case oNoOptions: break; /* no-options */
901         case oHomedir: opt.homedir = pargs.r.ret_str; break;
902         case oNoDetach: nodetach = 1; break;
903         case oLogFile: logfile = pargs.r.ret_str; break;
904         case oCsh: csh_style = 1; break;
905         case oSh: csh_style = 0; break;
906         case oServer: pipe_server = 1; break;
907         case oDaemon: is_daemon = 1; break;
908
909         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
910         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
911         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
912         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
913         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
914           break;
915         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
916           break;
917
918         case oUseStandardSocket:
919         case oNoUseStandardSocket:
920           obsolete_option (configname, configlineno, "use-standard-socket");
921           break;
922
923         case oFakedSystemTime:
924           {
925             time_t faked_time = isotime2epoch (pargs.r.ret_str);
926             if (faked_time == (time_t)(-1))
927               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
928             gnupg_set_time (faked_time, 0);
929           }
930           break;
931
932         case oKeepTTY: opt.keep_tty = 1; break;
933         case oKeepDISPLAY: opt.keep_display = 1; break;
934
935         case oSSHSupport:
936           ssh_support = 1;
937           break;
938         case oPuttySupport:
939 #        ifdef HAVE_W32_SYSTEM
940           putty_support = 1;
941 #        endif
942           break;
943
944         case oExtraSocket:
945           opt.extra_socket = 1;  /* (1 = points into argv)  */
946           socket_name_extra = pargs.r.ret_str;
947           break;
948
949         case oBrowserSocket:
950           opt.browser_socket = 1;  /* (1 = points into argv)  */
951           socket_name_browser = pargs.r.ret_str;
952           break;
953
954         case oDebugQuickRandom:
955           /* Only used by the first stage command line parser.  */
956           break;
957
958         case oWriteEnvFile:
959           obsolete_option (configname, configlineno, "write-env-file");
960           break;
961
962         default : pargs.err = configfp? 1:2; break;
963         }
964     }
965   if (configfp)
966     {
967       fclose( configfp );
968       configfp = NULL;
969       /* Keep a copy of the name so that it can be read on SIGHUP. */
970       if (config_filename != configname)
971         {
972           xfree (config_filename);
973           config_filename = configname;
974         }
975       configname = NULL;
976       goto next_pass;
977     }
978
979   xfree (configname);
980   configname = NULL;
981   if (log_get_errorcount(0))
982     exit(2);
983
984   finalize_rereadable_options ();
985
986   /* Turn the homedir into an absolute one. */
987   opt.homedir = make_absfilename (opt.homedir, NULL);
988
989   /* Print a warning if an argument looks like an option.  */
990   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
991     {
992       int i;
993
994       for (i=0; i < argc; i++)
995         if (argv[i][0] == '-' && argv[i][1] == '-')
996           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
997     }
998
999 #ifdef ENABLE_NLS
1000   /* gpg-agent usually does not output any messages because it runs in
1001      the background.  For log files it is acceptable to have messages
1002      always encoded in utf-8.  We switch here to utf-8, so that
1003      commands like --help still give native messages.  It is far
1004      easier to switch only once instead of for every message and it
1005      actually helps when more then one thread is active (avoids an
1006      extra copy step). */
1007     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1008 #endif
1009
1010   if (!pipe_server && !is_daemon && !gpgconf_list)
1011     {
1012      /* We have been called without any options and thus we merely
1013         check whether an agent is already running.  We do this right
1014         here so that we don't clobber a logfile with this check but
1015         print the status directly to stderr. */
1016       opt.debug = 0;
1017       set_debug ();
1018       check_for_running_agent (0);
1019       agent_exit (0);
1020     }
1021
1022   set_debug ();
1023
1024   if (atexit (cleanup))
1025     {
1026       log_error ("atexit failed\n");
1027       cleanup ();
1028       exit (1);
1029     }
1030
1031   initialize_module_cache ();
1032   initialize_module_call_pinentry ();
1033   initialize_module_call_scd ();
1034   initialize_module_trustlist ();
1035
1036   /* Try to create missing directories. */
1037   create_directories ();
1038
1039   if (debug_wait && pipe_server)
1040     {
1041       log_debug ("waiting for debugger - my pid is %u .....\n",
1042                  (unsigned int)getpid());
1043       gnupg_sleep (debug_wait);
1044       log_debug ("... okay\n");
1045     }
1046
1047   if (gpgconf_list == 3)
1048     {
1049       /* We now use the standard socket always - return true for
1050          backward compatibility.  */
1051       agent_exit (0);
1052     }
1053   else if (gpgconf_list == 2)
1054     agent_exit (0);
1055   else if (gpgconf_list)
1056     {
1057       char *filename;
1058       char *filename_esc;
1059
1060       /* List options and default values in the GPG Conf format.  */
1061       filename = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
1062                                 NULL );
1063       filename_esc = percent_escape (filename, NULL);
1064
1065       es_printf ("%s-%s.conf:%lu:\"%s\n",
1066                  GPGCONF_NAME, GPG_AGENT_NAME,
1067                  GC_OPT_FLAG_DEFAULT, filename_esc);
1068       xfree (filename);
1069       xfree (filename_esc);
1070
1071       es_printf ("verbose:%lu:\n"
1072               "quiet:%lu:\n"
1073               "debug-level:%lu:\"none:\n"
1074               "log-file:%lu:\n",
1075               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1076               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1077               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1078               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1079       es_printf ("default-cache-ttl:%lu:%d:\n",
1080               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1081       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1082               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1083       es_printf ("max-cache-ttl:%lu:%d:\n",
1084               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1085       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1086               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1087       es_printf ("enforce-passphrase-constraints:%lu:\n",
1088               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1089       es_printf ("min-passphrase-len:%lu:%d:\n",
1090               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1091       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1092               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1093               MIN_PASSPHRASE_NONALPHA);
1094       es_printf ("check-passphrase-pattern:%lu:\n",
1095               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1096       es_printf ("max-passphrase-days:%lu:%d:\n",
1097               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1098               MAX_PASSPHRASE_DAYS);
1099       es_printf ("enable-passphrase-history:%lu:\n",
1100               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1101       es_printf ("no-grab:%lu:\n",
1102               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1103       es_printf ("ignore-cache-for-signing:%lu:\n",
1104               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1105       es_printf ("no-allow-external-cache:%lu:\n",
1106               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1107       es_printf ("no-allow-mark-trusted:%lu:\n",
1108               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1109       es_printf ("disable-scdaemon:%lu:\n",
1110               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1111       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1112 #ifdef HAVE_W32_SYSTEM
1113       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1114 #endif
1115       es_printf ("allow-loopback-pinentry:%lu:\n",
1116                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1117       es_printf ("allow-emacs-pinentry:%lu:\n",
1118                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1119
1120       agent_exit (0);
1121     }
1122
1123   /* Now start with logging to a file if this is desired. */
1124   if (logfile)
1125     {
1126       log_set_file (logfile);
1127       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1128                              | GPGRT_LOG_WITH_TIME
1129                              | GPGRT_LOG_WITH_PID));
1130       current_logfile = xstrdup (logfile);
1131     }
1132
1133   /* Make sure that we have a default ttyname. */
1134   if (!default_ttyname && gnupg_ttyname (1))
1135     default_ttyname = xstrdup (gnupg_ttyname (1));
1136   if (!default_ttytype && getenv ("TERM"))
1137     default_ttytype = xstrdup (getenv ("TERM"));
1138
1139
1140   if (pipe_server)
1141     {
1142       /* This is the simple pipe based server */
1143       ctrl_t ctrl;
1144
1145       ctrl = xtrycalloc (1, sizeof *ctrl);
1146       if (!ctrl)
1147         {
1148           log_error ("error allocating connection control data: %s\n",
1149                      strerror (errno) );
1150           agent_exit (1);
1151         }
1152       ctrl->session_env = session_env_new ();
1153       if (!ctrl->session_env)
1154         {
1155           log_error ("error allocating session environment block: %s\n",
1156                      strerror (errno) );
1157           xfree (ctrl);
1158           agent_exit (1);
1159         }
1160       agent_init_default_ctrl (ctrl);
1161       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1162       agent_deinit_default_ctrl (ctrl);
1163       xfree (ctrl);
1164     }
1165   else if (!is_daemon)
1166     ; /* NOTREACHED */
1167   else
1168     { /* Regular server mode */
1169       gnupg_fd_t fd;
1170       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1171       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1172       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1173       pid_t pid;
1174
1175       /* Remove the DISPLAY variable so that a pinentry does not
1176          default to a specific display.  There is still a default
1177          display when gpg-agent was started using --display or a
1178          client requested this using an OPTION command.  Note, that we
1179          don't do this when running in reverse daemon mode (i.e. when
1180          exec the program given as arguments). */
1181 #ifndef HAVE_W32_SYSTEM
1182       if (!opt.keep_display && !argc)
1183         gnupg_unsetenv ("DISPLAY");
1184 #endif
1185
1186       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1187          always try to interact with Emacs.  The variable is set when
1188          a client requested this using an OPTION command.  */
1189       gnupg_unsetenv ("INSIDE_EMACS");
1190
1191       /* Create the sockets.  */
1192       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1193       fd = create_server_socket (socket_name, 1, 0,
1194                                  &redir_socket_name, &socket_nonce);
1195
1196       if (opt.extra_socket)
1197         {
1198           socket_name_extra = create_socket_name (socket_name_extra, 0);
1199           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1200           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1201                                            &redir_socket_name_extra,
1202                                            &socket_nonce_extra);
1203         }
1204
1205       if (opt.browser_socket)
1206         {
1207           socket_name_browser = create_socket_name (socket_name_browser, 0);
1208           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1209           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1210                                              &redir_socket_name_browser,
1211                                              &socket_nonce_browser);
1212         }
1213
1214       if (ssh_support)
1215         {
1216           socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1217           fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1218                                          &redir_socket_name_ssh,
1219                                          &socket_nonce_ssh);
1220         }
1221
1222       /* If we are going to exec a program in the parent, we record
1223          the PID, so that the child may check whether the program is
1224          still alive. */
1225       if (argc)
1226         parent_pid = getpid ();
1227
1228       fflush (NULL);
1229 #ifdef HAVE_W32_SYSTEM
1230       (void)csh_style;
1231       (void)nodetach;
1232       pid = getpid ();
1233 #else /*!HAVE_W32_SYSTEM*/
1234       pid = fork ();
1235       if (pid == (pid_t)-1)
1236         {
1237           log_fatal ("fork failed: %s\n", strerror (errno) );
1238           exit (1);
1239         }
1240       else if (pid)
1241         { /* We are the parent */
1242           char *infostr_ssh_sock, *infostr_ssh_valid;
1243
1244           /* Close the socket FD. */
1245           close (fd);
1246
1247           /* The signal mask might not be correct right now and thus
1248              we restore it.  That is not strictly necessary but some
1249              programs falsely assume a cleared signal mask.  */
1250
1251 #ifdef HAVE_SIGPROCMASK
1252           if (startup_signal_mask_valid)
1253             {
1254               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1255                 log_error ("error restoring signal mask: %s\n",
1256                            strerror (errno));
1257             }
1258           else
1259             log_info ("no saved signal mask\n");
1260 #endif /*HAVE_SIGPROCMASK*/
1261
1262           /* Create the SSH info string if enabled. */
1263           if (ssh_support)
1264             {
1265               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1266                             socket_name_ssh) < 0)
1267                 {
1268                   log_error ("out of core\n");
1269                   kill (pid, SIGTERM);
1270                   exit (1);
1271                 }
1272               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1273                             (unsigned long)getpid()) < 0)
1274                 {
1275                   log_error ("out of core\n");
1276                   kill (pid, SIGTERM);
1277                   exit (1);
1278                 }
1279             }
1280
1281           *socket_name = 0; /* Don't let cleanup() remove the socket -
1282                                the child should do this from now on */
1283           if (opt.extra_socket)
1284             *socket_name_extra = 0;
1285           if (opt.browser_socket)
1286             *socket_name_browser = 0;
1287           if (ssh_support)
1288             *socket_name_ssh = 0;
1289
1290           if (argc)
1291             { /* Run the program given on the commandline.  */
1292               if (ssh_support && (putenv (infostr_ssh_sock)
1293                                   || putenv (infostr_ssh_valid)))
1294                 {
1295                   log_error ("failed to set environment: %s\n",
1296                              strerror (errno) );
1297                   kill (pid, SIGTERM );
1298                   exit (1);
1299                 }
1300
1301               /* Close all the file descriptors except the standard
1302                  ones and those open at startup.  We explicitly don't
1303                  close 0,1,2 in case something went wrong collecting
1304                  them at startup.  */
1305               close_all_fds (3, startup_fd_list);
1306
1307               /* Run the command.  */
1308               execvp (argv[0], argv);
1309               log_error ("failed to run the command: %s\n", strerror (errno));
1310               kill (pid, SIGTERM);
1311               exit (1);
1312             }
1313           else
1314             {
1315               /* Print the environment string, so that the caller can use
1316                  shell's eval to set it */
1317               if (csh_style)
1318                 {
1319                   if (ssh_support)
1320                     {
1321                       *strchr (infostr_ssh_sock, '=') = ' ';
1322                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1323                     }
1324                 }
1325               else
1326                 {
1327                   if (ssh_support)
1328                     {
1329                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1330                                  infostr_ssh_sock);
1331                     }
1332                 }
1333               if (ssh_support)
1334                 {
1335                   xfree (infostr_ssh_sock);
1336                   xfree (infostr_ssh_valid);
1337                 }
1338               exit (0);
1339             }
1340           /*NOTREACHED*/
1341         } /* End parent */
1342
1343       /*
1344          This is the child
1345        */
1346
1347       /* Detach from tty and put process into a new session */
1348       if (!nodetach )
1349         {
1350           int i;
1351           unsigned int oldflags;
1352
1353           /* Close stdin, stdout and stderr unless it is the log stream */
1354           for (i=0; i <= 2; i++)
1355             {
1356               if (!log_test_fd (i) && i != fd )
1357                 {
1358                   if ( ! close (i)
1359                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1360                     {
1361                       log_error ("failed to open '%s': %s\n",
1362                                  "/dev/null", strerror (errno));
1363                       cleanup ();
1364                       exit (1);
1365                     }
1366                 }
1367             }
1368           if (setsid() == -1)
1369             {
1370               log_error ("setsid() failed: %s\n", strerror(errno) );
1371               cleanup ();
1372               exit (1);
1373             }
1374
1375           log_get_prefix (&oldflags);
1376           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1377           opt.running_detached = 1;
1378         }
1379
1380       if (chdir("/"))
1381         {
1382           log_error ("chdir to / failed: %s\n", strerror (errno));
1383           exit (1);
1384         }
1385
1386       {
1387         struct sigaction sa;
1388
1389         sa.sa_handler = SIG_IGN;
1390         sigemptyset (&sa.sa_mask);
1391         sa.sa_flags = 0;
1392         sigaction (SIGPIPE, &sa, NULL);
1393       }
1394 #endif /*!HAVE_W32_SYSTEM*/
1395
1396       log_info ("%s %s started\n", strusage(11), strusage(13) );
1397       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1398       assuan_sock_close (fd);
1399     }
1400
1401   return 0;
1402 }
1403
1404
1405 /* Exit entry point.  This function should be called instead of a
1406    plain exit.  */
1407 void
1408 agent_exit (int rc)
1409 {
1410   /*FIXME: update_random_seed_file();*/
1411
1412   /* We run our cleanup handler because that may close cipher contexts
1413      stored in secure memory and thus this needs to be done before we
1414      explicitly terminate secure memory.  */
1415   cleanup ();
1416
1417 #if 1
1418   /* at this time a bit annoying */
1419   if (opt.debug & DBG_MEMSTAT_VALUE)
1420     {
1421       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1422       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1423     }
1424   if (opt.debug)
1425     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1426 #endif
1427   gcry_control (GCRYCTL_TERM_SECMEM );
1428   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1429   exit (rc);
1430 }
1431
1432
1433 /* Each thread has its own local variables conveyed by a control
1434    structure usually identified by an argument named CTRL.  This
1435    function is called immediately after allocating the control
1436    structure.  Its purpose is to setup the default values for that
1437    structure.  Note that some values may have already been set.  */
1438 static void
1439 agent_init_default_ctrl (ctrl_t ctrl)
1440 {
1441   assert (ctrl->session_env);
1442
1443   /* Note we ignore malloc errors because we can't do much about it
1444      and the request will fail anyway shortly after this
1445      initialization. */
1446   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1447   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1448   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1449   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1450   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1451
1452   if (ctrl->lc_ctype)
1453     xfree (ctrl->lc_ctype);
1454   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1455
1456   if (ctrl->lc_messages)
1457     xfree (ctrl->lc_messages);
1458   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1459                                     /**/ : NULL;
1460   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1461 }
1462
1463
1464 /* Release all resources allocated by default in the control
1465    structure.  This is the counterpart to agent_init_default_ctrl.  */
1466 static void
1467 agent_deinit_default_ctrl (ctrl_t ctrl)
1468 {
1469   session_env_release (ctrl->session_env);
1470
1471   if (ctrl->lc_ctype)
1472     xfree (ctrl->lc_ctype);
1473   if (ctrl->lc_messages)
1474     xfree (ctrl->lc_messages);
1475 }
1476
1477
1478 /* Because the ssh protocol does not send us information about the
1479    current TTY setting, we use this function to use those from startup
1480    or those explictly set.  This is also used for the restricted mode
1481    where we ignore requests to change the environment.  */
1482 gpg_error_t
1483 agent_copy_startup_env (ctrl_t ctrl)
1484 {
1485   static const char *names[] =
1486     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1487   gpg_error_t err = 0;
1488   int idx;
1489   const char *value;
1490
1491   for (idx=0; !err && names[idx]; idx++)
1492       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1493       err = session_env_setenv (ctrl->session_env, names[idx], value);
1494
1495   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1496     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1497       err = gpg_error_from_syserror ();
1498
1499   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1500     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1501       err = gpg_error_from_syserror ();
1502
1503   if (err)
1504     log_error ("error setting default session environment: %s\n",
1505                gpg_strerror (err));
1506
1507   return err;
1508 }
1509
1510
1511 /* Reread parts of the configuration.  Note, that this function is
1512    obviously not thread-safe and should only be called from the PTH
1513    signal handler.
1514
1515    Fixme: Due to the way the argument parsing works, we create a
1516    memory leak here for all string type arguments.  There is currently
1517    no clean way to tell whether the memory for the argument has been
1518    allocated or points into the process' original arguments.  Unless
1519    we have a mechanism to tell this, we need to live on with this. */
1520 static void
1521 reread_configuration (void)
1522 {
1523   ARGPARSE_ARGS pargs;
1524   FILE *fp;
1525   unsigned int configlineno = 0;
1526   int dummy;
1527
1528   if (!config_filename)
1529     return; /* No config file. */
1530
1531   fp = fopen (config_filename, "r");
1532   if (!fp)
1533     {
1534       log_info (_("option file '%s': %s\n"),
1535                 config_filename, strerror(errno) );
1536       return;
1537     }
1538
1539   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1540
1541   memset (&pargs, 0, sizeof pargs);
1542   dummy = 0;
1543   pargs.argc = &dummy;
1544   pargs.flags = 1;  /* do not remove the args */
1545   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1546     {
1547       if (pargs.r_opt < -1)
1548         pargs.err = 1; /* Print a warning. */
1549       else /* Try to parse this option - ignore unchangeable ones. */
1550         parse_rereadable_options (&pargs, 1);
1551     }
1552   fclose (fp);
1553   finalize_rereadable_options ();
1554   set_debug ();
1555 }
1556
1557
1558 /* Return the file name of the socket we are using for native
1559    requests.  */
1560 const char *
1561 get_agent_socket_name (void)
1562 {
1563   const char *s = socket_name;
1564
1565   return (s && *s)? s : NULL;
1566 }
1567
1568 /* Return the file name of the socket we are using for SSH
1569    requests.  */
1570 const char *
1571 get_agent_ssh_socket_name (void)
1572 {
1573   const char *s = socket_name_ssh;
1574
1575   return (s && *s)? s : NULL;
1576 }
1577
1578
1579 /* Under W32, this function returns the handle of the scdaemon
1580    notification event.  Calling it the first time creates that
1581    event.  */
1582 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1583 void *
1584 get_agent_scd_notify_event (void)
1585 {
1586   static HANDLE the_event = INVALID_HANDLE_VALUE;
1587
1588   if (the_event == INVALID_HANDLE_VALUE)
1589     {
1590       HANDLE h, h2;
1591       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1592
1593       /* We need to use a manual reset event object due to the way our
1594          w32-pth wait function works: If we would use an automatic
1595          reset event we are not able to figure out which handle has
1596          been signaled because at the time we single out the signaled
1597          handles using WFSO the event has already been reset due to
1598          the WFMO.  */
1599       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1600       if (!h)
1601         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1602       else if (!DuplicateHandle (GetCurrentProcess(), h,
1603                                  GetCurrentProcess(), &h2,
1604                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1605         {
1606           log_error ("setting syncronize for scd notify event failed: %s\n",
1607                      w32_strerror (-1) );
1608           CloseHandle (h);
1609         }
1610       else
1611         {
1612           CloseHandle (h);
1613           the_event = h2;
1614         }
1615     }
1616
1617   return the_event;
1618 }
1619 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1620
1621
1622
1623 /* Create a name for the socket in the home directory as using
1624    STANDARD_NAME.  We also check for valid characters as well as
1625    against a maximum allowed length for a unix domain socket is done.
1626    The function terminates the process in case of an error.  Returns:
1627    Pointer to an allocated string with the absolute name of the socket
1628    used.  */
1629 static char *
1630 create_socket_name (char *standard_name, int with_homedir)
1631 {
1632   char *name;
1633
1634   if (with_homedir)
1635     name = make_filename (opt.homedir, standard_name, NULL);
1636   else
1637     name = make_filename (standard_name, NULL);
1638   if (strchr (name, PATHSEP_C))
1639     {
1640       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1641       agent_exit (2);
1642     }
1643   return name;
1644 }
1645
1646
1647
1648 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1649    or terminates the process in case of an error.  Note that this
1650    function needs to be used for the regular socket first (indicated
1651    by PRIMARY) and only then for the extra and the ssh sockets.  If
1652    the socket has been redirected the name of the real socket is
1653    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
1654    Cygwin compatible socket is created (Windows only). */
1655 static gnupg_fd_t
1656 create_server_socket (char *name, int primary, int cygwin,
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 #if ASSUAN_VERSION_NUMBER >= 0x020300 /* >= 2.3.0 */
1677   if (cygwin)
1678     assuan_sock_set_flag (fd, "cygwin", 1);
1679 #else
1680   (void)cygwin;
1681 #endif
1682
1683   unaddr = xmalloc (sizeof *unaddr);
1684   addr = (struct sockaddr*)unaddr;
1685
1686 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1687   {
1688     int redirected;
1689
1690     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1691       {
1692         if (errno == ENAMETOOLONG)
1693           log_error (_("socket name '%s' is too long\n"), name);
1694         else
1695           log_error ("error preparing socket '%s': %s\n",
1696                      name, gpg_strerror (gpg_error_from_syserror ()));
1697         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1698         agent_exit (2);
1699       }
1700     if (redirected)
1701       {
1702         *r_redir_name = xstrdup (unaddr->sun_path);
1703         if (opt.verbose)
1704           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1705       }
1706   }
1707 #else /* Assuan < 2.1.4 */
1708   memset (unaddr, 0, sizeof *unaddr);
1709   unaddr->sun_family = AF_UNIX;
1710   if (strlen (name) + 1 >= sizeof (unaddr->sun_path))
1711     {
1712       log_error (_("socket name '%s' is too long\n"), name);
1713       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1714       agent_exit (2);
1715     }
1716   strcpy (unaddr->sun_path, name);
1717 #endif /* Assuan < 2.1.4 */
1718
1719   len = SUN_LEN (unaddr);
1720   rc = assuan_sock_bind (fd, addr, len);
1721
1722   /* Our error code mapping on W32CE returns EEXIST thus we also test
1723      for this. */
1724   if (rc == -1
1725       && (errno == EADDRINUSE
1726 #ifdef HAVE_W32_SYSTEM
1727           || errno == EEXIST
1728 #endif
1729           ))
1730     {
1731       /* Check whether a gpg-agent is already running.  We do this
1732          test only if this is the primary socket.  For secondary
1733          sockets we assume that a test for gpg-agent has already been
1734          done and reuse the requested socket.  Testing the ssh-socket
1735          is not possible because at this point, though we know the new
1736          Assuan socket, the Assuan server and thus the ssh-agent
1737          server is not yet operational; this would lead to a hang.  */
1738       if (primary && !check_for_running_agent (1))
1739         {
1740           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
1741           log_set_file (NULL);
1742           log_error (_("a gpg-agent is already running - "
1743                        "not starting a new one\n"));
1744           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1745           assuan_sock_close (fd);
1746           agent_exit (2);
1747         }
1748       gnupg_remove (unaddr->sun_path);
1749       rc = assuan_sock_bind (fd, addr, len);
1750     }
1751   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1752     log_error (_("error getting nonce for the socket\n"));
1753   if (rc == -1)
1754     {
1755       /* We use gpg_strerror here because it allows us to get strings
1756          for some W32 socket error codes.  */
1757       log_error (_("error binding socket to '%s': %s\n"),
1758                  unaddr->sun_path,
1759                  gpg_strerror (gpg_error_from_syserror ()));
1760
1761       assuan_sock_close (fd);
1762       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1763       agent_exit (2);
1764     }
1765
1766   if (listen (FD2INT(fd), 5 ) == -1)
1767     {
1768       log_error (_("listen() failed: %s\n"), strerror (errno));
1769       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1770       assuan_sock_close (fd);
1771       agent_exit (2);
1772     }
1773
1774   if (opt.verbose)
1775     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1776
1777   return fd;
1778 }
1779
1780
1781 /* Check that the directory for storing the private keys exists and
1782    create it if not.  This function won't fail as it is only a
1783    convenience function and not strictly necessary.  */
1784 static void
1785 create_private_keys_directory (const char *home)
1786 {
1787   char *fname;
1788   struct stat statbuf;
1789
1790   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1791   if (stat (fname, &statbuf) && errno == ENOENT)
1792     {
1793       if (gnupg_mkdir (fname, "-rwx"))
1794         log_error (_("can't create directory '%s': %s\n"),
1795                    fname, strerror (errno) );
1796       else if (!opt.quiet)
1797         log_info (_("directory '%s' created\n"), fname);
1798     }
1799   xfree (fname);
1800 }
1801
1802 /* Create the directory only if the supplied directory name is the
1803    same as the default one.  This way we avoid to create arbitrary
1804    directories when a non-default home directory is used.  To cope
1805    with HOME, we compare only the suffix if we see that the default
1806    homedir does start with a tilde.  We don't stop here in case of
1807    problems because other functions will throw an error anyway.*/
1808 static void
1809 create_directories (void)
1810 {
1811   struct stat statbuf;
1812   const char *defhome = standard_homedir ();
1813   char *home;
1814
1815   home = make_filename (opt.homedir, NULL);
1816   if ( stat (home, &statbuf) )
1817     {
1818       if (errno == ENOENT)
1819         {
1820           if (
1821 #ifdef HAVE_W32_SYSTEM
1822               ( !compare_filenames (home, defhome) )
1823 #else
1824               (*defhome == '~'
1825                 && (strlen (home) >= strlen (defhome+1)
1826                     && !strcmp (home + strlen(home)
1827                                 - strlen (defhome+1), defhome+1)))
1828                || (*defhome != '~' && !strcmp (home, defhome) )
1829 #endif
1830                )
1831             {
1832               if (gnupg_mkdir (home, "-rwx"))
1833                 log_error (_("can't create directory '%s': %s\n"),
1834                            home, strerror (errno) );
1835               else
1836                 {
1837                   if (!opt.quiet)
1838                     log_info (_("directory '%s' created\n"), home);
1839                   create_private_keys_directory (home);
1840                 }
1841             }
1842         }
1843       else
1844         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1845     }
1846   else if ( !S_ISDIR(statbuf.st_mode))
1847     {
1848       log_error (_("can't use '%s' as home directory\n"), home);
1849     }
1850   else /* exists and is a directory. */
1851     {
1852       create_private_keys_directory (home);
1853     }
1854   xfree (home);
1855 }
1856
1857
1858
1859 /* This is the worker for the ticker.  It is called every few seconds
1860    and may only do fast operations. */
1861 static void
1862 handle_tick (void)
1863 {
1864   static time_t last_minute;
1865
1866   if (!last_minute)
1867     last_minute = time (NULL);
1868
1869   /* Check whether the scdaemon has died and cleanup in this case. */
1870   agent_scd_check_aliveness ();
1871
1872   /* If we are running as a child of another process, check whether
1873      the parent is still alive and shutdown if not. */
1874 #ifndef HAVE_W32_SYSTEM
1875   if (parent_pid != (pid_t)(-1))
1876     {
1877       if (kill (parent_pid, 0))
1878         {
1879           shutdown_pending = 2;
1880           log_info ("parent process died - shutting down\n");
1881           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1882           cleanup ();
1883           agent_exit (0);
1884         }
1885     }
1886 #endif /*HAVE_W32_SYSTEM*/
1887
1888   /* Code to be run from time to time.  */
1889 #if CHECK_OWN_SOCKET_INTERVAL > 0
1890   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1891     {
1892       check_own_socket ();
1893       last_minute = time (NULL);
1894     }
1895 #endif
1896
1897 }
1898
1899
1900 /* A global function which allows us to call the reload stuff from
1901    other places too.  This is only used when build for W32.  */
1902 void
1903 agent_sighup_action (void)
1904 {
1905   log_info ("SIGHUP received - "
1906             "re-reading configuration and flushing cache\n");
1907
1908   agent_flush_cache ();
1909   reread_configuration ();
1910   agent_reload_trustlist ();
1911   /* We flush the module name cache so that after installing a
1912      "pinentry" binary that one can be used in case the
1913      "pinentry-basic" fallback was in use.  */
1914   gnupg_module_name_flush_some ();
1915 }
1916
1917
1918 /* A helper function to handle SIGUSR2.  */
1919 static void
1920 agent_sigusr2_action (void)
1921 {
1922   if (opt.verbose)
1923     log_info ("SIGUSR2 received - updating card event counter\n");
1924   /* Nothing to check right now.  We only increment a counter.  */
1925   bump_card_eventcounter ();
1926 }
1927
1928
1929 #ifndef HAVE_W32_SYSTEM
1930 /* The signal handler for this program.  It is expected to be run in
1931    its own trhead and not in the context of a signal handler.  */
1932 static void
1933 handle_signal (int signo)
1934 {
1935   switch (signo)
1936     {
1937 #ifndef HAVE_W32_SYSTEM
1938     case SIGHUP:
1939       agent_sighup_action ();
1940       break;
1941
1942     case SIGUSR1:
1943       log_info ("SIGUSR1 received - printing internal information:\n");
1944       /* Fixme: We need to see how to integrate pth dumping into our
1945          logging system.  */
1946       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1947       agent_query_dump_state ();
1948       agent_scd_dump_state ();
1949       break;
1950
1951     case SIGUSR2:
1952       agent_sigusr2_action ();
1953       break;
1954
1955     case SIGTERM:
1956       if (!shutdown_pending)
1957         log_info ("SIGTERM received - shutting down ...\n");
1958       else
1959         log_info ("SIGTERM received - still %i open connections\n",
1960                   active_connections);
1961       shutdown_pending++;
1962       if (shutdown_pending > 2)
1963         {
1964           log_info ("shutdown forced\n");
1965           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1966           cleanup ();
1967           agent_exit (0);
1968         }
1969       break;
1970
1971     case SIGINT:
1972       log_info ("SIGINT received - immediate shutdown\n");
1973       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1974       cleanup ();
1975       agent_exit (0);
1976       break;
1977 #endif
1978     default:
1979       log_info ("signal %d received - no action defined\n", signo);
1980     }
1981 }
1982 #endif
1983
1984 /* Check the nonce on a new connection.  This is a NOP unless we we
1985    are using our Unix domain socket emulation under Windows.  */
1986 static int
1987 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1988 {
1989   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1990     {
1991       log_info (_("error reading nonce on fd %d: %s\n"),
1992                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1993       assuan_sock_close (ctrl->thread_startup.fd);
1994       xfree (ctrl);
1995       return -1;
1996     }
1997   else
1998     return 0;
1999 }
2000
2001
2002 #ifdef HAVE_W32_SYSTEM
2003 /* The window message processing function for Putty.  Warning: This
2004    code runs as a native Windows thread.  Use of our own functions
2005    needs to be bracket with pth_leave/pth_enter. */
2006 static LRESULT CALLBACK
2007 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2008 {
2009   int ret = 0;
2010   int w32rc;
2011   COPYDATASTRUCT *cds;
2012   const char *mapfile;
2013   HANDLE maphd;
2014   PSID mysid = NULL;
2015   PSID mapsid = NULL;
2016   void *data = NULL;
2017   PSECURITY_DESCRIPTOR psd = NULL;
2018   ctrl_t ctrl = NULL;
2019
2020   if (msg != WM_COPYDATA)
2021     {
2022       return DefWindowProc (hwnd, msg, wparam, lparam);
2023     }
2024
2025   cds = (COPYDATASTRUCT*)lparam;
2026   if (cds->dwData != PUTTY_IPC_MAGIC)
2027     return 0;  /* Ignore data with the wrong magic.  */
2028   mapfile = cds->lpData;
2029   if (!cds->cbData || mapfile[cds->cbData - 1])
2030     return 0;  /* Ignore empty and non-properly terminated strings.  */
2031
2032   if (DBG_IPC)
2033     {
2034       npth_protect ();
2035       log_debug ("ssh map file '%s'", mapfile);
2036       npth_unprotect ();
2037     }
2038
2039   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2040   if (DBG_IPC)
2041     {
2042       npth_protect ();
2043       log_debug ("ssh map handle %p\n", maphd);
2044       npth_unprotect ();
2045     }
2046
2047   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2048     return 0;
2049
2050   npth_protect ();
2051
2052   mysid = w32_get_user_sid ();
2053   if (!mysid)
2054     {
2055       log_error ("error getting my sid\n");
2056       goto leave;
2057     }
2058
2059   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2060                            OWNER_SECURITY_INFORMATION,
2061                            &mapsid, NULL, NULL, NULL,
2062                            &psd);
2063   if (w32rc)
2064     {
2065       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2066       goto leave;
2067     }
2068
2069   if (DBG_IPC)
2070     {
2071       char *sidstr;
2072
2073       if (!ConvertSidToStringSid (mysid, &sidstr))
2074         sidstr = NULL;
2075       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2076       LocalFree (sidstr);
2077       if (!ConvertSidToStringSid (mapsid, &sidstr))
2078         sidstr = NULL;
2079       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2080       LocalFree (sidstr);
2081     }
2082
2083   if (!EqualSid (mysid, mapsid))
2084     {
2085       log_error ("ssh map file has a non-matching sid\n");
2086       goto leave;
2087     }
2088
2089   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2090   if (DBG_IPC)
2091     log_debug ("ssh IPC buffer at %p\n", data);
2092   if (!data)
2093     goto leave;
2094
2095   /* log_printhex ("request:", data, 20); */
2096
2097   ctrl = xtrycalloc (1, sizeof *ctrl);
2098   if (!ctrl)
2099     {
2100       log_error ("error allocating connection control data: %s\n",
2101                  strerror (errno) );
2102       goto leave;
2103     }
2104   ctrl->session_env = session_env_new ();
2105   if (!ctrl->session_env)
2106     {
2107       log_error ("error allocating session environment block: %s\n",
2108                  strerror (errno) );
2109       goto leave;
2110     }
2111
2112   agent_init_default_ctrl (ctrl);
2113   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2114     ret = 1; /* Valid ssh message has been constructed.  */
2115   agent_deinit_default_ctrl (ctrl);
2116   /* log_printhex ("  reply:", data, 20); */
2117
2118  leave:
2119   xfree (ctrl);
2120   if (data)
2121     UnmapViewOfFile (data);
2122   xfree (mapsid);
2123   if (psd)
2124     LocalFree (psd);
2125   xfree (mysid);
2126   CloseHandle (maphd);
2127
2128   npth_unprotect ();
2129
2130   return ret;
2131 }
2132 #endif /*HAVE_W32_SYSTEM*/
2133
2134
2135 #ifdef HAVE_W32_SYSTEM
2136 /* The thread handling Putty's IPC requests.  */
2137 static void *
2138 putty_message_thread (void *arg)
2139 {
2140   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2141                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2142   HWND hwnd;
2143   MSG msg;
2144
2145   (void)arg;
2146
2147   if (opt.verbose)
2148     log_info ("putty message loop thread started\n");
2149
2150   /* The message loop runs as thread independent from our nPth system.
2151      This also means that we need to make sure that we switch back to
2152      our system before calling any no-windows function.  */
2153   npth_unprotect ();
2154
2155   /* First create a window to make sure that a message queue exists
2156      for this thread.  */
2157   if (!RegisterClass (&wndwclass))
2158     {
2159       npth_protect ();
2160       log_error ("error registering Pageant window class");
2161       return NULL;
2162     }
2163   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2164                          0, 0, 0, 0,
2165                          HWND_MESSAGE,  /* hWndParent */
2166                          NULL,          /* hWndMenu   */
2167                          NULL,          /* hInstance  */
2168                          NULL);         /* lpParm     */
2169   if (!hwnd)
2170     {
2171       npth_protect ();
2172       log_error ("error creating Pageant window");
2173       return NULL;
2174     }
2175
2176   while (GetMessage(&msg, NULL, 0, 0))
2177     {
2178       TranslateMessage(&msg);
2179       DispatchMessage(&msg);
2180     }
2181
2182   /* Back to nPth.  */
2183   npth_protect ();
2184
2185   if (opt.verbose)
2186     log_info ("putty message loop thread stopped\n");
2187   return NULL;
2188 }
2189 #endif /*HAVE_W32_SYSTEM*/
2190
2191
2192 static void *
2193 do_start_connection_thread (ctrl_t ctrl)
2194 {
2195   agent_init_default_ctrl (ctrl);
2196   if (opt.verbose)
2197     log_info (_("handler 0x%lx for fd %d started\n"),
2198               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2199
2200   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2201   if (opt.verbose)
2202     log_info (_("handler 0x%lx for fd %d terminated\n"),
2203               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2204
2205   agent_deinit_default_ctrl (ctrl);
2206   xfree (ctrl);
2207   return NULL;
2208 }
2209
2210
2211 /* This is the standard connection thread's main function.  */
2212 static void *
2213 start_connection_thread_std (void *arg)
2214 {
2215   ctrl_t ctrl = arg;
2216
2217   if (check_nonce (ctrl, &socket_nonce))
2218     {
2219       log_error ("handler 0x%lx nonce check FAILED\n",
2220                  (unsigned long) npth_self());
2221       return NULL;
2222     }
2223
2224   return do_start_connection_thread (ctrl);
2225 }
2226
2227
2228 /* This is the extra socket connection thread's main function.  */
2229 static void *
2230 start_connection_thread_extra (void *arg)
2231 {
2232   ctrl_t ctrl = arg;
2233
2234   if (check_nonce (ctrl, &socket_nonce_extra))
2235     {
2236       log_error ("handler 0x%lx nonce check FAILED\n",
2237                  (unsigned long) npth_self());
2238       return NULL;
2239     }
2240
2241   ctrl->restricted = 1;
2242   return do_start_connection_thread (ctrl);
2243 }
2244
2245
2246 /* This is the browser socket connection thread's main function.  */
2247 static void *
2248 start_connection_thread_browser (void *arg)
2249 {
2250   ctrl_t ctrl = arg;
2251
2252   if (check_nonce (ctrl, &socket_nonce_browser))
2253     {
2254       log_error ("handler 0x%lx nonce check FAILED\n",
2255                  (unsigned long) npth_self());
2256       return NULL;
2257     }
2258
2259   ctrl->restricted = 2;
2260   return do_start_connection_thread (ctrl);
2261 }
2262
2263
2264 /* This is the ssh connection thread's main function.  */
2265 static void *
2266 start_connection_thread_ssh (void *arg)
2267 {
2268   ctrl_t ctrl = arg;
2269
2270   if (check_nonce (ctrl, &socket_nonce_ssh))
2271     return NULL;
2272
2273   agent_init_default_ctrl (ctrl);
2274   if (opt.verbose)
2275     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2276               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2277
2278   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2279   if (opt.verbose)
2280     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2281               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2282
2283   agent_deinit_default_ctrl (ctrl);
2284   xfree (ctrl);
2285   return NULL;
2286 }
2287
2288
2289 /* Connection handler loop.  Wait for connection requests and spawn a
2290    thread after accepting a connection.  */
2291 static void
2292 handle_connections (gnupg_fd_t listen_fd,
2293                     gnupg_fd_t listen_fd_extra,
2294                     gnupg_fd_t listen_fd_browser,
2295                     gnupg_fd_t listen_fd_ssh)
2296 {
2297   npth_attr_t tattr;
2298   struct sockaddr_un paddr;
2299   socklen_t plen;
2300   fd_set fdset, read_fdset;
2301   int ret;
2302   gnupg_fd_t fd;
2303   int nfd;
2304   int saved_errno;
2305   struct timespec abstime;
2306   struct timespec curtime;
2307   struct timespec timeout;
2308 #ifdef HAVE_W32_SYSTEM
2309   HANDLE events[2];
2310   unsigned int events_set;
2311 #endif
2312   struct {
2313     const char *name;
2314     void *(*func) (void *arg);
2315     gnupg_fd_t l_fd;
2316   } listentbl[] = {
2317     { "std",     start_connection_thread_std   },
2318     { "extra",   start_connection_thread_extra },
2319     { "browser", start_connection_thread_browser },
2320     { "ssh",    start_connection_thread_ssh   }
2321   };
2322
2323
2324   ret = npth_attr_init(&tattr);
2325   if (ret)
2326     log_fatal ("error allocating thread attributes: %s\n",
2327                strerror (ret));
2328   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2329
2330 #ifndef HAVE_W32_SYSTEM
2331   npth_sigev_init ();
2332   npth_sigev_add (SIGHUP);
2333   npth_sigev_add (SIGUSR1);
2334   npth_sigev_add (SIGUSR2);
2335   npth_sigev_add (SIGINT);
2336   npth_sigev_add (SIGTERM);
2337   npth_sigev_fini ();
2338 #else
2339 # ifdef HAVE_W32CE_SYSTEM
2340   /* Use a dummy event. */
2341   sigs = 0;
2342   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2343 # else
2344   events[0] = get_agent_scd_notify_event ();
2345   events[1] = INVALID_HANDLE_VALUE;
2346 # endif
2347 #endif
2348
2349   /* On Windows we need to fire up a separate thread to listen for
2350      requests from Putty (an SSH client), so we can replace Putty's
2351      Pageant (its ssh-agent implementation). */
2352 #ifdef HAVE_W32_SYSTEM
2353   if (putty_support)
2354     {
2355       npth_t thread;
2356
2357       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2358       if (ret)
2359         {
2360           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2361         }
2362     }
2363 #endif /*HAVE_W32_SYSTEM*/
2364
2365   /* Set a flag to tell call-scd.c that it may enable event
2366      notifications.  */
2367   opt.sigusr2_enabled = 1;
2368
2369   FD_ZERO (&fdset);
2370   FD_SET (FD2INT (listen_fd), &fdset);
2371   nfd = FD2INT (listen_fd);
2372   if (listen_fd_extra != GNUPG_INVALID_FD)
2373     {
2374       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2375       if (FD2INT (listen_fd_extra) > nfd)
2376         nfd = FD2INT (listen_fd_extra);
2377     }
2378   if (listen_fd_browser != GNUPG_INVALID_FD)
2379     {
2380       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2381       if (FD2INT (listen_fd_browser) > nfd)
2382         nfd = FD2INT (listen_fd_browser);
2383     }
2384   if (listen_fd_ssh != GNUPG_INVALID_FD)
2385     {
2386       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2387       if (FD2INT (listen_fd_ssh) > nfd)
2388         nfd = FD2INT (listen_fd_ssh);
2389     }
2390
2391   listentbl[0].l_fd = listen_fd;
2392   listentbl[1].l_fd = listen_fd_extra;
2393   listentbl[2].l_fd = listen_fd_browser;
2394   listentbl[3].l_fd = listen_fd_ssh;
2395
2396   npth_clock_gettime (&abstime);
2397   abstime.tv_sec += TIMERTICK_INTERVAL;
2398
2399   for (;;)
2400     {
2401       /* Shutdown test.  */
2402       if (shutdown_pending)
2403         {
2404           if (active_connections == 0)
2405             break; /* ready */
2406
2407           /* Do not accept new connections but keep on running the
2408              loop to cope with the timer events.  */
2409           FD_ZERO (&fdset);
2410         }
2411
2412       /* POSIX says that fd_set should be implemented as a structure,
2413          thus a simple assignment is fine to copy the entire set.  */
2414       read_fdset = fdset;
2415
2416       npth_clock_gettime (&curtime);
2417       if (!(npth_timercmp (&curtime, &abstime, <)))
2418         {
2419           /* Timeout.  */
2420           handle_tick ();
2421           npth_clock_gettime (&abstime);
2422           abstime.tv_sec += TIMERTICK_INTERVAL;
2423         }
2424       npth_timersub (&abstime, &curtime, &timeout);
2425
2426 #ifndef HAVE_W32_SYSTEM
2427       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2428                           npth_sigev_sigmask ());
2429       saved_errno = errno;
2430
2431       {
2432         int signo;
2433         while (npth_sigev_get_pending (&signo))
2434           handle_signal (signo);
2435       }
2436 #else
2437       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2438                           events, &events_set);
2439       saved_errno = errno;
2440
2441       /* This is valid even if npth_eselect returns an error.  */
2442       if (events_set & 1)
2443         agent_sigusr2_action ();
2444 #endif
2445
2446       if (ret == -1 && saved_errno != EINTR)
2447         {
2448           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2449                      strerror (saved_errno));
2450           npth_sleep (1);
2451           continue;
2452         }
2453       if (ret <= 0)
2454         /* Interrupt or timeout.  Will be handled when calculating the
2455            next timeout.  */
2456         continue;
2457
2458       if (!shutdown_pending)
2459         {
2460           int idx;
2461           ctrl_t ctrl;
2462           npth_t thread;
2463
2464           for (idx=0; idx < DIM(listentbl); idx++)
2465             {
2466               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2467                 continue;
2468               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2469                 continue;
2470
2471               plen = sizeof paddr;
2472               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2473                                         (struct sockaddr *)&paddr, &plen));
2474               if (fd == GNUPG_INVALID_FD)
2475                 {
2476                   log_error ("accept failed for %s: %s\n",
2477                              listentbl[idx].name, strerror (errno));
2478                 }
2479               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2480                 {
2481                   log_error ("error allocating connection data for %s: %s\n",
2482                              listentbl[idx].name, strerror (errno) );
2483                   assuan_sock_close (fd);
2484                 }
2485               else if ( !(ctrl->session_env = session_env_new ()))
2486                 {
2487                   log_error ("error allocating session env block for %s: %s\n",
2488                              listentbl[idx].name, strerror (errno) );
2489                   xfree (ctrl);
2490                   assuan_sock_close (fd);
2491                 }
2492               else
2493                 {
2494                   ctrl->thread_startup.fd = fd;
2495                   ret = npth_create (&thread, &tattr,
2496                                      listentbl[idx].func, ctrl);
2497                   if (ret)
2498                     {
2499                       log_error ("error spawning connection handler for %s:"
2500                                  " %s\n", listentbl[idx].name, strerror (ret));
2501                       assuan_sock_close (fd);
2502                       xfree (ctrl);
2503                     }
2504                 }
2505               fd = GNUPG_INVALID_FD;
2506             }
2507         }
2508     }
2509
2510   cleanup ();
2511   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2512   npth_attr_destroy (&tattr);
2513 }
2514
2515
2516
2517 /* Helper for check_own_socket.  */
2518 static gpg_error_t
2519 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2520 {
2521   membuf_t *mb = opaque;
2522   put_membuf (mb, buffer, length);
2523   return 0;
2524 }
2525
2526
2527 /* The thread running the actual check.  We need to run this in a
2528    separate thread so that check_own_thread can be called from the
2529    timer tick.  */
2530 static void *
2531 check_own_socket_thread (void *arg)
2532 {
2533   int rc;
2534   char *sockname = arg;
2535   assuan_context_t ctx = NULL;
2536   membuf_t mb;
2537   char *buffer;
2538
2539   check_own_socket_running++;
2540
2541   rc = assuan_new (&ctx);
2542   if (rc)
2543     {
2544       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2545       goto leave;
2546     }
2547
2548   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2549   if (rc)
2550     {
2551       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2552       goto leave;
2553     }
2554
2555   init_membuf (&mb, 100);
2556   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2557                         NULL, NULL, NULL, NULL);
2558   put_membuf (&mb, "", 1);
2559   buffer = get_membuf (&mb, NULL);
2560   if (rc || !buffer)
2561     {
2562       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2563                  "GETINFO pid", gpg_strerror (rc));
2564       rc = 1;
2565     }
2566   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2567     {
2568       log_error ("socket is now serviced by another server\n");
2569       rc = 1;
2570     }
2571   else if (opt.verbose > 1)
2572     log_error ("socket is still served by this server\n");
2573
2574   xfree (buffer);
2575
2576  leave:
2577   xfree (sockname);
2578   if (ctx)
2579     assuan_release (ctx);
2580   if (rc)
2581     {
2582       /* We may not remove the socket as it is now in use by another
2583          server.  Setting the name to empty does this.  */
2584       if (socket_name)
2585         *socket_name = 0;
2586       if (socket_name_ssh)
2587         *socket_name_ssh = 0;
2588       shutdown_pending = 2;
2589       log_info ("this process is useless - shutting down\n");
2590     }
2591   check_own_socket_running--;
2592   return NULL;
2593 }
2594
2595
2596 /* Check whether we are still listening on our own socket.  In case
2597    another gpg-agent process started after us has taken ownership of
2598    our socket, we would linger around without any real task.  Thus we
2599    better check once in a while whether we are really needed.  */
2600 static void
2601 check_own_socket (void)
2602 {
2603   char *sockname;
2604   npth_t thread;
2605   npth_attr_t tattr;
2606   int err;
2607
2608   if (disable_check_own_socket)
2609     return;
2610
2611   if (check_own_socket_running || shutdown_pending)
2612     return;  /* Still running or already shutting down.  */
2613
2614   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2615   if (!sockname)
2616     return; /* Out of memory.  */
2617
2618   err = npth_attr_init (&tattr);
2619   if (err)
2620     return;
2621   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2622   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2623   if (err)
2624     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2625   npth_attr_destroy (&tattr);
2626 }
2627
2628
2629
2630 /* Figure out whether an agent is available and running. Prints an
2631    error if not.  If SILENT is true, no messages are printed.
2632    Returns 0 if the agent is running. */
2633 static int
2634 check_for_running_agent (int silent)
2635 {
2636   gpg_error_t err;
2637   char *sockname;
2638   assuan_context_t ctx = NULL;
2639
2640   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2641
2642   err = assuan_new (&ctx);
2643   if (!err)
2644     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2645   xfree (sockname);
2646   if (err)
2647     {
2648       if (!silent)
2649         log_error (_("no gpg-agent running in this session\n"));
2650
2651       if (ctx)
2652         assuan_release (ctx);
2653       return -1;
2654     }
2655
2656   if (!opt.quiet && !silent)
2657     log_info ("gpg-agent running and available\n");
2658
2659   assuan_release (ctx);
2660   return 0;
2661 }