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