From 00121d66c388c2536714bec6d8b2003ed5b47c88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Simon=20St=C3=BCrz?= Date: Mon, 3 Oct 2016 21:27:44 +0200 Subject: [PATCH] wifi connection working --- server/guhcore.cpp | 6 +- server/jsonrpc/jsontypes.cpp | 33 ++++++- server/jsonrpc/jsontypes.h | 5 ++ server/jsonrpc/networkmanagerhandler.cpp | 90 +++++++++++++++++++ server/jsonrpc/networkmanagerhandler.h | 4 + server/networkmanager/networkconnection.cpp | 51 +++++++++-- server/networkmanager/networkconnection.h | 16 ++++ server/networkmanager/networkdevice.cpp | 1 - server/networkmanager/networkdevice.h | 1 - server/networkmanager/networkmanager.cpp | 67 +++++++++++++- server/networkmanager/networkmanager.h | 16 ++++ server/networkmanager/networksettings.cpp | 19 ++-- server/networkmanager/networksettings.h | 4 + .../networkmanager/wirelessnetworkmanager.cpp | 25 ++++-- .../networkmanager/wirelessnetworkmanager.h | 6 +- 15 files changed, 318 insertions(+), 26 deletions(-) diff --git a/server/guhcore.cpp b/server/guhcore.cpp index 28a5eae9..5a14d112 100644 --- a/server/guhcore.cpp +++ b/server/guhcore.cpp @@ -461,7 +461,11 @@ GuhCore::GuhCore(QObject *parent) : m_webServer = new WebServer(m_configuration->webServerAddress(), m_configuration->webServerPort(), m_configuration->webServerPublicFolder(), this); m_serverManager->restServer()->registerWebserver(m_webServer); - m_networkManager = new NetworkManager(this); + if (!NetworkManager::available()) { + m_networkManager = 0; + } else { + m_networkManager = new NetworkManager(this); + } // Connect the configuration changes connect(m_configuration, &GuhConfiguration::cloudEnabledChanged, m_cloudManager, &CloudManager::onCloudEnabledChanged); diff --git a/server/jsonrpc/jsontypes.cpp b/server/jsonrpc/jsontypes.cpp index 1640a96d..fe84c5be 100644 --- a/server/jsonrpc/jsontypes.cpp +++ b/server/jsonrpc/jsontypes.cpp @@ -84,6 +84,7 @@ QVariantList JsonTypes::s_loggingEventType; QVariantList JsonTypes::s_repeatingMode; QVariantList JsonTypes::s_cloudError; QVariantList JsonTypes::s_configurationError; +QVariantList JsonTypes::s_networkManagerState; QVariantMap JsonTypes::s_paramType; QVariantMap JsonTypes::s_param; @@ -112,10 +113,11 @@ QVariantMap JsonTypes::s_calendarItem; QVariantMap JsonTypes::s_timeEventItem; QVariantMap JsonTypes::s_repeatingOption; QVariantMap JsonTypes::s_wirelessAccessPoint; +QVariantMap JsonTypes::s_networkDevice; void JsonTypes::init() { - // BasicTypes + // Enums s_basicType = enumToStrings(JsonTypes::staticMetaObject, "BasicType"); s_stateOperator = enumToStrings(Types::staticMetaObject, "StateOperator"); s_valueOperator = enumToStrings(Types::staticMetaObject, "ValueOperator"); @@ -135,6 +137,7 @@ void JsonTypes::init() s_repeatingMode = enumToStrings(RepeatingOption::staticMetaObject, "RepeatingMode"); s_cloudError = enumToStrings(Cloud::staticMetaObject, "CloudError"); s_configurationError = enumToStrings(GuhConfiguration::staticMetaObject, "ConfigurationError"); + s_networkManagerState = enumToStrings(NetworkManager::staticMetaObject, "NetworkManagerState"); // ParamType s_paramType.insert("id", basicTypeToString(Uuid)); @@ -321,11 +324,16 @@ void JsonTypes::init() s_repeatingOption.insert("o:weekDays", QVariantList() << basicTypeToString(Int)); s_repeatingOption.insert("o:monthDays", QVariantList() << basicTypeToString(Int)); + // WirelessAccessPoint s_wirelessAccessPoint.insert("ssid", basicTypeToString(QVariant::String)); s_wirelessAccessPoint.insert("macAddress", basicTypeToString(QVariant::String)); s_wirelessAccessPoint.insert("frequency", basicTypeToString(QVariant::Double)); s_wirelessAccessPoint.insert("signalStrength", basicTypeToString(QVariant::Int)); + // NetworkDevice + s_networkDevice.insert("name", basicTypeToString(QVariant::String)); + s_networkDevice.insert("type", basicTypeToString(QVariant::String)); + s_initialized = true; } @@ -371,6 +379,7 @@ QVariantMap JsonTypes::allTypes() allTypes.insert("RepeatingMode", repeatingMode()); allTypes.insert("CloudError", cloudError()); allTypes.insert("ConfigurationError", configurationError()); + allTypes.insert("NetworkManagerState", networkManagerState()); allTypes.insert("StateType", stateTypeDescription()); allTypes.insert("StateDescriptor", stateDescriptorDescription()); @@ -398,6 +407,7 @@ QVariantMap JsonTypes::allTypes() allTypes.insert("TimeEventItem", timeEventItemDescription()); allTypes.insert("RepeatingOption", repeatingOptionDescription()); allTypes.insert("WirelessAccessPoint", wirelessAccessPointDescription()); + allTypes.insert("NetworkDevice", networkDeviceDescription()); return allTypes; } @@ -962,6 +972,14 @@ QVariantMap JsonTypes::packWirelessAccessPoint(WirelessAccessPoint *wirelessAcce return wirelessAccessPointVariant; } +QVariantMap JsonTypes::packNetworkDevice(NetworkDevice *networkDevice) +{ + QVariantMap networkDeviceVariant; + networkDeviceVariant.insert("name", networkDevice->interface()); + networkDeviceVariant.insert("type", NetworkDevice::deviceTypeToString(networkDevice->deviceType())); + return networkDeviceVariant; +} + /*! Returns a variant list of the supported vendors. */ QVariantList JsonTypes::packSupportedVendors() { @@ -1726,6 +1744,12 @@ QPair JsonTypes::validateVariant(const QVariant &templateVariant, qCWarning(dcJsonRpc) << "WirelessAccessPoint not matching"; return result; } + } else if (refName == networkDeviceRef()) { + QPair result = validateMap(networkDeviceDescription(), variant.toMap()); + if (!result.first) { + qCWarning(dcJsonRpc) << "NetworkDevice not matching"; + return result; + } } else if (refName == basicTypeRef()) { QPair result = validateBasicType(variant); if (!result.first) { @@ -1834,6 +1858,12 @@ QPair JsonTypes::validateVariant(const QVariant &templateVariant, qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(configurationErrorRef()); return result; } + } else if (refName == networkManagerStateRef()) { + QPair result = validateEnum(s_networkManagerState, variant); + if (!result.first) { + qCWarning(dcJsonRpc) << QString("Value %1 not allowed in %2").arg(variant.toString()).arg(networkManagerStateRef()); + return result; + } } else { Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data()); return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName)); @@ -1896,6 +1926,7 @@ QPair JsonTypes::validateBasicType(const QVariant &variant) if (variant.canConvert(QVariant::Time) && QVariant(variant).convert(QVariant::Time)) { return report(true, ""); } + return report(false, QString("Error validating basic type %1.").arg(variant.toString())); } diff --git a/server/jsonrpc/jsontypes.h b/server/jsonrpc/jsontypes.h index 6977b9fe..98791bf3 100644 --- a/server/jsonrpc/jsontypes.h +++ b/server/jsonrpc/jsontypes.h @@ -47,6 +47,8 @@ #include "cloud/cloudconnection.h" +#include "networkmanager/networkmanager.h" +#include "networkmanager/networkdevice.h" #include "networkmanager/wirelessaccesspoint.h" #include @@ -129,6 +131,7 @@ public: DECLARE_TYPE(repeatingMode, "RepeatingMode", RepeatingOption, RepeatingMode) DECLARE_TYPE(cloudError, "CloudError", Cloud, CloudError) DECLARE_TYPE(configurationError, "ConfigurationError", GuhConfiguration, ConfigurationError) + DECLARE_TYPE(networkManagerState, "NetworkManagerState", NetworkManager, NetworkManagerState) DECLARE_OBJECT(paramType, "ParamType") DECLARE_OBJECT(param, "Param") @@ -157,6 +160,7 @@ public: DECLARE_OBJECT(timeEventItem, "TimeEventItem") DECLARE_OBJECT(repeatingOption, "RepeatingOption") DECLARE_OBJECT(wirelessAccessPoint, "WirelessAccessPoint") + DECLARE_OBJECT(networkDevice, "NetworkDevice") // pack types static QVariantMap packEventType(const EventType &eventType); @@ -186,6 +190,7 @@ public: static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem); static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor); static QVariantMap packWirelessAccessPoint(WirelessAccessPoint *wirelessAccessPoint); + static QVariantMap packNetworkDevice(NetworkDevice *networkDevice); // pack resources static QVariantList packRules(const QList rules); diff --git a/server/jsonrpc/networkmanagerhandler.cpp b/server/jsonrpc/networkmanagerhandler.cpp index 3793db93..99d76ee6 100644 --- a/server/jsonrpc/networkmanagerhandler.cpp +++ b/server/jsonrpc/networkmanagerhandler.cpp @@ -36,7 +36,35 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) : setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points."); setParams("GetWirelessAccessPoints", params); returns.insert("wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef()); + returns.insert("o:networkError", QVariantList() << JsonTypes::wirelessAccessPointRef()); setReturns("GetWirelessAccessPoints", returns); + + params.clear(); returns.clear(); + setDescription("GetNetworkStatus", "Get the current network manager status."); + setParams("GetNetworkStatus", params); + returns.insert("networkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool)); + returns.insert("wirelessNetworkingEnabled", JsonTypes::basicTypeToString(QVariant::Bool)); + returns.insert("state", JsonTypes::networkManagerStateRef()); + setReturns("GetNetworkStatus", returns); + + params.clear(); returns.clear(); + setDescription("GetNetworkDevices", "Get the list of current network devices."); + setParams("GetNetworkDevices", params); + returns.insert("networkDevices", QVariantList() << JsonTypes::networkDeviceRef()); + setReturns("GetNetworkDevices", returns); + + params.clear(); returns.clear(); + setDescription("ScanWifiNetworks", "Start a wifi scan for searching new networks."); + setParams("ScanWifiNetworks", params); + setReturns("ScanWifiNetworks", returns); + + params.clear(); returns.clear(); + setDescription("ConnectWifiNetwork", "Connect to the wifi network with the given ssid and password."); + params.insert("ssid", JsonTypes::basicTypeToString(QVariant::String)); + params.insert("o:password", JsonTypes::basicTypeToString(QVariant::String)); + setParams("ConnectWifiNetwork", params); + //returns.insert("networkDevices", QVariantList() << JsonTypes::networkDeviceRef()); + setReturns("ConnectWifiNetwork", returns); } QString NetworkManagerHandler::name() const @@ -44,11 +72,29 @@ QString NetworkManagerHandler::name() const return "NetworkManager"; } +JsonReply *NetworkManagerHandler::GetNetworkStatus(const QVariantMap ¶ms) +{ + Q_UNUSED(params); + + // TODO: check available + // TODO: returns (networkManager error) + + QVariantMap returns; + returns.insert("networkingEnabled", GuhCore::instance()->networkManager()->networkingEnabled()); + returns.insert("wirelessNetworkingEnabled", GuhCore::instance()->networkManager()->wirelessEnabled()); + returns.insert("state", JsonTypes::networkManagerStateToString(GuhCore::instance()->networkManager()->state())); + return createReply(returns); +} + JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap ¶ms) { Q_UNUSED(params); QVariantList wirelessAccessPoints; + + // TODO: check available + // TODO: returns (networkManager error) + foreach (WirelessAccessPoint *wirelessAccessPoint, GuhCore::instance()->networkManager()->wirelessNetworkManager()->accessPoints()) wirelessAccessPoints.append(JsonTypes::packWirelessAccessPoint(wirelessAccessPoint)); @@ -57,4 +103,48 @@ JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &par return createReply(returns); } +JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap ¶ms) +{ + Q_UNUSED(params); + + QVariantList networkDevices; + + // TODO: check available + // TODO: returns (networkManager error) + + foreach (NetworkDevice *networkDevice, GuhCore::instance()->networkManager()->networkDevices()) + networkDevices.append(JsonTypes::packNetworkDevice(networkDevice)); + + QVariantMap returns; + returns.insert("networkDevices", networkDevices); + return createReply(returns); +} + +JsonReply *NetworkManagerHandler::ScanWifiNetworks(const QVariantMap ¶ms) +{ + Q_UNUSED(params); + + // TODO: check available + // TODO: returns (networkManager error) + + GuhCore::instance()->networkManager()->wirelessNetworkManager()->scanWirelessNetworks(); + + QVariantMap returns; + return createReply(returns); +} + +JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap ¶ms) +{ + QString ssid = params.value("ssid").toString(); + QString password = params.value("password").toString(); + + // TODO: check available + // TODO: returns (networkManager error) + + GuhCore::instance()->networkManager()->connectWifi(ssid, password); + + QVariantMap returns; + return createReply(returns); +} + } diff --git a/server/jsonrpc/networkmanagerhandler.h b/server/jsonrpc/networkmanagerhandler.h index a2b2416c..29e9c7a0 100644 --- a/server/jsonrpc/networkmanagerhandler.h +++ b/server/jsonrpc/networkmanagerhandler.h @@ -35,7 +35,11 @@ public: QString name() const; + Q_INVOKABLE JsonReply *GetNetworkStatus(const QVariantMap ¶ms); Q_INVOKABLE JsonReply *GetWirelessAccessPoints(const QVariantMap ¶ms); + Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap ¶ms); + Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap ¶ms); + Q_INVOKABLE JsonReply *ConnectWifiNetwork(const QVariantMap ¶ms); signals: diff --git a/server/networkmanager/networkconnection.cpp b/server/networkmanager/networkconnection.cpp index 60b84cc3..667c9aeb 100644 --- a/server/networkmanager/networkconnection.cpp +++ b/server/networkmanager/networkconnection.cpp @@ -48,11 +48,7 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject return; const QDBusArgument &argument = query.arguments().at(0).value(); - ConnectionSettings settingsMap = qdbus_cast(argument); - - foreach (const QString &category, settingsMap.keys()) - if (category == "connection") - qCDebug(dcNetworkManager()) << " --> " << category << qUtf8Printable(QJsonDocument::fromVariant(settingsMap.value(category)).toJson(QJsonDocument::Indented)); + m_connectionSettings = qdbus_cast(argument); } @@ -61,4 +57,49 @@ QDBusObjectPath NetworkConnection::objectPath() const return m_objectPath; } +QString NetworkConnection::id() const +{ + return m_connectionSettings.value("connection").value("id").toString(); +} + +QString NetworkConnection::name() const +{ + return m_connectionSettings.value("connection").value("name").toString(); +} + +QString NetworkConnection::type() const +{ + return m_connectionSettings.value("connection").value("type").toString(); +} + +QUuid NetworkConnection::uuid() const +{ + return m_connectionSettings.value("connection").value("uuid").toUuid(); +} + +QString NetworkConnection::interfaceName() const +{ + return m_connectionSettings.value("connection").value("interface-name").toString(); +} + +bool NetworkConnection::autoconnect() const +{ + return m_connectionSettings.value("connection").value("autoconnect").toBool(); +} + +QDateTime NetworkConnection::timeStamp() const +{ + return QDateTime::fromTime_t(m_connectionSettings.value("connection").value("timestamp").toUInt()); +} + +QDebug operator<<(QDebug debug, NetworkConnection *networkConnection) +{ + debug.nospace() << "NetworkConnection(" << networkConnection->id() << ", "; + debug.nospace() << networkConnection->uuid().toString() << ", "; + debug.nospace() << networkConnection->interfaceName() << ", "; + debug.nospace() << networkConnection->type() << ", "; + debug.nospace() << networkConnection->timeStamp().toString("dd.MM.yyyy hh:mm") << ") "; + return debug; +} + } diff --git a/server/networkmanager/networkconnection.h b/server/networkmanager/networkconnection.h index 526bee22..d258de4f 100644 --- a/server/networkmanager/networkconnection.h +++ b/server/networkmanager/networkconnection.h @@ -21,8 +21,10 @@ #ifndef NETWORKCONNECTION_H #define NETWORKCONNECTION_H +#include #include #include +#include #include #include #include @@ -41,15 +43,29 @@ public: QDBusObjectPath objectPath() const; + ConnectionSettings connectionSettings() const; + + QString id() const; + QString name() const; + QString type() const; + QUuid uuid() const; + QString interfaceName() const; + bool autoconnect() const; + QDateTime timeStamp() const; + private: QDBusObjectPath m_objectPath; + ConnectionSettings m_connectionSettings; + signals: public slots: }; +QDebug operator<<(QDebug debug, NetworkConnection *networkConnection); + } Q_DECLARE_METATYPE(guhserver::ConnectionSettings) diff --git a/server/networkmanager/networkdevice.cpp b/server/networkmanager/networkdevice.cpp index 6db118eb..62686c6b 100644 --- a/server/networkmanager/networkdevice.cpp +++ b/server/networkmanager/networkdevice.cpp @@ -33,7 +33,6 @@ NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) m_deviceState(DeviceStateUnknown), m_deviceStateReason(DeviceStateReasonUnknown) { - QDBusConnection systemBus = QDBusConnection::systemBus(); if (!systemBus.isConnected()) { qCWarning(dcNetworkManager()) << "NetworkDevice: System DBus not connected"; diff --git a/server/networkmanager/networkdevice.h b/server/networkmanager/networkdevice.h index 198744af..fdbfef7f 100644 --- a/server/networkmanager/networkdevice.h +++ b/server/networkmanager/networkdevice.h @@ -169,7 +169,6 @@ public: static QString deviceStateToString(const DeviceState &deviceState); static QString deviceStateReasonToString(const DeviceStateReason &deviceStateReason); - private: QDBusObjectPath m_objectPath; diff --git a/server/networkmanager/networkmanager.cpp b/server/networkmanager/networkmanager.cpp index b04f23de..c4da1754 100644 --- a/server/networkmanager/networkmanager.cpp +++ b/server/networkmanager/networkmanager.cpp @@ -21,13 +21,21 @@ #include "networkmanager.h" #include "loggingcategories.h" +#include "networkconnection.h" + #include +#include namespace guhserver { NetworkManager::NetworkManager(QObject *parent) : QObject(parent), - m_wirelessNetworkManager(0) + m_networkManagerInterface(0), + m_wirelessNetworkManager(0), + m_state(NetworkManagerStateUnknown), + m_connectivityState(NetworkManagerConnectivityStateUnknown), + m_networkingEnabled(false), + m_wirelessEnabled(false) { // Create interface m_networkManagerInterface = new QDBusInterface(serviceString, pathString, serviceString, QDBusConnection::systemBus(), this); @@ -115,6 +123,63 @@ NetworkManager::NetworkManagerConnectivityState NetworkManager::connectivityStat return m_connectivityState; } +NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &ssid, const QString &password) +{ + // https://developer.gnome.org/NetworkManager/stable/ref-settings.html + + QVariantMap connectionSettings; + connectionSettings.insert("autoconnect", true); + connectionSettings.insert("id", ssid +" (guhIO)"); + connectionSettings.insert("type", "802-11-wireless"); + + QVariantMap wirelessSettings; + wirelessSettings.insert("ssid", ssid.toUtf8()); + wirelessSettings.insert("security", "802-11-wireless-security"); + wirelessSettings.insert("mode", "infrastructure"); + + QVariantMap wirelessSecuritySettings; + wirelessSecuritySettings.insert("auth-alg", "open"); + wirelessSecuritySettings.insert("key-mgmt", "wpa-psk"); + wirelessSecuritySettings.insert("psk", password); + + QVariantMap ipv4Settings; + ipv4Settings.insert("method", "auto"); + + QVariantMap ipv6Settings; + ipv6Settings.insert("method", "auto"); + + // Build connection object + ConnectionSettings settings; + settings.insert("connection", connectionSettings); + settings.insert("802-11-wireless", wirelessSettings); + settings.insert("802-11-wireless-security", wirelessSecuritySettings); + settings.insert("ipv4", ipv4Settings); + settings.insert("ipv6", ipv6Settings); + + // Get the access point object path + WirelessAccessPoint *accessPoint = m_wirelessNetworkManager->getAccessPoint(ssid); + if (!accessPoint) { + qCWarning(dcNetworkManager()) << "Could not find access point with ssid:" << ssid; + return NetworkManagerErrorAccessPointNotFound; + } + + // Add connection + QDBusObjectPath connectionObjectPath = m_networkSettings->addConnection(settings); + if (connectionObjectPath.path().isEmpty()) + return NetworkManagerErrorWirelessConnectionFailed; + + // Activate connection + QDBusMessage query = m_networkManagerInterface->call("ActivateConnection", QVariant::fromValue(connectionObjectPath), + QVariant::fromValue(m_wirelessNetworkManager->objectPath()), + QVariant::fromValue(accessPoint->objectPath())); + if(query.type() != QDBusMessage::ReplyMessage) { + qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage(); + return NetworkManagerErrorWirelessConnectionFailed; + } + + return NetworkManagerErrorNoError; +} + bool NetworkManager::networkingEnabled() const { return m_networkingEnabled; diff --git a/server/networkmanager/networkmanager.h b/server/networkmanager/networkmanager.h index 9c0a941c..c787bdec 100644 --- a/server/networkmanager/networkmanager.h +++ b/server/networkmanager/networkmanager.h @@ -42,6 +42,7 @@ class NetworkManager : public QObject Q_OBJECT Q_ENUMS(NetworkManagerState) Q_ENUMS(NetworkManagerConnectivityState) + Q_ENUMS(NetworkManagerError) public: enum NetworkManagerState { @@ -63,6 +64,16 @@ public: NetworkManagerConnectivityStateFull = 5 }; + enum NetworkManagerError { + NetworkManagerErrorNoError, + NetworkManagerErrorWirelessNotAvailable, + NetworkManagerErrorAccessPointNotFound, + NetworkManagerErrorWirelessNetworkingDisabled, + NetworkManagerErrorWirelessConnectionFailed, + NetworkManagerErrorNetworkingDisabled, + NetworkManagerErrorNetworkManagerNotAvailable + }; + explicit NetworkManager(QObject *parent = 0); static bool available(); @@ -73,11 +84,16 @@ public: WirelessNetworkManager *wirelessNetworkManager() const; + QString stateToTranslatedString() const; + // Properties QString version() const; NetworkManagerState state() const; NetworkManagerConnectivityState connectivityState() const; + NetworkManagerError connectWifi(const QString &ssid, const QString &password); + + // Networking bool networkingEnabled() const; bool enableNetworking(); diff --git a/server/networkmanager/networksettings.cpp b/server/networkmanager/networksettings.cpp index 1c1a1af6..6bbb2220 100644 --- a/server/networkmanager/networksettings.cpp +++ b/server/networkmanager/networksettings.cpp @@ -21,7 +21,6 @@ #include "networksettings.h" #include "dbus-interfaces.h" #include "loggingcategories.h" -#include "networkconnection.h" namespace guhserver { @@ -38,12 +37,24 @@ NetworkSettings::NetworkSettings(QObject *parent) : QObject(parent) QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "NewConnection", this, SLOT(connectionAdded(QDBusObjectPath))); QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "ConnectionRemoved", this, SLOT(connectionRemoved(QDBusObjectPath))); QDBusConnection::systemBus().connect(serviceString, settingsPathString, settingsInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap))); +} +QDBusObjectPath NetworkSettings::addConnection(const ConnectionSettings &settings) +{ + QDBusMessage query = m_settingsInterface->call("AddConnection", QVariant::fromValue(settings)); + if(query.type() != QDBusMessage::ReplyMessage) { + qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage(); + return QDBusObjectPath(); + } + + if (query.arguments().isEmpty()) + return QDBusObjectPath(); + + return query.arguments().at(0).value(); } void NetworkSettings::loadConnections() { - // Get QDBusMessage query = m_settingsInterface->call("ListConnections"); if(query.type() != QDBusMessage::ReplyMessage) { qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage(); @@ -65,12 +76,10 @@ void NetworkSettings::loadConnections() void NetworkSettings::connectionAdded(const QDBusObjectPath &objectPath) { - NetworkConnection *connection = new NetworkConnection(objectPath, this); m_connections.insert(objectPath, connection); - qCDebug(dcNetworkManager()) << "Settings: [+]" << objectPath.path(); - + qCDebug(dcNetworkManager()) << "Settings: [+]" << connection; } void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath) diff --git a/server/networkmanager/networksettings.h b/server/networkmanager/networksettings.h index 3ed0f2ed..2ade053f 100644 --- a/server/networkmanager/networksettings.h +++ b/server/networkmanager/networksettings.h @@ -27,6 +27,8 @@ #include #include +#include "networkconnection.h" + namespace guhserver { class NetworkConnection; @@ -37,6 +39,8 @@ class NetworkSettings : public QObject public: explicit NetworkSettings(QObject *parent = 0); + QDBusObjectPath addConnection(const ConnectionSettings &settings); + private: QDBusInterface *m_settingsInterface; QHash m_connections; diff --git a/server/networkmanager/wirelessnetworkmanager.cpp b/server/networkmanager/wirelessnetworkmanager.cpp index 060f9fc4..ef92e7b3 100644 --- a/server/networkmanager/wirelessnetworkmanager.cpp +++ b/server/networkmanager/wirelessnetworkmanager.cpp @@ -24,12 +24,13 @@ #include "loggingcategories.h" #include +#include namespace guhserver { -WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath, QObject *parent) : +WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent) : QObject(parent), - m_path(devicePath.path()), + m_objectPath(objectPath), m_connected(false), m_managed(false), m_state(DeviceStateUnknown), @@ -41,9 +42,9 @@ WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath return; } - QDBusConnection::systemBus().connect(serviceString, m_path, wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath))); - QDBusConnection::systemBus().connect(serviceString, m_path, wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath))); - QDBusConnection::systemBus().connect(serviceString, m_path, deviceInterfaceString, "StateChanged", this, SLOT(deviceStateChanged(quint32,quint32,quint32))); + QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath))); + QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath))); + QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), deviceInterfaceString, "StateChanged", this, SLOT(deviceStateChanged(quint32,quint32,quint32))); readWirelessDeviceProperties(); @@ -52,6 +53,11 @@ WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &devicePath readAccessPoints(); } +QDBusObjectPath WirelessNetworkManager::objectPath() const +{ + return m_objectPath; +} + QString WirelessNetworkManager::udi() const { return m_udi; @@ -105,7 +111,7 @@ void WirelessNetworkManager::scanWirelessNetworks() return; } - QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, systemBus); + QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, systemBus); if(!wirelessInterface.isValid()) { qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not scan wireless networks: Invalid wireless dbus interface"; return; @@ -118,6 +124,7 @@ void WirelessNetworkManager::scanWirelessNetworks() } } + QList WirelessNetworkManager::accessPoints() { return m_accessPointsTable.values(); @@ -155,7 +162,7 @@ QString WirelessNetworkManager::deviceStateReasonToString(const WirelessNetworkM void WirelessNetworkManager::readAccessPoints() { - QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, QDBusConnection::systemBus()); + QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, QDBusConnection::systemBus()); if(!wirelessInterface.isValid()) { qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read access points: Invalid wireless dbus interface"; return; @@ -181,13 +188,13 @@ void WirelessNetworkManager::readAccessPoints() void WirelessNetworkManager::readWirelessDeviceProperties() { - QDBusInterface wirelessInterface(serviceString, m_path, wirelessInterfaceString, QDBusConnection::systemBus()); + QDBusInterface wirelessInterface(serviceString, m_objectPath.path(), wirelessInterfaceString, QDBusConnection::systemBus()); if(!wirelessInterface.isValid()) { qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read access points: Invalid wireless dbus interface"; return; } - QDBusInterface driverInterface(serviceString, m_path, deviceInterfaceString, QDBusConnection::systemBus()); + QDBusInterface driverInterface(serviceString, m_objectPath.path(), deviceInterfaceString, QDBusConnection::systemBus()); if(!driverInterface.isValid()) { qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Could not read driver information: Invalid driver dbus interface"; return; diff --git a/server/networkmanager/wirelessnetworkmanager.h b/server/networkmanager/wirelessnetworkmanager.h index f6fbfaf4..d11f0ba5 100644 --- a/server/networkmanager/wirelessnetworkmanager.h +++ b/server/networkmanager/wirelessnetworkmanager.h @@ -122,7 +122,9 @@ public: DeviceStateReasonParentManagedChanged = 62 }; - explicit WirelessNetworkManager(const QDBusObjectPath &devicePath, QObject *parent = 0); + explicit WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent = 0); + + QDBusObjectPath objectPath() const; QString udi() const; QString macAddress() const; @@ -145,7 +147,7 @@ public: static QString deviceStateReasonToString(const DeviceStateReason &stateReason); private: - QString m_path; + QDBusObjectPath m_objectPath; QString m_udi; QString m_macAddress;