/*
* 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 cryptographic handler for SRTP/SRTCP streams.
*
*/




#ifndef __SRTP_CRYPTOHANDLER_H__
#define __SRTP_CRYPTOHANDLER_H__

// INCLUDES
#include <e32base.h>
#include "srtpdef.h"
#include "msrtpcryptohandlercontext.h"
#include "srtpcryptocontext.h"
#include "srtpcryptoparams.h"

// FORWARD DECLARATIONS
class CSRTPMasterKey;
class CSRTPMasterSalt;
class CSRTPCryptoContext;
class CSRTPStream;
class MSRTPCipher;
class MSRTPKeyDerivation;
class MSRTPAuthentication;
class CSRTPPacket;

/**
* Contains RTP/RTCP common handling of cryptographic context.
*/
class CSRTPCryptoHandler : public CBase, public MSRTPCryptoHandlerContext
    {
        
   public: // from MSRTPCryptoHandlerContext   
      
        /*
        * virtual function for initializing 
        * plain packet class (CSRTPPacketRTP or CSRTPPacketRTCP) 
        * @param aPacket   RTP/RTCP packet.
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void
        */        
        virtual void InitializePlainPacketL(const TDesC8& aPacket)=0;

        /*
        * virtual function for initializing 
        * encrypted packet class (CSRTPPacketSRTP or CSRTPPacketSRTCP) 
        * @param aPacket   SRTP/SRTCP packet.
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void
        */        
        virtual void InitializeEncryptedPacketL(const TDesC8& aPacket)=0;
        /* 
        * Virtual function for deriving session 
        * encryption, salting and authentication keys
        * for RTP or RTCP 
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void                
        */
        virtual void DeriveSessionKeysL()=0; 
               
        /*
        * virtual function for checking that crypto context MKI and 
        * packet MKI match.
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void
        */        
        virtual void CheckMasterKeyIdentifierL()=0;   
             
        /*
        * virtual function for performing the authentication step
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void
        */        
        virtual void AuthenticateL()=0;
        
        /*
        * virtual function for performing the replay protection step
        * @leave KErrNone if success, system-wide error code otherwise
        * @return void
        */        
        virtual void ReplayProtectionL()=0;

        /*
        * virtual function for encrypting plain packet
        * @leave KErrNone if success, system-wide error code otherwise
        * @return encrypted packet
        */        
        virtual HBufC8* EncryptL()=0;
        
        /*
        * virtual function for decrypting ciphered packet
        * @leave KErrNone if success, system-wide error code otherwise
        * @return plain packet
        */        
        virtual HBufC8* DecryptL()=0;       
        
        /*
        * function for querying whether master key or salt has been updated
        * @return master keys update status
        */        
        virtual TBool MasterKeysUpdated()=0;
 
   public:  // from CSRTPCryptoContext           
        /**
        * Callback from CSRTPCryptoContext when a master key is changed.
        */
        void SRTPMasterKeyChanged();        
        /**
        * Callback from CSRTPCryptoContext when a master salt is changed.
        */
        void SRTPMasterSaltChanged();
        
        
        
   public:                    
        /**
        * Get roll-over counter value.
        * @return current ROC value. 
        */
        TUint32 ROC( ) const;  
        /*
        * Get corresponding CSRTPCryptoContext
        * (either session or stream specific)
        * @return CSRTPCryptoContext
        */                                            
        CSRTPCryptoContext& Context();
        
        const TSrtpCryptoParams& CryptoParams();
   
        virtual ~CSRTPCryptoHandler( );                
                                                 
    protected: // methods   
    
        CSRTPCryptoHandler( CSRTPStream& aStream);
                
        void ConstructL( );
                
                        
        /*
        * Deletes session keys (encryption, 
        * salting and authentication) and sets them NULL
        * @return void
        */                                            
        void DeleteSessionKeys();    

        /**
        * Set roll-over counter value.
        * @param aROC The new ROC value. 
        * @return void
        */
        void SetROC( TUint32 aROC );

        /**
        * Get 32 bit SSRC value
        * @return SSRC 
        */
        TUint SSRC() const;
             
        /*
        * Count X value, 
        * which  used in session key derivation
        * Common to RTP and RTCP.
        * The length of X is the same as master key length
        * (padding will be performed later)
        * @param a_R, r, index DIV key_derivation_rate
        * @param aLabel, label 8 bit RTP/RTCP label 
        * @param aIndexLength, 
        * @param &aRes  resulting n bit x value
        * @return void
        */
        void Count_X(TUint64 a_R,
                    TInt8 aLabel, 
                    const TUint64 aIndexLength, 
                    TDes8 &aRes);                
        

        
        /*
        * Check Packet Index with Replay window
        * Common for RTP and RTCP.
        * @param aDelta  the difference between the stored packet Index and 
        *  current Packet Index
        * @return KErrNone if checks Ok, if not, return KErrArgument
        */
        TInt ReplayCheck(TInt aDelta) ;
        
        /*
        * Set Encryptor and Auth
        * Common for RTP and RTCP.
        * @param aEngAlg  Encrption Alg using for cryptor handler
        * @param aAuthAlg Authentication Algorithem using for crypto handler
        * @return void
        */
        void SetEncAndAuthL (TSRTPEncAlg aEngAlg, 
										TSRTPAuthAlg aAuthAlg);

    public: 
        /**
        * iHandlerOffset, List offset.
        * Owned by CCryptoContext object.
        */
        static const TInt iHandlerOffset;

        /**
        * iHandlerLink, Link to list.
        * Owned by CSRTPCryptoHandler object.
        */
        TSglQueLink iHandlerLink;
        
    protected: // data
    
        CSRTPStream&            iStream;         // stream
        
        CSRTPPacket*            iCurrentPacket;   // packet class        
        // algorithms: 
        MSRTPKeyDerivation*     iKeyDeriver;     // key divider algorithm
        MSRTPAuthentication*    iAuthenticator;  // authentication algorithm
        MSRTPCipher*            iCipher;         // encryption/decryption alg.
        TBool                   iMasterDataUpdated; // is master key or salt updated   
                    
        // session keys:
        HBufC8*                 iSessionEncrKey;  // session encryption/decryption key (k_e)
        HBufC8*                 iSessionAuthKey;  // session authentication key (k_a)
        HBufC8*                 iSessionSaltKey;  // session salting key (k_s)
		TBool                   iReKey; // is master key or salt updated    
		TUint64			  		iBitmap;		//Replay List
		TUint64					iNumPackets; //Number of packets has been recived / sending
    	
    private:
    #ifdef EUNIT_TESTING
        friend class UT_CSRTPCryptoHandler;
        friend class UT_CSRTPCryptoHandlerSRTP;
        friend class UT_CSRTPStreamIn;
        friend class UT_CSRTPStreamOut;
    #endif 
                   
    };
#endif // __SRTP_CRYPTOHANDLER_H__