/*

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

*

*/

#include <es_sock.h>

#include <badesca.h>

#include <random.h>

#include "ikev2message.h"

#include "ikev2const.h"

#include "ikecalist.h"

#include "ikecaelem.h"

#include "ikev2trafficselector.h"

#include "ikecrypto.h"

#include "ikev2identity.h"

#include "ikemsgheader.h"

#include "ikedebug.h"

static const TUint8 KMessageIdFieldOffset = 20; 

static const TUint KIkePayloadGenericHeaderLength = 4;

static const TUint8 KLengthFieldOffset = 2;

static const TUint32 KSha1Length = 20;

static const TUint32 KCertReqHeaderLength = 5;

static const TUint32 KCertHeaderLength = 5;

static const TUint32 KSaHeaderLength = 4;

static const TUint32 KKeHeaderLength = 8;

static const TUint32 KNonceHeaderLength = 4;

static const TUint32 KAuthHeaderLength = 8;

static const TUint32 KNotifyHeaderLength = 8;

static const TUint32 KConfigurationHeaderLength = 8;

static const TUint32 KVendorIdHeaderLength = 4;

static const TUint32 KDeleteHeaderLength = 8;

static const TUint32 KEapHeaderLength = 4;

static const TUint32 KTsHeaderLength = 8;

static const TUint32 KEncryptedHeaderLength = 4;

_LIT8(KNonEspMarker, "\0\0\0\0");

CIkeV2Payload::CIkeV2Payload(TUint8 aPayloadType)

:iPayloadType(aPayloadType)

    {    

    }

CIkeV2Payload::~CIkeV2Payload()

    {

    delete iPayloadData;

    }

TUint8 CIkeV2Payload::PayloadType() const

    {

    return iPayloadType;

    }

TUint8 CIkeV2Payload::NextPayload() const

    {

    __ASSERT_DEBUG(iPayloadData->Length() >= KIkePayloadGenericHeaderLength,

                   User::Invariant());

    return (*iPayloadData)[0];

    }

void CIkeV2Payload::SetNextPayload(TUint8 aNextPayload)

    {

    __ASSERT_DEBUG(iPayloadData->Length() >= KIkePayloadGenericHeaderLength,

                   User::Invariant());

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr[0] = aNextPayload;

    }

TUint16 CIkeV2Payload::PayloadLength() const

    {

    __ASSERT_DEBUG(iPayloadData->Length() >= KIkePayloadGenericHeaderLength,

                   User::Invariant());

    return BigEndian::Get16(iPayloadData->Ptr() + KLengthFieldOffset);

    }

void CIkeV2Payload::SetPayloadLength(TUint16 aLength)

    {

    __ASSERT_DEBUG(iPayloadData->Length() >= KIkePayloadGenericHeaderLength,

                   User::Invariant());

    const TUint KLengthPosition = 2; 

    BigEndian::Put16(reinterpret_cast<TUint8*>(&aLength), aLength);

    TPtrC8 length(reinterpret_cast<TUint8*>(&aLength), sizeof(aLength));

    TPtr8 lengthPtr(iPayloadData->Des().MidTPtr(KLengthPosition, 

                                                length.Length()));    

    lengthPtr = length; 

    }

TPtrC8 CIkeV2Payload::PayloadData() const

    {

    return TPtrC8(*iPayloadData);

    }

CIkevV2CertReqPayload* CIkevV2CertReqPayload::NewL(const CIkeCaList& aCaList)

    {

    CIkevV2CertReqPayload* self = new (ELeave) CIkevV2CertReqPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aCaList);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2CertReqPayload::CIkevV2CertReqPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_CR)

    {

    }

void CIkevV2CertReqPayload::ConstructL(const CIkeCaList& aCaList)

    {

    __ASSERT_DEBUG(aCaList.Count() > 0, User::Invariant());

    TUint16 length = (aCaList.Count() * KSha1Length) + KCertReqHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    TUint8 encoding = X509_CERTIFICATE_SIGN;       

    TPtrC8 encodingPtr(&encoding, sizeof(encoding));

    payloadDataPtr.Append(encodingPtr);

    for (TUint i = 0; i < aCaList.Count(); ++i)

        {

        payloadDataPtr.Append(aCaList[i]->KeyHash());

        }

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2CertPayload* CIkevV2CertPayload::NewL(const TDesC8& aCertData)

    {

    CIkevV2CertPayload* self = new (ELeave) CIkevV2CertPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aCertData);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2CertPayload::CIkevV2CertPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_CERT)

    {

    }

void CIkevV2CertPayload::ConstructL(const TDesC8& aCertData)

    {

    TUint16 length = aCertData.Length() + KCertHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);  

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    TUint8 encoding = X509_CERTIFICATE_SIGN;     

    TPtrC8 encodingPtr(&encoding, sizeof(encoding));

    payloadDataPtr.Append(encodingPtr);       

    payloadDataPtr.Append(aCertData);   

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2SaPayload* CIkevV2SaPayload::NewL(const TDesC8& aSaData)

    {

    CIkevV2SaPayload* self = new (ELeave) CIkevV2SaPayload; 

    CleanupStack::PushL(self);

    self->ConstructL(aSaData);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2SaPayload::CIkevV2SaPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_SA)

    {    

    }

void CIkevV2SaPayload::ConstructL(const TDesC8& aSaData)

    {

    TUint16 length = aSaData.Length() + KSaHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    payloadDataPtr.Append(aSaData);

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2KePayload* CIkevV2KePayload::NewL(TUint16 aDHGroup, const TDesC8& aKeData)

    {    

    CIkevV2KePayload* self = new (ELeave) CIkevV2KePayload;

    CleanupStack::PushL(self);

    self->ConstructL(aDHGroup, aKeData);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2KePayload::CIkevV2KePayload()

:CIkeV2Payload(IKEV2_PAYLOAD_KE)

    {

    }

void CIkevV2KePayload::ConstructL(TUint16 aDHGroup, const TDesC8& aKeData)

    {

    static const TUint8 KReservedFieldLength = 2;

    TUint16 length = aKeData.Length() + KKeHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    BigEndian::Put16(reinterpret_cast<TUint8*>(&aDHGroup), aDHGroup);

    TPtrC8 dhGroupPtr(reinterpret_cast<TUint8*>(&aDHGroup), sizeof(aDHGroup));

    payloadDataPtr.Append(dhGroupPtr);

    //Leave reserved bytes zero

    payloadDataPtr.SetLength(payloadDataPtr.Length() + KReservedFieldLength);

    TPtr8 reservedBytes = payloadDataPtr.RightTPtr(KReservedFieldLength);

    reservedBytes.FillZ();

    payloadDataPtr.Append(aKeData);  

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2NoncePayload* CIkevV2NoncePayload::NewL(const TDesC8& aNonceData)

    {

    CIkevV2NoncePayload* self = new (ELeave) CIkevV2NoncePayload;

    CleanupStack::PushL(self);

    self->ConstructL(aNonceData);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2NoncePayload::CIkevV2NoncePayload()

:CIkeV2Payload(IKEV2_PAYLOAD_NONCE)

    {

    }

void CIkevV2NoncePayload::ConstructL(const TDesC8& aNonceData)

    {

    TUint16 length = aNonceData.Length() + KNonceHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);  

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    payloadDataPtr.Append(aNonceData);

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2IdPayload::CIkevV2IdPayload(TUint8 aPayloadType)

:CIkeV2Payload(aPayloadType)

    {    

    }

void CIkevV2IdPayload::ConstructL(const CIkeV2Identity& aIdentity)

    {        

    TPtrC8 idPayloadData = aIdentity.PayloadData();

    TUint32 length = idPayloadData.Length() + KIkePayloadGenericHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);    

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    payloadDataPtr.Append(idPayloadData);

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkevV2IdiPayload* CIkevV2IdiPayload::NewL(const CIkeV2Identity& aIdentity)

    {    

    CIkevV2IdiPayload* self = new (ELeave) CIkevV2IdiPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aIdentity);

    CleanupStack::Pop(self);

    return self;

    }

CIkevV2IdiPayload::CIkevV2IdiPayload()

:CIkevV2IdPayload(IKEV2_PAYLOAD_ID_I)

    {  

    }

CIkevV2IdrPayload* CIkevV2IdrPayload::NewL(const CIkeV2Identity& aIdentity)

    {    

    CIkevV2IdrPayload* self = new (ELeave) CIkevV2IdrPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aIdentity);

    CleanupStack::Pop(self);

    return self;    

    }

CIkevV2IdrPayload::CIkevV2IdrPayload()

:CIkevV2IdPayload(IKEV2_PAYLOAD_ID_R)

    {    

    }

CIkeV2AuthPayload* CIkeV2AuthPayload::NewL(TUint8 aAuthMethod, const TDesC8& aAuthData)

    {

    CIkeV2AuthPayload* self = new (ELeave) CIkeV2AuthPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aAuthMethod, aAuthData);

    CleanupStack::Pop(self);

    return self;

    }

CIkeV2AuthPayload::CIkeV2AuthPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_AUTH)

    {

    }

void CIkeV2AuthPayload::ConstructL(TUint8 aAuthMethod, const TDesC8& aAuthData)

    {

    static const TUint8 KReservedFieldLength = 3;

    TUint32 length = aAuthData.Length() + KAuthHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);    

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    TPtrC8 authTypePtr(&aAuthMethod, sizeof(aAuthMethod));

    payloadDataPtr.Append(authTypePtr);

    //Leave reserved bytes zero

    payloadDataPtr.SetLength(payloadDataPtr.Length() + KReservedFieldLength);    

    TPtr8 reservedField = payloadDataPtr.RightTPtr(KReservedFieldLength);

    reservedField.FillZ();

    payloadDataPtr.Append(aAuthData);   

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkeV2NotifyPayload* CIkeV2NotifyPayload::NewL(TUint8 aProtocolId,

                                               const TDesC8& aSpi,

                                               TUint16 aNotifyType,

                                               const TDesC8& aNotifyData)

    {    

    CIkeV2NotifyPayload* self = new (ELeave) CIkeV2NotifyPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aProtocolId, aSpi, aNotifyType, aNotifyData);

    CleanupStack::Pop(self);

    return self;

    }

CIkeV2NotifyPayload::CIkeV2NotifyPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_NOTIF)

    {

    }

void CIkeV2NotifyPayload::ConstructL(TUint8 aProtocolId,

                                     const TDesC8& aSpi,

                                     TUint16 aNotifyType,

                                     const TDesC8& aNotifyData)

    {    

    TUint32 length = aSpi.Length() + aNotifyData.Length() + KNotifyHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);    

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    TPtrC8 protocolIdPtr(&aProtocolId, sizeof(aProtocolId));

    TUint8 spiSize = aSpi.Length();

    TPtrC8 spiSizePtr(&spiSize, sizeof(spiSize));

    BigEndian::Put16(reinterpret_cast<TUint8*>(&aNotifyType), aNotifyType);

    TPtrC8 notifyTypePtr(reinterpret_cast<TUint8*>(&aNotifyType), sizeof(aNotifyType));

    payloadDataPtr.Append(protocolIdPtr);

    payloadDataPtr.Append(spiSizePtr);

    payloadDataPtr.Append(notifyTypePtr);

    payloadDataPtr.Append(aSpi);

    payloadDataPtr.Append(aNotifyData);  

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkeV2ConfigurationPayload* CIkeV2ConfigurationPayload::NewL(TUint8 aCfgType, 

                                                             const TDesC8& aConfigurationData)

    {

    CIkeV2ConfigurationPayload* self = new (ELeave) CIkeV2ConfigurationPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aCfgType, aConfigurationData);

    CleanupStack::Pop(self);

    return self;

    }

CIkeV2ConfigurationPayload::CIkeV2ConfigurationPayload()

: CIkeV2Payload(IKEV2_PAYLOAD_CONFIG)

    {    

    }

void CIkeV2ConfigurationPayload::ConstructL(TUint8 aCfgType, 

                                            const TDesC8& aConfigurationData)

    {

    static const TUint8 KReservedFieldLength = 3;

    TUint32 length = aConfigurationData.Length() + KConfigurationHeaderLength;

    iPayloadData = HBufC8::NewL(length);

    TPtr8 payloadDataPtr(iPayloadData->Des());

    payloadDataPtr.SetLength(KIkePayloadGenericHeaderLength);    

    payloadDataPtr.FillZ();

    SetPayloadLength(length);

    TPtrC8 cfgTypePtr(reinterpret_cast<TUint8*>(&aCfgType), sizeof(aCfgType));

    payloadDataPtr.Append(cfgTypePtr);

    //Leave reserved bytes zero

    payloadDataPtr.SetLength(payloadDataPtr.Length() + KReservedFieldLength);    

    TPtr8 reservedField = payloadDataPtr.RightTPtr(KReservedFieldLength);

    reservedField.FillZ();

    payloadDataPtr.Append(aConfigurationData);  

    __ASSERT_DEBUG(PayloadLength() == iPayloadData->Length(), User::Invariant());

    }

CIkeV2VendorIdPayload* CIkeV2VendorIdPayload::NewL(const TDesC8& aVendorIdData)

    {

    CIkeV2VendorIdPayload* self = new (ELeave) CIkeV2VendorIdPayload;

    CleanupStack::PushL(self);

    self->ConstructL(aVendorIdData);

    CleanupStack::Pop(self);

    return self;

    }

CIkeV2VendorIdPayload::CIkeV2VendorIdPayload()

:CIkeV2Payload(IKEV2_PAYLOAD_VID)

    {    

    }

void CIkeV2VendorIdPayload::ConstructL(const TDesC8& aVendorIdData)

    {        

    TUint32 length = aVendorIdData.Length() + KVendorIdHeaderLength;