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