MCL/sf/mw/qtextensions: comparison qtmobility/src/bearer/qcorewlanengine

equal deleted inserted replaced

-:cfcbf08528c4
+:5822d84012fb
 #include <QtCore/qcoreapplication.h>
 #include <QtCore/qstringlist.h>
 #include <QtCore/qdebug.h>
+#include <QDir>
 #if defined(MAC_SDK_10_6) //not much functionality without this
 #include <CoreWLAN/CoreWLAN.h>
 #include <CoreWLAN/CWInterface.h>
 #include <CoreWLAN/CWNetwork.h>
 #include <CoreWLAN/CWNetwork.h>
+#include <CoreWLAN/CW8021XProfile.h>
 #endif
 #include <Foundation/NSEnumerator.h>
 #include <Foundation/NSKeyValueObserving.h>
 #include <Foundation/NSAutoreleasePool.h>
 @interface QNSListener : NSObject
 {
 NSNotificationCenter *center;
 CWInterface * currentInterface;
 }
-- (void)notificationHandler:(NSNotification *)notification;
+- (void)notificationHandler;//:(NSNotification *)notification;
 - (void)remove;
 @end
 @implementation QNSListener
 - (id) init
 -(void)remove
 {
 [center removeObserver:self];
 }
-- (void)notificationHandler:(NSNotification *)notification
+- (void)notificationHandler;//:(NSNotification *)notification
 {
 QTM_NAMESPACE::QCoreWlanEngine::instance()->requestUpdate();
 }
 @end
 #endif
 {
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 getAllScInterfaces();
 startNetworkChangeLoop();
 #ifdef MAC_SDK_10_6
-QNSListener *listener;
+if([[CWInterface supportedInterfaces] count] > 0 ) {
-listener = [[QNSListener alloc] init];
+QNSListener *listener;
-#endif
+listener = [[QNSListener alloc] init];
+hasWifi = true;
+} else {
+hasWifi = false;
+}
+#endif
+getUserConfigurations();
 requestUpdate();
+[pool release];
 }
 QCoreWlanEngine::~QCoreWlanEngine()
 {
 QNetworkConfigurationPrivate* cpPriv = 0;
 return configurationInterface.contains(id.toUInt());
 }
 void QCoreWlanEngine::connectToId(const QString &id)
 {
-NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
 QString interfaceString = getInterfaceFromId(id);
 if(networkInterfaces.value(interfaceString) == "WLAN") {
 #if defined(MAC_SDK_10_6)
+NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
 CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceString)];
-CWConfiguration *userConfig = [ wifiInterface configuration];
+if([wifiInterface power]) {
-NSSet *remNets = [userConfig rememberedNetworks]; //CWWirelessProfile
+NSError *err = nil;
+NSMutableDictionary *params = [NSMutableDictionary dictionaryWithCapacity:0];
-NSEnumerator *enumerator = [remNets objectEnumerator];
-CWWirelessProfile *wProfile;
+NSString *wantedSsid = 0;
-NSUInteger index=0;
+bool okToProceed = true;
-NSDictionary *parametersDict;
+if(getNetworkNameFromSsid(id) != id) {
-NSArray* apArray;
+NSArray *array = [CW8021XProfile allUser8021XProfiles];
+for (NSUInteger i=0; i<[array count]; ++i) {
-CW8021XProfile *user8021XProfile;
+if(id == nsstringToQString([[array objectAtIndex:i] userDefinedName])
-NSError *err;
+|| id == nsstringToQString([[array objectAtIndex:i] ssid]) ) {
-NSMutableDictionary *params;
+QString thisName = getSsidFromNetworkName(id);
+if(thisName.isEmpty()) {
-while ((wProfile = [enumerator nextObject])) { //CWWirelessProfile
+wantedSsid = qstringToNSString(id);
+} else {
-if(id == nsstringToQString([wProfile ssid])) {
+wantedSsid = qstringToNSString(thisName);
-user8021XProfile = nil;
+}
-user8021XProfile = [ wProfile user8021XProfile];
+okToProceed = false;
+[params setValue: [array objectAtIndex:i] forKey:kCWAssocKey8021XProfile];
-err = nil;
+break;
-params = [NSMutableDictionary dictionaryWithCapacity:0];
+}
-if(user8021XProfile) {
-[params setValue: user8021XProfile forKey:kCWAssocKey8021XProfile];
-} else {
-[params setValue: [wProfile passphrase] forKey: kCWAssocKeyPassphrase];
 }
+}
-parametersDict = nil;
-apArray = [NSMutableArray arrayWithArray:[wifiInterface scanForNetworksWithParameters:parametersDict error:&err]];
+if(okToProceed) {
+NSUInteger index = 0;
-if(!err) {
+CWConfiguration *userConfig = [ wifiInterface configuration];
-for(uint row=0; row < [apArray count]; row++ ) {
+NSSet *remNets = [userConfig rememberedNetworks];
-CWNetwork *apNetwork = [apArray objectAtIndex:row];
+NSEnumerator *enumerator = [remNets objectEnumerator];
-if([[apNetwork ssid] compare:[wProfile ssid]] == NSOrderedSame) {
+CWWirelessProfile *wProfile;
-bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
+while ((wProfile = [enumerator nextObject])) {
+if(id == nsstringToQString([wProfile ssid])) {
-if(!result) {
-emit connectionError(id, ConnectError);
+wantedSsid = [wProfile ssid];
-} else {
+[params setValue: [wProfile passphrase] forKey: kCWAssocKeyPassphrase];
-[autoreleasepool release];
+break;
-return;
+}
-}
+index++;
+}
+}
+NSDictionary *parametersDict = nil;
+NSArray *apArray = [NSMutableArray arrayWithArray:[wifiInterface scanForNetworksWithParameters:parametersDict error:&err]];
+if(!err) {
+for(uint row=0; row < [apArray count]; row++ ) {
+CWNetwork *apNetwork = [apArray objectAtIndex:row];
+if([[apNetwork ssid] compare:wantedSsid] == NSOrderedSame) {
+bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
+if(!result) {
+emit connectionError(id, ConnectError);
+} else {
+[autoreleasepool release];
+return;
 }
 }
 }
-}
+} else {
-index++;
+qDebug() <<"ERROR"<< nsstringToQString([err localizedDescription ]);
 }
 emit connectionError(id, InterfaceLookupError);
-#endif
+[autoreleasepool release];
-} else {
-// not wifi
+} else {
+// not wifi
+}
+#endif
 }
 emit connectionError(id, OperationNotSupported);
-[autoreleasepool release];
 }
 void QCoreWlanEngine::disconnectFromId(const QString &id)
 {
 QString interfaceString = getInterfaceFromId(id);
 }
 void QCoreWlanEngine::requestUpdate()
 {
 getAllScInterfaces();
+getUserConfigurations();
 emit configurationsChanged();
 }
 QCoreWlanEngine *QCoreWlanEngine::instance()
 {
 return coreWlanEngine();
 }
+QString QCoreWlanEngine::getSsidFromNetworkName(const QString &name)
+{
+QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+while (i.hasNext()) {
+i.next();
+QMap<QString,QString> map = i.value();
+QMapIterator<QString, QString> ij(i.value());
+while (ij.hasNext()) {
+ij.next();
+if(name == i.key()) {
+return ij.key();
+}
+}
+}
+return QString();
+}
+QString QCoreWlanEngine::getNetworkNameFromSsid(const QString &ssid)
+{
+QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+while (i.hasNext()) {
+i.next();
+QMap<QString,QString> map = i.value();
+QMapIterator<QString, QString> ij(i.value());
+while (ij.hasNext()) {
+ij.next();
+if(ij.key() == ssid) {
+return i.key();
+}
+}
+return map.key(ssid);
+}
+return QString();
+}
 QList<QNetworkConfigurationPrivate *> QCoreWlanEngine::scanForSsids(const QString &interfaceName)
 {
 QList<QNetworkConfigurationPrivate *> foundConfigs;
+if(!hasWifi) {
+return foundConfigs;
+}
 #if defined(MAC_SDK_10_6)
 NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
 CWInterface *currentInterface = [CWInterface interfaceWithName:qstringToNSString(interfaceName)];
+QStringList addedConfigs;
 if([currentInterface power]) {
 NSError *err = nil;
 NSDictionary *parametersDict = nil;
 NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
 CWNetwork *apNetwork;
 if(!err) {
 for(uint row=0; row < [apArray count]; row++ ) {
-NSAutoreleasePool *looppool = [[NSAutoreleasePool alloc] init];
 apNetwork = [apArray objectAtIndex:row];
+QString networkSsid = nsstringToQString([apNetwork ssid]);
 QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
-QString networkSsid = nsstringToQString([apNetwork ssid]);
 cpPriv->name = networkSsid;
 cpPriv->isValid = true;
 cpPriv->id = networkSsid;
 cpPriv->internet = true;
 cpPriv->bearer = QLatin1String("WLAN");
 cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
 cpPriv->serviceInterface = QNetworkInterface::interfaceFromName(interfaceName);
+bool known = isKnownSsid(networkSsid);
 if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
-QString interfaceSsidString = nsstringToQString( [currentInterface ssid]);
+if( cpPriv->name == nsstringToQString( [currentInterface ssid])) {
-if( cpPriv->name == interfaceSsidString) {
 cpPriv->state |=  QNetworkConfiguration::Active;
 }
 }
 if(!cpPriv->state) {
-if(isKnownSsid(cpPriv->serviceInterface.name(), networkSsid)) {
+if(known) {
 cpPriv->state =  QNetworkConfiguration::Discovered;
 } else {
-cpPriv->state =  QNetworkConfiguration::Defined;
+cpPriv->state = QNetworkConfiguration::Undefined;
 }
-}
-if(!cpPriv->state) {
-cpPriv->state = QNetworkConfiguration::Undefined;
 }
 if([[apNetwork securityMode ] intValue]== kCWSecurityModeOpen)
 cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
 else
 cpPriv->purpose = QNetworkConfiguration::PrivatePurpose;
 foundConfigs.append(cpPriv);
-[looppool release];
+addedConfigs << networkSsid;
-}
-}
+} //end scanned row
 }
+} //end power
+// add known configurations that are not around.
+QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+while (i.hasNext()) {
+i.next();
+QString networkName = i.key();
+if(!addedConfigs.contains(networkName)) {
+QString interfaceName;
+QMapIterator<QString, QString> ij(i.value());
+while (ij.hasNext()) {
+ij.next();
+interfaceName = ij.value();
+}
+QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();
+cpPriv->name = networkName;
+cpPriv->isValid = true;
+cpPriv->id = networkName;
+cpPriv->internet = true;
+cpPriv->bearer = QLatin1String("WLAN");
+cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+cpPriv->serviceInterface = QNetworkInterface::interfaceFromName(interfaceName);
+QString ssid = getSsidFromNetworkName(networkName);
+if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
+if( ssid == nsstringToQString( [currentInterface ssid])) {
+cpPriv->state |=  QNetworkConfiguration::Active;
+}
+}
+if( addedConfigs.contains(ssid)) {
+cpPriv->state |=  QNetworkConfiguration::Discovered;
+}
+if(!cpPriv->state) {
+cpPriv->state =  QNetworkConfiguration::Defined;
+}
+foundConfigs.append(cpPriv);
+}
+}
 [autoreleasepool drain];
 #else
 Q_UNUSED(interfaceName);
 #endif
 return foundConfigs;
 }
 bool QCoreWlanEngine::isWifiReady(const QString &wifiDeviceName)
 {
 #if defined(MAC_SDK_10_6)
-CWInterface *defaultInterface = [CWInterface interfaceWithName: qstringToNSString(wifiDeviceName)];
+if([[CWInterface supportedInterfaces] count] > 0 ) {
-if([defaultInterface power])
+CWInterface *defaultInterface = [CWInterface interfaceWithName: qstringToNSString(wifiDeviceName)];
-return true;
+if([defaultInterface power])
+return true;
+}
 #else
 Q_UNUSED(wifiDeviceName);
 #endif
 return false;
 }
-bool QCoreWlanEngine::isKnownSsid(const QString &interfaceName, const QString &ssid)
+bool QCoreWlanEngine::isKnownSsid( const QString &ssid)
 {
 #if defined(MAC_SDK_10_6)
-CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceName)];
+QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
-CWConfiguration *userConfig = [wifiInterface configuration];
+while (i.hasNext()) {
-NSSet *remNets = [userConfig rememberedNetworks];
+i.next();
-for (CWWirelessProfile *wProfile in remNets) {
+QMap<QString,QString> map = i.value();
-if(ssid == nsstringToQString([wProfile ssid]))
+if(map.keys().contains(ssid)) {
 return true;
+}
 }
 #else
-Q_UNUSED(interfaceName);
 Q_UNUSED(ssid);
 #endif
 return false;
 }
 CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode);
 return;
 }
+void QCoreWlanEngine::getUserConfigurations()
+{
+#ifdef MAC_SDK_10_6
+NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
+userProfiles.clear();
+NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
+for(uint row=0; row < [wifiInterfaces count]; row++ ) {
+CWInterface *wifiInterface = [CWInterface interfaceWithName: [wifiInterfaces objectAtIndex:row]];
+NSString *nsInterfaceName = [wifiInterface name];
+// add user configured system networks
+SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, (CFStringRef)@"Qt corewlan", nil, nil);
+CFDictionaryRef airportPlist = (const __CFDictionary*)SCDynamicStoreCopyValue(dynRef, (CFStringRef)[NSString stringWithFormat:@"Setup:/Network/Interface/%@/AirPort", nsInterfaceName]);
+CFRelease(dynRef);
+NSDictionary *prefNetDict = [airportPlist objectForKey:@"PreferredNetworks"];
+NSArray *thisSsidarray = [prefNetDict valueForKey:@"SSID_STR"];
+for(NSString *ssidkey in thisSsidarray) {
+QString thisSsid = nsstringToQString(ssidkey);
+if(!userProfiles.contains(thisSsid)) {
+QMap <QString,QString> map;
+map.insert(thisSsid, nsstringToQString(nsInterfaceName));
+userProfiles.insert(thisSsid, map);
+}
+}
+CFRelease(airportPlist);
+// 802.1X user profiles
+QString userProfilePath = QDir::homePath() + "/Library/Preferences/com.apple.eap.profiles.plist";
+NSDictionary* eapDict = [[NSMutableDictionary alloc] initWithContentsOfFile:qstringToNSString(userProfilePath)];
+NSString *profileStr= @"Profiles";
+NSString *nameStr = @"UserDefinedName";
+NSString *networkSsidStr = @"Wireless Network";
+for (id profileKey in eapDict) {
+if ([profileStr isEqualToString:profileKey]) {
+NSDictionary *itemDict = [eapDict objectForKey:profileKey];
+for (id itemKey in itemDict) {
+NSInteger dictSize = [itemKey count];
+id objects[dictSize];
+id keys[dictSize];
+[itemKey getObjects:objects andKeys:keys];
+QString networkName;
+QString ssid;
+for(int i = 0; i < dictSize; i++) {
+if([nameStr isEqualToString:keys[i]]) {
+networkName = nsstringToQString(objects[i]);
+}
+if([networkSsidStr isEqualToString:keys[i]]) {
+ssid = nsstringToQString(objects[i]);
+}
+if(!userProfiles.contains(networkName)
+&& !ssid.isEmpty()) {
+QMap<QString,QString> map;
+map.insert(ssid, nsstringToQString(nsInterfaceName));
+userProfiles.insert(networkName, map);
+}
+}
+}
+}
+}
+}
+[autoreleasepool release];
+#endif
+}
 #include "moc_qcorewlanengine_mac_p.cpp"
 QTM_END_NAMESPACE

branch	RCL_3
changeset 1	5822d84012fb
parent 0	cfcbf08528c4
child 2	87be51aa5b5b