/*

* Copyright (c) 2005 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.

*

*/

// INCLUDES

#include "srtputils.h"

#include <e32math.h>

#define DES_AS_8_BIT(str) (TPtrC8((TText8*)((str).Ptr()), (str).Size()))

// ---------------------------------------------------------------------------

// TSRTPUtils::CountIV()

// ---------------------------------------------------------------------------

//

TInt TSRTPUtils::CountIV(TDes8& aRes, 

                        const TDesC8& aSalt,

                        TUint aSSRC,

                        TUint64 aIndex)

    { 

    SRTP_DEBUG_DETAIL( "TSRTPUtils::CountIV ENNTRY");

    TBuf8<32> firstIVTerm;    

    TBuf8<32> secondIVTerm;    

    TBuf8<32> thirdIVTerm;    

    GetIVFirstTerm(firstIVTerm, aSalt);

    GetIVSecondTerm(secondIVTerm, aSSRC);

    GetIVThirdTerm(thirdIVTerm, aIndex);

    if (aRes.Length() != 16)

        {

        SRTP_DEBUG_TINT_VALUE( "the length is", aRes.Length() );

        return KErrArgument;        

        }

    //first XOR 1st (=padded session salt) and 2nd (= padded SSRC) terms

    for (TInt i=0; i<16; i++)

        {

        aRes[i] = firstIVTerm[i] ^ secondIVTerm[i];        

        }      

    //next XOR result with 1st term

    for (TInt i=0; i<16; i++)

        {

        aRes[i] = thirdIVTerm[i] ^ aRes[i];        

        }      

    SRTP_DEBUG_DETAIL( "TSRTPUtils::CountIV EXIT");

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::GetIVFirstTerm()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::GetIVFirstTerm(TDes8& aRes, const TDesC8& aSalt)

    {

    TInt count = 16 - aSalt.Length();

    aRes.Copy(aSalt);

    for (TInt i = 0; i<count; i++ )

        {

        aRes.Append(0x00);        

        }            

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::GetIVSecondTerm()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::GetIVSecondTerm(TDes8& aRes, TUint aSSRC)

    {

    TBuf8<32> ssrc;    

    TBuf8<32> temp;    

    ssrc.AppendNumUC(aSSRC, EHex); 

    TSRTPUtils::DeHex(ssrc, aRes); 

    for (TInt i=0; i<8; i++)

        {

        aRes.Append(0x00);        

        }

    TInt count = 16 - aRes.Length();

    for (TInt i = 0; i<count; i++ )

        {

        temp.Append(0x00);        

        }                    

    aRes.Insert(0, temp);        

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::GetIVThirdTerm()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::GetIVThirdTerm(TDes8& aRes, TUint64 aIndex)

    {

    TBuf8<32> temp;

    TBuf8<32> index;    

    index.AppendNumUC(aIndex, EHex); 

    TSRTPUtils::DeHex(index, aRes); 

    aRes.Append(0x00);        

    aRes.Append(0x00);        

    TInt count = 16 - aRes.Length();

    for (TInt i = 0; i<count; i++ )

        {

        temp.Append(0x00);        

        }                    

    aRes.Insert(0, temp);        

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::Cnt_r()

// ---------------------------------------------------------------------------

//

TUint64 TSRTPUtils::Cnt_r(const TUint64 aIndex, 

                         const TUint32 aDerivRate)

    {   

    return SrtpDIV(aIndex, aDerivRate);

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::Cnt_key_id()

// ---------------------------------------------------------------------------

//

TUint64 TSRTPUtils::Cnt_key_id(const TUint8 aLabel,

                              const TUint64 a_R,

                              const TUint64 aIndexLength)

    {   

    return (aLabel * aIndexLength + a_R);

    }    

// ---------------------------------------------------------------------------

// TUint16 TSRTPUtils::Read16()

// ---------------------------------------------------------------------------

//

TUint16 TSRTPUtils::Read16( const TUint8* const aPointer )

    {

    return static_cast<TUint16>( aPointer[1] + ( aPointer[0] << 8 ) );

    }    

// ---------------------------------------------------------------------------

// TSRTPUtils::Write16()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::Write16( TUint8* const aPointer, TUint16 aValue )

    {

    // check value range (16 bits)

    aPointer[0] = static_cast<TUint8>( ( aValue & 0xFF00 ) >> 8 );

    aPointer[1] = static_cast<TUint8>( aValue & 0x00FF );

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::Write32()

// Write a 32-bit aValue as 4 consecutive bytes in MSB order

// Memory (at least 4 bytes) must have been allocated to aPointer

// before the function is called.

// ---------------------------------------------------------------------------

void TSRTPUtils::Write32( TUint8* const aPointer, TUint32 aValue )

    {

    aPointer[0] = static_cast<TUint8>( ( aValue & 0xFF000000 ) >> 24 );

    aPointer[1] = static_cast<TUint8>( ( aValue & 0x00FF0000 ) >> 16 );

    aPointer[2] = static_cast<TUint8>( ( aValue & 0x0000FF00 ) >> 8 );

    aPointer[3] = static_cast<TUint8>( aValue & 0x000000FF );

    }

// ---------------------------------------------------------------------------

// TUint32 TSRTPUtils::Read32()

// Read a 32-bit aValue given as 4 consecutive bytes in MSB order

// Memory (at least 4 bytes) must have been allocated to aPointer

// before the function is called.

// ---------------------------------------------------------------------------

TUint32 TSRTPUtils::Read32( const TUint8* const aPointer )

    {

    return ( aPointer[3] +

             ( static_cast<TUint32>( aPointer[2] ) << 8 ) +

             ( static_cast<TUint32>( aPointer[1] ) << 16 ) +

             ( static_cast<TUint32>( aPointer[0] ) << 24 ) );

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::Cnt_x()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::Cnt_x(const TUint64 a_key_id, TDes8& aRes, const TDesC8& aSalt)

    {  

    TBuf8<32> key_id;    

    TBuf8<16> key_id_dehexed;    

    key_id.AppendNumUC(a_key_id, EHex); 

    TSRTPUtils::DeHex(key_id, key_id_dehexed); 

    aRes.Copy(aSalt);

    TUint key_length = key_id_dehexed.Length();

    TUint salt_length = aRes.Length();

    TInt i,j;

    for (i=key_length-1, j=salt_length-1; i>=0; i--, j--)

        {

        aRes[j] = key_id_dehexed[i] ^ aRes[j];        

        }      

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::SrtpDIV()

// ---------------------------------------------------------------------------

//

TUint64 TSRTPUtils::SrtpDIV(const TUint64 aA ,const TUint64 aB)

    {   

    if (aB == 0)

        {

        return 0;        

        }

    else

        {

        return (aA / aB);

        }

    }

// ---------------------------------------------------------------------------

// TSRTPUtils::HexVal()

// ---------------------------------------------------------------------------

//

TUint8 TSRTPUtils::HexVal(TUint8 c)

	{

	if (c >= 'a' && c <= 'f')

		return (TUint8)(c - 'a' + 10);

	else if (c >= 'A' && c <= 'F')

		return (TUint8)(c - 'A' + 10);

	else if (c >= '0' && c <= '9')

		return (TUint8)(c - '0');

	else

		return 0;

	}

// ---------------------------------------------------------------------------

// TSRTPUtils::HexString()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::HexString(HBufC8& aString)

    {

    TPtr8 ptr=aString.Des();

    if (aString.Length()%2)

        {

        ptr.SetLength(0);

        return;

        }

    TInt i;

    for (i=0;i<aString.Length();i+=2)

        {

        TUint8 tmp;

        tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));

        tmp*=16;

        tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));

        ptr[i/2]=tmp;

        }

    ptr.SetLength(aString.Length()/2);

    }	

// ---------------------------------------------------------------------------

// TSRTPUtils::DeHex()

// ---------------------------------------------------------------------------

//

void TSRTPUtils::DeHex(const TDesC8 &aSrc, TDes8 &aDest)

	{

	const TUint8 *s = aSrc.Ptr();

	int i = aSrc.Length();

	TUint8 d1, d2;

    TReal remainder;

    Math::Mod(remainder,i,2);

    if (remainder>0)

        {

		d1 = TSRTPUtils::HexVal(*s++);        

		aDest.Append((TUint8)(d1));	

		i--;	    		    

        }	

	    while (i > 0)

		    {

		    d1 = TSRTPUtils::HexVal(*s++);

		    d2 = TSRTPUtils::HexVal(*s++);		    

		    aDest.Append((TUint8)(d1 * 16 + d2));		    

		    i -= 2;

		    }        

	}

#ifdef _SRTP_FILE

// ---------------------------------------------------------------------------

// TInt TSRTPUtils::Print()

// 

// ---------------------------------------------------------------------------

//

void  TSRTPUtils::Print( const TDesC& aName, const TDesC& aP )

    {

    HBufC* msg = NULL;

    TRAPD( msgError, msg = HBufC::NewL( aP.Length() + 20 ) );

    if ( msgError != KErrNone )

       	{

    	delete msg; msg = NULL;

    	return;

    	}

    TPtr16 b( msg->Des() );

    b.Append( KSRTPString );

    b.AppendFormat( _L( "%u - " ), ( TUint * ) ( TSRTPUtils::GtGetTime() ) );

    b.Append( aP );

    b.Append( _L( "\n" ) );

    TFileUtil::LogMessage( aName, b );

    delete msg;

    }

// ---------------------------------------------------------------------------

// TInt TSRTPUtils::Print()

// 

// ---------------------------------------------------------------------------

//

void TSRTPUtils::Print( const TDesC& aName, const TDesC& aP, TInt aValue )

    {

    HBufC* msg = NULL;

    TRAPD( msgError, msg = HBufC::NewL( aP.Length() + 106 ) );

    if ( msgError != KErrNone )

        {

    	delete msg; msg = NULL;

    	return;

    	}

    TPtr16 b( msg->Des() );

    b.Append( KSRTPString );

    //apend current time

    b.AppendFormat( _L( "%u - " ), ( TUint * ) ( TSRTPUtils::GtGetTime() ) );

    b.Append( aP );

    b.AppendFormat( _L( "<%d> " ), aValue );

    b.Append( _L( "\n" ) );

    TFileUtil::LogMessage( aName, b );

    delete msg;

    }

// ---------------------------------------------------------------------------

// TInt TFileUtil::LogMessage()

// 

// ---------------------------------------------------------------------------

//

TInt TFileUtil::LogMessage( const TFileName& name, const TDesC& mess )

    {

    RFs fs;

    RFile file;

    TFileName nameWithPath;

    nameWithPath = KDefaultPath;

    nameWithPath.Append( name );

    nameWithPath.ZeroTerminate();

    TInt err = fs.Connect();

    if ( err != KErrNone )

        return err;

    err = file.Open( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );

    if ( err == KErrNotFound )

        err = file.Create( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );

    if ( err != KErrNone )

        return err;

    TInt off( 0 );

    err = file.Seek( ESeekEnd, off );

    if ( err != KErrNone )

        return err;

    file.Write( DES_AS_8_BIT (mess) );

    file.Flush();

    file.Close();

    fs.Close();

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TInt TFileUtil::InitLogFile()

// 

// ---------------------------------------------------------------------------

//

TInt TFileUtil::InitLogFile( const TFileName& name )

    {

    RFs fs;

    RFile file;

    TFileName nameWithPath;

    nameWithPath = KDefaultPath;

    nameWithPath.Append( name );

    nameWithPath.ZeroTerminate();

    TInt err = fs.Connect();

    if ( err != KErrNone )

        return err;

    err = file.Replace( fs, nameWithPath, EFileStream | EFileWrite | EFileShareExclusive );

    if ( err != KErrNone )

        return err;

    file.Close();

    fs.Close();

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// void SrtpPrint()

// Utility function for logging a string

// ---------------------------------------------------------------------------

//

void TSRTPUtils::SrtpPrintToFile( TPtrC8 aString )

    {

	TSRTPUtils::OctetToHexString( aString, aString.Length(), KLogFile );      	

    }

// ---------------------------------------------------------------------------

// void TSRTPUtils::OctetToHexString()

// Write the Hex Character to the files

// ---------------------------------------------------------------------------

//

void

TSRTPUtils::OctetToHexString(TPtrC8 aString, int length, const TDesC& aName) 

	{

	  TBuf<256> test;

	  int i;

	  /* double length, since one octet takes two hex characters */

	  TInt len= length *2;

	  if (len<256)

	  	{

	    for (i=0;i<length;i++)

	        {

	        TUint8 di;

	        di= (TUint8)((aString[i]>>4)&0xF);

	        test.AppendNumUC(di, EHex);

	        di=(TUint8)(aString[i]&0xF);

	        test.AppendNumUC(di, EHex);

	        }

	    test.Append( _L( "\n" ));

	   	TFileUtil::LogMessage( aName, test );

	  	}

	}

#endif

#ifdef _DEBUG

// ---------------------------------------------------------------------------

// TInt TSRTPUtils::Print()

// 

// ---------------------------------------------------------------------------

//

void TSRTPUtils::Print( const TDesC& aP )

    {

    HBufC* msg = NULL;

    TRAPD( msgError, msg = HBufC::NewL( aP.Length() + 20 ) );

    if ( msgError != KErrNone )

    	{

    	delete msg; msg = NULL;

    	return;

    	}

    TPtr16 b( msg->Des() );

    b.Append( KSRTPString );

    //apend current time

    b.AppendFormat( _L( "%u - " ), ( TUint * ) ( TSRTPUtils::GtGetTime() ) );

    b.Append( aP );

    b.Append( _L( "\n" ) );

    TBuf<128> buf;

    buf.Copy( b );

    RDebug::Print( buf );

    delete msg;

    }