/*
* Copyright (c) 2005-2009 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:
*
*/


#include <e32base.h>
#include <f32file.h>

#include <hash.h> // CryptoHW (md5hash)

#include "T_DataVerify.h"



/*@{*/
//Command LIT's
_LIT(KCmdVerifyData,	"VerifyData");
/*@}*/

/*@{*/
//LIT's for reading params from ini file
_LIT( KDataVerifyType,  "VerifyType" );
_LIT( KDataVerifyFile,  "VerifyFile" );
_LIT( KChecksum,     	"Checksum" );
_LIT( KMD5Type,			"MD5" );        // Use MD5 with data verify
/*@}*/


namespace DataVerify
	{
	const TInt KMD5Size = 32;
    const TInt KMD5length  = 32;
    const TInt KBufsize    = 512;
    const TInt KCharlength = 2;
	}

typedef TBuf8<DataVerify::KMD5length> THashBuf;

CT_DataVerify::CT_DataVerify():
	iMD5(NULL)
	{
	}

CT_DataVerify* CT_DataVerify::NewL()
	{
	CT_DataVerify* ret = new (ELeave) CT_DataVerify();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

CT_DataVerify::~CT_DataVerify()
	{
    iFs.Close();
    if(iMD5)
    	{
    	delete iMD5;
    	iMD5 = NULL;
    	}
	}

void CT_DataVerify::ConstructL()
	{
    User::LeaveIfError( iFs.Connect() );
    iMD5 = CMD5::NewL();
	}

TAny* CT_DataVerify::GetObject()
	{
	return NULL;
	}

TBool CT_DataVerify::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)
	{
	TBool retVal=ETrue;
	
	if (aCommand==KCmdVerifyData)
		{	
		DoCmdVerifyData(aSection);	
		}
	else
		{
		ERR_PRINTF1(_L("Unknown command"));
		retVal=EFalse;
		}

	return retVal;
	}


/**
 * Verifies that the downloaded file is not corrupted by using a previously calculated checksum.
 * @param aSection - The section in config file to look for the Data Verify Type, the file to verify and the checksum.
 * @return error - Error code. KErrNone if checksum is equal.
 */
void CT_DataVerify::DoCmdVerifyData(const TTEFSectionName& aSection)
    {
    INFO_PRINTF1(_L("*START* CT_TransferData::DoCmdVerifyData"));
    
    TBool dataOk =ETrue;
    TPtrC type;
    if(!GetStringFromConfig(aSection, KDataVerifyType, type ))
    	{
    	ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDataVerifyType);
    	SetBlockResult(EFail);
    	dataOk = EFalse;
    	}
    
    TPtrC filename;
    if(!GetStringFromConfig(aSection, KDataVerifyFile, filename ))
    	{
    	ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDataVerifyFile);
    	SetBlockResult(EFail);
    	dataOk = EFalse;
    	}
    
    TPtrC checksumParameter;
    if(!GetStringFromConfig(aSection, KChecksum, checksumParameter ))
    	{
    	ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KChecksum);
    	SetBlockResult(EFail);
    	dataOk = EFalse;
    	}
    if(dataOk)
    	{
    	TBuf8<DataVerify::KMD5Size> checksum;
    	checksum.Append(checksumParameter);

        if (type == KMD5Type)
            {
            INFO_PRINTF1(_L("MD5 selected"));
            TRAPD(error, VerifyChecksumL(checksum, filename));
            if (error == KErrNone)
                {
                INFO_PRINTF1(_L("Data verify succeeded"));
                }
            else
            	{
                ERR_PRINTF2(_L("VerifyData failed [%d]"), error);
                SetError(error);
            	}
            }
    	}

    
    INFO_PRINTF1(_L("*END* CT_TransferData::DoCmdVerifyData"));
    }


/**
 * Verify Data integrity
 *
 * @param aMethod			The verification method
 * @param aFileName			File to verify
 * @param aChecksum			Checksum
 *
 * @return					N/A
 *
 * @leave					System wide error
 */
void CT_DataVerify::VerifyData( const TDataVerifyMethod aMethod, const TFileName& aFileName, const TDesC& aChecksum )
	{
	TBool dataOk = ETrue;
	
	if( aFileName.Length() > KMaxFileName)
		{
		ERR_PRINTF2(_L("Illegal filename: %S"), &aFileName);
		SetBlockResult(EFail);
		dataOk = EFalse;
		}
	if(dataOk)
		{
		THashBuf checksum;
		checksum.Append( aChecksum );
		
		// Use MD5 to verify file
		if( aMethod == EDataVerifyMethodMD5 )
			{
			// MD5 selected
			TRAPD(error, VerifyChecksumL( checksum, aFileName ));
			if(error == KErrNone)
				{
				INFO_PRINTF1(_L("Data verify succeeded."));
				}
			else
				{
				ERR_PRINTF2(_L("Checksum verification left with error %d"), error);
				SetBlockResult(EFail);
				}
			}
		else
			{
			ERR_PRINTF1(_L("Verification method not supported"));
			SetBlockResult(EFail);
			}
		}
	}

/**
 * Verify File integrity
 *
 * @param aReferenceFileName	Reference file against to verify integrity
 * @param aDataFileName			File to verify
 *
 * @return						N/A
 *
 * @leave						System wide error
 */
void CT_DataVerify::VerifyFileL( const TFileName& aReferenceFileName, const TFileName& aDataFileName )
	{
	THashBuf refHash;

	// hash the first file
	HashFileL( aReferenceFileName, refHash );

	THashBuf dataHash;
	// hash the second file
	HashFileL( aDataFileName, dataHash );

	// compare hashes together
	if( !CompareBuffers( refHash, dataHash ) )
		{
		// Data was corrupted
		User::Leave( KErrCorrupt );
		}
	}

/**
 * Verify Buffer integrity
 *
 * @param aReferenceFileName	Reference file against to verify integrity
 * @param aData					Buffer to verify
 *
 * @return						N/A
 *
 * @leave						System wide error
 */
void CT_DataVerify::VerifyBufferL( const TFileName& aReferenceFileName, const TDesC8& aData )
    {
	HBufC8* refdata = 0;
	TPtr8 ptr = refdata->Des();
	// read file into buffer, file must fit into HBufC8
	ReadFileL( aReferenceFileName, ptr );

	// compare read file with given buffer
	if( !CompareBuffers( refdata->Des(), aData ) )
		{
		// Data was corrupted
		User::Leave( KErrCorrupt );
		}
    }

/**
 * Verify Buffer integrity
 *
 * @param aReferenceBuffer		Reference buffer against to verify integrity
 * @param aData					Buffer to verify
 *
 * @return						N/A
 *
 * @leave						System wide error
 */
void CT_DataVerify::VerifyBufferL( const TDesC8& aReferenceData, const TDesC8& aData )
	{
	// Compare buffers
	if ( !CompareBuffers( aReferenceData, aData ) )
		{
		// Data was corrupted
		User::Leave( KErrCorrupt );
		}
    }

/**
 * Verify Checksum integrity
 *
 * @param aReferenceMD5Checksum		Reference checksum
 * @param aDataFileName				File to verify
 *
 * @return							N/A
 *
 * @leave							System wide error
 */
void CT_DataVerify::VerifyChecksumL( const TDesC8& aReferenceMD5Checksum, const TFileName& aDataFileName )
	{
	// MD5 checksum is always 128 bit (32 char) long
	if( aReferenceMD5Checksum.Length() != DataVerify::KMD5length )
		{
		User::Leave( KErrBadDescriptor );
		}

	THashBuf hash;
	// hash file
	HashFileL( aDataFileName, hash );

	// converting MD5 checksum to binary is necessary because Hash() function
	// returns hash in binary format and reference checksum given in parameter
	// is a 32 character long string
	THashBuf conversion;
	ConvertString2HexL( aReferenceMD5Checksum, conversion );

	if( !CompareBuffers( conversion, hash ) )
		{
		// Data was corrupted
		User::Leave( KErrCorrupt );
		}
	}

/**
 * Verify Checksum integrity
 *
 * @param aReferenceMD5Checksum		Reference checksum
 * @param aData						Data to verify
 *
 * @return							N/A
 *
 * @leave							System wide error
 */
void CT_DataVerify::VerifyChecksumL( const TDesC8& aReferenceMD5Checksum, const TDesC8& aData )
    {
	// MD5 checksum is always 128 bit (32 char) long
	if( aReferenceMD5Checksum.Length() != DataVerify::KMD5length )
		{
		// MD5 Checksum was not correct length (32 characters)
		User::Leave( KErrBadDescriptor );
		}

	// hash the given buffer
	TPtrC8 hash = iMD5->Hash(aData);

	// converting MD5 checksum to binary is necessary because Hash() function
	// returns hash in binary format and reference checksum given in parameter
	// is a 32 character long string
	THashBuf conversion;
	ConvertString2HexL( aReferenceMD5Checksum, conversion );

	// Compare hashs together
	if( !CompareBuffers( conversion, hash ) )
		{
		// Data was corrupted
		User::Leave( KErrCorrupt );
		}
	}

/**
 * Compare Buffers
 *
 * @param aReferenceBuffer		Reference buffer
 * @param aDataBuffer			Buffer to compare
 *
 * @return						ETrue if buffer contents match
 */
TBool CT_DataVerify::CompareBuffers( const TDesC8& aReferenceBuffer, const TDesC8& aDataBuffer )
	{
	TBool res = EFalse;
	TInt result = aReferenceBuffer.Compare( aDataBuffer );
	
	if( result == 0 )
		{
		// Buffer contents match
		res = ETrue;
		}
	return res;
	}

/**
 * Read File
 *
 * @param aFileName			File name to read
 * @param aBuf				Buffer to read file content
 *
 * @return					N/A
 *
 * @leave					System wide error
 */
void CT_DataVerify::ReadFileL(const TFileName& aFileName, TDes8& aBuf)
    {
    RFile file;
    User::LeaveIfError( file.Open( iFs, aFileName, EFileRead ) );
    CleanupClosePushL( file );

    // Get the file size
    TInt size;
    User::LeaveIfError( file.Size( size ) );

    // allocate memory from heap for file content
    HBufC8* buf = HBufC8::NewLC( size );
    aBuf = buf->Des();

    // read file content into buffer, file may be too big for HBufC8
    User::LeaveIfError( file.Read( aBuf ) );

    CleanupStack::Pop( buf );
    CleanupStack::PopAndDestroy( &file ); // file.Close
    }

/**
 * Hash file in pieces
 *
 * @param aFileName			File name to be hashed
 * @param aDes				Hash value
 *
 * @return					N/A
 *
 * @leave					System wide error
 */
void CT_DataVerify::HashFileL( const TFileName& aFileName, TDes8& aDes )
	{
	RFile file;
	User::LeaveIfError( file.Open( iFs, aFileName, EFileRead ) );
	CleanupClosePushL( file );

	TBuf8<DataVerify::KBufsize> buf;

	TInt error = KErrNone;
	iMD5->Reset();
	// File can be hashed in pieces
	while( error == KErrNone ) // loop until something goes wrong
		{
		error = file.Read( buf, DataVerify::KBufsize );
		if( buf.Length() != 0 )
			{
			// MD5 checksum is calculated in pieces
			iMD5->Update(buf);
			}
		else
			{
			// file ended, end loop
			break;
			}
		}
	// Return calculated MD5 checksum
	aDes = iMD5->Final();

	CleanupStack::PopAndDestroy(&file); // file.Close
	}

/**
 * Write File
 *
 * @param aFileName			File name
 * @param aData				Data to be written into file name.
 *
 * @return					N/A
 *
 * @leave					System wide error
 */
void CT_DataVerify::WriteFileL( const TFileName& aFileName, const TDesC8& aData )
    {
    RFile file;
    // Create file, replace if exists
    User::LeaveIfError( file.Replace( iFs, aFileName, EFileWrite|EFileStream ) );
    CleanupClosePushL( file );
    // Write data into file
    User::LeaveIfError( file.Write( aData ) );
    // Commit write
    User::LeaveIfError( file.Flush() );

    CleanupStack::PopAndDestroy( &file ); // file.Close
    }

/**
 * Convert a string to Hexadecimal
 *
 * @param aData			String descriptor
 * @param aDes			Descriptor where Hex value is stored
 *
 * @return				N/A
 *
 * @leave				System wide error
 */
void CT_DataVerify::ConvertString2HexL( const TDesC8& aData, TDes8& aDes )
    {
	TBuf8<DataVerify::KCharlength> charBuf;

	// Check that buffer is even number
	if( ( aData.Length() % DataVerify::KCharlength ) != 0 )
		{
		User::Leave( KErrBadDescriptor );
		}

	// Go through the data and convert it two characters at a time
	// buffer overflow does not occur because buffer is checked to be even number first
	for( TInt i = 0, limit = aData.Length()-DataVerify::KCharlength; i <= limit; i+=DataVerify::KCharlength )
		{
		// Clean char buffer first
		charBuf.Delete( 0, charBuf.Length() );
		
		// Add KCharlength characters into buffer
		for ( TInt j = 0; j < DataVerify::KCharlength; j++ )
			{
			charBuf.Append( aData[i+j] );
			}

		TUint number;
		TLex8 converter = TLex8( charBuf );
		// Two characters together represent a hex number in MD5 checksum
		User::LeaveIfError( converter.Val( number, EHex ) );

		aDes.Append( number );
		}
	}