diff -r 000000000000 -r 094583676ce7 IMPSengine/engsrv/src/impssrvutils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/IMPSengine/engsrv/src/impssrvutils.cpp Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,1069 @@ +/* +* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test utilities for WV engine +* +* +*/ + + +// INCLUDE FILES +#include +#include +#include "impsservercommon.h" +#include "impsutils.h" +#include "impserrors.h" +#include "impsservices.h" +#include "impssrvutils.h" +#include "impskey.h" +#include "impssdatautils.h" +#include "impsfields.h" +#include "wvengineinternalcrkeys.h" + +// MACROS +#ifdef _DEBUG +#define _IMPS_LOGGING_ +#endif + +// CONSTANTS +#ifdef _DEBUG +_LIT8( KImpsIniPollTime, "PollTime" ); +_LIT8( KImpsIniXmlLog, "XmlLog" ); +_LIT8( KImpsIniXmlPollingLog, "XmlPollingLog" ); +_LIT8( KImpsIniNoWAPSMSCIR, "NoWAPSMSCIR" ); +_LIT8( KImpsIniNoWAPUDPCIR, "NoWAPUDPCIR" ); +_LIT8( KImpsIniNoTCPSCIR, "NoTCPSCIR" ); +_LIT8( KImpsIniNoUDPSCIR, "NoUDPSCIR" ); +_LIT8( KImpsIniKeepAlive, "KeepAlive" ); +_LIT8( KImpsIniCIRModePollTime, "CIRModePollTime" ); +_LIT8( KImpsIniMultiTrans, "MultiTrans" ); +_LIT8( KImpsIniACExpiry, "ACExpiry" ); +_LIT8( KImpsIniGRExpiry, "GRExpiry" ); +_LIT8( KImpsIniPRExpiry, "PRExpiry" ); +_LIT8( KImpsIniFUExpiry, "FUExpiry" ); +_LIT8( KImpsIniIMExpiry, "IMExpiry" ); +_LIT8( KImpsIniPDPExpiry, "PDPExpiry" ); +_LIT8( KImpsIni4WayLogin, "4WayLogin" ); +_LIT8( KImpsIniMaxMessageSize, "MaxMessageSize" ); +#endif + + +// ================= MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------- +// TImpsSrvUtils::InitializeServices +// --------------------------------------------------------- +// +void TImpsSrvUtils::InitializeServices( + TImpsServices& aServices, TBool aReactive ) + { + + // clear the service tree + Mem::FillZ( &aServices, sizeof( TImpsServices ) ); + + // IM Send NewMessage and receive are requested plus IMAuthFunc + TImpsFeature* feat = aServices.Feature( EIMFeat ); + feat->SetSupported( ETrue ); + feat->SetFunction( EAllFuncs , ETrue ); + feat->SetCapability( KImpsServiceNEWM | KImpsServiceGLBLU + | KImpsServiceBLENT , ETrue ); + + // All group features are requested + feat = aServices.Feature( EGroupFeat ); + feat->SetSupported( ETrue ); + feat->SetFunction( EAllFuncs, ETrue ); + feat->SetCapability( 0xFFFFFFFF , ETrue ); //lint !e569 + + // Reactive Presence is optional, if it is supported + // then the entire Presence is supported. + // WV 1.2 contains a new element GETAUT but there is no + // need to handle that separately, since the entire Presence + // is negotiated then. + feat = aServices.Feature( EPresenceFeat ); + feat->SetSupported( ETrue ); + if ( aReactive ) + { + feat->SetFunction( EAllFuncs, ETrue ); + feat->SetCapability( 0xFFFFFFFF , ETrue ); //lint !e569 + } + else + { + // Part of presence features are requested + // PresenceAuth functions has limited support. + feat->SetFunction( EPresenceAuthFunc, ETrue ); + feat->SetCapability( + KImpsServiceGETWL, ETrue ); + feat->SetFunction( EContListFunc, ETrue ); + feat->SetCapability( KImpsServiceGCLI | + KImpsServiceCCLI | KImpsServiceDCLI | KImpsServiceMCLS, ETrue ); + feat->SetFunction( EAttrListFunc, ETrue ); + feat->SetCapability( + KImpsServiceCALI | KImpsServiceDALI | KImpsServiceGALS , ETrue ); + feat->SetFunction( EPresenceDeliverFunc, ETrue ); + feat->SetCapability( KImpsServiceGETPR | KImpsServiceUPDPR, ETrue ); + } + + // Part of fundamental features are requested: + // SearchFunc and InviteFunc supported. + // ServiceFunc not supported. + feat = aServices.Feature( EFundamentalFeat ); + feat->SetSupported( ETrue ); + feat->SetFunction( EInviteFunc, ETrue ); + feat->SetFunction( ESearchFunc , ETrue ); + feat->SetCapability( KImpsServiceINVIT | KImpsServiceCAINV | + KImpsServiceSRCH | KImpsServiceSTSRC, ETrue ); + } + + +// ----------------------------------------------------------------------------- +// TImpsSrvUtils::DiscardServicesL +// --------------------------------------------------------------------------- +void TImpsSrvUtils::DiscardServicesL( + MImpsDataAccessor* aData, + TImpsServices* aServices ) + { + + CImpsKey* myKey = CImpsKey::NewLC(); // <<< myKey + TImpsSDataUtils::AddValuesFromArrayL( + myKey, + KClientServiceResElements, + sizeof( KClientServiceResElements ) / + sizeof( KClientServiceResElements[0] ) ); + + // notice: ignore Client id this time + + // Discareded Functions + myKey->AddL( CREATEKEY( EImpsKeyFunctions, 0 ) ); + if ( !aData->CheckBranchExistenceL( myKey ) ) + { + // Nothing is denied. + CleanupStack::PopAndDestroy( 1 ); + return; + } + + myKey->AddL( CREATEKEY( EImpsKeyWVCSPFeat, 0 ) ); + TInt enumi( 0 ); + TInt index( 0 ); + TImpsKeyType kType; + + if ( aData->CheckBranchExistenceL( myKey ) ) + { + // Check if empty WVCSPFeat. That means deny all. + // Decoder may have inserted the element with empty data although + // it has a child. Therefore RestoreEmptyL cannot be used here. + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // All is denied + TImpsFeature* imF = aServices->Feature( EIMFeat ); + imF->SetSupported( EFalse ); + imF->SetFunction( EAllFuncs, EFalse ); + imF->SetCapability( 0xFFFFFFFF , EFalse ); + + TImpsFeature* prF = aServices->Feature( EPresenceFeat ); + prF->SetSupported( EFalse ); + prF->SetFunction( EAllFuncs, EFalse ); + prF->SetCapability( 0xFFFFFFFF , EFalse ); + + TImpsFeature* funF = aServices->Feature( EFundamentalFeat ); + funF->SetSupported( EFalse ); + funF->SetFunction( EAllFuncs, EFalse ); + funF->SetCapability( 0xFFFFFFFF , EFalse ); + + TImpsFeature* grF = aServices->Feature( EGroupFeat ); + grF->SetSupported( EFalse ); + grF->SetFunction( EAllFuncs, EFalse ); + grF->SetCapability( 0xFFFFFFFF , EFalse ); + CleanupStack::PopAndDestroy( 1 ); + return; + } + + // IM + myKey->AddL( CREATEKEY( EImpsKeyIMFeat, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + TImpsFeature* imF = aServices->Feature( EIMFeat ); + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // Whole IM denied + imF->SetSupported( EFalse ); + imF->SetFunction( EAllFuncs, EFalse ); + imF->SetCapability( 0xFFFFFFFF , EFalse ); + } + else + { + + // Let's check functions too, although server should not send these + // because of we have not ordered them. + myKey->AddL( CREATEKEY( EImpsKeyIMSendFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // EImpsKeyIMSendFunc not supported + imF->SetFunction( EIMSendFunc, EFalse ); + } + // we are not interested in IMSendFunc details now. + } + // IMReceiveFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyIMReceiveFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // EImpsKeyIMReceiveFunc not supported + imF->SetFunction( EIMReceiveFunc, EFalse ); + imF->SetCapability( KImpsServiceNEWM , EFalse ); + } + else + { + // Check if NEWM not supported + myKey->AddL( CREATEKEY( EImpsKeyNEWM , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + imF->SetCapability( KImpsServiceNEWM, EFalse ); + } + myKey->PopL(); + } + } + // IMAuthFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyIMAuthFunc , 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // IMAuthFunc not supported + imF->SetFunction( EIMAuthFunc, EFalse ); + imF->SetCapability( KImpsServiceGLBLU | KImpsServiceBLENT, EFalse ); + } + else + { + // Check if GLBLU not supported + myKey->AddL( CREATEKEY( EImpsKeyGLBLU , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + imF->SetCapability( KImpsServiceGLBLU, EFalse ); + } + // Check if BLENT not supported + myKey->ReplaceLastL( CREATEKEY( EImpsKeyBLENT , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + imF->SetCapability( KImpsServiceBLENT, EFalse ); + } + myKey->PopL(); + } + } + myKey->PopL(); + } + } // IM + + // Presence + + myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceFeat, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + TImpsFeature* prF = aServices->Feature( EPresenceFeat ); + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // Presence totally denied + prF->SetSupported( EFalse ); + prF->SetFunction( EAllFuncs, EFalse ); + prF->SetCapability( 0xFFFFFFFF , EFalse ); + } + else + { + // Check first AttListFunc + myKey->AddL( CREATEKEY( EImpsKeyAttListFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // AttListFunc not supported + prF->SetFunction( EAttrListFunc, EFalse ); + prF->SetCapability( KImpsServiceCALI | KImpsServiceDALI | + KImpsServiceGALS, EFalse ); + } + else + { + // Check CALI + myKey->AddL( CREATEKEY( EImpsKeyCALI , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceCALI, EFalse ); + } + // Check DALI + myKey->ReplaceLastL( CREATEKEY( EImpsKeyDALI , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceDALI, EFalse ); + } + // Check GALS + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGALS , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceGALS, EFalse ); + } + myKey->PopL(); + } + } + // PresenceDeliverFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceDeliverFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // PresenceDeliverFunc not supported + prF->SetFunction( EPresenceDeliverFunc, EFalse ); + prF->SetCapability( KImpsServiceGETPR | KImpsServiceUPDPR, EFalse ); + } + else + { + // Check GETPR + myKey->AddL( CREATEKEY( EImpsKeyGETPR , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceGETPR, EFalse ); + } + // Check UPDPR + myKey->ReplaceLastL( CREATEKEY( EImpsKeyUPDPR , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceUPDPR, EFalse ); + } + myKey->PopL(); + } + } + + // PresenceAuthFunc + // Get the WV version since WV 1.2 includes a brand new + // element GETAUT. + CImpsFields* f = aData->GetImpsFields(); + TImpsCspVersion ver = f->CspVersion(); + myKey->ReplaceLastL( CREATEKEY( EImpsKeyPresenceAuthFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // PresenceAuthFunc not supported + prF->SetFunction( EPresenceAuthFunc, EFalse ); + prF->SetCapability( KImpsServiceGETWL | KImpsServiceREACT | + KImpsServiceCAAUT, EFalse ); + } + else + { + // Check GETWL + myKey->AddL( CREATEKEY( EImpsKeyGETWL, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceGETWL, EFalse ); + } + // Check REACT + myKey->ReplaceLastL( CREATEKEY( EImpsKeyREACT, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceREACT, EFalse ); + } + // Check CAAUT + myKey->ReplaceLastL( CREATEKEY( EImpsKeyCAAUT, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceCAAUT, EFalse ); + } + // Check GETAUT, clear it always in WV 1.1 + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGETAUT, 0 ) ); + if ( ver == EImpsCspVersion11 || + ( aData->RestoreEmptyL( myKey ) ) ) + { + prF->SetCapability( KImpsServiceGETAUT, EFalse ); + } + myKey->PopL(); + } + + // ContactListFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyContListFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // ContactListFunc not supported + prF->SetFunction( EContListFunc, EFalse ); + prF->SetCapability( KImpsServiceGCLI | KImpsServiceCCLI | + KImpsServiceDCLI | KImpsServiceMCLS, EFalse ); + } + else + { + // Check GCLI + myKey->AddL( CREATEKEY( EImpsKeyGCLI, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceGCLI, EFalse ); + } + // Check CCLI + myKey->ReplaceLastL( CREATEKEY( EImpsKeyCCLI, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceCCLI, EFalse ); + } + // Check DCLI + myKey->ReplaceLastL( CREATEKEY( EImpsKeyDCLI, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceDCLI, EFalse ); + } + // Check MCLS + myKey->ReplaceLastL( CREATEKEY( EImpsKeyMCLS, 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + prF->SetCapability( KImpsServiceMCLS, EFalse ); + } + myKey->PopL(); + } + } + } + myKey->PopL(); + } + } // Presence + + // Fundamental + + myKey->ReplaceLastL( CREATEKEY( EImpsKeyFundamentalFeat, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + TImpsFeature* fF = aServices->Feature( EFundamentalFeat ); + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // Fundamental totally denied + fF->SetSupported( EFalse ); + fF->SetFunction( EAllFuncs, EFalse ); + fF->SetCapability( 0xFFFFFFFF , EFalse ); + } + else + { + // Check first SearchFunc + myKey->AddL( CREATEKEY( EImpsKeySearchFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // SearchFunc not supported + fF->SetFunction( ESearchFunc, EFalse ); + fF->SetCapability( KImpsServiceSRCH | KImpsServiceSTSRC, EFalse ); + } + else + { + // Check SRCH + myKey->AddL( CREATEKEY( EImpsKeySRCH , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + fF->SetCapability( KImpsServiceSRCH, EFalse ); + } + // Check STSRC + myKey->ReplaceLastL( CREATEKEY( EImpsKeySTSRC , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + fF->SetCapability( KImpsServiceSTSRC, EFalse ); + } + myKey->PopL(); + } + } + // InviteFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyInviteFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // InviteFunc not supported + fF->SetFunction( EInviteFunc, EFalse ); + fF->SetCapability( KImpsServiceINVIT | KImpsServiceCAINV, EFalse ); + } + else + { + // Check INVIT + myKey->AddL( CREATEKEY( EImpsKeyINVIT , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + fF->SetCapability( KImpsServiceINVIT, EFalse ); + } + // Check CAINV + myKey->ReplaceLastL( CREATEKEY( EImpsKeyCAINV , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + fF->SetCapability( KImpsServiceCAINV, EFalse ); + } + myKey->PopL(); + } + } + myKey->PopL(); + } + // We are not interested in ServiceFunc now + } // Fundamental + + + // Group + TImpsFeature* grF = aServices->Feature( EGroupFeat ); + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupFeat, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // Group totally denied + grF->SetSupported( EFalse ); + grF->SetFunction( EAllFuncs, EFalse ); + grF->SetCapability( 0xFFFFFFFF , EFalse ); + } + else + { + // Check first GroupMgmtFunc + myKey->AddL( CREATEKEY( EImpsKeyGroupMgmtFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // GroupMgmtFunc not supported + grF->SetFunction( EGroupMgmtFunc, EFalse ); + grF->SetCapability( KImpsServiceCREAG | KImpsServiceDELGR | + KImpsServiceGETGP | KImpsServiceSETGP, EFalse ); + } + else + { + // Check CREAG + myKey->AddL( CREATEKEY( EImpsKeyCREAG , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceCREAG, EFalse ); + } + // Check DELGR + myKey->ReplaceLastL( CREATEKEY( EImpsKeyDELGR , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceDELGR, EFalse ); + } + // Check GETGP + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGETGP , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceGETGP, EFalse ); + } + // Check SETGP + myKey->ReplaceLastL( CREATEKEY( EImpsKeySETGP , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceSETGP, EFalse ); + } + myKey->PopL(); + } + } + // GroupUseFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupUseFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // GroupUseFunc not supported + grF->SetFunction( EGroupUseFunc, EFalse ); + grF->SetCapability( KImpsServiceSUBGCN | KImpsServiceGRCHN, EFalse ); + } + else + { + // Check SUBGCN + myKey->AddL( CREATEKEY( EImpsKeySUBGCN , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceSUBGCN, EFalse ); + } + // Check GRCHN + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGRCHN , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceGRCHN, EFalse ); + } + myKey->PopL(); + } + } + // GroupAuthFunc + myKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupAuthFunc, 0 ) ); + if ( aData->CheckBranchExistenceL( myKey ) ) + { + if ( !aData->RestoreAlternativeL( myKey, enumi, index, kType ) ) + { + // GroupAuthFunc not supported + grF->SetFunction( EGroupAuthFunc, EFalse ); + grF->SetCapability( KImpsServiceGETGM | KImpsServiceADDGM | + KImpsServiceRMVGM | KImpsServiceMBRAC | KImpsServiceREJEC, EFalse ); + } + else + { + // Check GETGM + myKey->AddL( CREATEKEY( EImpsKeyGETGM , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceGETGM, EFalse ); + } + // Check ADDGM + myKey->ReplaceLastL( CREATEKEY( EImpsKeyADDGM , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceADDGM, EFalse ); + } + // Check RMVGM + myKey->ReplaceLastL( CREATEKEY( EImpsKeyRMVGM , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceRMVGM, EFalse ); + } + // Check MBRAC + myKey->ReplaceLastL( CREATEKEY( EImpsKeyMBRAC , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceMBRAC, EFalse ); + } + // Check REJEC + myKey->ReplaceLastL( CREATEKEY( EImpsKeyREJEC , 0 ) ); + if ( aData->RestoreEmptyL( myKey ) ) + { + grF->SetCapability( KImpsServiceREJEC, EFalse ); + } + myKey->PopL(); + } + } + myKey->PopL(); + } + } // Group + + + myKey->PopL(); + } + + CleanupStack::PopAndDestroy( 1 ); // >>> myKey + } + + +// --------------------------------------------------------- +// TImpsSrvUtils::CheckServiceL +// --------------------------------------------------------- +void TImpsSrvUtils::CheckServiceL( + TImpsFeatures aFeature, + TImpsServices* aSrvS ) + { + if ( !aSrvS ) + { + User::Leave( KErrNotSupported ); + } + TImpsFeature* srvF = aSrvS->Feature( aFeature ); + if ( !srvF->IsSupported() ) + { + User::Leave( KErrNotSupported ); + } + } + +// --------------------------------------------------------- +// TImpsSrvSettings::TImpsSrvSettings +// --------------------------------------------------------- +// +TImpsSrvSettings::TImpsSrvSettings( /*RFs& aFs*/ ) + : + // iFs ( aFs ), + iPollTime( KImpsPollTime ), + iAliveTime( KImpsAliveTime ), + iMaxPollTime( KImpsMaxPoll ), + iXmlLog( 1 ), + iUDPWAPCIR( 1 ), + iSMSWAPCIR( 1 ), + iTCPSCIR( 1 ), + iUDPSCIR( 1 ), + iAccessExp( KImpsClientExpr ), + iImExp( KImpsClientExpr ), + iPrExp( KImpsPresClientExpr ), + iGrExp( KImpsClientExpr ), + iFuExp( KImpsFundClientExpr ), + iMultiTrans( KImpsMultiTrans ), + iFourWayLogin( ETrue ), + iPDPExpiry( KImpsPDPMaxIdleTime ), + iCIRModePollTime( KImpsCIRModePollTime ), + iMaxMessageSize( KImpsAcceptedContentLength ) + {} + +// --------------------------------------------------------- +// TImpsSrvSettings::ReadStaticSettings +// --------------------------------------------------------- +// +void TImpsSrvSettings::ReadStaticSettings() + { + TInt aux = 0; + // Read Central Repository settings + TRAPD( errx, aux = TImpsDataUtils::GetCenRepIntValueL( KCRUIDWVEngineVariation, KWVEngineDropContextWhileIdle ) ); + if ( !errx ) + { + iPDPExpiry = 60 * aux; + } + TRAP( errx, iFourWayLogin = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineLoginMethod ) ); + TRAP( errx, iPollTime = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEnginePollTime ) ); + TRAP( errx, iAliveTime = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineDefaultKeepAliveTime ) ); + TRAP( errx, iAccessExp = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineACExpiryTime ) ); + TRAP( errx, iImExp = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineIMExpiryTime ) ); + TRAP( errx, iGrExp = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineGRExpiryTime ) ); + TRAP( errx, iFuExp = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineFUExpiryTime ) ); + TRAP( errx, iPrExp = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEnginePRExpiryTime ) ); + TRAP( errx, iCIRModePollTime = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineCIRModePollTime ) ); + TRAP( errx, iMultiTrans = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineMultiTrans ) ); + TRAP( errx, iMaxMessageSize = TImpsDataUtils::GetCenRepIntValueL( + KCRUIDWVEngineVariation, KWVEngineMaxMessageSize ) ); + + // debug logging +#ifdef _IMPS_LOGGING_ + CImpsClientLogger::Log( _L( "Server: ReadSettings iPDPExpiry=%d iFourWayLogin=%d iPollTime=%d iAliveTime=%d" ), + iPDPExpiry, iFourWayLogin, iPollTime, iAliveTime ); + CImpsClientLogger::Log( _L( "Server: ReadSettings iAccessExp=%d iImExp=%d iGrExp=%d iFuExp=%d iPrExp=%d iCIRModePollTime=%d iMultiTrans=%d iMaxMsgSize=%d" ), + iAccessExp, iImExp, iGrExp, iFuExp, iPrExp, iCIRModePollTime, iMultiTrans, iMaxMessageSize ); +#endif + } + +// --------------------------------------------------------- +// TImpsSrvSettings::ReadIniFileL +// --------------------------------------------------------- +// +#pragma CTC SKIP +#ifdef _DEBUG + +void TImpsSrvSettings::ReadIniFileL( RFs& aFs ) + { + // Set few values without reading them from ini file + TBool retx = EFalse; + TInt errx = KErrNone; + + CImpsSettingFile* configFile = CImpsSettingFile::NewL( aFs ); + CleanupStack::PushL( configFile ); // ***** + // Search current drive + TFileName path; + Dll::FileName( path ); + TDriveName drive( TParsePtrC( path ).Drive( ) ); + + // In emulator we try to find from c drive + // in hardware we try to find from current drive and then from RAM. +#ifdef __WINS__ + TFileName fileN( KImpsIniFile ); +#else + TFileName fileN( drive ); + fileN.Append( KImpsIniFile ); +#endif + + TInt err = 0; + + // Open temporary config file + TRAP( err, configFile->OpenL( fileN ) ); + if ( err && drive.CompareF( _L( "c:" ) ) ) + { + err = KErrNone; + fileN = _L( "c:" ); + fileN.Append( KImpsIniFile ); + TRAP( err, configFile->OpenL( fileN ) ); + } + if ( err ) + { + err = KErrNone; +#ifdef _IMPS_LOGGING_ + CImpsClientLogger::Log( _L( "Server: Config file not found ***" ) ); +#endif + User::Leave( KImpsErrorConfig ); + } + else + { +#ifdef _IMPS_LOGGING_ + CImpsClientLogger::Log( _L( "Server: Config file found ***" ) ); +#endif + } + + iXmlLog = 0; + TUint32 myPoll = 0; + TPtrC8 myPtr; + TBuf<8> pollBuffer; + // read poll time + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniPollTime ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myPoll, EDecimal ); + iPollTime = ( TInt ) myPoll; + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniXmlLog ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iXmlLog += 1; + } + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniXmlPollingLog ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iXmlLog += 2; + } + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniNoWAPSMSCIR ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iSMSWAPCIR = 0; + } + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniNoWAPUDPCIR ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iUDPWAPCIR = 0; + } + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniNoTCPSCIR ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iTCPSCIR = 0; + } + } + + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniNoUDPSCIR ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iUDPSCIR = 0; + } + } + + // read Keep-Alive-Time + TUint32 myTime = iAliveTime; // default + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniKeepAlive ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iAliveTime = ( TInt ) myTime; + } + + // read CIR mode PollTime + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniCIRModePollTime ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iCIRModePollTime = ( TInt ) myTime; + } + + // read Access expiry time + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniACExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iAccessExp = ( TInt ) myTime; + } + + // read group expiry + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniGRExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iGrExp = ( TInt ) myTime; + } + + // read presence expiry + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniPRExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iPrExp = ( TInt ) myTime; + } + + // read fundamental expiry + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniFUExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iFuExp = ( TInt ) myTime; + } + + // read IM expiry + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniIMExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iImExp = ( TInt ) myTime; + } + + // read PDP expiry + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniPDPExpiry ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iPDPExpiry = ( TInt ) myTime; + } + + // MultiTrans initial + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniMultiTrans ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iMultiTrans = ( TInt ) myTime; + } + + // 4-way login + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIni4WayLogin ) ) ); + if ( !err ) + { + if ( !myPtr.CompareF( _L8( "False" ) ) ) + { + iFourWayLogin = EFalse; + } + else if ( !myPtr.CompareF( _L8( "True" ) ) ) + { + iFourWayLogin = ETrue; + } + } + + // Maximum IM message size + myTime = 0; + TRAP( err, myPtr.Set( configFile->KeyValueL( KImpsIniMaxMessageSize ) ) ); + if ( !err ) + { + pollBuffer.Copy( myPtr ); + TLex lex; + lex.Assign( pollBuffer ); + lex.Val( myTime, EDecimal ); + iMaxMessageSize = ( TInt ) myTime; + } + + CleanupStack::PopAndDestroy( 1 ); // configFile + + // debug logging +#ifdef _IMPS_LOGGING_ + CImpsClientLogger::Log( _L( "Server: ReadFile iPDPExpiry=%d iFourWayLogin=%d iPollTime=%d iAliveTime=%d" ), + iPDPExpiry, iFourWayLogin, iPollTime, iAliveTime ); + CImpsClientLogger::Log( _L( "Server: ReadFile iAccessExp=%d iImExp=%d iGrExp=%d iFuExp=%d iPrExp=%d iCIRModePollTime=%d iMultiTrans=%d iMaxMsgSize=%d" ), + iAccessExp, iImExp, iGrExp, iFuExp, iPrExp, iCIRModePollTime, iMultiTrans, iMaxMessageSize ); + CImpsClientLogger::Log( _L( "Server: ReadFile \ + iXmlLog=%d, iSMSWAPCIR=%d, iUDPWAPCIR=%d,iTCPSCIR=%d,iUDPSCIR=%d" ), + iXmlLog, iSMSWAPCIR, iUDPWAPCIR, iTCPSCIR, iUDPSCIR ); +#endif + } + +#endif // _DEBUG +#pragma CTC ENDSKIP + +// --------------------------------------------------------- +// TImpsSrvSettings::SetCirBindingsL +// --------------------------------------------------------- +// +void TImpsSrvSettings::SetCirBindingsL( + MImpsDataAccessor* myAccess, MImpsKey* myKey ) + { + TBool everyElement( EFalse ); + TInt myInt = 0; + + // Check supported CIRMethods + for ( TInt i = 0; !everyElement; i++ ) + { + myKey->AddL( CREATEKEY( EImpsKeySupportedCIRMethod, i ) ); + if ( myAccess->RestoreIntegerL( myKey, myInt ) ) + { + if ( myInt == EImpsWAPUDP ) + { + iUDPWAPCIR++; + } + else if ( myInt == EImpsWAPSMS ) + { + iSMSWAPCIR++; + } + else if ( myInt == EImpsSUDP ) + { + iUDPSCIR++; + } + else if ( myInt == EImpsSTCP ) + { + iTCPSCIR++; + } + } + else + { + // All methods handled + everyElement = ETrue; + } + myKey->PopL(); + } + } + + +// --------------------------------------------------------- +// TImpsSessIdent::TImpsSessIdent +// --------------------------------------------------------- +// +TImpsSessIdent::TImpsSessIdent( + const TDesC& aSID, const TDesC& aSAP, const TDesC& aUserId ) + : iSID( aSID ), iSAP( aSAP ), iUserId( aUserId ) + {} + + + +// End of File