syncmlfw/ds/syncagent/src/nsmldsagent.cpp
changeset 0 b497e44ab2fc
child 9 57a65a3a658c
child 32 5d0ec111abfc
--- /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 <SyncMLHistory.h>
+#include <e32property.h>
+#include <DataSyncInternalPSKeys.h>
+#include <nsmlconstants.h>
+#include <nsmldebug.h>
+
+// 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 <e32base.h>
+#include <centralrepository.h> 
+#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<TNSmlContentSpecificSyncType>* 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 )
+		{
+		// <MAPINFO_RESEND_MOD_BEGIN>
+		iDSCurrBeginSubState = EBeginSubScanMapInfo;
+		// iDSCurrBeginSubState = EBeginSubCreateLUIDBuffers;
+		// <MAPINFO_RESEND_MOD_END>
+		}
+	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 )
+					    {
+					   		// <MAPINFO_RESEND_MOD_BEGIN>
+							if ( ( !iDSContent->HasSyncHistoryL() || iDSContent->SlowSyncRequestL() || clientLastSyncAnchor == TTime( 0 ) )&& !iDSContent->MapExists() )
+							// if ( !iDSContent->HasSyncHistoryL() || iDSContent->SlowSyncRequestL() || clientLastSyncAnchor == TTime( 0 )   )
+							// <MAPINFO_RESEND_MOD_BEGIN>
+							{								
+								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 )
+		{
+
+// <MAPINFO_RESEND_MOD_BEGIN>
+        iDSContent->SetMapRemovable();
+		iDSContent->RemoveAllRemovableMap();
+// <MAPINFO_RESEND_MOD_BEGIN>
+
+		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 )
+		{
+			
+// <MAPINFO_RESEND_MOD_BEGIN>
+		iDSContent->RemoveAllRemovableMap();
+// <MAPINFO_RESEND_MOD_BEGIN>
+			
+		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<TUint32>( 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<TSmlProtocolVersion>( 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<TSmlTaskId> 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<CSyncMLFilter> 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<TSyncMLFilterMatchType>( (*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<TSmlSyncType>( (*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;
+// <MAPINFO_RESEND_MOD_BEGIN>
+		case EClientResendMapInfo:
+			ClientResendMapInfoStateL();
+			break;
+// <MAPINFO_RESEND_MOD_END>
+		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 );
+// <MAPINFO_RESEND_MOD_BEGIN>
+							iCurrMainState = EClientResendMapInfo;
+							DBG_FILE(_S8("CNSmlDSAgent::NextMainStateL Moved to EClientResendMapInfo..."));
+							// iCurrMainState = EClientModifications;
+// <MAPINFO_RESEND_MOD_END>
+							}
+						}
+					}
+				}
+			break;
+// <MAPINFO_RESEND_MOD_BEGIN>
+		case EClientResendMapInfo:
+			iPrevSyncState = iCurrMainState;
+			if(iMapResendStatusPackage)
+				{
+				iCurrMainState = ESending;
+				}
+			else
+				{
+				iCurrMainState = EClientModifications;
+				}
+			break;
+// <MAPINFO_RESEND_MOD_END>	
+		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:
+// <MAPINFO_RESEND_MOD_BEGIN>
+			if(iPrevSyncState==EClientResendMapInfo)
+				{
+				iCurrMainState = EClientModifications;
+				// If map exitst remove map info, think to implement.
+				iDSContent->CleanMapInfo();
+				}
+			else
+				{
+// <MAPINFO_RESEND_MOD_END>
+			iPrevSyncState = iCurrMainState;
+			if ( iDSContent->AllDatabasesAreInterruptedImmediately() )
+				{
+				iCurrMainState = EFinishing;
+				}
+			else
+				{
+				if ( iBusyStatusReceived )
+					{
+					iCurrMainState = EResultAlert;
+					}
+				else
+					{
+					if ( iDSCurrMapAcknowledgeState == EMapAckMessageReceived )
+						{	
+						iCurrMainState = EClientAlertNext;
+						}
+					else
+						{
+						iCurrMainState = EFinishing;
+						}
+					}
+				}
+// <MAPINFO_RESEND_MOD_BEGIN>
+				}
+// <MAPINFO_RESEND_MOD_END>
+			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;
+// <MAPINFO_RESEND_MOD_BEGIN>
+		case EBeginSubScanMapInfo:
+			BeginSubScanMapInfo();
+			break;
+// <MAPINFO_RESEND_MOD_END>
+		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"));
+	
+// <MAPINFO_RESEND_MOD_BEGIN>
+	if( iDSContent->ResendUsed() )
+		{
+		DBG_FILE(_S8("CNSmlDSAgent::FinaliseWhenErrorL - calling iDSContent->PackupRequestL..."));
+		iDSContent->PackupRequestL( iDSClientNextSyncAnchor );
+		}
+// <MAPINFO_RESEND_MOD_END>
+	
+	//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<TSmlTaskId> 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<TNSmlContentSpecificSyncType>* aTypeArray )
+	{
+	iDSContent->InitContentDataL();
+	
+	if ( aTypeArray )
+		{
+		iDSSyncTypeArray = new ( ELeave ) CArrayFixFlat<TNSmlContentSpecificSyncType>( 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 );
+			}
+		}
+	}
+
+// <MAPINFO_RESEND_MOD_BEGIN>
+
+// ---------------------------------------------------------
+// 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"));
+	}
+// <MAPINFO_RESEND_MOD_END>
+
+// 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;
+	// <MAPINFO_RESEND_MOD_BEGIN>
+		case EClientResendMapInfo:
+// <MAPINFO_RESEND_MOD_END>
+		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