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