/*! 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; }