/*
* Copyright (c) 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:  Class to represent IKEv2 payloads and to construct IKEv2 datagrams
*
*/

#ifndef IKEV2MESSAGE_H_
#define IKEV2MESSAGE_H_

#include <e32base.h>

class CIkeCaList;
class CDesC8Array;
class TIkeV2TrafficSelector;
class CIkeV2Identity;

NONSHARABLE_CLASS(CIkeV2Payload) : public CBase
    {
public:        
    ~CIkeV2Payload();
    
    TUint8 NextPayload() const;
    void SetNextPayload(TUint8 aNextPayload);
    
    TUint16 PayloadLength() const;
    void SetPayloadLength(TUint16 aLength);

    TPtrC8 PayloadData() const;
    TUint8 PayloadType() const;
    
protected:
    CIkeV2Payload(TUint8 aPayloadType);
    
    HBufC8* iPayloadData;

private:
    TUint8 iPayloadType;
    };


NONSHARABLE_CLASS(CIkevV2CertReqPayload) : public CIkeV2Payload
    {
public:
    static CIkevV2CertReqPayload* NewL(const CIkeCaList& aCaList);   
    
private:
    CIkevV2CertReqPayload();
    void ConstructL(const CIkeCaList& aCaList);        
    };

NONSHARABLE_CLASS(CIkevV2CertPayload) : public CIkeV2Payload
    {
public:
    static CIkevV2CertPayload* NewL(const TDesC8& aCertData);   
    
private:
    CIkevV2CertPayload();
    void ConstructL(const TDesC8& aCertData);        
    };



NONSHARABLE_CLASS(CIkevV2SaPayload) : public CIkeV2Payload
    {
public:
    static CIkevV2SaPayload* NewL(const TDesC8& aSaData);   
    
private:
    CIkevV2SaPayload();
    void ConstructL(const TDesC8& aSaData);
        
    };


NONSHARABLE_CLASS(CIkevV2KePayload) : public CIkeV2Payload
    {
public:
    static CIkevV2KePayload* NewL(TUint16 aDHGroup, const TDesC8& aKeData);   
    
private:
    CIkevV2KePayload();
    void ConstructL(TUint16 aDHGroup, const TDesC8& aKeData);        
    };


NONSHARABLE_CLASS(CIkevV2NoncePayload) : public CIkeV2Payload
    {
public:
    static CIkevV2NoncePayload* NewL(const TDesC8& aNonceData);   
    
private:
    CIkevV2NoncePayload();
    void ConstructL(const TDesC8& aNonceData);        
    };


NONSHARABLE_CLASS(CIkevV2IdPayload) : public CIkeV2Payload
    {    
protected:
    CIkevV2IdPayload(TUint8 aPayloadType);
    void ConstructL(const CIkeV2Identity& aIdentity);        
    };

NONSHARABLE_CLASS(CIkevV2IdiPayload) : public CIkevV2IdPayload
    {
public:
    static CIkevV2IdiPayload* NewL(const CIkeV2Identity& aIdentity);   
    
private:
    CIkevV2IdiPayload();        
    };


NONSHARABLE_CLASS(CIkevV2IdrPayload) : public CIkevV2IdPayload
    {
public:
    static CIkevV2IdrPayload* NewL(const CIkeV2Identity& aIdentity);   
    
private:
    CIkevV2IdrPayload();        
    };


NONSHARABLE_CLASS(CIkeV2AuthPayload) : public CIkeV2Payload
    {
public:
    static CIkeV2AuthPayload* NewL(TUint8 aAuthMethod, const TDesC8& aAuthData);  
    
private:
    CIkeV2AuthPayload();
    void ConstructL(TUint8 aAuthMethod, const TDesC8& aAuthData);    
    };


NONSHARABLE_CLASS(CIkeV2NotifyPayload) : public CIkeV2Payload
    {
public:
    static CIkeV2NotifyPayload* NewL(TUint8 aProtocolId,
                                     const TDesC8& aSpi,
                                     TUint16 aNotifyType,
                                     const TDesC8& aNotifyData);  
    
private:
    CIkeV2NotifyPayload();
    void ConstructL(TUint8 aProtocolId,
                    const TDesC8& aSpi,
                    TUint16 aNotifyType,
                    const TDesC8& aNotifyData);    
    };


NONSHARABLE_CLASS(CIkeV2ConfigurationPayload) : public CIkeV2Payload
    {
public:
    static CIkeV2ConfigurationPayload* NewL(TUint8 aCfgType, 
                                            const TDesC8& aConfigurationData);      
    
private:
    CIkeV2ConfigurationPayload();
    void ConstructL(TUint8 aCfgType, 
                    const TDesC8& aConfigurationData);
    };


NONSHARABLE_CLASS(CIkeV2VendorIdPayload) : public CIkeV2Payload
    {
public:
    static CIkeV2VendorIdPayload* NewL(const TDesC8& aVendorIdData);      
    
private:
    CIkeV2VendorIdPayload();
    void ConstructL(const TDesC8& aVendorIdData);
    };


NONSHARABLE_CLASS(CIkeV2DeletePayload) : public CIkeV2Payload
    {
public:
    static CIkeV2DeletePayload* NewL(TUint8 aProtocolId, const CDesC8Array& aSpiList);      
    
private:
    CIkeV2DeletePayload();
    void ConstructL(TUint8 aProtocolId, const CDesC8Array& aSpiList);
    };


NONSHARABLE_CLASS(CIkeV2EapPayload) : public CIkeV2Payload
    {
public:
    static CIkeV2EapPayload* NewL(const TDesC8& aEapData);      
    
private:
    CIkeV2EapPayload();
    void ConstructL(const TDesC8& aEapData);
    };


NONSHARABLE_CLASS(CIkeV2TsPayload) : public CIkeV2Payload
    {            
protected:
    CIkeV2TsPayload(TUint aPayloadType);
    void ConstructL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
    };

class CIkeV2TsiPayload : public CIkeV2TsPayload
    {            
public: 
    static CIkeV2TsiPayload* NewL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
    
private:
    CIkeV2TsiPayload();
    };

NONSHARABLE_CLASS(CIkeV2TsrPayload) : public CIkeV2TsPayload
    {            
public: 
    static CIkeV2TsrPayload* NewL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
    
private:
    CIkeV2TsrPayload();
    };


NONSHARABLE_CLASS(CIkeV2EncryptedPayload) : public CIkeV2TsPayload
    {
public:
    static CIkeV2EncryptedPayload* NewL(TUint aBlockSize);
    
    TUint BlockSize() const;
    TPtrC8 InitializationVector() const;
    
    void SetContentLength(TUint16 aLength);
private:
    CIkeV2EncryptedPayload();
    void ConstructL(TUint aBlockSize);
    
    TUint iBlockSize;
    };

class MIkeDebug;
class TInetAddr;

NONSHARABLE_CLASS(CIkeV2Message) : public CBase
    {
public:
    
    /**
     *  Constructs new IKE message.
     *  
     *  @param aInitiatorSpi Initiator SPI 
     *  @param aResponderSpi Responder SPI
     *  @param aExchangeType Type of the exchange. Possible values are:
     *                       IKE_SA_INIT, IKE_AUTH, CREATE_CHILD_SA and INFORMATIONAL.
     *  @param aFlags Message flags. Possible flags are:
     *                IKEV2_INITIATOR and IKEV2_RESPONSE_MSG.                             
     */
    static CIkeV2Message* NewL(const TDesC8& aInitiatorSpi,
                               const TDesC8& aResponderSpi,
                               TUint8 aExchangeType,
                               TBool aIntiator,
                               TBool aResponse,
                               TUint32 aMessageId,
                               MIkeDebug& aDebug);
    ~CIkeV2Message();
    
    TPtrC8 InitiatorSpi()const;        
    TPtrC8 ResponderSpi() const;
    
    TUint8 NextPayload() const;
    
    TUint8 MajorVersion() const;
    TUint8 MinorVersion() const;
    
    TUint8 ExchangeType() const;
    
    TUint8 Flags() const;
        
    TUint32 MessageId() const;   
      
    TUint32 Length() const;
    
    void AppendCertReqPayloadL(const CIkeCaList& aCaList);
    void AppendCertPayloadL(const TDesC8& aCertificateData);     
    void AppendSaPayloadL(const TDesC8& aSaData);  
    void AppendKePayloadL(TUint16 aDHGroup, const TDesC8& aKeData); 
    void AppendNoncePayloadL(const TDesC8& aNonceData);
    void AppendIdiPayloadL(const CIkeV2Identity& aIdentity);
    void AppendIdrPayloadL(const CIkeV2Identity& aIdentity);
    void AppendAuthPayloadL(TUint8 aAuthMethod, const TDesC8& aAuthData);
    void AppendNotifyPayloadL(TUint8 aProtocolId,
                              const TDesC8& aSpi,
                              TUint16 aNotifyType,
                              const TDesC8& aNotifyData);

    /**
     * A special method for adding a cookie notify in the
     * beginning of an existing ike message. 
     */
    void PrependCookieNotifyPayloadL(TUint8 aProtocolId,
                                     const TDesC8& aCookieData);    
    
    void AppendConfigurationPayloadL(TUint8 aCfgType, 
                                    const TDesC8& aConfigurationData);
    void AppendVendorIdPayloadL(const TDesC8& aVendorIdData);    
    void AppendDeletePayloadL(TUint8 aProtocolId, const CDesC8Array& aSpiList);
    void AppendEapPayloadL(const TDesC8& aEapData);
    void AppendTsiPayloadL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
    void AppendTsrPayloadL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
    
    /**
     *  Adds the encrypted payload to the message.
     *  The added encrypted payload has to be the first added payload.
     */
    void AppendEncryptedPayloadL(TUint aBlockSize);
    
    
    /**
     *  Gets the ike message datagram, which is ready to be
     *  send to the receiver.  
     *  
     *  @param aEncryptionAlgorith Encryption algorithm to be used to encrypt the datagram.
     *                             If the message does not contain an encryption payload, this
     *                             parameter is ignored.
     *  @param aEncryptionKey Encryption key used to used to encrypt the datagram.
     *                        If the message does not contain an encryption payload, this
     *                        parameter is ignored.
     *  @param aIntegrityAlgorithm Algorithm used to calculate the integrity checks sum.
     *                             If the message does not contain an encryption payload, this
     *                             parameter is ignored.                
     *  @param aSourceAddress Source address of the datagram. Needed for message tracing in
     *                        debug builds.
     *  @param aDestinationAddress Destination address of the datagram. Needed for message tracing in
     *                        debug builds.                        
     */
    void PrepareIkeMessageDatagramL(TUint16 aEncryptionAlgorithm, 
                                    const TDesC8& aEncryptionKey,
                                    TUint16 aIntegrityAlgorithm,
                                    const TDesC8& aIntegrityKey,
                                    const TInetAddr& aSourceAddress,
                                    const TInetAddr& aDestinationAddress);
    
    TPtrC8 IkeMessageDatagram() const;
private:    
    CIkeV2Message(MIkeDebug& aDebug);
    void ConstructL(const TDesC8& aInitiatorSpi,
                    const TDesC8& aResponderSpi,
                    TUint8 aExchangeType,
                    TBool aIntiator,
                    TBool aResponse,
                    TUint32 aMessageId);
    
    void AppendPayloadL(CIkeV2Payload* aPayload);
    
    void SetFlags(TUint8 aFlags);
    void SetLength(TUint32 aDatagramLength);
    void SetNextPayload(TUint8 aNextPayload);
        
    
    MIkeDebug& iDebug;
    HBufC8* iIkeV2MessageHeader;
    RPointerArray<CIkeV2Payload> iPayloads;
    
    TBool   iModified;
    HBufC8* iIkeV2Datagram;
    };

#endif /* IKEV2MESSAGE_H_ */