1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of the plugins of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 3 requirements
23 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24 **
25 ** GNU General Public License Usage
26 ** Alternatively, this file may be used under the terms of the GNU
27 ** General Public License version 2.0 or (at your option) the GNU General
28 ** Public license version 3 or any later version approved by the KDE Free
29 ** Qt Foundation. The licenses are as published by the Free Software
30 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31 ** included in the packaging of this file. Please review the following
32 ** information to ensure the GNU General Public License requirements will
33 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34 ** https://www.gnu.org/licenses/gpl-3.0.html.
35 **
36 ** $QT_END_LICENSE$
37 **
38 ****************************************************************************/
39
40 #include <QObject>
41 #include <QList>
42 #include <QtDBus/QtDBus>
43 #include <QtDBus/QDBusConnection>
44 #include <QtDBus/QDBusError>
45 #include <QtDBus/QDBusInterface>
46 #include <QtDBus/QDBusMessage>
47 #include <QtDBus/QDBusReply>
48 #include <QtDBus/QDBusPendingCallWatcher>
49 #include <QtDBus/QDBusObjectPath>
50 #include <QtDBus/QDBusPendingCall>
51
52 #include "qnetworkmanagerservice.h"
53
54 #ifndef QT_NO_DBUS
55
56 #define DBUS_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
57
58 QT_BEGIN_NAMESPACE
59
60
QNetworkManagerInterface(QObject * parent)61 QNetworkManagerInterface::QNetworkManagerInterface(QObject *parent)
62 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
63 QLatin1String(NM_DBUS_PATH),
64 NM_DBUS_INTERFACE,
65 QDBusConnection::systemBus(),parent)
66 {
67 if (!isValid()) {
68 return;
69 }
70
71 PropertiesDBusInterface managerPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
72 QLatin1String(NM_DBUS_PATH),
73 DBUS_PROPERTIES_INTERFACE,
74 QDBusConnection::systemBus());
75 QDBusPendingReply<QVariantMap> propsReply
76 = managerPropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE));
77
78 if (!propsReply.isError()) {
79 propertyMap = propsReply.value();
80 } else {
81 qWarning() << "propsReply" << propsReply.error().message();
82 }
83
84 QDBusPendingReply<QList <QDBusObjectPath> > nmReply
85 = call(QLatin1String("GetDevices"));
86 nmReply.waitForFinished();
87 if (!nmReply.isError()) {
88 devicesPathList = nmReply.value();
89 } else {
90 qWarning() << "nmReply" << nmReply.error().message();
91 }
92
93 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
94 QLatin1String(NM_DBUS_PATH),
95 QLatin1String(NM_DBUS_INTERFACE),
96 QLatin1String("PropertiesChanged"),
97 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
98 }
99
~QNetworkManagerInterface()100 QNetworkManagerInterface::~QNetworkManagerInterface()
101 {
102 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
103 QLatin1String(NM_DBUS_PATH),
104 QLatin1String(NM_DBUS_INTERFACE),
105 QLatin1String("PropertiesChanged"),
106 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
107 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
108 QLatin1String(NM_DBUS_PATH),
109 QLatin1String(NM_DBUS_INTERFACE),
110 QLatin1String("DeviceAdded"),
111 this,SIGNAL(deviceAdded(QDBusObjectPath)));
112 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
113 QLatin1String(NM_DBUS_PATH),
114 QLatin1String(NM_DBUS_INTERFACE),
115 QLatin1String("DeviceRemoved"),
116 this,SIGNAL(deviceRemoved(QDBusObjectPath)));
117 }
118
setConnections()119 bool QNetworkManagerInterface::setConnections()
120 {
121 if (!isValid())
122 return false;
123
124 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
125 QLatin1String(NM_DBUS_PATH),
126 QLatin1String(NM_DBUS_INTERFACE),
127 QLatin1String("PropertiesChanged"),
128 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
129
130 bool allOk = false;
131 if (QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
132 QLatin1String(NM_DBUS_PATH),
133 QLatin1String(NM_DBUS_INTERFACE),
134 QLatin1String("DeviceAdded"),
135 this,SIGNAL(deviceAdded(QDBusObjectPath)))) {
136 allOk = true;
137 }
138 if (QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
139 QLatin1String(NM_DBUS_PATH),
140 QLatin1String(NM_DBUS_INTERFACE),
141 QLatin1String("DeviceRemoved"),
142 this,SIGNAL(deviceRemoved(QDBusObjectPath)))) {
143 allOk = true;
144 }
145
146 return allOk;
147 }
148
getDevices()149 QList <QDBusObjectPath> QNetworkManagerInterface::getDevices()
150 {
151 if (devicesPathList.isEmpty()) {
152 //qWarning("using blocking call!");
153 QDBusReply<QList<QDBusObjectPath> > reply = call(QLatin1String("GetDevices"));
154 devicesPathList = reply.value();
155 }
156 return devicesPathList;
157 }
158
activateConnection(QDBusObjectPath connectionPath,QDBusObjectPath devicePath,QDBusObjectPath specificObject)159 void QNetworkManagerInterface::activateConnection(QDBusObjectPath connectionPath,
160 QDBusObjectPath devicePath,
161 QDBusObjectPath specificObject)
162 {
163 QDBusPendingCall pendingCall = asyncCall(QLatin1String("ActivateConnection"),
164 QVariant::fromValue(connectionPath),
165 QVariant::fromValue(devicePath),
166 QVariant::fromValue(specificObject));
167
168 QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(pendingCall);
169 connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
170 this, SIGNAL(activationFinished(QDBusPendingCallWatcher*)));
171 }
172
deactivateConnection(QDBusObjectPath connectionPath)173 void QNetworkManagerInterface::deactivateConnection(QDBusObjectPath connectionPath)
174 {
175 asyncCall(QLatin1String("DeactivateConnection"), QVariant::fromValue(connectionPath));
176 }
177
wirelessEnabled() const178 bool QNetworkManagerInterface::wirelessEnabled() const
179 {
180 if (propertyMap.contains("WirelessEnabled"))
181 return propertyMap.value("WirelessEnabled").toBool();
182 return false;
183 }
184
wirelessHardwareEnabled() const185 bool QNetworkManagerInterface::wirelessHardwareEnabled() const
186 {
187 if (propertyMap.contains("WirelessHardwareEnabled"))
188 return propertyMap.value("WirelessHardwareEnabled").toBool();
189 return false;
190 }
191
activeConnections() const192 QList <QDBusObjectPath> QNetworkManagerInterface::activeConnections() const
193 {
194 if (propertyMap.contains("ActiveConnections")) {
195
196 const QDBusArgument &dbusArgs = qvariant_cast<QDBusArgument>(propertyMap.value("ActiveConnections"));
197 QDBusObjectPath path;
198 QList <QDBusObjectPath> list;
199
200 dbusArgs.beginArray();
201 while (!dbusArgs.atEnd()) {
202 dbusArgs >> path;
203 list.append(path);
204 }
205 dbusArgs.endArray();
206
207 return list;
208 }
209
210 QList <QDBusObjectPath> list;
211 list << QDBusObjectPath();
212 return list;
213 }
214
state()215 QNetworkManagerInterface::NMState QNetworkManagerInterface::state()
216 {
217 if (propertyMap.contains("State"))
218 return static_cast<QNetworkManagerInterface::NMState>(propertyMap.value("State").toUInt());
219 return QNetworkManagerInterface::NM_STATE_UNKNOWN;
220 }
221
version() const222 QString QNetworkManagerInterface::version() const
223 {
224 if (propertyMap.contains("Version"))
225 return propertyMap.value("Version").toString();
226 return QString();
227 }
228
propertiesSwap(QMap<QString,QVariant> map)229 void QNetworkManagerInterface::propertiesSwap(QMap<QString,QVariant> map)
230 {
231 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i) {
232 propertyMap.insert(i.key(),i.value());
233
234 if (i.key() == QLatin1String("State")) {
235 quint32 state = i.value().toUInt();
236 if (state == NM_DEVICE_STATE_ACTIVATED
237 || state == NM_DEVICE_STATE_DISCONNECTED
238 || state == NM_DEVICE_STATE_UNAVAILABLE
239 || state == NM_DEVICE_STATE_FAILED) {
240 Q_EMIT propertiesChanged(map);
241 Q_EMIT stateChanged(state);
242 }
243 } else if (i.key() == QLatin1String("ActiveConnections")) {
244 Q_EMIT propertiesChanged(map);
245 }
246 }
247 }
248
QNetworkManagerInterfaceAccessPoint(const QString & dbusPathName,QObject * parent)249 QNetworkManagerInterfaceAccessPoint::QNetworkManagerInterfaceAccessPoint(const QString &dbusPathName, QObject *parent)
250 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
251 dbusPathName,
252 NM_DBUS_INTERFACE_ACCESS_POINT,
253 QDBusConnection::systemBus(),parent)
254 {
255 }
256
~QNetworkManagerInterfaceAccessPoint()257 QNetworkManagerInterfaceAccessPoint::~QNetworkManagerInterfaceAccessPoint()
258 {
259 }
260
flags() const261 quint32 QNetworkManagerInterfaceAccessPoint::flags() const
262 {
263 if (propertyMap.contains("Flags"))
264 return propertyMap.value("Flags").toUInt();
265 return 0;
266 }
267
wpaFlags() const268 quint32 QNetworkManagerInterfaceAccessPoint::wpaFlags() const
269 {
270 if (propertyMap.contains("WpaFlags"))
271 return propertyMap.value("WpaFlags").toUInt();
272 return 0;
273 }
274
rsnFlags() const275 quint32 QNetworkManagerInterfaceAccessPoint::rsnFlags() const
276 {
277 if (propertyMap.contains("RsnFlags"))
278 return propertyMap.value("RsnFlags").toUInt();
279 return 0;
280 }
281
ssid() const282 QString QNetworkManagerInterfaceAccessPoint::ssid() const
283 {
284 if (propertyMap.contains("Ssid"))
285 return propertyMap.value("Ssid").toString();
286 return QString();
287 }
288
frequency() const289 quint32 QNetworkManagerInterfaceAccessPoint::frequency() const
290 {
291 if (propertyMap.contains("Frequency"))
292 return propertyMap.value("Frequency").toUInt();
293 return 0;
294 }
295
hwAddress() const296 QString QNetworkManagerInterfaceAccessPoint::hwAddress() const
297 {
298 if (propertyMap.contains("HwAddress"))
299 return propertyMap.value("HwAddress").toString();
300 return QString();
301 }
302
mode() const303 quint32 QNetworkManagerInterfaceAccessPoint::mode() const
304 {
305 if (propertyMap.contains("Mode"))
306 return propertyMap.value("Mode").toUInt();
307 return 0;
308 }
309
maxBitrate() const310 quint32 QNetworkManagerInterfaceAccessPoint::maxBitrate() const
311 {
312 if (propertyMap.contains("MaxBitrate"))
313 return propertyMap.value("MaxBitrate").toUInt();
314 return 0;
315 }
316
strength() const317 quint32 QNetworkManagerInterfaceAccessPoint::strength() const
318 {
319 if (propertyMap.contains("Strength"))
320 return propertyMap.value("Strength").toUInt();
321 return 0;
322 }
323
propertiesSwap(QMap<QString,QVariant> map)324 void QNetworkManagerInterfaceAccessPoint::propertiesSwap(QMap<QString,QVariant> map)
325 {
326 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i)
327 propertyMap.insert(i.key(),i.value());
328 }
329
QNetworkManagerInterfaceDevice(const QString & deviceObjectPath,QObject * parent)330 QNetworkManagerInterfaceDevice::QNetworkManagerInterfaceDevice(const QString &deviceObjectPath, QObject *parent)
331 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
332 deviceObjectPath,
333 NM_DBUS_INTERFACE_DEVICE,
334 QDBusConnection::systemBus(),parent)
335 {
336
337 if (!isValid()) {
338 return;
339 }
340 PropertiesDBusInterface devicePropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
341 deviceObjectPath,
342 DBUS_PROPERTIES_INTERFACE,
343 QDBusConnection::systemBus(),parent);
344
345 QDBusPendingReply<QVariantMap> propsReply
346 = devicePropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE_DEVICE));
347
348 if (!propsReply.isError()) {
349 propertyMap = propsReply.value();
350 }
351
352 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
353 deviceObjectPath,
354 QLatin1String(NM_DBUS_INTERFACE_DEVICE),
355 QLatin1String("PropertiesChanged"),
356 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
357 }
358
~QNetworkManagerInterfaceDevice()359 QNetworkManagerInterfaceDevice::~QNetworkManagerInterfaceDevice()
360 {
361 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
362 path(),
363 QLatin1String(NM_DBUS_INTERFACE_DEVICE),
364 QLatin1String("PropertiesChanged"),
365 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
366 }
367
udi() const368 QString QNetworkManagerInterfaceDevice::udi() const
369 {
370 if (propertyMap.contains("Udi"))
371 return propertyMap.value("Udi").toString();
372 return QString();
373 }
374
networkInterface() const375 QString QNetworkManagerInterfaceDevice::networkInterface() const
376 {
377 if (propertyMap.contains("Interface"))
378 return propertyMap.value("Interface").toString();
379 return QString();
380 }
381
ip4Address() const382 quint32 QNetworkManagerInterfaceDevice::ip4Address() const
383 {
384 if (propertyMap.contains("Ip4Address"))
385 return propertyMap.value("Ip4Address").toUInt();
386 return 0;
387 }
388
state() const389 quint32 QNetworkManagerInterfaceDevice::state() const
390 {
391 if (propertyMap.contains("State"))
392 return propertyMap.value("State").toUInt();
393 return 0;
394 }
395
deviceType() const396 quint32 QNetworkManagerInterfaceDevice::deviceType() const
397 {
398 if (propertyMap.contains("DeviceType"))
399 return propertyMap.value("DeviceType").toUInt();
400 return 0;
401 }
402
ip4config() const403 QDBusObjectPath QNetworkManagerInterfaceDevice::ip4config() const
404 {
405 if (propertyMap.contains("Ip4Config"))
406 return qvariant_cast<QDBusObjectPath>(propertyMap.value("Ip4Config"));
407 return QDBusObjectPath();
408 }
409
propertiesSwap(QMap<QString,QVariant> map)410 void QNetworkManagerInterfaceDevice::propertiesSwap(QMap<QString,QVariant> map)
411 {
412 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i) {
413 if (i.key() == QLatin1String("AvailableConnections")) { //Device
414 const QDBusArgument &dbusArgs = qvariant_cast<QDBusArgument>(i.value());
415 QDBusObjectPath path;
416 QStringList paths;
417 dbusArgs.beginArray();
418 while (!dbusArgs.atEnd()) {
419 dbusArgs >> path;
420 paths << path.path();
421 }
422 dbusArgs.endArray();
423 Q_EMIT connectionsChanged(paths);
424 }
425 propertyMap.insert(i.key(),i.value());
426 }
427 Q_EMIT propertiesChanged(map);
428 }
429
QNetworkManagerInterfaceDeviceWired(const QString & ifaceDevicePath,QObject * parent)430 QNetworkManagerInterfaceDeviceWired::QNetworkManagerInterfaceDeviceWired(const QString &ifaceDevicePath, QObject *parent)
431 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
432 ifaceDevicePath,
433 NM_DBUS_INTERFACE_DEVICE_WIRED,
434 QDBusConnection::systemBus(), parent)
435 {
436 if (!isValid()) {
437 return;
438 }
439 PropertiesDBusInterface deviceWiredPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
440 ifaceDevicePath,
441 DBUS_PROPERTIES_INTERFACE,
442 QDBusConnection::systemBus(),parent);
443
444 QDBusPendingReply<QVariantMap> propsReply
445 = deviceWiredPropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRED));
446
447 if (!propsReply.isError()) {
448 propertyMap = propsReply.value();
449 }
450
451 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
452 ifaceDevicePath,
453 QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRED),
454 QLatin1String("PropertiesChanged"),
455 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
456 }
457
~QNetworkManagerInterfaceDeviceWired()458 QNetworkManagerInterfaceDeviceWired::~QNetworkManagerInterfaceDeviceWired()
459 {
460 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
461 path(),
462 QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRED),
463 QLatin1String("PropertiesChanged"),
464 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
465 }
466
hwAddress() const467 QString QNetworkManagerInterfaceDeviceWired::hwAddress() const
468 {
469 if (propertyMap.contains("HwAddress"))
470 return propertyMap.value("HwAddress").toString();
471 return QString();
472 }
473
speed() const474 quint32 QNetworkManagerInterfaceDeviceWired::speed() const
475 {
476 if (propertyMap.contains("Speed"))
477 return propertyMap.value("Speed").toUInt();
478 return 0;
479 }
480
carrier() const481 bool QNetworkManagerInterfaceDeviceWired::carrier() const
482 {
483 if (propertyMap.contains("Carrier"))
484 return propertyMap.value("Carrier").toBool();
485 return false;
486 }
487
availableConnections()488 QStringList QNetworkManagerInterfaceDeviceWired::availableConnections()
489 {
490 QStringList list;
491 if (propertyMap.contains("AvailableConnections")) {
492 const QDBusArgument &dbusArgs = qvariant_cast<QDBusArgument>(propertyMap.value("Carrier"));
493 QDBusObjectPath path;
494 dbusArgs.beginArray();
495 while (!dbusArgs.atEnd()) {
496 dbusArgs >> path;
497 list << path.path();
498 }
499 dbusArgs.endArray();
500 }
501
502 return list;
503 }
504
propertiesSwap(QMap<QString,QVariant> map)505 void QNetworkManagerInterfaceDeviceWired::propertiesSwap(QMap<QString,QVariant> map)
506 {
507 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i) {
508 propertyMap.insert(i.key(),i.value());
509 if (i.key() == QLatin1String("Carrier"))
510 Q_EMIT carrierChanged(i.value().toBool());
511 }
512 Q_EMIT propertiesChanged(map);
513 }
514
QNetworkManagerInterfaceDeviceWireless(const QString & ifaceDevicePath,QObject * parent)515 QNetworkManagerInterfaceDeviceWireless::QNetworkManagerInterfaceDeviceWireless(const QString &ifaceDevicePath, QObject *parent)
516 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
517 ifaceDevicePath,
518 NM_DBUS_INTERFACE_DEVICE_WIRELESS,
519 QDBusConnection::systemBus(), parent)
520 {
521 if (!isValid()) {
522 return;
523 }
524
525 interfacePath = ifaceDevicePath;
526 QDBusPendingReply<QList <QDBusObjectPath> > nmReply
527 = call(QLatin1String("GetAccessPoints"));
528
529 if (!nmReply.isError()) {
530 accessPointsList = nmReply.value();
531 }
532
533 PropertiesDBusInterface deviceWirelessPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
534 interfacePath,
535 DBUS_PROPERTIES_INTERFACE,
536 QDBusConnection::systemBus(),parent);
537
538 QDBusPendingReply<QVariantMap> propsReply
539 = deviceWirelessPropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS));
540
541 if (!propsReply.isError()) {
542 propertyMap = propsReply.value();
543 }
544
545 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
546 interfacePath,
547 QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
548 QLatin1String("PropertiesChanged"),
549 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
550 }
551
~QNetworkManagerInterfaceDeviceWireless()552 QNetworkManagerInterfaceDeviceWireless::~QNetworkManagerInterfaceDeviceWireless()
553 {
554 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
555 path(),
556 QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
557 QLatin1String("PropertiesChanged"),
558 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
559 }
560
setConnections()561 bool QNetworkManagerInterfaceDeviceWireless::setConnections()
562 {
563 return true;
564 }
565
getAccessPoints()566 QList <QDBusObjectPath> QNetworkManagerInterfaceDeviceWireless::getAccessPoints()
567 {
568 if (accessPointsList.isEmpty()) {
569 //qWarning("Using blocking call!");
570 QDBusReply<QList<QDBusObjectPath> > reply
571 = call(QLatin1String("GetAccessPoints"));
572 accessPointsList = reply.value();
573 }
574 return accessPointsList;
575 }
576
hwAddress() const577 QString QNetworkManagerInterfaceDeviceWireless::hwAddress() const
578 {
579 if (propertyMap.contains("HwAddress"))
580 return propertyMap.value("HwAddress").toString();
581 return QString();
582 }
583
mode() const584 quint32 QNetworkManagerInterfaceDeviceWireless::mode() const
585 {
586 if (propertyMap.contains("Mode"))
587 return propertyMap.value("Mode").toUInt();
588 return 0;
589 }
590
bitrate() const591 quint32 QNetworkManagerInterfaceDeviceWireless::bitrate() const
592 {
593 if (propertyMap.contains("Bitrate"))
594 return propertyMap.value("Bitrate").toUInt();
595 return 0;
596 }
597
activeAccessPoint() const598 QDBusObjectPath QNetworkManagerInterfaceDeviceWireless::activeAccessPoint() const
599 {
600 if (propertyMap.contains("ActiveAccessPoint"))
601 return qvariant_cast<QDBusObjectPath>(propertyMap.value("ActiveAccessPoint"));
602 return QDBusObjectPath();
603 }
604
wirelessCapabilities() const605 quint32 QNetworkManagerInterfaceDeviceWireless::wirelessCapabilities() const
606 {
607 if (propertyMap.contains("WirelelessCapabilities"))
608 return propertyMap.value("WirelelessCapabilities").toUInt();
609 return 0;
610 }
611
requestScan()612 void QNetworkManagerInterfaceDeviceWireless::requestScan()
613 {
614 asyncCall(QLatin1String("RequestScan"));
615 }
616
propertiesSwap(QMap<QString,QVariant> map)617 void QNetworkManagerInterfaceDeviceWireless::propertiesSwap(QMap<QString,QVariant> map)
618 {
619 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i) {
620 propertyMap.insert(i.key(),i.value());
621 if (i.key() == QLatin1String("ActiveAccessPoint")) //DeviceWireless
622 Q_EMIT propertiesChanged(map);
623 }
624 }
625
QNetworkManagerInterfaceDeviceModem(const QString & ifaceDevicePath,QObject * parent)626 QNetworkManagerInterfaceDeviceModem::QNetworkManagerInterfaceDeviceModem(const QString &ifaceDevicePath, QObject *parent)
627 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
628 ifaceDevicePath,
629 NM_DBUS_INTERFACE_DEVICE_MODEM,
630 QDBusConnection::systemBus(), parent)
631 {
632 if (!isValid()) {
633 return;
634 }
635 PropertiesDBusInterface deviceModemPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
636 ifaceDevicePath,
637 QLatin1String("org.freedesktop.DBus.Properties"),
638 QDBusConnection::systemBus(),parent);
639
640 QDBusPendingReply<QVariantMap> propsReply
641 = deviceModemPropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE_DEVICE_MODEM));
642
643 if (!propsReply.isError()) {
644 propertyMap = propsReply.value();
645 }
646
647 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
648 ifaceDevicePath,
649 QLatin1String(NM_DBUS_INTERFACE_DEVICE_MODEM),
650 QLatin1String("PropertiesChanged"),
651 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
652 }
653
~QNetworkManagerInterfaceDeviceModem()654 QNetworkManagerInterfaceDeviceModem::~QNetworkManagerInterfaceDeviceModem()
655 {
656 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
657 path(),
658 QLatin1String(NM_DBUS_PATH_SETTINGS),
659 QLatin1String(NM_DBUS_IFACE_SETTINGS),
660 QLatin1String("NewConnection"),
661 this, SIGNAL(newConnection(QDBusObjectPath)));
662 }
663
modemCapabilities() const664 QNetworkManagerInterfaceDeviceModem::ModemCapabilities QNetworkManagerInterfaceDeviceModem::modemCapabilities() const
665 {
666 if (propertyMap.contains("ModemCapabilities"))
667 return static_cast<QNetworkManagerInterfaceDeviceModem::ModemCapabilities>(propertyMap.value("ModemCapabilities").toUInt());
668 return QNetworkManagerInterfaceDeviceModem::None;
669 }
670
currentCapabilities() const671 QNetworkManagerInterfaceDeviceModem::ModemCapabilities QNetworkManagerInterfaceDeviceModem::currentCapabilities() const
672 {
673 if (propertyMap.contains("CurrentCapabilities"))
674 return static_cast<QNetworkManagerInterfaceDeviceModem::ModemCapabilities>(propertyMap.value("CurrentCapabilities").toUInt());
675 return QNetworkManagerInterfaceDeviceModem::None;
676 }
677
propertiesSwap(QMap<QString,QVariant> map)678 void QNetworkManagerInterfaceDeviceModem::propertiesSwap(QMap<QString,QVariant> map)
679 {
680 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i)
681 propertyMap.insert(i.key(),i.value());
682 Q_EMIT propertiesChanged(map);
683 }
684
685
QNetworkManagerSettings(const QString & settingsService,QObject * parent)686 QNetworkManagerSettings::QNetworkManagerSettings(const QString &settingsService, QObject *parent)
687 : QDBusAbstractInterface(settingsService,
688 NM_DBUS_PATH_SETTINGS,
689 NM_DBUS_IFACE_SETTINGS,
690 QDBusConnection::systemBus(), parent)
691 {
692 if (!isValid()) {
693 return;
694 }
695 interfacePath = settingsService;
696 QDBusPendingReply<QList <QDBusObjectPath> > nmReply
697 = call(QLatin1String("ListConnections"));
698
699 if (!nmReply.isError()) {
700 connectionsList = nmReply.value();
701 }
702 }
703
~QNetworkManagerSettings()704 QNetworkManagerSettings::~QNetworkManagerSettings()
705 {
706 }
707
setConnections()708 bool QNetworkManagerSettings::setConnections()
709 {
710 bool allOk = true;
711 if (!QDBusConnection::systemBus().connect(interfacePath,
712 QLatin1String(NM_DBUS_PATH_SETTINGS),
713 QLatin1String(NM_DBUS_IFACE_SETTINGS),
714 QLatin1String("NewConnection"),
715 this, SIGNAL(newConnection(QDBusObjectPath)))) {
716 allOk = false;
717 qWarning("NewConnection could not be connected");
718 }
719
720 return allOk;
721 }
722
listConnections()723 QList <QDBusObjectPath> QNetworkManagerSettings::listConnections()
724 {
725 if (connectionsList.isEmpty()) {
726 //qWarning("Using blocking call!");
727 QDBusReply<QList<QDBusObjectPath> > reply
728 = call(QLatin1String("ListConnections"));
729 connectionsList = reply.value();
730 }
731 return connectionsList;
732 }
733
734
getConnectionByUuid(const QString & uuid)735 QString QNetworkManagerSettings::getConnectionByUuid(const QString &uuid)
736 {
737 QDBusReply<QDBusObjectPath > reply = call(QDBus::Block, QLatin1String("GetConnectionByUuid"), uuid);
738 return reply.value().path();
739 }
740
QNetworkManagerSettingsConnection(const QString & settingsService,const QString & connectionObjectPath,QObject * parent)741 QNetworkManagerSettingsConnection::QNetworkManagerSettingsConnection(const QString &settingsService, const QString &connectionObjectPath, QObject *parent)
742 : QDBusAbstractInterface(settingsService,
743 connectionObjectPath,
744 NM_DBUS_IFACE_SETTINGS_CONNECTION,
745 QDBusConnection::systemBus(), parent)
746 {
747 qDBusRegisterMetaType<QNmSettingsMap>();
748 if (!isValid()) {
749 return;
750 }
751 interfacepath = connectionObjectPath;
752 QDBusPendingReply<QNmSettingsMap> nmReply
753 = call(QLatin1String("GetSettings"));
754 if (!nmReply.isError()) {
755 settingsMap = nmReply.value();
756 }
757 }
758
~QNetworkManagerSettingsConnection()759 QNetworkManagerSettingsConnection::~QNetworkManagerSettingsConnection()
760 {
761 QDBusConnection::systemBus().disconnect(service(),
762 path(),
763 QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION),
764 QLatin1String("Updated"),
765 this, SIGNAL(updated()));
766 QDBusConnection::systemBus().disconnect(service(),
767 path(),
768 QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION),
769 QLatin1String("Removed"),
770 this, SIGNAL(slotSettingsRemoved()));
771 }
772
setConnections()773 bool QNetworkManagerSettingsConnection::setConnections()
774 {
775 if (!isValid())
776 return false;
777
778 QDBusConnection dbusConnection = QDBusConnection::systemBus();
779 bool allOk = true;
780 if (!dbusConnection.connect(service(),
781 interfacepath,
782 QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION),
783 QLatin1String("Updated"),
784 this, SIGNAL(updated()))) {
785 allOk = false;
786 }
787
788 if (!dbusConnection.connect(service(),
789 interfacepath,
790 QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION),
791 QLatin1String("Removed"),
792 this, SIGNAL(slotSettingsRemoved()))) {
793 allOk = false;
794 }
795 return allOk;
796 }
797
slotSettingsRemoved()798 void QNetworkManagerSettingsConnection::slotSettingsRemoved()
799 {
800 Q_EMIT removed(interfacepath);
801 }
802
getSettings()803 QNmSettingsMap QNetworkManagerSettingsConnection::getSettings()
804 {
805 if (settingsMap.isEmpty()) {
806 //qWarning("Using blocking call!");
807 QDBusReply<QNmSettingsMap> reply = call(QLatin1String("GetSettings"));
808 settingsMap = reply.value();
809 }
810 return settingsMap;
811 }
812
getType()813 NMDeviceType QNetworkManagerSettingsConnection::getType()
814 {
815 const QString devType =
816 settingsMap.value(QLatin1String("connection")).value(QLatin1String("type")).toString();
817
818 if (devType == QLatin1String("802-3-ethernet"))
819 return DEVICE_TYPE_ETHERNET;
820 else if (devType == QLatin1String("802-11-wireless"))
821 return DEVICE_TYPE_WIFI;
822 else if (devType == QLatin1String("gsm"))
823 return DEVICE_TYPE_MODEM;
824 else
825 return DEVICE_TYPE_UNKNOWN;
826 }
827
isAutoConnect()828 bool QNetworkManagerSettingsConnection::isAutoConnect()
829 {
830 const QVariant autoConnect =
831 settingsMap.value(QLatin1String("connection")).value(QLatin1String("autoconnect"));
832
833 // NetworkManager default is to auto connect
834 if (!autoConnect.isValid())
835 return true;
836
837 return autoConnect.toBool();
838 }
839
getTimestamp()840 quint64 QNetworkManagerSettingsConnection::getTimestamp()
841 {
842 return settingsMap.value(QLatin1String("connection"))
843 .value(QLatin1String("timestamp")).toUInt();
844 }
845
getId()846 QString QNetworkManagerSettingsConnection::getId()
847 {
848 return settingsMap.value(QLatin1String("connection")).value(QLatin1String("id")).toString();
849 }
850
getUuid()851 QString QNetworkManagerSettingsConnection::getUuid()
852 {
853 const QString id = settingsMap.value(QLatin1String("connection"))
854 .value(QLatin1String("uuid")).toString();
855
856 // is no uuid, return the connection path
857 return id.isEmpty() ? path() : id;
858 }
859
getSsid()860 QString QNetworkManagerSettingsConnection::getSsid()
861 {
862 return settingsMap.value(QLatin1String("802-11-wireless"))
863 .value(QLatin1String("ssid")).toString();
864 }
865
getMacAddress()866 QString QNetworkManagerSettingsConnection::getMacAddress()
867 {
868 NMDeviceType type = getType();
869
870 if (type == DEVICE_TYPE_ETHERNET) {
871 return settingsMap.value(QLatin1String("802-3-ethernet"))
872 .value(QLatin1String("mac-address")).toString();
873 } else if (type == DEVICE_TYPE_WIFI) {
874 return settingsMap.value(QLatin1String("802-11-wireless"))
875 .value(QLatin1String("mac-address")).toString();
876 } else {
877 return QString();
878 }
879 }
880
getSeenBssids()881 QStringList QNetworkManagerSettingsConnection::getSeenBssids()
882 {
883 if (getType() == DEVICE_TYPE_WIFI) {
884 return settingsMap.value(QLatin1String("802-11-wireless"))
885 .value(QLatin1String("seen-bssids")).toStringList();
886 } else {
887 return QStringList();
888 }
889 }
890
QNetworkManagerConnectionActive(const QString & activeConnectionObjectPath,QObject * parent)891 QNetworkManagerConnectionActive::QNetworkManagerConnectionActive(const QString &activeConnectionObjectPath, QObject *parent)
892 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
893 activeConnectionObjectPath,
894 NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
895 QDBusConnection::systemBus(), parent)
896 {
897 if (!isValid()) {
898 return;
899 }
900 PropertiesDBusInterface connectionActivePropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
901 activeConnectionObjectPath,
902 QLatin1String("org.freedesktop.DBus.Properties"),
903 QDBusConnection::systemBus());
904
905
906 QDBusPendingReply<QVariantMap> propsReply
907 = connectionActivePropertiesInterface.call(QDBus::Block, QLatin1String("GetAll"), QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION));
908
909 if (!propsReply.isError()) {
910 propertyMap = propsReply.value();
911 } else {
912 qWarning() << propsReply.error().message();
913 }
914
915 QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
916 activeConnectionObjectPath,
917 QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION),
918 QLatin1String("PropertiesChanged"),
919 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
920 }
921
~QNetworkManagerConnectionActive()922 QNetworkManagerConnectionActive::~QNetworkManagerConnectionActive()
923 {
924 QDBusConnection::systemBus().disconnect(QLatin1String(NM_DBUS_SERVICE),
925 path(),
926 QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION),
927 QLatin1String("PropertiesChanged"),
928 this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
929 }
930
connection() const931 QDBusObjectPath QNetworkManagerConnectionActive::connection() const
932 {
933 if (propertyMap.contains("Connection"))
934 return qvariant_cast<QDBusObjectPath>(propertyMap.value("Connection"));
935 return QDBusObjectPath();
936 }
937
specificObject() const938 QDBusObjectPath QNetworkManagerConnectionActive::specificObject() const
939 {
940 if (propertyMap.contains("SpecificObject"))
941 return qvariant_cast<QDBusObjectPath>(propertyMap.value("SpecificObject"));
942 return QDBusObjectPath();
943 }
944
devices() const945 QStringList QNetworkManagerConnectionActive::devices() const
946 {
947 QStringList list;
948 if (propertyMap.contains("Devices")) {
949 const QDBusArgument &dbusArgs = qvariant_cast<QDBusArgument>(propertyMap.value("Devices"));
950 QDBusObjectPath path;
951
952 dbusArgs.beginArray();
953 while (!dbusArgs.atEnd()) {
954 dbusArgs >> path;
955 list.append(path.path());
956 }
957 dbusArgs.endArray();
958 }
959 return list;
960 }
961
state() const962 quint32 QNetworkManagerConnectionActive::state() const
963 {
964 if (propertyMap.contains("State"))
965 return propertyMap.value("State").toUInt();
966 return 0;
967 }
968
defaultRoute() const969 bool QNetworkManagerConnectionActive::defaultRoute() const
970 {
971 if (propertyMap.contains("Default"))
972 return propertyMap.value("Default").toBool();
973 return false;
974 }
975
default6Route() const976 bool QNetworkManagerConnectionActive::default6Route() const
977 {
978 if (propertyMap.contains("Default6"))
979 return propertyMap.value("Default6").toBool();
980 return false;
981 }
982
propertiesSwap(QMap<QString,QVariant> map)983 void QNetworkManagerConnectionActive::propertiesSwap(QMap<QString,QVariant> map)
984 {
985 for (auto i = map.cbegin(), end = map.cend(); i != end; ++i) {
986 propertyMap.insert(i.key(),i.value());
987 if (i.key() == QLatin1String("State")) {
988 quint32 state = i.value().toUInt();
989 if (state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED
990 || state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) {
991 Q_EMIT propertiesChanged(map);
992 }
993 }
994 }
995 }
996
QNetworkManagerIp4Config(const QString & deviceObjectPath,QObject * parent)997 QNetworkManagerIp4Config::QNetworkManagerIp4Config( const QString &deviceObjectPath, QObject *parent)
998 : QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
999 deviceObjectPath,
1000 NM_DBUS_INTERFACE_IP4_CONFIG,
1001 QDBusConnection::systemBus(), parent)
1002 {
1003 if (!isValid()) {
1004 return;
1005 }
1006 }
1007
~QNetworkManagerIp4Config()1008 QNetworkManagerIp4Config::~QNetworkManagerIp4Config()
1009 {
1010 }
1011
domains() const1012 QStringList QNetworkManagerIp4Config::domains() const
1013 {
1014 return property("Domains").toStringList();
1015 }
1016
1017 QT_END_NAMESPACE
1018
1019 #endif // QT_NO_DBUS
1020