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