diff options
Diffstat (limited to 'src/qtdevicesettings/networksettingsplugin/networksettings/connman/networksettingsmanager_linux.cpp')
| -rw-r--r-- | src/qtdevicesettings/networksettingsplugin/networksettings/connman/networksettingsmanager_linux.cpp | 583 |
1 files changed, 583 insertions, 0 deletions
diff --git a/src/qtdevicesettings/networksettingsplugin/networksettings/connman/networksettingsmanager_linux.cpp b/src/qtdevicesettings/networksettingsplugin/networksettings/connman/networksettingsmanager_linux.cpp new file mode 100644 index 0000000..c4973ea --- /dev/null +++ b/src/qtdevicesettings/networksettingsplugin/networksettings/connman/networksettingsmanager_linux.cpp @@ -0,0 +1,583 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the Qt Device Utilities module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include <QQmlPropertyMap> + +#include "networkconfig.h" +#include "networksettingsmanager_linux_p.h" +#include "connman_manager_interface.cpp" +#include "moc_connman_manager_interface.cpp" +#include "connman_service_interface.h" +#include "connman_technology_interface.h" + +const QString PropertyIPv4("IPv4"); +const QString PropertyIPv4Config("IPv4.Configuration"); +const QString PropertyIPv6("IPv6"); +const QString PropertyIPv6Config("IPv6.Configuration"); +const QString PropertyNameservers("Nameservers"); +const QString PropertyNameserversConfig("Nameservers.Configuration"); +const QString PropertyDomains("Domains"); +const QString PropertyDomainsConfig("Domains.Configuration"); +const QString PropertyProxy("Proxy"); +const QString PropertyProxyConfig("Proxy.Configuration"); +const QString PropertyState("State"); +const QString PropertyName("Name"); +const QString PropertyType("Type"); +const QString PropertyConnected("Connected"); +const QString PropertyPowered("Powered"); +const QString PropertyAddress("Address"); +const QString PropertyNetMask("Netmask"); +const QString PropertyGateway("Gateway"); +const QString PropertyPrefixLength("PrefixLength"); +const QString PropertyMethod("Method"); +const QString PropertyPrivacy("Privacy"); +const QString PropertyUrl("Url"); +const QString PropertyServers("Servers"); +const QString PropertyExcludes("Excludes"); +const QString AttributeAuto("auto"); +const QString AttributeDhcp("dhcp"); +const QString AttributeManual("manual"); +const QString AttributeOff("off"); +const QString AttributeDisabled("disabled"); +const QString AttributeEnabled("enabled"); +const QString AttributePreferred("preferred"); +const QString AttributeDirect("direct"); +const QString AttributeWifi("wifi"); +const QString AttributeEthernet("ethernet"); +const QString AttributeIdle("idle"); +const QString AttributeFailure("failure"); +const QString AttributeAssociation("association"); +const QString AttributeConfiguration("configuration"); +const QString AttributeReady("ready"); +const QString AttributeDisconnect("disconnect"); +const QString AttributeOneline("online"); + +//Conversion operations for datatypes +const QDBusArgument &operator>>(const QDBusArgument &argument, ConnmanMap &obj) +{ + argument.beginStructure(); + argument >> obj.objectPath >> obj.propertyMap; + argument.endStructure(); + return argument; +} + +QDBusArgument &operator<<(QDBusArgument &argument, const ConnmanMap &obj) +{ + argument.beginStructure(); + argument << obj.objectPath << obj.propertyMap; + argument.endStructure(); + return argument; +} + +const QVariantMap &operator>>(const QVariantMap &argument, IPv4Config &obj) +{ + obj.setAddress(argument[PropertyAddress].toString()); + obj.setMask(argument[PropertyNetMask].toString()); + obj.setGateway(argument[PropertyGateway].toString()); + + QString method = argument[PropertyMethod].toString(); + + if (method == AttributeDhcp) { + obj.setMethod(IPv4Config::Dhcp); + } + else if (method == AttributeManual) { + obj.setMethod(IPv4Config::Manual); + } + else if (method == AttributeOff) { + obj.setMethod(IPv4Config::Off); + } + else { + obj.setMethod(IPv4Config::Off); + } + return argument; +} + +const QVariantMap &operator<<(QVariantMap &argument, const IPv4Config &obj) +{ + argument.insert(PropertyAddress, QVariant::fromValue(obj.address())); + + argument.insert(PropertyNetMask, QVariant::fromValue(obj.mask())); + + argument.insert(PropertyGateway, QVariant::fromValue(obj.gateway())); + + QString method; + switch (obj.method()) { + case IPv4Config::Dhcp: + method = AttributeDhcp; + break; + case IPv4Config::Manual: + method = AttributeManual; + break; + case IPv4Config::Off: + method = AttributeOff; + break; + default: + break; + } + argument.insert(PropertyMethod, QVariant::fromValue(method)); + return argument; +} + +const QVariantMap &operator>>(const QVariantMap &argument, IPv6Config &obj) +{ + obj.setAddress(argument[PropertyAddress].toString()); + obj.setGateway(argument[PropertyGateway].toString()); + obj.setPrefixLength(argument[PropertyPrefixLength].toInt()); + QString method = argument[PropertyMethod].toString(); + if (method == AttributeAuto) { + obj.setMethod(IPv6Config::Auto); + } + else if (method == AttributeManual) { + obj.setMethod(IPv6Config::Manual); + } + else if (method == AttributeOff) { + obj.setMethod(IPv6Config::Off); + } + QString privacy = argument[PropertyPrivacy].toString(); + + if (privacy == AttributeDisabled) { + obj.setPrivacy(IPv6Config::Disabled); + } + else if (privacy == AttributeEnabled) { + obj.setPrivacy(IPv6Config::Enabled); + } + else if (privacy == AttributePreferred) { + obj.setPrivacy(IPv6Config::Preferred); + } + return argument; +} + +const QVariantMap &operator<<(QVariantMap &argument, const IPv6Config &obj) +{ + argument.insert(PropertyAddress, QVariant::fromValue(obj.address())); + argument.insert(PropertyGateway, QVariant::fromValue(obj.address())); + argument.insert(PropertyPrefixLength, QVariant::fromValue(obj.prefixLength())); + + QString method; + switch (obj.method()) { + case IPv6Config::Auto: + method = AttributeAuto; + break; + case IPv6Config::Manual: + method = AttributeManual; + break; + case IPv6Config::Off: + method = AttributeOff; + break; + default: + break; + } + argument.insert(PropertyMethod, QVariant::fromValue(method)); + + QString privacy; + switch (obj.privacy()) { + case IPv6Config::Disabled: + method = AttributeDisabled; + break; + case IPv6Config::Enabled: + method = AttributeEnabled; + break; + case IPv6Config::Preferred: + method = AttributePreferred; + break; + default: + break; + } + argument.insert(PropertyPrivacy, QVariant::fromValue(privacy)); + + return argument; +} + + +const QVariantMap &operator>>(const QVariantMap &argument, ProxyConfig &obj) +{ + QString method = argument[PropertyMethod].toString(); + if (method == AttributeDirect) { + obj.setMethod(ProxyConfig::Direct); + } + else if (method == AttributeAuto) { + obj.setMethod(ProxyConfig::Auto); + } + else if (method == AttributeManual) { + obj.setMethod(ProxyConfig::Manual); + } + + QString urlStr = argument[PropertyUrl].toString(); + obj.setUrl(QUrl(urlStr)); + + obj.setServers(argument[PropertyServers].toStringList()); + obj.setExcludes(argument[PropertyExcludes].toStringList()); + + return argument; +} + +const QVariantMap &operator<<(QVariantMap &argument, const ProxyConfig &obj) +{ + QString method; + switch (obj.method()) { + case ProxyConfig::Direct: + method = AttributeDirect; + break; + case ProxyConfig::Auto: + method = AttributeAuto; + break; + case ProxyConfig::Manual: + method = AttributeManual; + break; + default: + break; + } + argument.insert(PropertyMethod, QVariant::fromValue(method)); + argument.insert(PropertyUrl, QVariant::fromValue(obj.url().toString())); + argument.insert(PropertyServers, QVariant::fromValue(obj.servers())); + argument.insert(PropertyServers, QVariant::fromValue(obj.excludes())); + + return argument; +} + +const QString &operator>>(const QString &argument, NetworkType &obj) +{ + if (argument == AttributeEthernet) { + obj.setType(NetworkType::Wired); + } + else if (argument == AttributeWifi) { + obj.setType(NetworkType::Wifi); + } + else { + obj.setType(NetworkType::Unknown); + } + + return argument; +} + +const QString &operator>>(const QString &argument, NetworkState &obj) +{ + if (argument == AttributeIdle) { + obj.setState(NetworkState::Idle); + } + else if (argument == AttributeFailure) { + obj.setState(NetworkState::Failure); + } + else if (argument == AttributeAssociation) { + obj.setState(NetworkState::Association); + } + else if (argument == AttributeConfiguration) { + obj.setState(NetworkState::Configuration); + } + else if (argument == AttributeReady) { + obj.setState(NetworkState::Ready); + } + else if (argument == AttributeDisconnect) { + obj.setState(NetworkState::Disconnect); + } + else if (argument == AttributeOneline) { + obj.setState(NetworkState::Online); + } + else { + obj.setState(NetworkState::Undefined); + } + return argument; +} + +NetworkServicePrivate::NetworkServicePrivate(const QString& aPath, NetworkService *parent) : + QObject(parent) + ,q_ptr(parent) + ,m_path(aPath) +{ + qDBusRegisterMetaType<ConnmanMap>(); + qDBusRegisterMetaType<ConnmanMapList>(); + + m_service = new NetConnmanServiceInterface("net.connman", m_path, + QDBusConnection::systemBus(), this); + + connect(m_service, SIGNAL(PropertyChanged(QString,QDBusVariant)), + this, SLOT(updateProperty(QString,QDBusVariant))); + + QDBusPendingReply<QVariantMap> reply = m_service->GetProperties(); + QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this); + + connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), + this, SLOT(propertiesUpdated(QDBusPendingCallWatcher*))); +} + +void NetworkServicePrivate::setupIpv6Config() +{ + QVariantMap param; + param << m_ipv6config; + if (m_service) + m_service->SetProperty(PropertyIPv6Config, QDBusVariant(QVariant(param))); +} + +void NetworkServicePrivate::setupNameserversConfig() +{ + QVariant param = QVariant::fromValue(m_nameserverConfig.stringList()); + if (m_service) + m_service->SetProperty(PropertyNameserversConfig, QDBusVariant(QVariant(param))); +} + +void NetworkServicePrivate::setupDomainsConfig() +{ + QVariant param = QVariant::fromValue(m_domainsConfig.stringList()); + if (m_service) + m_service->SetProperty(PropertyDomainsConfig, QDBusVariant(QVariant(param))); +} + +void NetworkServicePrivate::setupProxyConfig() +{ + QVariantMap param; + param << m_proxyConfig; + if (m_service) + m_service->SetProperty(PropertyProxyConfig, QDBusVariant(QVariant(param))); +} + +void NetworkServicePrivate::setupIpv4Config() +{ + QVariantMap param; + param << m_ipv4config; + if (m_service) + m_service->SetProperty(PropertyIPv4Config, QDBusVariant(QVariant(param))); +} + + +void NetworkServicePrivate::propertiesUpdated(QDBusPendingCallWatcher *call) +{ + QDBusPendingReply<QVariantMap> reply = *call; + call->deleteLater(); + + if (!reply.isError()) + setupConfiguration(reply.value()); +} + +void NetworkServicePrivate::updateProperty(const QString &name, const QDBusVariant &value) +{ + updateProperty(name, value.variant()); +} + +void NetworkServicePrivate::updateProperty(const QString& key, const QVariant& val) +{ + Q_Q(NetworkService); + + if (key == PropertyIPv4) { + QVariantMap value = qdbus_cast<QVariantMap>(val); + value >> m_ipv4config; + emit q->ipv4Changed(); + } + else if (key == PropertyIPv6) { + QVariantMap value = qdbus_cast<QVariantMap>(val); + value >> m_ipv6config; + emit q->ipv6Changed(); + } + else if (key == PropertyNameservers) { + QStringList value = qdbus_cast<QStringList>(val); + m_nameserverConfig.setStringList(value); + emit q->nameserversChanged(); + } + else if (key == PropertyDomains) { + QStringList value = qdbus_cast<QStringList>(val); + m_domainsConfig.setStringList(value); + emit q->domainsChanged(); + } + else if (key == PropertyProxy) { + QVariantMap value = qdbus_cast<QVariantMap>(val); + value >> m_proxyConfig; + emit q->proxyChanged(); + } + else if (key == PropertyState) { + QString value = qdbus_cast<QString>(val); + value >> m_state; + emit q->stateChanged(); + } + else if (key == PropertyName) { + m_name = qdbus_cast<QString>(val); + emit q->nameChanged(); + } + else if (key == PropertyType) { + QString value = qdbus_cast<QString>(val); + value >> m_type; + } +} + +void NetworkServicePrivate::setupConfiguration(const QVariantMap &properties) +{ + QVariantMap::const_iterator it = properties.constBegin(), end = properties.constEnd(); + for ( ; it != end; ++it) { + updateProperty(it.key(), it.value()); + } +} + +NetworkTechnology::NetworkTechnology(const QString& path, const QVariantMap& properties, QObject* parent) + : NetworkItem(parent) + { + m_technology = new NetConnmanTechnologyInterface("net.connman", path, + QDBusConnection::systemBus(), this); + connect(m_technology, SIGNAL(PropertyChanged(QString,QDBusVariant)), + this, SLOT(updateProperty(QString,QDBusVariant))); + + updateProperty(PropertyName, properties[PropertyName]); + updateProperty(PropertyType, properties[PropertyType]); + updateProperty(PropertyConnected, properties[PropertyConnected]); + updateProperty(PropertyPowered, properties[PropertyPowered]); + } + +void NetworkTechnology::updateProperty(const QString &name, const QDBusVariant &value) +{ + updateProperty(name, value.variant()); +} + +void NetworkTechnology::updateProperty(const QString &name, const QVariant &value) +{ + if (name == PropertyName) { + m_name = qdbus_cast<QString>(value); + } + else if (name == PropertyType) { + qdbus_cast<QString>(value) >> m_type; + emit typeChanged(); + } + else if (name == PropertyConnected) { + bool connected = qdbus_cast<bool>(value); + if (connected) + m_state.setState(NetworkState::Online); + else + m_state.setState(NetworkState::Disconnect); + emit stateChanged(); + } + else if (name == PropertyPowered) { + m_powered = qdbus_cast<bool>(value); + emit poweredChanged(); + } +} + + +NetworkSettingsManagerPrivate::NetworkSettingsManagerPrivate(NetworkSettingsManager *parent) + :QObject(parent) + ,q_ptr(parent) +{ + m_manager = new NetConnmanManagerInterface("net.connman", "/", + QDBusConnection::systemBus(), this); + + if (m_manager->isValid()) { + //List technologies + QDBusPendingReply<ConnmanMapList> reply = m_manager->GetTechnologies(); + QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this); + connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), + this, SLOT(getTechnologiesFinished(QDBusPendingCallWatcher*))); + + reply = m_manager->GetServices(); + watcher = new QDBusPendingCallWatcher(reply, this); + connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), + this, SLOT(getServicesFinished(QDBusPendingCallWatcher*))); + } + else { + delete m_manager; + m_manager = NULL; + } +} + +void NetworkSettingsManagerPrivate::getServicesFinished(QDBusPendingCallWatcher *watcher) +{ + Q_Q(NetworkSettingsManager); + QDBusPendingReply<ConnmanMapList> reply = *watcher; + watcher->deleteLater(); + if (reply.isError()) + return; + + foreach (const ConnmanMap &object, reply.value()) { + const QString servicePath = object.objectPath.path(); + NetworkService *service = new NetworkService(servicePath, this); + m_services.append(service); + + //Update status property + QString n = qdbus_cast<QString>(object.propertyMap[PropertyName]); + QString t = qdbus_cast<QString>(object.propertyMap[PropertyType]); + QString s = qdbus_cast<QString>(object.propertyMap[PropertyState]); + + NetworkType type; + t >> type; + NetworkState state; + s >> state; + + foreach (NetworkItem* item, m_networksModel.getModel()) { + if (item->name() == n && item->type() == type.type()) { + item->setState(state.state()); + } + } + } + emit q->servicesChanged(); +} + +void NetworkSettingsManagerPrivate::getTechnologiesFinished(QDBusPendingCallWatcher *watcher) +{ + Q_Q(NetworkSettingsManager); + QDBusPendingReply<ConnmanMapList> reply = *watcher; + watcher->deleteLater(); + if (reply.isError()) + return; + + foreach (const ConnmanMap &object, reply.value()) { + NetworkTechnology *item = new NetworkTechnology(object.objectPath.path(), object.propertyMap, this); + + //Wired to the top + if (item->type() == NetworkType::Wired) + m_networksModel.insert(0, item); + else if (item->type() == NetworkType::Wifi) { + connect(item, &NetworkItem::poweredChanged, q, &NetworkSettingsManager::wifiPoweredChanged); + m_networksModel.append(item); + } + emit q->networksChanged(); + } +} + +bool NetworkSettingsManagerPrivate::wifiPowered() +{ + foreach (NetworkItem* item, m_networksModel.getModel()) { + if (item->type() == NetworkType::Wifi) { + return item->powered(); + } + } + return false; +} + +void NetworkSettingsManagerPrivate::setWifiPowered(const bool powered) +{ + foreach (NetworkItem* item, m_networksModel.getModel()) { + if (item->type() == NetworkType::Wifi) { + NetworkTechnology* technology = qobject_cast<NetworkTechnology*>(item); + if (technology) { + NetConnmanTechnologyInterface *connmantech = technology->getTechnology(); + connmantech->SetProperty(PropertyPowered, QDBusVariant(QVariant(powered))); + } + } + } +} |