path: root/src/output/dnssim/https2.c

/*
 * Copyright (c) 2020, CZ.NIC, z.s.p.o.
 * All rights reserved.
 *
 * This file is part of dnsjit.
 *
 * dnsjit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * dnsjit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with dnsjit.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include "output/dnssim.h"
#include "output/dnssim/internal.h"
#include "output/dnssim/ll.h"
#include "core/assert.h"
#include "lib/base64url.h"

#include <gnutls/gnutls.h>
#include <string.h>

#if GNUTLS_VERSION_NUMBER >= DNSSIM_MIN_GNUTLS_VERSION

#define OUTPUT_DNSSIM_MAKE_NV(NAME, VALUE, VALUELEN)                 \
    {                                                                \
        (uint8_t*)NAME, (uint8_t*)VALUE, sizeof(NAME) - 1, VALUELEN, \
            NGHTTP2_NV_FLAG_NONE                                     \
    }

#define OUTPUT_DNSSIM_MAKE_NV2(NAME, VALUE)                                   \
    {                                                                         \
        (uint8_t*)NAME, (uint8_t*)VALUE, sizeof(NAME) - 1, sizeof(VALUE) - 1, \
            NGHTTP2_NV_FLAG_NONE                                              \
    }

#define OUTPUT_DNSSIM_HTTP_GET_TEMPLATE "?dns="
#define OUTPUT_DNSSIM_HTTP_GET_TEMPLATE_LEN (sizeof(OUTPUT_DNSSIM_HTTP_GET_TEMPLATE) - 1)
#define OUTPUT_DNSSIM_HTTP2_INITIAL_MAX_CONCURRENT_STREAMS 100
#define OUTPUT_DNSSIM_HTTP2_DEFAULT_MAX_CONCURRENT_STREAMS 0xffffffffu

static core_log_t _log = LOG_T_INIT("output.dnssim");

static ssize_t _http2_send(nghttp2_session* session, const uint8_t* data, size_t length, int flags, void* user_data)
{
    _output_dnssim_connection_t* conn = (_output_dnssim_connection_t*)user_data;
    mlassert(conn, "conn can't be null");
    mlassert(conn->tls, "conn must have tls ctx");
    mlassert(conn->tls->session, "conn must have tls session");

    mldebug("http2 (%p): sending data, len=%ld", session, length);

    ssize_t len = 0;
    if ((len = gnutls_record_send(conn->tls->session, data, length)) < 0) {
        mlwarning("gnutls_record_send failed: %s", gnutls_strerror(len));
        len = NGHTTP2_ERR_CALLBACK_FAILURE;
    }

    return len;
}

static ssize_t _http2_on_data_provider_read(nghttp2_session* session, int32_t stream_id, uint8_t* buf, size_t length, uint32_t* data_flags, nghttp2_data_source* source, void* user_data)
{
    _output_dnssim_https2_data_provider_t* buffer = source->ptr;
    mlassert(buffer, "no data provider");
    mlassert(buffer->len <= MAX_DNSMSG_SIZE, "invalid dnsmsg size: %zu B", buffer->len);

    ssize_t sent = (length < buffer->len) ? length : buffer->len;
    mlassert(sent >= 0, "negative length of bytes to send");

    memcpy(buf, buffer->buf, sent);
    buffer->buf += sent;
    buffer->len -= sent;
    if (buffer->len == 0)
        *data_flags |= NGHTTP2_DATA_FLAG_EOF;

    return sent;
}

static _output_dnssim_query_tcp_t* _http2_get_stream_qry(_output_dnssim_connection_t* conn, int32_t stream_id)
{
    mlassert(conn, "conn is nil");
    mlassert(stream_id >= 0, "invalid stream_id");

    _output_dnssim_query_tcp_t* qry = (_output_dnssim_query_tcp_t*)conn->sent;
    while (qry != NULL && qry->stream_id != stream_id) {
        qry = (_output_dnssim_query_tcp_t*)qry->qry.next;
    }

    return qry;
}

static int _http2_on_header(nghttp2_session* session, const nghttp2_frame* frame, const uint8_t* name, size_t namelen, const uint8_t* value, size_t valuelen, uint8_t flags, void* user_data)
{
    if (frame->hd.type == NGHTTP2_HEADERS && frame->headers.cat == NGHTTP2_HCAT_RESPONSE) {
        if (namelen == 7 && strncmp((char*)name, ":status", 7) == 0) {
            if (valuelen != 3 || (value[0] != '1' && value[0] != '2')) {
                /* When reponse code isn't 1xx or 2xx, close the query.
                 * This will result in request timeout, which currently seems
                 * slightly better than mocking SERVFAIL for statistics. */
                _output_dnssim_connection_t* conn = (_output_dnssim_connection_t*)user_data;
                mlassert(conn, "conn is nil");
                _output_dnssim_query_tcp_t* qry = _http2_get_stream_qry(conn, frame->hd.stream_id);

                if (qry != NULL) {
                    _output_dnssim_close_query_https2(qry);
                    mlinfo("http response %s, closing query", value);
                }
            }
        }
    }
    return 0;
}

static int _http2_on_data_recv(nghttp2_session* session, uint8_t flags, int32_t stream_id, const uint8_t* data, size_t len, void* user_data)
{
    _output_dnssim_connection_t* conn = (_output_dnssim_connection_t*)user_data;
    mlassert(conn, "conn is nil");

    _output_dnssim_query_tcp_t* qry = _http2_get_stream_qry(conn, stream_id);

    mldebug("http2: data chunk recv, session=%p, len=%d", session, len);

    if (qry) {
        if (qry->recv_buf_len == 0) {
            if (len > MAX_DNSMSG_SIZE) {
                mlwarning("http response exceeded maximum size of dns message");
                return -1;
            }
            mlfatal_oom(qry->recv_buf = malloc(len));
            memcpy(qry->recv_buf, data, len);
            qry->recv_buf_len = len;
        } else {
            size_t total_len = qry->recv_buf_len + len;
            if (total_len > MAX_DNSMSG_SIZE) {
                mlwarning("http response exceeded maximum size of dns message");
                return -1;
            }
            mlfatal_oom(qry->recv_buf = realloc(qry->recv_buf, total_len));
            memcpy(qry->recv_buf + qry->recv_buf_len, data, len);
            qry->recv_buf_len = total_len;
        }
    } else {
        mldebug("no query associated with this stream id, ignoring");
    }

    return 0;
}

static void _http2_check_max_streams(_output_dnssim_connection_t* conn)
{
    mlassert(conn, "conn can't be null");
    mlassert(conn->http2, "conn must have http2 ctx");

    switch (conn->state) {
    case _OUTPUT_DNSSIM_CONN_ACTIVE:
        if (conn->http2->open_streams >= conn->http2->max_concurrent_streams) {
            mlinfo("http2 (%p): reached maximum number of concurrent streams (%ld)",
                conn->http2->session, conn->http2->max_concurrent_streams);
            conn->state = _OUTPUT_DNSSIM_CONN_CONGESTED;
        }
        break;
    case _OUTPUT_DNSSIM_CONN_CONGESTED:
        if (conn->http2->open_streams < conn->http2->max_concurrent_streams)
            conn->state = _OUTPUT_DNSSIM_CONN_ACTIVE;
        break;
    default:
        break;
    }
}

static int _http2_on_stream_close(nghttp2_session* session, int32_t stream_id, uint32_t error_code, void* user_data)
{
    _output_dnssim_connection_t* conn = (_output_dnssim_connection_t*)user_data;
    mlassert(conn, "conn can't be null");
    mlassert(conn->http2, "conn must have http2 ctx");
    mlassert(conn->http2->open_streams > 0, "conn has no open streams");

    conn->http2->open_streams--;
    _http2_check_max_streams(conn);
    return 0;
}

static int _http2_on_frame_recv(nghttp2_session* session, const nghttp2_frame* frame, void* user_data)
{
    _output_dnssim_connection_t* conn = (_output_dnssim_connection_t*)user_data;
    mlassert(conn, "conn can't be null");
    mlassert(conn->tls, "conn must have tls ctx");
    mlassert(conn->tls->session, "conn must have tls session");
    mlassert(conn->http2, "conn must have http2 ctx");

    switch (frame->hd.type) {
    case NGHTTP2_DATA:
        if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
            mldebug("http2 (%p): final DATA frame recv", session);
            _output_dnssim_query_tcp_t* qry = _http2_get_stream_qry(conn, frame->hd.stream_id);

            if (qry != NULL) {
                conn->http2->current_qry = qry;
                _output_dnssim_read_dnsmsg(conn, qry->recv_buf_len, (char*)qry->recv_buf);
            }
        }
        break;
    case NGHTTP2_SETTINGS:
        if (!conn->http2->remote_settings_received) {
            /* On the first SETTINGS frame, set concurrent streams to unlimited, same as nghttp2. */
            conn->http2->remote_settings_received = true;
            conn->http2->max_concurrent_streams   = OUTPUT_DNSSIM_HTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;
            _http2_check_max_streams(conn);
        }
        nghttp2_settings* settings = (nghttp2_settings*)frame;
        int               i;
        for (i = 0; i < settings->niv; i++) {
            switch (settings->iv[i].settings_id) {
            case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
                conn->http2->max_concurrent_streams = settings->iv[i].value;
                _http2_check_max_streams(conn);
                break;
            default:
                break;
            }
        }
        break;
    default:
        break;
    }
    return 0;
}

int _output_dnssim_https2_init(_output_dnssim_connection_t* conn)
{
    mlassert(conn, "conn is nil");
    mlassert(conn->tls == NULL, "conn already has tls context");
    mlassert(conn->http2 == NULL, "conn already has http2 context");
    mlassert(conn->client, "conn must be associated with a client");
    mlassert(conn->client->dnssim, "client must have dnssim");

    int                        ret = -1;
    nghttp2_session_callbacks* callbacks;
    nghttp2_option*            option;
    output_dnssim_t*           self = conn->client->dnssim;

    /* Initialize TLS session. */
    ret = _output_dnssim_tls_init(conn);
    if (ret < 0)
        return ret;

    /* Configure ALPN to negotiate HTTP/2. */
    const gnutls_datum_t protos[] = {
        { (unsigned char*)"h2", 2 }
    };
    ret = gnutls_alpn_set_protocols(conn->tls->session, protos, 1, 0);
    if (ret < 0) {
        lwarning("failed to set ALPN protocol: %s", gnutls_strerror(ret));
        return ret;
    }

    lfatal_oom(conn->http2 = calloc(1, sizeof(_output_dnssim_http2_ctx_t)));
    conn->http2->max_concurrent_streams = OUTPUT_DNSSIM_HTTP2_INITIAL_MAX_CONCURRENT_STREAMS;

    /* Set up HTTP/2 callbacks and client. */
    lassert(nghttp2_session_callbacks_new(&callbacks) == 0, "out of memory");
    nghttp2_session_callbacks_set_send_callback(callbacks, _http2_send);
    nghttp2_session_callbacks_set_on_header_callback(callbacks, _http2_on_header);
    nghttp2_session_callbacks_set_on_data_chunk_recv_callback(callbacks, _http2_on_data_recv);
    nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks, _http2_on_frame_recv);
    nghttp2_session_callbacks_set_on_stream_close_callback(callbacks, _http2_on_stream_close);

    lassert(nghttp2_option_new(&option) == 0, "out of memory");
    nghttp2_option_set_peer_max_concurrent_streams(option, conn->http2->max_concurrent_streams);

    ret = nghttp2_session_client_new2(&conn->http2->session, callbacks, conn, option);

    nghttp2_session_callbacks_del(callbacks);
    nghttp2_option_del(option);

    if (ret < 0) {
        free(conn->http2);
        conn->http2 = NULL;
    }

    return ret;
}

int _output_dnssim_https2_setup(_output_dnssim_connection_t* conn)
{
    mlassert(conn, "conn is nil");
    mlassert(conn->tls, "conn must have tls ctx");
    mlassert(conn->tls->session, "conn must have tls session");
    mlassert(conn->http2, "conn must have http2 ctx");
    mlassert(conn->http2->session, "conn must have http2 session");

    int ret = -1;

    /* Check "h2" protocol was negotiated with ALPN. */
    gnutls_datum_t proto;
    ret = gnutls_alpn_get_selected_protocol(conn->tls->session, &proto);
    if (ret < 0) {
        mlwarning("http2: failed to get negotiated protocol: %s", gnutls_strerror(ret));
        return ret;
    }
    if (proto.size != 2 || memcmp("h2", proto.data, 2) != 0) {
        mlwarning("http2: protocol is not negotiated");
        return ret;
    }

    /* Submit SETTIGNS frame. */
    static const nghttp2_settings_entry iv[] = {
        { NGHTTP2_SETTINGS_MAX_FRAME_SIZE, MAX_DNSMSG_SIZE },
        { NGHTTP2_SETTINGS_ENABLE_PUSH, 0 }, /* Only we can initiate streams. */
    };
    ret = nghttp2_submit_settings(conn->http2->session, NGHTTP2_FLAG_NONE, iv, sizeof(iv) / sizeof(*iv));
    if (ret < 0) {
        mlwarning("http2: failed to submit SETTINGS: %s", nghttp2_strerror(ret));
        return ret;
    }

    ret = 0;
    return ret;
}

void _output_dnssim_https2_process_input_data(_output_dnssim_connection_t* conn, size_t len, const char* data)
{
    mlassert(conn, "conn is nil");
    mlassert(conn->http2, "conn must have http2 ctx");
    mlassert(conn->http2->session, "conn must have http2 session");

    /* Process incoming frames. */
    ssize_t ret         = 0;
    conn->prevent_close = true;
    ret                 = nghttp2_session_mem_recv(conn->http2->session, (uint8_t*)data, len);
    conn->prevent_close = false;
    if (ret < 0) {
        mlwarning("failed nghttp2_session_mem_recv: %s", nghttp2_strerror(ret));
        _output_dnssim_conn_close(conn);
        return;
    } else if (conn->state == _OUTPUT_DNSSIM_CONN_CLOSE_REQUESTED) {
        _output_dnssim_conn_close(conn);
        return;
    }
    mlassert(ret == len, "nghttp2_session_mem_recv didn't process all data");

    /* Send any frames the read might have triggered. */
    ret = nghttp2_session_send(conn->http2->session);
    if (ret < 0) {
        mlwarning("failed nghttp2_session_send: %s", nghttp2_strerror(ret));
        _output_dnssim_conn_close(conn);
        return;
    }
}

int _output_dnssim_create_query_https2(output_dnssim_t* self, _output_dnssim_request_t* req)
{
    mlassert_self();
    lassert(req, "req is nil");
    lassert(req->client, "request must have a client associated with it");

    _output_dnssim_query_tcp_t* qry;

    lfatal_oom(qry = calloc(1, sizeof(_output_dnssim_query_tcp_t)));

    qry->qry.transport = OUTPUT_DNSSIM_TRANSPORT_HTTPS2;
    qry->qry.req       = req;
    qry->qry.state     = _OUTPUT_DNSSIM_QUERY_PENDING_WRITE;
    qry->stream_id     = -1;
    req->qry           = &qry->qry; // TODO change when adding support for multiple Qs for req
    _ll_append(req->client->pending, &qry->qry);

    return _output_dnssim_handle_pending_queries(req->client);
}

void _output_dnssim_close_query_https2(_output_dnssim_query_tcp_t* qry)
{
    mlassert(qry, "qry can't be null");
    mlassert(qry->qry.req, "query must be part of a request");
    _output_dnssim_request_t* req = qry->qry.req;
    mlassert(req->client, "request must belong to a client");

    _ll_try_remove(req->client->pending, &qry->qry);
    if (qry->conn) {
        _output_dnssim_connection_t* conn = qry->conn;
        _ll_try_remove(conn->sent, &qry->qry);
        qry->conn = NULL;
        _output_dnssim_conn_idle(conn);
    }

    if (qry->recv_buf != NULL)
        free(qry->recv_buf);

    _ll_remove(req->qry, &qry->qry);
    free(qry);
}

void _output_dnssim_https2_close(_output_dnssim_connection_t* conn)
{
    mlassert(conn, "conn can't be nil");
    mlassert(conn->http2, "conn must have http2 ctx");

    nghttp2_session_del(conn->http2->session);
    _output_dnssim_tls_close(conn);
}

static int _http2_send_query_get(_output_dnssim_connection_t* conn, _output_dnssim_query_tcp_t* qry)
{
    mlassert(conn, "conn can't be null");
    mlassert(qry, "qry can't be null");
    mlassert(qry->qry.req, "req can't be null");
    mlassert(qry->qry.req->payload, "payload can't be null");
    mlassert(qry->qry.req->payload->len <= MAX_DNSMSG_SIZE, "payload too big");
    mlassert(conn->client, "conn must be associated with client");
    mlassert(conn->client->dnssim, "client must have dnssim");

    output_dnssim_t*       self    = conn->client->dnssim;
    core_object_payload_t* content = qry->qry.req->payload;

    const size_t uri_path_len = strlen(_self->h2_uri_path);
    const size_t path_len     = uri_path_len
                            + OUTPUT_DNSSIM_HTTP_GET_TEMPLATE_LEN
                            + (content->len * 4) / 3 + 3  /* upper limit of base64 encoding */
                            + 1;  /* terminating null byte */
    if (path_len >= _MAX_URI_LEN) {
        self->discarded++;
        linfo("http2: uri path with query too long, query discarded");
        return 0;
    }
    char path[path_len];
    memcpy(path, _self->h2_uri_path, uri_path_len);
    memcpy(&path[uri_path_len], OUTPUT_DNSSIM_HTTP_GET_TEMPLATE, OUTPUT_DNSSIM_HTTP_GET_TEMPLATE_LEN);

    int32_t ret = base64url_encode(content->payload, content->len,
        (uint8_t*)&path[uri_path_len + OUTPUT_DNSSIM_HTTP_GET_TEMPLATE_LEN],
        sizeof(path) - uri_path_len - OUTPUT_DNSSIM_HTTP_GET_TEMPLATE_LEN - 1);
    if (ret < 0) {
        self->discarded++;
        linfo("http2: base64url encode of query failed, query discarded");
        return 0;
    }

    nghttp2_nv hdrs[] = {
        OUTPUT_DNSSIM_MAKE_NV2(":method", "GET"),
        OUTPUT_DNSSIM_MAKE_NV2(":scheme", "https"),
        OUTPUT_DNSSIM_MAKE_NV(":authority", _self->h2_uri_authority, strlen(_self->h2_uri_authority)),
        OUTPUT_DNSSIM_MAKE_NV(":path", path, uri_path_len + sizeof(OUTPUT_DNSSIM_HTTP_GET_TEMPLATE) - 1 + ret),
        OUTPUT_DNSSIM_MAKE_NV2("accept", "application/dns-message"),
    };

    qry->stream_id = nghttp2_submit_request(conn->http2->session, NULL, hdrs, sizeof(hdrs) / sizeof(nghttp2_nv), NULL, NULL);

    if (qry->stream_id < 0) {
        mldebug("http2 (%p): failed to submit request: %s", conn->http2->session, nghttp2_strerror(qry->stream_id));
        return -1;
    }
    mldebug("http2 (%p): GET %s", conn->http2->session, path);
    conn->http2->open_streams++;
    _http2_check_max_streams(conn);

    ret = nghttp2_session_send(conn->http2->session);
    if (ret < 0) {
        mldebug("http2 (%p): failed session send: %s", conn->http2->session, nghttp2_strerror(ret));
        return -1;
    }

    return 0;
}

static int _http2_send_query_post(_output_dnssim_connection_t* conn, _output_dnssim_query_tcp_t* qry)
{
    mlassert(conn, "conn can't be null");
    mlassert(qry, "qry can't be null");
    mlassert(qry->qry.req, "req can't be null");
    mlassert(qry->qry.req->payload, "payload can't be null");
    mlassert(qry->qry.req->payload->len <= MAX_DNSMSG_SIZE, "payload too big");
    mlassert(conn->client, "conn must be associated with client");
    mlassert(conn->client->dnssim, "client must have dnssim");

    output_dnssim_t* self = conn->client->dnssim;

    core_object_payload_t* content = qry->qry.req->payload;

    int window_size = nghttp2_session_get_remote_window_size(conn->http2->session);
    if (content->len > window_size) {
        mldebug("http2 (%p): insufficient remote window size, deferring", conn->http2->session);
        return 0;
    }

    char content_length[6]; /* max dnslen "65535" */
    int  content_length_len = snprintf(content_length, 6, "%zd", content->len);

    nghttp2_nv hdrs[] = {
        OUTPUT_DNSSIM_MAKE_NV2(":method", "POST"),
        OUTPUT_DNSSIM_MAKE_NV2(":scheme", "https"),
        OUTPUT_DNSSIM_MAKE_NV(":authority", _self->h2_uri_authority, strlen(_self->h2_uri_authority)),
        OUTPUT_DNSSIM_MAKE_NV(":path", _self->h2_uri_path, strlen(_self->h2_uri_path)),
        OUTPUT_DNSSIM_MAKE_NV2("accept", "application/dns-message"),
        OUTPUT_DNSSIM_MAKE_NV2("content-type", "application/dns-message"),
        OUTPUT_DNSSIM_MAKE_NV("content-length", content_length, content_length_len)
    };

    _output_dnssim_https2_data_provider_t data = {
        .buf = content->payload,
        .len = content->len
    };

    nghttp2_data_provider data_provider = {
        .source.ptr    = &data,
        .read_callback = _http2_on_data_provider_read
    };

    qry->stream_id = nghttp2_submit_request(conn->http2->session, NULL, hdrs, sizeof(hdrs) / sizeof(nghttp2_nv), &data_provider, NULL);

    if (qry->stream_id < 0) {
        mldebug("http2 (%p): failed to submit request: %s", conn->http2->session, nghttp2_strerror(qry->stream_id));
        return -1;
    }
    mldebug("http2 (%p): POST payload len=%ld", conn->http2->session, content->len);
    conn->http2->open_streams++;
    _http2_check_max_streams(conn);

    window_size = nghttp2_session_get_stream_remote_window_size(conn->http2->session, qry->stream_id);
    mlassert(content->len <= window_size,
        "unsupported: http2 stream window size (%ld B) is smaller than dns payload (%ld B)",
        window_size, content->len);

    int ret = nghttp2_session_send(conn->http2->session);
    if (ret < 0) {
        mldebug("http2 (%p): failed session send: %s", conn->http2->session, nghttp2_strerror(ret));
        return -1;
    }

    return 0;
}

void _output_dnssim_https2_write_query(_output_dnssim_connection_t* conn, _output_dnssim_query_tcp_t* qry)
{
    mlassert(qry, "qry can't be null");
    mlassert(qry->qry.state == _OUTPUT_DNSSIM_QUERY_PENDING_WRITE, "qry must be pending write");
    mlassert(conn, "conn can't be null");
    mlassert(conn->state == _OUTPUT_DNSSIM_CONN_ACTIVE, "connection state != ACTIVE");
    mlassert(conn->http2, "conn must have http2 ctx");
    mlassert(conn->http2->session, "conn must have http2 session");
    mlassert(conn->client, "conn must be associated with client");
    mlassert(conn->client->pending, "conn has no pending queries");
    mlassert(conn->client->dnssim, "client must have dnssim");

    int              ret  = 0;
    output_dnssim_t* self = conn->client->dnssim;

    if (!nghttp2_session_check_request_allowed(conn->http2->session)) {
        mldebug("http2 (%p): request not allowed", conn->http2->session);
        _output_dnssim_conn_close(conn);
        return;
    }

    switch (_self->h2_method) {
    case OUTPUT_DNSSIM_H2_POST:
        ret = _http2_send_query_post(conn, qry);
        break;
    case OUTPUT_DNSSIM_H2_GET:
        ret = _http2_send_query_get(conn, qry);
        break;
    default:
        lfatal("http2: unsupported method");
    }

    if (ret < 0) {
        _output_dnssim_conn_close(conn);
        return;
    }

    qry->conn = conn;
    _ll_remove(conn->client->pending, &qry->qry);
    _ll_append(conn->sent, &qry->qry);

    /* Stop idle timer, since there are queries to answer now. */
    if (conn->idle_timer != NULL) {
        conn->is_idle = false;
        uv_timer_stop(conn->idle_timer);
    }

    qry->qry.state = _OUTPUT_DNSSIM_QUERY_SENT;
}

#endif