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
74using namespace Microsoft::WRL;
75using namespace Microsoft::WRL::Wrappers;
76using namespace ABI::Windows::Foundation;
77using namespace ABI::Windows::Foundation::Collections;
78using namespace ABI::Windows::Networking;
79using 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
93QT_BEGIN_NAMESPACE
94
95#ifndef QT_NO_NETWORKINTERFACE
96static 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
231QGenericEngine::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
239QGenericEngine::~QGenericEngine()
240{
241}
242
243QString QGenericEngine::getInterfaceFromId(const QString &id)
244{
245 QMutexLocker locker(&mutex);
246
247 return configurationInterface.value(akey: id);
248}
249
250bool QGenericEngine::hasIdentifier(const QString &id)
251{
252 QMutexLocker locker(&mutex);
253
254 return configurationInterface.contains(akey: id);
255}
256
257void QGenericEngine::connectToId(const QString &id)
258{
259 emit connectionError(id, error: OperationNotSupported);
260}
261
262void QGenericEngine::disconnectFromId(const QString &id)
263{
264 emit connectionError(id, error: OperationNotSupported);
265}
266
267void QGenericEngine::initialize()
268{
269 doRequestUpdate();
270}
271
272void QGenericEngine::requestUpdate()
273{
274 doRequestUpdate();
275}
276
277void 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
397QNetworkSession::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
425QNetworkConfigurationManager::Capabilities QGenericEngine::capabilities() const
426{
427 return QNetworkConfigurationManager::ForcedRoaming;
428}
429
430QNetworkSessionPrivate *QGenericEngine::createSessionBackend()
431{
432 return new QNetworkSessionPrivateImpl;
433}
434
435QNetworkConfigurationPrivatePointer QGenericEngine::defaultConfiguration()
436{
437 return QNetworkConfigurationPrivatePointer();
438}
439
440
441bool QGenericEngine::requiresPolling() const
442{
443 return true;
444}
445
446QT_END_NAMESPACE
447

source code of qtbase/src/plugins/bearer/generic/qgenericengine.cpp