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