/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qcorewlanengine_mac_p.h"

#include "qnetworkconfiguration_p.h"

#include <QtCore/qthread.h>

#include <QThread>

#include <QtCore/qmutex.h>

#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>

#include <SystemConfiguration/SCNetworkConfiguration.h>

QMap <QString, QString> networkInterfaces;

#ifdef MAC_SDK_10_6

@interface QNSListener : NSObject

{

    NSNotificationCenter *center;

    CWInterface * currentInterface;

}

- (void)notificationHandler;//:(NSNotification *)notification;

- (void)remove;

@end

@implementation QNSListener

- (id) init

{

    [super init];

    center = [NSNotificationCenter defaultCenter];

    currentInterface = [CWInterface interfaceWithName:nil];

    [center addObserver:self selector:@selector(notificationHandler:) name:kCWLinkDidChangeNotification object:nil];

    [center addObserver:self selector:@selector(notificationHandler:) name:kCWPowerDidChangeNotification object:nil];

    return self;

}

-(void)dealloc

{

   [center release];

   [currentInterface release];

   [super dealloc];

}

-(void)remove

{

    [center removeObserver:self];

}

- (void)notificationHandler;//:(NSNotification *)notification

{

    QTM_NAMESPACE::QCoreWlanEngine::instance()->requestUpdate();

}

@end

QNSListener *listener = 0;

#endif

QTM_BEGIN_NAMESPACE

Q_GLOBAL_STATIC(QCoreWlanEngine, coreWlanEngine)

inline QString cfstringRefToQstring(CFStringRef cfStringRef) {

    QString retVal;

    CFIndex maxLength = 2 * CFStringGetLength(cfStringRef) + 1/*zero term*/; // max UTF8

    char *cstring = new char[maxLength];

    if (CFStringGetCString(CFStringRef(cfStringRef), cstring, maxLength, kCFStringEncodingUTF8)) {

        retVal = QString::fromUtf8(cstring);

    }

    delete[] cstring;

    return retVal;

}

inline CFStringRef qstringToCFStringRef(const QString &string)

{

    return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(string.unicode()),

                                        string.length());

}

inline NSString *qstringToNSString(const QString &qstr)

{ return [reinterpret_cast<const NSString *>(qstringToCFStringRef(qstr)) autorelease]; }

inline QString nsstringToQString(const NSString *nsstr)

{ return cfstringRefToQstring(reinterpret_cast<const CFStringRef>(nsstr)); }

inline QStringList nsarrayToQStringList(void *nsarray)

{

    QStringList result;

    NSArray *array = static_cast<NSArray *>(nsarray);

    for (NSUInteger i=0; i<[array count]; ++i)

        result << nsstringToQString([array objectAtIndex:i]);

    return result;

}

void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef changedKeys, void *info)

{

    for ( long i = 0; i < CFArrayGetCount(changedKeys); i++) {

        CFStringRef changed = (CFStringRef)CFArrayGetValueAtIndex(changedKeys, i);

        if( cfstringRefToQstring(changed).contains("/Network/Global/IPv4")) {

            QCoreWlanEngine* wlanEngine = static_cast<QCoreWlanEngine*>(info);

            wlanEngine->requestUpdate();

        }

    }

    return;

}

QScanThread::QScanThread(QObject *parent)

    :QThread(parent)

{

}

QScanThread::~QScanThread()

{

}

void QScanThread::quit()

{

    wait();

}

void QScanThread::run()

{

#if defined(MAC_SDK_10_6)

    getUserProfiles();

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    QStringList found;

    mutex.lock();

    CWInterface *currentInterface;

    if(interfaceName.isEmpty()) {

        currentInterface = [CWInterface interfaceWithName:nil];

        interfaceName = nsstringToQString([currentInterface name]);

    } else {

        currentInterface = [CWInterface interfaceWithName:qstringToNSString(interfaceName)];

    }

    mutex.unlock();

    if([currentInterface power]) {

        NSError *err = nil;

        NSDictionary *parametersDict =  [NSDictionary dictionaryWithObjectsAndKeys:

                                         [NSNumber numberWithBool:YES], kCWScanKeyMerge,

                                         [NSNumber numberWithInteger:100], kCWScanKeyRestTime, nil];

        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];

        CWNetwork *apNetwork;

        if (!err) {

            for(uint row=0; row < [apArray count]; row++ ) {

                apNetwork = [apArray objectAtIndex:row];

                const QString networkSsid = nsstringToQString([apNetwork ssid]);

                found.append(networkSsid);

                QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;

                bool known = isKnownSsid(networkSsid);

                if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {

                    if( networkSsid == nsstringToQString( [currentInterface ssid])) {

                        state = QNetworkConfiguration::Active;

                    }

                }

                if(state == QNetworkConfiguration::Undefined) {

                    if(known) {

                        state = QNetworkConfiguration::Discovered;

                    } else {

                        state = QNetworkConfiguration::Undefined;

                    }

                }

                QNetworkConfiguration::Purpose purpose = QNetworkConfiguration::UnknownPurpose;

                if([[apNetwork securityMode] intValue] == kCWSecurityModeOpen) {

                    purpose = QNetworkConfiguration::PublicPurpose;

                } else {

                    purpose = QNetworkConfiguration::PrivatePurpose;

                }

                found.append(foundNetwork(networkSsid, networkSsid, state, interfaceName, purpose));

            } //end row

        }//end error

    }// endwifi power

// add known configurations that are not around.

    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);

    while (i.hasNext()) {

        i.next();

        QString networkName = i.key();

        const QString id = networkName;

        if(!found.contains(id)) {

            QString networkSsid = getSsidFromNetworkName(networkName);

            const QString ssidId = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));

            QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;

            QString interfaceName;

            QMapIterator<QString, QString> ij(i.value());

            while (ij.hasNext()) {

                ij.next();

                interfaceName = ij.value();

            }

            if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {

                if( networkSsid == nsstringToQString([currentInterface ssid])) {

                    state = QNetworkConfiguration::Active;

                }

            }

            if(state == QNetworkConfiguration::Undefined) {

                if( userProfiles.contains(networkName)

                    && found.contains(ssidId)) {

                    state = QNetworkConfiguration::Discovered;

                }

            }

            if(state == QNetworkConfiguration::Undefined) {

                state = QNetworkConfiguration::Defined;

            }

            found.append(foundNetwork(id, networkName, state, interfaceName, QNetworkConfiguration::UnknownPurpose));

        }

    }

    emit networksChanged();

    [pool release];

#endif

}

QStringList QScanThread::foundNetwork(const QString &id, const QString &name, const QNetworkConfiguration::StateFlags state, const QString &interfaceName, const QNetworkConfiguration::Purpose purpose)

{

    QStringList found;

    QMutexLocker locker(&mutex);

    QNetworkConfigurationPrivate *ptr = new QNetworkConfigurationPrivate;

    ptr->name = name;

    ptr->isValid = true;

    ptr->id = id;

    ptr->state = state;

    ptr->type = QNetworkConfiguration::InternetAccessPoint;

    ptr->bearer = QLatin1String("WLAN");

    ptr->purpose = purpose;

    ptr->internet = true;

    ptr->serviceInterface = QNetworkInterface::interfaceFromName(interfaceName);

    fetchedConfigurations.append( ptr);

    configurationInterface[name] =  interfaceName;

    locker.unlock();

    locker.relock();

    found.append(id);

    return found;

}

QList<QNetworkConfigurationPrivate *> QScanThread::getConfigurations()

{

    QMutexLocker locker(&mutex);

    QList<QNetworkConfigurationPrivate *> foundConfigurations;

    for (int i = 0; i < fetchedConfigurations.count(); ++i) {

        QNetworkConfigurationPrivate *config = new QNetworkConfigurationPrivate;

        config->name = fetchedConfigurations.at(i)->name;

        config->isValid = fetchedConfigurations.at(i)->isValid;

        config->id = fetchedConfigurations.at(i)->id;

        config->state = fetchedConfigurations.at(i)->state;

        config->bearer = fetchedConfigurations.at(i)->bearer;

        config->type = fetchedConfigurations.at(i)->type;

        config->roamingSupported = fetchedConfigurations.at(i)->roamingSupported;

        config->purpose = fetchedConfigurations.at(i)->purpose;

        config->internet = fetchedConfigurations.at(i)->internet;

        foundConfigurations.append(config);

    }

    return foundConfigurations;

}

void QScanThread::getUserProfiles()

{

#if defined(MAC_SDK_10_6)

    QMutexLocker locker(&mutex);

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    userProfiles.clear();

    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];

    for(uint row=0; row < [wifiInterfaces count]; row++ ) {

        CWInterface *wifiInterface = [CWInterface interfaceWithName: [wifiInterfaces objectAtIndex:row]];

        if (![wifiInterface power])

            continue;

        NSString *nsInterfaceName = [wifiInterface name];

// add user configured system networks

        SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, (CFStringRef)@"Qt corewlan", nil, nil);

        NSDictionary * airportPlist = (NSDictionary *)SCDynamicStoreCopyValue(dynRef, (CFStringRef)[NSString stringWithFormat:@"Setup:/Network/Interface/%@/AirPort", nsInterfaceName]);

        CFRelease(dynRef);

        NSDictionary *prefNetDict = [airportPlist objectForKey:@"PreferredNetworks"];

        NSArray *thisSsidarray = [prefNetDict valueForKey:@"SSID_STR"];

        NSEnumerator *ssidEnumerator = [thisSsidarray objectEnumerator];

        NSString *ssidkey;

        while ((ssidkey = [ssidEnumerator nextObject])) {

            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 = [[[NSDictionary alloc] initWithContentsOfFile:qstringToNSString(userProfilePath)] autorelease];

        NSString *profileStr= @"Profiles";

        NSString *nameStr = @"UserDefinedName";

        NSString *networkSsidStr = @"Wireless Network";

        id profileKey;

        NSEnumerator *dictEnumerator = [eapDict objectEnumerator];

        while ((profileKey = [dictEnumerator nextObject])) {

            if ([profileStr isEqualToString:profileKey]) {

                NSDictionary *itemDict = [eapDict objectForKey:profileKey];

                id itemKey;

                NSEnumerator *dictEnumerator = [thisSsidarray objectEnumerator];

                while ((itemKey = [dictEnumerator nextObject])) {

                    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);

                        }

                    }

                }

            }

        }

    }

    [pool release];

#endif    

}

QString QScanThread::getSsidFromNetworkName(const QString &name)

{

    QMutexLocker locker(&mutex);

    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();

             const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") +i.key()));

             if(name == i.key() || name == networkNameHash) {

                 return ij.key();

             }

        }

    }

    return QString();

}

QString QScanThread::getNetworkNameFromSsid(const QString &ssid)

{

    QMutexLocker locker(&mutex);

    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 QString();

}

bool QScanThread::isKnownSsid(const QString &ssid)

{

    QMutexLocker locker(&mutex);

    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);

    while (i.hasNext()) {

        i.next();

        QMap<QString,QString> map = i.value();

        if(map.keys().contains(ssid)) {

            return true;

        }

    }

    return false;

}

QCoreWlanEngine::QCoreWlanEngine(QObject *parent)

:   QNetworkSessionEngine(parent)

{

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    getAllScInterfaces();

    scanThread = new QScanThread(this);

    connect(scanThread, SIGNAL(networksChanged()),

            this, SIGNAL(configurationsChanged()));

    QTimer::singleShot(0,this,SLOT(init()));

    [pool release];

}

QCoreWlanEngine::~QCoreWlanEngine()

{

    QNetworkConfigurationPrivate* cpPriv = 0;

    foundConfigurations.clear();

    while(!foundConfigurations.isEmpty()) {

        cpPriv = foundConfigurations.takeFirst();

        delete cpPriv;

    }

}

void QCoreWlanEngine::init()

{

#ifdef MAC_SDK_10_6

    if([[CWInterface supportedInterfaces] count] > 0 && !listener) {

        listener = [[QNSListener alloc] init];

        hasWifi = true;

    } else {

        hasWifi = false;

    }

#endif

    storeSession = NULL;

    scanThread->start();

    startNetworkChangeLoop();

}

QList<QNetworkConfigurationPrivate *> QCoreWlanEngine::getConfigurations(bool *ok)

{

    if (ok)

        *ok = true;

    foundConfigurations.clear();

    QNetworkConfigurationPrivate* cpPriv = 0;

    QMutexLocker locker(&mutex);

     QList<QNetworkConfigurationPrivate *> fetchedConfigurations = scanThread->getConfigurations();

locker.unlock();

     for (int i = 0; i < fetchedConfigurations.count(); ++i) {

         QNetworkConfigurationPrivate *config = new QNetworkConfigurationPrivate();

         cpPriv = fetchedConfigurations.at(i);

         config->name = cpPriv->name;

         config->isValid = cpPriv->isValid;

         config->id = cpPriv->id;

         config->state = cpPriv->state;

         config->type = cpPriv->type;

         config->roamingSupported = cpPriv->roamingSupported;

         config->purpose = cpPriv->purpose;

         config->internet = cpPriv->internet;

         config->serviceInterface = cpPriv->serviceInterface;

         config->bearer = cpPriv->bearer;