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