/*
* 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