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