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