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