qhostinfo_p.h

Go to the documentation of this file.

// Copyright (C) 2016 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
// Qt-Security score:significant reason:default
 
#ifndef QHOSTINFO_P_H
#define QHOSTINFO_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists for the convenience
// of the QHostInfo class.  This header file may change from
// version to version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtNetwork/private/qtnetworkglobal_p.h>
#include "QtCore/qcoreapplication.h"
#include "private/qcoreapplication_p.h"
#include "private/qmetaobject_p.h"
#include "QtNetwork/qhostinfo.h"
#include "QtCore/qmutex.h"
#include "QtCore/qwaitcondition.h"
#include "QtCore/qobject.h"
#include "QtCore/qpointer.h"
#include "QtCore/qthread.h"
#if QT_CONFIG(thread)
#include "QtCore/qthreadpool.h"
#endif
#include "QtCore/qrunnable.h"
#include "QtCore/qlist.h"
#include "QtCore/qqueue.h"
#include <QElapsedTimer>
#include <QCache>
 
#include <atomic>
 
QT_BEGIN_NAMESPACE
 
 
class QHostInfoResult : public QObject
{
    Q_OBJECT
public:
    explicit QHostInfoResult(const QObject *receiver, QtPrivate::SlotObjUniquePtr slot);
    ~QHostInfoResult() override;
 
    void postResultsReady(const QHostInfo &info);
 
Q_SIGNALS:
    void resultsReady(const QHostInfo &info);
 
private Q_SLOTS:
    void finalizePostResultsReady(const QHostInfo &info);
 
private:
    QHostInfoResult(QHostInfoResult *other)
        : receiver(other->receiver.get() != other ? other->receiver.get() : this),
          slotObj{std::move(other->slotObj)}
    {
        // cleanup if the application terminates before results are delivered
        connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
                this, &QObject::deleteLater);
        // maintain thread affinity
        moveToThread(other->thread());
    }
 
    // receiver is either a QObject provided by the user,
    // or it's set to `this` (to emulate the behavior of the contextless connect())
    QPointer<const QObject> receiver = nullptr;
    QtPrivate::SlotObjUniquePtr slotObj;
};
 
class QHostInfoAgent
{
public:
    static QHostInfo fromName(const QString &hostName);
    static QHostInfo lookup(const QString &hostName);
    static QHostInfo reverseLookup(const QHostAddress &address);
};
 
class QHostInfoPrivate
{
public:
    inline QHostInfoPrivate()
        : err(QHostInfo::NoError),
          errorStr(QLatin1StringView(QT_TRANSLATE_NOOP("QHostInfo", "Unknown error"))),
          lookupId(0)
    {
    }
    static int lookupHostImpl(const QString &name,
                              const QObject *receiver,
                              QtPrivate::QSlotObjectBase *slotObj,
                              const char *member);
 
    QHostInfo::HostInfoError err;
    QString errorStr;
    QList<QHostAddress> addrs;
    QString hostName;
    int lookupId;
};
 
// These functions are outside of the QHostInfo class and strictly internal.
// Do NOT use them outside of QAbstractSocket.
QHostInfo Q_NETWORK_EXPORT qt_qhostinfo_lookup(const QString &name, QObject *receiver, const char *member, bool *valid, int *id);
void Q_AUTOTEST_EXPORT qt_qhostinfo_clear_cache();
void Q_AUTOTEST_EXPORT qt_qhostinfo_enable_cache(bool e);
void Q_AUTOTEST_EXPORT qt_qhostinfo_cache_inject(const QString &hostname, const QHostInfo &resolution);
 
class QHostInfoCache
{
public:
#if defined(QT_BUILD_INTERNAL) || QT_CONFIG(hostinfocache)
    // unit tests require the ability to manipulate the cache
    QHostInfoCache();
    const int max_age; // seconds
 
    QHostInfo get(const QString &name, bool *valid);
    void put(const QString &name, const QHostInfo &info);
    void clear();
 
    bool isEnabled() { return enabled.load(std::memory_order_relaxed); }
    // this function is currently only used for the auto tests
    // and not usable by public API
    void setEnabled(bool e) { enabled.store(e, std::memory_order_relaxed); }
private:
    std::atomic<bool> enabled;
    struct QHostInfoCacheElement {
        QHostInfo info;
        QElapsedTimer age;
    };
    QCache<QString,QHostInfoCacheElement> cache;
    QMutex mutex;
#else
    QHostInfo get(const QString &, bool *valid) { *valid = false; return QHostInfo(); }
    void put(const QString &, const QHostInfo &) { }
    void clear() {}
    bool isEnabled() { return false; }
    void setEnabled(bool) { }
#endif
};
 
// the following classes are used for the (normal) case: We use multiple threads to lookup DNS
 
class QHostInfoRunnable : public QRunnable
{
public:
    explicit QHostInfoRunnable(const QString &hn, int i, const QObject *receiver,
                               QtPrivate::SlotObjUniquePtr slotObj);
    ~QHostInfoRunnable() override;
 
    void run() override;
 
    QString toBeLookedUp;
    int id;
    QHostInfoResult resultEmitter;
};
 
 
class QHostInfoLookupManager
{
public:
    QHostInfoLookupManager();
    ~QHostInfoLookupManager();
 
    void clear();
 
    // called from QHostInfo
    void scheduleLookup(QHostInfoRunnable *r);
    void abortLookup(int id);
 
    // called from QHostInfoRunnable
    void lookupFinished(QHostInfoRunnable *r);
    bool wasAborted(int id);
 
#if __has_attribute(no_unique_address) && __cplusplus >= 201803L
    [[no_unique_address]]
#endif
    QHostInfoCache cache;
 
    friend class QHostInfoRunnable;
protected:
#if QT_CONFIG(thread)
    QList<QHostInfoRunnable*> currentLookups; // in progress
    QList<QHostInfoRunnable*> postponedLookups; // postponed because in progress for same host
#endif
    QQueue<QHostInfoRunnable*> scheduledLookups; // not yet started
    QList<QHostInfoRunnable*> finishedLookups; // recently finished
    QList<int> abortedLookups; // ids of aborted lookups
 
#if QT_CONFIG(thread)
    QThreadPool threadPool;
#endif
    QMutex mutex;
 
    bool wasDeleted;
 
private:
    void rescheduleWithMutexHeld();
};
 
QT_END_NAMESPACE
 
#endif // QHOSTINFO_P_H