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