1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the plugins of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | // see comment in ../platformdefs_win.h. |
41 | #define WIN32_LEAN_AND_MEAN 1 |
42 | |
43 | #include "qgenericengine.h" |
44 | #include "../qnetworksession_impl.h" |
45 | |
46 | #include <QtNetwork/private/qnetworkconfiguration_p.h> |
47 | |
48 | #include <QtCore/qthread.h> |
49 | #include <QtCore/qmutex.h> |
50 | #include <QtCore/qcoreapplication.h> |
51 | #include <QtCore/qstringlist.h> |
52 | |
53 | #include <QtCore/qdebug.h> |
54 | #include <QtCore/private/qcoreapplication_p.h> |
55 | |
56 | #if defined(Q_OS_WIN32) |
57 | // PMIB_TCPTABLE2 is only available since Vista |
58 | #if _WIN32_WINNT < 0x0601 |
59 | # undef _WIN32_WINNT |
60 | # define _WIN32_WINNT 0x0601 |
61 | #endif // _WIN32_WINNT < 0x0601 |
62 | #include "../platformdefs_win.h" |
63 | #include <iphlpapi.h> |
64 | #endif |
65 | |
66 | #ifdef Q_OS_WINRT |
67 | #include <qfunctions_winrt.h> |
68 | |
69 | #include <wrl.h> |
70 | #include <windows.foundation.h> |
71 | #include <windows.foundation.collections.h> |
72 | #include <windows.networking.connectivity.h> |
73 | |
74 | using namespace Microsoft::WRL; |
75 | using namespace Microsoft::WRL::Wrappers; |
76 | using namespace ABI::Windows::Foundation; |
77 | using namespace ABI::Windows::Foundation::Collections; |
78 | using namespace ABI::Windows::Networking; |
79 | using namespace ABI::Windows::Networking::Connectivity; |
80 | #endif // Q_OS_WINRT |
81 | |
82 | // needed as interface is used as parameter name in qGetInterfaceType |
83 | #undef interface |
84 | |
85 | #ifdef Q_OS_LINUX |
86 | #include <sys/socket.h> |
87 | #include <sys/ioctl.h> |
88 | #include <net/if.h> |
89 | #include <net/if_arp.h> |
90 | #include <unistd.h> |
91 | #endif |
92 | |
93 | QT_BEGIN_NAMESPACE |
94 | |
95 | #ifndef QT_NO_NETWORKINTERFACE |
96 | static QNetworkConfiguration::BearerType qGetInterfaceType(const QString &interface) |
97 | { |
98 | #if defined(Q_OS_WIN32) |
99 | // QNetworkInterface::name returns a more friendly name on Windows. That name is not |
100 | // accepted as an identifier for CreateFile so we have to obtain the Luid. |
101 | std::wstring buf = interface.toStdWString(); |
102 | if (buf.size() == 0) |
103 | return QNetworkConfiguration::BearerUnknown; |
104 | |
105 | NET_LUID luid; |
106 | NETIO_STATUS status = ConvertInterfaceNameToLuidW(buf.c_str(), &luid); |
107 | if (status != NO_ERROR) |
108 | return QNetworkConfiguration::BearerUnknown; |
109 | |
110 | switch (luid.Info.IfType) { |
111 | case IF_TYPE_ETHERNET_CSMACD: |
112 | case IF_TYPE_ISO88025_TOKENRING: |
113 | case IF_TYPE_PPP: |
114 | case IF_TYPE_SOFTWARE_LOOPBACK: |
115 | return QNetworkConfiguration::BearerEthernet; |
116 | case IF_TYPE_IEEE80211: |
117 | return QNetworkConfiguration::BearerWLAN; |
118 | case IF_TYPE_ATM: |
119 | case IF_TYPE_IEEE1394: |
120 | case IF_TYPE_OTHER: |
121 | case IF_TYPE_TUNNEL: |
122 | return QNetworkConfiguration::BearerUnknown; |
123 | default: |
124 | #ifdef BEARER_MANAGEMENT_DEBUG |
125 | qDebug() << "Interface Type" << luid.Info.IfType; |
126 | #endif |
127 | return QNetworkConfiguration::BearerUnknown; |
128 | } |
129 | return QNetworkConfiguration::BearerUnknown; |
130 | |
131 | #elif defined(Q_OS_LINUX) |
132 | int sock = socket(AF_INET, SOCK_DGRAM, protocol: 0); |
133 | |
134 | ifreq request; |
135 | strncpy(dest: request.ifr_name, src: interface.toLocal8Bit().data(), n: sizeof(request.ifr_name) - 1); |
136 | request.ifr_name[sizeof(request.ifr_name) - 1] = '\0'; |
137 | int result = ioctl(fd: sock, SIOCGIFHWADDR, &request); |
138 | close(fd: sock); |
139 | |
140 | if (result >= 0 && request.ifr_hwaddr.sa_family == ARPHRD_ETHER) |
141 | return QNetworkConfiguration::BearerEthernet; |
142 | #elif defined(Q_OS_WINRT) |
143 | ComPtr<INetworkInformationStatics> networkInfoStatics; |
144 | HRESULT hr = GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &networkInfoStatics); |
145 | Q_ASSERT_SUCCEEDED(hr); |
146 | ComPtr<IVectorView<ConnectionProfile *>> connectionProfiles; |
147 | hr = networkInfoStatics->GetConnectionProfiles(&connectionProfiles); |
148 | Q_ASSERT_SUCCEEDED(hr); |
149 | if (!connectionProfiles) |
150 | return QNetworkConfiguration::BearerUnknown; |
151 | |
152 | unsigned int size; |
153 | hr = connectionProfiles->get_Size(&size); |
154 | Q_ASSERT_SUCCEEDED(hr); |
155 | for (unsigned int i = 0; i < size; ++i) { |
156 | ComPtr<IConnectionProfile> profile; |
157 | hr = connectionProfiles->GetAt(i, &profile); |
158 | Q_ASSERT_SUCCEEDED(hr); |
159 | |
160 | ComPtr<INetworkAdapter> adapter; |
161 | hr = profile->get_NetworkAdapter(&adapter); |
162 | // Indicates that no internet connection is available/the device is in airplane mode |
163 | if (hr == E_INVALIDARG) |
164 | return QNetworkConfiguration::BearerUnknown; |
165 | Q_ASSERT_SUCCEEDED(hr); |
166 | GUID id; |
167 | hr = adapter->get_NetworkAdapterId(&id); |
168 | Q_ASSERT_SUCCEEDED(hr); |
169 | OLECHAR adapterName[39]={0}; |
170 | int length = StringFromGUID2(id, adapterName, 39); |
171 | // "length - 1" as we have to remove the null terminator from it in order to compare |
172 | if (!length |
173 | || QString::fromRawData(reinterpret_cast<const QChar *>(adapterName), length - 1) != interface) |
174 | continue; |
175 | |
176 | ComPtr<IConnectionProfile2> profile2; |
177 | hr = profile.As(&profile2); |
178 | Q_ASSERT_SUCCEEDED(hr); |
179 | boolean isWLan; |
180 | hr = profile2->get_IsWlanConnectionProfile(&isWLan); |
181 | Q_ASSERT_SUCCEEDED(hr); |
182 | if (isWLan) |
183 | return QNetworkConfiguration::BearerWLAN; |
184 | |
185 | boolean isWWan; |
186 | hr = profile2->get_IsWwanConnectionProfile(&isWWan); |
187 | Q_ASSERT_SUCCEEDED(hr); |
188 | if (isWWan) { |
189 | ComPtr<IWwanConnectionProfileDetails> details; |
190 | hr = profile2->get_WwanConnectionProfileDetails(&details); |
191 | Q_ASSERT_SUCCEEDED(hr); |
192 | WwanDataClass dataClass; |
193 | hr = details->GetCurrentDataClass(&dataClass); |
194 | Q_ASSERT_SUCCEEDED(hr); |
195 | switch (dataClass) { |
196 | case WwanDataClass_Edge: |
197 | case WwanDataClass_Gprs: |
198 | return QNetworkConfiguration::Bearer2G; |
199 | case WwanDataClass_Umts: |
200 | return QNetworkConfiguration::BearerWCDMA; |
201 | case WwanDataClass_LteAdvanced: |
202 | return QNetworkConfiguration::BearerLTE; |
203 | case WwanDataClass_Hsdpa: |
204 | case WwanDataClass_Hsupa: |
205 | return QNetworkConfiguration::BearerHSPA; |
206 | case WwanDataClass_Cdma1xRtt: |
207 | case WwanDataClass_Cdma3xRtt: |
208 | case WwanDataClass_CdmaUmb: |
209 | return QNetworkConfiguration::BearerCDMA2000; |
210 | case WwanDataClass_Cdma1xEvdv: |
211 | case WwanDataClass_Cdma1xEvdo: |
212 | case WwanDataClass_Cdma1xEvdoRevA: |
213 | case WwanDataClass_Cdma1xEvdoRevB: |
214 | return QNetworkConfiguration::BearerEVDO; |
215 | case WwanDataClass_Custom: |
216 | case WwanDataClass_None: |
217 | default: |
218 | return QNetworkConfiguration::BearerUnknown; |
219 | } |
220 | } |
221 | return QNetworkConfiguration::BearerEthernet; |
222 | } |
223 | #else |
224 | Q_UNUSED(interface); |
225 | #endif |
226 | |
227 | return QNetworkConfiguration::BearerUnknown; |
228 | } |
229 | #endif |
230 | |
231 | QGenericEngine::QGenericEngine(QObject *parent) |
232 | : QBearerEngineImpl(parent) |
233 | { |
234 | //workaround for deadlock in __cxa_guard_acquire with webkit on macos x |
235 | //initialise the Q_GLOBAL_STATIC in same thread as the AtomicallyInitializedStatic |
236 | (void)QNetworkInterface::interfaceFromIndex(index: 0); |
237 | } |
238 | |
239 | QGenericEngine::~QGenericEngine() |
240 | { |
241 | } |
242 | |
243 | QString QGenericEngine::getInterfaceFromId(const QString &id) |
244 | { |
245 | QMutexLocker locker(&mutex); |
246 | |
247 | return configurationInterface.value(akey: id); |
248 | } |
249 | |
250 | bool QGenericEngine::hasIdentifier(const QString &id) |
251 | { |
252 | QMutexLocker locker(&mutex); |
253 | |
254 | return configurationInterface.contains(akey: id); |
255 | } |
256 | |
257 | void QGenericEngine::connectToId(const QString &id) |
258 | { |
259 | emit connectionError(id, error: OperationNotSupported); |
260 | } |
261 | |
262 | void QGenericEngine::disconnectFromId(const QString &id) |
263 | { |
264 | emit connectionError(id, error: OperationNotSupported); |
265 | } |
266 | |
267 | void QGenericEngine::initialize() |
268 | { |
269 | doRequestUpdate(); |
270 | } |
271 | |
272 | void QGenericEngine::requestUpdate() |
273 | { |
274 | doRequestUpdate(); |
275 | } |
276 | |
277 | void QGenericEngine::doRequestUpdate() |
278 | { |
279 | #ifndef QT_NO_NETWORKINTERFACE |
280 | QMutexLocker locker(&mutex); |
281 | |
282 | // Immediately after connecting with a wireless access point |
283 | // QNetworkInterface::allInterfaces() will sometimes return an empty list. Calling it again a |
284 | // second time results in a non-empty list. If we loose interfaces we will end up removing |
285 | // network configurations which will break current sessions. |
286 | QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces(); |
287 | if (interfaces.isEmpty()) |
288 | interfaces = QNetworkInterface::allInterfaces(); |
289 | |
290 | QStringList previous = accessPointConfigurations.keys(); |
291 | |
292 | // create configuration for each interface |
293 | while (!interfaces.isEmpty()) { |
294 | QNetworkInterface interface = interfaces.takeFirst(); |
295 | |
296 | if (!interface.isValid()) |
297 | continue; |
298 | |
299 | // ignore loopback interface |
300 | if (interface.flags() & QNetworkInterface::IsLoopBack) |
301 | continue; |
302 | |
303 | #ifndef Q_OS_WIN |
304 | // ignore WLAN interface handled in separate engine |
305 | if (qGetInterfaceType(interface: interface.name()) == QNetworkConfiguration::BearerWLAN) |
306 | continue; |
307 | #endif |
308 | |
309 | uint identifier; |
310 | if (interface.index()) |
311 | identifier = qHash(key: QLatin1String("generic:" ) + QString::number(interface.index())); |
312 | else |
313 | identifier = qHash(key: QLatin1String("generic:" ) + interface.hardwareAddress()); |
314 | |
315 | const QString id = QString::number(identifier); |
316 | |
317 | previous.removeAll(t: id); |
318 | |
319 | QString name = interface.humanReadableName(); |
320 | if (name.isEmpty()) |
321 | name = interface.name(); |
322 | |
323 | QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined; |
324 | if ((interface.flags() & QNetworkInterface::IsRunning) && !interface.addressEntries().isEmpty()) |
325 | state |= QNetworkConfiguration::Active; |
326 | |
327 | if (accessPointConfigurations.contains(akey: id)) { |
328 | QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(akey: id); |
329 | |
330 | bool changed = false; |
331 | |
332 | ptr->mutex.lock(); |
333 | |
334 | if (!ptr->isValid) { |
335 | ptr->isValid = true; |
336 | changed = true; |
337 | } |
338 | |
339 | if (ptr->name != name) { |
340 | ptr->name = name; |
341 | changed = true; |
342 | } |
343 | |
344 | if (ptr->id != id) { |
345 | ptr->id = id; |
346 | changed = true; |
347 | } |
348 | |
349 | if (ptr->state != state) { |
350 | ptr->state = state; |
351 | changed = true; |
352 | } |
353 | |
354 | ptr->mutex.unlock(); |
355 | |
356 | if (changed) { |
357 | locker.unlock(); |
358 | emit configurationChanged(config: ptr); |
359 | locker.relock(); |
360 | } |
361 | } else { |
362 | QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate); |
363 | |
364 | ptr->name = name; |
365 | ptr->isValid = true; |
366 | ptr->id = id; |
367 | ptr->state = state; |
368 | ptr->type = QNetworkConfiguration::InternetAccessPoint; |
369 | ptr->bearerType = qGetInterfaceType(interface: interface.name()); |
370 | |
371 | accessPointConfigurations.insert(akey: id, avalue: ptr); |
372 | configurationInterface.insert(akey: id, avalue: interface.name()); |
373 | |
374 | locker.unlock(); |
375 | emit configurationAdded(config: ptr); |
376 | locker.relock(); |
377 | } |
378 | } |
379 | |
380 | while (!previous.isEmpty()) { |
381 | QNetworkConfigurationPrivatePointer ptr = |
382 | accessPointConfigurations.take(akey: previous.takeFirst()); |
383 | |
384 | configurationInterface.remove(akey: ptr->id); |
385 | |
386 | locker.unlock(); |
387 | emit configurationRemoved(config: ptr); |
388 | locker.relock(); |
389 | } |
390 | |
391 | locker.unlock(); |
392 | #endif |
393 | |
394 | emit updateCompleted(); |
395 | } |
396 | |
397 | QNetworkSession::State QGenericEngine::sessionStateForId(const QString &id) |
398 | { |
399 | QMutexLocker locker(&mutex); |
400 | |
401 | QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(akey: id); |
402 | |
403 | if (!ptr) |
404 | return QNetworkSession::Invalid; |
405 | |
406 | QMutexLocker configLocker(&ptr->mutex); |
407 | |
408 | if (!ptr->isValid) { |
409 | return QNetworkSession::Invalid; |
410 | } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) { |
411 | return QNetworkSession::Connected; |
412 | } else if ((ptr->state & QNetworkConfiguration::Discovered) == |
413 | QNetworkConfiguration::Discovered) { |
414 | return QNetworkSession::Disconnected; |
415 | } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) { |
416 | return QNetworkSession::NotAvailable; |
417 | } else if ((ptr->state & QNetworkConfiguration::Undefined) == |
418 | QNetworkConfiguration::Undefined) { |
419 | return QNetworkSession::NotAvailable; |
420 | } |
421 | |
422 | return QNetworkSession::Invalid; |
423 | } |
424 | |
425 | QNetworkConfigurationManager::Capabilities QGenericEngine::capabilities() const |
426 | { |
427 | return QNetworkConfigurationManager::ForcedRoaming; |
428 | } |
429 | |
430 | QNetworkSessionPrivate *QGenericEngine::createSessionBackend() |
431 | { |
432 | return new QNetworkSessionPrivateImpl; |
433 | } |
434 | |
435 | QNetworkConfigurationPrivatePointer QGenericEngine::defaultConfiguration() |
436 | { |
437 | return QNetworkConfigurationPrivatePointer(); |
438 | } |
439 | |
440 | |
441 | bool QGenericEngine::requiresPolling() const |
442 | { |
443 | return true; |
444 | } |
445 | |
446 | QT_END_NAMESPACE |
447 | |