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