qnetworkproxy.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 
#include "qnetworkproxy.h"
 
#ifndef QT_NO_NETWORKPROXY
 
#include "private/qnetworkrequest_p.h"
#if QT_CONFIG(socks5)
#include "private/qsocks5socketengine_p.h"
#endif
 
#if QT_CONFIG(http)
#include "private/qhttpsocketengine_p.h"
#endif
 
#include "qauthenticator.h"
#include "qdebug.h"
#include "qmutex.h"
#include "qstringlist.h"
#include "qurl.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QT_IMPL_METATYPE_EXTERN(QNetworkProxy)
 
class QSocks5SocketEngineHandler;
class QHttpSocketEngineHandler;
 
class QGlobalNetworkProxy
{
public:
    QGlobalNetworkProxy()
        : applicationLevelProxy(nullptr)
        , applicationLevelProxyFactory(nullptr)
#if QT_CONFIG(socks5)
        , socks5SocketEngineHandler(nullptr)
#endif
#if QT_CONFIG(http)
        , httpSocketEngineHandler(nullptr)
#endif
#ifdef QT_USE_SYSTEM_PROXIES
        , useSystemProxies(true)
#else
        , useSystemProxies(false)
#endif
    {
#if QT_CONFIG(socks5)
        socks5SocketEngineHandler = new QSocks5SocketEngineHandler();
#endif
#if QT_CONFIG(http)
        httpSocketEngineHandler = new QHttpSocketEngineHandler();
#endif
    }
 
    ~QGlobalNetworkProxy()
    {
        delete applicationLevelProxy;
        delete applicationLevelProxyFactory;
#if QT_CONFIG(socks5)
        delete socks5SocketEngineHandler;
#endif
#if QT_CONFIG(http)
        delete httpSocketEngineHandler;
#endif
    }
 
    bool usesSystemConfiguration() const
    {
        return useSystemProxies;
    }
 
    void setUseSystemConfiguration(bool enable)
    {
        QMutexLocker lock(&mutex);
        useSystemProxies = enable;
 
        if (useSystemProxies) {
            if (applicationLevelProxy)
                *applicationLevelProxy = QNetworkProxy();
            delete applicationLevelProxyFactory;
            applicationLevelProxyFactory = nullptr;
        }
    }
 
    void setApplicationProxy(const QNetworkProxy &proxy)
    {
        QMutexLocker lock(&mutex);
        if (!applicationLevelProxy)
            applicationLevelProxy = new QNetworkProxy;
        *applicationLevelProxy = proxy;
        delete applicationLevelProxyFactory;
        applicationLevelProxyFactory = nullptr;
        useSystemProxies = false;
    }
 
    void setApplicationProxyFactory(QNetworkProxyFactory *factory)
    {
        QMutexLocker lock(&mutex);
        if (factory == applicationLevelProxyFactory)
            return;
        if (applicationLevelProxy)
            *applicationLevelProxy = QNetworkProxy();
        delete applicationLevelProxyFactory;
        applicationLevelProxyFactory = factory;
        useSystemProxies = false;
    }
 
    QNetworkProxy applicationProxy()
    {
        return proxyForQuery(QNetworkProxyQuery()).constFirst();
    }
 
    QList<QNetworkProxy> proxyForQuery(const QNetworkProxyQuery &query);
 
private:
    QRecursiveMutex mutex;
    QNetworkProxy *applicationLevelProxy;
    QNetworkProxyFactory *applicationLevelProxyFactory;
#if QT_CONFIG(socks5)
    QSocks5SocketEngineHandler *socks5SocketEngineHandler;
#endif
#if QT_CONFIG(http)
    QHttpSocketEngineHandler *httpSocketEngineHandler;
#endif
    bool useSystemProxies;
};
 
QList<QNetworkProxy> QGlobalNetworkProxy::proxyForQuery(const QNetworkProxyQuery &query)
{
    QMutexLocker locker(&mutex);
 
    QList<QNetworkProxy> result;
 
    // don't look for proxies for a local connection
    QHostAddress parsed;
    QString hostname = query.url().host();
    if (hostname == "localhost"_L1 || hostname.startsWith("localhost."_L1)
            || (parsed.setAddress(hostname) && (parsed.isLoopback()))) {
        result << QNetworkProxy(QNetworkProxy::NoProxy);
        return result;
    }
 
    if (!applicationLevelProxyFactory) {
        if (applicationLevelProxy
            && applicationLevelProxy->type() != QNetworkProxy::DefaultProxy) {
            result << *applicationLevelProxy;
        } else if (useSystemProxies) {
            result = QNetworkProxyFactory::systemProxyForQuery(query);
 
            // Make sure NoProxy is in the list, so that QTcpServer can work:
            // it searches for the first proxy that can has the ListeningCapability capability
            // if none have (as is the case with HTTP proxies), it fails to bind.
            // NoProxy allows it to fallback to the 'no proxy' case and bind.
            result << QNetworkProxy(QNetworkProxy::NoProxy);
        } else {
            result << QNetworkProxy(QNetworkProxy::NoProxy);
        }
        return result;
    }
 
    // we have a factory
    result = applicationLevelProxyFactory->queryProxy(query);
    if (result.isEmpty()) {
        qWarning("QNetworkProxyFactory: factory %p has returned an empty result set",
                 applicationLevelProxyFactory);
        result << QNetworkProxy(QNetworkProxy::NoProxy);
    }
    return result;
}
 
Q_GLOBAL_STATIC(QGlobalNetworkProxy, globalNetworkProxy)
 
namespace {
    template<bool> struct StaticAssertTest;
    template<> struct StaticAssertTest<true> { enum { Value = 1 }; };
}
 
static inline void qt_noop_with_arg(int) {}
#define q_static_assert(expr)   qt_noop_with_arg(sizeof(StaticAssertTest< expr >::Value))
 
static QNetworkProxy::Capabilities defaultCapabilitiesForType(QNetworkProxy::ProxyType type)
{
    q_static_assert(int(QNetworkProxy::DefaultProxy) == 0);
    q_static_assert(int(QNetworkProxy::FtpCachingProxy) == 5);
    static const int defaults[] =
    {
        /* [QNetworkProxy::DefaultProxy] = */
        (int(QNetworkProxy::ListeningCapability) |
         int(QNetworkProxy::TunnelingCapability) |
         int(QNetworkProxy::UdpTunnelingCapability) |
         int(QNetworkProxy::SctpTunnelingCapability) |
         int(QNetworkProxy::SctpListeningCapability)),
        /* [QNetworkProxy::Socks5Proxy] = */
        (int(QNetworkProxy::TunnelingCapability) |
         int(QNetworkProxy::ListeningCapability) |
         int(QNetworkProxy::UdpTunnelingCapability) |
         int(QNetworkProxy::HostNameLookupCapability)),
        // it's weird to talk about the proxy capabilities of a "not proxy"...
        /* [QNetworkProxy::NoProxy] = */
        (int(QNetworkProxy::ListeningCapability) |
         int(QNetworkProxy::TunnelingCapability) |
         int(QNetworkProxy::UdpTunnelingCapability) |
         int(QNetworkProxy::SctpTunnelingCapability) |
         int(QNetworkProxy::SctpListeningCapability)),
        /* [QNetworkProxy::HttpProxy] = */
        (int(QNetworkProxy::TunnelingCapability) |
         int(QNetworkProxy::CachingCapability) |
         int(QNetworkProxy::HostNameLookupCapability)),
        /* [QNetworkProxy::HttpCachingProxy] = */
        (int(QNetworkProxy::CachingCapability) |
         int(QNetworkProxy::HostNameLookupCapability)),
        /* [QNetworkProxy::FtpCachingProxy] = */
        (int(QNetworkProxy::CachingCapability) |
         int(QNetworkProxy::HostNameLookupCapability)),
    };
 
    if (int(type) < 0 || int(type) > int(QNetworkProxy::FtpCachingProxy))
        type = QNetworkProxy::DefaultProxy;
    return QNetworkProxy::Capabilities(defaults[int(type)]);
}
 
class QNetworkProxyPrivate: public QSharedData
{
public:
    QString hostName;
    QString user;
    QString password;
    QNetworkProxy::Capabilities capabilities;
    quint16 port;
    QNetworkProxy::ProxyType type;
    bool capabilitiesSet;
    QNetworkHeadersPrivate headers;
 
    inline QNetworkProxyPrivate(QNetworkProxy::ProxyType t = QNetworkProxy::DefaultProxy,
                                const QString &h = QString(), quint16 p = 0,
                                const QString &u = QString(), const QString &pw = QString())
        : hostName(h),
          user(u),
          password(pw),
          capabilities(defaultCapabilitiesForType(t)),
          port(p),
          type(t),
          capabilitiesSet(false)
    { }
 
    inline bool operator==(const QNetworkProxyPrivate &other) const
    {
        return type == other.type &&
            port == other.port &&
            hostName == other.hostName &&
            user == other.user &&
            password == other.password &&
            capabilities == other.capabilities;
    }
};
 
template<> void QSharedDataPointer<QNetworkProxyPrivate>::detach()
{
    if (d && d->ref.loadRelaxed() == 1)
        return;
    QNetworkProxyPrivate *x = (d ? new QNetworkProxyPrivate(*d)
                               : new QNetworkProxyPrivate);
    x->ref.ref();
    if (d && !d->ref.deref())
        delete d;
    d = x;
}
 
QNetworkProxy::QNetworkProxy()
    : d(nullptr)
{
    // make sure we have QGlobalNetworkProxy singleton created, otherwise
    // you don't have any socket engine handler created when directly setting
    // a proxy to a socket
    globalNetworkProxy();
}
 
QNetworkProxy::QNetworkProxy(ProxyType type, const QString &hostName, quint16 port,
                  const QString &user, const QString &password)
    : d(new QNetworkProxyPrivate(type, hostName, port, user, password))
{
    // make sure we have QGlobalNetworkProxy singleton created, otherwise
    // you don't have any socket engine handler created when directly setting
    // a proxy to a socket
    globalNetworkProxy();
}
 
QNetworkProxy::QNetworkProxy(const QNetworkProxy &other)
    : d(other.d)
{
}
 
QNetworkProxy::~QNetworkProxy()
{
    // QSharedDataPointer takes care of deleting for us
}
 
bool QNetworkProxy::operator==(const QNetworkProxy &other) const
{
    return d == other.d || (d && other.d && *d == *other.d);
}
 
QNetworkProxy &QNetworkProxy::operator=(const QNetworkProxy &other)
{
    d = other.d;
    return *this;
}
 
void QNetworkProxy::setType(QNetworkProxy::ProxyType type)
{
    d->type = type;
    if (!d->capabilitiesSet)
        d->capabilities = defaultCapabilitiesForType(type);
}
 
QNetworkProxy::ProxyType QNetworkProxy::type() const
{
    return d ? d->type : DefaultProxy;
}
 
void QNetworkProxy::setCapabilities(Capabilities capabilities)
{
    d->capabilities = capabilities;
    d->capabilitiesSet = true;
}
 
QNetworkProxy::Capabilities QNetworkProxy::capabilities() const
{
    return d ? d->capabilities : defaultCapabilitiesForType(DefaultProxy);
}
 
bool QNetworkProxy::isCachingProxy() const
{
    return capabilities() & CachingCapability;
}
 
bool QNetworkProxy::isTransparentProxy() const
{
    return capabilities() & TunnelingCapability;
}
 
void QNetworkProxy::setUser(const QString &user)
{
    d->user = user;
}
 
QString QNetworkProxy::user() const
{
    return d ? d->user : QString();
}
 
void QNetworkProxy::setPassword(const QString &password)
{
    d->password = password;
}
 
QString QNetworkProxy::password() const
{
    return d ? d->password : QString();
}
 
void QNetworkProxy::setHostName(const QString &hostName)
{
    d->hostName = hostName;
}
 
QString QNetworkProxy::hostName() const
{
    return d ? d->hostName : QString();
}
 
void QNetworkProxy::setPort(quint16 port)
{
    d->port = port;
}
 
quint16 QNetworkProxy::port() const
{
    return d ? d->port : 0;
}
 
void QNetworkProxy::setApplicationProxy(const QNetworkProxy &networkProxy)
{
    if (globalNetworkProxy()) {
        // don't accept setting the proxy to DefaultProxy
        if (networkProxy.type() == DefaultProxy)
            globalNetworkProxy()->setApplicationProxy(QNetworkProxy::NoProxy);
        else
            globalNetworkProxy()->setApplicationProxy(networkProxy);
    }
}
 
QNetworkProxy QNetworkProxy::applicationProxy()
{
    if (globalNetworkProxy())
        return globalNetworkProxy()->applicationProxy();
    return QNetworkProxy();
}
 
QHttpHeaders QNetworkProxy::headers() const
{
    if (d->type != HttpProxy && d->type != HttpCachingProxy)
        return {};
    return d->headers.headers();
}
 
void QNetworkProxy::setHeaders(QHttpHeaders &&newHeaders)
{
    if (d->type == HttpProxy || d->type == HttpCachingProxy)
        d->headers.setHeaders(std::move(newHeaders));
}
 
void QNetworkProxy::setHeaders(const QHttpHeaders &newHeaders)
{
    if (d->type == HttpProxy || d->type == HttpCachingProxy)
        d->headers.setHeaders(newHeaders);
}
 
QVariant QNetworkProxy::header(QNetworkRequest::KnownHeaders header) const
{
    if (d->type != HttpProxy && d->type != HttpCachingProxy)
        return QVariant();
    return d->headers.cookedHeaders.value(header);
}
 
void QNetworkProxy::setHeader(QNetworkRequest::KnownHeaders header, const QVariant &value)
{
    if (d->type == HttpProxy || d->type == HttpCachingProxy)
        d->headers.setCookedHeader(header, value);
}
 
bool QNetworkProxy::hasRawHeader(const QByteArray &headerName) const
{
    if (d->type != HttpProxy && d->type != HttpCachingProxy)
        return false;
    return d->headers.headers().contains(headerName);
}
 
QByteArray QNetworkProxy::rawHeader(const QByteArray &headerName) const
{
    if (d->type != HttpProxy && d->type != HttpCachingProxy)
        return QByteArray();
    return d->headers.rawHeader(headerName);
}
 
QList<QByteArray> QNetworkProxy::rawHeaderList() const
{
    if (d->type != HttpProxy && d->type != HttpCachingProxy)
        return QList<QByteArray>();
    return d->headers.rawHeadersKeys();
}
 
void QNetworkProxy::setRawHeader(const QByteArray &headerName, const QByteArray &headerValue)
{
    if (d->type == HttpProxy || d->type == HttpCachingProxy)
        d->headers.setRawHeader(headerName, headerValue);
}
 
class QNetworkProxyQueryPrivate: public QSharedData
{
public:
    inline QNetworkProxyQueryPrivate()
        : localPort(-1), type(QNetworkProxyQuery::TcpSocket)
    { }
 
    bool operator==(const QNetworkProxyQueryPrivate &other) const
    {
        return type == other.type &&
            localPort == other.localPort &&
            remote == other.remote;
    }
 
    QUrl remote;
    int localPort;
    QNetworkProxyQuery::QueryType type;
};
 
template<> void QSharedDataPointer<QNetworkProxyQueryPrivate>::detach()
{
    if (d && d->ref.loadRelaxed() == 1)
        return;
    QNetworkProxyQueryPrivate *x = (d ? new QNetworkProxyQueryPrivate(*d)
                                    : new QNetworkProxyQueryPrivate);
    x->ref.ref();
    if (d && !d->ref.deref())
        delete d;
    d = x;
}
 
QNetworkProxyQuery::QNetworkProxyQuery()
{
}
 
QNetworkProxyQuery::QNetworkProxyQuery(const QUrl &requestUrl, QueryType queryType)
{
    d->remote = requestUrl;
    d->type = queryType;
}
 
QNetworkProxyQuery::QNetworkProxyQuery(const QString &hostname, int port,
                                       const QString &protocolTag,
                                       QueryType queryType)
{
    d->remote.setScheme(protocolTag);
    d->remote.setHost(hostname);
    d->remote.setPort(port);
    d->type = queryType;
}
 
QNetworkProxyQuery::QNetworkProxyQuery(quint16 bindPort, const QString &protocolTag,
                                       QueryType queryType)
{
    d->remote.setScheme(protocolTag);
    d->localPort = bindPort;
    d->type = queryType;
}
 
QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkProxyQuery &other)
    : d(other.d)
{
}
 
QNetworkProxyQuery::~QNetworkProxyQuery()
{
    // QSharedDataPointer automatically deletes
}
 
QNetworkProxyQuery &QNetworkProxyQuery::operator=(const QNetworkProxyQuery &other)
{
    d = other.d;
    return *this;
}
 
bool QNetworkProxyQuery::operator==(const QNetworkProxyQuery &other) const
{
    return d == other.d || (d && other.d && *d == *other.d);
}
 
QNetworkProxyQuery::QueryType QNetworkProxyQuery::queryType() const
{
    return d ? d->type : TcpSocket;
}
 
void QNetworkProxyQuery::setQueryType(QueryType type)
{
    d->type = type;
}
 
int QNetworkProxyQuery::peerPort() const
{
    return d ? d->remote.port() : -1;
}
 
void QNetworkProxyQuery::setPeerPort(int port)
{
    d->remote.setPort(port);
}
 
QString QNetworkProxyQuery::peerHostName() const
{
    return d ? d->remote.host() : QString();
}
 
void QNetworkProxyQuery::setPeerHostName(const QString &hostname)
{
    d->remote.setHost(hostname);
}
 
int QNetworkProxyQuery::localPort() const
{
    return d ? d->localPort : -1;
}
 
void QNetworkProxyQuery::setLocalPort(int port)
{
    d->localPort = port;
}
 
QString QNetworkProxyQuery::protocolTag() const
{
    return d ? d->remote.scheme() : QString();
}
 
void QNetworkProxyQuery::setProtocolTag(const QString &protocolTag)
{
    d->remote.setScheme(protocolTag);
}
 
QUrl QNetworkProxyQuery::url() const
{
    return d ? d->remote : QUrl();
}
 
void QNetworkProxyQuery::setUrl(const QUrl &url)
{
    d->remote = url;
}
 
QNetworkProxyFactory::QNetworkProxyFactory()
{
}
 
QNetworkProxyFactory::~QNetworkProxyFactory()
{
}
 
bool QNetworkProxyFactory::usesSystemConfiguration()
{
    if (globalNetworkProxy())
        return globalNetworkProxy()->usesSystemConfiguration();
    return false;
}
 
void QNetworkProxyFactory::setUseSystemConfiguration(bool enable)
{
    if (globalNetworkProxy())
        globalNetworkProxy()->setUseSystemConfiguration(enable);
}
 
void QNetworkProxyFactory::setApplicationProxyFactory(QNetworkProxyFactory *factory)
{
    if (globalNetworkProxy())
        globalNetworkProxy()->setApplicationProxyFactory(factory);
}
 
QList<QNetworkProxy> QNetworkProxyFactory::proxyForQuery(const QNetworkProxyQuery &query)
{
    if (!globalNetworkProxy())
        return QList<QNetworkProxy>() << QNetworkProxy(QNetworkProxy::NoProxy);
    return globalNetworkProxy()->proxyForQuery(query);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QNetworkProxy &proxy)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
    QNetworkProxy::ProxyType type = proxy.type();
    switch (type) {
    case QNetworkProxy::NoProxy:
        debug << "NoProxy ";
        break;
    case QNetworkProxy::DefaultProxy:
        debug << "DefaultProxy ";
        break;
    case QNetworkProxy::Socks5Proxy:
        debug << "Socks5Proxy ";
        break;
    case QNetworkProxy::HttpProxy:
        debug << "HttpProxy ";
        break;
    case QNetworkProxy::HttpCachingProxy:
        debug << "HttpCachingProxy ";
        break;
    case QNetworkProxy::FtpCachingProxy:
        debug << "FtpCachingProxy ";
        break;
    default:
        debug << "Unknown proxy " << int(type);
        break;
    }
    debug << '"' << proxy.hostName() << ':' << proxy.port() << "\" ";
    QNetworkProxy::Capabilities caps = proxy.capabilities();
    QStringList scaps;
    if (caps & QNetworkProxy::TunnelingCapability)
        scaps << QStringLiteral("Tunnel");
    if (caps & QNetworkProxy::ListeningCapability)
        scaps << QStringLiteral("Listen");
    if (caps & QNetworkProxy::UdpTunnelingCapability)
        scaps << QStringLiteral("UDP");
    if (caps & QNetworkProxy::CachingCapability)
        scaps << QStringLiteral("Caching");
    if (caps & QNetworkProxy::HostNameLookupCapability)
        scaps << QStringLiteral("NameLookup");
    if (caps & QNetworkProxy::SctpTunnelingCapability)
        scaps << QStringLiteral("SctpTunnel");
    if (caps & QNetworkProxy::SctpListeningCapability)
        scaps << QStringLiteral("SctpListen");
    debug << '[' << scaps.join(u' ') << ']';
    return debug;
}
 
QDebug operator<<(QDebug debug, const QNetworkProxyQuery &proxyQuery)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace()
        << "ProxyQuery("
        << "type: " << proxyQuery.queryType()
        << ", protocol: " << proxyQuery.protocolTag()
        << ", peerPort: " << proxyQuery.peerPort()
        << ", peerHostName: " << proxyQuery.peerHostName()
        << ", localPort: " << proxyQuery.localPort()
        << ", url: " << proxyQuery.url()
        << ')';
    return debug;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qnetworkproxy.cpp"
 
#endif // QT_NO_NETWORKPROXY