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




/*
TCP Relay packet header:

    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Relay type    | Reserved=0x00 |           Data length         |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

*/

#include <es_sock.h>
#include "natfwunsaftcprelaypacket.h"
#include "natfwunsafutils.h"

// CONSTANTS
const TInt KByteSize = 8;

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CNATFWUNSAFTcpRelayPacket* CNATFWUNSAFTcpRelayPacket::NewL(
    const TDesC8& aData,
    const TRelayType aType)
    {
    CNATFWUNSAFTcpRelayPacket* self =
        CNATFWUNSAFTcpRelayPacket::NewLC(aData, aType);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CNATFWUNSAFTcpRelayPacket* CNATFWUNSAFTcpRelayPacket::NewLC(
    const TDesC8& aData,
    const TRelayType aType)
    {
    CNATFWUNSAFTcpRelayPacket* self =
        new (ELeave) CNATFWUNSAFTcpRelayPacket();
    CleanupStack::PushL(self);
    self->ConstructL(aData, aType);
    return self;
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::CreateL
// -----------------------------------------------------------------------------
//
CNATFWUNSAFTcpRelayPacket* CNATFWUNSAFTcpRelayPacket::CreateL(
    const TDesC8& aData,
    const TRelayType aType )
    {
    return NewL(aData, aType);
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::CNATFWUNSAFTcpRelayPacket
// -----------------------------------------------------------------------------
//
CNATFWUNSAFTcpRelayPacket::CNATFWUNSAFTcpRelayPacket()
    {
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::~CNATFWUNSAFTcpRelayPacket
// -----------------------------------------------------------------------------
//
CNATFWUNSAFTcpRelayPacket::~CNATFWUNSAFTcpRelayPacket()
    {
    delete iData;
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::ConstructL
// -----------------------------------------------------------------------------
//
void CNATFWUNSAFTcpRelayPacket::ConstructL(
    const TDesC8& aData,
    const TRelayType aType )
    {
    CheckLengthL(aData.Length());
    iData = aData.AllocL();
    iType = aType;
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::EncodeL
// -----------------------------------------------------------------------------
//
EXPORT_C CBufBase* CNATFWUNSAFTcpRelayPacket::EncodeL() const
    {
    CBufBase* relay = EncodeRelayHeaderLC();
    relay->InsertL(relay->Size(), *iData);
    CleanupStack::Pop(relay);
    SetRelayLength(*relay);
    return relay;
    }
    
// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::EncodeRelayHeaderLC
// -----------------------------------------------------------------------------
//
CBufBase* CNATFWUNSAFTcpRelayPacket::EncodeRelayHeaderLC() const
    {
    CBufBase* header = CBufFlat::NewL(EFrameSize);
    CleanupStack::PushL(header);
    TUint16 relayType = Type();
     // Last eight bits of frame type are reserved as zeros
    relayType <<= KByteSize;
    TUint16 bigEndianType(0);
    BigEndian::Put16(reinterpret_cast<TUint8*>(&bigEndianType), relayType);
    header->InsertL(EFrameTypeOffset, &bigEndianType, sizeof(bigEndianType));
    //Value is zero, so it is same also in the big endian representation
    TUint16 frameLength(0);
    header->InsertL(EFrameLengthOffset, &frameLength, sizeof(frameLength));
    return header;
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::RelayLength
// TInt is guaranteed to be at least 32 bits.
// -----------------------------------------------------------------------------
//
TInt CNATFWUNSAFTcpRelayPacket::RelayLength(const TDesC8& aRelay)
    {
    if (aRelay.Length() < EFrameSize)
        {
        return KErrNotFound;
        }

    return BigEndian::Get16(aRelay.Mid(EFrameLengthOffset).Ptr());
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::SetRelayLength
// UNSAF Relay length does not include the NATFWUNSAF header
// -----------------------------------------------------------------------------
//
void CNATFWUNSAFTcpRelayPacket::SetRelayLength(CBufBase& aRelay)
    {
    SetRelayLength(aRelay, aRelay.Size() - EFrameSize);
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::SetRelayLength
// -----------------------------------------------------------------------------
//
void CNATFWUNSAFTcpRelayPacket::SetRelayLength(CBufBase& aRelay, TInt aLength)
    {
    __ASSERT_ALWAYS(aLength >= 0, User::Panic(KNullDesC, KErrUnderflow));

    TUint16 bigEndianLength(0);
    BigEndian::Put16(reinterpret_cast<TUint8*>(&bigEndianLength),
                 static_cast<TUint16>(aLength));

    aRelay.Write(EFrameLengthOffset, &bigEndianLength,
        sizeof(bigEndianLength));
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::CheckLengthL
// Check the granularity of attribute's length.
// -----------------------------------------------------------------------------
//
void CNATFWUNSAFTcpRelayPacket::CheckLengthL(TInt aLength) const
    {
    __ASSERT_ALWAYS((aLength % EGranularity) == 0, User::Leave(KErrCorrupt));
    }

// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::Data
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CNATFWUNSAFTcpRelayPacket::Data() const
    {
    return *iData;
    }
    
// -----------------------------------------------------------------------------
// CNATFWUNSAFTcpRelayPacket::Type
// -----------------------------------------------------------------------------
//
EXPORT_C CNATFWUNSAFTcpRelayPacket::TRelayType
    CNATFWUNSAFTcpRelayPacket::Type() const
    {
    return iType;
    }