NetworkManagerQt

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

KDE's Doxygen guidelines are available online.