/*
* 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 packet handling routines.
*
*/




// INCLUDES
#include "srtppacketrtp.h"
#include "srtputils.h"
#include "srtpcryptohandler.h"
#include "srtpcryptocontext.h"
#include "srtpmasterkey.h"
#include "srtpmastersalt.h"

// -----------------------------------------------------------------------------
// CSRTPPacketRTP::CSRTPPacketRTP
// -----------------------------------------------------------------------------
//
CSRTPPacketRTP::CSRTPPacketRTP(const TDesC8& aPacket,
                   CSRTPCryptoHandler& aHandler)
    : CSRTPPacket(aPacket, aHandler),
        iSequenceNumber(0),
        iPacketIndex(0)
            {
            
            }

// -----------------------------------------------------------------------------
// CSRTPPacketRTP::~CSRTPPacketRTP
// -----------------------------------------------------------------------------
//
CSRTPPacketRTP::~CSRTPPacketRTP()
            {
            
            }

// ---------------------------------------------------------------------------
// Two-phased constructor. 
// 
// ---------------------------------------------------------------------------
//
CSRTPPacketRTP* CSRTPPacketRTP::NewL(const TDesC8& aPacket,
                      CSRTPCryptoHandler& aHandler)
    {
    CSRTPPacketRTP* self = new( ELeave )CSRTPPacketRTP( aPacket, aHandler);
    CleanupStack::PushL( self );    
    self->ConstructL();
    CleanupStack::Pop( self );        
    return self;
    }

// -----------------------------------------------------------------------------
// void CSRTPPacketRTP::ConstructL
// -----------------------------------------------------------------------------
//
void CSRTPPacketRTP::ConstructL()
    {            
    CSRTPPacket::ConstructL(); 
    UpdateHeaderLengthL();
    
    SRTP_DEBUG_TINT_VALUE( "RTP header length", iHeaderLength );
        
    UpdateSequenceNumber();        
    UpdatePayloadLength();
    
    SRTP_DEBUG_TINT_VALUE( "RTP payload length", iPayloadLength );
     
    UpdatePayload();           
    
    }
// ---------------------------------------------------------------------------
// CSRTPPacketRTP::UpdateHeaderLengthL()
// ---------------------------------------------------------------------------
//
void CSRTPPacketRTP::UpdateHeaderLengthL()
    {    
    //TUint payloadOffset = KMinSizeRtpHeader;
    TInt size = iPacket.Length();
    if (size < KMinSizeRtpHeader)
    	{
    	User::Leave(KErrCorrupt);
    	}
	const TUint8 *pointer = iDataP;	

    //CC
    TUint8 numCSRC = static_cast<TUint8>( iDataP[0] & 0x0F );
    
    //header extension
    TUint8 headerExt = static_cast<TUint8>( ( iDataP[0] & 0x10 ) >> 4 );    
    
    //go to the end of SSRC
    pointer +=KMinSizeRtpHeader;
    
    if (numCSRC)
        {
        pointer += numCSRC * 4;  
        }
    
    if (headerExt)
        {        
        // Make sure there is a header extension to read
        if ( ( size - ( pointer - iDataP ) ) < 4 )
            {
            User::Leave(KErrCorrupt);
            }

        // bypass header extension type
        pointer += 2;

        // header extension length in number of 32-bit words
        TUint16 extLength = TSRTPUtils::Read16( pointer );
        pointer += 2;

		// jump the extension length
        pointer += extLength * 4;

        // Make sure the extension length is valid
        if ( (size - ( pointer - iDataP ) ) < (extLength * 4) )
            {
            User::Leave(KErrCorrupt);            
            }         
        }
    
    iHeaderLength = pointer - iDataP;
    if ( iHeaderLength > size )
    	{
    	User::Leave( KErrCorrupt );
    	}
    }

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::UpdatePayloadLength()
// ---------------------------------------------------------------------------
//
void CSRTPPacketRTP::UpdatePayloadLength()
    {    
     // In RTP case the payload length is easy to calculate
     //This is only for sending the packe while payload is 512bits 
    TInt packetlen= iPacket.Length() - iHeaderLength;
   	iPayloadLength = packetlen;
   	if ( iPacket.Length() <= iHeaderLength )
     	{
     	iPayloadLength = 0;
     	}
    }

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::UpdateSeqNumber()
// ---------------------------------------------------------------------------
//
void CSRTPPacketRTP::UpdateSequenceNumber( )
    {
//    search the Seq number and update iCurrentSeq here
	const TUint8 *pointer = iDataP;	
	pointer+=2;
    
    iSequenceNumber = static_cast<TUint16>( TSRTPUtils::Read16( pointer ) );
    }


// ---------------------------------------------------------------------------
// CSRTPPacketRTP::CountEncryptedPacketSizeL()
// ---------------------------------------------------------------------------
//
TUint CSRTPPacketRTP::CountEncryptedPacketSizeL()
    {
    TUint srtpPacketSize = iHeaderLength + iPayloadLength;
    	srtpPacketSize += iHandler.Context().MasterKey().MKI().Length();  
	//in Normal case
    if ( iHandler.Context().CryptoParams().iSrtpAuthAlg != EAuthNull )
        {
        srtpPacketSize += iHandler.Context().CryptoParams().iSrtpAuthTagLen/8;
        }
    if (!TagWithROCLengthL() &&(
    	iHandler.Context().CryptoParams().iSrtpAuthAlg != EAuthNull &&
    	iHandler.Context().CryptoParams().iSrtpAuthAlg != EAuthHMAC_SHA1))
    	{
    	srtpPacketSize -= KSRTPROCLength4;
    	}
    if (!TagWithROCLengthL() &&
    	iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthRCCm1)
    	{
    	srtpPacketSize -= (KSRTPAuthTagLength80/8);
    	}	
    return srtpPacketSize;
    }
        
        
// ---------------------------------------------------------------------------
// CSRTPPacketRTP::CreateEncryptedPacketL()
// ---------------------------------------------------------------------------
//
HBufC8* CSRTPPacketRTP::CreateEncryptedPacketL(TUint8* aEncryptedPayloadPtr)
    {
    // create encrypted SRTP packet
    // first count needed packet size
    TUint srtpPacketSize = CountEncryptedPacketSizeL();
    
    return CopyHeaderAndPayloadL(srtpPacketSize, aEncryptedPayloadPtr);    
    }

    
// ---------------------------------------------------------------------------
// CSRTPPacketRTP::CountSenderPacketIndex()
// ---------------------------------------------------------------------------
//
void CSRTPPacketRTP::CountSenderPacketIndex()
    {   
    TUint32 roc= iHandler.ROC();//note it uses local ROC
    
    iPacketIndex = ((65536/*K2EXP16*/* roc) + iSequenceNumber);
    
    }

    
// ---------------------------------------------------------------------------
// CSRTPPacketRTP::SequenceNumber()
// ---------------------------------------------------------------------------
//
TUint16 CSRTPPacketRTP::SequenceNumber()
    {
    return iSequenceNumber;
    }

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::PacketIndex()
// ---------------------------------------------------------------------------
//
TUint64 CSRTPPacketRTP::PacketIndex()
    {
    return iPacketIndex;
    }

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::SetPacketIndex()
// ---------------------------------------------------------------------------
//
void CSRTPPacketRTP::SetPacketIndex(TUint64 aPacketIndex)
    {
    iPacketIndex = aPacketIndex;
    }

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::GetSenderROC
// ---------------------------------------------------------------------------
//
TUint32 CSRTPPacketRTP::GetSenderROC()    
	{
	//Note that SenderROC is now only attached with RTP/SRTP packet
	/*RCCm1 and RCCm2
	Only when SEQ % R (ROC transmission rate) =0
	Then there is attached sender ROC in the packet 4 octets before MAC
	so after payload there is 14 (4+ 10) octets if HMAC-SHA1-80 is used
	*/
	/*RCCm3
	Only when SEQ % R (ROC transmission rate )=0
	Then there is attached sender ROC in the packet 4 octets after packet payload
	but no MAC
	*/
	const TUint8 *pointer = iDataP;	
	pointer+= iHeaderLength;
	pointer+= iPayloadLength;
	pointer+= iHandler.Context().MasterKey().MKI().Length();  
    iSenderROC = static_cast<TUint16>( TSRTPUtils::Read32( pointer ) );
	
	//return
	return iSenderROC;
	}

// ---------------------------------------------------------------------------
// CSRTPPacketRTP::TagWithROCLengthL()
// ---------------------------------------------------------------------------
//
TBool CSRTPPacketRTP::TagWithROCLengthL()
	{
	//mode 1 and 2 add ROC when SEQ%TransRate =0
	//mode 1 will not have any tag if SEQ%TransRate !=0
	TReal remainder;
	TUint16 rate = iHandler.Context().CryptoParams().iROCTransRate;
	User::LeaveIfError( Math::Mod(remainder ,iSequenceNumber,rate));
	if (remainder==0 && 
		((iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthRCCm1 )||
		(iHandler.Context().CryptoParams().iSrtpAuthAlg  == EAuthRCCm2) ||
		(iHandler.Context().CryptoParams().iSrtpAuthAlg  == EAuthRCCm3)))
		{
		return ETrue;
		}
	return EFalse;
	}


    
// VIRTUAL functions    
HBufC8* CSRTPPacketRTP::CreateDecryptedPacketL(TUint8* /*aDecryptedPayloadPtr*/)
    {    
    ////should call inherited class
    User::Leave(KErrTotalLossOfPrecision);
    return  NULL;    
    }

TPtrC8 CSRTPPacketRTP::AuthenticationTag()
    {   
    //should call inherited class
    return  NULL;     
    }

TPtrC8 CSRTPPacketRTP::MasterKeyIdentifier()
    {
    ////should call inherited class
    return  NULL;        
    }