bb07656a5fba06fef6813f69e66b5c90e68fec33
[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
719 static void
720 thread_init (void)
721 {
722   npth_init ();
723   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
724
725   /* Now with NPth running we can set the logging callback.  Our
726      windows implementation does not yet feature the NPth TLS
727      functions.  */
728 #ifndef HAVE_W32_SYSTEM
729   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
730     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
731       log_set_pid_suffix_cb (pid_suffix_callback);
732 #endif /*!HAVE_W32_SYSTEM*/
733 }
734
735
736 int
737 main (int argc, char **argv)
738 {
739   enum cmd_and_opt_values cmd = 0;
740   ARGPARSE_ARGS pargs;
741   int orig_argc;
742   char **orig_argv;
743   FILE *configfp = NULL;
744   char *configname = NULL;
745   const char *shell;
746   unsigned configlineno;
747   int parse_debug = 0;
748   int default_config =1;
749   int greeting = 0;
750   int nogreeting = 0;
751   int nodetach = 0;
752   int csh_style = 0;
753   char *logfile = NULL;
754 #if USE_LDAP
755   char *ldapfile = NULL;
756 #endif /*USE_LDAP*/
757   int debug_wait = 0;
758   int rc;
759   struct assuan_malloc_hooks malloc_hooks;
760
761   early_system_init ();
762   set_strusage (my_strusage);
763   log_set_prefix (DIRMNGR_NAME, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
764
765   /* Make sure that our subsystems are ready.  */
766   i18n_init ();
767   init_common_subsystems (&argc, &argv);
768
769   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
770
771  /* Check that the libraries are suitable.  Do it here because
772     the option parsing may need services of the libraries. */
773   if (!ksba_check_version (NEED_KSBA_VERSION) )
774     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
775                NEED_KSBA_VERSION, ksba_check_version (NULL) );
776
777   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
778   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
779
780   /* Init TLS library.  */
781 #if HTTP_USE_NTBTLS
782   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
783     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
784                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
785 #elif HTTP_USE_GNUTLS
786   rc = gnutls_global_init ();
787   if (rc)
788     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
789 #endif /*HTTP_USE_GNUTLS*/
790
791   /* Init Assuan. */
792   malloc_hooks.malloc = gcry_malloc;
793   malloc_hooks.realloc = gcry_realloc;
794   malloc_hooks.free = gcry_free;
795   assuan_set_malloc_hooks (&malloc_hooks);
796   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
797   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
798   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
799   assuan_sock_init ();
800   setup_libassuan_logging (&opt.debug, dirmngr_assuan_log_monitor);
801
802   setup_libgcrypt_logging ();
803
804   /* Setup defaults. */
805   shell = getenv ("SHELL");
806   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
807     csh_style = 1;
808
809   /* Reset rereadable options to default values. */
810   parse_rereadable_options (NULL, 0);
811
812   /* LDAP defaults.  */
813   opt.add_new_ldapservers = 0;
814   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
815
816   /* Other defaults.  */
817
818   /* Check whether we have a config file given on the commandline */
819   orig_argc = argc;
820   orig_argv = argv;
821   pargs.argc = &argc;
822   pargs.argv = &argv;
823   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
824   while (arg_parse( &pargs, opts))
825     {
826       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
827         parse_debug++;
828       else if (pargs.r_opt == oOptions)
829         { /* Yes there is one, so we do not try the default one, but
830              read the option file when it is encountered at the
831              commandline */
832           default_config = 0;
833         }
834       else if (pargs.r_opt == oNoOptions)
835         default_config = 0; /* --no-options */
836       else if (pargs.r_opt == oHomedir)
837         {
838           gnupg_set_homedir (pargs.r.ret_str);
839         }
840     }
841
842   socket_name = dirmngr_socket_name ();
843   if (default_config)
844     configname = make_filename (gnupg_homedir (), DIRMNGR_NAME".conf", NULL );
845
846   argc = orig_argc;
847   argv = orig_argv;
848   pargs.argc = &argc;
849   pargs.argv = &argv;
850   pargs.flags= 1;  /* do not remove the args */
851  next_pass:
852   if (configname)
853     {
854       configlineno = 0;
855       configfp = fopen (configname, "r");
856       if (!configfp)
857         {
858           if (default_config)
859             {
860               if( parse_debug )
861                 log_info (_("Note: no default option file '%s'\n"),
862                           configname );
863             }
864           else
865             {
866               log_error (_("option file '%s': %s\n"),
867                          configname, strerror(errno) );
868               exit(2);
869             }
870           xfree (configname);
871           configname = NULL;
872         }
873       if (parse_debug && configname )
874         log_info (_("reading options from '%s'\n"), configname );
875       default_config = 0;
876     }
877
878   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
879     {
880       if (parse_rereadable_options (&pargs, 0))
881         continue; /* Already handled */
882       switch (pargs.r_opt)
883         {
884         case aServer:
885         case aDaemon:
886         case aSupervised:
887         case aShutdown:
888         case aFlush:
889         case aListCRLs:
890         case aLoadCRL:
891         case aFetchCRL:
892         case aGPGConfList:
893         case aGPGConfTest:
894           cmd = pargs.r_opt;
895           break;
896
897         case oQuiet: opt.quiet = 1; break;
898         case oVerbose: opt.verbose++; break;
899         case oBatch: opt.batch=1; break;
900
901         case oDebugWait: debug_wait = pargs.r.ret_int; break;
902
903         case oOptions:
904           /* Config files may not be nested (silently ignore them) */
905           if (!configfp)
906             {
907                 xfree(configname);
908                 configname = xstrdup(pargs.r.ret_str);
909                 goto next_pass;
910             }
911           break;
912         case oNoGreeting: nogreeting = 1; break;
913         case oNoVerbose: opt.verbose = 0; break;
914         case oNoOptions: break; /* no-options */
915         case oHomedir: /* Ignore this option here. */; break;
916         case oNoDetach: nodetach = 1; break;
917         case oLogFile: logfile = pargs.r.ret_str; break;
918         case oCsh: csh_style = 1; break;
919         case oSh: csh_style = 0; break;
920         case oLDAPFile:
921 #        if USE_LDAP
922           ldapfile = pargs.r.ret_str;
923 #        endif /*USE_LDAP*/
924           break;
925         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
926         case oLDAPTimeout:
927           opt.ldaptimeout = pargs.r.ret_int;
928           break;
929
930         case oFakedSystemTime:
931           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
932           break;
933
934         case oForce: opt.force = 1; break;
935
936         case oSocketName: socket_name = pargs.r.ret_str; break;
937
938         default : pargs.err = configfp? 1:2; break;
939         }
940     }
941   if (configfp)
942     {
943       fclose (configfp);
944       configfp = NULL;
945       /* Keep a copy of the name so that it can be read on SIGHUP. */
946       opt.config_filename = configname;
947       configname = NULL;
948       goto next_pass;
949     }
950   xfree (configname);
951   configname = NULL;
952   if (log_get_errorcount(0))
953     exit(2);
954   if (nogreeting )
955     greeting = 0;
956
957   if (!opt.homedir_cache)
958     opt.homedir_cache = xstrdup (gnupg_homedir ());
959
960   if (greeting)
961     {
962       es_fprintf (es_stderr, "%s %s; %s\n",
963                   strusage(11), strusage(13), strusage(14) );
964       es_fprintf (es_stderr, "%s\n", strusage(15) );
965     }
966
967 #ifdef IS_DEVELOPMENT_VERSION
968   log_info ("NOTE: this is a development version!\n");
969 #endif
970
971   /* Print a warning if an argument looks like an option.  */
972   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
973     {
974       int i;
975
976       for (i=0; i < argc; i++)
977         if (argv[i][0] == '-' && argv[i][1] == '-')
978           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
979     }
980
981   if (!access ("/etc/"DIRMNGR_NAME, F_OK)
982       && !strncmp (gnupg_homedir (), "/etc/", 5))
983     log_info
984       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
985        " other directory names changed.  Please check that no other version"
986        " of dirmngr is still installed.  To disable this warning, remove the"
987        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
988
989   if (gnupg_faked_time_p ())
990     {
991       gnupg_isotime_t tbuf;
992
993       log_info (_("WARNING: running with faked system time: "));
994       gnupg_get_isotime (tbuf);
995       dump_isotime (tbuf);
996       log_printf ("\n");
997     }
998
999   set_debug ();
1000   set_tor_mode ();
1001
1002   /* Get LDAP server list from file. */
1003 #if USE_LDAP
1004   if (!ldapfile)
1005     {
1006       ldapfile = make_filename (gnupg_homedir (),
1007                                 "dirmngr_ldapservers.conf",
1008                                 NULL);
1009       opt.ldapservers = parse_ldapserver_file (ldapfile);
1010       xfree (ldapfile);
1011     }
1012   else
1013       opt.ldapservers = parse_ldapserver_file (ldapfile);
1014 #endif /*USE_LDAP*/
1015
1016 #ifndef HAVE_W32_SYSTEM
1017   /* We need to ignore the PIPE signal because the we might log to a
1018      socket and that code handles EPIPE properly.  The ldap wrapper
1019      also requires us to ignore this silly signal. Assuan would set
1020      this signal to ignore anyway.*/
1021   signal (SIGPIPE, SIG_IGN);
1022 #endif
1023
1024   /* Ready.  Now to our duties. */
1025   if (!cmd)
1026     cmd = aServer;
1027   rc = 0;
1028
1029   if (cmd == aServer)
1030     {
1031       /* Note that this server mode is mainly useful for debugging.  */
1032       if (argc)
1033         wrong_args ("--server");
1034
1035       if (logfile)
1036         {
1037           log_set_file (logfile);
1038           log_set_prefix (NULL, GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
1039         }
1040
1041       if (debug_wait)
1042         {
1043           log_debug ("waiting for debugger - my pid is %u .....\n",
1044                      (unsigned int)getpid());
1045           gnupg_sleep (debug_wait);
1046           log_debug ("... okay\n");
1047         }
1048
1049
1050       thread_init ();
1051       cert_cache_init ();
1052       crl_cache_init ();
1053       http_register_netactivity_cb (netactivity_action);
1054       start_command_handler (ASSUAN_INVALID_FD);
1055       shutdown_reaper ();
1056     }
1057 #ifndef HAVE_W32_SYSTEM
1058   else if (cmd == aSupervised)
1059     {
1060       /* In supervised mode, we expect file descriptor 3 to be an
1061          already opened, listening socket.
1062
1063          We will also not detach from the controlling process or close
1064          stderr; the supervisor should handle all of that.  */
1065       struct stat statbuf;
1066       if (fstat (3, &statbuf) == -1 && errno == EBADF)
1067         {
1068           log_error ("file descriptor 3 must be validin --supervised mode\n");
1069           dirmngr_exit (1);
1070         }
1071       socket_name = gnupg_get_socket_name (3);
1072
1073       /* Now start with logging to a file if this is desired. */
1074       if (logfile)
1075         {
1076           log_set_file (logfile);
1077           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1078                                  |GPGRT_LOG_WITH_TIME
1079                                  |GPGRT_LOG_WITH_PID));
1080           current_logfile = xstrdup (logfile);
1081         }
1082       else
1083         log_set_prefix (NULL, 0);
1084
1085       thread_init ();
1086       cert_cache_init ();
1087       crl_cache_init ();
1088       http_register_netactivity_cb (netactivity_action);
1089       handle_connections (3);
1090       shutdown_reaper ();
1091     }
1092 #endif /*HAVE_W32_SYSTEM*/
1093   else if (cmd == aDaemon)
1094     {
1095       assuan_fd_t fd;
1096       pid_t pid;
1097       int len;
1098       struct sockaddr_un serv_addr;
1099
1100       if (argc)
1101         wrong_args ("--daemon");
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
1113 #ifndef HAVE_W32_SYSTEM
1114       if (strchr (socket_name, ':'))
1115         {
1116           log_error (_("colons are not allowed in the socket name\n"));
1117           dirmngr_exit (1);
1118         }
1119 #endif
1120       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1121       if (fd == ASSUAN_INVALID_FD)
1122         {
1123           log_error (_("can't create socket: %s\n"), strerror (errno));
1124           cleanup ();
1125           dirmngr_exit (1);
1126         }
1127
1128       {
1129         int redirected;
1130
1131         if (assuan_sock_set_sockaddr_un (socket_name,
1132                                          (struct sockaddr*)&serv_addr,
1133                                          &redirected))
1134           {
1135             if (errno == ENAMETOOLONG)
1136               log_error (_("socket name '%s' is too long\n"), socket_name);
1137             else
1138               log_error ("error preparing socket '%s': %s\n",
1139                          socket_name,
1140                          gpg_strerror (gpg_error_from_syserror ()));
1141             dirmngr_exit (1);
1142           }
1143         if (redirected)
1144           {
1145             redir_socket_name = xstrdup (serv_addr.sun_path);
1146             if (opt.verbose)
1147               log_info ("redirecting socket '%s' to '%s'\n",
1148                         socket_name, redir_socket_name);
1149           }
1150       }
1151
1152       len = SUN_LEN (&serv_addr);
1153
1154       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1155       if (rc == -1
1156           && (errno == EADDRINUSE
1157 #ifdef HAVE_W32_SYSTEM
1158               || errno == EEXIST
1159 #endif
1160               ))
1161         {
1162           /* Fixme: We should test whether a dirmngr is already running. */
1163           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1164           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1165         }
1166       if (rc != -1
1167           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1168         log_error (_("error getting nonce for the socket\n"));
1169       if (rc == -1)
1170         {
1171           log_error (_("error binding socket to '%s': %s\n"),
1172                      serv_addr.sun_path,
1173                      gpg_strerror (gpg_error_from_errno (errno)));
1174           assuan_sock_close (fd);
1175           dirmngr_exit (1);
1176         }
1177       cleanup_socket = 1;
1178
1179       if (gnupg_chmod (serv_addr.sun_path, "-rwx"))
1180         log_error (_("can't set permissions of '%s': %s\n"),
1181                    serv_addr.sun_path, strerror (errno));
1182
1183       if (listen (FD2INT (fd), 5) == -1)
1184         {
1185           log_error (_("listen() failed: %s\n"), strerror (errno));
1186           assuan_sock_close (fd);
1187           dirmngr_exit (1);
1188         }
1189
1190       if (opt.verbose)
1191         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1192
1193       es_fflush (NULL);
1194
1195       /* Note: We keep the dirmngr_info output only for the sake of
1196          existing scripts which might use this to detect a successful
1197          start of the dirmngr.  */
1198 #ifdef HAVE_W32_SYSTEM
1199       (void)csh_style;
1200       (void)nodetach;
1201
1202       pid = getpid ();
1203       es_printf ("set %s=%s;%lu;1\n",
1204                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1205 #else
1206       pid = fork();
1207       if (pid == (pid_t)-1)
1208         {
1209           log_fatal (_("error forking process: %s\n"), strerror (errno));
1210           dirmngr_exit (1);
1211         }
1212
1213       if (pid)
1214         { /* We are the parent */
1215           char *infostr;
1216
1217           /* Don't let cleanup() remove the socket - the child is
1218              responsible for doing that.  */
1219           cleanup_socket = 0;
1220
1221           close (fd);
1222
1223           /* Create the info string: <name>:<pid>:<protocol_version> */
1224           if (asprintf (&infostr, "%s=%s:%lu:1",
1225                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1226             {
1227               log_error (_("out of core\n"));
1228               kill (pid, SIGTERM);
1229               dirmngr_exit (1);
1230             }
1231           /* Print the environment string, so that the caller can use
1232              shell's eval to set it.  But see above.  */
1233           if (csh_style)
1234             {
1235               *strchr (infostr, '=') = ' ';
1236               es_printf ( "setenv %s;\n", infostr);
1237             }
1238           else
1239             {
1240               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1241             }
1242           free (infostr);
1243           exit (0);
1244           /*NEVER REACHED*/
1245         } /* end parent */
1246
1247
1248       /*
1249          This is the child
1250        */
1251
1252       /* Detach from tty and put process into a new session */
1253       if (!nodetach )
1254         {
1255           int i;
1256           unsigned int oldflags;
1257
1258           /* Close stdin, stdout and stderr unless it is the log stream */
1259           for (i=0; i <= 2; i++)
1260             {
1261               if (!log_test_fd (i) && i != fd )
1262                 {
1263                   if ( !close (i)
1264                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1265                     {
1266                       log_error ("failed to open '%s': %s\n",
1267                                  "/dev/null", strerror (errno));
1268                       cleanup ();
1269                       dirmngr_exit (1);
1270                     }
1271                 }
1272             }
1273
1274           if (setsid() == -1)
1275             {
1276               log_error ("setsid() failed: %s\n", strerror(errno) );
1277               dirmngr_exit (1);
1278             }
1279
1280           log_get_prefix (&oldflags);
1281           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1282           opt.running_detached = 1;
1283
1284           if (chdir("/"))
1285             {
1286               log_error ("chdir to / failed: %s\n", strerror (errno));
1287               dirmngr_exit (1);
1288             }
1289         }
1290 #endif
1291
1292       thread_init ();
1293       cert_cache_init ();
1294       crl_cache_init ();
1295       http_register_netactivity_cb (netactivity_action);
1296       handle_connections (fd);
1297       shutdown_reaper ();
1298     }
1299   else if (cmd == aListCRLs)
1300     {
1301       /* Just list the CRL cache and exit. */
1302       if (argc)
1303         wrong_args ("--list-crls");
1304       crl_cache_init ();
1305       crl_cache_list (es_stdout);
1306     }
1307   else if (cmd == aLoadCRL)
1308     {
1309       struct server_control_s ctrlbuf;
1310
1311       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1312       dirmngr_init_default_ctrl (&ctrlbuf);
1313
1314       thread_init ();
1315       cert_cache_init ();
1316       crl_cache_init ();
1317       if (!argc)
1318         rc = crl_cache_load (&ctrlbuf, NULL);
1319       else
1320         {
1321           for (; !rc && argc; argc--, argv++)
1322             rc = crl_cache_load (&ctrlbuf, *argv);
1323         }
1324       dirmngr_deinit_default_ctrl (&ctrlbuf);
1325     }
1326   else if (cmd == aFetchCRL)
1327     {
1328       ksba_reader_t reader;
1329       struct server_control_s ctrlbuf;
1330
1331       if (argc != 1)
1332         wrong_args ("--fetch-crl URL");
1333
1334       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1335       dirmngr_init_default_ctrl (&ctrlbuf);
1336
1337       thread_init ();
1338       cert_cache_init ();
1339       crl_cache_init ();
1340       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1341       if (rc)
1342         log_error (_("fetching CRL from '%s' failed: %s\n"),
1343                      argv[0], gpg_strerror (rc));
1344       else
1345         {
1346           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1347           if (rc)
1348             log_error (_("processing CRL from '%s' failed: %s\n"),
1349                        argv[0], gpg_strerror (rc));
1350           crl_close_reader (reader);
1351         }
1352       dirmngr_deinit_default_ctrl (&ctrlbuf);
1353     }
1354   else if (cmd == aFlush)
1355     {
1356       /* Delete cache and exit. */
1357       if (argc)
1358         wrong_args ("--flush");
1359       rc = crl_cache_flush();
1360     }
1361   else if (cmd == aGPGConfTest)
1362     dirmngr_exit (0);
1363   else if (cmd == aGPGConfList)
1364     {
1365       unsigned long flags = 0;
1366       char *filename;
1367       char *filename_esc;
1368
1369       /* First the configuration file.  This is not an option, but it
1370          is vital information for GPG Conf.  */
1371       if (!opt.config_filename)
1372         opt.config_filename = make_filename (gnupg_homedir (),
1373                                              "dirmngr.conf", NULL );
1374
1375       filename = percent_escape (opt.config_filename, NULL);
1376       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1377               GC_OPT_FLAG_DEFAULT, filename);
1378       xfree (filename);
1379
1380       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1381       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1382       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1383       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1384       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1385
1386       /* --csh and --sh are mutually exclusive, something we can not
1387          express in GPG Conf.  --options is only usable from the
1388          command line, really.  --debug-all interacts with --debug,
1389          and having both of them is thus problematic.  --no-detach is
1390          also only usable on the command line.  --batch is unused.  */
1391
1392       filename = make_filename (gnupg_homedir (),
1393                                 "dirmngr_ldapservers.conf",
1394                                 NULL);
1395       filename_esc = percent_escape (filename, NULL);
1396       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1397               filename_esc);
1398       xfree (filename_esc);
1399       xfree (filename);
1400
1401       es_printf ("ldaptimeout:%lu:%u\n",
1402               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1403       es_printf ("max-replies:%lu:%u\n",
1404               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1405       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1406       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1407       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1408       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1409
1410       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1411       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1412
1413       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1414       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1415       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1416       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1417       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1418       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1419       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1420       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1421       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1422       /* Note: The next one is to fix a typo in gpgconf - should be
1423          removed eventually. */
1424       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1425
1426       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1427       es_printf ("keyserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1428       es_printf ("nameserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1429       es_printf ("resolver-timeout:%lu:%u\n",
1430                  flags | GC_OPT_FLAG_DEFAULT, 0);
1431     }
1432   cleanup ();
1433   return !!rc;
1434 }
1435
1436
1437 static void
1438 cleanup (void)
1439 {
1440   crl_cache_deinit ();
1441   cert_cache_deinit (1);
1442   reload_dns_stuff (1);
1443
1444 #if USE_LDAP
1445   ldapserver_list_free (opt.ldapservers);
1446 #endif /*USE_LDAP*/
1447   opt.ldapservers = NULL;
1448
1449   if (cleanup_socket)
1450     {
1451       cleanup_socket = 0;
1452       if (redir_socket_name)
1453         gnupg_remove (redir_socket_name);
1454       else if (socket_name && *socket_name)
1455         gnupg_remove (socket_name);
1456     }
1457 }
1458
1459
1460 void
1461 dirmngr_exit (int rc)
1462 {
1463   cleanup ();
1464   exit (rc);
1465 }
1466
1467
1468 void
1469 dirmngr_init_default_ctrl (ctrl_t ctrl)
1470 {
1471   if (opt.http_proxy)
1472     ctrl->http_proxy = xstrdup (opt.http_proxy);
1473 }
1474
1475
1476 void
1477 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1478 {
1479   if (!ctrl)
1480     return;
1481   xfree (ctrl->http_proxy);
1482   ctrl->http_proxy = NULL;
1483 }
1484
1485
1486 /* Create a list of LDAP servers from the file FILENAME. Returns the
1487    list or NULL in case of errors.
1488
1489    The format fo such a file is line oriented where empty lines and
1490    lines starting with a hash mark are ignored.  All other lines are
1491    assumed to be colon seprated with these fields:
1492
1493    1. field: Hostname
1494    2. field: Portnumber
1495    3. field: Username
1496    4. field: Password
1497    5. field: Base DN
1498
1499 */
1500 #if USE_LDAP
1501 static ldap_server_t
1502 parse_ldapserver_file (const char* filename)
1503 {
1504   char buffer[1024];
1505   char *p;
1506   ldap_server_t server, serverstart, *serverend;
1507   int c;
1508   unsigned int lineno = 0;
1509   estream_t fp;
1510
1511   fp = es_fopen (filename, "r");
1512   if (!fp)
1513     {
1514       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1515       return NULL;
1516     }
1517
1518   serverstart = NULL;
1519   serverend = &serverstart;
1520   while (es_fgets (buffer, sizeof buffer, fp))
1521     {
1522       lineno++;
1523       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1524         {
1525           if (*buffer && es_feof (fp))
1526             ; /* Last line not terminated - continue. */
1527           else
1528             {
1529               log_error (_("%s:%u: line too long - skipped\n"),
1530                          filename, lineno);
1531               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1532                 ; /* Skip until end of line. */
1533               continue;
1534             }
1535         }
1536       /* Skip empty and comment lines.*/
1537       for (p=buffer; spacep (p); p++)
1538         ;
1539       if (!*p || *p == '\n' || *p == '#')
1540         continue;
1541
1542       /* Parse the colon separated fields. */
1543       server = ldapserver_parse_one (buffer, filename, lineno);
1544       if (server)
1545         {
1546           *serverend = server;
1547           serverend = &server->next;
1548         }
1549     }
1550
1551   if (es_ferror (fp))
1552     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1553   es_fclose (fp);
1554
1555   return serverstart;
1556 }
1557 #endif /*USE_LDAP*/
1558
1559 static fingerprint_list_t
1560 parse_ocsp_signer (const char *string)
1561 {
1562   gpg_error_t err;
1563   char *fname;
1564   estream_t fp;
1565   char line[256];
1566   char *p;
1567   fingerprint_list_t list, *list_tail, item;
1568   unsigned int lnr = 0;
1569   int c, i, j;
1570   int errflag = 0;
1571
1572
1573   /* Check whether this is not a filename and treat it as a direct
1574      fingerprint specification.  */
1575   if (!strpbrk (string, "/.~\\"))
1576     {
1577       item = xcalloc (1, sizeof *item);
1578       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1579         if ( string[i] != ':' )
1580           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1581       item->hexfpr[j] = 0;
1582       if (j != 40 || !(spacep (string+i) || !string[i]))
1583         {
1584           log_error (_("%s:%u: invalid fingerprint detected\n"),
1585                      "--ocsp-signer", 0);
1586           xfree (item);
1587           return NULL;
1588         }
1589       return item;
1590     }
1591
1592   /* Well, it is a filename.  */
1593   if (*string == '/' || (*string == '~' && string[1] == '/'))
1594     fname = make_filename (string, NULL);
1595   else
1596     {
1597       if (string[0] == '.' && string[1] == '/' )
1598         string += 2;
1599       fname = make_filename (gnupg_homedir (), string, NULL);
1600     }
1601
1602   fp = es_fopen (fname, "r");
1603   if (!fp)
1604     {
1605       err = gpg_error_from_syserror ();
1606       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1607       xfree (fname);
1608       return NULL;
1609     }
1610
1611   list = NULL;
1612   list_tail = &list;
1613   for (;;)
1614     {
1615       if (!es_fgets (line, DIM(line)-1, fp) )
1616         {
1617           if (!es_feof (fp))
1618             {
1619               err = gpg_error_from_syserror ();
1620               log_error (_("%s:%u: read error: %s\n"),
1621                          fname, lnr, gpg_strerror (err));
1622               errflag = 1;
1623             }
1624           es_fclose (fp);
1625           if (errflag)
1626             {
1627               while (list)
1628                 {
1629                   fingerprint_list_t tmp = list->next;
1630                   xfree (list);
1631                   list = tmp;
1632                 }
1633             }
1634           xfree (fname);
1635           return list; /* Ready.  */
1636         }
1637
1638       lnr++;
1639       if (!*line || line[strlen(line)-1] != '\n')
1640         {
1641           /* Eat until end of line. */
1642           while ( (c=es_getc (fp)) != EOF && c != '\n')
1643             ;
1644           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1645                            /* */: GPG_ERR_INCOMPLETE_LINE);
1646           log_error (_("%s:%u: read error: %s\n"),
1647                      fname, lnr, gpg_strerror (err));
1648           errflag = 1;
1649           continue;
1650         }
1651
1652       /* Allow for empty lines and spaces */
1653       for (p=line; spacep (p); p++)
1654         ;
1655       if (!*p || *p == '\n' || *p == '#')
1656         continue;
1657
1658       item = xcalloc (1, sizeof *item);
1659       *list_tail = item;
1660       list_tail = &item->next;
1661
1662       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1663         if ( p[i] != ':' )
1664           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1665       item->hexfpr[j] = 0;
1666       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1667         {
1668           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1669           errflag = 1;
1670         }
1671       i++;
1672       while (spacep (p+i))
1673         i++;
1674       if (p[i] && p[i] != '\n')
1675         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1676     }
1677   /*NOTREACHED*/
1678 }
1679
1680
1681
1682 \f
1683 /*
1684    Stuff used in daemon mode.
1685  */
1686
1687
1688
1689 /* Reread parts of the configuration.  Note, that this function is
1690    obviously not thread-safe and should only be called from the NPTH
1691    signal handler.
1692
1693    Fixme: Due to the way the argument parsing works, we create a
1694    memory leak here for all string type arguments.  There is currently
1695    no clean way to tell whether the memory for the argument has been
1696    allocated or points into the process' original arguments.  Unless
1697    we have a mechanism to tell this, we need to live on with this. */
1698 static void
1699 reread_configuration (void)
1700 {
1701   ARGPARSE_ARGS pargs;
1702   FILE *fp;
1703   unsigned int configlineno = 0;
1704   int dummy;
1705
1706   if (!opt.config_filename)
1707     return; /* No config file. */
1708
1709   fp = fopen (opt.config_filename, "r");
1710   if (!fp)
1711     {
1712       log_error (_("option file '%s': %s\n"),
1713                  opt.config_filename, strerror(errno) );
1714       return;
1715     }
1716
1717   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1718
1719   memset (&pargs, 0, sizeof pargs);
1720   dummy = 0;
1721   pargs.argc = &dummy;
1722   pargs.flags = 1;  /* do not remove the args */
1723   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1724     {
1725       if (pargs.r_opt < -1)
1726         pargs.err = 1; /* Print a warning. */
1727       else /* Try to parse this option - ignore unchangeable ones. */
1728         parse_rereadable_options (&pargs, 1);
1729     }
1730   fclose (fp);
1731
1732   set_debug ();
1733   set_tor_mode ();
1734 }
1735
1736
1737 /* A global function which allows us to trigger the reload stuff from
1738    other places.  */
1739 void
1740 dirmngr_sighup_action (void)
1741 {
1742   log_info (_("SIGHUP received - "
1743               "re-reading configuration and flushing caches\n"));
1744   reread_configuration ();
1745   cert_cache_deinit (0);
1746   crl_cache_deinit ();
1747   cert_cache_init ();
1748   crl_cache_init ();
1749   reload_dns_stuff (0);
1750   ks_hkp_reload ();
1751 }
1752
1753
1754 /* This function is called if some network activity was done.  At this
1755  * point we know the we have a network and we can decide whether to
1756  * run scheduled background tasks soon.  The function should return
1757  * quickly and only trigger actions for another thread. */
1758 static void
1759 netactivity_action (void)
1760 {
1761   network_activity_seen = 1;
1762 }
1763
1764
1765 /* The signal handler. */
1766 #ifndef HAVE_W32_SYSTEM
1767 static void
1768 handle_signal (int signo)
1769 {
1770   switch (signo)
1771     {
1772     case SIGHUP:
1773       dirmngr_sighup_action ();
1774       break;
1775
1776     case SIGUSR1:
1777       cert_cache_print_stats ();
1778       break;
1779
1780     case SIGUSR2:
1781       log_info (_("SIGUSR2 received - no action defined\n"));
1782       break;
1783
1784     case SIGTERM:
1785       if (!shutdown_pending)
1786         log_info (_("SIGTERM received - shutting down ...\n"));
1787       else
1788         log_info (_("SIGTERM received - still %d active connections\n"),
1789                   active_connections);
1790       shutdown_pending++;
1791       if (shutdown_pending > 2)
1792         {
1793           log_info (_("shutdown forced\n"));
1794           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1795           cleanup ();
1796           dirmngr_exit (0);
1797         }
1798       break;
1799
1800     case SIGINT:
1801       log_info (_("SIGINT received - immediate shutdown\n"));
1802       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1803       cleanup ();
1804       dirmngr_exit (0);
1805       break;
1806
1807     default:
1808       log_info (_("signal %d received - no action defined\n"), signo);
1809     }
1810 }
1811 #endif /*!HAVE_W32_SYSTEM*/
1812
1813
1814 /* Thread to do the housekeeping.  */
1815 static void *
1816 housekeeping_thread (void *arg)
1817 {
1818   static int sentinel;
1819   time_t curtime;
1820   struct server_control_s ctrlbuf;
1821
1822   (void)arg;
1823
1824   curtime = gnupg_get_time ();
1825   if (sentinel)
1826     {
1827       log_info ("housekeeping is already going on\n");
1828       return NULL;
1829     }
1830   sentinel++;
1831   if (opt.verbose > 1)
1832     log_info ("starting housekeeping\n");
1833
1834   memset (&ctrlbuf, 0, sizeof ctrlbuf);
1835   dirmngr_init_default_ctrl (&ctrlbuf);
1836
1837   ks_hkp_housekeeping (curtime);
1838   if (network_activity_seen)
1839     {
1840       network_activity_seen = 0;
1841       if (opt.allow_version_check)
1842         dirmngr_load_swdb (&ctrlbuf, 0);
1843     }
1844
1845   dirmngr_deinit_default_ctrl (&ctrlbuf);
1846
1847   if (opt.verbose > 1)
1848     log_info ("ready with housekeeping\n");
1849   sentinel--;
1850   return NULL;
1851
1852 }
1853
1854
1855 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1856 # pragma GCC push_options
1857 # pragma GCC optimize ("no-strict-overflow")
1858 #endif
1859 static int
1860 time_for_housekeeping_p (time_t curtime)
1861 {
1862   static time_t last_housekeeping;
1863
1864   if (!last_housekeeping)
1865     last_housekeeping = curtime;
1866
1867   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1868       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1869     {
1870       last_housekeeping = curtime;
1871       return 1;
1872     }
1873   return 0;
1874 }
1875 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1876 # pragma GCC pop_options
1877 #endif
1878
1879
1880 /* This is the worker for the ticker.  It is called every few seconds
1881    and may only do fast operations. */
1882 static void
1883 handle_tick (void)
1884 {
1885   if (time_for_housekeeping_p (gnupg_get_time ()))
1886     {
1887       npth_t thread;
1888       npth_attr_t tattr;
1889       int err;
1890
1891       err = npth_attr_init (&tattr);
1892       if (err)
1893         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1894       else
1895         {
1896           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1897           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1898           if (err)
1899             log_error ("error spawning housekeeping thread: %s\n",
1900                        strerror (err));
1901           npth_attr_destroy (&tattr);
1902         }
1903     }
1904 }
1905
1906
1907 /* Check the nonce on a new connection.  This is a NOP unless we are
1908    using our Unix domain socket emulation under Windows.  */
1909 static int
1910 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1911 {
1912   if (assuan_sock_check_nonce (fd, nonce))
1913     {
1914       log_info (_("error reading nonce on fd %d: %s\n"),
1915                 FD2INT (fd), strerror (errno));
1916       assuan_sock_close (fd);
1917       return -1;
1918     }
1919   else
1920     return 0;
1921 }
1922
1923
1924 /* Helper to call a connection's main function. */
1925 static void *
1926 start_connection_thread (void *arg)
1927 {
1928   union int_and_ptr_u argval;
1929   gnupg_fd_t fd;
1930
1931   memset (&argval, 0, sizeof argval);
1932   argval.aptr = arg;
1933   fd = argval.afd;
1934
1935   if (check_nonce (fd, &socket_nonce))
1936     {
1937       log_error ("handler nonce check FAILED\n");
1938       return NULL;
1939     }
1940
1941 #ifndef HAVE_W32_SYSTEM
1942   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1943 #endif
1944
1945   active_connections++;
1946   if (opt.verbose)
1947     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1948
1949   start_command_handler (fd);
1950
1951   if (opt.verbose)
1952     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1953   active_connections--;
1954
1955 #ifndef HAVE_W32_SYSTEM
1956   argval.afd = ASSUAN_INVALID_FD;
1957   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1958 #endif
1959
1960   return NULL;
1961 }
1962
1963
1964 #ifdef HAVE_INOTIFY_INIT
1965 /* Read an inotify event and return true if it matches NAME.  */
1966 static int
1967 my_inotify_is_name (int fd, const char *name)
1968 {
1969   union {
1970     struct inotify_event ev;
1971     char _buf[sizeof (struct inotify_event) + 100 + 1];
1972   } buf;
1973   int n;
1974   const char *s;
1975
1976   s = strrchr (name, '/');
1977   if (s && s[1])
1978     name = s + 1;
1979
1980   n = npth_read (fd, &buf, sizeof buf);
1981   if (n < sizeof (struct inotify_event))
1982     return 0;
1983   if (buf.ev.len < strlen (name)+1)
1984     return 0;
1985   if (strcmp (buf.ev.name, name))
1986     return 0; /* Not the desired file.  */
1987
1988   return 1; /* Found.  */
1989 }
1990 #endif /*HAVE_INOTIFY_INIT*/
1991
1992
1993 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
1994  * this function. */
1995 static void
1996 handle_connections (assuan_fd_t listen_fd)
1997 {
1998   npth_attr_t tattr;
1999 #ifndef HAVE_W32_SYSTEM
2000   int signo;
2001 #endif
2002   struct sockaddr_un paddr;
2003   socklen_t plen = sizeof( paddr );
2004   gnupg_fd_t fd;
2005   int nfd, ret;
2006   fd_set fdset, read_fdset;
2007   struct timespec abstime;
2008   struct timespec curtime;
2009   struct timespec timeout;
2010   int saved_errno;
2011   int my_inotify_fd = -1;
2012
2013   npth_attr_init (&tattr);
2014   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2015
2016 #ifndef HAVE_W32_SYSTEM /* FIXME */
2017   npth_sigev_init ();
2018   npth_sigev_add (SIGHUP);
2019   npth_sigev_add (SIGUSR1);
2020   npth_sigev_add (SIGUSR2);
2021   npth_sigev_add (SIGINT);
2022   npth_sigev_add (SIGTERM);
2023   npth_sigev_fini ();
2024 #endif
2025
2026 #ifdef HAVE_INOTIFY_INIT
2027   if (disable_check_own_socket)
2028     my_inotify_fd = -1;
2029   else if ((my_inotify_fd = inotify_init ()) == -1)
2030     log_info ("error enabling fast daemon termination: %s\n",
2031               strerror (errno));
2032   else
2033     {
2034       /* We need to watch the directory for the file because there
2035        * won't be an IN_DELETE_SELF for a socket file.  */
2036       char *slash = strrchr (socket_name, '/');
2037       log_assert (slash && slash[1]);
2038       *slash = 0;
2039       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2040         {
2041           close (my_inotify_fd);
2042           my_inotify_fd = -1;
2043         }
2044       *slash = '/';
2045     }
2046 #endif /*HAVE_INOTIFY_INIT*/
2047
2048
2049   /* Setup the fdset.  It has only one member.  This is because we use
2050      pth_select instead of pth_accept to properly sync timeouts with
2051      to full second.  */
2052   FD_ZERO (&fdset);
2053   FD_SET (FD2INT (listen_fd), &fdset);
2054   nfd = FD2INT (listen_fd);
2055   if (my_inotify_fd != -1)
2056     {
2057       FD_SET (my_inotify_fd, &fdset);
2058       if (my_inotify_fd > nfd)
2059         nfd = my_inotify_fd;
2060     }
2061
2062   npth_clock_gettime (&abstime);
2063   abstime.tv_sec += TIMERTICK_INTERVAL;
2064
2065   /* Main loop.  */
2066   for (;;)
2067     {
2068       /* Shutdown test.  */
2069       if (shutdown_pending)
2070         {
2071           if (!active_connections)
2072             break; /* ready */
2073
2074           /* Do not accept new connections but keep on running the
2075            * loop to cope with the timer events.
2076            *
2077            * Note that we do not close the listening socket because a
2078            * client trying to connect to that socket would instead
2079            * restart a new dirmngr instance - which is unlikely the
2080            * intention of a shutdown. */
2081           /* assuan_sock_close (listen_fd); */
2082           /* listen_fd = -1; */
2083           FD_ZERO (&fdset);
2084           nfd = -1;
2085           if (my_inotify_fd != -1)
2086             {
2087               FD_SET (my_inotify_fd, &fdset);
2088               nfd = my_inotify_fd;
2089             }
2090         }
2091
2092       /* Take a copy of the fdset.  */
2093       read_fdset = fdset;
2094
2095       npth_clock_gettime (&curtime);
2096       if (!(npth_timercmp (&curtime, &abstime, <)))
2097         {
2098           /* Timeout.  */
2099           handle_tick ();
2100           npth_clock_gettime (&abstime);
2101           abstime.tv_sec += TIMERTICK_INTERVAL;
2102         }
2103       npth_timersub (&abstime, &curtime, &timeout);
2104
2105 #ifndef HAVE_W32_SYSTEM
2106       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2107       saved_errno = errno;
2108
2109       while (npth_sigev_get_pending(&signo))
2110         handle_signal (signo);
2111 #else
2112       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2113       saved_errno = errno;
2114 #endif
2115
2116       if (ret == -1 && saved_errno != EINTR)
2117         {
2118           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2119                      strerror (saved_errno));
2120           npth_sleep (1);
2121           continue;
2122         }
2123
2124       if (ret <= 0)
2125         {
2126           /* Interrupt or timeout.  Will be handled when calculating the
2127              next timeout.  */
2128           continue;
2129         }
2130
2131       if (shutdown_pending)
2132         {
2133           /* Do not anymore accept connections.  */
2134           continue;
2135         }
2136
2137 #ifdef HAVE_INOTIFY_INIT
2138       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2139           && my_inotify_is_name (my_inotify_fd, socket_name))
2140         {
2141           shutdown_pending = 1;
2142           log_info ("socket file has been removed - shutting down\n");
2143         }
2144 #endif /*HAVE_INOTIFY_INIT*/
2145
2146       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
2147         {
2148           plen = sizeof paddr;
2149           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2150                                     (struct sockaddr *)&paddr, &plen));
2151           if (fd == GNUPG_INVALID_FD)
2152             {
2153               log_error ("accept failed: %s\n", strerror (errno));
2154             }
2155           else
2156             {
2157               char threadname[50];
2158               union int_and_ptr_u argval;
2159               npth_t thread;
2160
2161               memset (&argval, 0, sizeof argval);
2162               argval.afd = fd;
2163               snprintf (threadname, sizeof threadname,
2164                         "conn fd=%d", FD2INT(fd));
2165
2166               ret = npth_create (&thread, &tattr,
2167                                  start_connection_thread, argval.aptr);
2168               if (ret)
2169                 {
2170                   log_error ("error spawning connection handler: %s\n",
2171                              strerror (ret) );
2172                   assuan_sock_close (fd);
2173                 }
2174               npth_setname_np (thread, threadname);
2175             }
2176           fd = GNUPG_INVALID_FD;
2177         }
2178     }
2179
2180 #ifdef HAVE_INOTIFY_INIT
2181   if (my_inotify_fd != -1)
2182     close (my_inotify_fd);
2183 #endif /*HAVE_INOTIFY_INIT*/
2184   npth_attr_destroy (&tattr);
2185   if (listen_fd != -1)
2186     assuan_sock_close (fd);
2187   cleanup ();
2188   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2189 }
2190
2191 const char*
2192 dirmngr_get_current_socket_name (void)
2193 {
2194   if (socket_name)
2195     return socket_name;
2196   else
2197     return dirmngr_socket_name ();
2198 }