1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 // INCLUDE FILES

    19 #include "Cmmpacketcontexttsy.h"

    20 #include "Cmmpacketcontextlist.h"

    21 #include "cmmpacketservicegsmwcdmaext.h"

    22 #include "CMmPacketTsy.h"

    23 #include <ctsy/tflogger.h>

    24 #include "MmTsy_timeoutdefs.h"

    25 #include "MmTsy_numberOfSlots.h"

    26 

    27 // ============================ MEMBER FUNCTIONS ===============================

    28 

    29 

    30 CMmPacketContextTsy::CMmPacketContextTsy()

    31     {

    32     }

    33 

    34 CMmPacketContextTsy* CMmPacketContextTsy::NewL(

    35         CMmPacketServiceTsy* const aMmPacketService,

    36         const TInfoName& aHostCID, 

    37         const TDes& aName,  

    38         const TUint8 aProxyId ) 

    39     {

    40 TFLOGSTRING2( "TSY: CMmPacketContextTsy::NewL. Context name:%S", &aName );

    41 

    42     CMmPacketContextTsy* packetContext = new ( ELeave ) CMmPacketContextTsy();

    43 

    44     CleanupClosePushL( *packetContext );

    45     packetContext->iMmPacketService = aMmPacketService;

    46     packetContext->iContextName = aName;

    47     packetContext->iProxyId = aProxyId;

    48     packetContext->iHostCID = aHostCID;

    49     packetContext->ConstructL();

    50     CleanupStack::Pop();

    51     

    52     return packetContext;

    53     }

    54 

    55 void CMmPacketContextTsy::ConstructL()

    56     {

    57     InitModulesL();

    58     InitInternalAttributes();    

    59     }

    60     

    61 CMmPacketContextTsy::~CMmPacketContextTsy()

    62     {

    63 TFLOGSTRING2( "TSY: CMmPacketContextTsy::~CMmPacketContextTsy. Context name: %S", &iContextName );

    64 	

    65 	if( iMmPacketService )

    66 		{

    67 			

    68 		iMmPacketService->PacketContextList()->RemoveObject( this );

    69 

    70 	    // Set Dynamic Caps

    71 	    iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag(

    72 	        RPacketService::KCapsActivate, EFalse );

    73 	    

    74 	    if ( iIsDialUpContext )

    75 	        {

    76 	        iMmPacketService->ResetPointerToDialUpContext( iContextName );

    77 	        }

    78 	    

    79 		}

    80 		

    81     delete iMmPacketContextGsmWcdmaExt;

    82     delete iTsyReqHandleStore;

    83 

    84     }

    85 

    86 // ---------------------------------------------------------------------------

    87 // CMmPacketContextTsy::InitModulesL

    88 // Initialises extension modules for CMmPacketContextTsy

    89 // (other items were commented in a header).

    90 // ---------------------------------------------------------------------------

    91 //

    92 void CMmPacketContextTsy::InitModulesL()

    93     {

    94 

    95     iMmPacketContextGsmWcdmaExt = 

    96         CMmPacketContextGsmWcdmaExt::NewL( this, iMmPacketService );

    97 

    98 #ifdef REQHANDLE_TIMER   

    99     // Create req handle store

   100     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(  this,

   101         iMmPacketService->PhoneTsy(), EMaxNumOfPacketContextRequests,

   102         iPacketContextReqHandles );

   103 

   104 #else

   105         // Create req handle store

   106     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

   107         EMaxNumOfPacketContextRequests, iPacketContextReqHandles );

   108 

   109 #endif // REQHANDLE_TIMER

   110 

   111     }

   112 

   113 // ---------------------------------------------------------------------------

   114 // CMmPacketContextTsy::InitInternalAttributes

   115 // Initialises miscellaneous internal attributes.

   116 // (other items were commented in a header).

   117 // ---------------------------------------------------------------------------

   118 //

   119 void CMmPacketContextTsy::InitInternalAttributes()

   120     {

   121     iQoSProfile = NULL;

   122     iQoSProfileName.Zero();

   123 

   124     iLastErrorCause = KErrNone;

   125     iContextStatus = RPacketContext::EStatusUnknown;

   126     iContextStatusBeforeSuspending = RPacketContext::EStatusUnknown;

   127     iConnectionSpeed = 0;

   128     iNotifyConnectionSpeed = 0;

   129     iIsDialUpContext = EFalse;

   130 

   131     if ( iContextName.Compare( KStringExternal )== 0 

   132          || iContextName.Compare( KStringExternal2 )== 0 )

   133         {

   134         iIsDialUpContext = ETrue;

   135         }

   136     }

   137 

   138 // ---------------------------------------------------------------------------

   139 // CMmPacketContextTsy::Init

   140 // Initialisation method that is called from ETel Server.

   141 // ---------------------------------------------------------------------------

   142 //

   143 void CMmPacketContextTsy::Init()

   144     {

   145     }

   146 

   147 // ---------------------------------------------------------------------------

   148 // CMmPacketContextTsy::ExtFunc

   149 // TRAP's all CMmPacketContextTsy related MM Packet API requests in case that

   150 // they fail. This method functions only as a centralized TRAP for the

   151 // DoExtFuncL method that does the actual mapping of IPC number to TSY method

   152 // call.

   153 // (other items were commented in a header).

   154 // ---------------------------------------------------------------------------

   155 //

   156 TInt CMmPacketContextTsy::ExtFunc( 

   157         const TTsyReqHandle aTsyReqHandle, 

   158         const TInt aIpc, 

   159         const TDataPackage& aPackage )  

   160     {

   161 TFLOGSTRING3( "TSY: CMmPacketContextTsy::ExtFunc. IPC: %d Context name:%S", aIpc, &iContextName );

   162 

   163     TInt ret( KErrNone );

   164     TInt trapError( KErrNone );

   165 

   166     // Reset last tsy request type

   167     iReqHandleType = EMultimodePacketContextReqHandleUnknown;

   168 

   169     // Trap the call of DoExtFuncL

   170     TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ) );

   171 

   172     if ( KErrNone != trapError )

   173         {

   174         ReqCompleted( aTsyReqHandle, trapError );

   175         }

   176 

   177     else if ( KErrNone != ret )

   178         {

   179         ReqCompleted( aTsyReqHandle, ret );

   180         }

   181 

   182     if ( EMultimodePacketContextReqHandleUnknown != iReqHandleType )

   183         {

   184 #ifdef REQHANDLE_TIMER

   185         SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

   186 #else

   187         iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

   188 #endif // REQHANDLE_TIMER

   189         }

   190 

   191     return KErrNone;

   192     }

   193 

   194 // ---------------------------------------------------------------------------

   195 // CMmPacketContextTsy::DoExtFuncL

   196 // Packet Data specific functionality of CMmPacketContextTsy::ExtFunc

   197 // ---------------------------------------------------------------------------

   198 //

   199 TInt CMmPacketContextTsy::DoExtFuncL( 

   200         const TTsyReqHandle aTsyReqHandle,      

   201         const TInt aIpc,      

   202         const TDataPackage& aPackage )   

   203     {

   204 TFLOGSTRING3( "TSY: CMmPacketContextTsy::DoExtFuncL. IPC: %d Handle:%d",

   205                 aIpc, aTsyReqHandle );

   206 

   207     TInt ret( KErrNotSupported );

   208 

   209     TAny* dataPtr = aPackage.Ptr1();

   210     TAny* dataPtr2 = aPackage.Ptr2();

   211 

   212     switch ( aIpc )

   213         {

   214         case EPacketContextNotifyStatusChange:

   215             ret = NotifyStatusChange( 

   216                 REINTERPRET_CAST( RPacketContext::TContextStatus*, dataPtr ) );

   217             break;

   218         case EPacketContextNotifyConfigChanged:

   219             ret = NotifyConfigChanged( 

   220                 REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

   221             break;

   222         case EPacketContextNotifyConnectionSpeedChange:

   223             ret = NotifyConnectionSpeedChange( 

   224                 REINTERPRET_CAST( TUint*, dataPtr ) );

   225             break;

   226         case EPacketContextInitialiseContext:

   227             {

   228             TDes8* paramData = aPackage.Des1n();

   229             

   230             if(paramData != NULL)

   231             	{

   232             	if(sizeof(RPacketContext::TDataChannelV2) > paramData->MaxLength())

   233             		{

   234             		ret = KErrArgument;

   235             		}

   236             	else

   237             		{

   238             		ret = InitialiseContextL( reinterpret_cast< RPacketContext::TDataChannelV2*>( dataPtr ));

   239             		}

   240             	}

   241             else

   242             	{

   243             	ret = KErrArgument;

   244             	}

   245             break;

   246             }

   247         case EPacketContextSetConfig:

   248             ret = SetConfigL( 

   249                 REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

   250             break;

   251         case EPacketContextActivate:

   252             ret = ActivateL();

   253             break;

   254         case EPacketContextDeactivate:

   255             ret = DeactivateL();

   256             break;

   257         case EPacketContextDelete:

   258             ret = DeleteL();

   259             break;

   260         case EPacketContextGetStatus:

   261             ret = GetStatus( aTsyReqHandle, 

   262                 REINTERPRET_CAST( RPacketContext::TContextStatus*, dataPtr ) );

   263             break;

   264         case EPacketContextGetConfig:

   265             ret = GetConfig( aTsyReqHandle, 

   266                 REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

   267             break;

   268         case EPacketContextGetProfileName:

   269             ret = GetProfileName( aTsyReqHandle, 

   270                 REINTERPRET_CAST( TInfoName*, dataPtr ) );

   271             break;

   272         case EPacketContextGetConnectionSpeed:

   273             ret = GetConnectionSpeed( aTsyReqHandle, 

   274                 REINTERPRET_CAST( TUint*, dataPtr ) );

   275             break;

   276         case EPacketContextGetLastErrorCause:

   277             ret = GetLastErrorCause( aTsyReqHandle, 

   278                 REINTERPRET_CAST( TInt*, dataPtr ) );

   279             break;

   280         case EPacketContextGetDataVolumeTransferred:

   281             ret = GetDataVolumeTransferredL( aTsyReqHandle,

   282                 REINTERPRET_CAST( RPacketContext::TDataVolume*, dataPtr ) );

   283             break;

   284         case EPacketContextEnumeratePacketFilters:

   285             ret = EnumeratePacketFilters( aTsyReqHandle,

   286                 REINTERPRET_CAST( TInt*, dataPtr ) );

   287             break;

   288         case EPacketContextGetPacketFilterInfo:

   289             {

   290             TDes8* paramData = aPackage.Des2n();

   291             

   292             if (paramData)

   293             	{

   294             	TInt paramLength = paramData->MaxLength();

   295             	

   296             	RPacketContext::TPacketFilterV2 temp;

   297             	RPacketContext::TPacketFilterV2Pckg tempPckg(temp);

   298             	

   299             	TInt expectedLength = tempPckg.MaxLength();

   300 

   301 				if (paramLength == expectedLength)

   302 					{

   303 		            ret = GetPacketFilterInfo( aTsyReqHandle, REINTERPRET_CAST( TInt*, dataPtr ), REINTERPRET_CAST( TPacketBase*, dataPtr2 ) );

   304 					}

   305 				else

   306 					{

   307 					ret = KErrArgument;

   308 					}

   309             	}

   310             else

   311             	{

   312             	ret = KErrArgument;

   313             	}

   314             	

   315             }

   316             break;

   317         case EPacketContextAddPacketFilter:

   318             ret = AddPacketFilterL( aTsyReqHandle, aPackage.Des1n() );

   319             break;

   320         case EPacketContextRemovePacketFilter:

   321 #ifdef USING_CTSY_DISPATCHER            

   322         	ret = RemovePacketFilter( REINTERPRET_CAST( TInt*, dataPtr ) );

   323 #else

   324         	ret = RemovePacketFilter( aTsyReqHandle,

   325                 REINTERPRET_CAST( TInt*, dataPtr ) );     

   326 #endif        	

   327         	break;

   328         case EPacketContextModifyActiveContext:

   329             ret = ModifyActiveContextL();

   330             break;

   331         case EPacketContextGetDNSInfo:

   332             ret = GetDnsInfo( aTsyReqHandle, aPackage.Des1n() );

   333             break;

   334         case EPacketAddMediaAuthorization:

   335 	        ret = AddMediaAuthorizationL( aTsyReqHandle, aPackage.Des1n() );

   336 	        break;

   337 	    case EPacketRemoveMediaAuthorization:

   338 	        ret = RemoveMediaAuthorization( aTsyReqHandle, 

   339 	        		REINTERPRET_CAST( RPacketContext::TAuthorizationToken*,

   340                     dataPtr ) );

   341 	        break;	        

   342 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   343         case EPacketContextGetConnectionInfo:

   344             ret = GetConnectionInfo( aTsyReqHandle, 

   345                 reinterpret_cast<TConnectionInfoBase*>( dataPtr ) );            

   346             break;

   347         case EPacketContextNotifyConnectionInfoChange:

   348             ret = NotifyConnectionInfoChange(

   349                 reinterpret_cast<TConnectionInfoBase*>( dataPtr ) ); 

   350             break;      

   351 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   352         // These requests currently not supported

   353         //case EPacketContextLoanCommPort:

   354         //case EPacketContextRecoverCommPort:

   355         //case EPacketContextNotifyDataTransferred:

   356         default:

   357             break;

   358         }

   359 

   360     return ret;

   361     }

   362 

   363 // ---------------------------------------------------------------------------

   364 // CMmPacketContextTsy::ReqModeL

   365 // Returns request mode for given IPC.

   366 // ---------------------------------------------------------------------------

   367 //

   368 CTelObject::TReqMode CMmPacketContextTsy::ReqModeL( 

   369         const TInt aIpc ) 

   370     {

   371 TFLOGSTRING2( "TSY: CMmPacketContextTsy::ReqModeL. IPC: %d", aIpc );

   372 

   373     CTelObject::TReqMode reqMode( 0 );

   374     TBool doLeave( EFalse );

   375 

   376     switch ( aIpc )

   377         {

   378         // All disabled

   379         // TSYs wishing to implement their own buffering algorithm will place 

   380         // all requests in this category.  

   381 

   382         // Get methods that do not use DOS and return immediately. 

   383         // Flow control not required.

   384         case EPacketContextGetConnectionSpeed:

   385         case EPacketContextGetLastErrorCause:

   386         case EPacketContextGetProfileName:

   387         case EPacketContextEnumeratePacketFilters:

   388         case EPacketContextGetPacketFilterInfo:

   389 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   390         case EPacketContextGetConnectionInfo:                      

   391 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   392 

   393         // Other methods that do not use DOS and return immediately. 

   394         // Flow control not required.

   395     

   396         // Methods that can propably take a long time and cannot therefore be

   397         // flow controlled. Solution: All these methods must check req handle

   398         // table before handling the request. In case that the request table 

   399         // indicates that same method has been called and has not been 

   400         // completed, the method should return KErrServerBusy.

   401             if ( iIsDialUpContext )

   402                 {

   403                 doLeave = ETrue;

   404                 break;

   405                 }

   406         case EPacketContextGetStatus:

   407         case EPacketContextGetConfig:

   408             break;

   409 

   410         // KReqModeFlowControlObeyed

   411         // Commands that change the state of the phone, e.g. clearing the AoC 

   412         // counter, are commands that the TSY should only deal with one at 

   413         // a time.

   414 

   415         case EPacketContextInitialiseContext:

   416         case EPacketContextActivate:

   417         case EPacketContextDelete:

   418         case EPacketContextSetConfig:

   419         case EPacketContextAddPacketFilter:

   420         case EPacketContextRemovePacketFilter:

   421         case EPacketContextModifyActiveContext:

   422         case EPacketContextGetDNSInfo:

   423         case EPacketAddMediaAuthorization:

   424         case EPacketRemoveMediaAuthorization:

   425             if ( iIsDialUpContext )

   426                 {

   427                 doLeave = ETrue;

   428                 break;

   429                 }

   430         case EPacketContextDeactivate:

   431         case EPacketContextGetDataVolumeTransferred:

   432 

   433             {

   434             reqMode = KReqModeFlowControlObeyed;

   435             break;

   436             }

   437 

   438         // KReqModeMultipleCompletionEnabled | ReqModePostImmediately

   439         // Requests that notify a client about a change of state.

   440         // Since these requests do not require the issuing of any modem 

   441         // commands, they do not have to obey flow control.

   442         // The TSY never gets more than one of these outstanding.

   443         case EPacketContextNotifyConfigChanged:

   444         case EPacketContextNotifyConnectionSpeedChange:

   445             if ( iIsDialUpContext )

   446                 {

   447                 doLeave = ETrue;

   448                 break;

   449                 }

   450         case EPacketContextNotifyStatusChange:

   451 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   452         case EPacketContextNotifyConnectionInfoChange:           

   453 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   454             reqMode = KReqModeMultipleCompletionEnabled |

   455                 KReqModeRePostImmediately;

   456             break;

   457 

   458         // Cancel Requests

   459         // It's not necessary to include the Cancel methods in ReqModeL at all.

   460         // The ETel server never calls ReqModeL with a Cancel IPC.

   461 

   462         // Other variations of return values are unusable.

   463         // Following requests are not supported

   464         //case EPacketContextNotifyDataTransferred:

   465         //case EPacketContextLoanCommPort:

   466         //case EPacketContextRecoverCommPort:

   467         // Default

   468         default:

   469             doLeave = ETrue;

   470             break;

   471         }

   472 

   473     if ( doLeave )

   474         {

   475         User::Leave( KErrNotSupported );

   476         }

   477 

   478     return reqMode;

   479     }

   480 

   481 // ---------------------------------------------------------------------------

   482 // CMmPacketContextTsy::NumberOfSlotsL

   483 // Returns number of slots to be used for given IPC.

   484 // (other items were commented in a header).

   485 // ---------------------------------------------------------------------------

   486 //

   487 TInt CMmPacketContextTsy::NumberOfSlotsL(    

   488         const TInt aIpc )                            

   489     {

   490     TInt numberOfSlots( 0 );

   491 

   492     switch ( aIpc )

   493         {

   494         case EPacketContextNotifyStatusChange:

   495             numberOfSlots = KMmPacketContextNotifyStatusChangeSlots;

   496             break;

   497         case EPacketContextNotifyConfigChanged:

   498             numberOfSlots = KMmPacketContextNotifyConfigChangedSlots;

   499             break;

   500         case EPacketContextNotifyConnectionSpeedChange:

   501             numberOfSlots = KMmPacketContextNotifyConnectionSpeedChangeSlots;

   502             break;

   503 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   504         case EPacketContextNotifyConnectionInfoChange:

   505             numberOfSlots = KMmPacketContextNotifyConnectionInfoChangeSlots;

   506             break;                       

   507 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   508         default:

   509             // Unknown or invalid IPC

   510             User::Leave( KErrNotSupported );

   511             break;

   512 

   513         }  

   514 TFLOGSTRING3( "TSY: CMmPacketContextTsy::NumberOfSlotsL. IPC: %d Number of slots: %d",

   515                 aIpc, numberOfSlots );

   516 

   517     return numberOfSlots;

   518 

   519     }

   520 

   521 // ---------------------------------------------------------------------------

   522 // CMmPacketContextTsy::CancelService

   523 // Cancel the outstanding request.ETel Server when it is "cleaning-up" any

   524 //  outstanding asynchronous requests before closing a client's sub-session.

   525 //  This will happen if a client closes its R-class handle without cancelling

   526 //  outstanding asynchronous requests. Only Packet API requests are handled 

   527 //  here. Client can also cancel a request by calling CancelAsyncRequest 

   528 //  (defined in etel.h). The ETel server passes this kind of cancel requests

   529 //  to CancelService.

   530 // (other items were commented in a header).

   531 // ---------------------------------------------------------------------------

   532 //

   533 TInt CMmPacketContextTsy::CancelService(    

   534         const TInt aIpc,                            

   535         const TTsyReqHandle aTsyReqHandle )         

   536     {

   537 TFLOGSTRING3( "TSY: CMmPacketContextTsy::CancelService. IPC: %d Handle:%d",

   538                 aIpc, aTsyReqHandle );

   539 

   540     TInt ret( KErrNone );

   541 	TTsyReqHandle reqHandle( NULL );

   542     // Reset last tsy request type

   543     iReqHandleType = EMultimodePacketContextReqHandleUnknown;

   544 

   545     switch ( aIpc )

   546         {

   547         // TSY has started a request and it is not possible to then cancel 

   548         // this request. The best thing for the TSY to do in this case is to

   549         // proceed as though the Cancel never happened. The server's call to

   550         // the TSY cancel function will return synchronously. The TSY then

   551         // continues to wait for the original acknowledgement and when it

   552         // receives it, the TSY will complete the original request.

   553         case EPacketContextInitialiseContext:

   554         case EPacketContextActivate:

   555         case EPacketContextDeactivate:

   556         case EPacketContextDelete:

   557         case EPacketContextSetConfig:

   558         case EPacketContextGetConfig:

   559         case EPacketContextGetConnectionSpeed:

   560         case EPacketContextGetDataVolumeTransferred:

   561         case EPacketContextEnumeratePacketFilters:

   562         case EPacketContextGetPacketFilterInfo:

   563         case EPacketContextAddPacketFilter:

   564         case EPacketContextRemovePacketFilter:

   565         case EPacketContextModifyActiveContext:

   566         case EPacketContextGetDNSInfo:

   567         case EPacketAddMediaAuthorization:

   568         case EPacketRemoveMediaAuthorization:

   569 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   570         case EPacketContextGetConnectionInfo:                     

   571 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   572             break;

   573         // Notification Cancels, no special requirements.

   574         case EPacketContextNotifyStatusChange:

   575             iRetNotifyStatus = NULL;

   576             iReqHandleType = EMultimodePacketContextNotifyStatusChange;

   577             break;

   578         case EPacketContextNotifyConfigChanged:

   579             reqHandle = iTsyReqHandleStore->GetTsyReqHandle(

   580                 EMultimodePacketContextNotifyConfigChanged );

   581             if ( aTsyReqHandle == reqHandle )

   582                 {

   583                 iRetNotifyConfig = NULL;

   584                 iReqHandleType = EMultimodePacketContextNotifyConfigChanged;

   585                 }

   586             else

   587                 {

   588                 reqHandle = iTsyReqHandleStore->GetTsyReqHandle(

   589                     EMultimodePacketContextNotifyConfigChanged99 );

   590                 if ( aTsyReqHandle == reqHandle )

   591                     {

   592                     iRetNotifyConfig2 = NULL;

   593                     iReqHandleType =

   594                         EMultimodePacketContextNotifyConfigChanged99;

   595                     }

   596                 }

   597             break;

   598         case EPacketContextNotifyConnectionSpeedChange:

   599             iRetNotifyConnectionSpeed = NULL;

   600             iReqHandleType = 

   601                 EMultimodePacketContextNotifyConnectionSpeedChange;

   602             break;

   603 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   604         case EPacketContextNotifyConnectionInfoChange:

   605             iRetNotifyConnectionInfo = NULL;

   606             iReqHandleType =

   607                 EMultimodePacketContextNotifyConnectionInfoChange;

   608             break;                       

   609 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   610         // IPCs that are not supported

   611         //case EPacketContextLoanCommPort:

   612         //case EPacketContextRecoverCommPort:

   613         //case EPacketContextNotifyDataTransferred:

   614         // Default

   615         default:

   616             ret = KErrNotSupported;

   617             break;

   618         }

   619 

   620     if ( EMultimodePacketContextReqHandleUnknown != iReqHandleType )

   621         {

   622         // Reset tsy request handle

   623         iTsyReqHandleStore->ResetTsyReqHandle( iReqHandleType );

   624 

   625         // Complete request

   626         CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, KErrCancel );

   627         }

   628 

   629     return ret;

   630     }

   631 

   632 // ---------------------------------------------------------------------------

   633 // CMmPacketContextTsy::RegisterNotification

   634 // Register notification. RegisterNotification is called when the ETel Server

   635 // recognises that this notification is being posted for the first time on

   636 // this subsession object.It enables the TSY to "turn on" any regular 

   637 // notification messages that it may receive from DOS. If this object is

   638 // Dial-Up context only supported notification is 

   639 // EPacketContextNotifyStatusChange.

   640 // (other items were commented in a header).

   641 // ---------------------------------------------------------------------------

   642 //

   643 TInt CMmPacketContextTsy::RegisterNotification( 

   644         const TInt aIpc )              

   645     {

   646 TFLOGSTRING2( "TSY: CMmPacketContextTsy::RegisterNotification. IPC: %d", aIpc );

   647 

   648     TInt ret( KErrNone );

   649 

   650     switch ( aIpc )

   651         {

   652         case EPacketContextNotifyConfigChanged:

   653         case EPacketContextNotifyConnectionSpeedChange:

   654             if ( iIsDialUpContext )

   655                 {

   656                 ret = KErrNotSupported;

   657                 break;

   658                 }

   659         case EPacketContextNotifyStatusChange:          

   660 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   661         case EPacketContextNotifyConnectionInfoChange:                       

   662 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   663             break;

   664         //case EPacketContextNotifyDataTransferred:

   665         default:

   666             // Not supported

   667             ret = KErrNotSupported;

   668             break;

   669         }

   670 

   671     return ret;

   672     }

   673 

   674 // ---------------------------------------------------------------------------

   675 // CMmPacketContextTsy::DeregisterNotification

   676 // Deregister notification. DeregisterNotification is called when the ETel

   677 // Server recognises that this notification will not be posted again because 

   678 // the last client to have a handle on this sub-session object has just closed 

   679 // the handle. It enables the TSY to "turn off" any regular notification

   680 // messages that it may receive from DOS. If this object is Dial-Up context

   681 // only supported notification is EPacketContextNotifyStatusChange.

   682 // (other items were commented in a header).

   683 // ---------------------------------------------------------------------------

   684 //

   685 TInt CMmPacketContextTsy::DeregisterNotification(

   686         const TInt aIpc )                          

   687     {

   688 TFLOGSTRING2( "TSY: CMmPacketContextTsy::DeregisterNotification. IPC: %d", aIpc );

   689 

   690     TInt ret( KErrNone );

   691 

   692     switch ( aIpc )

   693         {

   694         case EPacketContextNotifyConfigChanged:

   695         case EPacketContextNotifyConnectionSpeedChange:

   696             if ( iIsDialUpContext )

   697                 {

   698                 ret = KErrNotSupported;

   699                 break;

   700                 }

   701         case EPacketContextNotifyStatusChange:

   702 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   703         case EPacketContextNotifyConnectionInfoChange:                    

   704 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   705             break;

   706         //case EPacketContextNotifyDataTransferred:

   707         default:

   708             // Not supported

   709             ret = KErrNotSupported;

   710             break;

   711         }

   712 

   713     return ret;

   714     }

   715 

   716 // ---------------------------------------------------------------------------

   717 // CMmPacketContextTsy::OpenNewObjectL

   718 // Create new QoS object and return a pointer to it.

   719 // (other items were commented in a header).

   720 // ---------------------------------------------------------------------------

   721 //

   722 CTelObject* CMmPacketContextTsy::OpenNewObjectL(    

   723         TDes& aNewName )                          

   724     {

   725 TFLOGSTRING( "TSY: CMmPacketContextTsy::OpenNewObjectL." );

   726 

   727     // Each context can have only one QoS

   728     if ( NULL != iQoSProfile )

   729         {

   730 TFLOGSTRING2( "TSY: CMmPacketContextTsy::OpenNewObjectL. Leaves with: %d", KErrAlreadyExists );

   731         User::Leave( KErrAlreadyExists );

   732         }

   733     

   734     else

   735         {

   736         // Create new QoS object

   737         iQoSProfile = CMmPacketQoSTsy::NewL( iMmPacketService, this );

   738 

   739         iQoSProfileName.Copy( iContextName );

   740         aNewName.Copy( iQoSProfileName );

   741         }

   742 TFLOGSTRING2( "TSY: CMmPacketContextTsy::OpenNewObjectL. aNewName: %S", &aNewName );

   743 

   744     return iQoSProfile;

   745     }

   746 

   747 // ---------------------------------------------------------------------------

   748 // CMmPacketContextTsy::OpenNewObjectByNameL

   749 // Return a pointer to QoS if it exists. The ETel Server calls this method 

   750 // after some client has requested to open existing QoS object. The TSY 

   751 // classes must not use this method.

   752 // (other items were commented in a header).

   753 // ---------------------------------------------------------------------------

   754 //

   755 CTelObject* CMmPacketContextTsy::OpenNewObjectByNameL(    

   756         const TDesC& aName )                     

   757     {

   758 TFLOGSTRING2( "TSY: CMmPacketContextTsy::OpenNewObjectByNameL. aName: %S", &aName );

   759 

   760     if ( aName != iQoSProfileName )

   761         {

   762 TFLOGSTRING2( "TSY: CMmPacketContextTsy::OpenNewObjectByNameL. Leaves with: %d", KErrNotFound );

   763         User::Leave( KErrNotFound );

   764         }

   765 

   766     return iQoSProfile;

   767     }

   768 

   769 // ---------------------------------------------------------------------------

   770 // CMmPacketContextTsy::InitialiseContextL

   771 // This function initialises the context created previously.

   772 // (other items were commented in a header).

   773 // ---------------------------------------------------------------------------

   774 //

   775 TInt CMmPacketContextTsy::InitialiseContextL(RPacketContext::TDataChannelV2* aDataChannel )

   776     {

   777 TFLOGSTRING( "TSY: CMmPacketContextTsy::InitialiseContextL." );

   778 

   779     TInt ret( KErrNone );

   780 

   781     // Initialise Context

   782     ret = iMmPacketContextGsmWcdmaExt->InitialiseContextL(aDataChannel);

   783 

   784     if ( KErrNone == ret )

   785         {

   786         // Store the request handle

   787         iReqHandleType = EMultimodePacketContextInitialiseContext;

   788         }

   789 

   790     return ret;

   791     }

   792 

   793 // ---------------------------------------------------------------------------

   794 // CMmPacketContextTsy::CompleteInitialiseContext

   795 // Complete the asynchronous InitialiseContext request.

   796 // (other items were commented in a header).

   797 // ---------------------------------------------------------------------------

   798 //

   799 void CMmPacketContextTsy::CompleteInitialiseContext(const TInt aResult )     

   800     {

   801 TFLOGSTRING2( "TSY: CMmPacketContextTsy::CompleteInitialiseContext. Error: %d", aResult );

   802 

   803     // Reset the req handle. Returns the deleted req handle

   804     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   805         EMultimodePacketContextInitialiseContext );

   806 

   807     if ( EMultimodePacketContextReqHandleUnknown != reqHandle )

   808         {

   809                // Complete the client request

   810         CMmPacketContextTsy::ReqCompleted( reqHandle, aResult );

   811         }

   812 

   813     }

   814 

   815 // ---------------------------------------------------------------------------

   816 // CMmPacketContextTsy::ActivateL

   817 // Activate a context. This function activates a context that has been

   818 // previously configured using the SetConfig() method from RPacketContext.

   819 // Once this function completes, the context will remain in an 'Activating'

   820 // state until PPP has been successfully negotiated between the phone & the

   821 // packet network gateway.Once PPP is negotiated, the context can be 

   822 // considered to be 'Activated'.

   823 // (other items were commented in a header).

   824 // ---------------------------------------------------------------------------

   825 //

   826 TInt CMmPacketContextTsy::ActivateL()

   827     {

   828 TFLOGSTRING2( "TSY: CMmPacketContextTsy::ActivateL. Context name:%S", &iContextName );

   829 

   830     TInt ret( KErrGprsServicesNotAllowed );

   831 

   832     if ( iMmPacketService->IsActivationAllowed() )

   833         {

   834         // Call ActivateL

   835         ret = iMmPacketContextGsmWcdmaExt->ActivateL();

   836         }

   837 

   838     if ( KErrNone == ret )

   839         {

   840         // Store the request handle

   841         iReqHandleType = EMultimodePacketContextActivate;

   842         }

   843 

   844     return ret;        

   845     }

   846 

   847 // ---------------------------------------------------------------------------

   848 // CMmPacketContextTsy::CompleteActivate

   849 // Complete the asynchronous Activate request.

   850 // (other items were commented in a header).

   851 // ---------------------------------------------------------------------------

   852 //

   853 void CMmPacketContextTsy::CompleteActivate( 

   854         const TInt aResult )

   855     {

   856 TFLOGSTRING2( "TSY: CMmPacketContextTsy::CompleteActivate. Error: %d", aResult );

   857     // Reset the req handle. Returns the deleted req handle

   858     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   859         EMultimodePacketContextActivate );

   860 

   861     if ( EMultimodePacketContextReqHandleUnknown != reqHandle )

   862         {

   863        

   864         // Complete the client request

   865         CMmPacketContextTsy::ReqCompleted( reqHandle, aResult );

   866         }

   867     }

   868 

   869 // ---------------------------------------------------------------------------

   870 // CMmPacketContextTsy::Deactivate

   871 // Deactivate a context previously configured on the phone.

   872 // (other items were commented in a header).

   873 // ---------------------------------------------------------------------------

   874 //

   875 TInt CMmPacketContextTsy::DeactivateL()

   876     {

   877 TFLOGSTRING2( "TSY: CMmPacketContextTsy::DeactivateL. Context name:%S", &iContextName );

   878     TInt ret( KErrNone );

   879 

   880     // Call Deactivate

   881     ret = iMmPacketContextGsmWcdmaExt->DeactivateL();

   882 

   883     if ( KErrNone == ret )

   884         {

   885         // Store the request handle

   886         iReqHandleType = EMultimodePacketContextDeactivate;

   887         }

   888 

   889     return ret;  

   890     }

   891 

   892 // ---------------------------------------------------------------------------

   893 // CMmPacketContextTsy::CompleteDeactivate

   894 // Complete the asynchronous Deactivate request.

   895 // (other items were commented in a header).

   896 // ---------------------------------------------------------------------------

   897 //

   898 void CMmPacketContextTsy::CompleteDeactivate( 

   899         const TInt aResult )    

   900     {

   901 TFLOGSTRING2( "TSY: CMmPacketContextTsy::CompleteDeactivate. Error: %d", aResult );

   902     // Reset the req handle. Returns the deleted req handle

   903     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   904         EMultimodePacketContextDeactivate );

   905 

   906     if ( EMultimodePacketContextReqHandleUnknown != reqHandle )

   907         {

   908         

   909         // Complete the client request

   910         CMmPacketContextTsy::ReqCompleted( reqHandle, aResult );

   911         }

   912     }

   913 

   914 // ---------------------------------------------------------------------------

   915 // CMmPacketContextTsy::DeleteL

   916 // Delete a context id previously created on the phone.

   917 // Note that although the context is considered as 'deleted', the 

   918 // client's RPacketContext subsession remains. To remove this, a client must

   919 // call Close() from RPacketContext.

   920 // (other items were commented in a header).

   921 // ---------------------------------------------------------------------------

   922 //

   923 TInt CMmPacketContextTsy::DeleteL()

   924     {

   925 TFLOGSTRING2( "TSY: CMmPacketContextTsy::DeleteL. Context name:%S", &iContextName );

   926 

   927     TInt ret( KErrNone );

   928 

   929     // Call DeleteL

   930     ret = iMmPacketContextGsmWcdmaExt->DeleteL();

   931 

   932     if ( KErrNone == ret )

   933         {

   934         // Store the request handle

   935         iReqHandleType = EMultimodePacketContextDelete;

   936         }

   937 

   938     return ret;

   939     }

   940 

   941 // ---------------------------------------------------------------------------

   942 // CMmPacketContextTsy::CompleteDelete

   943 // Complete the asynchronous Delete request.

   944 // (other items were commented in a header).

   945 // ---------------------------------------------------------------------------

   946 //

   947 void CMmPacketContextTsy::CompleteDelete( 

   948         const TInt aResult )        

   949     {

   950 TFLOGSTRING2( "TSY: CMmPacketContextTsy::CompleteDelete. Error: %d", aResult );

   951     // Reset the req handle. Returns the deleted req handle

   952     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   953         EMultimodePacketContextDelete );

   954 

   955     if ( EMultimodePacketContextReqHandleUnknown != reqHandle )

   956         {

   957         // Complete the client request

   958         CMmPacketContextTsy::ReqCompleted( reqHandle, aResult );

   959         }

   960     }

   961 

   962 // ---------------------------------------------------------------------------

   963 // CMmPacketContextTsy::GetConfig

   964 // Requests the current configuration of the context.

   965 // (other items were commented in a header).

   966 // ---------------------------------------------------------------------------

   967 //

   968 TInt CMmPacketContextTsy::GetConfig(

   969         const TTsyReqHandle aTsyReqHandle,    

   970         TPacketDataConfigBase* const aConfig )  

   971     {

   972 TFLOGSTRING2( "TSY: CMmPacketContextTsy::GetConfig. Context name:%S", &iContextName );

   973 

   974     // Get config

   975     TInt ret = iMmPacketContextGsmWcdmaExt->GetConfig( aConfig );

   976 

   977     // Complete Request

   978     CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, ret );

   979 

   980     return KErrNone;

   981     }

   982 

   983 // ---------------------------------------------------------------------------

   984 // CMmPacketContextTsy::GetConnectionSpeed

   985 // Allows a client to get the current connection speed.

   986 // (other items were commented in a header).

   987 // ---------------------------------------------------------------------------

   988 //

   989 TInt CMmPacketContextTsy::GetConnectionSpeed(

   990         const TTsyReqHandle aTsyReqHandle,         

   991         TUint* const aRate ) 

   992     {

   993 TFLOGSTRING3( "TSY: CMmPacketContextTsy::GetConnectionSpeed. Context name: %S Connection Speed:%d bps",

   994              &iContextName, iConnectionSpeed );

   995 

   996     // Get current connection speed rate

   997     *aRate = iConnectionSpeed;

   998 

   999     // Complete Request

  1000     CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, KErrNone );

  1001 

  1002     return KErrNone;

  1003     }

  1004 

  1005 // ---------------------------------------------------------------------------

  1006 // CMmPacketContextTsy::GetDataVolumeTransferred

  1007 // This function gets the data volume transferred.

  1008 // (other items were commented in a header).

  1009 // ---------------------------------------------------------------------------

  1010 //

  1011 TInt CMmPacketContextTsy::GetDataVolumeTransferredL(

  1012         const TTsyReqHandle aTsyReqHandle,   

  1013         RPacketContext::TDataVolume* const aVolume ) 

  1014     {

  1015 TFLOGSTRING2( "TSY: CMmPacketContextTsy::GetDataVolumeTransferredL. Context name:%S", &iContextName );

  1016 

  1017     TInt ret( KErrNone );

  1018 

  1019     if ( RPacketContext::EStatusDeleted != iContextStatus )

  1020         {

  1021         // Get data volume transferred

  1022         ret = iMmPacketContextGsmWcdmaExt->GetDataVolumeTransferredL();

  1023 

  1024         if ( KErrNone == ret )

  1025             {

  1026             // Store pointer

  1027             iRetDataVolume = aVolume;

  1028             // Store the request handle type

  1029             iReqHandleType = EMultimodePacketContextGetDataVolumeTransferred;

  1030             }

  1031         }

  1032     else

  1033         {

  1034         // Get current data volume

  1035         *aVolume = iDataVolume;

  1036         // Complete request

  1037         CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, KErrNone );

  1038         }

  1039 

  1040     return ret;

  1041     }

  1042 

  1043 // ---------------------------------------------------------------------------

  1044 // CMmPacketContextTsy::CompleteGetDataVolumeTransferred

  1045 // Complete the asynchronous GetDataVolumeTransferred request.

  1046 // (other items were commented in a header).

  1047 // ---------------------------------------------------------------------------

  1048 //

  1049 void CMmPacketContextTsy::CompleteGetDataVolumeTransferred( 

  1050         const TInt aResult )  

  1051     {

  1052 TFLOGSTRING2( "TSY: CMmPacketContextTsy::CompleteGetDataVolumeTransferred. Error: %d", aResult );

  1053 

  1054     // Reset the req handle. Returns the deleted req handle

  1055     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

  1056         EMultimodePacketContextGetDataVolumeTransferred );

  1057 

  1058     if ( EMultimodePacketContextReqHandleUnknown != reqHandle )

  1059         {

  1060         

  1061         if ( KErrNone == aResult )

  1062             {

  1063             *iRetDataVolume = iDataVolume;

  1064             }

  1065 

  1066         // Null ret pointer

  1067         iRetDataVolume = NULL;

  1068 

  1069         // Complete the client request

  1070         CMmPacketContextTsy::ReqCompleted( reqHandle, aResult );

  1071         }

  1072 

  1073     }

  1074 

  1075 // ---------------------------------------------------------------------------

  1076 // CMmPacketContextTsy::GetLastErrorCause

  1077 // This function retrieves the last error cause to have occurred.

  1078 // (other items were commented in a header).

  1079 // ---------------------------------------------------------------------------

  1080 //

  1081 TInt CMmPacketContextTsy::GetLastErrorCause(

  1082         const TTsyReqHandle aTsyReqHandle,  

  1083         TInt* const aError )    

  1084     {

  1085 TFLOGSTRING3( "TSY: CMmPacketContextTsy::GetLastErrorCause. Context name:%S Last error cause: %d",

  1086              &iContextName, iLastErrorCause );

  1087 

  1088     *aError = iLastErrorCause;

  1089     CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, KErrNone );

  1090 

  1091     return KErrNone;

  1092     }

  1093 

  1094 // ---------------------------------------------------------------------------

  1095 // CMmPacketContextTsy::GetProfileName

  1096 // Allows a client to retrieve the name of the QoS profile. The QoS profile is

  1097 // associated with the context. If no QoS profile has been defined by the

  1098 // client, the name to be returned will be NULL.

  1099 // (other items were commented in a header).

  1100 // ---------------------------------------------------------------------------

  1101 //

  1102 TInt CMmPacketContextTsy::GetProfileName(

  1103         const TTsyReqHandle aTsyReqHandle, 

  1104         TInfoName* const aQoSProfile )  

  1105     {

  1106     if ( NULL != iQoSProfile )

  1107         {

  1108         *aQoSProfile = iQoSProfileName;

  1109         }

  1110     else

  1111         {

  1112         // QoS profile not found

  1113         aQoSProfile->Zero();

  1114         }

  1115 

  1116 TFLOGSTRING3( "TSY: CMmPacketContextTsy::GetProfileName. Context name: %S QoS Profile Name: %S",

  1117              &iContextName, aQoSProfile );

  1118 

  1119     CMmPacketContextTsy::ReqCompleted( aTsyReqHandle, KErrNone );

  1120     return KErrNone;

  1121     }

  1122 

  1123 // ---------------------------------------------------------------------------

  1124 // CMmPacketContextTsy::GetStatus

  1125 // Allows a client to get the current status of the context.

  1126 // (other items were commented in a header).

  1127 // ---------------------------------------------------------------------------

  1128 //

  1129 TInt CMmPacketContextTsy::GetStatus(

  1130         const TTsyReqHandle aTsyReqHandle,   

  1131         RPacketContext::TContextStatus* const aContextStatus )

  1132     {

  1133 TFLOGSTRING3( "TSY: CMmPacketContextTsy::GetStatus. Context name: %S Context Status:%d",

  1134              &iContextName, iContextStatus );