// Copyright (c) 2005-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 <e32const.h>

 #include <e32debug.h>

 #include <bautils.h>

 #include <s32file.h>

 #include "CentRepConvTool.h"

 #include "shrepos.h"

 #include "inifile.h"

 #include "srvres.h"

 #include "srvparams.h"

 _LIT(KCentRepConvTool, "CentRep Conversion Tool:");

 const TInt KNumDigitsInUID = 8;

 //

 // factory method

 CCentRepConvTool* CCentRepConvTool::NewL(const TDesC& aCmd, RFs& aFs, TBool aWaitForAck)

 	{

 	CCentRepConvTool* self = new(ELeave) CCentRepConvTool(aCmd, aFs);

 	CleanupStack::PushL(self);

 	self->ConstructL(aWaitForAck);

 	CleanupStack::Pop(self);

 	return self;

 	}

 //

 // Constructor

 CCentRepConvTool::CCentRepConvTool(const TDesC& aCmd, RFs& aFs)

 	: iCmd(aCmd), iFs(aFs), iTextToBin(ETrue), iRepUid(KNullUid),

 	  iMyDataCage(KNullDesC), iDefaultPath(KNullDesC)

 	{

 	}

 //

 // two phase construct

 void CCentRepConvTool::ConstructL(TBool aWaitForAck)

 	{

 	iScrnOutput = CConsolePrint::NewL(aWaitForAck);

 	iFs.PrivatePath(iMyDataCage);

 	// set default I/O path

 	_LIT(KDefaultPathMask, "_:\\");

 	iDefaultPath.Copy(KDefaultPathMask);

 	iDefaultPath[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());

 	}

 //

 // destructor

 CCentRepConvTool::~CCentRepConvTool()

 	{

 	delete iScrnOutput;

 	delete iCentRepShrepos;

 	}

 //

 // setter

 void CCentRepConvTool::SetOutputMode(TBool aWaitForAck)

 	{

 	iScrnOutput->SetWaitMode(aWaitForAck);

 	}

 //

 // Extract input and output path from cmd line, determine text to

 // binary or binary to text, and invoke code in CentRep server classes

 // to do conversion.

 void CCentRepConvTool::ProcessCmdL()

 	{

 	_LIT(KSuccessMsg,"Output saved as: %S\r\n");

 	TPtrC inputPath(KNullDesC);

 	TPtrC outputPath(KNullDesC);

 	ParseCmdLineL(inputPath, outputPath);

 	// default input & output path is system drive root folder

 	iInputPath.Set(inputPath, NULL, NULL);

 	if (!iInputPath.DrivePresent() && !iInputPath.PathPresent())

 		{		

 		iInputPath.Set(inputPath, NULL, &iDefaultPath);

 		}

 	iOutputPath.Set(outputPath, NULL, NULL);

 	if (!iOutputPath.DrivePresent() && !iOutputPath.PathPresent())

 		{		

 		iOutputPath.Set(outputPath, NULL, &iDefaultPath);

 		}

 	// VerifyInputPathL must be call before VerifyOutputPathL!

 	VerifyInputPathL();

 	VerifyOutputPathL();

 	// Get UID from input filename

 	TLex lex(iInputPath.Name());

 	TUint32 intvalue;

 	lex.Val(intvalue, EHex);

 	iRepUid.iUid = intvalue;

 	TRAPD(err, DoConversionL());

 	if (err != KErrNone)    

 	    {    

         if (err == KErrCorrupt)    

             {    

             _LIT(KCorruptError, "Input file contains corrupted entries.\r\n");    

             RDebug::Print(KCentRepConvTool);    

             RDebug::Print(KCorruptError);    

             iScrnOutput->Printf(KCorruptError);    

             }    

         User::Leave(err);    

         } 

 	// Success

 	iScrnOutput->Printf(KSuccessMsg, &(iOutputPath.FullName()));

 	}

 //

 void CCentRepConvTool::DoConversionL()

 	{

 	iCentRepShrepos = CSharedRepository::NewL(iRepUid);

 	if (iTextToBin)

 		{

 		HBufC* tempIniFileName = iInputPath.FullName().AllocLC();

 		CIniFileIn* iniFile = NULL;

 		TInt ret=CIniFileIn::NewLC(iFs,iniFile,*tempIniFileName);

 		if (ret==KErrCorrupt)

 			User::LeaveIfError(iFs.Delete(*tempIniFileName));

 		User::LeaveIfError(ret);

 		User::LeaveIfError(iCentRepShrepos->ReloadContentL(*iniFile));

 		CleanupStack::PopAndDestroy(2); // tempIniFileName, iniFile

 		ExternalizeToCreL();

 		}

 	else

 		{

 		CDirectFileStore* store = CDirectFileStore::OpenLC(iFs,

 			iInputPath.FullName(), EFileRead|EFileShareReadersOnly);

 		if (store->Type()[0] != KDirectFileStoreLayoutUid)

 			{

 			CleanupStack::PopAndDestroy(store);

 			User::Leave(KErrCorrupt);

 			}		

 		// Get the root stream and attempt to read the index from it

 		TStreamId rootStreamId = store->Root() ;

 		RStoreReadStream rootStream ;

 		rootStream.OpenLC(*store, rootStreamId);

 		// Internalize the repository

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 		TUint8 creVersion;

 #endif		

 		iCentRepShrepos->InternalizeCreL(rootStream

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 		,creVersion

 #endif		

 		);

 		CleanupStack::PopAndDestroy(&rootStream);

 		CleanupStack::PopAndDestroy(store);

 		iCentRepShrepos->DoCommitChangesToIniFileL(iOutputPath.FullName()

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 		,creVersion

 #endif		

 		);

 		}

 	}

 //

 // Extract input path and output path from cmd line

 void CCentRepConvTool::ParseCmdLineL(TPtrC& aInputPath, TPtrC& aOutputPath)

 	{

 	_LIT(KNoWaitSwitch, "-nowait");

 	_LIT(KOutpathSwitch, "-o");

 	_LIT(KHelpSwitch, "-h");

 	_LIT(KBadArg, "Bad input arguments: %S\r\nUsage: CentRepConv [-o output_path]  [input_path\\]<repositoryUID>.txt\r\n");

 	_LIT(KHelpMsg, "Usage: CentRepConv [-o output_path]  [input_path\\]<repositoryUID>.txt\r\nDefault output_path=%S\r\nDefault input_path=%S\r\n");

 	const TInt KMaxNumTokens = 8; // Arbitrary. only expect 4. 

 	TPtrC tokens[KMaxNumTokens];

 	TLex lex(iCmd);

 	TInt i;

 	for (i = 0; !lex.Eos() && i < KMaxNumTokens; i++)

 		{

 		tokens[i].Set(lex.NextToken());

 		}

 	TInt numTokens = i;

 	// Expect: [-nowait] [-o output_path] [input_path\]<rep_UID>.txt

 	for (i = 0; i < numTokens; i++)

 		{

 		if (tokens[i].CompareF(KOutpathSwitch) == 0)

 			{

 			// Got the -o switch.

 			if ((i+2) < numTokens)

 				{

 				aOutputPath.Set(tokens[i+1]);

 				aInputPath.Set(tokens[i+2]);

 				}

 			break;	

 			} // tokens[i] == "-o"

 		else if (tokens[i].CompareF(KNoWaitSwitch) == 0)

 			{

 			SetOutputMode(EFalse);

 			continue;

 			}

 		else if (tokens[i].FindF(KHelpSwitch) == 0)

 			{

 			numTokens = 0; // indicator for help message

 			break;

 			}

 		else if ('-' == tokens[i][0])

 			{

 			continue; // unknown switch, assume intended for system

 			}

 		// No options. Token must be input file name.

 		aInputPath.Set(tokens[i]);

 		break;

 		} // for

 	if (0 == numTokens)

 		{

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KHelpMsg, &iDefaultPath, &iDefaultPath);

 		iScrnOutput->Printf(KHelpMsg, &iDefaultPath, &iDefaultPath);

 		User::Leave(KErrArgument);

 		}

 	// aOutputPath can be blank but aInputPath is mandatory.

 	if (aInputPath.Length() == 0)

 		{

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KBadArg, &iCmd);

 		iScrnOutput->Printf(KBadArg, &iCmd);

 		User::Leave(KErrArgument);

 		}

 	}

 //

 // Validate the input filenames.

 void CCentRepConvTool::VerifyInputPathL()

 	{

 	// Check input file is .txt or .cre

 	iTextToBin = (iInputPath.Ext().CompareF(*TServerResources::iIniExt) == 0);

 	TBool binInput = !iTextToBin && (iInputPath.Ext().CompareF(*TServerResources::iCreExt) == 0);

 	if (!iTextToBin && !binInput)

 		{

 		_LIT(KBadExt, "Bad input filename: %S\r\nInput file extension must be %S or %S\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KBadExt, &iCmd, TServerResources::iIniExt,

 			TServerResources::iCreExt);

 		iScrnOutput->Printf(KBadExt, &iCmd, TServerResources::iIniExt,

 			TServerResources::iCreExt);

 		User::Leave(KErrArgument);	

 		}

 	// check input filename is 8 hex digits.

 	TPtrC p(iInputPath.Name());

 	TBool validName = (KNumDigitsInUID == p.Length());

 	if (validName)

 		{

 		TLex lex(p);

 		for (TInt i = 0; validName && i<KNumDigitsInUID; i++)

 			{

 			if (lex.Peek().IsHexDigit())

 				{

 				lex.Inc();

 				}

 			else

 				{

 				validName = EFalse;

 				}				

 			} // for

 		} // if validName

 	if (!validName)	

 		{

 		_LIT(KBadRepUid, "Input filename in %S is not a valid UID.\r\nExpect 8 hex digits.\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KBadRepUid, &iCmd);

 		iScrnOutput->Printf(KBadRepUid, &iCmd);

 		User::Leave(KErrArgument);

 		}

 	p.Set(iInputPath.FullName());

 	if ( InOthersPrivatePath(p) )

 		{

 		_LIT(KInfileCaged, "Cannot access input file %S because it is in private data cage.\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KInfileCaged, &p);

 		iScrnOutput->Printf(KInfileCaged, &p);

 		User::Leave(KErrAccessDenied);

 		}

 	if (!BaflUtils::FileExists(iFs, p))

 		{

 		_LIT(KInFileNotExists, "Input file %S does not exist.\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KInFileNotExists, &p);

 		iScrnOutput->Printf(KInFileNotExists, &p);

 		User::Leave(KErrNotFound);

 		}

 	}

 //

 // Validate the output filenames.

 void CCentRepConvTool::VerifyOutputPathL()

 {

 	// If output filename is not specified, fill in the missing parts.

 	TBool EmptyOutFileName = EFalse;

 	TPtrC outFileName(iOutputPath.Name());

 	if (outFileName.Length())

 		{

 		if (0 != outFileName.CompareF(iInputPath.Name()))

 			{

 			_LIT(KUnmatchFilenames, "Bad input: %S\r\nInput filename does not match output filename.\r\n");

 			RDebug::Print(KCentRepConvTool);

 			RDebug::Print(KUnmatchFilenames, &iCmd);

 			iScrnOutput->Printf(KUnmatchFilenames, &iCmd);

 			User::Leave(KErrArgument);

 			}

 		}

 	else

 		{

 		EmptyOutFileName = ETrue;

 		outFileName.Set(iInputPath.Name()); 

 		}

 	TPtrC correctExt(*TServerResources::iCreExt);

 	TPtrC outFileExt(iOutputPath.Ext());

 	if (!iTextToBin)

 		{

 		correctExt.Set(*TServerResources::iIniExt);

 		}

 	if (outFileExt.Length())

 		{

 		// If output filename is specified, extension should match conversion.

 		if (0 != outFileExt.CompareF(correctExt))

 			{

 			_LIT(KUnmatchExt, "Bad input: %S\r\nExtension of output filename not valid.\r\n");

 			RDebug::Print(KCentRepConvTool);

 			RDebug::Print(KUnmatchExt, &iCmd);

 			iScrnOutput->Printf(KUnmatchExt, &iCmd);

 			User::Leave(KErrArgument);

 			}

 		}

 	else

 		{

 		EmptyOutFileName = ETrue;

 		outFileExt.Set(correctExt);

 		}

 	TPtrC p;

 	if (EmptyOutFileName)

 		{

 		const TInt KFilePlusExtLen = KNumDigitsInUID + 4; // e.g. 01234567.cre

 		TBuf<KFilePlusExtLen> newName(outFileName);

 		newName.Append(correctExt);

 		p.Set(iOutputPath.DriveAndPath());

 		TParse newpath;

 		newpath.Set(newName, NULL, &p);

 		p.Set(newpath.FullName());

 		iOutputPath.Set(p, NULL, NULL);

 		}

 	// Check output file is in other's private data cage

 	p.Set(iOutputPath.FullName());	

 	if ( InOthersPrivatePath(p) )

 		{

 		_LIT(KOutfileInDataCage, "Cannot write output file %S because it is in private data cage.\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KOutfileInDataCage, &p);

 		iScrnOutput->Printf(KOutfileInDataCage, &p);

 		User::Leave(KErrAccessDenied);

 		}

 	// Check saving output to read only drive.

 	p.Set(iOutputPath.DriveAndPath());	

 	TBool isReadOnly;

 	TInt ret;

 	ret = BaflUtils::DiskIsReadOnly(iFs, p, isReadOnly);

 	if (ret == KErrNone)

 		{

 		if (isReadOnly)

 			{

 			_LIT(KWriteToReadOnly, "Bad argument: output dir %S is in read only drive.\r\n");

 			RDebug::Print(KCentRepConvTool);

 			RDebug::Print(KWriteToReadOnly, &p);

 			iScrnOutput->Printf(KWriteToReadOnly, &p);

 			User::Leave(KErrArgument);

 			}

 		}

 	ret = iFs.MkDirAll(p);

 	if (ret != KErrNone && ret != KErrAlreadyExists)

 		{

 		_LIT(KCreateOutpathFail, "Create output path %S failed, err %d.\r\n");

 		RDebug::Print(KCentRepConvTool);

 		RDebug::Print(KCreateOutpathFail, &p, ret);

 		iScrnOutput->Printf(KCreateOutpathFail, &p, ret);

 		User::Leave(ret);

 		}

 	}

 //

 // Open a RWriteStream on top of a CDirectFileStore. Call

 // CSharedRepository's ExternalizeCre method to write the 

 // settings to file.

 void CCentRepConvTool::ExternalizeToCreL()

 	{

 	// Create file store

 	CDirectFileStore* store = CDirectFileStore::ReplaceLC(iFs,

 		iOutputPath.FullName(), (EFileWrite | EFileShareExclusive));

 	const TUid uid2  = KNullUid;

 	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid, uid2, KServerUid3)) ; 

 	// Write the stream index/dictionary as root stream within the store

 	// so we can access it when we do a restore later on

 	RStoreWriteStream rootStream ;

 	TStreamId rootStreamId = rootStream.CreateLC(*store) ;

 	iCentRepShrepos->ExternalizeCre(rootStream);

 	rootStream.CommitL();

 	CleanupStack::PopAndDestroy(&rootStream) ;

 	store->SetRootL(rootStreamId);

 	store->CommitL();

 	CleanupStack::PopAndDestroy(store); 	

 	}

 //

 // Check if given path is located in some other process's

 // private data cage

 TBool CCentRepConvTool::InOthersPrivatePath(const TDesC& aFullPathName)

 	{

 	_LIT(KPrivate, "\\private\\");

 	const TInt KPosAfterDrive = 2;

 	return aFullPathName.FindF(KPrivate) == KPosAfterDrive &&

 		   aFullPathName.FindF(iMyDataCage) == KErrNotFound;

 	}