/**
* 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 received Handshake protocol messages.
* Note that the Hello Request message, though a Handshake protocol message,
* is handled separately. 
* 
*
*/



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

#ifndef _HANDSHAKERECEIVEEVENTS_H_
#define _HANDSHAKERECEIVEEVENTS_H_

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

   CHandshake& Handshake(); //MUST NOT be called from CHelloRequest since that 
                           //is processed from CRecvAppData state machine
   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const = 0; // Determines object to accept a Handshake message.
   static TInt RxOffset();

protected:
   CHandshakeHeader* iHandshakeMessage; // Currently processed incoming message
   CRecordParser& iRecordParser;
   TSglQueLink iRxlink;			// Link object (singly linked list of received messages)
};


inline CHandshakeReceive::CHandshakeReceive( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CTlsEvent( &aTlsProvider, &aStateMachine ),
   iRecordParser( aRecordParser )
{
}

inline CHandshake& CHandshakeReceive::Handshake()
{
	return (CHandshake&) *iStateMachine;
}

inline TInt CHandshakeReceive::RxOffset()
{
	return _FOFF(CHandshakeReceive, iRxlink);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
class CHandshakeParser : public CTlsEvent
/**
 * @class This class collects a full handshake message and picks the next event  
 * class (from its list of allowed ones) to process the message.
 */
{
public:
   CHandshakeParser( CStateMachine& aStateMachine, CRecordParser& aRecordParser );
   ~CHandshakeParser();

   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
   virtual TBool AcceptRecord( TInt aRecordType ) const;
   
   TPtr8 Message();
   void SetMessageAsUserDataL( TInt aWaitingFor );
   void DestroyRxList();
   void AddToList( CHandshakeReceive& aRxMsgItem);

   CHandshake& Handshake();

protected:
   TInt ParseHeaderL();		//	Sets iNextEvent to a proper message parser
   CTlsEvent* LookUpEventL( const TUint8 aHandshakeType );
   CAsynchEvent* ProcessNextL( TRequestStatus& aStatus );

protected:
   TSglQue<CHandshakeReceive> iMessageList;		// List of expected Handshake protocol messages to receive
   TSglQueIter<CHandshakeReceive> iRxListIter;	// List iterator
   CRecordParser& iRecordParser;
   HBufC8* iMessage;							// Received handshake message 
   TPtr8 iMessagePtr;							// Pointer to the buffer returned by the Handshake Parser.
   TInt iWaitingFor;							// Number of bytes to read
   TUint8   iMessageType;     //received message type
};


/////////////////////////////////////////////////////////////////////////////////////////////////
/** SSL3.0/TLS1.0 RECEIVED MESSAGES **/

class CServerHello : public CHandshakeReceive
/**
 * @class This class represents a Server Hello message (received by the protocol).
 */
{
public:
   CServerHello( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser );
   ~CServerHello();

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

protected:
   TBool iCipherListRead; //for re-negotiation only due to a very bad TLS provider
   RArray<TTLSCipherSuite> iCipherList; //---------""------------------------
};


class CCertificateReq : public CHandshakeReceive
/**
 * @class This class represents a Certificate Request message (received by the protocol).
 */
{
public:
   CCertificateReq( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& iRecordParser );

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
};


class CServerCertificate : public CHandshakeReceive
/**
 * @class This class represents a Server Certificate message (received by the protocol).
 */
{
public:
   CServerCertificate( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& iRecordParser );

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );
};

class CServerKeyExch : public CHandshakeReceive
/**
 * @class This class represents a Server Key exchange message (received by the protocol).
 */
{
public:
   CServerKeyExch( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser );

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

protected:
   void CreateMessageL( TTLSKeyExchangeAlgorithm aKeyExchange, TAlgorithmId aSignAlgorithm );
};


class CServerHelloDone : public CHandshakeReceive
/**
 * @class This class represents a Server Hello Done message (received by the protocol).
 */
{
public:
   CServerHelloDone( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser );

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

};

class CRecvFinished : public CHandshakeReceive
/**
 * @class This class represents a Finished message from the server (received by the protocol).
 */
{
public:
   CRecvFinished( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser );
   ~CRecvFinished();

   virtual TBool AcceptMessage( const TUint8 aHandshakeType ) const;
   virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

private:
	CSHA1* iShaPtr;					// Copy of SHA1 hash object, used to hash the handshake messages
	CMD5*  iMd5Ptr;					// Copy of MD5 hash object, used to hash the handshake messages
};


// Inline methods - CHandshakeParser
inline CHandshakeParser::CHandshakeParser( CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CTlsEvent( NULL, &aStateMachine ),	
   iMessageList( CHandshakeReceive::RxOffset() ),
   iRxListIter( iMessageList ),
   iRecordParser( aRecordParser ),
   iMessagePtr(NULL, 0),
   iWaitingFor( KTlsHandshakeHeaderSize )
{
	LOG(Log::Printf(_L("CHandshakeParser::CHandshakeParser()\n"));)
}

inline CHandshake& CHandshakeParser::Handshake()
/**
 * This method returns a reference to a Handshake negotiation state machine.
 */
{
	LOG(Log::Printf(_L("CHandshakeParser::CHandshakeParser()\n"));)
	return (CHandshake&) *iStateMachine;
}

// Inline method - CServerHello
inline CServerHello::CServerHello( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser )
{
}

// Inline method - CCertificateReq
inline CCertificateReq::CCertificateReq( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser )
{
}

// Inline method - CServerCertificate
inline CServerCertificate::CServerCertificate( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser )
{
}

// Inline method - CServerKeyExch
inline CServerKeyExch::CServerKeyExch( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser )
{
}

// Inline method - CServerHelloDone
inline CServerHelloDone::CServerHelloDone( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser )
{
}

// Inline method - CRecvFinished
inline CRecvFinished::CRecvFinished( CTLSProvider& aTlsProvider, CStateMachine& aStateMachine, CRecordParser& aRecordParser ) :
   CHandshakeReceive( aTlsProvider, aStateMachine, aRecordParser ),
   iShaPtr( NULL ),
   iMd5Ptr( NULL )
{
}

#endif