diff -r 000000000000 -r b497e44ab2fc syncmlfw/ds/syncagent/src/nsmldsagent.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/syncmlfw/ds/syncagent/src/nsmldsagent.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,4248 @@ +/* +* Copyright (c) 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: DS Sync flow +* +*/ + +#define SYNCML_V3 +// INCLUDE FILES +#include +#include +#include +#include +#include + +// common includes with DM +#include "nsmlagenttestdefines.h" +#include "nsmlcliagconstants.h" +#include "NSmlAgentBase.h" +#include "NSmlCmdsBase.h" +#include "NSmlStatusContainer.h" +#include "NSmlResponseController.h" +#include "NSmlURI.h" +#include "NSmlHistoryArray.h" + +// DS specific includes +#include "nsmldsagconstants.h" +#include "NSmlDSAgent.h" +#include "NSmlDSCmds.h" +#include "nsmldscontent.h" +#include "nsmldserror.h" +#include "nsmldssettings.h" +#include "nsmlagentlog.h" +#include "nsmlroam.h" +//RD_AUTO_RESTART +#include +#include +#include "SyncMLErr.h" +#include "nsmldsconstants.h" +//RD_AUTO_RESTART +_LIT( KNetMon,"\\netmon.exe" ); +_LIT( KAutoRestart,"netmon" ); + +#ifndef __WINS__ +// This lowers the unnecessary compiler warning (armv5) to remark. +// "Warning: #174-D: expression has no effect..." is caused by +// DBG_ARGS8 macro in no-debug builds. +#pragma diag_remark 174 +#endif + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::CNSmlDSAgent +// C++ constructor. +// ----------------------------------------------------------------------------- +// +CNSmlDSAgent::CNSmlDSAgent() + { + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ConstructL +// Symbian 2nd phase constructor. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ConstructL( MSyncMLProgressObserver* aDSObserver ) + { + DBG_FILE(_S8("CNSmlDSAgent::ConstructL begins")); + CNSmlAgentBase::ConstructL(); + iDSObserver = aDSObserver; + iDSContent = CNSmlDSContent::NewL(); + iError = new ( ELeave ) TNSmlDSError; + iSyncMLMIMEType = KNSmlDSAgentMIMEType().AllocL(); + iResultAlertCode = KNSmlDSAgentResultAlert().AllocL(); + iNextMessageCode = KNSmlDSAgentNextMessage().AllocL(); + iEndOfDataAlertCode = KNSmlDSAgentNoEndOfData().AllocL(); + iUpdateLastAnchor=ETrue; + + //RD_AUTO_RESTART + //Check whether the Auto Restart Feature is enabled or not + TInt keyVal; + iAutoRestartInitiatedSync = EFalse; + TRAPD (err ,ReadRepositoryL(KNsmlDsAutoRestart, keyVal)); + if(err==KErrNone && keyVal==1) + { + iDSNetmon = CNsmlDSNetmon::NewL(*this); + DBG_FILE(_S8("CNSmlDSAgent::ConstructL DSNetmon is Launched")); + + CNsmlProfileUtil* profileUtil = CNsmlProfileUtil::NewLC(); + profileUtil->IsValidResumeL(iAutoRestartInitiatedSync); + profileUtil->WriteInterruptFlagL(0); + CleanupStack::PopAndDestroy(profileUtil); + } + else + { + iDSNetmon = NULL; + DBG_FILE(_S8("CNSmlDSAgent::ConstructL DSNetmon is not Launched")); + } + //RD_AUTO_RESTART + + // security policies for P&S reading and writing + _LIT_SECURITY_POLICY_S0( KNSmlPSWritePolicy, KNSmlSOSServerPolicyUID.iUid ); // SID check (sosserver) when writing + _LIT_SECURITY_POLICY_PASS( KNSmlPSReadPolicy ); // no checks done when reading + + // Define P&S data field for sync ON/OFF flag (may fail e.g. if exists already) + RProperty::Define( KPSUidDataSynchronizationInternalKeys, // category + KDataSyncStatus, // field + RProperty::EInt, // type + KNSmlPSReadPolicy, // read policy + KNSmlPSWritePolicy ); // write policy + DBG_FILE(_S8("CNSmlDSAgent::ConstructL ends")); + + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::NewL +// Symbian two-phased constructor. +// ----------------------------------------------------------------------------- +// +CNSmlDSAgent* CNSmlDSAgent::NewL( MSyncMLProgressObserver* aDSObserver ) + { + CNSmlDSAgent* self = new (ELeave) CNSmlDSAgent(); + CleanupStack::PushL( self ); + self->ConstructL( aDSObserver ); + CleanupStack::Pop(); // self + return self; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::~CNSmlDSAgent +// Destructor. +// ----------------------------------------------------------------------------- +// +CNSmlDSAgent::~CNSmlDSAgent() + { + delete iSyncLog; + delete iDSContent; + delete iDSServerId; + delete iServerAlertPackage; + + if ( iDSSyncTypeArray ) + { + iDSSyncTypeArray->Reset(); + delete iDSSyncTypeArray; + } + //RD_AUTO_RESTART + if(iDSNetmon) + { + delete iDSNetmon; + iDSNetmon = NULL; + } + //RD_AUTO_RESTART + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::Synchronise +// Starts the sync, returns immediately and the initiated sync continues in the +// RunL() function. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CNSmlDSAgent::Synchronise( TRequestStatus& aStatus, + TSmlProfileId aProfileId, + TSmlConnectionId aConnectionId, + CArrayFix* aTypeArray, + TNSmlSyncInitiation aSyncInitiation, + TInt aSessionId, + HBufC8* aAlertPackage ) + { + + CActiveScheduler::Add( this ); + + iCallerStatus = &aStatus; + iSyncInitiation = aSyncInitiation; + iProfileID = aProfileId; + iMediumType.iUid = aConnectionId; + iSessionId = aSessionId; + + *iCallerStatus = KRequestPending; + + TRAPD( err, PrepareSyncL( aTypeArray ) ); + + if ( err != KErrNone ) + { + DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, err, iDSContent->TaskId(), 0, 0 ); + User::RequestComplete( iCallerStatus, err ); + return; + } + + if ( iSyncInitiation == EServerAlerted && aAlertPackage ) + { + TRAP( err, iServerAlertPackage = aAlertPackage->AllocL() ); + + if ( err != KErrNone ) + { + DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, err, iDSContent->TaskId(), 0, 0 ); + User::RequestComplete( iCallerStatus, err ); + return; + } + } + + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + +// +// Private member functions +// +// +// Begin state sub-functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubStartStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubStartStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubStartStateL() begins")); + + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlConnecting, 0, 0 ); + iDSCurrBeginSubState = EBeginSubReadSettings; + + DBG_FILE(_S8("CNSmlDSAgent::BeginSubStartStateL() ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubReadSettingsStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubReadSettingsStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubReadSettingsStateL() begins")); + + ReadSettingsL(); + iDSCurrBeginSubState = EBeginSubSyncmlCmdsInstance; + + DBG_FILE(_S8("CNSmlDSAgent::BeginSubReadSettingsStateL() ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() begins")); + CreateSyncmlCmdsInstanceL(); + DBG_FILE(_S8("CNSmlDSAgent::BeginSubSyncmlCmdsInstanceStateL() ends")); + iDSCurrBeginSubState = EBeginSubServerAlerting; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubServerAlertingStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubServerAlertingStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() begins")); + + if ( iSyncInitiation == TNSmlSyncInitiation( EServerAlerted ) ) + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() Before ServerAlertStateL")); + ServerAlertStateL(); + } + + iDSContent->InitAllSyncLogEventsL( *iSyncLog ); + iDSCurrBeginSubState = EBeginSubOpenContentInstances; + + DBG_FILE(_S8("CNSmlDSAgent::BeginSubServerAlertingStateL() ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubOpenContentInstancesStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubOpenContentInstancesStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubOpenContentInstancesStateL() begins")); + TBool endOfOpening = EFalse; + OpenDatabaseInstancesL( endOfOpening ); + if ( endOfOpening ) + { + // + iDSCurrBeginSubState = EBeginSubScanMapInfo; + // iDSCurrBeginSubState = EBeginSubCreateLUIDBuffers; + // + } + DBG_FILE(_S8("CNSmlDSAgent::BeginSubOpenContentInstancesStateL() ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() begins")); + TBool endOfCreating( EFalse ); + + CreateLUIDBuffersL( endOfCreating ); + + if ( endOfCreating ) + { + iCurrBeginningState = EBeginConnectingToServer; + } + + DBG_FILE(_S8("CNSmlDSAgent::BeginSubCreateLUIDBuffersStateL() ends")); + } + +// +// Server Alert state functions +// + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerAlertStateL +// Marks server alerted databases as alerted +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerAlertStateL() + { + // parse syncml 1.1 server alert package + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + TPtr8 buffer( iSyncMLCmds->BufferAreaForParsingL() ); + + if ( iServerAlertPackage->Length() > buffer.MaxLength() ) + { + return; + } + + buffer.Copy( *iServerAlertPackage ); + delete iServerAlertPackage; + iServerAlertPackage = NULL; + + iDSCurrServerAlertState = EServerAlertWaitingStartMessage; + + while ( iSyncMLCmds->ProcessReceivedDataL() ) { } + + if ( iDSCurrServerAlertState != EServerAlertMessageReceived ) + { + User::Leave( TNSmlError::ESmlIncompleteMessage ); + } + } + + iDSContent->RemoveNotServerAlertedContents(); + + if ( iProtocolVer == ESmlVersion1_2 ) + { + if ( iDSContent->AllDatabasesAreInterrupted() ) + { + if ( iError->SyncLogErrorCode() ) + { + User::Leave( iError->SyncLogErrorCode() ); + } + else + { + User::Leave( TNSmlDSError::ESmlDSNoValidDatabases ); + } + } + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerAlertStartMessageStateL +// Handles SyncHdr in Server Alert Package from server. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerAlertStartMessageStateL( SmlSyncHdr_t* aSyncHdr ) + { + if ( iDSCurrServerAlertState != EServerAlertWaitingStartMessage ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + iSyncMLCmds->ProcessSyncHdrL( aSyncHdr ); + + iDSCurrServerAlertState = EServerAlertWaitingAlerts; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerAlertAlertCmdStateL +// Handles Alert command in Server Alert Package from server. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerAlertAlertCmdStateL( SmlAlert_t* aAlert ) + { + if ( iDSCurrServerAlertState != EServerAlertWaitingAlerts ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + if ( iSyncMLCmds->AlertCode( aAlert ) == KNSmlAgentDisplayAlert ) + { + iSyncMLCmds->ProcessAlertCmdL( aAlert, EFalse, EFalse, ETrue ); + } + else + { + iSyncMLCmds->ProcessAlertCmdL( aAlert, EFalse, ETrue ); + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerAlertEndMessageStateL +// Processes the end of the alert command in server alert package. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerAlertEndMessageStateL( TBool /*aFinal*/ ) + { + if ( iDSCurrServerAlertState != EServerAlertWaitingAlerts ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + iDSCurrServerAlertState = EServerAlertMessageReceived; + } + +// +// Client Initialisation state functions +// + +// --------------------------------------------------------- +// CNSmlDSAgent::InitStartingMessageStateL() +// "Initialising" event to UI, initialises interruption flags +// set by possible first initialisation attempt, makes SyncHdr +// --------------------------------------------------------- +void CNSmlDSAgent::InitStartingMessageStateL() + { + iDSContent->InitInterruptionFlags(); + iDSContent->SetToFirst(); + InitStartingMessageStateBaseL(); + } + +//RD_SUSPEND_RESUME +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::MapAlertCode +// Maps the Alert code +// ----------------------------------------------------------------------------- +// +TPtrC8 CNSmlDSAgent::MapAlertCode(TNSmlPreviousSyncType aAlertCode) + +{ + TPtrC8 prevAlert; + if ( aAlertCode == ESyncDSTwoWay ) + { + prevAlert.Set( KNSmlDSTwoWay); + } + else if ( aAlertCode == ESyncDSSlowSync) + { + prevAlert.Set(KNSmlDSSlowSync); + } + else if ( aAlertCode == ESyncDSOneWayFromClient) + { + prevAlert.Set(KNSmlDSOneWayFromClient); + } + else if ( aAlertCode == ESyncDSRefreshFromClient) + { + prevAlert.Set(KNSmlDSRefreshFromClient); + } + else if ( aAlertCode == ESyncDSOneWayFromServer ) + { + prevAlert.Set(KNSmlDSOneWayFromServer); + } + else if(aAlertCode ==ESyncDSRefreshFromServer ) + { + prevAlert.Set(KNSmlDSRefreshFromServer); + } + else if(aAlertCode ==ESyncDSTwoWayByServer ) + { + prevAlert.Set(KNSmlDSTwoWayByServer); + } + else if(aAlertCode ==ESyncDSOneWayFromClientByServer ) + { + prevAlert.Set(KNSmlDSOneWayFromClientByServer); + } + else if(aAlertCode ==ESyncDSRefreshFromClientByServer ) + { + prevAlert.Set(KNSmlDSRefreshFromClientByServer); + } + else if(aAlertCode ==ESyncDSOneWayFromServerByServer ) + { + prevAlert.Set(KNSmlDSOneWayFromServerByServer); + } + else if(aAlertCode ==ESyncDSRefreshFromServerByServer ) + { + prevAlert.Set(KNSmlDSRefreshFromServerByServer); + } + + return(prevAlert); + + +} +//RD_SUSPEND_RESUME + +// CNSmlDSAgent::InitAlertingStateL +// Makes Alert command for each database. If there is a previously completed +// sync the client suggests two-way sync else slow sync is proposed. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::InitAlertingStateL() + { + + if ( iDSClientNextSyncAnchor == TTime( 0 ) ) + { + iDSClientNextSyncAnchor.UniversalTime(); + } + + if ( iDSContent->SetToFirst() ) + { + + do + { + TBuf8<3> syncType( iDSContent->SyncType() ); + TTime clientLastSyncAnchor( iDSContent->LastSyncAnchorL() ); + TNSmlPreviousSyncType prevSyncType=iDSContent->PreviousClientSyncTypeL(); + iDSContent->SetSessionResumedL(EFalse); + if (!iDSContent->Interrupted()) + { + //RD_SUSPEND_RESUME + if(iDSContent->SuspendedStateL() == EStateNotStarted) + { + if ( syncType == KNSmlDSTwoWay ) + { + // + if ( ( !iDSContent->HasSyncHistoryL() || iDSContent->SlowSyncRequestL() || clientLastSyncAnchor == TTime( 0 ) )&& !iDSContent->MapExists() ) + // if ( !iDSContent->HasSyncHistoryL() || iDSContent->SlowSyncRequestL() || clientLastSyncAnchor == TTime( 0 ) ) + // + { + syncType = KNSmlDSSlowSync; + + } + } + } + //checks for protocol version, stage of interruption ,sync history to send resume command + else if (iProtocolVer==ESmlVersion1_2 && iDSContent->HasSyncHistoryL() && + prevSyncType!=ETypeNotSet && syncType!= KNSmlDSRefreshFromServer) + { + //Client rejects to the Resume session when the Sync type is changed in the UI + //Based on the section "Refusing to Resume a session" in the OMA-Protocol spec + //Two way sync will be proposed by the client instead of the Resume session + if(syncType.Compare(MapAlertCode(prevSyncType))==0) + { + syncType = KNSmlDSResume; + iDSContent->SetSessionResumedL(ETrue); + } + else + { + syncType=KNSmlDSSlowSync; + iDSContent->SetSessionResumedL(EFalse); + } + } + //RD_SUSPEND_RESUME + + iSyncMLCmds->DoAlertL( syncType, &clientLastSyncAnchor, &iDSClientNextSyncAnchor ); + iDSContent->SetInitAlertWaiting(); + + } + + + } + while ( iDSContent->SetToNext() ); + } + + iCurrClientInitState = EInitDeviceInfo; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::InitDeviceInfoStateL +// If there is some database which is not previously synced with the server then +// DevInfo is sent in a Put command. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::InitDeviceInfoStateL() + { + if ( iDSContent->SetToFirst() ) + { + do + { + if ( ( !iDSContent->HasSyncHistoryL() || iDSContent->LastSyncAnchorL() == TTime( 0 ) ) && !iDSContent->Interrupted() ) + { + iSyncMLCmds->DoPutL(); + iDSDeviceInfoRequestByClient = ETrue; + break; + } + } + while ( iDSContent->SetToNext() ); + } + + iCurrClientInitState = EInitAskingDeviceInfo; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::InitAskingDeviceInfoStateL() +// If there is one database which is not previosly synced with the +// server, Device Info is asked Get command +// --------------------------------------------------------- +void CNSmlDSAgent::InitAskingDeviceInfoStateL() + { + if ( iDSDeviceInfoRequestByClient ) + { + iSyncMLCmds->DoGetL(); + } + iCurrClientInitState = EInitEndingMessage; + } + +// +// Server Initialisation state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitialisationStateL() +// Main state function to read Sync Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitialisationStateL() + { + //DBG_FILE(_S8("CNSmlDSAgent::ServerInitialisationStateL begins")); + + TBool messageReceived( EFalse ); + + if ( iDSCurrServerInitState == EServerInitEnd ) + { + messageReceived = ETrue; + } + else + { + messageReceived = !iSyncMLCmds->ProcessReceivedDataL(); + } + + if ( messageReceived ) + { + switch ( iDSCurrServerInitState ) + { + case EServerInitMessageReceived: + { + iBusyStatusReceived = iSyncMLCmds->BusyStatus(); + NextMainStateL(); + break; + } + + case EServerInitPackageReceived: + { + if ( !iChallengeRequest ) + { + CheckStatusCodesAreReceivedL(); + CheckCommandsAreReceivedL(); + TInt retVal( iDSContent->SetTypeAndDevCapsL() ); + + if ( retVal != KErrNone ) + { + InterruptL( iDSContent->CurrentIndex(), TNSmlError::ESmlTypeNotSupported, EFalse, EFalse ); + } + } + + iDSLUIDBufferingStarted = EFalse; + iDSCurrServerInitState = EServerInitEnd; + break; + } + + case EServerInitEnd: + { + TBool endOfInits( EFalse ); + TInt resultCode( KErrNone ); + + iDSContent->SetDbAndTimeInitsL( endOfInits, resultCode, iDSLUIDBufferingStarted ); + iDSLUIDBufferingStarted = ETrue; + + User::LeaveIfError( resultCode ); + + if ( endOfInits ) + { + NextMainStateL(); + } + break; + } + + default: + { + User::Leave( TNSmlError::ESmlIncompleteMessage ); + } + } + } + //DBG_FILE(_S8("CNSmlDSAgent::ServerInitialisationStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitStartMessageStateL() +// Handles SyncHdr in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitStartMessageStateL( SmlSyncHdr_t* aSyncHdr ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitStartMessageStateL begins")); + if ( iDSCurrServerInitState != EServerInitWaitingStartMessage ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + iSyncMLCmds->ProcessSyncHdrL( aSyncHdr ); + iDSCurrServerInitState = EServerInitWaitingCommands; + DBG_FILE(_S8("CNSmlDSAgent::ServerInitStartMessageStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitStatusCmdStateL() +// Handles Status command in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitStatusCmdStateL( SmlStatus_t* aStatus ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitStatusCmdStateL begins")); + if ( iChallengeRequest ) + { + return; + } + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + DBG_FILE(_S8("CNSmlDSAgent::ServerInitStatusCmdStateL ends")); + iSyncMLCmds->ProcessStatusCmdL( aStatus ); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitResultsCmdStateL() +// Handles Results command in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitResultsCmdStateL( SmlResults_t* aResults ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitResultsCmdStateL begins")); + if ( iChallengeRequest ) + { + return; + } + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + if ( !iDSDeviceInfoRequestByClient ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + else + { + iSyncMLCmds->ProcessResultsCmdL( aResults ); + iDSDeviceInfoRequestByClient = EFalse; + } + DBG_FILE(_S8("CNSmlDSAgent::ServerInitResultsCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitAlertCmdStateL() +// Handles Alert command in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitAlertCmdStateL( SmlAlert_t* aAlert ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitAlertCmdStateL begins")); + if ( iChallengeRequest ) + { + return; + } + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + // Alert command may be init Alert, Next Alert or Display Alert + TBool nextAlert = EFalse; + TBool displayAlert = EFalse; + + if ( iSyncMLCmds->AlertCode( aAlert ) == KNSmlDSAgentNextMessage ) + { + if ( !iFinalMessageFromClient ) + { + nextAlert = ETrue; + } + } + else + { + if ( iSyncMLCmds->AlertCode( aAlert ) == KNSmlAgentDisplayAlert ) + { + displayAlert = ETrue; + } + } + + iSyncMLCmds->ProcessAlertCmdL( aAlert, nextAlert, EFalse, displayAlert ); + DBG_FILE(_S8("CNSmlDSAgent::ServerInitAlertCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitPutCmdStateL() +// Handles Put command in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitPutCmdStateL( SmlPut_t* aPut ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitPutCmdStateL begins")); + if ( iChallengeRequest ) + { + return; + } + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + iSyncMLCmds->ProcessPutCmdL( aPut ); + DBG_FILE(_S8("CNSmlDSAgent::ServerInitPutCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitGetCmdStateL() +// Handles Get command in Initialization Package from Server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitGetCmdStateL( SmlGet_t* aGet ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitGetCmdStateL begins")); + if ( iChallengeRequest ) + { + return; + } + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + iSyncMLCmds->ProcessGetCmdL( aGet ); + iDSDeviceInfoRequestedByServer = ETrue; + DBG_FILE(_S8("CNSmlDSAgent::ServerInitGetCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerInitEndMessageStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::ServerInitEndMessageStateL( TBool aFinal ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerInitEndMessageStateL begins")); + if ( iDSCurrServerInitState != EServerInitWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + if ( aFinal ) + { + iDSCurrServerInitState = EServerInitPackageReceived; + } + else + { + iDSCurrServerInitState = EServerInitMessageReceived; + } + DBG_FILE(_S8("CNSmlDSAgent::ServerInitEndMessageStateL ends")); + } + +// +// Client Modifications state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModificationsStateL() +// Makes Client Modification Package to Server +// Navigate according to state code +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModificationsStateL() + { + switch ( iDSCurrClientModState ) + { + case EClientModStartingMessage: + ClientModStartingMessageStateL(); + break; + case EClientModMakingStatus: + ClientModMakingStatusStateL(); + break; + case EClientModMakingResults: + ClientModMakingResultsStateL(); + break; + case EClientModStartingSync: + ClientModStartingSyncStateL(); + break; + case EClientModMakingUpdates: + ClientModMakingUpdatesStateL(); + break; + case EClientModEndingSync: + ClientModEndingSyncStateL(); + break; + case EClientModEndingMessage: + ClientModEndingMessageStateL(); + break; + default: + User::Leave( KErrGeneral ); + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModStartingMessageStateL() +// "Synchronising" event to UI, makes SyncHdr +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModStartingMessageStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModStartingMessageStateL begins")); + iSyncMLCmds->DoSyncHdrL(); + iBufferFull = EFalse; + iDSCurrClientModState = EClientModMakingStatus; + DBG_FILE(_S8("CNSmlDSAgent::ClientModStartingMessageStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModMakingStatusStateL() +// Writes all buffered status elements +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModMakingStatusStateL() + { + DBG_FILE(_S8("ClientModMakingStatusStateL begins")); + iSyncMLCmds->StatusContainer()->Begin(); + TBool found( ETrue ); + + while( found ) + { + SmlStatus_t* status; + found = iSyncMLCmds->StatusContainer()->NextStatusElement( status, ETrue ); + if ( found ) + { + iSyncMLCmds->DoStatusL( status ); + } + } + + iDSCurrClientModState = EClientModMakingResults; + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingStatusStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModMakingResultsStateL() +// Device Info to a server in Results command (if asked ) +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModMakingResultsStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingResultsStateL begins")); + if ( iDSDeviceInfoRequestedByServer && !iDSContent->AllDatabasesAreInterrupted() ) + { + iSyncMLCmds->DoResultsL(); + iDSDeviceInfoRequestedByServer = EFalse; + } + if ( iFinalMessageFromClient ) + { + iDSContent->SetToFirst(); + } + else + { + iDSContent->SetIndexToSaved(); + } + iDSCurrClientModState = EClientModStartingSync; + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingResultsStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModStartingSyncStateL() +// Makes Sync command +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModStartingSyncStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModStartingSyncStateL begins")); + CNSmlCmdsBase::TReturnValue ret; + if ( !iDSContent->Interrupted() ) + { + ret = iSyncMLCmds->DoStartSyncL(); + switch ( ret ) + { + case CNSmlCmdsBase::EReturnOK: + iDSCurrClientModState = EClientModMakingUpdates; + if ( !iDSContent->ClientItemCountAsked() ) + { + iDSContent->SetClientItemCountAsked(); + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlSendingModificationsToServer, iDSContent->ClientItemCount(), 0 ); + } + break; + case CNSmlCmdsBase::EReturnBufferFull: + iDSCurrClientModState = EClientModEndingMessage; + iBufferFull = ETrue; + break; + default: + break; + } + } + else + // skip interrupted database + { + if ( !iDSContent->SetToNext() ) + { + iDSCurrClientModState = EClientModEndingMessage; + } + } + DBG_FILE(_S8("CNSmlDSAgent::ClientModStartingSyncStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModMakingUpdatesStateL() +// Makes Replace or Delete command +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModMakingUpdatesStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingUpdatesStateL begins")); + + //RD_SUSPEND_RESUME + // Client modifications are not sent,if the previous session was interrupted at Server modifications state.Commented for Usability issue. + /*if(iDSContent->SuspendedState()== EStateServerModification && iDSContent->GetSessionResumed()) + { + iDSCurrClientModState = EClientModEndingSync; + }else */ + if ( iDSContent->SyncType() == KNSmlDSOneWayFromServer || + iDSContent->SyncType() == KNSmlDSOneWayFromServerByServer || + iDSContent->SyncType() == KNSmlDSRefreshFromServer || + iDSContent->SyncType() == KNSmlDSRefreshFromServerByServer ) + { + iDSCurrClientModState = EClientModEndingSync; + } + else + { + switch ( iSyncMLCmds->DoAddOrReplaceOrDeleteL() ) + { + case CNSmlCmdsBase::EReturnEndData: + iDSCurrClientModState = EClientModEndingSync; + break; + + case CNSmlCmdsBase::EReturnBufferFull: + iDSCurrClientModState = EClientModEndingSync; + iBufferFull = ETrue; + break; + + default: + break; + } + } + + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingUpdatesStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModEndingSyncStateL() +// End of Sync command +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModEndingSyncStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModEndingSyncStateL begins")); + + iSyncMLCmds->DoEndSyncL(); + + if ( iBufferFull ) + { + iDSCurrClientModState = EClientModEndingMessage; + } + else + { + if ( iDSContent->SetToNext() ) + { + iDSCurrClientModState = EClientModStartingSync; + } + else + { + iDSCurrClientModState = EClientModEndingMessage; + } + } + + DBG_FILE(_S8("CNSmlDSAgent::ClientModEndingSyncStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ClientModEndingMessageStateL() +// End of SyncMl Message, read amounts are notified to UI +// --------------------------------------------------------- +void CNSmlDSAgent::ClientModEndingMessageStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModEndingMessageStateL begins")); + if ( iBufferFull ) + { + iSyncMLCmds->DoEndMessageL( EFalse ); + iFinalMessageFromClient = EFalse; + iDSContent->SaveCurrentIndex(); + } + else + { + iSyncMLCmds->DoEndMessageL(); + iFinalMessageFromClient = ETrue; + } + NextMainStateL(); + DBG_FILE(_S8("CNSmlDSAgent::ClientModEndingMessageStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerModificationsStateL(() +// Main state function to read Server Modifications to Client Package +// --------------------------------------------------------- +void CNSmlDSAgent::ServerModificationsStateL() + { + DBG_FILE(_S8("ServerModificationsStateL begins")); + + if ( iCurrServerModState == EServerModWaitingStartMessage ) + { + +// + iDSContent->SetMapRemovable(); + iDSContent->RemoveAllRemovableMap(); +// + + iDSContent->SetSyncStatusToAll( ENoServerDataUpdated ); + } + + if ( !iSyncMLCmds->ProcessReceivedDataL() ) + { + if ( iCurrServerModState == EServerModMessageReceived ) + { + iBusyStatusReceived = iSyncMLCmds->BusyStatus(); + CheckStatusCodesAreReceivedL( EFalse ); + } + else + { + if ( iCurrServerModState == EServerModPackageReceived ) + { + CheckStatusCodesAreReceivedL(); + CheckCommandsAreReceivedL(); + iDSContent->SetSyncStatusToAll( ECompletedOK ); + } + else + { + User::Leave( TNSmlError::ESmlIncompleteMessage ); + } + } + NextMainStateL(); + } + + DBG_FILE(_S8("CNSmlDSAgent::ServerModificationsStateL ends")); + } + +// +// Server Modifications state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::ServerModStartSyncStateL(() +// Handles Sync command in Server Modifications to Client Package +// --------------------------------------------------------- +void CNSmlDSAgent::ServerModStartSyncStateL( SmlSync_t* aSync ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerModStartSyncStateL begins")); + + if ( iCurrServerModState != EServerModWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + iSyncMLCmds->ProcessSyncL( aSync ); + + iCurrServerModState = EServerModWaitingUpdateCommands; + + DBG_FILE(_S8("CNSmlDSAgent::ServerModStartSyncStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ServerModEndSyncStateL(() +// Handles end of Sync command +// --------------------------------------------------------- +void CNSmlDSAgent::ServerModEndSyncStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ServerModEndSyncStateL begins")); + + iSyncMLCmds->ProcessEndSyncL(); + + iCurrServerModState = EServerModWaitingCommands; + DBG_FILE(_S8("CNSmlDSAgent::ServerModEndSyncStateL ends")); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerModStartAtomicStateL +// Handles the Atomic command. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerModStartAtomicStateL( SmlAtomic_t* aContent ) + { + if ( ( iCurrServerModState != EServerModWaitingUpdateCommands ) && ( iCurrServerModState != EServerModWaitingCommands ) ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + if ( iNestedAtomicsCount > 0 ) + { + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAtomic, aContent->cmdID, aContent->flags ); + WriteWarningL( TNSmlError::ESmlUnexpectedCmd ); + } + else + { + iSyncMLCmds->ProcessAtomicL( aContent ); + } + + ++iNestedAtomicsCount; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ServerModEndAtomicStateL +// Handles the end of the Atomic command. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ServerModEndAtomicStateL() + { + if ( --iNestedAtomicsCount == 0 ) + { + iSyncMLCmds->ProcessEndAtomicL(); + } + } + +// +// Map Acknowledgement state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::MapAcknowledgeStateL() +// Main state function to read Map Acknowledgement from Server Package +// --------------------------------------------------------- +void CNSmlDSAgent::MapAcknowledgeStateL() + { + if ( !iSyncMLCmds->ProcessReceivedDataL() ) + { + if ( iDSCurrMapAcknowledgeState == EMapAckMessageReceived ) + { + iBusyStatusReceived = iSyncMLCmds->BusyStatus(); + } + else + { + if ( iDSCurrMapAcknowledgeState == EMapAckPackageReceived ) + { + CheckStatusCodesAreReceivedL(); + iDSContent->SetSyncStatusToAll( ECompletedOK ); + } + else + { + if ( iDSWaitingForMapAcknowledgement ) + { + User::Leave( TNSmlError::ESmlIncompleteMessage ); + } + } + } + NextMainStateL(); + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::MapAckStartMessageStateL +// Handles SyncHdr in Map Acknowledgement from Server Package +// --------------------------------------------------------- +void CNSmlDSAgent::MapAckStartMessageStateL( SmlSyncHdr_t* aSyncHdr ) + { + DBG_FILE(_S8("CNSmlDSAgent::MapAckStartMessageStateL begins")); + if ( iDSCurrMapAcknowledgeState != EMapAckWaitingStartMessage ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + iSyncMLCmds->ProcessSyncHdrL( aSyncHdr ); + iDSCurrMapAcknowledgeState = EMapAckWaitingCommands; + DBG_FILE(_S8("CNSmlDSAgent::MapAckStartMessageStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::MapAckStatusCmdStateL() +// Handles Status command in Map Acknowledgement from Server Package +// --------------------------------------------------------- +void CNSmlDSAgent::MapAckStatusCmdStateL( SmlStatus_t* aStatus ) + { + DBG_FILE(_S8("CNSmlDSAgent::MapAckStatusCmdStateL begins")); + if ( iDSCurrMapAcknowledgeState != EMapAckWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + iSyncMLCmds->ProcessStatusCmdL ( aStatus ); + DBG_FILE(_S8("CNSmlDSAgent::MapAckStatusCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::MapAckAlertCmdStateL() +// Handles Alert command in Map Acknowledgement from Server Package +// --------------------------------------------------------- +void CNSmlDSAgent::MapAckAlertCmdStateL( SmlAlert_t* aAlert ) + { + DBG_FILE(_S8("CNSmlDSAgent::MapAckAlertCmdStateL begins")); + if ( iDSCurrMapAcknowledgeState != EMapAckWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + if ( iSyncMLCmds->AlertCode( aAlert ) == KNSmlAgentDisplayAlert ) + { + iSyncMLCmds->ProcessAlertCmdL( aAlert, EFalse, EFalse, ETrue ); + } + else + { + if ( !iFinalMessageFromClient ) + { + iSyncMLCmds->ProcessAlertCmdL( aAlert, ETrue ); + } + } + + DBG_FILE(_S8("CNSmlDSAgent::MapAckAlertCmdStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::MapAckEndMessageStateL() +// Handles end of SyncML message +// --------------------------------------------------------- +void CNSmlDSAgent::MapAckEndMessageStateL( TBool aFinal ) + { + DBG_FILE(_S8("CNSmlDSAgent::MapAckEndMessageStateL begins")); + + if ( iDSCurrMapAcknowledgeState != EMapAckWaitingCommands ) + { + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + if ( aFinal ) + { + +// + iDSContent->RemoveAllRemovableMap(); +// + + iDSCurrMapAcknowledgeState = EMapAckPackageReceived; + } + else + { + iDSCurrMapAcknowledgeState = EMapAckMessageReceived; + } + + DBG_FILE(_S8("CNSmlDSAgent::MapAckEndMessageStateL ends")); + } + +// +// Finishing state functions +// + +// --------------------------------------------------------- +// CNSmlDSAgent::FinishingStateL() +// Finishing functions in the end of sync +// --------------------------------------------------------- +void CNSmlDSAgent::FinishingStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::FinishingStateL begins")); + + TInt index = iDSContent->CurrentIndex(); + TInt keyVal; + TRAPD (srerr ,ReadRepositoryL(KNsmlDsSuspendResume, keyVal)); + + if(srerr == KErrNone && keyVal == 1) + { + + TNSmlSyncSuspendedState suspendedState; + if(iDSContent->SetToFirst()) + { + do + { + suspendedState = CurrentState(); + iDSContent->SetSuspendedStateL(suspendedState); + }while( iDSContent->SetToNext() ); + } + + if(iDSContent->SetToFirst()) + { + do + { + TBuf8<3> syncType( iDSContent->SyncType()); + TNSmlPreviousSyncType prevSyncType=MapAlertCode(syncType); + //Sync Type of the Current Sync session is stored. + iDSContent->SetPreviousSyncTypeL( prevSyncType ); + }while( iDSContent->SetToNext() ); + } + + if(iDSContent->SetToFirst()) + { + do + { + TBuf8<3> clientSyncType( iDSContent->ClientSyncType()); + TNSmlPreviousSyncType prevClientType=MapAlertCode(clientSyncType); + //Sync Type proposed by Client in the Current Sync session is stored. + iDSContent->SetPreviousClientSyncTypeL( prevClientType ); + }while( iDSContent->SetToNext() ); + } + + } + //RD_SUSPEND_RESUME + iDSContent->SetIndex(index); + if( !iPacketDataUnAvailable && iUpdateLastAnchor ) + iDSContent->UpdateSyncAnchorsL( iDSClientNextSyncAnchor ); + iDSContent->FinalizeDatabasesL(); + FinishL(); + FinalizeSyncLogL(); + //RD_AUTO_RESTART (BPSS-7GBFF3) + //Check whether the Auto Restart Feature is enabled or not + TRAPD (arerr ,ReadRepositoryL(KNsmlDsAutoRestart, keyVal)); + + if(arerr == KErrNone && keyVal == 1) + { + if(!iPacketDataUnAvailable && !iAutoRestartInitiatedSync ) + { + DBG_FILE(_S8("CNSmlDSAgent::FinishingStateL About to check the Profile ID")); + + if(CheckProfileIdL()) + { + TerminateAutoRestart(); + } + } + } + //RD_AUTO_RESTART + + DBG_FILE(_S8("CNSmlDSAgent::FinishingStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::OpenDatabaseInstancesL +// Database instances (content data adapters are created) +// In the creation they are harcoded by the name,later on referenced +// by an index. +// --------------------------------------------------------- +void CNSmlDSAgent::OpenDatabaseInstancesL( TBool& aEnd ) + { + TInt resultCode; + TBool ret( EFalse ); + + if ( !iDSDatabaseOpeningStarted ) + { + ret = iDSContent->SetToFirst(); + iDSDatabaseOpeningStarted = ETrue; + } + else + { + ret = iDSContent->SetToNext(); + } + + if ( ret ) + { + iDSContent->OpenContentInstanceL( resultCode ); + + switch ( resultCode ) + { + case KErrNone: + { + TBool status( EFalse ); + + TRAPD( error, status = iDSContent->IsSupportedSyncTypeL( iDSContent->SyncType() )); + if ( error == KErrNone ) + { + if ( !status ) + { + InterruptL( iDSContent->CurrentIndex(), TNSmlDSError::ESmlDSUnsupportedSyncType, ETrue, EFalse ); + iDSContent->SetInterruptedBeforeSync(); + } + } + else + { + InterruptL( iDSContent->CurrentIndex(), error, ETrue, EFalse ); + iDSContent->SetInterruptedBeforeSync(); + } + + } + break; + + case KErrNotFound: + InterruptL( iDSContent->CurrentIndex(), TNSmlDSError::ESmlDSLocalDatabaseError, ETrue, EFalse ); + iDSContent->SetInterruptedBeforeSync(); + break; + + default: + User::Leave( resultCode ); + } + } + else + { + aEnd = ETrue; + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::CreateLUIDBuffersL +// +// --------------------------------------------------------- +void CNSmlDSAgent::CreateLUIDBuffersL( TBool& aEnd ) + { + TBool ret( EFalse ); + + if ( !iDSLUIDBufferingStarted ) + { + ret = iDSContent->SetToFirst(); + iDSLUIDBufferingStarted = ETrue; + } + else + { + ret = iDSContent->SetToNext(); + } + + if ( ret ) + { + if ( !iDSContent->Interrupted() ) + { + TInt resultCode(KErrNone); + TRAPD( error, iDSContent->CreateLUIDBufferL( resultCode )); + + if ( error != KErrNone || resultCode != KErrNone ) + { + InterruptL( iDSContent->CurrentIndex(), TNSmlDSError::ESmlDSLocalDatabaseError, EFalse, ETrue ); + } + } + } + else + { + aEnd = ETrue; + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::CreateSyncmlCmdsInstanceL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::CreateSyncmlCmdsInstanceL() + { + if ( !iSyncMLCmds ) + { + TBool versionCheck( ETrue ); + TBuf8<16> sessionIdString; + + if ( iSessionId == 0 ) + { + iSessionId = GetSessionIDL(); + ++iSessionId; + UpdateSessionIDL( iSessionId ); + } + + sessionIdString.Num( iSessionId ); + + if ( iSyncInitiation == EServerAlerted ) + { + versionCheck = EFalse; + } + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + iSyncMLCmds = CNSmlDSCmds::NewL( this, sessionIdString, KNSmlDSAgentVerProto, KNSmlSyncMLPublicId, *iSyncMLUserName, iSyncServer, *iDSContent, *iDSObserver, versionCheck ); + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + iSyncMLCmds = CNSmlDSCmds::NewL( this, sessionIdString, KNSmlDSAgentVerProto12, KNSmlSyncMLPublicId12, *iSyncMLUserName, iSyncServer, *iDSContent, *iDSObserver, versionCheck ); + } + + TInt value(0); + TRAPD (err , ReadRepositoryL(KNSmlMaxMsgSizeKey, value)); + if ( ( iMediumType == KUidNSmlMediumTypeInternet ) && ( err == KErrNone ) ) + { + iSyncMLCmds->SetMaximumWorkspaceSize( value ); + } + else if ( iMediumType != KUidNSmlMediumTypeInternet ) + { + iSyncMLCmds->SetMaximumWorkspaceSize( KNSmlLocalSyncWorkspaceSize ); + } + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::InfoMessageToSyncLogL() +// Info messages are written during the sync +// --------------------------------------------------------- +void CNSmlDSAgent::InfoMessageToSyncLogL( TInt appIndex, TInt aErrorCode ) + { + iDSContent->SetIndex( appIndex ); + DoErrorEvent( MSyncMLProgressObserver::ESmlWarning, aErrorCode, iDSContent->TaskId(), 0, 0 ); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ReadSettingsL() +// Reads sync settings +// --------------------------------------------------------- +void CNSmlDSAgent::ReadSettingsL() + { + DBG_FILE(_S8("CNSmlDSAgent::ReadSettingsL BEGIN")); + CNSmlDSProfile* profile = CNSmlDSSettings::NewLC()->ProfileL( iProfileID ); + //RD_AUTO_RESTART + if(iDSNetmon) + { + iDSNetmon->iProfileID=iProfileID; + } + //RD_AUTO_RESTART + if ( !profile ) + { + User::Leave( TNSmlError::ESmlErrorInSettings ); + } + + CleanupStack::PushL( profile ); + + SetDSSessionInfoL(profile); + + if ( iMediumType.iUid == -1 ) + { + iMediumType.iUid = profile->IntValue( EDSProfileTransportId ); + iIAPId = profile->IntValue( EDSProfileIAPId ); + } + else if ( iMediumType.iUid == KUidNSmlMediumTypeInternet.iUid ) + { + iIAPId = profile->IntValue( EDSProfileIAPId ); + } + //RD_AUTO_RESTART + ReplaceIAPIdL(); + //RD_AUTO_RESTART + DBG_FILE_CODE(iIAPId , _S8("CNSmlDSAgent::ReadSettingsL, The Access Point ID for the Sync Session is :")); + + iIAPIdArray = new ( ELeave ) CArrayFixFlat( KSmlArrayGranularity ); + iIAPIdArray->AppendL( iIAPId ); + + if ( profile->IntValue( EDSProfileAutoChangeIAP ) ) + { + RDbNamedDatabase* dBase = CNSmlDSSettings::NewLC()->Database(); + CNSmlRoamTable* roam = CNSmlRoamTable::NewLC( *dBase ); + CNSmlIAPArray* iapArray( roam->GetItemsForIdL( iProfileID ) ); + CleanupStack::PushL( iapArray ); + + for ( TInt index = 0 ; index < iapArray->Count() ; index++ ) + { + iIAPIdArray->AppendL( iapArray->At( index ) ); + } + + iapArray->Reset(); + CleanupStack::PopAndDestroy( 3 ); // iapArray, roam, settings + } + + iDSServerId = profile->StrValue( EDSProfileServerId ).AllocL(); + iSyncMLUserName = profile->StrValue( EDSProfileSyncServerUsername ).AllocL(); + iSyncMLPassword = profile->StrValue( EDSProfileSyncServerPassword ).AllocL(); + iSyncHTTPAuthUserName = profile->StrValue( EDSProfileHttpAuthUsername ).AllocL(); + iSyncHTTPAuthPassword = profile->StrValue( EDSProfileHttpAuthPassword ).AllocL(); + iSyncHTTPAuthUsed = profile->IntValue( EDSProfileHttpAuthUsed ); + iProtocolVer = static_cast( profile->IntValue( EDSProfileProtocolVersion ) ); + + // set sync started to P&S (if fails -> sync not interrupted) + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + RProperty::Set( KPSUidDataSynchronizationInternalKeys, + KDataSyncStatus, + EDataSyncRunning ); + } + else // TSmlProtocolVersion::ESmlVersion1_2 + { + RProperty::Set( KPSUidDataSynchronizationInternalKeys, + KDataSyncStatus, + EDataSyncRunning12 ); + } + + + TBool ifInternet = ETrue ; // CR: 403-1188 + if ( iMediumType == KUidNSmlMediumTypeInternet ) + { + iSyncServer = CNSmlURI::NewL( profile->StrValue( EDSProfileServerURL ), ETrue ); + } + else + { + iSyncServer = CNSmlURI::NewL( profile->StrValue( EDSProfileServerURL ), EFalse ); + ifInternet = EFalse ; // CR: 403-1188 + } + + if ( !profile->iContentTypes ) + { + User::Leave( TNSmlError::ESmlErrorInSettings ); + } + + RArray taskIdArray; + + + TBool isRemotedatabaseDefined(ETrue); + for ( TInt i = 0; i < profile->iContentTypes->Count(); i++ ) + { + TBool addContent( EFalse ); + TBool serverAlert(EFalse); + CNSmlDbCaps::ENSmlSyncTypes syncType( CNSmlDbCaps::EAllTypes ); + + if ( iDSSyncTypeArray ) + { + if ( iDSSyncTypeArray->Count() > 0 ) + { + for ( TInt j = 0; j < iDSSyncTypeArray->Count(); j++ ) + { + if ( (*profile->iContentTypes)[i]->IntValue( EDSAdapterTableId ) == iDSSyncTypeArray->At( j ).iTaskId) + { + if ( iSyncInitiation == EClientInitiated ) + { + if ( (*profile->iContentTypes)[i]->IntValue( EDSAdapterEnabled ) ) + { + addContent = ETrue; + serverAlert = ETrue; + syncType = iDSSyncTypeArray->At( j ).iType; + } + } + else + { + addContent = ETrue; + serverAlert = ETrue; + syncType = iDSSyncTypeArray->At( j ).iType; + } + + break; + } + } + } + else + { + addContent = (*profile->iContentTypes)[i]->IntValue( EDSAdapterEnabled ); + } + } + else + { + addContent = (*profile->iContentTypes)[i]->IntValue( EDSAdapterEnabled ); + } + + if ( addContent ) + { + iDSContent->AddNewContentL(); + iDSContent->SetImplementationUID( (*profile->iContentTypes)[i]->IntValue( EDSAdapterImplementationId ) ); + + CNSmlURI* database = CNSmlURI::NewLC( *iImeiCode ); + database->SetDatabaseL( (*profile->iContentTypes)[i]->StrValue( EDSAdapterClientDataSource ) ); + TRAPD( localDatabaseError, iDSContent->SetLocalDatabaseL( *database ) ); + + if ((*profile->iContentTypes)[i]->StrValue( EDSAdapterClientDataSource ) != database->DataBaseWithoutRelativePrefix()) + { + (*profile->iContentTypes)[i]->SetStrValue( EDSAdapterClientDataSource ,database->DataBaseWithoutRelativePrefix()); + profile->SaveL() ; + } + CleanupStack::PopAndDestroy(); // database + + if ( localDatabaseError ) + { + DBG_ARGS(_S("CNSmlDSAgent::ReadSettingsL: local database error %d"), localDatabaseError); + iDSContent->RemoveContent(); + /* CR: 403-1188 */ + if ( ifInternet == EFalse && + iSyncInitiation == EServerAlerted && + (*profile->iContentTypes)[i]->IntValue( EDSAdapterImplementationId ) == KUidNSmlAdapterEMail.iUid) + { + CNSmlDSContentType* type = profile->ContentType( KUidNSmlAdapterEMail.iUid ); + type->SetIntValue (EDSAdapterEnabled, EFalse) ; + profile->SaveL() ; + } // CR: 403-1188 + continue; + } + + database = CNSmlURI::NewLC( iSyncServer->HostNameWithPortL() ); + database->SetDatabaseL( (*profile->iContentTypes)[i]->StrValue( EDSAdapterServerDataSource ) ); + if(database->Database().Length() < 1) + { + isRemotedatabaseDefined = EFalse; + } + iDSContent->SetRemoteDatabaseL( *database ); + CleanupStack::PopAndDestroy(); //database + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* hostAddress = iSyncServer->HostName().AllocLC(); + + if ( !iDSContent->InitContentInstanceL( *hostAddress ) ) + { + iDSContent->RemoveContent(); + CleanupStack::PopAndDestroy(); // hostAddress + continue; + } + + CleanupStack::PopAndDestroy(); // hostAddress + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + if ( !iDSContent->InitContentInstanceL( *iDSServerId ) ) + { + iDSContent->RemoveContent(); + continue; + } + + RReadStream readStream( (*profile->iContentTypes)[i]->FilterReadStreamL() ); + CleanupClosePushL( readStream ); + + TInt numberOfFilters(0); + TInt error( KErrNone ); + TRAP(error, numberOfFilters = readStream.ReadInt32L() ); + + RPointerArray filters; + CleanupStack::PushL( TCleanupItem( DeleteRPointerArray, &filters ) ); + + for ( TInt filterIndex = 0; filterIndex < numberOfFilters; filterIndex++ ) + { + CSyncMLFilter* filter = CSyncMLFilter::NewLC( readStream ); + filters.AppendL( filter ); + CleanupStack::Pop(); // filter + } + + iDSContent->SetUsedFiltersL( filters, static_cast( (*profile->iContentTypes)[i]->IntValue( EDSAdapterFilterMatchType ) ) ); + + // ownership of array items is moved to iDSContent -> no need for ResetAndDestroy + filters.Close(); + + CleanupStack::Pop(); // filters + CleanupStack::PopAndDestroy(); // readStream + } + + if ( syncType == CNSmlDbCaps::EAllTypes ) + { + TSmlSyncType type = static_cast( (*profile->iContentTypes)[i]->IntValue( EDSAdapterSyncType ) ); + + switch ( type ) + { + case ESmlTwoWay: + syncType = CNSmlDbCaps::ETwoWaySync; + break; + + case ESmlOneWayFromServer: + syncType = CNSmlDbCaps::EOneWaySyncFromServer; + break; + + case ESmlOneWayFromClient: + syncType = CNSmlDbCaps::EOneWaySyncFromClient; + break; + + case ESmlSlowSync: + syncType = CNSmlDbCaps::ESlowTwoWaySync; + break; + + case ESmlRefreshFromServer: + syncType = CNSmlDbCaps::ERefreshSyncFromServer; + break; + + case ESmlRefreshFromClient: + syncType = CNSmlDbCaps::ERefreshSyncFromClient; + break; + + default: + User::Panic( _L("Sync type conversion error" ), type ); + } + } + + if ( syncType != CNSmlDbCaps::ESyncTypeNone ) + { + iDSContent->SetSyncTypeL( syncType ); + taskIdArray.Append( (*profile->iContentTypes)[i]->IntValue( EDSAdapterTableId ) ); + iDSContent->TaskId( (*profile->iContentTypes)[i]->IntValue( EDSAdapterTableId ) ); + + if ( serverAlert && iProtocolVer == ESmlVersion1_2 ) + { + iDSContent->SetAsServerAlerted(); + } + } + else + { + iDSContent->RemoveContent(); + } + } + } + + iSyncLog = CSyncMLHistoryJob::NewL( iProfileID, taskIdArray ); + + if ( iDSContent->Count() == 0 && iSyncInitiation == EClientInitiated ) + { + User::Leave( TNSmlError::ESmlErrorInSettings ); + } + // BPSS-7NZESW : If remote database value is empty,leave + //erorr log : Invalid remote database + if(!isRemotedatabaseDefined) + { + User::Leave( TNSmlError::ESmlStatusNotFound ); + } + taskIdArray.Close(); + CleanupStack::PopAndDestroy( 2 ); // profile, settings + DBG_FILE(_S8("CNSmlDSAgent::ReadSettingsL END")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::ReplaceIAPIdL() +// Gets IAPID from the Cenrep and if necessary will Replace +// the existing one +// --------------------------------------------------------- +void CNSmlDSAgent::ReplaceIAPIdL() +{ + //Check whether the Auto Restart Feature is enabled or not + TInt keyVal; + TRAPD (err ,ReadRepositoryL(KNsmlDsAutoRestart, keyVal)); + + if(err==KErrNone && keyVal==1) + { + TInt LastUsedIAPId = 0; + + CNsmlProfileUtil* profileUtil = CNsmlProfileUtil::NewLC(); + + if(iAutoRestartInitiatedSync) + { + //Read the IAPID from the Cenrep + profileUtil->AccessPointIdL(LastUsedIAPId); + if(LastUsedIAPId > 0) + { + //Check Whether the IAPID still exists + TApBearerType bearertype = CheckAPBearerTypeL(LastUsedIAPId); + if(bearertype != TApBearerType(-1)) + { + iIAPId = LastUsedIAPId; + DBG_FILE_CODE(iIAPId , _S8("CNSmlDSAgent::ReadSettingsL, The Access Point ID Replaced from the CenRep:")); + } + else + { + //Stop the DS Sync Session + DBG_FILE(_S8("CNSmlDSAgent::ReadSettingsL, The Access Point ID is invalid so stopping the session")); + iPacketDataUnAvailable = ETrue; + StopDSSession(); + } + } + } + + CleanupStack::PopAndDestroy(profileUtil); + } +} + +// --------------------------------------------------------- +// CNSmlDSAgent::GetSessionIDL() +// Gets SessionID from Agent Log +// --------------------------------------------------------- +TInt CNSmlDSAgent::GetSessionIDL() + { + CNSmlDSAgentLog* agentLog( CNSmlDSAgentLog::NewLC() ); + TInt sessionID( 0 ); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey = iSyncServer->HostName().AllocLC(); + sessionID = agentLog->SessionIDL( *searchKey ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + sessionID = agentLog->SessionIDL( *iDSServerId ); + } + + CleanupStack::PopAndDestroy(); // agentLog + + return sessionID; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::UpdateSessionIDL() +// Updates SessionID in Agent Log +// --------------------------------------------------------- +void CNSmlDSAgent::UpdateSessionIDL( TInt aSessionID ) + { + CNSmlDSAgentLog* agentLog( CNSmlDSAgentLog::NewLC() ); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey = iSyncServer->HostName().AllocLC(); + agentLog->SetSessionIDL( *searchKey, aSessionID ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + agentLog->SetSessionIDL( *iDSServerId, aSessionID ); + } + + CleanupStack::PopAndDestroy(); // agentLog + } + +// --------------------------------------------------------- +// CNSmlDSAgent::FinishL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::FinishL() + { + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlDisconnected, 0, 0 ); + + if ( iDSContent->AllDatabasesAreInterrupted() ) + { + DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, iError->SyncLogErrorCode(), 0, 0, 0 ); + User::RequestComplete( iCallerStatus, iError->SyncLogErrorCode() ); + } + else if ( iDSContent->AnyDatabaseIsInterrupted() ) + { + DoErrorEvent( MSyncMLProgressObserver::ESmlWarning, iError->SyncLogErrorCode(), 0, 0, 0 ); + iError->SetErrorCode( KErrNone ); + User::RequestComplete( iCallerStatus, KErrNone ); + } + //RD_AUTO_RESTART (BPSS-7GBGHP) + else if(iPacketDataUnAvailable) + { + DBG_FILE(_S8("CNSmlDSAgent::FinishL(), Setting the Dialog Text")); + + DoErrorEvent(MSyncMLProgressObserver::ESmlFatalError, + TNSmlError::ESmlCommunicationError, 0, 0, 0 ); + iError->SetErrorCode( TNSmlError::ESmlCommunicationError); + User::RequestComplete( iCallerStatus, TNSmlError::ESmlCommunicationError ); + } + //RD_AUTO_RESTART + else + { + User::RequestComplete( iCallerStatus, KErrNone ); + } + + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlCompleted, 0, 0 ); + + iEnd = ETrue; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::DoCancel +// Cancels ongoing asynchronous operations. +// --------------------------------------------------------- +void CNSmlDSAgent::DoCancel() + { + if ( iCommandIssued ) + { + TInt err( KErrNone ); + TRAP( err, iDSContent->CancelRequestL() ); + } + CNSmlAgentBase::DoCancel(); + } + +// +// Callback functions implementation +// +// --------------------------------------------------------- +// CNSmlDSAgent::smlAlertCmdFuncL +// Alert command from server. +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlAlertCmdFuncL( SmlAlertPtr_t aContent ) + { + iCallbackCalled = ETrue; + + if ( iSyncMLCmds->AlertCode( aContent ) < KNSmlDSMeaningfulAlertMin || + iSyncMLCmds->AlertCode( aContent ) > KNSmlDSMeaningfulAlertMax ) + { + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAlert, aContent->cmdID, aContent->flags ); + } + else + { + switch ( iCurrMainState ) + { + case EBeginning: + ServerAlertAlertCmdStateL( aContent ); + break; + + case EServerInitialisation: + ServerInitAlertCmdStateL( aContent ); + break; + + case EServerAlertNext: + ServerAlertNextAlertCmdStateL( aContent ); + break; + + case EServerModifications: + ServerModAlertCmdStateL( aContent ); + break; + + case EMapAcknowledge: + MapAckAlertCmdStateL( aContent ); + break; + + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAlert, aContent->cmdID, aContent->flags ); + } + } + + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlGetCmdFuncL +// Get command from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlGetCmdFuncL( SmlGetPtr_t aContent ) + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerInitialisation: + ServerInitGetCmdStateL( aContent ); + break; + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentGet, aContent->cmdID, aContent->flags ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlPutCmdFuncL +// Put command from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlPutCmdFuncL( SmlPutPtr_t aContent ) + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerInitialisation: + ServerInitPutCmdStateL( aContent ); + break; + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentPut, aContent->cmdID, aContent->flags ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlResultsCmdFuncL +// Results command from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlResultsCmdFuncL( SmlResultsPtr_t aContent ) + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerInitialisation: + ServerInitResultsCmdStateL( aContent ); + break; + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentResults, aContent->cmdID ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlStatusCmdFuncL +// Status command from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlStatusCmdFuncL( SmlStatusPtr_t aContent ) + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerInitialisation: + ServerInitStatusCmdStateL( aContent ); + break; + case EServerModifications: + ServerModStatusCmdStateL( aContent ); + break; + case EMapAcknowledge: + MapAckStatusCmdStateL( aContent ); + break; + case EServerAlertNext: + ServerAlertNextStatusCmdStateL( aContent ); + break; + default: + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlStartMessageFuncL +// SyncHdr from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlStartMessageFuncL( SmlSyncHdrPtr_t aContent ) + { + iCallbackCalled = ETrue; + + switch ( iCurrMainState ) + { + case EBeginning: + ServerAlertStartMessageStateL( aContent ); + break; + + case EServerInitialisation: + ServerInitStartMessageStateL( aContent ); + break; + + case EServerModifications: + ServerModStartMessageStateL( aContent ); + break; + + case EMapAcknowledge: + MapAckStartMessageStateL( aContent ); + break; + + case EServerAlertNext: + ServerAlertNextStartMessageStateL( aContent ); + break; + + default: + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlEndMessageFuncL +// End of SyncML message was reached +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlEndMessageFuncL( Boolean_t aFinal ) + { + iCallbackCalled = ETrue; + + switch ( iCurrMainState ) + { + case EBeginning: + ServerAlertEndMessageStateL( aFinal ); + break; + + case EServerInitialisation: + ServerInitEndMessageStateL( aFinal ); + break; + + case EServerModifications: + ServerModEndMessageStateL( aFinal ); + break; + + case EMapAcknowledge: + MapAckEndMessageStateL( aFinal ); + break; + + case EServerAlertNext: + ServerAlertNextEndMessageStateL( aFinal ); + break; + + default: + User::Leave( TNSmlError::ESmlUnexpectedCmd ); + } + + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlStartSyncFuncL +// Sync command from server +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlStartSyncFuncL( SmlSyncPtr_t aContent ) + { + iCallbackCalled = ETrue; + + switch ( iCurrMainState ) + { + case EServerModifications: + ServerModStartSyncStateL( aContent ); + break; + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentSync, aContent->cmdID, aContent->flags ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlEndSyncFuncL +// End of Sync command was reached +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlEndSyncFuncL() + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerModifications: + ServerModEndSyncStateL(); + break; + default: + break; + } + return 0; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::smlStartAtomicFuncL +// Atomic command from server. +// ----------------------------------------------------------------------------- +// +Ret_t CNSmlDSAgent::smlStartAtomicFuncL( SmlAtomicPtr_t aContent ) + { + iCallbackCalled = ETrue; + + switch ( iCurrMainState ) + { + case EServerModifications: + ServerModStartAtomicStateL( aContent ); + break; + + default: + iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentAtomic, aContent->cmdID, aContent->flags ); + break; + } + + return 0; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::smlEndAtomicFuncL +// The end of the Atomic command was reached. +// ----------------------------------------------------------------------------- +// +Ret_t CNSmlDSAgent::smlEndAtomicFuncL() + { + iCallbackCalled = ETrue; + + ServerModEndAtomicStateL(); + + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlStartSequenceFuncL +// Sequence command from server, Sequence is not supported +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlStartSequenceFuncL( SmlSequencePtr_t aContent ) + { + iCallbackCalled = ETrue; + iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentSequence, aContent->cmdID, aContent->flags ); + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::smlEndSequenceFuncL +// +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlEndSequenceFuncL() + { + iCallbackCalled = ETrue; + return 0; + } + + +// --------------------------------------------------------- +// CNSmlDSAgent::smlMoveCmdFuncL +// +// --------------------------------------------------------- +Ret_t CNSmlDSAgent::smlMoveCmdFuncL( SmlMovePtr_t aContent ) + { + iCallbackCalled = ETrue; + switch ( iCurrMainState ) + { + case EServerModifications: + ServerModUpdatesStateL( KNSmlAgentMove(), aContent ); + break; + default: + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAdd, aContent->cmdID, aContent->flags ); + } + return 0; + } + +// --------------------------------------------------------- +// CNSmlDSAgent::NavigateMainStateL() +// Navigate according to state code +// --------------------------------------------------------- +void CNSmlDSAgent::NavigateMainStateL() + { + switch ( iCurrMainState ) + { + case EBeginning: + BeginningStateL(); + break; + case EClientInitialisation: + ClientInitialisationStateL(); + break; + case EServerInitialisation: + ServerInitialisationStateL(); + break; +// + case EClientResendMapInfo: + ClientResendMapInfoStateL(); + break; +// + case EClientModifications: + ClientModificationsStateL(); + break; + case EServerModifications: + ServerModificationsStateL(); + break; + case EDataUpdateStatus: + DataUpdateStatusStateL(); + break; + case EMapAcknowledge: + MapAcknowledgeStateL(); + break; + case EResultAlert: + ResultAlertStateL(); + break; + case EClientAlertNext: + ClientAlertNextStateL(); + break; + case EServerAlertNext: + ServerAlertNextStateL(); + break; + case EFinishing: + FinishingStateL(); + break; + case ESending: + SendingStateL(); + break; + case EReceiving: + ReceivingStateL(); + break; + default: + User::Leave( KErrGeneral ); + } + } + +// --------------------------------------------------------- +// CNSmlDSAgent::NextMainStateL() +// Change main state +// --------------------------------------------------------- +void CNSmlDSAgent::NextMainStateL() + { + switch ( iCurrMainState ) + { + case EBeginning: + if ( iSyncInitiation == EClientInitiated && iDSContent->AllDatabasesAreInterruptedImmediately() ) + { + iCurrMainState = EFinishing; + } + else + { + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlConnected, 0, 0 ); + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlLoggingOn, 0, 0 ); + iCurrMainState = EClientInitialisation; + } + break; + + case EClientInitialisation: + iPrevSyncState = iCurrMainState; + iCurrMainState = ESending; + break; + + case EServerInitialisation: + iPrevSyncState = iCurrMainState; + if ( iDSContent->AllDatabasesAreInterruptedImmediately() ) + { + iCurrMainState = EFinishing; + } + else + { + if ( iBusyStatusReceived ) + { + iCurrMainState = EResultAlert; + } + else + { + if ( iChallengeRequest ) + { + iCurrMainState = EClientInitialisation; + } + else + { + if ( iDSCurrServerInitState == EServerInitMessageReceived ) + { + iCurrMainState = EClientAlertNext; + } + else + { + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlLoggedOn, 0, 0 ); +// + iCurrMainState = EClientResendMapInfo; + DBG_FILE(_S8("CNSmlDSAgent::NextMainStateL Moved to EClientResendMapInfo...")); + // iCurrMainState = EClientModifications; +// + } + } + } + } + break; +// + case EClientResendMapInfo: + iPrevSyncState = iCurrMainState; + if(iMapResendStatusPackage) + { + iCurrMainState = ESending; + } + else + { + iCurrMainState = EClientModifications; + } + break; +// + case EClientModifications: + iPrevSyncState = iCurrMainState; + iCurrMainState = ESending; + break; + + case EServerModifications: + iPrevSyncState = iCurrMainState; + if ( iDSContent->AllDatabasesAreInterruptedImmediately() ) + { + iCurrMainState = EFinishing; + } + else + { + if ( iBusyStatusReceived ) + { + iCurrMainState = EResultAlert; + } + else + { + if ( iCurrServerModState == EServerModMessageReceived ) + { + iCurrMainState = EClientAlertNext; + } + else + { + iCurrMainState = EDataUpdateStatus; + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlSendingMappingsToServer, 0, 0 ); + } + } + } + break; + + case EDataUpdateStatus: + iPrevSyncState = iCurrMainState; + if ( iStatusPackage && ( !iDSContent->AllDatabasesOneWayFromClient() ) ) + { + iCurrMainState = ESending; + } + else + { + iCurrMainState = EFinishing; + } + break; + + case EMapAcknowledge: +// + if(iPrevSyncState==EClientResendMapInfo) + { + iCurrMainState = EClientModifications; + // If map exitst remove map info, think to implement. + iDSContent->CleanMapInfo(); + } + else + { +// + iPrevSyncState = iCurrMainState; + if ( iDSContent->AllDatabasesAreInterruptedImmediately() ) + { + iCurrMainState = EFinishing; + } + else + { + if ( iBusyStatusReceived ) + { + iCurrMainState = EResultAlert; + } + else + { + if ( iDSCurrMapAcknowledgeState == EMapAckMessageReceived ) + { + iCurrMainState = EClientAlertNext; + } + else + { + iCurrMainState = EFinishing; + } + } + } +// + } +// + break; + + case EResultAlert: + iCurrMainState = ESending; + break; + + case EClientAlertNext: + iCurrMainState = ESending; + break; + + case EServerAlertNext: + if ( iDSContent->AllDatabasesAreInterruptedImmediately() ) + { + iCurrMainState = EFinishing; + } + else + { + iCurrMainState = iPrevSyncState; + } + break; + + case ESending: + if ( iDSContent->AllDatabasesAreInterrupted() ) + { + iCurrMainState = EFinishing; + } + else + { + iCurrMainState = EReceiving; + } + break; + + case EReceiving: + if ( ( !iFinalMessageFromClient ) && + ( iPrevSyncState == EClientModifications || iPrevSyncState == EDataUpdateStatus ) ) + { + iCurrMainState = EServerAlertNext; + } + else + if ( iPrevSyncState == EClientInitialisation || iPrevSyncState == EServerInitialisation ) + { + iCurrMainState = EServerInitialisation; + } + else + if ( iPrevSyncState == EClientModifications || iPrevSyncState == EServerModifications ) + { + iCurrMainState = EServerModifications; + } + else + { + iCurrMainState = EMapAcknowledge; + }; + + iDSContent->UpdateInterruptedFlags(); + break; + + default: + break; + } + + InitialiseSubStates(); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::InitialiseSubStates() +// +// --------------------------------------------------------- +// +void CNSmlDSAgent::InitialiseSubStates() + { + iCurrBeginningState = EBegin; + iDSCurrBeginSubState = EBeginSubStart; + iCurrClientInitState = EInitStartingMessage; + iDSCurrServerInitState = EServerInitWaitingStartMessage; + iDSCurrClientModState = EClientModStartingMessage; + iCurrResultAlertState = EResultAlertStartingMessage; + iCurrServerModState = EServerModWaitingStartMessage; + iCurrDataUpdateStatusState = EStatusStartingMessage; + iDSCurrMapAcknowledgeState = EMapAckWaitingStartMessage; + iCurrResultAlertState = EResultAlertStartingMessage; + iCurrClientAlertNextState = EClientAlertNextStartingMessage; + iCurrServerAlertNextState = EServerAlertNextWaitingStartMessage; + } + +// +// Beginning state functions +// +// +// --------------------------------------------------------- +// CNSmlDSAgent::BeginStateL() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginStateL() + { + switch ( iDSCurrBeginSubState ) + { + case EBeginSubStart: + BeginSubStartStateL(); + break; + case EBeginSubReadSettings: + BeginSubReadSettingsStateL(); + break; + case EBeginSubSyncmlCmdsInstance: + BeginSubSyncmlCmdsInstanceStateL(); + break; + case EBeginSubServerAlerting: + BeginSubServerAlertingStateL(); + break; + case EBeginSubOpenContentInstances: + BeginSubOpenContentInstancesStateL(); + break; +// + case EBeginSubScanMapInfo: + BeginSubScanMapInfo(); + break; +// + case EBeginSubCreateLUIDBuffers: + BeginSubCreateLUIDBuffersStateL(); + break; + default: + User::Leave( KErrGeneral ); + } + } + +// +// Server Modifications state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::ServerModUpdatesStateL(() +// Handles Add, Replace or Delete command from server +// --------------------------------------------------------- +void CNSmlDSAgent::ServerModUpdatesStateL( const TDesC8& aCmd, SmlGenericCmd_t* aContent ) + { + DBG_FILE(_S8("CNSmlDSAgent::ServerModUpdatesStateL begins")); + if ( iCurrServerModState != EServerModWaitingUpdateCommands ) + { + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, aCmd, aContent->cmdID, aContent->flags ); + } + if ( iDSContent->ContentIndexIsSet() ) + { + if ( iDSContent->SyncType() == KNSmlDSOneWayFromClient || + iDSContent->SyncType() == KNSmlDSOneWayFromClientByServer || + iDSContent->SyncType() == KNSmlDSRefreshFromClient || + iDSContent->SyncType() == KNSmlDSRefreshFromClientByServer ) + { + iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, aCmd, aContent->cmdID, aContent->flags ); + } + else + { + iSyncMLCmds->ProcessUpdatesL( aCmd, aContent ); + } + } + else + { + iSyncMLCmds->ProcessUpdatesL( aCmd, aContent ); + } + DBG_FILE(_S8("CNSmlDSAgent::ServerModUpdatesStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::DataUpdateStatusStartingMessageStateL() +// Notify "Finalising" to UI, makes SyncHdr +// --------------------------------------------------------- +void CNSmlDSAgent::DataUpdateStatusStartingMessageStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::DataUpdateStatusStartingMessageStateL begins")); + DataUpdateStatusStartingMessageStateBaseL(); + iDSContent->SetToFirst(); + DBG_FILE(_S8("CNSmlDSAgent::DataUpdateStatusStartingMessageStateL ends")); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::DataUpdateStatusMakingMapStateL() +// Makes Map command(s) +// --------------------------------------------------------- +void CNSmlDSAgent::DataUpdateStatusMakingMapStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::DataUpdateStatusMakingMapStateL begins")); + CNSmlCmdsBase::TReturnValue ret; + ret = iSyncMLCmds->DoMapL(); + switch ( ret ) + { + case CNSmlCmdsBase::EReturnOK: + iDSWaitingForMapAcknowledgement = ETrue; + // there is something to send + iStatusPackage = ETrue; + if ( !iDSContent->SetToNext() ) + { + iCurrDataUpdateStatusState = EStatusEndingMessage; + } + break; + case CNSmlCmdsBase::EReturnEndData: + if ( !iDSContent->SetToNext() ) + { + iCurrDataUpdateStatusState = EStatusEndingMessage; + } + break; + case CNSmlCmdsBase::EReturnBufferFull: + iBufferFull = ETrue; + iCurrDataUpdateStatusState = EStatusEndingMessage; + break; + default: + break; + } + DBG_FILE(_S8("CNSmlDSAgent::DataUpdateStatusMakingMapStateL ends")); + } + +// +// Alert for next state functions +// + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::ClientAlertNextMakingMapStateL +// Makes Map command(s). +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::ClientAlertNextMakingMapStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientAlertNextMakingMapStateL begins")); + + iDSContent->SetToFirst(); + + do + { + if ( iSyncMLCmds->DoMapL() == CNSmlCmdsBase::EReturnBufferFull ) + { + break; + } + } + while ( iDSContent->SetToNext() ); + + iCurrClientAlertNextState = EClientAlertNextEndingMessage; + + DBG_FILE(_S8("CNSmlDSAgent::ClientAlertNextMakingMapStateL ends")); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::NonceL +// Nonce (used in MD5 auth) from Agent Log +// ----------------------------------------------------------------------------- +// +HBufC* CNSmlDSAgent::NonceL() const + { + CNSmlDSAgentLog* agentLog = CNSmlDSAgentLog::NewLC(); + HBufC* nonce( NULL ); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey( iSyncServer->HostName().AllocLC() ); + nonce = agentLog->NonceL( *searchKey ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + nonce = agentLog->NonceL( *iDSServerId ); + } + + CleanupStack::PopAndDestroy(); // agentLog + + return nonce; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::SetNonceL +// Nonce from the server's challenge is stored to the Agent Log. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::SetNonceL( const TDesC& aNonce ) const + { + CNSmlDSAgentLog* agentLog = CNSmlDSAgentLog::NewLC(); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey( iSyncServer->HostName().AllocLC() ); + agentLog->SetNonceL( *searchKey, aNonce ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + agentLog->SetNonceL( *iDSServerId, aNonce ); + } + + CleanupStack::PopAndDestroy(); // agentLog + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::FinalizeSyncLog +// Writes the sync history after synchronisation. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::FinalizeSyncLog() + { + TInt err( KErrNone ); + TRAP( err, FinalizeSyncLogL() ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::FinalizeSyncLogL +// Writes the sync history after synchronisation. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::FinalizeSyncLogL() + { + if ( iSyncLog ) + { + iDSContent->FinalizeSyncLogEvents(); + + TTime time; + time.UniversalTime(); + iSyncLog->SetResult( time, iError->SyncLogErrorCode() ); + + CNSmlDSSettings* settings = CNSmlDSSettings::NewLC(); + CNSmlDSProfile* profile = settings->ProfileL( iProfileID ); + CleanupStack::PushL( profile ); + CNSmlHistoryArray* array = CNSmlHistoryArray::NewL(); + CleanupStack::PushL( array ); + array->SetOwnerShip( ETrue ); + + RReadStream& readStream = profile->LogReadStreamL(); + CleanupClosePushL( readStream ); + + if ( readStream.Source()->SizeL() > 0 ) + { + array->InternalizeL( readStream ); + } + + CleanupStack::PopAndDestroy(); // readStream + + array->AppendEntryL( iSyncLog ); + RWriteStream& writeStream = profile->LogWriteStreamL(); + CleanupClosePushL( writeStream ); + array->ExternalizeL( writeStream ); + CleanupStack::PopAndDestroy(); // writeStream + profile->WriteStreamCommitL(); + + CleanupStack::PopAndDestroy( 3 ); // array, settings, profile + + iSyncLog = NULL; + } + + // Set sync stopped to P&S + RProperty::Set( KPSUidDataSynchronizationInternalKeys, KDataSyncStatus, EDataSyncNotRunning ); + + ResetDSSessionInfoL(); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::WriteWarningL +// Sync level warning message to the Sync Log. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::WriteWarningL( TNSmlError::TNSmlAgentErrorCode aWarningCode ) + { + iDSContent->SetToFirst(); + + do + { + InfoMessageToSyncLogL( iDSContent->CurrentIndex(), aWarningCode ); + iDSContent->IncreaseWarnings(); + } + while ( iDSContent->SetToNext() ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::WriteWarningL +// Datastore level warning message to the Sync Log. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::WriteWarningL( TInt appIndex, TNSmlError::TNSmlAgentErrorCode aWarningCode ) + { + InfoMessageToSyncLogL( appIndex, aWarningCode ); + iDSContent->SetIndex( appIndex ); + iDSContent->IncreaseWarnings(); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::WriteWarningL +// Datastore level warning message to the Sync Log. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::WriteWarningL( TInt appIndex, TNSmlError::TNSmlSyncMLStatusCode aWarningCode ) + { + InfoMessageToSyncLogL( appIndex, aWarningCode ); + iDSContent->SetIndex( appIndex ); + iDSContent->IncreaseWarnings(); + } + +// --------------------------------------------------------- +// CNSmlDSAgent::CheckServerStatusCodeL() +// Status code validating +// --------------------------------------------------------- +void CNSmlDSAgent::CheckServerStatusCodeL( TInt aEntryID ) + { + TDesC8& cmd = iSyncMLCmds->ResponseController()->Cmd( aEntryID ); + TNSmlError::TNSmlSyncMLStatusCode status = STATIC_CAST( TNSmlError::TNSmlSyncMLStatusCode, iSyncMLCmds->ResponseController()->StatusCode( aEntryID ) ); + TBool error( EFalse ); + + switch ( status ) + { + case TNSmlError::ESmlStatusInProgress: + if ( cmd != KNSmlAgentSyncHdr ) + { + error = ETrue; + } + break; + + case TNSmlError::ESmlStatusOK: + case TNSmlError::ESmlStatusItemAdded: + case TNSmlError::ESmlStatusAcceptedForProcessing: + case TNSmlError::ESmlStatusNonAuthoriveResponse: + case TNSmlError::ESmlStatusNoContent: + case TNSmlError::ESmlStatusResetContent: + case TNSmlError::ESmlStatusConflictResolvedWithMerge: + case TNSmlError::ESmlStatusConflictResolvedWithClientsCommand: + case TNSmlError::ESmlStatusConflictResolvedWithDuplicate: + case TNSmlError::ESmlStatusConflict: + case TNSmlError::ESmlStatusConflictResolvedWithServerData: + case TNSmlError::ESmlStatusSoftDeleteUpdateConflict: + case TNSmlError::ESmlStatusDeleteWithoutArchive: + case TNSmlError::ESmlStatusItemIsNotDeleted: + case TNSmlError::ESmlStatusItemAccepted: + case TNSmlError::ESmlStatusAlreadyExists: + break; + + case TNSmlError::ESmlStatusAuthenticationAccepted: // 212 + if ( cmd == KNSmlAgentSyncHdr ) + { + iAlreadyAuthenticated = ETrue; + } + break; + + case TNSmlError::ESmlStatusUnauthorized: // 401 + if ( cmd == KNSmlAgentSyncHdr && iCurrMainState == EServerInitialisation ) + { + if ( iSyncMLCmds->ResponseController()->ChalType( aEntryID ).Length() != 0 ) + { + if ( AuthenticationRequirementL( *iSyncMLCmds->ResponseController(), aEntryID ) ) + { + iChallengeRequest = ETrue; + SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID ); + iSyncMLCmds->ResponseController()->ResetL(); + return; + } + else + { + // If authentication has failed then rest of the package is not + // important anymore. + User::Leave( status ); + } + } + else + { + // If authentication has failed then rest of the package is not + // important anymore. + User::Leave( status ); + } + } + break; + + case TNSmlError::ESmlStatusClientAuthenticationRequired: // 407 + if ( cmd == KNSmlAgentSyncHdr && iCurrMainState == EServerInitialisation ) + { + if ( AuthenticationRequirementL( *iSyncMLCmds->ResponseController(), aEntryID ) ) + { + iChallengeRequest = ETrue; + SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID ); + iSyncMLCmds->ResponseController()->ResetL(); + return; + } + } + error = ETrue; + break; + + case TNSmlError::ESmlStatusRefreshRequired: + if ( cmd == KNSmlAgentSync ) + { + TInt appIndex( -1 ); + appIndex = iSyncMLCmds->ResponseController()->AppIndex( aEntryID ); + iDSContent->SetIndex( appIndex ); + iDSContent->SetSlowSyncReqForNextSyncL( ETrue ); + } + //RD_SUSPEND_RESUME + if(iDSContent->SetToFirst()) + { + do + { + if ( iDSContent->GetSessionResumed() ) + { + if(cmd==KNSmlAgentAlert) + { + iDSContent->SetRefreshRequiredL(ETrue); + } + } + }while( iDSContent->SetToNext() ); + + } + //RD_SUSPEND_RESUME + break; + + default: + error = ETrue; + } + + if ( cmd == KNSmlAgentSyncHdr ) + { + SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID ); + } + + if ( cmd == KNSmlAgentAlert ) + { + if ( iSyncMLCmds->ResponseController()->ResponseDetail( aEntryID ) == CNSmlResponseController::EResponseInitAlert ) + { + if ( status == TNSmlError::ESmlStatusOptFeatureNotSupported ) + { + status = (TNSmlError::TNSmlSyncMLStatusCode) TNSmlDSError::ESmlDSUnsupportedSyncType; + } + else + { + if ( status == TNSmlError::ESmlStatusCommandFailed || + status == TNSmlError::ESmlStatusCommandNotAllowed ) + { + iDSContent->SetIndex( iSyncMLCmds->ResponseController()->AppIndex ( aEntryID ) ); + if ( !iDSContent->IsSupportedSyncTypeByServerL() ) + { + status = (TNSmlError::TNSmlSyncMLStatusCode) TNSmlDSError::ESmlDSUnsupportedSyncType; + } + else + { + if ( status == TNSmlError::ESmlStatusCommandFailed ) + { + status = TNSmlError::ESmlStatusNotFound; + } + } + } + } + } + } + + if ( cmd == KNSmlAgentAdd || cmd == KNSmlAgentReplace || cmd == KNSmlAgentPartialReplace || cmd == KNSmlAgentDelete || cmd == KNSmlAgentMove || cmd == KNSmlAgentSoftDelete ) + { + if ( !iSyncMLCmds->ResponseController()->MoreData( aEntryID ) ) + { + iDSContent->SetIndex( iSyncMLCmds->ResponseController()->AppIndex ( aEntryID ) ); + TLex8 lex( iSyncMLCmds->ResponseController()->LUID( aEntryID ) ); + TInt val; + lex.Val( val ); + iDSContent->SetAsReceivedL( val ); + } + } + + if ( !error ) + { + if ( cmd == KNSmlAgentAdd || cmd == KNSmlAgentReplace || cmd == KNSmlAgentPartialReplace ) + { + if ( status == TNSmlError::ESmlStatusItemAdded ) + { + iDSContent->IncreaseItemsAdded(); + } + else + { + if ( status != TNSmlError::ESmlStatusItemAccepted ) + { + iDSContent->IncreaseItemsChanged(); + } + } + } + + if ( cmd == KNSmlAgentDelete || cmd == KNSmlAgentSoftDelete ) + { + if ( status != TNSmlError::ESmlStatusItemIsNotDeleted ) + { + iDSContent->IncreaseItemsDeleted(); + } + } + + if (cmd == KNSmlAgentMove) + { + if ( status == TNSmlError::ESmlStatusOK ) + { + iDSContent->IncreaseItemsMoved(); + } + } + } + else + { + if ( cmd == KNSmlAgentAdd || cmd == KNSmlAgentReplace || cmd == KNSmlAgentPartialReplace || cmd == KNSmlAgentDelete || cmd == KNSmlAgentMove || cmd == KNSmlAgentSoftDelete ) + { + iDSContent->IncreaseItemsFailed(); + } + else + { + InterruptL( iSyncMLCmds->ResponseController()->AppIndex( aEntryID ), status, ETrue, ETrue ); + } + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::CheckCommandsAreReceivedL +// Checks that server has sent all expected commands. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::CheckCommandsAreReceivedL() + { + if ( iDSDeviceInfoRequestByClient ) + { + Interrupt( TNSmlDSError::ESmlDSDeviceInfoMissing, ETrue, EFalse ); + } + + iDSContent->SetToFirst(); + + do + { + if ( !iDSContent->Interrupted() ) + { + if ( iDSContent->WaitingInitAlert() ) + { + InterruptL( iDSContent->CurrentIndex(), TNSmlError::ESmlAlertMissingInInitialisation, EFalse, EFalse ); + } + } + } + while ( iDSContent->SetToNext() ); + } + +// +// Authentications +// + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::AuthTypeL +// Gets authentication type (basic/MD5) from the Agent Log. +// ----------------------------------------------------------------------------- +// +CNSmlAgentBase::TAuthenticationType CNSmlDSAgent::AuthTypeL() const + { + CNSmlAgentBase::TAuthenticationType authType( ENoAuth ); + CNSmlDSAgentLog* agentLog = CNSmlDSAgentLog::NewLC(); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey( iSyncServer->HostName().AllocLC() ); + authType = (CNSmlAgentBase::TAuthenticationType)agentLog->AuthTypeL( *searchKey ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + authType = (CNSmlAgentBase::TAuthenticationType)agentLog->AuthTypeL( *iDSServerId ); + } + + CleanupStack::PopAndDestroy(); // agentLog + + return authType; + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::SetAuthTypeL +// Saves authentication type to the Agent Log. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::SetAuthTypeL( CNSmlAgentBase::TAuthenticationType aAuthType ) const + { + CNSmlDSAgentLog* agentLog = CNSmlDSAgentLog::NewLC(); + + if ( iProtocolVer == ESmlVersion1_1_2 ) + { + HBufC* searchKey( iSyncServer->HostName().AllocLC() ); + agentLog->SetAuthTypeL( *searchKey, (TNSmlAgentLogAuthenticationType)aAuthType ); + CleanupStack::PopAndDestroy(); // searchKey + } + else if ( iProtocolVer == ESmlVersion1_2 ) + { + agentLog->SetAuthTypeL( *iDSServerId, (TNSmlAgentLogAuthenticationType)aAuthType ); + } + + CleanupStack::PopAndDestroy(); // agentLog + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::FreeResources +// Releases allocated resources. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::FreeResources() + { + FreeBaseResources(); + if(iEnd) + { + delete iDSContent; + iDSContent = NULL; + } + } + +// +// Error Handling functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::Interrupt() +// Synchronisation with all databases is interrupted +// Synchronisation level error code to Sync Log. +// --------------------------------------------------------- +void CNSmlDSAgent::Interrupt( TInt aErrorCode, TBool aImmediatelyInterruption, TBool aStatusError ) + { + DBG_FILE(_S8("CNSmlDSAgent::Interrupt()")); + + if ( !iDSContent->AllDatabasesAreInterrupted() || aStatusError ) + { + // Error code is updated only once, except errors due to + // error Status codes from the server + DoErrorEvent( MSyncMLProgressObserver::ESmlFatalError, aErrorCode, iDSContent->TaskId(), 0, 0 ); + } + + TBool ret( iDSContent->SetToFirst() ); + + while ( ret ) + { + + if ( !iDSContent->Interrupted() ) + { + iDSContent->SetInterrupted(); + } + + if ( aImmediatelyInterruption ) + { + // if immediately interrupted then no response is sent + iDSContent->SetImmediatelyInterrupted(); + } + + if ( aStatusError ) + { + // error due to error Status from a server + iDSContent->SetServerStatusError(); + } + + ret = iDSContent->SetToNext(); + + } + } + +//RD_SUSPEND_RESUME +// --------------------------------------------------------- +// CNSmlDSAgent::MapAlertCode() +// Maps the alert code +// --------------------------------------------------------- + +TNSmlPreviousSyncType CNSmlDSAgent::MapAlertCode(TDes8& aAlertCode) +{ + TNSmlPreviousSyncType alertcode=ETypeNotSet; + + if ( aAlertCode == KNSmlDSTwoWay ) + { + alertcode = ESyncDSTwoWay; + } + else if ( aAlertCode == KNSmlDSSlowSync ) + { + alertcode = ESyncDSSlowSync; + } + else if ( aAlertCode == KNSmlDSOneWayFromClient ) + { + alertcode = ESyncDSOneWayFromClient; + } + else if ( aAlertCode == KNSmlDSRefreshFromClient ) + { + alertcode = ESyncDSRefreshFromClient; + } + else if ( aAlertCode == KNSmlDSOneWayFromServer ) + { + alertcode = ESyncDSOneWayFromServer; + } + else if(aAlertCode ==KNSmlDSRefreshFromServer) + { + alertcode =ESyncDSRefreshFromServer; + } + else if(aAlertCode ==KNSmlDSTwoWayByServer) + { + alertcode =ESyncDSTwoWayByServer; + } + else if(aAlertCode ==KNSmlDSOneWayFromClientByServer) + { + alertcode =ESyncDSOneWayFromClientByServer; + } + else if(aAlertCode ==KNSmlDSRefreshFromClientByServer) + { + alertcode =ESyncDSRefreshFromClientByServer; + } + else if(aAlertCode ==KNSmlDSOneWayFromServerByServer) + { + alertcode =ESyncDSOneWayFromServerByServer; + } + else if(aAlertCode ==KNSmlDSRefreshFromServerByServer) + { + alertcode = ESyncDSRefreshFromServerByServer; + } + + return(alertcode); + +} +//RD_SUSPEND_RESUME + +// CNSmlDSAgent::InterruptL() +// Synchronisation with a given database is interrupted +// --------------------------------------------------------- +void CNSmlDSAgent::InterruptL( TInt appIndex, TInt aErrorCode, TBool aImmediatelyInterruption, TBool aStatusError ) + { + DBG_FILE(_S8("CNSmlDSAgent::InterruptL()")); + if ( !iDSContent->SetIndex( appIndex ) ) + { + // if index does not point to a database, interrupt all databases + Interrupt( aErrorCode, aImmediatelyInterruption, aStatusError ); + } + else + { + iDSContent->SetIndex( appIndex ); + if ( ( !iDSContent->Interrupted() ) || + ( aStatusError && !iDSContent->ServerStatusError() ) ) + { + // only one message to Sync Log expect Status code errors from a server + iDSContent->SetInterrupted(); + InfoMessageToSyncLogL( appIndex, aErrorCode ); + if ( aStatusError ) + { + iDSContent->SetServerStatusError(); + } + } + if ( aImmediatelyInterruption ) + { + // if immediately, any respose is not send + iDSContent->SetImmediatelyInterrupted(); + } + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::FinaliseWhenErrorL +// Gets called if sync is broken down immediately (Leave errors) +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::FinaliseWhenErrorL() + { + DBG_FILE(_S8("CNSmlDSAgent::FinaliseWhenErrorL begins")); + +// + if( iDSContent->ResendUsed() ) + { + DBG_FILE(_S8("CNSmlDSAgent::FinaliseWhenErrorL - calling iDSContent->PackupRequestL...")); + iDSContent->PackupRequestL( iDSClientNextSyncAnchor ); + } +// + + //RD_SUSPEND_RESUME + TInt keyVal; + TRAPD (srerr ,ReadRepositoryL(KNsmlDsSuspendResume, keyVal)); + if(srerr == KErrNone && keyVal == 1) + { + TNSmlSyncSuspendedState suspendedState; + if(iDSContent->SetToFirst()) + { + do + { + suspendedState = CurrentState(); + iDSContent->SetSuspendedStateL(suspendedState); + }while( iDSContent->SetToNext() ); + } + if(iDSContent->SetToFirst()) + { + do + { + TBuf8<3> syncType( iDSContent->SyncType()); + TNSmlPreviousSyncType prevalertcode=MapAlertCode(syncType); + //Sync Type of the Current Sync session is stored. + iDSContent->SetPreviousSyncTypeL( prevalertcode ); + }while( iDSContent->SetToNext() ); + } + if(iDSContent->SetToFirst()) + { + do + { + TBuf8<3> clientSyncType( iDSContent->ClientSyncType()); + TNSmlPreviousSyncType prevClientType=MapAlertCode(clientSyncType); + //Sync Type proposed by Client in the Current Sync session is stored. + iDSContent->SetPreviousClientSyncTypeL( prevClientType ); + }while( iDSContent->SetToNext() ); + } + } + //RD_SUSPEND_RESUME + + iDSContent->FinalizeDatabasesL(); + + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlDisconnected, 0, 0 ); + + if(iPacketDataUnAvailable) + { + DoErrorEvent(MSyncMLProgressObserver::ESmlFatalError, + TNSmlError::ESmlCommunicationError, 0, 0, 0 ); + } + + //RD_AUTO_RESTART (BPSS-7GBFF3) + DBG_FILE_CODE(iPacketDataUnAvailable,_S8("CNSmlDSAgent::FinaliseWhenErrorL PacketData is")); + //Check whether the Auto Restart Feature is enabled or not + TRAPD (arerr ,ReadRepositoryL(KNsmlDsAutoRestart, keyVal)); + + if(arerr == KErrNone && keyVal == 1) + { + if(!iPacketDataUnAvailable && !iAutoRestartInitiatedSync ) + { + + DBG_FILE(_S8("CNSmlDSAgent::FinaliseWhenErrorL About to check the Profile ID")); + + if(CheckProfileIdL()) + { + TerminateAutoRestart(); + } + } + } + //RD_AUTO_RESTART + + DBG_FILE(_S8("CNSmlDSAgent::FinaliseWhenErrorL ends")); + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::Interrupted +// Checks if all datastores are interrupted. +// ----------------------------------------------------------------------------- +// +TBool CNSmlDSAgent::Interrupted() + { + return iDSContent->AllDatabasesAreInterrupted(); + } +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::LaunchAutoRestart +// Launch the NETMON exe after saving the Profile Info to the CenRep and Killing +// the current DSSync session +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::LaunchAutoRestartL(TInt aError) +{ + DBG_FILE(_S8("CNSmlDSAgent::LaunchAutoRestart() begins")); + + + //Check whether the Users' Network is in Roaming + if(iDSNetmon) + { + if(iDSNetmon->IsRoaming()) + { + DBG_FILE(_S8("CNSmlDSAgent::LaunchAutoRestart() Users' Network in Roaming Leaving the fuction")); + User::Leave(aError); + } + } + + //Fix for BPSS-7H7JPF + //Check whether the Auto-Restart is to be launched for the Profile that is already interrupted + if(!iAutoRestartInitiatedSync) + { + TerminateAutoRestart(); + } + + + //Save the Profile Information + SaveProfileInfoL(); + + //Kill the DS Sync Sesssion + StopDSSession(); + + //Launch the NETMON exe + LaunchNETMONL(); + + DBG_FILE(_S8("CNSmlDSAgent::LaunchAutoRestart() ends")); + +} + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::SaveProfileInfo +// Save the Profile Information in to the Central Repository +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::SaveProfileInfoL() +{ + DBG_FILE(_S8("CNSmlDSAgent::SaveProfileInfo() begins")); + + CNsmlProfileUtil* profileUtil = CNsmlProfileUtil::NewLC(); + profileUtil->InternalizeFromSettingsDBL(this->iProfileID); + profileUtil->ExternalizeToCenrepL(); + profileUtil->WriteAccessPointIdL(iNetmonAPId); + + //Error fix for BPSS-7GYDJV + RArray taskIdArray; + if ( iDSSyncTypeArray && iDSSyncTypeArray->Count() > 0) + { + TInt count = iDSSyncTypeArray->Count(); + DBG_FILE_CODE(count, _S8("CNSmlDSAgent::SaveProfileInfo() TaskId Count")); + for ( TInt i = 0; i < count; i++ ) + { + TSmlTaskId taskid; + taskid = iDSSyncTypeArray->At( i ).iTaskId; + taskIdArray.AppendL( taskid ); + } + } + else + { + DBG_FILE(_S8("CNSmlDSAgent::SaveProfileInfo() No TaskId")); + taskIdArray.Reset(); + } + profileUtil->ExternalizeTaskIdL(taskIdArray); + taskIdArray.Close(); + + CleanupStack::PopAndDestroy(profileUtil); + + DBG_FILE(_S8("CNSmlDSAgent::SaveProfileInfo() ends")); +} + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::LaunchNETMON +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::LaunchNETMONL() +{ + DBG_FILE(_S8("CNSmlDSAgent::LaunchNETMONL() begins")); + //Kill if any existing NetMon exe is running + //TerminateAutoRestart(); + //Starts the new Netmon process to register for the Connmon events + //This exe will start the Sync session once the Network is available + RProcess rp; + TInt err = rp.Create(KNetMon,KNullDesC); + User::LeaveIfError(err); + rp.Resume(); + + DBG_FILE(_S8("CNSmlDSAgent::LaunchNETMONL() ends")); +} + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::StopDSSession +// Kill the current DS Sync Session +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::StopDSSession() +{ + DBG_FILE(_S8("CNSmlDSAgent::StopDSSession() begins")); + + iCurrMainState = EFinishing; + Cancel(); + + DBG_FILE(_S8("CNSmlDSAgent::StopDSSession() ends")); +} + + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::DoErrorEvent +// Unsures error event +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::DoErrorEvent( MSyncMLProgressObserver::TErrorLevel + aErrorLevel, + TInt aError, TInt aTaskId, + TInt aInfo1, TInt aInfo2 ) + { + if ( !iErrorNotified ) + { + iDSObserver->OnSyncMLSyncError( aErrorLevel, aError, + aTaskId, aInfo1, aInfo2 ); + iErrorNotified = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDSAgent::PrepareSyncL +// Prepares sync. +// ----------------------------------------------------------------------------- +// +void CNSmlDSAgent::PrepareSyncL( CArrayFix* aTypeArray ) + { + iDSContent->InitContentDataL(); + + if ( aTypeArray ) + { + iDSSyncTypeArray = new ( ELeave ) CArrayFixFlat( 4 ); + + for ( TInt i = 0; i < aTypeArray->Count(); i++ ) + { + TNSmlContentSpecificSyncType type; + type.iTaskId = aTypeArray->At( i ).iTaskId; + type.iType = aTypeArray->At( i ).iType; + iDSSyncTypeArray->AppendL( type ); + } + } + } + +// + +// --------------------------------------------------------- +// CNSmlDSAgent::BeginSubScanMapInfo() +// +// --------------------------------------------------------- +void CNSmlDSAgent::BeginSubScanMapInfo() + { + DBG_FILE(_S8("CNSmlDSAgent::BeginSubScanMapInfo() begins")); + TBool endOfMapLoading = EFalse; + TRAPD( err,ScanMapInfoL( endOfMapLoading ) ); + if( err != KErrNone || endOfMapLoading ) + { + DBG_FILE_CODE( endOfMapLoading, _S8("CNSmlDSAgent::BeginSubScanMapInfo(): endOfMapLoading: ") ); + DBG_FILE_CODE( err, _S8("CNSmlDSAgent::BeginSubScanMapInfo(): Moved to SubCreateLUIDBuffers...") ); + iDSCurrBeginSubState = EBeginSubCreateLUIDBuffers; + } + DBG_FILE(_S8("CNSmlDSAgent::BeginSubScanMapInfo() ends")); + } + +// +// Client Resend MapInformation state functions +// +// --------------------------------------------------------- +// CNSmlDSAgent::ClientResendMapInfoStateL() +// If mapinfo exists as a result of unsuccessfull last sync, +// it Makes Client Map Informtaion Package to be resent to Server +// Navigate according to state code +// --------------------------------------------------------- +void CNSmlDSAgent::ClientResendMapInfoStateL() + { + switch ( iCurrClientResendMapInfoState ) + { + case EResendMapInfoStartingMessage: + ClientResendMapInfoStartingMessageStateL(); + break; + case EResendMapInfoMakingStatus: + ClientResendMapInfoMakingStatusStateL(); + break; + case EResendMapInfoMakingResults: + ClientResendMapInfoMakingResultsStateL(); + break; + case EResendMapInfoStartingSync: + ClientResendMapInfoStartingSyncStateL(); + break; + case EResendMapInfoEndingSync: + ClientResendMapInfoEndingSyncStateL(); + break; + case EResendMapInfoMakingMap: + ClientResendMapInfoMakingMapStateL(); + break; + case EResendMapInfoEndingMessage: + ClientResendMapInfoEndingMessageStateL(); + break; + } + } + +void CNSmlDSAgent::ClientResendMapInfoStartingMessageStateL() + { + DBG_FILE(_S8("CNSmlAgentBase::ClientResendMapInfoStartingMessageStateL begins")); + iMapResendStatusPackage=EFalse; + iBufferFull = EFalse; + TBool mapFound=EFalse; + iDSContent->SetToFirst(); + if(iDSContent->MapExists()) + { + mapFound=ETrue; + } + while(iDSContent->SetToNext() && !mapFound) + { + if(iDSContent->MapExists()) + { + mapFound=ETrue; + } + } + if(mapFound) + { + DBG_FILE(_S8("CNSmlAgentBase::ClientResendMapInfoStartingMessageStateL Mapfound")); + iSyncMLCmds->DoSyncHdrL(); + iDSContent->SetToFirst(); + iCurrClientResendMapInfoState = EResendMapInfoMakingStatus; + } + else + { + NextMainStateL(); + } + DBG_FILE(_S8("CNSmlAgentBase::ClientResendMapInfoStartingMessageStateL ends")); + } + +void CNSmlDSAgent::ClientResendMapInfoMakingStatusStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientResendMapInfoMakingStatusStateL begins")); + iSyncMLCmds->StatusContainer()->Begin(); + TBool found( ETrue ); + while( found ) + { + SmlStatus_t* status; + found = iSyncMLCmds->StatusContainer()->NextStatusElement( status, ETrue ); + if ( found ) + { + iSyncMLCmds->DoStatusL( status ); + } + } + iCurrClientResendMapInfoState = EResendMapInfoMakingResults; + DBG_FILE(_S8("CNSmlAgent::ClientResendMapInfoMakingStatusStateL ends")); + } + + +void CNSmlDSAgent::ClientResendMapInfoMakingResultsStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientModMakingResultsStateL begins")); + if ( iDSDeviceInfoRequestedByServer && !iDSContent->AllDatabasesAreInterrupted() ) + { + iSyncMLCmds->DoResultsL(); + iDSDeviceInfoRequestedByServer = EFalse; + } + if ( iFinalMessageFromClient ) + { + iDSContent->SetToFirst(); + } + else + { + iDSContent->SetIndexToSaved(); + } + iCurrClientResendMapInfoState = EResendMapInfoStartingSync; + DBG_FILE(_S8("CNSmlAgent::ClientResendMapInfoMakingResultsStateL ends")); + } +// --------------------------------------------------------- +// CNSmlDSAgent::ClientResendMapInfoEndingSyncStateL() +// Makes Sync command +// --------------------------------------------------------- +void CNSmlDSAgent::ClientResendMapInfoStartingSyncStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientResendMapInfoStartingSyncStateL begins")); + CNSmlCmdsBase::TReturnValue ret; + if ( !iDSContent->Interrupted() ) + { + ret = iSyncMLCmds->DoStartSyncL(); + switch ( ret ) + { + case CNSmlCmdsBase::EReturnOK: + iCurrClientResendMapInfoState = EResendMapInfoEndingSync; + iDSObserver->OnSyncMLSyncProgress( MSyncMLProgressObserver::ESmlSendingMappingsToServer, 0, 0 ); + break; + case CNSmlCmdsBase::EReturnBufferFull: + iCurrClientResendMapInfoState = EResendMapInfoEndingSync; + iBufferFull = ETrue; + break; + default: + break; + } + } + else + // skip interrupted database + { + if ( !iDSContent->SetToNext() ) + { + iCurrClientResendMapInfoState = EResendMapInfoEndingSync; + } + } + DBG_FILE(_S8("CNSmlDSAgent::ClientResendMapInfoStartingSyncStateL ends")); + } +// --------------------------------------------------------- +// CNSmlDSAgent::ClientResendMapInfoEndingSyncStateL() +// End of Sync command +// --------------------------------------------------------- +void CNSmlDSAgent::ClientResendMapInfoEndingSyncStateL() + { + DBG_FILE(_S8("CNSmlDSAgent::ClientResendMapInfoEndingSyncStateL begins")); + iSyncMLCmds->DoEndSyncL(); + if ( iBufferFull ) + { + iCurrClientResendMapInfoState = EResendMapInfoEndingMessage; + } + else + { + if ( iDSContent->SetToNext() ) + { + iCurrClientResendMapInfoState = EResendMapInfoStartingSync; + } + else + { + iCurrClientResendMapInfoState = EResendMapInfoMakingMap; + iDSContent->SetToFirst(); + } + } + DBG_FILE(_S8("CNSmlDSAgent::ClientResendMapInfoEndingSyncStateL ends")); + } + +void CNSmlDSAgent::ClientResendMapInfoMakingMapStateL() + { + DBG_FILE(_S8("CNSmlAgent::ClientResendMapInfoMakingMapStateL begins")); + CNSmlCmdsBase::TReturnValue ret=CNSmlCmdsBase::EReturnOK; + ret = iSyncMLCmds->DoMapL(); + switch ( ret ) + { + case CNSmlCmdsBase::EReturnOK: + iDSWaitingForMapAcknowledgement = ETrue; + // there is something to send + iMapResendStatusPackage = ETrue; + if ( !iDSContent->SetToNext() ) + { + iCurrClientResendMapInfoState = EResendMapInfoEndingMessage; + } + break; + case CNSmlCmdsBase::EReturnEndData: + if ( !iDSContent->SetToNext() ) + { + iCurrClientResendMapInfoState = EResendMapInfoEndingMessage; + } + break; + case CNSmlCmdsBase::EReturnBufferFull: + iBufferFull = ETrue; + iCurrClientResendMapInfoState = EResendMapInfoEndingMessage; + break; + default: + break; + } + DBG_FILE(_S8("CNSmlAgent::ClientResendMapInfoMakingMapStateL ends")); + } + + +void CNSmlDSAgent::ClientResendMapInfoEndingMessageStateL() + { + DBG_FILE(_S8("CNSmlAgentBase::ClientResendMapInfoEndingMessageStateL begins")); + iSyncMLCmds->DoEndMessageL( EFalse ); + + if ( iBufferFull ) + { + iFinalMessageFromClient = EFalse; + } + else + { + iFinalMessageFromClient = ETrue; + } + + NextMainStateL(); + DBG_FILE(_S8("CNSmlAgentBase::ClientResendMapInfoEndingMessageStateL ends")); + } + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::ScanMapInfoL +// Map information is searched for all the databases physical storage and calls functions to load map if exists +// ------------------------------------------------------------------------------------------------------------------ +void CNSmlDSAgent::ScanMapInfoL( TBool& aEnd ) + { + DBG_FILE(_S8("CNSmlDSAgent::ScanMapInfoL() begins")); + + if ( !iCommandIssued ) + { + TBool ret = EFalse; + if ( !iDSMapOpeningStarted ) + { + ret = iDSContent->SetToFirst(); + iDSMapOpeningStarted = ETrue; + } + else + { + ret = iDSContent->SetToNext(); + } + if ( ret ) + { + iDSContent->ScanMapContentL(iStatus); + iCommandIssued = ETrue; + } + else + { + aEnd = ETrue; + } + } + else // command was completed + { + iCommandIssued = EFalse; + if ( iStatus.Int() == KErrNotFound ) + { + DBG_FILE_CODE( iStatus.Int(), _S8("CNSmlDSAgent::ScanMapInfoL(): Error! (1)") ); + //InterruptL( iDSContent->CurrentIndex(), TNSmlDSError::ESmlDSLocalDatabaseError, ETrue, EFalse ); + //iDSContent->SetInterruptedBeforeSync(); + } + else + { + DBG_FILE_CODE( iStatus.Int(), _S8("CNSmlDSAgent::ScanMapInfoL(): Error! (2)") ); + User::LeaveIfError( iStatus.Int() ); + } + } + DBG_FILE(_S8("CNSmlDSAgent::ScanMapInfoL() ends")); + } +// + +// CreateDSAgentL( MNSmlDSAgentObserver* aDSObserver ) +// Return the instance of the CNSmlDSAgent +// --------------------------------------------------------- +// +EXPORT_C CNSmlDSAgent* CreateDSAgentL( MSyncMLProgressObserver* aDSObserver ) + { + return CNSmlDSAgent::NewL( aDSObserver ); + } + + +//RD_SUSPEND_RESUME +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::SyncFailure() +// +// ------------------------------------------------------------------------------------------------------------------ +TBool CNSmlDSAgent::SyncFailure() +{ + DBG_FILE_CODE(iError->SyncLogErrorCode(),_S8("CNSmlDSAgent::SyncFailure( ).Error code")); + if(iError->SyncLogErrorCode()) + return(ETrue); + else + return(EFalse); +} + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CurrentStateInFinishing() +// +// ------------------------------------------------------------------------------------------------------------------ + +TNSmlSyncSuspendedState CNSmlDSAgent::CurrentStateInFinishing() +{ + TNSmlSyncSuspendedState state=EStateNotStarted; + + TBool chk=SyncFailure(); + DBG_FILE_CODE(chk,_S8("CNSmlDSAgent::CurrentStateInFinishing( )..Network failure check")); + + if(iDSContent->AnyDatabaseIsInterrupted() || iPacketDataUnAvailable + || chk ) + { + switch(iPrevSyncState) + { + case EBeginning: + case EClientInitialisation: + case EServerInitialisation: + case EResultAlert: + //if any sync failure occurs at pkt#1/pkt#2 stage, do not update + //sync anchors + if(chk) + iUpdateLastAnchor=EFalse; + state = EStateNotStarted; + break; + case EClientResendMapInfo: + case EClientModifications: + state = EStateClientModification; + break; + case EServerModifications: + state = EStateServerModification; + break; + case EDataUpdateStatus: + state = EStateDataUpdateStatus; + break; + case EMapAcknowledge: + state = EStateMapAcknowledge; + break; + + } + } + else + { + state = EStateNotStarted; + } + + return(state); +} + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CurrentStateInReceiving() +// +// ------------------------------------------------------------------------------------------------------------------ + +TNSmlSyncSuspendedState CNSmlDSAgent::CurrentStateInReceiving() +{ + TNSmlSyncSuspendedState state=EStateNotStarted; + if (iPrevSyncState == EClientInitialisation || iPrevSyncState == EServerInitialisation + || iPrevSyncState == EClientResendMapInfo ) + { + state = EStateNotStarted; + } + else if(iPrevSyncState == EClientModifications) + { + state = EStateClientModification; + } + else if (iPrevSyncState == EDataUpdateStatus) + { + state = EStateDataUpdateStatus; + } + else if (iPrevSyncState == EServerModifications ) + { + state = EStateServerModification; + } + else if (iPrevSyncState == EMapAcknowledge ) + { + state = EStateMapAcknowledge; + } + + return state; +} + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CurrentStateInClientAlertNext() +// +// ------------------------------------------------------------------------------------------------------------------ + +TNSmlSyncSuspendedState CNSmlDSAgent::CurrentStateInClientAlertNext() +{ + TNSmlSyncSuspendedState state=EStateNotStarted; + if (iPrevSyncState == EServerModifications) + { + state = EStateServerModification; + } + else if (iPrevSyncState == EMapAcknowledge) + { + state = EStateMapAcknowledge; + } + return(state); +} + + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CurrentStateInServerAlertNext() +// +// ------------------------------------------------------------------------------------------------------------------ + +TNSmlSyncSuspendedState CNSmlDSAgent::CurrentStateInServerAlertNext() +{ + TNSmlSyncSuspendedState state=EStateNotStarted; + if(iPrevSyncState == EClientModifications) + { + state = EStateClientModification; + } + else if (iPrevSyncState == EDataUpdateStatus) + { + state = EStateDataUpdateStatus; + } + return(state); +} + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CurrentState() +// +// ------------------------------------------------------------------------------------------------------------------ + + +TNSmlSyncSuspendedState CNSmlDSAgent::CurrentState( ) +{ + + TNSmlSyncSuspendedState state = EStateNotStarted; + + switch(iCurrMainState) + { + case EBeginning: + case EClientInitialisation: + case EServerInitialisation: + case EResultAlert: + if(SyncFailure()) + { + iUpdateLastAnchor=EFalse; + } + state=EStateNotStarted; + break; + case EFinishing: + state=CurrentStateInFinishing(); + break; + // + case EClientResendMapInfo: +// + case EClientModifications: + state = EStateClientModification; + break; + case EServerModifications: + state = EStateServerModification; + break; + case EDataUpdateStatus: + state = EStateDataUpdateStatus; + break; + case EMapAcknowledge: + state = EStateMapAcknowledge; + break; + + case EClientAlertNext: + state=CurrentStateInClientAlertNext(); + break; + + case EServerAlertNext: + state=CurrentStateInServerAlertNext(); + break; + case ESending: + case EReceiving: + { + state=CurrentStateInReceiving(); + break; + } + default: + state = EStateNotStarted; + break; + + } + DBG_FILE_CODE(state,_S8("CNSmlDSAgent::CurrentStateInFinishing( )..Network failure check")); + if(state!=EStateNotStarted && iUpdateLastAnchor) + iUpdateLastAnchor=EFalse; + return state; + } +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::ReadRepositoryL() +// +// ------------------------------------------------------------------------------------------------------------------ +void CNSmlDSAgent::ReadRepositoryL(TInt aKey, TInt& aValue) +{ + const TUid KRepositoryId = KCRUidDataSyncInternalKeys; + + CRepository* rep = CRepository::NewLC(KRepositoryId); + TInt err = rep->Get(aKey, aValue); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(rep); +} +//RD_SUSPEND_RESUME + +//RD_AUTO_RESTART +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::CheckProfileIdL() +// +// ------------------------------------------------------------------------------------------------------------------ +TBool CNSmlDSAgent::CheckProfileIdL() +{ + DBG_FILE(_S8("CNSmlDSAgent::CheckProfileId() begins")); + + CNsmlProfileUtil* profileUtil = CNsmlProfileUtil::NewLC(); + profileUtil->InternalizeFromCenrepL(); + TInt cachedprofileId = profileUtil->ProfileId(); + CleanupStack::PopAndDestroy(profileUtil); + + DBG_FILE_CODE(iProfileID, _S8("CNSmlDSAgent::CheckProfileId() Profile ID is")); + DBG_FILE_CODE(cachedprofileId, _S8("CNSmlDSAgent::CheckProfileId() cached Profile ID is")); + + if(iProfileID == cachedprofileId) + { + return ETrue; + } + + else + { + return EFalse; + } +} + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::TerminateAutoRestart() +// +// ------------------------------------------------------------------------------------------------------------------ +void CNSmlDSAgent::TerminateAutoRestart() +{ + DBG_FILE(_S8("CNSmlDSAgent::TerminateAutoRestart() begins")); + + TFullName processName; + TFindProcess process; + while ( process.Next( processName ) != KErrNotFound ) + { + //DBG_ARGS(_S("CNSmlDSAgent::TerminateAutoRestart() The Process name is %S"), &processName); + + if ( ( processName.Find( KAutoRestart ) != KErrNotFound ) ) + { + RProcess rprocess; + if (rprocess.Open(process, EOwnerProcess) == KErrNone) + { + DBG_FILE(_S8("CNSmlDSAgent::TerminateAutoRestart() Process is found, Killing the Process")); + rprocess.Terminate(KErrNone); + rprocess.Close(); + DBG_FILE(_S8("CNSmlDSAgent::TerminateAutoRestart() Process killed successfully")); + } + } + } + + DBG_FILE(_S8("CNSmlDSAgent::TerminateAutoRestart() ends")); +} +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::IsSyncClientInitiated() +// +// ------------------------------------------------------------------------------------------------------------------ +TBool CNSmlDSAgent::IsSyncClientInitiated() +{ + DBG_FILE_CODE(iSyncInitiation, _S8("CNSmlDSAgent::IsSyncClientInitiated() The Sync Initiation status is")); + + if(iSyncInitiation == EClientInitiated) + return ETrue; + else + return EFalse; +} +//RD_AUTO_RESTART + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::SetDSSessionInfoL() +// +// ------------------------------------------------------------------------------------------------------------------ +void CNSmlDSAgent::SetDSSessionInfoL(CNSmlDSProfile* aProfile) + { + + CRepository* rep = CRepository::NewLC(KNsmlDsSessionInfoKey); + TInt err = rep->Set(EDSSessionProfileId, aProfile->IntValue( EDSProfileId )); + err = rep->Set(EDSSessionProfileName, aProfile->StrValue( EDSProfileDisplayName )); + err = rep->Set(EDSSessionServerId, aProfile->StrValue( EDSProfileServerId )); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(rep); + + + } + +// ------------------------------------------------------------------------------------------------------------------ +// CNSmlDSAgent::ResetDSSessionInfoL() +// +// ------------------------------------------------------------------------------------------------------------------ +void CNSmlDSAgent::ResetDSSessionInfoL() + { + + CRepository* rep = CRepository::NewLC(KNsmlDsSessionInfoKey); + TInt err = rep->Set(EDSSessionProfileId, KErrNotFound); + err = rep->Set(EDSSessionProfileName, _L("")); + err = rep->Set(EDSSessionServerId, _L("")); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(rep); + } + +// End of file