diff --git a/src/accesspoint.cpp b/src/accesspoint.cpp index 80a1afe..2ac620c 100644 --- a/src/accesspoint.cpp +++ b/src/accesspoint.cpp @@ -1,234 +1,234 @@ /* Copyright 2008 Will Stephenson Copyright 2013 Daniel Nicoletti Copyright 2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "accesspoint_p.h" #include "manager_p.h" #include "wirelessdevice.h" #include "nmdebug.h" NetworkManager::AccessPointPrivate::AccessPointPrivate(const QString &path, AccessPoint *q) #ifdef NMQT_STATIC : iface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::sessionBus()) #else : iface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::systemBus()) #endif , capabilities(AccessPoint::None) , wpaFlags() , rsnFlags() , frequency(0) , maxBitRate(0) , mode(AccessPoint::Unknown) , signalStrength(0) , lastSeen(-1) , q_ptr(q) { uni = path; } NetworkManager::AccessPoint::Capabilities NetworkManager::AccessPointPrivate::convertCapabilities(int caps) { NetworkManager::AccessPoint::Capabilities capFlags; if (caps & NM_802_11_AP_FLAGS_PRIVACY) { capFlags |= AccessPoint::Privacy; } return capFlags; } NetworkManager::AccessPoint::WpaFlags NetworkManager::AccessPointPrivate::convertWpaFlags(uint theirFlags) { return (AccessPoint::WpaFlags)theirFlags; } NetworkManager::AccessPoint::AccessPoint(const QString &path, QObject *parent) : QObject(parent) , d_ptr(new AccessPointPrivate(path, this)) { Q_D(AccessPoint); // Get all AccessPoint's properties at once QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(d->iface.staticInterfaceName(), path); if (!initialProperties.isEmpty()) { d->propertiesChanged(initialProperties); } #if NM_CHECK_VERSION(1, 4, 0) QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->uni, NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("PropertiesChanged"), d, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList))); #else QObject::connect(&d->iface, &OrgFreedesktopNetworkManagerAccessPointInterface::PropertiesChanged, d, &AccessPointPrivate::propertiesChanged); #endif } NetworkManager::AccessPoint::~AccessPoint() { Q_D(AccessPoint); delete d; } QString NetworkManager::AccessPoint::uni() const { Q_D(const AccessPoint); return d->uni; } QString NetworkManager::AccessPoint::hardwareAddress() const { Q_D(const AccessPoint); return d->hardwareAddress; } NetworkManager::AccessPoint::Capabilities NetworkManager::AccessPoint::capabilities() const { Q_D(const AccessPoint); return d->capabilities; } NetworkManager::AccessPoint::WpaFlags NetworkManager::AccessPoint::wpaFlags() const { Q_D(const AccessPoint); return d->wpaFlags; } NetworkManager::AccessPoint::WpaFlags NetworkManager::AccessPoint::rsnFlags() const { Q_D(const AccessPoint); return d->rsnFlags; } QString NetworkManager::AccessPoint::ssid() const { Q_D(const AccessPoint); return d->ssid; } QByteArray NetworkManager::AccessPoint::rawSsid() const { Q_D(const AccessPoint); return d->rawSsid; } uint NetworkManager::AccessPoint::frequency() const { Q_D(const AccessPoint); return d->frequency; } uint NetworkManager::AccessPoint::maxBitRate() const { Q_D(const AccessPoint); return d->maxBitRate; } NetworkManager::AccessPoint::OperationMode NetworkManager::AccessPoint::mode() const { Q_D(const AccessPoint); return d->mode; } int NetworkManager::AccessPoint::signalStrength() const { Q_D(const AccessPoint); return d->signalStrength; } int NetworkManager::AccessPoint::lastSeen() const { Q_D(const AccessPoint); return d->lastSeen; } NetworkManager::AccessPoint::OperationMode NetworkManager::AccessPoint::convertOperationMode(uint mode) { NetworkManager::AccessPoint::OperationMode ourMode = NetworkManager::AccessPoint::Unknown; switch (mode) { case NM_802_11_MODE_UNKNOWN: ourMode = NetworkManager::AccessPoint::Unknown; break; case NM_802_11_MODE_ADHOC: ourMode = NetworkManager::AccessPoint::Adhoc; break; case NM_802_11_MODE_INFRA: ourMode = NetworkManager::AccessPoint::Infra; break; case NM_802_11_MODE_AP: ourMode = NetworkManager::AccessPoint::ApMode; break; default: qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled mode" << mode; } return ourMode; } void NetworkManager::AccessPointPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties) { Q_UNUSED(invalidatedProperties); if (interfaceName == QLatin1String("org.freedesktop.NetworkManager.AccessPoint")) { propertiesChanged(properties); } } void NetworkManager::AccessPointPrivate::propertiesChanged(const QVariantMap &properties) { Q_Q(AccessPoint); // qCDebug(NMQT) << Q_FUNC_INFO << properties; QVariantMap::const_iterator it = properties.constBegin(); while (it != properties.constEnd()) { const QString property = it.key(); if (property == QLatin1String("Flags")) { capabilities = convertCapabilities(it->toUInt()); Q_EMIT q->capabilitiesChanged(capabilities); } else if (property == QLatin1String("WpaFlags")) { wpaFlags = convertWpaFlags(it->toUInt()); Q_EMIT q->wpaFlagsChanged(wpaFlags); } else if (property == QLatin1String("RsnFlags")) { rsnFlags = convertWpaFlags(it->toUInt()); Q_EMIT q->rsnFlagsChanged(rsnFlags); } else if (property == QLatin1String("Ssid")) { rawSsid = it->toByteArray(); ssid = QString::fromUtf8(rawSsid); Q_EMIT q->ssidChanged(ssid); } else if (property == QLatin1String("Frequency")) { frequency = it->toUInt(); Q_EMIT q->frequencyChanged(frequency); } else if (property == QLatin1String("HwAddress")) { hardwareAddress = it->toString(); } else if (property == QLatin1String("Mode")) { mode = q->convertOperationMode(it->toUInt()); } else if (property == QLatin1String("MaxBitrate")) { maxBitRate = it->toUInt(); Q_EMIT q->bitRateChanged(maxBitRate); } else if (property == QLatin1String("Strength")) { signalStrength = it->toInt(); Q_EMIT q->signalStrengthChanged(signalStrength); } else if (property == QLatin1String("LastSeen")) { lastSeen = it->toInt(); Q_EMIT q->lastSeenChanged(lastSeen); } else { - qCWarning(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; + qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; } ++it; } } diff --git a/src/activeconnection.cpp b/src/activeconnection.cpp index e0dffe2..db6f476 100644 --- a/src/activeconnection.cpp +++ b/src/activeconnection.cpp @@ -1,417 +1,417 @@ /* Copyright 2011 Ilia Kats Copyright 2013 Daniel Nicoletti Copyright 2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "activeconnection.h" #include "activeconnection_p.h" #include "connection.h" #include "device.h" #include "nmdebug.h" #include "manager.h" #include "settings.h" #include #include "manager_p.h" NetworkManager::ActiveConnectionPrivate::ActiveConnectionPrivate(const QString &dbusPath, ActiveConnection *q) #ifdef NMQT_STATIC : iface(NetworkManagerPrivate::DBUS_SERVICE, dbusPath, QDBusConnection::sessionBus()) #else : iface(NetworkManagerPrivate::DBUS_SERVICE, dbusPath, QDBusConnection::systemBus()) #endif , dhcp4Config(nullptr) , dhcp6Config(nullptr) , state(ActiveConnection::Unknown) , q_ptr(q) { path = dbusPath; } NetworkManager::ActiveConnectionPrivate::~ActiveConnectionPrivate() { } NetworkManager::ActiveConnection::State NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(uint state) { return (NetworkManager::ActiveConnection::State)state; } NetworkManager::ActiveConnection::ActiveConnection(const QString &path, QObject *parent) : QObject(parent), d_ptr(new ActiveConnectionPrivate(path, this)) { Q_D(ActiveConnection); // Get all ActiveConnection's at once QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(d->iface.staticInterfaceName(), path); if (!initialProperties.isEmpty()) { d->propertiesChanged(initialProperties); } #ifndef NMQT_STATIC #if NM_CHECK_VERSION(1, 4, 0) QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("PropertiesChanged"), d, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList))); #else connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged); #endif #endif #ifdef NMQT_STATIC connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged); #endif #ifndef NMQT_STATIC /* * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly * BUG:352326 */ d->recheckProperties(); #endif } NetworkManager::ActiveConnection::ActiveConnection(ActiveConnectionPrivate &dd, QObject *parent) : QObject(parent), d_ptr(&dd) { Q_D(ActiveConnection); #ifndef NMQT_STATIC #if NM_CHECK_VERSION(1, 4, 0) QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("PropertiesChanged"), d, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList))); #else connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged); #endif #endif #ifdef NMQT_STATIC connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged); #endif #ifndef NMQT_STATIC /* * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly * BUG:352326 */ d->recheckProperties(); #endif } NetworkManager::ActiveConnection::~ActiveConnection() { delete d_ptr; } bool NetworkManager::ActiveConnection::isValid() const { Q_D(const ActiveConnection); return !d->connection.isNull(); } NetworkManager::Connection::Ptr NetworkManager::ActiveConnection::connection() const { Q_D(const ActiveConnection); return d->connection; } QString NetworkManager::ActiveConnection::path() const { Q_D(const ActiveConnection); return d->path; } bool NetworkManager::ActiveConnection::default4() const { Q_D(const ActiveConnection); return d->default4; } bool NetworkManager::ActiveConnection::default6() const { Q_D(const ActiveConnection); return d->default6; } NetworkManager::Dhcp4Config::Ptr NetworkManager::ActiveConnection::dhcp4Config() const { Q_D(const ActiveConnection); if (!d->dhcp4Config && !d->dhcp4ConfigPath.isNull()) { d->dhcp4Config = NetworkManager::Dhcp4Config::Ptr(new Dhcp4Config(d->dhcp4ConfigPath), &QObject::deleteLater); } return d->dhcp4Config; } NetworkManager::Dhcp6Config::Ptr NetworkManager::ActiveConnection::dhcp6Config() const { Q_D(const ActiveConnection); if (!d->dhcp6Config && !d->dhcp6ConfigPath.isNull()) { d->dhcp6Config = NetworkManager::Dhcp6Config::Ptr(new Dhcp6Config(d->dhcp6ConfigPath), &QObject::deleteLater); } return d->dhcp6Config; } NetworkManager::IpConfig NetworkManager::ActiveConnection::ipV4Config() const { Q_D(const ActiveConnection); if (!d->ipV4Config.isValid() && !d->ipV4ConfigPath.isNull()) { d->ipV4Config.setIPv4Path(d->ipV4ConfigPath); } return d->ipV4Config; } NetworkManager::IpConfig NetworkManager::ActiveConnection::ipV6Config() const { Q_D(const ActiveConnection); if (!d->ipV6Config.isValid() && !d->ipV6ConfigPath.isNull()) { d->ipV6Config.setIPv6Path(d->ipV6ConfigPath); } return d->ipV6Config; } QString NetworkManager::ActiveConnection::id() const { Q_D(const ActiveConnection); return d->id; } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::ActiveConnection::type() const { Q_D(const ActiveConnection); return NetworkManager::ConnectionSettings::typeFromString(d->type); } QString NetworkManager::ActiveConnection::master() const { Q_D(const ActiveConnection); return d->master; } QString NetworkManager::ActiveConnection::specificObject() const { Q_D(const ActiveConnection); return d->specificObject; } NetworkManager::ActiveConnection::State NetworkManager::ActiveConnection::state() const { Q_D(const ActiveConnection); return d->state; } bool NetworkManager::ActiveConnection::vpn() const { Q_D(const ActiveConnection); return d->vpn; } QString NetworkManager::ActiveConnection::uuid() const { Q_D(const ActiveConnection); return d->uuid; } QStringList NetworkManager::ActiveConnection::devices() const { Q_D(const ActiveConnection); return d->devices; } void NetworkManager::ActiveConnectionPrivate::recheckProperties() { Q_Q(ActiveConnection); /* * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly * BUG:352326 */ QStringList properties; const QDBusObjectPath ip4ConfigObjectPath = iface.ip4Config(); const QDBusObjectPath ip6ConfigObjectPath = iface.ip6Config(); const QDBusObjectPath dhcp4ConfigObjectPath = iface.dhcp4Config(); const QDBusObjectPath dhcp6ConfigObjectPath = iface.dhcp6Config(); if (state != NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(iface.state())) { properties << QLatin1String("State"); } if (!ip4ConfigObjectPath.path().isNull() && ip4ConfigObjectPath.path() != ipV4ConfigPath) { properties << QLatin1String("Ip4Config"); } if (!ip6ConfigObjectPath.path().isNull() && ip6ConfigObjectPath.path() != ipV6ConfigPath) { properties << QLatin1String("Ip6Config"); } if (!dhcp4ConfigObjectPath.path().isNull() && dhcp4ConfigObjectPath.path() != dhcp4ConfigPath) { properties << QLatin1String("Dhcp4Config"); } if (!dhcp6ConfigObjectPath.path().isNull() && dhcp6ConfigObjectPath.path() != dhcp6ConfigPath) { properties << QLatin1String("Dhcp6Config"); } Q_FOREACH (const QString &property, properties) { QDBusMessage message = QDBusMessage::createMethodCall(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("Get")); message << iface.staticInterfaceName() << property; QDBusPendingCall pendingCall = QDBusConnection::systemBus().asyncCall(message); QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingCall, this); connect(watcher, &QDBusPendingCallWatcher::finished, [watcher, q, this, property] () { watcher->deleteLater(); if (property == QLatin1String("State")) { state = NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(iface.state()); Q_EMIT q->stateChanged(state); } if (property == QLatin1String("Ip4Config")) { ipV4ConfigPath = iface.ip4Config().path(); Q_EMIT q->ipV4ConfigChanged(); } else if (property == QLatin1String("Ip6Config")) { ipV6ConfigPath = iface.ip6Config().path(); Q_EMIT q->ipV6ConfigChanged(); } else if (property == QLatin1String("Dhcp4Config")) { dhcp4ConfigPath = iface.dhcp4Config().path(); Q_EMIT q->dhcp4ConfigChanged(); } else if (property == QLatin1String("Dhcp6Config")) { dhcp6ConfigPath = iface.dhcp6Config().path(); Q_EMIT q->dhcp6ConfigChanged(); } }); } } void NetworkManager::ActiveConnectionPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties) { Q_UNUSED(invalidatedProperties); if (interfaceName == QLatin1String("org.freedesktop.NetworkManager.Connection.Active")) { propertiesChanged(properties); } } void NetworkManager::ActiveConnectionPrivate::propertiesChanged(const QVariantMap &properties) { // qCDebug(NMQT) << Q_FUNC_INFO << properties; QVariantMap::const_iterator it = properties.constBegin(); while (it != properties.constEnd()) { propertyChanged(it.key(), it.value()); ++it; } } void NetworkManager::ActiveConnectionPrivate::propertyChanged(const QString &property, const QVariant &value) { Q_Q(ActiveConnection); // qCDebug(NMQT) << property << " - " << value; if (property == QLatin1String("Connection")) { connection = NetworkManager::findConnection(qdbus_cast(value).path()); Q_EMIT q->connectionChanged(connection); const QString tmpId = connection->settings()->id(); const QString tmpType = connection->settings()->typeAsString(connection->settings()->connectionType()); if (tmpId != id) { id = tmpId; Q_EMIT q->idChanged(id); } if (tmpType != type) { Q_EMIT q->typeChanged(NetworkManager::ConnectionSettings::typeFromString(type)); } } else if (property == QLatin1String("Default")) { default4 = value.toBool(); Q_EMIT q->default4Changed(default4); } else if (property == QLatin1String("Default6")) { default6 = value.toBool(); Q_EMIT q->default6Changed(default6); } else if (property == QLatin1String("Dhcp4Config")) { QDBusObjectPath dhcp4ConfigPathTmp = (value).value(); if (dhcp4ConfigPathTmp.path().isNull()) { dhcp4Config.clear(); dhcp4ConfigPath.clear(); } else if (!dhcp4Config || dhcp4Config->path() != dhcp4ConfigPathTmp.path()) { dhcp4Config.clear(); dhcp4ConfigPath = dhcp4ConfigPathTmp.path(); } Q_EMIT q->dhcp4ConfigChanged(); } else if (property == QLatin1String("Dhcp6Config")) { QDBusObjectPath dhcp6ConfigPathTmp = (value).value(); if (dhcp6ConfigPathTmp.path().isNull()) { dhcp6Config.clear(); dhcp6ConfigPath.clear(); } else if (!dhcp6Config || dhcp6Config->path() != dhcp6ConfigPathTmp.path()) { dhcp6Config.clear(); dhcp6ConfigPath = dhcp6ConfigPathTmp.path(); } Q_EMIT q->dhcp6ConfigChanged(); } else if (property == QLatin1String("Ip4Config")) { QDBusObjectPath ip4ConfigObjectPathTmp = (value).value(); if (ip4ConfigObjectPathTmp.path().isNull() || ip4ConfigObjectPathTmp.path() == QLatin1String("/")) { ipV4ConfigPath.clear(); } else { ipV4ConfigPath = ip4ConfigObjectPathTmp.path(); } ipV4Config = IpConfig(); Q_EMIT q->ipV4ConfigChanged(); } else if (property == QLatin1String("Ip6Config")) { QDBusObjectPath ip6ConfigObjectPathTmp = (value).value(); if (ip6ConfigObjectPathTmp.path().isNull() || ip6ConfigObjectPathTmp.path() == QLatin1String("/")) { ipV6ConfigPath.clear(); } else { ipV6ConfigPath = ip6ConfigObjectPathTmp.path(); } ipV6Config = IpConfig(); Q_EMIT q->ipV6ConfigChanged(); } else if (property == QLatin1String("Id")) { id = value.toString(); Q_EMIT q->idChanged(id); } else if (property == QLatin1String("Type")) { type = value.toString(); Q_EMIT q->typeChanged(NetworkManager::ConnectionSettings::typeFromString(type)); } else if (property == QLatin1String("Master")) { master = qdbus_cast(value).path(); Q_EMIT q->masterChanged(master); } else if (property == QLatin1String("SpecificObject")) { specificObject = qdbus_cast(value).path(); Q_EMIT q->specificObjectChanged(specificObject); } else if (property == QLatin1String("State")) { state = NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(value.toUInt()); Q_EMIT q->stateChanged(state); } else if (property == QLatin1String("Vpn")) { vpn = value.toBool(); Q_EMIT q->vpnChanged(vpn); } else if (property == QLatin1String("Uuid")) { uuid = value.toString(); Q_EMIT q->uuidChanged(uuid); } else if (property == QLatin1String("Devices")) { devices.clear(); Q_FOREACH (const QDBusObjectPath & path, qdbus_cast< QList >(value)) { devices.append(path.path()); } Q_EMIT q->devicesChanged(); } else { - qCWarning(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; + qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; } } diff --git a/src/device.cpp b/src/device.cpp index 5935b56..052e4f8 100644 --- a/src/device.cpp +++ b/src/device.cpp @@ -1,609 +1,609 @@ /* Copyright 2008,2010 Will Stephenson Copyright 2013 Daniel Nicoletti Copyright 2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "device_p.h" #include "manager.h" #include "manager_p.h" #include "connection.h" #include "settings.h" #include "nmdebug.h" #include #include // logging category for this framework, default: log stuff >= warning Q_LOGGING_CATEGORY(NMQT, "networkmanager-qt", QtWarningMsg) namespace NetworkManager { class DeviceStateReasonPrivate { public: DeviceStateReasonPrivate(Device::State st, Device::StateChangeReason rsn) : state(st) , reason(rsn) {} DeviceStateReasonPrivate() : state(Device::UnknownState) , reason(Device::UnknownReason) {} Device::State state; Device::StateChangeReason reason; }; } NetworkManager::DeviceStateReason::DeviceStateReason(Device::State state, Device::StateChangeReason reason) : d_ptr(new DeviceStateReasonPrivate(state, reason)) { } NetworkManager::DeviceStateReason::DeviceStateReason(const NetworkManager::DeviceStateReason &other) : d_ptr(new DeviceStateReasonPrivate(*other.d_ptr)) { } NetworkManager::DeviceStateReason::~DeviceStateReason() { delete d_ptr; } NetworkManager::Device::State NetworkManager::DeviceStateReason::state() const { Q_D(const DeviceStateReason); return d->state; } NetworkManager::Device::StateChangeReason NetworkManager::DeviceStateReason::reason() const { Q_D(const DeviceStateReason); return d->reason; } NetworkManager::DeviceStateReason &NetworkManager::DeviceStateReason::operator=(const NetworkManager::DeviceStateReason &other) { if (&other != this) { *d_ptr = *other.d_ptr; } return *this; } NetworkManager::DevicePrivate::DevicePrivate(const QString &path, NetworkManager::Device *q) #ifdef NMQT_STATIC : deviceIface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::sessionBus()) #else : deviceIface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::systemBus()) #endif , uni(path) , designSpeed(0) , dhcp4Config(nullptr) , dhcp6Config(nullptr) , mtu(0) , q_ptr(q) { } NetworkManager::DevicePrivate::~DevicePrivate() { } void NetworkManager::DevicePrivate::init() { qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); // This needs to be initialized as soon as possible, because based on this property // we initialize the device type deviceType = convertType(deviceIface.deviceType()); deviceStatistics = DeviceStatistics::Ptr(new NetworkManager::DeviceStatistics(uni), &QObject::deleteLater); // Get all Device's properties at once QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(deviceIface.staticInterfaceName(), uni); if (!initialProperties.isEmpty()) { propertiesChanged(initialProperties); } QObject::connect(&deviceIface, &OrgFreedesktopNetworkManagerDeviceInterface::StateChanged, this, &DevicePrivate::deviceStateChanged); } NetworkManager::Device::MeteredStatus NetworkManager::DevicePrivate::convertMeteredStatus(uint metered) { NetworkManager::Device::MeteredStatus ourMeteredStatus = (NetworkManager::Device::MeteredStatus) metered; return ourMeteredStatus; } NetworkManager::Device::Capabilities NetworkManager::DevicePrivate::convertCapabilities(uint theirCaps) { NetworkManager::Device::Capabilities ourCaps = (NetworkManager::Device::Capabilities) theirCaps; return ourCaps; } NetworkManager::Device::State NetworkManager::DevicePrivate::convertState(uint theirState) { NetworkManager::Device::State ourState = static_cast(theirState); return ourState; } NetworkManager::Device::StateChangeReason NetworkManager::DevicePrivate::convertReason(uint theirReason) { NetworkManager::Device::StateChangeReason ourReason = (NetworkManager::Device::StateChangeReason)theirReason; return ourReason; } NetworkManager::Device::Type NetworkManager::DevicePrivate::convertType(uint type) { // These are identical to NM enums if (type <= NM_DEVICE_TYPE_TEAM) { return (NetworkManager::Device::Type)type; } switch (type) { case 16: // NM_DEVICE_TYPE_TUN return NetworkManager::Device::Tun; case 17: // NM_DEVICE_TYPE_IP_TUNNEL return NetworkManager::Device::IpTunnel; case 18: // NM_DEVICE_TYPE_MACVLAN return NetworkManager::Device::MacVlan; case 19: // NM_DEVICE_TYPE_VXLAN return NetworkManager::Device::VxLan; case 20: // NM_DEVICE_TYPE_VETH return NetworkManager::Device::Veth; case 21: // NM_DEVICE_TYPE_MACSEC return NetworkManager::Device::MacSec; case 22: // NM_DEVICE_TYPE_DUMMY return NetworkManager::Device::Dummy; } return NetworkManager::Device::UnknownType; } NetworkManager::Device::Device(const QString &path, QObject *parent) : QObject(parent) , d_ptr(new DevicePrivate(path, this)) { Q_D(Device); d->init(); } NetworkManager::Device::Device(DevicePrivate &dd, QObject *parent) : QObject(parent) , d_ptr(&dd) { Q_D(Device); d->init(); } void NetworkManager::DevicePrivate::propertyChanged(const QString &property, const QVariant &value) { Q_Q(Device); // qCDebug(NMQT) << property << " - " << value; if (property == QLatin1String("ActiveConnection")) { // FIXME workaround, because NM doesn't Q_EMIT correct value // d->activeConnection = value.value.path(); activeConnection = deviceIface.activeConnection().path(); Q_EMIT q->activeConnectionChanged(); } else if (property == QLatin1String("Autoconnect")) { autoconnect = value.toBool(); Q_EMIT q->autoconnectChanged(); } else if (property == QLatin1String("AvailableConnections")) { QStringList newAvailableConnections; QList availableConnectionsTmp = qdbus_cast< QList >(value); Q_FOREACH (const QDBusObjectPath & availableConnection, availableConnectionsTmp) { newAvailableConnections << availableConnection.path(); if (!availableConnections.contains(availableConnection.path())) { availableConnections << availableConnection.path(); Q_EMIT q->availableConnectionAppeared(availableConnection.path()); } } Q_FOREACH (const QString & availableConnection, availableConnections) { if (!newAvailableConnections.contains(availableConnection)) { availableConnections.removeOne(availableConnection); Q_EMIT q->availableConnectionDisappeared(availableConnection); } } Q_EMIT q->availableConnectionChanged(); } else if (property == QLatin1String("Capabilities")) { capabilities = NetworkManager::DevicePrivate::convertCapabilities(value.toUInt()); Q_EMIT q->capabilitiesChanged(); } else if (property == QLatin1String("DeviceType")) { deviceType = static_cast(value.toUInt()); } else if (property == QLatin1String("Dhcp4Config")) { QDBusObjectPath dhcp4ConfigPathTmp = value.value(); if (dhcp4ConfigPathTmp.path().isNull()) { dhcp4Config.clear(); dhcp4ConfigPath.clear(); } else if (!dhcp4Config || dhcp4Config->path() != dhcp4ConfigPathTmp.path()) { dhcp4Config.clear(); dhcp4ConfigPath = dhcp4ConfigPathTmp.path(); } Q_EMIT q->dhcp4ConfigChanged(); } else if (property == QLatin1String("Dhcp6Config")) { QDBusObjectPath dhcp6ConfigPathTmp = value.value(); if (dhcp6ConfigPathTmp.path().isNull()) { dhcp6Config.clear(); dhcp6ConfigPath.clear(); } else if (!dhcp6Config || dhcp6Config->path() != dhcp6ConfigPathTmp.path()) { dhcp6Config.clear(); dhcp6ConfigPath = dhcp6ConfigPathTmp.path(); } Q_EMIT q->dhcp6ConfigChanged(); } else if (property == QLatin1String("Driver")) { driver = value.toString(); Q_EMIT q->driverChanged(); } else if (property == QLatin1String("DriverVersion")) { driverVersion = value.toString(); Q_EMIT q->driverVersionChanged(); } else if (property == QLatin1String("FirmwareMissing")) { firmwareMissing = value.toBool(); Q_EMIT q->firmwareMissingChanged(); } else if (property == QLatin1String("FirmwareVersion")) { firmwareVersion = value.toString(); Q_EMIT q->firmwareVersionChanged(); } else if (property == QLatin1String("Interface")) { interfaceName = value.toString(); Q_EMIT q->interfaceNameChanged(); } else if (property == QLatin1String("Ip4Address")) { ipV4Address = QHostAddress(ntohl(value.toUInt())); Q_EMIT q->ipV4AddressChanged(); } else if (property == QLatin1String("Ip4Config")) { QDBusObjectPath ip4ConfigObjectPathTmp = value.value(); if (ip4ConfigObjectPathTmp.path().isNull() || ip4ConfigObjectPathTmp.path() == QLatin1String("/")) { ipV4ConfigPath.clear(); } else { ipV4ConfigPath = ip4ConfigObjectPathTmp.path(); } ipV4Config = IpConfig(); Q_EMIT q->ipV4ConfigChanged(); } else if (property == QLatin1String("Ip6Config")) { QDBusObjectPath ip6ConfigObjectPathTmp = value.value(); if (ip6ConfigObjectPathTmp.path().isNull() || ip6ConfigObjectPathTmp.path() == QLatin1String("/")) { ipV6ConfigPath.clear(); } else { ipV6ConfigPath = ip6ConfigObjectPathTmp.path(); } ipV6Config = IpConfig(); Q_EMIT q->ipV6ConfigChanged(); } else if (property == QLatin1String("IpInterface")) { ipInterface = value.toString(); Q_EMIT q->ipInterfaceChanged(); } else if (property == QLatin1String("Managed")) { managed = value.toBool(); Q_EMIT q->managedChanged(); } else if (property == QLatin1String("State")) { connectionState = NetworkManager::DevicePrivate::convertState(value.toUInt()); // FIXME NetworkManager 0.9.8 (maybe greater) doesn't // update ActiveConnection when disconnected // This is fixed in NM 73d128bbd17120225bb4986e3f05566f10fab581 if (connectionState == NetworkManager::Device::Disconnected && activeConnection != QLatin1String("/")) { activeConnection = QLatin1Char('/'); Q_EMIT q->activeConnectionChanged(); } Q_EMIT q->connectionStateChanged(); } else if (property == QLatin1String("StateReason")) { // just extracting the reason reason = NetworkManager::DevicePrivate::convertReason(qdbus_cast(value).reason); Q_EMIT q->stateReasonChanged(); } else if (property == QLatin1String("Udi")) { udi = value.toString(); Q_EMIT q->udiChanged(); } else if (property == QLatin1String("PhysicalPortId")) { physicalPortId = value.toString(); Q_EMIT q->physicalPortIdChanged(); } else if (property == QLatin1String("Mtu")) { mtu = value.toUInt(); Q_EMIT q->mtuChanged(); } else if (property == QLatin1String("NmPluginMissing")) { nmPluginMissing = value.toBool(); Q_EMIT q->nmPluginMissingChanged(nmPluginMissing); } else if (property == QLatin1String("Metered")) { metered = NetworkManager::DevicePrivate::convertMeteredStatus(value.toUInt()); Q_EMIT q->meteredChanged(metered); } else { - qCWarning(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; + qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; } } NetworkManager::Device::~Device() { Q_D(Device); delete d; } QString NetworkManager::Device::uni() const { Q_D(const Device); return d->uni; } QString NetworkManager::Device::interfaceName() const { Q_D(const Device); return d->interfaceName; } QString NetworkManager::Device::ipInterfaceName() const { Q_D(const Device); return d->ipInterface; } QString NetworkManager::Device::driver() const { Q_D(const Device); return d->driver; } QString NetworkManager::Device::driverVersion() const { Q_D(const Device); return d->driverVersion; } QString NetworkManager::Device::firmwareVersion() const { Q_D(const Device); return d->firmwareVersion; } NetworkManager::ActiveConnection::Ptr NetworkManager::Device::activeConnection() const { Q_D(const Device); return NetworkManager::findActiveConnection(d->activeConnection); } NetworkManager::Connection::List NetworkManager::Device::availableConnections() { Q_D(const Device); NetworkManager::Connection::List list; Q_FOREACH (const QString & availableConnection, d->availableConnections) { NetworkManager::Connection::Ptr connection = NetworkManager::findConnection(availableConnection); if (connection) { list << connection; } } return list; } bool NetworkManager::Device::firmwareMissing() const { Q_D(const Device); return d->firmwareMissing; } bool NetworkManager::Device::autoconnect() const { Q_D(const Device); return d->autoconnect; } void NetworkManager::Device::setAutoconnect(bool autoconnect) { Q_D(Device); d->deviceIface.setAutoconnect(autoconnect); } QString NetworkManager::Device::udi() const { Q_D(const Device); return d->udi; } QString NetworkManager::Device::physicalPortId() const { Q_D(const Device); return d->physicalPortId; } QHostAddress NetworkManager::Device::ipV4Address() const { Q_D(const Device); return d->ipV4Address; } NetworkManager::DeviceStateReason NetworkManager::Device::stateReason() const { Q_D(const Device); return DeviceStateReason(d->connectionState, d->reason); } NetworkManager::IpConfig NetworkManager::Device::ipV4Config() const { Q_D(const Device); if (!d->ipV4Config.isValid() && !d->ipV4ConfigPath.isNull()) { d->ipV4Config.setIPv4Path(d->ipV4ConfigPath); } return d->ipV4Config; } NetworkManager::IpConfig NetworkManager::Device::ipV6Config() const { Q_D(const Device); if (!d->ipV6Config.isValid() && !d->ipV6ConfigPath.isNull()) { d->ipV6Config.setIPv6Path(d->ipV6ConfigPath); } return d->ipV6Config; } NetworkManager::Dhcp4Config::Ptr NetworkManager::Device::dhcp4Config() const { Q_D(const Device); if (!d->dhcp4Config && !d->dhcp4ConfigPath.isNull()) { d->dhcp4Config = NetworkManager::Dhcp4Config::Ptr(new Dhcp4Config(d->dhcp4ConfigPath), &QObject::deleteLater); } return d->dhcp4Config; } NetworkManager::Dhcp6Config::Ptr NetworkManager::Device::dhcp6Config() const { Q_D(const Device); if (!d->dhcp6Config && !d->dhcp6ConfigPath.isNull()) { d->dhcp6Config = NetworkManager::Dhcp6Config::Ptr(new Dhcp6Config(d->dhcp6ConfigPath), &QObject::deleteLater); } return d->dhcp6Config; } bool NetworkManager::Device::isActive() const { Q_D(const Device); return !(d->connectionState == NetworkManager::Device::Unavailable || d->connectionState == NetworkManager::Device::Unmanaged || d->connectionState == NetworkManager::Device::Disconnected || d->connectionState == NetworkManager::Device::Failed); } bool NetworkManager::Device::isValid() const { Q_D(const Device); return d->deviceIface.isValid(); } bool NetworkManager::Device::managed() const { Q_D(const Device); return d->managed; } uint NetworkManager::Device::mtu() const { Q_D(const Device); return d->mtu; } bool NetworkManager::Device::nmPluginMissing() const { Q_D(const Device); return d->nmPluginMissing; } NetworkManager::Device::MeteredStatus NetworkManager::Device::metered() const { Q_D(const Device); return d->metered; } QDBusPendingReply<> NetworkManager::Device::disconnectInterface() { Q_D(Device); return d->deviceIface.Disconnect(); } QDBusPendingReply<> NetworkManager::Device::deleteInterface() { if (NetworkManager::checkVersion(1, 0, 0)) { Q_D(Device); return d->deviceIface.Delete(); } else { return QDBusPendingReply<>(); } } NetworkManager::Device::State NetworkManager::Device::state() const { Q_D(const Device); return d->connectionState; } int NetworkManager::Device::designSpeed() const { Q_D(const Device); return d->designSpeed; } NetworkManager::Device::Capabilities NetworkManager::Device::capabilities() const { Q_D(const Device); return d->capabilities; } QVariant NetworkManager::Device::capabilitiesV() const { Q_D(const Device); return QVariant(d->capabilities); } NetworkManager::DeviceStatistics::Ptr NetworkManager::Device::deviceStatistics() const { Q_D(const Device); return d->deviceStatistics; } void NetworkManager::DevicePrivate::deviceStateChanged(uint newState, uint oldState, uint reason) { Q_Q(Device); connectionState = NetworkManager::DevicePrivate::convertState(newState); reason = NetworkManager::DevicePrivate::convertReason(reason); Q_EMIT q->stateChanged(connectionState, NetworkManager::DevicePrivate::convertState(oldState), NetworkManager::DevicePrivate::convertReason(reason)); } void NetworkManager::DevicePrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties) { Q_UNUSED(invalidatedProperties); if (interfaceName.contains(QLatin1String("org.freedesktop.NetworkManager.Device")) && interfaceName != QLatin1String("org.freedesktop.NetworkManager.Device.Statistics")) { propertiesChanged(properties); } } void NetworkManager::DevicePrivate::propertiesChanged(const QVariantMap &properties) { // qCDebug(NMQT) << Q_FUNC_INFO << properties; QVariantMap::const_iterator it = properties.constBegin(); while (it != properties.constEnd()) { propertyChanged(it.key(), it.value()); ++it; } // FIXME workaround, we need to get a path to updated IPv[46]Config, // because NM doesn't Q_EMIT the updated value when the device is activated // BUG: https://bugzilla.gnome.org/show_bug.cgi?id=725657 if (properties.contains(QLatin1String("State")) && connectionState == NetworkManager::Device::Activated) { propertyChanged(QLatin1String("Ip4Config"), QVariant::fromValue(deviceIface.ip4Config())); propertyChanged(QLatin1String("Ip6Config"), QVariant::fromValue(deviceIface.ip6Config())); } } NetworkManager::Device::Type NetworkManager::Device::type() const { Q_D(const Device); return d->deviceType; } diff --git a/src/manager.cpp b/src/manager.cpp index 32473aa..55401ec 100644 --- a/src/manager.cpp +++ b/src/manager.cpp @@ -1,1114 +1,1114 @@ /* Copyright 2008,2010 Will Stephenson Copyright 2011-2013 Lamarque Souza Copyright 2013 Daniel Nicoletti Copyright 2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "manager.h" #include "manager_p.h" #include "macros.h" #undef signals #include #define signals Q_SIGNALS #include "activeconnection.h" #include "adsldevice.h" #include "bluetoothdevice.h" #include "bonddevice.h" #include "bridgedevice.h" #include "infinibanddevice.h" #include "iptunneldevice.h" #include "genericdevice.h" #include "modemdevice.h" #include "olpcmeshdevice.h" #include "settings.h" #include "settings_p.h" #include "vpnconnection.h" #include "vlandevice.h" #include "wireddevice.h" #include "wirelessdevice.h" #include "wimaxdevice.h" #include "gredevice.h" #include "macvlandevice.h" #include "tundevice.h" #include "vethdevice.h" #include "nmdebug.h" #define DBUS_PROPERTIES "org.freedesktop.DBus.Properties" #ifdef NMQT_STATIC const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1("org.kde.fakenetwork")); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1("/org/kde/fakenetwork")); const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1("/org/kde/fakenetwork/Settings")); #else const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1(NM_DBUS_SERVICE)); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1(NM_DBUS_PATH)); const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1(NM_DBUS_PATH_SETTINGS)); #endif const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES(QString::fromLatin1(DBUS_PROPERTIES)); Q_GLOBAL_STATIC(NetworkManager::NetworkManagerPrivate, globalNetworkManager) NetworkManager::NetworkManagerPrivate::NetworkManagerPrivate() #ifdef NMQT_STATIC : watcher(DBUS_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this) , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::sessionBus()) #else : watcher(DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForOwnerChange, this) , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::systemBus()) #endif , nmState(NetworkManager::Unknown) , m_connectivity(NetworkManager::UnknownConnectivity) , m_isNetworkingEnabled(false) , m_isWimaxEnabled(false) , m_isWimaxHardwareEnabled(false) , m_isWirelessEnabled(false) , m_isWirelessHardwareEnabled(false) , m_isWwanEnabled(false) , m_isWwanHardwareEnabled(false) , m_supportedInterfaceTypes(NetworkManager::Device::UnknownType) { connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceAdded, this, &NetworkManagerPrivate::onDeviceAdded); connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceRemoved, this, &NetworkManagerPrivate::onDeviceRemoved); #ifndef NMQT_STATIC #if NM_CHECK_VERSION(1, 4, 0) QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, NetworkManagerPrivate::DBUS_DAEMON_PATH, NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("PropertiesChanged"), this, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList))); #else connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged); #endif #endif #ifdef NMQT_STATIC connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged); #endif connect(&watcher, &QDBusServiceWatcher::serviceRegistered, this, &NetworkManagerPrivate::daemonRegistered); connect(&watcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManagerPrivate::daemonUnregistered); init(); } void NetworkManager::NetworkManagerPrivate::parseVersion(const QString &version) { const QStringList sl = version.split('.'); if (sl.size() > 2) { m_x = sl[0].toInt(); m_y = sl[1].toInt(); m_z = sl[2].toInt(); } else { m_x = -1; m_y = -1; m_z = -1; } } void NetworkManager::NetworkManagerPrivate::init() { qDBusRegisterMetaType(); qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); qDBusRegisterMetaType >(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); m_version = iface.version(); parseVersion(m_version); m_supportedInterfaceTypes = static_cast( NetworkManager::Device::Ethernet | NetworkManager::Device::Wifi | NetworkManager::Device::Modem | (checkVersion(1, 2, 0) ? 0 : NetworkManager::Device::Wimax) | NetworkManager::Device::Bluetooth | NetworkManager::Device::OlpcMesh | NetworkManager::Device::InfiniBand | NetworkManager::Device::Bond | NetworkManager::Device::Vlan | NetworkManager::Device::Adsl | NetworkManager::Device::Bridge | NetworkManager::Device::Generic | NetworkManager::Device::Team | NetworkManager::Device::MacVlan | NetworkManager::Device::Tun | NetworkManager::Device::Veth | NetworkManager::Device::IpTunnel ); // Get all Manager's properties async QVariantMap initialProperties = retrieveInitialProperties(iface.staticInterfaceName(), DBUS_DAEMON_PATH); if (!initialProperties.isEmpty()) { propertiesChanged(initialProperties); } QTimer::singleShot(0, [] { qobject_cast(settingsNotifier())->init(); }); if (iface.isValid()) { QList devices = iface.devices(); qCDebug(NMQT) << "Device list"; Q_FOREACH (const QDBusObjectPath & op, devices) { networkInterfaceMap.insert(op.path(), Device::Ptr()); Q_EMIT deviceAdded(op.path()); qCDebug(NMQT) << " " << op.path(); } } } NetworkManager::NetworkManagerPrivate::~NetworkManagerPrivate() { } QString NetworkManager::NetworkManagerPrivate::version() const { return m_version; } int NetworkManager::NetworkManagerPrivate::compareVersion(const QString &version) { int x, y, z; const auto sl = version.splitRef('.'); if (sl.size() > 2) { x = sl[0].toInt(); y = sl[1].toInt(); z = sl[2].toInt(); } else { x = -1; y = -1; z = -1; } return compareVersion(x, y, z); } int NetworkManager::NetworkManagerPrivate::compareVersion(const int x, const int y, const int z) const { if (m_x > x) { return 1; } else if (m_x < x) { return -1; } else if (m_y > y) { return 1; } else if (m_y < y) { return -1; } else if (m_z > z) { return 1; } else if (m_z < z) { return -1; } return 0; } bool NetworkManager::NetworkManagerPrivate::checkVersion(const int x, const int y, const int z) const { return 0 <= compareVersion(x, y, z); } NetworkManager::Device::Types NetworkManager::NetworkManagerPrivate::supportedInterfaceTypes() const { return m_supportedInterfaceTypes; } QVariantMap NetworkManager::NetworkManagerPrivate::retrieveInitialProperties(const QString &interfaceName, const QString &path) { QDBusMessage message = QDBusMessage::createMethodCall(DBUS_SERVICE, path, FDO_DBUS_PROPERTIES, QLatin1String("GetAll")); message << interfaceName; #ifdef NMQT_STATIC QDBusMessage resultMessage = QDBusConnection::sessionBus().call(message); #else QDBusMessage resultMessage = QDBusConnection::systemBus().call(message); #endif if (resultMessage.type() == QDBusMessage::ReplyMessage) { QVariantMap result; QDBusArgument dbusArgument = resultMessage.arguments().at(0).value(); while (!dbusArgument.atEnd()) { dbusArgument >> result; } return result; } return QVariantMap(); } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni) { NetworkManager::Device::Ptr networkInterface; auto it = networkInterfaceMap.constFind(uni); if (it != networkInterfaceMap.constEnd()) { if (*it) { networkInterface = *it; } else { networkInterface = createNetworkInterface(uni); networkInterfaceMap[uni] = networkInterface; } } return networkInterface; } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredActiveConnection(const QString &uni) { NetworkManager::ActiveConnection::Ptr activeConnection; if (!uni.isEmpty() && uni != QLatin1String("/")) { const auto it = m_activeConnections.constFind(uni); const bool contains = it != m_activeConnections.constEnd(); if (contains && *it) { activeConnection = *it; } else { activeConnection = NetworkManager::ActiveConnection::Ptr(new NetworkManager::VpnConnection(uni), &QObject::deleteLater); if (activeConnection->connection()) { m_activeConnections[uni] = activeConnection; if (!contains) { Q_EMIT activeConnectionAdded(uni); } } else { activeConnection.clear(); } } } return activeConnection; } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::createNetworkInterface(const QString &uni) { //qCDebug(NMQT); Device::Ptr createdInterface; Device::Ptr device(new Device(uni)); switch (device->type()) { case Device::Ethernet: createdInterface = Device::Ptr(new NetworkManager::WiredDevice(uni), &QObject::deleteLater); break; case Device::Wifi: createdInterface = Device::Ptr(new NetworkManager::WirelessDevice(uni), &QObject::deleteLater); break; case Device::Modem: createdInterface = Device::Ptr(new NetworkManager::ModemDevice(uni), &QObject::deleteLater); break; case Device::Bluetooth: createdInterface = Device::Ptr(new NetworkManager::BluetoothDevice(uni), &QObject::deleteLater); break; case Device::Wimax: createdInterface = Device::Ptr(new NetworkManager::WimaxDevice(uni), &QObject::deleteLater); break; case Device::OlpcMesh: createdInterface = Device::Ptr(new NetworkManager::OlpcMeshDevice(uni), &QObject::deleteLater); break; case Device::InfiniBand: createdInterface = Device::Ptr(new NetworkManager::InfinibandDevice(uni), &QObject::deleteLater); break; case Device::Bond: createdInterface = Device::Ptr(new NetworkManager::BondDevice(uni), &QObject::deleteLater); break; case Device::Vlan: createdInterface = Device::Ptr(new NetworkManager::VlanDevice(uni), &QObject::deleteLater); break; case Device::Adsl: createdInterface = Device::Ptr(new NetworkManager::AdslDevice(uni), &QObject::deleteLater); break; case Device::Bridge: createdInterface = Device::Ptr(new NetworkManager::BridgeDevice(uni), &QObject::deleteLater); break; //No need to check checkVersion, because we can't get Generic, Gre, MacVlan, Tun & Veth values in incompatible runtime case Device::Generic: createdInterface = Device::Ptr(new NetworkManager::GenericDevice(uni), &QObject::deleteLater); break; case Device::Gre: createdInterface = Device::Ptr(new NetworkManager::GreDevice(uni), &QObject::deleteLater); break; case Device::MacVlan: createdInterface = Device::Ptr(new NetworkManager::MacVlanDevice(uni), &QObject::deleteLater); break; case Device::Tun: createdInterface = Device::Ptr(new NetworkManager::TunDevice(uni), &QObject::deleteLater); break; case Device::Veth: createdInterface = Device::Ptr(new NetworkManager::VethDevice(uni), &QObject::deleteLater); break; case Device::IpTunnel: createdInterface = Device::Ptr(new NetworkManager::IpTunnelDevice(uni), &QObject::deleteLater); break; default: createdInterface = device; if (uni != QLatin1String("any")) { // VPN connections use "any" as uni for the network interface. qCDebug(NMQT) << "Can't create device of type " << device->type() << "for" << uni; } break; } return createdInterface; } NetworkManager::Status NetworkManager::NetworkManagerPrivate::status() const { return nmState; } NetworkManager::Device::List NetworkManager::NetworkManagerPrivate::networkInterfaces() { Device::List list; QMap::const_iterator i; for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key()); if (!networkInterface.isNull()) { list.append(networkInterface); } else { qCWarning(NMQT) << "warning: null network Interface for" << i.key(); } } return list; } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findDeviceByIpIface(const QString &iface) { QMap::const_iterator i; for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key()); if (networkInterface && networkInterface->udi() == iface) { return networkInterface; } } return Device::Ptr(); } bool NetworkManager::NetworkManagerPrivate::isNetworkingEnabled() const { return m_isNetworkingEnabled; } bool NetworkManager::NetworkManagerPrivate::isWirelessEnabled() const { return m_isWirelessEnabled; } bool NetworkManager::NetworkManagerPrivate::isWirelessHardwareEnabled() const { return m_isWirelessHardwareEnabled; } bool NetworkManager::NetworkManagerPrivate::isWwanEnabled() const { return m_isWwanEnabled; } bool NetworkManager::NetworkManagerPrivate::isWwanHardwareEnabled() const { return m_isWwanHardwareEnabled; } bool NetworkManager::NetworkManagerPrivate::isWimaxEnabled() const { return checkVersion(1, 2, 0) ? false : m_isWimaxEnabled; } bool NetworkManager::NetworkManagerPrivate::isWimaxHardwareEnabled() const { return checkVersion(1, 2, 0) ? false : m_isWimaxHardwareEnabled; } QDBusPendingReply NetworkManager::NetworkManagerPrivate::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) { QString extra_connection_parameter = connectionParameter; QString extra_interface_parameter = interfaceUni; if (extra_connection_parameter.isEmpty()) { extra_connection_parameter = QLatin1String("/"); } if (extra_interface_parameter.isEmpty()) { extra_interface_parameter = QLatin1String("/"); } // TODO store error code QDBusObjectPath connPath(connectionUni); QDBusObjectPath interfacePath(interfaceUni); // qCDebug(NMQT) << "Activating connection" << connPath.path() << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter; return iface.ActivateConnection(connPath, QDBusObjectPath(extra_interface_parameter), QDBusObjectPath(extra_connection_parameter)); } QDBusPendingReply NetworkManager::NetworkManagerPrivate::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter) { QString extra_connection_parameter = connectionParameter; if (extra_connection_parameter.isEmpty()) { extra_connection_parameter = QLatin1String("/"); } // TODO store error code QDBusObjectPath interfacePath(interfaceUni); return iface.AddAndActivateConnection(connection, interfacePath, QDBusObjectPath(extra_connection_parameter)); } QDBusPendingReply<> NetworkManager::NetworkManagerPrivate::deactivateConnection(const QString &activeConnectionPath) { return iface.DeactivateConnection(QDBusObjectPath(activeConnectionPath)); } void NetworkManager::NetworkManagerPrivate::setNetworkingEnabled(bool enabled) { iface.Enable(enabled); } void NetworkManager::NetworkManagerPrivate::setWirelessEnabled(bool enabled) { iface.setWirelessEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::setWwanEnabled(bool enabled) { iface.setWwanEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::setWimaxEnabled(bool enabled) { if (!checkVersion(1, 2, 0)) iface.setWimaxEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::sleep(bool sleep) { iface.Sleep(sleep); } void NetworkManager::NetworkManagerPrivate::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) { QString logLevel; QStringList logDomains; switch (level) { case NetworkManager::Error: logLevel = QLatin1String("ERR"); break; case NetworkManager::Warning: logLevel = QLatin1String("WARN"); break; case NetworkManager::Info: logLevel = QLatin1String("INFO"); break; case NetworkManager::Debug: logLevel = QLatin1String("DEBUG"); break; case NetworkManager::Trace: logLevel = QLatin1String("TRACE"); break; } if (!domains.testFlag(NoChange)) { if (domains.testFlag(NetworkManager::None)) { logDomains << QLatin1String("NONE"); } if (domains.testFlag(NetworkManager::Hardware)) { logDomains << QLatin1String("PLATFORM"); } if (domains.testFlag(NetworkManager::RFKill)) { logDomains << QLatin1String("RFKILL"); } if (domains.testFlag(NetworkManager::Ethernet)) { logDomains << QLatin1String("ETHER"); } if (domains.testFlag(NetworkManager::WiFi)) { logDomains << QLatin1String("WIFI"); } if (domains.testFlag(NetworkManager::Bluetooth)) { logDomains << QLatin1String("BT"); } if (domains.testFlag(NetworkManager::MobileBroadBand)) { logDomains << QLatin1String("MB"); } if (domains.testFlag(NetworkManager::DHCP4)) { logDomains << QLatin1String("DHCP4"); } if (domains.testFlag(NetworkManager::DHCP6)) { logDomains << QLatin1String("DHCP6"); } if (domains.testFlag(NetworkManager::PPP)) { logDomains << QLatin1String("PPP"); } if (domains.testFlag(NetworkManager::WiFiScan)) { logDomains << QLatin1String("WIFI_SCAN"); } if (domains.testFlag(NetworkManager::IPv4)) { logDomains << QLatin1String("IP4"); } if (domains.testFlag(NetworkManager::IPv6)) { logDomains << QLatin1String("IP6"); } if (domains.testFlag(NetworkManager::AutoIPv4)) { logDomains << QLatin1String("AUTOIP4"); } if (domains.testFlag(NetworkManager::DNS)) { logDomains << QLatin1String("DNS"); } if (domains.testFlag(NetworkManager::VPN)) { logDomains << QLatin1String("VPN"); } if (domains.testFlag(NetworkManager::Sharing)) { logDomains << QLatin1String("SHARING"); } if (domains.testFlag(NetworkManager::Supplicant)) { logDomains << QLatin1String("SUPPLICANT"); } if (domains.testFlag(NetworkManager::UserSet)) { logDomains << QLatin1String("USER_SET"); } if (domains.testFlag(NetworkManager::SysSet)) { logDomains << QLatin1String("SYS_SET"); } if (domains.testFlag(NetworkManager::Suspend)) { logDomains << QLatin1String("SUSPEND"); } if (domains.testFlag(NetworkManager::Core)) { logDomains << QLatin1String("CORE"); } if (domains.testFlag(NetworkManager::Devices)) { logDomains << QLatin1String("DEVICE"); } if (domains.testFlag(NetworkManager::OLPC)) { logDomains << QLatin1String("OLPC"); } if (domains.testFlag(NetworkManager::Wimax)) { logDomains << QLatin1String("WIMAX"); } if (domains.testFlag(NetworkManager::Infiniband)) { logDomains << QLatin1String("INFINIBAND"); } if (domains.testFlag(NetworkManager::Firewall)) { logDomains << QLatin1String("FIREWALL"); } if (domains.testFlag(NetworkManager::Adsl)) { logDomains << QLatin1String("ADSL"); } if (domains.testFlag(NetworkManager::Bond)) { logDomains << QLatin1String("BOND"); } if (domains.testFlag(NetworkManager::Vlan)) { logDomains << QLatin1String("VLAN"); } if (domains.testFlag(NetworkManager::Agents)) { logDomains << QLatin1String("AGENTS"); } if (domains.testFlag(NetworkManager::Settings)) { logDomains << QLatin1String("SETTINGS"); } if (domains.testFlag(NetworkManager::DbusProps)) { logDomains << QLatin1String("DBUS_PROPS"); } if (domains.testFlag(NetworkManager::Team)) { logDomains << QLatin1String("TEAM"); } if (domains.testFlag(NetworkManager::ConCheck)) { logDomains << QLatin1String("CONCHECK"); } if (domains.testFlag(NetworkManager::Dcb)) { logDomains << QLatin1String("DCB"); } if (domains.testFlag(NetworkManager::Dispatch)) { logDomains << QLatin1String("DISPATCH"); } } iface.SetLogging(logLevel, logDomains.join(QLatin1String(","))); } NMStringMap NetworkManager::NetworkManagerPrivate::permissions() { return iface.GetPermissions(); } NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::connectivity() const { return m_connectivity; } QDBusPendingReply NetworkManager::NetworkManagerPrivate::checkConnectivity() { return iface.CheckConnectivity(); } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::primaryConnection() { return findRegisteredActiveConnection(m_primaryConnection); } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::activatingConnection() { return findRegisteredActiveConnection(m_activatingConnection); } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::NetworkManagerPrivate::primaryConnectionType() { return checkVersion(1, 0, 0) ? m_primaryConnectionType : NetworkManager::ConnectionSettings::Unknown; } bool NetworkManager::NetworkManagerPrivate::isStartingUp() const { return iface.startup(); } NetworkManager::Device::MeteredStatus NetworkManager::NetworkManagerPrivate::metered() const { return checkVersion(1, 0, 6) ? m_metered : NetworkManager::Device::UnknownStatus; } void NetworkManager::NetworkManagerPrivate::onDeviceAdded(const QDBusObjectPath &objpath) { // qCDebug(NMQT); if (!networkInterfaceMap.contains(objpath.path())) { networkInterfaceMap.insert(objpath.path(), Device::Ptr()); Q_EMIT deviceAdded(objpath.path()); } } void NetworkManager::NetworkManagerPrivate::onDeviceRemoved(const QDBusObjectPath &objpath) { // qCDebug(NMQT); networkInterfaceMap.remove(objpath.path()); Q_EMIT deviceRemoved(objpath.path()); } void NetworkManager::NetworkManagerPrivate::connectivityChanged(uint connectivity) { NetworkManager::Connectivity newConnectivity = convertConnectivity(connectivity); if (m_connectivity != newConnectivity) { m_connectivity = newConnectivity; Q_EMIT Notifier::connectivityChanged(newConnectivity); } } void NetworkManager::NetworkManagerPrivate::stateChanged(uint state) { NetworkManager::Status newStatus = convertNMState(state); if (nmState != newStatus) { nmState = newStatus; Q_EMIT Notifier::statusChanged(newStatus); } } void NetworkManager::NetworkManagerPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties) { Q_UNUSED(invalidatedProperties); if (interfaceName == QLatin1String("org.freedesktop.NetworkManager")) { propertiesChanged(properties); } } void NetworkManager::NetworkManagerPrivate::propertiesChanged(const QVariantMap &changedProperties) { // qCDebug(NMQT) << Q_FUNC_INFO << changedProperties; QVariantMap::const_iterator it = changedProperties.constBegin(); while (it != changedProperties.constEnd()) { const QString property = it.key(); if (property == QLatin1String("ActiveConnections")) { QList activePaths = qdbus_cast< QList >(*it); if (activePaths.isEmpty()) { QMap::const_iterator it = m_activeConnections.constBegin(); while (it != m_activeConnections.constEnd()) { Q_EMIT activeConnectionRemoved(it.key()); ++it; } m_activeConnections.clear(); } else { QStringList knownConnections = m_activeConnections.keys(); Q_FOREACH (const QDBusObjectPath & ac, activePaths) { if (!m_activeConnections.contains(ac.path())) { m_activeConnections.insert(ac.path(), NetworkManager::ActiveConnection::Ptr()); Q_EMIT activeConnectionAdded(ac.path()); } else { knownConnections.removeOne(ac.path()); } // qCDebug(NMQT) << " " << ac.path(); } Q_FOREACH (const QString & path, knownConnections) { m_activeConnections.remove(path); Q_EMIT activeConnectionRemoved(path); } } Q_EMIT activeConnectionsChanged(); } else if (property == QLatin1String("NetworkingEnabled")) { m_isNetworkingEnabled = it->toBool(); qCDebug(NMQT) << property << m_isNetworkingEnabled; Q_EMIT networkingEnabledChanged(m_isNetworkingEnabled); } else if (property == QLatin1String("WirelessHardwareEnabled")) { m_isWirelessHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWirelessHardwareEnabled; Q_EMIT wirelessHardwareEnabledChanged(m_isWirelessHardwareEnabled); } else if (property == QLatin1String("WirelessEnabled")) { m_isWirelessEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWirelessEnabled; Q_EMIT wirelessEnabledChanged(m_isWirelessEnabled); } else if (property == QLatin1String("WwanHardwareEnabled")) { m_isWwanHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWwanHardwareEnabled; Q_EMIT wwanHardwareEnabledChanged(m_isWwanHardwareEnabled); } else if (property == QLatin1String("WwanEnabled")) { m_isWwanEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWwanEnabled; Q_EMIT wwanEnabledChanged(m_isWwanEnabled); } else if (property == QLatin1String("WimaxHardwareEnabled")) { m_isWimaxHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWimaxHardwareEnabled; Q_EMIT wimaxHardwareEnabledChanged(m_isWimaxHardwareEnabled); } else if (property == QLatin1String("WimaxEnabled")) { m_isWimaxEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWimaxEnabled; Q_EMIT wimaxEnabledChanged(m_isWimaxEnabled); } else if (property == QLatin1String("Version")) { m_version = it->toString(); parseVersion(m_version); } else if (property == QLatin1String("State")) { stateChanged(it->toUInt()); } else if (property == QLatin1String("Connectivity")) { connectivityChanged(it->toUInt()); } else if (property == QLatin1String("PrimaryConnection")) { m_primaryConnection = it->value().path(); Q_EMIT primaryConnectionChanged(m_primaryConnection); } else if (property == QLatin1String("ActivatingConnection")) { m_activatingConnection = it->value().path(); Q_EMIT activatingConnectionChanged(m_activatingConnection); } else if (property == QLatin1String("PrimaryConnectionType")) { m_primaryConnectionType = NetworkManager::ConnectionSettings::typeFromString(it->toString()); Q_EMIT primaryConnectionTypeChanged(m_primaryConnectionType); } else if (property == QLatin1String("Startup")) { Q_EMIT isStartingUpChanged(); } else if (property == QLatin1String("Metered")) { m_metered = (NetworkManager::Device::MeteredStatus)it->toUInt(); Q_EMIT meteredChanged(m_metered); } else { - qCWarning(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; + qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; } ++it; } } NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::convertConnectivity(uint connectivity) { NetworkManager::Connectivity convertedConnectivity = NetworkManager::UnknownConnectivity; switch (connectivity) { case NM_CONNECTIVITY_UNKNOWN: convertedConnectivity = NetworkManager::UnknownConnectivity; break; case NM_CONNECTIVITY_NONE: convertedConnectivity = NetworkManager::NoConnectivity; break; case NM_CONNECTIVITY_PORTAL: convertedConnectivity = NetworkManager::Portal; break; case NM_CONNECTIVITY_LIMITED: convertedConnectivity = NetworkManager::Limited; break; case NM_CONNECTIVITY_FULL: convertedConnectivity = NetworkManager::Full; break; } return convertedConnectivity; } NetworkManager::Status NetworkManager::NetworkManagerPrivate::convertNMState(uint state) { NetworkManager::Status status = NetworkManager::Unknown; switch (state) { case NM_STATE_UNKNOWN: status = NetworkManager::Unknown; break; case NM_STATE_ASLEEP: status = NetworkManager::Asleep; break; case NM_STATE_DISCONNECTED: status = NetworkManager::Disconnected; break; case NM_STATE_DISCONNECTING: status = NetworkManager::Disconnecting; break; case NM_STATE_CONNECTING: status = NetworkManager::Connecting; break; case NM_STATE_CONNECTED_LOCAL: status = NetworkManager::ConnectedLinkLocal; break; case NM_STATE_CONNECTED_SITE: status = NetworkManager::ConnectedSiteOnly; break; case NM_STATE_CONNECTED_GLOBAL: status = NetworkManager::Connected; break; } return status; } void NetworkManager::NetworkManagerPrivate::daemonRegistered() { init(); Q_EMIT serviceAppeared(); } void NetworkManager::NetworkManagerPrivate::daemonUnregistered() { stateChanged(NM_STATE_UNKNOWN); QMap::const_iterator i = networkInterfaceMap.constBegin(); while (i != networkInterfaceMap.constEnd()) { Q_EMIT deviceRemoved(i.key()); ++i; } networkInterfaceMap.clear(); QMap::const_iterator it = m_activeConnections.constBegin(); while (it != m_activeConnections.constEnd()) { Q_EMIT activeConnectionRemoved(it.key()); ++it; } m_activeConnections.clear(); qobject_cast(settingsNotifier())->daemonUnregistered(); Q_EMIT activeConnectionsChanged(); Q_EMIT serviceDisappeared(); } NetworkManager::ActiveConnection::List NetworkManager::NetworkManagerPrivate::activeConnections() { NetworkManager::ActiveConnection::List list; // We do not use const_iterator here because // findRegisteredActiveConnection() changes m_activeConnections. foreach (const QString &key, m_activeConnections.keys()) { NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(key); if (activeConnection) { list << activeConnection; } } return list; } QStringList NetworkManager::NetworkManagerPrivate::activeConnectionsPaths() const { return m_activeConnections.keys(); } QDBusPendingReply< QString, QString > NetworkManager::NetworkManagerPrivate::getLogging() { return iface.GetLogging(); } QString NetworkManager::version() { return globalNetworkManager->version(); } int NetworkManager::compareVersion(const QString &version) { return globalNetworkManager->compareVersion(version); } int NetworkManager::compareVersion(const int x, const int y, const int z) { return globalNetworkManager->compareVersion(x, y, z); } bool NetworkManager::checkVersion(const int x, const int y, const int z) { return globalNetworkManager->checkVersion(x, y, z); } NetworkManager::Status NetworkManager::status() { return globalNetworkManager->status(); } NetworkManager::ActiveConnection::List NetworkManager::activeConnections() { return globalNetworkManager->activeConnections(); } QStringList NetworkManager::activeConnectionsPaths() { return globalNetworkManager->activeConnectionsPaths(); } NetworkManager::ActiveConnection::Ptr NetworkManager::findActiveConnection(const QString &uni) { return globalNetworkManager->findRegisteredActiveConnection(uni); } NetworkManager::Device::List NetworkManager::networkInterfaces() { return globalNetworkManager->networkInterfaces(); } bool NetworkManager::isNetworkingEnabled() { return globalNetworkManager->isNetworkingEnabled(); } bool NetworkManager::isWirelessEnabled() { return globalNetworkManager->isWirelessEnabled(); } bool NetworkManager::isWirelessHardwareEnabled() { return globalNetworkManager->isWirelessHardwareEnabled(); } NetworkManager::Device::Ptr NetworkManager::findNetworkInterface(const QString &uni) { return globalNetworkManager->findRegisteredNetworkInterface(uni); } NetworkManager::Device::Ptr NetworkManager::findDeviceByIpFace(const QString &iface) { return globalNetworkManager->findDeviceByIpIface(iface); } QDBusPendingReply NetworkManager::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter) { return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter); } QDBusPendingReply NetworkManager::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) { return globalNetworkManager->activateConnection(connectionUni, interfaceUni, connectionParameter); } QDBusPendingReply<> NetworkManager::deactivateConnection(const QString &activeConnectionPath) { return globalNetworkManager->deactivateConnection(activeConnectionPath); } QDBusPendingReply< QString, QString > NetworkManager::getLogging() { return globalNetworkManager->getLogging(); } void NetworkManager::setNetworkingEnabled(bool enabled) { globalNetworkManager->setNetworkingEnabled(enabled); } void NetworkManager::setWirelessEnabled(bool enabled) { globalNetworkManager->setWirelessEnabled(enabled); } bool NetworkManager::isWwanEnabled() { return globalNetworkManager->isWwanEnabled(); } bool NetworkManager::isWwanHardwareEnabled() { return globalNetworkManager->isWwanHardwareEnabled(); } void NetworkManager::setWwanEnabled(bool enabled) { globalNetworkManager->setWwanEnabled(enabled); } bool NetworkManager::isWimaxEnabled() { return globalNetworkManager->isWimaxEnabled(); } bool NetworkManager::isWimaxHardwareEnabled() { return globalNetworkManager->isWimaxHardwareEnabled(); } void NetworkManager::setWimaxEnabled(bool enabled) { globalNetworkManager->setWimaxEnabled(enabled); } void NetworkManager::sleep(bool sleep) { globalNetworkManager->sleep(sleep); } void NetworkManager::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) { globalNetworkManager->setLogging(level, domains); } NMStringMap NetworkManager::permissions() { return globalNetworkManager->permissions(); } NetworkManager::Device::Types NetworkManager::supportedInterfaceTypes() { return globalNetworkManager->supportedInterfaceTypes(); } NetworkManager::Connectivity NetworkManager::connectivity() { return globalNetworkManager->connectivity(); } QDBusPendingReply NetworkManager::checkConnectivity() { return globalNetworkManager->checkConnectivity(); } NetworkManager::ActiveConnection::Ptr NetworkManager::primaryConnection() { return globalNetworkManager->primaryConnection(); } NetworkManager::ActiveConnection::Ptr NetworkManager::activatingConnection() { return globalNetworkManager->activatingConnection(); } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::primaryConnectionType() { return globalNetworkManager->primaryConnectionType(); } bool NetworkManager::isStartingUp() { return globalNetworkManager->isStartingUp(); } NetworkManager::Device::MeteredStatus NetworkManager::metered() { return globalNetworkManager->metered(); } NetworkManager::Notifier *NetworkManager::notifier() { return globalNetworkManager; }