/*!
Constructs a QNetworkConfigurationManager with the given \a parent.
*/
QNetworkConfigurationManager::QNetworkConfigurationManager( QObject* parent )
: QObject(parent)
{
QNetworkConfigurationManagerPrivate* priv = connManager();
connect(priv, SIGNAL(configurationAdded(QNetworkConfiguration)),
this, SIGNAL(configurationAdded(QNetworkConfiguration)));
connect(priv, SIGNAL(configurationRemoved(QNetworkConfiguration)),
this, SIGNAL(configurationRemoved(QNetworkConfiguration)));
connect(priv, SIGNAL(configurationUpdateComplete()),
this, SIGNAL(updateCompleted()));
connect(priv, SIGNAL(onlineStateChanged(bool)),
this, SIGNAL(onlineStateChanged(bool)));
connect(priv, SIGNAL(configurationChanged(QNetworkConfiguration)),
this, SIGNAL(configurationChanged(QNetworkConfiguration)));
}
void QNetworkConfigurationManagerPrivate::deleteConfiguration(QString& iap_id)
{
/* Called when IAPs are deleted in db, in this case we do not scan
* or read all the IAPs from db because it might take too much power
* (multiple applications would need to scan and read all IAPs from db)
*/
if (accessPointConfigurations.contains(iap_id)) {
QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.take(iap_id);
if (priv.data()) {
priv->isValid = false;
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug() << "IAP" << iap_id << "was removed from storage.";
#endif
QNetworkConfiguration item;
item.d = priv;
emit configurationRemoved(item);
} else
qWarning("Configuration not found for IAP %s", iap_id.toAscii().data());
} else {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug("IAP: %s, already missing from the known list", iap_id.toAscii().data());
#endif
}
}
AsemanNetworkManager::AsemanNetworkManager(QObject *parent) :
QObject(parent)
{
p = new AsemanNetworkCheckerPrivate;
p->network = new QNetworkConfigurationManager(this);
p->defaultItem = new AsemanNetworkManagerItem(this);
p->updateTimer = new QTimer(this);
p->updateTimer->setInterval(1000);
p->updateTimer->start();
p->lastConfig = p->network->defaultConfiguration();
connect(p->network, SIGNAL(configurationAdded(QNetworkConfiguration)),
SLOT(configureAdded(QNetworkConfiguration)));
connect(p->network, SIGNAL(configurationChanged(QNetworkConfiguration)),
this, SLOT(configureChanged(QNetworkConfiguration)));
connect(p->network, SIGNAL(configurationRemoved(QNetworkConfiguration)),
SLOT(configureRemoved(QNetworkConfiguration)));
connect(p->network, SIGNAL(updateCompleted()), SLOT(updateCheck()));
connect(p->updateTimer, SIGNAL(timeout()), SLOT(updateCheck()));
foreach(const QNetworkConfiguration &config, p->network->allConfigurations())
configureAdded(config);
updateCheck();
}
AddressesModelManager::AddressesModelManager (BaseSettingsManager *bsm, int defaultPort, QObject *parent)
: QObject { parent }
, Model_ { new QStandardItemModel { this } }
, BSM_ { bsm }
{
Model_->setHorizontalHeaderLabels ({ tr ("Host"), tr ("Port") });
Model_->horizontalHeaderItem (0)->setData (DataSources::DataFieldType::Enum,
DataSources::DataSourceRole::FieldType);
Model_->horizontalHeaderItem (1)->setData (DataSources::DataFieldType::Integer,
DataSources::DataSourceRole::FieldType);
const auto confManager = new QNetworkConfigurationManager { this };
connect (confManager,
SIGNAL (configurationAdded (QNetworkConfiguration)),
this,
SLOT (updateAvailInterfaces ()));
connect (confManager,
SIGNAL (configurationRemoved (QNetworkConfiguration)),
this,
SLOT (updateAvailInterfaces ()));
connect (confManager,
SIGNAL (configurationChanged (QNetworkConfiguration)),
this,
SLOT (updateAvailInterfaces ()));
updateAvailInterfaces ();
const auto& addrs = BSM_->Property ("ListenAddresses",
QVariant::fromValue (GetLocalAddresses (defaultPort))).value<AddrList_t> ();
qDebug () << Q_FUNC_INFO << addrs;
for (const auto& addr : addrs)
AppendRow (addr);
}
BearerEx::BearerEx(QWidget* parent)
: QMainWindow(parent)
{
setupUi(this);
createMenus();
connect(&m_NetworkConfigurationManager, SIGNAL(updateCompleted()), this, SLOT(configurationsUpdateCompleted()));
connect(&m_NetworkConfigurationManager, SIGNAL(configurationAdded(QNetworkConfiguration)),
this, SLOT(configurationAdded(QNetworkConfiguration)));
connect(&m_NetworkConfigurationManager, SIGNAL(configurationRemoved(QNetworkConfiguration)),
this, SLOT(configurationRemoved(QNetworkConfiguration)));
connect(&m_NetworkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
this, SLOT(onlineStateChanged(bool)));
connect(&m_NetworkConfigurationManager, SIGNAL(configurationChanged(QNetworkConfiguration)),
this, SLOT(configurationChanged(QNetworkConfiguration)));
showConfigurations();
}
void QBBEngine::removeConfiguration(const QString &id)
{
QMutexLocker locker(&mutex);
QNetworkConfigurationPrivatePointer ptr =
accessPointConfigurations.take(id);
configurationInterface.remove(ptr->id);
locker.unlock();
Q_EMIT configurationRemoved(ptr);
}
void QIcdEngine::deleteConfiguration(const QString &iap_id)
{
QMutexLocker locker(&mutex);
/* Called when IAPs are deleted in db, in this case we do not scan
* or read all the IAPs from db because it might take too much power
* (multiple applications would need to scan and read all IAPs from db)
*/
QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(iap_id);
if (ptr) {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug() << "IAP" << iap_id << "was removed from storage.";
#endif
locker.unlock();
emit configurationRemoved(ptr);
} else {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug("IAP: %s, already missing from the known list", iap_id.toAscii().data());
#endif
}
}
void QNetworkConfigurationManagerPrivate::configurationRemoved(const QString &id)
{
if (!accessPointConfigurations.contains(id))
return;
QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
accessPointConfigurations.take(id);
configurationEngine.remove(id);
ptr.data()->isValid = false;
if (!firstUpdate) {
QNetworkConfiguration item;
item.d = ptr;
emit configurationRemoved(item);
}
if (ptr.data()->state == QNetworkConfiguration::Active) {
--onlineConfigurations;
if (!firstUpdate && onlineConfigurations == 0)
emit onlineStateChanged(false);
}
}
void QGenericEngine::doRequestUpdate()
{
#ifndef QT_NO_NETWORKINTERFACE
QMutexLocker locker(&mutex);
// Immediately after connecting with a wireless access point
// QNetworkInterface::allInterfaces() will sometimes return an empty list. Calling it again a
// second time results in a non-empty list. If we loose interfaces we will end up removing
// network configurations which will break current sessions.
QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
if (interfaces.isEmpty())
interfaces = QNetworkInterface::allInterfaces();
QStringList previous = accessPointConfigurations.keys();
// create configuration for each interface
while (!interfaces.isEmpty()) {
QNetworkInterface interface = interfaces.takeFirst();
if (!interface.isValid())
continue;
// ignore loopback interface
if (interface.flags() & QNetworkInterface::IsLoopBack)
continue;
// ignore WLAN interface handled in separate engine
if (qGetInterfaceType(interface.name()) == QNetworkConfiguration::BearerWLAN)
continue;
uint identifier;
if (interface.index())
identifier = qHash(QLatin1String("generic:") + QString::number(interface.index()));
else
identifier = qHash(QLatin1String("generic:") + interface.hardwareAddress());
const QString id = QString::number(identifier);
previous.removeAll(id);
QString name = interface.humanReadableName();
if (name.isEmpty())
name = interface.name();
QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined;
if((interface.flags() & QNetworkInterface::IsUp) && !interface.addressEntries().isEmpty())
state |= QNetworkConfiguration::Active;
if (accessPointConfigurations.contains(id)) {
QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
bool changed = false;
ptr->mutex.lock();
if (!ptr->isValid) {
ptr->isValid = true;
changed = true;
}
if (ptr->name != name) {
ptr->name = name;
changed = true;
}
if (ptr->id != id) {
ptr->id = id;
changed = true;
}
if (ptr->state != state) {
ptr->state = state;
changed = true;
}
ptr->mutex.unlock();
if (changed) {
locker.unlock();
emit configurationChanged(ptr);
locker.relock();
}
} else {
QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
ptr->name = name;
ptr->isValid = true;
ptr->id = id;
ptr->state = state;
ptr->type = QNetworkConfiguration::InternetAccessPoint;
ptr->bearerType = qGetInterfaceType(interface.name());
accessPointConfigurations.insert(id, ptr);
configurationInterface.insert(id, interface.name());
locker.unlock();
emit configurationAdded(ptr);
locker.relock();
}
}
while (!previous.isEmpty()) {
QNetworkConfigurationPrivatePointer ptr =
accessPointConfigurations.take(previous.takeFirst());
configurationInterface.remove(ptr->id);
locker.unlock();
emit configurationRemoved(ptr);
locker.relock();
}
locker.unlock();
#endif
emit updateCompleted();
}
void QNativeWifiEngine::scanComplete()
{
QMutexLocker locker(&mutex);
if (!available()) {
locker.unlock();
emit updateCompleted();
return;
}
// enumerate interfaces
WLAN_INTERFACE_INFO_LIST *interfaceList;
DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
if (result != ERROR_SUCCESS) {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
#endif
locker.unlock();
emit updateCompleted();
return;
}
QStringList previous = accessPointConfigurations.keys();
for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
const WLAN_INTERFACE_INFO &interface = interfaceList->InterfaceInfo[i];
WLAN_AVAILABLE_NETWORK_LIST *networkList;
result = local_WlanGetAvailableNetworkList(handle, &interface.InterfaceGuid,
3, 0, &networkList);
if (result != ERROR_SUCCESS) {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug("%s: WlanGetAvailableNetworkList failed with error %ld\n",
__FUNCTION__, result);
#endif
continue;
}
QStringList seenNetworks;
for (unsigned int j = 0; j < networkList->dwNumberOfItems; ++j) {
WLAN_AVAILABLE_NETWORK &network = networkList->Network[j];
QString networkName;
if (network.strProfileName[0] != 0) {
networkName = QString::fromWCharArray(network.strProfileName);
} else {
networkName = QByteArray(reinterpret_cast<char *>(network.dot11Ssid.ucSSID),
network.dot11Ssid.uSSIDLength);
}
const QString id = QString::number(qHash(QLatin1String("WLAN:") + networkName));
previous.removeAll(id);
QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
if (!(network.dwFlags & WLAN_AVAILABLE_NETWORK_HAS_PROFILE))
state = QNetworkConfiguration::Undefined;
if (network.strProfileName[0] != 0) {
if (network.bNetworkConnectable) {
if (network.dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED)
state = QNetworkConfiguration::Active;
else
state = QNetworkConfiguration::Discovered;
} else {
state = QNetworkConfiguration::Defined;
}
}
if (seenNetworks.contains(networkName))
continue;
else
seenNetworks.append(networkName);
if (accessPointConfigurations.contains(id)) {
QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
bool changed = false;
ptr->mutex.lock();
if (!ptr->isValid) {
ptr->isValid = true;
changed = true;
}
if (ptr->name != networkName) {
ptr->name = networkName;
changed = true;
}
if (ptr->state != state) {
ptr->state = state;
changed = true;
}
ptr->mutex.unlock();
if (changed) {
locker.unlock();
emit configurationChanged(ptr);
locker.relock();
}
} else {
QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
ptr->name = networkName;
ptr->isValid = true;
ptr->id = id;
ptr->state = state;
ptr->type = QNetworkConfiguration::InternetAccessPoint;
ptr->bearerType = QNetworkConfiguration::BearerWLAN;
accessPointConfigurations.insert(id, ptr);
locker.unlock();
emit configurationAdded(ptr);
locker.relock();
}
}
local_WlanFreeMemory(networkList);
}
local_WlanFreeMemory(interfaceList);
while (!previous.isEmpty()) {
QNetworkConfigurationPrivatePointer ptr =
accessPointConfigurations.take(previous.takeFirst());
locker.unlock();
emit configurationRemoved(ptr);
locker.relock();
}
locker.unlock();
emit updateCompleted();
}
void QAndroidBearerEngine::updateConfigurations()
{
#ifndef QT_NO_NETWORKINTERFACE
if (m_connectivityManager == 0)
return;
{
QMutexLocker locker(&mutex);
QStringList oldKeys = accessPointConfigurations.keys();
QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
if (interfaces.isEmpty())
interfaces = QNetworkInterface::allInterfaces();
// Create a configuration for each of the main types (WiFi, Mobile, Bluetooth, WiMax, Ethernet)
foreach (const AndroidNetworkInfo &netInfo, m_connectivityManager->getAllNetworkInfo()) {
if (!netInfo.isValid())
continue;
const QString name = networkConfType(netInfo);
if (name.isEmpty())
continue;
QNetworkConfiguration::BearerType bearerType = getBearerType(netInfo);
QString interfaceName;
QNetworkConfiguration::StateFlag state = QNetworkConfiguration::Defined;
if (netInfo.isAvailable()) {
if (netInfo.isConnected()) {
// Attempt to map an interface to this configuration
while (!interfaces.isEmpty()) {
QNetworkInterface interface = interfaces.takeFirst();
// ignore loopback interface
if (!interface.isValid())
continue;
if (interface.flags() & QNetworkInterface::IsLoopBack)
continue;
// There is no way to get the interface from the NetworkInfo, so
// look for an active interface...
if (interface.flags() & QNetworkInterface::IsRunning
&& !interface.addressEntries().isEmpty()) {
state = QNetworkConfiguration::Active;
interfaceName = interface.name();
break;
}
}
}
}
const QString key = QString(QLatin1String("android:%1:%2")).arg(name).arg(interfaceName);
const QString id = QString::number(qHash(key));
m_configurationInterface[id] = interfaceName;
oldKeys.removeAll(id);
if (accessPointConfigurations.contains(id)) {
QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
bool changed = false;
{
const QMutexLocker confLocker(&ptr->mutex);
if (!ptr->isValid) {
ptr->isValid = true;
changed = true;
}
// Don't reset the bearer type to 'Unknown'
if (ptr->bearerType != QNetworkConfiguration::BearerUnknown
&& ptr->bearerType != bearerType) {
ptr->bearerType = bearerType;
changed = true;
}
if (ptr->name != name) {
ptr->name = name;
changed = true;
}
if (ptr->id != id) {
ptr->id = id;
changed = true;
}
if (ptr->state != state) {
ptr->state = state;
changed = true;
}
} // Unlock configuration
if (changed) {
locker.unlock();
Q_EMIT configurationChanged(ptr);
locker.relock();
}
} else {
QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
ptr->name = name;
ptr->isValid = true;
ptr->id = id;
ptr->state = state;
ptr->type = QNetworkConfiguration::InternetAccessPoint;
ptr->bearerType = bearerType;
accessPointConfigurations.insert(id, ptr);
locker.unlock();
Q_EMIT configurationAdded(ptr);
locker.relock();
}
}
while (!oldKeys.isEmpty()) {
QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldKeys.takeFirst());
m_configurationInterface.remove(ptr->id);
locker.unlock();
Q_EMIT configurationRemoved(ptr);
locker.relock();
}
} // Unlock engine
#endif // QT_NO_NETWORKINTERFACE
Q_EMIT updateCompleted();
}
void QNetworkConfigurationManagerPrivate::updateConfigurations()
{
if (firstUpdate) {
updateState = NotUpdating;
onlineConfigurations = 0;
#if defined (Q_OS_DARWIN)
coreWifi = QCoreWlanEngine::instance();
if (coreWifi) {
connect(coreWifi, SIGNAL(configurationsChanged()),
this, SLOT(updateConfigurations()));
}
#else
#if defined(BACKEND_NM)
nmWifi = QNmWifiEngine::instance();
if (nmWifi) {
connect(nmWifi, SIGNAL(configurationsChanged()),
this, SLOT(updateConfigurations()));
} else {
#endif
generic = QGenericEngine::instance();
if (generic) {
connect(generic, SIGNAL(configurationsChanged()),
this, SLOT(updateConfigurations()));
}
#if defined(BACKEND_NM)
}
#endif
#endif
#ifdef Q_OS_WIN
nla = QNlaEngine::instance();
if (nla) {
connect(nla, SIGNAL(configurationsChanged()),
this, SLOT(updateConfigurations()));
}
#endif
#ifdef Q_OS_WIN32
nativeWifi = QNativeWifiEngine::instance();
if (nativeWifi) {
connect(nativeWifi, SIGNAL(configurationsChanged()),
this, SLOT(updateConfigurations()));
capFlags |= QNetworkConfigurationManager::CanStartAndStopInterfaces;
}
#endif
}
QNetworkSessionEngine *engine = qobject_cast<QNetworkSessionEngine *>(sender());
if (updateState & Updating && engine) {
#if defined (Q_OS_DARWIN)
if (engine == coreWifi)
updateState &= ~CoreWifiUpdating;
#else
#if defined(BACKEND_NM)
if (engine == nmWifi)
updateState &= ~NmUpdating;
else if (engine == generic)
updateState &= ~GenericUpdating;
#else
if (engine == generic)
updateState &= ~GenericUpdating;
#endif
#endif
#ifdef Q_OS_WIN
else if (engine == nla)
updateState &= ~NlaUpdating;
#ifdef Q_OS_WIN32
else if (engine == nativeWifi)
updateState &= ~NativeWifiUpdating;
#endif
#endif
}
QList<QNetworkSessionEngine *> engines;
if (firstUpdate) {
#if defined (Q_OS_DARWIN)
if (coreWifi)
engines << coreWifi;
#else
#if defined(BACKEND_NM)
if (nmWifi)
engines << nmWifi;
else if (generic)
engines << generic;
#else
if (generic)
engines << generic;
#endif
#endif
#ifdef Q_OS_WIN
if (nla)
engines << nla;
#ifdef Q_OS_WIN32
if (nativeWifi)
engines << nativeWifi;
#endif
#endif
} else if (engine) {
engines << engine;
}
while (!engines.isEmpty()) {
engine = engines.takeFirst();
bool ok;
QList<QNetworkConfigurationPrivate *> foundConfigurations = engine->getConfigurations(&ok);
// Find removed configurations.
QList<QString> removedIdentifiers = configurationEngine.keys();
for (int i = 0; i < foundConfigurations.count(); ++i)
removedIdentifiers.removeOne(foundConfigurations.at(i)->id);
// Update or add configurations.
while (!foundConfigurations.isEmpty()) {
QNetworkConfigurationPrivate *cpPriv = foundConfigurations.takeFirst();
if (accessPointConfigurations.contains(cpPriv->id))
configurationChanged(cpPriv);
else
configurationAdded(cpPriv, engine);
delete cpPriv;
}
// Remove configurations.
while (!removedIdentifiers.isEmpty()) {
const QString id = removedIdentifiers.takeFirst();
if (configurationEngine.value(id) == engine)
configurationRemoved(id);
}
}
updateInternetServiceConfiguration();
if (updateState == Updating) {
updateState = NotUpdating;
emit configurationUpdateComplete();
}
if (firstUpdate)
firstUpdate = false;
}
