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

**

** 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 <QHash>

#include "qnetworksession_maemo_p.h"

#include <dbus/dbus.h>

#include <dbus/dbus-glib-lowlevel.h>

#include <maemo_icd.h>

#include <iapconf.h>

#include <proxyconf.h>

#include <sys/types.h>

#include <ifaddrs.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

QTM_BEGIN_NAMESPACE

static QHash<QString, QVariant> properties;

static QString get_network_interface();

static DBusConnection *dbus_connection;

static DBusHandlerResult signal_handler(DBusConnection *connection,

					DBusMessage *message,

					void *user_data);

#define ICD_DBUS_MATCH		"type='signal'," \

				"interface='" ICD_DBUS_INTERFACE "'," \

				"path='" ICD_DBUS_PATH "'"

static inline DBusConnection *get_dbus_conn(DBusError *error)

{

    DBusConnection *conn = dbus_bus_get(DBUS_BUS_SYSTEM, error);

#ifdef BEARER_MANAGEMENT_DEBUG

    qDebug() << "Listening to bus" << dbus_bus_get_unique_name(conn);

#endif

    return conn;

}

/* Helper class that monitors the Icd status messages and

 * can change the IAP status accordingly. This is a singleton.

 */

class IcdListener : public QObject

{

    Q_OBJECT

public:

    IcdListener() : first_call(true) { }

    friend DBusHandlerResult signal_handler(DBusConnection *connection,

					    DBusMessage *message,

					    void *user_data);

    void setup(QNetworkSessionPrivate *d);

    void cleanup();

    void cleanupSession(QNetworkSessionPrivate *ptr);

    enum IapConnectionStatus {

	/* The IAP was connected */

	CONNECTED = 0,

	/* The IAP was disconnected */

	DISCONNECTED,

	/* The IAP is disconnecting */

	DISCONNECTING,

	/* The IAP has a network address, but is not yet fully connected */

	NETWORK_UP

    };

private:

    void icdSignalReceived(QString&, QString&, QString&);

    bool first_call;

    QHash<QString, QNetworkSessionPrivate* > sessions;

};

Q_GLOBAL_STATIC(IcdListener, icdListener);

static DBusHandlerResult signal_handler(DBusConnection *,

					DBusMessage *message,

					void *user_data)

{

    if (dbus_message_is_signal(message,

				ICD_DBUS_INTERFACE,

				ICD_STATUS_CHANGED_SIG)) {

	IcdListener *icd = (IcdListener *)user_data;

	DBusError error;

	dbus_error_init(&error);

	char *iap_id = 0;

	char *network_type = 0;

	char *state = 0;

	if (dbus_message_get_args(message, &error,

				    DBUS_TYPE_STRING, &iap_id,

				    DBUS_TYPE_STRING, &network_type,

				    DBUS_TYPE_STRING, &state,

				    DBUS_TYPE_INVALID) == FALSE) {

	    qWarning() << QString("Failed to parse icd status signal: %1").arg(error.message);

        } else {

	    QString _iap_id(iap_id);

	    QString _network_type(network_type);

	    QString _state(state);

	    icd->icdSignalReceived(_iap_id, _network_type, _state);

	}

	dbus_error_free(&error);

        return DBUS_HANDLER_RESULT_HANDLED;

    }

    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

void IcdListener::setup(QNetworkSessionPrivate *d)

{

    if (first_call) {

	// We use the old Icd dbus interface like in ConIC

	DBusError error;

	dbus_error_init(&error);

	dbus_connection = get_dbus_conn(&error);

	if (dbus_error_is_set(&error)) {

	    qWarning() << "Cannot get dbus connection.";

	    dbus_error_free(&error);

	    return;

	}

	static struct DBusObjectPathVTable icd_vtable;

	icd_vtable.message_function = signal_handler;

	dbus_bus_add_match(dbus_connection, ICD_DBUS_MATCH, &error);

	if (dbus_error_is_set(&error)) {

	    qWarning() << "Cannot add match" << ICD_DBUS_MATCH;

	    dbus_error_free(&error);

	    return;

	}

	if (dbus_connection_register_object_path(dbus_connection,

						    ICD_DBUS_PATH,

						    &icd_vtable,

						    (void*)this) == FALSE) {

	    qWarning() << "Cannot register dbus signal handler, interface"<< ICD_DBUS_INTERFACE << "path" << ICD_DBUS_PATH;

	    dbus_error_free(&error);

	    return;

	}

#ifdef BEARER_MANAGEMENT_DEBUG

	qDebug() << "Listening" << ICD_STATUS_CHANGED_SIG << "signal from" << ICD_DBUS_SERVICE;

#endif

	first_call = false;

	dbus_error_free(&error);

    }

    QString id = d->activeConfig.identifier();

    if (!sessions.contains(id)) {

	QNetworkSessionPrivate *ptr = d;

	sessions.insert(id, ptr);

    }

}

void IcdListener::icdSignalReceived(QString& iap_id,

#ifdef BEARER_MANAGEMENT_DEBUG

				    QString& network_type,

#else

				    QString&,

#endif

				    QString& state)

{

    if (iap_id == OSSO_IAP_SCAN) // icd sends scan status signals which we will ignore

	return;

#ifdef BEARER_MANAGEMENT_DEBUG

    qDebug() << "Status received:" << iap_id << "type" << network_type << "state" << state;

#endif

    if (!sessions.contains(iap_id)) {

#ifdef BEARER_MANAGEMENT_DEBUG

	qDebug() << "No session for IAP" << iap_id;

#endif

	return;

    }

    QNetworkSessionPrivate *session = sessions.value(iap_id);

    QNetworkConfiguration ap_conf = session->manager.configurationFromIdentifier(iap_id);

    if (!ap_conf.isValid()) {

#ifdef BEARER_MANAGEMENT_DEBUG

	qDebug() << "Unknown IAP" << iap_id;

#endif

	return;

    }

    IapConnectionStatus status;

    if (state == "IDLE") {

	status = DISCONNECTED;

    } else if (state == "CONNECTED") {

	status = CONNECTED;

    } else if (state == "NETWORKUP") {

	status = NETWORK_UP;

    } else {

	//qDebug() << "Unknown state" << state;

	return;

    }

    if (status == DISCONNECTED) {

	if (ap_conf.state() == QNetworkConfiguration::Active) {

	    /* The IAP was just disconnected by Icd */

	    session->updateState(QNetworkSession::Disconnected);

	} else {

#ifdef BEARER_MANAGEMENT_DEBUG

	    qDebug() << "Got a network disconnect when in state" << ap_conf.state();

#endif

	}

    } else if (status == CONNECTED) {

	/* The IAP was just connected by Icd */

	session->updateState(QNetworkSession::Connected);

	session->updateIdentifier(iap_id);

	if (session->publicConfig.identifier() == OSSO_IAP_ANY) {

#ifdef BEARER_MANAGEMENT_DEBUG

	    qDebug() << "IAP" << iap_id << "connected when connecting to" << OSSO_IAP_ANY;

#endif

	} else {

#ifdef BEARER_MANAGEMENT_DEBUG

	    qDebug() << "IAP" << iap_id << "connected";

#endif

	}

    }

    return;

}

void IcdListener::cleanup()

{

    if (!first_call) {

	dbus_bus_remove_match(dbus_connection, ICD_DBUS_MATCH, NULL);

	dbus_connection_unref(dbus_connection);

    }

}

void IcdListener::cleanupSession(QNetworkSessionPrivate *ptr)

{

    if (ptr->publicConfig.type() == QNetworkConfiguration::UserChoice)

        (void)sessions.take(ptr->activeConfig.identifier());

    else

        (void)sessions.take(ptr->publicConfig.identifier());

}

void QNetworkSessionPrivate::cleanupSession(void)

{

    icdListener()->cleanupSession(this);

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

}

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

{

    if( newState != state) {

        state = newState;

	if (state == QNetworkSession::Disconnected) {

            isOpen = false;

	    currentNetworkInterface.clear();

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

		activeConfig.d->state = QNetworkConfiguration::Defined;

	    publicConfig.d->state = QNetworkConfiguration::Defined;

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

            isOpen = true;

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

		activeConfig.d->state = QNetworkConfiguration::Active;

		activeConfig.d->type = QNetworkConfiguration::InternetAccessPoint;

	    }

	    publicConfig.d->state = QNetworkConfiguration::Active;

	}

	emit q->stateChanged(newState);

    }

}

void QNetworkSessionPrivate::updateIdentifier(QString &newId)

{

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

	activeConfig.d->network_attrs |= ICD_NW_ATTR_IAPNAME;

	activeConfig.d->id = newId;

    } else {

	publicConfig.d->network_attrs |= ICD_NW_ATTR_IAPNAME;

	if (publicConfig.d->id != newId) {

	    qWarning() << "Your config id changed from" << publicConfig.d->id << "to" << newId;

	    publicConfig.d->id = newId;

	}

    }

}

quint64 QNetworkSessionPrivate::getStatistics(bool sent) const

{

    /* 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;

    quint64 counter_rx = 0, counter_tx = 0;

    if (!icd.statistics(stats_results)) {

	return 0;

    }

    foreach (Maemo::IcdStatisticsResult res, stats_results) {

	if (res.params.network_attrs & ICD_NW_ATTR_IAPNAME) {

	    /* network_id is the IAP UUID */

	    if (QString(res.params.network_id.data()) == activeConfig.identifier()) {

		counter_tx = res.bytes_sent;

		counter_rx = res.bytes_received;

	    }

	} else {

	    /* We probably will never get to this branch */

	    QNetworkConfigurationPrivate *d = activeConfig.d.data();

	    if (res.params.network_id == d->network_id) {

		counter_tx = res.bytes_sent;

		counter_rx = res.bytes_received;

	    }

	}

    }

    if (sent)

	return counter_tx;

    else

	return counter_rx;

}

quint64 QNetworkSessionPrivate::bytesWritten() const

{

    return getStatistics(true);

}

quint64 QNetworkSessionPrivate::bytesReceived() const

{

    return getStatistics(false);

}

quint64 QNetworkSessionPrivate::activeTime() const

{

    if (startTime.isNull()) {

        return 0;

    }

    return startTime.secsTo(QDateTime::currentDateTime());

}

QNetworkConfiguration& QNetworkSessionPrivate::copyConfig(QNetworkConfiguration &fromConfig, QNetworkConfiguration &toConfig, bool deepCopy)

{

    if (deepCopy) {

        QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();

        QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(cpPriv);

        toConfig.d = ptr;

    }

    toConfig.d->name = fromConfig.d->name;

    toConfig.d->isValid = fromConfig.d->isValid;

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

    // not contain a valid IAP id.

    toConfig.d->state = fromConfig.d->state;

    toConfig.d->type = fromConfig.d->type;

    toConfig.d->roamingSupported = fromConfig.d->roamingSupported;

    toConfig.d->purpose = fromConfig.d->purpose;

    toConfig.d->network_id = fromConfig.d->network_id;

    toConfig.d->iap_type = fromConfig.d->iap_type;

    toConfig.d->network_attrs = fromConfig.d->network_attrs;

    toConfig.d->service_type = fromConfig.d->service_type;

    toConfig.d->service_id = fromConfig.d->service_id;

    toConfig.d->service_attrs = fromConfig.d->service_attrs;

    toConfig.d->manager = fromConfig.d->manager;

    return toConfig;

}

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

 * state of the configuration.

 */

void QNetworkSessionPrivate::syncStateWithInterface()

{

    /* Start to listen Icd status messages. */

    icdListener()->setup(this);

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

     * connected state.

     */

    isOpen = false;

    opened = false;

    QObject::connect(&manager, SIGNAL(updateCompleted()), this, SLOT(networkConfigurationsChanged()));

    if (publicConfig.d.data()) {

	QNetworkConfigurationManagerPrivate* mgr = (QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager;

	if (mgr) {

	    QObject::connect(mgr, SIGNAL(configurationChanged(QNetworkConfiguration)),

			    this, SLOT(configurationChanged(QNetworkConfiguration)));

	} else {

	    qWarning()<<"Manager object not set when trying to connect configurationChanged signal. Your configuration object is not correctly setup, did you remember to call manager.updateConfigurations() before creating session object?";

	    state = QNetworkSession::Invalid;

	    lastError = QNetworkSession::UnknownSessionError;

	    return;

	}

    }

    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.d->id == state_results.first().params.network_id) {

		switch (state_results.first().state) {

		case ICD_STATE_DISCONNECTED:

		    state = QNetworkSession::Disconnected;

		    if (activeConfig.d.data())

			activeConfig.d->isValid = true;

		    break;

		case ICD_STATE_CONNECTING: