wifi connection working

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);

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<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
                     qCWarning(dcJsonRpc) << "WirelessAccessPoint not matching";
                     return result;
                 }
+            } else if (refName == networkDeviceRef()) {
+                QPair<bool, QString> result = validateMap(networkDeviceDescription(), variant.toMap());
+                if (!result.first) {
+                    qCWarning(dcJsonRpc) << "NetworkDevice not matching";
+                    return result;
+                }
             } else if (refName == basicTypeRef()) {
                 QPair<bool, QString> result = validateBasicType(variant);
                 if (!result.first) {
@@ -1834,6 +1858,12 @@ QPair<bool, QString> 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<bool, QString> 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<bool, QString> 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()));
 }
 

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 <QObject>
@@ -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<Rule> rules);

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 &params)
+{
+    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 &params)
 {
     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 &params)
+{
+    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 &params)
+{
+    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 &params)
+{
+    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);
+}
+
 }

server/jsonrpc/networkmanagerhandler.h

@@ -35,7 +35,11 @@ public:
 
     QString name() const;
 
+    Q_INVOKABLE JsonReply *GetNetworkStatus(const QVariantMap &params);
     Q_INVOKABLE JsonReply *GetWirelessAccessPoints(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *ConnectWifiNetwork(const QVariantMap &params);
 
 signals:
 

server/networkmanager/networkconnection.cpp

@@ -48,11 +48,7 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
         return;
 
     const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>();
-    ConnectionSettings settingsMap = qdbus_cast<ConnectionSettings>(argument);
+    m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
-
-    foreach (const QString &category, settingsMap.keys())
-        if (category == "connection")
-            qCDebug(dcNetworkManager()) << "    --> " << category << qUtf8Printable(QJsonDocument::fromVariant(settingsMap.value(category)).toJson(QJsonDocument::Indented));
 
 }
 
@@ -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;
+}
+
 }

server/networkmanager/networkconnection.h

@@ -21,8 +21,10 @@
 #ifndef NETWORKCONNECTION_H
 #define NETWORKCONNECTION_H
 
+#include <QUuid>
 #include <QDebug>
 #include <QObject>
+#include <QDateTime>
 #include <QDBusMetaType>
 #include <QDBusObjectPath>
 #include <QDBusConnection>
@@ -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)

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";

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;
 

server/networkmanager/networkmanager.cpp

@@ -21,13 +21,21 @@
 #include "networkmanager.h"
 #include "loggingcategories.h"
 
+#include "networkconnection.h"
+
 #include <QMetaEnum>
+#include <QUuid>
 
 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;

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();

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<QDBusObjectPath>();
 }
 
 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)

server/networkmanager/networksettings.h

@@ -27,6 +27,8 @@
 #include <QDBusInterface>
 #include <QDBusArgument>
 
+#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<QDBusObjectPath, NetworkConnection *> m_connections;

server/networkmanager/wirelessnetworkmanager.cpp

@@ -24,12 +24,13 @@
 #include "loggingcategories.h"
 
 #include <QMetaEnum>
+#include <QUuid>
 
 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_objectPath.path(), wirelessInterfaceString, "AccessPointAdded", this, SLOT(accessPointAdded(QDBusObjectPath)));
-    QDBusConnection::systemBus().connect(serviceString, m_path, wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath)));
+    QDBusConnection::systemBus().connect(serviceString, m_objectPath.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(), 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<WirelessAccessPoint *> 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;

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;