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