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

**

** Copyright (C) 2009 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::EPriorityStandard), state(QNetworkSession::Invalid),

      isOpen(false), ipConnectionNotifier(0), iError(QNetworkSession::UnknownSessionError),

{

    CActiveScheduler::Add(this);

    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;

    // Cancel possible RConnection::Start()

    Cancel();

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    if (iMobility) {

        delete iMobility;

        iMobility = NULL;

    }

#endif

    iConnection.Close();

    iSocketServ.Close();

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

}

void QNetworkSessionPrivate::syncStateWithInterface()

{

    if (!publicConfig.d) {

        return;

    }

    // Start monitoring changes in IAP states

    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

    // 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) {

        // There were no open connections to used IAP or SNAP

        if (iError == QNetworkSession::InvalidConfigurationError) {

            newState(QNetworkSession::Invalid);

        }

        else if ((publicConfig.d.data()->state & QNetworkConfiguration::Discovered) ==

            QNetworkConfiguration::Discovered) {

            newState(QNetworkSession::Disconnected);

        } else {

            newState(QNetworkSession::NotAvailable);

        }

    }

}

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;

}

{

    return QVariant();

}

{

}

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

{

    if (isOpen || (state == QNetworkSession::Connecting)) {

        return;

    }

    // Cancel notifications from RConnectionMonitor

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

    iConnectionMonitor.CancelNotifications();

        newState(QNetworkSession::Invalid);

        iError = QNetworkSession::InvalidConfigurationError;

        emit q->error(iError);

        syncStateWithInterface();

        return;

    }

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

        // Search through existing connections.

        // If there is already connection which matches to given IAP

        // try to attach to existing connection.

        TBool connected(EFalse);

        TConnectionInfoBuf connInfo;

        TUint count;

        if (iConnection.EnumerateConnections(count) == KErrNone) {

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

                // Note: GetConnectionInfo expects 1-based index.

                if (iConnection.GetConnectionInfo(i, connInfo) == KErrNone) {

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

                        if (iConnection.Attach(connInfo, RConnection::EAttachTypeNormal) == KErrNone) {

                            activeConfig = publicConfig;

                            activeInterface = interface(activeConfig.d.data()->numericId);

                            connected = ETrue;

                            startTime = QDateTime::currentDateTime();

                            isOpen = true;

                            // Make sure that state will be Connected

                            newState(QNetworkSession::Connected);

                            emit quitPendingWaitsForOpened();

                            break;

                        }

                    }

                }

            }

        }

        if (!connected) {

            TCommDbConnPref pref;

            pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

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

            iConnection.Start(pref, iStatus);

            if (!IsActive()) {

                SetActive();

            }

            newState(QNetworkSession::Connecting);

        }

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

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

        iConnection.Start(snapPref, iStatus);

        if (!IsActive()) {

            SetActive();

        }

        newState(QNetworkSession::Connecting);

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

{

    if (!isOpen) {

        return;

    }

    TUint activeIap = activeConfig.d.data()->numericId;

    isOpen = false;

    activeConfig = QNetworkConfiguration();

    serviceConfig = QNetworkConfiguration();

    Cancel();

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    if (iMobility) {

        delete iMobility;

        iMobility = NULL;

    }

#endif

    if (ipConnectionNotifier) {

        ipConnectionNotifier->StopNotifications();

    }

    iConnection.Close();

    iSocketServ.Close();

#ifdef Q_CC_NOKIAX86

    if ((allowSignals && iapClientCount(activeIap) <= 0) ||

#else

    if ((allowSignals && iapClientCount(activeIap) <= 1) ||

#endif

        (publicConfig.type() == QNetworkConfiguration::UserChoice)) {

        newState(QNetworkSession::Closing);

    }

    syncStateWithInterface();

    if (allowSignals) {

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

            newState(QNetworkSession::Disconnected);

        }

        emit q->closed();

    }

}

void QNetworkSessionPrivate::stop()

{

    }

}

void QNetworkSessionPrivate::migrate()

{

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    iMobility->MigrateToPreferredCarrier();

#endif

}

void QNetworkSessionPrivate::ignore()

{