/*

* 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:  SyncML HTTP client

*

*/

#include "nsmlhttp.h"

#include "nsmlhttpclient.h"

#include <e32property.h> 

#include <DevManInternalCRKeys.h>

#include <centralrepository.h>

#include "nsmlprivatepskeys.h"

#include "nsmlerror.h"

#ifdef __NSML_DEBUG__

#include "wbxml2xmlconverter.h"

#endif // __NSML_DEBUG__

#include <centralrepository.h>

#include <ssl.h>

#include "PMUtilInternalCRKeys.h"

#include "nsmlhttpPrivateCRKeys.h"

#include <nsmlunicodeconverter.h>

#include <ezcompressor.h>

#include <ezdecompressor.h>

#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

#include <featmgr.h>

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

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

// CNSmlHTTP::NewL()

// Two-phased constructor.

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

//

CNSmlHTTP* CNSmlHTTP::NewL()

    {

	CNSmlHTTP* self = new (ELeave) CNSmlHTTP();

	CleanupStack::PushL( self );

    self->ConstructL();

	CleanupStack::Pop(); //self

    return self;

    }

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

// CNSmlHTTP::CNSmlHTTP()

// constructor

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

//

CNSmlHTTP::CNSmlHTTP() 

: CActive( EPriorityStandard ), iReqBodySubmitBufferPtr( 0,0 )

	{

	CActiveScheduler::Add( this );

	}

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

// CNSmlHTTP::ConstructL()

// 2-phase constructor

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

//

void CNSmlHTTP::ConstructL() 

	{

	// construct shutdown timer

	DBG_FILE(_S8("CNSmlHTTP::ConstructL BEGIN"));

	FeatureManager::InitializeLibL();

	iShutdown = new (ELeave) CNSmlXptShutdownTimer( this );

	iShutdown->ConstructL();

	iNetworkStatusEngine = NULL;

	// do this only if session is DM 

	TInt session=0;    

    TInt r=RProperty::Get( KPSUidNSmlSOSServerKey, KNSmlSyncJobOngoing, session);                       

    DBG_FILE_CODE(session, _S8("CNSmlHTTP::ConstructL Current Session is (DM = 2, DS = 1) "));

    if( session == ESyncMLDMSession )//for dm session

       {

		TInt dmsessionTimeout = -1;

		CRepository *rep = NULL;

		TRAPD( err1, rep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ))

		DBG_FILE_CODE(err1, _S8("CNSmlHTTP::ConstructL cenrep read error code "));

		if(err1 == KErrNone)

		{

			rep->Get( KDevManDMSessionTimeout, dmsessionTimeout );

			delete rep;

			DBG_FILE_CODE(dmsessionTimeout, _S8("CNSmlHTTP::ContructL, DMSessiontimeout feature value from cenrep"));

			if( dmsessionTimeout > KNSmlDMMaxSessionTimeout || dmsessionTimeout < KNSmlDMMinSessionTimeout)

			{

			dmsessionTimeout = -1;

			}

			DBG_FILE_CODE(dmsessionTimeout, _S8("CNSmlHTTP::ContructL, DMSessiontimeout feature value "));

		}

		if(dmsessionTimeout != -1)

		{

			iNetworkStatusEngine = new (ELeave) CNsmlNetworkStatusEngine( this );

			iNetworkStatusEngine->ConstructL();

			iNetworkStatusEngine->NotifyL();

		}

       }

	iPreemptRequest = 0; 

	iServerContentEncoding = ExptNone;

	iServerAcceptEncoding = ExptNone;

	iSession = ESyncMLSessionUnknown;

    RProperty::Get( KPSUidNSmlSOSServerKey, KNSmlSyncJobOngoing, iSession);                       

	// construct dialup agent

	iDialUpAgent = new (ELeave) CNSmlDialUpAgent();

	iDialUpAgent->ConstructL();

	iEngineState = ExptIdle;

	iTimeOut = EFalse;

	iLastPart = EFalse;

	iAuthRetryCount=0;

	iAuthUsed=0;

	iTransObs = CHttpEventHandler::NewL();

	iTransObs->ConstructL( this );

	iMaxMsgSize = KNSmlDefaultWorkspaceSize;

    if( iSession == ESyncMLDSSession )

        {        

        TInt value(0);

        TRAPD( err, ReadRepositoryL( KNSmlMaxMsgSizeKey, value) );      

        if ( err == KErrNone )

            {

            iMaxMsgSize = value;

            }

        }

	}

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

// CNSmlHTTP::ReadRepositoryL(TInt aKey, TInt& aValue)

// 

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

TInt CNSmlHTTP::ReadRepositoryL(TInt aKey, TInt& aValue)

    {    

    const TUid KRepositoryId = KCRUidNSmlDSEngine;

    CRepository* rep = CRepository::NewLC(KRepositoryId);

    TInt err = rep->Get(aKey, aValue);    

    CleanupStack::PopAndDestroy(rep);

    return err;

    }

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

// CNSmlHTTP::~CNSmlHTTP()

// desctructor

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

//

CNSmlHTTP::~CNSmlHTTP() 

	{

DBG_FILE(_S8("CNSmlHTTP::~CNSmlHTTP() BEGIN"));

if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))

{

	DeleteCertificate(); 

}

	Cancel();

	delete iData;

	delete iReqBodySubmitBuffer;

	delete iURI;

	delete iMimeType;

	delete iHTTPusername;	

	delete iHTTPpassword;	

	delete iShutdown;

	iShutdown = NULL;

	if(iNetworkStatusEngine)

	{

		delete iNetworkStatusEngine;

		iNetworkStatusEngine = NULL;

	}

	iSess.Close();

	delete iTransObs;

	delete iDialUpAgent;

    delete iIAPidArray;

    FeatureManager::UnInitializeLib();

    DBG_FILE(_S8("CNSmlHTTP::~CNSmlHTTP() END"));

	}

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

// CNSmlHTTP::DoCancel()

// DoCancel() from CActive

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

//

void CNSmlHTTP::DoCancel() 

	{DBG_FILE(_S8("CNSmlHTTP::DoCancel() BEGIN"));

	iEngineState = ExptIdle;

	TInt cancelReason;

	iShutdown->Cancel();

	iDialUpAgent->Cancel();

	iSess.Close();

	if( iTimeOut )

		{DBG_FILE(_S8("CNSmlHTTP::DoCancel() timing out"));

		cancelReason = TNSmlHTTPErrCode::ENSmlHTTPErr_RequestTimeout;

		}

	else

		{

		cancelReason = KErrCancel;

		}

	// signal current (engine) thread request semaphore that this AO's 

	// request has completed

	TRequestStatus* status = &iStatus;		

	User::RequestComplete( status, cancelReason );

	// signal agent

	TRequestStatus* agentStatus = iAgentStatus;

	User::RequestComplete( agentStatus, cancelReason );

	DBG_FILE(_S8("CNSmlHTTP::DoCancel() END"));

	}

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

// CNSmlHTTP::CompleteRequest()

// called when asynchronous request should be completed with a purpose

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

//

void CNSmlHTTP::CompleteRequest()

{

	DBG_FILE(_S8("CNSmlHTTP::CompleteRequest BEGIN"));

		if(IsActive())

		{

		DBG_FILE(_S8("CNSmlHTTP::CompleteRequest iTrans.Cancel();"));

		iTrans.Cancel();

		DBG_FILE(_S8("CNSmlHTTP::CompleteRequest iTrans.Close();"));

		iTrans.Close();

		DBG_FILE(_S8("CNSmlHTTP::CompleteRequest isActive returned TRUE  "));

		iPreemptRequest++;

		DBG_FILE_CODE( iPreemptRequest, _S8("Increasing value of iPreemptRequest ") );

				TRequestStatus* status = &iStatus;

		User::RequestComplete( status, KErrTimedOut );

		}

	DBG_FILE(_S8("CNSmlHTTP::CompleteRequest ENDS "));

}

// CNSmlHTTP::RunL()

// Runl() from CActive

// called when asynchronous request completed

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

//

void CNSmlHTTP::RunL() 

	{

	DBG_FILE(_S8("CNSmlHTTP::RunL begins"));

	DBG_FILE_CODE( iEngineState, _S8("RunL iEgnineStatus is : ") );

	DBG_FILE_CODE( iStatus.Int(), _S8("RunL httpClient status is : ") );

	if(iEngineState == ExptOpenCommunication)

		{

		DBG_FILE(_S8("CNSmlHTTP::RunL before SetHttpConnectionInfoL"));

		DBG_FILE_CODE( iStatus.Int(), _S8("RunL HTTP client iStatus: ") );

		if( iStatus == KErrNone) 

			{  

			DBG_FILE(_S8("CNSmlHTTP::RunL Status was NO ERROR"));

			TRAPD( ret, SetHttpConnectionInfoL( EFalse ) );

			if ( ret != KErrNone )

				{

				DBG_FILE_CODE( ret, _S8("CNSmlHTTP::RunL SetHttpConnectionInfoL\

				 error:") );

				iShutdown->Cancel();

				TRequestStatus* status = iAgentStatus;

				User::RequestComplete( status, ret );

				iTimeOut = EFalse;

				return;

				}

			}

		DBG_FILE(_S8("CNSmlHTTP::RunL after SetHttpConnectionInfoL"));

		}

	iShutdown->Cancel();

	TRequestStatus* status = iAgentStatus;

	User::RequestComplete( status, iStatus.Int() );

	iTimeOut = EFalse;

	DBG_FILE(_S8("CNSmlHTTP::RunL ends"));

	}

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

// CNSmlHTTP::OpenCommunicationL

// Establishes a communication using the protocol service with the given ID.

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

//

void CNSmlHTTP::OpenCommunicationL( 

    CArrayFixFlat<TUint32>* aIAPidArray, 

    TDesC8& aURI, 

    TDesC8& aMimeType, 

    TRequestStatus &aStatus, 

    TDesC8& aHTTPusername, 

    TDesC8& aHTTPpassword, 

    TInt aHTTPauthused )

	{

	__ASSERT_ALWAYS( !IsActive(), User::Panic( _L("CNSmlHTTP"), 1 ) );

	if ( !iShutdown->IsActive() )

	    {

    	iShutdown->Start();    

	    }

	iAgentStatus = &aStatus;

	iEngineState = ExptOpenCommunication;

    iIAPidArray = new ( ELeave ) CArrayFixFlat<TUint32>(KSmlArrayGranularity);

    for ( TInt i = 0 ; i < aIAPidArray->Count() ; i++ )

        {

        iIAPidArray->AppendL( aIAPidArray->At( i ) );

        }

	iAuthUsed = aHTTPauthused;	

	// Open the RHTTPSession

	iSess.OpenL();

	// Install this class as the callback for authentication requests

	if( iAuthUsed ) 

		{

		InstallAuthenticationL(iSess);

		}

	delete iURI;

	iURI = NULL;

	iURI = HBufC8::NewL( aURI.Length() );

	TPtr8 iURIptr( iURI->Des() );

	iURIptr.Copy( aURI );

	delete iMimeType;

	iMimeType = NULL;

	iMimeType = HBufC8::NewL( aMimeType.Length() );

	TPtr8 iMIMEptr( iMimeType->Des() );

	iMIMEptr.Copy( aMimeType );

	delete iHTTPusername;

	iHTTPusername = NULL;

	if(aHTTPusername.Length()!=0)

		{

		iHTTPusername = HBufC8::NewL( aHTTPusername.Length() );

		TPtr8 iHTTPusernameptr( iHTTPusername->Des() );

		iHTTPusernameptr.Copy( aHTTPusername );

		}

	else

		{

		iHTTPusername = KNullDesC8().AllocL();

		}

	delete iHTTPpassword;

	iHTTPpassword = NULL;

	if(aHTTPpassword.Length()!=0)

		{

		iHTTPpassword = HBufC8::NewL( aHTTPpassword.Length() );

		TPtr8 iHTTPpasswordptr( iHTTPpassword->Des() );

		iHTTPpasswordptr.Copy( aHTTPpassword );

		}

	else

		{

		iHTTPpassword = KNullDesC8().AllocL();

		}

	TRAPD( err, ProcessRequestL() );

	User::LeaveIfError( err );

	}

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

// CNSmlHTTP::CloseCommunicationL( TRequestStatus &aStatus )

// Closes a previously opened communication.

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

//

void CNSmlHTTP::CloseCommunicationL( TRequestStatus &aStatus )

	{

	__ASSERT_ALWAYS( !IsActive(), User::Panic( _L("CNSmlHTTP"), 1 ) );

	iAgentStatus = &aStatus;

	iEngineState = ExptCloseCommunication;

	TRAPD( err, ProcessRequestL() );

	User::LeaveIfError( err );

	}

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

// CNSmlHTTP::ReceiveDataL

// Read data across a connection.

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

//

void CNSmlHTTP::ReceiveDataL( TDes8& aStartPtr, TRequestStatus &aStatus )

	{

	__ASSERT_ALWAYS( !IsActive(), User::Panic( _L("CNSmlHTTP"), 1 ) );

	iAgentStatus = &aStatus;

	if ( !iShutdown->IsActive() )

	    {

    	iShutdown->Start();    

	    }

	iEngineState = ExptReceiveData;

	GetResponseBodyL( aStartPtr );

	DBG_DUMP((void*)aStartPtr.Ptr(), aStartPtr.Length(), 

	_S8("ReceiveDataL (WBXML)"));

#ifdef __NSML_DEBUG__

	_DBG_FILE("CNSmlHTTP::ReceiveDataL(): CWbxml2XmlConverter::ConvertL()\

	 begin");

	CWbxml2XmlConverter* c = CWbxml2XmlConverter::NewLC();

	c->ConvertL(aStartPtr.Ptr(), aStartPtr.Length());

	DBG_DUMP((void*)c->Document().Ptr(), c->Document().Length(), 

	_S8("ReceiveDataL (XML)") );

	CleanupStack::PopAndDestroy(); // c

	_DBG_FILE("CNSmlHTTP::ReceiveDataL(): CWbxml2XmlConverter::ConvertL() end");

#endif // __NSML_DEBUG__

	TRAPD( err, ProcessRequestL() );

	User::LeaveIfError( err );

	}

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

// CNSmlHTTP::DeleteCertificate()

// Delete HTTP connection certificate.

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

//

void CNSmlHTTP::DeleteCertificate( )

	{

	if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))

		{

		}

		else

	{

	CRepository *re = NULL;

	TRAPD( erx, re = CRepository::NewL ( 

	        KCRUidPolicyManagementUtilInternalKeys ) );

	if (erx == KErrNone )

		{

		re->Reset( KSyncMLSessionCertificate );

		delete re;

		re = NULL;

		}

	else

		{

		DBG_ARGS8(_S8("ERROR Failed to delete reposiritry key %d"), erx );

		}

	}

}

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

// CNSmlHTTP::SaveCertificateL( RHTTPTransaction &aTransaction )

// save HTTP connection certificate.

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

//

void CNSmlHTTP::SaveCertificateL( RHTTPTransaction &aTransaction )

	{

		if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))

		{

			User::Leave(KErrNotSupported);

		}

	TCertInfo info ;

	TInt errx( aTransaction.ServerCert( info ) );

	if ( errx == KErrNone )

		{

		CRepository *re = NULL;

		TRAPD( erx, re = CRepository::NewL ( 

		            KCRUidPolicyManagementUtilInternalKeys ) );

		if (erx == KErrNone )

			{

			TPckg<TCertInfo> pcert( info );

			errx = re->Create( KSyncMLSessionCertificate, pcert ) ;

			if ( errx == KErrNone )

				{

				DBG_ARGS8(_S8("Wrote reposotry key %S"), &pcert );

				}

			else

				{

				if ( errx == KErrAlreadyExists )

					{

					errx = re->Set( KSyncMLSessionCertificate, pcert ) ;

					if ( errx != KErrNone )

						{

						DBG_ARGS8( _S8("ERROR Failed to add reposiritry \

						key %d"), errx );

						}

					}

				else

					{

					DBG_ARGS8( _S8("ERROR Failed to create reposiritry \

					key %d"), errx );	

					}

				}	

			delete re ;

			re = NULL;

			}

		else

			{

			DBG_ARGS8(_S8("ERROR Failed to open reposiritry %d"), erx );	

			}

		}

	else

		{

		DBG_ARGS8(_S8("ERROR Failed to get certificate %d"), errx );	

		}

	}

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

// CNSmlHTTP::CompressL

// Compress the data.

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

//

void CNSmlHTTP::CompressL(TDesC8& aStartPtr)

    {   

    HBufC8* tempBufferPtr = HBufC8::NewLC(iMaxMsgSize);

    TPtr8 unCompressed( tempBufferPtr->Des());

    unCompressed.Copy( aStartPtr );        

    iReqBodySubmitBuffer = NULL;

    iReqBodySubmitBuffer = HBufC8::NewMaxL( iMaxMsgSize );

    iReqBodySubmitBufferPtr.Set( iReqBodySubmitBuffer->Des() );

    TRAPD(err, CEZCompressor::CompressL(iReqBodySubmitBufferPtr, unCompressed, Z_BEST_COMPRESSION));

    CleanupStack::PopAndDestroy();

    if(err == KErrNone)