/*

* Copyright (c) 2010 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 FILES

#include <e32svr.h>

#include "tcrypt.h"

// EXTERNAL FUNCTION PROTOTYPES  

extern "C" {

IMPORT_C char *crypt(const char *key, const char *salt);

IMPORT_C void setkey(const char *key);

IMPORT_C void encrypt(char block[], int edflag);

}

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void GetBitVector(char data[], char* buffer);

LOCAL_C char *TrimWhiteSpaces(char *string);

// ============================= LOCAL FUNCTIONS ===============================

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

// TrimWhiteSpaces

// To to trim whitespaces in the input string

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

//

LOCAL_C char *TrimWhiteSpaces(char *string)

{

	char *pTemp = string;

	for(;*string != '\0'; string++)

	{

		if((*string == ' ') || (*string == '\t'))

		{

			pTemp++;

		}

	}

	return pTemp;

}

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

// GetBitVector

// This function unpacks the byte to obtain the corresponding bit vector

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

//

LOCAL_C void GetBitVector(char data[], char* buffer)

{

	int temp;

	if(buffer != NULL )

	{

		temp = strlen(buffer);

		for(int i = 0 ; i<temp ; ++i, ++buffer)

		{

			data[i] = *buffer - '0';

		}

	}

}

CTestCrypt::~CTestCrypt() 

	{ 

	}  

CTestCrypt::CTestCrypt(const TDesC& aStepName)

	{

	// MANDATORY Call to base class method to set up the human readable name for logging.

	SetTestStepName(aStepName);		

	}

TVerdict CTestCrypt::doTestStepPreambleL()

	{

	__UHEAP_MARK;	

	SetTestStepResult(EPass);

	iTestDataFile = fopen("C:\\tcrypt\\test_data.dat", "r");	

	if(iTestDataFile == NULL)

		{

		SetTestStepResult(EFail);	

		}

	return TestStepResult();

	}

TVerdict CTestCrypt::doTestStepPostambleL()

	{

	fclose(iTestDataFile);

	__UHEAP_MARKEND;	

	return TestStepResult();

	}

TVerdict CTestCrypt::doTestStepL()

	{

	int err;

	if(TestStepName() == KEncrypt)

		{

   		INFO_PRINTF1(_L("Encrypt():"));

   		err = Encrypt();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

	else if(TestStepName() == KCrypt)

		{

   		INFO_PRINTF1(_L("Crypt():"));

   		err = Crypt();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	return TestStepResult(); 

	}

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

// CTestCrypt::Encrypt

// Encrypt function

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

//

TInt CTestCrypt::Encrypt()

{

	static int tId = 0;

	char pTemp[30];

	memset(pTemp, 0, 30);

	sprintf(pTemp, "ENCRYPT_TEST_DATA_%d", ++tId);

    INFO_PRINTF2(_L("Begin: ENCRYPT_TEST_DATA_%d\n"), tId);

    // locate "test_data_id" from within the file

    if(!RepositionFilePointer(pTemp))

    {

    	// String not found...invalid test data ID

    	INFO_PRINTF1(_L("Requested test data ID could not be found\n"));

    	return KErrNotFound;

    }

	// Get the key, data block, operation to be performed and the 

	// expected output for the current test data ID

	char key[64] = 

	{

		 0

	};

	char block[64] = 

	{

		0

	};

	char output[64] = 

	{

		0

	};

	int edflag = -1;

	if(GetEncryptTestData(key, block, &edflag, output) != KErrNone)

	{

		// Test data not found or is not present in the expected 

		// format

		INFO_PRINTF1(_L("Test data not found or is not present in the expected format\n"));

		return KErrNotFound;

	}

	// Perform encryption/decryption

	// Invoke setkey from the libcrypt library

	setkey(key);

	// Call the encrypt function

	encrypt(block,edflag);

	// Verify if the final output is same as the expected output

	if(!strcmp(block,block))

	{

		INFO_PRINTF2(_L("End: ENCRYPT_TEST_DATA_%d\n"), tId);

		// Test case passed

		return KErrNone;

	}

	INFO_PRINTF1(_L("Output from the encrypt() function does not match the \"expected output\""));

	INFO_PRINTF2(_L("End: ENCRYPT_TEST_DATA_%d\n"), tId);

	return KErrNotFound;

}

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

// CTestCrypt::RepositionFilePointer

// This function positions the file pointer to the line immediately following

// the string aString

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

//

TInt CTestCrypt::RepositionFilePointer(const char *aString)

{

    char buffer[256];

   	char * ptr = NULL;

    while(fgets((char*)buffer, 256, iTestDataFile) != NULL)

    {

    	 ptr = NULL;

    	if((ptr=strchr(buffer,'\r')) || (ptr=strchr(buffer,'\n'))) //check for both

		*ptr='\0';

    	if(!strcmp(buffer, aString))

    	{

    		return 1;

    	}

    	memset(buffer, 0, 256);

    }

    return 0;

}

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

// CTestCrypt::GetEncryptTestData

// This function reads the test data for encrypt() API

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

//

TInt CTestCrypt::GetEncryptTestData(char key[], char block[], int *edflag, char output[])

{

	char buffer[256];

	char *p = NULL;

	bool bKey = false,		// will be set to true upon reading 'key'

	     bBlock = false,    // will be set to true upon reading 'data block'

	     bEdflag = false,   // will be set to true upon reading 'edflag'

	     bOutput = false;   // will be set to true upon reading 'expected output'

	char *pTemp = NULL;

   	char * ptr = NULL;

	while((p = fgets(buffer, 256, iTestDataFile)) != NULL)

	{

		ptr = NULL;

    	if((ptr=strchr(buffer,'\r')) || (ptr=strchr(buffer,'\n'))) //check for both

			*ptr='\0';

		if(strstr(buffer, "//") != NULL)

		{

			continue;

		}

		if(!strcmp(buffer, "END_TEST_DATA"))

		{

			if(bKey && bBlock && bEdflag && bOutput)

			{

				return KErrNone;

			}

			return KErrNotFound;

		}

		if(strstr(buffer, "KEY") != NULL)

		{

			// Read the key

			// Get bytes...

			pTemp = strstr(buffer, ":");

			if(pTemp != NULL)

			{

				pTemp++;

			    pTemp = TrimWhiteSpaces(pTemp);

				GetBitVector(key, pTemp);

			}

			bKey = true;

			continue;

		}

		if(strstr(buffer, "DATA_BLOCK") != NULL)

		{

			// Read the data block

			pTemp = strstr(buffer, ":");

			if(pTemp != NULL)

			{

				pTemp++;

				pTemp = TrimWhiteSpaces(pTemp);

				GetBitVector(block, pTemp);

			}

			bBlock = true;

			continue;

		}

		if(strstr(buffer, "ED_FLAG") != NULL)

		{

			// Read the ed_flag parameter

			pTemp = strstr(buffer, ":");

			if(pTemp != NULL)

			{

				pTemp++;

				pTemp = TrimWhiteSpaces(pTemp);

				*edflag = (*pTemp) - '0';

			}

			bEdflag = true;

			continue;

		}

		if(strstr(buffer, "EXPECTED_OUTPUT") != NULL)

		{

			// Read the bit vector for the expected output

			pTemp = strstr(buffer, ":");

			if(pTemp != NULL)

			{

				pTemp++;

				pTemp = TrimWhiteSpaces(pTemp);

				GetBitVector(output, pTemp);

			}

			bOutput = true;

			continue;

		}

	}

	return KErrNotFound;

}

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

// CTestCrypt::Crypt

// Test function to perform crypt() on the input data

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

//

TInt CTestCrypt::Crypt()

{

	static int tId = 0;

	char pTemp[30];

	memset(pTemp, 0, 30);

	sprintf(pTemp, "CRYPT_TEST_DATA_%d", ++tId);

    INFO_PRINTF2(_L("Begin CRYPT_TEST_DATA_%d\n"), tId);

    // locate "test_data_id" from within the file

    if(!RepositionFilePointer(pTemp))

    {

    	// String not found...invalid test data ID

    	INFO_PRINTF1(_L("Requested test data ID could not be found\n"));

    	return KErrNotFound;

    }

    char password[34] = 

    {

    	'\0'

    };

    char salt[30] = 

    {

    	'\0'

    };

    char output[35] = 

    {

    	'\0'

    };

    if(GetCryptTestData(password, salt, output) != KErrNone)

    {

    	// Data not in the expected format or is invalid

    	INFO_PRINTF1(_L("Test data not found or is not present in the expected format\n"));

    	return KErrNotFound;

    }

    char *crypt_output = NULL;

    // Invoke crypt()

    crypt_output = crypt(password,salt);

	if(!strcmp(output,""))

	{

		// Since salt is NULL, the expected output is ignored...

		return KErrNone;

	}

    if(!strcmp(salt, ""))

    {

		// salt is NULL, so skip the first byte from the crypt output

		if(crypt_output != NULL)

		{

			crypt_output++;

			if(!strcmp(crypt_output, &output[0]))

			{

				INFO_PRINTF2(_L("End: CRYPT_TEST_DATA_%d\n"), tId);

				return KErrNone;

			}

			INFO_PRINTF1(_L("Output from the crypt() function does not match the \"expected output\""));

			return KErrNotFound;

		}

    }

    else

    {

    	// salt is not NULL

    	if(!strcmp(crypt_output, output))

    	{

    		INFO_PRINTF2(_L("End: CRYPT_TEST_DATA_%d\n"), tId);

    		return KErrNone;

    	}

    	INFO_PRINTF1(_L("Output from the crypt() function does not match the \"expected output\""));

    	return KErrNotFound;

    }

    return KErrNotFound;

}

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

// CTestCrypt::GetCryptTestData

// To retrieve the test data for crypt() API

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

//

TInt CTestCrypt::GetCryptTestData(char password[], char salt[], char output[])

{

	char buffer[256];

	char *p = NULL;

	char *pTemp = NULL;

	int nLength = 0;

	bool bPassword = false,

	     bSalt = false,

	     bOutput = false;

   	char * ptr = NULL;

	while((p = fgets(buffer, 256, iTestDataFile)) != NULL)

	{

    	ptr = NULL;

    	if((ptr=strchr(buffer,'\r')) || (ptr=strchr(buffer,'\n'))) //check for both

			*ptr='\0';

		if(strstr(buffer, "//") != NULL)	// skip the comments

		{

			// "//" could appear within password or salt, so further

			// check is required

			// Since judicious use of whitespaces is allowed only from within

			// the comment lines, the comment line will always start with

			// "//"

			if(buffer[0] == '/' && buffer[1] == '/')

			{

				continue;

			}

		}

		if(!strcmp(buffer, "END_TEST_DATA"))

		{

			if(bPassword && bSalt && bOutput)

			{

				return KErrNone;

			}

			return KErrNotFound;

		}

		// Verify if the input buffer has "data". Data is followed by ":"

		pTemp = strstr(buffer, ":");

		if(pTemp != NULL)

		{

			pTemp++;

			pTemp = TrimWhiteSpaces(pTemp);

			nLength = strlen(pTemp);

			if(strstr(buffer, "PASSWORD") != NULL)

			{

				strncpy(password,pTemp,nLength);

				bPassword = true;

				continue;

			}

			else if(strstr(buffer, "SALT") != NULL)

			{

				strncpy(salt,pTemp,nLength);

				bSalt = true;

				continue;

			}

			else if(strstr(buffer, "EXPECTED_OUTPUT") != NULL)

			{

				strncpy(output,pTemp,nLength);

				bOutput = true;

				continue;

			}

			else

			{

				// Unexpected output

				return KErrNotFound;

			}

		}

	}

	return KErrNotFound;

}

//  End of File