/*

* 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 );

        return;

        }

    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);