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