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

**

** 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 <qmobilityglobal.h>

#include "qnetworksession_s60_p.h"

#include "qnetworkconfiguration_s60_p.h"

#include "qnetworkconfigmanager_s60_p.h"

#include <es_enum.h>

#include <es_sock.h>

#include <in_sock.h>

#include <stdapis/sys/socket.h>

#include <stdapis/net/if.h>

QTM_BEGIN_NAMESPACE

QNetworkSessionPrivate::QNetworkSessionPrivate()

    : CActive(CActive::EPriorityUserInput), state(QNetworkSession::Invalid),

      isOpen(false), iDynamicUnSetdefaultif(0), ipConnectionNotifier(0),

      iHandleStateNotificationsFromManager(false), iFirstSync(true), iStoppedByUser(false),

{

    CActiveScheduler::Add(this);

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    iMobility = NULL;

#endif

    // Try to load "Open C" dll dynamically and

    // try to attach to unsetdefaultif function dynamically.

    // This is to avoid build breaks with old OpenC versions.

    if (iOpenCLibrary.Load(_L("libc")) == KErrNone) {

        iDynamicUnSetdefaultif = (TOpenCUnSetdefaultifFunction)iOpenCLibrary.Lookup(597);

    }

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

    qDebug() << "QNS this : " << QString::number((uint)this) << " - ";

    if (iDynamicUnSetdefaultif)

    else

#endif

    TRAP_IGNORE(iConnectionMonitor.ConnectL());

}

QNetworkSessionPrivate::~QNetworkSessionPrivate()

{

    isOpen = false;

    // Cancel Connection Progress Notifications first.

    // Note: ConnectionNotifier must be destroyed before Canceling RConnection::Start()

    //       => deleting ipConnectionNotifier results RConnection::CancelProgressNotification()

    delete ipConnectionNotifier;

    ipConnectionNotifier = NULL;

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    if (iMobility) {

        delete iMobility;

        iMobility = NULL;

    }

#endif

    // Cancel possible RConnection::Start()

    Cancel();

    iSocketServ.Close();

    // Close global 'Open C' RConnection

    // Clears also possible unsetdefaultif() flags.

    setdefaultif(0);

    iConnectionMonitor.Close();

    iOpenCLibrary.Close();

}

void QNetworkSessionPrivate::configurationStateChanged(TUint32 accessPointId, TUint32 connMonId, QNetworkSession::State newState)

{

    if (iHandleStateNotificationsFromManager) {

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

        qDebug() << "QNS this : " << QString::number((uint)this) << " - "

#endif

        this->newState(newState, accessPointId);

    }

}

void QNetworkSessionPrivate::configurationRemoved(const QNetworkConfiguration& config)

{

    if (!publicConfig.d.data()) {

        return;

    }

    if (config.d.data()->numericId == publicConfig.d.data()->numericId) {

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

        qDebug() << "QNS this : " << QString::number((uint)this) << " - "

                 << "configurationRemoved IAP: " << QString::number(publicConfig.d.data()->numericId) << " : going to State: Invalid";

#endif

        this->newState(QNetworkSession::Invalid, publicConfig.d.data()->numericId);

    }

}

void QNetworkSessionPrivate::syncStateWithInterface()

{

        return;

    }

        QObject::connect(((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager), SIGNAL(configurationStateChanged(TUint32, TUint32, QNetworkSession::State)),

                         this, SLOT(configurationStateChanged(TUint32, TUint32, QNetworkSession::State)));

        // Listen to configuration removals, so that in case the configuration

        // this session is based on is removed, session knows to enter Invalid -state.

        QObject::connect(((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager),

                         SIGNAL(configurationRemoved(QNetworkConfiguration)),

                         this, SLOT(configurationRemoved(QNetworkConfiguration)));

    }

    // Start listening IAP state changes from QNetworkConfigurationManagerPrivate

    iHandleStateNotificationsFromManager = true;    

    }

}

QNetworkInterface QNetworkSessionPrivate::interface(TUint iapId) const

{

    QString interfaceName;

    TSoInetInterfaceInfo ifinfo;

    TPckg<TSoInetInterfaceInfo> ifinfopkg(ifinfo);

    TSoInetIfQuery ifquery;

    TPckg<TSoInetIfQuery> ifquerypkg(ifquery);

    // Open dummy socket for interface queries

    RSocket socket;

    TInt retVal = socket.Open(iSocketServ, _L("udp"));

    if (retVal != KErrNone) {

        return QNetworkInterface();

    }

    // Start enumerating interfaces

    socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);

    while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, ifinfopkg) == KErrNone) {

        ifquery.iName = ifinfo.iName;

        TInt err = socket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifquerypkg);

        if(err == KErrNone && ifquery.iZone[1] == iapId) { // IAP ID is index 1 of iZone

            if(ifinfo.iAddress.Address() > 0) {

                interfaceName = QString::fromUtf16(ifinfo.iName.Ptr(),ifinfo.iName.Length());

                break;

            }

        }

    }

    socket.Close();

    if (interfaceName.isEmpty()) {

        return QNetworkInterface();

    }

    return QNetworkInterface::interfaceFromName(interfaceName);

}

QNetworkInterface QNetworkSessionPrivate::currentInterface() const

{

    if (!publicConfig.isValid() || state != QNetworkSession::Connected) {

        return QNetworkInterface();

    }

    return activeInterface;

}

QVariant QNetworkSessionPrivate::sessionProperty(const QString& key) const

{

    if (key == "ConnectInBackground") {

        return QVariant(iConnectInBackground);

    }

    return QVariant();

}

void QNetworkSessionPrivate::setSessionProperty(const QString& key, const QVariant& value)

{

    // Valid value means adding property, invalid means removing it.

    if (key == "ConnectInBackground") {

        if (value.isValid()) {

            iConnectInBackground = value.toBool();

        } else {

            iConnectInBackground = EFalse;

        }

    }

}

QString QNetworkSessionPrivate::errorString() const

{

    switch (iError) {

    case QNetworkSession::UnknownSessionError:

        return tr("Unknown session error.");

    case QNetworkSession::SessionAbortedError:

        return tr("The session was aborted by the user or system.");

    case QNetworkSession::OperationNotSupportedError:

        return tr("The requested operation is not supported by the system.");

    case QNetworkSession::InvalidConfigurationError:

        return tr("The specified configuration cannot be used.");

    case QNetworkSession::RoamingError:

        return tr("Roaming was aborted or is not possible.");

    }

    return QString();

}

QNetworkSession::SessionError QNetworkSessionPrivate::error() const

{

    return iError;

}

void QNetworkSessionPrivate::open()

{

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

        qDebug() << "QNS this : " << QString::number((uint)this) << " - "

                << "open() called, session state is: " << state << " and isOpen is: "

                << isOpen;

#endif

        return;

    // Stop handling IAP state change signals from QNetworkConfigurationManagerPrivate

    // => RConnection::ProgressNotification will be used for IAP/SNAP monitoring

    iHandleStateNotificationsFromManager = false;

    // Configuration may have been invalidated after session creation by platform

    // (e.g. configuration has been deleted).

    if (!publicConfig.isValid()) {

        newState(QNetworkSession::Invalid);

        iError = QNetworkSession::InvalidConfigurationError;

        emit q->error(iError);

        return;

    }

    // If opening a undefined configuration, session emits error and enters

    // NotAvailable -state. Note that we will try ones in 'defined' state to avoid excessive

    // need for WLAN scans (via updateConfigurations()), because user may have walked

    // into a WLAN range, but periodic background scan has not occurred yet -->

    // we don't want to force application to make frequent updateConfigurations() calls

    // to be able to try if e.g. home WLAN is available.

    if (publicConfig.state() == QNetworkConfiguration::Undefined) {

        newState(QNetworkSession::NotAvailable);

        iError = QNetworkSession::InvalidConfigurationError;

        emit q->error(iError);

        return;

    }

    // Clear possible previous states

    iStoppedByUser = false;

    iClosedByUser = false;

    TInt error = iSocketServ.Connect();

    if (error != KErrNone) {

        // Could not open RSocketServ

        newState(QNetworkSession::Invalid);

        iError = QNetworkSession::UnknownSessionError;

        emit q->error(iError);

        syncStateWithInterface();    

        return;

    }

    error = iConnection.Open(iSocketServ);

    if (error != KErrNone) {

        // Could not open RConnection

        iSocketServ.Close();

        newState(QNetworkSession::Invalid);

        iError = QNetworkSession::UnknownSessionError;

        emit q->error(iError);

        syncStateWithInterface();    

        return;

    }

    // Use RConnection::ProgressNotification for IAP/SNAP monitoring

    // (<=> ConnectionProgressNotifier uses RConnection::ProgressNotification)

    if (!ipConnectionNotifier) {

        ipConnectionNotifier = new ConnectionProgressNotifier(*this,iConnection);

    }

    if (ipConnectionNotifier) {

        ipConnectionNotifier->StartNotifications();

    }

    if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {

            // With One Click Connectivity (Symbian^3 onwards) it is possible

            // to connect silently, without any popups.

            TConnPrefList pref;

            TExtendedConnPref prefs;

            prefs.SetIapId(publicConfig.d.data()->numericId);

            if (iConnectInBackground) {

                prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );

            }

            pref.AppendL(&prefs);

#else

            TCommDbConnPref pref;

            pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

            pref.SetIapId(publicConfig.d.data()->numericId);

#endif

            iConnection.Start(pref, iStatus);

            if (!IsActive()) {

                SetActive();

            }

    } else if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

        // On Symbian^3 if service network is not reachable, it triggers a UI (aka EasyWLAN) where

        // user can create new IAPs. To detect this, we need to store the number of IAPs

        // there was before connection was started.

        iKnownConfigsBeforeConnectionStart = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.keys();

        TConnPrefList snapPref;

        TExtendedConnPref prefs;

        prefs.SetSnapId(publicConfig.d.data()->numericId);

        if (iConnectInBackground) {

            prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );

        }

        snapPref.AppendL(&prefs);

#else

        TConnSnapPref snapPref(publicConfig.d.data()->numericId);

#endif

        iConnection.Start(snapPref, iStatus);

        if (!IsActive()) {

            SetActive();

        }

    } else if (publicConfig.type() == QNetworkConfiguration::UserChoice) {

        iKnownConfigsBeforeConnectionStart = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.keys();

        iConnection.Start(iStatus);

        if (!IsActive()) {

            SetActive();

        }

        newState(QNetworkSession::Connecting);

    }

    if (error != KErrNone) {

        isOpen = false;

        iError = QNetworkSession::UnknownSessionError;

        emit q->error(iError);

        if (ipConnectionNotifier) {

            ipConnectionNotifier->StopNotifications();

        }

        syncStateWithInterface();    

    }

}

TUint QNetworkSessionPrivate::iapClientCount(TUint aIAPId) const

{

    TRequestStatus status;

    TUint connectionCount;

    iConnectionMonitor.GetConnectionCount(connectionCount, status);

    User::WaitForRequest(status);

    if (status.Int() == KErrNone) {

        for (TUint i = 1; i <= connectionCount; i++) {

            TUint connectionId;

            TUint subConnectionCount;

            iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);

            TUint apId;

            iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);

            User::WaitForRequest(status);

            if (apId == aIAPId) {

                TConnMonClientEnumBuf buf;

                iConnectionMonitor.GetPckgAttribute(connectionId, 0, KClientInfo, buf, status);

                User::WaitForRequest(status);

                if (status.Int() == KErrNone) {

                    return buf().iCount;

                }

            }

        }

    }

    return 0;

}

void QNetworkSessionPrivate::close(bool allowSignals)

{

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

    qDebug() << "QNS this : " << QString::number((uint)this) << " - "

            << "close() called, session state is: " << state << " and isOpen is : "

            << isOpen;

#endif

    if (!isOpen && state != QNetworkSession::Connecting) {

        return;

    }

    // Mark this session as closed-by-user so that we are able to report

    // distinguish between stop() and close() state transitions

    // when reporting.

    iClosedByUser = true;

    isOpen = false;

    serviceConfig = QNetworkConfiguration();

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    if (iMobility) {

        delete iMobility;

        iMobility = NULL;

    }

#endif

    if (ipConnectionNotifier && !iHandleStateNotificationsFromManager) {

        ipConnectionNotifier->StopNotifications();

        // Start handling IAP state change signals from QNetworkConfigurationManagerPrivate

        iHandleStateNotificationsFromManager = true;

    }

    Cancel(); // closes iConnection