qnetworkinterface.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2017 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qnetworkinterface.h"
#include "qnetworkinterface_p.h"
 
#include "qdebug.h"
#include "qendian.h"
#include "private/qtools_p.h"
 
#ifndef QT_NO_NETWORKINTERFACE
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QNetworkAddressEntry)
QT_IMPL_METATYPE_EXTERN(QNetworkInterface)
 
static_assert(QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
           && sizeof(QScopedPointer<QNetworkAddressEntryPrivate>) == sizeof(std::unique_ptr<QNetworkAddressEntryPrivate>));
 
static QList<QNetworkInterfacePrivate *> postProcess(QList<QNetworkInterfacePrivate *> list)
{
    // Some platforms report a netmask but don't report a broadcast address
    // Go through all available addresses and calculate the broadcast address
    // from the IP and the netmask
    //
    // This is an IPv4-only thing -- IPv6 has no concept of broadcasts
    // The math is:
    //    broadcast = IP | ~netmask
 
    for (QNetworkInterfacePrivate *interface : list) {
        for (QNetworkAddressEntry &address : interface->addressEntries) {
            if (address.ip().protocol() != QAbstractSocket::IPv4Protocol)
                continue;
 
            if (!address.netmask().isNull() && address.broadcast().isNull()) {
                QHostAddress bcast = address.ip();
                bcast = QHostAddress(bcast.toIPv4Address() | ~address.netmask().toIPv4Address());
                address.setBroadcast(bcast);
            }
        }
    }
 
    return list;
}
 
Q_GLOBAL_STATIC(QNetworkInterfaceManager, manager)
 
QNetworkInterfaceManager::QNetworkInterfaceManager()
{
}
 
QNetworkInterfaceManager::~QNetworkInterfaceManager()
{
}
 
QSharedDataPointer<QNetworkInterfacePrivate> QNetworkInterfaceManager::interfaceFromName(const QString &name)
{
    const auto interfaceList = allInterfaces();
 
    bool ok;
    uint index = name.toUInt(&ok);
 
    for (const auto &interface : interfaceList) {
        if (ok && interface->index == int(index))
            return interface;
        else if (interface->name == name)
            return interface;
    }
 
    return empty;
}
 
QSharedDataPointer<QNetworkInterfacePrivate> QNetworkInterfaceManager::interfaceFromIndex(int index)
{
    const auto interfaceList = allInterfaces();
    for (const auto &interface : interfaceList) {
        if (interface->index == index)
            return interface;
    }
 
    return empty;
}
 
QList<QSharedDataPointer<QNetworkInterfacePrivate> > QNetworkInterfaceManager::allInterfaces()
{
    const QList<QNetworkInterfacePrivate *> list = postProcess(scan());
    QList<QSharedDataPointer<QNetworkInterfacePrivate> > result;
    result.reserve(list.size());
 
    for (QNetworkInterfacePrivate *ptr : list) {
        if ((ptr->flags & QNetworkInterface::IsUp) == 0) {
            // if the network interface isn't UP, the addresses are ineligible for DNS
            for (auto &addr : ptr->addressEntries)
                addr.setDnsEligibility(QNetworkAddressEntry::DnsIneligible);
        }
 
        result << QSharedDataPointer<QNetworkInterfacePrivate>(ptr);
    }
 
    return result;
}
 
QString QNetworkInterfacePrivate::makeHwAddress(int len, uchar *data)
{
    const int outLen = qMax(len * 2 + (len - 1) * 1, 0);
    QString result(outLen, Qt::Uninitialized);
    QChar *out = result.data();
    for (int i = 0; i < len; ++i) {
        if (i)
            *out++ = u':';
        *out++ = QLatin1Char(QtMiscUtils::toHexUpper(data[i] / 16));
        *out++ = QLatin1Char(QtMiscUtils::toHexUpper(data[i] % 16));
    }
    return result;
}
 
QNetworkAddressEntry::QNetworkAddressEntry()
    : d(new QNetworkAddressEntryPrivate)
{
}
 
QNetworkAddressEntry::QNetworkAddressEntry(const QNetworkAddressEntry &other)
    : d(new QNetworkAddressEntryPrivate(*other.d.get()))
{
}
 
QNetworkAddressEntry &QNetworkAddressEntry::operator=(const QNetworkAddressEntry &other)
{
    *d.get() = *other.d.get();
    return *this;
}
 
QNetworkAddressEntry::~QNetworkAddressEntry()
{
}
 
bool QNetworkAddressEntry::operator==(const QNetworkAddressEntry &other) const
{
    if (d == other.d) return true;
    if (!d || !other.d) return false;
    return d->address == other.d->address &&
        d->netmask == other.d->netmask &&
        d->broadcast == other.d->broadcast;
}
 
QNetworkAddressEntry::DnsEligibilityStatus QNetworkAddressEntry::dnsEligibility() const
{
    return d->dnsEligibility;
}
 
void QNetworkAddressEntry::setDnsEligibility(DnsEligibilityStatus status)
{
    d->dnsEligibility = status;
}
 
QHostAddress QNetworkAddressEntry::ip() const
{
    return d->address;
}
 
void QNetworkAddressEntry::setIp(const QHostAddress &newIp)
{
    d->address = newIp;
}
 
QHostAddress QNetworkAddressEntry::netmask() const
{
    return d->netmask.address(d->address.protocol());
}
 
void QNetworkAddressEntry::setNetmask(const QHostAddress &newNetmask)
{
    if (newNetmask.protocol() != ip().protocol()) {
        d->netmask = QNetmask();
        return;
    }
 
    d->netmask.setAddress(newNetmask);
}
 
int QNetworkAddressEntry::prefixLength() const
{
    return d->netmask.prefixLength();
}
 
void QNetworkAddressEntry::setPrefixLength(int length)
{
    d->netmask.setPrefixLength(d->address.protocol(), length);
}
 
QHostAddress QNetworkAddressEntry::broadcast() const
{
    return d->broadcast;
}
 
void QNetworkAddressEntry::setBroadcast(const QHostAddress &newBroadcast)
{
    d->broadcast = newBroadcast;
}
 
bool QNetworkAddressEntry::isLifetimeKnown() const
{
    return d->lifetimeKnown;
}
 
QDeadlineTimer QNetworkAddressEntry::preferredLifetime() const
{
    return d->preferredLifetime;
}
 
QDeadlineTimer QNetworkAddressEntry::validityLifetime() const
{
    return d->validityLifetime;
}
 
void QNetworkAddressEntry::setAddressLifetime(QDeadlineTimer preferred, QDeadlineTimer validity)
{
    d->preferredLifetime = preferred;
    d->validityLifetime = validity;
    d->lifetimeKnown = true;
}
 
void QNetworkAddressEntry::clearAddressLifetime()
{
    d->preferredLifetime = QDeadlineTimer::Forever;
    d->validityLifetime = QDeadlineTimer::Forever;
    d->lifetimeKnown = false;
}
 
bool QNetworkAddressEntry::isPermanent() const
{
    return d->validityLifetime.isForever();
}
 
QNetworkInterface::QNetworkInterface()
    : d(nullptr)
{
}
 
QNetworkInterface::~QNetworkInterface()
{
}
 
QNetworkInterface::QNetworkInterface(const QNetworkInterface &other)
    : d(other.d)
{
}
 
QNetworkInterface &QNetworkInterface::operator=(const QNetworkInterface &other)
{
    d = other.d;
    return *this;
}
 
bool QNetworkInterface::isValid() const
{
    return !name().isEmpty();
}
 
int QNetworkInterface::index() const
{
    return d ? d->index : 0;
}
 
int QNetworkInterface::maximumTransmissionUnit() const
{
    return d ? d->mtu : 0;
}
 
QString QNetworkInterface::name() const
{
    return d ? d->name : QString();
}
 
QString QNetworkInterface::humanReadableName() const
{
    return d ? !d->friendlyName.isEmpty() ? d->friendlyName : name() : QString();
}
 
QNetworkInterface::InterfaceFlags QNetworkInterface::flags() const
{
    return d ? d->flags : InterfaceFlags{};
}
 
QNetworkInterface::InterfaceType QNetworkInterface::type() const
{
    return d ? d->type : Unknown;
}
 
QString QNetworkInterface::hardwareAddress() const
{
    return d ? d->hardwareAddress : QString();
}
 
QList<QNetworkAddressEntry> QNetworkInterface::addressEntries() const
{
    return d ? d->addressEntries : QList<QNetworkAddressEntry>();
}
 
int QNetworkInterface::interfaceIndexFromName(const QString &name)
{
    if (name.isEmpty())
        return 0;
 
    bool ok;
    uint id = name.toUInt(&ok);
    if (!ok)
        id = QNetworkInterfaceManager::interfaceIndexFromName(name);
    return int(id);
}
 
QNetworkInterface QNetworkInterface::interfaceFromName(const QString &name)
{
    QNetworkInterface result;
    result.d = manager()->interfaceFromName(name);
    return result;
}
 
QNetworkInterface QNetworkInterface::interfaceFromIndex(int index)
{
    QNetworkInterface result;
    result.d = manager()->interfaceFromIndex(index);
    return result;
}
 
QString QNetworkInterface::interfaceNameFromIndex(int index)
{
    if (!index)
        return QString();
    return QNetworkInterfaceManager::interfaceNameFromIndex(index);
}
 
QList<QNetworkInterface> QNetworkInterface::allInterfaces()
{
    const QList<QSharedDataPointer<QNetworkInterfacePrivate> > privs = manager()->allInterfaces();
    QList<QNetworkInterface> result;
    result.reserve(privs.size());
    for (const auto &p : privs) {
        QNetworkInterface item;
        item.d = p;
        result << item;
    }
 
    return result;
}
 
QList<QHostAddress> QNetworkInterface::allAddresses()
{
    const QList<QSharedDataPointer<QNetworkInterfacePrivate> > privs = manager()->allInterfaces();
    QList<QHostAddress> result;
    for (const auto &p : privs) {
        // skip addresses if the interface isn't up
        if ((p->flags & QNetworkInterface::IsUp) == 0)
            continue;
 
        for (const QNetworkAddressEntry &entry : std::as_const(p->addressEntries))
            result += entry.ip();
    }
 
    return result;
}
 
#ifndef QT_NO_DEBUG_STREAM
static inline QDebug flagsDebug(QDebug debug, QNetworkInterface::InterfaceFlags flags)
{
    if (flags & QNetworkInterface::IsUp)
        debug << "IsUp ";
    if (flags & QNetworkInterface::IsRunning)
        debug << "IsRunning ";
    if (flags & QNetworkInterface::CanBroadcast)
        debug << "CanBroadcast ";
    if (flags & QNetworkInterface::IsLoopBack)
        debug << "IsLoopBack ";
    if (flags & QNetworkInterface::IsPointToPoint)
        debug << "IsPointToPoint ";
    if (flags & QNetworkInterface::CanMulticast)
        debug << "CanMulticast ";
    return debug;
}
 
QDebug operator<<(QDebug debug, const QNetworkAddressEntry &entry)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
    debug << "address = " << entry.ip();
    if (!entry.netmask().isNull())
        debug << ", netmask = " << entry.netmask();
    if (!entry.broadcast().isNull())
        debug << ", broadcast = " << entry.broadcast();
    return debug;
}
 
QDebug operator<<(QDebug debug, const QNetworkInterface &networkInterface)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
    debug << "QNetworkInterface(name = " << networkInterface.name()
          << ", hardware address = " << networkInterface.hardwareAddress()
          << ", flags = ";
    flagsDebug(debug, networkInterface.flags());
    debug << ", entries = " << networkInterface.addressEntries()
          << ")\n";
    return debug;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qnetworkinterface.cpp"
 
#endif // QT_NO_NETWORKINTERFACE