Merge branch 'master' of scm.dev.nokia.troll.no:qt/mobility-staging into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/mobility-staging: (165 commits)
  Add 'We mean it.' header.
  Use provided typedef for QNetworkConfigurationPrivatePointer.
  Fix public includes.
  Document networkSessionOnline() signal and mark as internal.
  Tag new classes as since 4.7.
  Fix documentation.
  Remove debug.
  Update copyright year to 2010.
  We don't need to migrate cached replies.
  Fix after reworking to use signals/slots.
  Remove debug.
  Rename and remove unused private slots.
  Add comments to private state enums.
  Revert "(ODBC) Use wchar_t instead of assuming 2 bytes."
  Move check for range header support to before deleting backend.
  Don't try to migrate finished or aborted requests.
  Clarify TemporaryNetworkFailureError docs.
  Remove functions used for testing.
  Connect signals between QNAM and QNetworkReplyImpl.
  Fix networkAccessEnabled implementation.
  ...

6 files changed, 2609 insertions, 0 deletions

diff --git a/src/plugins/bearer/symbian/main.cpp b/src/plugins/bearer/symbian/main.cpp
new file mode 100644
index 0000000..0321451
--- /dev/null
+++ b/src/plugins/bearer/symbian/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** 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 "symbianengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSymbianEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QSymbianEnginePlugin();
+    ~QSymbianEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QSymbianEnginePlugin::QSymbianEnginePlugin()
+{
+}
+
+QSymbianEnginePlugin::~QSymbianEnginePlugin()
+{
+}
+
+QStringList QSymbianEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("symbian");
+}
+
+QBearerEngine *QSymbianEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("symbian"))
+        return new SymbianEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QSymbianEnginePlugin)
+Q_EXPORT_PLUGIN2(qsymbianbearer, QSymbianEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/qnetworksession_impl.cpp b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
new file mode 100644
index 0000000..7762fb5
--- /dev/null
+++ b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
@@ -0,0 +1,1135 @@
+/****************************************************************************
+**
+** 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>
+
+QT_BEGIN_NAMESPACE
+
+QNetworkSessionPrivateImpl::QNetworkSessionPrivateImpl(SymbianEngine *engine)
+    : CActive(CActive::EPriorityStandard), engine(engine), ipConnectionNotifier(0),
+      iError(QNetworkSession::UnknownSessionError),
+      iALREnabled(0)
+{
+    CActiveScheduler::Add(this);
+    
+    // Try to load "Open C" dll dynamically and
+    // try to attach to setdefaultif function dynamically.
+    if (iOpenCLibrary.Load(_L("libc")) == KErrNone) {
+        iDynamicSetdefaultif = (TOpenCSetdefaultifFunction)iOpenCLibrary.Lookup(564);
+    }
+
+    TRAP_IGNORE(iConnectionMonitor.ConnectL());
+}
+
+QNetworkSessionPrivateImpl::~QNetworkSessionPrivateImpl()
+{
+    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();
+    if (iDynamicSetdefaultif) {
+        iDynamicSetdefaultif(0);
+    }
+
+    iConnectionMonitor.CancelNotifications();
+    iConnectionMonitor.Close();
+
+    iOpenCLibrary.Close();
+}
+
+void QNetworkSessionPrivateImpl::syncStateWithInterface()
+{
+    if (!privateConfiguration(publicConfig))
+        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 ((privateConfiguration(publicConfig)->state & QNetworkConfiguration::Discovered) ==
+            QNetworkConfiguration::Discovered) {
+            newState(QNetworkSession::Disconnected);
+        } else {
+            newState(QNetworkSession::NotAvailable);
+        }
+    }
+}
+
+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);
+}
+
+QNetworkInterface QNetworkSessionPrivateImpl::currentInterface() const
+{
+    if (!publicConfig.isValid() || state != QNetworkSession::Connected) {
+        return QNetworkInterface();
+    }
+    
+    return activeInterface;
+}
+
+QVariant QNetworkSessionPrivateImpl::sessionProperty(const QString& /*key*/) const
+{
+    return QVariant();
+}
+
+void QNetworkSessionPrivateImpl::setSessionProperty(const QString& /*key*/, const QVariant& /*value*/)
+{
+}
+
+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()
+{
+    if (isOpen || !privateConfiguration(publicConfig) || (state == QNetworkSession::Connecting)) {
+        return;
+    }
+
+    // Cancel notifications from RConnectionMonitor
+    // => RConnection::ProgressNotification will be used for IAP/SNAP monitoring
+    iConnectionMonitor.CancelNotifications();
+    
+    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) {
+        // 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 == toSymbianConfig(privateConfiguration(publicConfig))->numericId) {
+                        if (iConnection.Attach(connInfo, RConnection::EAttachTypeNormal) == KErrNone) {
+                            activeConfig = publicConfig;
+                            activeInterface = interface(toSymbianConfig(privateConfiguration(activeConfig))->numericId);
+                            connected = ETrue;
+                            startTime = QDateTime::currentDateTime();
+                            if (iDynamicSetdefaultif) {
+                                // Use name of the IAP to set default IAP
+                                QByteArray nameAsByteArray = publicConfig.name().toUtf8();
+                                ifreq ifr;
+                                strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+                                error = iDynamicSetdefaultif(&ifr);
+                            }
+                            isOpen = true;
+                            // Make sure that state will be Connected
+                            newState(QNetworkSession::Connected);
+                            emit quitPendingWaitsForOpened();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!connected) {
+            TCommDbConnPref pref;
+            pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
+            pref.SetIapId(toSymbianConfig(privateConfiguration(publicConfig))->numericId);
+            iConnection.Start(pref, iStatus);
+            if (!IsActive()) {
+                SetActive();
+            }
+            newState(QNetworkSession::Connecting);
+        }
+    } else if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+        TConnSnapPref snapPref(toSymbianConfig(privateConfiguration(publicConfig))->numericId);
+        iConnection.Start(snapPref, iStatus);
+        if (!IsActive()) {
+            SetActive();
+        }
+        newState(QNetworkSession::Connecting);
+    } else if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        iKnownConfigsBeforeConnectionStart = engine->accessPointConfigurations.keys();
+        iConnection.Start(iStatus);
+        if (!IsActive()) {
+            SetActive();
+        }
+        newState(QNetworkSession::Connecting);
+    }
+ 
+    if (error != KErrNone) {
+        isOpen = 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)
+{
+    if (!isOpen) {
+        return;
+    }
+
+    TUint activeIap = toSymbianConfig(privateConfiguration(activeConfig))->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();
+    if (iDynamicSetdefaultif) {
+        iDynamicSetdefaultif(0);
+    }
+
+#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 closed();
+    }
+}
+
+void QNetworkSessionPrivateImpl::stop()
+{
+    if (!isOpen) {
+        return;
+    }
+    isOpen = false;
+    newState(QNetworkSession::Closing);
+    iConnection.Stop(RConnection::EStopAuthoritative);
+    isOpen = true;
+    close(false);
+    emit closed();
+}
+
+void QNetworkSessionPrivateImpl::migrate()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->MigrateToPreferredCarrier();
+#endif
+}
+
+void QNetworkSessionPrivateImpl::ignore()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->IgnorePreferredCarrier();
+    if (!iALRUpgradingConnection) {
+        newState(QNetworkSession::Disconnected);
+    } else {
+        newState(QNetworkSession::Connected,iOldRoamingIap);
+    }
+#endif
+}
+
+void QNetworkSessionPrivateImpl::accept()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->NewCarrierAccepted();
+    if (iDynamicSetdefaultif) {
+        // Use name of the IAP to set default IAP
+        QByteArray nameAsByteArray = activeConfig.name().toUtf8();
+        ifreq ifr;
+        strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+        iDynamicSetdefaultif(&ifr);
+    }
+    newState(QNetworkSession::Connected, iNewRoamingIap);
+#endif
+}
+
+void QNetworkSessionPrivateImpl::reject()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->NewCarrierRejected();
+    if (!iALRUpgradingConnection) {
+        newState(QNetworkSession::Disconnected);
+    } else {
+        newState(QNetworkSession::Connected, iOldRoamingIap);
+    }
+#endif
+}
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+void QNetworkSessionPrivateImpl::PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,
+                                                       TAccessPointInfo aNewAPInfo,
+                                                       TBool aIsUpgrade,
+                                                       TBool aIsSeamless)
+{
+    iOldRoamingIap = aOldAPInfo.AccessPoint();
+    iNewRoamingIap = aNewAPInfo.AccessPoint();
+    newState(QNetworkSession::Roaming);
+    if (iALREnabled > 0) {
+        iALRUpgradingConnection = aIsUpgrade;
+        QList<QNetworkConfiguration> configs = publicConfig.children();
+        for (int i=0; i < configs.count(); i++) {
+            if (toSymbianConfig(privateConfiguration(configs[i]))->numericId == aNewAPInfo.AccessPoint()) {
+                emit preferredConfigurationChanged(configs[i], aIsSeamless);
+            }
+        }
+    } else {
+        migrate();
+    }
+}
+
+void QNetworkSessionPrivateImpl::NewCarrierActive(TAccessPointInfo /*aNewAPInfo*/, TBool /*aIsSeamless*/)
+{
+    if (iALREnabled > 0) {
+        emit newConfigurationActivated();
+    } else {
+        accept();
+    }
+}
+
+void QNetworkSessionPrivateImpl::Error(TInt /*aError*/)
+{
+    if (isOpen) {
+        isOpen = false;
+        activeConfig = QNetworkConfiguration();
+        serviceConfig = QNetworkConfiguration();
+        iError = QNetworkSession::RoamingError;
+        emit QNetworkSessionPrivate::error(iError);
+        Cancel();
+        if (ipConnectionNotifier) {
+            ipConnectionNotifier->StopNotifications();
+        }
+        syncStateWithInterface();
+        // In some cases IAP is still in Connected state when
+        // syncStateWithInterface(); is called
+        // => Following call makes sure that Session state
+        //    changes immediately to Disconnected.
+        newState(QNetworkSession::Disconnected);
+        emit closed();
+    }
+}
+#endif
+
+void QNetworkSessionPrivateImpl::setALREnabled(bool enabled)
+{
+    if (enabled) {
+        iALREnabled++;
+    } else {
+        iALREnabled--;
+    }
+}
+
+QNetworkConfiguration QNetworkSessionPrivateImpl::bestConfigFromSNAP(const QNetworkConfiguration& snapConfig) const
+{
+    QNetworkConfiguration config;
+    QList<QNetworkConfiguration> subConfigurations = snapConfig.children();
+    for (int i = 0; i < subConfigurations.count(); i++ ) {
+        if (subConfigurations[i].state() == QNetworkConfiguration::Active) {
+            config = subConfigurations[i];
+            break;
+        } else if (!config.isValid() && subConfigurations[i].state() == QNetworkConfiguration::Discovered) {
+            config = subConfigurations[i];
+        }
+    }
+    if (!config.isValid() && subConfigurations.count() > 0) {
+        config = subConfigurations[0];
+    }
+    return config;
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesWritten() const
+{
+    return transferredData(KUplinkData);
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesReceived() const
+{
+    return transferredData(KDownlinkData);
+}
+
+quint64 QNetworkSessionPrivateImpl::transferredData(TUint dataType) const
+{
+    if (!publicConfig.isValid()) {
+        return 0;
+    }
+    
+    QNetworkConfiguration config;
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        if (serviceConfig.isValid()) {
+            config = serviceConfig;
+        } else {
+            if (activeConfig.isValid()) {
+                config = activeConfig;
+            }
+        }
+    } else {
+        config = publicConfig;
+    }
+
+    if (!config.isValid()) {
+        return 0;
+    }
+    
+    TUint count;
+    TRequestStatus status;
+    iConnectionMonitor.GetConnectionCount(count, status);
+    User::WaitForRequest(status);
+    if (status.Int() != KErrNone) {
+        return 0;
+    }
+    
+    TUint transferredData = 0;
+    TUint numSubConnections;
+    TUint connectionId;
+    bool configFound;
+    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) {
+                configFound = false;
+                if (config.type() == QNetworkConfiguration::ServiceNetwork) {
+                    QList<QNetworkConfiguration> configs = config.children();
+                    for (int i=0; i < configs.count(); i++) {
+                        if (toSymbianConfig(privateConfiguration(configs[i]))->numericId == apId) {
+                            configFound = true;
+                            break;
+                        }
+                    }
+                } else if (toSymbianConfig(privateConfiguration(config))->numericId == apId) {
+                    configFound = true;
+                }
+                if (configFound) {
+                    TUint tData;
+                    iConnectionMonitor.GetUintAttribute(connectionId, 0, dataType, tData, status );
+                    User::WaitForRequest(status);
+                    if (status.Int() == KErrNone) {
+                    transferredData += tData;
+                    }
+                }
+            }
+        }
+    }
+    
+    return transferredData;
+}
+
+quint64 QNetworkSessionPrivateImpl::activeTime() const
+{
+    if (!isOpen || startTime.isNull()) {
+        return 0;
+    }
+    return startTime.secsTo(QDateTime::currentDateTime());
+}
+
+QNetworkConfiguration QNetworkSessionPrivateImpl::activeConfiguration(TUint32 iapId) const
+{
+    if (iapId == 0) {
+        _LIT(KSetting, "IAP\\Id");
+        iConnection.GetIntSetting(KSetting, iapId);
+    }
+ 
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+        // Try to search IAP from the used SNAP using IAP Id
+        QList<QNetworkConfiguration> children = publicConfig.children();
+        for (int i=0; i < children.count(); i++) {
+            if (toSymbianConfig(privateConfiguration(children[i]))->numericId == iapId) {
+                return children[i];
+            }
+        }
+
+        // Given IAP Id was not found from the used SNAP
+        // => Try to search matching IAP using mappingName
+        //    mappingName contains:
+        //      1. "Access point name" for "Packet data" Bearer
+        //      2. "WLAN network name" (= SSID) for "Wireless LAN" Bearer
+        //      3. "Dial-up number" for "Data call Bearer" or "High Speed (GSM)" Bearer
+        //    <=> Note: It's possible that in this case reported IAP is
+        //              clone of the one of the IAPs of the used SNAP
+        //              => If mappingName matches, clone has been found
+        QNetworkConfiguration pt = QNetworkConfigurationManager().configurationFromIdentifier(QString::number(qHash(iapId)));
+        if (privateConfiguration(pt)) {
+            for (int i=0; i < children.count(); i++) {
+                if (toSymbianConfig(privateConfiguration(children[i]))->mappingName == toSymbianConfig(privateConfiguration(pt))->mappingName) {
+                    return children[i];
+                }
+            }
+        } else {
+            // Given IAP Id was not found from known IAPs array
+            return QNetworkConfiguration();
+        }
+
+        // Matching IAP was not found from used SNAP
+        // => IAP from another SNAP is returned
+        //    (Note: Returned IAP matches to given IAP Id)
+        return pt;
+    }
+#endif
+    
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        if (engine) {
+            QNetworkConfiguration pt = QNetworkConfigurationManager().configurationFromIdentifier(QString::number(qHash(iapId)));
+            // Try to found User Selected IAP from known IAPs (accessPointConfigurations)
+            if (pt.isValid()) {
+                return pt;
+            } else {
+                // Check if new (WLAN) IAP was created in IAP/SNAP dialog
+                // 1. Sync internal configurations array to commsdb first
+                engine->updateConfigurations();
+                // 2. Check if new configuration was created during connection creation
+                QList<QString> knownConfigs = engine->accessPointConfigurations.keys();
+                if (knownConfigs.count() > iKnownConfigsBeforeConnectionStart.count()) {
+                    // Configuration count increased => new configuration was created
+                    // => Search new, created configuration
+                    QString newIapId;
+                    for (int i=0; i < iKnownConfigsBeforeConnectionStart.count(); i++) {
+                        if (knownConfigs[i] != iKnownConfigsBeforeConnectionStart[i]) {
+                            newIapId = knownConfigs[i];
+                            break;
+                        }
+                    }
+                    if (newIapId.isEmpty()) {
+                        newIapId = knownConfigs[knownConfigs.count()-1];
+                    }
+                    pt = QNetworkConfigurationManager().configurationFromIdentifier(newIapId);
+                    if (pt.isValid())
+                        return pt;
+                }
+            }
+        }
+        return QNetworkConfiguration();
+    }
+
+    return publicConfig;
+}
+
+void QNetworkSessionPrivateImpl::RunL()
+{
+    TInt statusCode = iStatus.Int();
+
+    switch (statusCode) {
+        case KErrNone: // Connection created succesfully
+            {
+            TInt error = KErrNone;
+            QNetworkConfiguration newActiveConfig = activeConfiguration();
+            if (!newActiveConfig.isValid()) {
+                error = KErrGeneral;
+            } else if (iDynamicSetdefaultif) {
+                // Use name of the IAP to set default IAP
+                QByteArray nameAsByteArray = newActiveConfig.name().toUtf8();
+                ifreq ifr;
+                strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+                error = iDynamicSetdefaultif(&ifr);
+            }
+            
+            if (error != KErrNone) {
+                isOpen = false;
+                iError = QNetworkSession::UnknownSessionError;
+                emit QNetworkSessionPrivate::error(iError);
+                Cancel();
+                if (ipConnectionNotifier) {
+                    ipConnectionNotifier->StopNotifications();
+                }
+                syncStateWithInterface();
+                return;
+            }
+ 
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                // Activate ALR monitoring
+                iMobility = CActiveCommsMobilityApiExt::NewL(iConnection, *this);
+            }
+#endif
+            isOpen = true;
+            activeConfig = newActiveConfig;
+            activeInterface = interface(toSymbianConfig(privateConfiguration(activeConfig))->numericId);
+            if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+                serviceConfig = QNetworkConfigurationManager().configurationFromIdentifier(toSymbianConfig(privateConfiguration(activeConfig))->serviceNetworkPtr->id);
+            }
+            
+            startTime = QDateTime::currentDateTime();
+
+            newState(QNetworkSession::Connected);
+            emit quitPendingWaitsForOpened();
+            }
+            break;
+        case KErrNotFound: // Connection failed
+            isOpen = false;
+            activeConfig = QNetworkConfiguration();
+            serviceConfig = QNetworkConfiguration();
+            iError = QNetworkSession::InvalidConfigurationError;
+            emit QNetworkSessionPrivate::error(iError);
+            Cancel();
+            if (ipConnectionNotifier) {
+                ipConnectionNotifier->StopNotifications();
+            }
+            syncStateWithInterface();
+            break;
+        case KErrCancel: // Connection attempt cancelled
+        case KErrAlreadyExists: // Connection already exists
+        default:
+            isOpen = false;
+            activeConfig = QNetworkConfiguration();
+            serviceConfig = QNetworkConfiguration();
+            iError = QNetworkSession::UnknownSessionError;
+            emit QNetworkSessionPrivate::error(iError);
+            Cancel();
+            if (ipConnectionNotifier) {
+                ipConnectionNotifier->StopNotifications();
+            }
+            syncStateWithInterface();
+            break;
+    }
+}
+
+void QNetworkSessionPrivateImpl::DoCancel()
+{
+    iConnection.Close();
+}
+
+bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint accessPointId)
+{
+    // Make sure that activeConfig is always updated when SNAP is signaled to be
+    // connected.
+    if (isOpen && publicConfig.type() == QNetworkConfiguration::ServiceNetwork &&
+        newState == QNetworkSession::Connected) {
+        activeConfig = activeConfiguration(accessPointId);
+        activeInterface = interface(toSymbianConfig(privateConfiguration(activeConfig))->numericId);
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+        if (iDynamicSetdefaultif) {
+            // Use name of the IAP to set default IAP
+            QByteArray nameAsByteArray = activeConfig.name().toUtf8();
+            ifreq ifr;
+            strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+            iDynamicSetdefaultif(&ifr);
+        }
+#endif
+    }
+
+    // Make sure that same state is not signaled twice in a row.
+    if (state == newState) {
+        return true;
+    }
+
+    // Make sure that Connecting state does not overwrite Roaming state
+    if (state == QNetworkSession::Roaming && newState == QNetworkSession::Connecting) {
+        return false;
+    }
+
+    bool emitSessionClosed = false;
+    if (isOpen && state == QNetworkSession::Connected && newState == QNetworkSession::Disconnected) {
+        // Active & Connected state should change directly to Disconnected state
+        // only when something forces connection to close (eg. when another
+        // application or session stops connection or when network drops
+        // unexpectedly).
+        isOpen = false;
+        activeConfig = QNetworkConfiguration();
+        serviceConfig = QNetworkConfiguration();
+        iError = QNetworkSession::SessionAbortedError;
+        emit QNetworkSessionPrivate::error(iError);
+        Cancel();
+        if (ipConnectionNotifier) {
+            ipConnectionNotifier->StopNotifications();
+        }
+        // Start monitoring changes in IAP states
+        TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
+        emitSessionClosed = true; // Emit SessionClosed after state change has been reported
+    }
+
+    bool retVal = false;
+    if (accessPointId == 0) {
+        state = newState;
+        emit stateChanged(state);
+        retVal = true;
+    } else {
+        if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+            if (toSymbianConfig(privateConfiguration(publicConfig))->numericId == accessPointId) {
+                state = newState;
+                emit stateChanged(state);
+                retVal = true;
+            }
+        } else if (publicConfig.type() == QNetworkConfiguration::UserChoice && isOpen) {
+            if (toSymbianConfig(privateConfiguration(activeConfig))->numericId == accessPointId) {
+                state = newState;
+                emit stateChanged(state);
+                retVal = true;
+            }
+        } else if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+            QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+            for (int i = 0; i < subConfigurations.count(); i++) {
+                if (toSymbianConfig(privateConfiguration(subConfigurations[i]))->numericId == accessPointId) {
+                    if (newState == QNetworkSession::Connected) {
+                        // Make sure that when AccessPoint is reported to be Connected
+                        // also state of the related configuration changes to Active.
+                        privateConfiguration(subConfigurations[i])->state = QNetworkConfiguration::Active;
+    
+                        state = newState;
+                        emit stateChanged(state);
+                        retVal = true;
+                    } else {
+                        if (newState == QNetworkSession::Disconnected) {
+                            // Make sure that when AccessPoint is reported to be disconnected
+                            // also state of the related configuration changes from Active to Defined.
+                            privateConfiguration(subConfigurations[i])->state = QNetworkConfiguration::Defined;
+                        }
+                        QNetworkConfiguration config = bestConfigFromSNAP(publicConfig);
+                        if ((config.state() == QNetworkConfiguration::Defined) ||
+                            (config.state() == QNetworkConfiguration::Discovered)) {
+                            state = newState;
+                            emit stateChanged(state);
+                            retVal = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    if (emitSessionClosed) {
+        emit closed();
+    }
+
+    return retVal;
+}
+
+void QNetworkSessionPrivateImpl::handleSymbianConnectionStatusChange(TInt aConnectionStatus,
+                                                                 TInt aError,
+                                                                 TUint accessPointId)
+{
+    switch (aConnectionStatus)
+        {
+        // Connection unitialised
+        case KConnectionUninitialised:
+            break;
+
+        // Starting connetion selection
+        case KStartingSelection:
+            break;
+
+        // Selection finished
+        case KFinishedSelection:
+            if (aError == KErrNone)
+                {
+                // The user successfully selected an IAP to be used
+                break;
+                }
+            else
+                {
+                // The user pressed e.g. "Cancel" and did not select an IAP
+                newState(QNetworkSession::Disconnected,accessPointId);
+                }
+            break;
+
+        // Connection failure
+        case KConnectionFailure:
+            newState(QNetworkSession::NotAvailable);
+            break;
+
+        // Prepearing connection (e.g. dialing)
+        case KPsdStartingConfiguration:
+        case KPsdFinishedConfiguration:
+        case KCsdFinishedDialling:
+        case KCsdScanningScript:
+        case KCsdGettingLoginInfo:
+        case KCsdGotLoginInfo:
+            break;
+
+        // Creating connection (e.g. GPRS activation)
+        case KCsdStartingConnect:
+        case KCsdFinishedConnect:
+            newState(QNetworkSession::Connecting,accessPointId);
+            break;
+
+        // Starting log in
+        case KCsdStartingLogIn:
+            break;
+
+        // Finished login
+        case KCsdFinishedLogIn:
+            break;
+
+        // Connection open
+        case KConnectionOpen:
+            break;
+
+        case KLinkLayerOpen:
+            newState(QNetworkSession::Connected,accessPointId);
+            break;
+
+        // Connection blocked or suspended
+        case KDataTransferTemporarilyBlocked:
+            break;
+
+        // Hangup or GRPS deactivation
+        case KConnectionStartingClose:
+            newState(QNetworkSession::Closing,accessPointId);
+            break;
+
+        // Connection closed
+        case KConnectionClosed:
+            break;
+
+        case KLinkLayerClosed:
+            newState(QNetworkSession::Disconnected,accessPointId);
+            break;
+
+        // Unhandled state
+        default:
+            break;
+        }
+}
+
+void QNetworkSessionPrivateImpl::EventL(const CConnMonEventBase& aEvent)
+{
+    switch (aEvent.EventType())
+    {
+        case EConnMonConnectionStatusChange:
+            {
+            CConnMonConnectionStatusChange* realEvent;
+            realEvent = (CConnMonConnectionStatusChange*) &aEvent;
+
+            TUint connectionId = realEvent->ConnectionId();
+            TInt connectionStatus = realEvent->ConnectionStatus();
+
+            // Try to Find IAP Id using connection Id
+            TUint apId = 0;
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                for (int i = 0; i < subConfigurations.count(); i++ ) {
+                    if (toSymbianConfig(privateConfiguration(subConfigurations[i]))->connectionId == connectionId) {
+                        apId = toSymbianConfig(privateConfiguration(subConfigurations[i]))->numericId;
+                        break;
+                    }
+                }
+            } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                if (toSymbianConfig(privateConfiguration(publicConfig))->connectionId == connectionId) {
+                    apId = toSymbianConfig(privateConfiguration(publicConfig))->numericId;
+                }
+            }
+
+            if (apId > 0) {
+                handleSymbianConnectionStatusChange(connectionStatus, KErrNone, apId);
+            }
+            }
+            break;
+
+        case EConnMonCreateConnection:
+            {
+            CConnMonCreateConnection* realEvent;
+            realEvent = (CConnMonCreateConnection*) &aEvent;
+            TUint apId;
+            TUint connectionId = realEvent->ConnectionId();
+            TRequestStatus status;
+            iConnectionMonitor.GetUintAttribute(connectionId, 0, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            if (status.Int() == KErrNone) {
+                // Store connection id to related AccessPoint Configuration
+                if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                    QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                    for (int i = 0; i < subConfigurations.count(); i++ ) {
+                        if (toSymbianConfig(privateConfiguration(subConfigurations[i]))->numericId == apId) {
+                            toSymbianConfig(privateConfiguration(subConfigurations[i]))->connectionId = connectionId;
+                            break;
+                        }
+                    }
+                } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                    if (toSymbianConfig(privateConfiguration(publicConfig))->numericId == apId) {
+                        toSymbianConfig(privateConfiguration(publicConfig))->connectionId = connectionId;
+                    }
+                }
+            }
+            }
+            break;
+
+        case EConnMonDeleteConnection:
+            {
+            CConnMonDeleteConnection* realEvent;
+            realEvent = (CConnMonDeleteConnection*) &aEvent;
+            TUint connectionId = realEvent->ConnectionId();
+            // Remove connection id from related AccessPoint Configuration
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                for (int i = 0; i < subConfigurations.count(); i++ ) {
+                    if (toSymbianConfig(privateConfiguration(subConfigurations[i]))->connectionId == connectionId) {
+                        toSymbianConfig(privateConfiguration(subConfigurations[i]))->connectionId = 0;
+                        break;
+                    }
+                }
+            } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                if (toSymbianConfig(privateConfiguration(publicConfig))->connectionId == connectionId) {
+                    toSymbianConfig(privateConfiguration(publicConfig))->connectionId = 0;
+                }
+            }
+            }
+            break;
+
+        default:
+            // For unrecognized events
+            break;
+    }
+}
+
+ConnectionProgressNotifier::ConnectionProgressNotifier(QNetworkSessionPrivateImpl &owner, RConnection &connection)
+    : CActive(CActive::EPriorityStandard), iOwner(owner), iConnection(connection)
+{
+    CActiveScheduler::Add(this);
+}
+
+ConnectionProgressNotifier::~ConnectionProgressNotifier()
+{
+    Cancel();
+}
+
+void ConnectionProgressNotifier::StartNotifications()
+{
+    if (!IsActive()) {
+        SetActive();
+    }
+    iConnection.ProgressNotification(iProgress, iStatus);
+}
+
+void ConnectionProgressNotifier::StopNotifications()
+{
+    Cancel();
+}
+
+void ConnectionProgressNotifier::DoCancel()
+{
+    iConnection.CancelProgressNotification();
+}
+
+void ConnectionProgressNotifier::RunL()
+{
+    if (iStatus == KErrNone) {
+        iOwner.handleSymbianConnectionStatusChange(iProgress().iStage, iProgress().iError);
+    
+        SetActive();
+        iConnection.ProgressNotification(iProgress, iStatus);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/qnetworksession_impl.h b/src/plugins/bearer/symbian/qnetworksession_impl.h
new file mode 100644
index 0000000..30f51e1
--- /dev/null
+++ b/src/plugins/bearer/symbian/qnetworksession_impl.h
@@ -0,0 +1,196 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QNETWORKSESSION_IMPL_H
+#define QNETWORKSESSION_IMPL_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtNetwork/private/qnetworksession_p.h>
+
+#include <QDateTime>
+
+#include <e32base.h>
+#include <CommDbConnPref.h>
+#include <es_sock.h>
+#include <rconnmon.h>
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <comms-infras/cs_mobility_apiext.h>
+#endif
+
+typedef int(*TOpenCSetdefaultifFunction)(const struct ifreq*);
+
+QT_BEGIN_NAMESPACE
+
+class ConnectionProgressNotifier;
+class SymbianEngine;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+class QNetworkSessionPrivateImpl : public QNetworkSessionPrivate, public CActive, public MMobilityProtocolResp,
+                                     public MConnectionMonitorObserver
+#else
+class QNetworkSessionPrivateImpl : public QNetworkSessionPrivate, public CActive, public MConnectionMonitorObserver
+#endif
+{
+    Q_OBJECT
+public:
+    QNetworkSessionPrivateImpl(SymbianEngine *engine);
+    ~QNetworkSessionPrivateImpl();
+    
+    //called by QNetworkSession constructor and ensures
+    //that the state is immediately updated (w/o actually opening
+    //a session). Also this function should take care of 
+    //notification hooks to discover future state changes.
+    void syncStateWithInterface();
+
+    QNetworkInterface currentInterface() const;
+    QVariant sessionProperty(const QString& key) const;
+    void setSessionProperty(const QString& key, const QVariant& value);
+    
+    void setALREnabled(bool enabled);
+
+    void open();
+    inline void close() { close(true); }
+    void close(bool allowSignals);
+    void stop();
+    void migrate();
+    void accept();
+    void ignore();
+    void reject();
+
+    QString errorString() const; //must return translated string
+    QNetworkSession::SessionError error() const;
+
+    quint64 bytesWritten() const;
+    quint64 bytesReceived() const;
+    quint64 activeTime() const;
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+public: // From MMobilityProtocolResp
+    void PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,
+                                   TAccessPointInfo aNewAPInfo,
+                                   TBool aIsUpgrade,
+                                   TBool aIsSeamless);
+
+    void NewCarrierActive(TAccessPointInfo aNewAPInfo, TBool aIsSeamless);
+
+    void Error(TInt aError);
+#endif    
+
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+    
+private: // MConnectionMonitorObserver
+    void EventL(const CConnMonEventBase& aEvent);
+    
+private:
+    TUint iapClientCount(TUint aIAPId) const;
+    quint64 transferredData(TUint dataType) const;
+    bool newState(QNetworkSession::State newState, TUint accessPointId = 0);
+    void handleSymbianConnectionStatusChange(TInt aConnectionStatus, TInt aError, TUint accessPointId = 0);
+    QNetworkConfiguration bestConfigFromSNAP(const QNetworkConfiguration& snapConfig) const;
+    QNetworkConfiguration activeConfiguration(TUint32 iapId = 0) const;
+    QNetworkInterface interface(TUint iapId) const;
+
+private: // data
+    SymbianEngine *engine;
+
+    mutable QNetworkInterface activeInterface;
+
+    QDateTime startTime;
+
+    RLibrary iOpenCLibrary;
+    TOpenCSetdefaultifFunction iDynamicSetdefaultif;
+
+    mutable RSocketServ iSocketServ;
+    mutable RConnection iConnection;
+    mutable RConnectionMonitor iConnectionMonitor;
+    ConnectionProgressNotifier* ipConnectionNotifier;
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    CActiveCommsMobilityApiExt* iMobility;
+#endif    
+    
+    QNetworkSession::SessionError iError;
+    TInt iALREnabled;
+    TBool iALRUpgradingConnection;
+    
+    QList<QString> iKnownConfigsBeforeConnectionStart;
+    
+    TUint32 iOldRoamingIap;
+    TUint32 iNewRoamingIap;
+
+    friend class ConnectionProgressNotifier;
+};
+
+class ConnectionProgressNotifier : public CActive
+{
+public:
+    ConnectionProgressNotifier(QNetworkSessionPrivateImpl &owner, RConnection &connection);
+    ~ConnectionProgressNotifier();
+    
+    void StartNotifications();
+    void StopNotifications();
+    
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+
+private: // Data
+    QNetworkSessionPrivateImpl &iOwner;
+    RConnection& iConnection;
+    TNifProgressBuf iProgress;
+    
+};
+
+QT_END_NAMESPACE
+
+#endif //QNETWORKSESSION_IMPL_H
+
diff --git a/src/plugins/bearer/symbian/symbian.pro b/src/plugins/bearer/symbian/symbian.pro
new file mode 100644
index 0000000..9fd1a74
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbian.pro
@@ -0,0 +1,37 @@
+TARGET = qsymbianbearer
+include(../../qpluginbase.pri)
+
+QT += network
+
+HEADERS += symbianengine.h \
+           qnetworksession_impl.h
+
+SOURCES += symbianengine.cpp \
+           qnetworksession_impl.cpp \
+           main.cpp
+
+exists($${EPOCROOT}epoc32/release/winscw/udeb/cmmanager.lib)| \
+exists($${EPOCROOT}epoc32/release/armv5/lib/cmmanager.lib) {
+    message("Building with SNAP support")
+    DEFINES += SNAP_FUNCTIONALITY_AVAILABLE
+    LIBS += -lcmmanager
+} else {
+    message("Building without SNAP support")
+    LIBS += -lapengine
+}
+
+INCLUDEPATH += $$APP_LAYER_SYSTEMINCLUDE
+
+LIBS += -lcommdb \
+        -lapsettingshandlerui \
+        -lconnmon \
+        -lcentralrepository \
+        -lesock \
+        -linsock \
+        -lecom \
+        -lefsrv \
+        -lnetmeta
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/symbian/symbianengine.cpp b/src/plugins/bearer/symbian/symbianengine.cpp
new file mode 100644
index 0000000..e25eda4
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbianengine.cpp
@@ -0,0 +1,955 @@
+/****************************************************************************
+**
+** 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 "symbianengine.h"
+#include "qnetworksession_impl.h"
+
+#include <commdb.h>
+#include <cdbcols.h>
+#include <d32dbms.h>
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <cmdestination.h>
+    #include <cmconnectionmethod.h>
+    #include <cmconnectionmethoddef.h>
+    #include <cmpluginwlandef.h>
+    #include <cmpluginpacketdatadef.h>
+    #include <cmplugindialcommondefs.h>
+#else
+    #include <apaccesspointitem.h>
+    #include <apdatahandler.h>
+    #include <aputils.h> 
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static const int KValueThatWillBeAddedToSNAPId = 1000;
+static const int KUserChoiceIAPId = 0;
+
+SymbianNetworkConfigurationPrivate::SymbianNetworkConfigurationPrivate()
+:   bearer(BearerUnknown), numericId(0), connectionId(0)
+{
+}
+
+SymbianNetworkConfigurationPrivate::~SymbianNetworkConfigurationPrivate()
+{
+}
+
+QString SymbianNetworkConfigurationPrivate::bearerName() const
+{
+    switch (bearer) {
+    case BearerEthernet:
+        return QLatin1String("Ethernet");
+    case BearerWLAN:
+        return QLatin1String("WLAN");
+    case Bearer2G:
+        return QLatin1String("2G");
+    case BearerCDMA2000:
+        return QLatin1String("CDMA2000");
+    case BearerWCDMA:
+        return QLatin1String("WCDMA");
+    case BearerHSPA:
+        return QLatin1String("HSPA");
+    case BearerBluetooth:
+        return QLatin1String("Bluetooth");
+    case BearerWiMAX:
+        return QLatin1String("WiMAX");
+    default:
+        return QString();
+    }
+}
+
+SymbianEngine::SymbianEngine(QObject *parent)
+:   QBearerEngine(parent), CActive(CActive::EPriorityIdle), iInitOk(true)
+{
+    CActiveScheduler::Add(this);
+
+    TRAPD(error, ipCommsDB = CCommsDatabase::NewL(EDatabaseTypeIAP));
+    if (error != KErrNone) {
+        iInitOk = false;
+        return;
+    }
+
+    TRAP_IGNORE(iConnectionMonitor.ConnectL());
+    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    TRAP(error, iCmManager.OpenL());
+    if (error != KErrNone) {
+        iInitOk = false;
+        return;
+    }
+#endif
+    
+    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+    cpPriv->name = "UserChoice";
+    cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+    cpPriv->state = QNetworkConfiguration::Discovered;
+    cpPriv->isValid = true;
+    cpPriv->id = QString::number(qHash(KUserChoiceIAPId));
+    cpPriv->numericId = KUserChoiceIAPId;
+    cpPriv->connectionId = 0;
+    cpPriv->type = QNetworkConfiguration::UserChoice;
+    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+    cpPriv->roamingSupported = false;
+
+    QNetworkConfigurationPrivatePointer ptr(cpPriv);
+    userChoiceConfigurations.insert(ptr->id, ptr);
+
+    updateConfigurations();
+    updateStatesToSnaps();
+    
+    // Start monitoring IAP and/or SNAP changes in Symbian CommsDB
+    startCommsDatabaseNotifications();
+}
+
+SymbianEngine::~SymbianEngine()
+{
+    Cancel();
+
+    iConnectionMonitor.CancelNotifications();
+    iConnectionMonitor.Close();
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    iCmManager.Close();
+#endif
+    
+    delete ipAccessPointsAvailabilityScanner;
+    delete ipCommsDB;
+}
+
+bool SymbianEngine::hasIdentifier(const QString &id)
+{
+    return accessPointConfigurations.contains(id) ||
+           snapConfigurations.contains(id) ||
+           userChoiceConfigurations.contains(id);
+}
+
+QNetworkConfigurationManager::Capabilities SymbianEngine::capabilities() const
+{
+    QNetworkConfigurationManager::Capabilities capFlags;
+
+    capFlags = QNetworkConfigurationManager::CanStartAndStopInterfaces |
+               QNetworkConfigurationManager::DirectConnectionRouting |
+               QNetworkConfigurationManager::SystemSessionSupport |
+               QNetworkConfigurationManager::DataStatistics;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    capFlags |= QNetworkConfigurationManager::ApplicationLevelRoaming |
+                QNetworkConfigurationManager::ForcedRoaming;
+#endif
+
+    return capFlags;
+}
+
+QNetworkSessionPrivate *SymbianEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl(this);
+}
+
+void SymbianEngine::requestUpdate()
+{
+    if (!iInitOk || iUpdateGoingOn) {
+        return;
+    }
+    iUpdateGoingOn = true;
+
+    stopCommsDatabaseNotifications();
+    updateConfigurations(); // Synchronous call
+    updateAvailableAccessPoints(); // Asynchronous call
+}
+
+void SymbianEngine::updateConfigurations()
+{
+    if (!iInitOk) {
+        return;
+    }
+
+    TRAP_IGNORE(updateConfigurationsL());
+}
+
+void SymbianEngine::updateConfigurationsL()
+{
+    QList<QString> knownConfigs = accessPointConfigurations.keys();
+    QList<QString> knownSnapConfigs = snapConfigurations.keys();
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    // S60 version is >= Series60 3rd Edition Feature Pack 2
+    TInt error = KErrNone;
+    
+    // Loop through all IAPs
+    RArray<TUint32> connectionMethods; // IAPs
+    CleanupClosePushL(connectionMethods);
+    iCmManager.ConnectionMethodL(connectionMethods);
+    for(int i = 0; i < connectionMethods.Count(); i++) {
+        RCmConnectionMethod connectionMethod = iCmManager.ConnectionMethodL(connectionMethods[i]);
+        CleanupClosePushL(connectionMethod);
+        TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+        QString ident = QString::number(qHash(iapId));
+        if (accessPointConfigurations.contains(ident)) {
+            knownConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate* cpPriv = NULL;
+            TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
+            if (error == KErrNone) {
+                QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                accessPointConfigurations.insert(ptr->id, ptr);
+                emit configurationAdded(ptr);
+            }
+        }
+        CleanupStack::PopAndDestroy(&connectionMethod);
+    }
+    CleanupStack::PopAndDestroy(&connectionMethods);
+    
+    // Loop through all SNAPs
+    RArray<TUint32> destinations;
+    CleanupClosePushL(destinations);
+    iCmManager.AllDestinationsL(destinations);
+    for(int i = 0; i < destinations.Count(); i++) {
+        RCmDestination destination;
+        destination = iCmManager.DestinationL(destinations[i]);
+        CleanupClosePushL(destination);
+        QString ident = QString::number(qHash(destination.Id()+KValueThatWillBeAddedToSNAPId)); //TODO: Check if it's ok to add 1000 SNAP Id to prevent SNAP ids overlapping IAP ids
+        if (snapConfigurations.contains(ident)) {
+            knownSnapConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+            CleanupStack::PushL(cpPriv);
+    
+            HBufC *pName = destination.NameLC();
+            cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+            CleanupStack::PopAndDestroy(pName);
+            pName = NULL;
+    
+            cpPriv->isValid = true;
+            cpPriv->id = ident;
+            cpPriv->numericId = destination.Id();
+            cpPriv->connectionId = 0;
+            cpPriv->state = QNetworkConfiguration::Defined;
+            cpPriv->type = QNetworkConfiguration::ServiceNetwork;
+            cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+            cpPriv->roamingSupported = false;
+
+            QNetworkConfigurationPrivatePointer ptr(cpPriv);
+            snapConfigurations.insert(ident, ptr);
+            emit configurationAdded(ptr);
+            
+            CleanupStack::Pop(cpPriv);
+        }
+        QNetworkConfigurationPrivatePointer privSNAP = snapConfigurations.value(ident);
+            
+        for (int j=0; j < destination.ConnectionMethodCount(); j++) {
+            RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);
+            CleanupClosePushL(connectionMethod);
+            
+            TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+            QString iface = QString::number(qHash(iapId));
+            // Check that IAP can be found from accessPointConfigurations list
+            QNetworkConfigurationPrivatePointer priv = accessPointConfigurations.value(iface);
+            if (!priv) {
+                SymbianNetworkConfigurationPrivate *cpPriv = NULL;
+                TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
+                if (error == KErrNone) {
+                    QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                    toSymbianConfig(ptr)->serviceNetworkPtr = privSNAP;
+                    accessPointConfigurations.insert(ptr->id, ptr);
+                    emit configurationAdded(ptr);
+                    privSNAP->serviceNetworkMembers.append(ptr);
+                }
+            } else {
+                knownConfigs.removeOne(iface);
+                // Check that IAP can be found from related SNAP's configuration list
+                bool iapFound = false;
+                for (int i = 0; i < privSNAP->serviceNetworkMembers.count(); i++) {
+                    if (toSymbianConfig(privSNAP->serviceNetworkMembers[i])->numericId == iapId) {
+                        iapFound = true;
+                        break;
+                    }
+                }
+                if (!iapFound) {
+                    toSymbianConfig(priv)->serviceNetworkPtr = privSNAP;
+                    privSNAP->serviceNetworkMembers.append(priv);
+                }
+            }
+            
+            CleanupStack::PopAndDestroy(&connectionMethod);
+        }
+        
+        if (privSNAP->serviceNetworkMembers.count() > 1) {
+            // Roaming is supported only if SNAP contains more than one IAP
+            privSNAP->roamingSupported = true;
+        }
+        
+        CleanupStack::PopAndDestroy(&destination);
+    }
+    CleanupStack::PopAndDestroy(&destinations);
+    
+#else
+    // S60 version is < Series60 3rd Edition Feature Pack 2
+    CCommsDbTableView* pDbTView = ipCommsDB->OpenTableLC(TPtrC(IAP));
+
+    // Loop through all IAPs
+    TUint32 apId = 0;
+    TInt retVal = pDbTView->GotoFirstRecord();
+    while (retVal == KErrNone) {
+        pDbTView->ReadUintL(TPtrC(COMMDB_ID), apId);
+        QString ident = QString::number(qHash(apId));
+        if (accessPointConfigurations.contains(ident)) {
+            knownConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+            if (readNetworkConfigurationValuesFromCommsDb(apId, cpPriv)) {
+                QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                accessPointConfigurations.insert(ident, ptr);
+
+                emit configurationAdded(ptr);
+            } else {
+                delete cpPriv;
+            }
+        }
+        retVal = pDbTView->GotoNextRecord();
+    }
+    CleanupStack::PopAndDestroy(pDbTView);
+#endif
+    updateActiveAccessPoints();
+    
+    foreach (const QString &oldIface, knownConfigs) {
+        //remove non existing IAP
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);
+        emit configurationRemoved(ptr);
+
+        // Remove non existing IAP from SNAPs
+        foreach (const QString &iface, snapConfigurations.keys()) {
+            QNetworkConfigurationPrivatePointer ptr2 = snapConfigurations.value(iface);
+            // => Check if one of the IAPs of the SNAP is active
+            for (int i = 0; i < ptr2->serviceNetworkMembers.count(); ++i) {
+                if (toSymbianConfig(ptr2->serviceNetworkMembers[i])->numericId ==
+                    toSymbianConfig(ptr)->numericId) {
+                    ptr2->serviceNetworkMembers.removeAt(i);
+                    break;
+                }
+            }
+        }    
+    }
+
+    foreach (const QString &oldIface, knownSnapConfigs) {
+        //remove non existing SNAPs
+        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);
+        emit configurationRemoved(ptr);
+    }
+}
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(
+        RCmConnectionMethod& connectionMethod)
+{
+    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+    CleanupStack::PushL(cpPriv);
+    
+    TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+    QString ident = QString::number(qHash(iapId));
+    
+    HBufC *pName = connectionMethod.GetStringAttributeL(CMManager::ECmName);
+    CleanupStack::PushL(pName);
+    cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+    CleanupStack::PopAndDestroy(pName);
+    pName = NULL;
+    
+    TUint32 bearerId = connectionMethod.GetIntAttributeL(CMManager::ECmCommsDBBearerType);
+    switch (bearerId) {
+    case KCommDbBearerCSD:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case KCommDbBearerWcdma:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWCDMA;
+        break;
+    case KCommDbBearerLAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    case KCommDbBearerVirtual:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    case KCommDbBearerPAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    case KCommDbBearerWLAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWLAN;
+        break;
+    default:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    }
+    
+    TInt error = KErrNone;
+    TUint32 bearerType = connectionMethod.GetIntAttributeL(CMManager::ECmBearerType);
+    switch (bearerType) {
+    case KUidPacketDataBearerType:
+        // "Packet data" Bearer => Mapping is done using "Access point name"
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EPacketDataAPName));
+        break;
+    case KUidWlanBearerType:
+        // "Wireless LAN" Bearer => Mapping is done using "WLAN network name" = SSID
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EWlanSSID));
+        break;
+    }
+    if (!pName) {
+        // "Data call" Bearer or "High Speed (GSM)" Bearer => Mapping is done using "Dial-up number"
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EDialDefaultTelNum));
+    }
+
+    if (error == KErrNone && pName) {
+        CleanupStack::PushL(pName);
+        cpPriv->mappingName = QString::fromUtf16(pName->Ptr(),pName->Length());
+        CleanupStack::PopAndDestroy(pName);
+        pName = NULL;
+    }
+ 
+    cpPriv->state = QNetworkConfiguration::Defined;
+    TBool isConnected = connectionMethod.GetBoolAttributeL(CMManager::ECmConnected);
+    if (isConnected) {
+        cpPriv->state = QNetworkConfiguration::Active;
+    }
+    
+    cpPriv->isValid = true;
+    cpPriv->id = ident;
+    cpPriv->numericId = iapId;
+    cpPriv->connectionId = 0;
+    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+    cpPriv->roamingSupported = false;
+    
+    CleanupStack::Pop(cpPriv);
+    return cpPriv;
+}
+#else
+bool SymbianEngine::readNetworkConfigurationValuesFromCommsDb(
+        TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
+{
+    TRAPD(error, readNetworkConfigurationValuesFromCommsDbL(aApId,apNetworkConfiguration));
+    if (error != KErrNone) {
+        return false;        
+    }
+    return true;
+}
+
+void SymbianEngine::readNetworkConfigurationValuesFromCommsDbL(
+        TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
+{
+    CApDataHandler* pDataHandler = CApDataHandler::NewLC(*ipCommsDB); 
+    CApAccessPointItem* pAPItem = CApAccessPointItem::NewLC(); 
+    TBuf<KCommsDbSvrMaxColumnNameLength> name;
+    
+    CApUtils* pApUtils = CApUtils::NewLC(*ipCommsDB);
+    TUint32 apId = pApUtils->WapIdFromIapIdL(aApId);
+    
+    pDataHandler->AccessPointDataL(apId,*pAPItem);
+    pAPItem->ReadTextL(EApIapName, name);
+    if (name.Compare(_L("Easy WLAN")) == 0) {
+        // "Easy WLAN" won't be accepted to the Configurations list
+        User::Leave(KErrNotFound);
+    }
+    
+    QString ident = QString::number(qHash(aApId));
+    
+    apNetworkConfiguration->name = QString::fromUtf16(name.Ptr(),name.Length());
+    apNetworkConfiguration->isValid = true;
+    apNetworkConfiguration->id = ident;
+    apNetworkConfiguration->numericId = aApId;
+    apNetworkConfiguration->connectionId = 0;
+    apNetworkConfiguration->state = (QNetworkConfiguration::Defined);
+    apNetworkConfiguration->type = QNetworkConfiguration::InternetAccessPoint;
+    apNetworkConfiguration->purpose = QNetworkConfiguration::UnknownPurpose;
+    apNetworkConfiguration->roamingSupported = false;
+    switch (pAPItem->BearerTypeL()) {
+    case EApBearerTypeCSD:      
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case EApBearerTypeGPRS:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case EApBearerTypeHSCSD:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerHSPA;
+        break;
+    case EApBearerTypeCDMA:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerCDMA2000;
+        break;
+    case EApBearerTypeWLAN:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerWLAN;
+        break;
+    case EApBearerTypeLAN:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    case EApBearerTypeLANModem:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    default:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    }
+    
+    CleanupStack::PopAndDestroy(pApUtils);
+    CleanupStack::PopAndDestroy(pAPItem);
+    CleanupStack::PopAndDestroy(pDataHandler);
+}
+#endif
+
+QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfiguration()
+{
+    QNetworkConfigurationPrivatePointer ptr;
+
+    if (iInitOk) {
+        stopCommsDatabaseNotifications();
+        TRAP_IGNORE(ptr = defaultConfigurationL());
+        startCommsDatabaseNotifications();
+    }
+
+    return ptr;
+}
+
+QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfigurationL()
+{
+    QNetworkConfigurationPrivatePointer ptr;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    // Check Default Connection (SNAP or IAP)
+    TCmDefConnValue defaultConnectionValue;
+    iCmManager.ReadDefConnL(defaultConnectionValue);
+    if (defaultConnectionValue.iType == ECmDefConnDestination) {
+        QString iface = QString::number(qHash(defaultConnectionValue.iId+KValueThatWillBeAddedToSNAPId));
+        ptr = snapConfigurations.value(iface);
+    } else if (defaultConnectionValue.iType == ECmDefConnConnectionMethod) {
+        QString iface = QString::number(qHash(defaultConnectionValue.iId));
+        ptr = accessPointConfigurations.value(iface);
+    }
+#endif
+    
+    if (!ptr->isValid) {
+        QString iface = QString::number(qHash(KUserChoiceIAPId));
+        ptr = userChoiceConfigurations.value(iface);
+    }
+    
+    return ptr;
+}
+
+void SymbianEngine::updateActiveAccessPoints()
+{
+    bool online = false;
+    QList<QString> inactiveConfigs = accessPointConfigurations.keys();
+
+    TRequestStatus status;
+    TUint connectionCount;
+    iConnectionMonitor.GetConnectionCount(connectionCount, status);
+    User::WaitForRequest(status);
+    
+    // Go through all connections and set state of related IAPs to Active
+    TUint connectionId;
+    TUint subConnectionCount;
+    TUint apId;
+    if (status.Int() == KErrNone) {
+        for (TUint i = 1; i <= connectionCount; i++) {
+            iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);
+            iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            QString ident = QString::number(qHash(apId));
+
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                online = true;
+                inactiveConfigs.removeOne(ident);
+
+                toSymbianConfig(ptr)->connectionId = connectionId;
+
+                // Configuration is Active
+                changeConfigurationStateTo(ptr, QNetworkConfiguration::Active);
+            }
+        }
+    }
+
+    // Make sure that state of rest of the IAPs won't be Active
+    foreach (const QString &iface, inactiveConfigs) {
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+        if (ptr) {
+            // Configuration is either Defined or Discovered
+            changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Discovered);
+        }
+    }
+
+    if (iOnline != online) {
+        iOnline = online;
+        emit this->onlineStateChanged(iOnline);
+    }
+}
+
+void SymbianEngine::updateAvailableAccessPoints()
+{
+    if (!ipAccessPointsAvailabilityScanner) {
+        ipAccessPointsAvailabilityScanner = new AccessPointsAvailabilityScanner(*this, iConnectionMonitor);
+    }
+    if (ipAccessPointsAvailabilityScanner) {
+        // Scanning may take a while because WLAN scanning will be done (if device supports WLAN).
+        ipAccessPointsAvailabilityScanner->StartScanning();
+    }
+}
+
+void SymbianEngine::accessPointScanningReady(TBool scanSuccessful, TConnMonIapInfo iapInfo)
+{
+    iUpdateGoingOn = false;
+    if (scanSuccessful) {
+        QList<QString> unavailableConfigs = accessPointConfigurations.keys();
+        
+        // Set state of returned IAPs to Discovered
+        // if state is not already Active
+        for(TUint i=0; i<iapInfo.iCount; i++) {
+            QString ident = QString::number(qHash(iapInfo.iIap[i].iIapId));
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                unavailableConfigs.removeOne(ident);
+                if (ptr->state < QNetworkConfiguration::Active) {
+                    // Configuration is either Discovered or Active
+                    changeConfigurationStateAtMinTo(ptr, QNetworkConfiguration::Discovered);
+                }
+            }
+        }
+        
+        // Make sure that state of rest of the IAPs won't be Discovered or Active
+        foreach (const QString &iface, unavailableConfigs) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr) {
+                // Configuration is Defined
+                changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Defined);
+            }
+        }
+    }
+
+    updateStatesToSnaps();
+    
+    startCommsDatabaseNotifications();
+    
+    emit updateCompleted();
+}
+
+void SymbianEngine::updateStatesToSnaps()
+{
+    // Go through SNAPs and set correct state to SNAPs
+    QList<QString> snapConfigIdents = snapConfigurations.keys();
+    foreach (QString iface, snapConfigIdents) {
+        bool discovered = false;
+        bool active = false;
+        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.value(iface);
+        // => Check if one of the IAPs of the SNAP is discovered or active
+        //    => If one of IAPs is active, also SNAP is active
+        //    => If one of IAPs is discovered but none of the IAPs is active, SNAP is discovered
+        for (int i=0; i<ptr->serviceNetworkMembers.count(); i++) {
+            if ((ptr->serviceNetworkMembers[i]->state & QNetworkConfiguration::Active)
+                    == QNetworkConfiguration::Active) {
+                active = true;
+                break;
+            } else if ((ptr->serviceNetworkMembers[i]->state & QNetworkConfiguration::Discovered)
+                        == QNetworkConfiguration::Discovered) {
+                discovered = true;
+            }
+        }
+        if (active) {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Active);
+        } else if (discovered) {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Discovered);
+        } else {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Defined);
+        }
+    }    
+}
+
+bool SymbianEngine::changeConfigurationStateTo(QNetworkConfigurationPrivatePointer ptr,
+                                               QNetworkConfiguration::StateFlags newState)
+{
+    if (newState != ptr->state) {
+        ptr->state = newState;
+        emit configurationChanged(ptr);
+        return true;
+    }
+    return false;
+}
+
+/* changeConfigurationStateAtMinTo function does not overwrite possible better
+ * state (e.g. Discovered state does not overwrite Active state) but
+ * makes sure that state is at minimum given state.
+*/
+bool SymbianEngine::changeConfigurationStateAtMinTo(QNetworkConfigurationPrivatePointer ptr,
+                                                    QNetworkConfiguration::StateFlags newState)
+{
+    if ((newState | ptr->state) != ptr->state) {
+        ptr->state = (ptr->state | newState);
+        emit configurationChanged(ptr);
+        return true;
+    }
+    return false;
+}
+
+/* changeConfigurationStateAtMaxTo function overwrites possible better
+ * state (e.g. Discovered state overwrites Active state) and
+ * makes sure that state is at maximum given state (e.g. Discovered state
+ * does not overwrite Defined state).
+*/
+bool SymbianEngine::changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivatePointer ptr,
+                                                    QNetworkConfiguration::StateFlags newState)
+{
+    if ((newState & ptr->state) != ptr->state) {
+        ptr->state = (newState & ptr->state);
+        emit configurationChanged(ptr);
+        return true;
+    }
+    return false;
+}
+
+void SymbianEngine::startCommsDatabaseNotifications()
+{
+    if (!iWaitingCommsDatabaseNotifications) {
+        iWaitingCommsDatabaseNotifications = ETrue;
+        if (!IsActive()) {
+            SetActive();
+            // Start waiting for new notification
+            ipCommsDB->RequestNotification(iStatus);
+        }
+    }
+}
+
+void SymbianEngine::stopCommsDatabaseNotifications()
+{
+    if (iWaitingCommsDatabaseNotifications) {
+        iWaitingCommsDatabaseNotifications = EFalse;
+        if (!IsActive()) {
+            SetActive();
+            // Make sure that notifier recorded events will not be returned
+            // as soon as the client issues the next RequestNotification() request.
+            ipCommsDB->RequestNotification(iStatus);
+            ipCommsDB->CancelRequestNotification();
+        } else {
+            ipCommsDB->CancelRequestNotification();
+        }
+    }
+}
+
+void SymbianEngine::RunL()
+{
+    if (iStatus != KErrCancel) {
+        RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
+        switch (event) {
+        case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
+        case RDbNotifier::ECommit:   /** A transaction has been committed.  */ 
+        case RDbNotifier::ERollback: /** A transaction has been rolled back */
+        case RDbNotifier::ERecover:  /** The database has been recovered    */
+            // Note that if further database events occur while a client is handling
+            // a request completion, the notifier records the most significant database
+            // event and this is signalled as soon as the client issues the next
+            // RequestNotification() request.
+            // => Stop recording notifications
+            stopCommsDatabaseNotifications();
+            TRAPD(error, updateConfigurationsL());
+            if (error == KErrNone) {
+                updateStatesToSnaps();
+            }
+            iWaitingCommsDatabaseNotifications = true;
+            break;
+        default:
+            // Do nothing
+            break;
+        }
+    }
+
+    if (iWaitingCommsDatabaseNotifications) {
+        if (!IsActive()) {
+            SetActive();
+            // Start waiting for new notification
+            ipCommsDB->RequestNotification(iStatus);
+        }
+    }
+}
+
+void SymbianEngine::DoCancel()
+{
+    ipCommsDB->CancelRequestNotification();
+}
+
+
+void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
+{
+    switch (aEvent.EventType()) {
+    case EConnMonCreateConnection:
+        {
+        CConnMonCreateConnection* realEvent;
+        realEvent = (CConnMonCreateConnection*) &aEvent;
+        TUint subConnectionCount = 0;
+        TUint apId;            
+        TUint connectionId = realEvent->ConnectionId();
+        TRequestStatus status;
+        iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+        User::WaitForRequest(status);
+        QString ident = QString::number(qHash(apId));
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+        if (ptr) {
+            toSymbianConfig(ptr)->connectionId = connectionId;
+            // Configuration is Active
+            if (changeConfigurationStateTo(ptr, QNetworkConfiguration::Active))
+                updateStatesToSnaps();
+
+            if (!iOnline) {
+                iOnline = true;
+                emit this->onlineStateChanged(iOnline);
+            }
+        }
+        }
+        break;
+
+    case EConnMonDeleteConnection:
+        {
+        CConnMonDeleteConnection* realEvent;
+        realEvent = (CConnMonDeleteConnection*) &aEvent;
+        TUint connectionId = realEvent->ConnectionId();
+
+        QNetworkConfigurationPrivatePointer ptr = dataByConnectionId(connectionId);
+        if (ptr) {
+            toSymbianConfig(ptr)->connectionId = 0;
+            // Configuration is either Defined or Discovered
+            if (changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Discovered))
+                updateStatesToSnaps();
+        }
+        
+        bool online = false;
+        foreach (const QString &iface, accessPointConfigurations.keys()) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr->state == QNetworkConfiguration::Active) {
+                online = true;
+                break;
+            }
+        }
+        if (iOnline != online) {
+            iOnline = online;
+            emit this->onlineStateChanged(iOnline);
+        }
+        }
+        break;
+
+    case EConnMonIapAvailabilityChange:
+        {
+        CConnMonIapAvailabilityChange* realEvent;
+        realEvent = (CConnMonIapAvailabilityChange*) &aEvent;
+        TConnMonIapInfo iaps = realEvent->IapAvailability();
+        QList<QString> unDiscoveredConfigs = accessPointConfigurations.keys();
+        for ( TUint i = 0; i < iaps.Count(); i++ ) {
+            QString ident = QString::number(qHash(iaps.iIap[i].iIapId));
+
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                // Configuration is either Discovered or Active 
+                changeConfigurationStateAtMinTo(ptr, QNetworkConfiguration::Discovered);
+                unDiscoveredConfigs.removeOne(ident);
+            }
+        }
+        foreach (const QString &iface, unDiscoveredConfigs) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr) {
+                // Configuration is Defined
+                changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Defined);
+            }
+        }
+        }
+        break;
+
+    default:
+        // For unrecognized events
+        break;
+    }
+}
+
+QNetworkConfigurationPrivatePointer SymbianEngine::dataByConnectionId(TUint aConnectionId)
+{
+    QNetworkConfiguration item;
+    
+    QHash<QString, QNetworkConfigurationPrivatePointer>::const_iterator i =
+            accessPointConfigurations.constBegin();
+    while (i != accessPointConfigurations.constEnd()) {
+        QNetworkConfigurationPrivatePointer ptr = i.value();
+        if (toSymbianConfig(ptr)->connectionId == aConnectionId)
+            return ptr;
+
+        ++i;
+    }
+
+    return QNetworkConfigurationPrivatePointer();
+}
+
+AccessPointsAvailabilityScanner::AccessPointsAvailabilityScanner(SymbianEngine& owner,
+                                                               RConnectionMonitor& connectionMonitor)
+    : CActive(CActive::EPriorityStandard), iOwner(owner), iConnectionMonitor(connectionMonitor)
+{
+    CActiveScheduler::Add(this);  
+}
+
+AccessPointsAvailabilityScanner::~AccessPointsAvailabilityScanner()
+{
+    Cancel();
+}
+
+void AccessPointsAvailabilityScanner::DoCancel()
+{
+    iConnectionMonitor.CancelAsyncRequest(EConnMonGetPckgAttribute);
+}
+
+void AccessPointsAvailabilityScanner::StartScanning()
+{
+    iConnectionMonitor.GetPckgAttribute(EBearerIdAll, 0, KIapAvailability, iIapBuf, iStatus);
+    if (!IsActive()) {
+        SetActive();
+    }
+}    
+
+void AccessPointsAvailabilityScanner::RunL()
+{
+    if (iStatus.Int() != KErrNone) {
+        iIapBuf().iCount = 0;
+        iOwner.accessPointScanningReady(false,iIapBuf());
+    } else {
+        iOwner.accessPointScanningReady(true,iIapBuf());
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/symbianengine.h b/src/plugins/bearer/symbian/symbianengine.h
new file mode 100644
index 0000000..587585b
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbianengine.h
@@ -0,0 +1,202 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef SYMBIANENGINE_H
+#define SYMBIANENGINE_H
+
+#include <QtNetwork/private/qbearerengine_p.h>
+#include <QtNetwork/qnetworkconfigmanager.h>
+
+#include <QHash>
+#include <rconnmon.h>
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <cmmanager.h>
+#endif
+
+class CCommsDatabase;
+
+QT_BEGIN_NAMESPACE
+class QTimer;
+QT_END_NAMESPACE
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkSessionPrivate;
+class AccessPointsAvailabilityScanner;
+
+class SymbianNetworkConfigurationPrivate : public QNetworkConfigurationPrivate
+{
+public:
+    enum Bearer {
+        BearerEthernet,
+        BearerWLAN,
+        Bearer2G,
+        BearerCDMA2000,
+        BearerWCDMA,
+        BearerHSPA,
+        BearerBluetooth,
+        BearerWiMAX,
+        BearerUnknown = -1
+    };
+
+    SymbianNetworkConfigurationPrivate();
+    ~SymbianNetworkConfigurationPrivate();
+
+    QString bearerName() const;
+
+    Bearer bearer;
+
+    TUint32 numericId;
+    TUint connectionId;
+
+    QNetworkConfigurationPrivatePointer serviceNetworkPtr;
+
+    QString mappingName;
+};
+
+inline SymbianNetworkConfigurationPrivate *toSymbianConfig(QNetworkConfigurationPrivatePointer ptr)
+{
+    return static_cast<SymbianNetworkConfigurationPrivate *>(ptr.data());
+}
+
+class SymbianEngine : public QBearerEngine, public CActive,
+                      public MConnectionMonitorObserver
+{
+    Q_OBJECT
+
+public:
+    SymbianEngine(QObject *parent = 0);
+    virtual ~SymbianEngine();
+
+    bool hasIdentifier(const QString &id);
+
+    void requestUpdate();
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+Q_SIGNALS:
+    void onlineStateChanged(bool isOnline);
+    
+public Q_SLOTS:
+    void updateConfigurations();
+
+private:
+    void updateStatesToSnaps();
+    bool changeConfigurationStateTo(QNetworkConfigurationPrivatePointer ptr,
+                                    QNetworkConfiguration::StateFlags newState);
+    bool changeConfigurationStateAtMinTo(QNetworkConfigurationPrivatePointer ptr,
+                                         QNetworkConfiguration::StateFlags newState);
+    bool changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivatePointer ptr,
+                                         QNetworkConfiguration::StateFlags newState);
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    SymbianNetworkConfigurationPrivate *configFromConnectionMethodL(RCmConnectionMethod& connectionMethod);
+#else
+    bool readNetworkConfigurationValuesFromCommsDb(
+            TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration);
+    void readNetworkConfigurationValuesFromCommsDbL(
+            TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration);
+#endif    
+    
+    void updateConfigurationsL();
+    void updateActiveAccessPoints();
+    void updateAvailableAccessPoints();
+    void accessPointScanningReady(TBool scanSuccessful, TConnMonIapInfo iapInfo);
+    void startCommsDatabaseNotifications();
+    void stopCommsDatabaseNotifications();
+
+    QNetworkConfigurationPrivatePointer defaultConfigurationL();
+    TBool GetS60PlatformVersion(TUint& aMajor, TUint& aMinor) const;
+    void startMonitoringIAPData(TUint32 aIapId);
+    QNetworkConfigurationPrivatePointer dataByConnectionId(TUint aConnectionId);
+
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+    
+private: // MConnectionMonitorObserver
+    void EventL(const CConnMonEventBase& aEvent);
+
+private: // Data
+    CCommsDatabase*    ipCommsDB;
+    RConnectionMonitor iConnectionMonitor;
+
+    TBool              iWaitingCommsDatabaseNotifications;
+    TBool              iOnline;
+    TBool              iInitOk;
+    TBool              iUpdateGoingOn;
+
+    
+    AccessPointsAvailabilityScanner* ipAccessPointsAvailabilityScanner;
+    
+    friend class QNetworkSessionPrivate;
+    friend class AccessPointsAvailabilityScanner;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    RCmManager iCmManager;
+#endif
+};
+
+class AccessPointsAvailabilityScanner : public CActive
+{
+public:
+    AccessPointsAvailabilityScanner(SymbianEngine& owner,
+                                   RConnectionMonitor& connectionMonitor); 
+    ~AccessPointsAvailabilityScanner();
+
+    void StartScanning();
+    
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+
+private: // Data
+    SymbianEngine& iOwner;
+    RConnectionMonitor& iConnectionMonitor;
+    TConnMonIapInfoBuf iIapBuf;
+};
+
+QT_END_NAMESPACE
+
+#endif