1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qmobilityglobal.h>

    43 #include "qnetworksession_s60_p.h"

    44 #include "qnetworkconfiguration_s60_p.h"

    45 #include "qnetworkconfigmanager_s60_p.h"

    46 #include <es_enum.h>

    47 #include <es_sock.h>

    48 #include <in_sock.h>

    49 #include <stdapis/sys/socket.h>

    50 #include <stdapis/net/if.h>

    51 

    52 QTM_BEGIN_NAMESPACE

    53 

    54 QNetworkSessionPrivate::QNetworkSessionPrivate()

    55     : CActive(CActive::EPriorityStandard), state(QNetworkSession::Invalid),

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

    57       iALREnabled(0)

    58 {

    59     CActiveScheduler::Add(this);

    60     

    61     // Try to load "Open C" dll dynamically and

    62     // try to attach to setdefaultif function dynamically.

    63     if (iOpenCLibrary.Load(_L("libc")) == KErrNone) {

    64         iDynamicSetdefaultif = (TOpenCSetdefaultifFunction)iOpenCLibrary.Lookup(564);

    65     }

    66 

    67     TRAP_IGNORE(iConnectionMonitor.ConnectL());

    68 }

    69 

    70 QNetworkSessionPrivate::~QNetworkSessionPrivate()

    71 {

    72     isOpen = false;

    73 

    74     // Cancel Connection Progress Notifications first.

    75     // Note: ConnectionNotifier must be destroyed before Canceling RConnection::Start()

    76     //       => deleting ipConnectionNotifier results RConnection::CancelProgressNotification()

    77     delete ipConnectionNotifier;

    78     ipConnectionNotifier = NULL;

    79 

    80     // Cancel possible RConnection::Start()

    81     Cancel();

    82     

    83 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

    84     if (iMobility) {

    85         delete iMobility;

    86         iMobility = NULL;

    87     }

    88 #endif

    89 

    90     iConnection.Close();

    91     iSocketServ.Close();

    92     if (iDynamicSetdefaultif) {

    93         iDynamicSetdefaultif(0);

    94     }

    95 

    96     iConnectionMonitor.CancelNotifications();

    97     iConnectionMonitor.Close();

    98 

    99     iOpenCLibrary.Close();

   100 }

   101 

   102 void QNetworkSessionPrivate::syncStateWithInterface()

   103 {

   104     if (!publicConfig.d) {

   105         return;

   106     }

   107 

   108     // Start monitoring changes in IAP states

   109     TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

   110 

   111     // Check open connections to see if there is already

   112     // an open connection to selected IAP or SNAP

   113     TUint count;

   114     TRequestStatus status;

   115     iConnectionMonitor.GetConnectionCount(count, status);

   116     User::WaitForRequest(status);

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

   118         return;

   119     }

   120 

   121     TUint numSubConnections;

   122     TUint connectionId;

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

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

   125         if (ret == KErrNone) {

   126             TUint apId;

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

   128             User::WaitForRequest(status);

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

   130                 TInt connectionStatus;

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

   132                 User::WaitForRequest(status);

   133                 if (connectionStatus == KLinkLayerOpen) {

   134                     if (state != QNetworkSession::Closing) {

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

   136                             return;

   137                         }

   138                     }

   139                 }

   140             }

   141         }

   142     }

   143 

   144     if (state != QNetworkSession::Connected) {

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

   146         if (iError == QNetworkSession::InvalidConfigurationError) {

   147             newState(QNetworkSession::Invalid);

   148         }

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

   150             QNetworkConfiguration::Discovered) {

   151             newState(QNetworkSession::Disconnected);

   152         } else {

   153             newState(QNetworkSession::NotAvailable);

   154         }

   155     }

   156 }

   157 

   158 QNetworkInterface QNetworkSessionPrivate::interface(TUint iapId) const

   159 {

   160     QString interfaceName;

   161 

   162     TSoInetInterfaceInfo ifinfo;

   163     TPckg<TSoInetInterfaceInfo> ifinfopkg(ifinfo);

   164     TSoInetIfQuery ifquery;

   165     TPckg<TSoInetIfQuery> ifquerypkg(ifquery);

   166  

   167     // Open dummy socket for interface queries

   168     RSocket socket;

   169     TInt retVal = socket.Open(iSocketServ, _L("udp"));

   170     if (retVal != KErrNone) {

   171         return QNetworkInterface();

   172     }

   173  

   174     // Start enumerating interfaces

   175     socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);

   176     while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, ifinfopkg) == KErrNone) {

   177         ifquery.iName = ifinfo.iName;

   178         TInt err = socket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifquerypkg);

   179         if(err == KErrNone && ifquery.iZone[1] == iapId) { // IAP ID is index 1 of iZone

   180             if(ifinfo.iAddress.Address() > 0) {

   181                 interfaceName = QString::fromUtf16(ifinfo.iName.Ptr(),ifinfo.iName.Length());

   182                 break;

   183             }

   184         }

   185     }

   186  

   187     socket.Close();

   188  

   189     if (interfaceName.isEmpty()) {

   190         return QNetworkInterface();

   191     }

   192  

   193     return QNetworkInterface::interfaceFromName(interfaceName);

   194 }

   195 

   196 QNetworkInterface QNetworkSessionPrivate::currentInterface() const

   197 {

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

   199         return QNetworkInterface();

   200     }

   201     

   202     return activeInterface;

   203 }

   204 

   205 QVariant QNetworkSessionPrivate::sessionProperty(const QString& /*key*/) const

   206 {

   207     return QVariant();

   208 }

   209 

   210 void QNetworkSessionPrivate::setSessionProperty(const QString& /*key*/, const QVariant& /*value*/)

   211 {

   212 }

   213 

   214 QString QNetworkSessionPrivate::errorString() const

   215 {

   216     switch (iError) {

   217     case QNetworkSession::UnknownSessionError:

   218         return tr("Unknown session error.");

   219     case QNetworkSession::SessionAbortedError:

   220         return tr("The session was aborted by the user or system.");

   221     case QNetworkSession::OperationNotSupportedError:

   222         return tr("The requested operation is not supported by the system.");

   223     case QNetworkSession::InvalidConfigurationError:

   224         return tr("The specified configuration cannot be used.");

   225     case QNetworkSession::RoamingError:

   226         return tr("Roaming was aborted or is not possible.");

   227     }

   228  

   229     return QString();

   230 }

   231 

   232 QNetworkSession::SessionError QNetworkSessionPrivate::error() const

   233 {

   234     return iError;

   235 }

   236 

   237 void QNetworkSessionPrivate::open()

   238 {

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

   240         return;

   241     }

   242 

   243     // Cancel notifications from RConnectionMonitor

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

   245     iConnectionMonitor.CancelNotifications();

   246 

   247     // Configuration must be at least in Discovered - state for connecting purposes.

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

   249                 QNetworkConfiguration::Discovered) {

   250         newState(QNetworkSession::Invalid);

   251         iError = QNetworkSession::InvalidConfigurationError;

   252         emit q->error(iError);

   253         syncStateWithInterface();

   254         return;

   255     }

   256     

   257     TInt error = iSocketServ.Connect();

   258     if (error != KErrNone) {

   259         // Could not open RSocketServ

   260         newState(QNetworkSession::Invalid);

   261         iError = QNetworkSession::UnknownSessionError;

   262         emit q->error(iError);

   263         syncStateWithInterface();    

   264         return;

   265     }

   266     

   267     error = iConnection.Open(iSocketServ);

   268     if (error != KErrNone) {

   269         // Could not open RConnection

   270         iSocketServ.Close();

   271         newState(QNetworkSession::Invalid);

   272         iError = QNetworkSession::UnknownSessionError;

   273         emit q->error(iError);

   274         syncStateWithInterface();    

   275         return;

   276     }

   277     

   278     // Use RConnection::ProgressNotification for IAP/SNAP monitoring

   279     // (<=> ConnectionProgressNotifier uses RConnection::ProgressNotification)

   280     if (!ipConnectionNotifier) {

   281         ipConnectionNotifier = new ConnectionProgressNotifier(*this,iConnection);

   282     }

   283     if (ipConnectionNotifier) {

   284         ipConnectionNotifier->StartNotifications();

   285     }

   286     

   287     if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {

   288         // Search through existing connections.

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

   290         // try to attach to existing connection.

   291         TBool connected(EFalse);

   292         TConnectionInfoBuf connInfo;

   293         TUint count;

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

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

   296                 // Note: GetConnectionInfo expects 1-based index.

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

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

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

   300                             activeConfig = publicConfig;

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

   302                             connected = ETrue;

   303                             startTime = QDateTime::currentDateTime();

   304                             if (iDynamicSetdefaultif) {

   305                                 // Use name of the IAP to set default IAP

   306                                 QByteArray nameAsByteArray = publicConfig.name().toUtf8();

   307                                 ifreq ifr;

   308                                 strcpy(ifr.ifr_name, nameAsByteArray.constData());

   309 

   310                                 error = iDynamicSetdefaultif(&ifr);

   311                             }

   312                             isOpen = true;

   313                             // Make sure that state will be Connected

   314                             newState(QNetworkSession::Connected);

   315                             emit quitPendingWaitsForOpened();

   316                             break;

   317                         }

   318                     }

   319                 }

   320             }

   321         }

   322         if (!connected) {

   323             TCommDbConnPref pref;

   324             pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

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

   326             iConnection.Start(pref, iStatus);

   327             if (!IsActive()) {

   328                 SetActive();

   329             }

   330             newState(QNetworkSession::Connecting);

   331         }

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

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

   334         iConnection.Start(snapPref, iStatus);

   335         if (!IsActive()) {

   336             SetActive();

   337         }

   338         newState(QNetworkSession::Connecting);

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

   340         iKnownConfigsBeforeConnectionStart = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.keys();

   341         iConnection.Start(iStatus);

   342         if (!IsActive()) {

   343             SetActive();

   344         }

   345         newState(QNetworkSession::Connecting);

   346     }

   347  

   348     if (error != KErrNone) {

   349         isOpen = false;

   350         iError = QNetworkSession::UnknownSessionError;

   351         emit q->error(iError);

   352         if (ipConnectionNotifier) {

   353             ipConnectionNotifier->StopNotifications();

   354         }

   355         syncStateWithInterface();    

   356     }

   357 }

   358 

   359 TUint QNetworkSessionPrivate::iapClientCount(TUint aIAPId) const

   360 {

   361     TRequestStatus status;

   362     TUint connectionCount;

   363     iConnectionMonitor.GetConnectionCount(connectionCount, status);

   364     User::WaitForRequest(status);

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

   366         for (TUint i = 1; i <= connectionCount; i++) {

   367             TUint connectionId;

   368             TUint subConnectionCount;

   369             iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);

   370             TUint apId;

   371             iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);

   372             User::WaitForRequest(status);

   373             if (apId == aIAPId) {

   374                 TConnMonClientEnumBuf buf;

   375                 iConnectionMonitor.GetPckgAttribute(connectionId, 0, KClientInfo, buf, status);

   376                 User::WaitForRequest(status);

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

   378                     return buf().iCount;

   379                 }

   380             }

   381         }

   382     }

   383     return 0;

   384 }

   385 

   386 void QNetworkSessionPrivate::close(bool allowSignals)

   387 {

   388     if (!isOpen) {

   389         return;

   390     }

   391 

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

   393     isOpen = false;

   394     activeConfig = QNetworkConfiguration();

   395     serviceConfig = QNetworkConfiguration();

   396     

   397     Cancel();

   398 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   399     if (iMobility) {

   400         delete iMobility;

   401         iMobility = NULL;

   402     }

   403 #endif

   404 

   405     if (ipConnectionNotifier) {

   406         ipConnectionNotifier->StopNotifications();

   407     }

   408     

   409     iConnection.Close();

   410     iSocketServ.Close();

   411     if (iDynamicSetdefaultif) {

   412         iDynamicSetdefaultif(0);

   413     }

   414 

   415 #ifdef Q_CC_NOKIAX86

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

   417 #else

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

   419 #endif

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

   421         newState(QNetworkSession::Closing);

   422     }

   423     

   424     syncStateWithInterface();

   425     if (allowSignals) {

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

   427             newState(QNetworkSession::Disconnected);

   428         }

   429         emit q->closed();

   430     }

   431 }

   432 

   433 void QNetworkSessionPrivate::stop()

   434 {

   435     if (!isOpen) {

   436         return;

   437     }

   438     isOpen = false;

   439     newState(QNetworkSession::Closing);

   440     iConnection.Stop(RConnection::EStopAuthoritative);

   441     isOpen = true;

   442     close(false);

   443     emit q->closed();

   444 }

   445 

   446 void QNetworkSessionPrivate::migrate()

   447 {

   448 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   449     iMobility->MigrateToPreferredCarrier();

   450 #endif

   451 }

   452 

   453 void QNetworkSessionPrivate::ignore()

   454 {

   455 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   456     iMobility->IgnorePreferredCarrier();

   457     if (!iALRUpgradingConnection) {

   458         newState(QNetworkSession::Disconnected);

   459     } else {

   460         newState(QNetworkSession::Connected,iOldRoamingIap);

   461     }

   462 #endif

   463 }

   464 

   465 void QNetworkSessionPrivate::accept()

   466 {

   467 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   468     iMobility->NewCarrierAccepted();

   469     if (iDynamicSetdefaultif) {

   470         // Use name of the IAP to set default IAP

   471         QByteArray nameAsByteArray = activeConfig.name().toUtf8();

   472         ifreq ifr;

   473         strcpy(ifr.ifr_name, nameAsByteArray.constData());

   474 

   475         iDynamicSetdefaultif(&ifr);

   476     }

   477     newState(QNetworkSession::Connected, iNewRoamingIap);

   478 #endif

   479 }

   480 

   481 void QNetworkSessionPrivate::reject()

   482 {

   483 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   484     iMobility->NewCarrierRejected();

   485     if (!iALRUpgradingConnection) {

   486         newState(QNetworkSession::Disconnected);

   487     } else {

   488         newState(QNetworkSession::Connected, iOldRoamingIap);

   489     }

   490 #endif

   491 }

   492 

   493 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   494 void QNetworkSessionPrivate::PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,

   495                                                        TAccessPointInfo aNewAPInfo,

   496                                                        TBool aIsUpgrade,

   497                                                        TBool aIsSeamless)

   498 {

   499     iOldRoamingIap = aOldAPInfo.AccessPoint();

   500     iNewRoamingIap = aNewAPInfo.AccessPoint();

   501     newState(QNetworkSession::Roaming);

   502     if (iALREnabled > 0) {

   503         iALRUpgradingConnection = aIsUpgrade;

   504         QList<QNetworkConfiguration> configs = publicConfig.children();

   505         for (int i=0; i < configs.count(); i++) {

   506             if (configs[i].d.data()->numericId == aNewAPInfo.AccessPoint()) {

   507                 emit q->preferredConfigurationChanged(configs[i],aIsSeamless);

   508             }

   509         }

   510     } else {

   511         migrate();

   512     }

   513 }

   514 

   515 void QNetworkSessionPrivate::NewCarrierActive(TAccessPointInfo /*aNewAPInfo*/, TBool /*aIsSeamless*/)

   516 {

   517     if (iALREnabled > 0) {

   518         emit q->newConfigurationActivated();

   519     } else {

   520         accept();

   521     }

   522 }

   523 

   524 void QNetworkSessionPrivate::Error(TInt /*aError*/)

   525 {

   526     if (isOpen) {

   527         isOpen = false;

   528         activeConfig = QNetworkConfiguration();

   529         serviceConfig = QNetworkConfiguration();

   530         iError = QNetworkSession::RoamingError;

   531         emit q->error(iError);

   532         Cancel();

   533         if (ipConnectionNotifier) {

   534             ipConnectionNotifier->StopNotifications();

   535         }

   536         syncStateWithInterface();

   537         // In some cases IAP is still in Connected state when

   538         // syncStateWithInterface(); is called

   539         // => Following call makes sure that Session state

   540         //    changes immediately to Disconnected.

   541         newState(QNetworkSession::Disconnected);

   542         emit q->closed();

   543     }

   544 }

   545 #endif

   546 

   547 void QNetworkSessionPrivate::setALREnabled(bool enabled)

   548 {

   549     if (enabled) {

   550         iALREnabled++;

   551     } else {

   552         iALREnabled--;

   553     }

   554 }

   555 

   556 QNetworkConfiguration QNetworkSessionPrivate::bestConfigFromSNAP(const QNetworkConfiguration& snapConfig) const

   557 {

   558     QNetworkConfiguration config;

   559     QList<QNetworkConfiguration> subConfigurations = snapConfig.children();

   560     for (int i = 0; i < subConfigurations.count(); i++ ) {

   561         if (subConfigurations[i].state() == QNetworkConfiguration::Active) {

   562             config = subConfigurations[i];

   563             break;

   564         } else if (!config.isValid() && subConfigurations[i].state() == QNetworkConfiguration::Discovered) {

   565             config = subConfigurations[i];

   566         }

   567     }

   568     if (!config.isValid() && subConfigurations.count() > 0) {

   569         config = subConfigurations[0];

   570     }

   571     return config;

   572 }

   573 

   574 quint64 QNetworkSessionPrivate::bytesWritten() const

   575 {

   576     return transferredData(KUplinkData);

   577 }

   578 

   579 quint64 QNetworkSessionPrivate::bytesReceived() const

   580 {

   581     return transferredData(KDownlinkData);

   582 }

   583 

   584 quint64 QNetworkSessionPrivate::transferredData(TUint dataType) const

   585 {

   586     if (!publicConfig.isValid()) {

   587         return 0;

   588     }

   589     

   590     QNetworkConfiguration config;

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

   592         if (serviceConfig.isValid()) {

   593             config = serviceConfig;

   594         } else {

   595             if (activeConfig.isValid()) {

   596                 config = activeConfig;

   597             }

   598         }

   599     } else {

   600         config = publicConfig;

   601     }

   602 

   603     if (!config.isValid()) {

   604         return 0;

   605     }

   606     

   607     TUint count;

   608     TRequestStatus status;

   609     iConnectionMonitor.GetConnectionCount(count, status);

   610     User::WaitForRequest(status);

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

   612         return 0;

   613     }

   614     

   615     TUint transferredData = 0;

   616     TUint numSubConnections;

   617     TUint connectionId;

   618     bool configFound;

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

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

   621         if (ret == KErrNone) {

   622             TUint apId;

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

   624             User::WaitForRequest(status);

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

   626                 configFound = false;

   627                 if (config.type() == QNetworkConfiguration::ServiceNetwork) {

   628                     QList<QNetworkConfiguration> configs = config.children();

   629                     for (int i=0; i < configs.count(); i++) {

   630                         if (configs[i].d.data()->numericId == apId) {

   631                             configFound = true;

   632                             break;

   633                         }

   634                     }

   635                 } else if (config.d.data()->numericId == apId) {

   636                     configFound = true;

   637                 }

   638                 if (configFound) {

   639                     TUint tData;

   640                     iConnectionMonitor.GetUintAttribute(connectionId, 0, dataType, tData, status );

   641                     User::WaitForRequest(status);

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

   643                     transferredData += tData;

   644                     }

   645                 }

   646             }

   647         }

   648     }

   649     

   650     return transferredData;

   651 }

   652 

   653 quint64 QNetworkSessionPrivate::activeTime() const

   654 {

   655     if (!isOpen || startTime.isNull()) {

   656         return 0;

   657     }

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

   659 }

   660 

   661 QNetworkConfiguration QNetworkSessionPrivate::activeConfiguration(TUint32 iapId) const

   662 {

   663     if (iapId == 0) {

   664         _LIT(KSetting, "IAP\\Id");

   665         iConnection.GetIntSetting(KSetting, iapId);

   666     }

   667  

   668 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   669     if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

   670         // Try to search IAP from the used SNAP using IAP Id

   671         QList<QNetworkConfiguration> children = publicConfig.children();

   672         for (int i=0; i < children.count(); i++) {

   673             if (children[i].d.data()->numericId == iapId) {

   674                 return children[i];

   675             }

   676         }

   677 

   678         // Given IAP Id was not found from the used SNAP

   679         // => Try to search matching IAP using mappingName

   680         //    mappingName contains:

   681         //      1. "Access point name" for "Packet data" Bearer

   682         //      2. "WLAN network name" (= SSID) for "Wireless LAN" Bearer

   683         //      3. "Dial-up number" for "Data call Bearer" or "High Speed (GSM)" Bearer

   684         //    <=> Note: It's possible that in this case reported IAP is

   685         //              clone of the one of the IAPs of the used SNAP

   686         //              => If mappingName matches, clone has been found

   687         QNetworkConfiguration pt;

   688         pt.d = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.value(QString::number(qHash(iapId)));

   689         if (pt.d) {

   690             for (int i=0; i < children.count(); i++) {

   691                 if (children[i].d.data()->mappingName == pt.d.data()->mappingName) {

   692                     return children[i];

   693                 }

   694             }

   695         } else {

   696             // Given IAP Id was not found from known IAPs array

   697             return QNetworkConfiguration();

   698         }

   699 

   700         // Matching IAP was not found from used SNAP

   701         // => IAP from another SNAP is returned

   702         //    (Note: Returned IAP matches to given IAP Id)

   703         return pt;

   704     }

   705 #endif

   706     

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

   708         if (publicConfig.d.data()->manager) {

   709             QNetworkConfiguration pt;

   710             // Try to found User Selected IAP from known IAPs (accessPointConfigurations)

   711             pt.d = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.value(QString::number(qHash(iapId)));

   712             if (pt.d) {

   713                 return pt;

   714             } else {

   715                 // Check if new (WLAN) IAP was created in IAP/SNAP dialog

   716                 // 1. Sync internal configurations array to commsdb first

   717                 ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->updateConfigurations();

   718                 // 2. Check if new configuration was created during connection creation

   719                 QList<QString> knownConfigs = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.keys();

   720                 if (knownConfigs.count() > iKnownConfigsBeforeConnectionStart.count()) {

   721                     // Configuration count increased => new configuration was created

   722                     // => Search new, created configuration

   723                     QString newIapId;

   724                     for (int i=0; i < iKnownConfigsBeforeConnectionStart.count(); i++) {

   725                         if (knownConfigs[i] != iKnownConfigsBeforeConnectionStart[i]) {

   726                             newIapId = knownConfigs[i];

   727                             break;

   728                         }

   729                     }

   730                     if (newIapId.isEmpty()) {

   731                         newIapId = knownConfigs[knownConfigs.count()-1];

   732                     }

   733                     pt.d = ((QNetworkConfigurationManagerPrivate*)publicConfig.d.data()->manager)->accessPointConfigurations.value(newIapId);

   734                     if (pt.d) {

   735                         return pt;

   736                     }

   737                 }

   738             }

   739         }

   740         return QNetworkConfiguration();

   741     }

   742 

   743     return publicConfig;

   744 }

   745 

   746 void QNetworkSessionPrivate::RunL()

   747 {

   748     TInt statusCode = iStatus.Int();

   749 

   750     switch (statusCode) {

   751         case KErrNone: // Connection created succesfully

   752             {

   753             TInt error = KErrNone;

   754             QNetworkConfiguration newActiveConfig = activeConfiguration();

   755             if (!newActiveConfig.isValid()) {

   756                 error = KErrGeneral;

   757             } else if (iDynamicSetdefaultif) {

   758                 // Use name of the IAP to set default IAP

   759                 QByteArray nameAsByteArray = newActiveConfig.name().toUtf8();

   760                 ifreq ifr;

   761                 strcpy(ifr.ifr_name, nameAsByteArray.constData());

   762 

   763                 error = iDynamicSetdefaultif(&ifr);

   764             }

   765             

   766             if (error != KErrNone) {

   767                 isOpen = false;

   768                 iError = QNetworkSession::UnknownSessionError;

   769                 emit q->error(iError);

   770                 Cancel();

   771                 if (ipConnectionNotifier) {

   772                     ipConnectionNotifier->StopNotifications();

   773                 }

   774                 syncStateWithInterface();

   775                 return;

   776             }

   777  

   778 #ifdef SNAP_FUNCTIONALITY_AVAILABLE

   779             if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

   780                 // Activate ALR monitoring

   781                 iMobility = CActiveCommsMobilityApiExt::NewL(iConnection, *this);

   782             }

   783 #endif

   784             isOpen = true;

   785             activeConfig = newActiveConfig;

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

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

   788                 QNetworkConfiguration pt;

   789                 pt.d = activeConfig.d.data()->serviceNetworkPtr;

   790                 serviceConfig = pt;

   791             }

   792             

   793             startTime = QDateTime::currentDateTime();

   794 

   795             newState(QNetworkSession::Connected);

   796             emit quitPendingWaitsForOpened();

   797             }

   798             break;

   799         case KErrNotFound: // Connection failed

   800             isOpen = false;

   801             activeConfig = QNetworkConfiguration();

   802             serviceConfig = QNetworkConfiguration();

   803             iError = QNetworkSession::InvalidConfigurationError;

   804             emit q->error(iError);

   805             Cancel();

   806             if (ipConnectionNotifier) {

   807                 ipConnectionNotifier->StopNotifications();

   808             }

   809             syncStateWithInterface();

   810             break;

   811         case KErrCancel: // Connection attempt cancelled

   812         case KErrAlreadyExists: // Connection already exists

   813         default:

   814             isOpen = false;

   815             activeConfig = QNetworkConfiguration();

   816             serviceConfig = QNetworkConfiguration();

   817             iError = QNetworkSession::UnknownSessionError;

   818             emit q->error(iError);

   819             Cancel();

   820             if (ipConnectionNotifier) {

   821                 ipConnectionNotifier->StopNotifications();

   822             }

   823             syncStateWithInterface();

   824             break;

   825     }

   826 }

   827 

   828 void QNetworkSessionPrivate::DoCancel()

   829 {

   830     iConnection.Close();

   831 }

   832 

   833 bool QNetworkSessionPrivate::newState(QNetworkSession::State newState, TUint accessPointId)

   834 {

   835     // Make sure that activeConfig is always updated when SNAP is signaled to be

   836     // connected.

   837     if (isOpen && publicConfig.type() == QNetworkConfiguration::ServiceNetwork &&

   838         newState == QNetworkSession::Connected) {

   839         activeConfig = activeConfiguration(accessPointId);

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

   841     }

   842 

   843     // Make sure that same state is not signaled twice in a row.

   844     if (state == newState) {

   845         return true;

   846     }

   847 

   848     // Make sure that Connecting state does not overwrite Roaming state

   849     if (state == QNetworkSession::Roaming && newState == QNetworkSession::Connecting) {

   850         return false;

   851     }

   852 

   853     bool emitSessionClosed = false;

   854     if (isOpen && state == QNetworkSession::Connected && newState == QNetworkSession::Disconnected) {

   855         // Active & Connected state should change directly to Disconnected state

   856         // only when something forces connection to close (eg. when another

   857         // application or session stops connection or when network drops

   858         // unexpectedly).

   859         isOpen = false;

   860         activeConfig = QNetworkConfiguration();

   861         serviceConfig = QNetworkConfiguration();

   862         iError = QNetworkSession::SessionAbortedError;

   863         emit q->error(iError);

   864         Cancel();

   865         if (ipConnectionNotifier) {

   866             ipConnectionNotifier->StopNotifications();

   867         }

   868         // Start monitoring changes in IAP states

   869         TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

   870         emitSessionClosed = true; // Emit SessionClosed after state change has been reported

   871     }

   872 

   873     bool retVal = false;

   874     if (accessPointId == 0) {

   875         state = newState;

   876         emit q->stateChanged(state);

   877         retVal = true;

   878     } else {

   879         if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {

   880             if (publicConfig.d.data()->numericId == accessPointId) {

   881                 state = newState;

   882                 emit q->stateChanged(state);

   883                 retVal = true;

   884             }

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

   886             if (activeConfig.d.data()->numericId == accessPointId) {

   887                 state = newState;

   888                 emit q->stateChanged(state);

   889                 retVal = true;

   890             }

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

   892             QList<QNetworkConfiguration> subConfigurations = publicConfig.children();

   893             for (int i = 0; i < subConfigurations.count(); i++) {

   894                 if (subConfigurations[i].d.data()->numericId == accessPointId) {

   895                     if (newState == QNetworkSession::Connected) {

   896                         // Make sure that when AccessPoint is reported to be Connected

   897                         // also state of the related configuration changes to Active.

   898                         subConfigurations[i].d.data()->state = QNetworkConfiguration::Active;

   899     

   900                         state = newState;

   901                         emit q->stateChanged(state);

   902                         retVal = true;

   903                     } else {

   904                         if (newState == QNetworkSession::Disconnected) {

   905                             // Make sure that when AccessPoint is reported to be disconnected

   906                             // also state of the related configuration changes from Active to Defined.

   907                             subConfigurations[i].d.data()->state = QNetworkConfiguration::Defined;

   908                         }

   909                         QNetworkConfiguration config = bestConfigFromSNAP(publicConfig);

   910                         if ((config.state() == QNetworkConfiguration::Defined) ||

   911                             (config.state() == QNetworkConfiguration::Discovered)) {

   912                             state = newState;

   913                             emit q->stateChanged(state);

   914                             retVal = true;

   915                         }

   916                     }

   917                 }

   918             }

   919         }

   920     }

   921     

   922     if (emitSessionClosed) {

   923         emit q->closed();

   924     }

   925 

   926     return retVal;

   927 }

   928 

   929 void QNetworkSessionPrivate::handleSymbianConnectionStatusChange(TInt aConnectionStatus,

   930                                                                  TInt aError,

   931                                                                  TUint accessPointId)

   932 {

   933     switch (aConnectionStatus)

   934         {

   935         // Connection unitialised

   936         case KConnectionUninitialised:

   937             break;

   938 

   939         // Starting connetion selection

   940         case KStartingSelection:

   941             break;

   942 

   943         // Selection finished

   944         case KFinishedSelection:

   945             if (aError == KErrNone)

   946                 {

   947                 // The user successfully selected an IAP to be used

   948                 break;

   949                 }

   950             else

   951                 {

   952                 // The user pressed e.g. "Cancel" and did not select an IAP

   953                 newState(QNetworkSession::Disconnected,accessPointId);

   954                 }

   955             break;

   956 

   957         // Connection failure

   958         case KConnectionFailure:

   959             newState(QNetworkSession::NotAvailable);

   960             break;

   961 

   962         // Prepearing connection (e.g. dialing)

   963         case KPsdStartingConfiguration:

   964         case KPsdFinishedConfiguration:

   965         case KCsdFinishedDialling:

   966         case KCsdScanningScript:

   967         case KCsdGettingLoginInfo:

   968         case KCsdGotLoginInfo:

   969             break;

   970 

   971         // Creating connection (e.g. GPRS activation)

   972         case KCsdStartingConnect:

   973         case KCsdFinishedConnect:

   974             newState(QNetworkSession::Connecting,accessPointId);

   975             break;

   976 

   977         // Starting log in

   978         case KCsdStartingLogIn:

   979             break;

   980 

   981         // Finished login

   982         case KCsdFinishedLogIn:

   983             break;

   984 

   985         // Connection open

   986         case KConnectionOpen:

   987             break;

   988 

   989         case KLinkLayerOpen:

   990             newState(QNetworkSession::Connected,accessPointId);

   991             break;

   992 

   993         // Connection blocked or suspended

   994         case KDataTransferTemporarilyBlocked:

   995             break;

   996 

   997         // Hangup or GRPS deactivation

   998         case KConnectionStartingClose:

   999             newState(QNetworkSession::Closing,accessPointId);

  1000             break;

  1001 

  1002         // Connection closed

  1003         case KConnectionClosed:

  1004             break;

  1005 

  1006         case KLinkLayerClosed:

  1007             newState(QNetworkSession::Disconnected,accessPointId);

  1008             break;

  1009 

  1010         // Unhandled state

  1011         default:

  1012             break;

  1013         }

  1014 }

  1015 

  1016 void QNetworkSessionPrivate::EventL(const CConnMonEventBase& aEvent)

  1017 {

  1018     switch (aEvent.EventType())

  1019     {

  1020         case EConnMonConnectionStatusChange:

  1021             {

  1022             CConnMonConnectionStatusChange* realEvent;

  1023             realEvent = (CConnMonConnectionStatusChange*) &aEvent;

  1024 

  1025             TUint connectionId = realEvent->ConnectionId();

  1026             TInt connectionStatus = realEvent->ConnectionStatus();

  1027 

  1028             // Try to Find IAP Id using connection Id

  1029             TUint apId = 0;

  1030             if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

  1031                 QList<QNetworkConfiguration> subConfigurations = publicConfig.children();

  1032                 for (int i = 0; i < subConfigurations.count(); i++ ) {

  1033                     if (subConfigurations[i].d.data()->connectionId == connectionId) {

  1034                         apId = subConfigurations[i].d.data()->numericId;

  1035                         break;

  1036                     }

  1037                 }

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

  1039                 if (publicConfig.d.data()->connectionId == connectionId) {

  1040                     apId = publicConfig.d.data()->numericId;

  1041                 }

  1042             }

  1043 

  1044             if (apId > 0) {

  1045                 handleSymbianConnectionStatusChange(connectionStatus, KErrNone, apId);

  1046             }

  1047             }

  1048             break;

  1049 

  1050         case EConnMonCreateConnection:

  1051             {

  1052             CConnMonCreateConnection* realEvent;

  1053             realEvent = (CConnMonCreateConnection*) &aEvent;

  1054             TUint apId;

  1055             TUint connectionId = realEvent->ConnectionId();

  1056             TRequestStatus status;

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

  1058             User::WaitForRequest(status);

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

  1060                 // Store connection id to related AccessPoint Configuration

  1061                 if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

  1062                     QList<QNetworkConfiguration> subConfigurations = publicConfig.children();

  1063                     for (int i = 0; i < subConfigurations.count(); i++ ) {

  1064                         if (subConfigurations[i].d.data()->numericId == apId) {

  1065                             subConfigurations[i].d.data()->connectionId = connectionId;

  1066                             break;

  1067                         }

  1068                     }

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

  1070                     if (publicConfig.d.data()->numericId == apId) {

  1071                         publicConfig.d.data()->connectionId = connectionId;

  1072                     }

  1073                 }

  1074             }

  1075             }

  1076             break;

  1077 

  1078         case EConnMonDeleteConnection:

  1079             {

  1080             CConnMonDeleteConnection* realEvent;

  1081             realEvent = (CConnMonDeleteConnection*) &aEvent;

  1082             TUint connectionId = realEvent->ConnectionId();

  1083             // Remove connection id from related AccessPoint Configuration

  1084             if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {

  1085                 QList<QNetworkConfiguration> subConfigurations = publicConfig.children();

  1086                 for (int i = 0; i < subConfigurations.count(); i++ ) {

  1087                     if (subConfigurations[i].d.data()->connectionId == connectionId) {

  1088                         subConfigurations[i].d.data()->connectionId = 0;

  1089                         break;

  1090                     }

  1091                 }

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

  1093                 if (publicConfig.d.data()->connectionId == connectionId) {

  1094                     publicConfig.d.data()->connectionId = 0;

  1095                 }

  1096             }

  1097             }

  1098             break;

  1099 

  1100         default:

  1101             // For unrecognized events

  1102             break;

  1103     }

  1104 }

  1105 

  1106 ConnectionProgressNotifier::ConnectionProgressNotifier(QNetworkSessionPrivate& owner, RConnection& connection)

  1107     : CActive(CActive::EPriorityStandard), iOwner(owner), iConnection(connection)

  1108 {

  1109     CActiveScheduler::Add(this);

  1110 }

  1111 

  1112 ConnectionProgressNotifier::~ConnectionProgressNotifier()

  1113 {

  1114     Cancel();

  1115 }

  1116 

  1117 void ConnectionProgressNotifier::StartNotifications()

  1118 {

  1119     if (!IsActive()) {

  1120         SetActive();

  1121     }

  1122     iConnection.ProgressNotification(iProgress, iStatus);

  1123 }

  1124 

  1125 void ConnectionProgressNotifier::StopNotifications()

  1126 {

  1127     Cancel();

  1128 }

  1129 

  1130 void ConnectionProgressNotifier::DoCancel()

  1131 {

  1132     iConnection.CancelProgressNotification();

  1133 }

  1134