/**

* 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:

* SSL3.0 and TLS1.0 Handshake negotiation header file.

* This file describes the Handshake negotiation state machine.

* 

*

*/

/**

 @file TlsHandshake.h

*/

#ifndef _TLSHANDSHAKE_H_

#define _TLSHANDSHAKE_H_

#include <x509cert.h>

#include <comms-infras/statemachine.h>

#include "LOGFILE.H"

#include <tlstypedef.h>

// History of the Handshake negotiation (i.e. events that have occured).

enum ETlsHandshakeHistory {

	ETlsHandshakeStart = 0,					/** Start of handshake negotiation */

	ETlsClientHelloSent = 0x0001,			/** Client Hello has been sent */

	ETlsServerHelloRecv = 0x0002,			/** Server Hello has been received */

	ETlsServerCertificateRecv = 0x0004,		/** Server Certificate has been received */

	ETlsServerKeyExchRecv = 0x0008,			/** Server Key Exchange has been received */

	ETlsCertificateReqRecv = 0x0010,			/** Certificate Request has been received */

	ETlsServerHelloDoneRecv = 0x0020,		/** Server Hello Done has been received */

	ETlsClientCertificateSent = 0x0040,		/** Client Certificate has been sent */

	ETlsClientKeyExchSent = 0x0080,			/** Client Key Exchange has been sent */

	ETlsCertificateVerifySent = 0x0100,		/** Certificate Verify has been sent */

	ETlsFinishedSent = 0x0200,				/** Client Finished has been sent */

	ETlsFinishedRecv = 0x0400,				/** Server Finished has been received */

	ETlsChangeCipherSent = 0x0800,			/** Change CipherSpec has been sent */

	ETlsChangeCipherRecv = 0x1000,			/** Change CipherSpec has been received */

	ETlsFullHandshake = 0x2000,				/** Full Handshake negotiation */

	ETlsAbbreviatedHandshake = 0x4000,		/** Abbreviated handshake negotiation */

	ETlsUsingPskKeyExchange = 0x8000		/** Using PSK for the key exchange */

};

const TInt8 KNullSessionId = 0;				// Zero value session id. 

class CTlsConnection;

class CTlsEvent;

class CSHA1;  

class CMD5;

class CSendAlert;

class CTLSSession;

class CHandshake : public CStateMachine

/** 

 * @class This class describes a state machine which handles SSL3.0/TLS1.0

 * handshake negotiations.

 */

{

public:

	static CHandshake* NewL( CTlsConnection& aTlsConnection ); 

	~CHandshake();

	void StartL( TRequestStatus* aClientStatus, MStateMachineNotify* aStateMachineNotify );

	CTlsEvent* InitiateReceiveL();

	CTlsEvent* InitiateTransmitL();

	void UpdateVerify( TDesC8& aMessage );

	CSHA1* SHA1Verify() const;

	CMD5*  MD5Verify() const;

	CSendAlert* SendAlert() const;

	TPtr8& ComposeMsg();

	TBool SessionReUse() const;

	CX509Certificate*& ServerCert();

	TAlgorithmId& SignatureAlg();

	void SetCertificateVerifyReqd( TBool aCertVerify );

	TBool CertificateVerifyReqd() const;

	void SetNegotiatedVersion( const TTLSProtocolVersion* aTlsVersion );

	TSglQue<CTlsEvent>& TxMessageList();

	void DestroyTxList();

	void AddToList( CTlsEvent& aMsgItem);

   void GetServerAddrInfo( TTLSServerAddr& serverInfo );

   void ResetCryptoAttributes();

   CTLSSession*& TlsSession();

   CTlsEvent* NextTxEvent();       //fetches the next event from the Tx queue and shifts

                                    //the queue iterator one element up

	void Cancel(TInt aLastError);

protected:

	CHandshake( CTlsConnection& aTlsConnection );

	void ConstructL( CTlsConnection& aTlsConnection );

	virtual void DoCancel();

protected:

	CTlsConnection& iTlsConnection;		// Reference to the TlsConnection object that's negotiating a handshake

	CSHA1* iSHA1Verify;					// SHA1 hash object, used to hash the handshake messages

	CMD5*  iMD5Verify;					// MD5 hash object, used to hash the handshake messages

public:

	TSglQue<CTlsEvent> iTransmitList;	// List of events (messages) to transmit

protected:

	TSglQueIter<CTlsEvent> iTxListIter;	// List iterator

	CSendAlert* iSendAlert;				// Pointer to a 'Send Alert' object

public:

	TPtr8 iComposeMsg;					// Pointer to a state machine fragment passed to a record composer object

	CX509Certificate* iServerCert;		// Server certificate. Used to process ServerKeyExchange message

	TAlgorithmId iSigAlg;				// Signature algorithm. Used to process the CertificateVerify message.

protected:

	TBool iCertVerify;					// Boolean value indicating whether the CertificateVerify message should be sent.

};

// Inline methods

inline CHandshake::CHandshake(CTlsConnection& aTlsConnection) :

   iTlsConnection(aTlsConnection),

   iTransmitList( CTlsEvent::TxOffset() ),

   iTxListIter( iTransmitList ),

   iComposeMsg(NULL, 0),

   iCertVerify(EFalse)

/**

 * Constructor. 

 * This method does the following:

 * 1 - Initialise a reference to the secure connection object.

 * 2 - Initialise iComposeMsg, the pointer descriptor used to access the data 

 *	   in the state machine's heap descriptor object, to NULL

 * 3 - Set the history of the negotiation, iHistory to the start. This object 

 *     keeps track of the negotiation and which messages have been sent or 

	   received thus far.

 */

{

	LOG(Log::Printf(_L("CHandshake::CHandshake()\n"));)

	iHistory = ETlsHandshakeStart; 

}

inline CTlsEvent* CHandshake::NextTxEvent()

{

   return iTxListIter++;

}

inline TPtr8& CHandshake::ComposeMsg()

/** 

 * This method returns a pointer descriptor (to the state machine's data fragment)

 */

{

	LOG(Log::Printf(_L("CHandshake::ComposeMsg()\n"));)

    return iComposeMsg;

}

inline CX509Certificate*& CHandshake::ServerCert()

/** 

 * This method returns a reference to the Server's certificate

 */

{

	LOG(Log::Printf(_L("CHandshake::ServerCert()\n"));)

    return iServerCert;

}

inline TAlgorithmId& CHandshake::SignatureAlg()

/** 

 * This method returns a reference to the Key exchange algorithm.

 */

{

	LOG(Log::Printf(_L("CHandshake::SignatureAlg()\n"));)

    return iSigAlg;

}

inline void CHandshake::SetCertificateVerifyReqd( TBool aCertVerify )

{

   iCertVerify = aCertVerify;

}

inline TBool CHandshake::CertificateVerifyReqd() const

/** 

 * This method returns a reference to a boolean which indicates whether the Certificate

 * Verify message should be sent.

 */

{

	LOG(Log::Printf(_L("CHandshake::CertificateVerifyReqd()\n"));)

    return iCertVerify;

}

inline CSendAlert* CHandshake::SendAlert() const

/** 

 * This method returns a pointer to a 'Send Alert' object. It is used when the 

 * handshake state machine has to send an alert.

 */

{

	LOG(Log::Printf(_L("CHandshake::SendAlert()\n"));)

	return iSendAlert;

}

inline CSHA1* CHandshake::SHA1Verify() const

/** 

 * This method returns a pointer to a SHA1 object. This is used to calculate a 

 * SHA hash of messages.

 */

{

	LOG(Log::Printf(_L("CHandshake::SHA1Verify()\n"));)

	return iSHA1Verify;

}

inline CMD5* CHandshake::MD5Verify() const

/** 

 * This method returns a pointer to a MD5 object. This is used to calculate a 

 * MD5 hash of messages.

 */

{

	LOG(Log::Printf(_L("CHandshake::MD5Verify()\n"));)

	return iMD5Verify;

}

inline TSglQue<CTlsEvent>& CHandshake::TxMessageList()

/**

 * This method returns the list header (of the messages to be transmitted).

 */

{

	LOG(Log::Printf(_L("CHandshake::TxMessageList()\n"));)

	return iTransmitList;

}

#endif