1/*
2 SPDX-FileCopyrightText: 2008, 2010 Will Stephenson <wstephenson@kde.org>
3 SPDX-FileCopyrightText: 2011-2013 Lamarque Souza <lamarque@kde.org>
4 SPDX-FileCopyrightText: 2013 Daniel Nicoletti <dantti12@gmail.com>
5 SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
6
7 SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
8*/
9
10#include "manager.h"
11#include "manager_p.h"
12
13#include "macros.h"
14
15#undef signals
16#include <libnm/NetworkManager.h>
17#define signals Q_SIGNALS
18
19#include "adsldevice.h"
20#include "bluetoothdevice.h"
21#include "bonddevice.h"
22#include "bridgedevice.h"
23#include "dbus/deviceinterface.h"
24#include "device_p.h"
25#include "genericdevice.h"
26#include "gredevice.h"
27#include "infinibanddevice.h"
28#include "iptunneldevice.h"
29#include "macvlandevice.h"
30#include "modemdevice.h"
31#include "olpcmeshdevice.h"
32#include "settings.h"
33#include "settings_p.h"
34#include "tundevice.h"
35#include "vethdevice.h"
36#include "vlandevice.h"
37#include "vpnconnection.h"
38#include "wifip2pdevice.h"
39#include "wimaxdevice.h"
40#include "wireddevice.h"
41#include "wireguarddevice.h"
42#include "wirelessdevice.h"
43
44#include "nmdebug.h"
45
46#include <QDBusMetaType>
47#include <QDBusReply>
48#include <QTimer>
49
50#define DBUS_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager"
51#define DBUS_PROPERTIES "org.freedesktop.DBus.Properties"
52
53#ifdef NMQT_STATIC
54const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1("org.kde.fakenetwork"));
55const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1("/org/kde/fakenetwork"));
56const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1("org.kde.fakenetwork"));
57const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1("/org/kde/fakenetwork/Settings"));
58#else
59const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1(NM_DBUS_SERVICE));
60const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1(NM_DBUS_PATH));
61const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1(NM_DBUS_INTERFACE));
62const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1(NM_DBUS_PATH_SETTINGS));
63#endif
64const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES(QString::fromLatin1(DBUS_PROPERTIES));
65const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER(QString::fromLatin1(DBUS_OBJECT_MANAGER));
66
67Q_GLOBAL_STATIC(NetworkManager::NetworkManagerPrivate, globalNetworkManager)
68
69NetworkManager::NetworkManagerPrivate::NetworkManagerPrivate()
70#ifdef NMQT_STATIC
71 : watcher(DBUS_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this)
72 , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::sessionBus())
73#else
74 : watcher(DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForOwnerChange, this)
75 , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::systemBus())
76#endif
77 , nmState(NetworkManager::Unknown)
78 , m_connectivity(NetworkManager::UnknownConnectivity)
79 , m_isNetworkingEnabled(false)
80 , m_isWimaxEnabled(false)
81 , m_isWimaxHardwareEnabled(false)
82 , m_isWirelessEnabled(false)
83 , m_isWirelessHardwareEnabled(false)
84 , m_isWwanEnabled(false)
85 , m_isWwanHardwareEnabled(false)
86 , m_isConnectivityCheckAvailable(false)
87 , m_isConnectivityCheckEnabled(false)
88 , m_globalDnsConfiguration(NetworkManager::DnsConfiguration())
89 , m_supportedInterfaceTypes(NetworkManager::Device::UnknownType)
90{
91 connect(sender: &iface, signal: &OrgFreedesktopNetworkManagerInterface::DeviceAdded, context: this, slot: &NetworkManagerPrivate::onDeviceAdded);
92 connect(sender: &iface, signal: &OrgFreedesktopNetworkManagerInterface::DeviceRemoved, context: this, slot: &NetworkManagerPrivate::onDeviceRemoved);
93
94#ifndef NMQT_STATIC
95 QDBusConnection::systemBus().connect(service: NetworkManagerPrivate::DBUS_SERVICE,
96 path: NetworkManagerPrivate::DBUS_DAEMON_PATH,
97 interface: NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
98 name: QLatin1String("PropertiesChanged"),
99 receiver: this,
100 SLOT(dbusPropertiesChanged(QString, QVariantMap, QStringList)));
101#else
102 connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged);
103#endif
104
105 // We register two listeners here:
106 // - a ServiceRegistered listener for newer NM versions that connect to the bus when the interfaces
107 // we care about are already initialized
108 // - and an InterfaceAdded listener for older NM versions that connect to the bus early,
109 // and then add interfaces dynamically
110 iface.connection().connect(service: NetworkManagerPrivate::DBUS_SERVICE,
111 path: "/org/freedesktop",
112 interface: NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER,
113 name: QLatin1String("InterfacesAdded"),
114 receiver: this,
115 SLOT(dbusInterfacesAdded(QDBusObjectPath, QVariantMap)));
116
117 connect(sender: &watcher, signal: &QDBusServiceWatcher::serviceRegistered, context: this, slot: &NetworkManagerPrivate::daemonRegistered);
118 connect(sender: &watcher, signal: &QDBusServiceWatcher::serviceUnregistered, context: this, slot: &NetworkManagerPrivate::daemonUnregistered);
119
120 init();
121}
122
123void NetworkManager::NetworkManagerPrivate::parseVersion(const QString &version)
124{
125 const QStringList sl = version.split(sep: '.');
126
127 if (sl.size() > 2) {
128 m_x = sl[0].toInt();
129 m_y = sl[1].toInt();
130 m_z = sl[2].toInt();
131 } else {
132 m_x = -1;
133 m_y = -1;
134 m_z = -1;
135 }
136}
137
138void NetworkManager::NetworkManagerPrivate::init()
139{
140 qDBusRegisterMetaType<UIntList>();
141 qDBusRegisterMetaType<UIntListList>();
142 // qDBusRegisterMetaType<IpV6DBusAddress>();
143 // qDBusRegisterMetaType<IpV6DBusAddressList>();
144 // qDBusRegisterMetaType<IpV6DBusNameservers>();
145 // qDBusRegisterMetaType<IpV6DBusRoute>();
146 // qDBusRegisterMetaType<IpV6DBusRouteList>();
147 qDBusRegisterMetaType<QList<QDBusObjectPath>>();
148 qDBusRegisterMetaType<DeviceDBusStateReason>();
149 qDBusRegisterMetaType<NMVariantMapMap>();
150 qDBusRegisterMetaType<NMVariantMapList>();
151 qDBusRegisterMetaType<NMStringMap>();
152
153 m_version = iface.version();
154 parseVersion(version: m_version);
155 /* clang-format off */
156 m_supportedInterfaceTypes = static_cast<NetworkManager::Device::Types>(
157 NetworkManager::Device::Ethernet
158 | NetworkManager::Device::Wifi
159 | NetworkManager::Device::Modem
160 | (checkVersion(x: 1, y: 2, z: 0) ? 0 : NetworkManager::Device::Wimax)
161 | NetworkManager::Device::Bluetooth
162 | NetworkManager::Device::OlpcMesh
163 | NetworkManager::Device::InfiniBand
164 | NetworkManager::Device::Bond
165 | NetworkManager::Device::Vlan
166 | NetworkManager::Device::Adsl
167 | NetworkManager::Device::Bridge
168 | NetworkManager::Device::Generic
169 | NetworkManager::Device::Team
170 | NetworkManager::Device::MacVlan
171 | NetworkManager::Device::Tun
172 | NetworkManager::Device::Veth
173 | NetworkManager::Device::IpTunnel
174 | NetworkManager::Device::WireGuard);
175 /* clang-format on */
176
177 // Get all Manager's properties async
178 QVariantMap initialProperties = retrieveInitialProperties(interfaceName: iface.staticInterfaceName(), path: DBUS_DAEMON_PATH);
179 if (!initialProperties.isEmpty()) {
180 propertiesChanged(changedProperties: initialProperties);
181 }
182
183 QTimer::singleShot(interval: 0, slot: [] {
184 qobject_cast<SettingsPrivate *>(object: settingsNotifier())->init();
185 });
186
187 const QList<QDBusObjectPath> devices = iface.devices();
188 qCDebug(NMQT) << "Device list";
189 for (const QDBusObjectPath &op : devices) {
190 networkInterfaceMap.insert(key: op.path(), value: Device::Ptr());
191 Q_EMIT deviceAdded(uni: op.path());
192 qCDebug(NMQT) << " " << op.path();
193 }
194}
195
196NetworkManager::NetworkManagerPrivate::~NetworkManagerPrivate()
197{
198}
199
200QString NetworkManager::NetworkManagerPrivate::version() const
201{
202 return m_version;
203}
204
205int NetworkManager::NetworkManagerPrivate::compareVersion(const QString &version)
206{
207 int x;
208 int y;
209 int z;
210 const auto sl = QStringView(version).split(sep: '.');
211 if (sl.size() > 2) {
212 x = sl[0].toInt();
213 y = sl[1].toInt();
214 z = sl[2].toInt();
215 } else {
216 x = -1;
217 y = -1;
218 z = -1;
219 }
220
221 return compareVersion(x, y, z);
222}
223
224int NetworkManager::NetworkManagerPrivate::compareVersion(const int x, const int y, const int z) const
225{
226 if (m_x > x) {
227 return 1;
228 } else if (m_x < x) {
229 return -1;
230 } else if (m_y > y) {
231 return 1;
232 } else if (m_y < y) {
233 return -1;
234 } else if (m_z > z) {
235 return 1;
236 } else if (m_z < z) {
237 return -1;
238 }
239 return 0;
240}
241
242bool NetworkManager::NetworkManagerPrivate::checkVersion(const int x, const int y, const int z) const
243{
244 return 0 <= compareVersion(x, y, z);
245}
246
247NetworkManager::Device::Types NetworkManager::NetworkManagerPrivate::supportedInterfaceTypes() const
248{
249 return m_supportedInterfaceTypes;
250}
251
252QVariantMap NetworkManager::NetworkManagerPrivate::retrieveInitialProperties(const QString &interfaceName, const QString &path)
253{
254 QDBusMessage message = QDBusMessage::createMethodCall(destination: DBUS_SERVICE, path, interface: FDO_DBUS_PROPERTIES, method: QLatin1String("GetAll"));
255 message << interfaceName;
256#ifdef NMQT_STATIC
257 QDBusMessage resultMessage = QDBusConnection::sessionBus().call(message);
258#else
259 QDBusMessage resultMessage = QDBusConnection::systemBus().call(message);
260#endif
261 if (resultMessage.type() == QDBusMessage::ReplyMessage) {
262 QVariantMap result;
263 QDBusArgument dbusArgument = resultMessage.arguments().at(i: 0).value<QDBusArgument>();
264 while (!dbusArgument.atEnd()) {
265 dbusArgument >> result;
266 }
267 return result;
268 }
269
270 return QVariantMap();
271}
272
273NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni)
274{
275 NetworkManager::Device::Ptr networkInterface;
276 auto it = networkInterfaceMap.constFind(key: uni);
277 if (it != networkInterfaceMap.constEnd()) {
278 if (*it) {
279 networkInterface = *it;
280 } else {
281 networkInterface = createNetworkInterface(uni);
282 networkInterfaceMap[uni] = networkInterface;
283 }
284 }
285 return networkInterface;
286}
287
288NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredActiveConnection(const QString &uni)
289{
290 NetworkManager::ActiveConnection::Ptr activeConnection;
291 if (!uni.isEmpty() && uni != QLatin1String("/")) {
292 const auto it = m_activeConnections.constFind(key: uni);
293 const bool contains = it != m_activeConnections.constEnd();
294 if (contains && *it) {
295 activeConnection = *it;
296 } else {
297 activeConnection = NetworkManager::ActiveConnection::Ptr(new NetworkManager::VpnConnection(uni), &QObject::deleteLater);
298 if (activeConnection->connection()) {
299 m_activeConnections[uni] = activeConnection;
300 if (!contains) {
301 Q_EMIT activeConnectionAdded(path: uni);
302 }
303 } else {
304 activeConnection.clear();
305 }
306 }
307 }
308 return activeConnection;
309}
310
311NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::createNetworkInterface(const QString &uni)
312{
313 // qCDebug(NMQT);
314 auto message = QDBusMessage::createMethodCall(destination: DBUS_SERVICE, path: uni, interface: FDO_DBUS_PROPERTIES, QStringLiteral("Get"));
315 message.setArguments({QLatin1String(OrgFreedesktopNetworkManagerDeviceInterface::staticInterfaceName()), QStringLiteral("DeviceType")});
316#ifdef NMQT_STATIC
317 auto bus = QDBusConnection::sessionBus();
318#else
319 auto bus = QDBusConnection::systemBus();
320#endif
321 QDBusReply<QVariant> reply = bus.call(message);
322 Device::Type type = reply.isValid() ? NetworkManager::DevicePrivate::convertType(reply.value().toInt()) : Device::UnknownType;
323 switch (type) {
324 case Device::Ethernet:
325 return Device::Ptr(new NetworkManager::WiredDevice(uni), &QObject::deleteLater);
326 case Device::Wifi:
327 return Device::Ptr(new NetworkManager::WirelessDevice(uni), &QObject::deleteLater);
328 case Device::WifiP2P:
329 return Device::Ptr(new NetworkManager::WifiP2PDevice(uni), &QObject::deleteLater);
330 case Device::Modem:
331 return Device::Ptr(new NetworkManager::ModemDevice(uni), &QObject::deleteLater);
332 case Device::Bluetooth:
333 return Device::Ptr(new NetworkManager::BluetoothDevice(uni), &QObject::deleteLater);
334 case Device::Wimax:
335 return Device::Ptr(new NetworkManager::WimaxDevice(uni), &QObject::deleteLater);
336 case Device::OlpcMesh:
337 return Device::Ptr(new NetworkManager::OlpcMeshDevice(uni), &QObject::deleteLater);
338 case Device::InfiniBand:
339 return Device::Ptr(new NetworkManager::InfinibandDevice(uni), &QObject::deleteLater);
340 case Device::Bond:
341 return Device::Ptr(new NetworkManager::BondDevice(uni), &QObject::deleteLater);
342 case Device::Vlan:
343 return Device::Ptr(new NetworkManager::VlanDevice(uni), &QObject::deleteLater);
344 case Device::Adsl:
345 return Device::Ptr(new NetworkManager::AdslDevice(uni), &QObject::deleteLater);
346 case Device::Bridge:
347 return Device::Ptr(new NetworkManager::BridgeDevice(uni), &QObject::deleteLater);
348 // No need to check checkVersion, because we can't get Generic, Gre, MacVlan, Tun & Veth values in incompatible runtime
349 case Device::Generic:
350 return Device::Ptr(new NetworkManager::GenericDevice(uni), &QObject::deleteLater);
351 case Device::Gre:
352 return Device::Ptr(new NetworkManager::GreDevice(uni), &QObject::deleteLater);
353 case Device::MacVlan:
354 return Device::Ptr(new NetworkManager::MacVlanDevice(uni), &QObject::deleteLater);
355 case Device::Tun:
356 return Device::Ptr(new NetworkManager::TunDevice(uni), &QObject::deleteLater);
357 case Device::Veth:
358 return Device::Ptr(new NetworkManager::VethDevice(uni), &QObject::deleteLater);
359 case Device::IpTunnel:
360 return Device::Ptr(new NetworkManager::IpTunnelDevice(uni), &QObject::deleteLater);
361 case Device::WireGuard:
362 return Device::Ptr(new NetworkManager::WireGuardDevice(uni), &QObject::deleteLater);
363 default:
364 if (uni != QLatin1String("any")) { // VPN connections use "any" as uni for the network interface.
365 qCDebug(NMQT) << "Can't create device of type" << type << "for" << uni;
366 }
367 }
368
369 return Device::Ptr(new Device(uni), &QObject::deleteLater);
370}
371
372NetworkManager::Status NetworkManager::NetworkManagerPrivate::status() const
373{
374 return nmState;
375}
376
377NetworkManager::Device::List NetworkManager::NetworkManagerPrivate::networkInterfaces()
378{
379 Device::List list;
380
381 QMap<QString, Device::Ptr>::const_iterator i;
382 for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) {
383 Device::Ptr networkInterface = findRegisteredNetworkInterface(uni: i.key());
384 if (!networkInterface.isNull()) {
385 list.append(t: networkInterface);
386 } else {
387 qCWarning(NMQT) << "warning: null network Interface for" << i.key();
388 }
389 }
390
391 return list;
392}
393
394NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findDeviceByIpIface(const QString &iface)
395{
396 QMap<QString, Device::Ptr>::const_iterator i;
397 for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) {
398 Device::Ptr networkInterface = findRegisteredNetworkInterface(uni: i.key());
399 if (networkInterface && networkInterface->udi() == iface) {
400 return networkInterface;
401 }
402 }
403
404 return Device::Ptr();
405}
406
407bool NetworkManager::NetworkManagerPrivate::isNetworkingEnabled() const
408{
409 return m_isNetworkingEnabled;
410}
411
412bool NetworkManager::NetworkManagerPrivate::isWirelessEnabled() const
413{
414 return m_isWirelessEnabled;
415}
416
417bool NetworkManager::NetworkManagerPrivate::isWirelessHardwareEnabled() const
418{
419 return m_isWirelessHardwareEnabled;
420}
421
422bool NetworkManager::NetworkManagerPrivate::isWwanEnabled() const
423{
424 return m_isWwanEnabled;
425}
426
427bool NetworkManager::NetworkManagerPrivate::isWwanHardwareEnabled() const
428{
429 return m_isWwanHardwareEnabled;
430}
431
432bool NetworkManager::NetworkManagerPrivate::isWimaxEnabled() const
433{
434 return checkVersion(x: 1, y: 2, z: 0) ? false : m_isWimaxEnabled;
435}
436
437bool NetworkManager::NetworkManagerPrivate::isWimaxHardwareEnabled() const
438{
439 return checkVersion(x: 1, y: 2, z: 0) ? false : m_isWimaxHardwareEnabled;
440}
441
442QDBusPendingReply<QDBusObjectPath>
443NetworkManager::NetworkManagerPrivate::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter)
444{
445 QString extra_connection_parameter = connectionParameter;
446 QString extra_interface_parameter = interfaceUni;
447 if (extra_connection_parameter.isEmpty()) {
448 extra_connection_parameter = QLatin1String("/");
449 }
450 if (extra_interface_parameter.isEmpty()) {
451 extra_interface_parameter = QLatin1String("/");
452 }
453 // TODO store error code
454 QDBusObjectPath connPath(connectionUni);
455 QDBusObjectPath interfacePath(interfaceUni);
456 // qCDebug(NMQT) << "Activating connection" << connPath.path() << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter;
457 return iface.ActivateConnection(connection: connPath, device: QDBusObjectPath(extra_interface_parameter), specific_object: QDBusObjectPath(extra_connection_parameter));
458}
459
460QDBusPendingReply<QDBusObjectPath, QDBusObjectPath> NetworkManager::NetworkManagerPrivate::addAndActivateConnection(const NMVariantMapMap &connection,
461 const QString &interfaceUni,
462 const QString &connectionParameter)
463{
464 QString extra_connection_parameter = connectionParameter;
465 if (extra_connection_parameter.isEmpty()) {
466 extra_connection_parameter = QLatin1String("/");
467 }
468 // TODO store error code
469 QDBusObjectPath interfacePath(interfaceUni);
470 return iface.AddAndActivateConnection(connection, device: interfacePath, specific_object: QDBusObjectPath(extra_connection_parameter));
471}
472
473QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap>
474NetworkManager::NetworkManagerPrivate::addAndActivateConnection2(const NMVariantMapMap &connection,
475 const QString &interfaceUni,
476 const QString &connectionParameter,
477 const QVariantMap &options)
478{
479 QString extra_connection_parameter = connectionParameter;
480 if (extra_connection_parameter.isEmpty()) {
481 extra_connection_parameter = QLatin1String("/");
482 }
483 // TODO store error code
484 QDBusObjectPath interfacePath(interfaceUni);
485 return iface.AddAndActivateConnection2(connection, device: interfacePath, specific_object: QDBusObjectPath(extra_connection_parameter), options);
486}
487
488QDBusPendingReply<> NetworkManager::NetworkManagerPrivate::deactivateConnection(const QString &activeConnectionPath)
489{
490 return iface.DeactivateConnection(active_connection: QDBusObjectPath(activeConnectionPath));
491}
492
493void NetworkManager::NetworkManagerPrivate::setNetworkingEnabled(bool enabled)
494{
495 iface.Enable(enable: enabled);
496}
497
498void NetworkManager::NetworkManagerPrivate::setWirelessEnabled(bool enabled)
499{
500 iface.setWirelessEnabled(enabled);
501}
502
503void NetworkManager::NetworkManagerPrivate::setWwanEnabled(bool enabled)
504{
505 iface.setWwanEnabled(enabled);
506}
507
508void NetworkManager::NetworkManagerPrivate::setWimaxEnabled(bool enabled)
509{
510 if (!checkVersion(x: 1, y: 2, z: 0)) {
511 iface.setWimaxEnabled(enabled);
512 }
513}
514
515void NetworkManager::NetworkManagerPrivate::sleep(bool sleep)
516{
517 iface.Sleep(sleep);
518}
519
520void NetworkManager::NetworkManagerPrivate::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains)
521{
522 QString logLevel;
523 QStringList logDomains;
524 switch (level) {
525 case NetworkManager::Error:
526 logLevel = QLatin1String("ERR");
527 break;
528 case NetworkManager::Warning:
529 logLevel = QLatin1String("WARN");
530 break;
531 case NetworkManager::Info:
532 logLevel = QLatin1String("INFO");
533 break;
534 case NetworkManager::Debug:
535 logLevel = QLatin1String("DEBUG");
536 break;
537 case NetworkManager::Trace:
538 logLevel = QLatin1String("TRACE");
539 break;
540 }
541 if (!domains.testFlag(flag: NoChange)) {
542 if (domains.testFlag(flag: NetworkManager::None)) {
543 logDomains << QLatin1String("NONE");
544 }
545 if (domains.testFlag(flag: NetworkManager::Hardware)) {
546 logDomains << QLatin1String("PLATFORM");
547 }
548 if (domains.testFlag(flag: NetworkManager::RFKill)) {
549 logDomains << QLatin1String("RFKILL");
550 }
551 if (domains.testFlag(flag: NetworkManager::Ethernet)) {
552 logDomains << QLatin1String("ETHER");
553 }
554 if (domains.testFlag(flag: NetworkManager::WiFi)) {
555 logDomains << QLatin1String("WIFI");
556 }
557 if (domains.testFlag(flag: NetworkManager::Bluetooth)) {
558 logDomains << QLatin1String("BT");
559 }
560 if (domains.testFlag(flag: NetworkManager::MobileBroadBand)) {
561 logDomains << QLatin1String("MB");
562 }
563 if (domains.testFlag(flag: NetworkManager::DHCP4)) {
564 logDomains << QLatin1String("DHCP4");
565 }
566 if (domains.testFlag(flag: NetworkManager::DHCP6)) {
567 logDomains << QLatin1String("DHCP6");
568 }
569 if (domains.testFlag(flag: NetworkManager::PPP)) {
570 logDomains << QLatin1String("PPP");
571 }
572 if (domains.testFlag(flag: NetworkManager::WiFiScan)) {
573 logDomains << QLatin1String("WIFI_SCAN");
574 }
575 if (domains.testFlag(flag: NetworkManager::IPv4)) {
576 logDomains << QLatin1String("IP4");
577 }
578 if (domains.testFlag(flag: NetworkManager::IPv6)) {
579 logDomains << QLatin1String("IP6");
580 }
581 if (domains.testFlag(flag: NetworkManager::AutoIPv4)) {
582 logDomains << QLatin1String("AUTOIP4");
583 }
584 if (domains.testFlag(flag: NetworkManager::DNS)) {
585 logDomains << QLatin1String("DNS");
586 }
587 if (domains.testFlag(flag: NetworkManager::VPN)) {
588 logDomains << QLatin1String("VPN");
589 }
590 if (domains.testFlag(flag: NetworkManager::Sharing)) {
591 logDomains << QLatin1String("SHARING");
592 }
593 if (domains.testFlag(flag: NetworkManager::Supplicant)) {
594 logDomains << QLatin1String("SUPPLICANT");
595 }
596 if (domains.testFlag(flag: NetworkManager::UserSet)) {
597 logDomains << QLatin1String("USER_SET");
598 }
599 if (domains.testFlag(flag: NetworkManager::SysSet)) {
600 logDomains << QLatin1String("SYS_SET");
601 }
602 if (domains.testFlag(flag: NetworkManager::Suspend)) {
603 logDomains << QLatin1String("SUSPEND");
604 }
605 if (domains.testFlag(flag: NetworkManager::Core)) {
606 logDomains << QLatin1String("CORE");
607 }
608 if (domains.testFlag(flag: NetworkManager::Devices)) {
609 logDomains << QLatin1String("DEVICE");
610 }
611 if (domains.testFlag(flag: NetworkManager::OLPC)) {
612 logDomains << QLatin1String("OLPC");
613 }
614 if (domains.testFlag(flag: NetworkManager::Wimax)) {
615 logDomains << QLatin1String("WIMAX");
616 }
617 if (domains.testFlag(flag: NetworkManager::Infiniband)) {
618 logDomains << QLatin1String("INFINIBAND");
619 }
620 if (domains.testFlag(flag: NetworkManager::Firewall)) {
621 logDomains << QLatin1String("FIREWALL");
622 }
623 if (domains.testFlag(flag: NetworkManager::Adsl)) {
624 logDomains << QLatin1String("ADSL");
625 }
626 if (domains.testFlag(flag: NetworkManager::Bond)) {
627 logDomains << QLatin1String("BOND");
628 }
629 if (domains.testFlag(flag: NetworkManager::Vlan)) {
630 logDomains << QLatin1String("VLAN");
631 }
632 if (domains.testFlag(flag: NetworkManager::Agents)) {
633 logDomains << QLatin1String("AGENTS");
634 }
635 if (domains.testFlag(flag: NetworkManager::Settings)) {
636 logDomains << QLatin1String("SETTINGS");
637 }
638 if (domains.testFlag(flag: NetworkManager::DbusProps)) {
639 logDomains << QLatin1String("DBUS_PROPS");
640 }
641 if (domains.testFlag(flag: NetworkManager::Team)) {
642 logDomains << QLatin1String("TEAM");
643 }
644 if (domains.testFlag(flag: NetworkManager::ConCheck)) {
645 logDomains << QLatin1String("CONCHECK");
646 }
647 if (domains.testFlag(flag: NetworkManager::Dcb)) {
648 logDomains << QLatin1String("DCB");
649 }
650 if (domains.testFlag(flag: NetworkManager::Dispatch)) {
651 logDomains << QLatin1String("DISPATCH");
652 }
653 }
654 iface.SetLogging(level: logLevel, domains: logDomains.join(sep: QLatin1Char(',')));
655}
656
657NMStringMap NetworkManager::NetworkManagerPrivate::permissions()
658{
659 return iface.GetPermissions();
660}
661
662NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::connectivity() const
663{
664 return m_connectivity;
665}
666
667QDBusPendingReply<uint> NetworkManager::NetworkManagerPrivate::checkConnectivity()
668{
669 return iface.CheckConnectivity();
670}
671
672NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::primaryConnection()
673{
674 return findRegisteredActiveConnection(uni: m_primaryConnection);
675}
676
677NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::activatingConnection()
678{
679 return findRegisteredActiveConnection(uni: m_activatingConnection);
680}
681
682NetworkManager::ConnectionSettings::ConnectionType NetworkManager::NetworkManagerPrivate::primaryConnectionType()
683{
684 return checkVersion(x: 1, y: 0, z: 0) ? m_primaryConnectionType : NetworkManager::ConnectionSettings::Unknown;
685}
686
687bool NetworkManager::NetworkManagerPrivate::isStartingUp() const
688{
689 return iface.startup();
690}
691
692NetworkManager::Device::MeteredStatus NetworkManager::NetworkManagerPrivate::metered() const
693{
694 return checkVersion(x: 1, y: 0, z: 6) ? m_metered : NetworkManager::Device::UnknownStatus;
695}
696
697NetworkManager::DnsConfiguration NetworkManager::NetworkManagerPrivate::globalDnsConfiguration() const
698{
699 return m_globalDnsConfiguration;
700}
701
702void NetworkManager::NetworkManagerPrivate::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration)
703{
704 m_globalDnsConfiguration = configuration;
705 iface.setGlobalDnsConfiguration(m_globalDnsConfiguration.toMap());
706}
707
708bool NetworkManager::NetworkManagerPrivate::isConnectivityCheckAvailable() const
709{
710 return m_isConnectivityCheckAvailable;
711}
712
713bool NetworkManager::NetworkManagerPrivate::isConnectivityCheckEnabled() const
714{
715 return m_isConnectivityCheckEnabled;
716}
717
718QString NetworkManager::NetworkManagerPrivate::connectivityCheckUri() const
719{
720 return m_connectivityCheckUri;
721}
722
723void NetworkManager::NetworkManagerPrivate::onDeviceAdded(const QDBusObjectPath &objpath)
724{
725 // qCDebug(NMQT);
726 if (!networkInterfaceMap.contains(key: objpath.path())) {
727 networkInterfaceMap.insert(key: objpath.path(), value: Device::Ptr());
728 Q_EMIT deviceAdded(uni: objpath.path());
729 }
730}
731
732void NetworkManager::NetworkManagerPrivate::onDeviceRemoved(const QDBusObjectPath &objpath)
733{
734 // qCDebug(NMQT);
735 networkInterfaceMap.remove(key: objpath.path());
736 Q_EMIT deviceRemoved(uni: objpath.path());
737}
738
739void NetworkManager::NetworkManagerPrivate::connectivityChanged(uint connectivity)
740{
741 NetworkManager::Connectivity newConnectivity = convertConnectivity(connectivity);
742 if (m_connectivity != newConnectivity) {
743 m_connectivity = newConnectivity;
744 Q_EMIT Notifier::connectivityChanged(connectivity: newConnectivity);
745 }
746}
747
748void NetworkManager::NetworkManagerPrivate::stateChanged(uint state)
749{
750 NetworkManager::Status newStatus = convertNMState(state);
751 if (nmState != newStatus) {
752 nmState = newStatus;
753 Q_EMIT Notifier::statusChanged(status: newStatus);
754 }
755}
756
757void NetworkManager::NetworkManagerPrivate::dbusPropertiesChanged(const QString &interfaceName,
758 const QVariantMap &properties,
759 const QStringList &invalidatedProperties)
760{
761 Q_UNUSED(invalidatedProperties);
762 if (interfaceName == QLatin1String("org.freedesktop.NetworkManager")) {
763 propertiesChanged(changedProperties: properties);
764 }
765}
766
767void NetworkManager::NetworkManagerPrivate::propertiesChanged(const QVariantMap &changedProperties)
768{
769 // qCDebug(NMQT) << Q_FUNC_INFO << changedProperties;
770
771 QVariantMap::const_iterator it = changedProperties.constBegin();
772 while (it != changedProperties.constEnd()) {
773 const QString property = it.key();
774 if (property == QLatin1String("ActiveConnections")) {
775 const QList<QDBusObjectPath> activePaths = qdbus_cast<QList<QDBusObjectPath>>(v: *it);
776 if (activePaths.isEmpty()) {
777 QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin();
778 while (it != m_activeConnections.constEnd()) {
779 Q_EMIT activeConnectionRemoved(path: it.key());
780 ++it;
781 }
782 m_activeConnections.clear();
783 } else {
784 QStringList knownConnections = m_activeConnections.keys();
785 for (const QDBusObjectPath &ac : activePaths) {
786 if (!m_activeConnections.contains(key: ac.path())) {
787 m_activeConnections.insert(key: ac.path(), value: NetworkManager::ActiveConnection::Ptr());
788 Q_EMIT activeConnectionAdded(path: ac.path());
789 } else {
790 knownConnections.removeOne(t: ac.path());
791 }
792 // qCDebug(NMQT) << " " << ac.path();
793 }
794 for (const QString &path : std::as_const(t&: knownConnections)) {
795 m_activeConnections.remove(key: path);
796 Q_EMIT activeConnectionRemoved(path);
797 }
798 }
799 Q_EMIT activeConnectionsChanged();
800 } else if (property == QLatin1String("NetworkingEnabled")) {
801 m_isNetworkingEnabled = it->toBool();
802 qCDebug(NMQT) << property << m_isNetworkingEnabled;
803 Q_EMIT networkingEnabledChanged(m_isNetworkingEnabled);
804 } else if (property == QLatin1String("WirelessHardwareEnabled")) {
805 m_isWirelessHardwareEnabled = it->toBool();
806 qCDebug(NMQT) << property << m_isWirelessHardwareEnabled;
807 Q_EMIT wirelessHardwareEnabledChanged(m_isWirelessHardwareEnabled);
808 } else if (property == QLatin1String("WirelessEnabled")) {
809 m_isWirelessEnabled = it->toBool();
810 qCDebug(NMQT) << property << m_isWirelessEnabled;
811 Q_EMIT wirelessEnabledChanged(m_isWirelessEnabled);
812 } else if (property == QLatin1String("WwanHardwareEnabled")) {
813 m_isWwanHardwareEnabled = it->toBool();
814 qCDebug(NMQT) << property << m_isWwanHardwareEnabled;
815 Q_EMIT wwanHardwareEnabledChanged(m_isWwanHardwareEnabled);
816 } else if (property == QLatin1String("WwanEnabled")) {
817 m_isWwanEnabled = it->toBool();
818 qCDebug(NMQT) << property << m_isWwanEnabled;
819 Q_EMIT wwanEnabledChanged(m_isWwanEnabled);
820 } else if (property == QLatin1String("WimaxHardwareEnabled")) {
821 m_isWimaxHardwareEnabled = it->toBool();
822 qCDebug(NMQT) << property << m_isWimaxHardwareEnabled;
823 Q_EMIT wimaxHardwareEnabledChanged(m_isWimaxHardwareEnabled);
824 } else if (property == QLatin1String("WimaxEnabled")) {
825 m_isWimaxEnabled = it->toBool();
826 qCDebug(NMQT) << property << m_isWimaxEnabled;
827 Q_EMIT wimaxEnabledChanged(m_isWimaxEnabled);
828 } else if (property == QLatin1String("Version")) {
829 m_version = it->toString();
830 parseVersion(version: m_version);
831 } else if (property == QLatin1String("State")) {
832 stateChanged(state: it->toUInt());
833 } else if (property == QLatin1String("Connectivity")) {
834 connectivityChanged(connectivity: it->toUInt());
835 } else if (property == QLatin1String("PrimaryConnection")) {
836 m_primaryConnection = it->value<QDBusObjectPath>().path();
837 Q_EMIT primaryConnectionChanged(uni: m_primaryConnection);
838 } else if (property == QLatin1String("ActivatingConnection")) {
839 m_activatingConnection = it->value<QDBusObjectPath>().path();
840 Q_EMIT activatingConnectionChanged(uni: m_activatingConnection);
841 } else if (property == QLatin1String("PrimaryConnectionType")) {
842 m_primaryConnectionType = NetworkManager::ConnectionSettings::typeFromString(typeString: it->toString());
843 Q_EMIT primaryConnectionTypeChanged(type: m_primaryConnectionType);
844 } else if (property == QLatin1String("Startup")) {
845 Q_EMIT isStartingUpChanged();
846 } else if (property == QLatin1String("Metered")) {
847 m_metered = (NetworkManager::Device::MeteredStatus)it->toUInt();
848 Q_EMIT meteredChanged(metered: m_metered);
849 } else if (property == QLatin1String("GlobalDnsConfiguration")) {
850 m_globalDnsConfiguration.fromMap(map: qdbus_cast<QVariantMap>(v: *it));
851 Q_EMIT globalDnsConfigurationChanged(configuration: m_globalDnsConfiguration);
852 } else if (property == QLatin1String("ConnectivityCheckAvailable")) {
853 m_isConnectivityCheckAvailable = it->toBool();
854 qCDebug(NMQT) << property << m_isConnectivityCheckAvailable;
855 Q_EMIT isConnectivityCheckAvailableChanged(m_isConnectivityCheckAvailable);
856 } else if (property == QLatin1String("ConnectivityCheckEnabled")) {
857 m_isConnectivityCheckEnabled = it->toBool();
858 qCDebug(NMQT) << property << m_isConnectivityCheckEnabled;
859 Q_EMIT isConnectivityCheckEnabledChanged(m_isConnectivityCheckEnabled);
860 } else if (property == QLatin1String("ConnectivityCheckUri")) {
861 m_connectivityCheckUri = it->toString().trimmed();
862 qCDebug(NMQT) << property << m_connectivityCheckUri;
863 Q_EMIT connectivityCheckUriChanged(m_connectivityCheckUri);
864 } else {
865 qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property;
866 }
867 ++it;
868 }
869}
870
871NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::convertConnectivity(uint connectivity)
872{
873 NetworkManager::Connectivity convertedConnectivity = NetworkManager::UnknownConnectivity;
874 switch (connectivity) {
875 case NM_CONNECTIVITY_UNKNOWN:
876 convertedConnectivity = NetworkManager::UnknownConnectivity;
877 break;
878 case NM_CONNECTIVITY_NONE:
879 convertedConnectivity = NetworkManager::NoConnectivity;
880 break;
881 case NM_CONNECTIVITY_PORTAL:
882 convertedConnectivity = NetworkManager::Portal;
883 break;
884 case NM_CONNECTIVITY_LIMITED:
885 convertedConnectivity = NetworkManager::Limited;
886 break;
887 case NM_CONNECTIVITY_FULL:
888 convertedConnectivity = NetworkManager::Full;
889 break;
890 }
891 return convertedConnectivity;
892}
893
894NetworkManager::Status NetworkManager::NetworkManagerPrivate::convertNMState(uint state)
895{
896 NetworkManager::Status status = NetworkManager::Unknown;
897 switch (state) {
898 case NM_STATE_UNKNOWN:
899 status = NetworkManager::Unknown;
900 break;
901 case NM_STATE_ASLEEP:
902 status = NetworkManager::Asleep;
903 break;
904 case NM_STATE_DISCONNECTED:
905 status = NetworkManager::Disconnected;
906 break;
907 case NM_STATE_DISCONNECTING:
908 status = NetworkManager::Disconnecting;
909 break;
910 case NM_STATE_CONNECTING:
911 status = NetworkManager::Connecting;
912 break;
913 case NM_STATE_CONNECTED_LOCAL:
914 status = NetworkManager::ConnectedLinkLocal;
915 break;
916 case NM_STATE_CONNECTED_SITE:
917 status = NetworkManager::ConnectedSiteOnly;
918 break;
919 case NM_STATE_CONNECTED_GLOBAL:
920 status = NetworkManager::Connected;
921 break;
922 }
923 return status;
924}
925
926void NetworkManager::NetworkManagerPrivate::dbusInterfacesAdded(const QDBusObjectPath &path, const QVariantMap &addedInterfaces)
927{
928 Q_UNUSED(path);
929
930 if (!addedInterfaces.contains(key: NetworkManagerPrivate::DBUS_DAEMON_INTERFACE)) {
931 return;
932 }
933
934 daemonRegistered();
935}
936
937void NetworkManager::NetworkManagerPrivate::daemonRegistered()
938{
939 if (iface.version().isEmpty()) {
940 // If this call fails, we've probably been called from ServiceRegistered on an old NM,
941 // and the interface isn't ready yet. Just exit and hope we get called again on InterfacesAdded.
942 return;
943 }
944
945 init();
946 Q_EMIT serviceAppeared();
947}
948
949void NetworkManager::NetworkManagerPrivate::daemonUnregistered()
950{
951 stateChanged(state: NM_STATE_UNKNOWN);
952 QMap<QString, Device::Ptr>::const_iterator i = networkInterfaceMap.constBegin();
953 while (i != networkInterfaceMap.constEnd()) {
954 Q_EMIT deviceRemoved(uni: i.key());
955 ++i;
956 }
957 networkInterfaceMap.clear();
958
959 QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin();
960 while (it != m_activeConnections.constEnd()) {
961 Q_EMIT activeConnectionRemoved(path: it.key());
962 ++it;
963 }
964 m_activeConnections.clear();
965
966 qobject_cast<SettingsPrivate *>(object: settingsNotifier())->daemonUnregistered();
967
968 Q_EMIT activeConnectionsChanged();
969 Q_EMIT serviceDisappeared();
970}
971
972NetworkManager::ActiveConnection::List NetworkManager::NetworkManagerPrivate::activeConnections()
973{
974 NetworkManager::ActiveConnection::List list;
975
976 // Take a copy because findRegisteredActiveConnection() may change m_activeConnections.
977 const QStringList keyList = m_activeConnections.keys();
978 for (const QString &key : keyList) {
979 NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(uni: key);
980
981 if (activeConnection) {
982 list << activeConnection;
983 }
984 }
985 return list;
986}
987
988QStringList NetworkManager::NetworkManagerPrivate::activeConnectionsPaths() const
989{
990 return m_activeConnections.keys();
991}
992
993QDBusPendingReply<QString, QString> NetworkManager::NetworkManagerPrivate::getLogging()
994{
995 return iface.GetLogging();
996}
997
998QString NetworkManager::version()
999{
1000 return globalNetworkManager->version();
1001}
1002
1003int NetworkManager::compareVersion(const QString &version)
1004{
1005 return globalNetworkManager->compareVersion(version);
1006}
1007
1008int NetworkManager::compareVersion(const int x, const int y, const int z)
1009{
1010 return globalNetworkManager->compareVersion(x, y, z);
1011}
1012
1013bool NetworkManager::checkVersion(const int x, const int y, const int z)
1014{
1015 return globalNetworkManager->checkVersion(x, y, z);
1016}
1017
1018NetworkManager::Status NetworkManager::status()
1019{
1020 return globalNetworkManager->status();
1021}
1022
1023NetworkManager::ActiveConnection::List NetworkManager::activeConnections()
1024{
1025 return globalNetworkManager->activeConnections();
1026}
1027
1028QStringList NetworkManager::activeConnectionsPaths()
1029{
1030 return globalNetworkManager->activeConnectionsPaths();
1031}
1032
1033NetworkManager::ActiveConnection::Ptr NetworkManager::findActiveConnection(const QString &uni)
1034{
1035 return globalNetworkManager->findRegisteredActiveConnection(uni);
1036}
1037
1038NetworkManager::Device::List NetworkManager::networkInterfaces()
1039{
1040 return globalNetworkManager->networkInterfaces();
1041}
1042
1043bool NetworkManager::isNetworkingEnabled()
1044{
1045 return globalNetworkManager->isNetworkingEnabled();
1046}
1047
1048bool NetworkManager::isWirelessEnabled()
1049{
1050 return globalNetworkManager->isWirelessEnabled();
1051}
1052
1053bool NetworkManager::isWirelessHardwareEnabled()
1054{
1055 return globalNetworkManager->isWirelessHardwareEnabled();
1056}
1057
1058NetworkManager::Device::Ptr NetworkManager::findNetworkInterface(const QString &uni)
1059{
1060 return globalNetworkManager->findRegisteredNetworkInterface(uni);
1061}
1062
1063NetworkManager::Device::Ptr NetworkManager::findDeviceByIpFace(const QString &iface)
1064{
1065 return globalNetworkManager->findDeviceByIpIface(iface);
1066}
1067
1068QDBusPendingReply<QDBusObjectPath, QDBusObjectPath>
1069NetworkManager::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter)
1070{
1071 return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter);
1072}
1073
1074QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap> NetworkManager::addAndActivateConnection2(const NMVariantMapMap &connection,
1075 const QString &interfaceUni,
1076 const QString &connectionParameter,
1077 const QVariantMap &options)
1078{
1079 if (checkVersion(x: 1, y: 16, z: 0)) {
1080 return globalNetworkManager->addAndActivateConnection2(connection, interfaceUni, connectionParameter, options);
1081 } else {
1082 return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter);
1083 }
1084}
1085
1086QDBusPendingReply<QDBusObjectPath>
1087NetworkManager::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter)
1088{
1089 return globalNetworkManager->activateConnection(connectionUni, interfaceUni, connectionParameter);
1090}
1091
1092QDBusPendingReply<> NetworkManager::deactivateConnection(const QString &activeConnectionPath)
1093{
1094 return globalNetworkManager->deactivateConnection(activeConnectionPath);
1095}
1096
1097QDBusPendingReply<QString, QString> NetworkManager::getLogging()
1098{
1099 return globalNetworkManager->getLogging();
1100}
1101
1102void NetworkManager::setNetworkingEnabled(bool enabled)
1103{
1104 globalNetworkManager->setNetworkingEnabled(enabled);
1105}
1106
1107void NetworkManager::setWirelessEnabled(bool enabled)
1108{
1109 globalNetworkManager->setWirelessEnabled(enabled);
1110}
1111
1112bool NetworkManager::isWwanEnabled()
1113{
1114 return globalNetworkManager->isWwanEnabled();
1115}
1116
1117bool NetworkManager::isWwanHardwareEnabled()
1118{
1119 return globalNetworkManager->isWwanHardwareEnabled();
1120}
1121
1122void NetworkManager::setWwanEnabled(bool enabled)
1123{
1124 globalNetworkManager->setWwanEnabled(enabled);
1125}
1126
1127bool NetworkManager::isWimaxEnabled()
1128{
1129 return globalNetworkManager->isWimaxEnabled();
1130}
1131
1132bool NetworkManager::isWimaxHardwareEnabled()
1133{
1134 return globalNetworkManager->isWimaxHardwareEnabled();
1135}
1136
1137void NetworkManager::setWimaxEnabled(bool enabled)
1138{
1139 globalNetworkManager->setWimaxEnabled(enabled);
1140}
1141
1142void NetworkManager::sleep(bool sleep)
1143{
1144 globalNetworkManager->sleep(sleep);
1145}
1146
1147void NetworkManager::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains)
1148{
1149 globalNetworkManager->setLogging(level, domains);
1150}
1151
1152NMStringMap NetworkManager::permissions()
1153{
1154 return globalNetworkManager->permissions();
1155}
1156
1157NetworkManager::Device::Types NetworkManager::supportedInterfaceTypes()
1158{
1159 return globalNetworkManager->supportedInterfaceTypes();
1160}
1161
1162NetworkManager::Connectivity NetworkManager::connectivity()
1163{
1164 return globalNetworkManager->connectivity();
1165}
1166
1167QDBusPendingReply<uint> NetworkManager::checkConnectivity()
1168{
1169 return globalNetworkManager->checkConnectivity();
1170}
1171
1172NetworkManager::ActiveConnection::Ptr NetworkManager::primaryConnection()
1173{
1174 return globalNetworkManager->primaryConnection();
1175}
1176
1177NetworkManager::ActiveConnection::Ptr NetworkManager::activatingConnection()
1178{
1179 return globalNetworkManager->activatingConnection();
1180}
1181
1182NetworkManager::ConnectionSettings::ConnectionType NetworkManager::primaryConnectionType()
1183{
1184 return globalNetworkManager->primaryConnectionType();
1185}
1186
1187bool NetworkManager::isStartingUp()
1188{
1189 return globalNetworkManager->isStartingUp();
1190}
1191
1192NetworkManager::Device::MeteredStatus NetworkManager::metered()
1193{
1194 return globalNetworkManager->metered();
1195}
1196
1197NetworkManager::DnsConfiguration NetworkManager::globalDnsConfiguration()
1198{
1199 return globalNetworkManager->globalDnsConfiguration();
1200}
1201
1202void NetworkManager::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration)
1203{
1204 globalNetworkManager->setGlobalDnsConfiguration(configuration);
1205}
1206
1207bool NetworkManager::isConnectivityCheckAvailable()
1208{
1209 return globalNetworkManager->isConnectivityCheckAvailable();
1210}
1211
1212bool NetworkManager::isConnectivityCheckEnabled()
1213{
1214 return globalNetworkManager->isConnectivityCheckEnabled();
1215}
1216
1217QString NetworkManager::connectivityCheckUri()
1218{
1219 return globalNetworkManager->connectivityCheckUri();
1220}
1221
1222NetworkManager::Notifier *NetworkManager::notifier()
1223{
1224 return globalNetworkManager;
1225}
1226
1227#include "moc_manager.cpp"
1228#include "moc_manager_p.cpp"
1229

source code of networkmanager-qt/src/manager.cpp