ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

continue and improve networkmanager api and functionality

Browse Source
This commit is contained in:
Simon Stürz 2016-10-14 18:12:22 +02:00 committed by Michael Zanetti
parent 8045b5a0e7
commit 41adc0d887
18 changed files with 635 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
server/jsonrpc/cloudhandler.cpp
View File

@ -44,6 +44,13 @@ CloudHandler::CloudHandler(QObject *parent) :
returns.insert("authenticated", JsonTypes::basicTypeToString(JsonTypes::Bool)); returns.insert("authenticated", JsonTypes::basicTypeToString(JsonTypes::Bool));
setReturns("GetConnectionStatus", returns); setReturns("GetConnectionStatus", returns);
params.clear(); returns.clear();
setDescription("Enable", "Enable or disable the cloud connection.");
params.insert("enable", JsonTypes::basicTypeToString(JsonTypes::Bool));
setParams("Enable", params);
returns.insert("cloudError", JsonTypes::cloudErrorRef());
setReturns("Enable", returns);
// Notification // Notification
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("ConnectionStatusChanged", "Emitted whenever the status of the cloud connection changed."); setDescription("ConnectionStatusChanged", "Emitted whenever the status of the cloud connection changed.");
@ -91,6 +98,13 @@ JsonReply *CloudHandler::GetConnectionStatus(const QVariantMap &params) const
return createReply(returns); return createReply(returns);
} }
JsonReply *CloudHandler::Enable(const QVariantMap &params) const
{
bool enable = params.value("enable").toBool();
GuhCore::instance()->configuration()->setCloudEnabled(enable);
return createReply(statusToReply(Cloud::CloudErrorNoError));
}
void CloudHandler::onConnectionStatusChanged() void CloudHandler::onConnectionStatusChanged()
{ {
QVariantMap params; QVariantMap params;

1
server/jsonrpc/cloudhandler.h
View File

@ -40,7 +40,6 @@ public:
Q_INVOKABLE JsonReply *Authenticate(const QVariantMap &params); Q_INVOKABLE JsonReply *Authenticate(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetConnectionStatus(const QVariantMap &params) const; Q_INVOKABLE JsonReply *GetConnectionStatus(const QVariantMap &params) const;
Q_INVOKABLE JsonReply *Enable(const QVariantMap &params) const; Q_INVOKABLE JsonReply *Enable(const QVariantMap &params) const;
Q_INVOKABLE JsonReply *Disable(const QVariantMap &params) const;
private: private:
QList<JsonReply *> m_asyncAuthenticationReplies; QList<JsonReply *> m_asyncAuthenticationReplies;

58
server/jsonrpc/jsontypes.cpp
View File

@ -115,7 +115,8 @@ QVariantMap JsonTypes::s_calendarItem;
QVariantMap JsonTypes::s_timeEventItem; QVariantMap JsonTypes::s_timeEventItem;
QVariantMap JsonTypes::s_repeatingOption; QVariantMap JsonTypes::s_repeatingOption;
QVariantMap JsonTypes::s_wirelessAccessPoint; QVariantMap JsonTypes::s_wirelessAccessPoint;
QVariantMap JsonTypes::s_networkDevice; QVariantMap JsonTypes::s_wiredNetworkDevice;
QVariantMap JsonTypes::s_wirelessNetworkDevice;
void JsonTypes::init() void JsonTypes::init()
{ {
@ -334,9 +335,19 @@ void JsonTypes::init()
s_wirelessAccessPoint.insert("frequency", basicTypeToString(QVariant::Double)); s_wirelessAccessPoint.insert("frequency", basicTypeToString(QVariant::Double));
s_wirelessAccessPoint.insert("signalStrength", basicTypeToString(QVariant::Int)); s_wirelessAccessPoint.insert("signalStrength", basicTypeToString(QVariant::Int));
// NetworkDevice // WiredNetworkDevice
s_networkDevice.insert("name", basicTypeToString(QVariant::String)); s_wiredNetworkDevice.insert("interface", basicTypeToString(QVariant::String));
s_networkDevice.insert("type", basicTypeToString(QVariant::String)); s_wiredNetworkDevice.insert("macAddress", basicTypeToString(QVariant::String));
s_wiredNetworkDevice.insert("state", networkDeviceStateRef());
s_wiredNetworkDevice.insert("bitRate", basicTypeToString(QVariant::String));
s_wiredNetworkDevice.insert("pluggedIn", basicTypeToString(QVariant::Bool));
// WirelessNetworkDevice
s_wirelessNetworkDevice.insert("interface", basicTypeToString(QVariant::String));
s_wirelessNetworkDevice.insert("macAddress", basicTypeToString(QVariant::String));
s_wirelessNetworkDevice.insert("state", networkDeviceStateRef());
s_wirelessNetworkDevice.insert("bitRate", basicTypeToString(QVariant::String));
s_wirelessNetworkDevice.insert("o:currentAccessPoint", wirelessAccessPointRef());
s_initialized = true; s_initialized = true;
} }
@ -412,7 +423,8 @@ QVariantMap JsonTypes::allTypes()
allTypes.insert("TimeEventItem", timeEventItemDescription()); allTypes.insert("TimeEventItem", timeEventItemDescription());
allTypes.insert("RepeatingOption", repeatingOptionDescription()); allTypes.insert("RepeatingOption", repeatingOptionDescription());
allTypes.insert("WirelessAccessPoint", wirelessAccessPointDescription()); allTypes.insert("WirelessAccessPoint", wirelessAccessPointDescription());
allTypes.insert("NetworkDevice", networkDeviceDescription()); allTypes.insert("WiredNetworkDevice", wiredNetworkDeviceDescription());
allTypes.insert("WirelessNetworkDevice", wirelessNetworkDeviceDescription());
return allTypes; return allTypes;
} }
@ -971,11 +983,29 @@ QVariantMap JsonTypes::packWirelessAccessPoint(WirelessAccessPoint *wirelessAcce
return wirelessAccessPointVariant; return wirelessAccessPointVariant;
} }
QVariantMap JsonTypes::packNetworkDevice(NetworkDevice *networkDevice) /*! Returns a variant map of the given \a networkDevice. */
QVariantMap JsonTypes::packWiredNetworkDevice(WiredNetworkDevice *networkDevice)
{ {
QVariantMap networkDeviceVariant; QVariantMap networkDeviceVariant;
networkDeviceVariant.insert("name", networkDevice->interface()); networkDeviceVariant.insert("interface", networkDevice->interface());
networkDeviceVariant.insert("type", NetworkDevice::deviceTypeToString(networkDevice->deviceType())); networkDeviceVariant.insert("macAddress", networkDevice->macAddress());
networkDeviceVariant.insert("state", networkDevice->deviceStateString());
networkDeviceVariant.insert("bitRate", QString("%1 [Mb/s]").arg(QString::number(networkDevice->bitRate())));
networkDeviceVariant.insert("pluggedIn", networkDevice->pluggedIn());
return networkDeviceVariant;
}
/*! Returns a variant map of the given \a networkDevice. */
QVariantMap JsonTypes::packWirelessNetworkDevice(WirelessNetworkDevice *networkDevice)
{
QVariantMap networkDeviceVariant;
networkDeviceVariant.insert("interface", networkDevice->interface());
networkDeviceVariant.insert("macAddress", networkDevice->macAddress());
networkDeviceVariant.insert("state", networkDevice->deviceStateString());
networkDeviceVariant.insert("bitRate", QString("%1 [Mb/s]").arg(QString::number(networkDevice->bitRate())));
if (networkDevice->activeAccessPoint())
networkDeviceVariant.insert("currentAccessPoint", JsonTypes::packWirelessAccessPoint(networkDevice->activeAccessPoint()));
return networkDeviceVariant; return networkDeviceVariant;
} }
@ -1744,10 +1774,16 @@ QPair<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qCWarning(dcJsonRpc) << "WirelessAccessPoint not matching"; qCWarning(dcJsonRpc) << "WirelessAccessPoint not matching";
return result; return result;
} }
} else if (refName == networkDeviceRef()) { } else if (refName == wiredNetworkDeviceRef()) {
QPair<bool, QString> result = validateMap(networkDeviceDescription(), variant.toMap()); QPair<bool, QString> result = validateMap(wiredNetworkDeviceDescription(), variant.toMap());
if (!result.first) { if (!result.first) {
qCWarning(dcJsonRpc) << "NetworkDevice not matching"; qCWarning(dcJsonRpc) << "WiredNetworkDevice not matching";
return result;
}
} else if (refName == wirelessNetworkDeviceRef()) {
QPair<bool, QString> result = validateMap(wirelessNetworkDeviceDescription(), variant.toMap());
if (!result.first) {
qCWarning(dcJsonRpc) << "WirelessNetworkDevice not matching";
return result; return result;
} }
} else if (refName == basicTypeRef()) { } else if (refName == basicTypeRef()) {

9
server/jsonrpc/jsontypes.h
View File

@ -48,7 +48,8 @@
#include "cloud/cloudconnection.h" #include "cloud/cloudconnection.h"
#include "networkmanager/networkmanager.h" #include "networkmanager/networkmanager.h"
#include "networkmanager/networkdevice.h" #include "networkmanager/wirednetworkdevice.h"
#include "networkmanager/wirelessnetworkdevice.h"
#include "networkmanager/wirelessaccesspoint.h" #include "networkmanager/wirelessaccesspoint.h"
#include <QObject> #include <QObject>
@ -161,7 +162,8 @@ public:
DECLARE_OBJECT(timeEventItem, "TimeEventItem") DECLARE_OBJECT(timeEventItem, "TimeEventItem")
DECLARE_OBJECT(repeatingOption, "RepeatingOption") DECLARE_OBJECT(repeatingOption, "RepeatingOption")
DECLARE_OBJECT(wirelessAccessPoint, "WirelessAccessPoint") DECLARE_OBJECT(wirelessAccessPoint, "WirelessAccessPoint")
DECLARE_OBJECT(networkDevice, "NetworkDevice") DECLARE_OBJECT(wiredNetworkDevice, "WiredNetworkDevice")
DECLARE_OBJECT(wirelessNetworkDevice, "WirelessNetworkDevice")
// pack types // pack types
static QVariantMap packEventType(const EventType &eventType); static QVariantMap packEventType(const EventType &eventType);
@ -191,7 +193,8 @@ public:
static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem); static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem);
static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor); static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor);
static QVariantMap packWirelessAccessPoint(WirelessAccessPoint *wirelessAccessPoint); static QVariantMap packWirelessAccessPoint(WirelessAccessPoint *wirelessAccessPoint);
static QVariantMap packNetworkDevice(NetworkDevice *networkDevice); static QVariantMap packWiredNetworkDevice(WiredNetworkDevice *networkDevice);
static QVariantMap packWirelessNetworkDevice(WirelessNetworkDevice *networkDevice);
// pack resources // pack resources
static QVariantList packRules(const QList<Rule> rules); static QVariantList packRules(const QList<Rule> rules);

174
server/jsonrpc/networkmanagerhandler.cpp
View File

@ -58,27 +58,38 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
setReturns("EnableWirelessNetworking", returns); setReturns("EnableWirelessNetworking", returns);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points."); setDescription("GetWirelessAccessPoints", "Get the current list of wireless network access points for the given interface. The interface has to be a WirelessNetworkDevice.");
params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
setParams("GetWirelessAccessPoints", params); setParams("GetWirelessAccessPoints", params);
returns.insert("o:wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef()); returns.insert("o:wirelessAccessPoints", QVariantList() << JsonTypes::wirelessAccessPointRef());
returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef()); returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
setReturns("GetWirelessAccessPoints", returns); setReturns("GetWirelessAccessPoints", returns);
params.clear(); returns.clear();
setDescription("DisconnectInterface", "Disconnect the given network interface. The interface will remain disconnected until the user connect it again.");
params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
setParams("DisconnectInterface", params);
returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
setReturns("DisconnectInterface", returns);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("GetNetworkDevices", "Get the list of current network devices."); setDescription("GetNetworkDevices", "Get the list of current network devices.");
setParams("GetNetworkDevices", params); setParams("GetNetworkDevices", params);
returns.insert("o:networkDevices", QVariantList() << JsonTypes::networkDeviceRef()); returns.insert("wiredNetworkDevices", QVariantList() << JsonTypes::wiredNetworkDeviceRef());
returns.insert("wirelessNetworkDevices", QVariantList() << JsonTypes::wirelessNetworkDeviceRef());
returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef()); returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
setReturns("GetNetworkDevices", returns); setReturns("GetNetworkDevices", returns);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("ScanWifiNetworks", "Start a wifi scan for searching new networks."); setDescription("ScanWifiNetworks", "Start a wifi scan for searching new networks.");
params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
setParams("ScanWifiNetworks", params); setParams("ScanWifiNetworks", params);
returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef()); returns.insert("networkManagerError", JsonTypes::networkManagerErrorRef());
setReturns("ScanWifiNetworks", returns); setReturns("ScanWifiNetworks", returns);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("ConnectWifiNetwork", "Connect to the wifi network with the given ssid and password."); setDescription("ConnectWifiNetwork", "Connect to the wifi network with the given ssid and password.");
params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
params.insert("ssid", JsonTypes::basicTypeToString(QVariant::String)); params.insert("ssid", JsonTypes::basicTypeToString(QVariant::String));
params.insert("o:password", JsonTypes::basicTypeToString(QVariant::String)); params.insert("o:password", JsonTypes::basicTypeToString(QVariant::String));
setParams("ConnectWifiNetwork", params); setParams("ConnectWifiNetwork", params);
@ -92,23 +103,47 @@ NetworkManagerHandler::NetworkManagerHandler(QObject *parent) :
setParams("NetworkStatusChanged", params); setParams("NetworkStatusChanged", params);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("NetworkDeviceChanged", "Emitted whenever a NetworkDevice has changed."); setDescription("WirelessNetworkDeviceAdded", "Emitted whenever a new WirelessNetworkDevice was added.");
params.insert("networkDevice", JsonTypes::networkDeviceRef()); params.insert("wirelessNetworkDevice", JsonTypes::wirelessNetworkDeviceRef());
setParams("NetworkDeviceChanged", params); setParams("WirelessNetworkDeviceAdded", params);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("NetworkDeviceAdded", "Emitted whenever a new NetworkDevice was added."); setDescription("WirelessNetworkDeviceRemoved", "Emitted whenever a WirelessNetworkDevice was removed.");
params.insert("networkDevice", JsonTypes::networkDeviceRef()); params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
setParams("NetworkDeviceAdded", params); setParams("WirelessNetworkDeviceRemoved", params);
params.clear(); returns.clear(); params.clear(); returns.clear();
setDescription("NetworkDeviceRemoved", "Emitted whenever a NetworkDevice was removed."); setDescription("WirelessNetworkDeviceChanged", "Emitted whenever the given WirelessNetworkDevice has changed.");
params.insert("networkDevice", JsonTypes::networkDeviceRef()); params.insert("wirelessNetworkDevice", JsonTypes::wirelessNetworkDeviceRef());
setParams("NetworkDeviceRemoved", params); setParams("WirelessNetworkDeviceChanged", params);
params.clear(); returns.clear();
setDescription("WiredNetworkDeviceAdded", "Emitted whenever a new WiredNetworkDevice was added.");
params.insert("wiredNetworkDevice", JsonTypes::wiredNetworkDeviceRef());
setParams("WiredNetworkDeviceAdded", params);
params.clear(); returns.clear();
setDescription("WiredNetworkDeviceRemoved", "Emitted whenever a WiredNetworkDevice was removed.");
params.insert("interface", JsonTypes::basicTypeToString(QVariant::String));
setParams("WiredNetworkDeviceRemoved", params);
params.clear(); returns.clear();
setDescription("WiredNetworkDeviceChanged", "Emitted whenever the given WiredNetworkDevice has changed.");
params.insert("wiredNetworkDevice", JsonTypes::wiredNetworkDeviceRef());
setParams("WiredNetworkDeviceChanged", params);
connect(GuhCore::instance()->networkManager(), &NetworkManager::stateChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged); connect(GuhCore::instance()->networkManager(), &NetworkManager::stateChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged);
connect(GuhCore::instance()->networkManager(), &NetworkManager::networkingEnabledChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged); connect(GuhCore::instance()->networkManager(), &NetworkManager::networkingEnabledChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wirelessEnabledChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged); connect(GuhCore::instance()->networkManager(), &NetworkManager::wirelessEnabledChanged, this, &NetworkManagerHandler::onNetworkManagerStatusChanged);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wirelessDeviceAdded, this, &NetworkManagerHandler::onWirelessNetworkDeviceAdded);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wirelessDeviceRemoved, this, &NetworkManagerHandler::onWirelessNetworkDeviceRemoved);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wirelessDeviceChanged, this, &NetworkManagerHandler::onWirelessNetworkDeviceChanged);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wiredDeviceAdded, this, &NetworkManagerHandler::onWiredNetworkDeviceAdded);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wiredDeviceRemoved, this, &NetworkManagerHandler::onWiredNetworkDeviceRemoved);
connect(GuhCore::instance()->networkManager(), &NetworkManager::wiredDeviceChanged, this, &NetworkManagerHandler::onWiredNetworkDeviceChanged);
} }
QString NetworkManagerHandler::name() const QString NetworkManagerHandler::name() const
@ -127,7 +162,7 @@ JsonReply *NetworkManagerHandler::GetNetworkStatus(const QVariantMap &params)
// Pack network manager status // Pack network manager status
QVariantMap returns; QVariantMap returns;
returns.insert("status", packNetworkManagerStatus()); returns.insert("status", packNetworkManagerStatus());
returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError)); returns.insert("networkManagerError", JsonTypes::networkManagerErrorToString(NetworkManager::NetworkManagerErrorNoError));
return createReply(returns); return createReply(returns);
} }
@ -160,8 +195,6 @@ JsonReply *NetworkManagerHandler::EnableWirelessNetworking(const QVariantMap &pa
JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &params) JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &params)
{ {
Q_UNUSED(params);
if (!GuhCore::instance()->networkManager()->available()) if (!GuhCore::instance()->networkManager()->available())
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable)); return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
@ -174,14 +207,26 @@ JsonReply *NetworkManagerHandler::GetWirelessAccessPoints(const QVariantMap &par
if (!GuhCore::instance()->networkManager()->wirelessEnabled()) if (!GuhCore::instance()->networkManager()->wirelessEnabled())
return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled)); return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled));
QVariantList wirelessAccessPoints; QString interface = params.value("interface").toString();
foreach (WirelessAccessPoint *wirelessAccessPoint, GuhCore::instance()->networkManager()->wirelessNetworkManager()->accessPoints())
wirelessAccessPoints.append(JsonTypes::packWirelessAccessPoint(wirelessAccessPoint));
QVariantMap returns; if (!GuhCore::instance()->networkManager()->getNetworkDevice(interface))
returns.insert("wirelessAccessPoints", wirelessAccessPoints); return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkInterfaceNotFound));
returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError));
return createReply(returns); foreach (WirelessNetworkDevice *networkDevice, GuhCore::instance()->networkManager()->wirelessNetworkDevices()) {
if (networkDevice->interface() == interface) {
QVariantList wirelessAccessPoints;
foreach (WirelessAccessPoint *wirelessAccessPoint, networkDevice->accessPoints())
wirelessAccessPoints.append(JsonTypes::packWirelessAccessPoint(wirelessAccessPoint));
QVariantMap returns;
returns.insert("wirelessAccessPoints", wirelessAccessPoints);
returns.insert("networkManagerError", JsonTypes::networkManagerErrorToString(NetworkManager::NetworkManagerErrorNoError));
return createReply(returns);
}
}
return createReply(statusToReply(NetworkManager::NetworkManagerErrorInvalidNetworkDeviceType));
} }
JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap &params) JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap &params)
@ -191,13 +236,18 @@ JsonReply *NetworkManagerHandler::GetNetworkDevices(const QVariantMap &params)
if (!GuhCore::instance()->networkManager()->available()) if (!GuhCore::instance()->networkManager()->available())
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable)); return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
QVariantList networkDevices; QVariantList wirelessNetworkDevices;
foreach (NetworkDevice *networkDevice, GuhCore::instance()->networkManager()->networkDevices()) foreach (WirelessNetworkDevice *networkDevice, GuhCore::instance()->networkManager()->wirelessNetworkDevices())
networkDevices.append(JsonTypes::packNetworkDevice(networkDevice)); wirelessNetworkDevices.append(JsonTypes::packWirelessNetworkDevice(networkDevice));
QVariantList wiredNetworkDevices;
foreach (WiredNetworkDevice *networkDevice, GuhCore::instance()->networkManager()->wiredNetworkDevices())
wiredNetworkDevices.append(JsonTypes::packWiredNetworkDevice(networkDevice));
QVariantMap returns; QVariantMap returns;
returns.insert("networkDevices", networkDevices); returns.insert("wirelessNetworkDevices", wirelessNetworkDevices);
returns.insert("networkManagerError", statusToReply(NetworkManager::NetworkManagerErrorNoError)); returns.insert("wiredNetworkDevices", wiredNetworkDevices);
returns.insert("networkManagerError", JsonTypes::networkManagerErrorToString(NetworkManager::NetworkManagerErrorNoError));
return createReply(returns); return createReply(returns);
} }
@ -218,8 +268,19 @@ JsonReply *NetworkManagerHandler::ScanWifiNetworks(const QVariantMap &params)
return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled)); return createReply(statusToReply(NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled));
GuhCore::instance()->networkManager()->wirelessNetworkManager()->scanWirelessNetworks(); QString interface = params.value("interface").toString();
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
if (!GuhCore::instance()->networkManager()->getNetworkDevice(interface))
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkInterfaceNotFound));
foreach (WirelessNetworkDevice *networkDevice, GuhCore::instance()->networkManager()->wirelessNetworkDevices()) {
if (networkDevice->interface() == interface) {
networkDevice->scanWirelessNetworks();
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
}
}
return createReply(statusToReply(NetworkManager::NetworkManagerErrorInvalidNetworkDeviceType));
} }
JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap &params) JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap &params)
@ -239,9 +300,23 @@ JsonReply *NetworkManagerHandler::ConnectWifiNetwork(const QVariantMap &params)
QString ssid = params.value("ssid").toString(); QString ssid = params.value("ssid").toString();
QString password = params.value("password").toString(); QString password = params.value("password").toString();
NetworkManager::NetworkManagerError error = GuhCore::instance()->networkManager()->connectWifi(ssid, password); QString interface = params.value("interface").toString();
return createReply(statusToReply(error)); return createReply(statusToReply(GuhCore::instance()->networkManager()->connectWifi(interface, ssid, password)));
}
JsonReply *NetworkManagerHandler::DisconnectInterface(const QVariantMap &params)
{
if (!GuhCore::instance()->networkManager()->available())
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkManagerNotAvailable));
QString interface = params.value("interface").toString();
NetworkDevice *networkDevice = GuhCore::instance()->networkManager()->getNetworkDevice(interface);
if (!networkDevice)
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNetworkInterfaceNotFound));
networkDevice->disconnectDevice();
return createReply(statusToReply(NetworkManager::NetworkManagerErrorNoError));
} }
QVariantMap NetworkManagerHandler::packNetworkManagerStatus() QVariantMap NetworkManagerHandler::packNetworkManagerStatus()
@ -258,19 +333,46 @@ void NetworkManagerHandler::onNetworkManagerStatusChanged()
emit NetworkStatusChanged(packNetworkManagerStatus()); emit NetworkStatusChanged(packNetworkManagerStatus());
} }
void NetworkManagerHandler::onNetworkDeviceChanged(NetworkDevice *networkDevice) void NetworkManagerHandler::onWirelessNetworkDeviceAdded(WirelessNetworkDevice *networkDevice)
{ {
Q_UNUSED(networkDevice) QVariantMap notification;
notification.insert("wirelessNetworkDevice", JsonTypes::packWirelessNetworkDevice(networkDevice));
emit WirelessNetworkDeviceAdded(notification);
} }
void NetworkManagerHandler::onNetworkDeviceAdded(NetworkDevice *networkDevice) void NetworkManagerHandler::onWirelessNetworkDeviceRemoved(const QString &interface)
{ {
Q_UNUSED(networkDevice) QVariantMap notification;
notification.insert("interface", interface);
emit WirelessNetworkDeviceRemoved(notification);
} }
void NetworkManagerHandler::onNetworkDeviceRemoved(NetworkDevice *networkDevice) void NetworkManagerHandler::onWirelessNetworkDeviceChanged(WirelessNetworkDevice *networkDevice)
{ {
Q_UNUSED(networkDevice) QVariantMap notification;
notification.insert("wirelessNetworkDevice", JsonTypes::packWirelessNetworkDevice(networkDevice));
emit WirelessNetworkDeviceChanged(notification);
}
void NetworkManagerHandler::onWiredNetworkDeviceAdded(WiredNetworkDevice *networkDevice)
{
QVariantMap notification;
notification.insert("wiredNetworkDevice", JsonTypes::packWiredNetworkDevice(networkDevice));
emit WiredNetworkDeviceAdded(notification);
}
void NetworkManagerHandler::onWiredNetworkDeviceRemoved(const QString &interface)
{
QVariantMap notification;
notification.insert("interface", interface);
emit WiredNetworkDeviceRemoved(notification);
}
void NetworkManagerHandler::onWiredNetworkDeviceChanged(WiredNetworkDevice *networkDevice)
{
QVariantMap notification;
notification.insert("wiredNetworkDevice", JsonTypes::packWiredNetworkDevice(networkDevice));
emit WiredNetworkDeviceChanged(notification);
} }
} }

28
server/jsonrpc/networkmanagerhandler.h
View File

@ -42,21 +42,37 @@ public:
Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap &params); Q_INVOKABLE JsonReply *GetNetworkDevices(const QVariantMap &params);
Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap &params); Q_INVOKABLE JsonReply *ScanWifiNetworks(const QVariantMap &params);
Q_INVOKABLE JsonReply *ConnectWifiNetwork(const QVariantMap &params); Q_INVOKABLE JsonReply *ConnectWifiNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *DisconnectInterface(const QVariantMap &params);
private: private:
QVariantMap packNetworkManagerStatus(); QVariantMap packNetworkManagerStatus();
signals: signals:
// NetworkManager
void NetworkStatusChanged(const QVariantMap &params); void NetworkStatusChanged(const QVariantMap &params);
void NetworkDeviceChanged(const QVariantMap &params);
void NetworkDeviceAdded(const QVariantMap &params); // NetworkDevices
void NetworkDeviceRemoved(const QVariantMap &params); void WiredNetworkDeviceAdded(const QVariantMap &params);
void WiredNetworkDeviceRemoved(const QVariantMap &params);
void WiredNetworkDeviceChanged(const QVariantMap &params);
void WirelessNetworkDeviceAdded(const QVariantMap &params);
void WirelessNetworkDeviceRemoved(const QVariantMap &params);
void WirelessNetworkDeviceChanged(const QVariantMap &params);
private slots: private slots:
// NetworkManager
void onNetworkManagerStatusChanged(); void onNetworkManagerStatusChanged();
void onNetworkDeviceChanged(NetworkDevice *networkDevice);
void onNetworkDeviceAdded(NetworkDevice *networkDevice); // NetworkDevices
void onNetworkDeviceRemoved(NetworkDevice *networkDevice); void onWirelessNetworkDeviceAdded(WirelessNetworkDevice *networkDevice);
void onWirelessNetworkDeviceRemoved(const QString &interface);
void onWirelessNetworkDeviceChanged(WirelessNetworkDevice *networkDevice);
void onWiredNetworkDeviceAdded(WiredNetworkDevice *networkDevice);
void onWiredNetworkDeviceRemoved(const QString &interface);
void onWiredNetworkDeviceChanged(WiredNetworkDevice *networkDevice);
}; };
} }

1
server/networkmanager/dbus-interfaces.h
View File

@ -32,6 +32,7 @@ static const QString settingsPathString("/org/freedesktop/NetworkManager/Setting
static const QString deviceInterfaceString("org.freedesktop.NetworkManager.Device"); static const QString deviceInterfaceString("org.freedesktop.NetworkManager.Device");
static const QString wirelessInterfaceString("org.freedesktop.NetworkManager.Device.Wireless"); static const QString wirelessInterfaceString("org.freedesktop.NetworkManager.Device.Wireless");
static const QString wiredInterfaceString("org.freedesktop.NetworkManager.Device.Wired");
static const QString accessPointInterfaceString("org.freedesktop.NetworkManager.AccessPoint"); static const QString accessPointInterfaceString("org.freedesktop.NetworkManager.AccessPoint");
static const QString settingsInterfaceString("org.freedesktop.NetworkManager.Settings"); static const QString settingsInterfaceString("org.freedesktop.NetworkManager.Settings");
static const QString connectionsInterfaceString("org.freedesktop.NetworkManager.Settings.Connection"); static const QString connectionsInterfaceString("org.freedesktop.NetworkManager.Settings.Connection");

49
server/networkmanager/networkdevice.cpp
View File

@ -39,30 +39,31 @@ NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent)
return; return;
} }
QDBusInterface networkDeviceInterface(serviceString, m_objectPath.path(), deviceInterfaceString, QDBusConnection::systemBus()); m_networkDeviceInterface = new QDBusInterface(serviceString, m_objectPath.path(), deviceInterfaceString, QDBusConnection::systemBus(), this);
if(!networkDeviceInterface.isValid()) { if(!m_networkDeviceInterface->isValid()) {
qCWarning(dcNetworkManager()) << "NetworkDevice: Invalid DBus device interface" << m_objectPath.path(); qCWarning(dcNetworkManager()) << "NetworkDevice: Invalid DBus device interface" << m_objectPath.path();
return; return;
} }
m_udi = networkDeviceInterface.property("Udi").toString(); m_udi = m_networkDeviceInterface->property("Udi").toString();
m_interface = networkDeviceInterface.property("Interface").toString(); m_interface = m_networkDeviceInterface->property("Interface").toString();
m_ipInterface = networkDeviceInterface.property("IpInterface").toString(); m_ipInterface = m_networkDeviceInterface->property("IpInterface").toString();
m_driver = networkDeviceInterface.property("Driver").toString(); m_driver = m_networkDeviceInterface->property("Driver").toString();
m_driverVersion = networkDeviceInterface.property("DriverVersion").toString(); m_driverVersion = m_networkDeviceInterface->property("DriverVersion").toString();
m_firmwareVersion = networkDeviceInterface.property("FirmwareVersion").toString(); m_firmwareVersion = m_networkDeviceInterface->property("FirmwareVersion").toString();
m_physicalPortId = networkDeviceInterface.property("PhysicalPortId").toString(); m_physicalPortId = m_networkDeviceInterface->property("PhysicalPortId").toString();
m_mtu = networkDeviceInterface.property("Mtu").toUInt(); m_mtu = m_networkDeviceInterface->property("Mtu").toUInt();
m_metered = networkDeviceInterface.property("Metered").toUInt(); m_metered = m_networkDeviceInterface->property("Metered").toUInt();
m_autoconnect = networkDeviceInterface.property("Autoconnect").toBool(); m_autoconnect = m_networkDeviceInterface->property("Autoconnect").toBool();
m_deviceState = NetworkDeviceState(networkDeviceInterface.property("State").toUInt()); m_deviceState = NetworkDeviceState(m_networkDeviceInterface->property("State").toUInt());
m_deviceType = DeviceType(networkDeviceInterface.property("DeviceType").toUInt()); m_deviceType = DeviceType(m_networkDeviceInterface->property("DeviceType").toUInt());
m_activeConnection = qdbus_cast<QDBusObjectPath>(networkDeviceInterface.property("ActiveConnection")); m_activeConnection = qdbus_cast<QDBusObjectPath>(m_networkDeviceInterface->property("ActiveConnection"));
m_ip4Config = qdbus_cast<QDBusObjectPath>(networkDeviceInterface.property("Ip4Config")); m_ip4Config = qdbus_cast<QDBusObjectPath>(m_networkDeviceInterface->property("Ip4Config"));
m_ip6Config = qdbus_cast<QDBusObjectPath>(networkDeviceInterface.property("Ip6Config")); m_ip6Config = qdbus_cast<QDBusObjectPath>(m_networkDeviceInterface->property("Ip6Config"));
QDBusConnection::systemBus().connect(serviceString, m_objectPath.path(), deviceInterfaceString, "StateChanged", this, SLOT(onStateChanged(uint,uint,uint)));
} }
QDBusObjectPath NetworkDevice::objectPath() const QDBusObjectPath NetworkDevice::objectPath() const
@ -155,6 +156,14 @@ QList<QDBusObjectPath> NetworkDevice::availableConnections() const
return m_availableConnections; return m_availableConnections;
} }
void NetworkDevice::disconnectDevice()
{
QDBusMessage query = m_networkDeviceInterface->call("Disconnect");
if(query.type() != QDBusMessage::ReplyMessage)
qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
}
QString NetworkDevice::deviceTypeToString(const NetworkDevice::DeviceType &deviceType) QString NetworkDevice::deviceTypeToString(const NetworkDevice::DeviceType &deviceType)
{ {
QMetaObject metaObject = NetworkDevice::staticMetaObject; QMetaObject metaObject = NetworkDevice::staticMetaObject;
@ -182,11 +191,9 @@ QString NetworkDevice::deviceStateReasonToString(const NetworkDevice::NetworkDev
void NetworkDevice::onStateChanged(uint newState, uint oldState, uint reason) void NetworkDevice::onStateChanged(uint newState, uint oldState, uint reason)
{ {
Q_UNUSED(oldState); Q_UNUSED(oldState);
qCDebug(dcNetworkManager()) << m_interface << "--> State changed:" << deviceStateToString(NetworkDeviceState(newState)) << ":" << deviceStateReasonToString(NetworkDeviceStateReason(reason));
qCDebug(dcNetworkManager()) << m_interface << deviceStateToString(NetworkDeviceState(newState)) << ":" << deviceStateReasonToString(NetworkDeviceStateReason(reason));
m_deviceState = NetworkDeviceState(newState); m_deviceState = NetworkDeviceState(newState);
emit deviceStateChanged(); emit deviceChanged();
} }
QDebug operator<<(QDebug debug, NetworkDevice *device) QDebug operator<<(QDebug debug, NetworkDevice *device)

6
server/networkmanager/networkdevice.h
View File

@ -169,11 +169,15 @@ public:
QDBusObjectPath ip4Config() const; QDBusObjectPath ip4Config() const;
QList<QDBusObjectPath> availableConnections() const; QList<QDBusObjectPath> availableConnections() const;
// Method
void disconnectDevice();
static QString deviceTypeToString(const DeviceType &deviceType); static QString deviceTypeToString(const DeviceType &deviceType);
static QString deviceStateToString(const NetworkDeviceState &deviceState); static QString deviceStateToString(const NetworkDeviceState &deviceState);
static QString deviceStateReasonToString(const NetworkDeviceStateReason &deviceStateReason); static QString deviceStateReasonToString(const NetworkDeviceStateReason &deviceStateReason);
private: private:
QDBusInterface *m_networkDeviceInterface;
QDBusObjectPath m_objectPath; QDBusObjectPath m_objectPath;
// Device properties // Device properties
@ -201,7 +205,7 @@ private slots:
void onStateChanged(uint newState, uint oldState, uint reason); void onStateChanged(uint newState, uint oldState, uint reason);
signals: signals:
void deviceStateChanged(); void deviceChanged();
}; };

125
server/networkmanager/networkmanager.cpp
View File

@ -30,7 +30,6 @@ namespace guhserver {
NetworkManager::NetworkManager(QObject *parent) : NetworkManager::NetworkManager(QObject *parent) :
QObject(parent), QObject(parent),
m_networkManagerInterface(0), m_networkManagerInterface(0),
m_wirelessNetworkManager(0),
m_available(false), m_available(false),
m_wifiAvailable(false), m_wifiAvailable(false),
m_state(NetworkManagerStateUnknown), m_state(NetworkManagerStateUnknown),
@ -70,7 +69,6 @@ NetworkManager::NetworkManager(QObject *parent) :
// Create settings // Create settings
m_networkSettings = new NetworkSettings(this); m_networkSettings = new NetworkSettings(this);
} }
bool NetworkManager::available() bool NetworkManager::available()
@ -88,9 +86,23 @@ QList<NetworkDevice *> NetworkManager::networkDevices() const
return m_networkDevices.values(); return m_networkDevices.values();
} }
WirelessNetworkManager *NetworkManager::wirelessNetworkManager() const QList<WirelessNetworkDevice *> NetworkManager::wirelessNetworkDevices() const
{ {
return m_wirelessNetworkManager; return m_wirelessNetworkDevices.values();
}
QList<WiredNetworkDevice *> NetworkManager::wiredNetworkDevices() const
{
return m_wiredNetworkDevices.values();
}
NetworkDevice *NetworkManager::getNetworkDevice(const QString &interface)
{
foreach (NetworkDevice *device, m_networkDevices.values()) {
if (device->interface() == interface)
return device;
}
return Q_NULLPTR;
} }
QString NetworkManager::version() const QString NetworkManager::version() const
@ -113,8 +125,27 @@ NetworkManager::NetworkManagerConnectivityState NetworkManager::connectivityStat
return m_connectivityState; return m_connectivityState;
} }
NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &ssid, const QString &password) NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &interface, const QString &ssid, const QString &password)
{ {
// Check interface
if (!getNetworkDevice(interface))
return NetworkManagerErrorNetworkInterfaceNotFound;
// Get wirelessNetworkDevice
WirelessNetworkDevice *wirelessNetworkDevice = 0;
foreach (WirelessNetworkDevice *networkDevice, wirelessNetworkDevices()) {
if (networkDevice->interface() == interface)
wirelessNetworkDevice = networkDevice;
}
if (!wirelessNetworkDevice)
return NetworkManagerErrorInvalidNetworkDeviceType;
// Get the access point object path
WirelessAccessPoint *accessPoint = wirelessNetworkDevice->getAccessPoint(ssid);
if (!accessPoint)
return NetworkManagerErrorAccessPointNotFound;
// https://developer.gnome.org/NetworkManager/stable/ref-settings.html // https://developer.gnome.org/NetworkManager/stable/ref-settings.html
QVariantMap connectionSettings; QVariantMap connectionSettings;
@ -146,12 +177,7 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &s
settings.insert("ipv4", ipv4Settings); settings.insert("ipv4", ipv4Settings);
settings.insert("ipv6", ipv6Settings); settings.insert("ipv6", ipv6Settings);
// Get the access point object path // TODO: check if connection exists
WirelessAccessPoint *accessPoint = m_wirelessNetworkManager->getAccessPoint(ssid);
if (!accessPoint) {
qCWarning(dcNetworkManager()) << "Could not find access point with ssid:" << ssid;
return NetworkManagerErrorAccessPointNotFound;
}
// Add connection // Add connection
QDBusObjectPath connectionObjectPath = m_networkSettings->addConnection(settings); QDBusObjectPath connectionObjectPath = m_networkSettings->addConnection(settings);
@ -159,9 +185,7 @@ NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &s
return NetworkManagerErrorWirelessConnectionFailed; return NetworkManagerErrorWirelessConnectionFailed;
// Activate connection // Activate connection
QDBusMessage query = m_networkManagerInterface->call("ActivateConnection", QVariant::fromValue(connectionObjectPath), QDBusMessage query = m_networkManagerInterface->call("ActivateConnection", QVariant::fromValue(connectionObjectPath), QVariant::fromValue(wirelessNetworkDevice->objectPath()), QVariant::fromValue(accessPoint->objectPath()));
QVariant::fromValue(m_wirelessNetworkManager->objectPath()),
QVariant::fromValue(accessPoint->objectPath()));
if(query.type() != QDBusMessage::ReplyMessage) { if(query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage(); qCWarning(dcNetworkManager()) << query.errorName() << query.errorMessage();
return NetworkManagerErrorWirelessConnectionFailed; return NetworkManagerErrorWirelessConnectionFailed;
@ -280,15 +304,42 @@ void NetworkManager::onDeviceAdded(const QDBusObjectPath &deviceObjectPath)
return; return;
} }
NetworkDevice *networkDevice = new NetworkDevice(deviceObjectPath, this); // Get device Type
qCDebug(dcNetworkManager()) << "[+]" << networkDevice; QDBusInterface networkDeviceInterface(serviceString, deviceObjectPath.path(), deviceInterfaceString, QDBusConnection::systemBus());
if(!networkDeviceInterface.isValid()) {
if (!m_wirelessNetworkManager && networkDevice->deviceType() == NetworkDevice::DeviceTypeWifi) { qCWarning(dcNetworkManager()) << "NetworkDevice: Invalid DBus device interface" << deviceObjectPath.path();
m_wifiAvailable = true; return;
m_wirelessNetworkManager = new WirelessNetworkManager(networkDevice->objectPath(), this);
} }
m_networkDevices.insert(deviceObjectPath, networkDevice); // Create object
NetworkDevice::DeviceType deviceType = NetworkDevice::DeviceType(networkDeviceInterface.property("DeviceType").toUInt());
switch (deviceType) {
case NetworkDevice::DeviceTypeWifi: {
WirelessNetworkDevice *wirelessNetworkDevice = new WirelessNetworkDevice(deviceObjectPath, this);
qCDebug(dcNetworkManager()) << "[+]" << wirelessNetworkDevice;
m_wifiAvailable = true;
m_networkDevices.insert(deviceObjectPath, wirelessNetworkDevice);
m_wirelessNetworkDevices.insert(deviceObjectPath, wirelessNetworkDevice);
connect(wirelessNetworkDevice, &WirelessNetworkDevice::deviceChanged, this, &NetworkManager::onWirelessDeviceChanged);
emit wirelessDeviceAdded(wirelessNetworkDevice);
break;
}
case NetworkDevice::DeviceTypeEthernet: {
WiredNetworkDevice *wiredNetworkDevice = new WiredNetworkDevice(deviceObjectPath, this);
qCDebug(dcNetworkManager()) << "[+]" << wiredNetworkDevice;
m_networkDevices.insert(deviceObjectPath, wiredNetworkDevice);
m_wiredNetworkDevices.insert(deviceObjectPath, wiredNetworkDevice);
connect(wiredNetworkDevice, &WiredNetworkDevice::deviceChanged, this, &NetworkManager::onWiredDeviceChanged);
emit wiredDeviceAdded(wiredNetworkDevice);
break;
}
default:
NetworkDevice *networkDevice = new NetworkDevice(deviceObjectPath, this);
qCDebug(dcNetworkManager()) << "[+]" << networkDevice;
m_networkDevices.insert(deviceObjectPath, networkDevice);
break;
}
} }
void NetworkManager::onDeviceRemoved(const QDBusObjectPath &deviceObjectPath) void NetworkManager::onDeviceRemoved(const QDBusObjectPath &deviceObjectPath)
@ -299,14 +350,28 @@ void NetworkManager::onDeviceRemoved(const QDBusObjectPath &deviceObjectPath)
} }
NetworkDevice *networkDevice = m_networkDevices.take(deviceObjectPath); NetworkDevice *networkDevice = m_networkDevices.take(deviceObjectPath);
qCDebug(dcNetworkManager()) << "[-]" << networkDevice;
if (m_wiredNetworkDevices.contains(deviceObjectPath)) {
qCDebug(dcNetworkManager()) << "[-]" << m_wiredNetworkDevices.value(deviceObjectPath);
m_wiredNetworkDevices.remove(deviceObjectPath);
emit wiredDeviceRemoved(networkDevice->interface());
} else if (m_wirelessNetworkDevices.contains(deviceObjectPath)) {
qCDebug(dcNetworkManager()) << "[-]" << m_wirelessNetworkDevices.value(deviceObjectPath);
m_wirelessNetworkDevices.remove(deviceObjectPath);
emit wirelessDeviceRemoved(networkDevice->interface());
} else {
qCDebug(dcNetworkManager()) << "[-]" << networkDevice;
}
// Check if wireless is still available
if (m_wirelessNetworkDevices.isEmpty())
m_wifiAvailable = false;
networkDevice->deleteLater(); networkDevice->deleteLater();
} }
void NetworkManager::onPropertiesChanged(const QVariantMap &properties) void NetworkManager::onPropertiesChanged(const QVariantMap &properties)
{ {
//qCDebug(dcNetworkManager()) << "Network manager properties changed" << properties;
if (properties.contains("Version")) if (properties.contains("Version"))
setVersion(properties.value("Version").toString()); setVersion(properties.value("Version").toString());
@ -324,4 +389,16 @@ void NetworkManager::onPropertiesChanged(const QVariantMap &properties)
} }
void NetworkManager::onWirelessDeviceChanged()
{
WirelessNetworkDevice *networkDevice = static_cast<WirelessNetworkDevice *>(sender());
emit wirelessDeviceChanged(networkDevice);
}
void NetworkManager::onWiredDeviceChanged()
{
WiredNetworkDevice *networkDevice = static_cast<WiredNetworkDevice *>(sender());
emit wiredDeviceChanged(networkDevice);
}
} }

27
server/networkmanager/networkmanager.h
View File

@ -28,9 +28,9 @@
#include <QDBusContext> #include <QDBusContext>
#include <QDBusArgument> #include <QDBusArgument>
#include "wirelessnetworkmanager.h"
#include "dbus-interfaces.h" #include "dbus-interfaces.h"
#include "networkdevice.h" #include "wirednetworkdevice.h"
#include "wirelessnetworkdevice.h"
#include "networksettings.h" #include "networksettings.h"
// Docs: https://developer.gnome.org/NetworkManager/unstable/spec.html // Docs: https://developer.gnome.org/NetworkManager/unstable/spec.html
@ -69,6 +69,8 @@ public:
NetworkManagerErrorUnknownError, NetworkManagerErrorUnknownError,
NetworkManagerErrorWirelessNotAvailable, NetworkManagerErrorWirelessNotAvailable,
NetworkManagerErrorAccessPointNotFound, NetworkManagerErrorAccessPointNotFound,
NetworkManagerErrorNetworkInterfaceNotFound,
NetworkManagerErrorInvalidNetworkDeviceType,
NetworkManagerErrorWirelessNetworkingDisabled, NetworkManagerErrorWirelessNetworkingDisabled,
NetworkManagerErrorWirelessConnectionFailed, NetworkManagerErrorWirelessConnectionFailed,
NetworkManagerErrorNetworkingDisabled, NetworkManagerErrorNetworkingDisabled,
@ -81,7 +83,10 @@ public:
bool wifiAvailable(); bool wifiAvailable();
QList<NetworkDevice *> networkDevices() const; QList<NetworkDevice *> networkDevices() const;
WirelessNetworkManager *wirelessNetworkManager() const; QList<WirelessNetworkDevice *> wirelessNetworkDevices() const;
QList<WiredNetworkDevice *> wiredNetworkDevices() const;
NetworkDevice *getNetworkDevice(const QString &interface);
// Properties // Properties
QString version() const; QString version() const;
@ -89,7 +94,7 @@ public:
QString stateString() const; QString stateString() const;
NetworkManagerConnectivityState connectivityState() const; NetworkManagerConnectivityState connectivityState() const;
NetworkManagerError connectWifi(const QString &ssid, const QString &password); NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password);
// Networking // Networking
bool networkingEnabled() const; bool networkingEnabled() const;
@ -101,10 +106,12 @@ public:
private: private:
QDBusInterface *m_networkManagerInterface; QDBusInterface *m_networkManagerInterface;
QHash<QDBusObjectPath, NetworkDevice *> m_networkDevices; QHash<QDBusObjectPath, NetworkDevice *> m_networkDevices;
QHash<QDBusObjectPath, WirelessNetworkDevice *> m_wirelessNetworkDevices;
QHash<QDBusObjectPath, WiredNetworkDevice *> m_wiredNetworkDevices;
NetworkSettings *m_networkSettings; NetworkSettings *m_networkSettings;
WirelessNetworkManager *m_wirelessNetworkManager;
bool m_available; bool m_available;
bool m_wifiAvailable; bool m_wifiAvailable;
@ -134,11 +141,21 @@ signals:
void stateChanged(); void stateChanged();
void connectivityStateChanged(); void connectivityStateChanged();
void wirelessDeviceAdded(WirelessNetworkDevice *wirelessDevice);
void wirelessDeviceRemoved(const QString &interface);
void wirelessDeviceChanged(WirelessNetworkDevice *wirelessDevice);
void wiredDeviceAdded(WiredNetworkDevice *wirelessDevice);
void wiredDeviceRemoved(const QString &interface);
void wiredDeviceChanged(WiredNetworkDevice *wirelessDevice);
private slots: private slots:
void onDeviceAdded(const QDBusObjectPath &deviceObjectPath); void onDeviceAdded(const QDBusObjectPath &deviceObjectPath);
void onDeviceRemoved(const QDBusObjectPath &deviceObjectPath); void onDeviceRemoved(const QDBusObjectPath &deviceObjectPath);
void onPropertiesChanged(const QVariantMap &properties); void onPropertiesChanged(const QVariantMap &properties);
void onWirelessDeviceChanged();
void onWiredDeviceChanged();
}; };
} }

8
server/networkmanager/networksettings.cpp
View File

@ -79,17 +79,19 @@ void NetworkSettings::connectionAdded(const QDBusObjectPath &objectPath)
NetworkConnection *connection = new NetworkConnection(objectPath, this); NetworkConnection *connection = new NetworkConnection(objectPath, this);
m_connections.insert(objectPath, connection); m_connections.insert(objectPath, connection);
qCDebug(dcNetworkManager()) << "Settings: [+]" << connection; //qCDebug(dcNetworkManager()) << "Settings: [+]" << connection;
} }
void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath) void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath)
{ {
qCDebug(dcNetworkManager()) << "Settings: [-]" << objectPath.path(); Q_UNUSED(objectPath);
//qCDebug(dcNetworkManager()) << "Settings: [-]" << objectPath.path();
} }
void NetworkSettings::propertiesChanged(const QVariantMap &properties) void NetworkSettings::propertiesChanged(const QVariantMap &properties)
{ {
qCDebug(dcNetworkManager()) << "Settins: properties changed" << properties; Q_UNUSED(properties);
//qCDebug(dcNetworkManager()) << "Settins: properties changed" << properties;
} }
} }

95
server/networkmanager/wirednetworkdevice.cpp Normal file
View File

@ -0,0 +1,95 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 2016 Simon Stürz <simon.stuerz@guh.io> *
* *
* This file is part of guh. *
* *
* Guh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, version 2 of the License. *
* *
* Guh 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with guh. If not, see <http://www.gnu.org/licenses/>. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "wirednetworkdevice.h"
#include "loggingcategories.h"
namespace guhserver {
WiredNetworkDevice::WiredNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) :
NetworkDevice(objectPath, parent)
{
QDBusConnection systemBus = QDBusConnection::systemBus();
if (!systemBus.isConnected()) {
qCWarning(dcNetworkManager()) << "WiredNetworkDevice: System DBus not connected";
return;
}
m_wiredInterface = new QDBusInterface(serviceString, this->objectPath().path(), wiredInterfaceString, systemBus, this);
if(!m_wiredInterface->isValid()) {
qCWarning(dcNetworkManager()) << "WiredNetworkDevice: Invalid wired dbus interface";
return;
}
setMacAddress(m_wiredInterface->property("HwAddress").toString());
setBitRate(m_wiredInterface->property("Bitrate").toInt());
setPluggedIn(m_wiredInterface->property("Carrier").toBool());
QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wiredInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap)));
}
QString WiredNetworkDevice::macAddress() const
{
return m_macAddress;
}
int WiredNetworkDevice::bitRate() const
{
return m_bitRate;
}
bool WiredNetworkDevice::pluggedIn() const
{
return m_pluggedIn;
}
void WiredNetworkDevice::setMacAddress(const QString &macAddress)
{
m_macAddress = macAddress;
}
void WiredNetworkDevice::setBitRate(const int &bitRate)
{
m_bitRate = bitRate;
}
void WiredNetworkDevice::setPluggedIn(const bool &pluggedIn)
{
m_pluggedIn = pluggedIn;
}
void WiredNetworkDevice::propertiesChanged(const QVariantMap &properties)
{
if (properties.contains("Carrier"))
setPluggedIn(properties.value("Carrier").toBool());
}
QDebug operator<<(QDebug debug, WiredNetworkDevice *networkDevice)
{
debug.nospace() << "WiredNetworkDevice(" << networkDevice->interface() << ", ";
debug.nospace() << networkDevice->macAddress() << ", ";
debug.nospace() << networkDevice->bitRate() << " [Mb/s], ";
debug.nospace() << networkDevice->pluggedIn() << ", ";
debug.nospace() << networkDevice->deviceStateString() << ") ";
return debug;
}
}

61
server/networkmanager/wirednetworkdevice.h Normal file
View File

@ -0,0 +1,61 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 2016 Simon Stürz <simon.stuerz@guh.io> *
* *
* This file is part of guh. *
* *
* Guh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, version 2 of the License. *
* *
* Guh 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with guh. If not, see <http://www.gnu.org/licenses/>. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef WIREDNETWORKDEVICE_H
#define WIREDNETWORKDEVICE_H
#include <QObject>
#include <QDBusObjectPath>
#include "networkdevice.h"
namespace guhserver {
class WiredNetworkDevice : public NetworkDevice
{
Q_OBJECT
public:
explicit WiredNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = 0);
QString macAddress() const;
int bitRate() const;
bool pluggedIn() const;
private:
QDBusInterface *m_wiredInterface;
QString m_macAddress;
int m_bitRate;
bool m_pluggedIn;
void setMacAddress(const QString &macAddress);
void setBitRate(const int &bitRate);
void setPluggedIn(const bool &pluggedIn);
private slots:
void propertiesChanged(const QVariantMap &properties);
};
QDebug operator<<(QDebug debug, WiredNetworkDevice *networkDevice);
}
#endif // WIREDNETWORKDEVICE_H

1
server/networkmanager/wirelessaccesspoint.cpp
View File

@ -102,7 +102,6 @@ void WirelessAccessPoint::setSecurityFlags(const WirelessAccessPoint::ApSecurity
void WirelessAccessPoint::onPropertiesChanged(const QVariantMap &properties) void WirelessAccessPoint::onPropertiesChanged(const QVariantMap &properties)
{ {
//qCDebug(dcNetworkManager()) << "AccessPoint" << ssid() << ": Properties changed" << properties;
if (properties.contains("Strength")) if (properties.contains("Strength"))
setSignalStrength(properties.value("Strength").toUInt()); setSignalStrength(properties.value("Strength").toUInt());

105
server/networkmanager/wirelessnetworkmanager.cpp → server/networkmanager/wirelessnetworkdevice.cpp
View File

@ -18,7 +18,7 @@
* * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "wirelessnetworkmanager.h" #include "wirelessnetworkdevice.h"
#include "dbus-interfaces.h" #include "dbus-interfaces.h"
#include "loggingcategories.h" #include "loggingcategories.h"
@ -28,18 +28,19 @@
namespace guhserver { namespace guhserver {
WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent) : WirelessNetworkDevice::WirelessNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) :
NetworkDevice(objectPath, parent) NetworkDevice(objectPath, parent),
m_activeAccessPoint(Q_NULLPTR)
{ {
QDBusConnection systemBus = QDBusConnection::systemBus(); QDBusConnection systemBus = QDBusConnection::systemBus();
if (!systemBus.isConnected()) { if (!systemBus.isConnected()) {
qCWarning(dcNetworkManager()) << "WirelessNetworkManager: System DBus not connected"; qCWarning(dcNetworkManager()) << "WirelessNetworkDevice: System DBus not connected";
return; return;
} }
m_wirelessInterface = new QDBusInterface(serviceString, this->objectPath().path(), wirelessInterfaceString, systemBus, this); m_wirelessInterface = new QDBusInterface(serviceString, this->objectPath().path(), wirelessInterfaceString, systemBus, this);
if(!m_wirelessInterface->isValid()) { if (!m_wirelessInterface->isValid()) {
qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Invalid wireless dbus interface"; qCWarning(dcNetworkManager()) << "WirelessNetworkDevice: Invalid wireless dbus interface";
return; return;
} }
@ -47,39 +48,44 @@ WirelessNetworkManager::WirelessNetworkManager(const QDBusObjectPath &objectPath
QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath))); QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "AccessPointRemoved", this, SLOT(accessPointRemoved(QDBusObjectPath)));
QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap))); QDBusConnection::systemBus().connect(serviceString, this->objectPath().path(), wirelessInterfaceString, "PropertiesChanged", this, SLOT(propertiesChanged(QVariantMap)));
m_macAddress = m_wirelessInterface->property("HwAddress").toString();
m_bitrate = m_wirelessInterface->property("Bitrate").toInt() / 1000;
qCDebug(dcNetworkManager()) << this;
readAccessPoints(); readAccessPoints();
setMacAddress(m_wirelessInterface->property("HwAddress").toString());
setBitrate(m_wirelessInterface->property("Bitrate").toInt());
setActiveAccessPoint(qdbus_cast<QDBusObjectPath>(m_wirelessInterface->property("ActiveAccessPoint")));
} }
QString WirelessNetworkManager::macAddress() const QString WirelessNetworkDevice::macAddress() const
{ {
return m_macAddress; return m_macAddress;
} }
int WirelessNetworkManager::bitrate() const int WirelessNetworkDevice::bitRate() const
{ {
return m_bitrate; return m_bitRate;
} }
void WirelessNetworkManager::scanWirelessNetworks() WirelessAccessPoint *WirelessNetworkDevice::activeAccessPoint()
{ {
return m_activeAccessPoint;
}
void WirelessNetworkDevice::scanWirelessNetworks()
{
qCDebug(dcNetworkManager()) << this << "Request scan";
QDBusMessage query = m_wirelessInterface->call("RequestScan", QVariantMap()); QDBusMessage query = m_wirelessInterface->call("RequestScan", QVariantMap());
if(query.type() != QDBusMessage::ReplyMessage) { if (query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNetworkManager()) << "Scan error:" << query.errorName() << query.errorMessage(); qCWarning(dcNetworkManager()) << "Scan error:" << query.errorName() << query.errorMessage();
return; return;
} }
} }
QList<WirelessAccessPoint *> WirelessNetworkManager::accessPoints() QList<WirelessAccessPoint *> WirelessNetworkDevice::accessPoints()
{ {
return m_accessPointsTable.values(); return m_accessPointsTable.values();
} }
WirelessAccessPoint *WirelessNetworkManager::getAccessPoint(const QString &ssid) WirelessAccessPoint *WirelessNetworkDevice::getAccessPoint(const QString &ssid)
{ {
foreach (WirelessAccessPoint *accessPoint, m_accessPointsTable.values()) { foreach (WirelessAccessPoint *accessPoint, m_accessPointsTable.values()) {
if (accessPoint->ssid() == ssid) if (accessPoint->ssid() == ssid)
@ -88,12 +94,12 @@ WirelessAccessPoint *WirelessNetworkManager::getAccessPoint(const QString &ssid)
return Q_NULLPTR; return Q_NULLPTR;
} }
WirelessAccessPoint *WirelessNetworkManager::getAccessPoint(const QDBusObjectPath &objectPath) WirelessAccessPoint *WirelessNetworkDevice::getAccessPoint(const QDBusObjectPath &objectPath)
{ {
return m_accessPointsTable.value(objectPath); return m_accessPointsTable.value(objectPath);
} }
void WirelessNetworkManager::readAccessPoints() void WirelessNetworkDevice::readAccessPoints()
{ {
QDBusMessage query = m_wirelessInterface->call("GetAccessPoints"); QDBusMessage query = m_wirelessInterface->call("GetAccessPoints");
if(query.type() != QDBusMessage::ReplyMessage) { if(query.type() != QDBusMessage::ReplyMessage) {
@ -106,54 +112,81 @@ void WirelessNetworkManager::readAccessPoints()
const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>(); const QDBusArgument &argument = query.arguments().at(0).value<QDBusArgument>();
argument.beginArray(); argument.beginArray();
while(!argument.atEnd()) { while (!argument.atEnd()) {
QDBusObjectPath accessPointObjectPath = qdbus_cast<QDBusObjectPath>(argument); QDBusObjectPath accessPointObjectPath = qdbus_cast<QDBusObjectPath>(argument);
accessPointAdded(accessPointObjectPath); accessPointAdded(accessPointObjectPath);
} }
argument.endArray(); argument.endArray();
} }
void WirelessNetworkManager::accessPointAdded(const QDBusObjectPath &objectPath) void WirelessNetworkDevice::setMacAddress(const QString &macAddress)
{
m_macAddress = macAddress;
}
void WirelessNetworkDevice::setBitrate(const int &bitRate)
{
m_bitRate = bitRate / 1000;
}
void WirelessNetworkDevice::setActiveAccessPoint(const QDBusObjectPath &activeAccessPointObjectPath)
{
if (m_accessPointsTable.contains(activeAccessPointObjectPath)) {
m_activeAccessPoint = m_accessPointsTable.value(activeAccessPointObjectPath);
} else {
m_activeAccessPoint = Q_NULLPTR;
}
}
void WirelessNetworkDevice::accessPointAdded(const QDBusObjectPath &objectPath)
{ {
QDBusInterface accessPointInterface(serviceString, objectPath.path(), accessPointInterfaceString, QDBusConnection::systemBus()); QDBusInterface accessPointInterface(serviceString, objectPath.path(), accessPointInterfaceString, QDBusConnection::systemBus());
if(!accessPointInterface.isValid()) { if (!accessPointInterface.isValid()) {
qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Invalid access point dbus interface"; qCWarning(dcNetworkManager()) << "WirelessNetworkDevice: Invalid access point dbus interface";
return; return;
} }
if (m_accessPointsTable.keys().contains(objectPath)) { if (m_accessPointsTable.keys().contains(objectPath)) {
qCWarning(dcNetworkManager()) << "WirelessNetworkManager: Access point already added" << objectPath.path(); qCWarning(dcNetworkManager()) << "WirelessNetworkDevice: Access point already added" << objectPath.path();
return; return;
} }
WirelessAccessPoint *accessPoint = new WirelessAccessPoint(objectPath, this); WirelessAccessPoint *accessPoint = new WirelessAccessPoint(objectPath, this);
//qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [+]" << accessPoint; //qCDebug(dcNetworkManager()) << "WirelessNetworkDevice: [+]" << accessPoint;
// Add access point
m_accessPointsTable.insert(objectPath, accessPoint); m_accessPointsTable.insert(objectPath, accessPoint);
} }
void WirelessNetworkManager::accessPointRemoved(const QDBusObjectPath &objectPath) void WirelessNetworkDevice::accessPointRemoved(const QDBusObjectPath &objectPath)
{ {
if (!m_accessPointsTable.keys().contains(objectPath)) if (!m_accessPointsTable.keys().contains(objectPath))
return; return;
// Remove access point
WirelessAccessPoint *accessPoint = m_accessPointsTable.take(objectPath); WirelessAccessPoint *accessPoint = m_accessPointsTable.take(objectPath);
//qCDebug(dcNetworkManager()) << "WirelessNetworkManager: [-]" << accessPoint; if (accessPoint == m_activeAccessPoint)
m_activeAccessPoint = Q_NULLPTR;
//qCDebug(dcNetworkManager()) << "WirelessNetworkDevice: [-]" << accessPoint;
accessPoint->deleteLater(); accessPoint->deleteLater();
} }
void WirelessNetworkManager::propertiesChanged(const QVariantMap &properties) void WirelessNetworkDevice::propertiesChanged(const QVariantMap &properties)
{ {
qCDebug(dcNetworkManager()) << "WirelessNetworkManager: Property changed" << properties; //qCDebug(dcNetworkManager()) << "WirelessNetworkDevice: Property changed" << properties;
if (properties.contains("Bitrate"))
setBitrate(properties.value("Bitrate").toInt());
if (properties.contains("ActiveAccessPoint"))
setActiveAccessPoint(qdbus_cast<QDBusObjectPath>(properties.value("ActiveAccessPoint")));
emit deviceChanged();
} }
QDebug operator<<(QDebug debug, WirelessNetworkManager *manager) QDebug operator<<(QDebug debug, WirelessNetworkDevice *manager)
{ {
debug.nospace() << "WirelessDevice(" << manager->interface() << ", "; debug.nospace() << "WirelessNetworkDevice(" << manager->interface() << ", ";
debug.nospace() << manager->macAddress() << ", "; debug.nospace() << manager->macAddress() << ", ";
debug.nospace() << manager->bitrate() << " [Mb/s], "; debug.nospace() << manager->bitRate() << " [Mb/s], ";
debug.nospace() << manager->deviceStateString() << ") "; debug.nospace() << manager->deviceStateString() << ") ";
return debug; return debug;
} }

28
server/networkmanager/wirelessnetworkmanager.h → server/networkmanager/wirelessnetworkdevice.h
View File

@ -34,34 +34,40 @@
namespace guhserver { namespace guhserver {
class WirelessNetworkManager : public NetworkDevice class WirelessNetworkDevice : public NetworkDevice
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit WirelessNetworkManager(const QDBusObjectPath &objectPath, QObject *parent = 0); explicit WirelessNetworkDevice(const QDBusObjectPath &objectPath, QObject *parent = 0);
// Properties
QString macAddress() const; QString macAddress() const;
int bitrate() const; int bitRate() const;
WirelessAccessPoint *activeAccessPoint();
void scanWirelessNetworks();
// Accesspoints
QList<WirelessAccessPoint *> accessPoints(); QList<WirelessAccessPoint *> accessPoints();
WirelessAccessPoint *getAccessPoint(const QString &ssid); WirelessAccessPoint *getAccessPoint(const QString &ssid);
WirelessAccessPoint *getAccessPoint(const QDBusObjectPath &objectPath); WirelessAccessPoint *getAccessPoint(const QDBusObjectPath &objectPath);
// Methods
void scanWirelessNetworks();
private: private:
QDBusInterface *m_wirelessInterface; QDBusInterface *m_wirelessInterface;
QString m_macAddress; QString m_macAddress;
int m_bitrate; int m_bitRate;
WirelessAccessPoint *m_activeAccessPoint;
QHash<QDBusObjectPath, WirelessAccessPoint *> m_accessPointsTable; QHash<QDBusObjectPath, WirelessAccessPoint *> m_accessPointsTable;
void readAccessPoints(); void readAccessPoints();
void setConnected(const bool &connected); void setMacAddress(const QString &macAddress);
void setState(const NetworkDeviceState &state); void setBitrate(const int &bitRate);
void setStateReason(const NetworkDeviceStateReason &stateReason); void setActiveAccessPoint(const QDBusObjectPath &activeAccessPointObjectPath);
private slots: private slots:
void accessPointAdded(const QDBusObjectPath &objectPath); void accessPointAdded(const QDBusObjectPath &objectPath);
@ -69,11 +75,11 @@ private slots:
void propertiesChanged(const QVariantMap &properties); void propertiesChanged(const QVariantMap &properties);
signals: signals:
void connectedChanged(const bool &connected); void bitRateChanged(const bool &connected);
void stateChanged(const NetworkDeviceState &state); void stateChanged(const NetworkDeviceState &state);
}; };
QDebug operator<<(QDebug debug, WirelessNetworkManager *manager); QDebug operator<<(QDebug debug, WirelessNetworkDevice *manager);
} }

6
server/server.pri
View File

@ -62,9 +62,10 @@ HEADERS += $$top_srcdir/server/guhcore.h \
$$top_srcdir/server/networkmanager/networkmanager.h \ $$top_srcdir/server/networkmanager/networkmanager.h \
$$top_srcdir/server/networkmanager/networkdevice.h \ $$top_srcdir/server/networkmanager/networkdevice.h \
$$top_srcdir/server/networkmanager/wirelessaccesspoint.h \ $$top_srcdir/server/networkmanager/wirelessaccesspoint.h \
$$top_srcdir/server/networkmanager/wirelessnetworkmanager.h \ $$top_srcdir/server/networkmanager/wirelessnetworkdevice.h \
$$top_srcdir/server/networkmanager/networksettings.h \ $$top_srcdir/server/networkmanager/networksettings.h \
$$top_srcdir/server/networkmanager/networkconnection.h \ $$top_srcdir/server/networkmanager/networkconnection.h \
$$top_srcdir/server/networkmanager/wirednetworkdevice.h \
SOURCES += $$top_srcdir/server/guhcore.cpp \ SOURCES += $$top_srcdir/server/guhcore.cpp \
@ -125,7 +126,8 @@ SOURCES += $$top_srcdir/server/guhcore.cpp \
$$top_srcdir/server/networkmanager/networkmanager.cpp \ $$top_srcdir/server/networkmanager/networkmanager.cpp \
$$top_srcdir/server/networkmanager/networkdevice.cpp \ $$top_srcdir/server/networkmanager/networkdevice.cpp \
$$top_srcdir/server/networkmanager/wirelessaccesspoint.cpp \ $$top_srcdir/server/networkmanager/wirelessaccesspoint.cpp \
$$top_srcdir/server/networkmanager/wirelessnetworkmanager.cpp \ $$top_srcdir/server/networkmanager/wirelessnetworkdevice.cpp \
$$top_srcdir/server/networkmanager/networksettings.cpp \ $$top_srcdir/server/networkmanager/networksettings.cpp \
$$top_srcdir/server/networkmanager/networkconnection.cpp \ $$top_srcdir/server/networkmanager/networkconnection.cpp \
$$top_srcdir/server/networkmanager/wirednetworkdevice.cpp \