Changeset 112811 for trunk/dports/aqua


Ignore:
Timestamp:
Nov 1, 2013, 8:58:27 PM (6 years ago)
Author:
michaelld@…
Message:

qt4-mac:

  • patch to provide support for OSX 10.9 Mavericks;
  • should address ticket #40852.
Location:
trunk/dports/aqua/qt4-mac
Files:
8 added
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/dports/aqua/qt4-mac/Portfile

    r111912 r112811  
    172172patchfiles-append   patch-src_plugins_bearer_corewlan_corewlan.pro.diff
    173173
    174 # (15) fix the corewlan source to work under 10.7
     174# (15) fix the corewlan source to work: this patch create a new
     175# (primary) file qcorewlanengine.mm for 10.7 and newer APIs and a
     176# secondary one qcorewlanengine_10_6.mm for 10.6 and older APIs.  The
     177# primary file internally selects which one to use.
    175178
    176179patchfiles-append   patch-src_plugins_bearer_corewlan_qcorewlanengine.mm.diff
     
    224227    patch-src_3rdparty_webkit_Source_WebCore_WebCore.pro.diff
    225228
    226 # (22) Under 10.8 only: Patch to fix corelib linking
    227 
    228 platform darwin 12 {
    229     patchfiles-append patch-src_corelib_corelib.pro.diff
     229# (22) Under 10.8 and 10.9: Patch to fix corelib linking
     230
     231platform darwin {
     232    if {${os.major} > 12} {
     233        patchfiles-append patch-src_corelib_corelib.pro.diff
     234    }
    230235}
    231236
     
    240245    patch-libc++.diff
    241246
    242 # TODO: More patches to fix Mavericks build
     247# (25) Fix CLuscene to build under 10.9 CLang
     248# (26) Fix qglobals.h to build under 10.9 CLang
     249# (27 a-e) Fix WebKit to build under 10.9 CLang
     250
     251platform darwin 13 {
     252    patchfiles-append   \
     253        patch-src_3rdparty_clucene_src_CLucene_search_FieldCacheImpl.cpp.diff \
     254        patch-src_corelib_global_qglobal.h.diff \
     255        patch-src_3rdparty_webkit_Source_WebCore_platform_Timer.h.diff \
     256        patch-src_3rdparty_webkit_Source_WebCore_platform_Timer.cpp.diff \
     257        patch-src_3rdparty_webkit_Source_WebKit_qt_WebCoreSupport_NotificationPresenterClientQt.cpp.diff \
     258        patch-src_3rdparty_webkit_Source_WebKit_qt_Api_qgraphicswebview.cpp.diff \
     259        patch-src_3rdparty_webkit_Source_WebCore_platform_network_qt_QNetworkReplyHandler.cpp.diff
     260}
     261
    243262platform darwin {
    244     if {${os.major} >= 13} {
     263    if {${os.major} > 13} {
    245264        # This project needs to be updated to build with clang++ against libc++
    246265        depends_lib
    247266        depends_run
    248267        pre-fetch {
    249             ui_error "$name does not build on OS X 10.9 Mavericks or later."
     268            ui_error "$name does not build on OSX later than 10.9 'Mavericks'."
    250269            error "unsupported platform"
    251270        }
     
    389408        ${worksrcpath}/config.tests/mac
    390409
     410    platform darwin 13 {
     411
     412        # Copy new Version of webkits' lib for OSX 10.9 only.
     413        # Attached by reference:
     414        # https://codereview.qt-project.org/#change,69328
     415        # http://trac.webkit.org/browser/trunk/WebKitLibraries/ChangeLog?rev=157771
     416
     417        copy ${filespath}/libWebKitSystemInterfaceMavericks.a \
     418            ${worksrcpath}/src/3rdparty/webkit/WebKitLibraries
     419    }
    391420}
    392421
  • trunk/dports/aqua/qt4-mac/files/patch-src_3rdparty_webkit_Source_WebKit_qt_QtWebKit.pro.diff

    r97950 r112811  
    1 --- src/3rdparty/webkit/Source/WebKit/qt/QtWebKit.pro.orig      2012-08-08 16:27:13.000000000 -0400
    2 +++ src/3rdparty/webkit/Source/WebKit/qt/QtWebKit.pro   2012-08-08 16:33:29.000000000 -0400
     1--- src/3rdparty/webkit/Source/WebKit/qt/QtWebKit.pro.orig      2013-06-07 07:16:58.000000000 +0200
     2+++ src/3rdparty/webkit/Source/WebKit/qt/QtWebKit.pro   2013-10-30 10:10:17.000000000 +0100
    33@@ -233,7 +233,7 @@
    44                        $$SOURCE_DIR/../WebKitLibraries/
     
    1010         }
    1111 
    12 @@ -297,7 +297,7 @@
     12@@ -255,6 +255,8 @@
     13             LIBS += $$SOURCE_DIR/../WebKitLibraries/libWebKitSystemInterfaceLion.a
     14         } else: equals(DARWIN_MAJOR_VERSION, "12") | contains(QMAKE_MAC_SDK, ".*MacOSX10.8.sdk") {
     15             LIBS += $$SOURCE_DIR/../WebKitLibraries/libWebKitSystemInterfaceMountainLion.a
     16+        } else: equals(DARWIN_MAJOR_VERSION, "13") | contains(QMAKE_MAC_SDK, ".*MacOSX10.9.sdk") {
     17+            LIBS += $$SOURCE_DIR/../WebKitLibraries/libWebKitSystemInterfaceMavericks.a
     18         }
     19     }
     20 }
     21@@ -297,7 +299,7 @@
    1322 
    1423 !symbian-abld:!symbian-sbsv2 {
     
    1928     INSTALLS += modfile
    2029 } else {
    21 @@ -305,7 +305,7 @@
     30@@ -305,7 +307,7 @@
    2231 
    2332     inst_modfile.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} ${QMAKE_FILE_OUT}
  • trunk/dports/aqua/qt4-mac/files/patch-src_plugins_bearer_corewlan_qcorewlanengine.mm.diff

    r94241 r112811  
    1 --- src/plugins/bearer/corewlan/qcorewlanengine.mm.orig 2011-08-04 16:33:29.000000000 +0200
    2 +++ src/plugins/bearer/corewlan/qcorewlanengine.mm      2011-08-04 16:34:21.000000000 +0200
    3 @@ -52,6 +52,10 @@
     1--- src/plugins/bearer/corewlan/qcorewlanengine.mm
     2+++ src/plugins/bearer/corewlan/qcorewlanengine.mm
     3@@ -52,29 +52,17 @@
    44 #include <QtCore/qdebug.h>
    55 
    66 #include <QDir>
    7 +#ifdef MAC_SDK_10_7
    8 +   #include <CoreWLAN/CoreWLANConstants.h>
    9 +   #include <CoreWLAN/CoreWLANTypes.h>
    10 +#endif
    11  #include <CoreWLAN/CoreWLAN.h>
    12  #include <CoreWLAN/CWInterface.h>
    13  #include <CoreWLAN/CWNetwork.h>
     7-#include <CoreWLAN/CoreWLAN.h>
     8-#include <CoreWLAN/CWInterface.h>
     9-#include <CoreWLAN/CWNetwork.h>
     10-#include <CoreWLAN/CWNetwork.h>
     11-#include <CoreWLAN/CW8021XProfile.h>
     12-
     13-#include <Foundation/NSEnumerator.h>
     14-#include <Foundation/NSKeyValueObserving.h>
     15-#include <Foundation/NSAutoreleasePool.h>
     16-#include <Foundation/NSLock.h>
     17-
     18-#include <SystemConfiguration/SCNetworkConfiguration.h>
     19+
     20+extern "C" { // Otherwise it won't find CWKeychain* symbols at link time
     21+#import <CoreWLAN/CoreWLAN.h>
     22+}
     23+
     24 #include "private/qcore_mac_p.h"
     25 
     26 #include <net/if.h>
     27 #include <ifaddrs.h>
     28 
     29-inline QString qt_NSStringToQString(const NSString *nsstr)
     30-{ return QCFString::toQString(reinterpret_cast<const CFStringRef>(nsstr)); }
     31-
     32-inline NSString *qt_QStringToNSString(const QString &qstr)
     33-{ return [const_cast<NSString *>(reinterpret_cast<const NSString *>(QCFString::toCFStringRef(qstr))) autorelease]; }
     34-
     35+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
     36 
     37 @interface QT_MANGLE_NAMESPACE(QNSListener) : NSObject
     38 {
     39@@ -86,6 +74,7 @@ inline NSString *qt_QStringToNSString(const QString &qstr)
     40 - (void)notificationHandler;//:(NSNotification *)notification;
     41 - (void)remove;
     42 - (void)setEngine:(QCoreWlanEngine *)coreEngine;
     43+- (QCoreWlanEngine *)engine;
     44 - (void)dealloc;
     45 
     46 @property (assign) QCoreWlanEngine* engine;
     47@@ -93,7 +82,6 @@ inline NSString *qt_QStringToNSString(const QString &qstr)
     48 @end
     49 
     50 @implementation QT_MANGLE_NAMESPACE(QNSListener)
     51-@synthesize engine;
     52 
     53 - (id) init
     54 {
     55@@ -101,7 +89,7 @@ inline NSString *qt_QStringToNSString(const QString &qstr)
     56     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     57     notificationCenter = [NSNotificationCenter defaultCenter];
     58     currentInterface = [CWInterface interfaceWithName:nil];
     59-    [notificationCenter addObserver:self selector:@selector(notificationHandler:) name:kCWPowerDidChangeNotification object:nil];
     60+    [notificationCenter addObserver:self selector:@selector(notificationHandler:) name:CWPowerDidChangeNotification object:nil];
     61     [locker unlock];
     62     [autoreleasepool release];
     63     return self;
     64@@ -120,6 +108,11 @@ inline NSString *qt_QStringToNSString(const QString &qstr)
     65     [locker unlock];
     66 }
     67 
     68+-(QCoreWlanEngine *)engine
     69+{
     70+    return engine;
     71+}
     72+
     73 -(void)remove
     74 {
     75     [locker lock];
     76@@ -133,7 +126,7 @@ inline NSString *qt_QStringToNSString(const QString &qstr)
     77 }
     78 @end
     79 
     80-QT_MANGLE_NAMESPACE(QNSListener) *listener = 0;
     81+static QT_MANGLE_NAMESPACE(QNSListener) *listener = 0;
     82 
     83 QT_BEGIN_NAMESPACE
     84 
     85@@ -170,36 +163,28 @@ void QScanThread::run()
     86     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     87     QStringList found;
     88     mutex.lock();
     89-    CWInterface *currentInterface = [CWInterface interfaceWithName:qt_QStringToNSString(interfaceName)];
     90+    CWInterface *currentInterface = [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceName)];
     91     mutex.unlock();
     92 
     93-    if([currentInterface power]) {
     94+    if (currentInterface.powerOn) {
     95         NSError *err = nil;
     96-        NSDictionary *parametersDict =  [NSDictionary dictionaryWithObjectsAndKeys:
     97-                                   [NSNumber numberWithBool:YES], kCWScanKeyMerge,
     98-                                   [NSNumber numberWithInt:kCWScanTypeFast], kCWScanKeyScanType,
     99-                                   [NSNumber numberWithInteger:100], kCWScanKeyRestTime, nil];
     100 
     101-        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
     102-        CWNetwork *apNetwork;
     103+        NSSet* apSet = [currentInterface scanForNetworksWithName:nil error:&err];
     104 
     105         if (!err) {
     106-
     107-            for(uint row=0; row < [apArray count]; row++ ) {
     108-                apNetwork = [apArray objectAtIndex:row];
     109-
     110-                const QString networkSsid = qt_NSStringToQString([apNetwork ssid]);
     111+            for (CWNetwork *apNetwork in apSet) {
     112+                const QString networkSsid = QCFString::toQString(CFStringRef([apNetwork ssid]));
     113                 const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
     114                 found.append(id);
     115 
     116                 QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
     117                 bool known = isKnownSsid(networkSsid);
     118-                if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
     119-                    if( networkSsid == qt_NSStringToQString( [currentInterface ssid])) {
     120+                if (currentInterface.serviceActive) {
     121+                    if( networkSsid == QCFString::toQString(CFStringRef([currentInterface ssid]))) {
     122                         state = QNetworkConfiguration::Active;
     123                     }
     124                 }
     125-                if(state == QNetworkConfiguration::Undefined) {
     126+                if (state == QNetworkConfiguration::Undefined) {
     127                     if(known) {
     128                         state = QNetworkConfiguration::Discovered;
     129                     } else {
     130@@ -207,7 +192,7 @@ void QScanThread::run()
     131                     }
     132                 }
     133                 QNetworkConfiguration::Purpose purpose = QNetworkConfiguration::UnknownPurpose;
     134-                if([[apNetwork securityMode] intValue] == kCWSecurityModeOpen) {
     135+                if ([apNetwork supportsSecurity:kCWSecurityNone]) {
     136                     purpose = QNetworkConfiguration::PublicPurpose;
     137                 } else {
     138                     purpose = QNetworkConfiguration::PrivatePurpose;
     139@@ -237,8 +222,8 @@ void QScanThread::run()
     140                 interfaceName = ij.value();
     141             }
     142 
     143-            if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
     144-                if( networkSsid == qt_NSStringToQString([currentInterface ssid])) {
     145+            if (currentInterface.serviceActive) {
     146+                if( networkSsid == QCFString::toQString(CFStringRef([currentInterface ssid]))) {
     147                     state = QNetworkConfiguration::Active;
     148                 }
     149             }
     150@@ -300,14 +285,14 @@ void QScanThread::getUserConfigurations()
     151     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     152     userProfiles.clear();
     153 
     154-    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
     155-    for(uint row=0; row < [wifiInterfaces count]; row++ ) {
     156+    NSSet *wifiInterfaces = [CWInterface interfaceNames];
     157+    for (NSString *ifName in wifiInterfaces) {
     158 
     159-        CWInterface *wifiInterface = [CWInterface interfaceWithName: [wifiInterfaces objectAtIndex:row]];
     160-        if ( ![wifiInterface power] )
     161+        CWInterface *wifiInterface = [CWInterface interfaceWithName: ifName];
     162+        if (!wifiInterface.powerOn)
     163             continue;
     164 
     165-        NSString *nsInterfaceName = [wifiInterface name];
     166+        NSString *nsInterfaceName = wifiInterface.ssid;
     167 // add user configured system networks
     168         SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, (CFStringRef)@"Qt corewlan", nil, nil);
     169         NSDictionary * airportPlist = (NSDictionary *)SCDynamicStoreCopyValue(dynRef, (CFStringRef)[NSString stringWithFormat:@"Setup:/Network/Interface/%@/AirPort", nsInterfaceName]);
     170@@ -316,11 +301,11 @@ void QScanThread::getUserConfigurations()
     171             NSDictionary *prefNetDict = [airportPlist objectForKey:@"PreferredNetworks"];
     172 
     173             NSArray *thisSsidarray = [prefNetDict valueForKey:@"SSID_STR"];
     174-            for(NSString *ssidkey in thisSsidarray) {
     175-                QString thisSsid = qt_NSStringToQString(ssidkey);
     176+            for (NSString *ssidkey in thisSsidarray) {
     177+                QString thisSsid = QCFString::toQString(CFStringRef(ssidkey));
     178                 if(!userProfiles.contains(thisSsid)) {
     179                     QMap <QString,QString> map;
     180-                    map.insert(thisSsid, qt_NSStringToQString(nsInterfaceName));
     181+                    map.insert(thisSsid, QCFString::toQString(CFStringRef(nsInterfaceName)));
     182                     userProfiles.insert(thisSsid, map);
     183                 }
     184             }
     185@@ -329,7 +314,7 @@ void QScanThread::getUserConfigurations()
     186 
     187         // 802.1X user profiles
     188         QString userProfilePath = QDir::homePath() + "/Library/Preferences/com.apple.eap.profiles.plist";
     189-        NSDictionary* eapDict = [[[NSDictionary alloc] initWithContentsOfFile:qt_QStringToNSString(userProfilePath)] autorelease];
     190+        NSDictionary* eapDict = [[[NSDictionary alloc] initWithContentsOfFile: (NSString *)QCFString::toCFStringRef(userProfilePath)] autorelease];
     191         if(eapDict != nil) {
     192             NSString *profileStr= @"Profiles";
     193             NSString *nameStr = @"UserDefinedName";
     194@@ -348,15 +333,15 @@ void QScanThread::getUserConfigurations()
     195                         QString ssid;
     196                         for(int i = 0; i < dictSize; i++) {
     197                             if([nameStr isEqualToString:keys[i]]) {
     198-                                networkName = qt_NSStringToQString(objects[i]);
     199+                                networkName = QCFString::toQString(CFStringRef(objects[i]));
     200                             }
     201                             if([networkSsidStr isEqualToString:keys[i]]) {
     202-                                ssid = qt_NSStringToQString(objects[i]);
     203+                                ssid = QCFString::toQString(CFStringRef(objects[i]));
     204                             }
     205                             if(!userProfiles.contains(networkName)
     206                                 && !ssid.isEmpty()) {
     207                                 QMap<QString,QString> map;
     208-                                map.insert(ssid, qt_NSStringToQString(nsInterfaceName));
     209+                                map.insert(ssid, QCFString::toQString(CFStringRef(nsInterfaceName)));
     210                                 userProfiles.insert(networkName, map);
     211                             }
     212                         }
     213@@ -444,7 +429,7 @@ void QCoreWlanEngine::initialize()
     214     QMutexLocker locker(&mutex);
     215     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     216 
     217-    if([[CWInterface supportedInterfaces] count] > 0 && !listener) {
     218+    if ([[CWInterface interfaceNames] count] > 0 && !listener) {
     219         listener = [[QT_MANGLE_NAMESPACE(QNSListener) alloc] init];
     220         listener.engine = this;
     221         hasWifi = true;
     222@@ -479,141 +464,68 @@ void QCoreWlanEngine::connectToId(const QString &id)
     223     QString interfaceString = getInterfaceFromId(id);
     224 
     225     CWInterface *wifiInterface =
     226-        [CWInterface interfaceWithName: qt_QStringToNSString(interfaceString)];
     227+        [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceString)];
     228 
     229-    if ([wifiInterface power]) {
     230+    if (wifiInterface.powerOn) {
     231         NSError *err = nil;
     232-        NSMutableDictionary *params = [NSMutableDictionary dictionaryWithCapacity:0];
     233-
     234         QString wantedSsid;
     235-
     236         QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
     237 
     238         const QString idHash = QString::number(qHash(QLatin1String("corewlan:") + ptr->name));
     239         const QString idHash2 = QString::number(qHash(QLatin1String("corewlan:") + scanThread->getNetworkNameFromSsid(ptr->name)));
     240 
     241-        bool using8021X = false;
     242-        if (idHash2 != id) {
     243-            NSArray *array = [CW8021XProfile allUser8021XProfiles];
     244-
     245-            for (NSUInteger i = 0; i < [array count]; ++i) {
     246-                const QString networkNameHashCheck = QString::number(qHash(QLatin1String("corewlan:") + qt_NSStringToQString([[array objectAtIndex:i] userDefinedName])));
     247-
     248-                const QString ssidHash = QString::number(qHash(QLatin1String("corewlan:") + qt_NSStringToQString([[array objectAtIndex:i] ssid])));
     249-
     250-                if (id == networkNameHashCheck || id == ssidHash) {
     251-                    const QString thisName = scanThread->getSsidFromNetworkName(id);
     252-                    if (thisName.isEmpty())
     253-                        wantedSsid = id;
     254-                    else
     255-                        wantedSsid = thisName;
     256-
     257-                    [params setValue: [array objectAtIndex:i] forKey:kCWAssocKey8021XProfile];
     258-                    using8021X = true;
     259-                    break;
     260-                }
     261+        QString wantedNetwork;
     262+        QMapIterator<QString, QMap<QString, QString> > i(scanThread->userProfiles);
     263+        while (i.hasNext()) {
     264+            i.next();
     265+            wantedNetwork = i.key();
     266+            const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") + wantedNetwork));
     267+            if (id == networkNameHash) {
     268+                wantedSsid = scanThread->getSsidFromNetworkName(wantedNetwork);
     269+                break;
     270             }
     271         }
     272 
     273-        if (!using8021X) {
     274-            QString wantedNetwork;
     275-            QMapIterator<QString, QMap<QString,QString> > i(scanThread->userProfiles);
     276-            while (i.hasNext()) {
     277-                i.next();
     278-                wantedNetwork = i.key();
     279-                const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") + wantedNetwork));
     280-                if (id == networkNameHash) {
     281-                    wantedSsid =  scanThread->getSsidFromNetworkName(wantedNetwork);
     282-                    break;
     283-                }
     284-            }
     285-        }
     286-        NSDictionary *scanParameters = [NSDictionary dictionaryWithObjectsAndKeys:
     287-                                        [NSNumber numberWithBool:YES], kCWScanKeyMerge,
     288-                                        [NSNumber numberWithInt:kCWScanTypeFast], kCWScanKeyScanType,
     289-                                        [NSNumber numberWithInteger:100], kCWScanKeyRestTime,
     290-                                        qt_QStringToNSString(wantedSsid), kCWScanKeySSID,
     291-                                        nil];
     292-
     293-        NSArray *scanArray = [wifiInterface scanForNetworksWithParameters:scanParameters error:&err];
     294+        NSSet *scanSet = [wifiInterface scanForNetworksWithName:(NSString *)QCFString::toCFStringRef(wantedSsid) error:&err];
     295 
     296         if(!err) {
     297-            for(uint row=0; row < [scanArray count]; row++ ) {
     298-                CWNetwork *apNetwork = [scanArray objectAtIndex:row];
     299-
     300-                if(wantedSsid == qt_NSStringToQString([apNetwork ssid])) {
     301-
     302-                    if(!using8021X) {
     303-                        SecKeychainAttribute attributes[3];
     304-
     305-                        NSString *account = [apNetwork ssid];
     306-                        NSString *keyKind = @"AirPort network password";
     307-                        NSString *keyName = account;
     308-
     309-                        attributes[0].tag = kSecAccountItemAttr;
     310-                        attributes[0].data = (void *)[account UTF8String];
     311-                        attributes[0].length = [account length];
     312-
     313-                        attributes[1].tag = kSecDescriptionItemAttr;
     314-                        attributes[1].data = (void *)[keyKind UTF8String];
     315-                        attributes[1].length = [keyKind length];
     316-
     317-                        attributes[2].tag = kSecLabelItemAttr;
     318-                        attributes[2].data = (void *)[keyName UTF8String];
     319-                        attributes[2].length = [keyName length];
     320-
     321-                        SecKeychainAttributeList attributeList = {3,attributes};
     322-
     323-                        SecKeychainSearchRef searchRef;
     324-                        SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, &attributeList, &searchRef);
     325-
     326-                        NSString *password = @"";
     327-                        SecKeychainItemRef searchItem;
     328-
     329-                        if (SecKeychainSearchCopyNext(searchRef, &searchItem) == noErr) {
     330-                            UInt32 realPasswordLength;
     331-                            SecKeychainAttribute attributesW[8];
     332-                            attributesW[0].tag = kSecAccountItemAttr;
     333-                            SecKeychainAttributeList listW = {1,attributesW};
     334-                            char *realPassword;
     335-                            OSStatus status = SecKeychainItemCopyContent(searchItem, NULL, &listW, &realPasswordLength,(void **)&realPassword);
     336-
     337-                            if (status == noErr) {
     338-                                if (realPassword != NULL) {
     339-
     340-                                    QByteArray pBuf;
     341-                                    pBuf.resize(realPasswordLength);
     342-                                    pBuf.prepend(realPassword);
     343-                                    pBuf.insert(realPasswordLength,'\0');
     344-
     345-                                    password = [NSString stringWithUTF8String:pBuf];
     346-                                }
     347-                                SecKeychainItemFreeContent(&listW, realPassword);
     348-                            }
     349-
     350-                            CFRelease(searchItem);
     351-                        } else {
     352-                            qDebug() << "SecKeychainSearchCopyNext error";
     353-                        }
     354-                        [params setValue: password forKey: kCWAssocKeyPassphrase];
     355-                    } // end using8021X
     356-
     357-
     358-                    bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
     359+            for (CWNetwork *apNetwork in scanSet) {
     360+                CFDataRef ssidData = (CFDataRef)[apNetwork ssidData];
     361+                bool result = false;
     362+
     363+                SecIdentityRef identity = 0;
     364+                // Check first whether we require IEEE 802.1X authentication for the wanted SSID
     365+                if (CWKeychainCopyEAPIdentity(ssidData, &identity) == errSecSuccess) {
     366+                    CFStringRef username = 0;
     367+                    CFStringRef password = 0;
     368+                    if (CWKeychainCopyEAPUsernameAndPassword(ssidData, &username, &password) == errSecSuccess) {
     369+                        result = [wifiInterface associateToEnterpriseNetwork:apNetwork
     370+                                    identity:identity username:(NSString *)username password:(NSString *)password
     371+                                    error:&err];
     372+                        CFRelease(username);
     373+                        CFRelease(password);
     374+                    }
     375+                    CFRelease(identity);
     376+                } else {
     377+                    CFStringRef password = 0;
     378+                    if (CWKeychainCopyPassword(ssidData, &password) == errSecSuccess) {
     379+                        result = [wifiInterface associateToNetwork:apNetwork password:(NSString *)password error:&err];
     380+                        CFRelease(password);
     381+                    }
     382+                }
     383 
     384-                    if(!err) {
     385-                        if(!result) {
     386-                            emit connectionError(id, ConnectError);
     387-                        } else {
     388-                            return;
     389-                        }
     390+                if (!err) {
     391+                    if (!result) {
     392+                        emit connectionError(id, ConnectError);
     393                     } else {
     394-                        qDebug() <<"associate ERROR"<<  qt_NSStringToQString([err localizedDescription ]);
     395+                        return;
     396                     }
     397+                } else {
     398+                    qDebug() <<"associate ERROR"<<  QCFString::toQString(CFStringRef([err localizedDescription ]));
     399                 }
     400             } //end scan network
     401         } else {
     402-            qDebug() <<"scan ERROR"<<  qt_NSStringToQString([err localizedDescription ]);
     403+            qDebug() <<"scan ERROR"<<  QCFString::toQString(CFStringRef([err localizedDescription ]));
     404         }
     405         emit connectionError(id, InterfaceLookupError);
     406     }
     407@@ -631,10 +543,10 @@ void QCoreWlanEngine::disconnectFromId(const QString &id)
     408     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     409 
     410     CWInterface *wifiInterface =
     411-        [CWInterface interfaceWithName: qt_QStringToNSString(interfaceString)];
     412+        [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceString)];
     413 
     414     [wifiInterface disassociate];
     415-    if ([[wifiInterface interfaceState]intValue] != kCWInterfaceStateInactive) {
     416+    if (wifiInterface.serviceActive) {
     417         locker.unlock();
     418         emit connectionError(id, DisconnectionError);
     419         locker.relock();
     420@@ -654,9 +566,9 @@ void QCoreWlanEngine::doRequestUpdate()
     421 
     422     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     423 
     424-    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
     425-    for (uint row = 0; row < [wifiInterfaces count]; ++row) {
     426-            scanThread->interfaceName = qt_NSStringToQString([wifiInterfaces objectAtIndex:row]);
     427+    NSSet *wifiInterfaces = [CWInterface interfaceNames];
     428+    for (NSString *ifName in wifiInterfaces) {
     429+            scanThread->interfaceName = QCFString::toQString(CFStringRef(ifName));
     430             scanThread->start();
     431     }
     432     locker.unlock();
     433@@ -669,8 +581,8 @@ bool QCoreWlanEngine::isWifiReady(const QString &wifiDeviceName)
     434     bool haswifi = false;
     435     if(hasWifi) {
     436         NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     437-        CWInterface *defaultInterface = [CWInterface interfaceWithName: qt_QStringToNSString(wifiDeviceName)];
     438-        if([defaultInterface power]) {
     439+        CWInterface *defaultInterface = [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(wifiDeviceName)];
     440+        if (defaultInterface.powerOn) {
     441             haswifi = true;
     442         }
     443         [autoreleasepool release];
     444@@ -898,7 +810,7 @@ quint64 QCoreWlanEngine::startTime(const QString &identifier)
     445                 bool ok = false;
     446                 for(int i = 0; i < dictSize; i++) {
     447                     if([ssidStr isEqualToString:keys[i]]) {
     448-                        const QString ident = QString::number(qHash(QLatin1String("corewlan:") + qt_NSStringToQString(objects[i])));
     449+                        const QString ident = QString::number(qHash(QLatin1String("corewlan:") + QCFString::toQString(CFStringRef(objects[i]))));
     450                         if(ident == identifier) {
     451                             ok = true;
     452                         }
     453@@ -944,3 +856,7 @@ quint64 QCoreWlanEngine::getBytes(const QString &interfaceName, bool b)
     454 }
     455 
     456 QT_END_NAMESPACE
     457+
     458+#else // QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE
     459+#include "qcorewlanengine_10_6.mm"
     460+#endif
     461diff --git a/src/plugins/bearer/corewlan/qcorewlanengine_10_6.mm b/src/plugins/bearer/corewlan/qcorewlanengine_10_6.mm
     462new file mode 100644
     463index 0000000..a3bf615
     464--- /dev/null
     465+++ src/plugins/bearer/corewlan/qcorewlanengine_10_6.mm
     466@@ -0,0 +1,916 @@
     467+/****************************************************************************
     468+**
     469+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
     470+** Contact: http://www.qt-project.org/legal
     471+**
     472+** This file is part of the plugins of the Qt Toolkit.
     473+**
     474+** $QT_BEGIN_LICENSE:LGPL$
     475+** Commercial License Usage
     476+** Licensees holding valid commercial Qt licenses may use this file in
     477+** accordance with the commercial license agreement provided with the
     478+** Software or, alternatively, in accordance with the terms contained in
     479+** a written agreement between you and Digia.  For licensing terms and
     480+** conditions see http://qt.digia.com/licensing.  For further information
     481+** use the contact form at http://qt.digia.com/contact-us.
     482+**
     483+** GNU Lesser General Public License Usage
     484+** Alternatively, this file may be used under the terms of the GNU Lesser
     485+** General Public License version 2.1 as published by the Free Software
     486+** Foundation and appearing in the file LICENSE.LGPL included in the
     487+** packaging of this file.  Please review the following information to
     488+** ensure the GNU Lesser General Public License version 2.1 requirements
     489+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
     490+**
     491+** In addition, as a special exception, Digia gives you certain additional
     492+** rights.  These rights are described in the Digia Qt LGPL Exception
     493+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
     494+**
     495+** GNU General Public License Usage
     496+** Alternatively, this file may be used under the terms of the GNU
     497+** General Public License version 3.0 as published by the Free Software
     498+** Foundation and appearing in the file LICENSE.GPL included in the
     499+** packaging of this file.  Please review the following information to
     500+** ensure the GNU General Public License version 3.0 requirements will be
     501+** met: http://www.gnu.org/copyleft/gpl.html.
     502+**
     503+**
     504+** $QT_END_LICENSE$
     505+**
     506+****************************************************************************/
     507+
     508+#include <SystemConfiguration/SCNetworkConfiguration.h>
     509+
     510+@interface QT_MANGLE_NAMESPACE(QNSListener) : NSObject
     511+{
     512+    NSNotificationCenter *notificationCenter;
     513+    CWInterface *currentInterface;
     514+    QCoreWlanEngine *engine;
     515+    NSLock *locker;
     516+}
     517+- (void)notificationHandler;//:(NSNotification *)notification;
     518+- (void)remove;
     519+- (void)setEngine:(QCoreWlanEngine *)coreEngine;
     520+- (QCoreWlanEngine *)engine;
     521+- (void)dealloc;
     522+
     523+@property (assign) QCoreWlanEngine* engine;
     524+
     525+@end
     526+
     527+@implementation QT_MANGLE_NAMESPACE(QNSListener)
     528+
     529+- (id) init
     530+{
     531+    [locker lock];
     532+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     533+    notificationCenter = [NSNotificationCenter defaultCenter];
     534+    currentInterface = [CWInterface interfaceWithName:nil];
     535+    [notificationCenter addObserver:self selector:@selector(notificationHandler:) name:kCWPowerDidChangeNotification object:nil];
     536+    [locker unlock];
     537+    [autoreleasepool release];
     538+    return self;
     539+}
     540+
     541+-(void)dealloc
     542+{
     543+    [super dealloc];
     544+}
     545+
     546+-(void)setEngine:(QCoreWlanEngine *)coreEngine
     547+{
     548+    [locker lock];
     549+    if(!engine)
     550+        engine = coreEngine;
     551+    [locker unlock];
     552+}
     553+
     554+-(QCoreWlanEngine *)engine
     555+{
     556+    return engine;
     557+}
     558+
     559+-(void)remove
     560+{
     561+    [locker lock];
     562+    [notificationCenter removeObserver:self];
     563+    [locker unlock];
     564+}
     565+
     566+- (void)notificationHandler//:(NSNotification *)notification
     567+{
     568+    engine->requestUpdate();
     569+}
     570+@end
     571+
     572+static QT_MANGLE_NAMESPACE(QNSListener) *listener = 0;
     573+
     574+QT_BEGIN_NAMESPACE
     575+
     576+void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef changedKeys, void *info)
     577+{
     578+    for ( long i = 0; i < CFArrayGetCount(changedKeys); i++) {
     579+
     580+        QString changed =  QCFString::toQString(CFStringRef((CFStringRef)CFArrayGetValueAtIndex(changedKeys, i)));
     581+        if( changed.contains("/Network/Global/IPv4")) {
     582+            QCoreWlanEngine* wlanEngine = static_cast<QCoreWlanEngine*>(info);
     583+            wlanEngine->requestUpdate();
     584+        }
     585+    }
     586+    return;
     587+}
     588+
     589+
     590+QScanThread::QScanThread(QObject *parent)
     591+    :QThread(parent)
     592+{
     593+}
     594+
     595+QScanThread::~QScanThread()
     596+{
     597+}
     598+
     599+void QScanThread::quit()
     600+{
     601+    wait();
     602+}
     603+
     604+void QScanThread::run()
     605+{
     606+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     607+    QStringList found;
     608+    mutex.lock();
     609+    CWInterface *currentInterface = [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceName)];
     610+    mutex.unlock();
     611+
     612+    if([currentInterface power]) {
     613+        NSError *err = nil;
     614+        NSDictionary *parametersDict =  [NSDictionary dictionaryWithObjectsAndKeys:
     615+                                   [NSNumber numberWithBool:YES], kCWScanKeyMerge,
     616+                                   [NSNumber numberWithInt:kCWScanTypeFast], kCWScanKeyScanType,
     617+                                   [NSNumber numberWithInteger:100], kCWScanKeyRestTime, nil];
     618+
     619+        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
     620+        CWNetwork *apNetwork;
     621+
     622+        if (!err) {
     623+
     624+            for(uint row=0; row < [apArray count]; row++ ) {
     625+                apNetwork = [apArray objectAtIndex:row];
     626+
     627+                const QString networkSsid = QCFString::toQString(CFStringRef([apNetwork ssid]));
     628+                const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
     629+                found.append(id);
     630+
     631+                QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
     632+                bool known = isKnownSsid(networkSsid);
     633+                if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
     634+                    if( networkSsid == QCFString::toQString(CFStringRef([currentInterface ssid]))) {
     635+                        state = QNetworkConfiguration::Active;
     636+                    }
     637+                }
     638+                if(state == QNetworkConfiguration::Undefined) {
     639+                    if(known) {
     640+                        state = QNetworkConfiguration::Discovered;
     641+                    } else {
     642+                        state = QNetworkConfiguration::Undefined;
     643+                    }
     644+                }
     645+                QNetworkConfiguration::Purpose purpose = QNetworkConfiguration::UnknownPurpose;
     646+                if([[apNetwork securityMode] intValue] == kCWSecurityModeOpen) {
     647+                    purpose = QNetworkConfiguration::PublicPurpose;
     648+                } else {
     649+                    purpose = QNetworkConfiguration::PrivatePurpose;
     650+                }
     651+
     652+                found.append(foundNetwork(id, networkSsid, state, interfaceName, purpose));
     653+
     654+            }
     655+        }
     656+    }
     657+    // add known configurations that are not around.
     658+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
     659+    while (i.hasNext()) {
     660+        i.next();
     661+
     662+        QString networkName = i.key();
     663+        const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkName));
     664+
     665+        if(!found.contains(id)) {
     666+            QString networkSsid = getSsidFromNetworkName(networkName);
     667+            const QString ssidId = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
     668+            QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
     669+            QString interfaceName;
     670+            QMapIterator<QString, QString> ij(i.value());
     671+            while (ij.hasNext()) {
     672+                ij.next();
     673+                interfaceName = ij.value();
     674+            }
     675+
     676+            if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
     677+                if( networkSsid == QCFString::toQString(CFStringRef([currentInterface ssid]))) {
     678+                    state = QNetworkConfiguration::Active;
     679+                }
     680+            }
     681+            if(state == QNetworkConfiguration::Undefined) {
     682+                if( userProfiles.contains(networkName)
     683+                    && found.contains(ssidId)) {
     684+                    state = QNetworkConfiguration::Discovered;
     685+                }
     686+            }
     687+
     688+            if(state == QNetworkConfiguration::Undefined) {
     689+                state = QNetworkConfiguration::Defined;
     690+            }
     691+
     692+            found.append(foundNetwork(id, networkName, state, interfaceName, QNetworkConfiguration::UnknownPurpose));
     693+        }
     694+    }
     695+    emit networksChanged();
     696+    [autoreleasepool release];
     697+}
     698+
     699+QStringList QScanThread::foundNetwork(const QString &id, const QString &name, const QNetworkConfiguration::StateFlags state, const QString &interfaceName, const QNetworkConfiguration::Purpose purpose)
     700+{
     701+    QStringList found;
     702+    QMutexLocker locker(&mutex);
     703+        QNetworkConfigurationPrivate *ptr = new QNetworkConfigurationPrivate;
     704+
     705+        ptr->name = name;
     706+        ptr->isValid = true;
     707+        ptr->id = id;
     708+        ptr->state = state;
     709+        ptr->type = QNetworkConfiguration::InternetAccessPoint;
     710+        ptr->bearerType = QNetworkConfiguration::BearerWLAN;
     711+        ptr->purpose = purpose;
     712+
     713+        fetchedConfigurations.append( ptr);
     714+        configurationInterface.insert(ptr->id, interfaceName);
     715+
     716+        locker.unlock();
     717+        locker.relock();
     718+       found.append(id);
     719+    return found;
     720+}
     721+
     722+QList<QNetworkConfigurationPrivate *> QScanThread::getConfigurations()
     723+{
     724+    QMutexLocker locker(&mutex);
     725+
     726+    QList<QNetworkConfigurationPrivate *> foundConfigurations = fetchedConfigurations;
     727+    fetchedConfigurations.clear();
     728+
     729+    return foundConfigurations;
     730+}
     731+
     732+void QScanThread::getUserConfigurations()
     733+{
     734+    QMutexLocker locker(&mutex);
     735+
     736+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     737+    userProfiles.clear();
     738+
     739+    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
     740+    for(uint row=0; row < [wifiInterfaces count]; row++ ) {
     741+
     742+        CWInterface *wifiInterface = [CWInterface interfaceWithName: [wifiInterfaces objectAtIndex:row]];
     743+        if ( ![wifiInterface power] )
     744+            continue;
     745+
     746+        NSString *nsInterfaceName = [wifiInterface name];
     747+// add user configured system networks
     748+        SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, (CFStringRef)@"Qt corewlan", nil, nil);
     749+        NSDictionary * airportPlist = (NSDictionary *)SCDynamicStoreCopyValue(dynRef, (CFStringRef)[NSString stringWithFormat:@"Setup:/Network/Interface/%@/AirPort", nsInterfaceName]);
     750+        CFRelease(dynRef);
     751+        if(airportPlist != nil) {
     752+            NSDictionary *prefNetDict = [airportPlist objectForKey:@"PreferredNetworks"];
     753+
     754+            NSArray *thisSsidarray = [prefNetDict valueForKey:@"SSID_STR"];
     755+            for(NSString *ssidkey in thisSsidarray) {
     756+                QString thisSsid = QCFString::toQString(CFStringRef(ssidkey));
     757+                if(!userProfiles.contains(thisSsid)) {
     758+                    QMap <QString,QString> map;
     759+                    map.insert(thisSsid, QCFString::toQString(CFStringRef(nsInterfaceName)));
     760+                    userProfiles.insert(thisSsid, map);
     761+                }
     762+            }
     763+            CFRelease(airportPlist);
     764+        }
     765+
     766+        // 802.1X user profiles
     767+        QString userProfilePath = QDir::homePath() + "/Library/Preferences/com.apple.eap.profiles.plist";
     768+        NSDictionary* eapDict = [[[NSDictionary alloc] initWithContentsOfFile: (NSString *)QCFString::toCFStringRef(userProfilePath)] autorelease];
     769+        if(eapDict != nil) {
     770+            NSString *profileStr= @"Profiles";
     771+            NSString *nameStr = @"UserDefinedName";
     772+            NSString *networkSsidStr = @"Wireless Network";
     773+            for (id profileKey in eapDict) {
     774+                if ([profileStr isEqualToString:profileKey]) {
     775+                    NSDictionary *itemDict = [eapDict objectForKey:profileKey];
     776+                    for (id itemKey in itemDict) {
     777+
     778+                        NSInteger dictSize = [itemKey count];
     779+                        id objects[dictSize];
     780+                        id keys[dictSize];
     781+
     782+                        [itemKey getObjects:objects andKeys:keys];
     783+                        QString networkName;
     784+                        QString ssid;
     785+                        for(int i = 0; i < dictSize; i++) {
     786+                            if([nameStr isEqualToString:keys[i]]) {
     787+                                networkName = QCFString::toQString(CFStringRef(objects[i]));
     788+                            }
     789+                            if([networkSsidStr isEqualToString:keys[i]]) {
     790+                                ssid = QCFString::toQString(CFStringRef(objects[i]));
     791+                            }
     792+                            if(!userProfiles.contains(networkName)
     793+                                && !ssid.isEmpty()) {
     794+                                QMap<QString,QString> map;
     795+                                map.insert(ssid, QCFString::toQString(CFStringRef(nsInterfaceName)));
     796+                                userProfiles.insert(networkName, map);
     797+                            }
     798+                        }
     799+                    }
     800+                }
     801+            }
     802+        }
     803+    }
     804+    [autoreleasepool release];
     805+}
     806+
     807+QString QScanThread::getSsidFromNetworkName(const QString &name)
     808+{
     809+    QMutexLocker locker(&mutex);
     810+
     811+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
     812+    while (i.hasNext()) {
     813+        i.next();
     814+        QMap<QString,QString> map = i.value();
     815+        QMapIterator<QString, QString> ij(i.value());
     816+         while (ij.hasNext()) {
     817+             ij.next();
     818+             const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") +i.key()));
     819+             if(name == i.key() || name == networkNameHash) {
     820+                 return ij.key();
     821+             }
     822+        }
     823+    }
     824+    return QString();
     825+}
     826+
     827+QString QScanThread::getNetworkNameFromSsid(const QString &ssid)
     828+{
     829+    QMutexLocker locker(&mutex);
     830+
     831+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
     832+    while (i.hasNext()) {
     833+        i.next();
     834+        QMap<QString,QString> map = i.value();
     835+        QMapIterator<QString, QString> ij(i.value());
     836+         while (ij.hasNext()) {
     837+             ij.next();
     838+             if(ij.key() == ssid) {
     839+                 return i.key();
     840+             }
     841+         }
     842+    }
     843+    return QString();
     844+}
     845+
     846+bool QScanThread::isKnownSsid(const QString &ssid)
     847+{
     848+    QMutexLocker locker(&mutex);
     849+
     850+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
     851+    while (i.hasNext()) {
     852+        i.next();
     853+        QMap<QString,QString> map = i.value();
     854+        if(map.keys().contains(ssid)) {
     855+            return true;
     856+        }
     857+    }
     858+    return false;
     859+}
     860+
     861+
     862+QCoreWlanEngine::QCoreWlanEngine(QObject *parent)
     863+:   QBearerEngineImpl(parent), scanThread(0)
     864+{
     865+    scanThread = new QScanThread(this);
     866+    connect(scanThread, SIGNAL(networksChanged()),
     867+            this, SLOT(networksChanged()));
     868+}
     869+
     870+QCoreWlanEngine::~QCoreWlanEngine()
     871+{
     872+    while (!foundConfigurations.isEmpty())
     873+        delete foundConfigurations.takeFirst();
     874+    [listener remove];
     875+    [listener release];
     876+}
     877+
     878+void QCoreWlanEngine::initialize()
     879+{
     880+    QMutexLocker locker(&mutex);
     881+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     882+
     883+    if([[CWInterface supportedInterfaces] count] > 0 && !listener) {
     884+        listener = [[QT_MANGLE_NAMESPACE(QNSListener) alloc] init];
     885+        listener.engine = this;
     886+        hasWifi = true;
     887+    } else {
     888+        hasWifi = false;
     889+    }
     890+    storeSession = NULL;
     891+
     892+    startNetworkChangeLoop();
     893+    [autoreleasepool release];
     894+}
     895+
     896+
     897+QString QCoreWlanEngine::getInterfaceFromId(const QString &id)
     898+{
     899+    QMutexLocker locker(&mutex);
     900+
     901+    return scanThread->configurationInterface.value(id);
     902+}
     903+
     904+bool QCoreWlanEngine::hasIdentifier(const QString &id)
     905+{
     906+    QMutexLocker locker(&mutex);
     907+
     908+    return scanThread->configurationInterface.contains(id);
     909+}
     910+
     911+void QCoreWlanEngine::connectToId(const QString &id)
     912+{
     913+    QMutexLocker locker(&mutex);
     914+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     915+    QString interfaceString = getInterfaceFromId(id);
     916+
     917+    CWInterface *wifiInterface =
     918+        [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceString)];
     919+
     920+    if ([wifiInterface power]) {
     921+        NSError *err = nil;
     922+        NSMutableDictionary *params = [NSMutableDictionary dictionaryWithCapacity:0];
     923+
     924+        QString wantedSsid;
     925+
     926+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
     927+
     928+        const QString idHash = QString::number(qHash(QLatin1String("corewlan:") + ptr->name));
     929+        const QString idHash2 = QString::number(qHash(QLatin1String("corewlan:") + scanThread->getNetworkNameFromSsid(ptr->name)));
     930+
     931+        bool using8021X = false;
     932+        if (idHash2 != id) {
     933+            NSArray *array = [CW8021XProfile allUser8021XProfiles];
     934+
     935+            for (NSUInteger i = 0; i < [array count]; ++i) {
     936+                const QString networkNameHashCheck = QString::number(qHash(QLatin1String("corewlan:") + QCFString::toQString(CFStringRef([[array objectAtIndex:i] userDefinedName]))));
     937+
     938+                const QString ssidHash = QString::number(qHash(QLatin1String("corewlan:") + QCFString::toQString(CFStringRef([[array objectAtIndex:i] ssid]))));
     939+
     940+                if (id == networkNameHashCheck || id == ssidHash) {
     941+                    const QString thisName = scanThread->getSsidFromNetworkName(id);
     942+                    if (thisName.isEmpty())
     943+                        wantedSsid = id;
     944+                    else
     945+                        wantedSsid = thisName;
     946+
     947+                    [params setValue: [array objectAtIndex:i] forKey:kCWAssocKey8021XProfile];
     948+                    using8021X = true;
     949+                    break;
     950+                }
     951+            }
     952+        }
     953+
     954+        if (!using8021X) {
     955+            QString wantedNetwork;
     956+            QMapIterator<QString, QMap<QString,QString> > i(scanThread->userProfiles);
     957+            while (i.hasNext()) {
     958+                i.next();
     959+                wantedNetwork = i.key();
     960+                const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") + wantedNetwork));
     961+                if (id == networkNameHash) {
     962+                    wantedSsid =  scanThread->getSsidFromNetworkName(wantedNetwork);
     963+                    break;
     964+                }
     965+            }
     966+        }
     967+        NSDictionary *scanParameters = [NSDictionary dictionaryWithObjectsAndKeys:
     968+                                        [NSNumber numberWithBool:YES], kCWScanKeyMerge,
     969+                                        [NSNumber numberWithInt:kCWScanTypeFast], kCWScanKeyScanType,
     970+                                        [NSNumber numberWithInteger:100], kCWScanKeyRestTime,
     971+                                        (NSString *)QCFString::toCFStringRef(wantedSsid), kCWScanKeySSID,
     972+                                        nil];
     973+
     974+        NSArray *scanArray = [wifiInterface scanForNetworksWithParameters:scanParameters error:&err];
     975+
     976+        if(!err) {
     977+            for(uint row=0; row < [scanArray count]; row++ ) {
     978+                CWNetwork *apNetwork = [scanArray objectAtIndex:row];
     979+
     980+                if(wantedSsid == QCFString::toQString(CFStringRef([apNetwork ssid]))) {
     981+
     982+                    if(!using8021X) {
     983+                        SecKeychainAttribute attributes[3];
     984+
     985+                        NSString *account = [apNetwork ssid];
     986+                        NSString *keyKind = @"AirPort network password";
     987+                        NSString *keyName = account;
     988+
     989+                        attributes[0].tag = kSecAccountItemAttr;
     990+                        attributes[0].data = (void *)[account UTF8String];
     991+                        attributes[0].length = [account length];
     992+
     993+                        attributes[1].tag = kSecDescriptionItemAttr;
     994+                        attributes[1].data = (void *)[keyKind UTF8String];
     995+                        attributes[1].length = [keyKind length];
     996+
     997+                        attributes[2].tag = kSecLabelItemAttr;
     998+                        attributes[2].data = (void *)[keyName UTF8String];
     999+                        attributes[2].length = [keyName length];
     1000+
     1001+                        SecKeychainAttributeList attributeList = {3,attributes};
     1002+
     1003+                        SecKeychainSearchRef searchRef;
     1004+                        SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, &attributeList, &searchRef);
     1005+
     1006+                        NSString *password = @"";
     1007+                        SecKeychainItemRef searchItem;
     1008+
     1009+                        if (SecKeychainSearchCopyNext(searchRef, &searchItem) == noErr) {
     1010+                            UInt32 realPasswordLength;
     1011+                            SecKeychainAttribute attributesW[8];
     1012+                            attributesW[0].tag = kSecAccountItemAttr;
     1013+                            SecKeychainAttributeList listW = {1,attributesW};
     1014+                            char *realPassword;
     1015+                            OSStatus status = SecKeychainItemCopyContent(searchItem, NULL, &listW, &realPasswordLength,(void **)&realPassword);
     1016+
     1017+                            if (status == noErr) {
     1018+                                if (realPassword != NULL) {
     1019+
     1020+                                    QByteArray pBuf;
     1021+                                    pBuf.resize(realPasswordLength);
     1022+                                    pBuf.prepend(realPassword);
     1023+                                    pBuf.insert(realPasswordLength,'\0');
     1024+
     1025+                                    password = [NSString stringWithUTF8String:pBuf];
     1026+                                }
     1027+                                SecKeychainItemFreeContent(&listW, realPassword);
     1028+                            }
     1029+
     1030+                            CFRelease(searchItem);
     1031+                        } else {
     1032+                            qDebug() << "SecKeychainSearchCopyNext error";
     1033+                        }
     1034+                        [params setValue: password forKey: kCWAssocKeyPassphrase];
     1035+                    } // end using8021X
     1036+
     1037+
     1038+                    bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
     1039+
     1040+                    if(!err) {
     1041+                        if(!result) {
     1042+                            emit connectionError(id, ConnectError);
     1043+                        } else {
     1044+                            return;
     1045+                        }
     1046+                    } else {
     1047+                        qDebug() <<"associate ERROR"<<  QCFString::toQString(CFStringRef([err localizedDescription ]));
     1048+                    }
     1049+                }
     1050+            } //end scan network
     1051+        } else {
     1052+            qDebug() <<"scan ERROR"<<  QCFString::toQString(CFStringRef([err localizedDescription ]));
     1053+        }
     1054+        emit connectionError(id, InterfaceLookupError);
     1055+    }
     1056+
     1057+    locker.unlock();
     1058+    emit connectionError(id, InterfaceLookupError);
     1059+    [autoreleasepool release];
     1060+}
     1061+
     1062+void QCoreWlanEngine::disconnectFromId(const QString &id)
     1063+{
     1064+    QMutexLocker locker(&mutex);
     1065+
     1066+    QString interfaceString = getInterfaceFromId(id);
     1067+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     1068+
     1069+    CWInterface *wifiInterface =
     1070+        [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(interfaceString)];
     1071+
     1072+    [wifiInterface disassociate];
     1073+    if ([[wifiInterface interfaceState]intValue] != kCWInterfaceStateInactive) {
     1074+        locker.unlock();
     1075+        emit connectionError(id, DisconnectionError);
     1076+        locker.relock();
     1077+    }
     1078+    [autoreleasepool release];
     1079+}
     1080+
     1081+void QCoreWlanEngine::requestUpdate()
     1082+{
     1083+    scanThread->getUserConfigurations();
     1084+    doRequestUpdate();
     1085+}
     1086+
     1087+void QCoreWlanEngine::doRequestUpdate()
     1088+{
     1089+    QMutexLocker locker(&mutex);
     1090+
     1091+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     1092+
     1093+    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
     1094+    for (uint row = 0; row < [wifiInterfaces count]; ++row) {
     1095+            scanThread->interfaceName = QCFString::toQString(CFStringRef([wifiInterfaces objectAtIndex:row]));
     1096+            scanThread->start();
     1097+    }
     1098+    locker.unlock();
     1099+    [autoreleasepool release];
     1100+}
     1101+
     1102+bool QCoreWlanEngine::isWifiReady(const QString &wifiDeviceName)
     1103+{
     1104+    QMutexLocker locker(&mutex);
     1105+    bool haswifi = false;
     1106+    if(hasWifi) {
     1107+        NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     1108+        CWInterface *defaultInterface = [CWInterface interfaceWithName: (NSString *)QCFString::toCFStringRef(wifiDeviceName)];
     1109+        if([defaultInterface power]) {
     1110+            haswifi = true;
     1111+        }
     1112+        [autoreleasepool release];
     1113+    }
     1114+    return haswifi;
     1115+}
     1116+
     1117+
     1118+QNetworkSession::State QCoreWlanEngine::sessionStateForId(const QString &id)
     1119+{
     1120+    QMutexLocker locker(&mutex);
     1121+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
     1122+
     1123+    if (!ptr)
     1124+        return QNetworkSession::Invalid;
     1125+
     1126+    if (!ptr->isValid) {
     1127+        return QNetworkSession::Invalid;
     1128+    } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
     1129+        return QNetworkSession::Connected;
     1130+    } else if ((ptr->state & QNetworkConfiguration::Discovered) ==
     1131+                QNetworkConfiguration::Discovered) {
     1132+        return QNetworkSession::Disconnected;
     1133+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
     1134+        return QNetworkSession::NotAvailable;
     1135+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
     1136+                QNetworkConfiguration::Undefined) {
     1137+        return QNetworkSession::NotAvailable;
     1138+    }
     1139+
     1140+    return QNetworkSession::Invalid;
     1141+}
     1142+
     1143+QNetworkConfigurationManager::Capabilities QCoreWlanEngine::capabilities() const
     1144+{
     1145+    return QNetworkConfigurationManager::ForcedRoaming;
     1146+}
     1147+
     1148+void QCoreWlanEngine::startNetworkChangeLoop()
     1149+{
     1150+
     1151+    SCDynamicStoreContext dynStoreContext = { 0, this/*(void *)storeSession*/, NULL, NULL, NULL };
     1152+    storeSession = SCDynamicStoreCreate(NULL,
     1153+                                 CFSTR("networkChangeCallback"),
     1154+                                 networkChangeCallback,
     1155+                                 &dynStoreContext);
     1156+    if (!storeSession ) {
     1157+        qWarning() << "could not open dynamic store: error:" << SCErrorString(SCError());
     1158+        return;
     1159+    }
     1160+
     1161+    CFMutableArrayRef notificationKeys;
     1162+    notificationKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
     1163+    CFMutableArrayRef patternsArray;
     1164+    patternsArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
     1165+
     1166+    CFStringRef storeKey;
     1167+    storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
     1168+                                                     kSCDynamicStoreDomainState,
     1169+                                                     kSCEntNetIPv4);
     1170+    CFArrayAppendValue(notificationKeys, storeKey);
     1171+    CFRelease(storeKey);
     1172+
     1173+    storeKey = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
     1174+                                                      kSCDynamicStoreDomainState,
     1175+                                                      kSCCompAnyRegex,
     1176+                                                      kSCEntNetIPv4);
     1177+    CFArrayAppendValue(patternsArray, storeKey);
     1178+    CFRelease(storeKey);
     1179+
     1180+    if (!SCDynamicStoreSetNotificationKeys(storeSession , notificationKeys, patternsArray)) {
     1181+        qWarning() << "register notification error:"<< SCErrorString(SCError());
     1182+        CFRelease(storeSession );
     1183+        CFRelease(notificationKeys);
     1184+        CFRelease(patternsArray);
     1185+        return;
     1186+    }
     1187+    CFRelease(notificationKeys);
     1188+    CFRelease(patternsArray);
     1189+
     1190+    runloopSource = SCDynamicStoreCreateRunLoopSource(NULL, storeSession , 0);
     1191+    if (!runloopSource) {
     1192+        qWarning() << "runloop source error:"<< SCErrorString(SCError());
     1193+        CFRelease(storeSession );
     1194+        return;
     1195+    }
     1196+
     1197+    CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode);
     1198+    return;
     1199+}
     1200+
     1201+QNetworkSessionPrivate *QCoreWlanEngine::createSessionBackend()
     1202+{
     1203+    return new QNetworkSessionPrivateImpl;
     1204+}
     1205+
     1206+QNetworkConfigurationPrivatePointer QCoreWlanEngine::defaultConfiguration()
     1207+{
     1208+    return QNetworkConfigurationPrivatePointer();
     1209+}
     1210+
     1211+bool QCoreWlanEngine::requiresPolling() const
     1212+{
     1213+    return true;
     1214+}
     1215+
     1216+void QCoreWlanEngine::networksChanged()
     1217+{
     1218+    QMutexLocker locker(&mutex);
     1219+
     1220+    QStringList previous = accessPointConfigurations.keys();
     1221+
     1222+    QList<QNetworkConfigurationPrivate *> foundConfigurations = scanThread->getConfigurations();
     1223+    while (!foundConfigurations.isEmpty()) {
     1224+        QNetworkConfigurationPrivate *cpPriv = foundConfigurations.takeFirst();
     1225+
     1226+        previous.removeAll(cpPriv->id);
     1227+
     1228+        if (accessPointConfigurations.contains(cpPriv->id)) {
     1229+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(cpPriv->id);
     1230+
     1231+            bool changed = false;
     1232+
     1233+            ptr->mutex.lock();
     1234+
     1235+            if (ptr->isValid != cpPriv->isValid) {
     1236+                ptr->isValid = cpPriv->isValid;
     1237+                changed = true;
     1238+            }
     1239+
     1240+            if (ptr->name != cpPriv->name) {
     1241+                ptr->name = cpPriv->name;
     1242+                changed = true;
     1243+            }
     1244+
     1245+            if (ptr->bearerType != cpPriv->bearerType) {
     1246+                ptr->bearerType = cpPriv->bearerType;
     1247+                changed = true;
     1248+            }
     1249+
     1250+            if (ptr->state != cpPriv->state) {
     1251+                ptr->state = cpPriv->state;
     1252+                changed = true;
     1253+            }
     1254+
     1255+            ptr->mutex.unlock();
     1256+
     1257+            if (changed) {
     1258+                locker.unlock();
     1259+                emit configurationChanged(ptr);
     1260+                locker.relock();
     1261+            }
     1262+
     1263+            delete cpPriv;
     1264+        } else {
     1265+            QNetworkConfigurationPrivatePointer ptr(cpPriv);
     1266+
     1267+            accessPointConfigurations.insert(ptr->id, ptr);
     1268+
     1269+            locker.unlock();
     1270+            emit configurationAdded(ptr);
     1271+            locker.relock();
     1272+        }
     1273+    }
     1274+
     1275+    while (!previous.isEmpty()) {
     1276+        QNetworkConfigurationPrivatePointer ptr =
     1277+            accessPointConfigurations.take(previous.takeFirst());
     1278+
     1279+        locker.unlock();
     1280+        emit configurationRemoved(ptr);
     1281+        locker.relock();
     1282+    }
     1283+
     1284+    locker.unlock();
     1285+    emit updateCompleted();
     1286+
     1287+}
     1288+
     1289+quint64 QCoreWlanEngine::bytesWritten(const QString &id)
     1290+{
     1291+    QMutexLocker locker(&mutex);
     1292+    const QString interfaceStr = getInterfaceFromId(id);
     1293+    return getBytes(interfaceStr,false);
     1294+}
     1295+
     1296+quint64 QCoreWlanEngine::bytesReceived(const QString &id)
     1297+{
     1298+    QMutexLocker locker(&mutex);
     1299+    const QString interfaceStr = getInterfaceFromId(id);
     1300+    return getBytes(interfaceStr,true);
     1301+}
     1302+
     1303+quint64 QCoreWlanEngine::startTime(const QString &identifier)
     1304+{
     1305+    QMutexLocker locker(&mutex);
     1306+    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
     1307+    quint64 timestamp = 0;
     1308+
     1309+    NSString *filePath = @"/Library/Preferences/SystemConfiguration/com.apple.airport.preferences.plist";
     1310+    NSDictionary* plistDict = [[[NSDictionary alloc] initWithContentsOfFile:filePath] autorelease];
     1311+    if(plistDict == nil)
     1312+        return timestamp;
     1313+    NSString *input = @"KnownNetworks";
     1314+    NSString *timeStampStr = @"_timeStamp";
     1315+
     1316+    NSString *ssidStr = @"SSID_STR";
     1317+
     1318+    for (id key in plistDict) {
     1319+        if ([input isEqualToString:key]) {
     1320+
     1321+            NSDictionary *knownNetworksDict = [plistDict objectForKey:key];
     1322+            if(knownNetworksDict == nil)
     1323+                return timestamp;
     1324+            for (id networkKey in knownNetworksDict) {
     1325+                bool isFound = false;
     1326+                NSDictionary *itemDict = [knownNetworksDict objectForKey:networkKey];
     1327+                if(itemDict == nil)
     1328+                    return timestamp;
     1329+                NSInteger dictSize = [itemDict count];
     1330+                id objects[dictSize];
     1331+                id keys[dictSize];
     1332+
     1333+                [itemDict getObjects:objects andKeys:keys];
     1334+                bool ok = false;
     1335+                for(int i = 0; i < dictSize; i++) {
     1336+                    if([ssidStr isEqualToString:keys[i]]) {
     1337+                        const QString ident = QString::number(qHash(QLatin1String("corewlan:") + QCFString::toQString(CFStringRef(objects[i]))));
     1338+                        if(ident == identifier) {
     1339+                            ok = true;
     1340+                        }
     1341+                    }
     1342+                    if(ok && [timeStampStr isEqualToString:keys[i]]) {
     1343+                        timestamp = (quint64)[objects[i] timeIntervalSince1970];
     1344+                        isFound = true;
     1345+                        break;
     1346+                    }
     1347+                }
     1348+                if(isFound)
     1349+                    break;
     1350+            }
     1351+        }
     1352+    }
     1353+    [autoreleasepool release];
     1354+    return timestamp;
     1355+}
     1356+
     1357+quint64 QCoreWlanEngine::getBytes(const QString &interfaceName, bool b)
     1358+{
     1359+    struct ifaddrs *ifAddressList, *ifAddress;
     1360+    struct if_data *if_data;
     1361+
     1362+    quint64 bytes = 0;
     1363+    ifAddressList = nil;
     1364+    if(getifaddrs(&ifAddressList) == 0) {
     1365+        for(ifAddress = ifAddressList; ifAddress; ifAddress = ifAddress->ifa_next) {
     1366+            if(interfaceName == ifAddress->ifa_name) {
     1367+                if_data = (struct if_data*)ifAddress->ifa_data;
     1368+                if(b) {
     1369+                    bytes = if_data->ifi_ibytes;
     1370+                    break;
     1371+                } else {
     1372+                    bytes = if_data->ifi_obytes;
     1373+                    break;
     1374+                }
     1375+            }
     1376+        }
     1377+        freeifaddrs(ifAddressList);
     1378+    }
     1379+    return bytes;
     1380+}
     1381+
     1382+QT_END_NAMESPACE
Note: See TracChangeset for help on using the changeset viewer.