diff --git a/autotests/managertest.cpp b/autotests/managertest.cpp index 6cc2429..0759a77 100644 --- a/autotests/managertest.cpp +++ b/autotests/managertest.cpp @@ -1,150 +1,170 @@ /* Copyright 2014 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 "managertest.h" #include "manager.h" #include "wireddevice.h" #include "fakenetwork/wireddevice.h" #include #include #include void ManagerTest::initTestCase() { fakeNetwork = new FakeNetwork(); } void ManagerTest::testDevices() { WiredDevice *device = new WiredDevice(); /* Device properties */ device->setAutoconnect(true); device->setCapabilities(3); device->setDeviceType(1); device->setDriver(QLatin1Literal("e1000e")); device->setDriverVersion(QLatin1Literal("2.3.2-k")); device->setFirmwareMissing(false); device->setFirmwareVersion(QLatin1Literal("0.13-3")); device->setInterface(QLatin1Literal("em1")); device->setManaged(true); device->setUdi(QLatin1Literal("/sys/devices/pci0000:00/0000:00:19.0/net/em1")); /* Wired device properties */ device->setCarrier(true); device->setHwAddress(QLatin1Literal("F0:DE:F1:FB:30:C1")); device->setPermanentHwAddress(QLatin1Literal("F0:DE:F1:FB:30:C1")); QSignalSpy addDeviceSpy(NetworkManager::notifier(), SIGNAL(deviceAdded(QString))); connect(NetworkManager::notifier(), &NetworkManager::Notifier::deviceAdded, this, &ManagerTest::testDeviceAdded); fakeNetwork->addDevice(device); QVERIFY(addDeviceSpy.wait()); QCOMPARE(NetworkManager::networkInterfaces().count(), 1); QCOMPARE(NetworkManager::networkInterfaces().first()->uni(), addDeviceSpy.at(0).at(0).toString()); const QString addedDevicePath = NetworkManager::networkInterfaces().first()->uni(); QSignalSpy removeDeviceSpy(NetworkManager::notifier(), SIGNAL(deviceRemoved(QString))); fakeNetwork->removeDevice(device); QVERIFY(removeDeviceSpy.wait()); QVERIFY(NetworkManager::networkInterfaces().isEmpty()); QCOMPARE(removeDeviceSpy.at(0).at(0).toString(), addedDevicePath); + addDeviceSpy.clear(); + + fakeNetwork->addDevice(device); + QVERIFY(addDeviceSpy.wait()); + QCOMPARE(NetworkManager::networkInterfaces().count(), 1); + QCOMPARE(NetworkManager::networkInterfaces().first()->uni(), addDeviceSpy.at(0).at(0).toString()); + + addDeviceSpy.clear(); + removeDeviceSpy.clear(); + + fakeNetwork->unregisterService(); + QTRY_COMPARE(removeDeviceSpy.count(), 1); + + fakeNetwork->registerService(); + QTRY_COMPARE(addDeviceSpy.count(), 1); + + // Make sure deviceAdded is emitted only once + addDeviceSpy.wait(100); + QCOMPARE(addDeviceSpy.count(), 1); + delete device; } void ManagerTest::testDeviceAdded(const QString &dev) { NetworkManager::Device::Ptr device = NetworkManager::findNetworkInterface(dev); QCOMPARE(device->autoconnect(), true); QCOMPARE(device->capabilities(), 3); QCOMPARE(device->type(), NetworkManager::Device::Ethernet); QCOMPARE(device->driver(), QLatin1Literal("e1000e")); QCOMPARE(device->driverVersion(), QLatin1Literal("2.3.2-k")); QCOMPARE(device->firmwareMissing(), false); QCOMPARE(device->firmwareVersion(), QLatin1Literal("0.13-3")); QCOMPARE(device->interfaceName(), QLatin1Literal("em1")); QCOMPARE(device->managed(), true); QCOMPARE(device->udi(), QLatin1Literal("/sys/devices/pci0000:00/0000:00:19.0/net/em1")); NetworkManager::WiredDevice::Ptr wiredDevice = device.objectCast(); QCOMPARE(wiredDevice->carrier(), true); QCOMPARE(wiredDevice->hardwareAddress(), QLatin1Literal("F0:DE:F1:FB:30:C1")); QCOMPARE(wiredDevice->permanentHardwareAddress(), QLatin1Literal("F0:DE:F1:FB:30:C1")); } void ManagerTest::testManager() { QCOMPARE(NetworkManager::connectivity(), NetworkManager::NoConnectivity); // QCOMPARE(NetworkManager::status(), NetworkManager::Disconnected); QCOMPARE(NetworkManager::version(), QLatin1Literal("0.9.10.0")); QSignalSpy wirelessEnabledChanged(NetworkManager::notifier(), SIGNAL(wirelessEnabledChanged(bool))); QCOMPARE(NetworkManager::isWirelessEnabled(), true); fakeNetwork->setWirelessEnabled(false); QVERIFY(wirelessEnabledChanged.wait()); QCOMPARE(wirelessEnabledChanged.count(), 1); QVERIFY(wirelessEnabledChanged.at(0).at(0).toBool() == false); QCOMPARE(NetworkManager::isWirelessEnabled(), false); QSignalSpy wirelessHwEnabledChanged(NetworkManager::notifier(), SIGNAL(wirelessHardwareEnabledChanged(bool))); QCOMPARE(NetworkManager::isWirelessHardwareEnabled(), true); fakeNetwork->setWirelessHardwareEnabled(false); QVERIFY(wirelessHwEnabledChanged.wait()); QCOMPARE(wirelessHwEnabledChanged.count(), 1); QVERIFY(wirelessHwEnabledChanged.at(0).at(0).toBool() == false); QCOMPARE(NetworkManager::isWirelessHardwareEnabled(), false); QSignalSpy wimaxEnabledChanged(NetworkManager::notifier(), SIGNAL(wimaxEnabledChanged(bool))); QCOMPARE(NetworkManager::isWimaxEnabled(), true); fakeNetwork->setWimaxEnabled(false); QVERIFY(wimaxEnabledChanged.wait()); QCOMPARE(wimaxEnabledChanged.count(), 1); QVERIFY(wimaxEnabledChanged.at(0).at(0).toBool() == false); QCOMPARE(NetworkManager::isWimaxEnabled(), false); QSignalSpy wimaxHwEnabledChanged(NetworkManager::notifier(), SIGNAL(wimaxHardwareEnabledChanged(bool))); QCOMPARE(NetworkManager::isWimaxHardwareEnabled(), true); fakeNetwork->setWimaxHardwareEnabled(false); QVERIFY(wimaxHwEnabledChanged.wait()); QCOMPARE(wimaxHwEnabledChanged.count(), 1); QVERIFY(wimaxHwEnabledChanged.at(0).at(0).toBool() == false); QCOMPARE(NetworkManager::isWimaxHardwareEnabled(), false); QSignalSpy wwanEnabledChanged(NetworkManager::notifier(), SIGNAL(wwanEnabledChanged(bool))); QCOMPARE(NetworkManager::isWwanEnabled(), true); fakeNetwork->setWwanEnabled(false); QVERIFY(wwanEnabledChanged.wait()); QCOMPARE(wwanEnabledChanged.count(), 1); QVERIFY(wwanEnabledChanged.at(0).at(0).toBool() == false); QCOMPARE(NetworkManager::isWwanEnabled(), false); // We make it here, so we can set all values back for futher testing fakeNetwork->setWirelessEnabled(true); fakeNetwork->setWirelessHardwareEnabled(true); fakeNetwork->setWimaxEnabled(true); fakeNetwork->setWimaxHardwareEnabled(true); fakeNetwork->setWwanEnabled(true); } QTEST_MAIN(ManagerTest) diff --git a/src/fakenetwork/fakenetwork.cpp b/src/fakenetwork/fakenetwork.cpp index fb5a97b..bc1144e 100644 --- a/src/fakenetwork/fakenetwork.cpp +++ b/src/fakenetwork/fakenetwork.cpp @@ -1,455 +1,469 @@ /* Copyright 2014 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 "connection.h" #include "fakenetwork.h" #include "wireddevice.h" #include "wirelessdevice.h" #include #include "connectionsettings.h" #include "../manager.h" FakeNetwork::FakeNetwork(QObject *parent) : QObject(parent) , m_activatingConnection(QDBusObjectPath("/")) , m_connectivity(NetworkManager::Connectivity::NoConnectivity) , m_networkingEnabled(true) , m_primaryConnection(QDBusObjectPath("/")) , m_state(20) , m_version(QLatin1Literal("0.9.10.0")) , m_wimaxEnabled(true) , m_wimaxHardwareEnabled(true) , m_wirelessEnabled(true) , m_wirelessHardwareEnabled(true) , m_wwanEnabled(true) , m_wwanHardwareEnabled(true) , m_activeConnectionsCounter(0) , m_deviceCounter(0) , m_settings(new Settings(this)) { - QDBusConnection::sessionBus().registerService(QLatin1Literal("org.kde.fakenetwork")); - QDBusConnection::sessionBus().registerObject(QLatin1Literal("/org/kde/fakenetwork"), this, QDBusConnection::ExportScriptableContents); - QDBusConnection::sessionBus().registerObject(QLatin1Literal("/org/kde/fakenetwork/Settings"), m_settings, QDBusConnection::ExportScriptableContents); - + registerService(); connect(m_settings, &Settings::connectionAdded, this, &FakeNetwork::onConnectionAdded); connect(m_settings, &Settings::connectionRemoved, this, &FakeNetwork::onConnectionRemoved); } FakeNetwork::~FakeNetwork() { - Q_FOREACH (const QDBusObjectPath & devicePath, m_devices.keys()) { - QDBusConnection::sessionBus().unregisterObject(devicePath.path()); - Q_EMIT DeviceRemoved(devicePath); - } + unregisterService(); qDeleteAll(m_devices); - delete m_settings; - QDBusConnection::sessionBus().unregisterObject(QLatin1Literal("/org/kde/fakenetwork/Settings")); - QDBusConnection::sessionBus().unregisterObject(QLatin1Literal("/org/kde/fakenetwork")); - QDBusConnection::sessionBus().unregisterService(QLatin1Literal("org.kde.fakenetwork")); } QDBusObjectPath FakeNetwork::activatingConnection() const { return m_activatingConnection; } QList< QDBusObjectPath > FakeNetwork::activeConnections() const { return m_activeConnections.keys(); } uint FakeNetwork::connectivity() const { return m_connectivity; } QList< QDBusObjectPath > FakeNetwork::devices() const { return m_devices.keys(); } bool FakeNetwork::networkingEnabled() const { return m_networkingEnabled; } QDBusObjectPath FakeNetwork::primaryConnection() const { return m_primaryConnection; } uint FakeNetwork::state() const { return m_state; } QString FakeNetwork::version() const { return m_version; } bool FakeNetwork::wimaxEnabled() const { return m_wimaxEnabled; } void FakeNetwork::setWimaxEnabled(bool enabled) { m_wimaxEnabled = enabled; QVariantMap map; map.insert(QLatin1Literal("WimaxEnabled"), m_wimaxEnabled); Q_EMIT PropertiesChanged(map); } bool FakeNetwork::wimaxHardwareEnabled() const { return m_wimaxHardwareEnabled; } void FakeNetwork::setWimaxHardwareEnabled(bool enabled) { m_wimaxHardwareEnabled = enabled; QVariantMap map; map.insert(QLatin1Literal("WimaxHardwareEnabled"), m_wimaxHardwareEnabled); Q_EMIT PropertiesChanged(map); } bool FakeNetwork::wirelessEnabled() const { return m_wirelessEnabled; } void FakeNetwork::setWirelessEnabled(bool enabled) { m_wirelessEnabled = enabled; QVariantMap map; map.insert(QLatin1Literal("WirelessEnabled"), m_wirelessEnabled); Q_EMIT PropertiesChanged(map); } bool FakeNetwork::wirelessHardwareEnabled() const { return m_wirelessHardwareEnabled; } void FakeNetwork::setWirelessHardwareEnabled(bool enabled) { m_wirelessHardwareEnabled = enabled; QVariantMap map; map.insert(QLatin1Literal("WirelessHardwareEnabled"), m_wirelessHardwareEnabled); Q_EMIT PropertiesChanged(map); } bool FakeNetwork::wwanEnabled() const { return m_wwanEnabled; } void FakeNetwork::setWwanEnabled(bool enabled) { m_wwanEnabled = enabled; QVariantMap map; map.insert(QLatin1Literal("WwanEnabled"), m_wwanEnabled); Q_EMIT PropertiesChanged(map); } bool FakeNetwork::wwanHardwareEnabled() const { return m_wwanHardwareEnabled; } void FakeNetwork::addDevice(Device *device) { QString newDevicePath = QString("/org/kde/fakenetwork/Devices/") + QString::number(m_deviceCounter++); device->setDevicePath(newDevicePath); m_devices.insert(QDBusObjectPath(newDevicePath), device); QDBusConnection::sessionBus().registerObject(newDevicePath, device, QDBusConnection::ExportScriptableContents); Q_EMIT DeviceAdded(QDBusObjectPath(newDevicePath)); } void FakeNetwork::removeDevice(Device *device) { m_devices.remove(QDBusObjectPath(device->devicePath())); QDBusConnection::sessionBus().unregisterObject(device->devicePath()); Q_EMIT DeviceRemoved(QDBusObjectPath(device->devicePath())); } +void FakeNetwork::registerService() +{ + QDBusConnection::sessionBus().registerService(QLatin1Literal("org.kde.fakenetwork")); + QDBusConnection::sessionBus().registerObject(QLatin1Literal("/org/kde/fakenetwork"), this, QDBusConnection::ExportScriptableContents); + QDBusConnection::sessionBus().registerObject(QLatin1Literal("/org/kde/fakenetwork/Settings"), m_settings, QDBusConnection::ExportScriptableContents); + + Q_FOREACH (const QDBusObjectPath & devicePath, m_devices.keys()) { + QDBusConnection::sessionBus().registerObject(devicePath.path(), m_devices.value(devicePath), QDBusConnection::ExportScriptableContents); + Q_EMIT DeviceAdded(devicePath); + } +} + +void FakeNetwork::unregisterService() +{ + Q_FOREACH (const QDBusObjectPath & devicePath, m_devices.keys()) { + QDBusConnection::sessionBus().unregisterObject(devicePath.path()); + Q_EMIT DeviceRemoved(devicePath); + } + + QDBusConnection::sessionBus().unregisterObject(QLatin1Literal("/org/kde/fakenetwork/Settings")); + QDBusConnection::sessionBus().unregisterObject(QLatin1Literal("/org/kde/fakenetwork")); + QDBusConnection::sessionBus().unregisterService(QLatin1Literal("org.kde.fakenetwork")); +} + QDBusObjectPath FakeNetwork::ActivateConnection(const QDBusObjectPath &connection, const QDBusObjectPath &device, const QDBusObjectPath &specific_object) { ActiveConnection *newActiveConnection = new ActiveConnection(this); QString newActiveConnectionPath = QString("/org/kde/fakenetwork/ActiveConnection/") + QString::number(m_activeConnectionsCounter++); m_activeConnections.insert(QDBusObjectPath(newActiveConnectionPath), newActiveConnection); QDBusConnection::sessionBus().registerObject(newActiveConnectionPath, newActiveConnection, QDBusConnection::ExportScriptableContents); m_activatingConnection = QDBusObjectPath(newActiveConnectionPath); QVariantMap map; map.insert(QLatin1Literal("ActiveConnections"), QVariant::fromValue >(m_activeConnections.keys())); map.insert(QLatin1Literal("ActivatingConnection"), QVariant::fromValue(QDBusObjectPath(newActiveConnectionPath))); Q_EMIT PropertiesChanged(map); newActiveConnection->addDevice(device); newActiveConnection->setActiveConnectionPath(newActiveConnectionPath); newActiveConnection->setConnection(connection); newActiveConnection->setSpecificObject(specific_object); newActiveConnection->setState(NetworkManager::ActiveConnection::Activating); map.clear(); const QList deviceList { device }; map.insert(QLatin1Literal("Devices"), QVariant::fromValue >(deviceList)); map.insert(QLatin1Literal("Connection"), QVariant::fromValue(connection)); if (!specific_object.path().isEmpty()) { map.insert(QLatin1Literal("SpecificObject"), QVariant::fromValue(connection)); } map.insert(QLatin1Literal("State"), NetworkManager::ActiveConnection::Activating); QDBusMessage message = QDBusMessage::createSignal(newActiveConnectionPath, QLatin1Literal("org.kde.fakenetwork.Connection.Active"), QLatin1Literal("PropertiesChanged")); message << map; QDBusConnection::sessionBus().send(message); Device *usedDevice = static_cast(QDBusConnection::sessionBus().objectRegisteredAt(device.path())); if (usedDevice) { m_activatedDevice = usedDevice->devicePath(); // Start simulation of activation usedDevice->setActiveConnection(newActiveConnectionPath); usedDevice->setState(NetworkManager::Device::Preparing); QTimer::singleShot(100, this, SLOT(updateConnectingState())); } return QDBusObjectPath(newActiveConnectionPath); } void FakeNetwork::updateConnectingState() { QVariantMap deviceMap; Device *device = m_devices.value(QDBusObjectPath(m_activatedDevice)); if (device->state() == NetworkManager::Device::Preparing) { device->setState(NetworkManager::Device::ConfiguringHardware); } else if (device->state() == NetworkManager::Device::ConfiguringHardware) { device->setState(NetworkManager::Device::NeedAuth); } else if (device->state() == NetworkManager::Device::NeedAuth) { device->setState(NetworkManager::Device::ConfiguringIp); } else if (device->state() == NetworkManager::Device::ConfiguringIp) { device->setState(NetworkManager::Device::CheckingIp); } else if (device->state() == NetworkManager::Device::CheckingIp) { device->setState(NetworkManager::Device::Activated); ActiveConnection *activeConnection = static_cast(QDBusConnection::sessionBus().objectRegisteredAt(device->activeConnection().path())); if (activeConnection) { QVariantMap activeConnectionMap; activeConnectionMap.insert(QLatin1Literal("State"), NetworkManager::ActiveConnection::Activated); activeConnection->setState(NetworkManager::ActiveConnection::Activated); QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1Literal("org.kde.fakenetwork.Connection.Active"), QLatin1Literal("PropertiesChanged")); message << activeConnectionMap; QDBusConnection::sessionBus().send(message); } // TODO: set dhcp4Config, dhcp6Config, ip4Config, ip6Config // IP Interface is usually same as interface device->setIpInterface(device->interface()); // Set some IP address device->setIpv4Address(1763189258); deviceMap.insert(QLatin1Literal("IpInterface"), device->ipInterface()); deviceMap.insert(QLatin1Literal("Ip4Address"), device->ip4Address()); deviceMap.insert(QLatin1Literal("ActiveConnection"), m_activatingConnection.path()); // Update FakeNetwork state, connectivity, primary connection m_connectivity = NetworkManager::Connectivity::Full; m_primaryConnection = m_activatingConnection; m_activatingConnection = QDBusObjectPath("/"); m_state = 70; QVariantMap networkMap; networkMap.insert(QLatin1Literal("ActivatingConnection"), QVariant::fromValue(m_activatingConnection)); networkMap.insert(QLatin1Literal("Connectivity"), NetworkManager::Connectivity::Full); networkMap.insert(QLatin1Literal("PrimaryConnection"), QVariant::fromValue(m_primaryConnection)); networkMap.insert(QLatin1Literal("State"), m_state); QDBusMessage message = QDBusMessage::createSignal(QLatin1Literal("/org/kde/fakenetwork"), QLatin1Literal("org.kde.fakenetwork"), QLatin1Literal("PropertiesChanged")); message << networkMap; QDBusConnection::sessionBus().send(message); Q_EMIT StateChanged(m_state); } deviceMap.insert(QLatin1Literal("State"), device->state()); QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1Literal("PropertiesChanged")); message << deviceMap; QDBusConnection::sessionBus().send(message); if (device->state() != NetworkManager::Device::Activated) { QTimer::singleShot(100, this, SLOT(updateConnectingState())); } } uint FakeNetwork::CheckConnectivity() const { return m_connectivity; } void FakeNetwork::DeactivateConnection(const QDBusObjectPath &active_connection) { ActiveConnection *activeConnection = m_activeConnections.value(active_connection); if (activeConnection) { activeConnection->setState(NetworkManager::ActiveConnection::Deactivating); QVariantMap activeConnectionMap; activeConnectionMap.insert(QLatin1Literal("State"), NetworkManager::ActiveConnection::Deactivating); activeConnection->setState(NetworkManager::ActiveConnection::Activated); QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1Literal("org.kde.fakenetwork.Connection.Active"), QLatin1Literal("PropertiesChanged")); message << activeConnectionMap; QDBusConnection::sessionBus().send(message); Device *device = m_devices.value(activeConnection->devices().first()); if (device) { m_deactivatedDevice = device->devicePath(); device->setState(NetworkManager::Device::Deactivating); QTimer::singleShot(100, this, SLOT(updateDeactivatingState())); } // Update FakeNetwork state, connectivity, primary connection m_connectivity = NetworkManager::Connectivity::NoConnectivity; m_primaryConnection = QDBusObjectPath("/"); m_state = 20; QVariantMap networkMap; networkMap.insert(QLatin1Literal("Connectivity"), m_connectivity); networkMap.insert(QLatin1Literal("PrimaryConnection"), QVariant::fromValue(m_primaryConnection)); networkMap.insert(QLatin1Literal("State"), m_state); message = QDBusMessage::createSignal(QLatin1Literal("/org/kde/fakenetwork"), QLatin1Literal("org.kde.fakenetwork"), QLatin1Literal("PropertiesChanged")); message << networkMap; QDBusConnection::sessionBus().send(message); Q_EMIT StateChanged(m_state); } } void FakeNetwork::updateDeactivatingState() { QVariantMap deviceMap; Device *device = m_devices.value(QDBusObjectPath(m_deactivatedDevice)); ActiveConnection *activeConnection = static_cast(QDBusConnection::sessionBus().objectRegisteredAt(device->activeConnection().path())); if (activeConnection) { QVariantMap activeConnectionMap; activeConnectionMap.insert(QLatin1Literal("State"), NetworkManager::ActiveConnection::Deactivated); activeConnection->setState(NetworkManager::ActiveConnection::Activated); QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1Literal("org.kde.fakenetwork.Connection.Active"), QLatin1Literal("PropertiesChanged")); message << activeConnectionMap; QDBusConnection::sessionBus().send(message); removeActiveConnection(QDBusObjectPath(activeConnection->activeConnectionPath())); } device->setActiveConnection(QLatin1Literal("/")); device->setState(NetworkManager::Device::Disconnected); // TODO: set dhcp4Config, dhcp6Config, ip4Config, ip6Config // IP Interface is usually same as interface device->setIpInterface(""); // Set some IP address device->setIpv4Address(0); deviceMap.insert(QLatin1Literal("ActiveConnection"), device->activeConnection().path()); deviceMap.insert(QLatin1Literal("IpInterface"), device->ipInterface()); deviceMap.insert(QLatin1Literal("Ip4Address"), device->ip4Address()); deviceMap.insert(QLatin1Literal("State"), device->state()); QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1Literal("PropertiesChanged")); message << deviceMap; QDBusConnection::sessionBus().send(message); } QDBusObjectPath FakeNetwork::GetDeviceByIpIface(const QString &iface) { // TODO return QDBusObjectPath(); } QList< QDBusObjectPath > FakeNetwork::GetDevices() const { return m_devices.keys(); } void FakeNetwork::onConnectionAdded(const QDBusObjectPath &connection) { Connection *newConnection = static_cast(QDBusConnection::sessionBus().objectRegisteredAt(connection.path())); if (newConnection) { NMVariantMapMap settings = newConnection->GetSettings(); NetworkManager::ConnectionSettings::ConnectionType type = NetworkManager::ConnectionSettings::typeFromString(settings.value(QLatin1Literal("connection")).value(QLatin1Literal("type")).toString()); if (!m_devices.isEmpty()) { Device *selectedDevice = nullptr; Q_FOREACH (Device * device, m_devices.values()) { if (type == NetworkManager::ConnectionSettings::Wired && device->deviceType() == NetworkManager::Device::Ethernet) { selectedDevice = device; device->addAvailableConnection(connection); break; } else if (type == NetworkManager::ConnectionSettings::Wireless && device->deviceType() == NetworkManager::Device::Wifi) { selectedDevice = device; // TODO break; } } if (selectedDevice) { QVariantMap map; map.insert(QLatin1Literal("AvailableConnections"), QVariant::fromValue >(selectedDevice->availableConnections())); QDBusMessage message = QDBusMessage::createSignal(selectedDevice->devicePath(), selectedDevice->deviceInterface(), QLatin1Literal("PropertiesChanged")); message << map; QDBusConnection::sessionBus().send(message); } } } } void FakeNetwork::onConnectionRemoved(const QDBusObjectPath &connection) { Q_FOREACH (Device * device, m_devices.values()) { if (device && device->availableConnections().contains(connection)) { device->removeAvailableConnection(connection); QVariantMap map; map.insert(QLatin1Literal("AvailableConnections"), QVariant::fromValue >(device->availableConnections())); QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1Literal("PropertiesChanged")); message << map; QDBusConnection::sessionBus().send(message); } } } void FakeNetwork::removeActiveConnection(const QDBusObjectPath &activeConnection) { delete m_activeConnections.value(activeConnection); m_activeConnections.remove(activeConnection); QDBusConnection::sessionBus().unregisterObject(activeConnection.path()); QVariantMap map; map.insert(QLatin1Literal("ActiveConnections"), QVariant::fromValue >(m_activeConnections.keys())); Q_EMIT PropertiesChanged(map); } diff --git a/src/fakenetwork/fakenetwork.h b/src/fakenetwork/fakenetwork.h index 1b724e5..bf0dd96 100644 --- a/src/fakenetwork/fakenetwork.h +++ b/src/fakenetwork/fakenetwork.h @@ -1,128 +1,130 @@ /* Copyright 2014 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 . */ #ifndef NETWORKMANAGERQT_FAKE_NETWORK_H #define NETWORKMANAGERQT_FAKE_NETWORK_H #include #include #include #include #include "../generictypes.h" #include "../device.h" #include "activeconnection.h" #include "device.h" #include "settings.h" class FakeNetwork : public QObject { Q_OBJECT Q_CLASSINFO("D-Bus Interface", "org.kde.fakenetwork") public: explicit FakeNetwork(QObject *parent = nullptr); virtual ~FakeNetwork(); Q_PROPERTY(QDBusObjectPath ActivatingConnection READ activatingConnection) Q_PROPERTY(QList ActiveConnections READ activeConnections) Q_PROPERTY(uint Connectivity READ connectivity) Q_PROPERTY(QList Devices READ devices) Q_PROPERTY(bool NetworkingEnabled READ networkingEnabled) Q_PROPERTY(QDBusObjectPath PrimaryConnection READ primaryConnection) Q_PROPERTY(uint State READ state) Q_PROPERTY(QString Version READ version) Q_PROPERTY(bool WimaxEnabled READ wimaxEnabled WRITE setWimaxEnabled) Q_PROPERTY(bool WimaxHardwareEnabled READ wimaxHardwareEnabled) Q_PROPERTY(bool WirelessEnabled READ wirelessEnabled WRITE setWirelessEnabled) Q_PROPERTY(bool WirelessHardwareEnabled READ wirelessHardwareEnabled) Q_PROPERTY(bool WwanEnabled READ wwanEnabled WRITE setWwanEnabled) Q_PROPERTY(bool WwanHardwareEnabled READ wwanHardwareEnabled) QDBusObjectPath activatingConnection() const; QList activeConnections() const; uint connectivity() const; QList devices() const; bool networkingEnabled() const; QDBusObjectPath primaryConnection() const; uint state() const; QString version() const; bool wimaxEnabled() const; void setWimaxEnabled(bool enabled); bool wimaxHardwareEnabled() const; void setWimaxHardwareEnabled(bool enabled); bool wirelessEnabled() const; void setWirelessEnabled(bool enabled); bool wirelessHardwareEnabled() const; void setWirelessHardwareEnabled(bool enabled); bool wwanEnabled() const; void setWwanEnabled(bool enabled); bool wwanHardwareEnabled() const; /* Not part of DBus interface */ void addDevice(Device *device); void removeDevice(Device *device); + void registerService(); + void unregisterService(); private Q_SLOTS: void onConnectionAdded(const QDBusObjectPath &connection); void onConnectionRemoved(const QDBusObjectPath &connection); void removeActiveConnection(const QDBusObjectPath &activeConnection); void updateConnectingState(); void updateDeactivatingState(); public Q_SLOTS: Q_SCRIPTABLE QDBusObjectPath ActivateConnection(const QDBusObjectPath &connection, const QDBusObjectPath &device, const QDBusObjectPath &specific_object); Q_SCRIPTABLE uint CheckConnectivity() const; Q_SCRIPTABLE void DeactivateConnection(const QDBusObjectPath &active_connection); Q_SCRIPTABLE QDBusObjectPath GetDeviceByIpIface(const QString &iface); Q_SCRIPTABLE QList GetDevices() const; Q_SIGNALS: Q_SCRIPTABLE void DeviceAdded(const QDBusObjectPath &device_path); Q_SCRIPTABLE void DeviceRemoved(const QDBusObjectPath &device_path); Q_SCRIPTABLE void PropertiesChanged(const QVariantMap &properties); Q_SCRIPTABLE void StateChanged(uint state); private: QDBusObjectPath m_activatingConnection; QMap m_activeConnections; uint m_connectivity; QMap m_devices; bool m_networkingEnabled; QDBusObjectPath m_primaryConnection; uint m_state; QString m_version; bool m_wimaxEnabled; bool m_wimaxHardwareEnabled; bool m_wirelessEnabled; bool m_wirelessHardwareEnabled; bool m_wwanEnabled; bool m_wwanHardwareEnabled; /* Not part of DBus interface */ QString m_activatedDevice; QString m_deactivatedDevice; int m_activeConnectionsCounter; int m_deviceCounter; Settings *m_settings; }; #endif diff --git a/src/manager.cpp b/src/manager.cpp index c523e13..2b16e9d 100644 --- a/src/manager.cpp +++ b/src/manager.cpp @@ -1,1105 +1,1105 @@ /* 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" #include #if NM_CHECK_VERSION(1, 0, 0) #include #else #include #endif #include "activeconnection.h" #include "adsldevice.h" #include "bluetoothdevice.h" #include "bonddevice.h" #include "bridgedevice.h" #include "infinibanddevice.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 ); // Get all Manager's properties async QVariantMap initialProperties = retrieveInitialProperties(iface.staticInterfaceName(), DBUS_DAEMON_PATH); if (!initialProperties.isEmpty()) { propertiesChanged(initialProperties); } QTimer::singleShot(0, [this] { 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; QStringList sl = version.split('.'); 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; if (networkInterfaceMap.contains(uni)) { if (networkInterfaceMap.value(uni)) { networkInterface = networkInterfaceMap.value(uni); } 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 bool contains = m_activeConnections.contains(uni); if (contains && m_activeConnections.value(uni)) { activeConnection = m_activeConnections.value(uni); } 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; 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()); } - 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; } ++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; QMap::const_iterator it = m_activeConnections.constBegin(); while (it != m_activeConnections.constEnd()) { NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(it.key()); if (activeConnection) { list << activeConnection; } ++it; } 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; }