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