/*

* 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:    .

*

*/

// INCLUDES

#include <e32std.h>

#include "srtpmasterkey.h"

#include "srtpmastersalt.h"

#include "srtpcryptohandler.h"

#include "srtpdef.h"

#include "srtpcryptocontext.h"

#include "srtpcryptoparams.h"

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

// Two-phased constructor. Used when stream uses its own cryptographic context

// 

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

//

EXPORT_C CSRTPCryptoContext* CSRTPCryptoContext::NewL( const CSRTPMasterKey* aKey,

                                            const CSRTPMasterSalt* aSalt, 

                                            const TSrtpCryptoParams& aCryptoParams)

    {

    CSRTPCryptoContext* self = CSRTPCryptoContext::NewLC( aKey,

                                                           aSalt,

                                                           aCryptoParams );

    CleanupStack::Pop( self );    

    return self;

    }	

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

// Two-phased constructor. Used when stream uses its own cryptographic context

// 

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

//

EXPORT_C CSRTPCryptoContext* CSRTPCryptoContext::NewLC( const CSRTPMasterKey* aKey,

                                            const CSRTPMasterSalt* aSalt,

                                            const TSrtpCryptoParams& aCryptoParams)

    {

    CSRTPCryptoContext* self = new( ELeave )CSRTPCryptoContext( aCryptoParams );

    CleanupStack::PushL( self );    

    self->ConstructL( aKey, aSalt );

    return self;

    }	

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

// CSRTPCryptoContext::CSRTPCryptoContext

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

//

CSRTPCryptoContext::CSRTPCryptoContext(  const TSrtpCryptoParams& aCryptoParams) :

            iHandlerList(CSRTPCryptoHandler::iHandlerOffset), 

            iHandlerIter( iHandlerList ),                           

            iCryptoParams (aCryptoParams)

            {

            }

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

// CSRTPCryptoContext::ConstructL

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

//

void CSRTPCryptoContext::ConstructL( const CSRTPMasterKey* aKey,

                                     const CSRTPMasterSalt* aSalt)

	{

    if( !aKey || !aSalt )

        {

        User::Leave( KErrNoMemory );

        }

    else

        {

        iKey = aKey;

        iSalt = aSalt;

        }

    if (!Valid())

    	{

    	User::Leave(KErrArgument);

    	}

    }

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

// CSRTPCryptoContext::CSRTPCryptoContext

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

//

CSRTPCryptoContext::~CSRTPCryptoContext( )

    {

    delete iKey; iKey=NULL;

    delete iSalt; iSalt=NULL;

    iHandlerList.Reset();

    }

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

// CSRTPCryptoContext::SetMasterKey()

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

//

EXPORT_C void CSRTPCryptoContext::SetMasterKey(const CSRTPMasterKey* aKey) 

    {

    if (iKey)

    	{

    	delete iKey; 

    	iKey=NULL;	

    	}

    iKey = aKey;

    CSRTPCryptoHandler* handler;

    iHandlerIter.SetToFirst();

    while( ( handler = iHandlerIter++ ) != NULL )

        {

        handler->SRTPMasterKeyChanged();        

        }

    }

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

// CSRTPCryptoContext::SetMasterSalt()

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

//

EXPORT_C  void CSRTPCryptoContext::SetMasterSalt(const CSRTPMasterSalt* aSalt) 

    {

    if(iSalt)

    	{

    	delete iSalt;

    	iSalt = NULL;	

    	}

    iSalt = aSalt;

    CSRTPCryptoHandler* handler;

    iHandlerIter.SetToFirst();

    while( ( handler = iHandlerIter++ ) != NULL )

        {

        handler->SRTPMasterSaltChanged();        

        }

    }

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

// CSRTPCryptoContext::AddCryptoChangeObserver()

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

//

 void CSRTPCryptoContext::AddCryptoChangeObserver(CSRTPCryptoHandler *aObserver)

    {

    iHandlerList.AddLast(*aObserver);

    }

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

// CSRTPCryptoContext::RemoveCryptoChangeObserver()

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

//

 void CSRTPCryptoContext::RemoveCryptoChangeObserver(CSRTPCryptoHandler *aObserver)

    {   

    if (!iHandlerList.IsEmpty() && FindHandler(aObserver))

        {

        iHandlerList.Remove(*aObserver);

        }

    }

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

// CSRTPCryptoContext::MasterKey()

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

//

EXPORT_C  const CSRTPMasterKey& CSRTPCryptoContext::MasterKey() const 

    {

    return *iKey;

    }

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

// CSRTPCryptoContext::MasterSalt()

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

//

EXPORT_C  const CSRTPMasterSalt& CSRTPCryptoContext::MasterSalt() const

    {

    return *iSalt;

    }

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

// CSRTPCryptoContext::CryptoParams()

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

//

EXPORT_C const TSrtpCryptoParams& CSRTPCryptoContext::CryptoParams() 

    {

    return iCryptoParams;

    }

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

// CSRTPCryptoContext::SetRCCm3Sync()

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

//

EXPORT_C void CSRTPCryptoContext::SetRCCm3Sync(TBool aSync)

	{

	iCryptoParams.iIsRCCm3Sync = aSync;

	}

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

// CSRTPCryptoContext::IsEqual()

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

//

TBool CSRTPCryptoContext::IsEqual(const CSRTPCryptoContext& aContext)

	{

	TBool isEqual= EFalse;

	if (!aContext.iKey->iKey->Compare(iKey->iKey->Des()) && 

		!aContext.iSalt->iKey->Compare(iSalt->iKey->Des()) &&

		!aContext.iKey->iMKI->Compare(iKey->iMKI->Des()))

		{

		if (aContext.iCryptoParams.iSrtpEncAlg==iCryptoParams.iSrtpEncAlg &&

			aContext.iCryptoParams.iSrtpEncAlg==iCryptoParams.iSrtcpEncAlg &&

			aContext.iCryptoParams.iSrtpAuthAlg==iCryptoParams.iSrtpAuthAlg  &&

			aContext.iCryptoParams.iSrtcpAuthAlg==iCryptoParams.iSrtcpAuthAlg &&

			aContext.iCryptoParams.iSrtpAuthTagLen==iCryptoParams.iSrtpAuthTagLen &&

			aContext.iCryptoParams.iSrtcpAuthTagLen==iCryptoParams.iSrtcpAuthTagLen &&

			aContext.iCryptoParams.iSrtpKeyDervRate==iCryptoParams.iSrtpKeyDervRate &&

			aContext.iCryptoParams.iSrtcpKeyDervRate==iCryptoParams.iSrtcpKeyDervRate &&

			aContext.iCryptoParams.iSrtpReplayProtection==iCryptoParams.iSrtpReplayProtection &&

			aContext.iCryptoParams.iSrtcpReplayProtection==iCryptoParams.iSrtcpReplayProtection &&

			aContext.iCryptoParams.iROCTransRate==iCryptoParams.iROCTransRate &&

			aContext.iCryptoParams.iMasterKeysLifeTime==iCryptoParams.iMasterKeysLifeTime &&

			aContext.iCryptoParams.iReplayWindowSizeHint==iCryptoParams.iReplayWindowSizeHint &&

			aContext.iCryptoParams.iIsRCCm3Sync==iCryptoParams.iIsRCCm3Sync)

		   		return !isEqual;

		}

	return isEqual;

	}

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

// CSRTPCryptoContext::operator=

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

//

const CSRTPCryptoContext& CSRTPCryptoContext::operator=(const CSRTPCryptoContext& aContext)

    {

    return aContext;

    }

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

// CSRTPCryptoContext::UpdateCryptoParams

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

//

void CSRTPCryptoContext::UpdateCryptoParams(const  TSrtpCryptoParams& aCryptoParams )

	{

	iCryptoParams = aCryptoParams;

	}

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

// CSRTPCryptoContext::FindCryptoHandler

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

//       

TBool CSRTPCryptoContext::FindHandler( CSRTPCryptoHandler *aObserver )

	{

	TBool found=EFalse;

	CSRTPCryptoHandler* handler=NULL;

	iHandlerIter.SetToFirst();

	handler =iHandlerIter;

	while ((handler=iHandlerIter++)!=NULL)

			{

			if (handler == aObserver)

				{

				found = ETrue;

				return found;

				}

			}

	return found;

	}

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

// CSRTPCryptoContext::Valid()

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

//        

EXPORT_C  TBool CSRTPCryptoContext::Valid() const

    {

    if (!(iKey->Valid()))

        {

        return EFalse;

        }    

    if (!(iSalt->Valid()))

        {

        return EFalse;

        }    

    if ((iCryptoParams.iSrtpEncAlg!=EEncAES_CM &&

          iCryptoParams.iSrtpEncAlg!=ENullAlg) ||( 

         iCryptoParams.iSrtcpEncAlg!=EEncAES_CM &&

        	iCryptoParams.iSrtcpEncAlg!=ENullAlg))

        {

        return EFalse;

        }  

    if ((iCryptoParams.iSrtpAuthAlg!=EAuthHMAC_SHA1 &&

          iCryptoParams.iSrtpAuthAlg!=EAuthNull  &&

          iCryptoParams.iSrtpAuthAlg!=EAuthRCCm1 &&

          iCryptoParams.iSrtpAuthAlg!=EAuthRCCm2 &&

          iCryptoParams.iSrtpAuthAlg!=EAuthRCCm3 ) || 

          (iCryptoParams.iSrtcpAuthAlg!=EAuthHMAC_SHA1 &&

          iCryptoParams.iSrtcpAuthAlg!=EAuthNull ))

        {

        return EFalse;

        }  

	if (iCryptoParams.iSrtpAuthAlg==EAuthHMAC_SHA1 &&

		(iCryptoParams.iSrtpAuthTagLen!=KSRTPAuthTagLength80 &&

		iCryptoParams.iSrtpAuthTagLen!=KSRTPAuthTagLength32

		))

		{

		return EFalse;

		}

	if (iCryptoParams.iSrtcpAuthAlg==EAuthHMAC_SHA1 &&

		(iCryptoParams.iSrtcpAuthTagLen!=KSRTPAuthTagLength80 &&

		iCryptoParams.iSrtcpAuthTagLen!=KSRTPAuthTagLength32

		))

		{

		return EFalse;

		}	

    if ((iCryptoParams.iSrtpAuthAlg==EAuthRCCm1 ||

          iCryptoParams.iSrtpAuthAlg==EAuthRCCm2 ) && 

          iCryptoParams.iSrtpAuthTagLen != KSRTPAuthTagLength112)

        {

        return EFalse;

        }  

	if (iCryptoParams.iSrtpAuthAlg==EAuthRCCm3 && 

          iCryptoParams.iSrtpAuthTagLen != KSRTPAuthTagLength32)

        {

        return EFalse;

        }  

	if ((iCryptoParams.iSrtpAuthAlg==EAuthNull  && 

          iCryptoParams.iSrtpAuthTagLen != 0)||(

          iCryptoParams.iSrtcpAuthAlg==EAuthNull  && 

          iCryptoParams.iSrtcpAuthTagLen != 0))

        {

        return EFalse;

        }  

    if (iCryptoParams.iPrefixLen!=KSRTPPrefixLength)

        {

        return EFalse;

        }  

    if (!iCryptoParams.iROCTransRate)

        {

        return EFalse;

        }      

    return ETrue;

    }