// 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 Connection header file.
// Describes a secure (SSL3.0/TLS1.0) connection.
// 
//

/**
 @file
*/

#ifndef _TLSCONNECTION_H_
#define _TLSCONNECTION_H_
 
#include <securesocketinterface.h>
#include <genericsecuresocket.h>
#include <ssl.h>
#include <tlsprovinterface.h> 
#include <tlstypedef.h>
#include <comms-infras/statemachine.h>
#include "LOGFILE.H"

//Tls protocol Panics
enum TTlsPanic
{
	ETlsPanicClientHelloMsgNotSent = 0,
	ETlsPanicHandshakeMsgAlreadyExists,
	ETlsPanicChangeCipherMsgNotReceived,
	ETlsPanicServerHelloMsgNotReceived,
	ETlsPanicNullHandshakeMsg,
	ETlsPanicNullServerCertificate,
	ETlsPanicInvalidProcessState,
	ETlsPanicInvalidTlsSession,
	ETlsPanicNullTlsSession,
	ETlsPanicTlsProviderNotReady,
	ETlsPanicNoCA,
	ETlsPanicNoDataToProcess,
	ETlsPanicNoUserData,
	ETlsPanicUserDataAlreadySet,
	ETlsPanicNullPointerToHandshakeHeaderBuffer,
	ETlsPanicNullPointerToHandshakeRecordParser,
	ETlsPanicAppDataResumeButNotStarted,
	ETlsPanicHelloRequestRecWhileInAppData,
	ETlsPanicSignatureAlreadyExists,
	ETlsPanicNullStateMachineHistory,
	ETlsPanicNullStateMachine,
	ETlsPanicInvalidStateMachine,
	ETlsPanicStateMachineAlreadyExists,
	ETlsPanicStateMachineStopped,
	ETlsPanicInvalidStatus,
	ETlsPanicAlertReceived,
	ETlsPanicAlreadyActive,
};

// Declaration for global panic function for Tls protocol
GLREF_C void TlsPanic(TTlsPanic aPanic);

// Constant values
const TInt KProtocolDescMinSize = 8;	//< Minimum size of the descriptor for the Protocol name

/*
In RFC2716 (PPP EAP TLS Authentication Protocol) section 3.5, label is defined as "client EAP encryption"

In draft-josefsson-pppext-eap-tls-eap-02 (Protected EAP Protocol (PEAP)) section 2.8, label is
defined as "client PEAP encryption". However, most of radius servers use "client EAP encryption" 
as the constant keying string.

In draft-ietf-pppext-eap-ttls-04 EAP Tunneled TLS Authentication Protocol (TTLS) section 7,
label is defined as "ttls keying material".

Following max size is sufficient to all those cases.
*/
const TInt KKeyingLabelMaxSize = 100;

// TlsConnection supported protocols 
_LIT( KProtocolVerSSL30, "SSL3.0" );	//< SSL 3.0 Protocol
_LIT( KProtocolVerTLS10, "TLS1.0" );	//< TLS 1.0 Protocol


// Forward Declarations
class CRecordParser;
class CRecordComposer;
class CSendAlert;
class CHandshake;
class CSendAppData;
class CRecvAppData;

class CTlsConnection : public CActive, public MSecureSocket, public MStateMachineNotify
/**
  * A secure (SSL v3.0 or TLS vl.0) connection.
  * Implements the MSecureSocket interface used by the SECURESOCKET.DLL to talk to 
  * the protocol implementation. Note that it only implements Client-mode support
  * for the SSL v3.0 and TLS v1.0 protocols.
  * Server-mode operation is NOT supported. 
  */
{
public:
	IMPORT_C static MSecureSocket* NewL(RSocket& aSocket, const TDesC& aProtocol);
	IMPORT_C static MSecureSocket* NewL(MGenericSecureSocket& aSocket, const TDesC& aProtocol);

	IMPORT_C static void UnloadDll(TAny* /*aPtr*/);

	 ~CTlsConnection();

	// MSecureSocket interface
	virtual TInt AvailableCipherSuites(TDes8& aCiphers);
	virtual void CancelAll();
	virtual void CancelHandshake();
	virtual void CancelRecv();
	virtual void CancelSend();
	virtual const CX509Certificate* ClientCert();
	virtual TClientCertMode ClientCertMode(); 
	virtual void Close();
	virtual TInt CurrentCipherSuite(TDes8& aCipherSuite);
	virtual TDialogMode	DialogMode(); 
	virtual void FlushSessionCache();
	virtual TInt GetOpt(TUint aOptionName,TUint aOptionLevel,TDes8& aOption);
	virtual TInt GetOpt(TUint aOptionName,TUint aOptionLevel,TInt& aOption);
	virtual TInt Protocol(TDes& aProtocol);
	virtual void Recv(TDes8& aDesc, TRequestStatus & aStatus);
	virtual void RecvOneOrMore(TDes8& aDesc, TRequestStatus& aStatus, TSockXfrLength& aLen);
	virtual void RenegotiateHandshake(TRequestStatus& aStatus);
	virtual void Send(const TDesC8& aDesc, TRequestStatus& aStatus);
	virtual void Send(const TDesC8& aDesc, TRequestStatus& aStatus, TSockXfrLength& aLen);
	virtual const CX509Certificate* ServerCert();
	virtual TInt SetAvailableCipherSuites(const TDesC8& aCiphers);
	virtual TInt SetClientCert(const CX509Certificate& aCert);
	virtual TInt SetClientCertMode(const TClientCertMode aClientCertMode);
	virtual TInt SetDialogMode(const TDialogMode aDialogMode);
	virtual TInt SetOpt(TUint aOptionName,TUint aOptionLevel, const TDesC8& aOption=KNullDesC8());
	virtual TInt SetOpt(TUint aOptionName,TUint aOptionLevel,TInt aOption);
	virtual TInt SetProtocol(const TDesC& aProtocol);
	virtual TInt SetServerCert(const CX509Certificate& aCert);
	virtual void StartClientHandshake(TRequestStatus& aStatus);
	virtual void StartServerHandshake(TRequestStatus& aStatus);

	// MStateMachineNotify interface
	virtual TBool OnCompletion(CStateMachine* aStateMachine); 

	// Internal functions (these 2 functions are only used by this class)
	void StartRenegotiation( TRequestStatus* aStatus );
	void StartClientHandshakeStateMachine( TRequestStatus* aStatus );

   void ResetCryptoAttributes();

   //helper getter
	CTLSProvider&		TlsProvider();
	CTLSSession*&		TlsSession();
	CRecordParser&		RecordParser() const;
	CRecordComposer&	RecordComposer() const;
	CSendAppData*		SendAppData() const;
	TBool				SessionReUse() const;
   void GetServerAddrInfo( TTLSServerAddr& serverInfo );

	// Retrieve or confirm the Connection states
	TBool IsHandshaking() const;
	TBool IsReNegotiating() const;
	TBool IsInDataMode() const;
	TBool IsIdle() const;

	// Methods from CActive
	void RunL();
	void DoCancel();

protected:
	CTlsConnection(); 
	void ConstructL(RSocket& aSocket, const TDesC& aProtocol);
	void ConstructL(MGenericSecureSocket& aSocket, const TDesC& aProtocol);
	void DeleteStateMachines();
	void CancelAll(TInt aError);
	TBool SendData(const TDesC8& aDesc, TRequestStatus& aStatus);
	TBool RecvData(TDes8& aDesc, TRequestStatus& aStatus);

	TInt GetKeyingMaterial(TDes8& aKeyingMaterial);

protected:
	CTLSProvider*		iTlsProvider;		//< TLS Provider interface 
	CTLSSession*		iTlsSession;		//< TLS Session interface
	CRecordParser*		iRecordParser;		//< Record parser object
	CRecordComposer*	iRecordComposer;	//< Record composer object
	CHandshake*			iHandshake;			//< Handshake negotiation state machine
	CSendAppData*		iSendAppData;		//< Application data transmission state machine
	CRecvAppData*		iRecvAppData;		//< Application data reception state machine
	TDialogMode			iDialogMode;		//< Dialog settings

   //to keep the certificates given to client so that the client doesn't have to delete them
   //=> compatible behaviour with the old tls
	CX509Certificate* iClientCert;
	CX509Certificate* iServerCert;

	CGenericSecureSocket<RSocket>* iGenericSocket;
};


// Inline functions

/**
 * Returns a pointer to an Application data tx. state machine.
 */
inline CSendAppData* CTlsConnection::SendAppData() const
{
	LOG(Log::Printf(_L("CTlsConnection::CSendAppData()"));)
	return iSendAppData;
}

/**
 * Returns a reference to a TlsProvider object.
 */ 
inline CTLSProvider& CTlsConnection::TlsProvider()
{
	LOG(Log::Printf(_L("CTlsConnection::TlsProvider()"));)
	return *iTlsProvider;
}

/**
 * Returns a reference to a TlsSession object.
 */ 
inline CTLSSession*& CTlsConnection::TlsSession()
{
	LOG(Log::Printf(_L("CTlsConnection::TlsSession()"));)
	return iTlsSession;
}

/**
 * Returns a reference to a Record parser object.
 */
inline CRecordParser& CTlsConnection::RecordParser() const
{
	LOG(Log::Printf(_L("CTlsConnection::RecordParser()"));)
	return *iRecordParser;
}

/**
 * Returns a reference to a Record composer object.
 */
inline CRecordComposer& CTlsConnection::RecordComposer() const
{
	LOG(Log::Printf(_L("CTlsConnection::RecordComposer()"));)
	return *iRecordComposer;
}

/**
 * Returns a Boolean value that indicates whether a connection is
 * handshaking.
 */
inline TBool CTlsConnection::IsHandshaking() const
{
	LOG(Log::Printf(_L("CTlsConnection::IsHandshaking()"));)
	return iHandshake && !IsInDataMode();
}

/**
 * Returns a Boolean value that indicates whether a connection is
 * renegotiating a handshake.
 */
inline TBool CTlsConnection::IsReNegotiating() const
{
	LOG(Log::Printf(_L("CTlsConnection::IsReNegotiating()"));)
	return iHandshake && IsInDataMode();
}

/**
 * Returns a Boolean value that indicates whether a connection is
 * in data mode (transmission or reception).
 */
inline TBool CTlsConnection::IsInDataMode() const
{
	LOG(Log::Printf(_L("CTlsConnection::IsInDataMode()"));)
	return iSendAppData != 0; // iSendAppData and iRecvAppData always go together;
}

inline TBool CTlsConnection::SessionReUse() const
{
	LOG(Log::Printf(_L("CTlsConnection::SessionReUse()"));)
	return ETrue;	//used to return a value set in the FlushSessionChance 
					//don't think this is a good idea PS
}

#endif