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