1 | /* |
2 | SPDX-FileCopyrightText: 2008, 2010 Will Stephenson <wstephenson@kde.org> |
3 | SPDX-FileCopyrightText: 2011-2013 Lamarque Souza <lamarque@kde.org> |
4 | SPDX-FileCopyrightText: 2013 Daniel Nicoletti <dantti12@gmail.com> |
5 | SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com> |
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 |
70 | : watcher(DBUS_SERVICE, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this) |
71 | , iface(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE, NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH, QDBusConnection::sessionBus()) |
72 | #else |
73 | : watcher(DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForOwnerChange, this) |
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_isConnectivityCheckAvailable(false) |
86 | , m_isConnectivityCheckEnabled(false) |
87 | , m_globalDnsConfiguration(NetworkManager::DnsConfiguration()) |
88 | , m_supportedInterfaceTypes(NetworkManager::Device::UnknownType) |
89 | { |
90 | connect(sender: &iface, signal: &OrgFreedesktopNetworkManagerInterface::DeviceAdded, context: this, slot: &NetworkManagerPrivate::onDeviceAdded); |
91 | connect(sender: &iface, signal: &OrgFreedesktopNetworkManagerInterface::DeviceRemoved, context: this, slot: &NetworkManagerPrivate::onDeviceRemoved); |
92 | |
93 | #ifndef NMQT_STATIC |
94 | QDBusConnection::systemBus().connect(service: NetworkManagerPrivate::DBUS_SERVICE, |
95 | path: NetworkManagerPrivate::DBUS_DAEMON_PATH, |
96 | interface: NetworkManagerPrivate::FDO_DBUS_PROPERTIES, |
97 | name: QLatin1String("PropertiesChanged" ), |
98 | receiver: this, |
99 | SLOT(dbusPropertiesChanged(QString, QVariantMap, QStringList))); |
100 | #else |
101 | connect(&iface, &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, this, &NetworkManagerPrivate::propertiesChanged); |
102 | #endif |
103 | |
104 | // We register two listeners here: |
105 | // - a ServiceRegistered listener for newer NM versions that connect to the bus when the interfaces |
106 | // we care about are already initialized |
107 | // - and an InterfaceAdded listener for older NM versions that connect to the bus early, |
108 | // and then add interfaces dynamically |
109 | iface.connection().connect(service: NetworkManagerPrivate::DBUS_SERVICE, |
110 | path: "/org/freedesktop" , |
111 | interface: NetworkManagerPrivate::FDO_DBUS_OBJECT_MANAGER, |
112 | name: QLatin1String("InterfacesAdded" ), |
113 | receiver: this, |
114 | SLOT(dbusInterfacesAdded(QDBusObjectPath, QVariantMap))); |
115 | |
116 | connect(sender: &watcher, signal: &QDBusServiceWatcher::serviceRegistered, context: this, slot: &NetworkManagerPrivate::daemonRegistered); |
117 | connect(sender: &watcher, signal: &QDBusServiceWatcher::serviceUnregistered, context: this, slot: &NetworkManagerPrivate::daemonUnregistered); |
118 | |
119 | init(); |
120 | } |
121 | |
122 | void NetworkManager::NetworkManagerPrivate::parseVersion(const QString &version) |
123 | { |
124 | const QStringList sl = version.split(sep: '.'); |
125 | |
126 | if (sl.size() > 2) { |
127 | m_x = sl[0].toInt(); |
128 | m_y = sl[1].toInt(); |
129 | m_z = sl[2].toInt(); |
130 | } else { |
131 | m_x = -1; |
132 | m_y = -1; |
133 | m_z = -1; |
134 | } |
135 | } |
136 | |
137 | void NetworkManager::NetworkManagerPrivate::init() |
138 | { |
139 | qDBusRegisterMetaType<UIntList>(); |
140 | qDBusRegisterMetaType<UIntListList>(); |
141 | // qDBusRegisterMetaType<IpV6DBusAddress>(); |
142 | // qDBusRegisterMetaType<IpV6DBusAddressList>(); |
143 | // qDBusRegisterMetaType<IpV6DBusNameservers>(); |
144 | // qDBusRegisterMetaType<IpV6DBusRoute>(); |
145 | // qDBusRegisterMetaType<IpV6DBusRouteList>(); |
146 | qDBusRegisterMetaType<QList<QDBusObjectPath>>(); |
147 | qDBusRegisterMetaType<DeviceDBusStateReason>(); |
148 | qDBusRegisterMetaType<NMVariantMapMap>(); |
149 | qDBusRegisterMetaType<NMVariantMapList>(); |
150 | qDBusRegisterMetaType<NMStringMap>(); |
151 | |
152 | m_version = iface.version(); |
153 | parseVersion(version: m_version); |
154 | /* clang-format off */ |
155 | m_supportedInterfaceTypes = static_cast<NetworkManager::Device::Types>( |
156 | NetworkManager::Device::Ethernet |
157 | | NetworkManager::Device::Wifi |
158 | | NetworkManager::Device::Modem |
159 | | (checkVersion(x: 1, y: 2, z: 0) ? 0 : NetworkManager::Device::Wimax) |
160 | | NetworkManager::Device::Bluetooth |
161 | | NetworkManager::Device::OlpcMesh |
162 | | NetworkManager::Device::InfiniBand |
163 | | NetworkManager::Device::Bond |
164 | | NetworkManager::Device::Vlan |
165 | | NetworkManager::Device::Adsl |
166 | | NetworkManager::Device::Bridge |
167 | | NetworkManager::Device::Generic |
168 | | NetworkManager::Device::Team |
169 | | NetworkManager::Device::MacVlan |
170 | | NetworkManager::Device::Tun |
171 | | NetworkManager::Device::Veth |
172 | | NetworkManager::Device::IpTunnel |
173 | | NetworkManager::Device::WireGuard); |
174 | /* clang-format on */ |
175 | |
176 | // Get all Manager's properties async |
177 | QVariantMap initialProperties = retrieveInitialProperties(interfaceName: iface.staticInterfaceName(), path: DBUS_DAEMON_PATH); |
178 | if (!initialProperties.isEmpty()) { |
179 | propertiesChanged(changedProperties: initialProperties); |
180 | } |
181 | |
182 | QTimer::singleShot(interval: 0, slot: [] { |
183 | qobject_cast<SettingsPrivate *>(object: settingsNotifier())->init(); |
184 | }); |
185 | |
186 | const QList<QDBusObjectPath> devices = iface.devices(); |
187 | qCDebug(NMQT) << "Device list" ; |
188 | for (const QDBusObjectPath &op : devices) { |
189 | networkInterfaceMap.insert(key: op.path(), value: Device::Ptr()); |
190 | Q_EMIT deviceAdded(uni: op.path()); |
191 | qCDebug(NMQT) << " " << op.path(); |
192 | } |
193 | } |
194 | |
195 | NetworkManager::NetworkManagerPrivate::~NetworkManagerPrivate() |
196 | { |
197 | } |
198 | |
199 | QString NetworkManager::NetworkManagerPrivate::version() const |
200 | { |
201 | return m_version; |
202 | } |
203 | |
204 | int NetworkManager::NetworkManagerPrivate::compareVersion(const QString &version) |
205 | { |
206 | int x; |
207 | int y; |
208 | int z; |
209 | const auto sl = QStringView(version).split(sep: '.'); |
210 | if (sl.size() > 2) { |
211 | x = sl[0].toInt(); |
212 | y = sl[1].toInt(); |
213 | z = sl[2].toInt(); |
214 | } else { |
215 | x = -1; |
216 | y = -1; |
217 | z = -1; |
218 | } |
219 | |
220 | return compareVersion(x, y, z); |
221 | } |
222 | |
223 | int NetworkManager::NetworkManagerPrivate::compareVersion(const int x, const int y, const int z) const |
224 | { |
225 | if (m_x > x) { |
226 | return 1; |
227 | } else if (m_x < x) { |
228 | return -1; |
229 | } else if (m_y > y) { |
230 | return 1; |
231 | } else if (m_y < y) { |
232 | return -1; |
233 | } else if (m_z > z) { |
234 | return 1; |
235 | } else if (m_z < z) { |
236 | return -1; |
237 | } |
238 | return 0; |
239 | } |
240 | |
241 | bool NetworkManager::NetworkManagerPrivate::checkVersion(const int x, const int y, const int z) const |
242 | { |
243 | return 0 <= compareVersion(x, y, z); |
244 | } |
245 | |
246 | NetworkManager::Device::Types NetworkManager::NetworkManagerPrivate::supportedInterfaceTypes() const |
247 | { |
248 | return m_supportedInterfaceTypes; |
249 | } |
250 | |
251 | QVariantMap NetworkManager::NetworkManagerPrivate::retrieveInitialProperties(const QString &interfaceName, const QString &path) |
252 | { |
253 | QDBusMessage message = QDBusMessage::createMethodCall(destination: DBUS_SERVICE, path, interface: FDO_DBUS_PROPERTIES, method: QLatin1String("GetAll" )); |
254 | message << interfaceName; |
255 | #ifdef NMQT_STATIC |
256 | QDBusMessage resultMessage = QDBusConnection::sessionBus().call(message); |
257 | #else |
258 | QDBusMessage resultMessage = QDBusConnection::systemBus().call(message); |
259 | #endif |
260 | if (resultMessage.type() == QDBusMessage::ReplyMessage) { |
261 | QVariantMap result; |
262 | QDBusArgument dbusArgument = resultMessage.arguments().at(i: 0).value<QDBusArgument>(); |
263 | while (!dbusArgument.atEnd()) { |
264 | dbusArgument >> result; |
265 | } |
266 | return result; |
267 | } |
268 | |
269 | return QVariantMap(); |
270 | } |
271 | |
272 | NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni) |
273 | { |
274 | NetworkManager::Device::Ptr networkInterface; |
275 | auto it = networkInterfaceMap.constFind(key: uni); |
276 | if (it != networkInterfaceMap.constEnd()) { |
277 | if (*it) { |
278 | networkInterface = *it; |
279 | } else { |
280 | networkInterface = createNetworkInterface(uni); |
281 | networkInterfaceMap[uni] = networkInterface; |
282 | } |
283 | } |
284 | return networkInterface; |
285 | } |
286 | |
287 | NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::findRegisteredActiveConnection(const QString &uni) |
288 | { |
289 | NetworkManager::ActiveConnection::Ptr activeConnection; |
290 | if (!uni.isEmpty() && uni != QLatin1String("/" )) { |
291 | const auto it = m_activeConnections.constFind(key: uni); |
292 | const bool contains = it != m_activeConnections.constEnd(); |
293 | if (contains && *it) { |
294 | activeConnection = *it; |
295 | } else { |
296 | activeConnection = NetworkManager::ActiveConnection::Ptr(new NetworkManager::VpnConnection(uni), &QObject::deleteLater); |
297 | if (activeConnection->connection()) { |
298 | m_activeConnections[uni] = activeConnection; |
299 | if (!contains) { |
300 | Q_EMIT activeConnectionAdded(path: uni); |
301 | } |
302 | } else { |
303 | activeConnection.clear(); |
304 | } |
305 | } |
306 | } |
307 | return activeConnection; |
308 | } |
309 | |
310 | NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::createNetworkInterface(const QString &uni) |
311 | { |
312 | // qCDebug(NMQT); |
313 | auto message = QDBusMessage::createMethodCall(destination: DBUS_SERVICE, path: uni, interface: FDO_DBUS_PROPERTIES, QStringLiteral("Get" )); |
314 | message.setArguments({QLatin1String(OrgFreedesktopNetworkManagerDeviceInterface::staticInterfaceName()), QStringLiteral("DeviceType" )}); |
315 | #ifdef NMQT_STATIC |
316 | auto bus = QDBusConnection::sessionBus(); |
317 | #else |
318 | auto bus = QDBusConnection::systemBus(); |
319 | #endif |
320 | QDBusReply<QVariant> reply = bus.call(message); |
321 | Device::Type type = reply.isValid() ? NetworkManager::DevicePrivate::convertType(reply.value().toInt()) : Device::UnknownType; |
322 | switch (type) { |
323 | case Device::Ethernet: |
324 | return Device::Ptr(new NetworkManager::WiredDevice(uni), &QObject::deleteLater); |
325 | case Device::Wifi: |
326 | return Device::Ptr(new NetworkManager::WirelessDevice(uni), &QObject::deleteLater); |
327 | case Device::Modem: |
328 | return Device::Ptr(new NetworkManager::ModemDevice(uni), &QObject::deleteLater); |
329 | case Device::Bluetooth: |
330 | return Device::Ptr(new NetworkManager::BluetoothDevice(uni), &QObject::deleteLater); |
331 | case Device::Wimax: |
332 | return Device::Ptr(new NetworkManager::WimaxDevice(uni), &QObject::deleteLater); |
333 | case Device::OlpcMesh: |
334 | return Device::Ptr(new NetworkManager::OlpcMeshDevice(uni), &QObject::deleteLater); |
335 | case Device::InfiniBand: |
336 | return Device::Ptr(new NetworkManager::InfinibandDevice(uni), &QObject::deleteLater); |
337 | case Device::Bond: |
338 | return Device::Ptr(new NetworkManager::BondDevice(uni), &QObject::deleteLater); |
339 | case Device::Vlan: |
340 | return Device::Ptr(new NetworkManager::VlanDevice(uni), &QObject::deleteLater); |
341 | case Device::Adsl: |
342 | return Device::Ptr(new NetworkManager::AdslDevice(uni), &QObject::deleteLater); |
343 | case Device::Bridge: |
344 | return Device::Ptr(new NetworkManager::BridgeDevice(uni), &QObject::deleteLater); |
345 | // No need to check checkVersion, because we can't get Generic, Gre, MacVlan, Tun & Veth values in incompatible runtime |
346 | case Device::Generic: |
347 | return Device::Ptr(new NetworkManager::GenericDevice(uni), &QObject::deleteLater); |
348 | case Device::Gre: |
349 | return Device::Ptr(new NetworkManager::GreDevice(uni), &QObject::deleteLater); |
350 | case Device::MacVlan: |
351 | return Device::Ptr(new NetworkManager::MacVlanDevice(uni), &QObject::deleteLater); |
352 | case Device::Tun: |
353 | return Device::Ptr(new NetworkManager::TunDevice(uni), &QObject::deleteLater); |
354 | case Device::Veth: |
355 | return Device::Ptr(new NetworkManager::VethDevice(uni), &QObject::deleteLater); |
356 | case Device::IpTunnel: |
357 | return Device::Ptr(new NetworkManager::IpTunnelDevice(uni), &QObject::deleteLater); |
358 | case Device::WireGuard: |
359 | return Device::Ptr(new NetworkManager::WireGuardDevice(uni), &QObject::deleteLater); |
360 | default: |
361 | if (uni != QLatin1String("any" )) { // VPN connections use "any" as uni for the network interface. |
362 | qCDebug(NMQT) << "Can't create device of type" << type << "for" << uni; |
363 | } |
364 | } |
365 | |
366 | return Device::Ptr(new Device(uni), &QObject::deleteLater); |
367 | } |
368 | |
369 | NetworkManager::Status NetworkManager::NetworkManagerPrivate::status() const |
370 | { |
371 | return nmState; |
372 | } |
373 | |
374 | NetworkManager::Device::List NetworkManager::NetworkManagerPrivate::networkInterfaces() |
375 | { |
376 | Device::List list; |
377 | |
378 | QMap<QString, Device::Ptr>::const_iterator i; |
379 | for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { |
380 | Device::Ptr networkInterface = findRegisteredNetworkInterface(uni: i.key()); |
381 | if (!networkInterface.isNull()) { |
382 | list.append(t: networkInterface); |
383 | } else { |
384 | qCWarning(NMQT) << "warning: null network Interface for" << i.key(); |
385 | } |
386 | } |
387 | |
388 | return list; |
389 | } |
390 | |
391 | NetworkManager::Device::Ptr NetworkManager::NetworkManagerPrivate::findDeviceByIpIface(const QString &iface) |
392 | { |
393 | QMap<QString, Device::Ptr>::const_iterator i; |
394 | for (i = networkInterfaceMap.constBegin(); i != networkInterfaceMap.constEnd(); ++i) { |
395 | Device::Ptr networkInterface = findRegisteredNetworkInterface(uni: i.key()); |
396 | if (networkInterface && networkInterface->udi() == iface) { |
397 | return networkInterface; |
398 | } |
399 | } |
400 | |
401 | return Device::Ptr(); |
402 | } |
403 | |
404 | bool NetworkManager::NetworkManagerPrivate::isNetworkingEnabled() const |
405 | { |
406 | return m_isNetworkingEnabled; |
407 | } |
408 | |
409 | bool NetworkManager::NetworkManagerPrivate::isWirelessEnabled() const |
410 | { |
411 | return m_isWirelessEnabled; |
412 | } |
413 | |
414 | bool NetworkManager::NetworkManagerPrivate::isWirelessHardwareEnabled() const |
415 | { |
416 | return m_isWirelessHardwareEnabled; |
417 | } |
418 | |
419 | bool NetworkManager::NetworkManagerPrivate::isWwanEnabled() const |
420 | { |
421 | return m_isWwanEnabled; |
422 | } |
423 | |
424 | bool NetworkManager::NetworkManagerPrivate::isWwanHardwareEnabled() const |
425 | { |
426 | return m_isWwanHardwareEnabled; |
427 | } |
428 | |
429 | bool NetworkManager::NetworkManagerPrivate::isWimaxEnabled() const |
430 | { |
431 | return checkVersion(x: 1, y: 2, z: 0) ? false : m_isWimaxEnabled; |
432 | } |
433 | |
434 | bool NetworkManager::NetworkManagerPrivate::isWimaxHardwareEnabled() const |
435 | { |
436 | return checkVersion(x: 1, y: 2, z: 0) ? false : m_isWimaxHardwareEnabled; |
437 | } |
438 | |
439 | QDBusPendingReply<QDBusObjectPath> |
440 | NetworkManager::NetworkManagerPrivate::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) |
441 | { |
442 | QString = connectionParameter; |
443 | QString = interfaceUni; |
444 | if (extra_connection_parameter.isEmpty()) { |
445 | extra_connection_parameter = QLatin1String("/" ); |
446 | } |
447 | if (extra_interface_parameter.isEmpty()) { |
448 | extra_interface_parameter = QLatin1String("/" ); |
449 | } |
450 | // TODO store error code |
451 | QDBusObjectPath connPath(connectionUni); |
452 | QDBusObjectPath interfacePath(interfaceUni); |
453 | // qCDebug(NMQT) << "Activating connection" << connPath.path() << "on interface" << interfacePath.path() << "with extra" << extra_connection_parameter; |
454 | return iface.ActivateConnection(connection: connPath, device: QDBusObjectPath(extra_interface_parameter), specific_object: QDBusObjectPath(extra_connection_parameter)); |
455 | } |
456 | |
457 | QDBusPendingReply<QDBusObjectPath, QDBusObjectPath> NetworkManager::NetworkManagerPrivate::addAndActivateConnection(const NMVariantMapMap &connection, |
458 | const QString &interfaceUni, |
459 | const QString &connectionParameter) |
460 | { |
461 | QString = connectionParameter; |
462 | if (extra_connection_parameter.isEmpty()) { |
463 | extra_connection_parameter = QLatin1String("/" ); |
464 | } |
465 | // TODO store error code |
466 | QDBusObjectPath interfacePath(interfaceUni); |
467 | return iface.AddAndActivateConnection(connection, device: interfacePath, specific_object: QDBusObjectPath(extra_connection_parameter)); |
468 | } |
469 | |
470 | QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap> |
471 | NetworkManager::NetworkManagerPrivate::addAndActivateConnection2(const NMVariantMapMap &connection, |
472 | const QString &interfaceUni, |
473 | const QString &connectionParameter, |
474 | const QVariantMap &options) |
475 | { |
476 | QString = connectionParameter; |
477 | if (extra_connection_parameter.isEmpty()) { |
478 | extra_connection_parameter = QLatin1String("/" ); |
479 | } |
480 | // TODO store error code |
481 | QDBusObjectPath interfacePath(interfaceUni); |
482 | return iface.AddAndActivateConnection2(connection, device: interfacePath, specific_object: QDBusObjectPath(extra_connection_parameter), options); |
483 | } |
484 | |
485 | QDBusPendingReply<> NetworkManager::NetworkManagerPrivate::deactivateConnection(const QString &activeConnectionPath) |
486 | { |
487 | return iface.DeactivateConnection(active_connection: QDBusObjectPath(activeConnectionPath)); |
488 | } |
489 | |
490 | void NetworkManager::NetworkManagerPrivate::setNetworkingEnabled(bool enabled) |
491 | { |
492 | iface.Enable(enable: enabled); |
493 | } |
494 | |
495 | void NetworkManager::NetworkManagerPrivate::setWirelessEnabled(bool enabled) |
496 | { |
497 | iface.setWirelessEnabled(enabled); |
498 | } |
499 | |
500 | void NetworkManager::NetworkManagerPrivate::setWwanEnabled(bool enabled) |
501 | { |
502 | iface.setWwanEnabled(enabled); |
503 | } |
504 | |
505 | void NetworkManager::NetworkManagerPrivate::setWimaxEnabled(bool enabled) |
506 | { |
507 | if (!checkVersion(x: 1, y: 2, z: 0)) { |
508 | iface.setWimaxEnabled(enabled); |
509 | } |
510 | } |
511 | |
512 | void NetworkManager::NetworkManagerPrivate::sleep(bool sleep) |
513 | { |
514 | iface.Sleep(sleep); |
515 | } |
516 | |
517 | void NetworkManager::NetworkManagerPrivate::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) |
518 | { |
519 | QString logLevel; |
520 | QStringList logDomains; |
521 | switch (level) { |
522 | case NetworkManager::Error: |
523 | logLevel = QLatin1String("ERR" ); |
524 | break; |
525 | case NetworkManager::Warning: |
526 | logLevel = QLatin1String("WARN" ); |
527 | break; |
528 | case NetworkManager::Info: |
529 | logLevel = QLatin1String("INFO" ); |
530 | break; |
531 | case NetworkManager::Debug: |
532 | logLevel = QLatin1String("DEBUG" ); |
533 | break; |
534 | case NetworkManager::Trace: |
535 | logLevel = QLatin1String("TRACE" ); |
536 | break; |
537 | } |
538 | if (!domains.testFlag(flag: NoChange)) { |
539 | if (domains.testFlag(flag: NetworkManager::None)) { |
540 | logDomains << QLatin1String("NONE" ); |
541 | } |
542 | if (domains.testFlag(flag: NetworkManager::Hardware)) { |
543 | logDomains << QLatin1String("PLATFORM" ); |
544 | } |
545 | if (domains.testFlag(flag: NetworkManager::RFKill)) { |
546 | logDomains << QLatin1String("RFKILL" ); |
547 | } |
548 | if (domains.testFlag(flag: NetworkManager::Ethernet)) { |
549 | logDomains << QLatin1String("ETHER" ); |
550 | } |
551 | if (domains.testFlag(flag: NetworkManager::WiFi)) { |
552 | logDomains << QLatin1String("WIFI" ); |
553 | } |
554 | if (domains.testFlag(flag: NetworkManager::Bluetooth)) { |
555 | logDomains << QLatin1String("BT" ); |
556 | } |
557 | if (domains.testFlag(flag: NetworkManager::MobileBroadBand)) { |
558 | logDomains << QLatin1String("MB" ); |
559 | } |
560 | if (domains.testFlag(flag: NetworkManager::DHCP4)) { |
561 | logDomains << QLatin1String("DHCP4" ); |
562 | } |
563 | if (domains.testFlag(flag: NetworkManager::DHCP6)) { |
564 | logDomains << QLatin1String("DHCP6" ); |
565 | } |
566 | if (domains.testFlag(flag: NetworkManager::PPP)) { |
567 | logDomains << QLatin1String("PPP" ); |
568 | } |
569 | if (domains.testFlag(flag: NetworkManager::WiFiScan)) { |
570 | logDomains << QLatin1String("WIFI_SCAN" ); |
571 | } |
572 | if (domains.testFlag(flag: NetworkManager::IPv4)) { |
573 | logDomains << QLatin1String("IP4" ); |
574 | } |
575 | if (domains.testFlag(flag: NetworkManager::IPv6)) { |
576 | logDomains << QLatin1String("IP6" ); |
577 | } |
578 | if (domains.testFlag(flag: NetworkManager::AutoIPv4)) { |
579 | logDomains << QLatin1String("AUTOIP4" ); |
580 | } |
581 | if (domains.testFlag(flag: NetworkManager::DNS)) { |
582 | logDomains << QLatin1String("DNS" ); |
583 | } |
584 | if (domains.testFlag(flag: NetworkManager::VPN)) { |
585 | logDomains << QLatin1String("VPN" ); |
586 | } |
587 | if (domains.testFlag(flag: NetworkManager::Sharing)) { |
588 | logDomains << QLatin1String("SHARING" ); |
589 | } |
590 | if (domains.testFlag(flag: NetworkManager::Supplicant)) { |
591 | logDomains << QLatin1String("SUPPLICANT" ); |
592 | } |
593 | if (domains.testFlag(flag: NetworkManager::UserSet)) { |
594 | logDomains << QLatin1String("USER_SET" ); |
595 | } |
596 | if (domains.testFlag(flag: NetworkManager::SysSet)) { |
597 | logDomains << QLatin1String("SYS_SET" ); |
598 | } |
599 | if (domains.testFlag(flag: NetworkManager::Suspend)) { |
600 | logDomains << QLatin1String("SUSPEND" ); |
601 | } |
602 | if (domains.testFlag(flag: NetworkManager::Core)) { |
603 | logDomains << QLatin1String("CORE" ); |
604 | } |
605 | if (domains.testFlag(flag: NetworkManager::Devices)) { |
606 | logDomains << QLatin1String("DEVICE" ); |
607 | } |
608 | if (domains.testFlag(flag: NetworkManager::OLPC)) { |
609 | logDomains << QLatin1String("OLPC" ); |
610 | } |
611 | if (domains.testFlag(flag: NetworkManager::Wimax)) { |
612 | logDomains << QLatin1String("WIMAX" ); |
613 | } |
614 | if (domains.testFlag(flag: NetworkManager::Infiniband)) { |
615 | logDomains << QLatin1String("INFINIBAND" ); |
616 | } |
617 | if (domains.testFlag(flag: NetworkManager::Firewall)) { |
618 | logDomains << QLatin1String("FIREWALL" ); |
619 | } |
620 | if (domains.testFlag(flag: NetworkManager::Adsl)) { |
621 | logDomains << QLatin1String("ADSL" ); |
622 | } |
623 | if (domains.testFlag(flag: NetworkManager::Bond)) { |
624 | logDomains << QLatin1String("BOND" ); |
625 | } |
626 | if (domains.testFlag(flag: NetworkManager::Vlan)) { |
627 | logDomains << QLatin1String("VLAN" ); |
628 | } |
629 | if (domains.testFlag(flag: NetworkManager::Agents)) { |
630 | logDomains << QLatin1String("AGENTS" ); |
631 | } |
632 | if (domains.testFlag(flag: NetworkManager::Settings)) { |
633 | logDomains << QLatin1String("SETTINGS" ); |
634 | } |
635 | if (domains.testFlag(flag: NetworkManager::DbusProps)) { |
636 | logDomains << QLatin1String("DBUS_PROPS" ); |
637 | } |
638 | if (domains.testFlag(flag: NetworkManager::Team)) { |
639 | logDomains << QLatin1String("TEAM" ); |
640 | } |
641 | if (domains.testFlag(flag: NetworkManager::ConCheck)) { |
642 | logDomains << QLatin1String("CONCHECK" ); |
643 | } |
644 | if (domains.testFlag(flag: NetworkManager::Dcb)) { |
645 | logDomains << QLatin1String("DCB" ); |
646 | } |
647 | if (domains.testFlag(flag: NetworkManager::Dispatch)) { |
648 | logDomains << QLatin1String("DISPATCH" ); |
649 | } |
650 | } |
651 | iface.SetLogging(level: logLevel, domains: logDomains.join(sep: QLatin1Char(','))); |
652 | } |
653 | |
654 | NMStringMap NetworkManager::NetworkManagerPrivate::permissions() |
655 | { |
656 | return iface.GetPermissions(); |
657 | } |
658 | |
659 | NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::connectivity() const |
660 | { |
661 | return m_connectivity; |
662 | } |
663 | |
664 | QDBusPendingReply<uint> NetworkManager::NetworkManagerPrivate::checkConnectivity() |
665 | { |
666 | return iface.CheckConnectivity(); |
667 | } |
668 | |
669 | NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::primaryConnection() |
670 | { |
671 | return findRegisteredActiveConnection(uni: m_primaryConnection); |
672 | } |
673 | |
674 | NetworkManager::ActiveConnection::Ptr NetworkManager::NetworkManagerPrivate::activatingConnection() |
675 | { |
676 | return findRegisteredActiveConnection(uni: m_activatingConnection); |
677 | } |
678 | |
679 | NetworkManager::ConnectionSettings::ConnectionType NetworkManager::NetworkManagerPrivate::primaryConnectionType() |
680 | { |
681 | return checkVersion(x: 1, y: 0, z: 0) ? m_primaryConnectionType : NetworkManager::ConnectionSettings::Unknown; |
682 | } |
683 | |
684 | bool NetworkManager::NetworkManagerPrivate::isStartingUp() const |
685 | { |
686 | return iface.startup(); |
687 | } |
688 | |
689 | NetworkManager::Device::MeteredStatus NetworkManager::NetworkManagerPrivate::metered() const |
690 | { |
691 | return checkVersion(x: 1, y: 0, z: 6) ? m_metered : NetworkManager::Device::UnknownStatus; |
692 | } |
693 | |
694 | NetworkManager::DnsConfiguration NetworkManager::NetworkManagerPrivate::globalDnsConfiguration() const |
695 | { |
696 | return m_globalDnsConfiguration; |
697 | } |
698 | |
699 | void NetworkManager::NetworkManagerPrivate::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration) |
700 | { |
701 | m_globalDnsConfiguration = configuration; |
702 | iface.setGlobalDnsConfiguration(m_globalDnsConfiguration.toMap()); |
703 | } |
704 | |
705 | bool NetworkManager::NetworkManagerPrivate::isConnectivityCheckAvailable() const |
706 | { |
707 | return m_isConnectivityCheckAvailable; |
708 | } |
709 | |
710 | bool NetworkManager::NetworkManagerPrivate::isConnectivityCheckEnabled() const |
711 | { |
712 | return m_isConnectivityCheckEnabled; |
713 | } |
714 | |
715 | QString NetworkManager::NetworkManagerPrivate::connectivityCheckUri() const |
716 | { |
717 | return m_connectivityCheckUri; |
718 | } |
719 | |
720 | void NetworkManager::NetworkManagerPrivate::onDeviceAdded(const QDBusObjectPath &objpath) |
721 | { |
722 | // qCDebug(NMQT); |
723 | if (!networkInterfaceMap.contains(key: objpath.path())) { |
724 | networkInterfaceMap.insert(key: objpath.path(), value: Device::Ptr()); |
725 | Q_EMIT deviceAdded(uni: objpath.path()); |
726 | } |
727 | } |
728 | |
729 | void NetworkManager::NetworkManagerPrivate::onDeviceRemoved(const QDBusObjectPath &objpath) |
730 | { |
731 | // qCDebug(NMQT); |
732 | networkInterfaceMap.remove(key: objpath.path()); |
733 | Q_EMIT deviceRemoved(uni: objpath.path()); |
734 | } |
735 | |
736 | void NetworkManager::NetworkManagerPrivate::connectivityChanged(uint connectivity) |
737 | { |
738 | NetworkManager::Connectivity newConnectivity = convertConnectivity(connectivity); |
739 | if (m_connectivity != newConnectivity) { |
740 | m_connectivity = newConnectivity; |
741 | Q_EMIT Notifier::connectivityChanged(connectivity: newConnectivity); |
742 | } |
743 | } |
744 | |
745 | void NetworkManager::NetworkManagerPrivate::stateChanged(uint state) |
746 | { |
747 | NetworkManager::Status newStatus = convertNMState(state); |
748 | if (nmState != newStatus) { |
749 | nmState = newStatus; |
750 | Q_EMIT Notifier::statusChanged(status: newStatus); |
751 | } |
752 | } |
753 | |
754 | void NetworkManager::NetworkManagerPrivate::dbusPropertiesChanged(const QString &interfaceName, |
755 | const QVariantMap &properties, |
756 | const QStringList &invalidatedProperties) |
757 | { |
758 | Q_UNUSED(invalidatedProperties); |
759 | if (interfaceName == QLatin1String("org.freedesktop.NetworkManager" )) { |
760 | propertiesChanged(changedProperties: properties); |
761 | } |
762 | } |
763 | |
764 | void NetworkManager::NetworkManagerPrivate::propertiesChanged(const QVariantMap &changedProperties) |
765 | { |
766 | // qCDebug(NMQT) << Q_FUNC_INFO << changedProperties; |
767 | |
768 | QVariantMap::const_iterator it = changedProperties.constBegin(); |
769 | while (it != changedProperties.constEnd()) { |
770 | const QString property = it.key(); |
771 | if (property == QLatin1String("ActiveConnections" )) { |
772 | const QList<QDBusObjectPath> activePaths = qdbus_cast<QList<QDBusObjectPath>>(v: *it); |
773 | if (activePaths.isEmpty()) { |
774 | QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin(); |
775 | while (it != m_activeConnections.constEnd()) { |
776 | Q_EMIT activeConnectionRemoved(path: it.key()); |
777 | ++it; |
778 | } |
779 | m_activeConnections.clear(); |
780 | } else { |
781 | QStringList knownConnections = m_activeConnections.keys(); |
782 | for (const QDBusObjectPath &ac : activePaths) { |
783 | if (!m_activeConnections.contains(key: ac.path())) { |
784 | m_activeConnections.insert(key: ac.path(), value: NetworkManager::ActiveConnection::Ptr()); |
785 | Q_EMIT activeConnectionAdded(path: ac.path()); |
786 | } else { |
787 | knownConnections.removeOne(t: ac.path()); |
788 | } |
789 | // qCDebug(NMQT) << " " << ac.path(); |
790 | } |
791 | for (const QString &path : std::as_const(t&: knownConnections)) { |
792 | m_activeConnections.remove(key: path); |
793 | Q_EMIT activeConnectionRemoved(path); |
794 | } |
795 | } |
796 | Q_EMIT activeConnectionsChanged(); |
797 | } else if (property == QLatin1String("NetworkingEnabled" )) { |
798 | m_isNetworkingEnabled = it->toBool(); |
799 | qCDebug(NMQT) << property << m_isNetworkingEnabled; |
800 | Q_EMIT networkingEnabledChanged(m_isNetworkingEnabled); |
801 | } else if (property == QLatin1String("WirelessHardwareEnabled" )) { |
802 | m_isWirelessHardwareEnabled = it->toBool(); |
803 | qCDebug(NMQT) << property << m_isWirelessHardwareEnabled; |
804 | Q_EMIT wirelessHardwareEnabledChanged(m_isWirelessHardwareEnabled); |
805 | } else if (property == QLatin1String("WirelessEnabled" )) { |
806 | m_isWirelessEnabled = it->toBool(); |
807 | qCDebug(NMQT) << property << m_isWirelessEnabled; |
808 | Q_EMIT wirelessEnabledChanged(m_isWirelessEnabled); |
809 | } else if (property == QLatin1String("WwanHardwareEnabled" )) { |
810 | m_isWwanHardwareEnabled = it->toBool(); |
811 | qCDebug(NMQT) << property << m_isWwanHardwareEnabled; |
812 | Q_EMIT wwanHardwareEnabledChanged(m_isWwanHardwareEnabled); |
813 | } else if (property == QLatin1String("WwanEnabled" )) { |
814 | m_isWwanEnabled = it->toBool(); |
815 | qCDebug(NMQT) << property << m_isWwanEnabled; |
816 | Q_EMIT wwanEnabledChanged(m_isWwanEnabled); |
817 | } else if (property == QLatin1String("WimaxHardwareEnabled" )) { |
818 | m_isWimaxHardwareEnabled = it->toBool(); |
819 | qCDebug(NMQT) << property << m_isWimaxHardwareEnabled; |
820 | Q_EMIT wimaxHardwareEnabledChanged(m_isWimaxHardwareEnabled); |
821 | } else if (property == QLatin1String("WimaxEnabled" )) { |
822 | m_isWimaxEnabled = it->toBool(); |
823 | qCDebug(NMQT) << property << m_isWimaxEnabled; |
824 | Q_EMIT wimaxEnabledChanged(m_isWimaxEnabled); |
825 | } else if (property == QLatin1String("Version" )) { |
826 | m_version = it->toString(); |
827 | parseVersion(version: m_version); |
828 | } else if (property == QLatin1String("State" )) { |
829 | stateChanged(state: it->toUInt()); |
830 | } else if (property == QLatin1String("Connectivity" )) { |
831 | connectivityChanged(connectivity: it->toUInt()); |
832 | } else if (property == QLatin1String("PrimaryConnection" )) { |
833 | m_primaryConnection = it->value<QDBusObjectPath>().path(); |
834 | Q_EMIT primaryConnectionChanged(uni: m_primaryConnection); |
835 | } else if (property == QLatin1String("ActivatingConnection" )) { |
836 | m_activatingConnection = it->value<QDBusObjectPath>().path(); |
837 | Q_EMIT activatingConnectionChanged(uni: m_activatingConnection); |
838 | } else if (property == QLatin1String("PrimaryConnectionType" )) { |
839 | m_primaryConnectionType = NetworkManager::ConnectionSettings::typeFromString(typeString: it->toString()); |
840 | Q_EMIT primaryConnectionTypeChanged(type: m_primaryConnectionType); |
841 | } else if (property == QLatin1String("Startup" )) { |
842 | Q_EMIT isStartingUpChanged(); |
843 | } else if (property == QLatin1String("Metered" )) { |
844 | m_metered = (NetworkManager::Device::MeteredStatus)it->toUInt(); |
845 | Q_EMIT meteredChanged(metered: m_metered); |
846 | } else if (property == QLatin1String("GlobalDnsConfiguration" )) { |
847 | m_globalDnsConfiguration.fromMap(map: qdbus_cast<QVariantMap>(v: *it)); |
848 | Q_EMIT globalDnsConfigurationChanged(configuration: m_globalDnsConfiguration); |
849 | } else if (property == QLatin1String("ConnectivityCheckAvailable" )) { |
850 | m_isConnectivityCheckAvailable = it->toBool(); |
851 | qCDebug(NMQT) << property << m_isConnectivityCheckAvailable; |
852 | Q_EMIT isConnectivityCheckAvailableChanged(m_isConnectivityCheckAvailable); |
853 | } else if (property == QLatin1String("ConnectivityCheckEnabled" )) { |
854 | m_isConnectivityCheckEnabled = it->toBool(); |
855 | qCDebug(NMQT) << property << m_isConnectivityCheckEnabled; |
856 | Q_EMIT isConnectivityCheckEnabledChanged(m_isConnectivityCheckEnabled); |
857 | } else if (property == QLatin1String("ConnectivityCheckUri" )) { |
858 | m_connectivityCheckUri = it->toString().trimmed(); |
859 | qCDebug(NMQT) << property << m_connectivityCheckUri; |
860 | Q_EMIT connectivityCheckUriChanged(m_connectivityCheckUri); |
861 | } else { |
862 | qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property; |
863 | } |
864 | ++it; |
865 | } |
866 | } |
867 | |
868 | NetworkManager::Connectivity NetworkManager::NetworkManagerPrivate::convertConnectivity(uint connectivity) |
869 | { |
870 | NetworkManager::Connectivity convertedConnectivity = NetworkManager::UnknownConnectivity; |
871 | switch (connectivity) { |
872 | case NM_CONNECTIVITY_UNKNOWN: |
873 | convertedConnectivity = NetworkManager::UnknownConnectivity; |
874 | break; |
875 | case NM_CONNECTIVITY_NONE: |
876 | convertedConnectivity = NetworkManager::NoConnectivity; |
877 | break; |
878 | case NM_CONNECTIVITY_PORTAL: |
879 | convertedConnectivity = NetworkManager::Portal; |
880 | break; |
881 | case NM_CONNECTIVITY_LIMITED: |
882 | convertedConnectivity = NetworkManager::Limited; |
883 | break; |
884 | case NM_CONNECTIVITY_FULL: |
885 | convertedConnectivity = NetworkManager::Full; |
886 | break; |
887 | } |
888 | return convertedConnectivity; |
889 | } |
890 | |
891 | NetworkManager::Status NetworkManager::NetworkManagerPrivate::convertNMState(uint state) |
892 | { |
893 | NetworkManager::Status status = NetworkManager::Unknown; |
894 | switch (state) { |
895 | case NM_STATE_UNKNOWN: |
896 | status = NetworkManager::Unknown; |
897 | break; |
898 | case NM_STATE_ASLEEP: |
899 | status = NetworkManager::Asleep; |
900 | break; |
901 | case NM_STATE_DISCONNECTED: |
902 | status = NetworkManager::Disconnected; |
903 | break; |
904 | case NM_STATE_DISCONNECTING: |
905 | status = NetworkManager::Disconnecting; |
906 | break; |
907 | case NM_STATE_CONNECTING: |
908 | status = NetworkManager::Connecting; |
909 | break; |
910 | case NM_STATE_CONNECTED_LOCAL: |
911 | status = NetworkManager::ConnectedLinkLocal; |
912 | break; |
913 | case NM_STATE_CONNECTED_SITE: |
914 | status = NetworkManager::ConnectedSiteOnly; |
915 | break; |
916 | case NM_STATE_CONNECTED_GLOBAL: |
917 | status = NetworkManager::Connected; |
918 | break; |
919 | } |
920 | return status; |
921 | } |
922 | |
923 | void NetworkManager::NetworkManagerPrivate::dbusInterfacesAdded(const QDBusObjectPath &path, const QVariantMap &addedInterfaces) |
924 | { |
925 | Q_UNUSED(path); |
926 | |
927 | if (!addedInterfaces.contains(key: NetworkManagerPrivate::DBUS_DAEMON_INTERFACE)) { |
928 | return; |
929 | } |
930 | |
931 | daemonRegistered(); |
932 | } |
933 | |
934 | void NetworkManager::NetworkManagerPrivate::daemonRegistered() |
935 | { |
936 | if (iface.version().isEmpty()) { |
937 | // If this call fails, we've probably been called from ServiceRegistered on an old NM, |
938 | // and the interface isn't ready yet. Just exit and hope we get called again on InterfacesAdded. |
939 | return; |
940 | } |
941 | |
942 | init(); |
943 | Q_EMIT serviceAppeared(); |
944 | } |
945 | |
946 | void NetworkManager::NetworkManagerPrivate::daemonUnregistered() |
947 | { |
948 | stateChanged(state: NM_STATE_UNKNOWN); |
949 | QMap<QString, Device::Ptr>::const_iterator i = networkInterfaceMap.constBegin(); |
950 | while (i != networkInterfaceMap.constEnd()) { |
951 | Q_EMIT deviceRemoved(uni: i.key()); |
952 | ++i; |
953 | } |
954 | networkInterfaceMap.clear(); |
955 | |
956 | QMap<QString, ActiveConnection::Ptr>::const_iterator it = m_activeConnections.constBegin(); |
957 | while (it != m_activeConnections.constEnd()) { |
958 | Q_EMIT activeConnectionRemoved(path: it.key()); |
959 | ++it; |
960 | } |
961 | m_activeConnections.clear(); |
962 | |
963 | qobject_cast<SettingsPrivate *>(object: settingsNotifier())->daemonUnregistered(); |
964 | |
965 | Q_EMIT activeConnectionsChanged(); |
966 | Q_EMIT serviceDisappeared(); |
967 | } |
968 | |
969 | NetworkManager::ActiveConnection::List NetworkManager::NetworkManagerPrivate::activeConnections() |
970 | { |
971 | NetworkManager::ActiveConnection::List list; |
972 | |
973 | // Take a copy because findRegisteredActiveConnection() may change m_activeConnections. |
974 | const QStringList keyList = m_activeConnections.keys(); |
975 | for (const QString &key : keyList) { |
976 | NetworkManager::ActiveConnection::Ptr activeConnection = findRegisteredActiveConnection(uni: key); |
977 | |
978 | if (activeConnection) { |
979 | list << activeConnection; |
980 | } |
981 | } |
982 | return list; |
983 | } |
984 | |
985 | QStringList NetworkManager::NetworkManagerPrivate::activeConnectionsPaths() const |
986 | { |
987 | return m_activeConnections.keys(); |
988 | } |
989 | |
990 | QDBusPendingReply<QString, QString> NetworkManager::NetworkManagerPrivate::getLogging() |
991 | { |
992 | return iface.GetLogging(); |
993 | } |
994 | |
995 | QString NetworkManager::version() |
996 | { |
997 | return globalNetworkManager->version(); |
998 | } |
999 | |
1000 | int NetworkManager::compareVersion(const QString &version) |
1001 | { |
1002 | return globalNetworkManager->compareVersion(version); |
1003 | } |
1004 | |
1005 | int NetworkManager::compareVersion(const int x, const int y, const int z) |
1006 | { |
1007 | return globalNetworkManager->compareVersion(x, y, z); |
1008 | } |
1009 | |
1010 | bool NetworkManager::checkVersion(const int x, const int y, const int z) |
1011 | { |
1012 | return globalNetworkManager->checkVersion(x, y, z); |
1013 | } |
1014 | |
1015 | NetworkManager::Status NetworkManager::status() |
1016 | { |
1017 | return globalNetworkManager->status(); |
1018 | } |
1019 | |
1020 | NetworkManager::ActiveConnection::List NetworkManager::activeConnections() |
1021 | { |
1022 | return globalNetworkManager->activeConnections(); |
1023 | } |
1024 | |
1025 | QStringList NetworkManager::activeConnectionsPaths() |
1026 | { |
1027 | return globalNetworkManager->activeConnectionsPaths(); |
1028 | } |
1029 | |
1030 | NetworkManager::ActiveConnection::Ptr NetworkManager::findActiveConnection(const QString &uni) |
1031 | { |
1032 | return globalNetworkManager->findRegisteredActiveConnection(uni); |
1033 | } |
1034 | |
1035 | NetworkManager::Device::List NetworkManager::networkInterfaces() |
1036 | { |
1037 | return globalNetworkManager->networkInterfaces(); |
1038 | } |
1039 | |
1040 | bool NetworkManager::isNetworkingEnabled() |
1041 | { |
1042 | return globalNetworkManager->isNetworkingEnabled(); |
1043 | } |
1044 | |
1045 | bool NetworkManager::isWirelessEnabled() |
1046 | { |
1047 | return globalNetworkManager->isWirelessEnabled(); |
1048 | } |
1049 | |
1050 | bool NetworkManager::isWirelessHardwareEnabled() |
1051 | { |
1052 | return globalNetworkManager->isWirelessHardwareEnabled(); |
1053 | } |
1054 | |
1055 | NetworkManager::Device::Ptr NetworkManager::findNetworkInterface(const QString &uni) |
1056 | { |
1057 | return globalNetworkManager->findRegisteredNetworkInterface(uni); |
1058 | } |
1059 | |
1060 | NetworkManager::Device::Ptr NetworkManager::findDeviceByIpFace(const QString &iface) |
1061 | { |
1062 | return globalNetworkManager->findDeviceByIpIface(iface); |
1063 | } |
1064 | |
1065 | QDBusPendingReply<QDBusObjectPath, QDBusObjectPath> |
1066 | NetworkManager::addAndActivateConnection(const NMVariantMapMap &connection, const QString &interfaceUni, const QString &connectionParameter) |
1067 | { |
1068 | return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter); |
1069 | } |
1070 | |
1071 | QDBusPendingReply<QDBusObjectPath, QDBusObjectPath, QVariantMap> NetworkManager::addAndActivateConnection2(const NMVariantMapMap &connection, |
1072 | const QString &interfaceUni, |
1073 | const QString &connectionParameter, |
1074 | const QVariantMap &options) |
1075 | { |
1076 | if (checkVersion(x: 1, y: 16, z: 0)) { |
1077 | return globalNetworkManager->addAndActivateConnection2(connection, interfaceUni, connectionParameter, options); |
1078 | } else { |
1079 | return globalNetworkManager->addAndActivateConnection(connection, interfaceUni, connectionParameter); |
1080 | } |
1081 | } |
1082 | |
1083 | QDBusPendingReply<QDBusObjectPath> |
1084 | NetworkManager::activateConnection(const QString &connectionUni, const QString &interfaceUni, const QString &connectionParameter) |
1085 | { |
1086 | return globalNetworkManager->activateConnection(connectionUni, interfaceUni, connectionParameter); |
1087 | } |
1088 | |
1089 | QDBusPendingReply<> NetworkManager::deactivateConnection(const QString &activeConnectionPath) |
1090 | { |
1091 | return globalNetworkManager->deactivateConnection(activeConnectionPath); |
1092 | } |
1093 | |
1094 | QDBusPendingReply<QString, QString> NetworkManager::getLogging() |
1095 | { |
1096 | return globalNetworkManager->getLogging(); |
1097 | } |
1098 | |
1099 | void NetworkManager::setNetworkingEnabled(bool enabled) |
1100 | { |
1101 | globalNetworkManager->setNetworkingEnabled(enabled); |
1102 | } |
1103 | |
1104 | void NetworkManager::setWirelessEnabled(bool enabled) |
1105 | { |
1106 | globalNetworkManager->setWirelessEnabled(enabled); |
1107 | } |
1108 | |
1109 | bool NetworkManager::isWwanEnabled() |
1110 | { |
1111 | return globalNetworkManager->isWwanEnabled(); |
1112 | } |
1113 | |
1114 | bool NetworkManager::isWwanHardwareEnabled() |
1115 | { |
1116 | return globalNetworkManager->isWwanHardwareEnabled(); |
1117 | } |
1118 | |
1119 | void NetworkManager::setWwanEnabled(bool enabled) |
1120 | { |
1121 | globalNetworkManager->setWwanEnabled(enabled); |
1122 | } |
1123 | |
1124 | bool NetworkManager::isWimaxEnabled() |
1125 | { |
1126 | return globalNetworkManager->isWimaxEnabled(); |
1127 | } |
1128 | |
1129 | bool NetworkManager::isWimaxHardwareEnabled() |
1130 | { |
1131 | return globalNetworkManager->isWimaxHardwareEnabled(); |
1132 | } |
1133 | |
1134 | void NetworkManager::setWimaxEnabled(bool enabled) |
1135 | { |
1136 | globalNetworkManager->setWimaxEnabled(enabled); |
1137 | } |
1138 | |
1139 | void NetworkManager::sleep(bool sleep) |
1140 | { |
1141 | globalNetworkManager->sleep(sleep); |
1142 | } |
1143 | |
1144 | void NetworkManager::setLogging(NetworkManager::LogLevel level, NetworkManager::LogDomains domains) |
1145 | { |
1146 | globalNetworkManager->setLogging(level, domains); |
1147 | } |
1148 | |
1149 | NMStringMap NetworkManager::permissions() |
1150 | { |
1151 | return globalNetworkManager->permissions(); |
1152 | } |
1153 | |
1154 | NetworkManager::Device::Types NetworkManager::supportedInterfaceTypes() |
1155 | { |
1156 | return globalNetworkManager->supportedInterfaceTypes(); |
1157 | } |
1158 | |
1159 | NetworkManager::Connectivity NetworkManager::connectivity() |
1160 | { |
1161 | return globalNetworkManager->connectivity(); |
1162 | } |
1163 | |
1164 | QDBusPendingReply<uint> NetworkManager::checkConnectivity() |
1165 | { |
1166 | return globalNetworkManager->checkConnectivity(); |
1167 | } |
1168 | |
1169 | NetworkManager::ActiveConnection::Ptr NetworkManager::primaryConnection() |
1170 | { |
1171 | return globalNetworkManager->primaryConnection(); |
1172 | } |
1173 | |
1174 | NetworkManager::ActiveConnection::Ptr NetworkManager::activatingConnection() |
1175 | { |
1176 | return globalNetworkManager->activatingConnection(); |
1177 | } |
1178 | |
1179 | NetworkManager::ConnectionSettings::ConnectionType NetworkManager::primaryConnectionType() |
1180 | { |
1181 | return globalNetworkManager->primaryConnectionType(); |
1182 | } |
1183 | |
1184 | bool NetworkManager::isStartingUp() |
1185 | { |
1186 | return globalNetworkManager->isStartingUp(); |
1187 | } |
1188 | |
1189 | NetworkManager::Device::MeteredStatus NetworkManager::metered() |
1190 | { |
1191 | return globalNetworkManager->metered(); |
1192 | } |
1193 | |
1194 | NetworkManager::DnsConfiguration NetworkManager::globalDnsConfiguration() |
1195 | { |
1196 | return globalNetworkManager->globalDnsConfiguration(); |
1197 | } |
1198 | |
1199 | void NetworkManager::setGlobalDnsConfiguration(const NetworkManager::DnsConfiguration &configuration) |
1200 | { |
1201 | globalNetworkManager->setGlobalDnsConfiguration(configuration); |
1202 | } |
1203 | |
1204 | bool NetworkManager::isConnectivityCheckAvailable() |
1205 | { |
1206 | return globalNetworkManager->isConnectivityCheckAvailable(); |
1207 | } |
1208 | |
1209 | bool NetworkManager::isConnectivityCheckEnabled() |
1210 | { |
1211 | return globalNetworkManager->isConnectivityCheckEnabled(); |
1212 | } |
1213 | |
1214 | QString NetworkManager::connectivityCheckUri() |
1215 | { |
1216 | return globalNetworkManager->connectivityCheckUri(); |
1217 | } |
1218 | |
1219 | NetworkManager::Notifier *NetworkManager::notifier() |
1220 | { |
1221 | return globalNetworkManager; |
1222 | } |
1223 | |
1224 | #include "moc_manager.cpp" |
1225 | #include "moc_manager_p.cpp" |
1226 | |