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