dirmngr/dirmngr.c

   1 /* dirmngr.c - Keyserver and X.509 LDAP access
   2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
   3  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2010, 2011 g10 Code GmbH
   4  * Copyright (C) 2014 Werner Koch
   5  *
   6  * This file is part of GnuPG.
   7  *
   8  * GnuPG is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * GnuPG is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <stddef.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <time.h>
  32 #include <fcntl.h>
  33 #ifndef HAVE_W32_SYSTEM
  34 #include <sys/socket.h>
  35 #include <sys/un.h>
  36 #endif
  37 #include <sys/stat.h>
  38 #include <unistd.h>
  39 #ifdef HAVE_SIGNAL_H
  40 # include <signal.h>
  41 #endif
  42 #ifdef HAVE_INOTIFY_INIT
  43 # include <sys/inotify.h>
  44 #endif /*HAVE_INOTIFY_INIT*/
  45 #include <npth.h>
  46
  47 #include "dirmngr-err.h"
  48
  49 #if  HTTP_USE_NTBTLS
  50 # include <ntbtls.h>
  51 #elif HTTP_USE_GNUTLS
  52 # include <gnutls/gnutls.h>
  53 #endif /*HTTP_USE_GNUTLS*/
  54
  55
  56 #define GNUPG_COMMON_NEED_AFLOCAL
  57 #include "dirmngr.h"
  58
  59 #include <assuan.h>
  60
  61 #include "certcache.h"
  62 #include "crlcache.h"
  63 #include "crlfetch.h"
  64 #include "misc.h"
  65 #if USE_LDAP
  66 # include "ldapserver.h"
  67 #endif
  68 #include "asshelp.h"
  69 #if USE_LDAP
  70 # include "ldap-wrapper.h"
  71 #endif
  72 #include "../common/init.h"
  73 #include "gc-opt-flags.h"
  74 #include "dns-stuff.h"
  75
  76 #ifndef ENAMETOOLONG
  77 # define ENAMETOOLONG EINVAL
  78 #endif
  79
  80
  81 enum cmd_and_opt_values {
  82   aNull = 0,
  83   oCsh            = 'c',
  84   oQuiet          = 'q',
  85   oSh             = 's',
  86   oVerbose        = 'v',
  87   oNoVerbose = 500,
  88
  89   aServer,
  90   aDaemon,
  91   aSupervised,
  92   aListCRLs,
  93   aLoadCRL,
  94   aFetchCRL,
  95   aShutdown,
  96   aFlush,
  97   aGPGConfList,
  98   aGPGConfTest,
  99
 100   oOptions,
 101   oDebug,
 102   oDebugAll,
 103   oDebugWait,
 104   oDebugLevel,
 105   oGnutlsDebug,
 106   oNoGreeting,
 107   oNoOptions,
 108   oHomedir,
 109   oNoDetach,
 110   oLogFile,
 111   oBatch,
 112   oDisableHTTP,
 113   oDisableLDAP,
 114   oIgnoreLDAPDP,
 115   oIgnoreHTTPDP,
 116   oIgnoreOCSPSvcUrl,
 117   oHonorHTTPProxy,
 118   oHTTPProxy,
 119   oLDAPProxy,
 120   oOnlyLDAPProxy,
 121   oLDAPFile,
 122   oLDAPTimeout,
 123   oLDAPAddServers,
 124   oOCSPResponder,
 125   oOCSPSigner,
 126   oOCSPMaxClockSkew,
 127   oOCSPMaxPeriod,
 128   oOCSPCurrentPeriod,
 129   oMaxReplies,
 130   oHkpCaCert,
 131   oFakedSystemTime,
 132   oForce,
 133   oAllowOCSP,
 134   oAllowVersionCheck,
 135   oSocketName,
 136   oLDAPWrapperProgram,
 137   oHTTPWrapperProgram,
 138   oIgnoreCertExtension,
 139   oUseTor,
 140   oKeyServer,
 141   oNameServer,
 142   oDisableCheckOwnSocket,
 143   oStandardResolver,
 144   oRecursiveResolver,
 145   oResolverTimeout,
 146   aTest
 147 };
 148
 149
 150
 151 static ARGPARSE_OPTS opts[] = {
 152
 153   ARGPARSE_group (300, N_("@Commands:\n ")),
 154
 155   ARGPARSE_c (aServer,   "server",  N_("run in server mode (foreground)") ),
 156   ARGPARSE_c (aDaemon,   "daemon",  N_("run in daemon mode (background)") ),
 157 #ifndef HAVE_W32_SYSTEM
 158   ARGPARSE_c (aSupervised,  "supervised", N_("run in supervised mode")),
 159 #endif
 160   ARGPARSE_c (aListCRLs, "list-crls", N_("list the contents of the CRL cache")),
 161   ARGPARSE_c (aLoadCRL,  "load-crl",  N_("|FILE|load CRL from FILE into cache")),
 162   ARGPARSE_c (aFetchCRL, "fetch-crl", N_("|URL|fetch a CRL from URL")),
 163   ARGPARSE_c (aShutdown, "shutdown",  N_("shutdown the dirmngr")),
 164   ARGPARSE_c (aFlush,    "flush",     N_("flush the cache")),
 165   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
 166   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
 167
 168   ARGPARSE_group (301, N_("@\nOptions:\n ")),
 169
 170   ARGPARSE_s_n (oVerbose,  "verbose",   N_("verbose")),
 171   ARGPARSE_s_n (oQuiet,    "quiet",     N_("be somewhat more quiet")),
 172   ARGPARSE_s_n (oSh,       "sh",        N_("sh-style command output")),
 173   ARGPARSE_s_n (oCsh,      "csh",       N_("csh-style command output")),
 174   ARGPARSE_s_s (oOptions,  "options",   N_("|FILE|read options from FILE")),
 175   ARGPARSE_s_s (oDebugLevel, "debug-level",
 176                 N_("|LEVEL|set the debugging level to LEVEL")),
 177   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
 178   ARGPARSE_s_s (oLogFile,  "log-file",
 179                 N_("|FILE|write server mode logs to FILE")),
 180   ARGPARSE_s_n (oBatch,    "batch",       N_("run without asking a user")),
 181   ARGPARSE_s_n (oForce,    "force",       N_("force loading of outdated CRLs")),
 182   ARGPARSE_s_n (oAllowOCSP, "allow-ocsp", N_("allow sending OCSP requests")),
 183   ARGPARSE_s_n (oAllowVersionCheck, "allow-version-check",
 184                 N_("allow online software version check")),
 185   ARGPARSE_s_n (oDisableHTTP, "disable-http", N_("inhibit the use of HTTP")),
 186   ARGPARSE_s_n (oDisableLDAP, "disable-ldap", N_("inhibit the use of LDAP")),
 187   ARGPARSE_s_n (oIgnoreHTTPDP,"ignore-http-dp",
 188                 N_("ignore HTTP CRL distribution points")),
 189   ARGPARSE_s_n (oIgnoreLDAPDP,"ignore-ldap-dp",
 190                 N_("ignore LDAP CRL distribution points")),
 191   ARGPARSE_s_n (oIgnoreOCSPSvcUrl, "ignore-ocsp-service-url",
 192                 N_("ignore certificate contained OCSP service URLs")),
 193
 194   ARGPARSE_s_s (oHTTPProxy,  "http-proxy",
 195                 N_("|URL|redirect all HTTP requests to URL")),
 196   ARGPARSE_s_s (oLDAPProxy,  "ldap-proxy",
 197                 N_("|HOST|use HOST for LDAP queries")),
 198   ARGPARSE_s_n (oOnlyLDAPProxy, "only-ldap-proxy",
 199                 N_("do not use fallback hosts with --ldap-proxy")),
 200
 201   ARGPARSE_s_s (oLDAPFile, "ldapserverlist-file",
 202                 N_("|FILE|read LDAP server list from FILE")),
 203   ARGPARSE_s_n (oLDAPAddServers, "add-servers",
 204                 N_("add new servers discovered in CRL distribution"
 205                    " points to serverlist")),
 206   ARGPARSE_s_i (oLDAPTimeout, "ldaptimeout",
 207                 N_("|N|set LDAP timeout to N seconds")),
 208
 209   ARGPARSE_s_s (oOCSPResponder, "ocsp-responder",
 210                 N_("|URL|use OCSP responder at URL")),
 211   ARGPARSE_s_s (oOCSPSigner, "ocsp-signer",
 212                 N_("|FPR|OCSP response signed by FPR")),
 213   ARGPARSE_s_i (oOCSPMaxClockSkew, "ocsp-max-clock-skew", "@"),
 214   ARGPARSE_s_i (oOCSPMaxPeriod,    "ocsp-max-period", "@"),
 215   ARGPARSE_s_i (oOCSPCurrentPeriod, "ocsp-current-period", "@"),
 216
 217   ARGPARSE_s_i (oMaxReplies, "max-replies",
 218                 N_("|N|do not return more than N items in one query")),
 219
 220   ARGPARSE_s_s (oNameServer, "nameserver", "@"),
 221   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
 222   ARGPARSE_s_s (oHkpCaCert, "hkp-cacert",
 223                 N_("|FILE|use the CA certificates in FILE for HKP over TLS")),
 224
 225   ARGPARSE_s_n (oUseTor, "use-tor", N_("route all network traffic via Tor")),
 226
 227   ARGPARSE_s_s (oSocketName, "socket-name", "@"),  /* Only for debugging.  */
 228
 229   ARGPARSE_s_u (oFakedSystemTime, "faked-system-time", "@"), /*(epoch time)*/
 230   ARGPARSE_s_s (oDebug,    "debug", "@"),
 231   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
 232   ARGPARSE_s_i (oGnutlsDebug, "gnutls-debug", "@"),
 233   ARGPARSE_s_i (oGnutlsDebug, "tls-debug", "@"),
 234   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
 235   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
 236   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
 237   ARGPARSE_s_s (oHomedir, "homedir", "@"),
 238   ARGPARSE_s_s (oLDAPWrapperProgram, "ldap-wrapper-program", "@"),
 239   ARGPARSE_s_s (oHTTPWrapperProgram, "http-wrapper-program", "@"),
 240   ARGPARSE_s_n (oHonorHTTPProxy, "honor-http-proxy", "@"),
 241   ARGPARSE_s_s (oIgnoreCertExtension,"ignore-cert-extension", "@"),
 242   ARGPARSE_s_n (oStandardResolver, "standard-resolver", "@"),
 243   ARGPARSE_s_n (oRecursiveResolver, "recursive-resolver", "@"),
 244   ARGPARSE_s_i (oResolverTimeout, "resolver-timeout", "@"),
 245
 246   ARGPARSE_group (302,N_("@\n(See the \"info\" manual for a complete listing "
 247                          "of all commands and options)\n")),
 248
 249   ARGPARSE_end ()
 250 };
 251
 252 /* The list of supported debug flags.  */
 253 static struct debug_flags_s debug_flags [] =
 254   {
 255     { DBG_X509_VALUE   , "x509"    },
 256     { DBG_CRYPTO_VALUE , "crypto"  },
 257     { DBG_MEMORY_VALUE , "memory"  },
 258     { DBG_CACHE_VALUE  , "cache"   },
 259     { DBG_MEMSTAT_VALUE, "memstat" },
 260     { DBG_HASHING_VALUE, "hashing" },
 261     { DBG_IPC_VALUE    , "ipc"     },
 262     { DBG_DNS_VALUE    , "dns"     },
 263     { DBG_NETWORK_VALUE, "network" },
 264     { DBG_LOOKUP_VALUE , "lookup"  },
 265     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
 266   };
 267
 268 #define DEFAULT_MAX_REPLIES 10
 269 #define DEFAULT_LDAP_TIMEOUT 100 /* arbitrary large timeout */
 270
 271 /* For the cleanup handler we need to keep track of the socket's name.  */
 272 static const char *socket_name;
 273 /* If the socket has been redirected, this is the name of the
 274    redirected socket..  */
 275 static const char *redir_socket_name;
 276
 277 /* We need to keep track of the server's nonces (these are dummies for
 278    POSIX systems). */
 279 static assuan_sock_nonce_t socket_nonce;
 280
 281 /* Only if this flag has been set will we remove the socket file.  */
 282 static int cleanup_socket;
 283
 284 /* Keep track of the current log file so that we can avoid updating
 285    the log file after a SIGHUP if it didn't changed. Malloced. */
 286 static char *current_logfile;
 287
 288 /* Helper to implement --debug-level. */
 289 static const char *debug_level;
 290
 291 /* Helper to set the NTBTLS or GNUTLS log level.  */
 292 static int opt_gnutls_debug = -1;
 293
 294 /* Flag indicating that a shutdown has been requested.  */
 295 static volatile int shutdown_pending;
 296
 297 /* Flags to indicate that we shall not watch our own socket. */
 298 static int disable_check_own_socket;
 299
 300 /* Counter for the active connections.  */
 301 static int active_connections;
 302
 303 /* This flag is set by any network access and used by the housekeeping
 304  * thread to run background network tasks.  */
 305 static int network_activity_seen;
 306
 307 /* This union is used to avoid compiler warnings in case a pointer is
 308    64 bit and an int 32 bit.  We store an integer in a pointer and get
 309    it back later (npth_getspecific et al.).  */
 310 union int_and_ptr_u
 311 {
 312   int  aint;
 313   assuan_fd_t afd;
 314   void *aptr;
 315 };
 316
 317
 318
 319 /* The key used to store the current file descriptor in the thread
 320    local storage.  We use this in conjunction with the
 321    log_set_pid_suffix_cb feature.  */
 322 #ifndef HAVE_W32_SYSTEM
 323 static int my_tlskey_current_fd;
 324 #endif
 325
 326 /* Prototypes. */
 327 static void cleanup (void);
 328 #if USE_LDAP
 329 static ldap_server_t parse_ldapserver_file (const char* filename);
 330 #endif /*USE_LDAP*/
 331 static fingerprint_list_t parse_ocsp_signer (const char *string);
 332 static void netactivity_action (void);
 333 static void handle_connections (assuan_fd_t listen_fd);
 334
 335 /* NPth wrapper function definitions. */
 336 ASSUAN_SYSTEM_NPTH_IMPL;
 337
 338 static const char *
 339 my_strusage( int level )
 340 {
 341   const char *p;
 342   switch ( level )
 343     {
 344     case 11: p = "@DIRMNGR@ (@GNUPG@)";
 345       break;
 346     case 13: p = VERSION; break;
 347     case 17: p = PRINTABLE_OS_NAME; break;
 348       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
 349          reporting address.  This is so that we can change the
 350          reporting address without breaking the translations.  */
 351     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 352     case 49: p = PACKAGE_BUGREPORT; break;
 353     case 1:
 354     case 40: p = _("Usage: @DIRMNGR@ [options] (-h for help)");
 355       break;
 356     case 41: p = _("Syntax: @DIRMNGR@ [options] [command [args]]\n"
 357                    "Keyserver, CRL, and OCSP access for @GNUPG@\n");
 358       break;
 359
 360     default: p = NULL;
 361     }
 362   return p;
 363 }
 364
 365
 366 /* Callback from libksba to hash a provided buffer.  Our current
 367    implementation does only allow SHA-1 for hashing. This may be
 368    extended by mapping the name, testing for algorithm availibility
 369    and adjust the length checks accordingly. */
 370 static gpg_error_t
 371 my_ksba_hash_buffer (void *arg, const char *oid,
 372                      const void *buffer, size_t length, size_t resultsize,
 373                      unsigned char *result, size_t *resultlen)
 374 {
 375   (void)arg;
 376
 377   if (oid && strcmp (oid, "1.3.14.3.2.26"))
 378     return gpg_error (GPG_ERR_NOT_SUPPORTED);
 379   if (resultsize < 20)
 380     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
 381   gcry_md_hash_buffer (2, result, buffer, length);
 382   *resultlen = 20;
 383   return 0;
 384 }
 385
 386
 387 /* GNUTLS log function callback.  */
 388 #ifdef HTTP_USE_GNUTLS
 389 static void
 390 my_gnutls_log (int level, const char *text)
 391 {
 392   int n;
 393
 394   n = strlen (text);
 395   while (n && text[n-1] == '\n')
 396     n--;
 397
 398   log_debug ("gnutls:L%d: %.*s\n", level, n, text);
 399 }
 400 #endif /*HTTP_USE_GNUTLS*/
 401
 402 /* Setup the debugging.  With a LEVEL of NULL only the active debug
 403    flags are propagated to the subsystems.  With LEVEL set, a specific
 404    set of debug flags is set; thus overriding all flags already
 405    set. */
 406 static void
 407 set_debug (void)
 408 {
 409   int numok = (debug_level && digitp (debug_level));
 410   int numlvl = numok? atoi (debug_level) : 0;
 411
 412   if (!debug_level)
 413     ;
 414   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
 415     opt.debug = 0;
 416   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
 417     opt.debug = DBG_IPC_VALUE;
 418   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
 419     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE);
 420   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
 421     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE
 422                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
 423   else if (!strcmp (debug_level, "guru") || numok)
 424     {
 425       opt.debug = ~0;
 426       /* Unless the "guru" string has been used we don't want to allow
 427          hashing debugging.  The rationale is that people tend to
 428          select the highest debug value and would then clutter their
 429          disk with debug files which may reveal confidential data.  */
 430       if (numok)
 431         opt.debug &= ~(DBG_HASHING_VALUE);
 432     }
 433   else
 434     {
 435       log_error (_("invalid debug-level '%s' given\n"), debug_level);
 436       log_info (_("valid debug levels are: %s\n"),
 437                 "none, basic, advanced, expert, guru");
 438       opt.debug = 0; /* Reset debugging, so that prior debug
 439                         statements won't have an undesired effect. */
 440     }
 441
 442
 443   if (opt.debug && !opt.verbose)
 444     {
 445       opt.verbose = 1;
 446       gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 447     }
 448   if (opt.debug && opt.quiet)
 449     opt.quiet = 0;
 450
 451   if (opt.debug & DBG_CRYPTO_VALUE )
 452     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
 453
 454 #if HTTP_USE_NTBTLS
 455   if (opt_gnutls_debug >= 0)
 456     {
 457       ntbtls_set_debug (opt_gnutls_debug, NULL, NULL);
 458     }
 459 #elif HTTP_USE_GNUTLS
 460   if (opt_gnutls_debug >= 0)
 461     {
 462       gnutls_global_set_log_function (my_gnutls_log);
 463       gnutls_global_set_log_level (opt_gnutls_debug);
 464     }
 465 #endif /*HTTP_USE_GNUTLS*/
 466
 467   if (opt.debug)
 468     parse_debug_flag (NULL, &opt.debug, debug_flags);
 469 }
 470
 471
 472 static void
 473 set_tor_mode (void)
 474 {
 475   if (opt.use_tor)
 476     {
 477       /* Enable Tor mode and when called again force a new curcuit
 478        * (e.g. on SIGHUP).  */
 479       enable_dns_tormode (1);
 480       if (assuan_sock_set_flag (ASSUAN_INVALID_FD, "tor-mode", 1))
 481         {
 482           log_error ("error enabling Tor mode: %s\n", strerror (errno));
 483           log_info ("(is your Libassuan recent enough?)\n");
 484         }
 485     }
 486 }
 487
 488
 489 static void
 490 wrong_args (const char *text)
 491 {
 492   es_fprintf (es_stderr, _("usage: %s [options] "), DIRMNGR_NAME);
 493   es_fputs (text, es_stderr);
 494   es_putc ('\n', es_stderr);
 495   dirmngr_exit (2);
 496 }
 497
 498
 499 /* Helper to stop the reaper thread for the ldap wrapper.  */
 500 static void
 501 shutdown_reaper (void)
 502 {
 503 #if USE_LDAP
 504   ldap_wrapper_wait_connections ();
 505 #endif
 506 }
 507
 508
 509 /* Handle options which are allowed to be reset after program start.
 510    Return true if the current option in PARGS could be handled and
 511    false if not.  As a special feature, passing a value of NULL for
 512    PARGS, resets the options to the default.  REREAD should be set
 513    true if it is not the initial option parsing. */
 514 static int
 515 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
 516 {
 517   if (!pargs)
 518     { /* Reset mode. */
 519       opt.quiet = 0;
 520       opt.verbose = 0;
 521       opt.debug = 0;
 522       opt.ldap_wrapper_program = NULL;
 523       opt.disable_http = 0;
 524       opt.disable_ldap = 0;
 525       opt.honor_http_proxy = 0;
 526       opt.http_proxy = NULL;
 527       opt.ldap_proxy = NULL;
 528       opt.only_ldap_proxy = 0;
 529       opt.ignore_http_dp = 0;
 530       opt.ignore_ldap_dp = 0;
 531       opt.ignore_ocsp_service_url = 0;
 532       opt.allow_ocsp = 0;
 533       opt.allow_version_check = 0;
 534       opt.ocsp_responder = NULL;
 535       opt.ocsp_max_clock_skew = 10 * 60;      /* 10 minutes.  */
 536       opt.ocsp_max_period = 90 * 86400;       /* 90 days.  */
 537       opt.ocsp_current_period = 3 * 60 * 60;  /* 3 hours. */
 538       opt.max_replies = DEFAULT_MAX_REPLIES;
 539       while (opt.ocsp_signer)
 540         {
 541           fingerprint_list_t tmp = opt.ocsp_signer->next;
 542           xfree (opt.ocsp_signer);
 543           opt.ocsp_signer = tmp;
 544         }
 545       FREE_STRLIST (opt.ignored_cert_extensions);
 546       http_register_tls_ca (NULL);
 547       FREE_STRLIST (opt.keyserver);
 548       /* Note: We do not allow resetting of opt.use_tor at runtime.  */
 549       disable_check_own_socket = 0;
 550       enable_standard_resolver (0);
 551       set_dns_timeout (0);
 552       return 1;
 553     }
 554
 555   switch (pargs->r_opt)
 556     {
 557     case oQuiet:   opt.quiet = 1; break;
 558     case oVerbose: opt.verbose++; break;
 559     case oDebug:
 560       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
 561       break;
 562     case oDebugAll: opt.debug = ~0; break;
 563     case oDebugLevel: debug_level = pargs->r.ret_str; break;
 564     case oGnutlsDebug: opt_gnutls_debug = pargs->r.ret_int; break;
 565
 566     case oLogFile:
 567       if (!reread)
 568         return 0; /* Not handled. */
 569       if (!current_logfile || !pargs->r.ret_str
 570           || strcmp (current_logfile, pargs->r.ret_str))
 571         {
 572           log_set_file (pargs->r.ret_str);
 573           xfree (current_logfile);
 574           current_logfile = xtrystrdup (pargs->r.ret_str);
 575         }
 576       break;
 577
 578     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
 579
 580     case oLDAPWrapperProgram:
 581       opt.ldap_wrapper_program = pargs->r.ret_str;
 582       break;
 583     case oHTTPWrapperProgram:
 584       opt.http_wrapper_program = pargs->r.ret_str;
 585       break;
 586
 587     case oDisableHTTP: opt.disable_http = 1; break;
 588     case oDisableLDAP: opt.disable_ldap = 1; break;
 589     case oHonorHTTPProxy: opt.honor_http_proxy = 1; break;
 590     case oHTTPProxy: opt.http_proxy = pargs->r.ret_str; break;
 591     case oLDAPProxy: opt.ldap_proxy = pargs->r.ret_str; break;
 592     case oOnlyLDAPProxy: opt.only_ldap_proxy = 1; break;
 593     case oIgnoreHTTPDP: opt.ignore_http_dp = 1; break;
 594     case oIgnoreLDAPDP: opt.ignore_ldap_dp = 1; break;
 595     case oIgnoreOCSPSvcUrl: opt.ignore_ocsp_service_url = 1; break;
 596
 597     case oAllowOCSP: opt.allow_ocsp = 1; break;
 598     case oAllowVersionCheck: opt.allow_version_check = 1; break;
 599     case oOCSPResponder: opt.ocsp_responder = pargs->r.ret_str; break;
 600     case oOCSPSigner:
 601       opt.ocsp_signer = parse_ocsp_signer (pargs->r.ret_str);
 602       break;
 603     case oOCSPMaxClockSkew: opt.ocsp_max_clock_skew = pargs->r.ret_int; break;
 604     case oOCSPMaxPeriod: opt.ocsp_max_period = pargs->r.ret_int; break;
 605     case oOCSPCurrentPeriod: opt.ocsp_current_period = pargs->r.ret_int; break;
 606
 607     case oMaxReplies: opt.max_replies = pargs->r.ret_int; break;
 608
 609     case oHkpCaCert:
 610       {
 611         char *tmpname;
 612
 613         /* Do tilde expansion and make path absolute.  */
 614         tmpname = make_absfilename (pargs->r.ret_str, NULL);
 615         http_register_tls_ca (tmpname);
 616         xfree (tmpname);
 617       }
 618       break;
 619
 620     case oIgnoreCertExtension:
 621       add_to_strlist (&opt.ignored_cert_extensions, pargs->r.ret_str);
 622       break;
 623
 624     case oUseTor: opt.use_tor = 1; break;
 625
 626     case oStandardResolver: enable_standard_resolver (1); break;
 627     case oRecursiveResolver: enable_recursive_resolver (1); break;
 628
 629     case oKeyServer:
 630       if (*pargs->r.ret_str)
 631         add_to_strlist (&opt.keyserver, pargs->r.ret_str);
 632       break;
 633
 634     case oNameServer:
 635       set_dns_nameserver (pargs->r.ret_str);
 636       break;
 637
 638     case oResolverTimeout:
 639       set_dns_timeout (pargs->r.ret_int);
 640       break;
 641
 642     default:
 643       return 0; /* Not handled. */
 644     }
 645
 646   set_dns_verbose (opt.verbose, !!DBG_DNS);
 647   http_set_verbose (opt.verbose, !!DBG_NETWORK);
 648
 649   return 1; /* Handled. */
 650 }
 651
 652
 653 #ifndef HAVE_W32_SYSTEM
 654 static int
 655 pid_suffix_callback (unsigned long *r_suffix)
 656 {
 657   union int_and_ptr_u value;
 658
 659   memset (&value, 0, sizeof value);
 660   value.aptr = npth_getspecific (my_tlskey_current_fd);
 661   *r_suffix = value.aint;
 662   return (*r_suffix != -1);  /* Use decimal representation.  */
 663 }
 664 #endif /*!HAVE_W32_SYSTEM*/
 665
 666
 667 static void
 668 thread_init (void)
 669 {
 670   npth_init ();
 671   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
 672
 673   /* Now with NPth running we can set the logging callback.  Our
 674      windows implementation does not yet feature the NPth TLS
 675      functions.  */
 676 #ifndef HAVE_W32_SYSTEM
 677   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
 678     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
 679       log_set_pid_suffix_cb (pid_suffix_callback);
 680 #endif /*!HAVE_W32_SYSTEM*/
 681 }
 682
 683
 684 int
 685 main (int argc, char **argv)
 686 {
 687   enum cmd_and_opt_values cmd = 0;
 688   ARGPARSE_ARGS pargs;
 689   int orig_argc;
 690   char **orig_argv;
 691   FILE *configfp = NULL;
 692   char *configname = NULL;
 693   const char *shell;
 694   unsigned configlineno;
 695   int parse_debug = 0;
 696   int default_config =1;
 697   int greeting = 0;
 698   int nogreeting = 0;
 699   int nodetach = 0;
 700   int csh_style = 0;
 701   char *logfile = NULL;
 702 #if USE_LDAP
 703   char *ldapfile = NULL;
 704 #endif /*USE_LDAP*/
 705   int debug_wait = 0;
 706   int rc;
 707   struct assuan_malloc_hooks malloc_hooks;
 708
 709   early_system_init ();
 710   set_strusage (my_strusage);
 711   log_set_prefix (DIRMNGR_NAME, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
 712
 713   /* Make sure that our subsystems are ready.  */
 714   i18n_init ();
 715   init_common_subsystems (&argc, &argv);
 716
 717   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
 718
 719  /* Check that the libraries are suitable.  Do it here because
 720     the option parsing may need services of the libraries. */
 721   if (!ksba_check_version (NEED_KSBA_VERSION) )
 722     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
 723                NEED_KSBA_VERSION, ksba_check_version (NULL) );
 724
 725   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
 726   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
 727
 728   /* Init TLS library.  */
 729 #if HTTP_USE_NTBTLS
 730   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
 731     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
 732                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
 733 #elif HTTP_USE_GNUTLS
 734   rc = gnutls_global_init ();
 735   if (rc)
 736     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
 737 #endif /*HTTP_USE_GNUTLS*/
 738
 739   /* Init Assuan. */
 740   malloc_hooks.malloc = gcry_malloc;
 741   malloc_hooks.realloc = gcry_realloc;
 742   malloc_hooks.free = gcry_free;
 743   assuan_set_malloc_hooks (&malloc_hooks);
 744   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
 745   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
 746   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
 747   assuan_sock_init ();
 748   setup_libassuan_logging (&opt.debug, dirmngr_assuan_log_monitor);
 749
 750   setup_libgcrypt_logging ();
 751
 752   /* Setup defaults. */
 753   shell = getenv ("SHELL");
 754   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
 755     csh_style = 1;
 756
 757   /* Reset rereadable options to default values. */
 758   parse_rereadable_options (NULL, 0);
 759
 760   /* LDAP defaults.  */
 761   opt.add_new_ldapservers = 0;
 762   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
 763
 764   /* Other defaults.  */
 765
 766   /* Check whether we have a config file given on the commandline */
 767   orig_argc = argc;
 768   orig_argv = argv;
 769   pargs.argc = &argc;
 770   pargs.argv = &argv;
 771   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
 772   while (arg_parse( &pargs, opts))
 773     {
 774       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
 775         parse_debug++;
 776       else if (pargs.r_opt == oOptions)
 777         { /* Yes there is one, so we do not try the default one, but
 778              read the option file when it is encountered at the
 779              commandline */
 780           default_config = 0;
 781         }
 782       else if (pargs.r_opt == oNoOptions)
 783         default_config = 0; /* --no-options */
 784       else if (pargs.r_opt == oHomedir)
 785         {
 786           gnupg_set_homedir (pargs.r.ret_str);
 787         }
 788     }
 789
 790   socket_name = dirmngr_socket_name ();
 791   if (default_config)
 792     configname = make_filename (gnupg_homedir (), DIRMNGR_NAME".conf", NULL );
 793
 794   argc = orig_argc;
 795   argv = orig_argv;
 796   pargs.argc = &argc;
 797   pargs.argv = &argv;
 798   pargs.flags= 1;  /* do not remove the args */
 799  next_pass:
 800   if (configname)
 801     {
 802       configlineno = 0;
 803       configfp = fopen (configname, "r");
 804       if (!configfp)
 805         {
 806           if (default_config)
 807             {
 808               if( parse_debug )
 809                 log_info (_("Note: no default option file '%s'\n"),
 810                           configname );
 811             }
 812           else
 813             {
 814               log_error (_("option file '%s': %s\n"),
 815                          configname, strerror(errno) );
 816               exit(2);
 817             }
 818           xfree (configname);
 819           configname = NULL;
 820         }
 821       if (parse_debug && configname )
 822         log_info (_("reading options from '%s'\n"), configname );
 823       default_config = 0;
 824     }
 825
 826   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
 827     {
 828       if (parse_rereadable_options (&pargs, 0))
 829         continue; /* Already handled */
 830       switch (pargs.r_opt)
 831         {
 832         case aServer:
 833         case aDaemon:
 834         case aSupervised:
 835         case aShutdown:
 836         case aFlush:
 837         case aListCRLs:
 838         case aLoadCRL:
 839         case aFetchCRL:
 840         case aGPGConfList:
 841         case aGPGConfTest:
 842           cmd = pargs.r_opt;
 843           break;
 844
 845         case oQuiet: opt.quiet = 1; break;
 846         case oVerbose: opt.verbose++; break;
 847         case oBatch: opt.batch=1; break;
 848
 849         case oDebugWait: debug_wait = pargs.r.ret_int; break;
 850
 851         case oOptions:
 852           /* Config files may not be nested (silently ignore them) */
 853           if (!configfp)
 854             {
 855                 xfree(configname);
 856                 configname = xstrdup(pargs.r.ret_str);
 857                 goto next_pass;
 858             }
 859           break;
 860         case oNoGreeting: nogreeting = 1; break;
 861         case oNoVerbose: opt.verbose = 0; break;
 862         case oNoOptions: break; /* no-options */
 863         case oHomedir: /* Ignore this option here. */; break;
 864         case oNoDetach: nodetach = 1; break;
 865         case oLogFile: logfile = pargs.r.ret_str; break;
 866         case oCsh: csh_style = 1; break;
 867         case oSh: csh_style = 0; break;
 868         case oLDAPFile:
 869 #        if USE_LDAP
 870           ldapfile = pargs.r.ret_str;
 871 #        endif /*USE_LDAP*/
 872           break;
 873         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
 874         case oLDAPTimeout:
 875           opt.ldaptimeout = pargs.r.ret_int;
 876           break;
 877
 878         case oFakedSystemTime:
 879           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
 880           break;
 881
 882         case oForce: opt.force = 1; break;
 883
 884         case oSocketName: socket_name = pargs.r.ret_str; break;
 885
 886         default : pargs.err = configfp? 1:2; break;
 887         }
 888     }
 889   if (configfp)
 890     {
 891       fclose (configfp);
 892       configfp = NULL;
 893       /* Keep a copy of the name so that it can be read on SIGHUP. */
 894       opt.config_filename = configname;
 895       configname = NULL;
 896       goto next_pass;
 897     }
 898   xfree (configname);
 899   configname = NULL;
 900   if (log_get_errorcount(0))
 901     exit(2);
 902   if (nogreeting )
 903     greeting = 0;
 904
 905   if (!opt.homedir_cache)
 906     opt.homedir_cache = xstrdup (gnupg_homedir ());
 907
 908   if (greeting)
 909     {
 910       es_fprintf (es_stderr, "%s %s; %s\n",
 911                   strusage(11), strusage(13), strusage(14) );
 912       es_fprintf (es_stderr, "%s\n", strusage(15) );
 913     }
 914
 915 #ifdef IS_DEVELOPMENT_VERSION
 916   log_info ("NOTE: this is a development version!\n");
 917 #endif
 918
 919   /* Print a warning if an argument looks like an option.  */
 920   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
 921     {
 922       int i;
 923
 924       for (i=0; i < argc; i++)
 925         if (argv[i][0] == '-' && argv[i][1] == '-')
 926           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
 927     }
 928
 929   if (!access ("/etc/"DIRMNGR_NAME, F_OK)
 930       && !strncmp (gnupg_homedir (), "/etc/", 5))
 931     log_info
 932       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
 933        " other directory names changed.  Please check that no other version"
 934        " of dirmngr is still installed.  To disable this warning, remove the"
 935        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
 936
 937   if (gnupg_faked_time_p ())
 938     {
 939       gnupg_isotime_t tbuf;
 940
 941       log_info (_("WARNING: running with faked system time: "));
 942       gnupg_get_isotime (tbuf);
 943       dump_isotime (tbuf);
 944       log_printf ("\n");
 945     }
 946
 947   set_debug ();
 948   set_tor_mode ();
 949
 950   /* Get LDAP server list from file. */
 951 #if USE_LDAP
 952   if (!ldapfile)
 953     {
 954       ldapfile = make_filename (gnupg_homedir (),
 955                                 "dirmngr_ldapservers.conf",
 956                                 NULL);
 957       opt.ldapservers = parse_ldapserver_file (ldapfile);
 958       xfree (ldapfile);
 959     }
 960   else
 961       opt.ldapservers = parse_ldapserver_file (ldapfile);
 962 #endif /*USE_LDAP*/
 963
 964 #ifndef HAVE_W32_SYSTEM
 965   /* We need to ignore the PIPE signal because the we might log to a
 966      socket and that code handles EPIPE properly.  The ldap wrapper
 967      also requires us to ignore this silly signal. Assuan would set
 968      this signal to ignore anyway.*/
 969   signal (SIGPIPE, SIG_IGN);
 970 #endif
 971
 972   /* Ready.  Now to our duties. */
 973   if (!cmd)
 974     cmd = aServer;
 975   rc = 0;
 976
 977   if (cmd == aServer)
 978     {
 979       /* Note that this server mode is mainly useful for debugging.  */
 980       if (argc)
 981         wrong_args ("--server");
 982
 983       if (logfile)
 984         {
 985           log_set_file (logfile);
 986           log_set_prefix (NULL, GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
 987         }
 988
 989       if (debug_wait)
 990         {
 991           log_debug ("waiting for debugger - my pid is %u .....\n",
 992                      (unsigned int)getpid());
 993           gnupg_sleep (debug_wait);
 994           log_debug ("... okay\n");
 995         }
 996
 997
 998       thread_init ();
 999       cert_cache_init ();
1000       crl_cache_init ();
1001       http_register_netactivity_cb (netactivity_action);
1002       start_command_handler (ASSUAN_INVALID_FD);
1003       shutdown_reaper ();
1004     }
1005 #ifndef HAVE_W32_SYSTEM
1006   else if (cmd == aSupervised)
1007     {
1008       /* In supervised mode, we expect file descriptor 3 to be an
1009          already opened, listening socket.
1010
1011          We will also not detach from the controlling process or close
1012          stderr; the supervisor should handle all of that.  */
1013       struct stat statbuf;
1014       if (fstat (3, &statbuf) == -1 && errno == EBADF)
1015         {
1016           log_error ("file descriptor 3 must be validin --supervised mode\n");
1017           dirmngr_exit (1);
1018         }
1019       socket_name = gnupg_get_socket_name (3);
1020
1021       /* Now start with logging to a file if this is desired. */
1022       if (logfile)
1023         {
1024           log_set_file (logfile);
1025           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1026                                  |GPGRT_LOG_WITH_TIME
1027                                  |GPGRT_LOG_WITH_PID));
1028           current_logfile = xstrdup (logfile);
1029         }
1030       else
1031         log_set_prefix (NULL, 0);
1032
1033       thread_init ();
1034       cert_cache_init ();
1035       crl_cache_init ();
1036       http_register_netactivity_cb (netactivity_action);
1037       handle_connections (3);
1038       shutdown_reaper ();
1039     }
1040 #endif /*HAVE_W32_SYSTEM*/
1041   else if (cmd == aDaemon)
1042     {
1043       assuan_fd_t fd;
1044       pid_t pid;
1045       int len;
1046       struct sockaddr_un serv_addr;
1047
1048       if (argc)
1049         wrong_args ("--daemon");
1050
1051       /* Now start with logging to a file if this is desired. */
1052       if (logfile)
1053         {
1054           log_set_file (logfile);
1055           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1056                                  |GPGRT_LOG_WITH_TIME
1057                                  |GPGRT_LOG_WITH_PID));
1058           current_logfile = xstrdup (logfile);
1059         }
1060
1061 #ifndef HAVE_W32_SYSTEM
1062       if (strchr (socket_name, ':'))
1063         {
1064           log_error (_("colons are not allowed in the socket name\n"));
1065           dirmngr_exit (1);
1066         }
1067 #endif
1068       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1069       if (fd == ASSUAN_INVALID_FD)
1070         {
1071           log_error (_("can't create socket: %s\n"), strerror (errno));
1072           cleanup ();
1073           dirmngr_exit (1);
1074         }
1075
1076       {
1077         int redirected;
1078
1079         if (assuan_sock_set_sockaddr_un (socket_name,
1080                                          (struct sockaddr*)&serv_addr,
1081                                          &redirected))
1082           {
1083             if (errno == ENAMETOOLONG)
1084               log_error (_("socket name '%s' is too long\n"), socket_name);
1085             else
1086               log_error ("error preparing socket '%s': %s\n",
1087                          socket_name,
1088                          gpg_strerror (gpg_error_from_syserror ()));
1089             dirmngr_exit (1);
1090           }
1091         if (redirected)
1092           {
1093             redir_socket_name = xstrdup (serv_addr.sun_path);
1094             if (opt.verbose)
1095               log_info ("redirecting socket '%s' to '%s'\n",
1096                         socket_name, redir_socket_name);
1097           }
1098       }
1099
1100       len = SUN_LEN (&serv_addr);
1101
1102       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1103       if (rc == -1
1104           && (errno == EADDRINUSE
1105 #ifdef HAVE_W32_SYSTEM
1106               || errno == EEXIST
1107 #endif
1108               ))
1109         {
1110           /* Fixme: We should test whether a dirmngr is already running. */
1111           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1112           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1113         }
1114       if (rc != -1
1115           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1116         log_error (_("error getting nonce for the socket\n"));
1117       if (rc == -1)
1118         {
1119           log_error (_("error binding socket to '%s': %s\n"),
1120                      serv_addr.sun_path,
1121                      gpg_strerror (gpg_error_from_errno (errno)));
1122           assuan_sock_close (fd);
1123           dirmngr_exit (1);
1124         }
1125       cleanup_socket = 1;
1126
1127       if (gnupg_chmod (serv_addr.sun_path, "-rwx"))
1128         log_error (_("can't set permissions of '%s': %s\n"),
1129                    serv_addr.sun_path, strerror (errno));
1130
1131       if (listen (FD2INT (fd), 5) == -1)
1132         {
1133           log_error (_("listen() failed: %s\n"), strerror (errno));
1134           assuan_sock_close (fd);
1135           dirmngr_exit (1);
1136         }
1137
1138       if (opt.verbose)
1139         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1140
1141       es_fflush (NULL);
1142
1143       /* Note: We keep the dirmngr_info output only for the sake of
1144          existing scripts which might use this to detect a successful
1145          start of the dirmngr.  */
1146 #ifdef HAVE_W32_SYSTEM
1147       (void)csh_style;
1148       (void)nodetach;
1149
1150       pid = getpid ();
1151       es_printf ("set %s=%s;%lu;1\n",
1152                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1153 #else
1154       pid = fork();
1155       if (pid == (pid_t)-1)
1156         {
1157           log_fatal (_("error forking process: %s\n"), strerror (errno));
1158           dirmngr_exit (1);
1159         }
1160
1161       if (pid)
1162         { /* We are the parent */
1163           char *infostr;
1164
1165           /* Don't let cleanup() remove the socket - the child is
1166              responsible for doing that.  */
1167           cleanup_socket = 0;
1168
1169           close (fd);
1170
1171           /* Create the info string: <name>:<pid>:<protocol_version> */
1172           if (asprintf (&infostr, "%s=%s:%lu:1",
1173                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1174             {
1175               log_error (_("out of core\n"));
1176               kill (pid, SIGTERM);
1177               dirmngr_exit (1);
1178             }
1179           /* Print the environment string, so that the caller can use
1180              shell's eval to set it.  But see above.  */
1181           if (csh_style)
1182             {
1183               *strchr (infostr, '=') = ' ';
1184               es_printf ( "setenv %s;\n", infostr);
1185             }
1186           else
1187             {
1188               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1189             }
1190           free (infostr);
1191           exit (0);
1192           /*NEVER REACHED*/
1193         } /* end parent */
1194
1195
1196       /*
1197          This is the child
1198        */
1199
1200       /* Detach from tty and put process into a new session */
1201       if (!nodetach )
1202         {
1203           int i;
1204           unsigned int oldflags;
1205
1206           /* Close stdin, stdout and stderr unless it is the log stream */
1207           for (i=0; i <= 2; i++)
1208             {
1209               if (!log_test_fd (i) && i != fd )
1210                 {
1211                   if ( !close (i)
1212                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1213                     {
1214                       log_error ("failed to open '%s': %s\n",
1215                                  "/dev/null", strerror (errno));
1216                       cleanup ();
1217                       dirmngr_exit (1);
1218                     }
1219                 }
1220             }
1221
1222           if (setsid() == -1)
1223             {
1224               log_error ("setsid() failed: %s\n", strerror(errno) );
1225               dirmngr_exit (1);
1226             }
1227
1228           log_get_prefix (&oldflags);
1229           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1230           opt.running_detached = 1;
1231
1232           if (chdir("/"))
1233             {
1234               log_error ("chdir to / failed: %s\n", strerror (errno));
1235               dirmngr_exit (1);
1236             }
1237         }
1238 #endif
1239
1240       thread_init ();
1241       cert_cache_init ();
1242       crl_cache_init ();
1243       http_register_netactivity_cb (netactivity_action);
1244       handle_connections (fd);
1245       shutdown_reaper ();
1246     }
1247   else if (cmd == aListCRLs)
1248     {
1249       /* Just list the CRL cache and exit. */
1250       if (argc)
1251         wrong_args ("--list-crls");
1252       crl_cache_init ();
1253       crl_cache_list (es_stdout);
1254     }
1255   else if (cmd == aLoadCRL)
1256     {
1257       struct server_control_s ctrlbuf;
1258
1259       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1260       dirmngr_init_default_ctrl (&ctrlbuf);
1261
1262       thread_init ();
1263       cert_cache_init ();
1264       crl_cache_init ();
1265       if (!argc)
1266         rc = crl_cache_load (&ctrlbuf, NULL);
1267       else
1268         {
1269           for (; !rc && argc; argc--, argv++)
1270             rc = crl_cache_load (&ctrlbuf, *argv);
1271         }
1272       dirmngr_deinit_default_ctrl (&ctrlbuf);
1273     }
1274   else if (cmd == aFetchCRL)
1275     {
1276       ksba_reader_t reader;
1277       struct server_control_s ctrlbuf;
1278
1279       if (argc != 1)
1280         wrong_args ("--fetch-crl URL");
1281
1282       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1283       dirmngr_init_default_ctrl (&ctrlbuf);
1284
1285       thread_init ();
1286       cert_cache_init ();
1287       crl_cache_init ();
1288       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1289       if (rc)
1290         log_error (_("fetching CRL from '%s' failed: %s\n"),
1291                      argv[0], gpg_strerror (rc));
1292       else
1293         {
1294           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1295           if (rc)
1296             log_error (_("processing CRL from '%s' failed: %s\n"),
1297                        argv[0], gpg_strerror (rc));
1298           crl_close_reader (reader);
1299         }
1300       dirmngr_deinit_default_ctrl (&ctrlbuf);
1301     }
1302   else if (cmd == aFlush)
1303     {
1304       /* Delete cache and exit. */
1305       if (argc)
1306         wrong_args ("--flush");
1307       rc = crl_cache_flush();
1308     }
1309   else if (cmd == aGPGConfTest)
1310     dirmngr_exit (0);
1311   else if (cmd == aGPGConfList)
1312     {
1313       unsigned long flags = 0;
1314       char *filename;
1315       char *filename_esc;
1316
1317       /* First the configuration file.  This is not an option, but it
1318          is vital information for GPG Conf.  */
1319       if (!opt.config_filename)
1320         opt.config_filename = make_filename (gnupg_homedir (),
1321                                              "dirmngr.conf", NULL );
1322
1323       filename = percent_escape (opt.config_filename, NULL);
1324       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1325               GC_OPT_FLAG_DEFAULT, filename);
1326       xfree (filename);
1327
1328       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1329       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1330       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1331       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1332       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1333
1334       /* --csh and --sh are mutually exclusive, something we can not
1335          express in GPG Conf.  --options is only usable from the
1336          command line, really.  --debug-all interacts with --debug,
1337          and having both of them is thus problematic.  --no-detach is
1338          also only usable on the command line.  --batch is unused.  */
1339
1340       filename = make_filename (gnupg_homedir (),
1341                                 "dirmngr_ldapservers.conf",
1342                                 NULL);
1343       filename_esc = percent_escape (filename, NULL);
1344       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1345               filename_esc);
1346       xfree (filename_esc);
1347       xfree (filename);
1348
1349       es_printf ("ldaptimeout:%lu:%u\n",
1350               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1351       es_printf ("max-replies:%lu:%u\n",
1352               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1353       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1354       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1355       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1356       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1357
1358       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1359       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1360
1361       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1362       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1363       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1364       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1365       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1366       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1367       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1368       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1369       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1370       /* Note: The next one is to fix a typo in gpgconf - should be
1371          removed eventually. */
1372       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1373
1374       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1375       es_printf ("keyserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1376       es_printf ("nameserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1377       es_printf ("resolver-timeout:%lu:%u\n",
1378                  flags | GC_OPT_FLAG_DEFAULT, 0);
1379     }
1380   cleanup ();
1381   return !!rc;
1382 }
1383
1384
1385 static void
1386 cleanup (void)
1387 {
1388   crl_cache_deinit ();
1389   cert_cache_deinit (1);
1390   reload_dns_stuff (1);
1391
1392 #if USE_LDAP
1393   ldapserver_list_free (opt.ldapservers);
1394 #endif /*USE_LDAP*/
1395   opt.ldapservers = NULL;
1396
1397   if (cleanup_socket)
1398     {
1399       cleanup_socket = 0;
1400       if (redir_socket_name)
1401         gnupg_remove (redir_socket_name);
1402       else if (socket_name && *socket_name)
1403         gnupg_remove (socket_name);
1404     }
1405 }
1406
1407
1408 void
1409 dirmngr_exit (int rc)
1410 {
1411   cleanup ();
1412   exit (rc);
1413 }
1414
1415
1416 void
1417 dirmngr_init_default_ctrl (ctrl_t ctrl)
1418 {
1419   if (opt.http_proxy)
1420     ctrl->http_proxy = xstrdup (opt.http_proxy);
1421 }
1422
1423
1424 void
1425 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1426 {
1427   if (!ctrl)
1428     return;
1429   xfree (ctrl->http_proxy);
1430   ctrl->http_proxy = NULL;
1431 }
1432
1433
1434 /* Create a list of LDAP servers from the file FILENAME. Returns the
1435    list or NULL in case of errors.
1436
1437    The format fo such a file is line oriented where empty lines and
1438    lines starting with a hash mark are ignored.  All other lines are
1439    assumed to be colon seprated with these fields:
1440
1441    1. field: Hostname
1442    2. field: Portnumber
1443    3. field: Username
1444    4. field: Password
1445    5. field: Base DN
1446
1447 */
1448 #if USE_LDAP
1449 static ldap_server_t
1450 parse_ldapserver_file (const char* filename)
1451 {
1452   char buffer[1024];
1453   char *p;
1454   ldap_server_t server, serverstart, *serverend;
1455   int c;
1456   unsigned int lineno = 0;
1457   estream_t fp;
1458
1459   fp = es_fopen (filename, "r");
1460   if (!fp)
1461     {
1462       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1463       return NULL;
1464     }
1465
1466   serverstart = NULL;
1467   serverend = &serverstart;
1468   while (es_fgets (buffer, sizeof buffer, fp))
1469     {
1470       lineno++;
1471       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1472         {
1473           if (*buffer && es_feof (fp))
1474             ; /* Last line not terminated - continue. */
1475           else
1476             {
1477               log_error (_("%s:%u: line too long - skipped\n"),
1478                          filename, lineno);
1479               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1480                 ; /* Skip until end of line. */
1481               continue;
1482             }
1483         }
1484       /* Skip empty and comment lines.*/
1485       for (p=buffer; spacep (p); p++)
1486         ;
1487       if (!*p || *p == '\n' || *p == '#')
1488         continue;
1489
1490       /* Parse the colon separated fields. */
1491       server = ldapserver_parse_one (buffer, filename, lineno);
1492       if (server)
1493         {
1494           *serverend = server;
1495           serverend = &server->next;
1496         }
1497     }
1498
1499   if (es_ferror (fp))
1500     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1501   es_fclose (fp);
1502
1503   return serverstart;
1504 }
1505 #endif /*USE_LDAP*/
1506
1507 static fingerprint_list_t
1508 parse_ocsp_signer (const char *string)
1509 {
1510   gpg_error_t err;
1511   char *fname;
1512   estream_t fp;
1513   char line[256];
1514   char *p;
1515   fingerprint_list_t list, *list_tail, item;
1516   unsigned int lnr = 0;
1517   int c, i, j;
1518   int errflag = 0;
1519
1520
1521   /* Check whether this is not a filename and treat it as a direct
1522      fingerprint specification.  */
1523   if (!strpbrk (string, "/.~\\"))
1524     {
1525       item = xcalloc (1, sizeof *item);
1526       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1527         if ( string[i] != ':' )
1528           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1529       item->hexfpr[j] = 0;
1530       if (j != 40 || !(spacep (string+i) || !string[i]))
1531         {
1532           log_error (_("%s:%u: invalid fingerprint detected\n"),
1533                      "--ocsp-signer", 0);
1534           xfree (item);
1535           return NULL;
1536         }
1537       return item;
1538     }
1539
1540   /* Well, it is a filename.  */
1541   if (*string == '/' || (*string == '~' && string[1] == '/'))
1542     fname = make_filename (string, NULL);
1543   else
1544     {
1545       if (string[0] == '.' && string[1] == '/' )
1546         string += 2;
1547       fname = make_filename (gnupg_homedir (), string, NULL);
1548     }
1549
1550   fp = es_fopen (fname, "r");
1551   if (!fp)
1552     {
1553       err = gpg_error_from_syserror ();
1554       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1555       xfree (fname);
1556       return NULL;
1557     }
1558
1559   list = NULL;
1560   list_tail = &list;
1561   for (;;)
1562     {
1563       if (!es_fgets (line, DIM(line)-1, fp) )
1564         {
1565           if (!es_feof (fp))
1566             {
1567               err = gpg_error_from_syserror ();
1568               log_error (_("%s:%u: read error: %s\n"),
1569                          fname, lnr, gpg_strerror (err));
1570               errflag = 1;
1571             }
1572           es_fclose (fp);
1573           if (errflag)
1574             {
1575               while (list)
1576                 {
1577                   fingerprint_list_t tmp = list->next;
1578                   xfree (list);
1579                   list = tmp;
1580                 }
1581             }
1582           xfree (fname);
1583           return list; /* Ready.  */
1584         }
1585
1586       lnr++;
1587       if (!*line || line[strlen(line)-1] != '\n')
1588         {
1589           /* Eat until end of line. */
1590           while ( (c=es_getc (fp)) != EOF && c != '\n')
1591             ;
1592           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1593                            /* */: GPG_ERR_INCOMPLETE_LINE);
1594           log_error (_("%s:%u: read error: %s\n"),
1595                      fname, lnr, gpg_strerror (err));
1596           errflag = 1;
1597           continue;
1598         }
1599
1600       /* Allow for empty lines and spaces */
1601       for (p=line; spacep (p); p++)
1602         ;
1603       if (!*p || *p == '\n' || *p == '#')
1604         continue;
1605
1606       item = xcalloc (1, sizeof *item);
1607       *list_tail = item;
1608       list_tail = &item->next;
1609
1610       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1611         if ( p[i] != ':' )
1612           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1613       item->hexfpr[j] = 0;
1614       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1615         {
1616           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1617           errflag = 1;
1618         }
1619       i++;
1620       while (spacep (p+i))
1621         i++;
1622       if (p[i] && p[i] != '\n')
1623         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1624     }
1625   /*NOTREACHED*/
1626 }
1627
1628
1629
1630 \f
1631 /*
1632    Stuff used in daemon mode.
1633  */
1634
1635
1636
1637 /* Reread parts of the configuration.  Note, that this function is
1638    obviously not thread-safe and should only be called from the NPTH
1639    signal handler.
1640
1641    Fixme: Due to the way the argument parsing works, we create a
1642    memory leak here for all string type arguments.  There is currently
1643    no clean way to tell whether the memory for the argument has been
1644    allocated or points into the process' original arguments.  Unless
1645    we have a mechanism to tell this, we need to live on with this. */
1646 static void
1647 reread_configuration (void)
1648 {
1649   ARGPARSE_ARGS pargs;
1650   FILE *fp;
1651   unsigned int configlineno = 0;
1652   int dummy;
1653
1654   if (!opt.config_filename)
1655     return; /* No config file. */
1656
1657   fp = fopen (opt.config_filename, "r");
1658   if (!fp)
1659     {
1660       log_error (_("option file '%s': %s\n"),
1661                  opt.config_filename, strerror(errno) );
1662       return;
1663     }
1664
1665   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1666
1667   memset (&pargs, 0, sizeof pargs);
1668   dummy = 0;
1669   pargs.argc = &dummy;
1670   pargs.flags = 1;  /* do not remove the args */
1671   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1672     {
1673       if (pargs.r_opt < -1)
1674         pargs.err = 1; /* Print a warning. */
1675       else /* Try to parse this option - ignore unchangeable ones. */
1676         parse_rereadable_options (&pargs, 1);
1677     }
1678   fclose (fp);
1679
1680   set_debug ();
1681   set_tor_mode ();
1682 }
1683
1684
1685 /* A global function which allows us to trigger the reload stuff from
1686    other places.  */
1687 void
1688 dirmngr_sighup_action (void)
1689 {
1690   log_info (_("SIGHUP received - "
1691               "re-reading configuration and flushing caches\n"));
1692   reread_configuration ();
1693   cert_cache_deinit (0);
1694   crl_cache_deinit ();
1695   cert_cache_init ();
1696   crl_cache_init ();
1697   reload_dns_stuff (0);
1698   ks_hkp_reload ();
1699 }
1700
1701
1702 /* This function is called if some network activity was done.  At this
1703  * point we know the we have a network and we can decide whether to
1704  * run scheduled background tasks soon.  The function should return
1705  * quickly and only trigger actions for another thread. */
1706 static void
1707 netactivity_action (void)
1708 {
1709   network_activity_seen = 1;
1710 }
1711
1712
1713 /* The signal handler. */
1714 #ifndef HAVE_W32_SYSTEM
1715 static void
1716 handle_signal (int signo)
1717 {
1718   switch (signo)
1719     {
1720     case SIGHUP:
1721       dirmngr_sighup_action ();
1722       break;
1723
1724     case SIGUSR1:
1725       cert_cache_print_stats ();
1726       break;
1727
1728     case SIGUSR2:
1729       log_info (_("SIGUSR2 received - no action defined\n"));
1730       break;
1731
1732     case SIGTERM:
1733       if (!shutdown_pending)
1734         log_info (_("SIGTERM received - shutting down ...\n"));
1735       else
1736         log_info (_("SIGTERM received - still %d active connections\n"),
1737                   active_connections);
1738       shutdown_pending++;
1739       if (shutdown_pending > 2)
1740         {
1741           log_info (_("shutdown forced\n"));
1742           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1743           cleanup ();
1744           dirmngr_exit (0);
1745         }
1746       break;
1747
1748     case SIGINT:
1749       log_info (_("SIGINT received - immediate shutdown\n"));
1750       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1751       cleanup ();
1752       dirmngr_exit (0);
1753       break;
1754
1755     default:
1756       log_info (_("signal %d received - no action defined\n"), signo);
1757     }
1758 }
1759 #endif /*!HAVE_W32_SYSTEM*/
1760
1761
1762 /* Check the nonce on a new connection.  This is a NOP unless we are
1763    using our Unix domain socket emulation under Windows.  */
1764 static int
1765 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1766 {
1767   if (assuan_sock_check_nonce (fd, nonce))
1768     {
1769       log_info (_("error reading nonce on fd %d: %s\n"),
1770                 FD2INT (fd), strerror (errno));
1771       assuan_sock_close (fd);
1772       return -1;
1773     }
1774   else
1775     return 0;
1776 }
1777
1778
1779 /* Helper to call a connection's main function. */
1780 static void *
1781 start_connection_thread (void *arg)
1782 {
1783   union int_and_ptr_u argval;
1784   gnupg_fd_t fd;
1785
1786   memset (&argval, 0, sizeof argval);
1787   argval.aptr = arg;
1788   fd = argval.afd;
1789
1790   if (check_nonce (fd, &socket_nonce))
1791     {
1792       log_error ("handler nonce check FAILED\n");
1793       return NULL;
1794     }
1795
1796 #ifndef HAVE_W32_SYSTEM
1797   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1798 #endif
1799
1800   active_connections++;
1801   if (opt.verbose)
1802     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1803
1804   start_command_handler (fd);
1805
1806   if (opt.verbose)
1807     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1808   active_connections--;
1809
1810 #ifndef HAVE_W32_SYSTEM
1811   argval.afd = ASSUAN_INVALID_FD;
1812   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1813 #endif
1814
1815   return NULL;
1816 }
1817
1818
1819 #ifdef HAVE_INOTIFY_INIT
1820 /* Read an inotify event and return true if it matches NAME.  */
1821 static int
1822 my_inotify_is_name (int fd, const char *name)
1823 {
1824   union {
1825     struct inotify_event ev;
1826     char _buf[sizeof (struct inotify_event) + 100 + 1];
1827   } buf;
1828   int n;
1829   const char *s;
1830
1831   s = strrchr (name, '/');
1832   if (s && s[1])
1833     name = s + 1;
1834
1835   n = npth_read (fd, &buf, sizeof buf);
1836   if (n < sizeof (struct inotify_event))
1837     return 0;
1838   if (buf.ev.len < strlen (name)+1)
1839     return 0;
1840   if (strcmp (buf.ev.name, name))
1841     return 0; /* Not the desired file.  */
1842
1843   return 1; /* Found.  */
1844 }
1845 #endif /*HAVE_INOTIFY_INIT*/
1846
1847
1848 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
1849  * this function. */
1850 static void
1851 handle_connections (assuan_fd_t listen_fd)
1852 {
1853   npth_attr_t tattr;
1854 #ifndef HAVE_W32_SYSTEM
1855   int signo;
1856 #endif
1857   struct sockaddr_un paddr;
1858   socklen_t plen = sizeof( paddr );
1859   gnupg_fd_t fd;
1860   int nfd, ret;
1861   fd_set fdset, read_fdset;
1862   int saved_errno;
1863   int my_inotify_fd = -1;
1864
1865   npth_attr_init (&tattr);
1866   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1867
1868 #ifndef HAVE_W32_SYSTEM /* FIXME */
1869   npth_sigev_init ();
1870   npth_sigev_add (SIGHUP);
1871   npth_sigev_add (SIGUSR1);
1872   npth_sigev_add (SIGUSR2);
1873   npth_sigev_add (SIGINT);
1874   npth_sigev_add (SIGTERM);
1875   npth_sigev_fini ();
1876 #endif
1877
1878 #ifdef HAVE_INOTIFY_INIT
1879   if (disable_check_own_socket)
1880     my_inotify_fd = -1;
1881   else if ((my_inotify_fd = inotify_init ()) == -1)
1882     log_info ("error enabling fast daemon termination: %s\n",
1883               strerror (errno));
1884   else
1885     {
1886       /* We need to watch the directory for the file because there
1887        * won't be an IN_DELETE_SELF for a socket file.  */
1888       char *slash = strrchr (socket_name, '/');
1889       log_assert (slash && slash[1]);
1890       *slash = 0;
1891       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
1892         {
1893           close (my_inotify_fd);
1894           my_inotify_fd = -1;
1895         }
1896       *slash = '/';
1897     }
1898 #endif /*HAVE_INOTIFY_INIT*/
1899
1900
1901   /* Setup the fdset.  */
1902   FD_ZERO (&fdset);
1903   FD_SET (FD2INT (listen_fd), &fdset);
1904   nfd = FD2INT (listen_fd);
1905   if (my_inotify_fd != -1)
1906     {
1907       FD_SET (my_inotify_fd, &fdset);
1908       if (my_inotify_fd > nfd)
1909         nfd = my_inotify_fd;
1910     }
1911
1912   /* Main loop.  */
1913   for (;;)
1914     {
1915       /* Shutdown test.  */
1916       if (shutdown_pending)
1917         {
1918           if (!active_connections)
1919             break; /* ready */
1920
1921           /* Do not accept new connections but keep on running the
1922            * select loop to wait for signals (e.g. SIGCHLD).
1923            *
1924            * Note that we do not close the listening socket because a
1925            * client trying to connect to that socket would instead
1926            * restart a new dirmngr instance - which is unlikely the
1927            * intention of a shutdown. */
1928           /* assuan_sock_close (listen_fd); */
1929           /* listen_fd = -1; */
1930           FD_ZERO (&fdset);
1931           nfd = -1;
1932           if (my_inotify_fd != -1)
1933             {
1934               FD_SET (my_inotify_fd, &fdset);
1935               nfd = my_inotify_fd;
1936             }
1937         }
1938
1939       /* Take a copy of the fdset.  */
1940       read_fdset = fdset;
1941
1942 #ifndef HAVE_W32_SYSTEM
1943       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, NULL, npth_sigev_sigmask());
1944       saved_errno = errno;
1945
1946       while (npth_sigev_get_pending(&signo))
1947         handle_signal (signo);
1948 #else
1949       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, NULL, NULL, NULL);
1950       saved_errno = errno;
1951 #endif
1952
1953       if (ret == -1 && saved_errno != EINTR)
1954         {
1955           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
1956                      strerror (saved_errno));
1957           npth_sleep (1);
1958           continue;
1959         }
1960
1961       if (ret <= 0)
1962         {
1963           /* Interrupt.  Will be handled at the top of the next loop.  */
1964           continue;
1965         }
1966
1967       if (shutdown_pending)
1968         {
1969           /* Do not anymore accept connections.  */
1970           continue;
1971         }
1972
1973 #ifdef HAVE_INOTIFY_INIT
1974       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
1975           && my_inotify_is_name (my_inotify_fd, socket_name))
1976         {
1977           shutdown_pending = 1;
1978           log_info ("socket file has been removed - shutting down\n");
1979         }
1980 #endif /*HAVE_INOTIFY_INIT*/
1981
1982       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
1983         {
1984           plen = sizeof paddr;
1985           fd = INT2FD (npth_accept (FD2INT(listen_fd),
1986                                     (struct sockaddr *)&paddr, &plen));
1987           if (fd == GNUPG_INVALID_FD)
1988             {
1989               log_error ("accept failed: %s\n", strerror (errno));
1990             }
1991           else
1992             {
1993               char threadname[50];
1994               union int_and_ptr_u argval;
1995               npth_t thread;
1996
1997               memset (&argval, 0, sizeof argval);
1998               argval.afd = fd;
1999               snprintf (threadname, sizeof threadname,
2000                         "conn fd=%d", FD2INT(fd));
2001
2002               ret = npth_create (&thread, &tattr,
2003                                  start_connection_thread, argval.aptr);
2004               if (ret)
2005                 {
2006                   log_error ("error spawning connection handler: %s\n",
2007                              strerror (ret) );
2008                   assuan_sock_close (fd);
2009                 }
2010               npth_setname_np (thread, threadname);
2011             }
2012           fd = GNUPG_INVALID_FD;
2013         }
2014     }
2015
2016 #ifdef HAVE_INOTIFY_INIT
2017   if (my_inotify_fd != -1)
2018     close (my_inotify_fd);
2019 #endif /*HAVE_INOTIFY_INIT*/
2020   npth_attr_destroy (&tattr);
2021   if (listen_fd != -1)
2022     assuan_sock_close (fd);
2023   cleanup ();
2024   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2025 }
2026
2027 const char*
2028 dirmngr_get_current_socket_name (void)
2029 {
2030   if (socket_name)
2031     return socket_name;
2032   else
2033     return dirmngr_socket_name ();
2034 }