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