/*
* 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 "msrtpstreamincontext.h"
#include "srtpstreamin.h"
#include "tsrtpstreaminstatebase.h"
#include "tsrtpstreaminstateuninit.h"
#include "tsrtpstreaminstatelatebind.h"
#include "tsrtpstreaminstatenormal.h"
#include "srtpsession.h"
#include "srtpcryptohandler.h"
#include "srtpcryptohandlersrtp.h"
#include "srtpcryptohandlersrtcp.h"
#include "srtputils.h"

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

// ---------------------------------------------------------------------------
// Constructor. Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamIn* CSRTPStreamIn::NewL( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      CSRTPCryptoContext* aCon,
                                      MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamIn* self = new( ELeave )CSRTPStreamIn( 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;
    }
		
// ---------------------------------------------------------------------------
// Constructor. Used when stream uses default cryptographic context
// and "late binding". No SSRC is provided by the user.
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamIn* CSRTPStreamIn::NewL( CSRTPSession& aSession)
    {
    CSRTPStreamIn* self = new( ELeave )CSRTPStreamIn( aSession);
    CleanupStack::PushL( self );    
    self->ConstructL();
    CleanupStack::Pop( self );        
    return self;
    }

// ---------------------------------------------------------------------------
// Constructor. Used when stream uses its own cryptographic context
// and "late binding". No SSRC is provided by the user.
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamIn* CSRTPStreamIn::NewL( CSRTPSession& aSession,
                                      CSRTPCryptoContext* aCon,
                                      MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamIn* self = new( ELeave )CSRTPStreamIn( aSession, 
                                                      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;
    }

// ---------------------------------------------------------------------------
// Constructor. Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamIn* CSRTPStreamIn::NewL( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamIn* self = new( ELeave )CSRTPStreamIn( aSession, aSSRC,aObs);
    return self;
    }

// ---------------------------------------------------------------------------
// Constructor. Used when stream uses its own cryptographic context
// and "late binding". No SSRC is provided by the user.
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPStreamIn* CSRTPStreamIn::NewL( CSRTPSession& aSession,
                                      MSRTPReKeyingObserver& aObs )
    {
    CSRTPStreamIn* self = new( ELeave )CSRTPStreamIn( aSession, aObs);
    return self;
    }    
// -----------------------------------------------------------------------------
// CSRTPStreamIn::ConstructL
// -----------------------------------------------------------------------------
//
void CSRTPStreamIn::ConstructL()
	{
	CreateCryptoHandlerSRTPL();
    CreateCryptoHandlerSRTCPL();
    InitializeStatesL();
	}

// -----------------------------------------------------------------------------
// CSRTPStreamIn::SetCryptoInL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CSRTPStreamIn::SetCryptoInL(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 );
            }
            
    	if (SSRC())
    		{
    		ChangeRTPState(MSRTPStreamInContext::ESRTPStreamInUninitialized);
    		ChangeRTCPState(MSRTPStreamInContext::ESRTPStreamInUninitialized);
    		}
    	else
    		{
    		ChangeRTPState(MSRTPStreamInContext::ESRTPStreamInLateBinding);
    		ChangeRTCPState(MSRTPStreamInContext::ESRTPStreamInLateBinding);
    		}	
		}
	}

// ---------------------------------------------------------------------------
// CSRTPStreamIn::ReInitialInStates
// 
// ---------------------------------------------------------------------------
//
void CSRTPStreamIn::UpdateCryptoAndStatesL()
	{
	if( !iStrmSpecificCrypto)
	    {
	    UpdateCryptoHandlerL();
		iStates.Reset(); 
		InitializeStatesL();
		if (SSRC())
			{
			ChangeRTPState(MSRTPStreamInContext::ESRTPStreamInUninitialized);
			ChangeRTCPState(MSRTPStreamInContext::ESRTPStreamInUninitialized);
			}
		else
			{
			ChangeRTPState(MSRTPStreamInContext::ESRTPStreamInLateBinding);
			ChangeRTCPState(MSRTPStreamInContext::ESRTPStreamInLateBinding);
			}	
		}
	}
// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn(  CSRTPSession& aSession,
                                    TUint aSSRC)
    :   CSRTPStream(aSession, aSSRC, ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInUninitialized),      
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInUninitialized)
           
    {
    
    }

// ---------------------------------------------------------------------------
// CSRTPStreamIn::~CSRTPStreamIn
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::~CSRTPStreamIn( )
    {
    delete iHandlerRTP;    
    delete iHandlerRTCP;
    if (iStrmSpecificCrypto ) 
    	{
    	delete iContext; iContext=NULL;
    	}  
	iStates.Reset();
	iHandlerRTP=NULL;
	iHandlerRTCP=NULL;  
    }
// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      CSRTPCryptoContext* aCon,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aSSRC, aCon, aObs, ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInUninitialized),      
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInUninitialized)
            
    {
    
    }

// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn( CSRTPSession& aSession,
                                      TUint aSSRC,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aSSRC, aObs, ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInUninitialized),      
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInUninitialized)
            
    {
    
    }
		
// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn(  CSRTPSession& aSession)
    :   CSRTPStream(aSession,  ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInLateBinding),     
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInLateBinding)
       
    {
    
    }

// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn( CSRTPSession& aSession,
                                      CSRTPCryptoContext* aCon,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aCon, aObs,  ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInLateBinding),     
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInLateBinding)
       
    {
    
    }

// ---------------------------------------------------------------------------
// CSRTPStreamIn::CSRTPStreamIn
// 
// ---------------------------------------------------------------------------
//
CSRTPStreamIn::CSRTPStreamIn( CSRTPSession& aSession,
                                      MSRTPReKeyingObserver& aObs )
    :   CSRTPStream(aSession, aObs,  ETrue),
        iStates(MSRTPStreamInContext::EMaxStates),
        iCurrentRTPState(MSRTPStreamInContext::ESRTPStreamInLateBinding),     
        iCurrentRTCPState(MSRTPStreamInContext::ESRTPStreamInLateBinding)
       
    {
    
    }
		

// ---------------------------------------------------------------------------
// HBufC8* CSRTPStreamIn::UnprotectSrtpL()
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPStreamIn::UnprotectSrtpL( const TDesC8& aPacket )
    {
 	SRTP_DEBUG_DETAIL( "CSRTPStreamIn::UnprotectSrtpL Entry" );
     
    if ( IsContextSet() )
    	{
    	SRTP_DEBUG_DETAIL( "CSRTPStreamIn::UnprotectSrtpL Exit" );
    	return (CurrentRTPState().DoUnprotectSrtpL(aPacket) );
    	}
    SRTP_DEBUG_DETAIL( "CSRTPStreamIn::UnprotectSrtpL Exit" );
    
    User::Leave (KErrArgument);
    return NULL;
    }

// ---------------------------------------------------------------------------
// HBufC8* CSRTPStreamIn::UnprotectSrtcpL()
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPStreamIn::UnprotectSrtcpL( const TDesC8& aPacket )
    {
    if (IsContextSet())
    	return (CurrentRTCPState().DoUnprotectSrtcpL(aPacket));
    User::Leave (KErrArgument);
    return NULL;
    }


// -----------------------------------------------------------------------------
// CSRTPStreamIn::InitializeStatesL
// -----------------------------------------------------------------------------
//	
void CSRTPStreamIn::InitializeStatesL()
    {
	iStates.AppendL(TSRTPStreamInStateUninit(*this, *iHandlerRTP, *iHandlerRTCP),
					sizeof(TSRTPStreamInStateUninit));
	iStates.AppendL(TSRTPStreamInStateLateBind(*this, *iHandlerRTP, *iHandlerRTCP),
					sizeof(TSRTPStreamInStateLateBind));
	iStates.AppendL(TSRTPStreamInStateNormal(*this, *iHandlerRTP, *iHandlerRTCP),
					sizeof(TSRTPStreamInStateNormal));
    }

// -----------------------------------------------------------------------------
// CSRTPStreamIn::ChangeRTPState
// -----------------------------------------------------------------------------
//      
void CSRTPStreamIn::ChangeRTPState(MSRTPStreamInContext::TContextInState aNewState)
    {
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamIn::ChangeRTPState", aNewState);
    
    iCurrentRTPState = aNewState;
    }

// -----------------------------------------------------------------------------
// CSRTPStreamIn::ChangeRTCPState
// -----------------------------------------------------------------------------
//      
void CSRTPStreamIn::ChangeRTCPState(MSRTPStreamInContext::TContextInState aNewState)
    {
    iCurrentRTCPState = aNewState;
    }

// ----------------------------------------------------------------------------
// CSRTPStreamIn::CurrentRTPState
// ----------------------------------------------------------------------------
//
TSRTPStreamInStateBase& CSRTPStreamIn::CurrentRTPState()
	{
	SRTP_DEBUG_TINT_VALUE( "CSRTPStreamIN::CurrentRTPState()", iCurrentRTPState);
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamIN::RTP State Count", iStates.Count() );    
    
	return iStates.At(iCurrentRTPState);
	}

// ----------------------------------------------------------------------------
// CSRTPStreamIn::CurrentRTCPState
// ----------------------------------------------------------------------------
//
TSRTPStreamInStateBase& CSRTPStreamIn::CurrentRTCPState()
	{
	SRTP_DEBUG_TINT_VALUE( "CSRTPStreamIN::CurrentRTCPState()", iCurrentRTPState );
    SRTP_DEBUG_TINT_VALUE( "CSRTPStreamIN::RTCP State Count", iStates.Count() );    
     	
	return iStates.At(iCurrentRTCPState);
	}