diff --git a/src/manager.cpp b/src/manager.cpp index ff60d40..b3f8613 100644 --- a/src/manager.cpp +++ b/src/manager.cpp @@ -1,1147 +1,1147 @@ /* Copyright 2008,2010 Will Stephenson Copyright 2011-2013 Lamarque Souza Copyright 2013 Daniel Nicoletti Copyright 2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "manager.h" #include "manager_p.h" #include "macros.h" #undef signals #include #define signals Q_SIGNALS #include "activeconnection.h" #include "adsldevice.h" #include "bluetoothdevice.h" #include "bonddevice.h" #include "bridgedevice.h" #include "infinibanddevice.h" #include "iptunneldevice.h" #include "genericdevice.h" #include "modemdevice.h" #include "olpcmeshdevice.h" #include "settings.h" #include "settings_p.h" #include "vpnconnection.h" #include "vlandevice.h" #include "wireddevice.h" #include "wirelessdevice.h" #include "wimaxdevice.h" #include "gredevice.h" #include "macvlandevice.h" #include "tundevice.h" #include "vethdevice.h" #include "wireguarddevice.h" #include "nmdebug.h" #define DBUS_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager" #define DBUS_PROPERTIES "org.freedesktop.DBus.Properties" #ifdef NMQT_STATIC const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1("org.kde.fakenetwork")); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1("/org/kde/fakenetwork")); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1("org.kde.fakenetwork")); const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1("/org/kde/fakenetwork/Settings")); #else const QString NetworkManager::NetworkManagerPrivate::DBUS_SERVICE(QString::fromLatin1(NM_DBUS_SERVICE)); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH(QString::fromLatin1(NM_DBUS_PATH)); const QString NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_INTERFACE(QString::fromLatin1(NM_DBUS_INTERFACE)); const QString NetworkManager::NetworkManagerPrivate::DBUS_SETTINGS_PATH(QString::fromLatin1(NM_DBUS_PATH_SETTINGS)); #endif const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES(QString::fromLatin1(DBUS_PROPERTIES)); const QString NetworkManager::NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER(QString::fromLatin1(DBUS_OBJECT_MANAGER)); Q_GLOBAL_STATIC(NetworkManager::NetworkManagerPrivate, globalNetworkManager) NetworkManager::NetworkManagerPrivate::NetworkManagerPrivate() #ifdef NMQT_STATIC : watcher(DBUS_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForUnregistration, this) , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::sessionBus()) #else : watcher(DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForUnregistration, this) , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::systemBus()) #endif , nmState(NetworkManager::Unknown) , m_connectivity(NetworkManager::UnknownConnectivity) , m_isNetworkingEnabled(false) , m_isWimaxEnabled(false) , m_isWimaxHardwareEnabled(false) , m_isWirelessEnabled(false) , m_isWirelessHardwareEnabled(false) , m_isWwanEnabled(false) , m_isWwanHardwareEnabled(false) , m_globalDnsConfiguration(NetworkManager::DnsConfiguration()) , m_supportedInterfaceTypes(NetworkManager::Device::UnknownType) { connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceAdded, this, &NetworkManagerPrivate::onDeviceAdded); connect(&iface, &OrgFreedesktopNetworkManagerInterface::DeviceRemoved, this, &NetworkManagerPrivate::onDeviceRemoved); #ifndef NMQT_STATIC QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, NetworkManagerPrivate::DBUS_DAEMON_PATH, NetworkManagerPrivate::FDO_DBUS_PROPERTIES, QLatin1String("PropertiesChanged"), this, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList))); #else connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged); #endif iface.connection().connect(NetworkManagerPrivate::DBUS_SERVICE, "/org/freedesktop", NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER, QLatin1String("InterfacesAdded"), this, SLOT(dbusInterfacesAdded(QDBusObjectPath,QVariantMap))); connect(&watcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManagerPrivate::daemonUnregistered); init(); } void NetworkManager::NetworkManagerPrivate::parseVersion(const QString &version) { const QStringList sl = version.split('.'); if (sl.size() > 2) { m_x = sl[0].toInt(); m_y = sl[1].toInt(); m_z = sl[2].toInt(); } else { m_x = -1; m_y = -1; m_z = -1; } } void NetworkManager::NetworkManagerPrivate::init() { qDBusRegisterMetaType(); qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); // qDBusRegisterMetaType(); qDBusRegisterMetaType >(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); m_version = iface.version(); parseVersion(m_version); m_supportedInterfaceTypes = static_cast( NetworkManager::Device::Ethernet | NetworkManager::Device::Wifi | NetworkManager::Device::Modem | (checkVersion(1, 2, 0) ? 0 : NetworkManager::Device::Wimax) | NetworkManager::Device::Bluetooth | NetworkManager::Device::OlpcMesh | NetworkManager::Device::InfiniBand | NetworkManager::Device::Bond | NetworkManager::Device::Vlan | NetworkManager::Device::Adsl | NetworkManager::Device::Bridge | NetworkManager::Device::Generic | NetworkManager::Device::Team | NetworkManager::Device::MacVlan | NetworkManager::Device::Tun | NetworkManager::Device::Veth | NetworkManager::Device::IpTunnel | NetworkManager::Device::WireGuard ); // Get all Manager's properties async QVariantMap initialProperties = retrieveInitialProperties(iface.staticInterfaceName(), DBUS_DAEMON_PATH); if (!initialProperties.isEmpty()) { propertiesChanged(initialProperties); } QTimer::singleShot(0, [] { qobject_cast(settingsNotifier())->init(); }); if (iface.isValid()) { QList devices = iface.devices(); qCDebug(NMQT) << "Device list"; Q_FOREACH (const QDBusObjectPath & op, devices) { networkInterfaceMap.insert(op.path(), Device::Ptr()); Q_EMIT deviceAdded(op.path()); qCDebug(NMQT) << " " << op.path(); } } } NetworkManager::NetworkManagerPrivate::~NetworkManagerPrivate() { } QString NetworkManager::NetworkManagerPrivate::version() const { return m_version; } int NetworkManager::NetworkManagerPrivate::compareVersion(const QString &version) { int x, y, z; const auto sl = version.splitRef('.'); if (sl.size() > 2) { x = sl[0].toInt(); y = sl[1].toInt(); z = sl[2].toInt(); } else { x = -1; y = -1; z = -1; } return compareVersion(x, y, z); } int NetworkManager::NetworkManagerPrivate::compareVersion(const int x, const int y, const int z) const { if (m_x > x) { return 1; } else if (m_x < x) { return -1; } else if (m_y > y) { return 1; } else if (m_y < y) { return -1; } else if (m_z > z) { return 1; } else if (m_z < z) { return -1; } return 0; } bool NetworkManager::NetworkManagerPrivate::checkVersion(const int x, const int y, const int z) const { return 0 <= compareVersion(x, y, z); } NetworkManager::Device::Types NetworkManager::NetworkManagerPrivate::supportedInterfaceTypes() const { return m_supportedInterfaceTypes; } QVariantMap NetworkManager::NetworkManagerPrivate::retrieveInitialProperties(const QString &interfaceName, const QString &path) { QDBusMessage message = QDBusMessage::createMethodCall(DBUS_SERVICE, path, FDO_DBUS_PROPERTIES, QLatin1String("GetAll")); message << interfaceName; #ifdef NMQT_STATIC QDBusMessage resultMessage = QDBusConnection::sessionBus().call(message); #else QDBusMessage resultMessage = QDBusConnection::systemBus().call(message); #endif if (resultMessage.type() == QDBusMessage::ReplyMessage) { QVariantMap result; QDBusArgument dbusArgument = resultMessage.arguments().at(0).value(); while (!dbusArgument.atEnd()) { dbusArgument >> result; } return result; } return QVariantMap(); } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni) { NetworkManager::Device::Ptr networkInterface; auto it = networkInterfaceMap.constFind(uni); if (it != networkInterfaceMap.constEnd()) { if (*it) { networkInterface = *it; } else { networkInterface = createNetworkInterface(uni); networkInterfaceMap[uni] = networkInterface; } } return networkInterface; } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredActiveConnection(const QString &uni) { NetworkManager::ActiveConnection::Ptr activeConnection; if (!uni.isEmpty() && uni != QLatin1String("/")) { const auto it = m_activeConnections.constFind(uni); const bool contains = it != m_activeConnections.constEnd(); if (contains && *it) { activeConnection = *it; } else { activeConnection = NetworkManager::ActiveConnection::Ptr(new NetworkManager::VpnConnection(uni), &QObject::deleteLater); if (activeConnection->connection()) { m_activeConnections[uni] = activeConnection; if (!contains) { Q_EMIT activeConnectionAdded(uni); } } else { activeConnection.clear(); } } } return activeConnection; } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::createNetworkInterface(const QString &uni) { //qCDebug(NMQT); Device::Ptr createdInterface; Device::Ptr device(new Device(uni)); switch (device->type()) { case Device::Ethernet: createdInterface = Device::Ptr(new NetworkManager::WiredDevice(uni), &QObject::deleteLater); break; case Device::Wifi: createdInterface = Device::Ptr(new NetworkManager::WirelessDevice(uni), &QObject::deleteLater); break; case Device::Modem: createdInterface = Device::Ptr(new NetworkManager::ModemDevice(uni), &QObject::deleteLater); break; case Device::Bluetooth: createdInterface = Device::Ptr(new NetworkManager::BluetoothDevice(uni), &QObject::deleteLater); break; case Device::Wimax: createdInterface = Device::Ptr(new NetworkManager::WimaxDevice(uni), &QObject::deleteLater); break; case Device::OlpcMesh: createdInterface = Device::Ptr(new NetworkManager::OlpcMeshDevice(uni), &QObject::deleteLater); break; case Device::InfiniBand: createdInterface = Device::Ptr(new NetworkManager::InfinibandDevice(uni), &QObject::deleteLater); break; case Device::Bond: createdInterface = Device::Ptr(new NetworkManager::BondDevice(uni), &QObject::deleteLater); break; case Device::Vlan: createdInterface = Device::Ptr(new NetworkManager::VlanDevice(uni), &QObject::deleteLater); break; case Device::Adsl: createdInterface = Device::Ptr(new NetworkManager::AdslDevice(uni), &QObject::deleteLater); break; case Device::Bridge: createdInterface = Device::Ptr(new NetworkManager::BridgeDevice(uni), &QObject::deleteLater); break; //No need to check checkVersion, because we can't get Generic, Gre, MacVlan, Tun & Veth values in incompatible runtime case Device::Generic: createdInterface = Device::Ptr(new NetworkManager::GenericDevice(uni), &QObject::deleteLater); break; case Device::Gre: createdInterface = Device::Ptr(new NetworkManager::GreDevice(uni), &QObject::deleteLater); break; case Device::MacVlan: createdInterface = Device::Ptr(new NetworkManager::MacVlanDevice(uni), &QObject::deleteLater); break; case Device::Tun: createdInterface = Device::Ptr(new NetworkManager::TunDevice(uni), &QObject::deleteLater); break; case Device::Veth: createdInterface = Device::Ptr(new NetworkManager::VethDevice(uni), &QObject::deleteLater); break; case Device::IpTunnel: createdInterface = Device::Ptr(new NetworkManager::IpTunnelDevice(uni), &QObject::deleteLater); break; case Device::WireGuard: createdInterface = Device::Ptr(new NetworkManager::WireGuardDevice(uni), &QObject::deleteLater); break; default: createdInterface = device; if (uni != QLatin1String("any")) { // VPN connections use "any" as uni for the network interface. qCDebug(NMQT) << "Can't create device of type " << device->type() << "for" << uni; } break; } return createdInterface; } NetworkManager::Status NetworkManager::NetworkManagerPrivate::status() const { return nmState; } NetworkManager::Device::List NetworkManager::NetworkManagerPrivate::networkInterfaces() { Device::List list; QMap::const_iterator i; for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key()); if (!networkInterface.isNull()) { list.append(networkInterface); } else { qCWarning(NMQT) << "warning: null network Interface for" << i.key(); } } return list; } NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findDeviceByIpIface(const QString &iface) { QMap::const_iterator i; for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { Device::Ptr networkInterface = findRegisteredNetworkInterface(i.key()); if (networkInterface && networkInterface->udi() == iface) { return networkInterface; } } return Device::Ptr(); } bool NetworkManager::NetworkManagerPrivate::isNetworkingEnabled() const { return m_isNetworkingEnabled; } bool NetworkManager::NetworkManagerPrivate::isWirelessEnabled() const { return m_isWirelessEnabled; } bool NetworkManager::NetworkManagerPrivate::isWirelessHardwareEnabled() const { return m_isWirelessHardwareEnabled; } bool NetworkManager::NetworkManagerPrivate::isWwanEnabled() const { return m_isWwanEnabled; } bool NetworkManager::NetworkManagerPrivate::isWwanHardwareEnabled() const { return m_isWwanHardwareEnabled; } bool NetworkManager::NetworkManagerPrivate::isWimaxEnabled() const { return checkVersion(1, 2, 0) ? false : m_isWimaxEnabled; } bool NetworkManager::NetworkManagerPrivate::isWimaxHardwareEnabled() const { return checkVersion(1, 2, 0) ? false : m_isWimaxHardwareEnabled; } QDBusPendingReply NetworkManager::NetworkManagerPrivate::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) { QString extra_connection_parameter = connectionParameter; QString extra_interface_parameter = interfaceUni; if (extra_connection_parameter.isEmpty()) { extra_connection_parameter = QLatin1String("/"); } if (extra_interface_parameter.isEmpty()) { extra_interface_parameter = QLatin1String("/"); } // TODO store error code QDBusObjectPath connPath(connectionUni); QDBusObjectPath interfacePath(interfaceUni); // qCDebug(NMQT) << "Activating connection" << connPath.path() << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter; return iface.ActivateConnection(connPath, QDBusObjectPath(extra_interface_parameter), QDBusObjectPath(extra_connection_parameter)); } QDBusPendingReply NetworkManager::NetworkManagerPrivate::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter) { QString extra_connection_parameter = connectionParameter; if (extra_connection_parameter.isEmpty()) { extra_connection_parameter = QLatin1String("/"); } // TODO store error code QDBusObjectPath interfacePath(interfaceUni); return iface.AddAndActivateConnection(connection, interfacePath, QDBusObjectPath(extra_connection_parameter)); } QDBusPendingReply<> NetworkManager::NetworkManagerPrivate::deactivateConnection(const QString &activeConnectionPath) { return iface.DeactivateConnection(QDBusObjectPath(activeConnectionPath)); } void NetworkManager::NetworkManagerPrivate::setNetworkingEnabled(bool enabled) { iface.Enable(enabled); } void NetworkManager::NetworkManagerPrivate::setWirelessEnabled(bool enabled) { iface.setWirelessEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::setWwanEnabled(bool enabled) { iface.setWwanEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::setWimaxEnabled(bool enabled) { if (!checkVersion(1, 2, 0)) iface.setWimaxEnabled(enabled); } void NetworkManager::NetworkManagerPrivate::sleep(bool sleep) { iface.Sleep(sleep); } void NetworkManager::NetworkManagerPrivate::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) { QString logLevel; QStringList logDomains; switch (level) { case NetworkManager::Error: logLevel = QLatin1String("ERR"); break; case NetworkManager::Warning: logLevel = QLatin1String("WARN"); break; case NetworkManager::Info: logLevel = QLatin1String("INFO"); break; case NetworkManager::Debug: logLevel = QLatin1String("DEBUG"); break; case NetworkManager::Trace: logLevel = QLatin1String("TRACE"); break; } if (!domains.testFlag(NoChange)) { if (domains.testFlag(NetworkManager::None)) { logDomains << QLatin1String("NONE"); } if (domains.testFlag(NetworkManager::Hardware)) { logDomains << QLatin1String("PLATFORM"); } if (domains.testFlag(NetworkManager::RFKill)) { logDomains << QLatin1String("RFKILL"); } if (domains.testFlag(NetworkManager::Ethernet)) { logDomains << QLatin1String("ETHER"); } if (domains.testFlag(NetworkManager::WiFi)) { logDomains << QLatin1String("WIFI"); } if (domains.testFlag(NetworkManager::Bluetooth)) { logDomains << QLatin1String("BT"); } if (domains.testFlag(NetworkManager::MobileBroadBand)) { logDomains << QLatin1String("MB"); } if (domains.testFlag(NetworkManager::DHCP4)) { logDomains << QLatin1String("DHCP4"); } if (domains.testFlag(NetworkManager::DHCP6)) { logDomains << QLatin1String("DHCP6"); } if (domains.testFlag(NetworkManager::PPP)) { logDomains << QLatin1String("PPP"); } if (domains.testFlag(NetworkManager::WiFiScan)) { logDomains << QLatin1String("WIFI_SCAN"); } if (domains.testFlag(NetworkManager::IPv4)) { logDomains << QLatin1String("IP4"); } if (domains.testFlag(NetworkManager::IPv6)) { logDomains << QLatin1String("IP6"); } if (domains.testFlag(NetworkManager::AutoIPv4)) { logDomains << QLatin1String("AUTOIP4"); } if (domains.testFlag(NetworkManager::DNS)) { logDomains << QLatin1String("DNS"); } if (domains.testFlag(NetworkManager::VPN)) { logDomains << QLatin1String("VPN"); } if (domains.testFlag(NetworkManager::Sharing)) { logDomains << QLatin1String("SHARING"); } if (domains.testFlag(NetworkManager::Supplicant)) { logDomains << QLatin1String("SUPPLICANT"); } if (domains.testFlag(NetworkManager::UserSet)) { logDomains << QLatin1String("USER_SET"); } if (domains.testFlag(NetworkManager::SysSet)) { logDomains << QLatin1String("SYS_SET"); } if (domains.testFlag(NetworkManager::Suspend)) { logDomains << QLatin1String("SUSPEND"); } if (domains.testFlag(NetworkManager::Core)) { logDomains << QLatin1String("CORE"); } if (domains.testFlag(NetworkManager::Devices)) { logDomains << QLatin1String("DEVICE"); } if (domains.testFlag(NetworkManager::OLPC)) { logDomains << QLatin1String("OLPC"); } if (domains.testFlag(NetworkManager::Wimax)) { logDomains << QLatin1String("WIMAX"); } if (domains.testFlag(NetworkManager::Infiniband)) { logDomains << QLatin1String("INFINIBAND"); } if (domains.testFlag(NetworkManager::Firewall)) { logDomains << QLatin1String("FIREWALL"); } if (domains.testFlag(NetworkManager::Adsl)) { logDomains << QLatin1String("ADSL"); } if (domains.testFlag(NetworkManager::Bond)) { logDomains << QLatin1String("BOND"); } if (domains.testFlag(NetworkManager::Vlan)) { logDomains << QLatin1String("VLAN"); } if (domains.testFlag(NetworkManager::Agents)) { logDomains << QLatin1String("AGENTS"); } if (domains.testFlag(NetworkManager::Settings)) { logDomains << QLatin1String("SETTINGS"); } if (domains.testFlag(NetworkManager::DbusProps)) { logDomains << QLatin1String("DBUS_PROPS"); } if (domains.testFlag(NetworkManager::Team)) { logDomains << QLatin1String("TEAM"); } if (domains.testFlag(NetworkManager::ConCheck)) { logDomains << QLatin1String("CONCHECK"); } if (domains.testFlag(NetworkManager::Dcb)) { logDomains << QLatin1String("DCB"); } if (domains.testFlag(NetworkManager::Dispatch)) { logDomains << QLatin1String("DISPATCH"); } } - iface.SetLogging(logLevel, logDomains.join(QLatin1String(","))); + iface.SetLogging(logLevel, logDomains.join(QLatin1Char(','))); } NMStringMap NetworkManager::NetworkManagerPrivate::permissions() { return iface.GetPermissions(); } NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::connectivity() const { return m_connectivity; } QDBusPendingReply NetworkManager::NetworkManagerPrivate::checkConnectivity() { return iface.CheckConnectivity(); } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::primaryConnection() { return findRegisteredActiveConnection(m_primaryConnection); } NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::activatingConnection() { return findRegisteredActiveConnection(m_activatingConnection); } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::NetworkManagerPrivate::primaryConnectionType() { return checkVersion(1, 0, 0) ? m_primaryConnectionType : NetworkManager::ConnectionSettings::Unknown; } bool NetworkManager::NetworkManagerPrivate::isStartingUp() const { return iface.startup(); } NetworkManager::Device::MeteredStatus NetworkManager::NetworkManagerPrivate::metered() const { return checkVersion(1, 0, 6) ? m_metered : NetworkManager::Device::UnknownStatus; } NetworkManager::DnsConfiguration NetworkManager::NetworkManagerPrivate::globalDnsConfiguration() const { return m_globalDnsConfiguration; } void NetworkManager::NetworkManagerPrivate::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration) { m_globalDnsConfiguration = configuration; iface.setGlobalDnsConfiguration(m_globalDnsConfiguration.toMap()); } void NetworkManager::NetworkManagerPrivate::onDeviceAdded(const QDBusObjectPath &objpath) { // qCDebug(NMQT); if (!networkInterfaceMap.contains(objpath.path())) { networkInterfaceMap.insert(objpath.path(), Device::Ptr()); Q_EMIT deviceAdded(objpath.path()); } } void NetworkManager::NetworkManagerPrivate::onDeviceRemoved(const QDBusObjectPath &objpath) { // qCDebug(NMQT); networkInterfaceMap.remove(objpath.path()); Q_EMIT deviceRemoved(objpath.path()); } void NetworkManager::NetworkManagerPrivate::connectivityChanged(uint connectivity) { NetworkManager::Connectivity newConnectivity = convertConnectivity(connectivity); if (m_connectivity != newConnectivity) { m_connectivity = newConnectivity; Q_EMIT Notifier::connectivityChanged(newConnectivity); } } void NetworkManager::NetworkManagerPrivate::stateChanged(uint state) { NetworkManager::Status newStatus = convertNMState(state); if (nmState != newStatus) { nmState = newStatus; Q_EMIT Notifier::statusChanged(newStatus); } } void NetworkManager::NetworkManagerPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties) { Q_UNUSED(invalidatedProperties); if (interfaceName == QLatin1String("org.freedesktop.NetworkManager")) { propertiesChanged(properties); } } void NetworkManager::NetworkManagerPrivate::propertiesChanged(const QVariantMap &changedProperties) { // qCDebug(NMQT) << Q_FUNC_INFO << changedProperties; QVariantMap::const_iterator it = changedProperties.constBegin(); while (it != changedProperties.constEnd()) { const QString property = it.key(); if (property == QLatin1String("ActiveConnections")) { QList activePaths = qdbus_cast< QList >(*it); if (activePaths.isEmpty()) { QMap::const_iterator it = m_activeConnections.constBegin(); while (it != m_activeConnections.constEnd()) { Q_EMIT activeConnectionRemoved(it.key()); ++it; } m_activeConnections.clear(); } else { QStringList knownConnections = m_activeConnections.keys(); Q_FOREACH (const QDBusObjectPath & ac, activePaths) { if (!m_activeConnections.contains(ac.path())) { m_activeConnections.insert(ac.path(), NetworkManager::ActiveConnection::Ptr()); Q_EMIT activeConnectionAdded(ac.path()); } else { knownConnections.removeOne(ac.path()); } // qCDebug(NMQT) << " " << ac.path(); } Q_FOREACH (const QString & path, knownConnections) { m_activeConnections.remove(path); Q_EMIT activeConnectionRemoved(path); } } Q_EMIT activeConnectionsChanged(); } else if (property == QLatin1String("NetworkingEnabled")) { m_isNetworkingEnabled = it->toBool(); qCDebug(NMQT) << property << m_isNetworkingEnabled; Q_EMIT networkingEnabledChanged(m_isNetworkingEnabled); } else if (property == QLatin1String("WirelessHardwareEnabled")) { m_isWirelessHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWirelessHardwareEnabled; Q_EMIT wirelessHardwareEnabledChanged(m_isWirelessHardwareEnabled); } else if (property == QLatin1String("WirelessEnabled")) { m_isWirelessEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWirelessEnabled; Q_EMIT wirelessEnabledChanged(m_isWirelessEnabled); } else if (property == QLatin1String("WwanHardwareEnabled")) { m_isWwanHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWwanHardwareEnabled; Q_EMIT wwanHardwareEnabledChanged(m_isWwanHardwareEnabled); } else if (property == QLatin1String("WwanEnabled")) { m_isWwanEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWwanEnabled; Q_EMIT wwanEnabledChanged(m_isWwanEnabled); } else if (property == QLatin1String("WimaxHardwareEnabled")) { m_isWimaxHardwareEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWimaxHardwareEnabled; Q_EMIT wimaxHardwareEnabledChanged(m_isWimaxHardwareEnabled); } else if (property == QLatin1String("WimaxEnabled")) { m_isWimaxEnabled = it->toBool(); qCDebug(NMQT) << property << m_isWimaxEnabled; Q_EMIT wimaxEnabledChanged(m_isWimaxEnabled); } else if (property == QLatin1String("Version")) { m_version = it->toString(); parseVersion(m_version); } else if (property == QLatin1String("State")) { stateChanged(it->toUInt()); } else if (property == QLatin1String("Connectivity")) { connectivityChanged(it->toUInt()); } else if (property == QLatin1String("PrimaryConnection")) { m_primaryConnection = it->value().path(); Q_EMIT primaryConnectionChanged(m_primaryConnection); } else if (property == QLatin1String("ActivatingConnection")) { m_activatingConnection = it->value().path(); Q_EMIT activatingConnectionChanged(m_activatingConnection); } else if (property == QLatin1String("PrimaryConnectionType")) { m_primaryConnectionType = NetworkManager::ConnectionSettings::typeFromString(it->toString()); Q_EMIT primaryConnectionTypeChanged(m_primaryConnectionType); } else if (property == QLatin1String("Startup")) { Q_EMIT isStartingUpChanged(); } else if (property == QLatin1String("Metered")) { m_metered = (NetworkManager::Device::MeteredStatus)it->toUInt(); Q_EMIT meteredChanged(m_metered); } else if (property == QLatin1String("GlobalDnsConfiguration")) { m_globalDnsConfiguration.fromMap(qdbus_cast(*it)); Q_EMIT globalDnsConfigurationChanged(m_globalDnsConfiguration); } else { qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; } ++it; } } NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::convertConnectivity(uint connectivity) { NetworkManager::Connectivity convertedConnectivity = NetworkManager::UnknownConnectivity; switch (connectivity) { case NM_CONNECTIVITY_UNKNOWN: convertedConnectivity = NetworkManager::UnknownConnectivity; break; case NM_CONNECTIVITY_NONE: convertedConnectivity = NetworkManager::NoConnectivity; break; case NM_CONNECTIVITY_PORTAL: convertedConnectivity = NetworkManager::Portal; break; case NM_CONNECTIVITY_LIMITED: convertedConnectivity = NetworkManager::Limited; break; case NM_CONNECTIVITY_FULL: convertedConnectivity = NetworkManager::Full; break; } return convertedConnectivity; } NetworkManager::Status NetworkManager::NetworkManagerPrivate::convertNMState(uint state) { NetworkManager::Status status = NetworkManager::Unknown; switch (state) { case NM_STATE_UNKNOWN: status = NetworkManager::Unknown; break; case NM_STATE_ASLEEP: status = NetworkManager::Asleep; break; case NM_STATE_DISCONNECTED: status = NetworkManager::Disconnected; break; case NM_STATE_DISCONNECTING: status = NetworkManager::Disconnecting; break; case NM_STATE_CONNECTING: status = NetworkManager::Connecting; break; case NM_STATE_CONNECTED_LOCAL: status = NetworkManager::ConnectedLinkLocal; break; case NM_STATE_CONNECTED_SITE: status = NetworkManager::ConnectedSiteOnly; break; case NM_STATE_CONNECTED_GLOBAL: status = NetworkManager::Connected; break; } return status; } void NetworkManager::NetworkManagerPrivate::interfacesAdded(const QDBusObjectPath &path, const QVariantMap &addedInterfaces) { Q_UNUSED(path); if(!addedInterfaces.contains(NetworkManagerPrivate::DBUS_DAEMON_INTERFACE)) return; init(); Q_EMIT serviceAppeared(); } void NetworkManager::NetworkManagerPrivate::daemonUnregistered() { stateChanged(NM_STATE_UNKNOWN); QMap::const_iterator i = networkInterfaceMap.constBegin(); while (i != networkInterfaceMap.constEnd()) { Q_EMIT deviceRemoved(i.key()); ++i; } networkInterfaceMap.clear(); QMap::const_iterator it = m_activeConnections.constBegin(); while (it != m_activeConnections.constEnd()) { Q_EMIT activeConnectionRemoved(it.key()); ++it; } m_activeConnections.clear(); qobject_cast(settingsNotifier())->daemonUnregistered(); Q_EMIT activeConnectionsChanged(); Q_EMIT serviceDisappeared(); } NetworkManager::ActiveConnection::List NetworkManager::NetworkManagerPrivate::activeConnections() { NetworkManager::ActiveConnection::List list; // We do not use const_iterator here because // findRegisteredActiveConnection() changes m_activeConnections. foreach (const QString &key, m_activeConnections.keys()) { NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(key); if (activeConnection) { list << activeConnection; } } return list; } QStringList NetworkManager::NetworkManagerPrivate::activeConnectionsPaths() const { return m_activeConnections.keys(); } QDBusPendingReply< QString, QString > NetworkManager::NetworkManagerPrivate::getLogging() { return iface.GetLogging(); } QString NetworkManager::version() { return globalNetworkManager->version(); } int NetworkManager::compareVersion(const QString &version) { return globalNetworkManager->compareVersion(version); } int NetworkManager::compareVersion(const int x, const int y, const int z) { return globalNetworkManager->compareVersion(x, y, z); } bool NetworkManager::checkVersion(const int x, const int y, const int z) { return globalNetworkManager->checkVersion(x, y, z); } NetworkManager::Status NetworkManager::status() { return globalNetworkManager->status(); } NetworkManager::ActiveConnection::List NetworkManager::activeConnections() { return globalNetworkManager->activeConnections(); } QStringList NetworkManager::activeConnectionsPaths() { return globalNetworkManager->activeConnectionsPaths(); } NetworkManager::ActiveConnection::Ptr NetworkManager::findActiveConnection(const QString &uni) { return globalNetworkManager->findRegisteredActiveConnection(uni); } NetworkManager::Device::List NetworkManager::networkInterfaces() { return globalNetworkManager->networkInterfaces(); } bool NetworkManager::isNetworkingEnabled() { return globalNetworkManager->isNetworkingEnabled(); } bool NetworkManager::isWirelessEnabled() { return globalNetworkManager->isWirelessEnabled(); } bool NetworkManager::isWirelessHardwareEnabled() { return globalNetworkManager->isWirelessHardwareEnabled(); } NetworkManager::Device::Ptr NetworkManager::findNetworkInterface(const QString &uni) { return globalNetworkManager->findRegisteredNetworkInterface(uni); } NetworkManager::Device::Ptr NetworkManager::findDeviceByIpFace(const QString &iface) { return globalNetworkManager->findDeviceByIpIface(iface); } QDBusPendingReply NetworkManager::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter) { return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter); } QDBusPendingReply NetworkManager::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) { return globalNetworkManager->activateConnection(connectionUni, interfaceUni, connectionParameter); } QDBusPendingReply<> NetworkManager::deactivateConnection(const QString &activeConnectionPath) { return globalNetworkManager->deactivateConnection(activeConnectionPath); } QDBusPendingReply< QString, QString > NetworkManager::getLogging() { return globalNetworkManager->getLogging(); } void NetworkManager::setNetworkingEnabled(bool enabled) { globalNetworkManager->setNetworkingEnabled(enabled); } void NetworkManager::setWirelessEnabled(bool enabled) { globalNetworkManager->setWirelessEnabled(enabled); } bool NetworkManager::isWwanEnabled() { return globalNetworkManager->isWwanEnabled(); } bool NetworkManager::isWwanHardwareEnabled() { return globalNetworkManager->isWwanHardwareEnabled(); } void NetworkManager::setWwanEnabled(bool enabled) { globalNetworkManager->setWwanEnabled(enabled); } bool NetworkManager::isWimaxEnabled() { return globalNetworkManager->isWimaxEnabled(); } bool NetworkManager::isWimaxHardwareEnabled() { return globalNetworkManager->isWimaxHardwareEnabled(); } void NetworkManager::setWimaxEnabled(bool enabled) { globalNetworkManager->setWimaxEnabled(enabled); } void NetworkManager::sleep(bool sleep) { globalNetworkManager->sleep(sleep); } void NetworkManager::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) { globalNetworkManager->setLogging(level, domains); } NMStringMap NetworkManager::permissions() { return globalNetworkManager->permissions(); } NetworkManager::Device::Types NetworkManager::supportedInterfaceTypes() { return globalNetworkManager->supportedInterfaceTypes(); } NetworkManager::Connectivity NetworkManager::connectivity() { return globalNetworkManager->connectivity(); } QDBusPendingReply NetworkManager::checkConnectivity() { return globalNetworkManager->checkConnectivity(); } NetworkManager::ActiveConnection::Ptr NetworkManager::primaryConnection() { return globalNetworkManager->primaryConnection(); } NetworkManager::ActiveConnection::Ptr NetworkManager::activatingConnection() { return globalNetworkManager->activatingConnection(); } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::primaryConnectionType() { return globalNetworkManager->primaryConnectionType(); } bool NetworkManager::isStartingUp() { return globalNetworkManager->isStartingUp(); } NetworkManager::Device::MeteredStatus NetworkManager::metered() { return globalNetworkManager->metered(); } NetworkManager::DnsConfiguration NetworkManager::globalDnsConfiguration() { return globalNetworkManager->globalDnsConfiguration(); } void NetworkManager::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration) { globalNetworkManager->setGlobalDnsConfiguration(configuration); } NetworkManager::Notifier *NetworkManager::notifier() { return globalNetworkManager; } diff --git a/src/settings/connectionsettings.cpp b/src/settings/connectionsettings.cpp index ab3424a..ae7a512 100644 --- a/src/settings/connectionsettings.cpp +++ b/src/settings/connectionsettings.cpp @@ -1,1117 +1,1117 @@ /* Copyright 2012-2013 Jan Grulich Copyright 2013 Daniel Nicoletti This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "connectionsettings.h" #include "connectionsettings_p.h" #include "wiredsetting.h" #include "olpcmeshsetting.h" #include "wirelesssetting.h" #include "wirelesssecuritysetting.h" #include "security8021xsetting.h" #include "adslsetting.h" #include "bluetoothsetting.h" #include "bondsetting.h" #include "bridgesetting.h" #include "bridgeportsetting.h" #include "gsmsetting.h" #include "cdmasetting.h" #include "infinibandsetting.h" #include "iptunnelsetting.h" #include "ipv4setting.h" #include "ipv6setting.h" #include "pppsetting.h" #include "pppoesetting.h" #include "serialsetting.h" #include "tunsetting.h" #include "vlansetting.h" #include "vpnsetting.h" #include "wimaxsetting.h" #include "wireguardsetting.h" #undef signals #include #if !NM_CHECK_VERSION(1, 6, 0) #define NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES "autoconnect-retries" #endif #if !NM_CHECK_VERSION(1, 16, 0) #define NM_SETTING_WIREGUARD_SETTING_NAME "wireguard" #endif #include "teamsetting.h" #include "genericsetting.h" #include namespace NetworkManager { extern int checkVersion(const int x, const int y, const int z); } NetworkManager::ConnectionSettingsPrivate::ConnectionSettingsPrivate(ConnectionSettings *q) : name(NM_SETTING_CONNECTION_SETTING_NAME) , uuid(QUuid().toString()) , type(ConnectionSettings::Wired) , autoconnect(true) , readOnly(false) , gatewayPingTimeout(0) , autoconnectPriority(0) , autoconnectRetries(-1) , autoconnectSlaves(ConnectionSettings::SlavesDefault) , lldp(ConnectionSettings::LldpDefault) , metered(ConnectionSettings::MeteredUnknown) , q_ptr(q) { } void NetworkManager::ConnectionSettingsPrivate::addSetting(const NetworkManager::Setting::Ptr &setting) { settings.push_back(setting); } void NetworkManager::ConnectionSettingsPrivate::clearSettings() { settings.clear(); } void NetworkManager::ConnectionSettingsPrivate::initSettings(NMBluetoothCapabilities bt_cap) { clearSettings(); switch (type) { case ConnectionSettings::Adsl: addSetting(Setting::Ptr(new AdslSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Bond: addSetting(Setting::Ptr(new BondSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Bluetooth: addSetting(Setting::Ptr(new BluetoothSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); //addSetting(Setting::Ptr(new Ipv6Setting())); if (bt_cap == NM_BT_CAPABILITY_DUN) { addSetting(Setting::Ptr(new GsmSetting())); addSetting(Setting::Ptr(new PppSetting())); addSetting(Setting::Ptr(new SerialSetting())); } break; case ConnectionSettings::Bridge: addSetting(Setting::Ptr(new BridgeSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Cdma: addSetting(Setting::Ptr(new CdmaSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); if (NetworkManager::checkVersion(1, 0, 0)) { addSetting(Setting::Ptr(new Ipv6Setting())); } addSetting(Setting::Ptr(new PppSetting())); break; case ConnectionSettings::Gsm: addSetting(Setting::Ptr(new GsmSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); if (NetworkManager::checkVersion(1, 0, 0)) { addSetting(Setting::Ptr(new Ipv6Setting())); } addSetting(Setting::Ptr(new PppSetting())); break; case ConnectionSettings::Infiniband: addSetting(Setting::Ptr(new InfinibandSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::OLPCMesh: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new OlpcMeshSetting())); break; case ConnectionSettings::Pppoe: addSetting(Setting::Ptr(new Ipv4Setting())); //addSetting(new Ipv6Setting())); addSetting(Setting::Ptr(new PppSetting())); addSetting(Setting::Ptr(new PppoeSetting())); addSetting(Setting::Ptr(new WiredSetting())); break; case ConnectionSettings::Vlan: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new VlanSetting())); break; case ConnectionSettings::Vpn: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new VpnSetting())); break; case ConnectionSettings::Wimax: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new WimaxSetting())); break; case ConnectionSettings::Wired: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new Security8021xSetting())); addSetting(Setting::Ptr(new WiredSetting())); break; case ConnectionSettings::Wireless: addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); addSetting(Setting::Ptr(new Security8021xSetting())); addSetting(Setting::Ptr(new WirelessSetting())); addSetting(Setting::Ptr(new WirelessSecuritySetting())); break; case ConnectionSettings::Team: addSetting(Setting::Ptr(new TeamSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Generic: addSetting(Setting::Ptr(new GenericSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Tun: addSetting(Setting::Ptr(new TunSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::IpTunnel: addSetting(Setting::Ptr(new IpTunnelSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::WireGuard: addSetting(Setting::Ptr(new WireGuardSetting())); addSetting(Setting::Ptr(new Ipv4Setting())); addSetting(Setting::Ptr(new Ipv6Setting())); break; case ConnectionSettings::Unknown: default: break; } } void NetworkManager::ConnectionSettingsPrivate::initSettings(const NetworkManager::ConnectionSettings::Ptr &connectionSettings) { Q_Q(ConnectionSettings); clearSettings(); switch (type) { case ConnectionSettings::Adsl: addSetting(connectionSettings->setting(Setting::Adsl)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Bond: addSetting(connectionSettings->setting(Setting::Bond)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Bluetooth: addSetting(connectionSettings->setting(Setting::Bluetooth)); addSetting(connectionSettings->setting(Setting::Ipv4)); if (NetworkManager::checkVersion(1, 0, 0)) { addSetting(connectionSettings->setting(Setting::Ipv6)); } if (q->setting(Setting::Gsm) && q->setting(Setting::Ppp) && q->setting(Setting::Serial)) { addSetting(connectionSettings->setting(Setting::Gsm)); addSetting(connectionSettings->setting(Setting::Ppp)); addSetting(connectionSettings->setting(Setting::Serial)); } break; case ConnectionSettings::Bridge: addSetting(connectionSettings->setting(Setting::Bridge)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Cdma: addSetting(connectionSettings->setting(Setting::Cdma)); addSetting(connectionSettings->setting(Setting::Ipv4)); if (NetworkManager::checkVersion(1, 0, 0)) { addSetting(connectionSettings->setting(Setting::Ipv6)); } addSetting(connectionSettings->setting(Setting::Ppp)); break; case ConnectionSettings::Gsm: addSetting(connectionSettings->setting(Setting::Gsm)); addSetting(connectionSettings->setting(Setting::Ipv4)); if (NetworkManager::checkVersion(1, 0, 0)) { addSetting(connectionSettings->setting(Setting::Ipv6)); } addSetting(connectionSettings->setting(Setting::Ppp)); break; case ConnectionSettings::Infiniband: addSetting(connectionSettings->setting(Setting::Infiniband)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::OLPCMesh: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::OlpcMesh)); break; case ConnectionSettings::Pppoe: addSetting(connectionSettings->setting(Setting::Ipv4)); //addSetting(Ipv6Setting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Ppp)); addSetting(connectionSettings->setting(Setting::Pppoe)); addSetting(connectionSettings->setting(Setting::Wired)); break; case ConnectionSettings::Vlan: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Vlan)); break; case ConnectionSettings::Vpn: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Vpn)); break; case ConnectionSettings::Wimax: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Wimax)); break; case ConnectionSettings::Wired: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Security8021x)); addSetting(connectionSettings->setting(Setting::Wired)); break; case ConnectionSettings::Wireless: addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); addSetting(connectionSettings->setting(Setting::Security8021x)); addSetting(connectionSettings->setting(Setting::Wireless)); addSetting(connectionSettings->setting(Setting::WirelessSecurity)); break; case ConnectionSettings::Team: addSetting(connectionSettings->setting(Setting::Team)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Generic: addSetting(connectionSettings->setting(Setting::Generic)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Tun: addSetting(connectionSettings->setting(Setting::Tun)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::IpTunnel: addSetting(connectionSettings->setting(Setting::IpTunnel)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::WireGuard: addSetting(connectionSettings->setting(Setting::WireGuard)); addSetting(connectionSettings->setting(Setting::Ipv4)); addSetting(connectionSettings->setting(Setting::Ipv6)); break; case ConnectionSettings::Unknown: default: break; } } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::ConnectionSettings::typeFromString(const QString &typeString) { ConnectionSettings::ConnectionType type = Wired; if (typeString == QLatin1String(NM_SETTING_ADSL_SETTING_NAME)) { type = Adsl; } else if (typeString == QLatin1String(NM_SETTING_BLUETOOTH_SETTING_NAME)) { type = Bluetooth; } else if (typeString == QLatin1String(NM_SETTING_BOND_SETTING_NAME)) { type = Bond; } else if (typeString == QLatin1String(NM_SETTING_BRIDGE_SETTING_NAME)) { type = Bridge; } else if (typeString == QLatin1String(NM_SETTING_CDMA_SETTING_NAME)) { type = Cdma; } else if (typeString == QLatin1String(NM_SETTING_GSM_SETTING_NAME)) { type = Gsm; } else if (typeString == QLatin1String(NM_SETTING_INFINIBAND_SETTING_NAME)) { type = Infiniband; } else if (typeString == QLatin1String(NM_SETTING_OLPC_MESH_SETTING_NAME)) { type = OLPCMesh; } else if (typeString == QLatin1String(NM_SETTING_PPPOE_SETTING_NAME)) { type = Pppoe; } else if (typeString == QLatin1String(NM_SETTING_VLAN_SETTING_NAME)) { type = Vlan; } else if (typeString == QLatin1String(NM_SETTING_VPN_SETTING_NAME)) { type = Vpn; } else if (typeString == QLatin1String(NM_SETTING_WIMAX_SETTING_NAME)) { type = Wimax; } else if (typeString == QLatin1String(NM_SETTING_WIRED_SETTING_NAME)) { type = Wired; } else if (typeString == QLatin1String(NM_SETTING_WIRELESS_SETTING_NAME)) { type = Wireless; } else if (typeString == QLatin1String(NM_SETTING_TEAM_SETTING_NAME)) { type = Team; } else if (typeString == QLatin1String(NM_SETTING_GENERIC_SETTING_NAME)) { type = Generic; } else if (typeString == QLatin1String(NM_SETTING_TUN_SETTING_NAME)) { type = Tun; } else if (typeString == QLatin1String(NM_SETTING_IP_TUNNEL_SETTING_NAME)) { type = IpTunnel; } else if (typeString == QLatin1String(NM_SETTING_WIREGUARD_SETTING_NAME)) { type = WireGuard; } return type; } QString NetworkManager::ConnectionSettings::typeAsString(NetworkManager::ConnectionSettings::ConnectionType type) { QString typeString; switch (type) { case Adsl: typeString = QLatin1String(NM_SETTING_ADSL_SETTING_NAME); break; case Bond: typeString = QLatin1String(NM_SETTING_BOND_SETTING_NAME); break; case Bluetooth: typeString = QLatin1String(NM_SETTING_BLUETOOTH_SETTING_NAME); break; case Bridge: typeString = QLatin1String(NM_SETTING_BRIDGE_SETTING_NAME); break; case Cdma: typeString = QLatin1String(NM_SETTING_CDMA_SETTING_NAME); break; case Gsm: typeString = QLatin1String(NM_SETTING_GSM_SETTING_NAME); break; case Infiniband: typeString = QLatin1String(NM_SETTING_INFINIBAND_SETTING_NAME); break; case OLPCMesh: typeString = QLatin1String(NM_SETTING_OLPC_MESH_SETTING_NAME); break; case Pppoe: typeString = QLatin1String(NM_SETTING_PPPOE_SETTING_NAME); break; case Vlan: typeString = QLatin1String(NM_SETTING_VLAN_SETTING_NAME); break; case Vpn: typeString = QLatin1String(NM_SETTING_VPN_SETTING_NAME); break; case Wimax: typeString = QLatin1String(NM_SETTING_WIMAX_SETTING_NAME); break; case Wired: typeString = QLatin1String(NM_SETTING_WIRED_SETTING_NAME); break; case Wireless: typeString = QLatin1String(NM_SETTING_WIRELESS_SETTING_NAME); break; case Team: typeString = QLatin1String(NM_SETTING_TEAM_SETTING_NAME); break; case Generic: typeString = QLatin1String(NM_SETTING_GENERIC_SETTING_NAME); break; case Tun: typeString = QLatin1String(NM_SETTING_TUN_SETTING_NAME); break; case IpTunnel: typeString = QLatin1String(NM_SETTING_IP_TUNNEL_SETTING_NAME); break; case WireGuard: typeString = QLatin1String(NM_SETTING_WIREGUARD_SETTING_NAME); break; default: break; }; return typeString; } QString NetworkManager::ConnectionSettings::createNewUuid() { return QUuid::createUuid().toString().mid(1, QUuid::createUuid().toString().length() - 2); } NetworkManager::ConnectionSettings::ConnectionSettings() : d_ptr(new ConnectionSettingsPrivate(this)) { } NetworkManager::ConnectionSettings::ConnectionSettings(NetworkManager::ConnectionSettings::ConnectionType type, NMBluetoothCapabilities bt_cap) : d_ptr(new ConnectionSettingsPrivate(this)) { setConnectionType(type, bt_cap); } NetworkManager::ConnectionSettings::ConnectionSettings(const NetworkManager::ConnectionSettings::Ptr &other) : d_ptr(new ConnectionSettingsPrivate(this)) { Q_D(ConnectionSettings); setId(other->id()); setUuid(other->uuid()); setInterfaceName(other->interfaceName()); setConnectionType(other->connectionType()); setPermissions(other->permissions()); setAutoconnect(other->autoconnect()); setAutoconnectPriority(other->autoconnectPriority()); setTimestamp(other->timestamp()); setReadOnly(other->readOnly()); setZone(other->zone()); setMaster(other->master()); setSlaveType(other->slaveType()); setGatewayPingTimeout(other->gatewayPingTimeout()); setAutoconnectRetries(other->autoconnectRetries()); setAutoconnectSlaves(other->autoconnectSlaves()); setLldp(other->lldp()); setMetered(other->metered()); setStableId(other->stableId()); d->initSettings(other); } NetworkManager::ConnectionSettings::ConnectionSettings(const NMVariantMapMap &map) : d_ptr(new ConnectionSettingsPrivate(this)) { fromMap(map); } NetworkManager::ConnectionSettings::~ConnectionSettings() { d_ptr->clearSettings(); delete d_ptr; } void NetworkManager::ConnectionSettings::fromMap(const NMVariantMapMap &map) { QVariantMap connectionSettings = map.value(QLatin1String(NM_SETTING_CONNECTION_SETTING_NAME)); setId(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_ID)).toString()); setUuid(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_UUID)).toString()); setConnectionType(typeFromString(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_TYPE)).toString())); if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_INTERFACE_NAME))) { setInterfaceName(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_INTERFACE_NAME)).toString()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_PERMISSIONS))) { QStringList permissions = connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_PERMISSIONS)).toStringList(); Q_FOREACH (const QString & permission, permissions) { - const QStringList split = permission.split(QLatin1String(":"), QString::KeepEmptyParts); + const QStringList split = permission.split(QLatin1Char(':'), QString::KeepEmptyParts); addToPermissions(split.at(1), split.at(2)); } } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT))) { setAutoconnect(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT)).toBool()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY))) { setAutoconnectPriority(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY)).toInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_TIMESTAMP))) { const int timestamp = connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_TIMESTAMP)).toInt(); QDateTime dateTime; dateTime.setTime_t(timestamp); setTimestamp(dateTime); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_READ_ONLY))) { setReadOnly(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_READ_ONLY)).toBool()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_ZONE))) { setZone(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_ZONE)).toString()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_MASTER))) { setMaster(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_MASTER)).toString()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_SLAVE_TYPE))) { setSlaveType(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_SLAVE_TYPE)).toString()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_SECONDARIES))) { setSecondaries(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_SECONDARIES)).toStringList()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT))) { setGatewayPingTimeout(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT)).toUInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES))) { setAutoconnectRetries(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES)).toInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES))) { setAutoconnectSlaves((NetworkManager::ConnectionSettings::AutoconnectSlaves)connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES)).toInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_LLDP))) { setLldp((NetworkManager::ConnectionSettings::Lldp)connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_LLDP)).toInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_METERED))) { setMetered((NetworkManager::ConnectionSettings::Metered)connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_METERED)).toInt()); } if (connectionSettings.contains(QLatin1String(NM_SETTING_CONNECTION_STABLE_ID))) { setStableId(connectionSettings.value(QLatin1String(NM_SETTING_CONNECTION_STABLE_ID)).toString()); } Q_FOREACH (const Setting::Ptr & setting, settings()) { if (map.contains(setting->name())) { setting->fromMap(map.value(setting->name())); setting->setInitialized(true); } else { setting->setInitialized(false); } } } NMVariantMapMap NetworkManager::ConnectionSettings::toMap() const { NMVariantMapMap result; QVariantMap connectionSetting; if (!id().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_ID), id()); } if (!uuid().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_UUID), uuid()); } if (connectionType()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_TYPE), typeAsString(connectionType())); } if (!interfaceName().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_INTERFACE_NAME), interfaceName()); } if (!permissions().isEmpty()) { QStringList perm; QHash perms = permissions(); QHash::const_iterator it = perms.constBegin(); while (it != perms.constEnd()) { const QString tmp = "user:" + it.key() + ':' + it.value(); perm << tmp; ++it; } connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_PERMISSIONS), perm); } if (!autoconnect()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT), autoconnect()); } if (autoconnectPriority()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY), autoconnectPriority()); } if (timestamp().isValid()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_TIMESTAMP), timestamp().toTime_t()); } if (readOnly()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_READ_ONLY), readOnly()); } if (!zone().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_ZONE), zone()); } if (!master().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_MASTER), master()); } if (!slaveType().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_SLAVE_TYPE), slaveType()); } if (!secondaries().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_SECONDARIES), secondaries()); } if (gatewayPingTimeout()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT), gatewayPingTimeout()); } if (autoconnectRetries() >= 0) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES), autoconnectRetries()); } connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES), autoconnectSlaves()); connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_LLDP), lldp()); connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_METERED), metered()); if (!stableId().isEmpty()) { connectionSetting.insert(QLatin1String(NM_SETTING_CONNECTION_STABLE_ID), stableId()); } result.insert(QLatin1String(NM_SETTING_CONNECTION_SETTING_NAME), connectionSetting); Q_FOREACH (const Setting::Ptr & setting, settings()) { QVariantMap map = setting->toMap(); if (!setting->isNull()) { result.insert(setting->name(), map); } } return result; } QString NetworkManager::ConnectionSettings::name() const { Q_D(const ConnectionSettings); return d->name; } void NetworkManager::ConnectionSettings::setId(const QString &id) { Q_D(ConnectionSettings); d->id = id; } QString NetworkManager::ConnectionSettings::id() const { Q_D(const ConnectionSettings); return d->id; } void NetworkManager::ConnectionSettings::setUuid(const QString &uuid) { Q_D(ConnectionSettings); d->uuid = uuid; } QString NetworkManager::ConnectionSettings::uuid() const { Q_D(const ConnectionSettings); return d->uuid; } void NetworkManager::ConnectionSettings::setInterfaceName(const QString &interfaceName) { Q_D(ConnectionSettings); d->interfaceName = interfaceName; } QString NetworkManager::ConnectionSettings::interfaceName() const { Q_D(const ConnectionSettings); return d->interfaceName; } void NetworkManager::ConnectionSettings::setConnectionType(NetworkManager::ConnectionSettings::ConnectionType type, NMBluetoothCapabilities bt_cap) { Q_D(ConnectionSettings); d->type = type; d->initSettings(bt_cap); } NetworkManager::ConnectionSettings::ConnectionType NetworkManager::ConnectionSettings::connectionType() const { Q_D(const ConnectionSettings); return d->type; } void NetworkManager::ConnectionSettings::addToPermissions(const QString &user, const QString &type) { Q_D(ConnectionSettings); d->permissions.insert(user, type); } void NetworkManager::ConnectionSettings::setPermissions(const QHash< QString, QString > &perm) { Q_D(ConnectionSettings); d->permissions = perm; } QHash< QString, QString > NetworkManager::ConnectionSettings::permissions() const { Q_D(const ConnectionSettings); return d->permissions; } void NetworkManager::ConnectionSettings::setAutoconnect(bool autoconnect) { Q_D(ConnectionSettings); d->autoconnect = autoconnect; } bool NetworkManager::ConnectionSettings::autoconnect() const { Q_D(const ConnectionSettings); return d->autoconnect; } void NetworkManager::ConnectionSettings::setAutoconnectPriority(int priority) { Q_D(ConnectionSettings); d->autoconnectPriority = priority; } int NetworkManager::ConnectionSettings::autoconnectPriority() const { Q_D(const ConnectionSettings); return d->autoconnectPriority; } void NetworkManager::ConnectionSettings::setTimestamp(const QDateTime ×tamp) { Q_D(ConnectionSettings); d->timestamp = timestamp; } QDateTime NetworkManager::ConnectionSettings::timestamp() const { Q_D(const ConnectionSettings); return d->timestamp; } void NetworkManager::ConnectionSettings::setReadOnly(bool readonly) { Q_D(ConnectionSettings); d->readOnly = readonly; } bool NetworkManager::ConnectionSettings::readOnly() const { Q_D(const ConnectionSettings); return d->readOnly; } void NetworkManager::ConnectionSettings::setZone(const QString &zone) { Q_D(ConnectionSettings); d->zone = zone; } QString NetworkManager::ConnectionSettings::zone() const { Q_D(const ConnectionSettings); return d->zone; } bool NetworkManager::ConnectionSettings::isSlave() const { Q_D(const ConnectionSettings); return !d->master.isEmpty() && !d->slaveType.isEmpty(); } void NetworkManager::ConnectionSettings::setMaster(const QString &master) { Q_D(ConnectionSettings); d->master = master; } QString NetworkManager::ConnectionSettings::master() const { Q_D(const ConnectionSettings); return d->master; } void NetworkManager::ConnectionSettings::setSlaveType(const QString &type) { Q_D(ConnectionSettings); d->slaveType = type; } QString NetworkManager::ConnectionSettings::slaveType() const { Q_D(const ConnectionSettings); return d->slaveType; } void NetworkManager::ConnectionSettings::setSecondaries(const QStringList &secondaries) { Q_D(ConnectionSettings); d->secondaries = secondaries; } QStringList NetworkManager::ConnectionSettings::secondaries() const { Q_D(const ConnectionSettings); return d->secondaries; } void NetworkManager::ConnectionSettings::setGatewayPingTimeout(quint32 timeout) { Q_D(ConnectionSettings); d->gatewayPingTimeout = timeout; } quint32 NetworkManager::ConnectionSettings::gatewayPingTimeout() const { Q_D(const ConnectionSettings); return d->gatewayPingTimeout; } int NetworkManager::ConnectionSettings::autoconnectRetries() const { Q_D(const ConnectionSettings); return d->autoconnectRetries; } void NetworkManager::ConnectionSettings::setAutoconnectRetries(int retries) { Q_D(ConnectionSettings); d->autoconnectRetries = retries; } NetworkManager::ConnectionSettings::AutoconnectSlaves NetworkManager::ConnectionSettings::autoconnectSlaves() const { Q_D(const ConnectionSettings); return d->autoconnectSlaves; } void NetworkManager::ConnectionSettings::setAutoconnectSlaves(NetworkManager::ConnectionSettings::AutoconnectSlaves autoconnectSlaves) { Q_D(ConnectionSettings); d->autoconnectSlaves = autoconnectSlaves; } NetworkManager::ConnectionSettings::Lldp NetworkManager::ConnectionSettings::lldp() const { Q_D(const ConnectionSettings); return d->lldp; } void NetworkManager::ConnectionSettings::setLldp(NetworkManager::ConnectionSettings::Lldp lldp) { Q_D(ConnectionSettings); d->lldp = lldp; } NetworkManager::ConnectionSettings::Metered NetworkManager::ConnectionSettings::metered() const { Q_D(const ConnectionSettings); return d->metered; } void NetworkManager::ConnectionSettings::setMetered(NetworkManager::ConnectionSettings::Metered metered) { Q_D(ConnectionSettings); d->metered = metered; } QString NetworkManager::ConnectionSettings::stableId() const { Q_D(const ConnectionSettings); return d->stableId; } void NetworkManager::ConnectionSettings::setStableId(const QString &stableId) { Q_D(ConnectionSettings); d->stableId = stableId; } NetworkManager::Setting::Ptr NetworkManager::ConnectionSettings::setting(Setting::SettingType type) const { Q_FOREACH (const Setting::Ptr & setting, settings()) { if (setting->type() == type) { return setting; } } return Setting::Ptr(); } NetworkManager::Setting::Ptr NetworkManager::ConnectionSettings::setting(const QString &type) const { return setting(Setting::typeFromString(type)); } NetworkManager::Setting::List NetworkManager::ConnectionSettings::settings() const { Q_D(const ConnectionSettings); return d->settings; } QDebug NetworkManager::operator <<(QDebug dbg, const NetworkManager::ConnectionSettings &setting) { dbg.nospace() << "CONNECTION SETTINGS\n"; dbg.nospace() << "===================\n"; dbg.nospace() << NM_SETTING_CONNECTION_ID << ": " << setting.id() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_UUID << ": " << setting.uuid() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_INTERFACE_NAME << ": " << setting.interfaceName() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_TYPE << ": " << setting.typeAsString(setting.connectionType()) << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_PERMISSIONS << ": " << setting.permissions() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_AUTOCONNECT << ": " << setting.autoconnect() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_AUTOCONNECT_PRIORITY << ": " << setting.autoconnectPriority() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_TIMESTAMP << ": " << setting.timestamp().toTime_t() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_READ_ONLY << ": " << setting.readOnly() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_ZONE << ": " << setting.zone() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_MASTER << ": " << setting.master() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_SLAVE_TYPE << ": " << setting.slaveType() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_SECONDARIES << ": " << setting.secondaries() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT << ": " << setting.gatewayPingTimeout() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_AUTOCONNECT_RETRIES << ": " << setting.autoconnectRetries() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES << ": " << setting.autoconnectSlaves() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_LLDP << ": " << setting.lldp() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_METERED << ": " << setting.metered() << '\n'; dbg.nospace() << NM_SETTING_CONNECTION_STABLE_ID << ": " << setting.stableId() << '\n'; dbg.nospace() << "===================\n"; Q_FOREACH (const Setting::Ptr & settingPtr, setting.settings()) { dbg.nospace() << settingPtr->typeAsString(settingPtr->type()).toUpper() << " SETTINGS\n"; dbg.nospace() << "---------------------------\n"; switch (settingPtr->type()) { case Setting::Adsl: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Bond: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Bluetooth: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Bridge: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::BridgePort: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Cdma: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Gsm: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Infiniband: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Ipv4: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Ipv6: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::OlpcMesh: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Ppp: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Pppoe: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Security8021x: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Serial: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Vlan: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Vpn: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Wimax: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Wired: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Wireless: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::WirelessSecurity: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Team: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::Tun: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::IpTunnel: dbg.nospace() << *(settingPtr.staticCast().data()); break; case Setting::WireGuard: dbg.nospace() << *(settingPtr.staticCast().data()); break; default: dbg.nospace() << *settingPtr.data(); } dbg.nospace() << '\n'; } return dbg.maybeSpace(); }