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




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

_LIT8( KMKINULL, "NULL");
// -----------------------------------------------------------------------------
// CSRTPPacketSRTCP::CSRTPPacketSRTCP
// -----------------------------------------------------------------------------
//
CSRTPPacketSRTCP::CSRTPPacketSRTCP(const TDesC8& aPacket,
                      CSRTPCryptoHandler& aHandler)
    : CSRTPPacketRTCP(aPacket, aHandler),
        iAuthenticationTag(TPtrC8()),       
        iMasterKeyIdentifier(TPtrC8())
            {
            
            }

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

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

// -----------------------------------------------------------------------------
// void CSRTPPacketSRTCP::ConstructL
// -----------------------------------------------------------------------------
//
void CSRTPPacketSRTCP::ConstructL()
    {            
    CSRTPPacketRTCP::ConstructL();
    UpdatePayloadLength();
    UpdatePayload();               
    UpdateAuthenticationTag();    
    UpdateMasterKeyIdentifier();        
    UpdatePacketIndex();     
    }

// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::AuthenticationTag()
// ---------------------------------------------------------------------------
//
TPtrC8 CSRTPPacketSRTCP::AuthenticationTag()
    {
    return iAuthenticationTag;
    }


// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::MasterKeyIdentifier()
// ---------------------------------------------------------------------------
//
TPtrC8 CSRTPPacketSRTCP::MasterKeyIdentifier()
    {
    return iMasterKeyIdentifier;
    }

// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::UpdatePayloadLength()
// ---------------------------------------------------------------------------
//
void CSRTPPacketSRTCP::UpdatePayloadLength()
    {    
     // the real RTCP packet length is 
     // the packet size - header - MKI - Auth tag- packetIndex
     TUint authTagLen = iHandler.Context().CryptoParams().iSrtcpAuthTagLen/8;
     TUint mkiLen=0;
     mkiLen=  iHandler.Context().MasterKey().MKI().Length();  
     TUint deductedLength = iHeaderLength + mkiLen + authTagLen + KSRTCPPacketIndexLength4; 
     iPayloadLength = iPacket.Length() - deductedLength;  
     
     if ( iPacket.Length() <= iHeaderLength )
     	{
     	iPayloadLength = 0;
     	}
    // iPayloadLength should be bigger than 0 
    }
    
    
// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::CountDecryptedPacketSize()
// ---------------------------------------------------------------------------
//
TUint CSRTPPacketSRTCP::CountDecryptedPacketSize()
    {
    return iHeaderLength + iPayloadLength;    
    }    
    
// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::CreateDecryptedPacketL()
// ---------------------------------------------------------------------------
//
HBufC8* CSRTPPacketSRTCP::CreateDecryptedPacketL(TUint8* aDecryptedPayloadPtr)
    {
    // create decrypted RTCP packet
    // first count needed packet size
    TUint rtpPacketSize = CountDecryptedPacketSize();
    
    return CopyHeaderAndPayloadL(rtpPacketSize, aDecryptedPayloadPtr);
    
    }

// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::UpdateAuthenticationTag()
// ---------------------------------------------------------------------------
//
void CSRTPPacketSRTCP::UpdateAuthenticationTag()
    {       
       TPtrC8 authTag = GetAuthenticationTag();    
       if (authTag.Compare(KNullDesC8))
       	{
       	iAuthenticationTag.Set(authTag.Ptr(), authTag.Length());	
       	}
       
    }    
// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::GetAuthenticationTagL()
// ---------------------------------------------------------------------------
//
TPtrC8 CSRTPPacketSRTCP::GetAuthenticationTag()
    { 
    // for RTCP, authTagLength existed only with HMAC_SHA1     
    if ((iHandler.Context().CryptoParams().iSrtcpAuthTagLen > 0) && 
        (iHandler.Context().CryptoParams().iSrtcpAuthAlg != EAuthNull))
        {
         TUint authTagLength = iHandler.Context().CryptoParams().iSrtcpAuthTagLen;
         
         TUint authTagLenInBytes = authTagLength/8;
         
         if (iHandler.Context().CryptoParams().iSrtcpAuthAlg != EAuthHMAC_SHA1)
         	{
         	authTagLenInBytes = KSRTPAuthTagLength80/8;
         	}
         		
         TUint packetLength = iPacket.Length();
         TUint position = packetLength - authTagLenInBytes;
         
         return iPacket.Mid(position,authTagLenInBytes);
        }
    //In case of the other Authentication mode
    TPtrC8 authTagNull(KNullDesC8);
    return  authTagNull;    
    }

// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::GetMasterKeyIdentifier()
// ---------------------------------------------------------------------------
//
TPtrC8 CSRTPPacketSRTCP::GetMasterKeyIdentifier()
    {
    if(iHandler.Context().MasterKey().MKI()!= KNullDesC8)
    	{    
	    TInt mkiLength = iHandler.Context().MasterKey().MKI().Length();
	    if (iHandler.Context().MasterKey().MKI().Length() > 0)
	        {
	         TUint authTagLength = iHandler.Context().CryptoParams().iSrtcpAuthTagLen;
	         TUint authTagLenInBytes = authTagLength/8;
	         TUint position = iPacket.Length() - authTagLenInBytes - mkiLength;
	                                
	         return iPacket.Mid(position,mkiLength);
	        }
    	}
    TPtrC8 mkiNull( KMKINULL );
    return  mkiNull; 
    }    
            
// ---------------------------------------------------------------------------
// CSRTPPacketSRTCP::UpdateMasterKeyIdentifier()
// ---------------------------------------------------------------------------
//
void CSRTPPacketSRTCP::UpdateMasterKeyIdentifier()
    {    
     TPtrC8 mki = GetMasterKeyIdentifier();
     if (mki.Compare( KMKINULL ))
     	{
     	iMasterKeyIdentifier.Set(mki.Ptr(),mki.Length());	
     	}
    }    
    
// ---------------------------------------------------------------------------
// CSRTPPacketRTP::UpdatePacketIndex()
// ---------------------------------------------------------------------------
//
void CSRTPPacketSRTCP::UpdatePacketIndex()
    {
    const TUint8 *pointer = iDataP;	
	pointer+=iHeaderLength;
	pointer+= iPayloadLength;//payload length as SRTCP report length
    
     
    iPacketIndex=static_cast<TUint32>(TSRTPUtils::Read32(pointer));
    }