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