Merge branch 'STABLE-BRANCH-2-2' into master
[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_prefix (GPGRT_LOGLVL_INFO, "ntbtls: ", fmt, argv);
791   else
792     {
793       char prefix[10+20];
794       snprintf (prefix, sizeof prefix, "ntbtls(%d): ", level);
795       log_logv_prefix (GPGRT_LOGLVL_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       if (debug_wait)
1207         {
1208           log_debug ("waiting for debugger - my pid is %u .....\n",
1209                      (unsigned int)getpid());
1210           gnupg_sleep (debug_wait);
1211           log_debug ("... okay\n");
1212         }
1213
1214 #ifndef HAVE_W32_SYSTEM
1215       if (strchr (socket_name, ':'))
1216         {
1217           log_error (_("colons are not allowed in the socket name\n"));
1218           dirmngr_exit (1);
1219         }
1220 #endif
1221       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1222       if (fd == ASSUAN_INVALID_FD)
1223         {
1224           log_error (_("can't create socket: %s\n"), strerror (errno));
1225           cleanup ();
1226           dirmngr_exit (1);
1227         }
1228
1229       {
1230         int redirected;
1231
1232         if (assuan_sock_set_sockaddr_un (socket_name,
1233                                          (struct sockaddr*)&serv_addr,
1234                                          &redirected))
1235           {
1236             if (errno == ENAMETOOLONG)
1237               log_error (_("socket name '%s' is too long\n"), socket_name);
1238             else
1239               log_error ("error preparing socket '%s': %s\n",
1240                          socket_name,
1241                          gpg_strerror (gpg_error_from_syserror ()));
1242             dirmngr_exit (1);
1243           }
1244         if (redirected)
1245           {
1246             redir_socket_name = xstrdup (serv_addr.sun_path);
1247             if (opt.verbose)
1248               log_info ("redirecting socket '%s' to '%s'\n",
1249                         socket_name, redir_socket_name);
1250           }
1251       }
1252
1253       len = SUN_LEN (&serv_addr);
1254
1255       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1256       if (rc == -1
1257           && (errno == EADDRINUSE
1258 #ifdef HAVE_W32_SYSTEM
1259               || errno == EEXIST
1260 #endif
1261               ))
1262         {
1263           /* Fixme: We should test whether a dirmngr is already running. */
1264           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1265           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1266         }
1267       if (rc != -1
1268           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1269         log_error (_("error getting nonce for the socket\n"));
1270       if (rc == -1)
1271         {
1272           log_error (_("error binding socket to '%s': %s\n"),
1273                      serv_addr.sun_path,
1274                      gpg_strerror (gpg_error_from_errno (errno)));
1275           assuan_sock_close (fd);
1276           dirmngr_exit (1);
1277         }
1278       cleanup_socket = 1;
1279
1280       if (gnupg_chmod (serv_addr.sun_path, "-rwx"))
1281         log_error (_("can't set permissions of '%s': %s\n"),
1282                    serv_addr.sun_path, strerror (errno));
1283
1284       if (listen (FD2INT (fd), listen_backlog) == -1)
1285         {
1286           log_error ("listen(fd,%d) failed: %s\n",
1287                      listen_backlog, strerror (errno));
1288           assuan_sock_close (fd);
1289           dirmngr_exit (1);
1290         }
1291
1292       if (opt.verbose)
1293         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1294
1295       es_fflush (NULL);
1296
1297       /* Note: We keep the dirmngr_info output only for the sake of
1298          existing scripts which might use this to detect a successful
1299          start of the dirmngr.  */
1300 #ifdef HAVE_W32_SYSTEM
1301       (void)csh_style;
1302       (void)nodetach;
1303
1304       pid = getpid ();
1305       es_printf ("set %s=%s;%lu;1\n",
1306                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1307 #else
1308       pid = fork();
1309       if (pid == (pid_t)-1)
1310         {
1311           log_fatal (_("error forking process: %s\n"), strerror (errno));
1312           dirmngr_exit (1);
1313         }
1314
1315       if (pid)
1316         { /* We are the parent */
1317           char *infostr;
1318
1319           /* Don't let cleanup() remove the socket - the child is
1320              responsible for doing that.  */
1321           cleanup_socket = 0;
1322
1323           close (fd);
1324
1325           /* Create the info string: <name>:<pid>:<protocol_version> */
1326           if (asprintf (&infostr, "%s=%s:%lu:1",
1327                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1328             {
1329               log_error (_("out of core\n"));
1330               kill (pid, SIGTERM);
1331               dirmngr_exit (1);
1332             }
1333           /* Print the environment string, so that the caller can use
1334              shell's eval to set it.  But see above.  */
1335           if (csh_style)
1336             {
1337               *strchr (infostr, '=') = ' ';
1338               es_printf ( "setenv %s;\n", infostr);
1339             }
1340           else
1341             {
1342               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1343             }
1344           free (infostr);
1345           exit (0);
1346           /*NEVER REACHED*/
1347         } /* end parent */
1348
1349
1350       /*
1351          This is the child
1352        */
1353
1354       /* Detach from tty and put process into a new session */
1355       if (!nodetach )
1356         {
1357           int i;
1358           unsigned int oldflags;
1359
1360           /* Close stdin, stdout and stderr unless it is the log stream */
1361           for (i=0; i <= 2; i++)
1362             {
1363               if (!log_test_fd (i) && i != fd )
1364                 {
1365                   if ( !close (i)
1366                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1367                     {
1368                       log_error ("failed to open '%s': %s\n",
1369                                  "/dev/null", strerror (errno));
1370                       cleanup ();
1371                       dirmngr_exit (1);
1372                     }
1373                 }
1374             }
1375
1376           if (setsid() == -1)
1377             {
1378               log_error ("setsid() failed: %s\n", strerror(errno) );
1379               dirmngr_exit (1);
1380             }
1381
1382           log_get_prefix (&oldflags);
1383           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1384           opt.running_detached = 1;
1385
1386         }
1387 #endif
1388
1389       if (!nodetach )
1390         {
1391           if (gnupg_chdir (gnupg_daemon_rootdir ()))
1392             {
1393               log_error ("chdir to '%s' failed: %s\n",
1394                          gnupg_daemon_rootdir (), strerror (errno));
1395               dirmngr_exit (1);
1396             }
1397         }
1398
1399       thread_init ();
1400       cert_cache_init (hkp_cacert_filenames);
1401       crl_cache_init ();
1402       http_register_netactivity_cb (netactivity_action);
1403       handle_connections (fd);
1404       shutdown_reaper ();
1405     }
1406   else if (cmd == aListCRLs)
1407     {
1408       /* Just list the CRL cache and exit. */
1409       if (argc)
1410         wrong_args ("--list-crls");
1411       crl_cache_init ();
1412       crl_cache_list (es_stdout);
1413     }
1414   else if (cmd == aLoadCRL)
1415     {
1416       struct server_control_s ctrlbuf;
1417
1418       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1419       dirmngr_init_default_ctrl (&ctrlbuf);
1420
1421       thread_init ();
1422       cert_cache_init (hkp_cacert_filenames);
1423       crl_cache_init ();
1424       if (!argc)
1425         rc = crl_cache_load (&ctrlbuf, NULL);
1426       else
1427         {
1428           for (; !rc && argc; argc--, argv++)
1429             rc = crl_cache_load (&ctrlbuf, *argv);
1430         }
1431       dirmngr_deinit_default_ctrl (&ctrlbuf);
1432     }
1433   else if (cmd == aFetchCRL)
1434     {
1435       ksba_reader_t reader;
1436       struct server_control_s ctrlbuf;
1437
1438       if (argc != 1)
1439         wrong_args ("--fetch-crl URL");
1440
1441       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1442       dirmngr_init_default_ctrl (&ctrlbuf);
1443
1444       thread_init ();
1445       cert_cache_init (hkp_cacert_filenames);
1446       crl_cache_init ();
1447       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1448       if (rc)
1449         log_error (_("fetching CRL from '%s' failed: %s\n"),
1450                      argv[0], gpg_strerror (rc));
1451       else
1452         {
1453           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1454           if (rc)
1455             log_error (_("processing CRL from '%s' failed: %s\n"),
1456                        argv[0], gpg_strerror (rc));
1457           crl_close_reader (reader);
1458         }
1459       dirmngr_deinit_default_ctrl (&ctrlbuf);
1460     }
1461   else if (cmd == aFlush)
1462     {
1463       /* Delete cache and exit. */
1464       if (argc)
1465         wrong_args ("--flush");
1466       rc = crl_cache_flush();
1467     }
1468   else if (cmd == aGPGConfTest)
1469     dirmngr_exit (0);
1470   else if (cmd == aGPGConfList)
1471     {
1472       unsigned long flags = 0;
1473       char *filename;
1474       char *filename_esc;
1475
1476       /* First the configuration file.  This is not an option, but it
1477          is vital information for GPG Conf.  */
1478       if (!opt.config_filename)
1479         opt.config_filename = make_filename (gnupg_homedir (),
1480                                              "dirmngr.conf", NULL );
1481
1482       filename = percent_escape (opt.config_filename, NULL);
1483       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1484               GC_OPT_FLAG_DEFAULT, filename);
1485       xfree (filename);
1486
1487       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1488       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1489       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1490       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1491       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1492
1493       /* --csh and --sh are mutually exclusive, something we can not
1494          express in GPG Conf.  --options is only usable from the
1495          command line, really.  --debug-all interacts with --debug,
1496          and having both of them is thus problematic.  --no-detach is
1497          also only usable on the command line.  --batch is unused.  */
1498
1499       filename = make_filename (gnupg_homedir (),
1500                                 "dirmngr_ldapservers.conf",
1501                                 NULL);
1502       filename_esc = percent_escape (filename, NULL);
1503       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1504               filename_esc);
1505       xfree (filename_esc);
1506       xfree (filename);
1507
1508       es_printf ("ldaptimeout:%lu:%u\n",
1509               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1510       es_printf ("max-replies:%lu:%u\n",
1511               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1512       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1513       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1514       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1515       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1516
1517       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1518       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1519
1520       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1521       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1522       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1523       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1524       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1525       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1526       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1527       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1528       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1529       /* Note: The next one is to fix a typo in gpgconf - should be
1530          removed eventually. */
1531       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1532
1533       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1534
1535       filename_esc = percent_escape (get_default_keyserver (0), NULL);
1536       es_printf ("keyserver:%lu:\"%s:\n", flags | GC_OPT_FLAG_DEFAULT,
1537                  filename_esc);
1538       xfree (filename_esc);
1539
1540
1541       es_printf ("nameserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1542       es_printf ("resolver-timeout:%lu:%u\n",
1543                  flags | GC_OPT_FLAG_DEFAULT, 0);
1544     }
1545   cleanup ();
1546   return !!rc;
1547 }
1548
1549
1550 static void
1551 cleanup (void)
1552 {
1553   crl_cache_deinit ();
1554   cert_cache_deinit (1);
1555   reload_dns_stuff (1);
1556
1557 #if USE_LDAP
1558   ldapserver_list_free (opt.ldapservers);
1559 #endif /*USE_LDAP*/
1560   opt.ldapservers = NULL;
1561
1562   if (cleanup_socket)
1563     {
1564       cleanup_socket = 0;
1565       if (redir_socket_name)
1566         gnupg_remove (redir_socket_name);
1567       else if (socket_name && *socket_name)
1568         gnupg_remove (socket_name);
1569     }
1570 }
1571
1572
1573 void
1574 dirmngr_exit (int rc)
1575 {
1576   cleanup ();
1577   exit (rc);
1578 }
1579
1580
1581 void
1582 dirmngr_init_default_ctrl (ctrl_t ctrl)
1583 {
1584   ctrl->magic = SERVER_CONTROL_MAGIC;
1585   if (opt.http_proxy)
1586     ctrl->http_proxy = xstrdup (opt.http_proxy);
1587   ctrl->http_no_crl = 1;
1588   ctrl->timeout = opt.connect_timeout;
1589 }
1590
1591
1592 void
1593 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1594 {
1595   if (!ctrl)
1596     return;
1597   ctrl->magic = 0xdeadbeef;
1598
1599   xfree (ctrl->http_proxy);
1600   ctrl->http_proxy = NULL;
1601 }
1602
1603
1604 /* Create a list of LDAP servers from the file FILENAME. Returns the
1605    list or NULL in case of errors.
1606
1607    The format fo such a file is line oriented where empty lines and
1608    lines starting with a hash mark are ignored.  All other lines are
1609    assumed to be colon seprated with these fields:
1610
1611    1. field: Hostname
1612    2. field: Portnumber
1613    3. field: Username
1614    4. field: Password
1615    5. field: Base DN
1616
1617 */
1618 #if USE_LDAP
1619 static ldap_server_t
1620 parse_ldapserver_file (const char* filename)
1621 {
1622   char buffer[1024];
1623   char *p;
1624   ldap_server_t server, serverstart, *serverend;
1625   int c;
1626   unsigned int lineno = 0;
1627   estream_t fp;
1628
1629   fp = es_fopen (filename, "r");
1630   if (!fp)
1631     {
1632       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1633       return NULL;
1634     }
1635
1636   serverstart = NULL;
1637   serverend = &serverstart;
1638   while (es_fgets (buffer, sizeof buffer, fp))
1639     {
1640       lineno++;
1641       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1642         {
1643           if (*buffer && es_feof (fp))
1644             ; /* Last line not terminated - continue. */
1645           else
1646             {
1647               log_error (_("%s:%u: line too long - skipped\n"),
1648                          filename, lineno);
1649               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1650                 ; /* Skip until end of line. */
1651               continue;
1652             }
1653         }
1654       /* Skip empty and comment lines.*/
1655       for (p=buffer; spacep (p); p++)
1656         ;
1657       if (!*p || *p == '\n' || *p == '#')
1658         continue;
1659
1660       /* Parse the colon separated fields. */
1661       server = ldapserver_parse_one (buffer, filename, lineno);
1662       if (server)
1663         {
1664           *serverend = server;
1665           serverend = &server->next;
1666         }
1667     }
1668
1669   if (es_ferror (fp))
1670     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1671   es_fclose (fp);
1672
1673   return serverstart;
1674 }
1675 #endif /*USE_LDAP*/
1676
1677 static fingerprint_list_t
1678 parse_ocsp_signer (const char *string)
1679 {
1680   gpg_error_t err;
1681   char *fname;
1682   estream_t fp;
1683   char line[256];
1684   char *p;
1685   fingerprint_list_t list, *list_tail, item;
1686   unsigned int lnr = 0;
1687   int c, i, j;
1688   int errflag = 0;
1689
1690
1691   /* Check whether this is not a filename and treat it as a direct
1692      fingerprint specification.  */
1693   if (!strpbrk (string, "/.~\\"))
1694     {
1695       item = xcalloc (1, sizeof *item);
1696       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1697         if ( string[i] != ':' )
1698           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1699       item->hexfpr[j] = 0;
1700       if (j != 40 || !(spacep (string+i) || !string[i]))
1701         {
1702           log_error (_("%s:%u: invalid fingerprint detected\n"),
1703                      "--ocsp-signer", 0);
1704           xfree (item);
1705           return NULL;
1706         }
1707       return item;
1708     }
1709
1710   /* Well, it is a filename.  */
1711   if (*string == '/' || (*string == '~' && string[1] == '/'))
1712     fname = make_filename (string, NULL);
1713   else
1714     {
1715       if (string[0] == '.' && string[1] == '/' )
1716         string += 2;
1717       fname = make_filename (gnupg_homedir (), string, NULL);
1718     }
1719
1720   fp = es_fopen (fname, "r");
1721   if (!fp)
1722     {
1723       err = gpg_error_from_syserror ();
1724       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1725       xfree (fname);
1726       return NULL;
1727     }
1728
1729   list = NULL;
1730   list_tail = &list;
1731   for (;;)
1732     {
1733       if (!es_fgets (line, DIM(line)-1, fp) )
1734         {
1735           if (!es_feof (fp))
1736             {
1737               err = gpg_error_from_syserror ();
1738               log_error (_("%s:%u: read error: %s\n"),
1739                          fname, lnr, gpg_strerror (err));
1740               errflag = 1;
1741             }
1742           es_fclose (fp);
1743           if (errflag)
1744             {
1745               while (list)
1746                 {
1747                   fingerprint_list_t tmp = list->next;
1748                   xfree (list);
1749                   list = tmp;
1750                 }
1751             }
1752           xfree (fname);
1753           return list; /* Ready.  */
1754         }
1755
1756       lnr++;
1757       if (!*line || line[strlen(line)-1] != '\n')
1758         {
1759           /* Eat until end of line. */
1760           while ( (c=es_getc (fp)) != EOF && c != '\n')
1761             ;
1762           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1763                            /* */: GPG_ERR_INCOMPLETE_LINE);
1764           log_error (_("%s:%u: read error: %s\n"),
1765                      fname, lnr, gpg_strerror (err));
1766           errflag = 1;
1767           continue;
1768         }
1769
1770       /* Allow for empty lines and spaces */
1771       for (p=line; spacep (p); p++)
1772         ;
1773       if (!*p || *p == '\n' || *p == '#')
1774         continue;
1775
1776       item = xcalloc (1, sizeof *item);
1777       *list_tail = item;
1778       list_tail = &item->next;
1779
1780       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1781         if ( p[i] != ':' )
1782           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1783       item->hexfpr[j] = 0;
1784       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1785         {
1786           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1787           errflag = 1;
1788         }
1789       i++;
1790       while (spacep (p+i))
1791         i++;
1792       if (p[i] && p[i] != '\n')
1793         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1794     }
1795   /*NOTREACHED*/
1796 }
1797
1798
1799
1800 \f
1801 /*
1802    Stuff used in daemon mode.
1803  */
1804
1805
1806
1807 /* Reread parts of the configuration.  Note, that this function is
1808    obviously not thread-safe and should only be called from the NPTH
1809    signal handler.
1810
1811    Fixme: Due to the way the argument parsing works, we create a
1812    memory leak here for all string type arguments.  There is currently
1813    no clean way to tell whether the memory for the argument has been
1814    allocated or points into the process' original arguments.  Unless
1815    we have a mechanism to tell this, we need to live on with this. */
1816 static void
1817 reread_configuration (void)
1818 {
1819   ARGPARSE_ARGS pargs;
1820   FILE *fp;
1821   unsigned int configlineno = 0;
1822   int dummy;
1823
1824   if (!opt.config_filename)
1825     return; /* No config file. */
1826
1827   fp = fopen (opt.config_filename, "r");
1828   if (!fp)
1829     {
1830       log_error (_("option file '%s': %s\n"),
1831                  opt.config_filename, strerror(errno) );
1832       return;
1833     }
1834
1835   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1836
1837   memset (&pargs, 0, sizeof pargs);
1838   dummy = 0;
1839   pargs.argc = &dummy;
1840   pargs.flags = 1;  /* do not remove the args */
1841   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1842     {
1843       if (pargs.r_opt < -1)
1844         pargs.err = 1; /* Print a warning. */
1845       else /* Try to parse this option - ignore unchangeable ones. */
1846         parse_rereadable_options (&pargs, 1);
1847     }
1848   fclose (fp);
1849
1850   post_option_parsing ();
1851 }
1852
1853
1854 /* A global function which allows us to trigger the reload stuff from
1855    other places.  */
1856 void
1857 dirmngr_sighup_action (void)
1858 {
1859   log_info (_("SIGHUP received - "
1860               "re-reading configuration and flushing caches\n"));
1861   reread_configuration ();
1862   cert_cache_deinit (0);
1863   crl_cache_deinit ();
1864   cert_cache_init (hkp_cacert_filenames);
1865   crl_cache_init ();
1866   reload_dns_stuff (0);
1867   ks_hkp_reload ();
1868 }
1869
1870
1871 /* This function is called if some network activity was done.  At this
1872  * point we know the we have a network and we can decide whether to
1873  * run scheduled background tasks soon.  The function should return
1874  * quickly and only trigger actions for another thread. */
1875 static void
1876 netactivity_action (void)
1877 {
1878   network_activity_seen = 1;
1879 }
1880
1881
1882 /* The signal handler. */
1883 #ifndef HAVE_W32_SYSTEM
1884 static void
1885 handle_signal (int signo)
1886 {
1887   switch (signo)
1888     {
1889     case SIGHUP:
1890       dirmngr_sighup_action ();
1891       break;
1892
1893     case SIGUSR1:
1894       cert_cache_print_stats ();
1895       domaininfo_print_stats ();
1896       break;
1897
1898     case SIGUSR2:
1899       log_info (_("SIGUSR2 received - no action defined\n"));
1900       break;
1901
1902     case SIGTERM:
1903       if (!shutdown_pending)
1904         log_info (_("SIGTERM received - shutting down ...\n"));
1905       else
1906         log_info (_("SIGTERM received - still %d active connections\n"),
1907                   active_connections);
1908       shutdown_pending++;
1909       if (shutdown_pending > 2)
1910         {
1911           log_info (_("shutdown forced\n"));
1912           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1913           cleanup ();
1914           dirmngr_exit (0);
1915         }
1916       break;
1917
1918     case SIGINT:
1919       log_info (_("SIGINT received - immediate shutdown\n"));
1920       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1921       cleanup ();
1922       dirmngr_exit (0);
1923       break;
1924
1925     default:
1926       log_info (_("signal %d received - no action defined\n"), signo);
1927     }
1928 }
1929 #endif /*!HAVE_W32_SYSTEM*/
1930
1931
1932 /* Thread to do the housekeeping.  */
1933 static void *
1934 housekeeping_thread (void *arg)
1935 {
1936   static int sentinel;
1937   time_t curtime;
1938   struct server_control_s ctrlbuf;
1939
1940   (void)arg;
1941
1942   curtime = gnupg_get_time ();
1943   if (sentinel)
1944     {
1945       log_info ("housekeeping is already going on\n");
1946       return NULL;
1947     }
1948   sentinel++;
1949   if (opt.verbose > 1)
1950     log_info ("starting housekeeping\n");
1951
1952   memset (&ctrlbuf, 0, sizeof ctrlbuf);
1953   dirmngr_init_default_ctrl (&ctrlbuf);
1954
1955   ks_hkp_housekeeping (curtime);
1956   if (network_activity_seen)
1957     {
1958       network_activity_seen = 0;
1959       if (opt.allow_version_check)
1960         dirmngr_load_swdb (&ctrlbuf, 0);
1961       workqueue_run_global_tasks (&ctrlbuf, 1);
1962     }
1963   else
1964     workqueue_run_global_tasks (&ctrlbuf, 0);
1965
1966   dirmngr_deinit_default_ctrl (&ctrlbuf);
1967
1968   if (opt.verbose > 1)
1969     log_info ("ready with housekeeping\n");
1970   sentinel--;
1971   return NULL;
1972
1973 }
1974
1975
1976 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1977 # pragma GCC push_options
1978 # pragma GCC optimize ("no-strict-overflow")
1979 #endif
1980 static int
1981 time_for_housekeeping_p (time_t curtime)
1982 {
1983   static time_t last_housekeeping;
1984
1985   if (!last_housekeeping)
1986     last_housekeeping = curtime;
1987
1988   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1989       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1990     {
1991       last_housekeeping = curtime;
1992       return 1;
1993     }
1994   return 0;
1995 }
1996 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1997 # pragma GCC pop_options
1998 #endif
1999
2000
2001 /* This is the worker for the ticker.  It is called every few seconds
2002    and may only do fast operations. */
2003 static void
2004 handle_tick (void)
2005 {
2006   struct stat statbuf;
2007
2008   if (time_for_housekeeping_p (gnupg_get_time ()))
2009     {
2010       npth_t thread;
2011       npth_attr_t tattr;
2012       int err;
2013
2014       err = npth_attr_init (&tattr);
2015       if (err)
2016         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
2017       else
2018         {
2019           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2020           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
2021           if (err)
2022             log_error ("error spawning housekeeping thread: %s\n",
2023                        strerror (err));
2024           npth_attr_destroy (&tattr);
2025         }
2026     }
2027
2028   /* Check whether the homedir is still available.  */
2029   if (!shutdown_pending
2030       && stat (gnupg_homedir (), &statbuf) && errno == ENOENT)
2031     {
2032       shutdown_pending = 1;
2033       log_info ("homedir has been removed - shutting down\n");
2034     }
2035 }
2036
2037
2038 /* Check the nonce on a new connection.  This is a NOP unless we are
2039    using our Unix domain socket emulation under Windows.  */
2040 static int
2041 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
2042 {
2043   if (assuan_sock_check_nonce (fd, nonce))
2044     {
2045       log_info (_("error reading nonce on fd %d: %s\n"),
2046                 FD2INT (fd), strerror (errno));
2047       assuan_sock_close (fd);
2048       return -1;
2049     }
2050   else
2051     return 0;
2052 }
2053
2054
2055 /* Helper to call a connection's main function. */
2056 static void *
2057 start_connection_thread (void *arg)
2058 {
2059   static unsigned int last_session_id;
2060   unsigned int session_id;
2061   union int_and_ptr_u argval;
2062   gnupg_fd_t fd;
2063
2064   memset (&argval, 0, sizeof argval);
2065   argval.aptr = arg;
2066   fd = argval.afd;
2067
2068   if (check_nonce (fd, &socket_nonce))
2069     {
2070       log_error ("handler nonce check FAILED\n");
2071       return NULL;
2072     }
2073
2074 #ifndef HAVE_W32_SYSTEM
2075   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2076 #endif
2077
2078   active_connections++;
2079   if (opt.verbose)
2080     log_info (_("handler for fd %d started\n"), FD2INT (fd));
2081
2082   session_id = ++last_session_id;
2083   if (!session_id)
2084     session_id = ++last_session_id;
2085   start_command_handler (fd, session_id);
2086
2087   if (opt.verbose)
2088     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
2089   active_connections--;
2090
2091   workqueue_run_post_session_tasks (session_id);
2092
2093 #ifndef HAVE_W32_SYSTEM
2094   argval.afd = ASSUAN_INVALID_FD;
2095   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2096 #endif
2097
2098   return NULL;
2099 }
2100
2101
2102 #ifdef HAVE_INOTIFY_INIT
2103 /* Read an inotify event and return true if it matches NAME.  */
2104 static int
2105 my_inotify_is_name (int fd, const char *name)
2106 {
2107   union {
2108     struct inotify_event ev;
2109     char _buf[sizeof (struct inotify_event) + 100 + 1];
2110   } buf;
2111   int n;
2112   const char *s;
2113
2114   s = strrchr (name, '/');
2115   if (s && s[1])
2116     name = s + 1;
2117
2118   n = npth_read (fd, &buf, sizeof buf);
2119   if (n < sizeof (struct inotify_event))
2120     return 0;
2121   if (buf.ev.len < strlen (name)+1)
2122     return 0;
2123   if (strcmp (buf.ev.name, name))
2124     return 0; /* Not the desired file.  */
2125
2126   return 1; /* Found.  */
2127 }
2128 #endif /*HAVE_INOTIFY_INIT*/
2129
2130
2131 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
2132  * this function. */
2133 static void
2134 handle_connections (assuan_fd_t listen_fd)
2135 {
2136   npth_attr_t tattr;
2137 #ifndef HAVE_W32_SYSTEM
2138   int signo;
2139 #endif
2140   struct sockaddr_un paddr;
2141   socklen_t plen = sizeof( paddr );
2142   int nfd, ret;
2143   fd_set fdset, read_fdset;
2144   struct timespec abstime;
2145   struct timespec curtime;
2146   struct timespec timeout;
2147   int saved_errno;
2148   int my_inotify_fd = -1;
2149
2150   npth_attr_init (&tattr);
2151   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2152
2153 #ifndef HAVE_W32_SYSTEM /* FIXME */
2154   npth_sigev_init ();
2155   npth_sigev_add (SIGHUP);
2156   npth_sigev_add (SIGUSR1);
2157   npth_sigev_add (SIGUSR2);
2158   npth_sigev_add (SIGINT);
2159   npth_sigev_add (SIGTERM);
2160   npth_sigev_fini ();
2161 #endif
2162
2163 #ifdef HAVE_INOTIFY_INIT
2164   if (disable_check_own_socket)
2165     my_inotify_fd = -1;
2166   else if ((my_inotify_fd = inotify_init ()) == -1)
2167     log_info ("error enabling fast daemon termination: %s\n",
2168               strerror (errno));
2169   else
2170     {
2171       /* We need to watch the directory for the file because there
2172        * won't be an IN_DELETE_SELF for a socket file.  */
2173       char *slash = strrchr (socket_name, '/');
2174       log_assert (slash && slash[1]);
2175       *slash = 0;
2176       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2177         {
2178           close (my_inotify_fd);
2179           my_inotify_fd = -1;
2180         }
2181       *slash = '/';
2182     }
2183 #endif /*HAVE_INOTIFY_INIT*/
2184
2185
2186   /* Setup the fdset.  It has only one member.  This is because we use
2187      pth_select instead of pth_accept to properly sync timeouts with
2188      to full second.  */
2189   FD_ZERO (&fdset);
2190   FD_SET (FD2INT (listen_fd), &fdset);
2191   nfd = FD2INT (listen_fd);
2192   if (my_inotify_fd != -1)
2193     {
2194       FD_SET (my_inotify_fd, &fdset);
2195       if (my_inotify_fd > nfd)
2196         nfd = my_inotify_fd;
2197     }
2198
2199   npth_clock_gettime (&abstime);
2200   abstime.tv_sec += TIMERTICK_INTERVAL;
2201
2202   /* Main loop.  */
2203   for (;;)
2204     {
2205       /* Shutdown test.  */
2206       if (shutdown_pending)
2207         {
2208           if (!active_connections)
2209             break; /* ready */
2210
2211           /* Do not accept new connections but keep on running the
2212            * loop to cope with the timer events.
2213            *
2214            * Note that we do not close the listening socket because a
2215            * client trying to connect to that socket would instead
2216            * restart a new dirmngr instance - which is unlikely the
2217            * intention of a shutdown. */
2218           /* assuan_sock_close (listen_fd); */
2219           /* listen_fd = -1; */
2220           FD_ZERO (&fdset);
2221           nfd = -1;
2222           if (my_inotify_fd != -1)
2223             {
2224               FD_SET (my_inotify_fd, &fdset);
2225               nfd = my_inotify_fd;
2226             }
2227         }
2228
2229       /* Take a copy of the fdset.  */
2230       read_fdset = fdset;
2231
2232       npth_clock_gettime (&curtime);
2233       if (!(npth_timercmp (&curtime, &abstime, <)))
2234         {
2235           /* Timeout.  When a shutdown is pending we use a shorter
2236            * interval to handle the shutdown more quickly.  */
2237           handle_tick ();
2238           npth_clock_gettime (&abstime);
2239           abstime.tv_sec += (shutdown_pending
2240                              ? TIMERTICK_INTERVAL_SHUTDOWN
2241                              : TIMERTICK_INTERVAL);
2242         }
2243       npth_timersub (&abstime, &curtime, &timeout);
2244
2245 #ifndef HAVE_W32_SYSTEM
2246       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2247                           npth_sigev_sigmask());
2248       saved_errno = errno;
2249
2250       while (npth_sigev_get_pending(&signo))
2251         handle_signal (signo);
2252 #else
2253       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2254       saved_errno = errno;
2255 #endif
2256
2257       if (ret == -1 && saved_errno != EINTR)
2258         {
2259           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2260                      strerror (saved_errno));
2261           npth_sleep (1);
2262           continue;
2263         }
2264
2265       if (ret <= 0)
2266         {
2267           /* Interrupt or timeout.  Will be handled when calculating the
2268              next timeout.  */
2269           continue;
2270         }
2271
2272       if (shutdown_pending)
2273         {
2274           /* Do not anymore accept connections.  */
2275           continue;
2276         }
2277
2278 #ifdef HAVE_INOTIFY_INIT
2279       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2280           && my_inotify_is_name (my_inotify_fd, socket_name))
2281         {
2282           shutdown_pending = 1;
2283           log_info ("socket file has been removed - shutting down\n");
2284         }
2285 #endif /*HAVE_INOTIFY_INIT*/
2286
2287       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
2288         {
2289           gnupg_fd_t fd;
2290
2291           plen = sizeof paddr;
2292           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2293                                     (struct sockaddr *)&paddr, &plen));
2294           if (fd == GNUPG_INVALID_FD)
2295             {
2296               log_error ("accept failed: %s\n", strerror (errno));
2297             }
2298           else
2299             {
2300               char threadname[50];
2301               union int_and_ptr_u argval;
2302               npth_t thread;
2303
2304               memset (&argval, 0, sizeof argval);
2305               argval.afd = fd;
2306               snprintf (threadname, sizeof threadname,
2307                         "conn fd=%d", FD2INT(fd));
2308
2309               ret = npth_create (&thread, &tattr,
2310                                  start_connection_thread, argval.aptr);
2311               if (ret)
2312                 {
2313                   log_error ("error spawning connection handler: %s\n",
2314                              strerror (ret) );
2315                   assuan_sock_close (fd);
2316                 }
2317               npth_setname_np (thread, threadname);
2318             }
2319         }
2320     }
2321
2322 #ifdef HAVE_INOTIFY_INIT
2323   if (my_inotify_fd != -1)
2324     close (my_inotify_fd);
2325 #endif /*HAVE_INOTIFY_INIT*/
2326   npth_attr_destroy (&tattr);
2327   if (listen_fd != GNUPG_INVALID_FD)
2328     assuan_sock_close (listen_fd);
2329   cleanup ();
2330   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2331 }
2332
2333 const char*
2334 dirmngr_get_current_socket_name (void)
2335 {
2336   if (socket_name)
2337     return socket_name;
2338   else
2339     return dirmngr_socket_name ();
2340 }