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