--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/dm/syncagent/src/nsmldmagent.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,2049 @@
+/*
+* 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: SyncML DM command handling
+*
+*/
+
+
+// INCLUDE FILES
+#include <SyncMLObservers.h>
+#include <SyncMLHistory.h>
+#include <PolicyEngineClient.h>
+#include <centralrepository.h>
+#include "PMUtilInternalCRKeys.h"
+
+#include <nsmlconstants.h>
+#include <nsmldebug.h>
+#include <nsmlunicodeconverter.h>
+// DM specific includes
+#include <nsmldmmodule.h>
+// common includes with DS
+#include "nsmlcliagconstants.h"
+#include "NSmlAgentBase.h"
+#include "NSmlCmdsBase.h"
+#include "NSmlStatusContainer.h"
+#include "NSmlResultsContainer.h"
+#include "NSmlResponseController.h"
+#include "NSmlAuth.h"
+#include "NSmlURI.h"
+#include "nsmlagenttestdefines.h"
+// DM specific includes
+#include "nsmldmagconstants.h"
+#include "NSmlDMAgent.h"
+#include "NSmlDMCmds.h"
+#include "nsmldmsettings.h"
+#include "nsmldmerror.h"
+#include "NSmlHistoryArray.h"
+// FOTA
+#include "NSmlDMGenericAlert.h"
+#include "NSmlPrivateAPI.h"
+// FOTA end
+#include <featmgr.h>
+const TUid KUidNotifier = { 0x101F8769 };
+const TInt KNotifierTimeout = 300000000; // 5 min timeout
+_LIT8 ( KNSmlDMFotaNode, "FUMO" );
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::NewL()
+// Creates new instance of CNSmlDMAgent.
+// Does not leave instance pointer to CleanupStack.
+// ---------------------------------------------------------
+//
+CNSmlDMAgent* CNSmlDMAgent::NewL( MSyncMLProgressObserver* aDMObserver )
+ {
+ CNSmlDMAgent* self = new (ELeave) CNSmlDMAgent();
+ CleanupStack::PushL( self );
+ self->ConstructL( aDMObserver );
+ CleanupStack::Pop();
+ return self;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::~CNSmlDMAgent()
+// Destructor
+// ---------------------------------------------------------
+//
+CNSmlDMAgent::~CNSmlDMAgent()
+ {
+ delete iDMTriggerMessage;
+ delete iDMServerId;
+ delete iDMServerPassword;
+ delete iDMServerDigest;
+ delete iSyncLog;
+ // FOTA
+ iGenAlerts.ResetAndDestroy();
+ iGenAlerts.Close();
+ // FOTA end
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ delete iNotifierObserver;
+}
+FeatureManager::UnInitializeLib();
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::Configure()
+// Starts the sync, returns immediately and the sync continues
+// in RunL() function
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::Configure( TRequestStatus& aStatus,TInt aProfileId,TInt aTransportId,TNSmlSyncInitiation aSyncInitiation,TInt aIapId)
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::Configure"));
+
+ CActiveScheduler::Add(this);
+ iProfileID = aProfileId;
+ iMediumType.iUid = aTransportId;
+ iSyncInitiation = aSyncInitiation;
+ iCallerStatus = &aStatus;
+ iNewIapId = aIapId;
+ *iCallerStatus = KRequestPending;
+ TRAPD(leaveCode,iSyncLog = CSyncMLHistoryJob::NewL());
+
+ if(leaveCode!=KErrNone)
+ {
+ User::RequestComplete( iCallerStatus, leaveCode );
+ return;
+ }
+
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+
+// FOTA
+// ---------------------------------------------------------
+// CNSmlDMAgent::SetGenericAlertL()
+// Appends a Generic Alert to the internal list.
+// The alert itself is sent in the later phase of the dm session.
+// @param aFwMgmtUri. The uri which has been used in the exe command whose final result is
+// about to be reported.
+// @param aMetaType. Meta/Type that should be used in the alert.
+// @param aMetaFormat. Meta/Format that should be used in the alert.
+// @param aFinalResult. The final result value which is reported to remote server.
+// @param aCorrelator. Correlator value used in the original exec command.
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::SetGenericAlertL ( const TDesC8& aFwMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat,
+ TInt aFinalResult, const TDesC8& aFwCorrelator )
+ {
+ CNSmlDMGenericAlert* genAlert = CNSmlDMGenericAlert::NewL ( aFwMgmtUri, aMetaType, aMetaFormat, aFinalResult, aFwCorrelator );
+ iGenAlerts.AppendL ( genAlert );
+ }
+
+// FOTA end
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::SetGenericAlertL()
+// Appends a Generic Alert to the internal list.
+// The alert itself is sent in the later phase of the dm session.
+// @param aFwMgmtUri. The uri which has been used in the exe command whose final result is
+// about to be reported.
+// @param aMetaType. Meta/Type that should be used in the alert.
+// @param aMetaFormat. Meta/Format that should be used in the alert.
+// @param aFinalResult. The final result value which is reported to remote server.
+// @param aCorrelator. Correlator value used in the original exec command.
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::SetGenericAlertL ( const TDesC8& aCorrelator, const RArray<CNSmlDMAlertItem>& aItemList )
+ {
+ CNSmlDMGenericAlert* genAlert = CNSmlDMGenericAlert::NewL ( aCorrelator, aItemList );
+ iGenAlerts.AppendL ( genAlert );
+ }
+
+//
+// Private member functions
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::CNSmlDMAgent()
+// Constructor
+// ---------------------------------------------------------
+//
+CNSmlDMAgent::CNSmlDMAgent()
+ {
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::ConstructL()
+// Two-way construction. Constructor may leave in EPOC.
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::ConstructL( MSyncMLProgressObserver* aDMObserver )
+ {
+ CNSmlAgentBase::ConstructL();
+ iDMObserver = aDMObserver;
+ iError = new (ELeave) TNSmlDMError;
+ iSyncMLMIMEType = KNSmlDMAgentMIMEType().AllocL();
+ iResultAlertCode = KNSmlDMAgentResultAlert().AllocL();
+ iNextMessageCode = KNSmlDMAgentNextMessage().AllocL();
+ //Session Abort Alert is used because there is no "End of Data Alert" in DM specs
+ iEndOfDataAlertCode = KNSmlDMAgentSessionAbortAlert().AllocL();
+ iSessionAbortAlertCode = KNSmlDMAgentSessionAbortAlert().AllocL();
+ FeatureManager::InitializeLibL();
+ iNewIapId = KErrNotFound;
+
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::SupportedAlert()
+// Check from code if supported Alert
+// ---------------------------------------------------------
+TBool CNSmlDMAgent::SupportedAlert( const TDesC8& aAlertCode ) const
+{
+if ( aAlertCode == KNSmlDMAgentServerInitAlert ||
+ aAlertCode == KNSmlDMAgentClientInitAlert ||
+ aAlertCode == KNSmlDMAgentResultAlert ||
+ aAlertCode == KNSmlDMAgentNextMessage ||
+ aAlertCode == KNSmlDMAgentSessionAbortAlert ||
+ aAlertCode == KNSmlDMAgentDisplayAlert ||
+ aAlertCode == KNSmlDMAgentContinueOrAbortAlert
+ || aAlertCode == KNSmlDMAgentUserInputAlert
+ || aAlertCode == KNSmlDMAgentSingleChoiceAlert
+ || aAlertCode == KNSmlDMAgentMultipleChoiceAlert )
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+//
+// Server Modifications state functions
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModificationsStateL(()
+// Main state function to read both Initialization from server client package
+// and Further server management operations package
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModificationsStateL()
+ {
+ _DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL begins"));
+
+ // FOTA
+ if ( !iChallengeRequest )
+ {
+ if ( iResetGenAlerts )
+ {
+ // Forward information to FOTA adapter if 1.1.2 otherwise any adapter
+ //which has sent GenAlert should be informed
+ // It can now mark GenAlerts sent.
+ if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112 ))
+ {
+ for ( TInt i(0); i<iGenAlerts.Count(); i++ )
+ {
+ if(iGenAlerts[i]->FinalResult() != 0)
+ {
+ iSyncMLCmds->MarkGenAlertsSentL(*iGenAlerts[i]->FwMgmtUri());
+ if(iGenAlerts[i]->FwMgmtUri()->Des().Find(KNSmlDMFotaNode)!=KErrNotFound)
+ {
+ iResetUserInitAlert= ETrue;
+ }
+ }
+ else
+ {
+ // Generic alerts could be present for other adapters like SCOMO
+ iSyncMLCmds->MarkGenAlertsSentL(*(*iGenAlerts[i]->DataItem())[0].iSource);
+ }
+ }
+ }
+ else
+ {
+ iSyncMLCmds->MarkGenAlertsSentL();
+ }
+ iResetGenAlerts = EFalse;
+ iGenAlerts.ResetAndDestroy();
+ }
+ if ( iResetUserInitAlert )
+ {
+ iSyncMLCmds->ResetGenericUserAlertL();
+ iResetUserInitAlert = EFalse;
+ }
+ }
+ // FOTA end
+
+ if ( !iSyncMLCmds->ProcessReceivedDataL() )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL end of Data"));
+ if ( iCurrServerModState == EServerModMessageReceived )
+ {
+ iBusyStatusReceived = iSyncMLCmds->BusyStatus();
+ }
+ else
+ {
+ if ( iCurrServerModState != EServerModPackageReceived )
+ {
+ User::Leave( TNSmlError::ESmlIncompleteMessage );
+ }
+ }
+ iSyncMLCmds->EndOfServerMessageL();
+ NextMainStateL();
+ }
+ //DBG_FILE(_S8("CNSmlDMAgent::ServerModificationsStateL ends"));
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModGetCmdStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModGetCmdStateL( SmlGet_t* aContent )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModGetCmdStateL begins"));
+ if ( iCurrServerModState != EServerModWaitingCommands )
+ {
+ User::Leave( TNSmlError::ESmlUnexpectedCmd );
+ }
+ iSyncMLCmds->ProcessGetCmdL( aContent );
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModGetCmdStateL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModStartAtomicStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModStartAtomicStateL( SmlAtomic_t* aContent )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModStartAtomicStateL begins"));
+ if ( 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;
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModStartAtomicStateL ends"));
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModEndAtomicStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModEndAtomicStateL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModEndAtomicStateL begins"));
+ --iNestedAtomicsCount;
+ if ( iNestedAtomicsCount == 0 )
+ {
+ iSyncMLCmds->ProcessEndAtomicL();
+ }
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModEndAtomicStateL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModStartSequenceStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModStartSequenceStateL( SmlSequence_t* aContent )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModStartSequenceStateL begins"));
+ if ( iCurrServerModState != EServerModWaitingCommands )
+ {
+ User::Leave( TNSmlError::ESmlUnexpectedCmd );
+ }
+ else
+ {
+ iSyncMLCmds->ProcessSequenceL( aContent );
+ }
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModStartSequenceStateL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModEndSequenceStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModEndSequenceStateL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModEndSequenceStateL begins"));
+ iSyncMLCmds->ProcessEndSequence();
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModEndSequenceStateL ends"));
+ }
+
+//
+// Finishing state functions
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::FinishingStateL()
+// Finishing functions in the end of sync
+// ---------------------------------------------------------
+void CNSmlDMAgent::FinishingStateL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::FinishingStateL begins"));
+ FinishL();
+ TRAP_IGNORE( FinalizeSyncLogL());
+ DBG_FILE(_S8("CNSmlDMAgent::FinishingStateL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ReadSettingsL()
+// Reads settings for the DM session
+// ---------------------------------------------------------
+void CNSmlDMAgent::ReadSettingsL()
+ {
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+
+ if( iNewIapId > KErrNotFound )
+ {
+ DBG_FILE_CODE(iIAPId,_S8("CNSmlDMAgent::ReadSettingsL not using profiles IAP:"));
+ iIAPId = iNewIapId;
+ }
+ else
+ {
+ DBG_FILE_CODE(iIAPId,_S8("CNSmlDMAgent::ReadSettingsL using profiles IAP"));
+ iIAPId = profile->IntValue( EDMProfileIAPId );
+ }
+ iIAPIdArray = new (ELeave) CArrayFixFlat<TUint32>(4);
+ iIAPIdArray->AppendL( iIAPId );
+
+
+ iSyncMLUserName = profile->StrValue( EDMProfileServerUsername ).AllocL();
+ iSyncMLPassword = profile->StrValue( EDMProfileServerPassword ).AllocL();
+
+ iSyncHTTPAuthUsed = profile->IntValue( EDMProfileHttpAuthUsed );
+ iSyncHTTPAuthUserName = profile->StrValue( EDMProfileHttpAuthUsername ).AllocL();
+ iSyncHTTPAuthPassword = profile->StrValue( EDMProfileHttpAuthPassword ).AllocL();
+
+ if ( iMediumType == KUidNSmlMediumTypeInternet )
+ {
+ iSyncServer= CNSmlURI::NewL( profile->StrValue( EDMProfileServerURL ), ETrue );
+ }
+ else
+ {
+ iSyncServer= CNSmlURI::NewL( profile->StrValue( EDMProfileServerURL ), EFalse );
+ }
+ iDMServerId = profile->StrValue( EDMProfileServerId ).AllocL();
+ iDMServerPassword = profile->StrValue( EDMProfileClientPassword ).AllocL();
+ iDMServerSessionId = profile->IntValue( EDMProfileSessionId );
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::InitSyncLogL()
+// Sync Log (shown In UI) initilisation in the beginning of sync
+// ---------------------------------------------------------
+void CNSmlDMAgent::InitSyncLogL()
+ {
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( profile )
+ {
+ CleanupStack::PushL( profile );
+ TTime now;
+ now.HomeTime();
+ CleanupStack::PopAndDestroy(2); //profile, settings
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); //settings
+ }
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::GetSessionIDL()
+// Gets SessionID from Agent Log
+// ---------------------------------------------------------
+TInt CNSmlDMAgent::GetSessionIDL()
+ {
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ TInt sessionID = 0;
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ sessionID = profile->IntValue( EDMProfileSessionId );
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ return sessionID;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::UpdateSessionIDL()
+// Updates SessionID in Agent Log
+// ---------------------------------------------------------
+void CNSmlDMAgent::UpdateSessionIDL( TInt aSessionID )
+ {
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ profile->SetIntValue( EDMProfileSessionId, aSessionID );
+ profile->SaveL();
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::FinishL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::FinishL()
+ {
+
+ iSyncMLCmds->WriteMappingInfoToDbL();
+ iSyncMLCmds->DisconnectFromOtherServers();
+ if ( Interrupted() )
+ {
+ iDMObserver->OnSyncMLSyncError(MSyncMLProgressObserver::ESmlFatalError,iError->SyncLogErrorCode(),0,0,0);
+ User::RequestComplete( iCallerStatus, iError->SyncLogErrorCode() );
+ }
+ else
+ {
+ iDMObserver->OnSyncMLSyncProgress(MSyncMLProgressObserver::ESmlCompleted,0,0);
+ User::RequestComplete( iCallerStatus, KErrNone );
+ }
+ iEnd = ETrue;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::InterruptedImmediately()
+//
+// ---------------------------------------------------------
+TBool CNSmlDMAgent::InterruptedImmediately()
+ {
+ return iDMImmediatelyInterruption;
+ }
+
+//
+// Callback functions implementation
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlAlertCmdFuncL
+// Alert command from server.
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlAlertCmdFuncL( SmlAlertPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ if ( !SupportedAlert( iSyncMLCmds->AlertCode( aContent ) ) )
+ {
+ iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentAlert, aContent->cmdID, aContent->flags );
+ }
+ else
+ {
+ switch ( iCurrMainState )
+ {
+ case EServerAlertNext:
+ ServerAlertNextAlertCmdStateL( aContent );
+ break;
+ case EServerModifications:
+ ServerModAlertCmdStateL( aContent );
+ break;
+ default:
+ break;
+ }
+ }
+ return 0;
+ }
+
+// ---------------------------------------------------------
+// CNSmlAgentBase::smlExecCmdFunc
+// Exec command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlExecCmdFuncL( SmlExecPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ // FOTA
+ ServerModUpdatesStateL ( aContent );
+ // FOTA end
+ break;
+ default:
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentExec, aContent->cmdID, aContent->flags );
+ break;
+ }
+ return 0;
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlAgentBase::smlCopyCmdFunc
+// Exec command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlCopyCmdFuncL( SmlCopyPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModUpdatesStateL( KNSmlAgentCopy(), aContent );
+ break;
+ default:
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentCopy, aContent->cmdID, aContent->flags );
+ break;
+ }
+ return 0;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlGetCmdFuncL
+// Get command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlGetCmdFuncL( SmlGetPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModGetCmdStateL( aContent );
+ break;
+ default:
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentGet, aContent->cmdID, aContent->flags );
+ break;
+ }
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlPutCmdFuncL
+// Put command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlPutCmdFuncL( SmlPutPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentPut, aContent->cmdID, aContent->flags );
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlResultsCmdFuncL
+// Results command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlResultsCmdFuncL( SmlResultsPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentResults, aContent->cmdID );
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlStatusCmdFuncL
+// Status command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlStatusCmdFuncL( SmlStatusPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModStatusCmdStateL( aContent );
+ break;
+ case EServerAlertNext:
+ ServerAlertNextStatusCmdStateL( aContent );
+ break;
+ default:
+ break;
+ }
+ return 0;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlStartMessageFuncL
+// SyncHdr from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlStartMessageFuncL( SmlSyncHdrPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModStartMessageStateL( aContent );
+ break;
+ case EServerAlertNext:
+ ServerAlertNextStartMessageStateL( aContent );
+ break;
+ default:
+ break;
+ }
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlEndMessageFuncL
+// End of SyncML message was reached
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlEndMessageFuncL( Boolean_t aFinal )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModEndMessageStateL( aFinal );
+ break;
+ case EServerAlertNext:
+ ServerAlertNextEndMessageStateL( aFinal );
+ break;
+ default:
+ User::Leave( TNSmlError::ESmlUnexpectedCmd );
+ break;
+ }
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlStartSyncFuncL
+// Sync command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlStartSyncFuncL( SmlSyncPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentSync, aContent->cmdID, aContent->flags );
+ WriteWarningL( TNSmlError::ESmlUnexpectedCmd );
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlEndSyncFuncL
+// End of Sync command was reached
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlEndSyncFuncL()
+ {
+ iCallbackCalled = ETrue;
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlStartAtomicFuncL
+// Atomic command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlStartAtomicFuncL( SmlAtomicPtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModStartAtomicStateL( aContent );
+ break;
+ default:
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAtomic, aContent->cmdID, aContent->flags );
+ break;
+ }
+
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlEndAtomicFuncL
+// End of Atomic command was reached
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlEndAtomicFuncL()
+ {
+ iCallbackCalled = ETrue;
+ ServerModEndAtomicStateL();
+ return 0;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlStartSequenceFuncL
+// Sequence command from server
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlStartSequenceFuncL( SmlSequencePtr_t aContent )
+ {
+ iCallbackCalled = ETrue;
+ switch ( iCurrMainState )
+ {
+ case EServerModifications:
+ ServerModStartSequenceStateL( aContent );
+ break;
+ default:
+ iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentSequence, aContent->cmdID, aContent->flags );
+ break;
+ }
+
+ return 0;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::smlEndSequenceFuncL
+// End of Sequence command was reached
+// ---------------------------------------------------------
+Ret_t CNSmlDMAgent::smlEndSequenceFuncL()
+ {
+ iCallbackCalled = ETrue;
+ ServerModEndSequenceStateL();
+ return 0;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::NavigateMainStateL()
+// Navigate according to state code
+// ---------------------------------------------------------
+void CNSmlDMAgent::NavigateMainStateL()
+ {
+#ifdef __CANCEL_TEST
+ iDMObserver->NotifyDisplayAlertL(KNullDesC,0,-99);
+#endif
+ switch ( iCurrMainState )
+ {
+ case EBeginning:
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ if ( iCurrBeginningState == EBegin )
+ {
+ CheckForcedCertificateCheckStateL();
+ }
+}
+ BeginningStateL();
+ break;
+ case EClientInitialisation:
+ ClientInitialisationStateL();
+ break;
+ case EServerModifications:
+ ServerModificationsStateL();
+ break;
+ case EDataUpdateStatus:
+ DataUpdateStatusStateL();
+ break;
+ case EResultAlert:
+ ResultAlertStateL();
+ break;
+ case EClientAlertNext:
+ ClientAlertNextStateL();
+ break;
+ case EServerAlertNext:
+ ServerAlertNextStateL();
+ break;
+ case EFinishing:
+ FinishingStateL();
+ break;
+ case ESending:
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ //if loop commented for DM session When TARM enabled TSW:ARAA-73XHUM
+ //if ( !CheckCertificateL())
+ //{
+ //Start sending state...
+ SendingStateL();
+ //}
+}
+else
+{
+ SendingStateL();
+}
+break;
+ case EReceiving:
+ ReceivingStateL();
+ break;
+ default:
+ break;
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::NextMainStateL()
+// Call a function which changes a state depending on type
+//
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::NextMainStateL()
+ {
+ if ( iCurrMainState == EReceiving )
+ {
+ iDMObserver->OnSyncMLSyncProgress(MSyncMLProgressObserver::ESmlReceivingServerCommands,0,0);
+ }
+ switch ( iCurrMainState )
+ {
+ case EBeginning:
+ if ( Interrupted() )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EFinishing"));
+ iCurrMainState = EFinishing;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EClientInitialisation"));
+ iCurrMainState = EClientInitialisation;
+ }
+ break;
+ case EClientInitialisation:
+ iPrevSyncState = iCurrMainState;
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL ESending"));
+ iCurrMainState = ESending;
+ break;
+ case EServerModifications:
+ iPrevSyncState = iCurrMainState;
+ if ( InterruptedImmediately() ) // immediately interruption needed?
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainState EFinishing"));
+ iCurrMainState = EFinishing;
+ }
+ else
+ {
+ if ( iBusyStatusReceived )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EResultAlert"));
+ iCurrMainState = EResultAlert;
+ }
+ else
+ {
+ if ( iChallengeRequest )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EClientInitialisation"));
+ iCurrMainState = EClientInitialisation;
+ }
+ else
+ {
+ if ( iCurrServerModState == EServerModMessageReceived )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EClientAlertNext"));
+ iCurrMainState = EClientAlertNext;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EDataUpdateStatus"));
+ iCurrMainState = EDataUpdateStatus;
+ }
+ }
+ }
+ }
+ break;
+ case EDataUpdateStatus:
+ iPrevSyncState = iCurrMainState;
+ if ( iStatusPackage )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL ESending"));
+ iCurrMainState = ESending;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EFinishing"));
+ iCurrMainState = EFinishing;
+ }
+ break;
+ case EResultAlert:
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL ESending"));
+ iCurrMainState = ESending;
+ break;
+ case EClientAlertNext:
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL ESending"));
+ iCurrMainState = ESending;
+ break;
+ case EServerAlertNext:
+ if ( Interrupted() )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EFinishing"));
+ iCurrMainState = EFinishing;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL Previous State"));
+ iCurrMainState = iPrevSyncState;
+ }
+ break;
+ case ESending:
+ if ( Interrupted() )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EFinishing"));
+ iCurrMainState = EFinishing;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EReceiving"));
+ iCurrMainState = EReceiving;
+ }
+ break;
+ case EReceiving:
+ if ( ( !iFinalMessageFromClient ) && ( iPrevSyncState == EDataUpdateStatus ) )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EServerAlertNext"));
+ iCurrMainState = EServerAlertNext;
+ }
+ else
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::NextMainStateL EServerModifications"));
+ iCurrMainState = EServerModifications;
+ }
+ break;
+ default:
+ break;
+ }
+ InitialiseSubStates();
+ if ( iCurrMainState == ESending )
+ {
+ iDMObserver->OnSyncMLSyncProgress(MSyncMLProgressObserver::ESmlSendingModificationsToServer,0,0);
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::InitialiseSubStates()
+//
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::InitialiseSubStates()
+ {
+ iCurrBeginningState = EBegin;
+ iCurrClientInitState = EInitStartingMessage;
+ iCurrResultAlertState = EResultAlertStartingMessage;
+ iCurrServerModState = EServerModWaitingStartMessage;
+ iCurrDataUpdateStatusState = EStatusStartingMessage;
+ iCurrResultAlertState = EResultAlertStartingMessage;
+ iCurrClientAlertNextState = EClientAlertNextStartingMessage;
+ iCurrServerAlertNextState = EServerAlertNextWaitingStartMessage;
+ }
+
+
+
+TBool CNSmlDMAgent::CheckCertificateL()
+{
+ if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ User::Leave(KErrNotSupported);
+ }
+ TBool retVal = EFalse;
+
+ //do certificate check...
+ if ( iForcedCertificateCheck && iCommandIssued)
+ {
+ //get session certificate via CentRep interface
+ CRepository * rep = 0;
+ TRAPD( err, rep = CRepository::NewL( KCRUidPolicyManagementUtilInternalKeys ))
+ TCertInfo info;
+
+ if( err == KErrNone)
+ {
+ //read certificate
+ TPckg<TCertInfo> certPck( info);
+ err = rep->Get( KSyncMLSessionCertificate, certPck);
+ delete rep;
+ }
+
+ TRole role = ENoRole;
+
+ if ( err == KErrNone)
+ {
+ //connect to policy engine
+ RPolicyEngine policyEngine;
+ err = policyEngine.Connect();
+
+ RPolicyManagement policyManagement;
+ err = policyManagement.Open( policyEngine);
+
+ //check certificate role
+ policyManagement.CertificateRole( info, role);
+
+ policyManagement.Close();
+ policyEngine.Close();
+ }
+
+ if ( role == ENoRole)
+ {
+ //if session doesn't have certificate or certificate doesn't have any role
+ //user acceptance is needed to resume the connection
+ UserConfirmateConnectionL();
+ retVal = ETrue;
+ }
+
+ iForcedCertificateCheck = EFalse;
+ }
+
+ return retVal;
+}
+
+void CNSmlDMAgent::UserConfirmateConnectionL()
+{
+ if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ User::Leave(KErrNotSupported);
+ }
+ delete iNotifierObserver;
+ iNotifierObserver = 0;
+ iNotifierObserver = new (ELeave) CNSmlAgentNotifierObserver( iStatus, 100);
+ iNotifierObserver->ConnectToNotifierL( this);
+
+}
+
+
+void CNSmlDMAgent::CheckForcedCertificateCheckStateL()
+{
+ if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ User::Leave(KErrNotSupported);
+ }
+ CRepository * rep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys );
+
+ User::LeaveIfError( rep->Get( KSyncMLForcedCertificateCheckKey, iForcedCertificateCheck));
+ CleanupStack::PopAndDestroy( rep);
+}
+
+
+
+
+//
+// Beginning state functions
+//
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::BeginStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::BeginStateL()
+ {
+ iDMObserver->OnSyncMLSyncProgress(MSyncMLProgressObserver::ESmlConnecting,0,0);
+
+ DBG_FILE(_S8("CNSmlDMAgent::BeginStateL Before InitSyncLogL"));
+ InitSyncLogL();
+ if ( iSyncInitiation == EServerAlerted )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::BeginStateL Before ParseTriggerMessageL"));
+ }
+ DBG_FILE(_S8("CNSmlDMAgent::BeginStateL Before ReadSettingsL"));
+ ReadSettingsL();
+ DBG_FILE(_S8("CNSmlDMAgent::BeginStateL Before CreateSyncmlCmdsInstanceL"));
+ CreateSyncmlCmdsInstanceL();
+ iCurrBeginningState = EBeginConnectingToServer;
+ }
+
+//
+// Client Initialisation state functions
+//
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::InitStartingMessageStateL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::InitStartingMessageStateL()
+ {
+ InitStartingMessageStateBaseL();
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::InitAlertingStateL()
+// Makes initialisation Alert command.
+// May also generate one or many generic alerts and
+// a generic user alert (i.e. user request to update firmware)
+// ---------------------------------------------------------
+void CNSmlDMAgent::InitAlertingStateL()
+ {
+ if ( !Interrupted() )
+ {
+ TBuf8<4> alertCode;
+ if ( iSyncInitiation == EClientInitiated )
+ {
+ alertCode = KNSmlDMAgentClientInitAlert;
+ }
+ else
+ {
+ alertCode = KNSmlDMAgentServerInitAlert;
+ }
+ iSyncMLCmds->DoAlertL( alertCode );
+ // FOTA
+ for ( TInt i(0); i<iGenAlerts.Count(); i++ )
+ {
+ // FOTA
+ if(iGenAlerts[i]->FinalResult() != 0)
+ {
+ iSyncMLCmds->DoGenericAlertL ( *iGenAlerts[i]->FwMgmtUri(), *iGenAlerts[i]->MetaType(), *iGenAlerts[i]->MetaFormat(),
+ iGenAlerts[i]->FinalResult(), *iGenAlerts[i]->FwCorrelator() );
+ }
+ else
+ {
+ // Other than FOTA case
+ iSyncMLCmds->DoGenericAlertL ( *iGenAlerts[i]->FwCorrelator(), *iGenAlerts[i]->DataItem());
+ }
+ }
+ if ( iGenAlerts.Count() > 0 )
+ {
+ iResetGenAlerts = ETrue;
+ }
+ iResetUserInitAlert = iSyncMLCmds->DoGenericUserAlertL ( iProfileID );
+ // FOTA end
+ }
+ iCurrClientInitState = EInitDeviceInfo;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::InitDeviceInfoStateL()
+// Device Info is sent in Replace command
+// ---------------------------------------------------------
+void CNSmlDMAgent::InitDeviceInfoStateL()
+ {
+ if ( !Interrupted() )
+ {
+ iSyncMLCmds->DoAddOrReplaceOrDeleteL();
+ }
+ iCurrClientInitState = EInitEndingMessage;
+ }
+
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModUpdatesStateL(()
+// Handles Add, Replace or Delete command from server
+// ---------------------------------------------------------
+void CNSmlDMAgent::ServerModUpdatesStateL( const TDesC8& aCmd, SmlGenericCmd_t* aContent )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModUpdatesStateL begins"));
+ if ( iCurrServerModState != EServerModWaitingCommands )
+ {
+ User::Leave( TNSmlError::ESmlUnexpectedCmd );
+ }
+ iSyncMLCmds->ProcessUpdatesL( aCmd, aContent );
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModUpdatesStateL ends"));
+ }
+// FOTA
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerModUpdatesStateL(()
+// Issues a process request for the arrived exec command.
+// @param aContent. The exec command structure, accordant
+// with the dtd.
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::ServerModUpdatesStateL ( SmlExec_t* aContent )
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModUpdatesStateL (for exec) begins"));
+ if ( iCurrServerModState != EServerModWaitingCommands )
+ {
+ User::Leave( TNSmlError::ESmlUnexpectedCmd );
+ }
+ iSyncMLCmds->ProcessExecCmdL ( aContent );
+ DBG_FILE(_S8("CNSmlDMAgent::ServerModUpdatesStateL (for exec) ends"));
+ }
+// FOTA end
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::DataUpdateStatusStartingMessageStateL()
+// Notify "Finalising" to UI, makes SyncHdr
+// ---------------------------------------------------------
+void CNSmlDMAgent::DataUpdateStatusStartingMessageStateL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::DataUpdateStatusStartingMessageStateL begins"));
+ DataUpdateStatusStartingMessageStateBaseL();
+ DBG_FILE(_S8("CNSmlDMAgent::DataUpdateStatusStartingMessageStateL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::DataUpdateStatusMakingResultsStateL()
+// Results to Get commands from a server
+// ---------------------------------------------------------
+void CNSmlDMAgent::DataUpdateStatusMakingResultsStateL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::DataUpdateStatusMakingResultsStateL begins"));
+ if ( iSyncMLCmds->ResultsContainer() )
+ {
+ if ( iSyncMLCmds->ResultsContainer()->AnyResults() )
+ {
+ // there is something to send
+ iStatusPackage = ETrue;
+ }
+ }
+ CNSmlCmdsBase::TReturnValue ret = iSyncMLCmds->DoResultsL();
+ if ( ret == CNSmlCmdsBase::EReturnBufferFull )
+ {
+ iBufferFull = ETrue;
+ }
+ iCurrDataUpdateStatusState = EStatusEndingMessage;
+ DBG_FILE(_S8("CNSmlDMAgent::DataUpdateStatusMakingResultsStateL ends"));
+ }
+
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::NonceL()
+// Nonce (used in MD5 auth) from DM Settings
+// ---------------------------------------------------------
+HBufC* CNSmlDMAgent::NonceL() const
+ {
+ HBufC* nonce = NULL;
+#ifndef __MODULETEST
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ nonce = profile->NonceLC( EDMProfileServerNonce );
+ CleanupStack::Pop(); //NonceLC
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+#endif
+ return( nonce );
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::SetNonceL()
+// Nonce from the server's challenge is stored to DM Settings
+// ---------------------------------------------------------
+void CNSmlDMAgent::SetNonceL( const TDesC& aNonce ) const
+ {
+#ifndef __MODULETEST
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ profile->SetNonceL( EDMProfileServerNonce, aNonce );
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+#endif
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerUserName()
+//
+// ---------------------------------------------------------
+TPtrC CNSmlDMAgent::ServerUserName() const
+ {
+ return *iDMServerId;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerPassword()
+//
+// ---------------------------------------------------------
+TPtrC CNSmlDMAgent::ServerPassword() const
+ {
+ return *iDMServerPassword;
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::ServerNonceAllocL()
+//
+// ---------------------------------------------------------
+HBufC* CNSmlDMAgent::ServerNonceAllocL() const
+ {
+ HBufC* nonce = NULL;
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ nonce = profile->NonceLC( EDMProfileClientNonce );
+ CleanupStack::Pop(); //NonceLC
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ return( nonce );
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::SetServerNonceL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::SetServerNonceL( const TDesC& aNonce ) const
+ {
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ profile->SetNonceL( EDMProfileClientNonce, aNonce );
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::FinalizeSyncLog()
+// Sync Log is written after sync
+// ---------------------------------------------------------
+void CNSmlDMAgent::FinalizeSyncLog()
+ {
+ TRAP_IGNORE( FinalizeSyncLogL() );
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::FinalizeSyncLogL()
+// Sync Log is written after sync
+// ---------------------------------------------------------
+void CNSmlDMAgent::FinalizeSyncLogL()
+ {
+ if(iSyncLog)
+ {
+ TTime now;
+ //now.HomeTime();//previously using
+ now.UniversalTime();
+ iSyncLog->SetResult(now, iError->SyncLogErrorCode());
+
+ CNSmlDMSettings* settings = CNSmlDMSettings::NewLC();
+ CNSmlDMProfile* profile = settings->ProfileL( iProfileID );
+ if(!profile)
+ {
+ iSyncLog = NULL;
+ CleanupStack::PopAndDestroy(); //setttings
+ return;
+ }
+ CleanupStack::PushL( profile );
+ if(iError->SyncLogErrorCode() == KErrNone)
+ {
+ RWriteStream& LastSyncStream = profile->LastSyncWriteStreamL();
+ CleanupClosePushL( LastSyncStream );
+ TPckgBuf<TTime> lastsynctime(now);
+ LastSyncStream << lastsynctime;
+ CleanupStack::PopAndDestroy();
+ profile->LastSyncStreamCommitL();
+ iSyncLog->SetLastSyncResult(now);//vijay
+ }
+ else
+ {
+ if(profile->HasLastSyncL())
+ {
+ RReadStream& Lastsyncstream=profile->LastSyncReadStreamL();
+ CleanupClosePushL( Lastsyncstream );
+ TTime SyncSuccessTime;
+ SyncSuccessTime.UniversalTime();
+ TPckgBuf<TTime> lastsynctime(SyncSuccessTime);
+ Lastsyncstream >> lastsynctime;
+ SyncSuccessTime = lastsynctime().Int64();
+ iSyncLog->SetLastSyncResult(SyncSuccessTime);
+ CleanupStack::PopAndDestroy();
+ }
+ }
+ 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;
+ }
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::CreateSyncmlCmdsInstanceL()
+//
+// ---------------------------------------------------------
+void CNSmlDMAgent::CreateSyncmlCmdsInstanceL()
+ {
+ if ( !iSyncMLCmds )
+ {
+ TInt numSessionID;
+ TBuf8<16> stringSessionID;
+ if ( iSyncInitiation == EServerAlerted )
+ {
+ numSessionID = iDMServerSessionId;
+ }
+ else
+ {
+ numSessionID = GetSessionIDL();
+ numSessionID++;
+ }
+ //Session id is greater than 16-bit max value
+ if( numSessionID > KMaxInt16 || numSessionID < 0 )
+ {
+ numSessionID = 0;
+ }
+ UpdateSessionIDL( numSessionID );
+ stringSessionID.Num( numSessionID );
+ if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112 ))
+ {
+ iSyncMLCmds = CNSmlDMCmds::NewL( this, stringSessionID, KNSmlDMAgentVerProto12, *iSyncMLUserName, iSyncServer, *iDMServerId, iDMObserver );
+ }
+ else
+ {
+ iSyncMLCmds = CNSmlDMCmds::NewL( this, stringSessionID, KNSmlDMAgentVerProto, *iSyncMLUserName, iSyncServer, *iDMServerId, iDMObserver );
+ }
+ }
+
+ iSyncMLCmds->ServerAuth()->SetSyncAgent( this );
+ if( !(( iMediumType == KUidNSmlMediumTypeBluetooth || iMediumType == KUidNSmlMediumTypeUSB || iMediumType == KUidNSmlMediumTypeIrDA )
+ && iDMServerPassword->Length() == 0 ))
+ {
+#ifndef __NO_SERVERAUTH
+ iSyncMLCmds->ServerAuth()->SetAuthRequiredL();
+#endif
+ }
+ if ( iSyncInitiation == EServerAlerted )
+ {
+ if ( iDMServerDigest )
+ {
+ iSyncMLCmds->ServerAuth()->SetCredentialL( *iDMServerDigest );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::CheckCommandsAreReceivedL()
+// Check that server has sent all expected commands,
+// empty function in DM
+// ---------------------------------------------------------
+void CNSmlDMAgent::CheckCommandsAreReceivedL()
+ {
+ }
+
+//
+// Authentications
+//
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::SetAuthTypeL()
+// Set authentication type to DM Settings
+// ---------------------------------------------------------
+void CNSmlDMAgent::SetAuthTypeL( CNSmlAgentBase::TAuthenticationType aAuthType ) const
+ {
+#ifndef __MODULETEST
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ profile->SetIntValue( EDMProfileAuthenticationRequired, aAuthType );
+ profile->SaveL();
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+#endif
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::AuthTypeL()
+// Read Authentication type from DM settings
+// ---------------------------------------------------------
+
+CNSmlAgentBase::TAuthenticationType CNSmlDMAgent::AuthTypeL() const
+ {
+ CNSmlAgentBase::TAuthenticationType authType = CNSmlAgentBase::ENoAuth;
+ #ifndef __MODULETEST
+ CNSmlDMProfile* profile = CNSmlDMSettings::NewLC()->ProfileL( iProfileID );
+ if ( !profile )
+ {
+ User::Leave( TNSmlError::ESmlErrorInSettings );
+ }
+ else
+ {
+ CleanupStack::PushL( profile );
+ authType = (CNSmlAgentBase::TAuthenticationType) profile->IntValue( EDMProfileAuthenticationRequired );
+ CleanupStack::PopAndDestroy( 2 ); //profile, settings
+ }
+ #endif
+ return authType;
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::FreeResources()
+// Release allocated resources
+// ---------------------------------------------------------
+//
+void CNSmlDMAgent::FreeResources()
+ {
+ delete iDMTriggerMessage;
+ iDMTriggerMessage = NULL;
+ delete iDMServerId;
+ iDMServerId = NULL;
+ delete iDMServerPassword;
+ iDMServerPassword = NULL;
+ delete iDMServerDigest;
+ iDMServerDigest = NULL;
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ delete iNotifierObserver;
+ iNotifierObserver = NULL;
+}
+ FreeBaseResources();
+ }
+
+
+//
+// Error Handling functions
+//
+// ---------------------------------------------------------
+// CNSmlDMAgent::FinaliseWhenErrorL()
+// This function is called if sync is breaked down immediately (Leave errors)
+// This function MUST NOT leave.
+// ---------------------------------------------------------
+void CNSmlDMAgent::FinaliseWhenErrorL()
+ {
+ DBG_FILE(_S8("CNSmlDMAgent::FinaliseWhenErrorL begins"));
+ if ( iSyncMLCmds )
+ {
+ iSyncMLCmds->WriteMappingInfoToDbL();
+ iSyncMLCmds->DisconnectFromOtherServers();
+ }
+ DBG_FILE(_S8("CNSmlDMAgent::FinaliseWhenErrorL ends"));
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::Interrupted()
+//
+// ---------------------------------------------------------
+TBool CNSmlDMAgent::Interrupted()
+ {
+ return iDMInterrupted;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::Interrupt()
+// Synchronisation with all databases is interrupted
+// Synchronisation level error code to Sync Log.
+// ---------------------------------------------------------
+void CNSmlDMAgent::Interrupt( TInt aErrorCode, TBool aImmediatelyInterruption, TBool aStatusError )
+ {
+ if ( !Interrupted() || aStatusError )
+ {
+ // Error code is updated only once, except errors due to
+ // error Status codes from the server
+ iError->SetErrorCode( aErrorCode );
+ iDMInterrupted = ETrue;
+ iSessionAbortAlertRequest = ETrue;
+ iDMImmediatelyInterruption = aImmediatelyInterruption;
+ }
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::InterruptL()
+// The function is implemented, because base class may use this one
+// In the case of DM, appIndex does not point anything.
+// ---------------------------------------------------------
+void CNSmlDMAgent::InterruptL( TInt /*appIndex*/, TInt aErrorCode, TBool aImmediatelyInterruption, TBool aStatusError )
+ {
+ Interrupt( aErrorCode, aImmediatelyInterruption, aStatusError );
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMAgent::WriteWarningL()
+// Sync level warning message to Sync Log
+// ---------------------------------------------------------
+void CNSmlDMAgent::WriteWarningL( TNSmlError::TNSmlAgentErrorCode aWarningCode )
+ {
+ iError->SetErrorCode( aWarningCode );
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::WriteWarningL()
+// Database level warning message to Sync Log
+// ---------------------------------------------------------
+void CNSmlDMAgent::WriteWarningL( TInt /*appIndex*/, TNSmlError::TNSmlAgentErrorCode aWarningCode )
+ {
+ WriteWarningL( aWarningCode );
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::WriteWarningL()
+// Database level warning message to Sync Log
+// ---------------------------------------------------------
+void CNSmlDMAgent::WriteWarningL( TInt /*appIndex*/, TNSmlError::TNSmlSyncMLStatusCode aWarningCode )
+ {
+ WriteWarningL( (TNSmlError::TNSmlAgentErrorCode) (TInt) aWarningCode );
+ }
+// ---------------------------------------------------------
+// CNSmlDMAgent::CheckServerStatusCodeL()
+// Status code validating
+// ---------------------------------------------------------
+void CNSmlDMAgent::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::ESmlStatusAuthenticationAccepted: //212
+ if ( cmd == KNSmlAgentSyncHdr )
+ {
+ iAlreadyAuthenticated = ETrue;
+ }
+ error = EFalse;
+ break;
+ case TNSmlError::ESmlStatusUnauthorized: // 401
+ if ( cmd == KNSmlAgentSyncHdr )
+ {
+ if ( iSyncMLCmds->ResponseController()->ChalType( aEntryID ).Length() != 0 )
+ {
+ if ( AuthenticationRequirementL( *iSyncMLCmds->ResponseController(), aEntryID ) )
+ {
+ iChallengeRequest = ETrue;
+ SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID );
+ iSyncMLCmds->ResponseController()->ResetL();
+ return;
+ }
+ else
+ {
+ error = ETrue;
+ }
+ }
+ else
+ {
+ error = ETrue;
+ }
+ }
+ break;
+ case TNSmlError::ESmlStatusClientAuthenticationRequired: // 407
+ if ( cmd == KNSmlAgentSyncHdr )
+ {
+ if ( AuthenticationRequirementL( *iSyncMLCmds->ResponseController(), aEntryID ) )
+ {
+ iChallengeRequest = ETrue;
+ SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID );
+ iSyncMLCmds->ResponseController()->ResetL();
+ return;
+ }
+ else
+ {
+ error = ETrue;
+ }
+ }
+ else
+ {
+ error = ETrue;
+ }
+ break;
+ default:
+ error = EFalse;
+ break;
+ }
+ if ( cmd == KNSmlAgentSyncHdr )
+ {
+ SaveIfNonceL( *iSyncMLCmds->ResponseController(), aEntryID );
+ }
+ if ( error )
+ {
+ InterruptL( iSyncMLCmds->ResponseController()->AppIndex( aEntryID ), status, ETrue, ETrue );
+ }
+ return;
+ }
+
+// FOTA
+// ---------------------------------------------------------
+// CNSmlDMGenericAlert::NewL()
+// Creates a new generic alert object.
+// @param aFwMgmtUri. The uri which has been used in the exe command whose final result is
+// about to be reported.
+// @param aMetaType. Meta/Type that should be used in the alert.
+// @param aMetaFormat. Meta/Format that should be used in the alert.
+// @param aFinalResult. The final result value which is reported to remote server.
+// @param aCorrelator. Correlator value used in the original exec command.
+// @return CNSmlDMGenericAlert*. New instance of this class.
+// ---------------------------------------------------------
+//
+CNSmlDMGenericAlert* CNSmlDMGenericAlert::NewL ( const TDesC8& aFwMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat,
+ TInt aFinalResult, const TDesC8& aFwCorrelator )
+ {
+ CNSmlDMGenericAlert* self = new (ELeave) CNSmlDMGenericAlert();
+ CleanupStack::PushL( self );
+ self->ConstructL ( aFwMgmtUri, aMetaType, aMetaFormat, aFinalResult, aFwCorrelator );
+ CleanupStack::Pop(); //self
+ return self;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMGenericAlert::NewL()
+// Creates a new generic alert object.
+// @param aFwMgmtUri. The uri which has been used in the exe command whose final result is
+// about to be reported.
+// @param aMetaType. Meta/Type that should be used in the alert.
+// @param aMetaFormat. Meta/Format that should be used in the alert.
+// @param aFinalResult. The final result value which is reported to remote server.
+// @param aCorrelator. Correlator value used in the original exec command.
+// @return CNSmlDMGenericAlert*. New instance of this class.
+// ---------------------------------------------------------
+//
+CNSmlDMGenericAlert* CNSmlDMGenericAlert::NewL ( const TDesC8& aCorrelator, const RArray<CNSmlDMAlertItem>& aItemList )
+ {
+ CNSmlDMGenericAlert* self = new (ELeave) CNSmlDMGenericAlert();
+ CleanupStack::PushL( self );
+ _LIT8(KDummy, "dummy");
+ self->ConstructL ( KDummy(), KDummy(), KDummy(), 0, aCorrelator, &aItemList );
+ CleanupStack::Pop(); //self
+ return self;
+ }
+
+// ---------------------------------------------------------
+// CNSmlDMGenericAlert::CNSmlDMGenericAlert()
+// C++ destructor.
+// ---------------------------------------------------------
+//
+CNSmlDMGenericAlert::~CNSmlDMGenericAlert()
+ {
+ delete iFwMgmtUri;
+ delete iMetaType;
+ delete iMetaFormat;
+ delete iFwCorrelator;
+ if (iDataItem)
+ {
+ iDataItem->Close();
+ }
+ delete iDataItem;
+ }
+
+
+// ---------------------------------------------------------
+// CNSmlDMGenericAlert::CNSmlDMGenericAlert()
+// C++ constructor.
+// ---------------------------------------------------------
+//
+CNSmlDMGenericAlert::CNSmlDMGenericAlert()
+ {
+ }
+// ---------------------------------------------------------
+// CNSmlDMGenericAlert::ConstructL()
+// Symbian 2nd phase constructor
+// ---------------------------------------------------------
+//
+void CNSmlDMGenericAlert::ConstructL( const TDesC8& aFwMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat,
+ TInt aFinalResult, const TDesC8& aFwCorrelator, const RArray<CNSmlDMAlertItem>* aItemList )
+ {
+ if(aFinalResult != 0)
+ {
+ iFwMgmtUri = aFwMgmtUri.AllocL();
+ iMetaType = aMetaType.AllocL();
+ iMetaFormat = aMetaFormat.AllocL();
+ }
+ iFwCorrelator = aFwCorrelator.AllocL();
+ iFinalResult = aFinalResult;
+
+
+ TInt count = 0;
+ if (aItemList)
+ count = aItemList->Count();
+
+ if( count > 0)
+ {
+ iDataItem = new (ELeave) RArray<CNSmlDMAlertItem>(); // new (ELeave) RArray<TDes8<255> > ();
+
+ for(TInt i =0; i< count ; i++)
+ {
+ CNSmlDMAlertItem* iItem = new (ELeave) CNSmlDMAlertItem ;
+ iItem->iSource = ((*aItemList)[i].iSource)->AllocL();
+ iItem->iTarget = ((*aItemList)[i].iTarget)->AllocL();
+ iItem->iMetaType = ((*aItemList)[i].iMetaType)->AllocL();
+ iItem->iMetaFormat = ((*aItemList)[i].iMetaFormat)->AllocL();
+ iItem->iMetaMark = ((*aItemList)[i].iMetaMark)->AllocL();
+ iItem->iData = ((*aItemList)[i].iData)->AllocL();
+ iDataItem->AppendL(*iItem);
+ }
+ }
+
+ }
+
+// FOTA end
+
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::CNSmlNotifierObserver(TRequestStatus& aStatus, CNSmlThreadEngine* aEngine, CNSmlThreadParams& aParams)
+// Constructor
+// --------------------------------------------------------------------------
+//
+CNSmlAgentNotifierObserver::CNSmlAgentNotifierObserver(TRequestStatus& aStatus, TInt aCreatorId)
+: CActive(0), iCallerStatus(aStatus), iCreatorId(aCreatorId)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::~CNSmlNotifierObserver()
+// Destructor
+// --------------------------------------------------------------------------
+//
+CNSmlAgentNotifierObserver::~CNSmlAgentNotifierObserver()
+ {
+ // StartNotifier called to avoid Notifier server panic, if
+ // notifier does not exist anymore.
+ TBuf8<1> dummy;
+ iNotifier.StartNotifier(KNullUid, dummy, dummy); // KNullUid should do also..
+ iNotifier.CancelNotifier( KUidNotifier );
+ iNotifier.Close();
+ iNotifierTimeOut.Cancel();
+ Cancel();
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::ConnectToNotifierL( const TSyncMLAppLaunchNotifParams& aParam )
+// Starts connection with notifier
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierObserver::ConnectToNotifierL( CNSmlAgentBase * aNSmlAgentBase)
+ {
+ iTimeOut = EFalse;
+ iNSmlAgentBase = aNSmlAgentBase;
+
+ if ( !IsActive() )
+ {
+ SetActive();
+ }
+
+ //connect to repository
+ CRepository* rep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys );
+
+ //get parameters
+ TSyncMLAppLaunchNotifParams params;
+ TPckg<TSyncMLAppLaunchNotifParams> data( params );
+ User::LeaveIfError( rep->Get( KSyncMLSessionParamsKey, data));
+
+ CleanupStack::PopAndDestroy( rep);
+
+ iNotifierTimeOut.LaunchNotifierTimer( this );
+ User::LeaveIfError( iNotifier.Connect() );
+ iNotifier.StartNotifierAndGetResponse( iStatus, KUidNotifier, data, iResBuf );
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::NotifierTimeOut()
+// Starts notifier time out timer
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierObserver::NotifierTimeOut()
+ {
+ iTimeOut = ETrue;
+ // StartNotifier called to avoid Notifier server panic, if
+ // notifier does not exist anymore.
+ TBuf8<1> dummy;
+ iNotifier.StartNotifier(KNullUid, dummy, dummy); // KNullUid should do also..
+
+ iNotifier.CancelNotifier( KUidNotifier );
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::DoCancel()
+// From base class
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierObserver::DoCancel()
+ {
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierObserver::RunL()
+// From base class
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierObserver::RunL()
+{
+
+ TInt ret = iStatus.Int();
+ if ( ret == KErrCancel || iTimeOut )
+ {
+ iNSmlAgentBase->DoOutsideCancel();
+ }
+ else
+ {
+ if ( ret == KErrNone )
+ {
+
+ TInt sid = iResBuf().iSecureId.iUid; // read secure id from notifier.
+
+ // Check the response and error code. If there is a fail, dump the job.
+ // Also compare sid to creator id saved for current job to secure that listener owns the job.
+/* if ( ret != KErrNone || sid != iThreadParams.iCurrentJob.CreatorId() )
+ {
+ if ( ret == KErrNone && sid != iThreadParams.iCurrentJob.CreatorId() )
+ {
+#ifndef __WINS__
+ ret = KErrPermissionDenied;
+#endif
+ }
+ }*/
+
+ }
+ }
+
+ TRequestStatus* sStatus = &iCallerStatus;
+ User::RequestComplete( sStatus, KErrNone );
+}
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierTimeOut::~CNSmlNotifierTimeOut()
+// Constructor
+// --------------------------------------------------------------------------
+//
+CNSmlAgentNotifierTimeOut::CNSmlAgentNotifierTimeOut()
+:CActive(0)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierTimeOut::~CNSmlNotifierTimeOut()
+// Destructor
+// --------------------------------------------------------------------------
+//
+CNSmlAgentNotifierTimeOut::~CNSmlAgentNotifierTimeOut()
+ {
+ Cancel();
+ iTimeOutTimer.Close();
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierTimeOut::LaunchNotifierTimer( CNSmlNotifierObserver* aObserver )
+// Starts notifier time out timer
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierTimeOut::LaunchNotifierTimer( CNSmlAgentNotifierObserver* aObserver )
+ {
+
+ if ( !IsActive() )
+ {
+ SetActive();
+ }
+
+ iTimeOutTimer.CreateLocal();
+ iTimeOutTimer.After( iStatus, KNotifierTimeout );
+ iObserver = aObserver;
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierTimeOut::DoCancel()
+// From base class
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierTimeOut::DoCancel()
+ {
+ iTimeOutTimer.Cancel();
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlNotifierTimeOut::RunL()
+// From base class
+// --------------------------------------------------------------------------
+//
+void CNSmlAgentNotifierTimeOut::RunL()
+ {
+ if ( iStatus.Int() != KErrCancel )
+ {
+ iObserver->NotifierTimeOut();
+ }
+ }
+
+
+
+// ---------------------------------------------------------
+// CreateDMAgentL( MNSmlDMAgentObserver* aDMObserver )
+// Return the instance of the CNSmlDMAgent
+// ---------------------------------------------------------
+//
+EXPORT_C CNSmlDMAgent* CreateDMAgentL( MSyncMLProgressObserver* aDMObserver )
+ {
+ return CNSmlDMAgent::NewL( aDMObserver );
+ }
+
+// End of File
+