/*
* 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:    Represents an SRTP stream.
*
*/




// INCLUDES
#include "srtpstreamout.h"
#include "tsrtpstreamoutstatebase.h"
#include "tsrtpstreamoutstateuninit.h"
#include "tsrtpstreamoutstatenormal.h"
#include "srtpsession.h"
#include "srtpcryptohandler.h"
#include "srtpcryptohandlersrtp.h"
#include "srtpcryptohandlersrtcp.h"
#include "srtputils.h"

// ---------------------------------------------------------------------------
// Two-phased constructor. Used when stream uses default cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamOut* CSRTPStreamOut::NewL( CSRTPSession& aSession, TUint aSSRC )
    {
    CSRTPStreamOut* self = new( ELeave )CSRTPStreamOut( aSession, aSSRC);
    CleanupStack::PushL( self );    
    self->ConstructL();
    CleanupStack::Pop( self );        
    return self;
    }

// ---------------------------------------------------------------------------
// Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamOut* CSRTPStreamOut::NewL( CSRTPSession& aSession,
                                       TUint aSSRC,
                                       CSRTPCryptoContext* aCon,
                                       MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamOut* self = new( ELeave )CSRTPStreamOut( aSession, aSSRC, 
                                                      aCon, aObs);
    CleanupStack::PushL( self );    
    TRAPD( err, self->ConstructL() );
    if ( err )
        {
        self->iStrmSpecificCrypto = EFalse; // Cannot take ownership
        User::Leave( err );
        }
    CleanupStack::Pop( self );        
    return self;
    }	

// ---------------------------------------------------------------------------
// Used when crypto context will be set later to this stream
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamOut* CSRTPStreamOut::NewL( CSRTPSession& aSession,
                                       TUint aSSRC,
                                       MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamOut* self = new( ELeave )CSRTPStreamOut( aSession, aSSRC, 
                                                       aObs);
         
    return self;
    }	

// ---------------------------------------------------------------------------
// CSRTPStreamOut::CSRTPStreamOut
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamOut::CSRTPStreamOut( CSRTPSession& aSession,
                                      TUint aSSRC)
    :   CSRTPStream(aSession, aSSRC, EFalse),
        iStates(MSRTPStreamOutContext::EMaxStates),
        iCurrentRTPState(ESRTPStreamOutUninitialized),
        iCurrentRTCPState(ESRTPStreamOutUninitialized)
    {
    
    }

// ---------------------------------------------------------------------------
// CSRTPStreamOut::CSRTPStreamOut
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamOut::CSRTPStreamOut( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      CSRTPCryptoContext* aCon,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aSSRC, aCon, aObs,  EFalse),
        iStates(MSRTPStreamOutContext::EMaxStates),
        iCurrentRTPState(ESRTPStreamOutUninitialized),      
        iCurrentRTCPState(ESRTPStreamOutUninitialized)    
    {
    
    }
    
// ---------------------------------------------------------------------------
// CSRTPStreamOut::CSRTPStreamOut
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamOut::CSRTPStreamOut( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aSSRC, aObs,  EFalse),
        iStates(MSRTPStreamOutContext::EMaxStates),
        iCurrentRTPState(ESRTPStreamOutUninitialized),      
        iCurrentRTCPState(ESRTPStreamOutUninitialized)    
    {
    
    }    
	
// -----------------------------------------------------------------------------
// CSRTPStreamOut::ConstructL
// -----------------------------------------------------------------------------
//
void CSRTPStreamOut::ConstructL()
	{
	CreateCryptoHandlerSRTPL();
    CreateCryptoHandlerSRTCPL();
    InitializeStatesL();
	}

// -----------------------------------------------------------------------------
// CSRTPStreamOut::SetCryptoOutL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CSRTPStreamOut::SetCryptoOutL(CSRTPCryptoContext* aCon)
	{
	//checking if there is one crytpocontext existed
	//construct only when stream has its own cryto handler
	if( !aCon)
	    {
	    User::Leave( KErrArgument );
	    }
	if (!iRekey )
		{
		delete iHandlerRTP; iHandlerRTP=NULL;    
    	delete iHandlerRTCP;iHandlerRTCP=NULL; 
    	delete iContext; iContext=NULL;
		iContext= aCon;
		iStrmSpecificCrypto= ETrue;
    	iStates.Reset(); 
    	//should create handler and initial state
    	TRAPD( err, 
    	    {
    	    CreateCryptoHandlerSRTPL();
        	CreateCryptoHandlerSRTCPL();
        	InitializeStatesL();
    	    } );
    	if ( err )
    	    {
    	    iContext = NULL; // Cannot take ownership if leave occurs
    	    User::Leave( err );
    	    }
    	ChangeRTPState(MSRTPStreamOutContext::ESRTPStreamOutUninitialized);
    	ChangeRTCPState(MSRTPStreamOutContext::ESRTPStreamOutUninitialized);
		}
	}
	
// ---------------------------------------------------------------------------
// CSRTPStreamOut::ReInitialOutStates
// 
// ---------------------------------------------------------------------------
//
void CSRTPStreamOut::UpdateCryptoAndStatesL()
	{
	if( !iStrmSpecificCrypto)
		{
		UpdateCryptoHandlerL();
		iStates.Reset(); 
		InitializeStatesL();
		ChangeRTPState(MSRTPStreamOutContext::ESRTPStreamOutUninitialized);
		ChangeRTCPState(MSRTPStreamOutContext::ESRTPStreamOutUninitialized);
		}	
	}
// ---------------------------------------------------------------------------
// HBufC8* CSRTPStreamOut::ProtectRtpL(
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPStreamOut::ProtectRtpL( const TDesC8& aPacket )
    {    
    if (IsContextSet())       
    	return (CurrentRTPState().DoProtectRtpL(aPacket));
    //it is using session crypto but the crypto handler is not been generated yet
    //it is stream specific crypto but handler is not set yet	
    User::Leave (KErrArgument);
    return NULL;
    }
    
// ---------------------------------------------------------------------------
// HBufC8* CSRTPStreamOut::ProtectRtcpL(
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPStreamOut::ProtectRtcpL( const TDesC8& aPacket )
    {
    if (IsContextSet())
    	return (CurrentRTCPState().DoProtectRtcpL(aPacket));
    User::Leave (KErrArgument);
    return NULL;
    }
    
// -----------------------------------------------------------------------------
// CSRTPStreamOut::InitializeStatesL
// -----------------------------------------------------------------------------
//	
void CSRTPStreamOut::InitializeStatesL()
    {
	iStates.AppendL(TSRTPStreamOutStateUninit(*this, *iHandlerRTP, *iHandlerRTCP),
					sizeof(TSRTPStreamOutStateUninit));
	iStates.AppendL(TSRTPStreamOutStateNormal(*this, *iHandlerRTP, *iHandlerRTCP),
					sizeof(TSRTPStreamOutStateNormal));
    }

// ---------------------------------------------------------------------------
// CSRTPStreamOut::~CSRTPStreamOut
// ---------------------------------------------------------------------------
//
CSRTPStreamOut::~CSRTPStreamOut( )
    {
    delete iHandlerRTP;   
    delete iHandlerRTCP;
    if (iStrmSpecificCrypto ) 
    	{
    	delete iContext; iContext=NULL;
    	}  
     
	iStates.Reset();
	iHandlerRTP=NULL;  
	iHandlerRTCP=NULL; 
	}    


// -----------------------------------------------------------------------------
// CSRTPStreamOut::ChangeRTPState
// -----------------------------------------------------------------------------
//      
void CSRTPStreamOut::ChangeRTPState(MSRTPStreamOutContext::TContextOutState aNewState)
    {
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamOut::ChangeRTPState to new State", aNewState);
     
    iCurrentRTPState = aNewState;
    }

// -----------------------------------------------------------------------------
// CSRTPStreamOut::ChangeRTCPState
// -----------------------------------------------------------------------------
//      
void CSRTPStreamOut::ChangeRTCPState(TContextOutState aNewState)
    {
    iCurrentRTCPState = aNewState;
    }

// ----------------------------------------------------------------------------
// CSRTPStreamOut::CurrentRTPState
// ----------------------------------------------------------------------------
//
TSRTPStreamOutStateBase& CSRTPStreamOut::CurrentRTPState()
	{
	SRTP_DEBUG_TINT_VALUE( "CSRTPStreamOut::CurrentRTPState()", iCurrentRTPState);
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamOut State count", iStates.Count() );    
                
    
    return iStates.At(iCurrentRTPState);
	}

// ----------------------------------------------------------------------------
// CSRTPStreamOut::CurrentRTCPState
// ----------------------------------------------------------------------------
//
TSRTPStreamOutStateBase& CSRTPStreamOut::CurrentRTCPState()
	{
	SRTP_DEBUG_TINT_VALUE( "CSRTPStreamOut::CurrentRTCPState()", iCurrentRTCPState);
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamOut State count", iStates.Count() );    
                
    return iStates.At(iCurrentRTCPState);
	}