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