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