/*

* 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 SRTP utility functions (mostly mathematical

*                 and calculation oriented).

*

*/

#ifndef __SRTPUTILS_H__

#define __SRTPUTILS_H__

// INCLUDES

#include <e32def.h>

#include <e32err.h>

#include <e32math.h>

#include <e32std.h>

#include <f32file.h>

#ifdef SRTP_UNIT_TEST_COVERAGE

#undef _DEBUG

#undef SRTP_LOG

#endif

#if ( defined( _DEBUG ) && ( defined ( SRTP_LOG )  ) )

#define _SRTP_FILE                     

#endif   

#if ( defined( _DEBUG ) && !( defined ( _SRTP_FILE )  ) )

#define SRTP_DEBUG_DETAIL( a ) { TSRTPUtils::Print( _L( a ) ); }

#define SRTP_DEBUG_PACKET( a ) 

#define SRTP_DEBUG_TINT_VALUE( a, b ) { TSRTPUtils::Print( _L( a ), static_cast<TInt>( b ) ); }

#define SRTP_DEBUG_TUINT_VALUE( a, b ) { TSRTPUtils::Print( _L( a ), static_cast<TInt>( b ) );}

#define SRTP_DEBUG_TUINT32_VALUE( a, b ) { TSRTPUtils::Print( _L( a ), static_cast<TInt>( b ) );}

#endif

#ifdef _SRTP_FILE 

#define SRTP_DEBUG_DETAIL( a ) { TSRTPUtils::Print( KLogFile,  _L( a ) ); }

#define SRTP_DEBUG_PACKET( a ) { TSRTPUtils::SrtpPrintToFile( a ); }

#define SRTP_DEBUG_TINT_VALUE( a, b ) { TSRTPUtils::Print( KLogFile, _L( a ), b ); }

#define SRTP_DEBUG_TUINT_VALUE( a, b ) { TSRTPUtils::Print( KLogFile, _L( a ), static_cast<TInt>( b ) ); }

#define SRTP_DEBUG_TUINT32_VALUE( a, b ) { TSRTPUtils::Print( KLogFile, _L( a ), static_cast<TInt>( b ) ); }

#endif

#if ( !defined( _DEBUG )  )

#define SRTP_DEBUG_DETAIL( a )

#define SRTP_DEBUG_PACKET( a ) 

#define SRTP_DEBUG_TINT_VALUE( a, b ) 

#define SRTP_DEBUG_TUINT_VALUE( a, b ) 

#define SRTP_DEBUG_TUINT32_VALUE( a, b ) 

#endif

// DATA TYPES

_LIT( KDefaultPath, "c:\\system\\data\\" );

_LIT( KLogFile, "LogFileSRTP.dat" );

_LIT( KSRTPString, "SRTP : ");

// 

const TUint16 K2EXP16           = 65536;

const TUint32 K2EXP32           = 4294967296;

const TUint64 KSRTPIndexLength  = 0x1000000000000;

const TUint64 KSRTCPIndexLength  = 0x100000000;

class TSRTPUtils

    {

    public: 

        /**

        * Count IV to be used as Integer Value in

        * AES-CM RTP/RTCP encryption/decryption.

        * @param aRes resulting 128 bit IV

        * @param aSalt 112 bit session salt (not padded)

        * @param aSSRC 32 bit SSRC value from packet (not padded)

        * @param aIndex 48 bit packet index (RTP, not padded) or

        *               31 bit SRTCP index (RTCP, not padded)

        * @return KErrNone/KErrArgument        

        */

        static TInt CountIV(TDes8& aRes, 

                        const TDesC8& aSalt,

                        TUint aSSRC,

                        TUint64 aIndex);

        /**

        * Add 16 bit padding for 112 bit session salt        

        * @param aRes resulting 128 bit padded session salt

        * @param aSalt 112 bit session salt 

        * @return void        

        */

        static void GetIVFirstTerm(TDes8& aRes, const TDesC8& aSalt);

        /**

        * Add 64 bit padding for 32 bit SSRC value

        * @param aRes resulting 96 bit padded SSRC value

        * @param aSSRC 32 bit SSRC value from packet

        * @return void        

        */

        static void GetIVSecondTerm(TDes8& aRes, TUint aSSRC);

        /**

        * Add 16 bit padding for RTP/RTCP packet index

        * @param aRes resulting 64/47 bit index

        * @param aIndex 48 bit packet index (RTP, not padded) or

        *               31 bit SRTCP index (RTCP, not padded)

        * @return void        

        */

        static void GetIVThirdTerm(TDes8& aRes, TUint64 aIndex);

        /*

        * r is calculated in following way:

        * 'index DIV key_derivation_rate'

        * This function is common to RTP and RTCP.

        * @param aIndex packet index

        * @param derivation rate 

        * @return 'index DIV key_derivation_rate'

        */

        static TUint64 Cnt_r(const TUint64 aIndex, const TUint32 aDerivRate);

        /*

        * key_id is calculated in following way:

        * 'label || r'

        * This function is common to RTP and RTCP.

        * @param aLabel 8 bit RTP/RTCP value

        * @param a_R, 'index DIV key_derivation_rate'

        * @param aIndexLength, packet index length (RTP or RTCP)

        * @return key_id ('label || r')

        */

        static TUint64 Cnt_key_id(const TUint8 aLabel,

                              const TUint64 a_R,

                              const TUint64 aIndexLength);

        /*

        * TUint16 SRTPUtils::Read16()

        * Read a 16-bit value given as 2 consecutive bytes in MSB order

        * Memory (at least 2 bytes) must have been allocated to pointer

        * before the function is called.

        */

        static TUint16 Read16( const TUint8* const aPointer );

        /*

        * Write a 16-bit value as 2 consecutive bytes in MSB order

        * Memory (at least 2 bytes) must have been allocated to pointer

        * before the function is called.

        */

        static void Write16( TUint8* const aPointer, TUint16 aValue );

        /*

        * TUint32 SRTPUtils::Read32()

        * Read a 32-bit value given as 2 consecutive bytes in MSB order

        * Memory (at least 2 bytes) must have been allocated to pointer

        * before the function is called.

        */

        static TUint32 Read32( const TUint8* const aPointer );

        /*

        * Write a 32-bit value as 2 consecutive bytes in MSB order

        * Memory (at least 2 bytes) must have been allocated to pointer

        * before the function is called.

        */

        static void Write32( TUint8* const aPointer, TUint32 aValue );

        /*

        * Calculates 'x', which is needed in key derivation.

        * Is calculated in following way:

        * 'key_id XOR master_salt'

        * This function is common to RTP and RTCP.

        * @param a_key_id, 

        * @param aRes, result

        * @param aSalt master salt

        * @return 'x', ('key_id XOR master_salt')

        */

        static void Cnt_x(const TUint64 a_key_id, TDes8& aRes, const TDesC8& aSalt);

        /*

        * Integer division of "a div b",

        * with exception that 'a div 0' == 0 for all a

        * This function is common to RTP and RTCP.

        * @param aA, value A

        * @param aB, value B

        * @return SRTP style "a div b"

        */

        static TUint64 SrtpDIV(const TUint64 aA ,const TUint64 aB);

        /*

        * Converts 8 bit descriptor ASCII values to hex values

        * @param aSrc, source descriptor

        * @param aDest, source descriptor

        * @return void

        */

        static void DeHex(const TDesC8 &aSrc, TDes8 &aDest);

        /*

        * Converts an 8 bit ASCII value to hex value

        * @param c, character

        * @return hex value 

        */

        static TUint8 HexVal(TUint8 c);

        /*

        * Converts a string into hex

        * @param aString, string to convert

        * @return none.

        */

        static void HexString(HBufC8& aString);

#ifdef _DEBUG        

		static TUint GtGetTime();

        static void Print( const TDesC& aP );

		static void Print( const TDesC& aP , TInt aValue );

#endif

#ifdef _SRTP_FILE

		static void Print( const TDesC& name, const TDesC& aP );

        static void Print( const TDesC& name, const TDesC& aP, TInt aValue );

		static void OctetToHexString(TPtrC8 aString, int length, const TDesC& aName);

		static void SrtpPrint( TPtrC8 aString );

		static void SrtpPrintToFile( TPtrC8 aString );

#endif

    };

#ifdef _SRTP_FILE    

class TFileUtil

    {

    public:

        static TInt LogMessage( const TFileName&, const TDesC& );

        static TInt InitLogFile( const TFileName& name );

    };

#endif

#endif // __SRTPUTILS_H__