/*

* Copyright (c) 2004 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:    General RTCP packet handling routines.

*

*/

// INCLUDES

#include "srtppacketrtcp.h"

#include "srtputils.h"

#include "srtpcryptohandler.h"

#include "srtpcryptocontext.h"

#include "srtpmasterkey.h"

#include "srtpmastersalt.h"

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

// CSRTPPacketRTCP::CSRTPPacketRTCP

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

//

CSRTPPacketRTCP::CSRTPPacketRTCP(const TDesC8& aPacket,

                   CSRTPCryptoHandler& aHandler)

    : CSRTPPacket(aPacket, aHandler)

            {

            }

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

// CSRTPPacketRTCP::~CSRTPPacketRTCP

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

//

CSRTPPacketRTCP::~CSRTPPacketRTCP()

            {

            }

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

// Two-phased constructor. 

// 

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

//

CSRTPPacketRTCP* CSRTPPacketRTCP::NewL(const TDesC8& aPacket,

                      CSRTPCryptoHandler& aHandler)

    {

    CSRTPPacketRTCP* self = new( ELeave )CSRTPPacketRTCP( aPacket, aHandler);

    CleanupStack::PushL( self );    

    self->ConstructL();

    CleanupStack::Pop( self );        

    return self;

    }

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

// void CSRTPPacketRTCP::ConstructL

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

//

void CSRTPPacketRTCP::ConstructL()

    {            

    CSRTPPacket::ConstructL(); 

    UpdateHeaderLengthL(); 

    UpdatePayloadLength();

    UpdatePayload();           

    }

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

// CSRTPPacketRTCP::UpdatePayloadLength()

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

//

void CSRTPPacketRTCP::UpdatePayloadLength()

    {    

     // In RTP case the payload length is easy to calculate

     iPayloadLength = iPacket.Length() - iHeaderLength;     

     if ( iPacket.Length() <= iHeaderLength )

     	{

     	iPayloadLength = 0;

     	}

    }

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

// CSRTPPacketRTCP::UpdateHeaderLengthL()

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

//

void CSRTPPacketRTCP::UpdateHeaderLengthL()

    {    

    TInt size = iPacket.Length();

	const TUint8 *pointer = iDataP;	

     // version

    if ( ( ( pointer[0] & 0xC0 ) >> 6 ) != 2/*RTPVersion*/ )

        {

       	User::Leave(KErrCorrupt);

        }

    // padding

    if ( pointer[0] & 0x20 )

        {

    	size -= iDataP[size - 1];

    	}

    // determine RTCP packet type

    TInt pt = static_cast<TInt>( pointer[1] );

    if ( ( pt!= 200 ) && (pt != 201) &&

	     ( pt != 202) && ( pt != 203 ) &&

	     ( pt != 204 ) )

        {

        User::Leave(KErrCorrupt);

        }

    // source/report Count

    //TInt sourceCount = ( pointer[0] & 0x1F );

    pointer += 2;

    TInt length =static_cast<TInt>( TSRTPUtils::Read16( pointer ) );

    if ( length * 4 > size )

        {

        User::Leave(KErrCorrupt);

        }

    pointer += 2;

    // SSRC of sender in case of RR

    if ( pt == 201 || pt==200 )

        {

	    TUint32 SSRC = TSRTPUtils::Read32( pointer );

	    pointer += 4;

        }

    //RFC 3711 3.4 - RR & SR

    iHeaderLength =pointer-iDataP;

    }

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

// CSRTPPacketRTCP::CountEncryptedPacketSizeL()

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

//

TUint CSRTPPacketRTCP::CountEncryptedPacketSizeL()

    {

   	TUint srtpPacketSize = iHeaderLength + iPayloadLength + KSRTCPPacketIndexLength4;

   	srtpPacketSize += iHandler.Context().MasterKey().MKI().Length();

    if ( iHandler.Context().CryptoParams().iSrtcpAuthAlg == EAuthHMAC_SHA1)

        {

        srtpPacketSize += iHandler.Context().CryptoParams().iSrtcpAuthTagLen/8;

        }

    return srtpPacketSize;

    }

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

// CSRTPPacketRTCP::CreateEncryptedPacketL()

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

//        

HBufC8* CSRTPPacketRTCP::CreateEncryptedPacketL(TUint8* aEncryptedPayloadPtr)

    {

     TUint srtpPacketSize = CountEncryptedPacketSizeL();

    return CopyHeaderAndPayloadL(srtpPacketSize, aEncryptedPayloadPtr);    

    }    

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

// CSRTPPacketRTCP::SetPacketIndex()

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

//

void CSRTPPacketRTCP::SetPacketIndex(TUint64 aPacketIndex)

    {

    iPacketIndex = aPacketIndex;

    }

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

// CSRTPPacketRTCP::PacketIndex()

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

//

TUint64 CSRTPPacketRTCP::PacketIndex()

    {

    return iPacketIndex;

    }

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

// CSRTPPacketRTCP::CreateDecryptedPacketL()

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

//   

HBufC8* CSRTPPacketRTCP::CreateDecryptedPacketL(TUint8* /*aDecryptedPayloadPtr*/)

    { 

    User::Leave(KErrTotalLossOfPrecision);

    return  NULL;           

    }

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

// CSRTPPacketRTCP::AuthenticationTag()

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

//

TPtrC8 CSRTPPacketRTCP::AuthenticationTag()

    {

    return  NULL;            

    }

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

// CSRTPPacketRTCP::MasterKeyIdentifier()

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

//

TPtrC8 CSRTPPacketRTCP::MasterKeyIdentifier()

    {

    return  NULL;            

    }