--- /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 <e32base.h>
+#include <CoreApplicationUIsSDKCRKeys.h>
+#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