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