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