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