/*

* Copyright (c) 2006-2007 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 "natfwunsafmessage.h"

#include "natfwunsaftransactionid.h"

#include "natfwunsafmessageintegrityattribute.h"

#include "natfwunsaffingerprintattribute.h"

#include "natfwunsafutils.h"

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::CNATFWUNSAFMessage

// -----------------------------------------------------------------------------

//

CNATFWUNSAFMessage::CNATFWUNSAFMessage(

    const TNATFWUNSAFTransactionID& aTransactionID)

#ifdef TEST_EUNIT

    : iAttributes(1)

#endif

    {

    iTransactionID = aTransactionID;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::~CNATFWUNSAFMessage

// -----------------------------------------------------------------------------

//

CNATFWUNSAFMessage::~CNATFWUNSAFMessage()

    {

    iAttributes.ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::TransactionID

// -----------------------------------------------------------------------------

//

EXPORT_C TNATFWUNSAFTransactionID CNATFWUNSAFMessage::TransactionID() const

    {

    return iTransactionID;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::HasAttribute

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CNATFWUNSAFMessage::HasAttribute(

    CNATFWUNSAFAttribute::TType aType) const

    {

    return Attribute(aType) ? ETrue : EFalse;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::Attribute

// -----------------------------------------------------------------------------

//

EXPORT_C CNATFWUNSAFAttribute* CNATFWUNSAFMessage::Attribute(

    CNATFWUNSAFAttribute::TType aType) const

    {

    for (TInt i = 0; i < iAttributes.Count(); ++i)

        {

        if (iAttributes[i]->Type() == aType)

            {

            return iAttributes[i];

            }

        }

    return NULL;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::AddAttributeL

// -----------------------------------------------------------------------------

//

EXPORT_C void CNATFWUNSAFMessage::AddAttributeL(

    CNATFWUNSAFAttribute* aAttribute)

    {

    __ASSERT_ALWAYS(aAttribute, User::Leave(KErrArgument));

    iAttributes.AppendL(aAttribute);

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::DetachAttribute

// -----------------------------------------------------------------------------

//

EXPORT_C void CNATFWUNSAFMessage::DetachAttribute(

    const CNATFWUNSAFAttribute* aAttribute)

    {

    TInt pos = iAttributes.Find(aAttribute);

    if (pos != KErrNotFound)

        {

        iAttributes.Remove(pos);

        }

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::DeleteAttribute

// Start search from the end of the array, so that deleting an attribute doesn't

// affect the positions of those attributes which haven't yet been checked.

// -----------------------------------------------------------------------------

//

EXPORT_C void CNATFWUNSAFMessage::DeleteAttribute(TUint16 aType)

    {

    for (TInt i = iAttributes.Count() - 1; i >= 0; --i)

        {

        if (iAttributes[i]->Type() == aType)

            {

            CNATFWUNSAFAttribute* attr = iAttributes[i];

            DetachAttribute(attr);

            delete attr;

            }

        }

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::EncodeL

// -----------------------------------------------------------------------------

//

EXPORT_C CBufBase* CNATFWUNSAFMessage::EncodeL() const

    {

    CBufBase* msg = EncodeMessageHeaderLC();

    for (TInt i = 0; i < iAttributes.Count(); ++i)

        {

        if (iAttributes[i]->Type() != CNATFWUNSAFAttribute::EMessageIntegrity &&

            iAttributes[i]->Type() != CNATFWUNSAFAttribute::EFingerprint)

            {

            HBufC8* attribute = iAttributes[i]->EncodeL();

            CleanupStack::PushL(attribute);

            msg->InsertL(msg->Size(), *attribute);

            CleanupStack::PopAndDestroy(attribute);

            }

        }

    CleanupStack::Pop(msg);

    msg->Compress();

    SetMessageLength(*msg);

    return msg;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::EncodeL

// 1. Encode the UNSAF message normally.

// 2. Create a MESSAGE-INTEGRITY attribute. This updates also the header's

//    length field to include the MESSAGE-INTEGRITY before computing the hash.

// 3. Encode it to the last attribute of the UNSAF message.

// 4. Create a FINGERPRINT attribute. This updates also the header's

//    length field to include the FINGERPRINT before computing the hash.

// 5. Encode it to the last attribute of the UNSAF message.

// -----------------------------------------------------------------------------

//

EXPORT_C CBufBase* CNATFWUNSAFMessage::EncodeL(

    const TDesC8& aSharedSecret,

    TBool aUseFingerprint) const

    {

    CBufBase* msg = EncodeL();

    CleanupStack::PushL(msg);

    if ( aSharedSecret.Length() )

        {

        //Long term credentials need be used if there's a REALM attribute

        CNATFWUNSAFMessageIntegrityAttribute* msgIntegrity =

            CNATFWUNSAFMessageIntegrityAttribute::NewLC(aSharedSecret, *msg,

                HasAttribute( CNATFWUNSAFAttribute::ERealm ));

        HBufC8* encodedMsgIntegrity = msgIntegrity->EncodeL();

        CleanupStack::PushL(encodedMsgIntegrity);

        msg->InsertL(msg->Size(), *encodedMsgIntegrity);

        CleanupStack::PopAndDestroy(encodedMsgIntegrity);

        CleanupStack::PopAndDestroy(msgIntegrity);

        }

    if ( aUseFingerprint )

        {

        CNATFWUNSAFFingerprintAttribute* fingerprint =

            CNATFWUNSAFFingerprintAttribute::NewLC(*msg);

        HBufC8* encodedFingerprint = fingerprint->EncodeL();

        CleanupStack::PushL(encodedFingerprint);

        msg->InsertL(msg->Size(), *encodedFingerprint);

        CleanupStack::PopAndDestroy(encodedFingerprint);

        CleanupStack::PopAndDestroy(fingerprint); 

        }

    CleanupStack::Pop(msg);

    msg->Compress();

    return msg;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::UnknownMandatoryAttributeFound

// -----------------------------------------------------------------------------

//

void CNATFWUNSAFMessage::UnknownMandatoryAttributeFound()

    {

    iUnknownMandatoryAttributes = ETrue;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::HasUnknownMandatoryAttributes

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CNATFWUNSAFMessage::HasUnknownMandatoryAttributes() const

    {

    return iUnknownMandatoryAttributes;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::EncodeMessageHeaderLC

// -----------------------------------------------------------------------------

//

CBufBase* CNATFWUNSAFMessage::EncodeMessageHeaderLC() const

    {

    CBufBase* header = CBufFlat::NewL(EHeaderSize);

    CleanupStack::PushL(header);

    TUint16 messageType = Type();

    TUint16 bigEndianType(0);

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

    //First two bits of a STUN message are zero

    bigEndianType = bigEndianType & EMessageTypeMask;

    header->InsertL(EMessageTypeOffset, &bigEndianType, sizeof(bigEndianType));

    TUint16 msgLength = 0;

    //Value is zero, so it is same also in the big endian representation

    header->InsertL(EMessageLengthOffset, &msgLength, sizeof(msgLength));

    TUint32 bigEndianCookie(0);

    BigEndian::Put32(reinterpret_cast<TUint8*>(&bigEndianCookie), EMagicCookie);

    header->InsertL(EMagicCookieOffset,

                    &bigEndianCookie,

                    sizeof(bigEndianCookie));

    header->InsertL(ETransactionIDOffset,

                    iTransactionID,

                    KMaxNATFWUNSAFTransactionIdLength);

    return header;

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::MessageLength

// TInt is guaranteed to be at least 32 bits.

// -----------------------------------------------------------------------------

//

TInt CNATFWUNSAFMessage::MessageLength(const TDesC8& aNATFWUNSAFMessage)

    {

    if (aNATFWUNSAFMessage.Length() < EHeaderSize)

        {

        return KErrNotFound;

        }

    return BigEndian::Get16(aNATFWUNSAFMessage.Mid(EMessageLengthOffset).Ptr());

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::SetMessageLength

// UNSAF message length does not include the NATFWUNSAF header

// -----------------------------------------------------------------------------

//

void CNATFWUNSAFMessage::SetMessageLength(CBufBase& aNATFWUNSAFMessage)

    {

    SetMessageLength(aNATFWUNSAFMessage,

        aNATFWUNSAFMessage.Size() - EHeaderSize);

    }

// -----------------------------------------------------------------------------

// CNATFWUNSAFMessage::SetMessageLength

// -----------------------------------------------------------------------------

//

void CNATFWUNSAFMessage::SetMessageLength(CBufBase& aNATFWUNSAFMessage,

    TInt aLength)

    {

    __ASSERT_ALWAYS(aLength >= 0, User::Panic(KNullDesC, KErrUnderflow));

    TUint16 bigEndianLength(0);

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

                     static_cast<TUint16>(aLength));

    aNATFWUNSAFMessage.Write(EMessageLengthOffset,

                        &bigEndianLength,

                        sizeof(bigEndianLength));

    }