/*

* 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/SRTCP streams.

*

*/

#ifndef __SRTP_CRYPTOCONTEXT_H__

#define __SRTP_CRYPTOCONTEXT_H__

// INCLUDES

#include <e32base.h>

#include "srtpdef.h"

#include <srtpcryptoparams.h>

// FORWARD DECLARATIONS

class CSRTPMasterKey;

class CSRTPMasterSalt;

class CSRTPCryptoHandler;

class TSrtpCryptoParams;

/**

* Contains a cryptographic context.

*/

class CSRTPCryptoContext : public CBase

    {

    //public: // enumerations

    public: // Construction

        /**

        * Use this function if the stream will use the SRTP session's default

        * cryptographic context. CSrtpSession take the ownership of

        * CSRTPCryptoContext if CSrtpSession is created with CSRTPCryptoContext

        * as input parameter.

        * @param aKey  The master key.

        * @param aSalt  The master salt.

		* @param aCryptoParams. Crypto Context parameters.

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

        */

        IMPORT_C static CSRTPCryptoContext* NewL( const CSRTPMasterKey* aKey,

                                            const CSRTPMasterSalt* aSalt, 

                                            const TSrtpCryptoParams& aCryptoParams);

         /**

        * Use this function if the stream will use the SRTP session's default

        * cryptographic context.

        * @param aKey  The master key.

        * @param aSalt  The master salt.

		* @param aCryptoParams. Crypto Context parameters.

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

        */

        IMPORT_C static CSRTPCryptoContext* NewLC( const CSRTPMasterKey* aKey,

                                            const CSRTPMasterSalt* aSalt, 

                                            const TSrtpCryptoParams& aCryptoParams );

        /**

        * Destructor

        * 

        */

        ~CSRTPCryptoContext();          

        /*

		* Gets current master key        

        * @return CSRTPMasterKey

        */

        IMPORT_C  const CSRTPMasterKey& MasterKey() const; 

        /*

		* Sets master key, the new master key will be used in encryptiuon 

		* and decryption. The previous master key will be deleted.        

        * @param aKey new master key

        */

        IMPORT_C void SetMasterKey( const CSRTPMasterKey* aKey); 

        /*

		* Gets current master salt             

        * @return CSRTPMasterSalt

        */

        IMPORT_C  const CSRTPMasterSalt& MasterSalt() const; 

        /*

		* Sets master salt, the new master salt key will be used in encryptiuon 

		* and decryption. The previous master salt key will be deleted.   

        * @param aSalt new master salt

        */

        IMPORT_C void SetMasterSalt(const CSRTPMasterSalt* aSalt); 

        /*

		* Check the validity of the whole TCryptoContext

        * @return validity of this CryptoContext

        */

        IMPORT_C TBool Valid() const;                 

        /*

		* Gets CryptoParams             

        * @return TSrtpCryptoParams Cryptocontext parameters

        */

        IMPORT_C const TSrtpCryptoParams& CryptoParams() ;

        /*

		* Feeback from Applicaiton to indicate that if the local ROC is

		* synchronized with the sender in RCC mode3.If it is not set, 

		* "Not-Synchronized" will be default. If it is synchronized, 

		* the packet would hence be processed using the local ROC.

		* Defined in RFC srtp-rcc-04 section 4.

		* @param aSync True if it is synchronized, False otherwise.

        */

        IMPORT_C void SetRCCm3Sync(TBool aSync) ;    

        /*

		* Check if the crypto context is equal

		* @param aContext True if it is equal, False otherwise.

        */

        TBool IsEqual(const CSRTPCryptoContext& aContext); 

        /*

		* Add cryptocontext user  

        * @param aObserver new CSRTPCryptoHandler instance

        */

        void AddCryptoChangeObserver(CSRTPCryptoHandler *aObserver);

        /*

		* Remove cryptocontext user  

        * @param aObserver CSRTPCryptoHandler instance

        */

        void RemoveCryptoChangeObserver(CSRTPCryptoHandler *aObserver);

    protected:

        /*

		* Update crypto parameters, internal use only 

        * @param aCryptoParams a new crypto parameters

        */

    	void UpdateCryptoParams(const  TSrtpCryptoParams& aCryptoParams );     

    private:

        /* copy constructor */

        CSRTPCryptoContext(const  TSrtpCryptoParams& aCryptoParams );

        void ConstructL (  const CSRTPMasterKey* aKey,

                           const CSRTPMasterSalt* aSalt);

        /* assignment operator */

        const CSRTPCryptoContext& operator=(const CSRTPCryptoContext& aContext);                     

        TBool FindHandler( CSRTPCryptoHandler *aObserver );

    private: // from Array

        /**

        * list of CSRTPCryptoHandler objects

        * owned by CSRTPCryptoContext object.

        */

        TSglQue<CSRTPCryptoHandler> iHandlerList;

        /**

        * CSRTPCryptoHandler iterator.

        * Owned by CSRTPCryptoContext object.

        */

        TSglQueIter<CSRTPCryptoHandler> iHandlerIter;

    private: // data

    	const CSRTPMasterKey *iKey;               // TSRTPMasterKey definitions

        const CSRTPMasterSalt *iSalt;             // TSRTPMasterSalt definitions

        TSrtpCryptoParams iCryptoParams;

        static const TInt iObserverOffset;   

    private:

    #ifdef EUNIT_TESTING

        friend class UT_CSRTPCryptoContext;

        friend class UT_CSRTPCryptoHandlerSRTCP;

    #endif              

    };

#endif // __SRTP_CRYPTOCONTEXT_H__