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