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

**

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

#include <QHash>

#include <maemo_icd.h>

#include <iapconf.h>

#include <proxyconf.h>

#include <ifaddrs.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#ifndef QT_NO_BEARERMANAGEMENT

QT_BEGIN_NAMESPACE

QDBusArgument &operator<<(QDBusArgument &argument,

                          const ICd2DetailsDBusStruct &icd2)

{

    argument.beginStructure();

    argument << icd2.serviceType;

    argument << icd2.serviceAttributes;

    argument << icd2.setviceId;

    argument << icd2.networkType;

    argument << icd2.networkAttributes;

    argument << icd2.networkId;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument,

                                ICd2DetailsDBusStruct &icd2)

{

    argument.beginStructure();

    argument >> icd2.serviceType;

    argument >> icd2.serviceAttributes;

    argument >> icd2.setviceId;

    argument >> icd2.networkType;

    argument >> icd2.networkAttributes;

    argument >> icd2.networkId;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument,

                                ICd2DetailsList &detailsList)

{

     argument.beginArray();

     detailsList.clear();

     while (!argument.atEnd()) {

         ICd2DetailsDBusStruct element;

         argument >> element;

         detailsList.append(element);

     }

     argument.endArray();

     return argument;

}

QDBusArgument &operator<<(QDBusArgument &argument,

                          const ICd2DetailsList &detailsList)

{

     argument.beginArray(qMetaTypeId<ICd2DetailsDBusStruct>());

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

         argument << detailsList[i];

     argument.endArray();

     return argument;

}

static QHash<QString, QVariant> properties;

static QString get_network_interface();

void QNetworkSessionPrivateImpl::iapStateChanged(const QString& iapid, uint icd_connection_state)

{

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

        updateIdentifier(iapid);

    }

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

         (activeConfig.identifier() == iapid)) ||

        (publicConfig.identifier() == iapid)) {

        switch (icd_connection_state) {

        case ICD_STATE_CONNECTING:

            updateState(QNetworkSession::Connecting);

            break;

        case ICD_STATE_CONNECTED:

            updateState(QNetworkSession::Connected);

            break;

        case ICD_STATE_DISCONNECTING:

            updateState(QNetworkSession::Closing);

            break;

        case ICD_STATE_DISCONNECTED:

            updateState(QNetworkSession::Disconnected);

            break;

        default:

            break;

        }

    }

}

void QNetworkSessionPrivateImpl::cleanupSession(void)

{

    QObject::disconnect(q, SIGNAL(stateChanged(QNetworkSession::State)), this, SLOT(updateProxies(QNetworkSession::State)));

}

void QNetworkSessionPrivateImpl::updateState(QNetworkSession::State newState)

{

    if (newState != state) {

        if (newState == QNetworkSession::Disconnected) {

            if (isOpen) {

                // The Session was aborted by the user or system

                lastError = QNetworkSession::SessionAbortedError;

                emit QNetworkSessionPrivate::error(lastError);

                emit closed();

            }

            if (m_stopTimer.isActive()) {

                // Session was closed by calling stop()

                m_stopTimer.stop();

            }

            isOpen = false;

            opened = false;

            currentNetworkInterface.clear();

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

                copyConfig(publicConfig, activeConfig);

                IcdNetworkConfigurationPrivate *icdConfig =

                    toIcdConfig(privateConfiguration(activeConfig));

                icdConfig->mutex.lock();

                icdConfig->state = QNetworkConfiguration::Defined;

                icdConfig->mutex.unlock();

            } else {

                if (!activeConfig.isValid()) {

                    // Active configuration (IAP) was removed from system

                    // => Connection was disconnected and configuration became

                    //    invalid

                    // => Also Session state must be changed to invalid

                    newState = QNetworkSession::Invalid;

                }

            }

        } else if (newState == QNetworkSession::Connected) {

            if (opened) {

                isOpen = true;

            }

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

            IcdNetworkConfigurationPrivate *icdConfig =

                toIcdConfig(privateConfiguration(activeConfig));

            icdConfig->mutex.lock();

            icdConfig->state = QNetworkConfiguration::Active;

            icdConfig->type = QNetworkConfiguration::InternetAccessPoint;

            icdConfig->mutex.unlock();

	    }

        IcdNetworkConfigurationPrivate *icdConfig =

            toIcdConfig(privateConfiguration(publicConfig));

        icdConfig->mutex.lock();

        icdConfig->state = QNetworkConfiguration::Active;

        icdConfig->mutex.unlock();

	}

        if (newState != state) {

            state = newState;

            emit stateChanged(newState);

        }

    }

}

void QNetworkSessionPrivateImpl::updateIdentifier(const QString &newId)

{

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

        IcdNetworkConfigurationPrivate *icdConfig =

            toIcdConfig(privateConfiguration(activeConfig));

        icdConfig->mutex.lock();

        icdConfig->network_attrs |= ICD_NW_ATTR_IAPNAME;

        icdConfig->id = newId;

        icdConfig->mutex.unlock();

    } else {

        IcdNetworkConfigurationPrivate *icdConfig =

            toIcdConfig(privateConfiguration(publicConfig));

        icdConfig->mutex.lock();

        icdConfig->network_attrs |= ICD_NW_ATTR_IAPNAME;

        if (icdConfig->id != newId)

            icdConfig->id = newId;

        icdConfig->mutex.unlock();

    }

}

{

    /* This could be also implemented by using the Maemo::Icd::statistics()

     * that gets the statistics data for a specific IAP. Change if

     * necessary.

     */

    Maemo::Icd icd;

    QList<Maemo::IcdStatisticsResult> stats_results;

    foreach (const Maemo::IcdStatisticsResult &res, stats_results) {

    }

}

quint64 QNetworkSessionPrivateImpl::bytesWritten() const

{

}

quint64 QNetworkSessionPrivateImpl::bytesReceived() const

{

}

quint64 QNetworkSessionPrivateImpl::activeTime() const

{

}

QNetworkConfiguration& QNetworkSessionPrivateImpl::copyConfig(QNetworkConfiguration &fromConfig,

                                                              QNetworkConfiguration &toConfig,

                                                              bool deepCopy)

{

    IcdNetworkConfigurationPrivate *cpPriv;

    if (deepCopy) {

        cpPriv = new IcdNetworkConfigurationPrivate;

        setPrivateConfiguration(toConfig, QNetworkConfigurationPrivatePointer(cpPriv));

    } else {

        cpPriv = toIcdConfig(privateConfiguration(toConfig));

    }

    IcdNetworkConfigurationPrivate *fromPriv = toIcdConfig(privateConfiguration(fromConfig));

    QMutexLocker toLocker(&cpPriv->mutex);

    QMutexLocker fromLocker(&fromPriv->mutex);

    cpPriv->name = fromPriv->name;

    cpPriv->isValid = fromPriv->isValid;

    // Note that we do not copy id field here as the publicConfig does

    // not contain a valid IAP id.

    cpPriv->state = fromPriv->state;

    cpPriv->type = fromPriv->type;

    cpPriv->roamingSupported = fromPriv->roamingSupported;

    cpPriv->purpose = fromPriv->purpose;

    cpPriv->network_id = fromPriv->network_id;

    cpPriv->iap_type = fromPriv->iap_type;

    cpPriv->network_attrs = fromPriv->network_attrs;

    cpPriv->service_type = fromPriv->service_type;

    cpPriv->service_id = fromPriv->service_id;

    cpPriv->service_attrs = fromPriv->service_attrs;

    return toConfig;

}

/* This is called by QNetworkSession constructor and it updates the current

 * state of the configuration.

 */

void QNetworkSessionPrivateImpl::syncStateWithInterface()

{

    /* Initially we are not active although the configuration might be in

     * connected state.

     */

    isOpen = false;

    opened = false;

    connect(engine, SIGNAL(iapStateChanged(const QString&, uint)),

            this, SLOT(iapStateChanged(const QString&, uint)));

    QObject::connect(q, SIGNAL(stateChanged(QNetworkSession::State)), this, SLOT(updateProxies(QNetworkSession::State)));

    state = QNetworkSession::Invalid;

    lastError = QNetworkSession::UnknownSessionError;

    switch (publicConfig.type()) {

    case QNetworkConfiguration::InternetAccessPoint:

        activeConfig = publicConfig;

        break;

    case QNetworkConfiguration::ServiceNetwork:

        serviceConfig = publicConfig;

	break;

    case QNetworkConfiguration::UserChoice:

	// active config will contain correct data after open() has succeeded

        copyConfig(publicConfig, activeConfig);

	/* We create new configuration that holds the actual configuration

	 * returned by icd. This way publicConfig still contains the

	 * original user specified configuration.

	 *

	 * Note that the new activeConfig configuration is not inserted

	 * to configurationManager as manager class will get the newly

	 * connected configuration from gconf when the IAP is saved.

	 * This configuration manager update is done by IapMonitor class.

	 * If the ANY connection fails in open(), then the configuration

	 * data is not saved to gconf and will not be added to

	 * configuration manager IAP list.

	 */

#ifdef BEARER_MANAGEMENT_DEBUG

	qDebug()<<"New configuration created for" << publicConfig.identifier();

#endif

	break;

    default:

	/* Invalid configuration, no point continuing */

	return;

    }

    if (!activeConfig.isValid())

	return;

    /* Get the initial state from icd */

    Maemo::Icd icd;

    QList<Maemo::IcdStateResult> state_results;

    /* Update the active config from first connection, this is ok as icd

     * supports only one connection anyway.

     */

    if (icd.state(state_results) && !state_results.isEmpty()) {

	/* If we did not get full state back, then we are not

	 * connected and can skip the next part.

	 */

	if (!(state_results.first().params.network_attrs == 0 &&

		state_results.first().params.network_id.isEmpty())) {

	    /* If we try to connect to specific IAP and we get results back

	     * that tell the icd is actually connected to another IAP,

	     * then do not update current state etc.

	     */

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

            publicConfig.identifier() == state_results.first().params.network_id) {

		switch (state_results.first().state) {

		case ICD_STATE_DISCONNECTED:

            state = QNetworkSession::Disconnected;

            if (QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig)) {

                ptr->mutex.lock();

                ptr->isValid = true;

                ptr->mutex.unlock();

            }

            break;

		case ICD_STATE_CONNECTING:

            state = QNetworkSession::Connecting;

            if (QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig)) {

                ptr->mutex.lock();

                ptr->isValid = true;

                ptr->mutex.unlock();

            }

            break;

		case ICD_STATE_CONNECTED:

        {

            if (!state_results.first().error.isEmpty())

                break;

            const QString id = state_results.first().params.network_id;

            QNetworkConfiguration config = manager.configurationFromIdentifier(id);

            if (config.isValid()) {

                //we don't want the copied data if the config is already known by the manager

                //just reuse it so that existing references to the old data get the same update

                setPrivateConfiguration(activeConfig, privateConfiguration(config));

            }

            QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);

            QMutexLocker configLocker(&ptr->mutex);

			state = QNetworkSession::Connected;

            toIcdConfig(ptr)->network_id = state_results.first().params.network_id;

            ptr->id = toIcdConfig(ptr)->network_id;

            toIcdConfig(ptr)->network_attrs = state_results.first().params.network_attrs;

            toIcdConfig(ptr)->iap_type = state_results.first().params.network_type;

            toIcdConfig(ptr)->service_type = state_results.first().params.service_type;

            toIcdConfig(ptr)->service_id = state_results.first().params.service_id;

            toIcdConfig(ptr)->service_attrs = state_results.first().params.service_attrs;

            ptr->type = QNetworkConfiguration::InternetAccessPoint;

            ptr->state = QNetworkConfiguration::Active;

            ptr->isValid = true;

            currentNetworkInterface = get_network_interface();

            Maemo::IAPConf iap_name(ptr->id);

			QString name_value = iap_name.value("name").toString();

			if (!name_value.isEmpty())

                ptr->name = name_value;

			else

                ptr->name = ptr->id;

            // Add the new active configuration to manager or update the old config

                engine->addSessionConfiguration(ptr);

                engine->changedSessionConfiguration(ptr);

        }

        break;

		case ICD_STATE_DISCONNECTING:

            state = QNetworkSession::Closing;

            if (QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig)) {

                ptr->mutex.lock();

                ptr->isValid = true;

                ptr->mutex.unlock();

            }

            break;

		default:

            break;

		}

    }

	} else {

#ifdef BEARER_MANAGEMENT_DEBUG

	    qDebug() << "status_req tells icd is not connected";

#endif

	}

    } else {

#ifdef BEARER_MANAGEMENT_DEBUG

	qDebug() << "status_req did not return any results from icd";

#endif

    }

    networkConfigurationsChanged();

}

void QNetworkSessionPrivateImpl::networkConfigurationsChanged()

{

    if (serviceConfig.isValid())

        updateStateFromServiceNetwork();

    else

        updateStateFromActiveConfig();

}

void QNetworkSessionPrivateImpl::updateStateFromServiceNetwork()

{

    QNetworkSession::State oldState = state;

    foreach (const QNetworkConfiguration &config, serviceConfig.children()) {

        if ((config.state() & QNetworkConfiguration::Active) != QNetworkConfiguration::Active)

            continue;

        if (activeConfig != config) {

            activeConfig = config;

            emit newConfigurationActivated();

        }

        state = QNetworkSession::Connected;

        if (state != oldState)

            emit stateChanged(state);