/*

* 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:    SRTP session class

*

*/

#ifndef __SRTP_SESSION_H__

#define __SRTP_SESSION_H__

// INCLUDES

#include <in_sock.h>

// FORWARD DECLARATIONS

class CSRTPStream;

class CSRTPCryptoContext;

class MSRTPReKeyingObserver;

/**

* Contains an SRTP session

*/

class CSRTPSession : public CBase

    {

    public: // construction

        /**

        * Two-phased constructor.

        * Use this function if each stream will have its own cryptographic

        * context.

        * @param aDestination  The destination address, including the port.

        * @leave KErrNone if success, system-wide error code otherwise

        */

        IMPORT_C static CSRTPSession* NewL(const TInetAddr& aDestination );

        /**

        * Two-phased constructor.

        * Use this function if all streams will use the same cryptographic

        * context.

        * @param aDestination  The destination address, including the port

        * @param aCon  The default cryptographic context for the session,

        *              ownership is transferred.

        * @param aObs  The callback object

        * @leave KErrNone if success, system-wide error code otherwise

        */

        IMPORT_C static CSRTPSession* NewL( const TInetAddr& aDestination,

                                     CSRTPCryptoContext* aCon,

                                     MSRTPReKeyingObserver& aObs );

        /**

        * Two-phased constructor. Creates a new CSRTPSession instance 

        * and pushes it to CleanupStack.

        * Use this function if each stream will have its own cryptographic

        * context.

        * @param aDestination  The destination address, including the port.

        * @leave KErrNone if success, system-wide error code otherwise

        */

        IMPORT_C static CSRTPSession* NewLC(const TInetAddr& aDestination );

        /**

        * Two-phased constructor. Creates a new CSRTPSession instance 

        * and pushes it to CleanupStack.

        * Use this function if all streams will use the same cryptographic

        * context.

        * @param aDestination  The destination address, including the port

        * @param aCon  The default cryptographic context for the session,

        *              ownership is transferred.

        * @param aObs  The callback object

        * @leave KErrNone if success, system-wide error code otherwise

        */

        IMPORT_C static CSRTPSession* NewLC(const TInetAddr& aDestination,

                                     CSRTPCryptoContext* aCon,

                                     MSRTPReKeyingObserver& aObs);

        /**

        * Destructor, remove and delete all the stream in the session

        */

        ~CSRTPSession();

        /**

        * Retrieve CSSRTPStream object associated with given SSRC.

        * Note that if there are any duplicates the first one is returned.

        * Otherwise, Multiple SRTP streams with identical SSRCs and with same 

        * stream type (In/Out stream) are not supported.

        * @param aSSRC - [input] SSRC of interest

        * @param aInInStream - True if stream type is CStreamIn, False otherwise

        * @return CSSRTPStream object if successful; Leave if not found.

        */

	    IMPORT_C CSRTPStream& StreamL(TUint aSSRC, TBool aIsInStream);

        /**

        * Session should find the match stream and protect stream

        * Note that if there are no matching stream, the function leave

        * @param aSSRC - [input] SSRC of interest

        * @param aPacket - [input] packet to be protected, the length of descriptor

        *  should be the same with the actual data, otherwise encoding will not be 

        *  correct.        

        * @return HBufC8 protected packet

        */

		IMPORT_C HBufC8* ProtectRTPL(TUint aSSRC, const TDesC8& aPacket);

        /**

        * Session should find the match stream and protect packet

        * Note that if there are no matching stream, the function leave

        * @param aSSRC - [input] SSRC of interest

        * @param aPacket - [input] packet to be protected, the length of descriptor

        *  should be the same with the actual data.              

        * @return HBufC8 protected packet

        */

		IMPORT_C HBufC8* ProtectRTCPL(TUint aSSRC, const TDesC8& aPacket);

        /**

        * SRTPSession find the match stream and unprotect stream

        * Note that if there are no matching stream, the function leave

        * In late binding cases, session will try to find the stream 

        * which SSRC is equal to zero and unprotect the packet. 

        * If the autenticate for the packet is successful, SSRC will be set to this stream.

        * @param aSSRC - [input] SSRC of interest

        * @param aPacket - [input] packet to be Unprotected      

        * @return HBufC8 Unprotected packet

        */		

		IMPORT_C HBufC8* UnprotectRTPL(TUint aSSRC, const TDesC8& aPacket);

       /**

        * SRTPSession find the match stream and unprotect packet

        * Note that if there are no matching stream, the function leaves

        * SRTP must have been recive earlier otherwise the function will leave

        * with KErrNotFound--no SSRC matching stream found

        * Note that the streamIn must have to be created to receive RTCP report if 

        * there is only one streamOut.

        * @param aSSRC - [input] SSRC of interest

        * @param aPacket - [input] packet to be Unprotected      

        * @return HBufC8 Unprotected packet

        */		

		IMPORT_C HBufC8* UnprotectRTCPL(TUint aSSRC, const TDesC8& aPacket);		

       /**

        * Return the destination address set in NewL

        * @return aDestination  The destination address, including the port.

        */		

		IMPORT_C const TInetAddr& RemoteAddr() ;

        /**

        * Set/Update crypto context sharing between streams 

        * Crypto context ownershíp is transfered.

        * Note that to update crypto context, the states and the number of packets received

        * will be reset. ROC will not be re-intialized. This can be used 

        * only when keys lifetime has not expired.

        * RFC 4568 6.5, 6.4

        * @param CSRTPCryptoContext

        * @leave KErrNone if success, system-wide error code otherwise

        */

        IMPORT_C void SetCryptoContextL(CSRTPCryptoContext* aCon);

        /**

        * Get cryptographic context associated for this session

        * @return CSRTPCryptoContext

        */

        CSRTPCryptoContext& GetCryptoContext();

        /**

        * Add given stream to the list of CSRTPStream objects

        * @param aStream  The stream to be added to list

        * @return void

        */

        void AddStreamToList(CSRTPStream *aStream);        

        /**

        * Remove given stream from the list of CSRTPStream objects

        * @param aStream  The stream to be removed

        * @return void

        */

        void RemoveStreamFromList(CSRTPStream *aStream);   

         /**

        * Call for Rekey 

        * @param aStream the stream which needs to be rekey

        * @param aIsStrmCrypto True if stream has it's own crypto, false otherwise

        * @return void

        */

        void ReKeyNeeded(const CSRTPStream& aStream, TBool aIsStrmCrypto);        

    private: //methods

        CSRTPSession (const TInetAddr& aDestination,

                      MSRTPReKeyingObserver& aObs);

        CSRTPSession(const TInetAddr& aDestination);

        void ConstructL ( CSRTPCryptoContext* aCon );

        TBool FindStream(TUint aSSRC, TBool aIsInStream);

        HBufC8* FindLateBindingStreamAndUnprotectRTPL(TUint aSSRC, 

												const TDesC8& aPacket);

		HBufC8* FindLateBindingStreamAndUnprotectRTCPL(TUint aSSRC, 

												const TDesC8& aPacket);	

        void RemoveAllStream( );        

    private: // from Array

        /**

        * iStreamLink, Link to list.

        */

        TSglQueLink iStreamLink;

        /**

        * list of CSRTPStream objects

        */

        TSglQue<CSRTPStream> iStreamList;

        /**

        * CSRTPStream iterator.

        */

        TSglQueIter<CSRTPStream> iStreamIter;

    private: //data

        /*

        destination address

        */

        const TInetAddr&          iDestination;  

        /*

        crypto context, owned

        */

        CSRTPCryptoContext* iContext;

        /*

        observer (application)

        */        

        MSRTPReKeyingObserver* iObserver;

        TUint8 iStreamCount;

    protected:

        /*

        * Session is created with cryptographic context

        */

        TBool   iSesssionCrypto; 

        /*

        * True if Rekey is called, False otherwise

        */

        TBool 	iRekey;  

    private:  

    	friend class CSRTPStream;

    	#ifdef EUNIT_TESTING

        friend class UT_CSRTPSession;

    #endif     

    };

#endif // __SRTP_SESSION_H__