/*
* 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:    Contains a default cryptographic context for SRTP streams.
*
*/




// INCLUDES
#include "srtpsession.h"
#include "srtpstream.h"
#include "srtpcryptocontext.h"
#include "srtpstreamin.h"
#include "srtpstreamout.h"
#include "msrtprekeyingobserver.h"
#include "srtputils.h"

// ---------------------------------------------------------------------------
// Two-phased constructor. Used when stream uses default cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPSession* CSRTPSession::NewL( const TInetAddr& aDestination )
    {
    CSRTPSession* self = CSRTPSession::NewLC( aDestination );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Two-phased constructor. Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPSession* CSRTPSession::NewL( const TInetAddr& aDestination,
                                     CSRTPCryptoContext* aCon,
                                     MSRTPReKeyingObserver& aObs ) 
    {
    CSRTPSession* self = CSRTPSession::NewLC( aDestination, aCon, aObs );
    CleanupStack::Pop( self );
    return self;    
    }


// ---------------------------------------------------------------------------
// Two-phased constructor. Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPSession* CSRTPSession::NewLC( const TInetAddr& aDestination )
    {                                     
    CSRTPSession* self = new( ELeave ) CSRTPSession ( aDestination );                                      
    CleanupStack::PushL( self );    
    return self;
    }	

// ---------------------------------------------------------------------------
// Two-phased constructor. Used when stream uses its own cryptographic context
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSRTPSession* CSRTPSession::NewLC( const TInetAddr& aDestination,
                                     CSRTPCryptoContext* aCon,
                                     MSRTPReKeyingObserver& aObs )
    {                                     
    CSRTPSession* self = new( ELeave ) CSRTPSession ( aDestination, aObs  );
    CleanupStack::PushL( self ); 
    self->ConstructL( aCon );                                      
    return self;
    }	
        

// -----------------------------------------------------------------------------
// CSRTPSession::CSRTPSession
// -----------------------------------------------------------------------------
//
 CSRTPSession::CSRTPSession( const TInetAddr& aDestination,
                             MSRTPReKeyingObserver& aObs )
    :   iStreamList(CSRTPStream::iStreamOffset),
        iStreamIter( iStreamList ),
        iDestination(aDestination),
        iObserver(&aObs),
        iStreamCount(NULL),    
        iRekey(EFalse)    
    {
    }

// -----------------------------------------------------------------------------
// CSRTPSession::CSRTPSession
// -----------------------------------------------------------------------------
//
 CSRTPSession::CSRTPSession(const TInetAddr& aDestination)
    :   iStreamList(CSRTPStream::iStreamOffset),
        iStreamIter( iStreamList ),
        iDestination(aDestination),
        iContext(NULL),
        iObserver(NULL),
        iStreamCount(NULL),    
        iSesssionCrypto(EFalse),
        iRekey(EFalse)             
    {
    }

// -----------------------------------------------------------------------------
// CSRTPSession::ConstructL
// -----------------------------------------------------------------------------
//
void CSRTPSession::ConstructL( CSRTPCryptoContext* aCon )
	{
	if( !aCon )
	    {
	    //delete this;// because of NewLC so we need to delete it
	    User::Leave( KErrArgument );
	    }
	else 
	    {
	    if (!aCon->Valid())
		    {
		    User::Leave( KErrArgument );
		    }
		iSesssionCrypto=ETrue;
		iContext = aCon;
		    
	    }
	}
	
	
// ---------------------------------------------------------------------------
// CSRTPSession::~CSRTPSession
// ---------------------------------------------------------------------------
//
CSRTPSession::~CSRTPSession()
    {
    if (iContext)
    	{
    	delete iContext;iContext=NULL;	
    	}
    if (iStreamCount)
    	{
    	RemoveAllStream( );
    	}
    iStreamList.Reset();	
    }

// -----------------------------------------------------------------------------
// CSRTPSession::UpdateCryptoContextL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSRTPSession::SetCryptoContextL(CSRTPCryptoContext* aCon)
	{
	//Note that ROC is not re-set.
	if( !aCon)
	    {
	    User::Leave( KErrArgument );
	    }
	if (!iRekey )
		{
		if (iContext && iSesssionCrypto )
			{
			delete iContext;iContext=NULL;
			}
		iSesssionCrypto = ETrue;
		iContext = aCon;
		//should implement a way that session knows how to updated the stream
		if (!iStreamList.IsEmpty())
			{
			CSRTPStream* item=NULL;
	
			iStreamIter.SetToFirst();
			while ((item=iStreamIter++) != NULL)
				{
				TRAPD( err, item->UpdateCryptoAndStatesL() );
				if ( err )
				    {
				    iContext = NULL; // Cannot take ownership if leave occurs
				    User::Leave( err );
				    }
				}
			}
		
		}
	}

// -----------------------------------------------------------------------------
// CSRTPSession::RemoteAddr()
// -----------------------------------------------------------------------------
//
EXPORT_C const TInetAddr& CSRTPSession::RemoteAddr() 
	{
	return iDestination;
	}

// ---------------------------------------------------------------------------
// CSRTPSession::StreamL
// ---------------------------------------------------------------------------
//       

EXPORT_C CSRTPStream& CSRTPSession::StreamL(TUint aSSRC, TBool aIsInStream)
	{
	CSRTPStream* item=NULL;
	
	iStreamIter.SetToFirst();
	while ((item=iStreamIter++) != NULL)
			{
			if (item->SSRC()==aSSRC && aIsInStream== item->StreamType())
				return *item;
			}
	User::Leave(KErrNotFound);
	return *item;
	}

// ---------------------------------------------------------------------------
// CSRTPSession::ProtectRTPL
// ---------------------------------------------------------------------------
// 
EXPORT_C HBufC8* CSRTPSession::ProtectRTPL(TUint aSSRC, const TDesC8& aPacket)
	{
	SRTP_DEBUG_DETAIL( "CSRTPSession::ProtectRTPL ENTRY" );
  	
	//find the matching ssrc stream
	CSRTPStreamOut* stream = static_cast<CSRTPStreamOut*> (&StreamL(aSSRC, EFalse));
	SRTP_DEBUG_TUINT_VALUE( "aSSRC is", aSSRC);
     
	//If it is streamIn
	SRTP_DEBUG_DETAIL( "CSRTPSession::ProtectRTPL EXIT" );

	return stream->ProtectRtpL( aPacket );
	}

// ---------------------------------------------------------------------------
// CSRTPSession::UnprotectRTPL
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPSession::UnprotectRTPL(TUint aSSRC, const TDesC8& aPacket)
	{
	SRTP_DEBUG_DETAIL( "CSRTPSession::UnprotectRTPL ENTRY" );
  	   
	//Find Stream by SSRC
	CSRTPStreamIn* stream;
	if(FindStream(aSSRC, ETrue))
		{
		SRTP_DEBUG_TUINT_VALUE( "not latebinding and stream found and aSSRC is", aSSRC);
    
		 stream= static_cast<CSRTPStreamIn*> (&StreamL(aSSRC, ETrue));
		//If found
		return stream->UnprotectSrtpL( aPacket );
		}
	//If not found, try to find the stream SSRC=0;	
	SRTP_DEBUG_DETAIL( "UnprotectRTPL is latebinding and If not found, try to find the stream SSRC=0");
    
    SRTP_DEBUG_DETAIL( "CSRTPSession::UnprotectRTPL EXIT" );		
	return FindLateBindingStreamAndUnprotectRTPL(aSSRC, aPacket);
		
	}
	
// ---------------------------------------------------------------------------
// CSRTPSession::ProtectRTCPL
// ---------------------------------------------------------------------------
// 
EXPORT_C HBufC8* CSRTPSession::ProtectRTCPL(TUint aSSRC, const TDesC8& aPacket)
	{
	//find the matching ssrc stream
	CSRTPStreamOut* stream = static_cast<CSRTPStreamOut*> (&StreamL(aSSRC, EFalse));
	//If it is streamIn
	return stream->ProtectRtcpL( aPacket );
	}

// ---------------------------------------------------------------------------
// CSRTPSession::UnprotectRTPL
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSRTPSession::UnprotectRTCPL(TUint aSSRC, const TDesC8& aPacket)
	{
	//Find Stream by SSRC
	CSRTPStreamIn* stream;
	if(FindStream(aSSRC, ETrue) )
		{
		 stream= static_cast<CSRTPStreamIn*> (&StreamL(aSSRC, ETrue));
		//If found
		return stream->UnprotectSrtcpL( aPacket );
		}
	//If not found, return NULL since there must already some RTP packet received	
	// But for outgoing stream to receive RR and SDES so it should be able to 
	// decod this RTCP packet as well
	return FindLateBindingStreamAndUnprotectRTCPL(aSSRC, aPacket);
		
	}	
// ---------------------------------------------------------------------------
// CSRTPSession::FindStream
// ---------------------------------------------------------------------------
//       

TBool CSRTPSession::FindStream(TUint aSSRC, TBool aIsInStream )
	{
	TBool found=EFalse;
	TInt count = iStreamCount;
	CSRTPStream* item=NULL;
	
	iStreamIter.SetToFirst();
	item=iStreamIter;
	while ((item=iStreamIter++) != NULL && count !=0)
			{
			if (item->SSRC()==aSSRC &&  (aIsInStream== item->StreamType()))
				{
				found = ETrue;
				return found;
				}
			count --;
			}
	return found;
	}

// ---------------------------------------------------------------------------
// CSRTPSession::FindLateBindingStreamAndUnprotect
// ---------------------------------------------------------------------------
//       

HBufC8* CSRTPSession::FindLateBindingStreamAndUnprotectRTPL(TUint aSSRC, 
													const TDesC8& aPacket)
	{
	SRTP_DEBUG_DETAIL( "CSRTPSession::FindLateBindingStreamAndUnprotectRTPL ENTRY" );
  	
	CSRTPStream* item=NULL;
	
	iStreamIter.SetToFirst();
	while ((item=iStreamIter++) != NULL)
			{
			//In the case of late binding state unprotect failed but SSRC 
    		// has set; we should set it again to the corrected one in the 
    		// case SSRC is different from previous one 											
			if ((item->StreamType()))
				{
				if ((item->SSRC()==0) || 
					(item->SSRC()!=0 && 
						static_cast<CSRTPStreamIn*> (item)->iCurrentRTPState== 
						MSRTPStreamInContext::ESRTPStreamInLateBinding) 
						)
					{
					SRTP_DEBUG_TUINT_VALUE( "FindLateBindingStreamAndUnprotectRTPL and ssrc is", aSSRC );
		  								
					item->SetSSRC(aSSRC);
					HBufC8* packet=	static_cast<CSRTPStreamIn*> 
									(item)->UnprotectSrtpL( aPacket );
					return packet;				
					}
	 			}
			}
	
	SRTP_DEBUG_TUINT_VALUE( "NOT Find any match SSRC in FindLBStrmUnprotectRTPL and ssrc is", aSSRC);
				 		
	//If not found stream ssrc =0it leaves
	User::Leave(KErrCorrupt);
	//keep away warnings
	SRTP_DEBUG_DETAIL( "CSRTPSession::FindLateBindingStreamAndUnprotectRTPL EXIT" );
  	
	return NULL;
	}

// ---------------------------------------------------------------------------
// CSRTPSession::FindLateBindingStreamAndUnprotectRTCP
// ---------------------------------------------------------------------------
//       

HBufC8* CSRTPSession::FindLateBindingStreamAndUnprotectRTCPL(TUint aSSRC, 
													const TDesC8& aPacket)
	{
	SRTP_DEBUG_DETAIL( "CSRTPSession::FindLateBindingStreamAndUnprotectRTCPL ENTRY" );
  	
	CSRTPStream* item=NULL;
	
	iStreamIter.SetToFirst();
	while ((item=iStreamIter++) != NULL)
			{
			//Only InStreams are handled for received RTCP Packets.
			if (item->StreamType())
				{
			//In the case of late binding state unprotect failed but SSRC 
    		// has set; we should set it again to the corrected one in the 
    		// case SSRC is different from previous one 											
		
			if ((item->SSRC()==0) || 
				(item->SSRC()!=0 && 
					static_cast<CSRTPStreamIn*> (item)->iCurrentRTCPState== 
					MSRTPStreamInContext::ESRTPStreamInLateBinding))
				{
					CSRTPStreamIn *pStrmIn = static_cast<CSRTPStreamIn*> (item);

					if(pStrmIn->SSRC()!=0 && pStrmIn->iCurrentRTPState == MSRTPStreamInContext::ESRTPStreamInNormal)
						{
						if(pStrmIn->SSRC() != aSSRC )
							{
							User::Leave(KErrCorrupt);
							}
						}
				item->SetSSRC(aSSRC);
				HBufC8* packet=	static_cast<CSRTPStreamIn*> 
								(item)->UnprotectSrtcpL( aPacket );
				return packet;				
				}
	 		SRTP_DEBUG_TUINT_VALUE( "FindLateBindingStreamAndUnprotectRTCPL and ssrc is", aSSRC);
				}
			}
	//If not found stream ssrc =0it leaves
	User::Leave(KErrCorrupt);
	//keep away warnings
	SRTP_DEBUG_DETAIL( "CSRTPSession::FindLateBindingStreamAndUnprotectRTCPL EXIT" );
  	
	return NULL;
	}

// ---------------------------------------------------------------------------
// CSRTPSession::AddStreamToList()
// ---------------------------------------------------------------------------
//
void CSRTPSession::AddStreamToList(CSRTPStream *aStream)
    {   
    iStreamList.AddLast(*aStream);
    ++iStreamCount;
    }

// ---------------------------------------------------------------------------
// CSRTPSession::RemoveStreamFromListL()
// ---------------------------------------------------------------------------
//
void CSRTPSession::RemoveStreamFromList(CSRTPStream *aStream)
    {   
    //when there are 2 same stream ...it could not remove
    TBool found = FindStream(aStream->SSRC(), aStream->StreamType() );
    if (found)
    	{
        iStreamList.Remove(*aStream);
	    --iStreamCount;
    	}
    }

// ---------------------------------------------------------------------------
// CSRTPSession::RemoveAllStream
// ---------------------------------------------------------------------------
//       

void CSRTPSession::RemoveAllStream( )
	{
	CSRTPStream* item=NULL;
	iStreamIter.SetToFirst();
	item=iStreamIter;
	while ((item=iStreamIter++) != NULL)
		{
		delete item; item=NULL;
		}
	}
// ---------------------------------------------------------------------------
// void CSRTPSession::GetCryptoContext()
// 
// ---------------------------------------------------------------------------
//
CSRTPCryptoContext& CSRTPSession::GetCryptoContext()
    {
     return *iContext;
    }


// ---------------------------------------------------------------------------
// void CSRTPSession::ReKeyNeeded()
// 
// ---------------------------------------------------------------------------
//
void CSRTPSession::ReKeyNeeded(const CSRTPStream& aStream, TBool aIsStrmCrypto)
    {
    if (iObserver)
		{
		if (aIsStrmCrypto)
			{
			iObserver->SRTPMasterKeyStaleEvent(aStream);
			}
		else
			{
			iObserver->SRTPMasterKeyStaleEvent(*this);
			}	
		}
	}