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