/*
* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
* Example CTestStep derived implementation
*
*/


/**
 @file
 @internalTechnology
*/
#include "symmetriccipherincrementalencryptdecryptstep.h"

#include "filewriter.h"
#include "filecompare.h"

using namespace CryptoSpi;

CSymmetricCipherIncrementalEncryptDecryptStep::~CSymmetricCipherIncrementalEncryptDecryptStep()
	{
	}


CSymmetricCipherIncrementalEncryptDecryptStep::CSymmetricCipherIncrementalEncryptDecryptStep(TInt aOffset) : iOffset(aOffset)
	{
	SetTestStepName(KSymmetricCipherIncrementalEncryptDecryptStep);
	}


TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepPreambleL()
	{
	SetTestStepResult(EPass);
	return TestStepResult();
	}


TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepL()
	{
	INFO_PRINTF1(_L("*** Symmetric Cipher - Incremental Encrypt/Decrypt ***"));
	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
	
  	if (TestStepResult()==EPass)
		{
		
		//Assume faliure, unless all is successful
		SetTestStepResult(EFail);
		
		TPtrC srcPath;
		if (!GetStringFromConfig(ConfigSection(),KConfigSourcePath, srcPath))
			{
			User::Leave(KErrNotFound);
			}
		
		TVariantPtrC operationMode;

		// Create a Symmetric Cipher with the values from the ini file	
		CryptoSpi::CSymmetricCipher * impl = NULL;	
			
		CKey* key = NULL;
		SetupCipherL(ETrue, EFalse, operationMode, impl, key);

		INFO_PRINTF1(_L("Plugin loaded."));
	
		CleanupStack::PushL(key);
		CleanupStack::PushL(impl);
		
		HBufC8* iv = NULL;
		TInt err(0);
		
		TInt blockSize(0);
		if (TUid(operationMode) == KOperationModeCTRUid)
			{
			blockSize = CtrModeCalcBlockSizeL(*impl);
			}
		else
			{
			blockSize = impl->BlockSize();
			}

		if((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid))
			{
			// blocksize is in bits so to allocate the correct number of bytes divide by 8
			// iv is left on the cleanup stack for the duration of the test and deleted in a conditional at the end of the outer block.
			// If this conditional block changes, take care to update the condition for deleting this allocated IV, near the end of this function.
			iv = HBufC8::NewLC(blockSize/8);	
				
			// blocksize is in bits so to allocate the correct number of 8 byte chunks divide by 64
			for(TInt i = 0 ; i <blockSize/64 ; i++)
				{
				iv->Des().Append(_L8("12345678"));
				}
					
			TRAP_LOG(err,impl->SetIvL(iv->Des()));
			}	

		// convert to bytesize
		blockSize/=8;
		blockSize += iOffset;
		
		//read from src file
		CFileReader* srcData = CFileReader::NewLC(srcPath,blockSize);


		// first step is to read from the src file one block
		// at a time, encrypt that block and then write
		// the encrypted block out to a temporary file.
		CFileWriter* encryptedDataWriter = CFileWriter::NewLC(TPtrC(KEncryptedFilePath));
			
		TInt numBlocks = srcData->NumBlocks();
				
		INFO_PRINTF1(_L("Encrypting Source Data..."));
	
		for(TInt i = 1 ; i <= numBlocks ; i++)
			{
			TRAP_LOG(err,srcData->ReadBlockL());
			
			//Create buffer for encrypted data
			TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*srcData).Length());
			HBufC8* encrypted =	HBufC8::NewLC(maxOutputLength);
			TPtr8 encryptedPtr = encrypted->Des();

			if(i == numBlocks)
				{
				TRAP_LOG(err,impl->ProcessFinalL(*srcData, encryptedPtr));
				}
			else
				{
				TRAP_LOG(err,impl->ProcessL(*srcData, encryptedPtr));
				}
					
			TRAP_LOG(err,encryptedDataWriter->WriteBlockL(encryptedPtr));
				
			CleanupStack::PopAndDestroy(encrypted); 
			}
		CleanupStack::PopAndDestroy(encryptedDataWriter); 
				
		if(err == KErrNone)
			{
			//Switch to decrypt
			TRAP_LOG(err,impl->SetCryptoModeL(KCryptoModeDecryptUid));
					
			//If in CTR mode need to reset the keystream to the start of the sequence used for encryption.
			if(TUid(operationMode) == KOperationModeCTRUid)
				{
				impl->SetIvL(iv->Des());
				}
				
			// the next step is to read the previously encrypted data
			// from the temporary file decrypting this one block
			// at a time and outputing this to a temporary file.
			CFileReader* encryptedDataReader = CFileReader::NewLC(TPtrC(KEncryptedFilePath),blockSize);
			CFileWriter* decryptedDataWriter = CFileWriter::NewLC(TPtrC(KDecryptedFilePath));
				
			numBlocks = encryptedDataReader->NumBlocks();
					
			INFO_PRINTF1(_L("Decrypting Data..."));
					
			for(TInt i = 1 ; i <= numBlocks ; i++)
				{
				TRAP_LOG(err,encryptedDataReader->ReadBlockL());
						
				//Create buffer for encrypted data
				TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*encryptedDataReader).Length());
				HBufC8* decrypted =	HBufC8::NewLC(maxOutputLength);
				TPtr8 decryptedPtr = decrypted->Des();

				//Perform the decryption operation
				if(i == numBlocks)
					{
					TRAP_LOG(err,impl->ProcessFinalL(*encryptedDataReader, decryptedPtr));
					}
				else
					{
					TRAP_LOG(err,impl->ProcessL(*encryptedDataReader, decryptedPtr));
					}
							
				TRAP_LOG(err,decryptedDataWriter->WriteBlockL(decryptedPtr));
					
				CleanupStack::PopAndDestroy(decrypted); 
				}
						
			CleanupStack::PopAndDestroy(decryptedDataWriter); 
			CleanupStack::PopAndDestroy(encryptedDataReader); 	
			}
				
		CleanupStack::PopAndDestroy(srcData);
		if((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid))
			{
			// Iv is left on the cleanupstack at creation.  
			// If it becomes possible for operationMode to be modified during
			// the test this needs to be re-engineered.
			CleanupStack::PopAndDestroy(iv);
			}
		CleanupStack::PopAndDestroy(impl);							
		CleanupStack::PopAndDestroy(key);
	
		// compare the src with the file thats been
		// encrypted then decrypted
		if(!TFileCompare::CompareL(srcPath,TPtrC(KDecryptedFilePath)))
			{
			INFO_PRINTF1(_L("PASS : Source File and Decrypted Data Match"));
			SetTestStepResult(EPass);
			}
		else
			{
			INFO_PRINTF1(_L("FAIL : Source File and Decrypted Data Mismatch"));	
			SetTestStepResult(EFail);
			}
				
		RFs rFs;
		rFs.Connect();
		rFs.Delete(	KDecryptedFilePath );
		rFs.Delete(	KEncryptedFilePath );
		rFs.Close();
		}
	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());

	return TestStepResult();
	}


TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepPostambleL()
	{
	return TestStepResult();
	}