422 lines
16 KiB
C++
422 lines
16 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2012 Jeremy Lainé <jeremy.laine@m4x.org>
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtNetwork module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qdnslookup_p.h"
|
|
|
|
#if QT_CONFIG(library)
|
|
#include <qlibrary.h>
|
|
#endif
|
|
#include <qvarlengtharray.h>
|
|
#include <qscopedpointer.h>
|
|
#include <qurl.h>
|
|
#include <private/qnativesocketengine_p.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/nameser.h>
|
|
#if !defined(Q_OS_OPENBSD)
|
|
# include <arpa/nameser_compat.h>
|
|
#endif
|
|
#include <resolv.h>
|
|
|
|
#if defined(__GNU_LIBRARY__) && !defined(__UCLIBC__)
|
|
# include <gnu/lib-names.h>
|
|
#endif
|
|
|
|
#if defined(Q_OS_FREEBSD) || QT_CONFIG(dlopen)
|
|
# include <dlfcn.h>
|
|
#endif
|
|
|
|
#include <cstring>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
#if QT_CONFIG(library)
|
|
|
|
#if defined(Q_OS_OPENBSD)
|
|
typedef struct __res_state* res_state;
|
|
#endif
|
|
typedef int (*dn_expand_proto)(const unsigned char *, const unsigned char *, const unsigned char *, char *, int);
|
|
static dn_expand_proto local_dn_expand = nullptr;
|
|
typedef void (*res_nclose_proto)(res_state);
|
|
static res_nclose_proto local_res_nclose = nullptr;
|
|
typedef int (*res_ninit_proto)(res_state);
|
|
static res_ninit_proto local_res_ninit = nullptr;
|
|
typedef int (*res_nquery_proto)(res_state, const char *, int, int, unsigned char *, int);
|
|
static res_nquery_proto local_res_nquery = nullptr;
|
|
|
|
// Custom deleter to close resolver state.
|
|
|
|
struct QDnsLookupStateDeleter
|
|
{
|
|
static inline void cleanup(struct __res_state *pointer)
|
|
{
|
|
local_res_nclose(pointer);
|
|
}
|
|
};
|
|
|
|
static QFunctionPointer resolveSymbol(QLibrary &lib, const char *sym)
|
|
{
|
|
if (lib.isLoaded())
|
|
return lib.resolve(sym);
|
|
|
|
#if defined(RTLD_DEFAULT) && (defined(Q_OS_FREEBSD) || QT_CONFIG(dlopen))
|
|
return reinterpret_cast<QFunctionPointer>(dlsym(RTLD_DEFAULT, sym));
|
|
#else
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
static bool resolveLibraryInternal()
|
|
{
|
|
QLibrary lib;
|
|
#ifdef LIBRESOLV_SO
|
|
lib.setFileName(QStringLiteral(LIBRESOLV_SO));
|
|
if (!lib.load())
|
|
#endif
|
|
{
|
|
lib.setFileName(QLatin1String("resolv"));
|
|
lib.load();
|
|
}
|
|
|
|
local_dn_expand = dn_expand_proto(resolveSymbol(lib, "__dn_expand"));
|
|
if (!local_dn_expand)
|
|
local_dn_expand = dn_expand_proto(resolveSymbol(lib, "dn_expand"));
|
|
|
|
local_res_nclose = res_nclose_proto(resolveSymbol(lib, "__res_nclose"));
|
|
if (!local_res_nclose)
|
|
local_res_nclose = res_nclose_proto(resolveSymbol(lib, "res_9_nclose"));
|
|
if (!local_res_nclose)
|
|
local_res_nclose = res_nclose_proto(resolveSymbol(lib, "res_nclose"));
|
|
|
|
local_res_ninit = res_ninit_proto(resolveSymbol(lib, "__res_ninit"));
|
|
if (!local_res_ninit)
|
|
local_res_ninit = res_ninit_proto(resolveSymbol(lib, "res_9_ninit"));
|
|
if (!local_res_ninit)
|
|
local_res_ninit = res_ninit_proto(resolveSymbol(lib, "res_ninit"));
|
|
|
|
local_res_nquery = res_nquery_proto(resolveSymbol(lib, "__res_nquery"));
|
|
if (!local_res_nquery)
|
|
local_res_nquery = res_nquery_proto(resolveSymbol(lib, "res_9_nquery"));
|
|
if (!local_res_nquery)
|
|
local_res_nquery = res_nquery_proto(resolveSymbol(lib, "res_nquery"));
|
|
|
|
return true;
|
|
}
|
|
Q_GLOBAL_STATIC_WITH_ARGS(bool, resolveLibrary, (resolveLibraryInternal()))
|
|
|
|
void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestName, const QHostAddress &nameserver, QDnsLookupReply *reply)
|
|
{
|
|
// Load dn_expand, res_ninit and res_nquery on demand.
|
|
resolveLibrary();
|
|
|
|
// If dn_expand, res_ninit or res_nquery is missing, fail.
|
|
if (!local_dn_expand || !local_res_nclose || !local_res_ninit || !local_res_nquery) {
|
|
reply->error = QDnsLookup::ResolverError;
|
|
reply->errorString = tr("Resolver functions not found");
|
|
return;
|
|
}
|
|
|
|
// Initialize state.
|
|
struct __res_state state;
|
|
std::memset(&state, 0, sizeof(state));
|
|
if (local_res_ninit(&state) < 0) {
|
|
reply->error = QDnsLookup::ResolverError;
|
|
reply->errorString = tr("Resolver initialization failed");
|
|
return;
|
|
}
|
|
|
|
//Check if a nameserver was set. If so, use it
|
|
if (!nameserver.isNull()) {
|
|
if (nameserver.protocol() == QAbstractSocket::IPv4Protocol) {
|
|
state.nsaddr_list[0].sin_addr.s_addr = htonl(nameserver.toIPv4Address());
|
|
state.nscount = 1;
|
|
} else if (nameserver.protocol() == QAbstractSocket::IPv6Protocol) {
|
|
#if defined(Q_OS_LINUX)
|
|
struct sockaddr_in6 *ns;
|
|
ns = state._u._ext.nsaddrs[0];
|
|
// nsaddrs will be NULL if no nameserver is set in /etc/resolv.conf
|
|
if (!ns) {
|
|
// Memory allocated here will be free'd in res_close() as we
|
|
// have done res_init() above.
|
|
ns = (struct sockaddr_in6*) calloc(1, sizeof(struct sockaddr_in6));
|
|
Q_CHECK_PTR(ns);
|
|
state._u._ext.nsaddrs[0] = ns;
|
|
}
|
|
#ifndef __UCLIBC__
|
|
// Set nsmap[] to indicate that nsaddrs[0] is an IPv6 address
|
|
// See: https://sourceware.org/ml/libc-hacker/2002-05/msg00035.html
|
|
state._u._ext.nsmap[0] = MAXNS + 1;
|
|
#endif
|
|
state._u._ext.nscount6 = 1;
|
|
ns->sin6_family = AF_INET6;
|
|
ns->sin6_port = htons(53);
|
|
SetSALen::set(ns, sizeof(*ns));
|
|
|
|
Q_IPV6ADDR ipv6Address = nameserver.toIPv6Address();
|
|
for (int i=0; i<16; i++) {
|
|
ns->sin6_addr.s6_addr[i] = ipv6Address[i];
|
|
}
|
|
#else
|
|
qWarning("%s", QDnsLookupPrivate::msgNoIpV6NameServerAdresses);
|
|
reply->error = QDnsLookup::ResolverError;
|
|
reply->errorString = tr(QDnsLookupPrivate::msgNoIpV6NameServerAdresses);
|
|
return;
|
|
#endif
|
|
}
|
|
}
|
|
#ifdef QDNSLOOKUP_DEBUG
|
|
state.options |= RES_DEBUG;
|
|
#endif
|
|
QScopedPointer<struct __res_state, QDnsLookupStateDeleter> state_ptr(&state);
|
|
|
|
// Perform DNS query.
|
|
QVarLengthArray<unsigned char, PACKETSZ> buffer(PACKETSZ);
|
|
std::memset(buffer.data(), 0, buffer.size());
|
|
int responseLength = local_res_nquery(&state, requestName, C_IN, requestType, buffer.data(), buffer.size());
|
|
if (Q_UNLIKELY(responseLength > PACKETSZ)) {
|
|
buffer.resize(responseLength);
|
|
std::memset(buffer.data(), 0, buffer.size());
|
|
responseLength = local_res_nquery(&state, requestName, C_IN, requestType, buffer.data(), buffer.size());
|
|
if (Q_UNLIKELY(responseLength > buffer.size())) {
|
|
// Ok, we give up.
|
|
reply->error = QDnsLookup::ResolverError;
|
|
reply->errorString.clear(); // We cannot be more specific, alas.
|
|
return;
|
|
}
|
|
}
|
|
|
|
unsigned char *response = buffer.data();
|
|
// Check the response header. Though res_nquery returns -1 as a
|
|
// responseLength in case of error, we still can extract the
|
|
// exact error code from the response.
|
|
HEADER *header = (HEADER*)response;
|
|
const int answerCount = ntohs(header->ancount);
|
|
switch (header->rcode) {
|
|
case NOERROR:
|
|
break;
|
|
case FORMERR:
|
|
reply->error = QDnsLookup::InvalidRequestError;
|
|
reply->errorString = tr("Server could not process query");
|
|
return;
|
|
case SERVFAIL:
|
|
reply->error = QDnsLookup::ServerFailureError;
|
|
reply->errorString = tr("Server failure");
|
|
return;
|
|
case NXDOMAIN:
|
|
reply->error = QDnsLookup::NotFoundError;
|
|
reply->errorString = tr("Non existent domain");
|
|
return;
|
|
case REFUSED:
|
|
reply->error = QDnsLookup::ServerRefusedError;
|
|
reply->errorString = tr("Server refused to answer");
|
|
return;
|
|
default:
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid reply received");
|
|
return;
|
|
}
|
|
|
|
// Check the reply is valid.
|
|
if (responseLength < int(sizeof(HEADER))) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid reply received");
|
|
return;
|
|
}
|
|
|
|
// Skip the query host, type (2 bytes) and class (2 bytes).
|
|
char host[PACKETSZ], answer[PACKETSZ];
|
|
unsigned char *p = response + sizeof(HEADER);
|
|
int status = local_dn_expand(response, response + responseLength, p, host, sizeof(host));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Could not expand domain name");
|
|
return;
|
|
}
|
|
p += status + 4;
|
|
|
|
// Extract results.
|
|
int answerIndex = 0;
|
|
while ((p < response + responseLength) && (answerIndex < answerCount)) {
|
|
status = local_dn_expand(response, response + responseLength, p, host, sizeof(host));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Could not expand domain name");
|
|
return;
|
|
}
|
|
const QString name = QUrl::fromAce(host);
|
|
|
|
p += status;
|
|
const quint16 type = (p[0] << 8) | p[1];
|
|
p += 2; // RR type
|
|
p += 2; // RR class
|
|
const quint32 ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
|
|
p += 4;
|
|
const quint16 size = (p[0] << 8) | p[1];
|
|
p += 2;
|
|
|
|
if (type == QDnsLookup::A) {
|
|
if (size != 4) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid IPv4 address record");
|
|
return;
|
|
}
|
|
const quint32 addr = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
|
|
QDnsHostAddressRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
record.d->value = QHostAddress(addr);
|
|
reply->hostAddressRecords.append(record);
|
|
} else if (type == QDnsLookup::AAAA) {
|
|
if (size != 16) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid IPv6 address record");
|
|
return;
|
|
}
|
|
QDnsHostAddressRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
record.d->value = QHostAddress(p);
|
|
reply->hostAddressRecords.append(record);
|
|
} else if (type == QDnsLookup::CNAME) {
|
|
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid canonical name record");
|
|
return;
|
|
}
|
|
QDnsDomainNameRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
record.d->value = QUrl::fromAce(answer);
|
|
reply->canonicalNameRecords.append(record);
|
|
} else if (type == QDnsLookup::NS) {
|
|
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid name server record");
|
|
return;
|
|
}
|
|
QDnsDomainNameRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
record.d->value = QUrl::fromAce(answer);
|
|
reply->nameServerRecords.append(record);
|
|
} else if (type == QDnsLookup::PTR) {
|
|
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid pointer record");
|
|
return;
|
|
}
|
|
QDnsDomainNameRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
record.d->value = QUrl::fromAce(answer);
|
|
reply->pointerRecords.append(record);
|
|
} else if (type == QDnsLookup::MX) {
|
|
const quint16 preference = (p[0] << 8) | p[1];
|
|
status = local_dn_expand(response, response + responseLength, p + 2, answer, sizeof(answer));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid mail exchange record");
|
|
return;
|
|
}
|
|
QDnsMailExchangeRecord record;
|
|
record.d->exchange = QUrl::fromAce(answer);
|
|
record.d->name = name;
|
|
record.d->preference = preference;
|
|
record.d->timeToLive = ttl;
|
|
reply->mailExchangeRecords.append(record);
|
|
} else if (type == QDnsLookup::SRV) {
|
|
const quint16 priority = (p[0] << 8) | p[1];
|
|
const quint16 weight = (p[2] << 8) | p[3];
|
|
const quint16 port = (p[4] << 8) | p[5];
|
|
status = local_dn_expand(response, response + responseLength, p + 6, answer, sizeof(answer));
|
|
if (status < 0) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid service record");
|
|
return;
|
|
}
|
|
QDnsServiceRecord record;
|
|
record.d->name = name;
|
|
record.d->target = QUrl::fromAce(answer);
|
|
record.d->port = port;
|
|
record.d->priority = priority;
|
|
record.d->timeToLive = ttl;
|
|
record.d->weight = weight;
|
|
reply->serviceRecords.append(record);
|
|
} else if (type == QDnsLookup::TXT) {
|
|
unsigned char *txt = p;
|
|
QDnsTextRecord record;
|
|
record.d->name = name;
|
|
record.d->timeToLive = ttl;
|
|
while (txt < p + size) {
|
|
const unsigned char length = *txt;
|
|
txt++;
|
|
if (txt + length > p + size) {
|
|
reply->error = QDnsLookup::InvalidReplyError;
|
|
reply->errorString = tr("Invalid text record");
|
|
return;
|
|
}
|
|
record.d->values << QByteArray((char*)txt, length);
|
|
txt += length;
|
|
}
|
|
reply->textRecords.append(record);
|
|
}
|
|
p += size;
|
|
answerIndex++;
|
|
}
|
|
}
|
|
|
|
#else
|
|
void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestName, const QHostAddress &nameserver, QDnsLookupReply *reply)
|
|
{
|
|
Q_UNUSED(requestType);
|
|
Q_UNUSED(requestName);
|
|
Q_UNUSED(nameserver);
|
|
reply->error = QDnsLookup::ResolverError;
|
|
reply->errorString = tr("Resolver library can't be loaded: No runtime library loading support");
|
|
return;
|
|
}
|
|
|
|
#endif /* QT_CONFIG(library) */
|
|
|
|
QT_END_NAMESPACE
|