/*! 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))); }
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(); }
void QNetworkConfigurationManagerPrivate::configurationAdded(QNetworkConfigurationPrivate *cpPriv, QNetworkSessionEngine *engine) { QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(new QNetworkConfigurationPrivate); ptr.data()->isValid = cpPriv->isValid; ptr.data()->name = cpPriv->name; ptr.data()->id = cpPriv->id; ptr.data()->state = cpPriv->state; ptr.data()->type = cpPriv->type; ptr.data()->roamingSupported = cpPriv->roamingSupported; ptr.data()->purpose = cpPriv->purpose; ptr.data()->internet = cpPriv->internet; ptr.data()->bearer = cpPriv->bearer; accessPointConfigurations.insert(cpPriv->id, ptr); configurationEngine.insert(cpPriv->id, engine); if (!firstUpdate) { QNetworkConfiguration item; item.d = ptr; emit configurationAdded(item); } if (ptr.data()->state == QNetworkConfiguration::Active) { ++onlineConfigurations; if (!firstUpdate && onlineConfigurations == 1) emit onlineStateChanged(true); } }
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 QNetworkConfigurationManagerPrivate::updateInternetServiceConfiguration() { if (!snapConfigurations.contains(QLatin1String("Internet Service Network"))) { QNetworkConfigurationPrivate *serviceNetwork = new QNetworkConfigurationPrivate; serviceNetwork->name = tr("Internet"); serviceNetwork->isValid = true; serviceNetwork->id = QLatin1String("Internet Service Network"); serviceNetwork->state = QNetworkConfiguration::Defined; serviceNetwork->type = QNetworkConfiguration::ServiceNetwork; QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(serviceNetwork); snapConfigurations.insert(serviceNetwork->id, ptr); if (!firstUpdate) { QNetworkConfiguration item; item.d = ptr; emit configurationAdded(item); } } QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr = snapConfigurations.value(QLatin1String("Internet Service Network")); QList<QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > serviceNetworkMembers; QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> >::const_iterator i = accessPointConfigurations.constBegin(); QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined; while (i != accessPointConfigurations.constEnd()) { QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> child = i.value(); if (child.data()->internet && ((child.data()->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined)) { serviceNetworkMembers.append(child); state |= child.data()->state; } ++i; } if (ptr.data()->state != state || ptr.data()->serviceNetworkMembers != serviceNetworkMembers) { ptr.data()->state = state; ptr.data()->serviceNetworkMembers = serviceNetworkMembers; QNetworkConfiguration item; item.d = ptr; emit configurationChanged(item); } }
void BearerMonitor::configurationAdded(const QNetworkConfiguration &config, QTreeWidgetItem *parent) { QTreeWidgetItem *item = new QTreeWidgetItem; updateItem(item, config); if (parent) parent->addChild(item); else treeWidget->addTopLevelItem(item); if (config.type() == QNetworkConfiguration::ServiceNetwork) { foreach (const QNetworkConfiguration &child, config.children()) configurationAdded(child, item); }
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 QNetworkConfigurationManagerPrivate::addConfiguration(QString& iap_id) { // Note: When new IAP is created, this function gets called multiple times // in a row. // For example: Empty type & name for WLAN was stored into newly // created IAP data in gconf when this function gets // called for the first time. // WLAN type & name are updated into IAP data in gconf // as soon as WLAN connection is up and running. // => And this function gets called again. if (!accessPointConfigurations.contains(iap_id)) { Maemo::IAPConf saved_iap(iap_id); QString iap_type = saved_iap.value("type").toString(); QString iap_name = saved_iap.value("name").toString(); QByteArray ssid = saved_iap.value("wlan_ssid").toByteArray(); if (!iap_type.isEmpty() && !iap_name.isEmpty()) { // Check if new IAP is actually Undefined WLAN configuration // Note: SSID is used as an iap id for Undefined WLAN configurations // => configuration must be searched using SSID if (!ssid.isEmpty() && accessPointConfigurations.contains(ssid)) { QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr = accessPointConfigurations.take(ssid); if (ptr.data()) { ptr->id = iap_id; ptr->iap_type = iap_type; ptr->network_attrs = getNetworkAttrs(true, iap_id, iap_type, QString()); ptr->network_id = ssid; ptr->service_id = saved_iap.value("service_id").toString(); ptr->service_type = saved_iap.value("service_type").toString(); if (m_onlineIapId == iap_id) { ptr->state = QNetworkConfiguration::Active; } else { ptr->state = QNetworkConfiguration::Defined; } accessPointConfigurations.insert(iap_id, ptr); configurationChanged(ptr.data()); } } else { QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate(); cpPriv->name = saved_iap.value("name").toString(); if (cpPriv->name.isEmpty()) cpPriv->name = iap_id; cpPriv->isValid = true; cpPriv->id = iap_id; cpPriv->iap_type = iap_type; cpPriv->network_attrs = getNetworkAttrs(true, iap_id, iap_type, QString()); cpPriv->service_id = saved_iap.value("service_id").toString(); cpPriv->service_type = saved_iap.value("service_type").toString(); if (iap_type.startsWith(QLatin1String("WLAN"))) { QByteArray ssid = saved_iap.value("wlan_ssid").toByteArray(); if (ssid.isEmpty()) { qWarning() << "Cannot get ssid for" << iap_id; } cpPriv->network_id = ssid; } cpPriv->type = QNetworkConfiguration::InternetAccessPoint; if (m_onlineIapId == iap_id) { cpPriv->state = QNetworkConfiguration::Active; } else { cpPriv->state = QNetworkConfiguration::Defined; } cpPriv->manager = this; QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv); accessPointConfigurations.insert(iap_id, ptr); #ifdef BEARER_MANAGEMENT_DEBUG qDebug("IAP: %s, name: %s, added to known list", iap_id.toAscii().data(), cpPriv->name.toAscii().data()); #endif QNetworkConfiguration item; item.d = ptr; emit configurationAdded(item); } } else { qWarning("IAP %s does not have \"type\" or \"name\" fields defined, skipping this IAP.", iap_id.toAscii().data()); } } else { #ifdef BEARER_MANAGEMENT_DEBUG qDebug() << "IAP" << iap_id << "already in db."; #endif /* Check if the data in db changed and update configuration accordingly */ QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr = accessPointConfigurations.value(iap_id); if (ptr.data()) { Maemo::IAPConf changed_iap(iap_id); QString iap_type = changed_iap.value("type").toString(); bool update_needed = false; /* if IAP type or ssid changed, we need to change the state */ ptr->network_attrs = getNetworkAttrs(true, iap_id, iap_type, QString()); ptr->service_id = changed_iap.value("service_id").toString(); ptr->service_type = changed_iap.value("service_type").toString(); if (!iap_type.isEmpty()) { ptr->name = changed_iap.value("name").toString(); if (ptr->name.isEmpty()) ptr->name = iap_id; ptr->isValid = true; if (ptr->iap_type != iap_type) { ptr->iap_type = iap_type; update_needed = true; } if (iap_type.startsWith(QLatin1String("WLAN"))) { QByteArray ssid = changed_iap.value("wlan_ssid").toByteArray(); if (ssid.isEmpty()) { qWarning() << "Cannot get ssid for" << iap_id; } if (ptr->network_id != ssid) { ptr->network_id = ssid; update_needed = true; } } } if (update_needed) { ptr->type = QNetworkConfiguration::InternetAccessPoint; if (m_onlineIapId == iap_id) { if (ptr->state < QNetworkConfiguration::Active) { ptr->state = QNetworkConfiguration::Active; configurationChanged(ptr.data()); } } else if (ptr->state < QNetworkConfiguration::Defined) { ptr->state = QNetworkConfiguration::Defined; configurationChanged(ptr.data()); } } } else { qWarning("Cannot find IAP %s from current configuration although it should be there.", iap_id.toAscii().data()); } } }
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 QBBEngine::updateConfiguration(const char *interface) { netstatus_interface_details_t *details = 0; if (netstatus_get_interface_details(interface, &details) != BPS_SUCCESS) { qBearerDebug() << Q_FUNC_INFO << "cannot retrieve details for interface" << interface; return; } const QString name = QString::fromLatin1(netstatus_interface_get_name(details)); const QString id = idForName(name); const netstatus_interface_type_t type = netstatus_interface_get_type(details); const netstatus_ip_status_t ipStatus = netstatus_interface_get_ip_status(details); netstatus_free_interface_details(&details); QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined; if (ipStatus == NETSTATUS_IP_STATUS_OK) state |= QNetworkConfiguration::Active; QMutexLocker locker(&mutex); if (accessPointConfigurations.contains(id)) { QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id); bool changed = false; QMutexLocker ptrLocker(&ptr->mutex); 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; } const netstatus_ip_status_t oldIpStatus = ptr->oldIpStatus; ptr->oldIpStatus = ipStatus; ptrLocker.unlock(); locker.unlock(); if (changed) { qBearerDebug() << Q_FUNC_INFO << "configuration changed:" << interface; Q_EMIT configurationChanged(ptr); } else { // maybe Wifi has changed but gateway not yet ready etc. qBearerDebug() << Q_FUNC_INFO << "configuration has not changed."; if (oldIpStatus != ipStatus) { // if IP status changed if (ipStatus != NETSTATUS_IP_STATUS_OK && ipStatus != NETSTATUS_IP_STATUS_ERROR_NOT_UP && ipStatus != NETSTATUS_IP_STATUS_ERROR_NOT_CONFIGURED) { // work around race condition in netstatus API by just checking // again in 300 ms QTimer::singleShot(300, this, SLOT(doRequestUpdate())); } } } return; } QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate); ptr->name = name; ptr->isValid = true; ptr->id = id; ptr->state = state; ptr->type = QNetworkConfiguration::InternetAccessPoint; ptr->bearerType = interfaceType(type); accessPointConfigurations.insert(id, ptr); configurationInterface.insert(id, name); locker.unlock(); qBearerDebug() << Q_FUNC_INFO << "configuration added:" << interface; Q_EMIT configurationAdded(ptr); }
void QIcdEngine::doRequestUpdate(QList<Maemo::IcdScanResult> scanned) { /* Contains all known iap_ids from storage */ QList<QString> knownConfigs = accessPointConfigurations.keys(); /* Contains all known WLAN network ids (like ssid) from storage */ QMultiHash<QByteArray, SSIDInfo* > notDiscoveredWLANConfigs; QList<QString> all_iaps; Maemo::IAPConf::getAll(all_iaps); foreach (const QString &iap_id, all_iaps) { QByteArray ssid; Maemo::IAPConf saved_ap(iap_id); bool is_temporary = saved_ap.value("temporary").toBool(); if (is_temporary) { #ifdef BEARER_MANAGEMENT_DEBUG qDebug() << "IAP" << iap_id << "is temporary, skipping it."; #endif continue; } QString iap_type = saved_ap.value("type").toString(); if (iap_type.startsWith(QLatin1String("WLAN"))) { ssid = saved_ap.value("wlan_ssid").toByteArray(); if (ssid.isEmpty()) continue; QString security_method = saved_ap.value("wlan_security").toString(); SSIDInfo *info = new SSIDInfo; info->iap_id = iap_id; info->wlan_security = security_method; notDiscoveredWLANConfigs.insert(ssid, info); } else if (iap_type.isEmpty()) { continue; } else { #ifdef BEARER_MANAGEMENT_DEBUG qDebug() << "IAP" << iap_id << "network type is" << iap_type; #endif ssid.clear(); } if (!accessPointConfigurations.contains(iap_id)) { IcdNetworkConfigurationPrivate *cpPriv = new IcdNetworkConfigurationPrivate; cpPriv->name = saved_ap.value("name").toString(); if (cpPriv->name.isEmpty()) { if (!ssid.isEmpty() && ssid.size() > 0) cpPriv->name = ssid.data(); else cpPriv->name = iap_id; } cpPriv->isValid = true; cpPriv->id = iap_id; cpPriv->network_id = ssid; cpPriv->network_attrs = getNetworkAttrs(true, iap_id, iap_type, QString()); cpPriv->iap_type = iap_type; cpPriv->bearerType = bearerTypeFromIapType(iap_type); cpPriv->service_id = saved_ap.value("service_id").toString(); cpPriv->service_type = saved_ap.value("service_type").toString(); cpPriv->type = QNetworkConfiguration::InternetAccessPoint; cpPriv->state = QNetworkConfiguration::Defined; QNetworkConfigurationPrivatePointer ptr(cpPriv); accessPointConfigurations.insert(iap_id, ptr); mutex.unlock(); emit configurationAdded(ptr); mutex.lock(); #ifdef BEARER_MANAGEMENT_DEBUG qDebug("IAP: %s, name: %s, ssid: %s, added to known list", iap_id.toAscii().data(), ptr->name.toAscii().data(), !ssid.isEmpty() ? ssid.data() : "-"); #endif } else { knownConfigs.removeOne(iap_id); #ifdef BEARER_MANAGEMENT_DEBUG qDebug("IAP: %s, ssid: %s, already exists in the known list", iap_id.toAscii().data(), !ssid.isEmpty() ? ssid.data() : "-"); #endif } }
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; }
void QBBEngine::updateConfiguration(const char *interface) { netstatus_interface_details_t *details = 0; if (netstatus_get_interface_details(interface, &details) != BPS_SUCCESS) { qBearerDebug() << Q_FUNC_INFO << "cannot retrieve details for interface" << interface; return; } const QString name = QString::fromLatin1(netstatus_interface_get_name(details)); const QString id = idForName(name); const int numberOfIpAddresses = netstatus_interface_get_num_ip_addresses(details); const bool isConnected = netstatus_interface_is_connected(details); const netstatus_interface_type_t type = netstatus_interface_get_type(details); netstatus_free_interface_details(&details); QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined; if (isConnected && (numberOfIpAddresses > 0)) state |= QNetworkConfiguration::Active; QMutexLocker locker(&mutex); if (accessPointConfigurations.contains(id)) { QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id); bool changed = false; QMutexLocker ptrLocker(&ptr->mutex); 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; } ptrLocker.unlock(); locker.unlock(); if (changed) { qBearerDebug() << Q_FUNC_INFO << "configuration changed:" << interface; Q_EMIT configurationChanged(ptr); } else { qBearerDebug() << Q_FUNC_INFO << "configuration has not changed."; } return; } QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate); ptr->name = name; ptr->isValid = true; ptr->id = id; ptr->state = state; ptr->type = QNetworkConfiguration::InternetAccessPoint; ptr->bearerType = interfaceType(type); accessPointConfigurations.insert(id, ptr); configurationInterface.insert(id, name); locker.unlock(); qBearerDebug() << Q_FUNC_INFO << "configuration added:" << interface; Q_EMIT configurationAdded(ptr); }