qdnslookup.cpp

Go to the documentation of this file.

// Copyright (C) 2012 Jeremy Lainé <jeremy.laine@m4x.org>
// Copyright (C) 2023 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdnslookup.h"
#include "qdnslookup_p.h"
 
#include <qapplicationstatic.h>
#include <qcoreapplication.h>
#include <qdatetime.h>
#include <qendian.h>
#include <qloggingcategory.h>
#include <qrandom.h>
#include <qspan.h>
#include <qurl.h>
 
#if QT_CONFIG(ssl)
#  include <qsslsocket.h>
#endif
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static Q_LOGGING_CATEGORY(lcDnsLookup, "qt.network.dnslookup", QtCriticalMsg)
 
namespace {
struct QDnsLookupThreadPool : QThreadPool
{
    QDnsLookupThreadPool()
    {
        // Run up to 5 lookups in parallel.
        setMaxThreadCount(5);
    }
};
}
 
Q_APPLICATION_STATIC(QDnsLookupThreadPool, theDnsLookupThreadPool);
 
static bool qt_qdnsmailexchangerecord_less_than(const QDnsMailExchangeRecord &r1, const QDnsMailExchangeRecord &r2)
{
    // Lower numbers are more preferred than higher ones.
    return r1.preference() < r2.preference();
}
 
/*
    Sorts a list of QDnsMailExchangeRecord objects according to RFC 5321.
*/
 
static void qt_qdnsmailexchangerecord_sort(QList<QDnsMailExchangeRecord> &records)
{
    // If we have no more than one result, we are done.
    if (records.size() <= 1)
        return;
 
    // Order the records by preference.
    std::sort(records.begin(), records.end(), qt_qdnsmailexchangerecord_less_than);
 
    int i = 0;
    while (i < records.size()) {
 
        // Determine the slice of records with the current preference.
        QList<QDnsMailExchangeRecord> slice;
        const quint16 slicePreference = records.at(i).preference();
        for (int j = i; j < records.size(); ++j) {
            if (records.at(j).preference() != slicePreference)
                break;
            slice << records.at(j);
        }
 
        // Randomize the slice of records.
        while (!slice.isEmpty()) {
            const unsigned int pos = QRandomGenerator::global()->bounded(slice.size());
            records[i++] = slice.takeAt(pos);
        }
    }
}
 
static bool qt_qdnsservicerecord_less_than(const QDnsServiceRecord &r1, const QDnsServiceRecord &r2)
{
    // Order by priority, or if the priorities are equal,
    // put zero weight records first.
    return r1.priority() < r2.priority()
       || (r1.priority() == r2.priority()
        && r1.weight() == 0 && r2.weight() > 0);
}
 
/*
    Sorts a list of QDnsServiceRecord objects according to RFC 2782.
*/
 
static void qt_qdnsservicerecord_sort(QList<QDnsServiceRecord> &records)
{
    // If we have no more than one result, we are done.
    if (records.size() <= 1)
        return;
 
    // Order the records by priority, and for records with an equal
    // priority, put records with a zero weight first.
    std::sort(records.begin(), records.end(), qt_qdnsservicerecord_less_than);
 
    int i = 0;
    while (i < records.size()) {
 
        // Determine the slice of records with the current priority.
        QList<QDnsServiceRecord> slice;
        const quint16 slicePriority = records.at(i).priority();
        unsigned int sliceWeight = 0;
        for (int j = i; j < records.size(); ++j) {
            if (records.at(j).priority() != slicePriority)
                break;
            sliceWeight += records.at(j).weight();
            slice << records.at(j);
        }
#ifdef QDNSLOOKUP_DEBUG
        qDebug("qt_qdnsservicerecord_sort() : priority %i (size: %i, total weight: %i)",
               slicePriority, slice.size(), sliceWeight);
#endif
 
        // Order the slice of records.
        while (!slice.isEmpty()) {
            const unsigned int weightThreshold = QRandomGenerator::global()->bounded(sliceWeight + 1);
            unsigned int summedWeight = 0;
            for (int j = 0; j < slice.size(); ++j) {
                summedWeight += slice.at(j).weight();
                if (summedWeight >= weightThreshold) {
#ifdef QDNSLOOKUP_DEBUG
                    qDebug("qt_qdnsservicerecord_sort() : adding %s %i (weight: %i)",
                           qPrintable(slice.at(j).target()), slice.at(j).port(),
                           slice.at(j).weight());
#endif
                    // Adjust the slice weight and take the current record.
                    sliceWeight -= slice.at(j).weight();
                    records[i++] = slice.takeAt(j);
                    break;
                }
            }
        }
    }
}
 
bool QDnsLookup::isProtocolSupported(Protocol protocol)
{
#if QT_CONFIG(libresolv) || defined(Q_OS_WIN)
    switch (protocol) {
    case QDnsLookup::Standard:
        return true;
    case QDnsLookup::DnsOverTls:
#  if QT_CONFIG(ssl)
        if (QSslSocket::supportsSsl())
            return true;
#  endif
        return false;
    }
#else
    Q_UNUSED(protocol)
#endif
    return false;
}
 
quint16 QDnsLookup::defaultPortForProtocol(Protocol protocol) noexcept
{
    switch (protocol) {
    case QDnsLookup::Standard:
        return DnsPort;
    case QDnsLookup::DnsOverTls:
        return DnsOverTlsPort;
    }
    return 0;       // will probably fail somewhere
}
 
QDnsLookup::QDnsLookup(QObject *parent)
    : QObject(*new QDnsLookupPrivate, parent)
{
}
 
QDnsLookup::QDnsLookup(Type type, const QString &name, QObject *parent)
    : QObject(*new QDnsLookupPrivate, parent)
{
    Q_D(QDnsLookup);
    d->name = name;
    d->type = type;
}
 
QDnsLookup::QDnsLookup(Type type, const QString &name, const QHostAddress &nameserver, QObject *parent)
    : QDnsLookup(type, name, nameserver, 0, parent)
{
}
 
 
 
QDnsLookup::QDnsLookup(Type type, const QString &name, const QHostAddress &nameserver, quint16 port, QObject *parent)
    : QObject(*new QDnsLookupPrivate, parent)
{
    Q_D(QDnsLookup);
    d->name = name;
    d->type = type;
    d->port = port;
    d->nameserver = nameserver;
}
 
QDnsLookup::QDnsLookup(Type type, const QString &name, Protocol protocol,
                       const QHostAddress &nameserver, quint16 port, QObject *parent)
    : QObject(*new QDnsLookupPrivate, parent)
{
    Q_D(QDnsLookup);
    d->name = name;
    d->type = type;
    d->nameserver = nameserver;
    d->port = port;
    d->protocol = protocol;
}
 
QDnsLookup::~QDnsLookup()
{
}
 
bool QDnsLookup::isAuthenticData() const
{
    return d_func()->reply.authenticData;
}
 
QDnsLookup::Error QDnsLookup::error() const
{
    return d_func()->reply.error;
}
 
QString QDnsLookup::errorString() const
{
    return d_func()->reply.errorString;
}
 
bool QDnsLookup::isFinished() const
{
    return d_func()->isFinished;
}
 
QString QDnsLookup::name() const
{
    return d_func()->name;
}
 
void QDnsLookup::setName(const QString &name)
{
    Q_D(QDnsLookup);
    d->name = name;
}
 
QBindable<QString> QDnsLookup::bindableName()
{
    Q_D(QDnsLookup);
    return &d->name;
}
 
QDnsLookup::Type QDnsLookup::type() const
{
    return d_func()->type;
}
 
void QDnsLookup::setType(Type type)
{
    Q_D(QDnsLookup);
    d->type = type;
}
 
QBindable<QDnsLookup::Type> QDnsLookup::bindableType()
{
    Q_D(QDnsLookup);
    return &d->type;
}
 
QHostAddress QDnsLookup::nameserver() const
{
    return d_func()->nameserver;
}
 
void QDnsLookup::setNameserver(const QHostAddress &nameserver)
{
    Q_D(QDnsLookup);
    d->nameserver = nameserver;
}
 
QBindable<QHostAddress> QDnsLookup::bindableNameserver()
{
    Q_D(QDnsLookup);
    return &d->nameserver;
}
 
quint16 QDnsLookup::nameserverPort() const
{
    return d_func()->port;
}
 
void QDnsLookup::setNameserverPort(quint16 nameserverPort)
{
    Q_D(QDnsLookup);
    d->port = nameserverPort;
}
 
QBindable<quint16> QDnsLookup::bindableNameserverPort()
{
    Q_D(QDnsLookup);
    return &d->port;
}
 
QDnsLookup::Protocol QDnsLookup::nameserverProtocol() const
{
    return d_func()->protocol;
}
 
void QDnsLookup::setNameserverProtocol(Protocol protocol)
{
    d_func()->protocol = protocol;
}
 
QBindable<QDnsLookup::Protocol> QDnsLookup::bindableNameserverProtocol()
{
    return &d_func()->protocol;
}
 
void QDnsLookup::setNameserver(Protocol protocol, const QHostAddress &nameserver, quint16 port)
{
    Qt::beginPropertyUpdateGroup();
    setNameserver(nameserver);
    setNameserverPort(port);
    setNameserverProtocol(protocol);
    Qt::endPropertyUpdateGroup();
}
 
QList<QDnsDomainNameRecord> QDnsLookup::canonicalNameRecords() const
{
    return d_func()->reply.canonicalNameRecords;
}
 
QList<QDnsHostAddressRecord> QDnsLookup::hostAddressRecords() const
{
    return d_func()->reply.hostAddressRecords;
}
 
QList<QDnsMailExchangeRecord> QDnsLookup::mailExchangeRecords() const
{
    return d_func()->reply.mailExchangeRecords;
}
 
QList<QDnsDomainNameRecord> QDnsLookup::nameServerRecords() const
{
    return d_func()->reply.nameServerRecords;
}
 
QList<QDnsDomainNameRecord> QDnsLookup::pointerRecords() const
{
    return d_func()->reply.pointerRecords;
}
 
QList<QDnsServiceRecord> QDnsLookup::serviceRecords() const
{
    return d_func()->reply.serviceRecords;
}
 
QList<QDnsTextRecord> QDnsLookup::textRecords() const
{
    return d_func()->reply.textRecords;
}
 
QList<QDnsTlsAssociationRecord> QDnsLookup::tlsAssociationRecords() const
{
    return d_func()->reply.tlsAssociationRecords;
}
 
#if QT_CONFIG(ssl)
void QDnsLookup::setSslConfiguration(const QSslConfiguration &sslConfiguration)
{
    Q_D(QDnsLookup);
    d->sslConfiguration.emplace(sslConfiguration);
}
 
QSslConfiguration QDnsLookup::sslConfiguration() const
{
    const Q_D(QDnsLookup);
    return d->sslConfiguration.value_or(QSslConfiguration::defaultConfiguration());
}
#endif
 
void QDnsLookup::abort()
{
    Q_D(QDnsLookup);
    if (d->runnable) {
        d->runnable = nullptr;
        d->reply = QDnsLookupReply();
        d->reply.error = QDnsLookup::OperationCancelledError;
        d->reply.errorString = tr("Operation cancelled");
        d->isFinished = true;
        emit finished();
    }
}
 
void QDnsLookup::lookup()
{
    Q_D(QDnsLookup);
    d->isFinished = false;
    d->reply = QDnsLookupReply();
    if (!QCoreApplication::instance()) {
        // NOT qCWarning because this isn't a result of the lookup
        qWarning("QDnsLookup requires a QCoreApplication");
        return;
    }
 
    auto l = [this](const QDnsLookupReply &reply) {
        Q_D(QDnsLookup);
        if (d->runnable == sender()) {
#ifdef QDNSLOOKUP_DEBUG
            qDebug("DNS reply for %s: %i (%s)", qPrintable(d->name), reply.error, qPrintable(reply.errorString));
#endif
#if QT_CONFIG(ssl)
            d->sslConfiguration = std::move(reply.sslConfiguration);
#endif
            d->reply = reply;
            d->runnable = nullptr;
            d->isFinished = true;
            emit finished();
        }
    };
 
    d->runnable = new QDnsLookupRunnable(d);
    connect(d->runnable, &QDnsLookupRunnable::finished, this, l,
            Qt::BlockingQueuedConnection);
    theDnsLookupThreadPool->start(d->runnable);
}
 
QDnsDomainNameRecord::QDnsDomainNameRecord()
    : d(new QDnsDomainNameRecordPrivate)
{
}
 
QDnsDomainNameRecord::QDnsDomainNameRecord(const QDnsDomainNameRecord &other)
    : d(other.d)
{
}
 
QDnsDomainNameRecord::~QDnsDomainNameRecord()
{
}
 
QString QDnsDomainNameRecord::name() const
{
    return d->name;
}
 
quint32 QDnsDomainNameRecord::timeToLive() const
{
    return d->timeToLive;
}
 
QString QDnsDomainNameRecord::value() const
{
    return d->value;
}
 
QDnsDomainNameRecord &QDnsDomainNameRecord::operator=(const QDnsDomainNameRecord &other)
{
    d = other.d;
    return *this;
}
QDnsHostAddressRecord::QDnsHostAddressRecord()
    : d(new QDnsHostAddressRecordPrivate)
{
}
 
QDnsHostAddressRecord::QDnsHostAddressRecord(const QDnsHostAddressRecord &other)
    : d(other.d)
{
}
 
QDnsHostAddressRecord::~QDnsHostAddressRecord()
{
}
 
QString QDnsHostAddressRecord::name() const
{
    return d->name;
}
 
quint32 QDnsHostAddressRecord::timeToLive() const
{
    return d->timeToLive;
}
 
QHostAddress QDnsHostAddressRecord::value() const
{
    return d->value;
}
 
QDnsHostAddressRecord &QDnsHostAddressRecord::operator=(const QDnsHostAddressRecord &other)
{
    d = other.d;
    return *this;
}
QDnsMailExchangeRecord::QDnsMailExchangeRecord()
    : d(new QDnsMailExchangeRecordPrivate)
{
}
 
QDnsMailExchangeRecord::QDnsMailExchangeRecord(const QDnsMailExchangeRecord &other)
    : d(other.d)
{
}
 
QDnsMailExchangeRecord::~QDnsMailExchangeRecord()
{
}
 
QString QDnsMailExchangeRecord::exchange() const
{
    return d->exchange;
}
 
QString QDnsMailExchangeRecord::name() const
{
    return d->name;
}
 
quint16 QDnsMailExchangeRecord::preference() const
{
    return d->preference;
}
 
quint32 QDnsMailExchangeRecord::timeToLive() const
{
    return d->timeToLive;
}
 
QDnsMailExchangeRecord &QDnsMailExchangeRecord::operator=(const QDnsMailExchangeRecord &other)
{
    d = other.d;
    return *this;
}
QDnsServiceRecord::QDnsServiceRecord()
    : d(new QDnsServiceRecordPrivate)
{
}
 
QDnsServiceRecord::QDnsServiceRecord(const QDnsServiceRecord &other)
    : d(other.d)
{
}
 
QDnsServiceRecord::~QDnsServiceRecord()
{
}
 
QString QDnsServiceRecord::name() const
{
    return d->name;
}
 
quint16 QDnsServiceRecord::port() const
{
    return d->port;
}
 
quint16 QDnsServiceRecord::priority() const
{
    return d->priority;
}
 
QString QDnsServiceRecord::target() const
{
    return d->target;
}
 
quint32 QDnsServiceRecord::timeToLive() const
{
    return d->timeToLive;
}
 
quint16 QDnsServiceRecord::weight() const
{
    return d->weight;
}
 
QDnsServiceRecord &QDnsServiceRecord::operator=(const QDnsServiceRecord &other)
{
    d = other.d;
    return *this;
}
QDnsTextRecord::QDnsTextRecord()
    : d(new QDnsTextRecordPrivate)
{
}
 
QDnsTextRecord::QDnsTextRecord(const QDnsTextRecord &other)
    : d(other.d)
{
}
 
QDnsTextRecord::~QDnsTextRecord()
{
}
 
QString QDnsTextRecord::name() const
{
    return d->name;
}
 
quint32 QDnsTextRecord::timeToLive() const
{
    return d->timeToLive;
}
 
QList<QByteArray> QDnsTextRecord::values() const
{
    return d->values;
}
 
QDnsTextRecord &QDnsTextRecord::operator=(const QDnsTextRecord &other)
{
    d = other.d;
    return *this;
}
QT_DEFINE_QSDP_SPECIALIZATION_DTOR(QDnsTlsAssociationRecordPrivate)
 
 
QDnsTlsAssociationRecord::QDnsTlsAssociationRecord()
    : d(new QDnsTlsAssociationRecordPrivate)
{
}
 
QDnsTlsAssociationRecord::QDnsTlsAssociationRecord(const QDnsTlsAssociationRecord &other) = default;
 
QDnsTlsAssociationRecord &
QDnsTlsAssociationRecord::operator=(const QDnsTlsAssociationRecord &other) = default;
 
QDnsTlsAssociationRecord::~QDnsTlsAssociationRecord() = default;
 
QString QDnsTlsAssociationRecord::name() const
{
    return d->name;
}
 
quint32 QDnsTlsAssociationRecord::timeToLive() const
{
    return d->timeToLive;
}
 
QDnsTlsAssociationRecord::CertificateUsage QDnsTlsAssociationRecord::usage() const
{
    return d->usage;
}
 
QDnsTlsAssociationRecord::Selector QDnsTlsAssociationRecord::selector() const
{
    return d->selector;
}
 
QDnsTlsAssociationRecord::MatchingType QDnsTlsAssociationRecord::matchType() const
{
    return d->matchType;
}
 
QByteArray QDnsTlsAssociationRecord::value() const
{
    return d->value;
}
 
static QDnsLookupRunnable::EncodedLabel encodeLabel(const QString &label)
{
    QDnsLookupRunnable::EncodedLabel::value_type rootDomain = u'.';
    if (label.isEmpty())
        return QDnsLookupRunnable::EncodedLabel(1, rootDomain);
 
    QString encodedLabel = qt_ACE_do(label, ToAceOnly, ForbidLeadingDot);
#ifdef Q_OS_WIN
    return encodedLabel;
#else
    return std::move(encodedLabel).toLatin1();
#endif
}
 
inline QDnsLookupRunnable::QDnsLookupRunnable(const QDnsLookupPrivate *d)
    : requestName(encodeLabel(d->name)),
      nameserver(d->nameserver),
      requestType(d->type),
      port(d->port),
      protocol(d->protocol)
{
    if (port == 0)
        port = QDnsLookup::defaultPortForProtocol(protocol);
#if QT_CONFIG(ssl)
    sslConfiguration = d->sslConfiguration;
#endif
}
 
void QDnsLookupRunnable::run()
{
    QDnsLookupReply reply;
 
    // Validate input.
    if (qsizetype n = requestName.size(); n > MaxDomainNameLength || n == 0) {
        reply.error = QDnsLookup::InvalidRequestError;
        reply.errorString = QDnsLookup::tr("Invalid domain name");
    } else {
        // Perform request.
        query(&reply);
 
        // Sort results.
        qt_qdnsmailexchangerecord_sort(reply.mailExchangeRecords);
        qt_qdnsservicerecord_sort(reply.serviceRecords);
    }
 
    emit finished(reply);
 
    // maybe print the lookup error as warning
    switch (reply.error) {
    case QDnsLookup::NoError:
    case QDnsLookup::OperationCancelledError:
    case QDnsLookup::NotFoundError:
    case QDnsLookup::ServerFailureError:
    case QDnsLookup::ServerRefusedError:
    case QDnsLookup::TimeoutError:
        break;      // no warning for these
 
    case QDnsLookup::ResolverError:
    case QDnsLookup::InvalidRequestError:
    case QDnsLookup::InvalidReplyError:
        qCWarning(lcDnsLookup()).nospace()
                << "DNS lookup failed (" << reply.error << "): "
              << qUtf16Printable(reply.errorString)
              << "; request was " << this;  // continues below
    }
}
 
inline QDebug operator<<(QDebug &d, QDnsLookupRunnable *r)
{
    // continued: print the information about the request
    d << r->requestName.left(MaxDomainNameLength);
    if (r->requestName.size() > MaxDomainNameLength)
        d << "... (truncated)";
    d << " type " << r->requestType;
    if (!r->nameserver.isNull()) {
        d << " to nameserver " << qUtf16Printable(r->nameserver.toString())
          << " port " << (r->port ? r->port : QDnsLookup::defaultPortForProtocol(r->protocol));
        switch (r->protocol) {
        case QDnsLookup::Standard:
            break;
        case QDnsLookup::DnsOverTls:
            d << " (TLS)";
        }
    }
    return d;
}
 
#if QT_CONFIG(ssl)
static constexpr std::chrono::milliseconds DnsOverTlsConnectTimeout(15'000);
static constexpr std::chrono::milliseconds DnsOverTlsTimeout(120'000);
static constexpr quint8 DnsAuthenticDataBit = 0x20;
 
static int makeReplyErrorFromSocket(QDnsLookupReply *reply, const QAbstractSocket *socket)
{
    QDnsLookup::Error error = [&] {
        switch (socket->error()) {
        case QAbstractSocket::SocketTimeoutError:
        case QAbstractSocket::ProxyConnectionTimeoutError:
            return QDnsLookup::TimeoutError;
        default:
            return QDnsLookup::ResolverError;
        }
    }();
    reply->setError(error, socket->errorString());
    return false;
}
 
bool QDnsLookupRunnable::sendDnsOverTls(QDnsLookupReply *reply, QSpan<unsigned char> query,
                                        ReplyBuffer &response)
{
    QSslSocket socket;
    socket.setSslConfiguration(sslConfiguration.value_or(QSslConfiguration::defaultConfiguration()));
 
#  if QT_CONFIG(networkproxy)
    socket.setProtocolTag("domain-s"_L1);
#  endif
 
    // Request the name server attempt to authenticate the reply.
    query[3] |= DnsAuthenticDataBit;
 
    do {
        quint16 size = qToBigEndian<quint16>(query.size());
        QDeadlineTimer timeout(DnsOverTlsTimeout);
 
        socket.connectToHostEncrypted(nameserver.toString(), port);
        socket.write(reinterpret_cast<const char *>(&size), sizeof(size));
        socket.write(reinterpret_cast<const char *>(query.data()), query.size());
        if (!socket.waitForEncrypted(DnsOverTlsConnectTimeout.count()))
            break;
 
        reply->sslConfiguration = socket.sslConfiguration();
 
        // accumulate reply
        auto waitForBytes = [&](void *buffer, int count) {
            int remaining = timeout.remainingTime();
            while (remaining >= 0 && socket.bytesAvailable() < count) {
                if (!socket.waitForReadyRead(remaining))
                    return false;
            }
            return socket.read(static_cast<char *>(buffer), count) == count;
        };
        if (!waitForBytes(&size, sizeof(size)))
            break;
 
        // note: strictly speaking, we're allocating memory based on untrusted data
        // but in practice, due to limited range of the data type (16 bits),
        // the maximum allocation is small.
        size = qFromBigEndian(size);
        response.resize(size);
        if (waitForBytes(response.data(), size)) {
            // check if the AD bit is set; we'll trust it over TLS requests
            if (size >= 4)
                reply->authenticData = response[3] & DnsAuthenticDataBit;
            return true;
        }
    } while (false);
 
    // handle errors
    return makeReplyErrorFromSocket(reply, &socket);
}
#else
bool QDnsLookupRunnable::sendDnsOverTls(QDnsLookupReply *reply, QSpan<unsigned char> query,
                                        ReplyBuffer &response)
{
    Q_UNUSED(query)
    Q_UNUSED(response)
    reply->setError(QDnsLookup::ResolverError, QDnsLookup::tr("SSL/TLS support not present"));
    return false;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qdnslookup.cpp"
#include "moc_qdnslookup_p.cpp"