/*

* 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:  Base class in Commmon Agent

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_partner.h>

#endif

#include <tconvbase64.h>

#include <hash.h>

#include <SyncMLHistory.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldefines.h>

#include <nsmlphoneinfo.h>

#include <nsmlunicodeconverter.h>

#include <centralrepository.h>

#include <DevManInternalCRKeys.h>

#include <e32property.h>

#include <http/thttpevent.h>

#include "nsmlprivatepskeys.h"

#include "nsmlcliagconstants.h"

#include "NSmlAgentBase.h"

#include "NSmlCmdsBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResponseController.h"

#include "nsmlerror.h"

#include "NSmlURI.h"

#include "nsmltransport.h"

#include "nsmlagenttestdefines.h"

#if defined (__NOTRANSPORT) || defined (_DEBUG)

#include "wbxml2xmlconverter.h"

#include <bautils.h>

#endif

//Rnd_AutoRestart

#include <es_sock.h> // RConnection RSocket

#include <es_enum.h> // TConnectionInfo

#include <commdb.h>

#include <cmconnectionmethoddef.h>

#include <cmconnectionmethod.h>

#include <cmmanager.h>

#include <cmpluginwlandef.h>

#include "nsmlhttp.h"

//Fix to Remove the Bad Compiler Warnings

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

const TUid KCRUidDataSyncInternalKeys  = { 0x2000CF7E };

const TInt KNsmlDsAutoRestart = 7; //(0x00000007)

//Rnd_AutoRestart

// CONSTANTS

_LIT( KPanicInvalidState, "Invalid state" );

// ================= MEMBER FUNCTIONS =======================

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

// CNSmlAgentBase::CNSmlAgentBase()

// C++ constructor

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

//

EXPORT_C CNSmlAgentBase::CNSmlAgentBase() : CActive(EPriorityLow), iBufferArea(0, 0)

    {

	}

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

// CNSmlAgentBase::~CNSmlAgentBase()

// Destructor

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

//

EXPORT_C CNSmlAgentBase::~CNSmlAgentBase()

    {

	Cancel();

	delete iImeiCode;

	delete iSyncMLUserName;

	delete iSyncMLPassword;

	delete iSyncServer;

	delete iSyncMLCmds;

	delete iSyncMLMIMEType;

	delete iResultAlertCode;

	delete iEndOfDataAlertCode;

	delete iSessionAbortAlertCode;

	delete iNextMessageCode;

	delete iTransport;		

	delete iError;

    delete iIAPIdArray;

	delete iSyncHTTPAuthUserName;

	delete iSyncHTTPAuthPassword;

	}

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

// CNSmlAgentBase::AlreadyAuthenticated()

// 

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

TBool CNSmlAgentBase::AlreadyAuthenticated() const

	{

	return iAlreadyAuthenticated;

	}

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

// CNSmlAgentBase::BasicCredentialL

// Creates B64 string form SyncML userID and password 

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

HBufC8* CNSmlAgentBase::BasicCredentialL() const

	{

	TBase64 B64Coder;

	HBufC8* userName;

	NSmlUnicodeConverter::HBufC8InUTF8LC( *iSyncMLUserName, userName );

	HBufC8* password;

	NSmlUnicodeConverter::HBufC8InUTF8LC( *iSyncMLPassword, password );

	_LIT8( KColon, ":" );

	HBufC8* clearText = HBufC8::NewLC( userName->Length() + KColon.iTypeLength + password->Length());

	TPtr8 clearTextPtr = clearText->Des();

	clearTextPtr = *userName;

	clearTextPtr += KColon;

	clearTextPtr += *password;

	HBufC8* B64String = HBufC8::NewLC( clearText->Length() * 2 );

	TPtr8 B64StringPtr( B64String->Des() );

	User::LeaveIfError( B64Coder.PortableEncode( *clearText, B64StringPtr ) );

	CleanupStack::Pop(); // B64String

	CleanupStack::PopAndDestroy( 3 ); //clearText, password, userName

	return B64String;

	}

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

// CNSmlAgentBase::Md5CredentialL

// Creates MD5 string form SyncML userID, password and nonce

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

HBufC8* CNSmlAgentBase::Md5CredentialL( TBool aServerAuth ) const

	{

	CMD5* md5 = CMD5::NewL();

	CleanupStack::PushL( md5 );

	TBase64 B64Coder;

	HBufC8* userName;

	if ( aServerAuth )

		{

		NSmlUnicodeConverter::HBufC8InUTF8LC( ServerUserName(), userName );

		}

	else

		{

		NSmlUnicodeConverter::HBufC8InUTF8LC( *iSyncMLUserName, userName );

		}

	HBufC8* password;

	if ( aServerAuth )

		{

		NSmlUnicodeConverter::HBufC8InUTF8LC( ServerPassword(), password );

		}

	else

		{

		NSmlUnicodeConverter::HBufC8InUTF8LC( *iSyncMLPassword, password );

		}

	HBufC* nonceInUnicode;

	if ( aServerAuth )

		{

		nonceInUnicode = ServerNonceAllocL();

		}

	else

		{

		nonceInUnicode = NonceL();

		}

	CleanupStack::PushL( nonceInUnicode );

	HBufC8* nonce = HBufC8::NewLC( nonceInUnicode->Length() );

	nonce->Des().Copy( *nonceInUnicode );

	_LIT8( KColon, ":" );

	HBufC8* userNamePassword = HBufC8::NewLC( userName->Length() + KColon.iTypeLength + password->Length() );

	TPtr8 userNamePasswordPtr = userNamePassword->Des();

	userNamePasswordPtr = *userName;

	userNamePasswordPtr += KColon;

	userNamePasswordPtr += *password;

	TPtrC8 userNamePasswordHash;

	userNamePasswordHash.Set( md5->Hash( *userNamePassword ) );

	HBufC8* B64UserNamePasswordString = HBufC8::NewLC( userNamePasswordHash.Length() * 2 );

	TPtr8 B64UserNamePasswordStringPtr( B64UserNamePasswordString->Des() );

	User::LeaveIfError( B64Coder.PortableEncode( userNamePasswordHash, B64UserNamePasswordStringPtr ) );

	HBufC8* userNamePasswordNonce = HBufC8::NewLC( B64UserNamePasswordStringPtr.Length() + KColon.iTypeLength + nonce->Length() );

	TPtr8 userNamePasswordNoncePtr = userNamePasswordNonce->Des();

	userNamePasswordNoncePtr = B64UserNamePasswordStringPtr;

	userNamePasswordNoncePtr += KColon;

	userNamePasswordNoncePtr += *nonce;

	TPtrC8 finalHash;

	md5->Reset();

	finalHash.Set( md5->Hash( *userNamePasswordNonce ) );

	HBufC8* B64String = HBufC8::NewLC( finalHash.Length() * 2 );

	TPtr8 B64StringPtr( B64String->Des() );

	User::LeaveIfError( B64Coder.PortableEncode( finalHash, B64StringPtr ) );

	CleanupStack::Pop();   // B64String

	CleanupStack::PopAndDestroy( 8 ); //userNamePasswordNonce, B64userNamePasswordNonce, userNamePassword, nonce, nonceInUnicode, password, userName, md5

	return  B64String;

	}

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

// CNSmlAgentBase::ServerNonceAllocL()

// 

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

EXPORT_C HBufC* CNSmlAgentBase::ServerNonceAllocL() const

	{

	return HBufC::NewL( 0 );

	}

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

// CNSmlAgentBase::SetServerNonceL()

// 

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

EXPORT_C void CNSmlAgentBase::SetServerNonceL( const TDesC& /*aNonce*/ ) const

	{

	}

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

// CNSmlAgentBase::SetEndOfDataAlertRequest()

// 

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

EXPORT_C void CNSmlAgentBase::SetEndOfDataAlertRequest()

	{

	iEndOfDataAlertRequest = ETrue;

	}

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

// CNSmlAgentBase::SyncLog()

// Returns pointer to the syncml history log.

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

EXPORT_C CSyncMLHistoryJob* CNSmlAgentBase::SyncLog()

	{

	return iSyncLog;

	}

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

// CNSmlAgentBase::CallbackCalled()

// 

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

EXPORT_C TBool CNSmlAgentBase::CallbackCalled() const

	{

	return iCallbackCalled;

	}

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

// CNSmlAgentBase::SetOffCallbackCalled()

// 

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

EXPORT_C void CNSmlAgentBase::SetOffCallbackCalled()

	{

	iCallbackCalled = EFalse;

	}

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

// CNSmlAgentBase::RunL()

// 

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

EXPORT_C void CNSmlAgentBase::RunL()

    {

	TRAPD( leaveCode, NavigateMainStateL() );

	if ( leaveCode != KErrNone )

		{

		ErrorHandling( leaveCode );

		}

	if ( iCancelForced )

		{

		ErrorHandling( KErrCancel );

		}

	if ( !iEnd )

		{

		SetActive();

		#ifndef __NOTRANSPORT

		if ( !iCommandIssued ) //When asychronous transport service is not called

							   //thread is signalled immediately 	

		#endif

			{

			TRequestStatus* status = &iStatus;

			User::RequestComplete( status, KErrNone );

			}

		}

	if ( iEnd )

		{

		FreeResources();	

		}

	}

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

// CNSmlAgentBase::DoOutsideCancel()

// 

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

EXPORT_C void CNSmlAgentBase::DoOutsideCancel() 

	{ 

	iCancelForced = ETrue;

	}

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

// CNSmlAgentBase::DoCancel()

// 

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

EXPORT_C void CNSmlAgentBase::DoCancel()

    {

	#ifndef __NOTRANSPORT

	iTransport->Disconnect(); 

	#endif

	ErrorHandling( KErrCancel );

	return;

    }

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

// CNSmlAgentBase::smlAddCmdFunc

// Add command from server

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

EXPORT_C Ret_t CNSmlAgentBase::smlAddCmdFuncL( SmlAddPtr_t aContent )

	{

	iCallbackCalled = ETrue;

	switch ( iCurrMainState )

		{

		case EServerModifications:

			ServerModUpdatesStateL( KNSmlAgentAdd(), aContent );

			break;

		default:

			iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentAdd, aContent->cmdID, aContent->flags );

		}

	return 0;

	}

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

// CNSmlAgentBase::smlCopyCmdFunc

// Copy command from server, Copy is not supported

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

EXPORT_C Ret_t CNSmlAgentBase::smlCopyCmdFuncL( SmlCopyPtr_t aContent )

	{

	iCallbackCalled = ETrue;

	iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentCopy, aContent->cmdID, aContent->flags );

	return 0;

	}

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

// CNSmlAgentBaset::smlDeleteCmdFunc

// Delete command from server

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

EXPORT_C Ret_t CNSmlAgentBase::smlDeleteCmdFuncL( SmlDeletePtr_t aContent )

	{

	iCallbackCalled = ETrue;

	switch ( iCurrMainState )

		{

		case EServerModifications:

			ServerModUpdatesStateL( KNSmlAgentDelete(), aContent );

			break;

		default:

			iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentDelete, aContent->cmdID, aContent->flags );

		}

	return 0;

	}

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

// CNSmlAgentBase::smlExecCmdFunc

// Exec command from server

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

EXPORT_C Ret_t CNSmlAgentBase::smlExecCmdFuncL( SmlExecPtr_t aContent )

	{

	iCallbackCalled = ETrue;

	iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentExec, aContent->cmdID, aContent->flags );

	return 0;

	}

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

// CNSmlAgentBase::smlMapCmdFunc

// Map command from server, Map is not supported

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

EXPORT_C Ret_t CNSmlAgentBase::smlMapCmdFuncL( SmlMapPtr_t aContent )

	{

	iCallbackCalled = ETrue;

	iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentMap, aContent->cmdID );

	return 0;

	}

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

// CNSmlAgentBase::smlReplaceCmdFunc

// Replace command from server

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

EXPORT_C Ret_t CNSmlAgentBase::smlReplaceCmdFuncL( SmlReplacePtr_t aContent )

	{

	iCallbackCalled = ETrue;

	switch ( iCurrMainState )

		{

		case EServerModifications:

			ServerModUpdatesStateL( KNSmlAgentReplace(), aContent );

			break;

		default:

			iSyncMLCmds->StatusToUnsupportedCommandL( ETrue, KNSmlAgentReplace, aContent->cmdID, aContent->flags );

		}

	return 0;

	}

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

// CNSmlAgentBase::smlSearchCmdFunc

// Search command from server

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

EXPORT_C Ret_t CNSmlAgentBase::smlSearchCmdFuncL( SmlSearchPtr_t aContent )

	{

	iCallbackCalled = ETrue;

	iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentSearch, aContent->cmdID, aContent->flags );

	return 0;

	}

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

// CNSmlAgentBase::smlMoveCmdFunc

// Copy command from server, Copy is not supported

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

//1.2 CHANGES

EXPORT_C Ret_t CNSmlAgentBase::smlMoveCmdFuncL( SmlMovePtr_t aContent )

	{

	iCallbackCalled = ETrue;

	iSyncMLCmds->StatusToUnsupportedCommandL( EFalse, KNSmlAgentMove, aContent->cmdID, aContent->flags );

	return 0;

	}

//end chnages

//

//  Protected member functions

//

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

// CNSmlAgentBase::ConstructL()

// 

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

//

EXPORT_C void CNSmlAgentBase::ConstructL()

    {

    iSendRetries = 3;

	iCurrMainState = EBeginning;

	#ifndef __NOTRANSPORT

	iTransport = CNSmlTransport::NewL();	

	#endif

	CNSmlPhoneInfo* phoneInfo = CNSmlPhoneInfo::NewLC();

	iImeiCode = HBufC::NewL( 50 );

	TPtr imeiCodePtr = iImeiCode->Des();  

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

	CleanupStack::PopAndDestroy();  //phoneInfo

	InitialiseSubStates();

	//Auto_Restart

    iPacketDataUnAvailable = EFalse;    

    iNetmonAPId = 0;

    iAllowAutoRestart = EFalse;

	}

//

// Beginning state functions 

//

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

// CNSmlAgentBase::BeginningStateL()

// This state is performed in the beginning of sync.

// Navigate according to sub state code

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

//

EXPORT_C void CNSmlAgentBase::BeginningStateL() 

	{

	switch ( iCurrBeginningState )

		{

		case EBegin:

			BeginStateL();

			break;

		case EBeginConnectingToServer:

			BeginConnectingStateL();

			break;

		default:

			User::Panic( KPanicInvalidState, iCurrBeginningState );

		}

	}

//

//  Client Initialisation state functions 

//

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

// CNSmlAgentBase::ClientInitialisationStateL()

// Makes Sync Initialization Package from Client 

// Navigate according to sub state code.

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

EXPORT_C void CNSmlAgentBase::ClientInitialisationStateL()

	{

	switch ( iCurrClientInitState )

		{

		case EInitStartingMessage:

			InitStartingMessageStateL();

			break;

		case EInitMakingStatus:

			InitMakingStatusStateL();

			break;

		case EInitAlerting:

			InitAlertingStateL();

			break;

		case EInitDeviceInfo:

			InitDeviceInfoStateL();

			break;

		case EInitAskingDeviceInfo:

			InitAskingDeviceInfoStateL();

			break;

		case EInitEndingMessage:

			InitEndingMessageStateL();

			break;

		default:

			User::Panic( KPanicInvalidState, iCurrClientInitState );

		}

	}

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

// CNSmlAgentBase::InitStartingMessageBaseStateL()

// "Initialising" event to UI,  makes SyncHdr  

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

EXPORT_C void CNSmlAgentBase::InitStartingMessageStateBaseL()

	{

	iChallengeRequest = EFalse;

	iSyncMLCmds->DoSyncHdrL();