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