--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/common/sosserver/src/nsmlsossession.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,2480 @@
+/*
+* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Symbian OS Server source.
+*
+*/
+
+#include <s32mem.h>
+#include <SyncMLErr.h>
+
+#include <nsmlconstants.h>
+#include <nsmldebug.h>
+#include "nsmlsosserver.h"
+
+#include "nsmldssettings.h"
+#include "nsmldmsettings.h"
+#include "nsmldshostclient.h"
+#include <featmgr.h>
+// CONSTANTS
+const TInt KNSmlMutexLoopCounter = 5;
+
+// LOCAL FUNCTION PROTOTYPES
+//
+LOCAL_C TInt NSmlGrabMutex( RMutex& aMutex, const TDesC& aMutexName );
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession* CNSmlSOSSession::NewL( CNSmlSOSServer* aServer, CNSmlSOSHandler* aHandler )
+// --------------------------------------------------------------------------
+//
+CNSmlSOSSession* CNSmlSOSSession::NewL( CNSmlSOSServer* aServer, CNSmlSOSHandler* aHandler )
+ {
+ _DBG_FILE("CNSmlSOSSession::NewL(): begin");
+
+ CNSmlSOSSession* self= new (ELeave) CNSmlSOSSession( aServer, aHandler );
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(); // self
+
+ _DBG_FILE("CNSmlSOSSession::NewL(): end");
+
+ return self;
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession::CNSmlSOSSession( CNSmlSOSServer* aServer, CNSmlSOSHandler* aHandler )
+// --------------------------------------------------------------------------
+//
+CNSmlSOSSession::CNSmlSOSSession( CNSmlSOSServer* aServer, CNSmlSOSHandler* aHandler ) : iServer(aServer), iHandler(aHandler)
+ {
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ConstructL()
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ConstructL()
+ {FeatureManager::InitializeLibL();
+ iHandler->IncreaseSessionCount();
+
+ iObjCon = iServer->NewContainerL();
+ iObjIndex = CObjectIx::NewL();
+ iDsClient = CNSmlDSHostClient::NewL();
+ iDSSettings = CNSmlDSSettings::NewL();
+ iDMSettings = CNSmlDMSettings::NewL();
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession::~CNSmlSOSSession()
+// --------------------------------------------------------------------------
+//
+CNSmlSOSSession::~CNSmlSOSSession()
+ {
+ _DBG_FILE("CNSmlSOSSession::~CNSmlSOSSession(): begin");
+ delete iObjIndex;
+ delete iDMAuthInfo;
+ iArray.Close();
+ iEventBuffer.Reset();
+ iEventBuffer.Close();
+
+ //delete progress event buffer
+ iProgressEventBuffer.Reset();
+ iProgressEventBuffer.Close();
+
+ iContactSuiteProgressEventBuffer.Reset();
+ iContactSuiteProgressEventBuffer.Close();
+
+ delete iDsClient;
+ delete iDSSettings;
+ delete iDMSettings;
+
+ if ( iHandler )
+ {
+ iHandler->DecreaseSessionCount();
+ iHandler->ClearSessionFromJob( this );
+ }
+ FeatureManager::UnInitializeLib();
+ _DBG_FILE("CNSmlSOSSession::~CNSmlSOSSession(): end");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ServiceL( const RMessage2& aMessage )
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ServiceL( const RMessage2& aMessage )
+ {
+ if ( iHandler->IsSuspended() && aMessage.Function() != ECmdEventRequest ) // Check if server is suspended.
+ {
+ _DBG_FILE("CNSmlSOSSession::ServiceL(): server suspended !");
+ aMessage.Complete( SyncMLError::KErrSuspended ); // Server suspended, block the messege.
+ return;
+ }
+
+ TRAPD(err,DispatchMessageL(aMessage));
+ if ( err != KErrNone )
+ {
+ aMessage.Complete( err );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::DispatchMessageL( const RMessage2& aMessage )
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::DispatchMessageL( const RMessage2& aMessage )
+ {
+ switch( aMessage.Function() )
+ {
+ // requests
+ case ECmdEventRequest:
+ iEventMsgHandle = aMessage.Handle();
+ iHandler->AddEventMsgL( aMessage );
+ CompleteBufferedEventL();
+ return;
+ case ECmdEventRequestCancel:
+ iHandler->CancelEventMsg(iEventMsgHandle);
+ iEventBuffer.Reset();
+ aMessage.Complete(KErrNone);
+ return;
+ case ECmdProgressRequest:
+ iHandler->AddProgressMsgL( aMessage );
+ // Handle current progress events from buffer
+ CompleteBufferedProgressEventL();
+ return;
+ case ECmdContactSuiteProgressRequest:
+ iHandler->AddContactSuiteProgressMsgL( aMessage );
+ // Handle current progress events from buffer
+ CompleteBufferedContactSuiteProgressEventL();
+ return;
+ case ECmdContactSuiteProgressRequestCancel:
+ iHandler->CancelContactSuiteProgressMsg(this);
+ iHandler->RegisterContactSuiteObserversWithProfileId( 0 );
+ // Reset progress event buffer
+ iContactSuiteProgressEventBuffer.Reset();
+ aMessage.Complete(KErrNone);
+ return;
+ case ECmdContactSuiteRegisterObserversWithProfileId:
+ iHandler->RegisterContactSuiteObserversWithProfileId( aMessage.Int0() );
+ return;
+ case ECmdProgressRequestCancel:
+ iHandler->CancelProgressMsg(this);
+ // Reset progress event buffer
+ iProgressEventBuffer.Reset();
+ aMessage.Complete(KErrNone);
+ return;
+ // session
+ case ECmdProfileDelete:
+ DeleteProfileL( aMessage );
+ return;
+ case ECmdJobListCurrent:
+ CurrentJobL( aMessage );
+ return;
+ case ECmdJobListStart:
+ QueuedJobsL( aMessage );
+ return;
+ case ECmdJobListNext:
+ PackIntDataL( aMessage );
+ return;
+ case ECmdProfileListStart:
+ ProfileListL( aMessage );
+ return;
+ case ECmdProfileListNext:
+ PackIntDataL( aMessage );
+ return;
+ // profile
+ case ECmdProfileCreateDM:
+ CreateProfileL( aMessage, ESmlDevMan );
+ return;
+ case ECmdProfileCreateDS:
+ CreateProfileL( aMessage, ESmlDataSync );
+ return;
+ case ECmdProfileOpenDM:
+ OpenProfileL( aMessage, ESmlDevMan );
+ return;
+ case ECmdProfileOpenDS:
+ OpenProfileL( aMessage, ESmlDataSync );
+ return;
+ case ECmdProfileGet:
+ GetProfileL( aMessage );
+ return;
+ case ECmdProfileSet:
+ SetProfileL( aMessage );
+ return;
+ case ECmdProfileClose:
+ CloseProfile( aMessage );
+ return;
+ case ECmdConnList:
+ ConnectionListL( aMessage );
+ return;
+ case ECmdTaskDelete:
+ DeleteTaskL( aMessage );
+ return;
+ case ECmdTaskListStart:
+ TaskListL( aMessage );
+ return;
+ case ECmdTaskListNext:
+ PackIntDataL( aMessage );
+ return;
+ // task
+ case ECmdCreateTask:
+ CreateTaskL( aMessage );
+ return;
+ case ECmdTaskOpen:
+ OpenTaskL( aMessage );
+ return;
+ case ECmdTaskGet:
+ GetTaskL( aMessage );
+ return;
+ case ECmdTaskFilterBufferSize:
+ OpenTaskSupportedFiltersL( aMessage );
+ return;
+ case ECmdTaskSupportedFilters:
+ GetTaskSupportedFiltersL( aMessage );
+ return;
+ case ECmdTaskSet:
+ SetTaskL( aMessage );
+ return;
+ case ECmdTaskClose:
+ CloseTaskL( aMessage );
+ return;
+ // connection
+ case ECmdConnOpen:
+ OpenConnectionL( aMessage );
+ return;
+ case ECmdConnGet:
+ GetConnectionL( aMessage );
+ return;
+ case ECmdConnSet:
+ SetConnectionL( aMessage );
+ return;
+ case ECmdConnClose:
+ CloseConnectionL( aMessage );
+ return;
+ // history log
+ case ECmdHistoryLogOpen:
+ OpenHistoryLogL( aMessage );
+ return;
+ case ECmdHistoryLogGet:
+ GetHistoryLogL( aMessage );
+ return;
+ case ECmdHistoryLogReset:
+ ResetHistoryLogL( aMessage );
+ return;
+ case ECmdHistoryLogClose:
+ CloseHistoryLogL( aMessage );
+ return;
+ // data provider
+ case ECmdDataProviderOpen:
+ OpenDataProviderL( aMessage );
+ return;
+ case ECmdDataProviderGet:
+ GetDataProviderL( aMessage );
+ return;
+ case ECmdDataProviderClose:
+ CloseDataProviderL( aMessage );
+ return;
+ // job
+ case ECmdDataSyncJobCreateForProfile:
+ CreateJobL( EDSJobProfile, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForProfileST:
+ CreateJobL( EDSJobProfileST, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTasks:
+ CreateJobL( EDSJobTasks, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTasksST:
+ CreateJobL( EDSJobTasksST, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTransport:
+ CreateJobL( EDSJobTransport, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTransportST:
+ CreateJobL( EDSJobTransportST, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTransportAndTasks:
+ CreateJobL( EDSJobTaskTrans, aMessage );
+ return;
+ case ECmdDataSyncJobCreateForTransportAndTasksST:
+ CreateJobL( EDSJobTaskTransST, aMessage );
+ return;
+ case ECmdDevManJobCreate:
+ CreateJobL( EDMJobProfile, aMessage );
+ return;
+ case ECmdDevManJobCreateForTransport:
+ CreateJobL( EDMJobTransport, aMessage );
+ return;
+ case ECmdJobOpen:
+ OpenJobL( aMessage );
+ return;
+ case ECmdJobGet:
+ GetJobL( aMessage );
+ return;
+ case ECmdJobStop:
+ StopJob( aMessage );
+ return;
+ case ECmdJobClose:
+ CloseJobL( aMessage );
+ return;
+ case ECmdServerAlert:
+ ServerAlertL( aMessage );
+ return;
+ case ECmdInitDMAuthInfo:
+ InitDMAuthInfoL( aMessage );
+ return;
+ case ECmdGetDMAuthInfo:
+ GetDMAuthInfoL( aMessage );
+ return;
+ case ECmdSetDMAuthInfo:
+ SetDMAuthInfoL( aMessage );
+ return;
+ // FOTA
+ case ECmdAddDMGenericAlert:
+ AddDMGenericAlertL( aMessage );
+ return;
+ // FOTA end
+ case ECmdAddGenericAlert:
+ AddGenericAlertL( aMessage );
+ return;
+ default:
+ aMessage.Panic( _L("CNSmlSOSSession"), KErrArgument );
+ return;
+ }
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ServerAlertL( const RMessage2& aMessage )
+// Sends server alert parameters to handler.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ServerAlertL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::ServerAlertL(): begin");
+
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL(0) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 0, bufPtr, 0 );
+
+ iHandler->ServerAlertL( bufPtr, (TSmlUsageType) aMessage.Int1(), (TSmlProtocolVersion) aMessage.Int2(), aMessage.Int3() );
+
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Complete(KErrNone);
+
+ _DBG_FILE("CNSmlSOSSession::ServerAlertL(): end");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::InitDMAuthInfoL( const RMessage2& aMessage )
+// Reads DM authentication info from settings and returns size of data to client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::InitDMAuthInfoL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::InitDMAuthInfoL(): begin");
+ if ( aMessage.SecureId().iId != KUidDMServer.iUid &&
+ aMessage.SecureId().iId != KUidWAPPush.iUid &&
+ aMessage.SecureId().iId != KUidSRCS.iUid )
+ {
+ aMessage.Complete(KErrPermissionDenied); // Complete message with error code.
+ _DBG_FILE("CNSmlSOSSession::InitDMAuthInfoL(): incompatible secure id!");
+ return;
+ }
+
+ TInt ret(KErrNotFound);
+
+ CNSmlDMSettings* settings = CNSmlDMSettings::NewLC();
+ CNSmlDMProfile* prof = settings->ProfileL( aMessage.Int0() );
+
+ if ( prof )
+ {
+ CleanupStack::PushL( prof );
+
+ CBufBase* buffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity );
+ CleanupStack::PushL( buffer );
+
+ HBufC* svrNonce = prof->NonceLC( EDMProfileServerNonce );
+ HBufC* cntNonce = prof->NonceLC( EDMProfileClientNonce );
+
+ RBufWriteStream stream( *buffer );
+ CleanupClosePushL(stream);
+
+ stream.WriteInt32L( svrNonce->Size() );
+ stream << *svrNonce;
+
+ stream.WriteInt32L( cntNonce->Size() );
+ stream << *cntNonce;
+
+ stream.WriteInt32L( prof->IntValue( EDMProfileAuthenticationRequired ) );
+ stream.CommitL();
+
+ CleanupStack::PopAndDestroy(&stream);
+ CleanupStack::PopAndDestroy(cntNonce);
+ CleanupStack::PopAndDestroy(svrNonce);
+
+ delete iDMAuthInfo;
+ iDMAuthInfo = buffer;
+ CleanupStack::Pop( buffer );
+
+ CleanupStack::PopAndDestroy(prof);
+ ret = KErrNone;
+ }
+
+ CleanupStack::PopAndDestroy(settings);
+
+ TPckgBuf<TInt> sizeBuf(iDMAuthInfo->Size() );
+
+ aMessage.WriteL( 1, sizeBuf );
+ aMessage.Complete(ret);
+ _DBG_FILE("CNSmlSOSSession::InitDMAuthInfoL(): end");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetDMAuthInfoL( const RMessage2& aMessage )
+// Writes DM authentication data to client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetDMAuthInfoL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::GetDMAuthInfoL(): begin");
+
+ #ifndef __WINS__
+ if ( aMessage.SecureId().iId != KUidDMServer.iUid &&
+ aMessage.SecureId().iId != KUidWAPPush.iUid &&
+ aMessage.SecureId().iId != KUidSRCS.iUid )
+ {
+ aMessage.Complete(KErrPermissionDenied); // Complete message with error code.
+ _DBG_FILE("CNSmlSOSSession::GetDMAuthInfoL(): incompatible secure id!");
+ return;
+ }
+#endif
+
+ if ( !iDMAuthInfo )
+ {
+ aMessage.Complete( KErrNotFound );
+ }
+ aMessage.WriteL( 0, iDMAuthInfo->Ptr(0), 0 );
+ aMessage.Complete( KErrNone );
+ _DBG_FILE("CNSmlSOSSession::GetDMAuthInfoL(): end");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::SetDMAuthInfoL( const RMessage2& aMessage )
+// Writes DM authentication info to the settings database.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::SetDMAuthInfoL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::SetDMAuthInfoL(): begin");
+#ifndef __WINS__
+ if ( aMessage.SecureId().iId != KUidDMServer.iUid &&
+ aMessage.SecureId().iId != KUidWAPPush.iUid &&
+ aMessage.SecureId().iId != KUidSRCS.iUid )
+ {
+ aMessage.Complete(KErrPermissionDenied); // Complete message with error code.
+ _DBG_FILE("CNSmlSOSSession::SetDMAuthInfoL(): incompatible secure id!");
+ return;
+ }
+#endif
+
+ TInt ret(KErrNotFound);
+
+ CNSmlDMSettings* settings = CNSmlDMSettings::NewLC();
+ CNSmlDMProfile* prof = settings->ProfileL( aMessage.Int0() );
+
+ if (prof)
+ {
+ CleanupStack::PushL(prof);
+
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL(1) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 1, bufPtr, 0 );
+
+ RDesReadStream stream;
+ stream.Open(bufPtr);
+ CleanupClosePushL(stream);
+
+ TInt maxlen(0);
+ TInt pc(0);
+
+ maxlen = stream.ReadInt32L();
+ prof->SetNonceL( EDMProfileServerNonce, HBufC::NewLC(stream,maxlen)->Des() ); pc++;
+ maxlen = stream.ReadInt32L();
+ prof->SetNonceL( EDMProfileClientNonce, HBufC::NewLC(stream,maxlen)->Des() ); pc++;
+
+ prof->SetIntValue( EDMProfileAuthenticationRequired ,stream.ReadInt32L() );
+
+ CleanupStack::PopAndDestroy(pc);
+
+ ret = prof->SaveL();
+
+ CleanupStack::PopAndDestroy(&stream);
+ CleanupStack::PopAndDestroy(buffer);
+ CleanupStack::PopAndDestroy(prof);
+ }
+
+ CleanupStack::PopAndDestroy(settings);
+
+ aMessage.Complete( ret );
+ _DBG_FILE("CNSmlSOSSession::SetDMAuthInfoL(): end");
+ }
+
+
+// FOTA
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::AddDMGenericAlert( const RMessage2& aMessage )
+// Reads General Alert related data from aMessage and passes that data
+// to handler.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::AddDMGenericAlertL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::AddDMGenericAlert(): begin");
+
+ // get the buffer
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL( 0 ) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 0, bufPtr, 0 );
+
+ // open stream to the buffer
+ RDesReadStream stream;
+ stream.Open( bufPtr );
+ CleanupClosePushL( stream );
+
+ // read data field by field
+
+ // mgmt uri
+ TInt length = stream.ReadInt32L();
+ HBufC8* mgmtUri = HBufC8::NewLC( length );
+ TPtr8 dataPtr = mgmtUri->Des();
+ stream.ReadL( dataPtr, length );
+
+ // meta type
+ length = stream.ReadInt32L();
+ HBufC8* metaType = HBufC8::NewLC( length );
+ dataPtr.Set( metaType->Des() );
+ stream.ReadL( dataPtr, length );
+
+ // meta format
+ length = stream.ReadInt32L();
+ HBufC8* metaFormat = HBufC8::NewLC( length );
+ dataPtr.Set( metaFormat->Des() );
+ stream.ReadL( dataPtr, length );
+
+ // correlator
+ length = stream.ReadInt32L();
+ HBufC8* correlator = HBufC8::NewLC( length );
+ dataPtr.Set( correlator->Des() );
+ stream.ReadL( dataPtr, length );
+
+ TInt finalResult = stream.ReadInt32L();
+
+ // give data to handler
+ iHandler->GenericAlertL( mgmtUri, metaType, metaFormat, finalResult, correlator );
+
+ CleanupStack::PopAndDestroy( 6 ); // correlator, metaFormat, metaType, mgmtUri, stream, buffer
+
+ aMessage.Complete( KErrNone );
+
+ _DBG_FILE("CNSmlSOSSession::AddDMGenericAlert(): end");
+ }
+
+// FOTA end
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::AddGenericAlert( const RMessage2& aMessage )
+// Reads General Alert related data from aMessage and passes that data
+// to handler.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::AddGenericAlertL( const RMessage2& aMessage )
+ {
+ _DBG_FILE("CNSmlSOSSession::AddGenericAlert(): begin");
+
+ // get the buffer
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL( 0 ) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 0, bufPtr, 0 );
+
+ // open stream to the buffer
+ RDesReadStream stream;
+ stream.Open( bufPtr );
+ CleanupClosePushL( stream );
+
+ // read data field by field
+
+ // mgmt uri
+ TInt length = stream.ReadInt32L();
+ HBufC8* correlator = HBufC8::NewLC( length );
+ TPtr8 dataPtr = correlator->Des();
+ stream.ReadL( dataPtr, length );
+
+ // mgmt Item
+ TInt count = stream.ReadInt32L();
+ RArray<CNSmlDMAlertItem> iItemArray;
+
+ if(count > 0)
+ {
+ for(TInt i= 0; i<count; i++)
+ {
+ CNSmlDMAlertItem iItem; // = new (ELeave) CNSmlDMAlertItem ();
+ // mgmt Sourceuri
+ length = stream.ReadInt32L();
+ iItem.iSource = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iSource->Des());
+ stream.ReadL( dataPtr, length );
+
+ // mgmt Targeturi
+ length = stream.ReadInt32L();
+ iItem.iTarget = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iTarget->Des());
+ stream.ReadL( dataPtr, length );
+
+ // meta type
+ length = stream.ReadInt32L();
+ iItem.iMetaType = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iMetaType->Des() );
+ stream.ReadL( dataPtr, length );
+
+ // meta format
+ length = stream.ReadInt32L();
+ iItem.iMetaFormat = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iMetaFormat->Des() );
+ stream.ReadL( dataPtr, length );
+
+ // meta Mark
+
+ length = stream.ReadInt32L();
+ iItem.iMetaMark = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iMetaMark->Des() );
+ stream.ReadL( dataPtr, length );
+
+ // Data
+
+ length = stream.ReadInt32L();
+ iItem.iData = HBufC8::NewLC( length );
+ dataPtr.Set( iItem.iData->Des());
+ stream.ReadL( dataPtr, length );
+
+ iItemArray.AppendL(iItem);
+ }
+}
+
+// TInt finalResult = stream.ReadInt32L();
+
+ // give data to handler
+ iHandler->GenericAlertL( correlator, &iItemArray );
+ if(count > 0)
+ {
+ for(TInt i= 0; i<count; i++)
+ {
+ CleanupStack::PopAndDestroy(6); // mgmtData, metaMark, metaFormat, metaType, mgmtTargetUri, mgmtUri
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 3 ); // correlator, stream, buffer,
+
+ aMessage.Complete( KErrNone );
+
+ _DBG_FILE("CNSmlSOSSession::AddGenericAlert(): end");
+ }
+
+// void CNSmlSOSSession::DeleteProfileL( const RMessage2& aMessage )
+// Deletes profile with given usage type and id from settings.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::DeleteProfileL( const RMessage2& aMessage )
+ {
+ TInt profId = aMessage.Int0();
+ // Check if client has required capabilities.
+ if ( !aMessage.HasCapability( ECapabilityWriteUserData ) )
+ {
+ aMessage.Complete(KErrPermissionDenied); // Complete message with error code.
+ return;
+ }
+ // Check if profile is currently locked by another (or this) session.
+ TInt ret = iHandler->IsLocked( profId );
+ if ( ret != KErrNone )
+ {
+ aMessage.Complete(KErrLocked); // Complete message with error code.
+ return;
+ }
+
+ ret = KErrNotFound; // this is returned if profile is not found
+
+ TBool isHidden = EFalse;
+ if ( profId < KMaxDataSyncID ) // DS profile
+ {
+ if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ //Check Setting enforcement state
+ if ( CheckSettingEnforcementStateL( aMessage, EDataSyncEnforcement))
+ {
+ _DBG_FILE("CNSmlSOSSession::DeleteProfileL(): CheckSettingEnforcementStateL (DS) returned ETrue");
+ return;
+ }
+ }
+ // deleting hidden profile allowed only if request from dm server
+ TBool deleteHidden = MessageFromDMServer( aMessage );
+
+ CNSmlDSProfile* prof = iDSSettings->ProfileL( profId );
+ if ( prof )
+ {
+ isHidden = prof->IntValue( EDSProfileHidden );
+ TInt allowDelete = prof->IntValue( EDSProfileDeleteAllowed );
+
+ delete prof;
+ prof = NULL;
+ if ( ( !allowDelete ) || ( !deleteHidden && isHidden ) )
+ {
+ // not allowed to delete, or attempted to delete hidden profile, but request
+ // is not from dm server
+ aMessage.Complete( KErrAccessDenied );
+ return;
+ }
+ ret = iDSSettings->DeleteProfileL( profId );
+ }
+ }
+ else // DM Profile
+ {
+ if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ //Check Setting enforcement state
+ if ( CheckSettingEnforcementStateL( aMessage, ESyncMLEnforcement) )
+ {
+ _DBG_FILE("CNSmlSOSSession::SetProfileL(): CheckSettingEnforcementStateL (DM) returned ETrue");
+ return;
+ }
+ }
+ CNSmlDMProfile* prof = iDMSettings->ProfileL( profId );
+ if ( prof )
+ {
+ TInt allowDelete = prof->IntValue( EDMProfileDeleteAllowed );
+ delete prof;
+ prof = NULL;
+ if ( !allowDelete )
+ {
+ aMessage.Complete( KErrAccessDenied );
+ return;
+ }
+ ret = iDMSettings->DeleteProfileL( profId );
+ }
+ }
+
+ aMessage.Complete(ret);
+
+ // send event message only if profile is not hidden
+ if ( !isHidden )
+ {
+ iHandler->CompleteEventMsgL( MSyncMLEventObserver::EProfileDeleted, profId, ret );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CurrentJobL( const RMessage2& aMessage )
+// Returns id and type of currently processed job.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CurrentJobL( const RMessage2& aMessage )
+ {
+ TInt id(0);
+ TSmlUsageType type;
+ iHandler->CurrentJob( id, type );
+
+ TPckgBuf<TInt> jobId(id);
+ TPckgBuf<TInt> jobType(type);
+
+ aMessage.WriteL( 0, jobId );
+ aMessage.WriteL( 1, jobType );
+
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::QueuedJobsL( const RMessage2& aMessage )
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::QueuedJobsL( const RMessage2& aMessage )
+ {
+ // Fetch queued jobs into iArray from where they are read in PackIntDataL().
+ iHandler->QueuedJobsL( iArray, (TSmlUsageType) aMessage.Int1() );
+ PackIntDataL( aMessage );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ProfileListL( const RMessage2& aMessage )
+// Reads profile ids of selected type from settings data base.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ProfileListL( const RMessage2& aMessage )
+ {
+ iArray.Reset();
+ iArrayIndex = 0;
+ if ( aMessage.Int1() == ESmlDataSync )
+ {
+ TBool includeHidden = MessageFromDMServer( aMessage ); // list hidden profiles, only if request from dm servers
+
+ CNSmlDSProfileList* profList = new (ELeave) CArrayPtrFlat<CNSmlDSProfileListItem>( 8 );
+ CleanupStack::PushL( PtrArrCleanupItem ( CNSmlDSProfileListItem, profList ) );
+ iDSSettings->GetAllProfileListL( profList );
+
+ for( TInt i = 0 ; i < profList->Count() ; i++ )
+ {
+ TInt id = profList->At(i)->IntValue( EDSProfileId );
+ if ( !includeHidden )
+ {
+ CNSmlDSProfile* dsProf = iDSSettings->ProfileL( id );
+ if ( dsProf->IntValue( EDSProfileHidden ) )
+ {
+ // current profile is hidden and hidden profiles are not included
+ delete dsProf; dsProf = NULL;
+ continue;
+ }
+ delete dsProf; dsProf = NULL;
+ }
+
+ iArray.AppendL( id );
+ }
+
+ CleanupStack::PopAndDestroy(profList);
+ }
+ else
+ {
+ TBool includeHidden = MessageFromDMServer( aMessage ); // list hidden profiles, only if request from dm servers
+
+ CNSmlDMProfileList* profList = new (ELeave) CArrayPtrFlat<CNSmlDMProfileListItem>( 8 );
+ CleanupStack::PushL( PtrArrCleanupItem ( CNSmlDMProfileListItem, profList ) );
+ iDMSettings->GetProfileListL( profList );
+ for( TInt i=0 ; i < profList->Count() ; i++ )
+ {
+ TInt id = profList->At(i)->IntValue( EDMProfileId );
+ if ( !includeHidden )
+ {
+ CNSmlDMProfile* dmProf = iDMSettings->ProfileL( id );
+ if ( dmProf->IntValue( EDMProfileHidden ) )
+ {
+ // current profile is hidden and hidden profiles are not included
+ delete dmProf;
+ dmProf = NULL;
+ continue;
+ }
+ delete dmProf;
+ dmProf = NULL;
+ }
+
+ iArray.AppendL( id );
+ }
+ CleanupStack::PopAndDestroy(profList);
+ }
+
+ PackIntDataL( aMessage );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::PackIntDataL( const RMessage2& aMessage )
+// Returns integer arrays to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::PackIntDataL( const RMessage2& aMessage )
+ {
+ TInt startIndex(iArrayIndex);
+ TInt countLeft = iArray.Count() - iArrayIndex;
+ // Only the amount of KMaxArrayCount is added.
+ const TInt count = ( countLeft > KMaxArrayCount ) ? KMaxArrayCount : countLeft;
+
+ iArrayIndex += count;
+
+ HBufC8* buffer = HBufC8::NewLC((count * KSizeofTInt32) + KSizeofTInt8);
+ TPtr8 bufPtr = buffer->Des();
+
+ RDesWriteStream stream;
+ stream.Open( bufPtr );
+ CleanupClosePushL(stream);
+ stream.WriteUint8L(TUint(count));
+ for ( TInt c = startIndex ; c < iArrayIndex ; c++ )
+ {
+ stream.WriteInt32L( iArray[c] );
+ }
+ stream.CommitL();
+ aMessage.WriteL( 0, bufPtr, 0 );
+
+ CleanupStack::PopAndDestroy(&stream);
+ CleanupStack::PopAndDestroy(buffer);
+ // If there are items left in the array, return KErrOverflow, else KErrNone.
+ TInt ret = ( iArrayIndex < iArray.Count() ) ? KErrOverflow : KErrNone;
+
+ aMessage.Complete( ret );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CreateProfileL( const RMessage2& aMessage,
+// const TSmlUsageType aUsageType )
+// Creates a new profile sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CreateProfileL(
+ const RMessage2& aMessage,
+ const TSmlUsageType aUsageType )
+ {
+ // Check if client has required capabilities.
+ if ( !aMessage.HasCapability( ECapabilityWriteUserData ) )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ //Check Setting enforcement state
+ KSettingEnforcements settingType = ESyncMLEnforcement;
+ if ( aUsageType == ESmlDataSync)
+ {
+ _DBG_FILE("CNSmlSOSSession::CreateProfileL(): \
+ settingType = EDataSyncEnforcement");
+ settingType = EDataSyncEnforcement;
+ }
+
+ if ( CheckSettingEnforcementStateL( aMessage, settingType) )
+ {
+ _DBG_FILE("CNSmlSOSSession::CreateProfileL(): \
+ CheckSettingEnforcementStateL returned ETrue");
+ return;
+ }
+}
+
+ CNSmlProfile* prof = new (ELeave) CNSmlProfile( aUsageType, *this );
+ CleanupStack::PushL(prof);
+ prof->SetCreatorId( aMessage.SecureId() );
+ iObjCon->AddL( prof );
+ CleanupStack::Pop(prof);
+ TInt handle = iObjIndex->AddL( prof );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenProfileL( const RMessage2& aMessage,
+// const TSmlUsageType aUsageType )
+// Creates a new profile sub session and reads data of existing profile.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenProfileL( const RMessage2& aMessage, const TSmlUsageType aUsageType )
+ {
+ // Check if client has capabilities required for selected open mode.
+ if ( aMessage.Int2() == ESmlOpenRead )
+ {
+ if ( !aMessage.HasCapability( ECapabilityReadUserData ) )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+ }
+ else // aMessage.Int2() == ESmlOpenReadWrite
+ {
+ if ( !aMessage.HasCapability( ECapabilityWriteUserData ) )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+ }
+
+ CNSmlProfile* prof = new (ELeave) CNSmlProfile( aUsageType, *this );
+ CleanupStack::PushL(prof);
+ iObjCon->AddL( prof );
+ CleanupStack::Pop(prof);
+ TInt handle = iObjIndex->AddL( prof );
+
+ if ( aMessage.Int2() == ESmlOpenReadWrite )
+ {
+ // Opening Read-Write mode, check if profile is already locked.
+ if ( iHandler->IsLocked( aMessage.Int1() ) )
+ {
+ // Profile is already locked by another session.
+ iObjIndex->Remove( handle );
+ aMessage.Complete( KErrLocked );
+ return;
+ }
+ // Lock the profile.
+ // Lock info is needed in handler and sub session to assure that only lock owner removes the lock.
+ iHandler->LockProfile( aMessage.Int1() );
+ prof->SetLocked();
+ }
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ // Fecth and copy profile data to the object.
+ TInt ret = prof->FetchDataL( aMessage.Int1(), MessageFromDMServer( aMessage ) );
+ // Get size of the data buffer.
+ if ( ret == KErrNone )
+ {
+ TPckgBuf<TInt> dataSize = prof->DataSize();
+ aMessage.WriteL(0, dataSize, 0);
+ }
+ else // Opening subsession failed, remove subsession object.
+ {
+ iObjIndex->Remove( handle );
+ }
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetProfileL( const RMessage2& aMessage )
+// Writes profile data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetProfileL( const RMessage2& aMessage )
+ {
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if ( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ aMessage.WriteL( 0, prof->ReadData(), 0 );
+ aMessage.Complete( KErrNone );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ConnectionListL( const RMessage2& aMessage )
+// Reads list of connections of opened profile fron settings.
+// (Currently only one connection per profile is supported.)
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ConnectionListL( const RMessage2& aMessage )
+ {
+ iArray.Reset();
+ iArrayIndex = 0;
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ prof->ConnectionListL( iArray );
+ PackIntDataL( aMessage );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::TaskListL( const RMessage2& aMessage )
+// Reads list of tasks of selected profile from settings.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::TaskListL( const RMessage2& aMessage )
+ {
+ iArray.Reset();
+ iArrayIndex = 0;
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ // Get task ids and append them to iArray.
+ prof->TaskListL( iArray );
+ // PackIntDataL writes ids to aMessage.
+ PackIntDataL( aMessage );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::DeleteTaskL( const RMessage2& aMessage )
+// Deletes task from profile.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::DeleteTaskL( const RMessage2& aMessage )
+ {
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if ( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ if ( !prof->IsLocked() ) // Profile hasn't been opened to write mode.
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+ TBool wasDeleted = prof->DeleteTaskL( aMessage.Int0() );
+
+ if ( wasDeleted )
+ {
+ aMessage.Complete( KErrNone );
+ }
+ else
+ {
+ aMessage.Complete( KErrNotFound );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::SetProfileL( const RMessage2& aMessage )
+// Writes profile data to the database.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::SetProfileL( const RMessage2& aMessage )
+ {
+ TInt ret(KErrNone);
+ // Check if client has required capabilities.
+ if ( !aMessage.HasCapability( ECapabilityWriteUserData ) )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if ( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+{
+ //Check Setting enforcement state
+ KSettingEnforcements settingType = ESyncMLEnforcement;
+ if ( prof->GetUsageType() == ESmlDataSync)
+ {
+ _DBG_FILE( "CNSmlSOSSession::SetProfileL(): settingType = \
+ EDataSyncEnforcement" );
+ settingType = EDataSyncEnforcement;
+ }
+
+ if ( CheckSettingEnforcementStateL( aMessage, settingType ) )
+ {
+ _DBG_FILE("CNSmlSOSSession::SetProfileL(): \
+ CheckSettingEnforcementStateL returned ETrue");
+ return;
+ }
+}
+
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL(1) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 1, bufPtr, 0 );
+
+ TInt profId = prof->ProfileId();
+
+ MSyncMLEventObserver::TEvent event;
+ if ( profId != KNSmlNullId )
+ {
+ event = MSyncMLEventObserver::EProfileChanged;
+ }
+ else
+ {
+ event = MSyncMLEventObserver::EProfileCreated;
+ }
+
+ TBool isHidden = EFalse;
+ ret = prof->UpdateDataL( profId, bufPtr, isHidden );
+
+ CleanupStack::PopAndDestroy(buffer);
+
+ if ( !prof->IsLocked() ) // Lock profile if it is new.
+ {
+ iHandler->LockProfile( profId );
+ prof->SetLocked();
+ }
+
+ TPckgBuf<TInt> id(profId);
+
+ aMessage.WriteL(0, id, 0);
+ aMessage.Complete(ret);
+
+ // send event msg only if profile is not hidden
+ if ( !isHidden )
+ {
+ iHandler->CompleteEventMsgL( event, profId );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseProfile( const RMessage2& aMessage )
+// Closes profile sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseProfile( const RMessage2& aMessage )
+ {
+ CNSmlProfile* prof = ProfileFromHandle( aMessage.Int3() );
+ if ( !prof )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ // Check if this profile object is locked and remove if needed.
+ if( prof->IsLocked() )
+ {
+ iHandler->RemoveLock( prof->ProfileId() );
+ }
+
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlProfile* CNSmlSOSSession::ProfileFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlProfile* CNSmlSOSSession::ProfileFromHandle( TUint aHandle )
+ {
+ return (CNSmlProfile*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CreateTaskL( const RMessage2& aMessage )
+// Creates a new task sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CreateTaskL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = new (ELeave) CNSmlTask( aMessage.Int0(), ETrue, *this );
+ CleanupStack::PushL(task);
+ task->SetDataProviderId( aMessage.Int1() );
+ task->SetCreatorId( aMessage.SecureId() );
+
+ iObjCon->AddL( task );
+ CleanupStack::Pop();
+ TInt handle = iObjIndex->AddL( task );
+
+ TPckgBuf<TInt> handlePckg(handle);
+
+ aMessage.WriteL(3, handlePckg, 0);
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenTaskL( const RMessage2& aMessage )
+// Creates a new task sub session and reads data of existing task.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenTaskL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = new (ELeave) CNSmlTask( aMessage.Int1(), EFalse, *this );
+ CleanupStack::PushL(task);
+ iObjCon->AddL( task );
+ CleanupStack::Pop(task);
+ TInt handle = iObjIndex->AddL( task );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ // Fecth and copy data to the object.
+ TInt ret = task->FetchDataL( aMessage.Int2() );
+
+ if ( ret == KErrNone )
+ {
+ // Get size of the data buffer.
+ TPckgBuf<TInt> dataSize = task->DataSize();
+ aMessage.WriteL(0, dataSize, 0);
+ }
+ else // Opening subsession failed, remove subsession object.
+ {
+ iObjIndex->Remove( handle );
+ }
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetTaskL( const RMessage2& aMessage )
+// Writes task data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetTaskL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = TaskFromHandle( aMessage.Int3() );
+ if ( !task )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ aMessage.WriteL( 0, task->ReadData(), 0 );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenTaskSupportedFiltersL( const RMessage2& aMessage )
+// Resolves the size of the filter buffer.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenTaskSupportedFiltersL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = TaskFromHandle( aMessage.Int3() );
+ if ( !task )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ TPckgBuf<TInt> dataSize = task->PrepareFilterBufferL( aMessage.Int1() );
+ aMessage.WriteL(0, dataSize, 0);
+
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetTaskSupportedFiltersL( const RMessage2& aMessage )
+//
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetTaskSupportedFiltersL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = TaskFromHandle( aMessage.Int3() );
+ if ( !task )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ aMessage.WriteL( 0, task->ReadFilter(), 0 );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::SetTaskL( const RMessage2& aMessage )
+// Writes task data to the database.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::SetTaskL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = TaskFromHandle( aMessage.Int3() );
+ if ( !task )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL(1) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 1, bufPtr, 0 );
+
+ TInt taskId(0);
+ TInt ret = task->UpdateDataL( taskId, bufPtr );
+
+ TPckgBuf<TInt> id(taskId);
+ aMessage.WriteL(0, id, 0);
+
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseTaskL( const RMessage2& aMessage )
+// Closes task sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseTaskL( const RMessage2& aMessage )
+ {
+ CNSmlTask* task = TaskFromHandle( aMessage.Int3() );
+ if ( !task )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlTask* CNSmlSOSSession::TaskFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlTask* CNSmlSOSSession::TaskFromHandle( TUint aHandle )
+ {
+ return (CNSmlTask*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenConnectionL( const RMessage2& aMessage )
+// Creates a new connection sub session and reads data from settings.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenConnectionL( const RMessage2& aMessage )
+ {
+ CNSmlConnection* conn = new (ELeave) CNSmlConnection( aMessage.Int1(), aMessage.Int2(), *this );
+ CleanupStack::PushL(conn);
+ iObjCon->AddL( conn );
+ CleanupStack::Pop(conn);
+ TInt handle = iObjIndex->AddL( conn );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ // Fecth and copy data to the object.
+ TInt ret = conn->FetchDataL();
+
+ if ( ret == KErrNone )
+ {
+ // Get size of the data buffer.
+ TPckgBuf<TInt> dataSize = conn->DataSize();
+ aMessage.WriteL(0, dataSize, 0);
+ }
+ else // Opening subsession failed, remove subsession object.
+ {
+ iObjIndex->Remove( handle );
+ }
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetConnectionL( const RMessage2& aMessage )
+// Writes connection data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetConnectionL( const RMessage2& aMessage )
+ {
+ CNSmlConnection* conn = ConnectionFromHandle( aMessage.Int3() );
+ if ( !conn )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ aMessage.WriteL( 0, conn->ReadData(), 0 );
+ aMessage.Complete( KErrNone );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::SetConnectionL( const RMessage2& aMessage )
+// Writes connection data to the database.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::SetConnectionL( const RMessage2& aMessage )
+ {
+ CNSmlConnection* conn = ConnectionFromHandle( aMessage.Int3() );
+ if ( !conn )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ HBufC8* buffer = HBufC8::NewLC( aMessage.GetDesLengthL(0) );
+ TPtr8 bufPtr = buffer->Des();
+ aMessage.ReadL( 0, bufPtr, 0 );
+
+ TInt ret = conn->UpdateDataL( bufPtr );
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseConnectionL( const RMessage2& aMessage )
+// Closes connection sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseConnectionL( const RMessage2& aMessage )
+ {
+ CNSmlConnection* conn = ConnectionFromHandle( aMessage.Int3() );
+ if ( !conn )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlConnection* CNSmlSOSSession::ConnectionFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlConnection* CNSmlSOSSession::ConnectionFromHandle( TUint aHandle )
+ {
+ return (CNSmlConnection*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenHistoryLogL( const RMessage2& aMessage )
+// Creates history log sub session and reads data from settings.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenHistoryLogL( const RMessage2& aMessage )
+ {
+ CNSmlHistoryLog* log = new (ELeave) CNSmlHistoryLog( aMessage.Int1(), *this );
+ CleanupStack::PushL(log);
+ iObjCon->AddL( log );
+ CleanupStack::Pop();
+ TInt handle = iObjIndex->AddL( log );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ // Fecth and copy data to the object.
+ TInt ret = log->FetchDataL();
+ // Get size of the data buffer.
+ if ( ret == KErrNone )
+ {
+ TPckgBuf<TInt> dataSize = log->DataSize();
+ aMessage.WriteL(0, dataSize, 0);
+ }
+ else // Opening subsession failed, remove subsession object.
+ {
+ iObjIndex->Remove( handle );
+ }
+ aMessage.Complete(ret);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetHistoryLogL( const RMessage2& aMessage )
+// Writes history log data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetHistoryLogL( const RMessage2& aMessage )
+ {
+ CNSmlHistoryLog* log = HistoryLogFromHandle( aMessage.Int3() );
+ if ( !log )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ aMessage.WriteL( 0, log->ReadData(), 0 );
+ aMessage.Complete( KErrNone );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::ResetHistoryLogL( const RMessage2& aMessage )
+// Resets history log from settings.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::ResetHistoryLogL( const RMessage2& aMessage )
+ {
+ CNSmlHistoryLog* log = HistoryLogFromHandle( aMessage.Int3() );
+ if ( !log )
+ {
+ aMessage.Complete( KErrBadHandle );
+ }
+ log->ResetL();
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseHistoryLogL( const RMessage2& aMessage )
+// Closes history log sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseHistoryLogL( const RMessage2& aMessage )
+ {
+ CNSmlHistoryLog* log = HistoryLogFromHandle( aMessage.Int3() );
+ if ( !log )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlHistoryLog* CNSmlSOSSession::HistoryLogFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlHistoryLog* CNSmlSOSSession::HistoryLogFromHandle( TUint aHandle )
+ {
+ return (CNSmlHistoryLog*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenDataProviderL( const RMessage2& aMessage )
+// Creates data provider sub session and reads data from DS host client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenDataProviderL( const RMessage2& aMessage )
+ {
+ CNSmlDataProvider* dprov = new (ELeave) CNSmlDataProvider( aMessage.Int1(), *this );
+ CleanupStack::PushL(dprov);
+ iObjCon->AddL( dprov );
+ CleanupStack::Pop(dprov);
+ TInt handle = iObjIndex->AddL( dprov );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+ // Fecth and copy data to the object.
+ TRAPD(ret, dprov->FetchDataL() );
+ // Get size of the data buffer.
+ if ( ret == KErrNone )
+ {
+ TPckgBuf<TInt> dataSize = dprov->DataSize();
+ aMessage.WriteL(0, dataSize, 0);
+ }
+ else // Opening subsession failed, remove subsession object.
+ {
+ iObjIndex->Remove( handle );
+ }
+
+ aMessage.Complete( ret );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetDataProviderL( const RMessage2& aMessage )
+// Writes data provider data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetDataProviderL( const RMessage2& aMessage )
+ {
+ CNSmlDataProvider* dprov = DataProviderFromHandle( aMessage.Int3() );
+ if ( !dprov )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ aMessage.WriteL( 0, dprov->ReadData(), 0 );
+ aMessage.Complete( KErrNone );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseDataProviderL( const RMessage2& aMessage )
+// Close data provider sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseDataProviderL( const RMessage2& aMessage )
+ {
+ CNSmlDataProvider* dprov = DataProviderFromHandle( aMessage.Int3() );
+ if ( !dprov )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlDataProvider* CNSmlSOSSession::DataProviderFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlDataProvider* CNSmlSOSSession::DataProviderFromHandle( TUint aHandle )
+ {
+ return (CNSmlDataProvider*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CreateJobL( const TNSmlJobType aJobType, const RMessage2& aMessage )
+// Creates job sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CreateJobL( const TNSmlJobType aJobType, const RMessage2& aMessage )
+ {
+ // Check if client has capabilities required for create job.
+ if ( !aMessage.HasCapability( ECapabilityNetworkServices ) ||
+ !aMessage.HasCapability( ECapabilityLocalServices ) )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return;
+ }
+
+ CNSmlJob* job = new (ELeave) CNSmlJob();
+ CleanupStack::PushL(job);
+ // Parse job data and set values to job.
+ HBufC8* data = HBufC8::NewLC( KMaxJobDataSize );
+ TPtr8 dataPtr = data->Des();
+ aMessage.ReadL( 1, dataPtr, 0 );
+
+ RDesReadStream stream;
+ stream.Open(dataPtr);
+ CleanupClosePushL(stream);
+
+ job->SetOwnerSession( this );
+ job->SetCreatorId( aMessage.SecureId() );
+ job->SetJobType( aJobType );
+ job->SetProfId( stream.ReadInt32L() ); // Prof id is always first in stream.
+ job->iPending = EFalse;
+
+ switch( aJobType )
+ {
+ case EDSJobProfile:
+ {
+ job->SetUsageType( ESmlDataSync );
+ break;
+ }
+ case EDSJobProfileST:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetSyncType( (TSmlSyncType) stream.ReadInt32L() );
+ break;
+ }
+ case EDSJobTasks:
+ {
+ job->SetUsageType( ESmlDataSync );
+ TInt taskCount = stream.ReadInt8L();
+ for( TInt i(0) ; i < taskCount ; i++ )
+ {
+ job->AddTaskIdL( stream.ReadInt32L() );
+ }
+ break;
+ }
+ case EDSJobTasksST:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetSyncType( (TSmlSyncType) stream.ReadInt32L() );
+ TInt taskCount = stream.ReadInt8L();
+ for( TInt i(0) ; i < taskCount ; i++ )
+ {
+ job->AddTaskIdL( stream.ReadInt32L() );
+ }
+ break;
+ }
+ case EDSJobTransport:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetTransportId( stream.ReadInt32L() );
+ break;
+ }
+ case EDSJobTransportST:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetTransportId( stream.ReadInt32L() );
+ job->SetSyncType( (TSmlSyncType) stream.ReadInt32L() );
+ break;
+ }
+ case EDSJobTaskTrans:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetTransportId( stream.ReadInt32L() );
+ TInt taskCount = stream.ReadInt8L();
+ for( TInt i(0) ; i < taskCount ; i++ )
+ {
+ job->AddTaskIdL( stream.ReadInt32L() );
+ }
+ break;
+ }
+ case EDSJobTaskTransST:
+ {
+ job->SetUsageType( ESmlDataSync );
+ job->SetTransportId( stream.ReadInt32L() );
+ job->SetSyncType( (TSmlSyncType) stream.ReadInt32L() );
+ TInt taskCount = stream.ReadInt8L();
+ for( TInt i(0) ; i < taskCount ; i++ )
+ {
+ job->AddTaskIdL( stream.ReadInt32L() );
+ }
+ break;
+ }
+ case EDMJobProfile:
+ {
+ job->SetUsageType( ESmlDevMan );
+ break;
+ }
+ case EDMJobTransport:
+ {
+ job->SetUsageType( ESmlDevMan );
+ TBuf<10> checkapid; //Maximum 8 chars only
+ checkapid.Num(stream.ReadInt32L());
+ //Checks for IAP Id for this session,If transport id = 1022xxxx
+ //1022 signifies the rest of 4 digits xxxx as IapId
+ if( (checkapid.Left(KNSmlHalfTransportIdLength))
+ .Compare(KNSmlDMJobIapPrefix) == KErrNone )
+ {
+ TLex tempapid((checkapid.Left(KNSmlHalfTransportIdLength*2))
+ .Right(KNSmlHalfTransportIdLength));
+ TInt useiapid = KErrNotFound;
+ tempapid.Val(useiapid);
+ DBG_FILE_CODE(useiapid, _S8("CNSmlSOSSession::CreateJobL: \
+ IapId for this session is"));
+ job->SetJobIapId(useiapid);
+ }
+ else
+ {
+ job->SetTransportId( stream.ReadInt32L() );
+ }
+ break;
+ }
+ default:
+ break;
+
+ }
+
+ CheckJobDataL( job );
+
+ CNSmlJobObject* jobObj = new (ELeave) CNSmlJobObject();
+ CleanupStack::PushL(jobObj);
+ iObjCon->AddL( jobObj );
+ CleanupStack::Pop(jobObj);
+ TInt handle = iObjIndex->AddL( jobObj );
+ TPckg<TInt> handlePckg(handle);
+ aMessage.WriteL( 3, handlePckg, 0);
+
+ CleanupStack::PopAndDestroy(&stream);
+ CleanupStack::PopAndDestroy(data);
+
+ TInt id(0);
+ TInt ret = iHandler->AddJobL( job, id );
+ CleanupStack::Pop(job);
+ jobObj->SetJobId( id );
+ TPckgBuf<TInt> jobId(id);
+
+ aMessage.WriteL(0, jobId, 0 );
+ aMessage.Complete( ret );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::OpenJobL( const RMessage2& aMessage )
+// Creates job sub session and find job instance from job queue.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::OpenJobL( const RMessage2& aMessage )
+ {
+ // Find job data macthing with job id..
+ CNSmlJob* job = iHandler->FindJob( aMessage.Int1() );
+ if ( !job )
+ {
+ aMessage.Complete(KErrNotFound);
+ return;
+ }
+ TInt currJob(0);
+ TSmlUsageType type;
+ iHandler->CurrentJob( currJob, type );
+
+ if ( job->JobId() == currJob && !job->CreatorId() ) // Server alert job.
+ {
+ job->SetCreatorId(aMessage.SecureId()); // Set creator id to identify notifier.
+ job->SetOwnerSession(this);
+ }
+
+ CNSmlJobObject* jobObj = new (ELeave) CNSmlJobObject();
+ CleanupStack::PushL(jobObj);
+ iObjCon->AddL( jobObj );
+ CleanupStack::Pop(jobObj);
+ TInt handle = iObjIndex->AddL( jobObj );
+ TPckgBuf<TInt> handlePckg(handle);
+ aMessage.WriteL(3, handlePckg, 0);
+
+ jobObj->SetJobId( job->JobId() );
+ TInt size = KSizeofTInt32; // Add size of profile id to data size.
+ if ( job->UsageType() == ESmlDataSync )
+ {
+ RArray<TInt> tasks;
+ job->TaskIds( tasks );
+ TInt taskIdCount = tasks.Count();
+ tasks.Close();
+ size += KSizeofTInt8 + (taskIdCount * KSizeofTInt32); // Calculate size of task ids to data size.
+ }
+ // Get size of the data buffer.
+ TPckgBuf<TInt> dataSize(size);
+
+ aMessage.WriteL(0, dataSize, 0);
+ aMessage.Complete( KErrNone );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::GetJobL( const RMessage2& aMessage )
+// Writes job data to the client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::GetJobL( const RMessage2& aMessage )
+ {
+ CNSmlJobObject* jobObj = JobFromHandle( aMessage.Int3() );
+ if ( !jobObj )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+
+ CNSmlJob* job = iHandler->FindJob( jobObj->JobId() );
+ if ( !job )
+ {
+ aMessage.Complete( KErrNotFound ); // job has been completed between open and get
+ return;
+ }
+
+ TInt profId = job->ProfileId();
+ TInt dataSize = KSizeofTInt32;
+ RArray<TInt> taskIds;
+
+ if ( job->UsageType() == ESmlDataSync ) // Add task ids if DS job
+ {
+ RArray<TInt> taskIds;
+ job->TaskIds( taskIds );
+ dataSize += KSizeofTInt8 + ( taskIds.Count() * KSizeofTInt32 );
+ taskIds.Close();
+ }
+
+ HBufC8* buf = HBufC8::NewLC( dataSize );
+ TPtr8 bufPtr = buf->Des();
+
+ RDesWriteStream stream;
+ stream.Open( bufPtr );
+ CleanupClosePushL(stream);
+
+ stream.WriteInt32L( profId );
+
+ if ( job->UsageType() == ESmlDataSync )
+ {
+ // Write count of tasks and then task ids.
+ stream.WriteInt8L( taskIds.Count() );
+ if ( taskIds.Count() ) // Add task ids if DS job
+ {
+ for( TInt i(0) ; i < taskIds.Count() ; i++ )
+ {
+ stream.WriteInt32L( taskIds[i] );
+ }
+ }
+ }
+
+ taskIds.Close();
+ stream.CommitL();
+ aMessage.WriteL( 0, bufPtr, 0 );
+ CleanupStack::PopAndDestroy(&stream);
+ CleanupStack::PopAndDestroy(buf);
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlJobObject* CNSmlSOSSession::JobFromHandle( TUint aHandle )
+// Finds sub session instance by sub session handle.
+// --------------------------------------------------------------------------
+//
+CNSmlJobObject* CNSmlSOSSession::JobFromHandle( TUint aHandle )
+ {
+ return (CNSmlJobObject*)iObjIndex->At( aHandle );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::StopJob( const RMessage2& aMessage )
+// Removes job from queue or cancels the job if currently running.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::StopJob( const RMessage2& aMessage )
+ {
+ CNSmlJobObject* jobObj = JobFromHandle( aMessage.Int3() );
+ if( !jobObj )
+ {
+ aMessage.Complete(KErrBadHandle);
+ return;
+ }
+ // Handler checks if Secure Id matches with one who created the job.
+ aMessage.Complete( iHandler->StopJob( jobObj->JobId(), aMessage.SecureId() ) );
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CloseJobL( const RMessage2& aMessage )
+// Closes job sub session.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CloseJobL( const RMessage2& aMessage )
+ {
+ CNSmlJobObject* jobObj = JobFromHandle( aMessage.Int3() );
+ if ( !jobObj )
+ {
+ aMessage.Complete( KErrBadHandle );
+ return;
+ }
+ iObjIndex->Remove( aMessage.Int3() );
+ aMessage.Complete(KErrNone);
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CheckJobDataL( CNSmlJob* aJob )
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CheckJobDataL( CNSmlJob* aJob )
+ {
+ TInt ret = KErrNone;
+
+ switch( aJob->JobType() )
+ {
+ case EDSJobProfile:
+ case EDSJobProfileST:
+ case EDSJobTasks:
+ case EDSJobTasksST:
+ case EDSJobTransport:
+ case EDSJobTransportST:
+ case EDSJobTaskTrans:
+ case EDSJobTaskTransST:
+ {
+ CNSmlDSProfile* prof = iDSSettings->ProfileL( aJob->ProfileId() );
+ if ( !prof ) // profile not found, leave error
+ {
+ ret = KErrArgument;
+ }
+
+ delete prof;
+ }
+ break;
+ case EDMJobProfile:
+ case EDMJobTransport:
+ {
+ CNSmlDMProfile* prof = iDMSettings->ProfileL( aJob->ProfileId() );
+ if ( !prof ) // profile not found, leave error
+ {
+ ret = KErrArgument;
+ }
+
+ delete prof;
+ }
+ break;
+ default:
+ break;
+
+ }
+
+ User::LeaveIfError( ret );
+ }
+
+
+// --------------------------------------------------------------------------
+// TBool CNSmlSOSSession::CheckSettingEnforcementStateL( const RMessage2&
+// aMessage, KSettingEnforcements aSetting )
+// Checks is setting enforcement activated. If activated block all messages
+// except messages from DM server
+// --------------------------------------------------------------------------
+//
+TBool CNSmlSOSSession::CheckSettingEnforcementStateL(
+ const RMessage2& aMessage,
+ KSettingEnforcements aSetting )
+ {
+ if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ User::Leave(KErrNotSupported);
+ }
+ _DBG_FILE( "CNSmlSOSSession::CheckSettingEnforcementStateL(): start" );
+ //if message was sent by DM server it is always ok, but if it comes from
+ // other instance setting enforcement will be checked
+ if ( !MessageFromDMServer( aMessage ) )
+ {
+ CSettingEnforcementInfo* info = CSettingEnforcementInfo::NewL();
+ CleanupStack::PushL( info);
+
+ TBool enforcementActive = EFalse;
+ User::LeaveIfError( info->EnforcementActive( aSetting,
+ enforcementActive ) );
+
+ CleanupStack::PopAndDestroy( info);
+
+ //complete message is client hasn't got permission to data
+ if ( enforcementActive )
+ {
+ aMessage.Complete( KErrPermissionDenied );
+ return ETrue;
+ }
+ }
+
+ _DBG_FILE("CNSmlSOSSession::CheckSettingEnforcementStateL(): end");
+ return EFalse;
+ }
+
+
+
+// --------------------------------------------------------------------------
+// TBool CNSmlSOSSession::MessageFromDMServer( const RMessage2& aMessage )
+// Checks if message was sent by DM server.
+// --------------------------------------------------------------------------
+//
+TBool CNSmlSOSSession::MessageFromDMServer( const RMessage2& aMessage )
+ {
+ TInt id = aMessage.SecureId().iId;
+ if ( id == KUidDMServer.iUid || id == KUidDmFotaServer.iUid)
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::StoreToEventBuffer( MSyncMLEventObserver::TEvent aEvent, TInt aJobId, TInt aStatus )
+// Adds job event to buffer for later completion.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::StoreToEventBuffer( MSyncMLEventObserver::TEvent aEvent, TInt aJobId, TInt aStatus )
+ {
+ _DBG_FILE("CNSmlSOSSession::StoreToEventBuffer : Begin");
+ TNSmlJobEvent jobEvent;
+ jobEvent.iEvent = aEvent;
+ jobEvent.iJobId = aJobId;
+ jobEvent.iEndStatus = aStatus;
+ iEventBuffer.Append( jobEvent );
+ _DBG_FILE("CNSmlSOSSession::StoreToEventBuffer : End");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CompleteBufferedEvent()
+// Completes delayed job event.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CompleteBufferedEventL()
+ {
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedEventL : Begin");
+ if ( iEventBuffer.Count() > 0 )
+ {
+ TNSmlJobEvent jobEvent;
+ jobEvent = iEventBuffer[0];
+ iHandler->CompleteEventMsgL( jobEvent.iEvent, jobEvent.iJobId, jobEvent.iEndStatus );
+ DBG_FILE_CODE( jobEvent.iEvent, _S8("Buffered Event Completed"));
+ iEventBuffer.Remove(0);
+ }
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedEventL : End");
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession::StoreToProgessEventBuffer( const TNSmlProgressEvent& aProgressEventItem )
+// Adds progress event to progress buffer.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::StoreToProgessEventBuffer( const TNSmlProgressEvent& aProgressEventItem )
+ {
+ _DBG_FILE("CNSmlSOSSession::StoreToProgessEventBuffer : Begin");
+
+ // Acquire mutex
+ RMutex mutex;
+ TInt mutexError = NSmlGrabMutex( mutex, KNSmlSOSServerMutexName() );
+
+ switch ( aProgressEventItem.iEventType )
+ {
+ case ENSmlSyncError:
+ iProgressEventBuffer.Append( aProgressEventItem );
+ if( iHandler->GetContactSuiteRegisteredProfileId() == iHandler->GetCurrentOngoingSessionProfileId())
+ {
+ iContactSuiteProgressEventBuffer.Append( aProgressEventItem );
+ }
+ break;
+
+ case ENSmlSyncProgress:
+ iProgressEventBuffer.Append( aProgressEventItem );
+ if( iHandler->GetContactSuiteRegisteredProfileId() == iHandler->GetCurrentOngoingSessionProfileId())
+ {
+ iContactSuiteProgressEventBuffer.Append( aProgressEventItem );
+ }
+ break;
+
+ case ENSmlModifications:
+ {
+ if ( iProgressEventBuffer.Count() == 0 )
+ {
+ iProgressEventBuffer.Append( aProgressEventItem );
+ }
+ else
+ {
+ // Add modifications to buffer
+ BufferDoModifications( aProgressEventItem );
+ }
+
+ if( iHandler->GetContactSuiteRegisteredProfileId() == iHandler->GetCurrentOngoingSessionProfileId())
+ {
+ if ( iContactSuiteProgressEventBuffer.Count() == 0 )
+ {
+ iContactSuiteProgressEventBuffer.Append( aProgressEventItem );
+ }
+ else
+ {
+ // Add modifications to buffer
+ BufferContactSuiteDoModifications( aProgressEventItem );
+ }
+ }
+
+ }
+ break;
+
+ default:
+ break;
+ };
+
+ if ( !mutexError )
+ {
+ mutex.Signal(); // Finished buffering
+ mutex.Close();
+ }
+
+ // Handle buffered progress events
+ TRAP_IGNORE( CompleteBufferedProgressEventL() );
+ if( iHandler->GetContactSuiteRegisteredProfileId() == iHandler->GetCurrentOngoingSessionProfileId())
+ {
+ TRAP_IGNORE( CompleteBufferedContactSuiteProgressEventL() );
+ }
+
+ _DBG_FILE("CNSmlSOSSession::StoreToProgessEventBuffer : End");
+ }
+
+// --------------------------------------------------------------------------
+// void CNSmlSOSSession::CompleteBufferedProgressEventL()
+// Completes delayed progress event. Buffer is created and sent to client.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::CompleteBufferedProgressEventL()
+ {
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedProgressEventL : Begin");
+
+ // Acquire mutex
+ RMutex mutex;
+ TInt mutexError = NSmlGrabMutex( mutex, KNSmlSOSServerMutexName() );
+ if ( !mutexError )
+ {
+ CleanupClosePushL( mutex );
+ }
+
+ if ( iProgressEventBuffer.Count() > 0 )
+ {
+ HBufC8* buf = NULL;
+ TNSmlProgressEvent event = iProgressEventBuffer[0];
+
+ switch ( iProgressEventBuffer[0].iEventType )
+ {
+ case ENSmlSyncError:
+ {
+ buf = iHandler->WriteSyncErrorL( event.iErrorLevel, event.iInfo1, event.iInfo2, event.iInfo3, event.iInfo4 );
+ }
+ break;
+
+ case ENSmlSyncProgress:
+ {
+ buf = iHandler->WriteSyncProgressL( event.iProgressStatus, event.iInfo1, event.iInfo2 );
+ }
+ break;
+
+ case ENSmlModifications:
+ {
+ buf = iHandler->WriteSyncModificationsL( event.iInfo1, event.iClientMods, event.iServerMods );
+ }
+ break;
+
+ default:
+ break;
+ };
+
+
+ if ( iHandler->CompleteBufProgressMsg( *buf, this )) // if owner not found do not remove from buffer
+ {
+ iProgressEventBuffer.Remove(0);
+ }
+
+ delete buf;
+ buf = NULL;
+
+
+ }
+
+ if ( !mutexError )
+ {
+ // Release mutex
+ mutex.Signal();
+ CleanupStack::PopAndDestroy( &mutex );
+ }
+
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedProgressEventL : End");
+ }
+
+void CNSmlSOSSession::CompleteBufferedContactSuiteProgressEventL()
+ {
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedContactSuiteProgressEventL : Begin");
+
+ if( iHandler->GetCurrentOngoingSessionProfileId() == 0 )
+ {
+ return;
+ }
+ // Acquire mutex
+ RMutex mutex;
+ TInt mutexError = NSmlGrabMutex( mutex, KNSmlSOSServerMutexName() );
+ if ( !mutexError )
+ {
+ CleanupClosePushL( mutex );
+ }
+
+ if ( iContactSuiteProgressEventBuffer.Count() > 0 )
+ {
+ HBufC8* buf = NULL;
+ TNSmlProgressEvent event = iContactSuiteProgressEventBuffer[0];
+
+ switch ( iContactSuiteProgressEventBuffer[0].iEventType )
+ {
+ case ENSmlSyncError:
+ {
+ buf = iHandler->WriteSyncErrorL( event.iErrorLevel, event.iInfo1, event.iInfo2, event.iInfo3, event.iInfo4 );
+ }
+ break;
+
+ case ENSmlSyncProgress:
+ {
+ buf = iHandler->WriteSyncProgressL( event.iProgressStatus, event.iInfo1, event.iInfo2 );
+ }
+ break;
+
+ case ENSmlModifications:
+ {
+ buf = iHandler->WriteSyncModificationsL( event.iInfo1, event.iClientMods, event.iServerMods );
+ }
+ break;
+
+ default:
+ break;
+ };
+
+
+ /*
+ if ( iHandler->CompleteBufProgressMsg( *buf, this )) // if owner not found do not remove from buffer
+ {
+ iProgressEventBuffer.Remove(0);
+ }
+ */
+ if ( iHandler->CompleteBufContactSuiteProgressMsg( *buf, this )) // if owner not found do not remove from buffer
+ {
+ iContactSuiteProgressEventBuffer.Remove(0);
+ }
+
+ delete buf;
+ buf = NULL;
+
+
+ }
+
+ if ( !mutexError )
+ {
+ // Release mutex
+ mutex.Signal();
+ CleanupStack::PopAndDestroy( &mutex );
+ }
+
+ _DBG_FILE("CNSmlSOSSession::CompleteBufferedProgressEventL : End");
+ }
+
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession::HandleModifications( const TNSmlProgressEvent& aProgressEventItem )
+// Handle buffered modifications.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::BufferDoModifications( const TNSmlProgressEvent& aProgressEventItem )
+ {
+ _DBG_FILE("CNSmlSOSSession::BufferDoModifications : Begin");
+
+ TInt last = iProgressEventBuffer.Count()-1;
+
+ // Is the last event modifications event
+ TBool doSum = iProgressEventBuffer[last].iEventType == ENSmlModifications ? ETrue : EFalse;
+
+ if ( doSum )
+ {
+ iProgressEventBuffer[last].iClientMods.iNumAdded += aProgressEventItem.iClientMods.iNumAdded;
+ iProgressEventBuffer[last].iClientMods.iNumReplaced += aProgressEventItem.iClientMods.iNumReplaced;
+ iProgressEventBuffer[last].iClientMods.iNumMoved += aProgressEventItem.iClientMods.iNumMoved;
+ iProgressEventBuffer[last].iClientMods.iNumDeleted += aProgressEventItem.iClientMods.iNumDeleted;
+ iProgressEventBuffer[last].iClientMods.iNumFailed += aProgressEventItem.iClientMods.iNumFailed;
+
+ iProgressEventBuffer[last].iServerMods.iNumAdded += aProgressEventItem.iServerMods.iNumAdded;
+ iProgressEventBuffer[last].iServerMods.iNumReplaced += aProgressEventItem.iServerMods.iNumReplaced;
+ iProgressEventBuffer[last].iServerMods.iNumMoved += aProgressEventItem.iServerMods.iNumMoved;
+ iProgressEventBuffer[last].iServerMods.iNumDeleted += aProgressEventItem.iServerMods.iNumDeleted;
+ iProgressEventBuffer[last].iServerMods.iNumFailed += aProgressEventItem.iServerMods.iNumFailed;
+ }
+ else
+ {
+ iProgressEventBuffer.Append( aProgressEventItem );
+ }
+
+ _DBG_FILE("CNSmlSOSSession::BufferDoModifications : End");
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlSOSSession::HandleModifications( const TNSmlProgressEvent& aProgressEventItem )
+// Handle buffered modifications.
+// --------------------------------------------------------------------------
+//
+void CNSmlSOSSession::BufferContactSuiteDoModifications( const TNSmlProgressEvent& aProgressEventItem )
+ {
+ _DBG_FILE("CNSmlSOSSession::BufferDoModifications : Begin");
+
+ TInt last = iContactSuiteProgressEventBuffer.Count()-1;
+
+ TBool doSum = iContactSuiteProgressEventBuffer[last].iEventType == ENSmlModifications ? ETrue : EFalse;
+ if ( doSum )
+ {
+ iContactSuiteProgressEventBuffer[last].iClientMods.iNumAdded += aProgressEventItem.iClientMods.iNumAdded;
+ iContactSuiteProgressEventBuffer[last].iClientMods.iNumReplaced += aProgressEventItem.iClientMods.iNumReplaced;
+ iContactSuiteProgressEventBuffer[last].iClientMods.iNumMoved += aProgressEventItem.iClientMods.iNumMoved;
+ iContactSuiteProgressEventBuffer[last].iClientMods.iNumDeleted += aProgressEventItem.iClientMods.iNumDeleted;
+ iContactSuiteProgressEventBuffer[last].iClientMods.iNumFailed += aProgressEventItem.iClientMods.iNumFailed;
+
+ iContactSuiteProgressEventBuffer[last].iServerMods.iNumAdded += aProgressEventItem.iServerMods.iNumAdded;
+ iContactSuiteProgressEventBuffer[last].iServerMods.iNumReplaced += aProgressEventItem.iServerMods.iNumReplaced;
+ iContactSuiteProgressEventBuffer[last].iServerMods.iNumMoved += aProgressEventItem.iServerMods.iNumMoved;
+ iContactSuiteProgressEventBuffer[last].iServerMods.iNumDeleted += aProgressEventItem.iServerMods.iNumDeleted;
+ iContactSuiteProgressEventBuffer[last].iServerMods.iNumFailed += aProgressEventItem.iServerMods.iNumFailed;
+ }
+ else
+ {
+ iContactSuiteProgressEventBuffer.Append( aProgressEventItem );
+ }
+
+
+ _DBG_FILE("CNSmlSOSSession::BufferDoModifications : End");
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlDSSettings& CNSmlSOSSession::DSSettings()
+// Returns reference to ds settings.
+// --------------------------------------------------------------------------
+//
+TBool CNSmlSOSSession::ProgressEventsBuffered()
+ {
+ _DBG_FILE("CNSmlSOSSession::ProgressEventsBuffered() : Begin");
+ return iProgressEventBuffer.Count() == 0 ? EFalse : ETrue;
+
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlDSSettings& CNSmlSOSSession::DSSettings()
+// Returns reference to ds settings.
+// --------------------------------------------------------------------------
+//
+CNSmlDSSettings& CNSmlSOSSession::DSSettings()
+ {
+ return *iDSSettings;
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlDMSettings& CNSmlSOSSession::DMSettings()
+// Returns reference to dm settings.
+// --------------------------------------------------------------------------
+//
+CNSmlDMSettings& CNSmlSOSSession::DMSettings()
+ {
+ return *iDMSettings;
+ }
+
+// --------------------------------------------------------------------------
+// CNSmlDSHostClient& CNSmlSOSSession::HostClient()
+// Returns reference to ds hoist client.
+// --------------------------------------------------------------------------
+//
+CNSmlDSHostClient& CNSmlSOSSession::HostClient()
+ {
+ return *iDsClient;
+ }
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// --------------------------------------------------------------------------------
+// void NSmlGrabMutex( RMutex& aMutex, const TDesC& aMutexName )
+// --------------------------------------------------------------------------------
+LOCAL_C TInt NSmlGrabMutex(
+ RMutex& aMutex, // Mutex to acquire.
+ const TDesC& aMutexName ) // Name of the mutex.
+ {
+ TInt returnValue( KErrGeneral );
+ TInt counter( 0 );
+ while( counter < KNSmlMutexLoopCounter )
+ {
+ counter++;
+ TInt ret = aMutex.CreateGlobal(aMutexName);
+ if( ret == KErrNone ) // We created the mutex -> Issue wait()
+ {
+ aMutex.Wait();
+ break;
+ }
+ if( ret == KErrAlreadyExists ) // Mutex already existed -> Open it
+ {
+ ret = aMutex.OpenGlobal(aMutexName);
+ if( ret == KErrNone ) // We got handle to the mutex -> Issue wait()
+ {
+ aMutex.Wait();
+ break;
+ }
+ }
+ }
+ if ( counter < KNSmlMutexLoopCounter )
+ {
+ returnValue = KErrNone;
+ }
+ return returnValue;
+ }