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