/*

* Copyright (c) 2002-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:    Provides services for SDP Security Descriptions.

*

*/

// INCLUDE FILES

#include    "mcesecuredesstream.h"

#include	"mcemmlogs.h"

#include    <tconvbase64.h> // TImCodecB64

#include    <random.h> 

#include    <e32math.h>

#include 	<sdpdocument.h>

#include    <sdpcodecstringconstants.h>

#include    <sdpcodecstringpool.h>

#include    <sdpmediafield.h>

#include    <sdpfmtattributefield.h>

#include    <sdpattributefield.h>

#include    <mmccsrtpmasterkey.h>

#include    <mmccsrtpmastersalt.h>

#include 	<mmccsecureinterface.h>

#include 	"mcesecuresession.h"

#include 	"mcecomsession.h"

#include 	"mcecommediastream.h"

#include 	"mcesip.h"

#define MSG_IGNORE_RETURN( )\

    if( iGnoreSdpMsg ){ iSecureSession.RemoveSecureCrypto(); return; }

// ============================ MEMBER FUNCTIONS ===============================

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

// CMceSecureDesStream::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMceSecureDesStream::ConstructL(CSdpMediaField& aMediaField)

    {

   	iCryptoOuts = new ( ELeave ) CArrayFixFlat< TMceSecureCryptoInfo >( KCryptoGranularity );

    iCryptoIns = new ( ELeave ) CArrayFixFlat< TMceSecureCryptoInfo >( KCryptoGranularity );

    iMediaField=aMediaField.CloneL();

    }

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

// CMceSecureDesStream::NewL

// Two-phased constructor.

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

//

CMceSecureDesStream* CMceSecureDesStream::NewL( CMceSecureMediaSession& aSecureSession,

												CSdpMediaField& aMediaField,

											CMccSecureInterface& aSecureInterface,

											CMceComMediaStream& aMediaStream)

    {

    CMceSecureDesStream* self = new (ELeave) CMceSecureDesStream(aSecureSession,

    															aSecureInterface,

    															aMediaStream);

    CleanupStack::PushL( self );

    self->ConstructL(aMediaField);

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceSecureDesStream::CMceSecureDesStream

// Two-phased constructor.

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

//

CMceSecureDesStream::CMceSecureDesStream(	CMceSecureMediaSession& aSecureSession,

											CMccSecureInterface& aSecureInterface,

        									CMceComMediaStream& aMediaStream

        									):

	iSecureSession(aSecureSession),

	iSecInf(aSecureInterface),

	iMediaStream(aMediaStream),

	iIsSAVP(ETrue),

	iCryptoContextOutId(0),

	iCryptoContextInId(0),

	iOldLocalMediaPort(0)

	{

    }

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

// CMceSecureDesStream::CMceSecureDesStream

// Destructor

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

//

CMceSecureDesStream::~CMceSecureDesStream()

    {

    if(iCryptoOuts!=NULL)

        {

    	if ( iCryptoOuts->Count() )

    		{

    		iCryptoOuts->Reset();

    		}

        }

    if(iCryptoIns!=NULL)

        {

	    if ( iCryptoIns->Count() )

    		{

    		iCryptoIns->Reset();

    		}

        }

    delete iCryptoOuts;

    delete iCryptoIns;

    iCryptoOut.iMasterKeys.Close();

    iCryptoIn.iMasterKeys.Close();

    iCryptoOut.iSaltKeys.Close();

    iCryptoIn.iSaltKeys.Close();

    iCryptoOut.iEncodedKeys.Close();

    iCryptoIn.iEncodedKeys.Close();

   	iCryptoOut.CryptoDestruct();

   	iCryptoIn.CryptoDestruct();

   	delete iMediaField;

   	delete iMKIBuf;

    }

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

// CMceSecureDesStream::GenerateRandomKeys

// Generates security keys

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

//

void CMceSecureDesStream::GenerateRandomKeys( TMceSecureCryptoInfo& aCrypto )

    {

    MCEMM_DEBUG("CMceSecureDesStream::GenerateRandomKeys, Entry ")

    MCEMM_DEBUG("Generate Keys")

	TBuf8< KMasterKeyAndSaltLength > random;

	RandomString( random );

	// Encode random string

	TBuf8< KEncodedStringLength > encoded;

	Base64Encode( random, encoded );

	aCrypto.ResetKeys();

	aCrypto.iEncodedKey = encoded;

	//added generated masterkey

	aCrypto.iSetMasterKey = random.Mid( 0, KMasterKeyLength );

	//added generated salt key

	aCrypto.iSetSaltKey = random.Mid( KMasterKeyLength );

	aCrypto.iKeysCreated = ETrue;

	random.Zero();

    MCEMM_DEBUG("CMceSecureDesStream::GenerateRandomKeys, Exit ")   

    }

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

// CMceSecureDesStream::EncodeSecureSdpL()

// Generates security key to SDP offer/Answer.

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

//

void CMceSecureDesStream::EncodeSecureSdpL( 

    CSdpMediaField& aMediaField,

    TBool aIsAnswer )

    {

   	MCEMM_DEBUG("CMceSecureDesStream::EncodeSecureSdpL(), Entry ")

    iGnoreSdpMsg = EFalse;

    const TUint8 KCryptoTag = 1;

   	TInt authCount = ClientCrytoCount();

   	authCount = authCount ? authCount : KAuthTagLengthTypeCount;

   	MCEMM_DEBUG_DVALUE("iKeyNeedUpdated", iSecureSession.iKeyNeedUpdated )

  	TBuf8< KCryptoLineMaxLength > cryptoLine;

    if ( aIsAnswer ) 

    	{

    	MCEMM_DEBUG("Encode Secure Answer")

		if ( iSecureSession.iCryptoContextUpdate )

		    {

		    iCryptoOuts->Reset();

		    iSecureSession.iCryptoContextUpdate = EFalse;	

		    }

    	iCryptoOut.iTag = KCryptoTag;

       	GenerateCryptoLineL( cryptoLine, iCryptoOut.iTag, aIsAnswer );

    	if ( !iGnoreSdpMsg && 

    	     KCryptoAttributeValueMinLength <= cryptoLine.Length() &&

             iCryptoOut.iEncodedKey.Length() > 0 )

            {

    		AppendCryptoAttributeL(	cryptoLine, aMediaField );    

    		}

        cryptoLine.Zero();                        

    	}

    else if ( iSecureSession.iKeyNeedUpdated && 

              iSecureSession.iCryptoContextUpdate )

    	{

    	MCEMM_DEBUG("Encode Secure Offer; Crypto Update Required")		

    	iSecureSession.iCryptoContextUpdate = EFalse;

    	TInt tagIndex = 0;

    	TInt tag;

    	iCryptoOuts->Reset();

   		for ( tagIndex = 0; tagIndex < authCount; tagIndex++ )

			{

			tag = tagIndex+1;

			GenerateCryptoLineL( cryptoLine, tag, aIsAnswer );	

		    if ( !iGnoreSdpMsg && 

		         KCryptoAttributeValueMinLength <= cryptoLine.Length() )

		        {

		        AppendCryptoAttributeL(	cryptoLine, aMediaField );  

		        }

			cryptoLine.Zero();

			}

    	}     	

   	else 

   		{ 

   		MCEMM_DEBUG("Encode Updated Offer; No Crypto Update Required")	

   		iCryptoOut.iTag = KCryptoTag;

       	GenerateCryptoLineL( cryptoLine, iCryptoOut.iTag, aIsAnswer );	

		if ( !iGnoreSdpMsg && 

		      KCryptoAttributeValueMinLength <= cryptoLine.Length() &&

              iCryptoOut.iEncodedKey.Length() > 0 )

            {

		    AppendCryptoAttributeL(	cryptoLine, aMediaField );    

		    }	

       	cryptoLine.Zero();                        

   		}       	    

    if ( !iGnoreSdpMsg )

    	{

    	SetSecureProtocolL( aMediaField );

    	iCryptoUpdateNeeded = 

    	    iCryptoUpdateNeeded ? EFalse : iCryptoUpdateNeeded;

    	MCEMM_DEBUG("Encode Secure Crypto Succeeded")

    	}

   	if ( !aMediaField.IsValid() )

   	    {

   	    User::Leave( KErrCorrupt );

   	    }

    MCEMM_DEBUG("CMceSecureDesStream::EncodeSecureSdpL(), Exit")	

    }

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

// CMceSecureDesStream::StoreKeys()

// Store security keys

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

//

void CMceSecureDesStream::StoreKeys( TDesC8& aData )

    {

    //DecodeAnswer or Offer

    //multiple tag

    	/*a=crypto:1 AES_CM_128_HMAC_SHA1_80

       inline:WVNfX19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz|2^20|1:4

       FEC_ORDER=FEC_SRTP

      a=crypto:2 F8_128_HMAC_SHA1_80

       inline:MTIzNDU2Nzg5QUJDREUwMTIzNDU2Nzg5QUJjZGVm|2^20|1:4;

       inline:QUJjZGVmMTIzNDU2Nzg5QUJDREUwMTIzNDU2Nzg5|2^20|2:4

       FEC_ORDER=FEC_SRTP

	*/

    TBuf8 < KMasterKeyAndSaltLength > masterKeyAndSalt;

    Base64Decode( aData, masterKeyAndSalt );

	//it should be validate already so it is our prefered key

	iCryptoIn.iEncodedKey = aData;

	iCryptoIn.iSetMasterKey = masterKeyAndSalt.Mid( 0, KMasterKeyLength );

	iCryptoIn.iSetSaltKey = masterKeyAndSalt.Mid( KMasterKeyLength );

	iCryptoIn.iKeysCreated = ETrue;

    }

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

// CMceSecureDesStream::DecodeSecureSdpL()

// Decode Secure Sdp Offer / Update

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

//

void CMceSecureDesStream::DecodeSecureSdpL( CSdpMediaField& aMediaField )

    {

    MCEMM_DEBUG("CMceSecureDesStream::DecodeSecureSdpL(), Entry")

    MCEMM_DEBUG_DVALUE("iKeyNeedUpdated", iSecureSession.iKeyNeedUpdated )

    iGnoreSdpMsg = EFalse;

    CSdpAttributeField* attributeField = NULL;    

	RPointerArray< CSdpAttributeField > attrList =  

                aMediaField.AttributeFields();

    TInt attrCount = attrList.Count();

    TInt cryptoAttrCount =

        iSecureSession.SdpCryptoAttributeCount( aMediaField );

    iCryptoIns->Reset();

    RemoveClientCrypto();

    for (TInt j = 0; j < attrCount; j++ )

        {

       	attributeField = attrList[ j ];

        RStringF attribute = attributeField->Attribute();

        // check if attribute is 'crypto'

        if ( attribute.DesC().Match(KCrypto)!= KErrNotFound )

            {

           	--cryptoAttrCount;

           	//check how many inline

           	ValidateOfferByAnswerL( attributeField->Value() );

           	if ( !cryptoAttrCount && iGnoreSdpMsg && !iCryptoIns->Count() )

           		{

           		//Last attribute ignored and no valid attributes found

           		User::Leave ( KErrArgument );

           		}

		    if ( !cryptoAttrCount )

		        {

		        break;

		        }

		    }

        }

	if ( iCryptoIns->Count() )

	    {

	    //acceptable crypto suite found, not to be ignored

	    iGnoreSdpMsg = EFalse;

	    }

    if ( !iGnoreSdpMsg && SetMediaProfile ( aMediaField ) == KErrNone )

    	{

    	SetMultipleClientCryptoL( *iCryptoIns );

    	MCEMM_DEBUG(" Set Multiple Client Cryptoto")

    	User::LeaveIfError ( CountCryptoInOffer( aMediaField ) );

    	Session().iIsSecureSession =  !iGnoreSdpMsg ? ETrue : EFalse;

    	}

    MCEMM_DEBUG("CMceSecureDesStream::DecodeSecureSdpL(), Exit")      

    MSG_IGNORE_RETURN()

    }

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

// CMceSecureDesStream::DecodeSecureSdpAnswerL()

// Decode Secure Sdp Offer/Answer

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

//

void CMceSecureDesStream::DecodeSecureSdpAnswerL( CSdpMediaField& aMediaField)

    {

    MCEMM_DEBUG("CMceSecureDesStream::DecodeSecureSdpAnswerL(), Entry")  

    MCEMM_DEBUG_DVALUE("iKeyNeedUpdated", iSecureSession.iKeyNeedUpdated)

    TInt cryptoCount = iSecureSession.SdpCryptoAttributeCount(aMediaField);

    if ( cryptoCount != KCryptoAnswerCount )

    	{

    	User::Leave( KErrArgument );

    	}

	CSdpAttributeField* attr = MediaFieldAttrMatch( aMediaField, KCrypto);    

    // check if attribute is 'crypto' 

    if ( attr )

        {

        ValidateAnswerByOfferL( attr->Value() );

    	if ( !iGnoreSdpMsg  && SetMediaProfile ( aMediaField ) == KErrNone )

			{

			if ( iSecureSession.iKeyNeedUpdated )

				{

				Session().iIsSecureSession = ETrue;

				Session().iClientCryptoSuites.Reset();

				SetClientCryptoL( iCryptoIn );

				}

			if ( iSecureSession.iLSReadyToBind )

				{

				SetCryptoContextL();

				}

			MSG_IGNORE_RETURN()

			if ( !iCryptoIn.iCryptoSuite.Length() )

				{

				User::Leave( KErrArgument );

				}

			MCEMM_DEBUG("Set Crypto Context succeed")  	

			}

		else

			{

			MCEMM_DEBUG("No suitable crypto or malformate crypto session reject")      

			User::Leave( KErrArgument );

			}

		}

    MCEMM_DEBUG("CMceSecureDesStream::DecodeSecureSdpAnswerL(), Exit")    

  	MSG_IGNORE_RETURN()

    }

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

// CMceSecureDesStream::RemvoeSecureSdpL

// Remove Secure Sdp Offer/Answer

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

//

void CMceSecureDesStream::RemvoeSecureSdp(CSdpMediaField& aMediaField)

	{

	MCEMM_DEBUG("CMceSecureDesStream::RemvoeSecureSdpL(), Entry") 

    RStringF mediaType = aMediaField.Media();

    RPointerArray< CSdpAttributeField> attrList =  

                    aMediaField.AttributeFields();

	TInt attrCount = attrList.Count();

    for (TInt index = attrCount; index >0 ; index-- )

        {

        CSdpAttributeField* attributeField = attrList[index-1];

        RStringF attribute = attributeField->Attribute();

                 // check if attribute is 'crypto' 

        if ( KErrNotFound != attribute.DesC().Find( KCrypto ) )

            {   

            TInt removing =aMediaField.AttributeFields().Find(attributeField);

            aMediaField.AttributeFields().Remove(removing);

            delete attributeField;

            attributeField=NULL;

            }

        }

	mediaType.Close();

	MCEMM_DEBUG("CMceSecureDesStream::RemvoeSecureSdpL(), Exit")     

	}

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

// CMceSecureDesStream::SetCryptoContext( )

// Sets crypto context to MCC

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

//

void CMceSecureDesStream::SetCryptoContextL( )

    {

    MCEMM_DEBUG("SetCryptoContext(), Entry")   

    TBool storedIgnoreSdpMsg = EFalse;

    //Check state first if the crypto has been set

    if ( !iCryptoIn.iIfCryptoContextIdSet && 

    	!iCryptoOut.iIfCryptoContextIdSet &&

    	iCryptoIn.iSetMasterKey.Length() && 

    	iCryptoIn.iSetSaltKey.Length() &&

    	iCryptoOut.iSetMasterKey.Length() &&

    	iCryptoOut.iSetSaltKey.Length() )

    	{

    	MCEMM_DEBUG("First Time Bind")

    	CreateCryptoContextL( iCryptoIn );

    	CreateCryptoContextL( iCryptoOut ); 

    	MCEMM_DEBUG_DVALUE( "iCryptoContextOutId", iCryptoIn.iCryptoContextId )

		MCEMM_DEBUG_DVALUE( "iCryptoContextInId", iCryptoOut.iCryptoContextId )

    	iCryptoOuts->Reset();

    	}

    else if ( iCryptoIn.iSetMasterKey.Length() && 

    		iCryptoIn.iSetSaltKey.Length() &&

    	  	iCryptoOut.iSetMasterKey.Length() &&

    	 	iCryptoOut.iSetSaltKey.Length() )

		{

		MCEMM_DEBUG("Bind has done before so this is for updated")  

		if ( iCryptoContextInId != 0  && iCryptoContextOutId != 0 )

			{

			iCryptoIn.iCryptoContextId = iCryptoContextInId;

			iCryptoOut.iCryptoContextId =  iCryptoContextOutId;

			}

		MCEMM_DEBUG_DVALUE( "Updated iCryptoContextOutId", iCryptoIn.iCryptoContextId )

		MCEMM_DEBUG_DVALUE( "Updated iCryptoContextInId", iCryptoOut.iCryptoContextId )

    	if ( iSecureSession.iKeyNeedUpdated )

    		{

    		UpdateCryptoContextL( iCryptoIn ); 

    		storedIgnoreSdpMsg = iGnoreSdpMsg;

    		UpdateCryptoContextL( iCryptoOut ); 

    		iGnoreSdpMsg = iGnoreSdpMsg && storedIgnoreSdpMsg;

    		}

    	else

    		{

    		iWaitingBinding = ETrue;	

    		}

    	iCryptoOuts->Reset(); 

    	}

    iGnoreSdpMsg = (iCryptoIn.iIfCryptoContextIdSet && 

    				iCryptoOut.iIfCryptoContextIdSet ) &&

    				!iGnoreSdpMsg ? EFalse : ETrue;		

    MCEMM_DEBUG("SetCryptoContext(), Exit")

    }

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

// CMceSecureDesStream::CreateCryptoContextL()

// 

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

//     

void CMceSecureDesStream::CreateCryptoContextL( TMceSecureCryptoInfo& aCrypto )

    {

    MCEMM_DEBUG("CMceSecureDesStream::CreateCryptoContextL Entry")

    // if  ESrtpNullAlg == iEncAlgms Fallback to RTP, set NULL policy

    // Create phony master and salt from local values 

    // since remote keys not available

    iWaitingBinding = EFalse;

    TInt err(KErrNone);

    FormMKIL(aCrypto);

    TBuf8<KMKILength> mki;

    mki.Copy( KNullDesC8 );

   	TMccSrtpMasterKey masterKey(aCrypto.iSetMasterKey, mki); 

    if (aCrypto.iMKIUsed && iMKIBuf)

    	{

    	masterKey.iMKI.Copy(iMKIBuf->Des()); 

    	masterKey.iMKI.SetLength(aCrypto.iMKILength);

    	}

    TMccSrtpMasterSalt saltKey( aCrypto.iSetSaltKey);

	TMccSrtpCryptoParams params;

    params.iSrtpEncAlg = aCrypto.iEncAlgms; 

    params.iSrtcpEncAlg = aCrypto.iEncAlgms; 

    params.iSrtpAuthAlg = aCrypto.iAuthAlgms; 

    params.iSrtcpAuthAlg = aCrypto.iAuthAlgms; 

    params.iSrtpAuthTagLen = aCrypto.iTagLen;

    params.iSrtcpAuthTagLen = aCrypto.iTagLen;

    if ( aCrypto.iMKLifeTime )