/*

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

*

*/

// INCLUDES

#include "srtppacketsrtp.h"

#include "srtpcryptohandler.h"

#include "srtpcryptocontext.h"

#include "srtpmasterkey.h"

#include "srtpmastersalt.h"

#include "srtputils.h"

_LIT8( KMKINULL, "NULL");

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

// CSRTPPacketSRTP::CSRTPPacketSRTP

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

//

CSRTPPacketSRTP::CSRTPPacketSRTP(const TDesC8& aPacket,

                      CSRTPCryptoHandler& aHandler)

    : CSRTPPacketRTP(aPacket, aHandler),

        iAuthenticationTag(TPtrC8()),       

        iMasterKeyIdentifier(TPtrC8())

            {

            }

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

// CSRTPPacketSRTP::~CSRTPPacketSRTP

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

//

CSRTPPacketSRTP::~CSRTPPacketSRTP()

            {

            }

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

// Two-phased constructor. 

// 

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

//

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

                      CSRTPCryptoHandler& aHandler)

    {

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

    CleanupStack::PushL( self );    

    self->ConstructL();

    CleanupStack::Pop( self );        

    return self;

    }

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

// void CSRTPPacketSRTP::ConstructL

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

//

void CSRTPPacketSRTP::ConstructL()

    {            

    CSRTPPacketRTP::ConstructL();

    UpdatePayloadLengthL();

    SRTP_DEBUG_TINT_VALUE( "SRTP payload length", iPayloadLength );

    UpdatePayload();               

    UpdateAuthenticationTagL();    

    UpdateMasterKeyIdentifier();        

    }

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

// CSRTPPacketSRTP::AuthenticationTag()

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

//

TPtrC8 CSRTPPacketSRTP::AuthenticationTag()

    {

    SRTP_DEBUG_DETAIL( "SRTP HMAC authen tag and the tag in the packet" );

    SRTP_DEBUG_PACKET( iAuthenticationTag );    

    return iAuthenticationTag;

    }

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

// CSRTPPacketSRTP::MasterKeyIdentifier()

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

//

TPtrC8 CSRTPPacketSRTP::MasterKeyIdentifier()

    {

    return iMasterKeyIdentifier;

    }

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

// CSRTPPacketSRTP::UpdatePayloadLengthL()

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

//

void CSRTPPacketSRTP::UpdatePayloadLengthL()

    {    

    SRTP_DEBUG_DETAIL( "CSRTPPacketSRTP::UpdatePayloadLengthL ENTRY" );

     // the real RTP packet length is 

     // the packet size - header - MKI - Auth tag

     // Need implementation of caculating RCC

     // when RCC is not included but the tag length is 14 or 8

     TUint rocLength=KSRTPROCLength4;

     TUint authTagLen=0;

     authTagLen = iHandler.Context().CryptoParams().iSrtpAuthTagLen/8;	

     if (!TagWithROCLengthL() && (

     	iHandler.Context().CryptoParams().iSrtpAuthAlg  == EAuthRCCm2 ||

     	iHandler.Context().CryptoParams().iSrtpAuthAlg  == EAuthRCCm3))

     	{

     	authTagLen -= rocLength;

     	}

     if (!TagWithROCLengthL() && (

     	iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthRCCm1))

     	{

     	authTagLen=0;

     	}	

     TUint deductedLen = HeaderLength() + iHandler.Context().MasterKey().MKI().Length() + authTagLen;     

     iPayloadLength = iPacket.Length() - deductedLen;    

     if ( iPacket.Length() <= HeaderLength() )

     	{

     	iPayloadLength = 0;

     	}	

    SRTP_DEBUG_TINT_VALUE( "SRTP payload length", iPayloadLength);

    SRTP_DEBUG_DETAIL( "CSRTPPacketSRTP::UpdatePayloadLengthL EXIT" );

    }

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

// CSRTPPacketSRTP::CountDecryptedPacketSize()

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

//

TUint CSRTPPacketSRTP::CountDecryptedPacketSize()

    {

    return iHeaderLength + iPayloadLength;    

    }    

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

// CSRTPPacketSRTP::CreateDecryptedPacketL()

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

//

HBufC8* CSRTPPacketSRTP::CreateDecryptedPacketL(TUint8* aDecryptedPayloadPtr)

    {

    // create decrypted RTP packet

    // first count needed packet size

    TUint rtpPacketSize = CountDecryptedPacketSize();

    return CopyHeaderAndPayloadL(rtpPacketSize, aDecryptedPayloadPtr);

    }

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

// CSRTPPacketSRTP::UpdateAuthenticationTag()

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

//

void CSRTPPacketSRTP::UpdateAuthenticationTagL()

    {       

    //Here means MAC part

    TPtrC8 authTag = GetAuthenticationTagL();  

    if (authTag.Compare(KNullDesC8))

       	{     

    	iAuthenticationTag.Set(authTag.Ptr(), authTag.Length());

       	}

    }    

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

// CSRTPPacketSRTP::GetAuthenticationTag()

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

//

TPtrC8 CSRTPPacketSRTP::GetAuthenticationTagL()

    {       

    if ((iHandler.Context().CryptoParams().iSrtpAuthTagLen > 0) && 

        iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthHMAC_SHA1)

        {

         TUint authTagLength = iHandler.Context().CryptoParams().iSrtpAuthTagLen;

         TUint authTagLenInBytes = authTagLength/8;

         TUint packetLength = iPacket.Length();

         TUint position = packetLength - authTagLenInBytes;

         return iPacket.Mid(position,authTagLenInBytes);

        }

     if ((iHandler.Context().CryptoParams().iSrtpAuthTagLen > 0) &&

     	((iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthRCCm1 && 

     		TagWithROCLengthL()) ||

        iHandler.Context().CryptoParams().iSrtpAuthAlg == EAuthRCCm2))

     	{

     	TUint authTagLength = iHandler.Context().CryptoParams().iSrtpAuthTagLen;

     	TUint authTagLenInBytes = authTagLength/8;//14

     	//Here we only need MAC part

     	authTagLenInBytes-= 4;

     	TUint packetLength = iPacket.Length();

        TUint position = packetLength - authTagLenInBytes;

        return iPacket.Mid(position,authTagLenInBytes);

     	}  

    // in case of EAuthRCCm3 and EAuthNULL  	 

    TPtrC8 authTagNull(KNullDesC8);

    return  authTagNull;    

    } 

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

// CSRTPPacketSRTP::GetMasterKeyIdentifier()

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

//

TPtrC8 CSRTPPacketSRTP::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().iSrtpAuthTagLen;

	         TUint authTagLenInBytes = authTagLength/8;

	         TUint position = iPacket.Length() - authTagLenInBytes - mkiLength;

	         return iPacket.Mid(position,mkiLength);

	        }

    	}

    TPtrC8 mkiNull( KMKINULL );

    return  mkiNull; 

    }    

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

// CSRTPPacketSRTP::UpdateMasterKeyIdentifierL()

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

//

void CSRTPPacketSRTP::UpdateMasterKeyIdentifier()

    {    

     TPtrC8 mki = GetMasterKeyIdentifier();

     if (mki.Compare( KMKINULL ))

     	{

     	iMasterKeyIdentifier.Set(mki.Ptr(),mki.Length());	

     	}

    }