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

**

** 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 plugins of the Qt Toolkit.

**

** $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 "qnetworksession_impl.h"

#include "symbianengine.h"

#include <es_enum.h>

#include <es_sock.h>

#include <in_sock.h>

#include <stdapis/sys/socket.h>

#include <stdapis/net/if.h>

#ifndef QT_NO_BEARERMANAGEMENT

QT_BEGIN_NAMESPACE

QNetworkSessionPrivateImpl::QNetworkSessionPrivateImpl(SymbianEngine *engine)

:   CActive(CActive::EPriorityUserInput), engine(engine),

    iDynamicUnSetdefaultif(0), ipConnectionNotifier(0),

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

    iClosedByUser(false), iError(QNetworkSession::UnknownSessionError), iALREnabled(0),

    iConnectInBackground(false), isOpening(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)

        qDebug() << "dynamic unsetdefaultif() is present in PIPS library. ";

    else

        qDebug() << "dynamic unsetdefaultif() not present in PIPS library. ";

#endif

    TRAP_IGNORE(iConnectionMonitor.ConnectL());

}

QNetworkSessionPrivateImpl::~QNetworkSessionPrivateImpl()

{

    isOpen = false;

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

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

    qDebug() << "QNS this : " << QString::number((uint)this) << " - destroyed (and setdefaultif(0))";

#endif

}

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

{

    if (iHandleStateNotificationsFromManager) {

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

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

                 << "configurationStateChanged from manager for IAP : " << QString::number(accessPointId)

                 << "connMon ID : " << QString::number(connMonId) << " : to a state: " << newState

                 << "whereas my current state is: " << state;

#else

      Q_UNUSED(connMonId);

#endif

        this->newState(newState, accessPointId);

    }

}

void QNetworkSessionPrivateImpl::configurationRemoved(QNetworkConfigurationPrivatePointer config)

{

    if (!publicConfig.isValid())

        return;

    TUint32 publicNumericId =

        toSymbianConfig(privateConfiguration(publicConfig))->numericIdentifier();

    if (toSymbianConfig(config)->numericIdentifier() == publicNumericId) {

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

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

                 << "configurationRemoved IAP: " << QString::number(publicNumericId) << " : going to State: Invalid";

#endif

        this->newState(QNetworkSession::Invalid, publicNumericId);

    }

}

void QNetworkSessionPrivateImpl::syncStateWithInterface()

{

    if (!publicConfig.isValid())

        return;

    if (iFirstSync && publicConfig.isValid()) {

        QObject::connect(engine, 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(engine, SIGNAL(configurationRemoved(QNetworkConfigurationPrivatePointer)),

                         this, SLOT(configurationRemoved(QNetworkConfigurationPrivatePointer)));

    }

    // Start listening IAP state changes from QNetworkConfigurationManagerPrivate

    iHandleStateNotificationsFromManager = true;    

    // Check open connections to see if there is already

    // an open connection to selected IAP or SNAP

    TUint count;

    TRequestStatus status;

    iConnectionMonitor.GetConnectionCount(count, status);

    User::WaitForRequest(status);

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

        return;

    }

    TUint numSubConnections;

    TUint connectionId;

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

        TInt ret = iConnectionMonitor.GetConnectionInfo(i, connectionId, numSubConnections);

        if (ret == KErrNone) {

            TUint apId;

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

            User::WaitForRequest(status);

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

                TInt connectionStatus;

                iConnectionMonitor.GetIntAttribute(connectionId, 0, KConnectionStatus, connectionStatus, status);

                User::WaitForRequest(status);

                if (connectionStatus == KLinkLayerOpen) {

                    if (state != QNetworkSession::Closing) {

                        if (newState(QNetworkSession::Connected, apId)) {

                            return;

                        }

                    }

                }

            }

        }

    }

    if (state != QNetworkSession::Connected) {

        if ((publicConfig.state() & QNetworkConfiguration::Discovered) ==

            QNetworkConfiguration::Discovered) {

            newState(QNetworkSession::Disconnected);

        } else {

            newState(QNetworkSession::NotAvailable);

        }

    }

}

#ifndef QT_NO_NETWORKINTERFACE

QNetworkInterface QNetworkSessionPrivateImpl::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);

}

#endif

#ifndef QT_NO_NETWORKINTERFACE

QNetworkInterface QNetworkSessionPrivateImpl::currentInterface() const

{

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

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

             << "currentInterface() requested, state: " << state

             << "publicConfig validity: " << publicConfig.isValid();

    if (activeInterface.isValid())

        qDebug() << "interface is: " << activeInterface.humanReadableName();

#endif

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

        return QNetworkInterface();

    }

    return activeInterface;

}

#endif

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

{

    if (key == "ConnectInBackground") {

        return QVariant(iConnectInBackground);

    }

    return QVariant();

}

void QNetworkSessionPrivateImpl::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 QNetworkSessionPrivateImpl::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 QNetworkSessionPrivateImpl::error() const

{

    return iError;

}

void QNetworkSessionPrivateImpl::open()

{

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

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

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

                << isOpen << isOpening;

#endif

    if (isOpen || isOpening)

        return;

    isOpening = true;

    // 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 QNetworkSessionPrivate::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 QNetworkSessionPrivate::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 QNetworkSessionPrivate::error(iError);

        syncStateWithInterface();    

        return;

    }

    error = iConnection.Open(iSocketServ);

    if (error != KErrNone) {

        // Could not open RConnection

        iSocketServ.Close();

        newState(QNetworkSession::Invalid);

        iError = QNetworkSession::UnknownSessionError;

        emit QNetworkSessionPrivate::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) {

            SymbianNetworkConfigurationPrivate *symbianConfig =

                toSymbianConfig(privateConfiguration(publicConfig));

#ifdef OCC_FUNCTIONALITY_AVAILABLE

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

            // to connect silently, without any popups.

            TConnPrefList pref;

            TExtendedConnPref prefs;

            prefs.SetIapId(symbianConfig->numericIdentifier());

            if (iConnectInBackground) {

                prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );

            }

            pref.AppendL(&prefs);

#else

            TCommDbConnPref pref;

            pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

            pref.SetIapId(symbianConfig->numericIdentifier());

#endif

            iConnection.Start(pref, iStatus);

            if (!IsActive()) {

                SetActive();

            }

            // Avoid flip flop of states if the configuration is already

            // active. IsOpen/opened() will indicate when ready.

            if (state != QNetworkSession::Connected) {

                newState(QNetworkSession::Connecting);

            }

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

        SymbianNetworkConfigurationPrivate *symbianConfig =

            toSymbianConfig(privateConfiguration(publicConfig));

#ifdef OCC_FUNCTIONALITY_AVAILABLE

        // 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 = engine->accessPointConfigurationIdentifiers();

        TConnPrefList snapPref;

        TExtendedConnPref prefs;

        prefs.SetSnapId(symbianConfig->numericIdentifier());

        if (iConnectInBackground) {

            prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );

        }

        snapPref.AppendL(&prefs);

#else

        TConnSnapPref snapPref(symbianConfig->numericIdentifier());

#endif

        iConnection.Start(snapPref, iStatus);

        if (!IsActive()) {

            SetActive();

        }

        // Avoid flip flop of states if the configuration is already

        // active. IsOpen/opened() will indicate when ready.

        if (state != QNetworkSession::Connected) {

            newState(QNetworkSession::Connecting);

        }

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

        iKnownConfigsBeforeConnectionStart = engine->accessPointConfigurationIdentifiers();

        iConnection.Start(iStatus);

        if (!IsActive()) {

            SetActive();

        }

        newState(QNetworkSession::Connecting);

    }

    if (error != KErrNone) {

        isOpen = false;

        isOpening = false;

        iError = QNetworkSession::UnknownSessionError;

        emit QNetworkSessionPrivate::error(iError);

        if (ipConnectionNotifier) {

            ipConnectionNotifier->StopNotifications();

        }

        syncStateWithInterface();    

    }

}

TUint QNetworkSessionPrivateImpl::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 QNetworkSessionPrivateImpl::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;

    isOpening = 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