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

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