networkmanager-qt/src/manager.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2008, 2010 Will Stephenson <wstephenson@kde.org>
0003     SPDX-FileCopyrightText: 2011-2013 Lamarque Souza <lamarque@kde.org>
0004     SPDX-FileCopyrightText: 2013 Daniel Nicoletti <dantti12@gmail.com>
0005     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
0006
0007     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0008 */
0009
0010 #include "manager.h"
0011 #include "manager_p.h"
0012
0013 #include "macros.h"
0014
0015 #undef signals
0016 #include <libnm/NetworkManager.h>
0017 #define signals Q_SIGNALS
0018
0019 #include "adsldevice.h"
0020 #include "bluetoothdevice.h"
0021 #include "bonddevice.h"
0022 #include "bridgedevice.h"
0023 #include "dbus/deviceinterface.h"
0024 #include "device_p.h"
0025 #include "genericdevice.h"
0026 #include "gredevice.h"
0027 #include "infinibanddevice.h"
0028 #include "iptunneldevice.h"
0029 #include "macvlandevice.h"
0030 #include "modemdevice.h"
0031 #include "olpcmeshdevice.h"
0032 #include "settings.h"
0033 #include "settings_p.h"
0034 #include "tundevice.h"
0035 #include "vethdevice.h"
0036 #include "vlandevice.h"
0037 #include "vpnconnection.h"
0038 #include "wimaxdevice.h"
0039 #include "wireddevice.h"
0040 #include "wireguarddevice.h"
0041 #include "wirelessdevice.h"
0042
0043 #include "nmdebug.h"
0044
0045 #define DBUS_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager"
0046 #define DBUS_PROPERTIES "org.freedesktop.DBus.Properties"
0047
0048 #ifdef NMQT_STATIC
0049 const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1("org.kde.fakenetwork"));
0050 const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1("/org/kde/fakenetwork"));
0051 const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1("org.kde.fakenetwork"));
0052 const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1("/org/kde/fakenetwork/Settings"));
0053 #else
0054 const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1(NM_DBUS_SERVICE));
0055 const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1(NM_DBUS_PATH));
0056 const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1(NM_DBUS_INTERFACE));
0057 const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1(NM_DBUS_PATH_SETTINGS));
0058 #endif
0059 const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES(QString::fromLatin1(DBUS_PROPERTIES));
0060 const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER(QString::fromLatin1(DBUS_OBJECT_MANAGER));
0061
0062 Q_GLOBAL_STATIC(NetworkManager::NetworkManagerPrivate, globalNetworkManager)
0063
0064 NetworkManager::NetworkManagerPrivate::NetworkManagerPrivate()
0065 #ifdef NMQT_STATIC
0066     : watcher(DBUS_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForUnregistration, this)
0067     , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::sessionBus())
0068 #else
0069     : watcher(DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForUnregistration, this)
0070     , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::systemBus())
0071 #endif
0072     , nmState(NetworkManager::Unknown)
0073     , m_connectivity(NetworkManager::UnknownConnectivity)
0074     , m_isNetworkingEnabled(false)
0075     , m_isWimaxEnabled(false)
0076     , m_isWimaxHardwareEnabled(false)
0077     , m_isWirelessEnabled(false)
0078     , m_isWirelessHardwareEnabled(false)
0079     , m_isWwanEnabled(false)
0080     , m_isWwanHardwareEnabled(false)
0081     , m_globalDnsConfiguration(NetworkManager::DnsConfiguration())
0082     , m_supportedInterfaceTypes(NetworkManager::Device::UnknownType)
0083 {
0084     connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceAdded, this, &NetworkManagerPrivate::onDeviceAdded);
0085     connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceRemoved, this, &NetworkManagerPrivate::onDeviceRemoved);
0086
0087 #ifndef NMQT_STATIC
0088     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE,
0089                                          NetworkManagerPrivate::DBUS_DAEMON_PATH,
0090                                          NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
0091                                          QLatin1String("PropertiesChanged"),
0092                                          this,
0093                                          SLOT(dbusPropertiesChanged(QString, QVariantMap, QStringList)));
0094 #else
0095     connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged);
0096 #endif
0097
0098     iface.connection().connect(NetworkManagerPrivate::DBUS_SERVICE,
0099                                "/org/freedesktop",
0100                                NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER,
0101                                QLatin1String("InterfacesAdded"),
0102                                this,
0103                                SLOT(dbusInterfacesAdded(QDBusObjectPath, QVariantMap)));
0104
0105     connect(&watcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManagerPrivate::daemonUnregistered);
0106
0107     init();
0108 }
0109
0110 void NetworkManager::NetworkManagerPrivate::parseVersion(const QString &version)
0111 {
0112     const QStringList sl = version.split('.');
0113
0114     if (sl.size() > 2) {
0115         m_x = sl[0].toInt();
0116         m_y = sl[1].toInt();
0117         m_z = sl[2].toInt();
0118     } else {
0119         m_x = -1;
0120         m_y = -1;
0121         m_z = -1;
0122     }
0123 }
0124
0125 void NetworkManager::NetworkManagerPrivate::init()
0126 {
0127     qDBusRegisterMetaType<UIntList>();
0128     qDBusRegisterMetaType<UIntListList>();
0129     //     qDBusRegisterMetaType<IpV6DBusAddress>();
0130     //     qDBusRegisterMetaType<IpV6DBusAddressList>();
0131     //     qDBusRegisterMetaType<IpV6DBusNameservers>();
0132     //     qDBusRegisterMetaType<IpV6DBusRoute>();
0133     //     qDBusRegisterMetaType<IpV6DBusRouteList>();
0134     qDBusRegisterMetaType<QList<QDBusObjectPath>>();
0135     qDBusRegisterMetaType<DeviceDBusStateReason>();
0136     qDBusRegisterMetaType<NMVariantMapMap>();
0137     qDBusRegisterMetaType<NMVariantMapList>();
0138     qDBusRegisterMetaType<NMStringMap>();
0139
0140     m_version = iface.version();
0141     parseVersion(m_version);
0142     /* clang-format off */
0143     m_supportedInterfaceTypes = static_cast<NetworkManager::Device::Types>(
0144         NetworkManager::Device::Ethernet
0145         | NetworkManager::Device::Wifi
0146         | NetworkManager::Device::Modem
0147         | (checkVersion(1, 2, 0) ? 0 : NetworkManager::Device::Wimax)
0148         | NetworkManager::Device::Bluetooth
0149         | NetworkManager::Device::OlpcMesh
0150         | NetworkManager::Device::InfiniBand
0151         | NetworkManager::Device::Bond
0152         | NetworkManager::Device::Vlan
0153         | NetworkManager::Device::Adsl
0154         | NetworkManager::Device::Bridge
0155         | NetworkManager::Device::Generic
0156         | NetworkManager::Device::Team
0157         | NetworkManager::Device::MacVlan
0158         | NetworkManager::Device::Tun
0159         | NetworkManager::Device::Veth
0160         | NetworkManager::Device::IpTunnel
0161         | NetworkManager::Device::WireGuard);
0162     /* clang-format on */
0163
0164     // Get all Manager's properties async
0165     QVariantMap initialProperties = retrieveInitialProperties(iface.staticInterfaceName(), DBUS_DAEMON_PATH);
0166     if (!initialProperties.isEmpty()) {
0167         propertiesChanged(initialProperties);
0168     }
0169
0170     QTimer::singleShot(0, [] {
0171         qobject_cast<SettingsPrivate *>(settingsNotifier())->init();
0172     });
0173
0174     if (iface.isValid()) {
0175         const QList<QDBusObjectPath> devices = iface.devices();
0176         qCDebug(NMQT) << "Device list";
0177         for (const QDBusObjectPath &op : devices) {
0178             networkInterfaceMap.insert(op.path(), Device::Ptr());
0179             Q_EMIT deviceAdded(op.path());
0180             qCDebug(NMQT) << "  " << op.path();
0181         }
0182     }
0183 }
0184
0185 NetworkManager::NetworkManagerPrivate::~NetworkManagerPrivate()
0186 {
0187 }
0188
0189 QString NetworkManager::NetworkManagerPrivate::version() const
0190 {
0191     return m_version;
0192 }
0193
0194 int NetworkManager::NetworkManagerPrivate::compareVersion(const QString &version)
0195 {
0196     int x;
0197     int y;
0198     int z;
0199 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
0200     const auto sl = QStringView(version).split('.');
0201 #else
0202     const auto sl = version.splitRef('.');
0203 #endif
0204     if (sl.size() > 2) {
0205         x = sl[0].toInt();
0206         y = sl[1].toInt();
0207         z = sl[2].toInt();
0208     } else {
0209         x = -1;
0210         y = -1;
0211         z = -1;
0212     }
0213
0214     return compareVersion(x, y, z);
0215 }
0216
0217 int NetworkManager::NetworkManagerPrivate::compareVersion(const int x, const int y, const int z) const
0218 {
0219     if (m_x > x) {
0220         return 1;
0221     } else if (m_x < x) {
0222         return -1;
0223     } else if (m_y > y) {
0224         return 1;
0225     } else if (m_y < y) {
0226         return -1;
0227     } else if (m_z > z) {
0228         return 1;
0229     } else if (m_z < z) {
0230         return -1;
0231     }
0232     return 0;
0233 }
0234
0235 bool NetworkManager::NetworkManagerPrivate::checkVersion(const int x, const int y, const int z) const
0236 {
0237     return 0 <= compareVersion(x, y, z);
0238 }
0239
0240 NetworkManager::Device::Types NetworkManager::NetworkManagerPrivate::supportedInterfaceTypes() const
0241 {
0242     return m_supportedInterfaceTypes;
0243 }
0244
0245 QVariantMap NetworkManager::NetworkManagerPrivate::retrieveInitialProperties(const QString &interfaceName, const QString &path)
0246 {
0247     QDBusMessage message = QDBusMessage::createMethodCall(DBUS_SERVICE, path, FDO_DBUS_PROPERTIES, QLatin1String("GetAll"));
0248     message << interfaceName;
0249 #ifdef NMQT_STATIC
0250     QDBusMessage resultMessage = QDBusConnection::sessionBus().call(message);
0251 #else
0252     QDBusMessage resultMessage = QDBusConnection::systemBus().call(message);
0253 #endif
0254     if (resultMessage.type() == QDBusMessage::ReplyMessage) {
0255         QVariantMap result;
0256         QDBusArgument dbusArgument = resultMessage.arguments().at(0).value<QDBusArgument>();
0257         while (!dbusArgument.atEnd()) {
0258             dbusArgument >> result;
0259         }
0260         return result;
0261     }
0262
0263     return QVariantMap();
0264 }
0265
0266 NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni)
0267 {
0268     NetworkManager::Device::Ptr networkInterface;
0269     auto it = networkInterfaceMap.constFind(uni);
0270     if (it != networkInterfaceMap.constEnd()) {
0271         if (*it) {
0272             networkInterface = *it;
0273         } else {
0274             networkInterface = createNetworkInterface(uni);
0275             networkInterfaceMap[uni] = networkInterface;
0276         }
0277     }
0278     return networkInterface;
0279 }
0280
0281 NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredActiveConnection(const QString &uni)
0282 {
0283     NetworkManager::ActiveConnection::Ptr activeConnection;
0284     if (!uni.isEmpty() && uni != QLatin1String("/")) {
0285         const auto it = m_activeConnections.constFind(uni);
0286         const bool contains = it != m_activeConnections.constEnd();
0287         if (contains && *it) {
0288             activeConnection = *it;
0289         } else {
0290             activeConnection = NetworkManager::ActiveConnection::Ptr(new NetworkManager::VpnConnection(uni), &QObject::deleteLater);
0291             if (activeConnection->connection()) {
0292                 m_activeConnections[uni] = activeConnection;
0293                 if (!contains) {
0294                     Q_EMIT activeConnectionAdded(uni);
0295                 }
0296             } else {
0297                 activeConnection.clear();
0298             }
0299         }
0300     }
0301     return activeConnection;
0302 }
0303
0304 NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::createNetworkInterface(const QString &uni)
0305 {
0306     // qCDebug(NMQT);
0307     auto message = QDBusMessage::createMethodCall(DBUS_SERVICE, uni, FDO_DBUS_PROPERTIES, QStringLiteral("Get"));
0308     message.setArguments({QLatin1String(OrgFreedesktopNetworkManagerDeviceInterface::staticInterfaceName()), QStringLiteral("DeviceType")});
0309 #ifdef NMQT_STATIC
0310     auto bus = QDBusConnection::sessionBus();
0311 #else
0312     auto bus = QDBusConnection::systemBus();
0313 #endif
0314     QDBusReply<QVariant> reply = bus.call(message);
0315     Device::Type type = reply.isValid() ? NetworkManager::DevicePrivate::convertType(reply.value().toInt()) : Device::UnknownType;
0316     switch (type) {
0317     case Device::Ethernet:
0318         return Device::Ptr(new NetworkManager::WiredDevice(uni), &QObject::deleteLater);
0319     case Device::Wifi:
0320         return Device::Ptr(new NetworkManager::WirelessDevice(uni), &QObject::deleteLater);
0321     case Device::Modem:
0322         return Device::Ptr(new NetworkManager::ModemDevice(uni), &QObject::deleteLater);
0323     case Device::Bluetooth:
0324         return Device::Ptr(new NetworkManager::BluetoothDevice(uni), &QObject::deleteLater);
0325     case Device::Wimax:
0326         return Device::Ptr(new NetworkManager::WimaxDevice(uni), &QObject::deleteLater);
0327     case Device::OlpcMesh:
0328         return Device::Ptr(new NetworkManager::OlpcMeshDevice(uni), &QObject::deleteLater);
0329     case Device::InfiniBand:
0330         return Device::Ptr(new NetworkManager::InfinibandDevice(uni), &QObject::deleteLater);
0331     case Device::Bond:
0332         return Device::Ptr(new NetworkManager::BondDevice(uni), &QObject::deleteLater);
0333     case Device::Vlan:
0334         return Device::Ptr(new NetworkManager::VlanDevice(uni), &QObject::deleteLater);
0335     case Device::Adsl:
0336         return Device::Ptr(new NetworkManager::AdslDevice(uni), &QObject::deleteLater);
0337     case Device::Bridge:
0338         return Device::Ptr(new NetworkManager::BridgeDevice(uni), &QObject::deleteLater);
0339     // No need to check checkVersion, because we can't get Generic, Gre, MacVlan, Tun & Veth values in incompatible runtime
0340     case Device::Generic:
0341         return Device::Ptr(new NetworkManager::GenericDevice(uni), &QObject::deleteLater);
0342     case Device::Gre:
0343         return Device::Ptr(new NetworkManager::GreDevice(uni), &QObject::deleteLater);
0344     case Device::MacVlan:
0345         return Device::Ptr(new NetworkManager::MacVlanDevice(uni), &QObject::deleteLater);
0346     case Device::Tun:
0347         return Device::Ptr(new NetworkManager::TunDevice(uni), &QObject::deleteLater);
0348     case Device::Veth:
0349         return Device::Ptr(new NetworkManager::VethDevice(uni), &QObject::deleteLater);
0350     case Device::IpTunnel:
0351         return Device::Ptr(new NetworkManager::IpTunnelDevice(uni), &QObject::deleteLater);
0352     case Device::WireGuard:
0353         return Device::Ptr(new NetworkManager::WireGuardDevice(uni), &QObject::deleteLater);
0354     default:
0355         if (uni != QLatin1String("any")) { // VPN connections use "any" as uni for the network interface.
0356             qCDebug(NMQT) << "Can't create device of type" << type << "for" << uni;
0357         }
0358     }
0359
0360     return Device::Ptr(new Device(uni), &QObject::deleteLater);
0361 }
0362
0363 NetworkManager::Status NetworkManager::NetworkManagerPrivate::status() const
0364 {
0365     return nmState;
0366 }
0367
0368 NetworkManager::Device::List NetworkManager::NetworkManagerPrivate::networkInterfaces()
0369 {
0370     Device::List list;
0371
0372     QMap<QString, Device::Ptr>::const_iterator i;
0373     for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) {
0374         Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key());
0375         if (!networkInterface.isNull()) {
0376             list.append(networkInterface);
0377         } else {
0378             qCWarning(NMQT) << "warning: null network Interface for" << i.key();
0379         }
0380     }
0381
0382     return list;
0383 }
0384
0385 NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findDeviceByIpIface(const QString &iface)
0386 {
0387     QMap<QString, Device::Ptr>::const_iterator i;
0388     for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) {
0389         Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key());
0390         if (networkInterface && networkInterface->udi() == iface) {
0391             return networkInterface;
0392         }
0393     }
0394
0395     return Device::Ptr();
0396 }
0397
0398 bool NetworkManager::NetworkManagerPrivate::isNetworkingEnabled() const
0399 {
0400     return m_isNetworkingEnabled;
0401 }
0402
0403 bool NetworkManager::NetworkManagerPrivate::isWirelessEnabled() const
0404 {
0405     return m_isWirelessEnabled;
0406 }
0407
0408 bool NetworkManager::NetworkManagerPrivate::isWirelessHardwareEnabled() const
0409 {
0410     return m_isWirelessHardwareEnabled;
0411 }
0412
0413 bool NetworkManager::NetworkManagerPrivate::isWwanEnabled() const
0414 {
0415     return m_isWwanEnabled;
0416 }
0417
0418 bool NetworkManager::NetworkManagerPrivate::isWwanHardwareEnabled() const
0419 {
0420     return m_isWwanHardwareEnabled;
0421 }
0422
0423 bool NetworkManager::NetworkManagerPrivate::isWimaxEnabled() const
0424 {
0425     return checkVersion(1, 2, 0) ? false : m_isWimaxEnabled;
0426 }
0427
0428 bool NetworkManager::NetworkManagerPrivate::isWimaxHardwareEnabled() const
0429 {
0430     return checkVersion(1, 2, 0) ? false : m_isWimaxHardwareEnabled;
0431 }
0432
0433 QDBusPendingReply<QDBusObjectPath>
0434 NetworkManager::NetworkManagerPrivate::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter)
0435 {
0436     QString extra_connection_parameter = connectionParameter;
0437     QString extra_interface_parameter = interfaceUni;
0438     if (extra_connection_parameter.isEmpty()) {
0439         extra_connection_parameter = QLatin1String("/");
0440     }
0441     if (extra_interface_parameter.isEmpty()) {
0442         extra_interface_parameter = QLatin1String("/");
0443     }
0444     // TODO store error code
0445     QDBusObjectPath connPath(connectionUni);
0446     QDBusObjectPath interfacePath(interfaceUni);
0447     // qCDebug(NMQT) << "Activating connection" << connPath.path() << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter;
0448     return iface.ActivateConnection(connPath, QDBusObjectPath(extra_interface_parameter), QDBusObjectPath(extra_connection_parameter));
0449 }
0450
0451 QDBusPendingReply<QDBusObjectPath, QDBusObjectPath> NetworkManager::NetworkManagerPrivate::addAndActivateConnection(const NMVariantMapMap &connection,
0452                                                                                                                     const QString &interfaceUni,
0453                                                                                                                     const QString &connectionParameter)
0454 {
0455     QString extra_connection_parameter = connectionParameter;
0456     if (extra_connection_parameter.isEmpty()) {
0457         extra_connection_parameter = QLatin1String("/");
0458     }
0459     // TODO store error code
0460     QDBusObjectPath interfacePath(interfaceUni);
0461     return iface.AddAndActivateConnection(connection, interfacePath, QDBusObjectPath(extra_connection_parameter));
0462 }
0463
0464 QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap>
0465 NetworkManager::NetworkManagerPrivate::addAndActivateConnection2(const NMVariantMapMap &connection,
0466                                                                  const QString &interfaceUni,
0467                                                                  const QString &connectionParameter,
0468                                                                  const QVariantMap &options)
0469 {
0470     QString extra_connection_parameter = connectionParameter;
0471     if (extra_connection_parameter.isEmpty()) {
0472         extra_connection_parameter = QLatin1String("/");
0473     }
0474     // TODO store error code
0475     QDBusObjectPath interfacePath(interfaceUni);
0476     return iface.AddAndActivateConnection2(connection, interfacePath, QDBusObjectPath(extra_connection_parameter), options);
0477 }
0478
0479 QDBusPendingReply<> NetworkManager::NetworkManagerPrivate::deactivateConnection(const QString &activeConnectionPath)
0480 {
0481     return iface.DeactivateConnection(QDBusObjectPath(activeConnectionPath));
0482 }
0483
0484 void NetworkManager::NetworkManagerPrivate::setNetworkingEnabled(bool enabled)
0485 {
0486     iface.Enable(enabled);
0487 }
0488
0489 void NetworkManager::NetworkManagerPrivate::setWirelessEnabled(bool enabled)
0490 {
0491     iface.setWirelessEnabled(enabled);
0492 }
0493
0494 void NetworkManager::NetworkManagerPrivate::setWwanEnabled(bool enabled)
0495 {
0496     iface.setWwanEnabled(enabled);
0497 }
0498
0499 void NetworkManager::NetworkManagerPrivate::setWimaxEnabled(bool enabled)
0500 {
0501     if (!checkVersion(1, 2, 0)) {
0502         iface.setWimaxEnabled(enabled);
0503     }
0504 }
0505
0506 void NetworkManager::NetworkManagerPrivate::sleep(bool sleep)
0507 {
0508     iface.Sleep(sleep);
0509 }
0510
0511 void NetworkManager::NetworkManagerPrivate::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains)
0512 {
0513     QString logLevel;
0514     QStringList logDomains;
0515     switch (level) {
0516     case NetworkManager::Error:
0517         logLevel = QLatin1String("ERR");
0518         break;
0519     case NetworkManager::Warning:
0520         logLevel = QLatin1String("WARN");
0521         break;
0522     case NetworkManager::Info:
0523         logLevel = QLatin1String("INFO");
0524         break;
0525     case NetworkManager::Debug:
0526         logLevel = QLatin1String("DEBUG");
0527         break;
0528     case NetworkManager::Trace:
0529         logLevel = QLatin1String("TRACE");
0530         break;
0531     }
0532     if (!domains.testFlag(NoChange)) {
0533         if (domains.testFlag(NetworkManager::None)) {
0534             logDomains << QLatin1String("NONE");
0535         }
0536         if (domains.testFlag(NetworkManager::Hardware)) {
0537             logDomains << QLatin1String("PLATFORM");
0538         }
0539         if (domains.testFlag(NetworkManager::RFKill)) {
0540             logDomains << QLatin1String("RFKILL");
0541         }
0542         if (domains.testFlag(NetworkManager::Ethernet)) {
0543             logDomains << QLatin1String("ETHER");
0544         }
0545         if (domains.testFlag(NetworkManager::WiFi)) {
0546             logDomains << QLatin1String("WIFI");
0547         }
0548         if (domains.testFlag(NetworkManager::Bluetooth)) {
0549             logDomains << QLatin1String("BT");
0550         }
0551         if (domains.testFlag(NetworkManager::MobileBroadBand)) {
0552             logDomains << QLatin1String("MB");
0553         }
0554         if (domains.testFlag(NetworkManager::DHCP4)) {
0555             logDomains << QLatin1String("DHCP4");
0556         }
0557         if (domains.testFlag(NetworkManager::DHCP6)) {
0558             logDomains << QLatin1String("DHCP6");
0559         }
0560         if (domains.testFlag(NetworkManager::PPP)) {
0561             logDomains << QLatin1String("PPP");
0562         }
0563         if (domains.testFlag(NetworkManager::WiFiScan)) {
0564             logDomains << QLatin1String("WIFI_SCAN");
0565         }
0566         if (domains.testFlag(NetworkManager::IPv4)) {
0567             logDomains << QLatin1String("IP4");
0568         }
0569         if (domains.testFlag(NetworkManager::IPv6)) {
0570             logDomains << QLatin1String("IP6");
0571         }
0572         if (domains.testFlag(NetworkManager::AutoIPv4)) {
0573             logDomains << QLatin1String("AUTOIP4");
0574         }
0575         if (domains.testFlag(NetworkManager::DNS)) {
0576             logDomains << QLatin1String("DNS");
0577         }
0578         if (domains.testFlag(NetworkManager::VPN)) {
0579             logDomains << QLatin1String("VPN");
0580         }
0581         if (domains.testFlag(NetworkManager::Sharing)) {
0582             logDomains << QLatin1String("SHARING");
0583         }
0584         if (domains.testFlag(NetworkManager::Supplicant)) {
0585             logDomains << QLatin1String("SUPPLICANT");
0586         }
0587         if (domains.testFlag(NetworkManager::UserSet)) {
0588             logDomains << QLatin1String("USER_SET");
0589         }
0590         if (domains.testFlag(NetworkManager::SysSet)) {
0591             logDomains << QLatin1String("SYS_SET");
0592         }
0593         if (domains.testFlag(NetworkManager::Suspend)) {
0594             logDomains << QLatin1String("SUSPEND");
0595         }
0596         if (domains.testFlag(NetworkManager::Core)) {
0597             logDomains << QLatin1String("CORE");
0598         }
0599         if (domains.testFlag(NetworkManager::Devices)) {
0600             logDomains << QLatin1String("DEVICE");
0601         }
0602         if (domains.testFlag(NetworkManager::OLPC)) {
0603             logDomains << QLatin1String("OLPC");
0604         }
0605         if (domains.testFlag(NetworkManager::Wimax)) {
0606             logDomains << QLatin1String("WIMAX");
0607         }
0608         if (domains.testFlag(NetworkManager::Infiniband)) {
0609             logDomains << QLatin1String("INFINIBAND");
0610         }
0611         if (domains.testFlag(NetworkManager::Firewall)) {
0612             logDomains << QLatin1String("FIREWALL");
0613         }
0614         if (domains.testFlag(NetworkManager::Adsl)) {
0615             logDomains << QLatin1String("ADSL");
0616         }
0617         if (domains.testFlag(NetworkManager::Bond)) {
0618             logDomains << QLatin1String("BOND");
0619         }
0620         if (domains.testFlag(NetworkManager::Vlan)) {
0621             logDomains << QLatin1String("VLAN");
0622         }
0623         if (domains.testFlag(NetworkManager::Agents)) {
0624             logDomains << QLatin1String("AGENTS");
0625         }
0626         if (domains.testFlag(NetworkManager::Settings)) {
0627             logDomains << QLatin1String("SETTINGS");
0628         }
0629         if (domains.testFlag(NetworkManager::DbusProps)) {
0630             logDomains << QLatin1String("DBUS_PROPS");
0631         }
0632         if (domains.testFlag(NetworkManager::Team)) {
0633             logDomains << QLatin1String("TEAM");
0634         }
0635         if (domains.testFlag(NetworkManager::ConCheck)) {
0636             logDomains << QLatin1String("CONCHECK");
0637         }
0638         if (domains.testFlag(NetworkManager::Dcb)) {
0639             logDomains << QLatin1String("DCB");
0640         }
0641         if (domains.testFlag(NetworkManager::Dispatch)) {
0642             logDomains << QLatin1String("DISPATCH");
0643         }
0644     }
0645     iface.SetLogging(logLevel, logDomains.join(QLatin1Char(',')));
0646 }
0647
0648 NMStringMap NetworkManager::NetworkManagerPrivate::permissions()
0649 {
0650     return iface.GetPermissions();
0651 }
0652
0653 NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::connectivity() const
0654 {
0655     return m_connectivity;
0656 }
0657
0658 QDBusPendingReply<uint> NetworkManager::NetworkManagerPrivate::checkConnectivity()
0659 {
0660     return iface.CheckConnectivity();
0661 }
0662
0663 NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::primaryConnection()
0664 {
0665     return findRegisteredActiveConnection(m_primaryConnection);
0666 }
0667
0668 NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::activatingConnection()
0669 {
0670     return findRegisteredActiveConnection(m_activatingConnection);
0671 }
0672
0673 NetworkManager::ConnectionSettings::ConnectionType NetworkManager::NetworkManagerPrivate::primaryConnectionType()
0674 {
0675     return checkVersion(1, 0, 0) ? m_primaryConnectionType : NetworkManager::ConnectionSettings::Unknown;
0676 }
0677
0678 bool NetworkManager::NetworkManagerPrivate::isStartingUp() const
0679 {
0680     return iface.startup();
0681 }
0682
0683 NetworkManager::Device::MeteredStatus NetworkManager::NetworkManagerPrivate::metered() const
0684 {
0685     return checkVersion(1, 0, 6) ? m_metered : NetworkManager::Device::UnknownStatus;
0686 }
0687
0688 NetworkManager::DnsConfiguration NetworkManager::NetworkManagerPrivate::globalDnsConfiguration() const
0689 {
0690     return m_globalDnsConfiguration;
0691 }
0692
0693 void NetworkManager::NetworkManagerPrivate::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration)
0694 {
0695     m_globalDnsConfiguration = configuration;
0696     iface.setGlobalDnsConfiguration(m_globalDnsConfiguration.toMap());
0697 }
0698
0699 void NetworkManager::NetworkManagerPrivate::onDeviceAdded(const QDBusObjectPath &objpath)
0700 {
0701     // qCDebug(NMQT);
0702     if (!networkInterfaceMap.contains(objpath.path())) {
0703         networkInterfaceMap.insert(objpath.path(), Device::Ptr());
0704         Q_EMIT deviceAdded(objpath.path());
0705     }
0706 }
0707
0708 void NetworkManager::NetworkManagerPrivate::onDeviceRemoved(const QDBusObjectPath &objpath)
0709 {
0710     // qCDebug(NMQT);
0711     networkInterfaceMap.remove(objpath.path());
0712     Q_EMIT deviceRemoved(objpath.path());
0713 }
0714
0715 void NetworkManager::NetworkManagerPrivate::connectivityChanged(uint connectivity)
0716 {
0717     NetworkManager::Connectivity newConnectivity = convertConnectivity(connectivity);
0718     if (m_connectivity != newConnectivity) {
0719         m_connectivity = newConnectivity;
0720         Q_EMIT Notifier::connectivityChanged(newConnectivity);
0721     }
0722 }
0723
0724 void NetworkManager::NetworkManagerPrivate::stateChanged(uint state)
0725 {
0726     NetworkManager::Status newStatus = convertNMState(state);
0727     if (nmState != newStatus) {
0728         nmState = newStatus;
0729         Q_EMIT Notifier::statusChanged(newStatus);
0730     }
0731 }
0732
0733 void NetworkManager::NetworkManagerPrivate::dbusPropertiesChanged(const QString &interfaceName,
0734                                                                   const QVariantMap &properties,
0735                                                                   const QStringList &invalidatedProperties)
0736 {
0737     Q_UNUSED(invalidatedProperties);
0738     if (interfaceName == QLatin1String("org.freedesktop.NetworkManager")) {
0739         propertiesChanged(properties);
0740     }
0741 }
0742
0743 void NetworkManager::NetworkManagerPrivate::propertiesChanged(const QVariantMap &changedProperties)
0744 {
0745     // qCDebug(NMQT) << Q_FUNC_INFO << changedProperties;
0746
0747     QVariantMap::const_iterator it = changedProperties.constBegin();
0748     while (it != changedProperties.constEnd()) {
0749         const QString property = it.key();
0750         if (property == QLatin1String("ActiveConnections")) {
0751             const QList<QDBusObjectPath> activePaths = qdbus_cast<QList<QDBusObjectPath>>(*it);
0752             if (activePaths.isEmpty()) {
0753                 QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin();
0754                 while (it != m_activeConnections.constEnd()) {
0755                     Q_EMIT activeConnectionRemoved(it.key());
0756                     ++it;
0757                 }
0758                 m_activeConnections.clear();
0759             } else {
0760                 QStringList knownConnections = m_activeConnections.keys();
0761                 for (const QDBusObjectPath &ac : activePaths) {
0762                     if (!m_activeConnections.contains(ac.path())) {
0763                         m_activeConnections.insert(ac.path(), NetworkManager::ActiveConnection::Ptr());
0764                         Q_EMIT activeConnectionAdded(ac.path());
0765                     } else {
0766                         knownConnections.removeOne(ac.path());
0767                     }
0768                     // qCDebug(NMQT) << "  " << ac.path();
0769                 }
0770                 for (const QString &path : std::as_const(knownConnections)) {
0771                     m_activeConnections.remove(path);
0772                     Q_EMIT activeConnectionRemoved(path);
0773                 }
0774             }
0775             Q_EMIT activeConnectionsChanged();
0776         } else if (property == QLatin1String("NetworkingEnabled")) {
0777             m_isNetworkingEnabled = it->toBool();
0778             qCDebug(NMQT) << property << m_isNetworkingEnabled;
0779             Q_EMIT networkingEnabledChanged(m_isNetworkingEnabled);
0780         } else if (property == QLatin1String("WirelessHardwareEnabled")) {
0781             m_isWirelessHardwareEnabled = it->toBool();
0782             qCDebug(NMQT) << property << m_isWirelessHardwareEnabled;
0783             Q_EMIT wirelessHardwareEnabledChanged(m_isWirelessHardwareEnabled);
0784         } else if (property == QLatin1String("WirelessEnabled")) {
0785             m_isWirelessEnabled = it->toBool();
0786             qCDebug(NMQT) << property << m_isWirelessEnabled;
0787             Q_EMIT wirelessEnabledChanged(m_isWirelessEnabled);
0788         } else if (property == QLatin1String("WwanHardwareEnabled")) {
0789             m_isWwanHardwareEnabled = it->toBool();
0790             qCDebug(NMQT) << property << m_isWwanHardwareEnabled;
0791             Q_EMIT wwanHardwareEnabledChanged(m_isWwanHardwareEnabled);
0792         } else if (property == QLatin1String("WwanEnabled")) {
0793             m_isWwanEnabled = it->toBool();
0794             qCDebug(NMQT) << property << m_isWwanEnabled;
0795             Q_EMIT wwanEnabledChanged(m_isWwanEnabled);
0796         } else if (property == QLatin1String("WimaxHardwareEnabled")) {
0797             m_isWimaxHardwareEnabled = it->toBool();
0798             qCDebug(NMQT) << property << m_isWimaxHardwareEnabled;
0799             Q_EMIT wimaxHardwareEnabledChanged(m_isWimaxHardwareEnabled);
0800         } else if (property == QLatin1String("WimaxEnabled")) {
0801             m_isWimaxEnabled = it->toBool();
0802             qCDebug(NMQT) << property << m_isWimaxEnabled;
0803             Q_EMIT wimaxEnabledChanged(m_isWimaxEnabled);
0804         } else if (property == QLatin1String("Version")) {
0805             m_version = it->toString();
0806             parseVersion(m_version);
0807         } else if (property == QLatin1String("State")) {
0808             stateChanged(it->toUInt());
0809         } else if (property == QLatin1String("Connectivity")) {
0810             connectivityChanged(it->toUInt());
0811         } else if (property == QLatin1String("PrimaryConnection")) {
0812             m_primaryConnection = it->value<QDBusObjectPath>().path();
0813             Q_EMIT primaryConnectionChanged(m_primaryConnection);
0814         } else if (property == QLatin1String("ActivatingConnection")) {
0815             m_activatingConnection = it->value<QDBusObjectPath>().path();
0816             Q_EMIT activatingConnectionChanged(m_activatingConnection);
0817         } else if (property == QLatin1String("PrimaryConnectionType")) {
0818             m_primaryConnectionType = NetworkManager::ConnectionSettings::typeFromString(it->toString());
0819             Q_EMIT primaryConnectionTypeChanged(m_primaryConnectionType);
0820         } else if (property == QLatin1String("Startup")) {
0821             Q_EMIT isStartingUpChanged();
0822         } else if (property == QLatin1String("Metered")) {
0823             m_metered = (NetworkManager::Device::MeteredStatus)it->toUInt();
0824             Q_EMIT meteredChanged(m_metered);
0825         } else if (property == QLatin1String("GlobalDnsConfiguration")) {
0826             m_globalDnsConfiguration.fromMap(qdbus_cast<QVariantMap>(*it));
0827             Q_EMIT globalDnsConfigurationChanged(m_globalDnsConfiguration);
0828         } else {
0829             qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property;
0830         }
0831         ++it;
0832     }
0833 }
0834
0835 NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::convertConnectivity(uint connectivity)
0836 {
0837     NetworkManager::Connectivity convertedConnectivity = NetworkManager::UnknownConnectivity;
0838     switch (connectivity) {
0839     case NM_CONNECTIVITY_UNKNOWN:
0840         convertedConnectivity = NetworkManager::UnknownConnectivity;
0841         break;
0842     case NM_CONNECTIVITY_NONE:
0843         convertedConnectivity = NetworkManager::NoConnectivity;
0844         break;
0845     case NM_CONNECTIVITY_PORTAL:
0846         convertedConnectivity = NetworkManager::Portal;
0847         break;
0848     case NM_CONNECTIVITY_LIMITED:
0849         convertedConnectivity = NetworkManager::Limited;
0850         break;
0851     case NM_CONNECTIVITY_FULL:
0852         convertedConnectivity = NetworkManager::Full;
0853         break;
0854     }
0855     return convertedConnectivity;
0856 }
0857
0858 NetworkManager::Status NetworkManager::NetworkManagerPrivate::convertNMState(uint state)
0859 {
0860     NetworkManager::Status status = NetworkManager::Unknown;
0861     switch (state) {
0862     case NM_STATE_UNKNOWN:
0863         status = NetworkManager::Unknown;
0864         break;
0865     case NM_STATE_ASLEEP:
0866         status = NetworkManager::Asleep;
0867         break;
0868     case NM_STATE_DISCONNECTED:
0869         status = NetworkManager::Disconnected;
0870         break;
0871     case NM_STATE_DISCONNECTING:
0872         status = NetworkManager::Disconnecting;
0873         break;
0874     case NM_STATE_CONNECTING:
0875         status = NetworkManager::Connecting;
0876         break;
0877     case NM_STATE_CONNECTED_LOCAL:
0878         status = NetworkManager::ConnectedLinkLocal;
0879         break;
0880     case NM_STATE_CONNECTED_SITE:
0881         status = NetworkManager::ConnectedSiteOnly;
0882         break;
0883     case NM_STATE_CONNECTED_GLOBAL:
0884         status = NetworkManager::Connected;
0885         break;
0886     }
0887     return status;
0888 }
0889
0890 void NetworkManager::NetworkManagerPrivate::dbusInterfacesAdded(const QDBusObjectPath &path, const QVariantMap &addedInterfaces)
0891 {
0892     Q_UNUSED(path);
0893
0894     if (!addedInterfaces.contains(NetworkManagerPrivate::DBUS_DAEMON_INTERFACE)) {
0895         return;
0896     }
0897
0898     init();
0899     Q_EMIT serviceAppeared();
0900 }
0901
0902 void NetworkManager::NetworkManagerPrivate::daemonUnregistered()
0903 {
0904     stateChanged(NM_STATE_UNKNOWN);
0905     QMap<QString, Device::Ptr>::const_iterator i = networkInterfaceMap.constBegin();
0906     while (i != networkInterfaceMap.constEnd()) {
0907         Q_EMIT deviceRemoved(i.key());
0908         ++i;
0909     }
0910     networkInterfaceMap.clear();
0911
0912     QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin();
0913     while (it != m_activeConnections.constEnd()) {
0914         Q_EMIT activeConnectionRemoved(it.key());
0915         ++it;
0916     }
0917     m_activeConnections.clear();
0918
0919     qobject_cast<SettingsPrivate *>(settingsNotifier())->daemonUnregistered();
0920
0921     Q_EMIT activeConnectionsChanged();
0922     Q_EMIT serviceDisappeared();
0923 }
0924
0925 NetworkManager::ActiveConnection::List NetworkManager::NetworkManagerPrivate::activeConnections()
0926 {
0927     NetworkManager::ActiveConnection::List list;
0928
0929     // Take a copy because findRegisteredActiveConnection() may change m_activeConnections.
0930     const QStringList keyList = m_activeConnections.keys();
0931     for (const QString &key : keyList) {
0932         NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(key);
0933
0934         if (activeConnection) {
0935             list << activeConnection;
0936         }
0937     }
0938     return list;
0939 }
0940
0941 QStringList NetworkManager::NetworkManagerPrivate::activeConnectionsPaths() const
0942 {
0943     return m_activeConnections.keys();
0944 }
0945
0946 QDBusPendingReply<QString, QString> NetworkManager::NetworkManagerPrivate::getLogging()
0947 {
0948     return iface.GetLogging();
0949 }
0950
0951 QString NetworkManager::version()
0952 {
0953     return globalNetworkManager->version();
0954 }
0955
0956 int NetworkManager::compareVersion(const QString &version)
0957 {
0958     return globalNetworkManager->compareVersion(version);
0959 }
0960
0961 int NetworkManager::compareVersion(const int x, const int y, const int z)
0962 {
0963     return globalNetworkManager->compareVersion(x, y, z);
0964 }
0965
0966 bool NetworkManager::checkVersion(const int x, const int y, const int z)
0967 {
0968     return globalNetworkManager->checkVersion(x, y, z);
0969 }
0970
0971 NetworkManager::Status NetworkManager::status()
0972 {
0973     return globalNetworkManager->status();
0974 }
0975
0976 NetworkManager::ActiveConnection::List NetworkManager::activeConnections()
0977 {
0978     return globalNetworkManager->activeConnections();
0979 }
0980
0981 QStringList NetworkManager::activeConnectionsPaths()
0982 {
0983     return globalNetworkManager->activeConnectionsPaths();
0984 }
0985
0986 NetworkManager::ActiveConnection::Ptr NetworkManager::findActiveConnection(const QString &uni)
0987 {
0988     return globalNetworkManager->findRegisteredActiveConnection(uni);
0989 }
0990
0991 NetworkManager::Device::List NetworkManager::networkInterfaces()
0992 {
0993     return globalNetworkManager->networkInterfaces();
0994 }
0995
0996 bool NetworkManager::isNetworkingEnabled()
0997 {
0998     return globalNetworkManager->isNetworkingEnabled();
0999 }
1000
1001 bool NetworkManager::isWirelessEnabled()
1002 {
1003     return globalNetworkManager->isWirelessEnabled();
1004 }
1005
1006 bool NetworkManager::isWirelessHardwareEnabled()
1007 {
1008     return globalNetworkManager->isWirelessHardwareEnabled();
1009 }
1010
1011 NetworkManager::Device::Ptr NetworkManager::findNetworkInterface(const QString &uni)
1012 {
1013     return globalNetworkManager->findRegisteredNetworkInterface(uni);
1014 }
1015
1016 NetworkManager::Device::Ptr NetworkManager::findDeviceByIpFace(const QString &iface)
1017 {
1018     return globalNetworkManager->findDeviceByIpIface(iface);
1019 }
1020
1021 QDBusPendingReply<QDBusObjectPath, QDBusObjectPath>
1022 NetworkManager::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter)
1023 {
1024     return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter);
1025 }
1026
1027 QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap> NetworkManager::addAndActivateConnection2(const NMVariantMapMap &connection,
1028                                                                                                            const QString &interfaceUni,
1029                                                                                                            const QString &connectionParameter,
1030                                                                                                            const QVariantMap &options)
1031 {
1032     if (checkVersion(1, 16, 0)) {
1033         return globalNetworkManager->addAndActivateConnection2(connection, interfaceUni, connectionParameter, options);
1034     } else {
1035         return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter);
1036     }
1037 }
1038
1039 QDBusPendingReply<QDBusObjectPath>
1040 NetworkManager::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter)
1041 {
1042     return globalNetworkManager->activateConnection(connectionUni, interfaceUni, connectionParameter);
1043 }
1044
1045 QDBusPendingReply<> NetworkManager::deactivateConnection(const QString &activeConnectionPath)
1046 {
1047     return globalNetworkManager->deactivateConnection(activeConnectionPath);
1048 }
1049
1050 QDBusPendingReply<QString, QString> NetworkManager::getLogging()
1051 {
1052     return globalNetworkManager->getLogging();
1053 }
1054
1055 void NetworkManager::setNetworkingEnabled(bool enabled)
1056 {
1057     globalNetworkManager->setNetworkingEnabled(enabled);
1058 }
1059
1060 void NetworkManager::setWirelessEnabled(bool enabled)
1061 {
1062     globalNetworkManager->setWirelessEnabled(enabled);
1063 }
1064
1065 bool NetworkManager::isWwanEnabled()
1066 {
1067     return globalNetworkManager->isWwanEnabled();
1068 }
1069
1070 bool NetworkManager::isWwanHardwareEnabled()
1071 {
1072     return globalNetworkManager->isWwanHardwareEnabled();
1073 }
1074
1075 void NetworkManager::setWwanEnabled(bool enabled)
1076 {
1077     globalNetworkManager->setWwanEnabled(enabled);
1078 }
1079
1080 bool NetworkManager::isWimaxEnabled()
1081 {
1082     return globalNetworkManager->isWimaxEnabled();
1083 }
1084
1085 bool NetworkManager::isWimaxHardwareEnabled()
1086 {
1087     return globalNetworkManager->isWimaxHardwareEnabled();
1088 }
1089
1090 void NetworkManager::setWimaxEnabled(bool enabled)
1091 {
1092     globalNetworkManager->setWimaxEnabled(enabled);
1093 }
1094
1095 void NetworkManager::sleep(bool sleep)
1096 {
1097     globalNetworkManager->sleep(sleep);
1098 }
1099
1100 void NetworkManager::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains)
1101 {
1102     globalNetworkManager->setLogging(level, domains);
1103 }
1104
1105 NMStringMap NetworkManager::permissions()
1106 {
1107     return globalNetworkManager->permissions();
1108 }
1109
1110 NetworkManager::Device::Types NetworkManager::supportedInterfaceTypes()
1111 {
1112     return globalNetworkManager->supportedInterfaceTypes();
1113 }
1114
1115 NetworkManager::Connectivity NetworkManager::connectivity()
1116 {
1117     return globalNetworkManager->connectivity();
1118 }
1119
1120 QDBusPendingReply<uint> NetworkManager::checkConnectivity()
1121 {
1122     return globalNetworkManager->checkConnectivity();
1123 }
1124
1125 NetworkManager::ActiveConnection::Ptr NetworkManager::primaryConnection()
1126 {
1127     return globalNetworkManager->primaryConnection();
1128 }
1129
1130 NetworkManager::ActiveConnection::Ptr NetworkManager::activatingConnection()
1131 {
1132     return globalNetworkManager->activatingConnection();
1133 }
1134
1135 NetworkManager::ConnectionSettings::ConnectionType NetworkManager::primaryConnectionType()
1136 {
1137     return globalNetworkManager->primaryConnectionType();
1138 }
1139
1140 bool NetworkManager::isStartingUp()
1141 {
1142     return globalNetworkManager->isStartingUp();
1143 }
1144
1145 NetworkManager::Device::MeteredStatus NetworkManager::metered()
1146 {
1147     return globalNetworkManager->metered();
1148 }
1149
1150 NetworkManager::DnsConfiguration NetworkManager::globalDnsConfiguration()
1151 {
1152     return globalNetworkManager->globalDnsConfiguration();
1153 }
1154
1155 void NetworkManager::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration)
1156 {
1157     globalNetworkManager->setGlobalDnsConfiguration(configuration);
1158 }
1159
1160 NetworkManager::Notifier *NetworkManager::notifier()
1161 {
1162     return globalNetworkManager;
1163 }