/**
* Copyright (c) 2003-2009 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:
* Header file containing classes for transmitted Handshake protocol messages.
* 
*
*/



/**
 @file HandshakeTransmitEvents.h
*/
#include "tlsevent.h"
#include "tlsconnection.h"
#include <tlstypedef.h>

#ifndef _HANDSHAKETRANSMITEVENTS_H_
#define _HANDSHAKETRANSMITEVENTS_H_

class CHandshake;
class CHandshakeHeader;
class CRecordComposer;
class CHandshakeTransmit : public CTlsEvent
/**
 * @class This abstract class describes transmitted SSL3.0 and TLS1.0 Handshake 
 * protocol messages (event classes). It owns the transmitted message.
 */
{
public:
   CHandshakeTransmit( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   ~CHandshakeTransmit();
   CHandshake& Handshake();

   CHandshakeHeader* HandshakeMessage() const;

protected:
   void ComposeHandshakeHeader( TInt aHistoryUpdate, ETlsHandshakeMessage aHandshakeMessage, TDesC8& aDesComposeMsg );

protected:
   CHandshakeHeader* iHandshakeMessage; // Currently processed outgoing message
   CRecordComposer& iRecordComposer;
};

/////////////////////////////////////////////////////////////////////////////////////////////////
/** SSL3.0/TLS1/0 TRANSMITTED MESSAGES **/

enum EClientHelloStates
{
	ETlsGetSessionInfo,				/** Get Session information */
	ETlsGetCiphers,					/** Get the list of proposed ciphers */
	ETlsComposeHello				/** Compose the Hello message */
};

enum EClientCertificateStates
{
	ETlsGetCertInfo,				/** Get the encoded Client certificate */
	ETlsComposeClientCert			/** Compose the Client certificate message */
};

enum EClientKeyExchangeStates
{
	ETlsGetKeyExchangeMsg,			/** Get the Client key exchange message data */
	ETlsComposeKeyExchange			/** Compose the message. */
};

enum ECertificateVerifyStates
{
	ETlsGetSignature,				/** Get the signed info (signature). */
	ETlsComposeCertVerify			/** Compose the Certificate Verify message */
};

enum EFinishedStates
{
	ETlsGetFinishedMsg,				/** Get the Finished message data */
	ETlsComposeFinished				/** Compose the message. */
};

class CClientHello : public CHandshakeTransmit
/**
 * @class This class is used to process a Client Hello message (transmitted by the protocol).
 */
{
public:
   CClientHello( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   ~CClientHello();
   
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
private:
   EClientHelloStates iClientHelloStates;	// Client Hello states, used to compose the message
   TPtr8 iBody;								// Body of Client Hello message
   RArray<TTLSCipherSuite> iCipherList; //CTlsProvider::CipherSuites returns an array rather than descriptor
};

class CClientKeyExch : public CHandshakeTransmit
/**
 * @class This class is used to process a Client Key Exchange message (transmitted by the protocol).
 */
{
public:
   CClientKeyExch( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
   ~CClientKeyExch();
   
private:
	EClientKeyExchangeStates iClientKeyExcStates;	// Client Key exchange states, used for message composition
	HBufC8* iKeyExchBuf;							// Buffer for the Key exchange message
	TPtr8 iBody;									// Body of Client Key exchange message

};

class CClientCertificate : public CHandshakeTransmit
/**
 * @class This class is used to process a Client Certificate message (transmitted by the protocol).
 * @brief This message is used to authenticate a client.
 */
{
public:
   CClientCertificate( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
   ~CClientCertificate();

private:
   EClientCertificateStates iClientCertStates;	// Client Certificate states, used to compose the message.
   RPointerArray<HBufC8> iCertArray;
};

class CCertificateVerify : public CHandshakeTransmit
/**
 * @class This class is used to process a Client Verify message (transmitted by the protocol).
 */
{
public:
   CCertificateVerify( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   ~CCertificateVerify();
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

private:
	ECertificateVerifyStates iCertVerifyStates;	// Certificate Verify states, used to compose the message.
	HBufC8* iSignature;
};

class CSendFinished : public CHandshakeTransmit
/**
 * @class This class is used to process a Finished message (transmitted by the protocol).
 */
{
public:
   CSendFinished( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer );
   ~CSendFinished();
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

private:
	EFinishedStates iFinishedStates;	// Finished states, used to compose the message.
	HBufC8* iFinishedMsg;				// Buffer for the Finished message
	TPtr8 iBody;						// Body of the Finished message
	CSHA1* iShaHashPtr;					// Copy of SHA1 hash object, used to hash the handshake messages
	CMD5*  iMd5HashPtr;					// Copy of MD5 hash object, used to hash the handshake messages
};

// Inline methods

// CHandshakeTransmit inline methods.
inline CHandshakeTransmit::CHandshakeTransmit( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
   CTlsEvent( &aTlsProvider, &aStateMachine ),
   iRecordComposer( aRecordComposer )
{
}

inline CHandshakeHeader* CHandshakeTransmit::HandshakeMessage() const
{
   return iHandshakeMessage;
}

inline CHandshake& CHandshakeTransmit::Handshake()
/**
 * This method returns a reference to a Handshake negotiation state machine.
 */
{
	return (CHandshake&) *iStateMachine;
}

// CClientHello inline methods
inline CClientHello::CClientHello( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
   CHandshakeTransmit( aTlsProvider, aStateMachine, aRecordComposer ),
   iClientHelloStates( ETlsGetSessionInfo ),
   iBody( NULL, 0 )
{
}

// CClientKeyExch inline methods
inline CClientKeyExch::CClientKeyExch( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
	CHandshakeTransmit( aTlsProvider, aStateMachine, aRecordComposer ),
	iClientKeyExcStates( ETlsGetKeyExchangeMsg ),
	iBody( NULL, 0 )
{
	iKeyExchBuf = NULL;
}

// CClientCertificate inline methods
inline CClientCertificate::CClientCertificate( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
   CHandshakeTransmit( aTlsProvider, aStateMachine, aRecordComposer ),
   iClientCertStates( ETlsGetCertInfo )
{
	   
}

// CCertificateVerify inline methods
inline CCertificateVerify::CCertificateVerify( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
   CHandshakeTransmit( aTlsProvider, aStateMachine, aRecordComposer ),
   iCertVerifyStates( ETlsGetSignature )
{
	iSignature = NULL;
}

// CSendFinished inline methods
inline CSendFinished::CSendFinished( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordComposer& aRecordComposer ) :
   CHandshakeTransmit( aTlsProvider, aStateMachine, aRecordComposer ),
   iFinishedStates( ETlsGetFinishedMsg ),
   iBody ( NULL, 0 ),
   iShaHashPtr ( NULL ),
   iMd5HashPtr ( NULL )	
{
	iFinishedMsg = NULL;
}

#endif