Adding upstream version 1.7.3.upstream/1.7.3upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1707 insertions, 0 deletions

diff --git a/doh.cc b/doh.cc
new file mode 100644
index 0000000..ed29758
--- /dev/null
+++ b/doh.cc
@@ -0,0 +1,1707 @@
+#include "config.h"
+#include "doh.hh"
+
+#ifdef HAVE_DNS_OVER_HTTPS
+#define H2O_USE_EPOLL 1
+
+#include <errno.h>
+#include <iostream>
+#include <thread>
+
+#include <boost/algorithm/string.hpp>
+#include <h2o.h>
+//#include <h2o/http1.h>
+#include <h2o/http2.h>
+
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+
+#include "base64.hh"
+#include "dnsname.hh"
+#undef CERT
+#include "dnsdist.hh"
+#include "dnsdist-tcp.hh"
+#include "misc.hh"
+#include "dns.hh"
+#include "dolog.hh"
+#include "dnsdist-ecs.hh"
+#include "dnsdist-proxy-protocol.hh"
+#include "dnsdist-rules.hh"
+#include "dnsdist-xpf.hh"
+#include "libssl.hh"
+#include "threadname.hh"
+
+/* So, how does this work. We use h2o for our http2 and TLS needs.
+   If the operator has configured multiple IP addresses to listen on,
+   we launch multiple h2o listener threads. We can hook in to multiple
+   URLs though on the same IP. There is no SNI yet (I think).
+
+   h2o is event driven, so we get callbacks if a new DNS query arrived.
+   When it does, we do some minimal parsing on it, and send it on to the
+   dnsdist worker thread which we also launched.
+
+   This dnsdist worker thread injects the query into the normal dnsdist flow
+   (over a pipe). The response also goes back over a (different) pipe,
+   where we pick it up and deliver it back to h2o.
+
+   For coordination, we use the h2o socket multiplexer, which is sensitive to our
+   pipe too.
+*/
+
+/* h2o notes.
+   Paths and parameters etc just *happen* to be null-terminated in HTTP2.
+   They are not in HTTP1. So you MUST use the length field!
+*/
+
+/* 'Intermediate' compatibility from https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28default.29 */
+#define DOH_DEFAULT_CIPHERS "ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS"
+
+class DOHAcceptContext
+{
+public:
+  DOHAcceptContext()
+  {
+    memset(&d_h2o_accept_ctx, 0, sizeof(d_h2o_accept_ctx));
+    d_rotatingTicketsKey.clear();
+  }
+  DOHAcceptContext(const DOHAcceptContext&) = delete;
+  DOHAcceptContext& operator=(const DOHAcceptContext&) = delete;
+
+  h2o_accept_ctx_t* get()
+  {
+    return &d_h2o_accept_ctx;
+  }
+
+  ~DOHAcceptContext()
+  {
+    SSL_CTX_free(d_h2o_accept_ctx.ssl_ctx);
+    d_h2o_accept_ctx.ssl_ctx = nullptr;
+  }
+
+  void decrementConcurrentConnections()
+  {
+    if (d_cs != nullptr) {
+      --d_cs->tcpCurrentConnections;
+    }
+  }
+
+  time_t getNextTicketsKeyRotation() const
+  {
+    return d_ticketsKeyNextRotation;
+  }
+
+  size_t getTicketsKeysCount() const
+  {
+    size_t res = 0;
+    if (d_ticketKeys) {
+      res = d_ticketKeys->getKeysCount();
+    }
+    return res;
+  }
+
+  void rotateTicketsKey(time_t now)
+  {
+    if (!d_ticketKeys) {
+      return;
+    }
+
+    d_ticketKeys->rotateTicketsKey(now);
+
+    if (d_ticketsKeyRotationDelay > 0) {
+      d_ticketsKeyNextRotation = now + d_ticketsKeyRotationDelay;
+    }
+  }
+
+  void loadTicketsKeys(const std::string& keyFile)
+  {
+    if (!d_ticketKeys) {
+      return;
+    }
+    d_ticketKeys->loadTicketsKeys(keyFile);
+
+    if (d_ticketsKeyRotationDelay > 0) {
+      d_ticketsKeyNextRotation = time(nullptr) + d_ticketsKeyRotationDelay;
+    }
+  }
+
+  void handleTicketsKeyRotation()
+  {
+    if (d_ticketsKeyRotationDelay == 0) {
+      return;
+    }
+
+    time_t now = time(nullptr);
+    if (now > d_ticketsKeyNextRotation) {
+      if (d_rotatingTicketsKey.test_and_set()) {
+        /* someone is already rotating */
+        return;
+      }
+      try {
+        rotateTicketsKey(now);
+
+        d_rotatingTicketsKey.clear();
+      }
+      catch(const std::runtime_error& e) {
+        d_rotatingTicketsKey.clear();
+        throw std::runtime_error(std::string("Error generating a new tickets key for TLS context:") + e.what());
+      }
+      catch(...) {
+        d_rotatingTicketsKey.clear();
+        throw;
+      }
+    }
+  }
+
+  std::map<int, std::string> d_ocspResponses;
+  std::unique_ptr<OpenSSLTLSTicketKeysRing> d_ticketKeys{nullptr};
+  std::unique_ptr<FILE, int(*)(FILE*)> d_keyLogFile{nullptr, fclose};
+  ClientState* d_cs{nullptr};
+  time_t d_ticketsKeyRotationDelay{0};
+
+private:
+  h2o_accept_ctx_t d_h2o_accept_ctx;
+  std::atomic<uint64_t> d_refcnt{1};
+  time_t d_ticketsKeyNextRotation{0};
+  std::atomic_flag d_rotatingTicketsKey;
+};
+
+// we create one of these per thread, and pass around a pointer to it
+// through the bowels of h2o
+struct DOHServerConfig
+{
+  DOHServerConfig(uint32_t idleTimeout, uint32_t internalPipeBufferSize): accept_ctx(std::make_shared<DOHAcceptContext>())
+  {
+    int fd[2];
+    if (pipe(fd) < 0) {
+      unixDie("Creating a pipe for DNS over HTTPS");
+    }
+    dohquerypair[0] = fd[1];
+    dohquerypair[1] = fd[0];
+
+    setNonBlocking(dohquerypair[0]);
+    if (internalPipeBufferSize > 0) {
+      setPipeBufferSize(dohquerypair[0], internalPipeBufferSize);
+    }
+
+    if (pipe(fd) < 0) {
+      close(dohquerypair[0]);
+      close(dohquerypair[1]);
+      unixDie("Creating a pipe for DNS over HTTPS");
+    }
+
+    dohresponsepair[0] = fd[1];
+    dohresponsepair[1] = fd[0];
+
+    setNonBlocking(dohresponsepair[0]);
+    if (internalPipeBufferSize > 0) {
+      setPipeBufferSize(dohresponsepair[0], internalPipeBufferSize);
+    }
+
+    setNonBlocking(dohresponsepair[1]);
+
+    h2o_config_init(&h2o_config);
+    h2o_config.http2.idle_timeout = idleTimeout * 1000;
+    /* if you came here for a way to make the number of concurrent streams (concurrent requests per connection)
+       configurable, or even just bigger, I have bad news for you.
+       h2o_config.http2.max_concurrent_requests_per_connection (default of 100) is capped by
+       H2O_HTTP2_SETTINGS_HOST.max_concurrent_streams which is not configurable. Even if decided to change the
+       hard-coded value, libh2o's author warns that there might be parts of the code where the stream ID is stored
+       in 8 bits, making 256 a hard value: https://github.com/h2o/h2o/issues/805
+    */
+  }
+  DOHServerConfig(const DOHServerConfig&) = delete;
+  DOHServerConfig& operator=(const DOHServerConfig&) = delete;
+
+  LocalHolders holders;
+  std::set<std::string> paths;
+  h2o_globalconf_t h2o_config;
+  h2o_context_t h2o_ctx;
+  std::shared_ptr<DOHAcceptContext> accept_ctx{nullptr};
+  ClientState* cs{nullptr};
+  std::shared_ptr<DOHFrontend> df{nullptr};
+  int dohquerypair[2]{-1,-1};
+  int dohresponsepair[2]{-1,-1};
+};
+
+/* This internal function sends back the object to the main thread to send a reply.
+   The caller should NOT release or touch the unit after calling this function */
+static void sendDoHUnitToTheMainThread(DOHUnitUniquePtr&& du, const char* description)
+{
+  /* taking a naked pointer since we are about to send that pointer over a pipe */
+  auto ptr = du.release();
+  /* increasing the reference counter. This should not be strictly needed because
+     we already hold a reference and will only release it if we failed to send the
+     pointer over the pipe, but TSAN seems confused when the responder thread gets
+     a reply from a backend before the send() syscall sending the corresponding query
+     to that backend has returned in the initial thread.
+     The memory barrier needed to increase that counter seems to work around that.
+  */
+  ptr->get();
+  static_assert(sizeof(ptr) <= PIPE_BUF, "Writes up to PIPE_BUF are guaranteed not to be interleaved and to either fully succeed or fail");
+
+  ssize_t sent = write(ptr->rsock, &ptr, sizeof(ptr));
+  if (sent != sizeof(ptr)) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      ++g_stats.dohResponsePipeFull;
+      vinfolog("Unable to pass a %s to the DoH worker thread because the pipe is full", description);
+    }
+    else {
+      vinfolog("Unable to pass a %s to the DoH worker thread because we couldn't write to the pipe: %s", description, stringerror());
+    }
+
+    /* we fail to write over the pipe so we do not need to hold to that ref anymore */
+    ptr->release();
+  }
+  /* we decrement the counter incremented above at the beginning of that function */
+  ptr->release();
+}
+
+/* This function is called from other threads than the main DoH one,
+   instructing it to send a 502 error to the client.
+   It takes ownership of the unit. */
+void handleDOHTimeout(DOHUnitUniquePtr&& oldDU)
+{
+  if (oldDU == nullptr) {
+    return;
+  }
+
+/* we are about to erase an existing DU */
+  oldDU->status_code = 502;
+
+  sendDoHUnitToTheMainThread(std::move(oldDU), "DoH timeout");
+}
+
+struct DOHConnection
+{
+  std::shared_ptr<DOHAcceptContext> d_acceptCtx{nullptr};
+  struct timeval d_connectionStartTime{0, 0};
+  size_t d_nbQueries{0};
+  int d_desc{-1};
+};
+
+static thread_local std::unordered_map<int, DOHConnection> t_conns;
+
+static void on_socketclose(void *data)
+{
+  auto conn = reinterpret_cast<DOHConnection*>(data);
+  if (conn != nullptr) {
+    if (conn->d_acceptCtx) {
+      struct timeval now;
+      gettimeofday(&now, nullptr);
+
+      auto diff = now - conn->d_connectionStartTime;
+
+      conn->d_acceptCtx->decrementConcurrentConnections();
+      conn->d_acceptCtx->d_cs->updateTCPMetrics(conn->d_nbQueries, diff.tv_sec * 1000 + diff.tv_usec / 1000);
+    }
+
+    t_conns.erase(conn->d_desc);
+  }
+}
+
+static const std::string& getReasonFromStatusCode(uint16_t statusCode)
+{
+  /* no need to care too much about this, HTTP/2 has no 'reason' anyway */
+  static const std::unordered_map<uint16_t, std::string> reasons = {
+    { 200, "OK" },
+    { 301, "Moved Permanently" },
+    { 302, "Found" },
+    { 303, "See Other" },
+    { 304, "Not Modified" },
+    { 305, "Use Proxy" },
+    { 306, "Switch Proxy" },
+    { 307, "Temporary Redirect" },
+    { 308, "Permanent Redirect" },
+    { 400, "Bad Request" },
+    { 401, "Unauthorized" },
+    { 402, "Payment Required" },
+    { 403, "Forbidden" },
+    { 404, "Not Found" },
+    { 405, "Method Not Allowed" },
+    { 406, "Not Acceptable" },
+    { 407, "Proxy Authentication Required" },
+    { 408, "Request Timeout" },
+    { 409, "Conflict" },
+    { 410, "Gone" },
+    { 411, "Length Required" },
+    { 412, "Precondition Failed" },
+    { 413, "Payload Too Large" },
+    { 414, "URI Too Long" },
+    { 415, "Unsupported Media Type" },
+    { 416, "Range Not Satisfiable" },
+    { 417, "Expectation Failed" },
+    { 418, "I'm a teapot" },
+    { 451, "Unavailable For Legal Reasons" },
+    { 500, "Internal Server Error" },
+    { 501, "Not Implemented" },
+    { 502, "Bad Gateway" },
+    { 503, "Service Unavailable" },
+    { 504, "Gateway Timeout" },
+    { 505, "HTTP Version Not Supported" }
+  };
+  static const std::string unknown = "Unknown";
+
+  const auto it = reasons.find(statusCode);
+  if (it == reasons.end()) {
+    return unknown;
+  }
+  else {
+    return it->second;
+  }
+}
+
+/* Always called from the main DoH thread */
+static void handleResponse(DOHFrontend& df, st_h2o_req_t* req, uint16_t statusCode, const PacketBuffer& response, const std::vector<std::pair<std::string, std::string>>& customResponseHeaders, const std::string& contentType, bool addContentType)
+{
+  constexpr int overwrite_if_exists = 1;
+  constexpr int maybe_token = 1;
+  for (auto const& headerPair : customResponseHeaders) {
+    h2o_set_header_by_str(&req->pool, &req->res.headers, headerPair.first.c_str(), headerPair.first.size(), maybe_token, headerPair.second.c_str(), headerPair.second.size(), overwrite_if_exists);
+  }
+
+  if (statusCode == 200) {
+    ++df.d_validresponses;
+    req->res.status = 200;
+
+    if (addContentType) {
+      if (contentType.empty()) {
+        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, nullptr, H2O_STRLIT("application/dns-message"));
+      }
+      else {
+        /* we need to duplicate the header content because h2o keeps a pointer and we will be deleted before the response has been sent */
+        h2o_iovec_t ct = h2o_strdup(&req->pool, contentType.c_str(), contentType.size());
+        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, nullptr, ct.base, ct.len);
+      }
+    }
+
+    if (df.d_sendCacheControlHeaders && response.size() > sizeof(dnsheader)) {
+      uint32_t minTTL = getDNSPacketMinTTL(reinterpret_cast<const char*>(response.data()), response.size());
+      if (minTTL != std::numeric_limits<uint32_t>::max()) {
+        std::string cacheControlValue = "max-age=" + std::to_string(minTTL);
+        /* we need to duplicate the header content because h2o keeps a pointer and we will be deleted before the response has been sent */
+        h2o_iovec_t ccv = h2o_strdup(&req->pool, cacheControlValue.c_str(), cacheControlValue.size());
+        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CACHE_CONTROL, nullptr, ccv.base, ccv.len);
+      }
+    }
+
+    req->res.content_length = response.size();
+    h2o_send_inline(req, reinterpret_cast<const char*>(response.data()), response.size());
+  }
+  else if (statusCode >= 300 && statusCode < 400) {
+    /* in that case the response is actually a URL */
+    /* we need to duplicate the URL because h2o uses it for the location header, keeping a pointer, and we will be deleted before the response has been sent */
+    h2o_iovec_t url = h2o_strdup(&req->pool, reinterpret_cast<const char*>(response.data()), response.size());
+    h2o_send_redirect(req, statusCode, getReasonFromStatusCode(statusCode).c_str(), url.base, url.len);
+    ++df.d_redirectresponses;
+  }
+  else {
+    // we need to make sure it's null-terminated */
+    if (!response.empty() && response.at(response.size() - 1) == 0) {
+      h2o_send_error_generic(req, statusCode, getReasonFromStatusCode(statusCode).c_str(), reinterpret_cast<const char*>(response.data()), H2O_SEND_ERROR_KEEP_HEADERS);
+    }
+    else {
+      switch(statusCode) {
+      case 400:
+        h2o_send_error_400(req, getReasonFromStatusCode(statusCode).c_str(), "invalid DNS query" , 0);
+        break;
+      case 403:
+        h2o_send_error_403(req, getReasonFromStatusCode(statusCode).c_str(), "dns query not allowed", 0);
+        break;
+      case 502:
+        h2o_send_error_502(req, getReasonFromStatusCode(statusCode).c_str(), "no downstream server available", 0);
+        break;
+      case 500:
+        /* fall-through */
+      default:
+        h2o_send_error_500(req, getReasonFromStatusCode(statusCode).c_str(), "Internal Server Error", 0);
+        break;
+      }
+    }
+
+    ++df.d_errorresponses;
+  }
+}
+
+class DoHTCPCrossQuerySender : public TCPQuerySender
+{
+public:
+  DoHTCPCrossQuerySender(DOHUnitUniquePtr&& du_): du(std::move(du_))
+  {
+  }
+
+  bool active() const override
+  {
+    return true;
+  }
+
+  const ClientState* getClientState() const override
+  {
+    if (!du || !du->dsc || !du->dsc->cs) {
+      throw std::runtime_error("No query associated to this DoHTCPCrossQuerySender");
+    }
+
+    return du->dsc->cs;
+  }
+
+  void handleResponse(const struct timeval& now, TCPResponse&& response) override
+  {
+    if (!du) {
+      return;
+    }
+
+    if (du->rsock == -1) {
+      return;
+    }
+
+    du->response = std::move(response.d_buffer);
+    du->ids = std::move(response.d_idstate);
+
+    thread_local LocalStateHolder<vector<DNSDistResponseRuleAction>> localRespRuleActions = g_respruleactions.getLocal();
+    DNSResponse dr = makeDNSResponseFromIDState(du->ids, du->response);
+    dnsheader cleartextDH;
+    memcpy(&cleartextDH, dr.getHeader(), sizeof(cleartextDH));
+
+    if (!processResponse(du->response, localRespRuleActions, dr, false, false)) {
+      du.reset();
+      return;
+    }
+
+    double udiff = du->ids.sentTime.udiff();
+    vinfolog("Got answer from %s, relayed to %s (https), took %f usec", du->downstream->remote.toStringWithPort(), du->ids.origRemote.toStringWithPort(), udiff);
+
+    auto backendProtocol = du->downstream->getProtocol();
+    if (backendProtocol == dnsdist::Protocol::DoUDP && du->tcp) {
+      backendProtocol = dnsdist::Protocol::DoTCP;
+    }
+    handleResponseSent(du->ids, udiff, *dr.remote, du->downstream->remote, du->response.size(), cleartextDH, backendProtocol);
+
+    ++g_stats.responses;
+    if (du->ids.cs) {
+      ++du->ids.cs->responses;
+    }
+
+    sendDoHUnitToTheMainThread(std::move(du), "cross-protocol response");
+  }
+
+  void handleXFRResponse(const struct timeval& now, TCPResponse&& response) override
+  {
+    return handleResponse(now, std::move(response));
+  }
+
+  void notifyIOError(IDState&& query, const struct timeval& now) override
+  {
+    if (!du) {
+      return;
+    }
+
+    if (du->rsock == -1) {
+      return;
+    }
+
+    du->ids = std::move(query);
+    du->status_code = 502;
+    sendDoHUnitToTheMainThread(std::move(du), "cross-protocol error response");
+  }
+
+private:
+  DOHUnitUniquePtr du;
+};
+
+class DoHCrossProtocolQuery : public CrossProtocolQuery
+{
+public:
+  DoHCrossProtocolQuery(DOHUnitUniquePtr&& du_): du(std::move(du_))
+  {
+    query = InternalQuery(std::move(du->query), std::move(du->ids));
+    /* we _could_ remove it from the query buffer and put in query's d_proxyProtocolPayload,
+       clearing query.d_proxyProtocolPayloadAdded and du->proxyProtocolPayloadSize.
+       Leave it for now because we know that the onky case where the payload has been
+       added is when we tried over UDP, got a TC=1 answer and retried over TCP/DoT,
+       and we know the TCP/DoT code can handle it. */
+    query.d_proxyProtocolPayloadAdded = du->proxyProtocolPayloadSize > 0;
+    downstream = du->downstream;
+    proxyProtocolPayloadSize = du->proxyProtocolPayloadSize;
+  }
+
+  void handleInternalError()
+  {
+    du->status_code = 502;
+    sendDoHUnitToTheMainThread(std::move(du), "DoH internal error");
+  }
+
+  std::shared_ptr<TCPQuerySender> getTCPQuerySender() override
+  {
+    auto sender = std::make_shared<DoHTCPCrossQuerySender>(std::move(du));
+    return sender;
+  }
+
+private:
+  DOHUnitUniquePtr du;
+};
+
+/*
+   We are not in the main DoH thread but in the DoH 'client' thread.
+*/
+static void processDOHQuery(DOHUnitUniquePtr&& du)
+{
+  uint16_t queryId = 0;
+  ComboAddress remote;
+  bool duRefCountIncremented = false;
+  try {
+    if (!du->req) {
+      // we got closed meanwhile. XXX small race condition here
+      // but we should be fine as long as we don't touch du->req
+      // outside of the main DoH thread
+      du->status_code = 500;
+      sendDoHUnitToTheMainThread(std::move(du), "DoH killed in flight");
+      return;
+    }
+    remote = du->ids.origRemote;
+    DOHServerConfig* dsc = du->dsc;
+    auto& holders = dsc->holders;
+    ClientState& cs = *dsc->cs;
+
+    if (du->query.size() < sizeof(dnsheader)) {
+      ++g_stats.nonCompliantQueries;
+      du->status_code = 400;
+      sendDoHUnitToTheMainThread(std::move(du), "DoH non-compliant query");
+      return;
+    }
+
+    ++cs.queries;
+    ++g_stats.queries;
+
+    /* we need an accurate ("real") value for the response and
+       to store into the IDS, but not for insertion into the
+       rings for example */
+    struct timespec queryRealTime;
+    gettime(&queryRealTime, true);
+
+    {
+      /* don't keep that pointer around, it will be invalidated if the buffer is ever resized */
+      struct dnsheader* dh = reinterpret_cast<struct dnsheader*>(du->query.data());
+
+      if (!checkQueryHeaders(dh)) {
+        du->status_code = 400;
+        sendDoHUnitToTheMainThread(std::move(du), "DoH invalid headers");
+        return;
+      }
+
+      if (dh->qdcount == 0) {
+        dh->rcode = RCode::NotImp;
+        dh->qr = true;
+        du->response = std::move(du->query);
+
+        sendDoHUnitToTheMainThread(std::move(du), "DoH empty query");
+        return;
+      }
+
+      queryId = ntohs(dh->id);
+    }
+
+    uint16_t qtype, qclass;
+    unsigned int qnameWireLength = 0;
+    DNSName qname(reinterpret_cast<const char*>(du->query.data()), du->query.size(), sizeof(dnsheader), false, &qtype, &qclass, &qnameWireLength);
+    DNSQuestion dq(&qname, qtype, qclass, &du->ids.origDest, &du->ids.origRemote, du->query, dnsdist::Protocol::DoH, &queryRealTime);
+    dq.ednsAdded = du->ids.ednsAdded;
+    /* store the raw pointer */
+    dq.du = du.get();
+    dq.sni = std::move(du->sni);
+
+    auto result = processQuery(dq, cs, holders, du->downstream);
+
+    if (result == ProcessQueryResult::Drop) {
+      du->status_code = 403;
+      sendDoHUnitToTheMainThread(std::move(du), "DoH dropped query");
+      return;
+    }
+
+    if (result == ProcessQueryResult::SendAnswer) {
+      if (du->response.empty()) {
+        du->response = std::move(du->query);
+      }
+      sendDoHUnitToTheMainThread(std::move(du), "DoH self-answered response");
+      return;
+    }
+
+    if (result != ProcessQueryResult::PassToBackend) {
+      du->status_code = 500;
+      sendDoHUnitToTheMainThread(std::move(du), "DoH no backend available");
+      return;
+    }
+
+    if (du->downstream == nullptr) {
+      du->status_code = 502;
+      sendDoHUnitToTheMainThread(std::move(du), "DoH no backend available");
+      return;
+    }
+
+    if (du->downstream->isTCPOnly()) {
+      std::string proxyProtocolPayload;
+      /* we need to do this _before_ creating the cross protocol query because
+         after that the buffer will have been moved */
+      if (du->downstream->useProxyProtocol) {
+        proxyProtocolPayload = getProxyProtocolPayload(dq);
+      }
+
+      du->ids.origID = htons(queryId);
+      du->ids.cs = &cs;
+      setIDStateFromDNSQuestion(du->ids, dq, std::move(qname));
+
+      du->tcp = true;
+      std::shared_ptr<DownstreamState>& downstream = du->downstream;
+
+      /* this moves du->ids, careful! */
+      auto cpq = std::make_unique<DoHCrossProtocolQuery>(std::move(du));
+      cpq->query.d_proxyProtocolPayload = std::move(proxyProtocolPayload);
+
+      if (downstream->passCrossProtocolQuery(std::move(cpq))) {
+        return;
+      }
+      else {
+        cpq->handleInternalError();
+        return;
+      }
+    }
+
+    ComboAddress dest = du->ids.origDest;
+    unsigned int idOffset = (du->downstream->idOffset++) % du->downstream->idStates.size();
+    IDState* ids = &du->downstream->idStates[idOffset];
+    ids->age = 0;
+    DOHUnit* oldDU = nullptr;
+    if (ids->isInUse()) {
+      /* that means that the state was in use, possibly with an allocated
+         DOHUnit that we will need to handle, but we can't touch it before
+         confirming that we now own this state */
+      oldDU = ids->du;
+    }
+
+    /* we atomically replace the value, we now own this state */
+    int64_t generation = ids->generation++;
+    if (!ids->markAsUsed(generation)) {
+      /* the state was not in use.
+         we reset 'oldDU' because it might have still been in use when we read it. */
+      oldDU = nullptr;
+      ++du->downstream->outstanding;
+    }
+    else {
+      ids->du = nullptr;
+      /* we are reusing a state, no change in outstanding but if there was an existing DOHUnit we need
+         to handle it because it's about to be overwritten. */
+      ++du->downstream->reuseds;
+      ++g_stats.downstreamTimeouts;
+      handleDOHTimeout(DOHUnitUniquePtr(oldDU, DOHUnit::release));
+    }
+
+    ids->origFD = 0;
+    /* increase the ref count since we are about to store the pointer */
+    du->get();
+    duRefCountIncremented = true;
+    /* store the raw pointer */
+    ids->du = du.get();
+
+    ids->cs = &cs;
+    ids->origID = htons(queryId);
+    setIDStateFromDNSQuestion(*ids, dq, std::move(qname));
+
+    dq.getHeader()->id = idOffset;
+
+    /* If we couldn't harvest the real dest addr, still
+       write down the listening addr since it will be useful
+       (especially if it's not an 'any' one).
+       We need to keep track of which one it is since we may
+       want to use the real but not the listening addr to reply.
+    */
+    if (dest.sin4.sin_family != 0) {
+      ids->origDest = dest;
+      ids->destHarvested = true;
+    }
+    else {
+      ids->origDest = cs.local;
+      ids->destHarvested = false;
+    }
+
+    bool failed = false;
+    if (du->downstream->useProxyProtocol) {
+      try {
+        size_t payloadSize = 0;
+        if (addProxyProtocol(dq, &payloadSize)) {
+          du->proxyProtocolPayloadSize = payloadSize;
+        }
+      }
+      catch (const std::exception& e) {
+        vinfolog("Adding proxy protocol payload to DoH query from %s failed: %s", ids->origDest.toStringWithPort(), e.what());
+        failed = true;
+      }
+    }
+
+    try {
+      if (!failed) {
+        int fd = pickBackendSocketForSending(du->downstream);
+        /* you can't touch du after this line, unless the call returned a non-negative value,
+           because it might already have been freed */
+        ssize_t ret = udpClientSendRequestToBackend(du->downstream, fd, du->query);
+
+        if (ret < 0) {
+          failed = true;
+        }
+      }
+
+      if (failed) {
+        /* we are about to handle the error, make sure that
+           this pointer is not accessed when the state is cleaned,
+           but first check that it still belongs to us */
+        if (ids->tryMarkUnused(generation)) {
+          ids->du = nullptr;
+          du->release();
+          duRefCountIncremented = false;
+          --du->downstream->outstanding;
+        }
+        ++du->downstream->sendErrors;
+        ++g_stats.downstreamSendErrors;
+        du->status_code = 502;
+        sendDoHUnitToTheMainThread(std::move(du), "DoH internal error");
+        return;
+      }
+    }
+    catch (const std::exception& e) {
+      if (duRefCountIncremented) {
+        du->release();
+      }
+      throw;
+    }
+
+    vinfolog("Got query for %s|%s from %s (https), relayed to %s", ids->qname.toString(), QType(ids->qtype).toString(), remote.toStringWithPort(), du->downstream->getName());
+  }
+  catch (const std::exception& e) {
+    vinfolog("Got an error in DOH question thread while parsing a query from %s, id %d: %s", remote.toStringWithPort(), queryId, e.what());
+    du->status_code = 500;
+    sendDoHUnitToTheMainThread(std::move(du), "DoH internal error");
+    return;
+  }
+
+  return;
+}
+
+/* called when a HTTP response is about to be sent, from the main DoH thread */
+static void on_response_ready_cb(struct st_h2o_filter_t *self, h2o_req_t *req, h2o_ostream_t **slot)
+{
+  if (req == nullptr) {
+    return;
+  }
+
+  DOHServerConfig* dsc = reinterpret_cast<DOHServerConfig*>(req->conn->ctx->storage.entries[0].data);
+
+  DOHFrontend::HTTPVersionStats* stats = nullptr;
+  if (req->version < 0x200) {
+    /* HTTP 1.x */
+    stats = &dsc->df->d_http1Stats;
+  }
+  else {
+    /* HTTP 2.0 */
+    stats = &dsc->df->d_http2Stats;
+  }
+
+  switch (req->res.status) {
+  case 200:
+    ++stats->d_nb200Responses;
+    break;
+  case 400:
+    ++stats->d_nb400Responses;
+    break;
+  case 403:
+    ++stats->d_nb403Responses;
+    break;
+  case 500:
+    ++stats->d_nb500Responses;
+    break;
+  case 502:
+    ++stats->d_nb502Responses;
+    break;
+  default:
+    ++stats->d_nbOtherResponses;
+    break;
+  }
+
+  h2o_setup_next_ostream(req, slot);
+}
+
+/* this is called by h2o when our request dies.
+   We use this to signal to the 'du' that this req is no longer alive */
+static void on_generator_dispose(void *_self)
+{
+  DOHUnit** du = reinterpret_cast<DOHUnit**>(_self);
+  if (*du) { // if 0, on_dnsdist cleaned up du already
+    (*du)->self = nullptr;
+    (*du)->req = nullptr;
+  }
+}
+
+/* This executes in the main DoH thread.
+   We allocate a DOHUnit and send it to dnsdistclient() function in the doh client thread
+   via a pipe */
+static void doh_dispatch_query(DOHServerConfig* dsc, h2o_handler_t* self, h2o_req_t* req, PacketBuffer&& query, const ComboAddress& local, const ComboAddress& remote, std::string&& path)
+{
+  try {
+    /* we only parse it there as a sanity check, we will parse it again later */
+    uint16_t qtype;
+    DNSName qname(reinterpret_cast<const char*>(query.data()), query.size(), sizeof(dnsheader), false, &qtype);
+
+    auto du = std::make_unique<DOHUnit>();
+    du->dsc = dsc;
+    du->req = req;
+    du->ids.origDest = local;
+    du->ids.origRemote = remote;
+    du->rsock = dsc->dohresponsepair[0];
+    du->query = std::move(query);
+    du->path = std::move(path);
+    /* we are doing quite some copies here, sorry about that,
+       but we can't keep accessing the req object once we are in a different thread
+       because the request might get killed by h2o at pretty much any time */
+    if (req->scheme != nullptr) {
+      du->scheme = std::string(req->scheme->name.base, req->scheme->name.len);
+    }
+    du->host = std::string(req->authority.base, req->authority.len);
+    du->query_at = req->query_at;
+    du->headers.reserve(req->headers.size);
+    for (size_t i = 0; i < req->headers.size; ++i) {
+      du->headers.emplace_back(std::string(req->headers.entries[i].name->base, req->headers.entries[i].name->len),
+                               std::string(req->headers.entries[i].value.base, req->headers.entries[i].value.len));
+    }
+
+#ifdef HAVE_H2O_SOCKET_GET_SSL_SERVER_NAME
+    h2o_socket_t* sock = req->conn->callbacks->get_socket(req->conn);
+    const char * sni = h2o_socket_get_ssl_server_name(sock);
+    if (sni != nullptr) {
+      du->sni = sni;
+    }
+#endif /* HAVE_H2O_SOCKET_GET_SSL_SERVER_NAME */
+
+    du->self = reinterpret_cast<DOHUnit**>(h2o_mem_alloc_shared(&req->pool, sizeof(*self), on_generator_dispose));
+    auto ptr = du.release();
+    *(ptr->self) = ptr;
+    try  {
+      static_assert(sizeof(ptr) <= PIPE_BUF, "Writes up to PIPE_BUF are guaranteed not to be interleaved and to either fully succeed or fail");
+      ssize_t sent = write(dsc->dohquerypair[0], &ptr, sizeof(ptr));
+      if (sent != sizeof(ptr)) {
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+          ++g_stats.dohQueryPipeFull;
+          vinfolog("Unable to pass a DoH query to the DoH worker thread because the pipe is full");
+        }
+        else {
+          vinfolog("Unable to pass a DoH query to the DoH worker thread because we couldn't write to the pipe: %s", stringerror());
+        }
+        ptr->release();
+        ptr = nullptr;
+        h2o_send_error_500(req, "Internal Server Error", "Internal Server Error", 0);
+      }
+    }
+    catch (...) {
+      if (ptr != nullptr) {
+        ptr->release();
+      }
+    }
+  }
+  catch(const std::exception& e) {
+    vinfolog("Had error parsing DoH DNS packet from %s: %s", remote.toStringWithPort(), e.what());
+    h2o_send_error_400(req, "Bad Request", "The DNS query could not be parsed", 0);
+  }
+}
+
+/* can only be called from the main DoH thread */
+static bool getHTTPHeaderValue(const h2o_req_t* req, const std::string& headerName, pdns_string_view& value)
+{
+  bool found = false;
+  /* early versions of boost::string_ref didn't have the ability to compare to string */
+  pdns_string_view headerNameView(headerName);
+
+  for (size_t i = 0; i < req->headers.size; ++i) {
+    if (pdns_string_view(req->headers.entries[i].name->base, req->headers.entries[i].name->len) == headerNameView) {
+      value = pdns_string_view(req->headers.entries[i].value.base, req->headers.entries[i].value.len);
+      /* don't stop there, we might have more than one header with the same name, and we want the last one */
+      found = true;
+    }
+  }
+
+  return found;
+}
+
+/* can only be called from the main DoH thread */
+static void processForwardedForHeader(const h2o_req_t* req, ComboAddress& remote)
+{
+  static const std::string headerName = "x-forwarded-for";
+  pdns_string_view value;
+
+  if (getHTTPHeaderValue(req, headerName, value)) {
+    try {
+      auto pos = value.rfind(',');
+      if (pos != pdns_string_view::npos) {
+        ++pos;
+        for (; pos < value.size() && value[pos] == ' '; ++pos)
+        {
+        }
+
+        if (pos < value.size()) {
+          value = value.substr(pos);
+        }
+      }
+      auto newRemote = ComboAddress(std::string(value));
+      remote = newRemote;
+    }
+    catch (const std::exception& e) {
+      vinfolog("Invalid X-Forwarded-For header ('%s') received from %s : %s", std::string(value), remote.toStringWithPort(), e.what());
+    }
+    catch (const PDNSException& e) {
+      vinfolog("Invalid X-Forwarded-For header ('%s') received from %s : %s", std::string(value), remote.toStringWithPort(), e.reason);
+    }
+  }
+}
+
+/*
+  A query has been parsed by h2o, this executes in the main DoH thread.
+  For GET, the base64url-encoded payload is in the 'dns' parameter, which might be the first parameter, or not.
+  For POST, the payload is the payload.
+ */
+static int doh_handler(h2o_handler_t *self, h2o_req_t *req)
+{
+  try {
+    if (!req->conn->ctx->storage.size) {
+      return 0; // although we might was well crash on this
+    }
+    h2o_socket_t* sock = req->conn->callbacks->get_socket(req->conn);
+    ComboAddress remote;
+    ComboAddress local;
+
+    if (h2o_socket_getpeername(sock, reinterpret_cast<struct sockaddr*>(&remote)) == 0) {
+      /* getpeername failed, likely because the connection has already been closed,
+         but anyway that means we can't get the remote address, which could allow an ACL bypass */
+      h2o_send_error_500(req, getReasonFromStatusCode(500).c_str(), "Internal Server Error - Unable to get remote address", 0);
+      return 0;
+    }
+
+    h2o_socket_getsockname(sock, reinterpret_cast<struct sockaddr*>(&local));
+    DOHServerConfig* dsc = reinterpret_cast<DOHServerConfig*>(req->conn->ctx->storage.entries[0].data);
+
+    if (dsc->df->d_trustForwardedForHeader) {
+      processForwardedForHeader(req, remote);
+    }
+
+    auto& holders = dsc->holders;
+    if (!holders.acl->match(remote)) {
+      ++g_stats.aclDrops;
+      vinfolog("Query from %s (DoH) dropped because of ACL", remote.toStringWithPort());
+      h2o_send_error_403(req, "Forbidden", "dns query not allowed because of ACL", 0);
+      return 0;
+    }
+
+    const int descriptor = h2o_socket_get_fd(sock);
+    if (descriptor != -1) {
+      auto& conn = t_conns.at(descriptor);
+      ++conn.d_nbQueries;
+      if (conn.d_nbQueries == 1) {
+        if (h2o_socket_get_ssl_session_reused(sock) == 0) {
+          ++dsc->cs->tlsNewSessions;
+        }
+        else {
+          ++dsc->cs->tlsResumptions;
+        }
+      }
+    }
+
+    if (auto tlsversion = h2o_socket_get_ssl_protocol_version(sock)) {
+      if(!strcmp(tlsversion, "TLSv1.0"))
+        ++dsc->cs->tls10queries;
+      else if(!strcmp(tlsversion, "TLSv1.1"))
+        ++dsc->cs->tls11queries;
+      else if(!strcmp(tlsversion, "TLSv1.2"))
+        ++dsc->cs->tls12queries;
+      else if(!strcmp(tlsversion, "TLSv1.3"))
+        ++dsc->cs->tls13queries;
+      else
+        ++dsc->cs->tlsUnknownqueries;
+    }
+
+    if (dsc->df->d_exactPathMatching) {
+      // would be nice to be able to use a pdns_string_view there, but we would need heterogeneous lookups
+      // (having string in the set and compare them to string_view, for example. Note that comparing
+      // two boost::string_view uses the pointer, not the content).
+      const std::string pathOnly(req->path_normalized.base, req->path_normalized.len);
+      if (dsc->paths.count(pathOnly) == 0) {
+        h2o_send_error_404(req, "Not Found", "there is no endpoint configured for this path", 0);
+        return 0;
+      }
+    }
+
+    // would be nice to be able to use a pdns_string_view there,
+    // but regex (called by matches() internally) requires a null-terminated string
+    string path(req->path.base, req->path.len);
+    /* the responses map can be updated at runtime, so we need to take a copy of
+       the shared pointer, increasing the reference counter */
+    auto responsesMap = dsc->df->d_responsesMap;
+    /* 1 byte for the root label, 2 type, 2 class, 4 TTL (fake), 2 record length, 2 option length, 2 option code, 2 family, 1 source, 1 scope, 16 max for a full v6 */
+    const size_t maxAdditionalSizeForEDNS = 35U;
+    if (responsesMap) {
+      for (const auto& entry : *responsesMap) {
+        if (entry->matches(path)) {
+          const auto& customHeaders = entry->getHeaders();
+          handleResponse(*dsc->df, req, entry->getStatusCode(), entry->getContent(), customHeaders ? *customHeaders : dsc->df->d_customResponseHeaders, std::string(), false);
+          return 0;
+        }
+      }
+    }
+
+    if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("POST"))) {
+      ++dsc->df->d_postqueries;
+      if(req->version >= 0x0200)
+        ++dsc->df->d_http2Stats.d_nbQueries;
+      else
+        ++dsc->df->d_http1Stats.d_nbQueries;
+
+      PacketBuffer query;
+      /* We reserve a few additional bytes to be able to add EDNS later */
+      query.reserve(req->entity.len + maxAdditionalSizeForEDNS);
+      query.resize(req->entity.len);
+      memcpy(query.data(), req->entity.base, req->entity.len);
+      doh_dispatch_query(dsc, self, req, std::move(query), local, remote, std::move(path));
+    }
+    else if(req->query_at != SIZE_MAX && (req->path.len - req->query_at > 5)) {
+      auto pos = path.find("?dns=");
+      if(pos == string::npos)
+        pos = path.find("&dns=");
+      if(pos != string::npos) {
+        // need to base64url decode this
+        string sdns(path.substr(pos+5));
+        boost::replace_all(sdns,"-", "+");
+        boost::replace_all(sdns,"_", "/");
+        // re-add padding that may have been missing
+        switch (sdns.size() % 4) {
+        case 2:
+          sdns.append(2, '=');
+          break;
+        case 3:
+          sdns.append(1, '=');
+          break;
+        }
+
+        PacketBuffer decoded;
+
+        /* rough estimate so we hopefully don't need a new allocation later */
+        /* We reserve at few additional bytes to be able to add EDNS later */
+        const size_t estimate = ((sdns.size() * 3) / 4);
+        decoded.reserve(estimate + maxAdditionalSizeForEDNS);
+        if(B64Decode(sdns, decoded) < 0) {
+          h2o_send_error_400(req, "Bad Request", "Unable to decode BASE64-URL", 0);
+          ++dsc->df->d_badrequests;
+          return 0;
+        }
+        else {
+          ++dsc->df->d_getqueries;
+          if(req->version >= 0x0200)
+            ++dsc->df->d_http2Stats.d_nbQueries;
+          else
+            ++dsc->df->d_http1Stats.d_nbQueries;
+
+          doh_dispatch_query(dsc, self, req, std::move(decoded), local, remote, std::move(path));
+        }
+      }
+      else
+      {
+        vinfolog("HTTP request without DNS parameter: %s", req->path.base);
+        h2o_send_error_400(req, "Bad Request", "Unable to find the DNS parameter", 0);
+        ++dsc->df->d_badrequests;
+        return 0;
+      }
+    }
+    else {
+      h2o_send_error_400(req, "Bad Request", "Unable to parse the request", 0);
+      ++dsc->df->d_badrequests;
+    }
+    return 0;
+  }
+  catch(const std::exception& e)
+  {
+    errlog("DOH Handler function failed with error %s", e.what());
+    return 0;
+  }
+}
+
+HTTPHeaderRule::HTTPHeaderRule(const std::string& header, const std::string& regex)
+  : d_header(toLower(header)), d_regex(regex), d_visual("http[" + header+ "] ~ " + regex)
+{
+}
+
+bool HTTPHeaderRule::matches(const DNSQuestion* dq) const
+{
+  if (!dq->du) {
+    return false;
+  }
+
+  for (const auto& header : dq->du->headers) {
+    if (header.first == d_header) {
+      return d_regex.match(header.second);
+    }
+  }
+  return false;
+}
+
+string HTTPHeaderRule::toString() const
+{
+  return d_visual;
+}
+
+HTTPPathRule::HTTPPathRule(const std::string& path)
+  :  d_path(path)
+{
+
+}
+
+bool HTTPPathRule::matches(const DNSQuestion* dq) const
+{
+  if (!dq->du) {
+    return false;
+  }
+
+  if (dq->du->query_at == SIZE_MAX) {
+    return dq->du->path == d_path;
+  }
+  else {
+    return d_path.compare(0, d_path.size(), dq->du->path, 0, dq->du->query_at) == 0;
+  }
+}
+
+string HTTPPathRule::toString() const
+{
+  return "url path == " + d_path;
+}
+
+HTTPPathRegexRule::HTTPPathRegexRule(const std::string& regex): d_regex(regex), d_visual("http path ~ " + regex)
+{
+}
+
+bool HTTPPathRegexRule::matches(const DNSQuestion* dq) const
+{
+  if (!dq->du) {
+    return false;
+  }
+
+  return d_regex.match(dq->du->getHTTPPath());
+}
+
+string HTTPPathRegexRule::toString() const
+{
+  return d_visual;
+}
+
+std::unordered_map<std::string, std::string> DOHUnit::getHTTPHeaders() const
+{
+  std::unordered_map<std::string, std::string> results;
+  results.reserve(headers.size());
+
+  for (const auto& header : headers) {
+    results.insert(header);
+  }
+
+  return results;
+}
+
+std::string DOHUnit::getHTTPPath() const
+{
+  if (query_at == SIZE_MAX) {
+    return path;
+  }
+  else {
+    return std::string(path, 0, query_at);
+  }
+}
+
+std::string DOHUnit::getHTTPHost() const
+{
+  return host;
+}
+
+std::string DOHUnit::getHTTPScheme() const
+{
+  return scheme;
+}
+
+std::string DOHUnit::getHTTPQueryString() const
+{
+  if (query_at == SIZE_MAX) {
+    return std::string();
+  }
+  else {
+    return path.substr(query_at);
+  }
+}
+
+void DOHUnit::setHTTPResponse(uint16_t statusCode, PacketBuffer&& body_, const std::string& contentType_)
+{
+  status_code = statusCode;
+  response = std::move(body_);
+  if (!response.empty() && statusCode >= 400) {
+    // we need to make sure it's null-terminated */
+    if (response.at(response.size() - 1) != 0) {
+      response.push_back(0);
+    }
+  }
+
+  contentType = contentType_;
+}
+
+/* query has been parsed by h2o, which called doh_handler() in the main DoH thread.
+   In order not to blockfor long, doh_handler() called doh_dispatch_query() which allocated
+   a DOHUnit object and passed it to us */
+static void dnsdistclient(int qsock)
+{
+  setThreadName("dnsdist/doh-cli");
+
+  for(;;) {
+    try {
+      DOHUnit* ptr = nullptr;
+      ssize_t got = read(qsock, &ptr, sizeof(ptr));
+      if (got < 0) {
+        warnlog("Error receiving internal DoH query: %s", strerror(errno));
+        continue;
+      }
+      else if (static_cast<size_t>(got) < sizeof(ptr)) {
+        continue;
+      }
+
+      DOHUnitUniquePtr du(ptr, DOHUnit::release);
+      /* we are not in the main DoH thread anymore, so there is a real risk of
+         a race condition where h2o kills the query while we are processing it,
+         so we can't touch the content of du->req until we are back into the
+         main DoH thread */
+      if (!du->req) {
+        // it got killed in flight already
+        du->self = nullptr;
+        continue;
+      }
+
+      // if there was no EDNS, we add it with a large buffer size
+      // so we can use UDP to talk to the backend.
+      auto dh = const_cast<struct dnsheader*>(reinterpret_cast<const struct dnsheader*>(du->query.data()));
+
+      if (!dh->arcount) {
+        if (generateOptRR(std::string(), du->query, 4096, 4096, 0, false)) {
+          dh = const_cast<struct dnsheader*>(reinterpret_cast<const struct dnsheader*>(du->query.data())); // may have reallocated
+          dh->arcount = htons(1);
+          du->ids.ednsAdded = true;
+        }
+      }
+      else {
+        // we leave existing EDNS in place
+      }
+
+      processDOHQuery(std::move(du));
+    }
+    catch (const std::exception& e) {
+      errlog("Error while processing query received over DoH: %s", e.what());
+    }
+    catch (...) {
+      errlog("Unspecified error while processing query received over DoH");
+    }
+  }
+}
+
+/* Called in the main DoH thread if h2o finds that dnsdist gave us an answer by writing into
+   the dohresponsepair[0] side of the pipe so from:
+   - handleDOHTimeout() when we did not get a response fast enough (called
+     either from the health check thread (active) or from the frontend ones (reused))
+   - dnsdistclient (error 500 because processDOHQuery() returned a negative value)
+   - processDOHQuery (self-answered queries)
+   */
+static void on_dnsdist(h2o_socket_t *listener, const char *err)
+{
+  /* we want to read as many responses from the pipe as possible before
+     giving up. Even if we are overloaded and fighting with the DoH connections
+     for the CPU, the first thing we need to do is to send responses to free slots
+     anyway, otherwise queries and responses are piling up in our pipes, consuming
+     memory and likely coming up too late after the client has gone away */
+  while (true) {
+    DOHUnit *ptr = nullptr;
+    DOHServerConfig* dsc = reinterpret_cast<DOHServerConfig*>(listener->data);
+    ssize_t got = read(dsc->dohresponsepair[1], &ptr, sizeof(ptr));
+
+    if (got < 0) {
+      if (errno != EWOULDBLOCK && errno != EAGAIN) {
+        errlog("Error reading a DOH internal response: %s", strerror(errno));
+      }
+      return;
+    }
+    else if (static_cast<size_t>(got) != sizeof(ptr)) {
+      errlog("Error reading a DoH internal response, got %d bytes instead of the expected %d", got, sizeof(ptr));
+      return;
+    }
+
+    DOHUnitUniquePtr du(ptr, DOHUnit::release);
+    if (!du->req) { // it got killed in flight
+      du->self = nullptr;
+      continue;
+    }
+
+    if (!du->tcp &&
+        du->truncated &&
+        du->query.size() > du->proxyProtocolPayloadSize &&
+        (du->query.size() - du->proxyProtocolPayloadSize) > sizeof(dnsheader)) {
+      /* restoring the original ID */
+      dnsheader* queryDH = reinterpret_cast<struct dnsheader*>(du->query.data() + du->proxyProtocolPayloadSize);
+      queryDH->id = du->ids.origID;
+
+      du->tcp = true;
+      du->truncated = false;
+      auto cpq = std::make_unique<DoHCrossProtocolQuery>(std::move(du));
+
+      if (g_tcpclientthreads && g_tcpclientthreads->passCrossProtocolQueryToThread(std::move(cpq))) {
+        continue;
+      }
+      else {
+        vinfolog("Unable to pass DoH query to a TCP worker thread after getting a TC response over UDP");
+        continue;
+      }
+    }
+
+    if (du->self) {
+      // we are back in the h2o main thread now, so we don't risk
+      // a race (h2o killing the query) when accessing du->req anymore
+      *du->self = nullptr; // so we don't clean up again in on_generator_dispose
+      du->self = nullptr;
+    }
+
+    handleResponse(*dsc->df, du->req, du->status_code, du->response, dsc->df->d_customResponseHeaders, du->contentType, true);
+  }
+}
+
+/* called when a TCP connection has been accepted, the TLS session has not been established */
+static void on_accept(h2o_socket_t *listener, const char *err)
+{
+  DOHServerConfig* dsc = reinterpret_cast<DOHServerConfig*>(listener->data);
+  h2o_socket_t *sock = nullptr;
+
+  if (err != nullptr) {
+    return;
+  }
+
+  if ((sock = h2o_evloop_socket_accept(listener)) == nullptr) {
+    return;
+  }
+
+  const int descriptor = h2o_socket_get_fd(sock);
+  if (descriptor == -1) {
+    h2o_socket_close(sock);
+    return;
+  }
+
+  auto concurrentConnections = ++dsc->cs->tcpCurrentConnections;
+  if (dsc->cs->d_tcpConcurrentConnectionsLimit > 0 && concurrentConnections > dsc->cs->d_tcpConcurrentConnectionsLimit) {
+    --dsc->cs->tcpCurrentConnections;
+    h2o_socket_close(sock);
+    return;
+  }
+
+  if (concurrentConnections > dsc->cs->tcpMaxConcurrentConnections.load()) {
+    dsc->cs->tcpMaxConcurrentConnections.store(concurrentConnections);
+  }
+
+  auto& conn = t_conns[descriptor];
+
+  gettimeofday(&conn.d_connectionStartTime, nullptr);
+  conn.d_nbQueries = 0;
+  conn.d_acceptCtx = std::atomic_load_explicit(&dsc->accept_ctx, std::memory_order_acquire);
+  conn.d_desc = descriptor;
+
+  sock->on_close.cb = on_socketclose;
+  sock->on_close.data = &conn;
+  sock->data = dsc;
+
+  ++dsc->df->d_httpconnects;
+
+  h2o_accept(conn.d_acceptCtx->get(), sock);
+}
+
+static int create_listener(const ComboAddress& addr, std::shared_ptr<DOHServerConfig>& dsc, int fd)
+{
+  auto sock = h2o_evloop_socket_create(dsc->h2o_ctx.loop, fd, H2O_SOCKET_FLAG_DONT_READ);
+  sock->data = dsc.get();
+  h2o_socket_read_start(sock, on_accept);
+
+  return 0;
+}
+
+static int ocsp_stapling_callback(SSL* ssl, void* arg)
+{
+  if (ssl == nullptr || arg == nullptr) {
+    return SSL_TLSEXT_ERR_NOACK;
+  }
+  const auto ocspMap = reinterpret_cast<std::map<int, std::string>*>(arg);
+  return libssl_ocsp_stapling_callback(ssl, *ocspMap);
+}
+
+static int ticket_key_callback(SSL *s, unsigned char keyName[TLS_TICKETS_KEY_NAME_SIZE], unsigned char *iv, EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc)
+{
+  DOHAcceptContext* ctx = reinterpret_cast<DOHAcceptContext*>(libssl_get_ticket_key_callback_data(s));
+  if (ctx == nullptr || !ctx->d_ticketKeys) {
+    return -1;
+  }
+
+  ctx->handleTicketsKeyRotation();
+
+  auto ret = libssl_ticket_key_callback(s, *ctx->d_ticketKeys, keyName, iv, ectx, hctx, enc);
+  if (enc == 0) {
+    if (ret == 0) {
+      ++ctx->d_cs->tlsUnknownTicketKey;
+    }
+    else if (ret == 2) {
+      ++ctx->d_cs->tlsInactiveTicketKey;
+    }
+  }
+
+  return ret;
+}
+
+static void setupTLSContext(DOHAcceptContext& acceptCtx,
+                            TLSConfig& tlsConfig,
+                            TLSErrorCounters& counters)
+{
+  if (tlsConfig.d_ciphers.empty()) {
+    tlsConfig.d_ciphers = DOH_DEFAULT_CIPHERS;
+  }
+
+  auto ctx = libssl_init_server_context(tlsConfig, acceptCtx.d_ocspResponses);
+
+  if (tlsConfig.d_enableTickets && tlsConfig.d_numberOfTicketsKeys > 0) {
+    acceptCtx.d_ticketKeys = std::make_unique<OpenSSLTLSTicketKeysRing>(tlsConfig.d_numberOfTicketsKeys);
+    SSL_CTX_set_tlsext_ticket_key_cb(ctx.get(), &ticket_key_callback);
+    libssl_set_ticket_key_callback_data(ctx.get(), &acceptCtx);
+  }
+
+  if (!acceptCtx.d_ocspResponses.empty()) {
+    SSL_CTX_set_tlsext_status_cb(ctx.get(), &ocsp_stapling_callback);
+    SSL_CTX_set_tlsext_status_arg(ctx.get(), &acceptCtx.d_ocspResponses);
+  }
+
+  libssl_set_error_counters_callback(ctx, &counters);
+
+  if (!tlsConfig.d_keyLogFile.empty()) {
+    acceptCtx.d_keyLogFile = libssl_set_key_log_file(ctx, tlsConfig.d_keyLogFile);
+  }
+
+  h2o_ssl_register_alpn_protocols(ctx.get(), h2o_http2_alpn_protocols);
+
+  acceptCtx.d_ticketsKeyRotationDelay = tlsConfig.d_ticketsKeyRotationDelay;
+  if (tlsConfig.d_ticketKeyFile.empty()) {
+    acceptCtx.handleTicketsKeyRotation();
+  }
+  else {
+    acceptCtx.loadTicketsKeys(tlsConfig.d_ticketKeyFile);
+  }
+
+  auto nativeCtx = acceptCtx.get();
+  nativeCtx->ssl_ctx = ctx.release();
+}
+
+static void setupAcceptContext(DOHAcceptContext& ctx, DOHServerConfig& dsc, bool setupTLS)
+{
+  auto nativeCtx = ctx.get();
+  nativeCtx->ctx = &dsc.h2o_ctx;
+  nativeCtx->hosts = dsc.h2o_config.hosts;
+  ctx.d_ticketsKeyRotationDelay = dsc.df->d_tlsConfig.d_ticketsKeyRotationDelay;
+
+  if (setupTLS && dsc.df->isHTTPS()) {
+    try {
+      setupTLSContext(ctx,
+                      dsc.df->d_tlsConfig,
+                      dsc.df->d_tlsCounters);
+    }
+    catch (const std::runtime_error& e) {
+      throw std::runtime_error("Error setting up TLS context for DoH listener on '" + dsc.df->d_local.toStringWithPort() + "': " + e.what());
+    }
+  }
+  ctx.d_cs = dsc.cs;
+}
+
+void DOHFrontend::rotateTicketsKey(time_t now)
+{
+  if (d_dsc && d_dsc->accept_ctx) {
+    d_dsc->accept_ctx->rotateTicketsKey(now);
+  }
+}
+
+void DOHFrontend::loadTicketsKeys(const std::string& keyFile)
+{
+  if (d_dsc && d_dsc->accept_ctx) {
+    d_dsc->accept_ctx->loadTicketsKeys(keyFile);
+  }
+}
+
+void DOHFrontend::handleTicketsKeyRotation()
+{
+  if (d_dsc && d_dsc->accept_ctx) {
+    d_dsc->accept_ctx->handleTicketsKeyRotation();
+  }
+}
+
+time_t DOHFrontend::getNextTicketsKeyRotation() const
+{
+  if (d_dsc && d_dsc->accept_ctx) {
+    return d_dsc->accept_ctx->getNextTicketsKeyRotation();
+  }
+  return 0;
+}
+
+size_t DOHFrontend::getTicketsKeysCount() const
+{
+  size_t res = 0;
+  if (d_dsc && d_dsc->accept_ctx) {
+    res = d_dsc->accept_ctx->getTicketsKeysCount();
+  }
+  return res;
+}
+
+void DOHFrontend::reloadCertificates()
+{
+  auto newAcceptContext = std::make_shared<DOHAcceptContext>();
+  setupAcceptContext(*newAcceptContext, *d_dsc, true);
+  std::atomic_store_explicit(&d_dsc->accept_ctx, newAcceptContext, std::memory_order_release);
+}
+
+void DOHFrontend::setup()
+{
+  registerOpenSSLUser();
+
+  d_dsc = std::make_shared<DOHServerConfig>(d_idleTimeout, d_internalPipeBufferSize);
+
+  if  (isHTTPS()) {
+    try {
+      setupTLSContext(*d_dsc->accept_ctx,
+                      d_tlsConfig,
+                      d_tlsCounters);
+    }
+    catch (const std::runtime_error& e) {
+      throw std::runtime_error("Error setting up TLS context for DoH listener on '" + d_local.toStringWithPort() + "': " + e.what());
+    }
+  }
+}
+
+static h2o_pathconf_t *register_handler(h2o_hostconf_t *hostconf, const char *path, int (*on_req)(h2o_handler_t *, h2o_req_t *))
+{
+  h2o_pathconf_t *pathconf = h2o_config_register_path(hostconf, path, 0);
+  if (pathconf == nullptr) {
+    return pathconf;
+  }
+  h2o_filter_t *filter = h2o_create_filter(pathconf, sizeof(*filter));
+  if (filter) {
+    filter->on_setup_ostream = on_response_ready_cb;
+  }
+
+  h2o_handler_t *handler = h2o_create_handler(pathconf, sizeof(*handler));
+  if (handler != nullptr) {
+    handler->on_req = on_req;
+  }
+
+  return pathconf;
+}
+
+// this is the entrypoint from dnsdist.cc
+void dohThread(ClientState* cs)
+{
+  try {
+    std::shared_ptr<DOHFrontend>& df = cs->dohFrontend;
+    auto& dsc = df->d_dsc;
+    dsc->cs = cs;
+    dsc->df = cs->dohFrontend;
+    dsc->h2o_config.server_name = h2o_iovec_init(df->d_serverTokens.c_str(), df->d_serverTokens.size());
+
+    std::thread dnsdistThread(dnsdistclient, dsc->dohquerypair[1]);
+    dnsdistThread.detach(); // gets us better error reporting
+
+    setThreadName("dnsdist/doh");
+    // I wonder if this registers an IP address.. I think it does
+    // this may mean we need to actually register a site "name" here and not the IP address
+    h2o_hostconf_t *hostconf = h2o_config_register_host(&dsc->h2o_config, h2o_iovec_init(df->d_local.toString().c_str(), df->d_local.toString().size()), 65535);
+
+    for(const auto& url : df->d_urls) {
+      register_handler(hostconf, url.c_str(), doh_handler);
+      dsc->paths.insert(url);
+    }
+
+    h2o_context_init(&dsc->h2o_ctx, h2o_evloop_create(), &dsc->h2o_config);
+
+    // in this complicated way we insert the DOHServerConfig pointer in there
+    h2o_vector_reserve(nullptr, &dsc->h2o_ctx.storage, 1);
+    dsc->h2o_ctx.storage.entries[0].data = dsc.get();
+    ++dsc->h2o_ctx.storage.size;
+
+    auto sock = h2o_evloop_socket_create(dsc->h2o_ctx.loop, dsc->dohresponsepair[1], H2O_SOCKET_FLAG_DONT_READ);
+    sock->data = dsc.get();
+
+    // this listens to responses from dnsdist to turn into http responses
+    h2o_socket_read_start(sock, on_dnsdist);
+
+    setupAcceptContext(*dsc->accept_ctx, *dsc, false);
+
+    if (create_listener(df->d_local, dsc, cs->tcpFD) != 0) {
+      throw std::runtime_error("DOH server failed to listen on " + df->d_local.toStringWithPort() + ": " + strerror(errno));
+    }
+
+    bool stop = false;
+    do {
+      int result = h2o_evloop_run(dsc->h2o_ctx.loop, INT32_MAX);
+      if (result == -1) {
+        if (errno != EINTR) {
+          errlog("Error in the DoH event loop: %s", strerror(errno));
+          stop = true;
+        }
+      }
+    }
+    while (stop == false);
+
+  }
+  catch (const std::exception& e) {
+    throw runtime_error("DOH thread failed to launch: " + std::string(e.what()));
+  }
+  catch (...) {
+    throw runtime_error("DOH thread failed to launch");
+  }
+}
+
+void handleUDPResponseForDoH(DOHUnitUniquePtr&& du, PacketBuffer&& udpResponse, IDState&& state)
+{
+  du->response = std::move(udpResponse);
+  du->ids = std::move(state);
+
+  const dnsheader* dh = reinterpret_cast<const struct dnsheader*>(du->response.data());
+  if (!dh->tc) {
+    thread_local LocalStateHolder<vector<DNSDistResponseRuleAction>> localRespRuleActions = g_respruleactions.getLocal();
+    DNSResponse dr = makeDNSResponseFromIDState(du->ids, du->response);
+    dnsheader cleartextDH;
+    memcpy(&cleartextDH, dr.getHeader(), sizeof(cleartextDH));
+
+    if (!processResponse(du->response, localRespRuleActions, dr, false, true)) {
+      return;
+    }
+
+    double udiff = du->ids.sentTime.udiff();
+    vinfolog("Got answer from %s, relayed to %s (https), took %f usec", du->downstream->remote.toStringWithPort(), du->ids.origRemote.toStringWithPort(), udiff);
+
+    handleResponseSent(du->ids, udiff, *dr.remote, du->downstream->remote, du->response.size(), cleartextDH, du->downstream->getProtocol());
+
+    ++g_stats.responses;
+    if (du->ids.cs) {
+      ++du->ids.cs->responses;
+    }
+  }
+  else {
+    du->truncated = true;
+  }
+
+  sendDoHUnitToTheMainThread(std::move(du), "DoH response");
+}
+
+#else /* HAVE_DNS_OVER_HTTPS */
+
+void handleDOHTimeout(DOHUnitUniquePtr&& oldDU)
+{
+}
+
+#endif /* HAVE_DNS_OVER_HTTPS */