// Copyright (c) 2008-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 "crccheck.h"

 const TInt TDBMS_CRCChecks::SetSessionPath(const TDesC& aPath)

 	{

 	return ifs.SetSessionPath(aPath);

 	}

 TInt TDBMS_CRCChecks::FileCrcL(const RFile& aFile, TUint32 &asum)

 	{

 	const TInt KFileCrcBufSize = 1024;

 	TInt err;

 	TInt pos = 0;

 	// Seek to the beginning of the file.

 	if( (err = aFile.Seek(ESeekStart, pos)) != KErrNone)

 		return err;

 	RBuf8 buffer;

 	if((err = buffer.Create(KFileCrcBufSize)) != KErrNone)

 		return err;

 	CleanupClosePushL(buffer);

 	asum=0;

 	for(;;)

 		{

 		err = aFile.Read(buffer, KFileCrcBufSize);

 		if(err) break;

 		TInt len = buffer.Length();

 		if(len == 0) break;

 		Mem::Crc32(asum, (TAny*) buffer.Ptr(), len);

 		}

 	CleanupStack::PopAndDestroy(1, &buffer);

 	return err;

 	}

 const TInt TDBMS_CRCChecks::GenerateCrcL(const TPtrC aFile)

 	{

 	RFile file;

 	TInt err = file.Open(ifs, aFile, EFileRead);

 	RDebug::Print(_L("==================== File open=%S, err=%d\n"), &aFile, err);

 	if(err != KErrNone) 

 		return err;

 	CleanupClosePushL(file);

 	TestCheckInfo tcinf;

 	err = file.Size(tcinf.filesz);

 	if(err)

 		{

 		CleanupStack::PopAndDestroy(1);

 		return err;

 		}

 	err = FileCrcL(file, tcinf.crc);

 	if(err)

 		{

 		CleanupStack::PopAndDestroy(1);

 		return err;

 		}

     err = iarray.Append(tcinf);

 	CleanupStack::PopAndDestroy(1);

 	return err;

 	}

 const TInt TDBMS_CRCChecks::RecordCount()

 	{

 	return iarray.Count();

 	}

 const TestCheckInfo TDBMS_CRCChecks::operator[](const TInt aidx)

 	{

 	return iarray[aidx];

 	}

 const TInt TDBMS_CRCChecks::DumpCrcRecordsL(const TDesC &alog)

 	{

 	RFile logfile;

 	TInt err = logfile.Replace(ifs, alog, EFileWrite);

 	RDebug::Print(_L("==================== File replace=%S, err=%d\n"), &alog, err);

 	if(err != KErrNone)

 		return err;

 	CleanupClosePushL(logfile);

 	TBuf8<0x100> output;

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

 		{

 		output.SetLength(0);

 		TestCheckInfo tc = iarray[i];

 		output.AppendFormat(_L8("%d %d 0x%08x\n"), i+1, tc.filesz, tc.crc );

 		err = logfile.Write(output);

 		if(err) break;

 		}

 	CleanupStack::PopAndDestroy(1);

 	return err;

 	}

 const TInt TDBMS_CRCChecks::ValidateCrcRecordsL(const TDesC &alog)

 	{

 	RFile logfile;

 	TInt err = logfile.Open(ifs, alog, EFileRead);

 	RDebug::Print(_L("==================== File open=%S, err=%d\n"), &alog, err);

 	if(err != KErrNone)

 		return err;

 	CleanupClosePushL(logfile);

 	TInt logfilesz;

 	if((err = logfile.Size(logfilesz)) != KErrNone)

 		{

 		CleanupStack::PopAndDestroy(1);

 		return err;

 		}

 	RBuf8 input;

 	if((err = input.Create(logfilesz)) != KErrNone)

 		{

 		CleanupStack::PopAndDestroy(1);

 		return err;

 		}

 	CleanupClosePushL(input);

 	// Read the entire file.

 	err = logfile.Read(input);

 	if(err != KErrNone)

 		{

 		CleanupStack::PopAndDestroy(2);

 		return err;

 		}

 	TInt nread = input.Length();

 	if(nread != logfilesz)

 		{

 		CleanupStack::PopAndDestroy(2);

 		User::Leave(KErrCorrupt);  // wrong error.

 		}

 	TPtrC8 slice;

 	slice.Set(input);

 	TInt offset=0;

 	TBuf8<0x100> expected;

 	TInt i; // we check this after the loop...

 	for(i=0; ; i++)

 		{

 		// Find the next carriage return in the file. 'slice' represents

 		// the next bit of the file before the next carriage return.

 		// Will this break on Symbian? That has '\r\n'...

 		TInt nextcr = slice.Locate(TChar('\n'));

 		// If no carriage return is found we must have reached the end of

 		// the file.

 		if(nextcr == KErrNotFound)

 		  	break;

 		// 'got' is the current line from the file, including the carriage

 		// return.

 		TPtrC8 got = slice.Left(nextcr+1);

 		// Before we construct the string this object expects to see,

 		// check we're not out of array..

 		// The number of lines in the file we checking should match what

 		// we have in our internal array.

 		if(i >= iarray.Count())

 			{

 			err = ECrcCheckMoreRecords;

 			break;

 			}

 		// Construct a string from our internal data that is expected to be

 		// the same as the data read in from the crc file.

 		expected.SetLength(0);

 		TestCheckInfo tc = iarray[i];

 		expected.AppendFormat(_L8("%d %d 0x%08x\n"), i+1, tc.filesz, tc.crc );

         // Compare what we've got to what we expect.

 		if(got.Compare(expected) != 0)

 			{

 			err = ECrcCheckMismatch;

 			break;

 			}

 		offset += nextcr + 1;

 		slice.Set(input.Mid(offset));

 		}

 	// The number of lines in the file we checking should match what

 	// we have in our internal array. Here this indicates that we seem to

 	// have more in our array than appear in the file.

 	if(!err && (i != iarray.Count()))

 		err = ECrcCheckFewerRecords;

 	CleanupStack::PopAndDestroy(2);

 	return err;

 	}

 const void TDBMS_CRCChecks::ErrorReportL(const TInt aerr, TPtrC& aerrmsg)

 	{

 	switch(aerr)

 		{

 		case KErrNotFound:

 				aerrmsg.Set(_L("Failed to open CRC log file.\n"));

 				break;

 		case KErrNoMemory:

 				aerrmsg.Set(_L("Out of memory.\n"));

 				break;

 		case KErrNone:

 		case ECrcCheckOk:

 				aerrmsg.Set(_L("CRC check ok.\n"));

 				break;

 		case ECrcCheckMismatch:

 				aerrmsg.Set(_L("CRC mismatch.\n"));

 				break;

 		case ECrcCheckFewerRecords:

 				aerrmsg.Set(_L("Fewer CRCs than in the file!\n"));

 				break;

 		case ECrcCheckMoreRecords:

 				aerrmsg.Set(_L("More CRCs in the file than I have!\n"));

 				break;

 		default:

 				aerrmsg.Set(_L("Broken!\n")); // PANIC?

 				break;

 		}

 	return;

 	}

 #ifdef CRC_TEST

 int E32Main(void)

 	{

 	CTrapCleanup *cleanup = CTrapCleanup::New();

 	__ASSERT_ALWAYS(cleanup != NULL, User::Invariant());

 	TDBMS_CRCChecks mycrc;

 	TInt err;

    	TRAPD(lc, err = mycrc.GenerateCrcL(_L("crcchecks.mmp")));

    	TRAP(lc, err = mycrc.GenerateCrcL(_L("bld.inf")));

 	TRAP(lc, err = mycrc.DumpCrcRecordsL(_L("wibble")));

    	TRAP(lc, err = mycrc.GenerateCrcL(_L("t_alter.mmp")));

 	TRAP(lc, err = mycrc.ValidateCrcRecordsL(_L("wibble")));

 	switch(err)

 		{

 		case TDBMS_CRCChecks::ECrcCheckMismatch:

 				printf("Got CRC mismatch\n");

 				break;

 		case TDBMS_CRCChecks::ECrcCheckFewerRecords:

 				printf("I have more CRCs than in the file!\n");

 				break;

 		case TDBMS_CRCChecks::ECrcCheckMoreRecords:

 				printf("More CRCs in the file than I have!\n");

 				break;

 		default:

 				printf("Broken!\n");

 				break;

 		}

 	printf("Leavecode = %d, err = %d\n", lc, err );

 	delete cleanup;

 	}

 #endif