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 "CMmCustomTsy.h"

    20 #include "CMmCustomGsmExt.h"

    21 #include "cmmcalllist.h"

    22 #include "cmmphoneextinterface.h"

    23 #include "CMmWimTsy.h"

    24 #include "cmmcalltsy.h"

    25 #include "CMmCommonStaticUtility.h"

    26 #include "CMmSimLockTsy.h"

    27 #include "MmTsy_conf.h"

    28 #include <ctsy/tflogger.h>

    29 #include "cmmpblist.h"

    30 #include "cmmphonebookstoretsy.h"

    31 #include "CMmPacketTsy.h"

    32 #include "CMmSIMTsy.h"

    33 #include "CMmCustomSecurityTsy.h"

    34 #include <ctsy/serviceapi/gsmerror.h>

    35 #include <ctsy/serviceapi/cmmcustomvendorext.h>

    36 #include "cmmnettsy.h"  // for CMmNetTsy::CipheringIndicatorForcedOff()

    37 #include <ctsy/serviceapi/ctsydomaincrkeys.h>

    38 #include "ctsyprivatecrpkeys.h"

    39 #include <featureuids.h>

    40 

    41 // ======== MEMBER FUNCTIONS ========

    42 

    43 CMmCustomTsy::CMmCustomTsy()

    44     {

    45     iMmPhoneTsy = NULL;

    46     iMmCustomExtInterface = NULL;

    47     Mem::FillZ( iMmSubTsy, sizeof( iMmSubTsy ) );

    48 

    49     // initialize internal data

    50     iCipheringInfo.iIndStatus = EFalse;

    51     iCipheringInfo.iCiphStatus = EFalse;

    52     }

    53 

    54 void CMmCustomTsy::ConstructL(

    55     CMmPhoneTsy* aMmPhoneTsy )

    56     {

    57 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL");

    58     iMmPhoneTsy = aMmPhoneTsy;

    59 

    60     iMmCustomExtInterface = CMmCustomGsmExt::NewL( aMmPhoneTsy, this );

    61     iMmSubTsy[ESubTsyIdxWIM] = CMmWimTsy::NewL( this );

    62     iMmSubTsy[ESubTsyIdxSimLock] = CMmSimLockTsy::NewL( this );

    63     iMmSubTsy[ESubTsyIdxPacket] = CMmPacketTsy::NewL( this, aMmPhoneTsy );

    64 

    65     iMmSubTsy[ESubTsyIdxSIM]  = CMmSIMTsy::NewL( this );

    66 

    67     iMmSecurityTsy = CMmCustomSecurityTsy::NewL( this, aMmPhoneTsy );

    68 

    69     // Create custom vendor extension

    70     // Send request to the Domestic OS layer.

    71     iMmCustomVendorExt = (CMmCustomVendorExt*) NULL;

    72     CMmDataPackage package;

    73 

    74     package.PackData( &iMmCustomVendorExt ); // ptr to ptr

    75     Phone()->MessageManager()->HandleRequestL(

    76             EMmTsyGetCustomVendorExtPtrIPC, &package );

    77 TFLOGSTRING2("TSY: CMmCustomTsy::ConstructL -- iMmCustomVendorExt=0x%x", TUint(iMmCustomVendorExt));

    78     // The request above is 'completed' immediatedly (there is no need for

    79     // actual complete)

    80 

    81     // iMmCustomVendorExt should now hold ptr to custom vendor extension.

    82     // But if not, no problem, we just use the base class.

    83     if ( NULL == iMmCustomVendorExt )

    84         {

    85 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- no vendor IPC extensions");

    86         iMmCustomVendorExt = new(ELeave)CMmCustomVendorExt();

    87         }

    88     

    89     // initialize custom vendor extension 

    90     iMmCustomVendorExt->InitializeL( *this );

    91 

    92 #ifdef REQHANDLE_TIMER

    93     // Create req handle store

    94     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhoneTsy,

    95         ECustomTsyMaxNumOfRequests, iCustomReqHandles );

    96 #else

    97     // Create req handle store

    98     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

    99         ECustomTsyMaxNumOfRequests, iCustomReqHandles );

   100 #endif

   101 

   102     // register custom tsy in the message manager

   103     Phone()->MessageManager()->RegisterTsyObject(

   104         CMmMessageManagerBase::ECustomTsy, this );

   105 

   106     iAdnCacheStatus = RMmCustomAPI::ECacheNotReady;

   107     iFdnCacheStatus = RMmCustomAPI::ECacheNotReady;

   108 

   109     iISVDialNumberCheckObject = NULL;

   110     iISVDialNumberCheck = EFalse;

   111     iGetIccCfStatusBootUp = ETrue;

   112     //Get pointer to public CenRep

   113     iCFISCentRep = iMmPhoneTsy->GetCfisCenRep();

   114     iCFISPrivateCentRep = iMmPhoneTsy->GetCfisPRCenRep();

   115 	TInt err = iFeatureControl.Open();

   116 	iUsingFeatureManager = (err == KErrNone);

   117     

   118     // update/receive Icc Call forward information

   119     if( iMmPhoneTsy->NosBootState()->iSIMReady )

   120         {

   121 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- GET ICC call forward indicators");       

   122         // Get Icc cfis values from LTSY

   123         Phone()->MessageManager()->HandleRequestL( 

   124             ECustomGetIccCallForwardingStatusIPC );

   125         }

   126         

   127     // check if HomeZoneParams has been already read in NotifySimStatusReady

   128  	// if not, query again

   129     if ( !iMmPhoneTsy->GetHomeZoneParamsChecked() )

   130     	{

   131 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - GetHomeZoneParamsChecked()");    	

   132         CMmSIMTsy* simCustomTsy = NULL;

   133         simCustomTsy = ( CMmSIMTsy* )GetSIMTsyPtr();

   134 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - pointer created");

   135 	

   136         if ( simCustomTsy )

   137             {

   138 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL()");

   139             simCustomTsy->CheckViagHomezoneParamsL();

   140             iMmPhoneTsy->SetHomeZoneParamsChecked( ETrue );

   141             }

   142         else

   143         	{

   144 TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL() False");        		

   145 			iMmPhoneTsy->SetHomeZoneParamsChecked( EFalse );

   146         	}

   147     	}     

   148     }

   149 

   150 CMmCustomTsy* CMmCustomTsy::NewL(

   151     CMmPhoneTsy* aMmPhoneTsy )

   152     {

   153 TFLOGSTRING("TSY: CMmCustomTsy::NewL");

   154     CMmCustomTsy* mmCustomTsy = new ( ELeave ) CMmCustomTsy();

   155     CleanupClosePushL( *mmCustomTsy );

   156     mmCustomTsy->ConstructL( aMmPhoneTsy );

   157     CleanupStack::Pop( mmCustomTsy );

   158 

   159     return mmCustomTsy;

   160     }

   161 

   162 CMmCustomTsy::~CMmCustomTsy()

   163     {

   164 TFLOGSTRING("TSY: CMmCustomTsy::~CMmCustomTsy");

   165 

   166 	iFeatureControl.Close();

   167 	

   168     // Delete subsystems

   169     for ( TInt i = 0; ESubTsyIdxMaxNum > i; i++ )

   170         {

   171         delete iMmSubTsy[i];

   172         }

   173 

   174     if ( iMmCustomVendorExt )

   175         {

   176         // delete vendor extension

   177         delete iMmCustomVendorExt;

   178         }

   179 

   180     if ( iMmSecurityTsy )

   181         {

   182         // Delete SecurityTsy

   183         delete iMmSecurityTsy;

   184         }

   185 

   186     if ( iMmCustomExtInterface )

   187         {

   188         // Delete GSM extensions

   189         delete iMmCustomExtInterface;

   190         }

   191 

   192     if ( iTsyReqHandleStore )

   193         {

   194         // delete req handle store

   195         delete iTsyReqHandleStore;

   196         }

   197 

   198     iMmCustomVendorExt = NULL;

   199     iMmSecurityTsy = NULL;

   200     iMmCustomExtInterface = NULL;

   201     iTsyReqHandleStore = NULL;

   202     iISVDialNumberCheckObject = NULL;

   203     iCFISCentRep = NULL;

   204 

   205     if ( iMmPhoneTsy )

   206         {

   207         iMmPhoneTsy->SetCustomTsy( NULL );

   208 

   209         // unregister custom tsy in the message manager

   210         iMmPhoneTsy->MessageManager()->DeregisterTsyObject(this);

   211         }

   212     }

   213 

   214 // ---------------------------------------------------------------------------

   215 // CMmCustomTsy::Phone

   216 // Returns pointer to PhoneTsy object

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

   218 // ---------------------------------------------------------------------------

   219 //

   220 CMmPhoneTsy* CMmCustomTsy::Phone()

   221     {

   222     return iMmPhoneTsy;

   223     }

   224 

   225 

   226 // ---------------------------------------------------------------------------

   227 // CMmCustomTsy::ExtFunc

   228 // Dispatches extension function requests. All functions that are not part

   229 // of the core function set, are routed via the ExtFunc method.

   230 // At the beginning of this method, packaged pointers are unpacked. Then

   231 // the correct function is selected using the IPC number.

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

   233 // ---------------------------------------------------------------------------

   234 //

   235 TInt CMmCustomTsy::ExtFunc(

   236     const TTsyReqHandle aTsyReqHandle,

   237     const TInt aIpc,

   238     const TDataPackage& aPackage )

   239     {

   240     TInt ret = KErrNone;

   241     TInt trapError = KErrNone;

   242     iReqHandleType = ECustomTsyReqHandleUnknown;

   243 

   244     // before processing further the request, check if offline mode status

   245     // is enabled and if the given request can be perfomed in that case.

   246     if ( ERfsStateInfoInactive == iMmPhoneTsy->GetRfStateInfo() &&

   247         !IsRequestPossibleInOffline( aIpc ) )

   248         {

   249 TFLOGSTRING2 ("TSY: Offline mode ON, request is not allowed: %d", aIpc );

   250         ret = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral,

   251                 KErrGsmOfflineOpNotAllowed );

   252 

   253         // Complete the request with appropiate error

   254         ReqCompleted ( aTsyReqHandle, ret );

   255         }

   256     else

   257         {

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

   259 

   260         if ( KErrNone != trapError )

   261             {

   262             // error handling. Object cannot be created.

   263             ret = trapError;

   264             }

   265         if ( KErrNone != ret )

   266             {

   267             ReqCompleted( aTsyReqHandle, ret );

   268             }

   269         }

   270 

   271     return KErrNone;

   272     }

   273 

   274 // ---------------------------------------------------------------------------

   275 // CMmCustomTsy::DoExtFuncL

   276 // This DoExtFuncL is called by Etel server when it has Custom API

   277 // request for the TSY. To process a request handle, request type and request

   278 // data are passed to the Custom TSY.

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

   280 // ---------------------------------------------------------------------------

   281 //

   282 TInt CMmCustomTsy::DoExtFuncL(

   283     const TTsyReqHandle aTsyReqHandle,

   284     const TInt aIpc,

   285     const TDataPackage& aPackage )

   286     {

   287     TInt ret( KErrNotSupported );

   288 

   289     // first check if request is supported in CMmSecurityTsy

   290     // (due layering that class is no longer a part of extension modules)

   291 

   292     ret = iMmSecurityTsy->DoExtFuncL( aTsyReqHandle, aIpc, aPackage );

   293 

   294     if ( KErrNotSupported == ret )

   295         {

   296         // then check if this is vendor extension IPC

   297         // these IPCs are handled by VendorExt class in licensee tsy.

   298        if ( iMmCustomVendorExt->SupportingIPC(aIpc) )

   299           {

   300           ret = iMmCustomVendorExt->DoExtFuncL( aTsyReqHandle, aIpc,

   301                     aPackage );

   302           }

   303        else

   304           {

   305           // then check all the Custom extension modules

   306           ret = CMmTsyBase::DoBaseExtFuncL( aTsyReqHandle, aIpc, aPackage );

   307 	      }

   308 

   309         // if extension modules did not serve this request

   310         if ( KErrNotSupported == ret )

   311             {

   312             // reset last tsy request type

   313             iReqHandleType = ECustomTsyReqHandleUnknown;

   314 

   315             switch ( aIpc )

   316                 {

   317                 // Perform IMS Authentication

   318                 case EMobilePhoneIMSAuthenticate:

   319                     ret = ImsAuthenticationL( aTsyReqHandle,

   320                         REINTERPRET_CAST(

   321                         RMobilePhone::TImsAuthenticateDataV5*,

   322                         aPackage.Ptr1() ) );

   323                     break;

   324                 // Get sim authentication data

   325                 case ECustomGetSimAuthenticationDataIPC:

   326                     ret = SimAuthenticationL( aTsyReqHandle, aPackage );

   327                     break;

   328                 // Notify Dtmf event

   329                 case ECustomNotifyDtmfEventIPC:

   330                     ret = NotifyDtmfEvent(

   331                         REINTERPRET_CAST( RMmCustomAPI::TDtmfInfo*,

   332                         aPackage.Ptr1() ) );

   333                     break;

   334                 // Get Diagnostic Octets - info 

   335                 case ECustomGetDiagnosticOctetsIPC:

   336                    ret = GetDiagnosticInfo ( aTsyReqHandle,

   337                        REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

   338                    break;

   339                 // Get Remote Alerting Tone Status

   340                 case ECustomGetRemoteAlertingToneStatusIPC:

   341                     ret = GetRemoteAlertingToneStatus ( aTsyReqHandle,

   342                         REINTERPRET_CAST(

   343                         RMmCustomAPI::TRemoteAlertingToneStatus*,

   344                         aPackage.Ptr1() ) );

   345                     break;

   346                 // Call Origin

   347                 case ECustomCallOriginIPC:

   348                     ret = GetCallOrigin( aTsyReqHandle,

   349                         REINTERPRET_CAST( TName*, aPackage.Ptr1() ),

   350                         REINTERPRET_CAST( RMmCustomAPI::TCallOrigin*,

   351                         aPackage.Ptr2() ) );

   352                     break;

   353                 // Terminate a Call/all calls

   354                 case ECustomTerminateCallIPC:

   355                     ret = TerminateCallL( aTsyReqHandle,

   356                         REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

   357                     break;

   358                 // Get Als Blocked

   359                 case ECustomGetAlsBlockedIPC:

   360                     ret = GetAlsBlockedL( aTsyReqHandle,

   361                         REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*,

   362                         aPackage.Ptr1() ) );

   363                     break;

   364                 // Set Alternative Line Service Blocked

   365                 case ECustomSetAlsBlockedIPC:

   366                     ret = SetAlsBlockedL( aTsyReqHandle,

   367                         REINTERPRET_CAST( RMmCustomAPI::TSetAlsBlock*,

   368                         aPackage.Ptr1() ) );

   369                     break;

   370                 // Notify Als Blocked Change

   371                 case ECustomNotifyAlsBlockedChangedIPC:

   372                     ret = NotifyAlsBlockedChanged (

   373                         REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*,

   374                         aPackage.Ptr1() ) );

   375                     break;

   376                 // Get ALS pp support

   377                 case ECustomCheckAlsPpSupportIPC:

   378                     ret = GetAlsPpSupportL( aTsyReqHandle,

   379                         REINTERPRET_CAST( RMmCustomAPI::TAlsSupport*,

   380                                           aPackage.Ptr1() ) );

   381                     break;

   382                 // Get ciphering information

   383                 case ECustomGetCipheringInfoIPC:

   384                     ret = GetCipheringInfoL( aTsyReqHandle,

   385                         REINTERPRET_CAST( RMmCustomAPI::TCipheringInfo*,

   386                         aPackage.Ptr1() ) );

   387                     break;

   388                 // Notify ciphering information change

   389                 case ECustomNotifyCipheringInfoChangeIPC:

   390                     ret = NotifyCipheringInfoChange(

   391                         REINTERPRET_CAST(RMmCustomAPI::TCipheringInfo*,

   392                         aPackage.Ptr1() ) );

   393                     break;

   394                 // Notify NSPS status

   395                 case ECustomNotifyNSPSStatusIPC:

   396                     ret = NotifyNSPSStatus (

   397                          REINTERPRET_CAST(RMmCustomAPI::TNspsStatus*,

   398                          aPackage.Ptr1() ) );

   399                     break;

   400                 // Wake up network from NSPS status

   401                 case ECustomNetWakeupIPC:

   402                     ret = NetWakeupL( aTsyReqHandle );

   403                     break;

   404                 case ECustomClearCallBlackListIPC:

   405                     ret = ClearCallBlackListL ( aTsyReqHandle );

   406                     break;

   407                 // SS additional info notification

   408                 case ECustomSsAdditionalInfoNotificationIPC:

   409                      ret = SsAdditionalInfoNotification(

   410                         REINTERPRET_CAST( RMmCustomAPI::TSsAdditionalInfo*,

   411                         aPackage.Ptr1() ) );

   412                      break;

   413                 // Get the air time duration

   414                 case ECustomGetAirTimeDurationIPC:

   415                     ret = GetAirTimeDuration ( aTsyReqHandle,

   416                         REINTERPRET_CAST( TTimeIntervalSeconds*,

   417                         aPackage.Ptr1() ) );

   418                     break;

   419                 // Check emergency number

   420                 case ECustomCheckEmergencyNumberIPC:

   421                     ret = CheckEmergencyNumberL( aTsyReqHandle,

   422                         REINTERPRET_CAST( RMmCustomAPI::TEmerNumberCheckMode*,

   423                             aPackage.Ptr1() ),

   424                         REINTERPRET_CAST( TBool*, aPackage.Ptr2() ) );

   425                     break;

   426                 // Get Network Operator Name

   427                 case ECustomGetNetworkProviderNameIPC:

   428                     ret = GetNetworkOperatorNameL( aPackage.Des1u() );

   429                     break;

   430                 // Get two digit dial support

   431                 case ECustomCheckTwoDigitDialSupportIPC:

   432                     ret = CheckTwoDigitDialSupportL( aTsyReqHandle,

   433                         REINTERPRET_CAST( RMmCustomAPI::TTwoDigitDialSupport*,

   434                         aPackage.Ptr1() ) );

   435                     break;

   436                 // Notify when phonebook cache is ready

   437                 case ECustomNotifyPndCacheReadyIPC:

   438                     ret = NotifyPhoneBookCacheReady( aTsyReqHandle,

   439                         REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

   440                     break;

   441                 // Get phonebook cache status

   442                 case ECustomGetPndCacheStatusIPC:

   443                     ret = GetPndCacheStatus( aTsyReqHandle,

   444                         REINTERPRET_CAST( RMmCustomAPI::TPndCacheStatus*,

   445                             aPackage.Ptr1() ),

   446                         REINTERPRET_CAST( const TName*, aPackage.Des2u() ) );

   447                     break;

   448                 // Get the programmable operator name

   449                 case ECustomGetOperatorNameIPC:

   450                     ret = GetOperatorNameL( aTsyReqHandle,

   451                         REINTERPRET_CAST( RMmCustomAPI::TOperatorNameInfo*,

   452                         aPackage.Ptr1() ) );

   453                     break;

   454                 // Notify SS Network event

   455                 case ECustomNotifySsNetworkEventIPC:

   456                     ret = NotifySsNetworkEvent(

   457                         REINTERPRET_CAST( RMmCustomAPI::TSsTypeAndMode*,

   458                         aPackage.Ptr1() ),

   459                         REINTERPRET_CAST( RMmCustomAPI::TSsInfo*,

   460                         aPackage.Ptr2() ) );

   461                     break;

   462                 // Get the programmable operator logo

   463                 case ECustomGetProgrammableOperatorLogoIPC:

   464                     ret = GetProgrammableOperatorLogoL( aTsyReqHandle,

   465                         REINTERPRET_CAST( RMmCustomAPI::TOperatorId*,

   466                         aPackage.Ptr1() ),

   467                         REINTERPRET_CAST( RMmCustomAPI::TOperatorLogo*,

   468                         aPackage.Ptr2() ) );

   469                     break;

   470                 // Sat refresh complete notification

   471                 case ECustomSatRefreshCompleteNotificationIPC:

   472                     ret = SatRefreshCompleteNotification();

   473                     break;

   474                 // Reset the net server

   475                 case ECustomResetNetServerIPC:

   476                     ret = ResetNetServerL( aTsyReqHandle );

   477                     break;

   478                 // Notify Network Connection Failure

   479                 case ECustomNotifyNetworkConnectionFailureIPC:

   480                     ret = NotifyNetworkConnectionFailure( );

   481                     break;

   482                 // Get supported network modes

   483                 case ECustomGetSystemNetworkModesIPC:

   484                     ret = GetSystemNetworkModesL( aTsyReqHandle,

   485                         REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) );

   486                     break;

   487                 // Set system network mode

   488                 case ECustomSetSystemNetworkModeIPC:

   489                     ret = SetSystemNetworkModeL( aTsyReqHandle,

   490                         REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

   491                         aPackage.Ptr1()) );

   492                     break;

   493                 // Get current system network mode

   494                 case ECustomGetCurrentSystemNetworkModesIPC:

   495                     ret = GetCurrentSystemNetworkModeL( aTsyReqHandle,

   496                         REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) );

   497                     break;

   498                 // Get supported network bands

   499                 case ECustomGetBandSelectionIPC:

   500                     ret = GetSystemNetworkBandL( aTsyReqHandle,

   501                         REINTERPRET_CAST(RMmCustomAPI::TBandSelection*,

   502                         aPackage.Ptr1()),

   503                         REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

   504                         aPackage.Ptr2()) );

   505                     break;

   506                 // Set system network band

   507                 case ECustomSetBandSelectionIPC:

   508                     ret = SetSystemNetworkBandL( aTsyReqHandle,

   509                         REINTERPRET_CAST(RMmCustomAPI::TBandSelection*,

   510                         aPackage.Ptr1() ),

   511                         REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

   512                         aPackage.Ptr2() ) );

   513                     break;

   514                 // Notify SS request complete

   515                 case ECustomNotifySsRequestCompleteIPC:

   516                     ret = SsRequestCompleteNotification(

   517                          REINTERPRET_CAST( TInt*, aPackage.Ptr1() ) );

   518                     break;

   519                 case ECustomGetLifeTimeIPC:

   520                     ret = GetLifeTimeL( aTsyReqHandle, aPackage.Des1n() );

   521                     break;

   522                 case ECustomReadSimFileIPC:

   523                     ret = GetSimFileInfoL(aTsyReqHandle, aPackage.Des1n(),

   524                         aPackage.Des2n());

   525                     break;

   526                 // Get 3G phonebook info

   527                 case EGet3GPBInfoIPC:

   528                     ret = Get3GPBInfo ( aTsyReqHandle,

   529                         REINTERPRET_CAST( RMmCustomAPI::T3GPBInfo*,

   530                         aPackage.Ptr1() ) );

   531                     break;

   532                 case ECustomSetDriveModeIPC:

   533                     ret = SetDriveModeL( aTsyReqHandle,

   534                         REINTERPRET_CAST( RMmCustomAPI::TSetDriveMode*,

   535                         aPackage.Ptr1() ) );

   536                     break;

   537                 case ECustomSetSimMessageStatusReadIPC:

   538                     ret = SetSimMessageStatusReadL( aTsyReqHandle,

   539                         *( REINTERPRET_CAST(TTime*, aPackage.Ptr1() ) ),

   540                         *( REINTERPRET_CAST(TInt*, aPackage.Ptr2() ) ) );

   541                     break;

   542                 case ECustomNotifyRauEventIPC:

   543                     ret = NotifyRauEvent(

   544                         REINTERPRET_CAST( RMmCustomAPI::TRauEventStatus*,

   545                         aPackage.Ptr1() ) );

   546                     break;

   547                 case ECustomReadHSxPAStatusIPC:

   548                     ret = ReadHSxPAStatusL( aTsyReqHandle, REINTERPRET_CAST(

   549                         RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) );

   550                     break;

   551                 case ECustomWriteHSxPAStatusIPC:

   552                     ret = WriteHSxPAStatusL( aTsyReqHandle, REINTERPRET_CAST(

   553                         RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) );

   554                     break;

   555                 case ECustomNotifyHSxPAStatusIPC:

   556                     ret = NotifyHSxPAStatus( REINTERPRET_CAST(

   557                         RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) );

   558                     break;

   559                 case ECustomGetIccCallForwardingStatusIPC:

   560                 	ret = GetIccCallForwardingStatusL( aTsyReqHandle,

   561                     	aPackage.Des1n() );

   562                 	break;

   563                 case ECustomNotifyIccCallForwardingStatusChangeIPC:

   564                     ret = NotifyIccCallForwardingStatusChange(

   565                     	aPackage.Des1n() );

   566                     break;

   567                 case ECustomNotifyCellInfoChangeIPC:

   568                     ret = NotifyCellInfoChange( aPackage.Des1n() );

   569                     break;

   570                 case ECustomGetCellInfoIPC:

   571                     ret = GetCellInfoL( aPackage.Des1n() );

   572                     break;

   573                 case ECustomGetServiceTableSupportbyApplicationIPC:

   574                     ret = GetUSIMServiceSupportL( aTsyReqHandle, 

   575                         REINTERPRET_CAST( RMmCustomAPI::TAppSupport*, 

   576                         aPackage.Ptr1() ) );

   577                     break;

   578                 case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   579                     ret = NotifyRemoteAlertingToneStatusChange(

   580                         REINTERPRET_CAST( 

   581                         RMmCustomAPI::TRemoteAlertingToneStatus*,

   582                         aPackage.Ptr1() ) );

   583                     break;

   584                 default:

   585                     // ret is already set as KErrNotSupported

   586 TFLOGSTRING2("TSY: CMmCustomTsy::DoExtFuncL unsupported ipc=%d", aIpc);

   587                     break;

   588                 }

   589 

   590             // save request handle

   591             if ( ECustomTsyReqHandleUnknown != iReqHandleType )

   592                 {

   593 #ifdef REQHANDLE_TIMER

   594                 // set timer for the request

   595                 SetTypeOfResponse ( iReqHandleType, aTsyReqHandle );

   596 #else

   597                 iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType,

   598                     aTsyReqHandle );

   599 #endif // REQHANDLE_TIMER

   600                 }

   601             }

   602         }

   603 

   604     return ret;

   605     }

   606 

   607 // ---------------------------------------------------------------------------

   608 // CMmCustomTsy::RegisterNotification

   609 // Called when the server recognises that this notification is being posted

   610 // for the first time on this sub-session object. It enables the TSY to

   611 // "turn on" any regular notification messages that it may receive from DOS.

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

   613 // ---------------------------------------------------------------------------

   614 //

   615 TInt CMmCustomTsy::RegisterNotification(

   616     const TInt aIpc )

   617     {

   618     TInt ret ( KErrNotSupported );

   619 

   620     switch( aIpc )

   621         {

   622         case ECustomNotifyRauEventIPC:

   623         case ECustomNotifyDtmfEventIPC:

   624         case ECustomNotifyAlsBlockedChangedIPC:

   625         case ECustomNotifyCipheringInfoChangeIPC:

   626         case ECustomNotifyNSPSStatusIPC:

   627         case ECustomSsAdditionalInfoNotificationIPC:

   628         case ECustomNotifySsRequestCompleteIPC:

   629         case ECustomNotifyPndCacheReadyIPC:

   630         case ECustomNotifySsNetworkEventIPC:

   631         case ECustomSatRefreshCompleteNotificationIPC:

   632         case ECustomNotifyNetworkConnectionFailureIPC:

   633         case ECustomNotifyHSxPAStatusIPC:

   634         case ECustomNotifyIccCallForwardingStatusChangeIPC:

   635         case ECustomNotifyCellInfoChangeIPC:

   636         case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   637             ret =  KErrNone;

   638             break;

   639 

   640         default:

   641             if ( iMmCustomVendorExt->SupportingIPC( aIpc ) )

   642                 {

   643                 ret = iMmCustomVendorExt->RegisterNotification( aIpc );

   644                 }

   645             else

   646                 {

   647                 ret = CMmTsyBase::RegisterNotification( aIpc );

   648                 }

   649             break;

   650         }

   651 

   652     return ret;

   653     }

   654 

   655 // ---------------------------------------------------------------------------

   656 // CMmCustomTsy::DeregisterNotification

   657 // Called when the server recognises that this notification will not be posted

   658 // again because the last client to have a handle on this sub-session object

   659 // has just closed the handle. It enables the TSY to "turn off" any regular

   660 // notification messages that it may receive from DOS.

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

   662 // ---------------------------------------------------------------------------

   663 //

   664 TInt CMmCustomTsy::DeregisterNotification(

   665     const TInt aIpc )

   666     {

   667     TInt ret ( KErrNotFound );

   668 

   669     switch( aIpc )

   670         {

   671         case ECustomNotifyRauEventIPC:

   672         case ECustomNotifyDtmfEventIPC:

   673         case ECustomNotifyAlsBlockedChangedIPC:

   674         case ECustomNotifyCipheringInfoChangeIPC:

   675         case ECustomNotifyNSPSStatusIPC:

   676         case ECustomSsAdditionalInfoNotificationIPC:

   677         case ECustomNotifySsRequestCompleteIPC:

   678         case ECustomNotifyPndCacheReadyIPC:

   679         case ECustomNotifySsNetworkEventIPC:

   680         case ECustomSatRefreshCompleteNotificationIPC:

   681         case ECustomNotifyNetworkConnectionFailureIPC:

   682         case ECustomNotifyHSxPAStatusIPC:

   683         case ECustomNotifyIccCallForwardingStatusChangeIPC:

   684         case ECustomNotifyCellInfoChangeIPC:

   685         case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   686             ret =  KErrNone;

   687             break;

   688         default:

   689             if ( iMmCustomVendorExt->SupportingIPC( aIpc ) )

   690                 {

   691                 ret = iMmCustomVendorExt->DeregisterNotification( aIpc );

   692                 }

   693             else

   694                 {

   695                 ret = CMmTsyBase::DeregisterNotification( aIpc );

   696                 }

   697             break;

   698         }

   699 

   700     return ret;

   701     }

   702 

   703 // ---------------------------------------------------------------------------

   704 // CMmCustomTsy::ReqModeL

   705 // Returns request mode for given IPC. If the IPC number belongs to some of

   706 // the Custom API functions.

   707 // Possible return values:

   708 //     tsy has own buffering            =0x00000000  

   709 //     KReqModeMultipleCompletionEnabled=0x00000001

   710 //     KReqModeFlowControlObeyed=0x00000002

   711 //     KReqModeRePostImmediately=0x00000004

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

   713 // ---------------------------------------------------------------------------

   714 //

   715 CTelObject::TReqMode CMmCustomTsy::ReqModeL(

   716     const TInt aIpc )

   717     {

   718     CTelObject::TReqMode ret = 0;

   719 

   720     switch ( aIpc )

   721         {

   722         // methods using DOS

   723         case ECustomNetWakeupIPC:

   724         case ECustomGetNetworkProviderNameIPC:

   725         case ECustomCheckTwoDigitDialSupportIPC:

   726         case ECustomGetOperatorNameIPC:

   727         case ECustomResetNetServerIPC:

   728             ret = KReqModeFlowControlObeyed;

   729             break;

   730             

   731         //TSYs wishing to implement their own buffering can return 0 

   732         case ECustomSetAlsBlockedIPC:            

   733         case ECustomSetDriveModeIPC:            

   734             ret = 0;

   735             break;

   736 

   737         // Notifications

   738         case ECustomNotifyRauEventIPC:

   739         case ECustomNotifyDtmfEventIPC:

   740         case ECustomNotifyAlsBlockedChangedIPC:

   741         case ECustomNotifyCipheringInfoChangeIPC:

   742         case ECustomNotifyNSPSStatusIPC:

   743         case ECustomSsAdditionalInfoNotificationIPC:

   744         case ECustomNotifyPndCacheReadyIPC:

   745         case ECustomNotifySsNetworkEventIPC:

   746         case ECustomSatRefreshCompleteNotificationIPC:

   747         case ECustomNotifyNetworkConnectionFailureIPC:

   748         case ECustomNotifySsRequestCompleteIPC:

   749         case ECustomNotifyHSxPAStatusIPC:

   750         case ECustomNotifyIccCallForwardingStatusChangeIPC:

   751         case ECustomNotifyCellInfoChangeIPC:

   752         case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   753             ret = KReqModeRePostImmediately |

   754                   KReqModeMultipleCompletionEnabled;

   755             break;

   756 

   757         // methods that are using DOS but have own flow control system

   758         case ECustomGetProgrammableOperatorLogoIPC:

   759         case ECustomTerminateCallIPC:

   760         case ECustomCheckEmergencyNumberIPC:

   761         case ECustomCheckAlsPpSupportIPC:

   762         case ECustomGetAlsBlockedIPC:

   763         case ECustomGetCipheringInfoIPC:

   764         case ECustomClearCallBlackListIPC:

   765         case ECustomGetSystemNetworkModesIPC:

   766         case ECustomSetSystemNetworkModeIPC:

   767         case ECustomGetCurrentSystemNetworkModesIPC:

   768         case ECustomReadHSxPAStatusIPC:

   769         case ECustomWriteHSxPAStatusIPC:

   770         case ECustomGetIccCallForwardingStatusIPC:

   771         case ECustomGetCellInfoIPC:

   772         case ECustomGetBandSelectionIPC:

   773         case ECustomSetBandSelectionIPC:

   774 

   775         // methods not using DOS

   776         case ECustomCallOriginIPC:

   777         case ECustomGetDiagnosticOctetsIPC:

   778         case ECustomGetAirTimeDurationIPC:

   779         case ECustomGetRemoteAlertingToneStatusIPC:

   780         case ECustomGetPndCacheStatusIPC:

   781         case ECustomGetLifeTimeIPC:

   782         case ECustomReadSimFileIPC:

   783         case EGet3GPBInfoIPC:

   784         case EMobilePhoneIMSAuthenticate:

   785         case ECustomGetSimAuthenticationDataIPC:

   786        	case ECustomGetServiceTableSupportbyApplicationIPC:

   787 

   788         // from Security Tsy

   789         case ECustomCheckSecurityCodeIPC:

   790         case ECustomIsBlockedIPC:

   791         case ECustomDisablePhoneLockIPC:

   792         case ECustomGetActivePinIPC:

   793         case ECustomSetSimMessageStatusReadIPC:

   794             ret = 0;

   795             break;

   796         default:

   797             if ( iMmCustomVendorExt->SupportingIPC( aIpc ) )

   798                 {

   799                 ret = iMmCustomVendorExt->ReqModeL( aIpc );

   800                 }

   801             else

   802                 {

   803                 ret = CMmTsyBase::ReqModeL ( aIpc );

   804                 }

   805             break;

   806         }

   807 

   808     return ret;

   809     }

   810 

   811 // ---------------------------------------------------------------------------

   812 // CMmCustomTsy::NumberOfSlotsL

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

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

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

   816 //

   817 TInt CMmCustomTsy::NumberOfSlotsL(

   818     const TInt aIpc )

   819     {

   820     TInt numberOfSlots ( KMmCustomDefaultSlots );

   821 

   822     switch ( aIpc )

   823         {

   824         case ECustomNotifyDtmfEventIPC:

   825             numberOfSlots = KMmCustomNotifyDtmfEventSlots;

   826             break;

   827         case ECustomNotifyRauEventIPC:

   828         case ECustomNotifyAlsBlockedChangedIPC:

   829         case ECustomNotifyCipheringInfoChangeIPC:

   830         case ECustomNotifyNSPSStatusIPC:

   831         case ECustomSsAdditionalInfoNotificationIPC:

   832         case ECustomNotifySsRequestCompleteIPC:

   833         case ECustomNotifyPndCacheReadyIPC:

   834         case ECustomNotifySsNetworkEventIPC:

   835         case ECustomSatRefreshCompleteNotificationIPC:

   836         case ECustomNotifyNetworkConnectionFailureIPC:

   837         case ECustomNotifyHSxPAStatusIPC:

   838         case ECustomNotifyIccCallForwardingStatusChangeIPC:

   839         case ECustomNotifyCellInfoChangeIPC:

   840         case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   841             break;

   842 

   843         default:

   844             if ( iMmCustomVendorExt->SupportingIPC( aIpc ) )

   845                 {

   846                 numberOfSlots = iMmCustomVendorExt->NumberOfSlotsL( aIpc );

   847                 }

   848             else

   849                 {

   850                 numberOfSlots = CMmTsyBase:: NumberOfSlotsL( aIpc );

   851                 }

   852             break;

   853         }

   854 

   855     return numberOfSlots;

   856     }

   857 

   858 // ---------------------------------------------------------------------------

   859 // CMmCustomTsy::GetRequiredPlatSecCaps

   860 // ETel server calls this method to find out capabilities of custom IPCs.

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

   862 // ---------------------------------------------------------------------------

   863 //

   864 TSecurityPolicy CMmCustomTsy::GetRequiredPlatSecCaps(

   865     const TInt aIpc )

   866     {

   867 TFLOGSTRING2( "TSY: CMmCustomTsy::GetRequiredPlatSecCaps ipc=%d", aIpc );

   868     // assume fail as default return value

   869     TSecurityPolicy policy( TSecurityPolicy::EAlwaysFail );

   870 

   871     // deal with cancellations

   872     TInt ipc ( aIpc );

   873     if (ipc >= KIpcCustomExt + EMobileCancelOffset)

   874         {

   875         ipc  -= EMobileCancelOffset;

   876 TFLOGSTRING2("TSY: CMmCustomTsy::GetRequiredPlatSecCaps cancel for ipc=%d", ipc);

   877         }

   878 

   879     switch ( ipc )

   880         {

   881         case ECustomNotifyRauEventIPC:

   882         case ECustomSatRefreshCompleteNotificationIPC: // To be removed

   883         case ECustomNotifyPndCacheReadyIPC:

   884         case ECustomGetPndCacheStatusIPC:

   885         case EGet3GPBInfoIPC:

   886         case ECustomNotifyDtmfEventIPC:

   887         case ECustomGetRemoteAlertingToneStatusIPC:

   888         case ECustomCallOriginIPC:

   889         case ECustomGetAlsBlockedIPC:

   890         case ECustomNotifyAlsBlockedChangedIPC:

   891         case ECustomCheckAlsPpSupportIPC:

   892         case ECustomCheckEmergencyNumberIPC:

   893         case ECustomGetCipheringInfoIPC:

   894         case ECustomNotifyCipheringInfoChangeIPC:

   895         case ECustomNotifyNSPSStatusIPC:

   896         case ECustomNotifyProgrammableOperatorLogoChangeIPC:

   897         case ECustomNotifyNetworkConnectionFailureIPC:

   898         case ECustomNotifySsRequestCompleteIPC:

   899         case ECustomGetActivePinIPC:

   900         case ECustomGetSystemNetworkModesIPC:

   901         case ECustomGetCurrentSystemNetworkModesIPC:

   902         case ECustomGetATRIPC:

   903         case ECustomNotifySimCardStatusIPC:

   904         case ECustomGetSimCardReaderStatusIPC:

   905         case ECustomNotifyHSxPAStatusIPC:

   906         case ECustomNotifyIccCallForwardingStatusChangeIPC:

   907         case ECustomNotifyCellInfoChangeIPC:

   908         case ECustomGetBandSelectionIPC:

   909         case ECustomNotifyRemoteAlertingToneStatusChangeIPC:

   910 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=None");

   911             policy = TSecurityPolicy( TSecurityPolicy::EAlwaysPass );

   912             break;

   913 

   914         // NetworkControl

   915         case ECustomResetNetServerIPC:

   916         case ECustomSetSystemNetworkModeIPC:

   917         case ECustomSimWarmResetIPC:

   918         case ECustomSetBandSelectionIPC:

   919 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl");

   920             policy = TSecurityPolicy( ECapabilityNetworkControl );

   921             break;

   922 

   923         // NetworkControl, PowerMgmt

   924         case ECustomPowerSimOnIPC:

   925         case ECustomPowerSimOffIPC:

   926 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl, PowerMgmt");

   927             policy = TSecurityPolicy( ECapabilityNetworkControl,

   928                 ECapabilityPowerMgmt );

   929             break;

   930 

   931         // NetworkControl, ReadDeviceData

   932         case ECustomReleaseFileIPC:

   933         case ECustomRestartFileIPC:

   934 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl, ReadDeviceData");

   935             policy = TSecurityPolicy( ECapabilityNetworkControl,

   936                 ECapabilityReadDeviceData );

   937             break;

   938 

   939         // NetworkServices

   940         case ECustomTerminateCallIPC:

   941         case ECustomCancelUssdSessionIPC:

   942 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkServices");

   943             policy = TSecurityPolicy( ECapabilityNetworkServices );

   944             break;

   945 

   946         // NetworkServices, WriteDeviceData

   947         case ECustomSetDriveModeIPC:

   948 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkServices, WriteDeviceData");

   949             policy = TSecurityPolicy( ECapabilityNetworkServices,

   950                 ECapabilityWriteDeviceData );

   951             break;

   952 

   953         // ReadDeviceData

   954         case EReadViagHomeZoneParamsIPC:

   955         case ECustomGetNetworkProviderNameIPC:

   956         case ECustomGetDiagnosticOctetsIPC:

   957         case ECustomGetLifeTimeIPC:

   958         case ECustomGetOperatorNameIPC:

   959         case ECustomGetProgrammableOperatorLogoIPC:

   960         case ECustomSsAdditionalInfoNotificationIPC:

   961         case ECustomIsBlockedIPC:

   962         case ECustomCheckTwoDigitDialSupportIPC:

   963         case ECustomNotifyEGprsInfoChange:

   964         case ECustomGetEGprsInfo:

   965         case EMobilePhoneIMSAuthenticate:

   966         case ECustomReadHSxPAStatusIPC:

   967         case ECustomGetIccCallForwardingStatusIPC:

   968         case ECustomGetCellInfoIPC:

   969 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData");

   970             policy = TSecurityPolicy( ECapabilityReadDeviceData );

   971             break;

   972 

   973         // ReadDeviceData, Location

   974         case EReadViagHomeZoneCacheIPC:

   975 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, Location");

   976             policy = TSecurityPolicy( ECapabilityReadDeviceData,

   977                 ECapabilityLocation );

   978             break;

   979 

   980         // ReadDeviceData, ReadUserData

   981         case ECustomNotifySsNetworkEventIPC:

   982 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy= ReadDeviceData, ReadUserData");

   983             policy = TSecurityPolicy( ECapabilityReadDeviceData,

   984                 ECapabilityReadUserData );

   985             break;

   986 

   987         // ReadDeviceData, ReadUserData, Location

   988         case ECustomReadSimFileIPC:

   989 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, ReadUserData, Location");

   990             policy = TSecurityPolicy( ECapabilityReadDeviceData,

   991                 ECapabilityReadUserData,

   992                 ECapabilityLocation );

   993             break;

   994 

   995         // ReadDeviceData, ReadUserData, WriteUserData, NetworkControl

   996         case ECustomGetSimAuthenticationDataIPC:

   997 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, ReadUserData, WriteUserData, NetworkControl");

   998             policy = TSecurityPolicy( ECapabilityReadDeviceData,

   999                 ECapabilityReadUserData,

  1000                 ECapabilityWriteUserData,

  1001                 ECapabilityNetworkControl );

  1002             break;

  1003 

  1004        	case ECustomGetServiceTableSupportbyApplicationIPC:

  1005 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData");

  1006             policy = TSecurityPolicy( ECapabilityReadDeviceData );

  1007             break;

  1008         // ReadDeviceData, WriteDeviceData, ReadUserData, WriteUserData,

  1009         // Location, NetworkServices, NetworkControl

  1010         case ECustomSendAPDUReqIPC:

  1011         case ECustomSendAPDUReqV2IPC:

  1012 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, WriteDeviceData, ReadUserData, WriteUserData, Location, NetworkServices, NetworkControl");

  1013             policy = TSecurityPolicy( ECapabilityReadDeviceData,

  1014                 ECapabilityWriteDeviceData,

  1015                 ECapabilityReadUserData,

  1016                 ECapabilityWriteUserData,

  1017                 ECapabilityLocation,

  1018                 ECapabilityNetworkServices,

  1019                 ECapabilityNetworkControl  );

  1020             break;

  1021 

  1022         // ReadUserData

  1023         case ECustomStartSimCbTopicBrowsingIPC:

  1024         case ECustomGetNextSimCbTopicIPC:

  1025         case ECustomGetAirTimeDurationIPC:

  1026 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadUserData");

  1027             policy = TSecurityPolicy( ECapabilityReadUserData );

  1028             break;

  1029 

  1030         // WriteDeviceData

  1031         case ECustomSetAlwaysOnMode:

  1032         case ECustomSimLockActivateIPC:

  1033         case ECustomSimLockDeActivateIPC:

  1034         case ECustomSetAlsBlockedIPC:

  1035         case ECustomClearCallBlackListIPC:

  1036         case ECustomNetWakeupIPC:

  1037         case ECustomCheckSecurityCodeIPC:

  1038         case ECustomDisablePhoneLockIPC:

  1039         case ECustomSetSimMessageStatusReadIPC:

  1040         case ECustomWriteHSxPAStatusIPC:

  1041 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData");

  1042             policy = TSecurityPolicy( ECapabilityWriteDeviceData );

  1043             break;

  1044 

  1045         // WriteDeviceData, Location

  1046         case EWriteViagHomeZoneCacheIPC:

  1047 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData, Location");

  1048             policy = TSecurityPolicy( ECapabilityWriteDeviceData,

  1049                 ECapabilityLocation );

  1050             break;

  1051 

  1052         // WriteUserData

  1053         case ECustomDeleteSimCbTopicIPC:

  1054 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteUserData");

  1055             policy = TSecurityPolicy( ECapabilityWriteUserData );

  1056             break;

  1057 

  1058         // WriteDeviceData

  1059         case EWriteViagHomeZoneUHZIUESettingsIPC:

  1060 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData");

  1061             policy = TSecurityPolicy( ECapabilityWriteDeviceData );

  1062             break;

  1063         default:

  1064             if ( iMmCustomVendorExt->SupportingIPC(ipc) )

  1065                 {

  1066                 policy = iMmCustomVendorExt->GetRequiredPlatSecCaps(ipc);

  1067                 }

  1068             else

  1069                 {

  1070                 // if none of the above then we end up here,

  1071                 // as a default we already have caps as alwaysfail.

  1072 TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=AlwaysFail");

  1073                 }

  1074             break;

  1075         }

  1076 

  1077     return policy;

  1078     }

  1079 

  1080 // ---------------------------------------------------------------------------

  1081 // CMmCustomTsy::CancelService

  1082 // When the clients close their sub-sessions (eg. by calling RPhone::Close),

  1083 // they may not have cancelled all their outstanding asynchronous requests

  1084 // before closing. It is up to the ETel server to clean up in this situation,

  1085 // so the server will find the list of outstanding requests related to that

  1086 // sub-session object and pass these outstanding IPC request numbers, one at

  1087 // a time, to the CancelService function in the TSY.

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

  1089 // ---------------------------------------------------------------------------

  1090 //

  1091 TInt CMmCustomTsy::CancelService(

  1092     const TInt aIpc,

  1093     const TTsyReqHandle aTsyReqHandle )

  1094     {

  1095     TInt ret ( KErrGeneral );

  1096 

  1097     // When the clients close their sub-sessions (eg. by calling

  1098     // RPhone::Close), they may not have cancelled all their outstanding

  1099     // asynchronous requests before closing. It is up to the ETel server to

  1100     // clean up in this situation, so the server will find the list of

  1101     // outstanding requests related to that sub-session object and pass these

  1102     // outstanding IPC request numbers, one at a time, to the CancelService

  1103     // function in the TSY.

  1104 

  1105     switch ( aIpc )

  1106         {

  1107         case ECustomTerminateCallIPC:

  1108         case ECustomSetAlsBlockedIPC:

  1109         case ECustomNetWakeupIPC:

  1110         case ECustomClearCallBlackListIPC:

  1111         case ECustomResetNetServerIPC:

  1112         case ECustomGetPndCacheStatusIPC:

  1113         case ECustomSetDriveModeIPC:

  1114         case ECustomSetBandSelectionIPC:	

  1115         case ECustomSetSystemNetworkModeIPC:            

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

  1117             // cancel it. The best thing for the TSY to do in

  1118             // this case is to proceed as though the Cancel never happened.

  1119             // The server's call to the TSY cancel function will return

  1120             // synchronously. The TSY then continues to wait for the methods

  1121             // acknowledgement and when it receives it, the TSY will complete

  1122             // the original request.

  1123             ret = KErrNone;

  1124             break;

  1125         case ECustomNotifyRauEventIPC:

  1126             ret = NotifyRauEventCancel();

  1127             break;

  1128         case ECustomNotifyDtmfEventIPC:

  1129             ret = NotifyDtmfEventCancel( aTsyReqHandle );

  1130             break;

  1131         case ECustomGetAlsBlockedIPC:

  1132             ret = GetAlsBlockedCancel ();

  1133             break;

  1134         case ECustomGetCipheringInfoIPC: