/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Common Agent SyncML command handling

*

*/

// INCLUDE FILES

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldefines.h>

#include <nsmlphoneinfo.h>

#include <nsmlunicodeconverter.h>

#include "nsmlcliagconstants.h"

#include "NSmlCmdsBase.h"

#include "NSmlAgentBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResponseController.h"

#include "NSmlResultsContainer.h"

#include "NSmlURI.h"

#include "NSmlAuth.h"

#include "WBXMLSyncMLGenerator.h"

#include "WBXMLSyncMLParser.h"

#include "WBXMLGeneratorError.h"

#include "WBXMLParser.h"

#include "smldtd.h"

// ---------------------------------------------------------

// CNSmlCmdsBase::CNSmlCmdsBase()

// Constructor

// ---------------------------------------------------------

//

EXPORT_C CNSmlCmdsBase::CNSmlCmdsBase()

    {

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::~CNSmlCmdsBase()

// Destructor

// ---------------------------------------------------------

//

EXPORT_C CNSmlCmdsBase::~CNSmlCmdsBase()

    {

//1.2 CHANGES: 1.1 and 1.2 version support

	delete iVerDTD;

//end changes

	delete iVerProto;

	delete iSentSyncHdrTarget;

	delete iSentSyncHdrSource;

	delete iRespURI;

	delete iStatusToServer;

	delete iResponseController;

	delete iResultsToServer;

	delete iGenerator;

	delete iParser;

	delete iDocHandler;

	delete iPhoneInfo;

	delete iServerAuth;

	delete iSessionID;

	delete iSyncMLUserName;

	delete iSyncServer;

	delete iLargeObjectItem;

	delete iRecBuf;

	delete iLargeObjectUID;

	delete iCurrServerMsgID;

	delete iBufferArea;

	iReadStream.Close();

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessCopyCmdL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ProcessCopyCmdL(SmlCopy_t* /*aCopy*/)

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessExecCmdL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ProcessExecCmdL(SmlExec_t* /*aExec*/)

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessMapCmdL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ProcessMapCmdL(SmlMap_t* /*aContent*/)

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessSearchCmdL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ProcessSearchCmdL(SmlSearch_t* /*aSearch*/)

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::FetchIDMappingTableL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::FetchIDMappingTableL(const TInt /*aType*/)

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::CloseIDMappingTableL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::CloseIDMappingTableL()

	{

	//for future use

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::DeleteIDMappingTableL

// 

// ---------------------------------------------------------

EXPORT_C TBool CNSmlCmdsBase::DeleteIDMappingTableL(const TDesC& /*aId*/, const TDesC& /*aDatabase*/)

	{

	//for future use

	return EFalse;

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::EndOfServerMessageL

// 

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::EndOfServerMessageL() const

	{

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::WriteMappingInfoToDbL

// Empty default implementation.

// ---------------------------------------------------------

EXPORT_C TInt CNSmlCmdsBase::WriteMappingInfoToDbL() const

	{

	// Defined only in DM agent

	return KErrNone;

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::DoSyncHdrL

// Makes SyncHdr element and calls parser to generate xml

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::DoSyncHdrL() 

	{

	// create generator instance first

	if ( !iGenerator )

		{

		iGenerator = new( ELeave ) CWBXMLSyncMLGenerator( iVersionPublicId );

		}

	// create workspace

	iGenerator->CreateWorkspaceL( iWorkspaceSize );

	//initialise SyncHdr

	SmlSyncHdr_t* syncHdr = new( ELeave ) SmlSyncHdr_t; 

	CleanupStack::PushL( syncHdr );

	//element type

	syncHdr->elementType = SML_PE_HEADER;

	//VerDTD element  

//1.2 CHANGES: 1.2 and 1.1 version support

	PcdataNewL ( syncHdr->version, *iVerDTD );

//changes end

	//VerProto element  

	PcdataNewL ( syncHdr->proto, *iVerProto );

	//sessionID element

	PcdataNewL ( syncHdr->sessionID, *iSessionID );

	//msgID element

	TBuf8<16> stringMsgID; 

	stringMsgID.Num( ++iCurrMsgID );

	PcdataNewL( syncHdr->msgID, stringMsgID );

	//Target element

	delete iSentSyncHdrTarget;

	iSentSyncHdrTarget = NULL;

	if ( iRespURI )

		{

		// Target changes if a server has issued RespURI in previous message

		DoTargetL( syncHdr->target, iRespURI->HostName() );

		iSentSyncHdrTarget = CNSmlURI::NewL( iRespURI->HostName() );

		}

	else

		{

		DoTargetL( syncHdr->target, iSyncServer->HostName() ); 

		iSentSyncHdrTarget = CNSmlURI::NewL( iSyncServer->HostName() );

		}

	//Source element

	HBufC* imeiCode = HBufC::NewLC( 50 );

	TPtr imeiCodePtr = imeiCode->Des();  

	iPhoneInfo->PhoneDataL( CNSmlPhoneInfo::EPhoneSerialNumber, imeiCodePtr );

	CNSmlAgentBase::TAuthenticationType authType;

	authType = iAgent->AuthTypeL();

	if ( ( !iAlreadyAuthenticated ) &&  ( authType == CNSmlAgentBase::EMD5 ) )

		{

		DoSourceL( syncHdr->source, imeiCodePtr, *iSyncMLUserName);

		}

	else

		{

		DoSourceL( syncHdr->source, imeiCodePtr ); 

		}

	delete iSentSyncHdrSource;

	iSentSyncHdrSource = NULL;

	iSentSyncHdrSource = CNSmlURI::NewL( *imeiCode );

	CleanupStack::PopAndDestroy(); //imeiCode

	// Cred element 

	if ( authType == CNSmlAgentBase::ENoAuth || iAgent->AlreadyAuthenticated() )

		{

		syncHdr->cred = NULL;

		}

	else

		{

		syncHdr->cred = new( ELeave ) SmlCred_t;

		SmlMetInfMetInf_t* metInf;

		DoMetInfLC( metInf ); 

		if ( authType == CNSmlAgentBase::EMD5 )

			{

			PcdataNewL( metInf->type, KNSmlAgentAuthMD5 );

			PcdataNewL( metInf->format, KNSmlAgentBase64Format );

			}

		else  // Basic

			{

			PcdataNewL( metInf->type, KNSmlAgentAuthBasic );

			}

		DoMetaL( syncHdr->cred->meta, metInf );

		CleanupStack::Pop(); //metInf

		HBufC8* credential;

		if ( authType == CNSmlAgentBase::EMD5 )

			{

			credential = iAgent->Md5CredentialL();

			}

		else // Basic

			{

			credential = iAgent->BasicCredentialL();

			}

		CleanupStack::PushL( credential ); 

		PcdataNewL ( syncHdr->cred->data, *credential );

		CleanupStack::PopAndDestroy(); //credential

		}

	// MaxMsgSize

	SmlMetInfMetInf_t* maxMsgMetInf;

	DoMetInfLC( maxMsgMetInf );

	TBuf<16> maxMsgSize;

	maxMsgSize.Num( iWorkspaceSize );

	HBufC8* maxMsgSizeInUTF8 = NULL;

	NSmlUnicodeConverter::HBufC8InUTF8LC( maxMsgSize, maxMsgSizeInUTF8 );

	PcdataNewL( maxMsgMetInf->maxmsgsize, *maxMsgSizeInUTF8 );

	CleanupStack::PopAndDestroy(); //maxMsgSizeInUTF8

	if ( iSynchHdrMaxObjSize > 0 )

		{

		DoMaxObjSizeL( *maxMsgMetInf, iSynchHdrMaxObjSize );

		}

	DoMetaL( syncHdr->meta, maxMsgMetInf );

	CleanupStack::Pop(); //maxMsgMetInf

	TInt ret;

	ret = iGenerator->smlStartMessage( syncHdr );

	if ( ret != KWBXMLGeneratorOk )

		{

		User::Leave( ret );

		}

	CleanupStack::PopAndDestroy(); //syncHdr

	iCurrCmdID = 0;

	//save Status response information for response status controlling

	CreateAndInitResponseItemL( KNSmlAgentSyncHdr );

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::DoStatusL

// Generate Status element and calls Ref.Toolkit parser to generate xml 

// ---------------------------------------------------------

EXPORT_C CNSmlCmdsBase::TReturnValue CNSmlCmdsBase::DoStatusL( SmlStatus_t* aStatus ) 

	{

	TReturnValue returnValue = EReturnOK;

	//CmdID element

	SmlPcdata_t* cmdID = NULL;

	DoCmdIdL( cmdID );

	CleanupStack::PushL( cmdID );

	TInt entryID = iStatusToServer->CurrentEntryID();

	iStatusToServer->SetCmdIDL( entryID, cmdID );

	CleanupStack::PopAndDestroy(); //cmdID

	// call SyncML generator

	TInt ret = iGenerator->smlStatusCmd( aStatus );

	switch ( ret )

		{

		case KWBXMLGeneratorOk:

			iStatusToServer->RemoveWritten( entryID );

			break;

		case KWBXMLGeneratorBufferFull:

			returnValue = CNSmlCmdsBase::EReturnBufferFull;

			break;

		default:

			User::Leave( ret );

		}

	return returnValue;

	}

// FOTA

// ---------------------------------------------------------

// CNSmlCmdsBase::DoGenericAlertL

// Makes generic alert. 

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::DoGenericAlertL (  const TDesC8& /*aFwMgmtUri*/, const TDesC8& /*aMetaType*/, 

									const TDesC8& /*aMetaFormat*/, TInt /*aFinalResult*/, const TDesC8& /*aFwCorrelator*/ ) 

	{

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::DoGenericAlertL

// Makes generic alert. 

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::DoGenericAlertL (  const TDesC8& /*aCorrelator*/, const RArray<CNSmlDMAlertItem>& /*aData*/ ) 

	{

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::DoGenericUserAlertL

// Makes generic user alert. 

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C TBool CNSmlCmdsBase::DoGenericUserAlertL ( TInt /*aProfileId*/ ) 

	{

	return EFalse;

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ResetGenericUserAlertL

// Resets a user request for fw update in the central repository.

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ResetGenericUserAlertL() 

	{

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::MarkGenAlertsSentL

// When the generic alerts are successfully sent to the remote 

// server, the FOTA adapter needs to be informed about this.

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::MarkGenAlertsSentL() 

	{

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::MarkGenAlertsSentL(const TDesC8)

// When the generic alerts are successfully sent to the remote 

// server, the respective adapter needs to be informed about this.

// URI will have adapter's root node.

// This is needed only in Device Management.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::MarkGenAlertsSentL(const TDesC8 &aURI) 

    {

    }

// ---------------------------------------------------------

// CNSmlCmdsBase::DisconnectFromOtherServers

// Closes the connections to callback server and host servers.

// This is needed only in Device Management, since the 

// disconnecting cannot be made after the active scheduler

// of the thread is stopped.

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::DisconnectFromOtherServers() 

	{

	}

// FOTA end

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessReceivedDataL

// Parse next received SyncML command using Ref.Toolkit parser

// ---------------------------------------------------------

EXPORT_C TBool CNSmlCmdsBase::ProcessReceivedDataL()

	{

	if ( !iDocHandler )

		{

		iDocHandler = CWBXMLSyncMLDocHandler::NewL( iAgent );

		}

	if ( !iParser )

		{

		iParser = CWBXMLParser::NewL();

		iParser->SetDocumentHandler( iDocHandler );

		iParser->SetExtensionHandler( iDocHandler );

		if ( !iBufferArea )

			{

			iBufferArea = HBufC8::NewL( iWorkspaceSize );

			}

		iReadStream.Open( *iBufferArea ); 

		iParser->SetDocumentL( iReadStream );

		}

	TWBXMLParserError ret = KWBXMLParserErrorOk;

	iAgent->SetOffCallbackCalled();

	while ( ret == KWBXMLParserErrorOk && !iAgent->CallbackCalled() )

		{

		ret = iParser->ParseL();

		}

	if ( ret == KWBXMLParserErrorOk )   

		{

		return ETrue;

		}

	else

		{

		delete iBufferArea;

		iBufferArea = NULL;

		delete iParser;

		iParser = NULL;

		if ( ret == KWBXMLParserErrorEof )

			{

			return EFalse;

			}

		else

			{

			User::Leave( ret );

			return EFalse;   // this sentence ignores compiler warning

			}

		}

	}

// ---------------------------------------------------------

// CNSmlCmdsBase::ProcessSyncHdrL

// Process received SyncHdr element

// ---------------------------------------------------------

EXPORT_C void CNSmlCmdsBase::ProcessSyncHdrL( SmlSyncHdr_t* aSyncHdr )

	{

	if ( !aSyncHdr ) 

		{

		User::Leave( TNSmlError::ESmlSyncHdrMissing );

		}

	// Status response flag 

	if ( IsFlagSet( aSyncHdr->flags, SmlNoResp_f ) )

		{

		iStatusToServerNoResponse = ETrue;

		}

	else

		{

		iStatusToServerNoResponse = EFalse;

		}

	// build corresponding status element to server

	if ( !iStatusToServer )

		{

		iStatusToServer = CNSmlStatusContainer::NewL();

		}

	iStatusToServer->InitMsgRefL( aSyncHdr->msgID );

	delete iCurrServerMsgID;

	iCurrServerMsgID = NULL;

	iCurrServerMsgID = HBufC8::NewL(0);

	TInt statusID;

	statusID = iStatusToServer->CreateNewStatusElementL(); 

	HBufC8* cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength );	

	*cmdRef = KNSmlAgentSyncHdrCmdID;

	SmlPcdata_t*  cmdRefElement;

	PcdataNewL ( cmdRefElement, *cmdRef );

	CleanupStack::PushL( cmdRefElement );

	iStatusToServer->SetCmdRefL( statusID, cmdRefElement );

	CleanupStack::PopAndDestroy( 2 ); //cmdRefElement, cmdRef

	iStatusToServer->SetCmdL( statusID, KNSmlAgentSyncHdr ); 

	iStatusToServer->SetNoResponse( statusID, IsFlagSet( aSyncHdr->flags, SmlNoResp_f ) );

	iStatusToServer->AddTargetRefL( statusID, aSyncHdr->target );

	iStatusToServer->AddSourceRefL( statusID, aSyncHdr->source );

	iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusOK );

	//respURI

	if ( aSyncHdr->respURI )

		{

		HBufC* respURI;

		PCDATAToUnicodeLC( *aSyncHdr->respURI, respURI );

		respURI->Des().TrimRight();

		if ( respURI->Length() > 0 )

			{

			delete iRespURI;

			iRespURI = NULL;

			iRespURI = CNSmlURI::NewL( *respURI );

			}

		CleanupStack::PopAndDestroy(); //respURI

		}

	// verDTD and verProto (Check only once) 

	// sync is interrupted if version is other than 1.1 

	if ( !iVersionCheck )	

		{

		iVersionIsChecked = ETrue;

		}

	if ( !iVersionIsChecked )

		{

		if ( !aSyncHdr->version->content )

			{

			iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusVersionNotSupported );

			iAgent->Interrupt( TNSmlError::ESmlVerDTDMissing, EFalse, EFalse );

			return;

			}

		TPtr8 verDTD( (TUint8*) aSyncHdr->version->content, aSyncHdr->version->length, aSyncHdr->version->length );

		TrimRightSpaceAndNull( verDTD );

//1.2 CHANGES: 1.1 and 1.2 version support

		if ( ( verDTD != KNSmlAgentVerDTD11 ) && (verDTD != KNSmlAgentVerDTD12 ))

			{

			iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusVersionNotSupported );

			SmlPcdata_t* data = NULL;

			PcdataNewL( data, *iVerDTD );

//changes end			

			CleanupStack::PushL( data );

			iStatusToServer->AddItemDataL( statusID, data );

			CleanupStack::PopAndDestroy(); //data

			iAgent->Interrupt( TNSmlError::ESmlVerDTDNotSupported, EFalse, EFalse );