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