// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// please do not delete

// 

//

/**

 @file CProtocolHandler.h

 @warning : This file contains Rose Model ID comments 

*/

#ifndef __CPROTOCOLHANDLER_H__

#define __CPROTOCOLHANDLER_H__

// System includes

#include <e32base.h>

#include <http/framework/httplogger.h>

#include <http/mhttpfilter.h>

#include <http/rhttpsession.h>

// Forward declarations

class CHeaderCodec;

class CProtTransaction;

class CSecurityPolicy;

class MProtHandlerInterface;

/**

The ECom protocol handler plugin interface UID.

@publishedAll

@released

*/

const TUid KUidProtocolHandlerPluginInterface = {0x1000A449};

// 

/**

Defined active object priorities for the Protocol Handler

@publishedAll

@released

*/

const TInt KProtocolHandlerActivePriority = CActive::EPriorityStandard;

/**

Defined active object priorities for the Transaction

@publishedAll

@released

*/

const TInt KTransactionActivePriority = KProtocolHandlerActivePriority+1;

//##ModelId=3C4C186A02A3

class CProtocolHandler : public CActive, public MHTTPFilter

/**

An abstract protocol handler.  Protocol handlers are required to

act as the bridge between abstract representations of sessions, transactions and

headers (the client side of the HTTP architecture) and specific comms transports

(the network side of the architecture).

Each instance of a concrete subclass of CProtocolHandler is associated

with a specific	client session, and hence with a particular choice of proxy type,

and by implication, transport type.  It is designed to appear like a filter in

order to be placed at the end of a session's filter queue.  This allows it to 

receive transaction-related events in the same way that any other filter

(or indeed, the client) does.  An active object, it may implement a queuing

system for submitted transactions, according to the chosen internal service

model.

In order to divide the abstract functionality associated with handling the HTTP

protocol handler from the specifics needed for a particular choice of transport,

this class defines a number of pure virtual methods which allow it to defer

transport-specific choices or mechamisms.  These are mainly concerned with the

service model (ie. allocation of transactions to objects that can handle them), the

codec model (ie. on-demand encoding/decoding of	HTTP header data) and general

housekeeping (eg. instantiation and cleanup of objects at particular points in

a transaction lifecycle).

@publishedAll

@released

*/

	{

public:	// Methods

/**	

	Standard factory constructor. This is the ECOM interface class from

	which concrete protocol handlers are derived. The method queries

	ECOM for the protocol handler plugin that matches the protocol

	description passed in.

	@param			aProtocol	(in) The name of the protocol required.

	@param			aSession	(in) The HTTP session on which this protocol handler

									 will be installed.

	@leave			KErrNoMemory if there was not enough memory to create the object.

*/

	//##ModelId=3C4C186B007E

	static CProtocolHandler* NewL(const TDesC8& aProtocol, RHTTPSession aSession);

/**	

	Intended Usage:	Class destructor.

*/

	//##ModelId=3C4C186B0075

	IMPORT_C virtual ~CProtocolHandler();

/**	

	Obtain the protocol handler's header codec.

	@return			The header codec owned by this protocol handler, or NULL if one

					has not yet been created.

	@see CHeaderCodec

*/

	//##ModelId=3C4C186B0074

	IMPORT_C CHeaderCodec* Codec() const;

/** 

	Get the Server Certificate for the current session.

	@return	The certificate information or NULL if it is not available

*/

	IMPORT_C const CCertificate* SessionServerCert();

/** 

	Get the Server Certificate for the specified transaction.

	@param	aTransaction The transaction for which the certificate is requested

	@return	The certificate information or NULL if it is not available

*/

	IMPORT_C const CCertificate* TransactionServerCert( RHTTPTransaction aTransaction);

public:	// Methods to be implemented in specific protocol handlers

/** 

	Intended Usage:	Get the Server Certificate for the current session.

	@param	aServerCert A TCertInfo which will be filled with the certificate information

	@return	An error code.  KErrNone if aServerCert has been completed, otherwise one of 

	the system wide error codes

*/

	virtual TInt SessionServerCert(TCertInfo& aServerCert) = 0;

/** 

	Intended Usage:	Get the Server Certificate for the specified transaction.

	@param	aServerCert A TCertInfo which will be filled with the certificate information

	@param	aTransaction The transaction for which the certificate is requested

	@return	An error code.  KErrNone if aServerCert has been completed, otherwise one of 

			the system wide error codes

*/

	virtual TInt TransactionServerCert(TCertInfo& aServerCert, RHTTPTransaction aTransaction) = 0;

public:	// Methods from MHTTPFilterBase

/**

	Intended Usage:	Called when the filter's registration conditions are satisfied for events that

	occur on a transaction. Any Leaves must be handled by the appropriate MHFRunError.

	Note that this function is not allowed to leave if called with certain events. 

	@see THTTPEvent

	@param aTransaction The transaction that the event has occurred on.

	@param aEvent aEvent The event that has occurred.

	@leave Standard Symbian OS error codes. e.g. KErrNoMemory.

	@see MHTTPFilterBase	

*/

	//##ModelId=3C4C186B0061

	IMPORT_C virtual void MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

/**

	Intended Usage:	Called when the filters registration conditions are satisfied for events that occur

	on the session. Any leaves must be handled by the appropriate MHFRunError.

	@param aEvent The session event that has occured.

	@leave KErrNoMemory if an attempt to allocate memory has failed

	@leave KErrHttpCantResetRequestBody if the request body needed to be rewound by the client

		   but it doesn't support this

	@see MHTTPFilterBase

*/

	//##ModelId=3C4C186B0057

	IMPORT_C virtual void MHFSessionRunL(const THTTPSessionEvent& aEvent);

/**

	Intended Usage:	Called when RunL leaves from a transaction event. This works in the same

	way as CActve::RunError; return KErrNone if you have handled the error.

	If you don't completely handle the error, a panic will occur.

	@param aError The leave code that RunL left with.

	@param aTransaction The transaction that was being processed.

	@param aEvent The Event that was being processed.

	@return KErrNone if the error has been cancelled or the code

			of the continuing error otherwise.

	@see MHTTPFilterBase

*/

	//##ModelId=3C4C186B0043

	IMPORT_C virtual TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

/**

	Intended Usage:	Called when MHFRunL leaves from a session event. This works in the same

	way as CActve::RunError. If you don't completely handle the error, a panic will occur.

	@param aError The leave code that RunL left with.

	@param aEvent The Event that was being processed.

	@return KErrNone if the error has been cancelled or the code

			of the continuing error otherwise.	

	@see MHTTPFilterBase

*/

	//##ModelId=3C4C186B0038	

	IMPORT_C virtual TInt MHFSessionRunError(TInt aError, const THTTPSessionEvent& aEvent);

public:	// Methods from MHTTPFilter

/** 

	Intended Usage:	Called when the filter is being removed from a session's filter queue.

	@param aSession The session it's being removed from

	@param aHandle The filter handle. Complex filters may need to 

				   refer to this to keep track of which particular registration is

				   being unloaded.

	@see MHTTFilter

*/

	//##ModelId=3C4C186B0025

	IMPORT_C virtual void MHFUnload(RHTTPSession aSession, THTTPFilterHandle aHandle);

/** 

	Intended Usage:	Called when the filter is being added to the session's filter queue.

	@param aSession The session it's being added to.

	@param aHandle The filter handle. Complex filters may need to keep

				   track of this, for instance if generating events in response to

				   external stimuli

	@see MHTTFilter

 */

	//##ModelId=3C4C186B001A

	IMPORT_C virtual void MHFLoad(RHTTPSession aSession, THTTPFilterHandle aHandle);

protected: // callbacks/methods for sub-classes

/**	

	Callback method for concrete protocol handler sub-classes to

	inform the base protocol handler that a transaction has completed.

	The concrete protocol handler must call this method in order to

	supply a completion event that will be sent to the client.

	In addition, the method allows the base protocol handler to do some

	queue management.

	@param			aTrans			(in) the completed transaction

	@param			aEventStatus	(in) an event to be sent back to the client along

										 the filter queue

	@leave			THTTPPanic::EInvalidFilterHandle if unable to send event.

 */

	//##ModelId=3C4C186B0010

	IMPORT_C void TransactionCompletedL(RHTTPTransaction aTrans, THTTPEvent aEventStatus);

/**	

	Obtain the number of currently active transactions

	@return			The number of currently active transactions

 */

	//##ModelId=3C4C186B0006

	IMPORT_C TInt NumActiveTransactions() const;

/**	

	Callback method for concrete protocol handler sub-classes to

	inform the base protocol handler that a transaction has failed

	utterly. (i.e. the sub-class used aTrans.Fail().) The base protocol

	handler sets the transaction state to be cancelled.

	@param			aTrans			(in) the completed transaction

 */

	//##ModelId=3C4C186A03E5

	IMPORT_C void TransactionFailed(RHTTPTransaction aTrans);

/**	

	Completes this active object - allows the protocol handler to

	reevaluate the queue of pending transactions and service new ones

	if possible.

 */

	//##ModelId=3C4C186A03E4

	IMPORT_C void CompleteSelf();

/**	

	Searches the array of CProtTransaction objects to if the

	aTransaction object is wrapped by one of them. If one is found aProtTransaction is set to it

	@param aTransaction	The transaction to search for.

	@param aProtTransaction	Reference to a CProtTransaction which will be set to the

		   CProtTransaction which wraps the RHTTPTransaction.

	@return If a CProtTransaction object is found, a positive value is

			returned that is the index to that object in the array. If 

			no object is found, KErrNotFound is returned.

 */

	IMPORT_C TInt FindTransaction(RHTTPTransaction aTransaction, const CProtTransaction*& aProtTransaction) const;

private: // methods to be implemented in specific protocol handlers

/**	Intended usage:	Creates the specific type of codec required for a specific type

					of protocol handler.

					This must be implemented by a concrete protocol handler sub-class.

 */

	//##ModelId=3C4C186A03DC

	virtual void CreateCodecL() = 0;

/**	Intended Usage:	Creates a representation of a client transaction to be used in the

					protocol handler.  Since the protocol handler deals with the low-

					level data for a transaction as sent over a particular transport,

					an appropriate CProtTransaction-derived class is used that owns a

					CRxData and a CTxData to handle the low-level data.

					This must be implemented by a concrete protocol handler sub-class.

	@leave			KErrNoMemory if there was not enough memory to create the object.

					create the object.

	@param			aTransaction	The RHTTPTransaction object associated with

									this CProtTransaction object.

	@return			A pointer to a created CProtTransaction-derived class.

	@see			CRxData

	@see			CTxData

 */

	//##ModelId=3C4C186A03DA

	virtual CProtTransaction* CreateProtTransactionL(RHTTPTransaction aTransaction) = 0;

/**	Intended Usage:	Attempt to service the transaction.  This implies that the concrete

					protocol handler will allocate some transport resources to the

					transaction - which could fail if the protocol handler has hit an

					internal limit of resources or bandwidth.

					Implementations of this interface may leave with any of KErrHttpInvalidUri,

					KErrGeneral, KErrNoMemory

					This must be implemented by a concrete protocol handler sub-class.

	@param			aTrans	The pending protocol transaction object which is to be

							serviced.

	@return			A flag that indicates if the transaction can be serviced immediately.

 */

	//##ModelId=3C4C186A03D0

	virtual TBool ServiceL(CProtTransaction& aTrans) = 0;

/**	Intended Usage:	Called when the RHTTPTransaction object corresponding to aTrans has

					been closed by the client. This allows the concrete protocol handler

					to do any cleanup required for this particular transaction.

					Ownership of the CProtTransaction object is transferred back to the

					concrete protocol handler, which then has deletion responsibility

					for it.  By the time this function has been called, the base

					protocol handler will have dequeued the transaction.

					The client's RHTTPTransaction will be closed when this function

					returns,  so it is not possible to send events to the client during

					the function's execution.

					This must be implemented by a concrete protocol handler sub-class.

	@param			aTrans		(in) A pointer to the transaction about to be closed.

 */

	//##ModelId=3C4C186A03C6

	virtual void ClosedTransactionHook(CProtTransaction* aTrans) = 0;

/**	Intended Usage:	Called when the RHTTPTransaction object corresponding to aTrans has

					been cancelled by the client or an intermediate filter. This allows

					the concrete protocol handler to do any cleanup and to perform the

					necessary actions for cancellation on its transport layer.

					This must be implemented by a concrete protocol handler sub-class.

	@param			aTrans		(in) A reference to the transaction being cancelled.

 */

	//##ModelId=3C4C186A03B3

	virtual void CancelTransactionHook(CProtTransaction& aTransaction) = 0;

/**	Intended Usage:	Called to notify the concrete protocol handler that new request

					body data is available for transmission.

					This must be implemented by a concrete protocol handler sub-class.

	@param			aTrans		(in) A reference to the transaction whose request body

									 has new data available.

 */

	//##ModelId=3C4C186A03A8

	virtual void NotifyNewRequestBodyPart(CProtTransaction& aTransaction) = 0;

protected: // Methods inherited from CActive

/**	Intended Usage:	Do some processing when a previous asynchronous request made by

					this object has completed.

 */

	//##ModelId=3C4C186A0377

	IMPORT_C virtual void RunL();

/**	Intended Usage:	Do any cleanup required should RunL leave

	@param			aError		(in) The error code that RunL left with

	@return			A final error code - KErrNone if the error was handled by this

					method.

 */

	//##ModelId=3C4C186A036E

	IMPORT_C virtual TInt RunError(TInt aError);

/**	Intended Usage:	Cancel outstanding asynchronous requests that this object has made

 */

	//##ModelId=3C4C186A036D

	IMPORT_C virtual void DoCancel();

protected:	// Methods

/**	

	Constructs a protocol handler associated with the supplied HTTP

	client session.

	@param			aSession	(in) The session on which the new protocol handler will

									 be installed.

 */

	IMPORT_C CProtocolHandler(RHTTPSession aSession);

/**	

	Second phase construction in which any necessary allocation is done

	Implementations of this interface may leave with KErrNoMemory

	@param aSession The HTTP session on which this protocol handler

		   will be installed.

 */

	//##ModelId=3C4C186A036C

	IMPORT_C void ConstructL(RHTTPSession aSession);

protected: // Attributes

	/** The session to which this protocol handler is dedicated

	*/

	//##ModelId=3C4C186A033C

	RHTTPSession iSession;

	/** The codec used for this protocol handler (to be specialised in subclasses)

	*/

	//##ModelId=3C4C186A032F

	CHeaderCodec* iCodec;

	/** HTTP logger handle (debug only)

	*/

	__DECLARE_LOG

	/** An interface providing the security policy. This may be NULL if there is no security policy plugin */

	//##ModelId=3C4C186A031D

	CSecurityPolicy* iSecurityPolicy;	

private: // Methods

/**	

	Called after a client RHTTPTransaction::SubmitL(), this method

	enqueues the supplied client transaction.  It checks to see if there

	already exists a CProtTransaction for this transaction. If there is

	and its state is ECancelled, then the associated request data is

	reset and the state changed to EPending. A CompleteSelf() is issued.

	In the case of an existing CProtTransaction that has not been

	cancelled, the submit event is ignored. If no CProtTransaction

	object existed, then one is created for the transaction and a

	CompleteSelf() is issued.

	@leave			KErrHttpCantResetRequestBody if the request body data cannot

					be reset. KErrNoMemory if a new CProtTransaction cannot be

					created or added to the transaction queue.

	@param			aTransaction	The submitted transaction.

	@pre 			None

	@post			If there is a new pending CProtTransaction object the protocol

					handler will have been self-completed (i.e. the RunL will be 

					called).

 */

	//##ModelId=3C4C186A0362

	void SubmitTransactionL(RHTTPTransaction aTransaction);

/**	

	Sets the state of the CProtTransaction object for this 

	transaction to ECancelled, and resets the object. This

	object can be reused if the transaction is resubmitted.

	@param			RHTTPTransaction aTrans

	@pre 			A CProtTransaction object exists for this transaction.

	@post			The state of the CProtTransaction object is set to ECancelled 

					and it has been reset.

 */

	//##ModelId=3C4C186A0359

	void HandleCancelTransaction(RHTTPTransaction aTrans);

/**	

	Removes the CProtTransaction object for the transaction

	from the queue of CProtTransaction objects.

	@param			RHTTPTransaction aTrans

	@pre 			A CProtTransaction object exists for this transaction.

	@post			The CProtTransaction object has been removed from the queue.

 */

	//##ModelId=3C4C186A034F

	void HandleClosedTransaction(RHTTPTransaction aTrans);

/**	

	Searches the array of CProtTransaction objects to if the

	aTransaction object is wrapped by one of them.

	@param			aTransaction	The transaction to search for.

	@return			If a CProtTransaction object is found, a positive value is

					returned that is the index to that object in the array. If 

					no object is found, KErrNotFound is returned.

 */

	//##ModelId=3C4C186A0346

	TInt FindTransaction(RHTTPTransaction aTransaction) const;

protected:

/**	

	Intended Usage: This is a mechanism for allowing future change to CProtocolHandler API 

	without breaking BC.

	@param aInterfaceId		the UID of the API function being called.

	@param aInterfacePtr	reference to pointer to actual function implementation (in the derived class)

 */

	inline virtual void GetInterfaceL(TUid aInterfaceId, MProtHandlerInterface*& aInterfacePtr);

public:

/**	Intended Usage:	Reserve a slot in the v-table to preserve future BC

 */

	//##ModelId=3C4C186A0344

	inline virtual void Reserved2();

private: // Attributes

	/** A list of transactions. Each transaction has a list state, e.g. pending,

		active, etc.

	*/

	//##ModelId=3C4C186A0313

	RPointerArray<CProtTransaction>		iTransactions;

	/**	The transaction which is currently being serviced - used in RunError so 

		we know which transaction caused RunL to leave.

	*/

	//##ModelId=3C4C186A02FF

	RHTTPTransaction					iCurrentTransaction;

	/** The destructor key UID indentification required by ECom

	*/

	//##ModelId=3C4C186A02F5

	TUid iDtor_ID_Key;

	};

/**

Interface for adding to ProtocolHandler API

@publishedAll

@released

*/

const TInt KProtHandlerSessionServerCertUid		= 0x1028180D;

const TInt KProtHandlerTransactionServerCertUid	= 0x1028180E;

class MProtHandlerInterface

	{

public:

	/** 

	Intended Usage: Get the Server Certificate for the current session.

	@return	The certificate information or NULL if it is not available

	*/

	virtual const CCertificate*  SessionServerCert() = 0;

	/** 

	Intended Usage: Get the Server Certificate for the specified transaction.

	@param	aTransaction The transaction for which the certificate is requested

	@return	The certificate information or NULL if it is not available

	*/

	virtual const CCertificate* TransactionServerCert( RHTTPTransaction aTransaction) = 0;

	};

inline void CProtocolHandler::GetInterfaceL(TUid, MProtHandlerInterface*&)

	{}

inline void CProtocolHandler::Reserved2()

	{}

#endif // __CPROTOCOLHANDLER_H__