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