/*

* Copyright (c) 2006 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:    Implementation of the MCC Crypto Adapter

*

*/

// System includes

#include <e32base.h>

#include <srtpcryptocontext.h>

#include <srtpmasterkey.h>

#include <srtpmastersalt.h>

#include <mmf/common/mmfcontrollerframework.h>

// User include

#include "mmcccryptoadapter.h"

#include "mccrtpdefs.h"

#include "mmcccryptocontext.h"

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

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

// TMccCryptoAdapter::CreateCryptoContextL

// 

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

//    

CSRTPCryptoContext* TMccCryptoAdapter::CreateCryptoContextL( 

                                   const TMccCryptoContext& aContextParams )

    {

	TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::CreateCryptoContextL IN" )

    const TMccSrtpMasterKey mccMasterkey( aContextParams.MasterKey() ); 

    const TMccSrtpMasterSalt mccMasterSalt( aContextParams.MasterSalt() );

    const TMccSrtpCryptoParams mccCryptoParams( aContextParams.CryptoParams() ); 

    // Creates Srtp master key

    CSRTPMasterKey* masterKey = CSRTPMasterKey::NewL( mccMasterkey.iMasterKey,

                                                      mccMasterkey.iMKI,

                                                      mccMasterkey.iEncKeyBitLength,

                                                      mccMasterkey.iAuthKeyBitLength );

    CleanupStack::PushL( masterKey );

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::masterKey - iEncKeyBitLength: %d ", mccMasterkey.iEncKeyBitLength )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::masterKey - iAuthKeyBitLength: %d ", mccMasterkey.iAuthKeyBitLength  )    

    // Creates Srtp master salt                                   

    CSRTPMasterSalt* masterSalt = CSRTPMasterSalt::NewL( mccMasterSalt.iMasterSalt,

                                                         mccMasterSalt.iSaltKeyLength );

    CleanupStack::PushL( masterSalt );

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::masterSalt - iSaltKeyLength: %d ", mccMasterSalt.iSaltKeyLength )    

    // Creates Srtp crypto params

    TSrtpCryptoParams cryptoParams;

    cryptoParams.iSrtpEncAlg = ( TSRTPEncAlg )mccCryptoParams.iSrtpEncAlg;

    cryptoParams.iSrtpAuthAlg = ( TSRTPAuthAlg )mccCryptoParams.iSrtpAuthAlg;

    cryptoParams.iSrtpAuthTagLen = mccCryptoParams.iSrtpAuthTagLen;

    cryptoParams.iPrefixLen = mccCryptoParams.iPrefixLen;

    cryptoParams.iSrtpReplayProtection = mccCryptoParams.iSrtpReplayProtection;

    cryptoParams.iSrtpKeyDervRate = mccCryptoParams.iSrtpKeyDervRate;

    // RTCP Crypto Params

    cryptoParams.iSrtcpEncAlg = ( TSRTPEncAlg )mccCryptoParams.iSrtcpEncAlg;

    cryptoParams.iSrtcpAuthAlg = ( TSRTPAuthAlg )mccCryptoParams.iSrtcpAuthAlg;

    cryptoParams.iSrtcpAuthTagLen = mccCryptoParams.iSrtcpAuthTagLen;

    cryptoParams.iSrtcpReplayProtection = mccCryptoParams.iSrtcpReplayProtection;

    cryptoParams.iSrtcpKeyDervRate = mccCryptoParams.iSrtcpKeyDervRate;

    cryptoParams.iROCTransRate = mccCryptoParams.iROCTransRate;

    cryptoParams.iMasterKeysLifeTime = mccCryptoParams.iMasterKeysLifeTime;

    cryptoParams.iReplayWindowSizeHint = mccCryptoParams.iReplayWindowSizeHint;

    cryptoParams.iIsRCCm3Sync = mccCryptoParams.iIsRCCm3Sync;

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtpEncAlg, [0=null, 1=AES_CM]: %d", ( TUint )cryptoParams.iSrtpEncAlg )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtpAuthAlg [0=null, 1=HMAC_SHA1 2=RCCm1, 3=RCCm2, 4=RCCm3]: %d", ( TUint )cryptoParams.iSrtpAuthAlg )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtpAuthTagLen: %d", cryptoParams.iSrtpAuthTagLen )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iPrefixLen: %d", cryptoParams.iPrefixLen )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtpReplayProtection: %d", cryptoParams.iSrtpReplayProtection )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtpKeyDervRate: %d", cryptoParams.iSrtpKeyDervRate )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT( "" )  

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtcpEncAlg, [0=null, 1=AES_CM] : %d", ( TUint )cryptoParams.iSrtcpEncAlg )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtcpAuthAlg [0=null, 1=HMAC_SHA1 2=RCCm1, 3=RCCm2, 4=RCCm3]: %d", ( TUint )cryptoParams.iSrtcpAuthAlg )   

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtcpAuthTagLen: %d", cryptoParams.iSrtcpAuthTagLen )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtcpReplayProtection: %d", cryptoParams.iSrtcpReplayProtection )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iSrtcpKeyDervRate: %d", cryptoParams.iSrtcpKeyDervRate )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iROCTransRate: %d", cryptoParams.iROCTransRate)

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iMasterKeysLifeTime: %d", cryptoParams.iMasterKeysLifeTime )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iReplayWindowSizeHint: %d", cryptoParams.iReplayWindowSizeHint )

    TRACE_RTP_CRYPTO_ADAPTER_PRINT2( "TMccCryptoAdapter::cryptoParams - iIsRCCm3Sync: %d", cryptoParams.iIsRCCm3Sync )     

    CleanupStack::Pop( masterSalt );

    CleanupStack::Pop( masterKey );

    CSRTPCryptoContext* context = CSRTPCryptoContext::NewL( masterKey,

                                                            masterSalt, 

                                                            cryptoParams );

	TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::CreateCryptoContextL OUT" );   

    return context;   

    };

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

// TMccCryptoAdapter::UpdateCryptoContextL()

// 

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

//   

void TMccCryptoAdapter::UpdateCryptoContextL( const TMccCryptoContext& aContextParams,

                                              CSRTPCryptoContext& aContext )

    {

    TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL IN" )

    const TMccSrtpMasterKey mccMasterkey( aContextParams.MasterKey() ); 

    const TMccSrtpMasterSalt mccMasterSalt( aContextParams.MasterSalt() );

    const TMccSrtpCryptoParams mccCryptoParams( aContextParams.CryptoParams() );

    // Creates Srtp master key

    CSRTPMasterKey* masterKey = CSRTPMasterKey::NewL( mccMasterkey.iMasterKey,

                                                      mccMasterkey.iMKI,

                                                      mccMasterkey.iEncKeyBitLength,

                                                      mccMasterkey.iAuthKeyBitLength );

    CleanupStack::PushL( masterKey );

    CSRTPMasterSalt* masterSalt = CSRTPMasterSalt::NewL( mccMasterSalt.iMasterSalt,

                                                         mccMasterSalt.iSaltKeyLength );

    CleanupStack::PushL( masterSalt );

    if ( EFalse == masterKey->Valid() )

        {

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL Masterkey isn't valid" )

        User::Leave( KErrArgument );

        }

    if ( EFalse == masterSalt->Valid() )

        {

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL Mastersalt isn't valid" )

        User::Leave( KErrArgument );

        } 

    if ( ( aContext.MasterSalt().MasterSalt()).Compare( masterSalt->MasterSalt() ) != 0 )

        {               

        aContext.SetMasterSalt( masterSalt );

        CleanupStack::Pop( masterSalt );

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL MasterSalt Is changed" )  

        }

    else

        {

        CleanupStack::PopAndDestroy( masterSalt );

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL MasterSalt Isn't changed" )   

        }

    if ( ( aContext.MasterKey().MasterKey()).Compare( masterKey->MasterKey() ) != 0 ||

         ( aContext.MasterKey().MKI()).Compare( masterKey->MKI() ) != 0 )

        {               

        aContext.SetMasterKey( masterKey );

        CleanupStack::Pop( masterKey );

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL MasterKey Is changed" ) 

        }

    else

        {

        CleanupStack::PopAndDestroy( masterKey );

        TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL MasterKey Isn't changed" )  

        }

    TRACE_RTP_CRYPTO_ADAPTER_PRINT( "TMccCryptoAdapter::UpdateCryptoContextL OUT" )            

    }

//  End of File