// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // f32\sfile\sf_prel.cpp

 // 

 //

 #include "sf_std.h"

 #include "u32std.h"

 #include <e32hal.h>

 #include "sf_cache_man.h"

 _LIT(KLitInitCompleteThread,"InitCompleteThread");

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 _LIT(KCorruptFileNamesList,"CorruptFileNames.lst");

 _LIT(KSysData,"\\sys\\data\\");

 _LIT(KSystemData,"\\system\\data\\");

 /**

 ASCII text file reader constructor

 This code is more or less lifted directly from estart.cpp

 */

 TText8FileReader::TText8FileReader()

 	{

 	iBufPos=-1;

 	iFileDataBuf=NULL;

 	iFileSize=0;	

 	}

 /**

 ASCII text file reader destructor

 */	

 TText8FileReader::~TText8FileReader()

 	{

 	delete[] iFileDataBuf;

 	}	

 /**	

 Supply an ASCII text file for the file reader. 

 This function reads the entire contents of this file into a buffer, converting to

 unicode / folding each character. Subsequent parsing of the file data is all done from this

 buffer.

 @param aFile The file to be read. Must already be opened for read access in EFileStreamText mode.  

 @return	KErrNone if no error.

 */

 TInt TText8FileReader::Set(RFile& aFile)

 	{

 	iFile=aFile;

 	iBuf.Zero();

 	iBufPos=0;

 	// Read the size of the file

 	TInt r=iFile.Size(iFileSize);

 	if (r!=KErrNone || !iFileSize)

 		return(KErrGeneral);

 	// Allocate a buffer to read in the 

 	iFileDataBuf=new TText[iFileSize+1];	// +1 in case need to NULL terminate the end of the last string

 	if (iFileDataBuf==NULL)

 		return(KErrNoMemory);

 	// Read the entire contents of the file into the buffer

 	TPtr fdata(NULL,0);	

 	TInt pos=0;

 	r=iFile.Seek(ESeekStart,pos);

 	while (pos<iFileSize)

 		{

 		if ((r=iFile.Read(iBuf))!=KErrNone)

 			return(r);

 		fdata.Set((iFileDataBuf+pos),0,iBuf.Length());	

 		fdata.Copy(iBuf);

 		fdata.Fold();

 		pos+=iBuf.Length();	

 		}

 	return(KErrNone);	

 	}

 /**

 Return the next record from the text file.

 @param aPtr A TPtr which is setup with the address and length of the next record, referencing

 the data in the reader's buffer.

 @return	KErrNone if a record is successfully loaded into the buffer, KErrEof if the end of the

 file is encountered, KErrGeneral if a file hasn't been set.

 */

 TInt TText8FileReader::Read(TPtr& aPtr)

 	{

 	// Check that Set() has been called.

 	if (iBufPos<0)

 		return(KErrGeneral);

 	// Check if we have run into the end of the file	

 	TInt bufRemainder=(iFileSize-iBufPos);

 	if (!bufRemainder)

 		return(KErrEof);

 	// Setup the descriptor passed with the next record - don't include the record terminator

 	// The line terminators are CR + LF for DOS

 	// whereas only LF for Unix line endings

 	aPtr.Set((iFileDataBuf+iBufPos),bufRemainder,bufRemainder);

 	TInt len=aPtr.Locate('\n');

 	if (len != KErrNotFound)

 		{

 		iBufPos += len;

 	    // Check for DOS line ending to support both DOS and Unix formats

 	    if ((len != 0) && (iFileDataBuf[iBufPos-1] == '\r'))

 			{

 			len--;

 			}

 		aPtr.SetLength(len);

 		}

 	else

 		iBufPos=iFileSize;

 	// Point iBufPos to the next non-empty line

 	while (iBufPos<iFileSize && (iFileDataBuf[iBufPos]=='\n' || iFileDataBuf[iBufPos]=='\r'))

 		iBufPos++;

 	return(KErrNone);

 	}

 /**

 Parse a record and split it into filename, error code & use once flag

 @param aLine, this a a record from read from the file

 @param aName, this is the parsed filename component of the record

 @param aReturnCode, the error code that will be returned when an attempt is made to open the file

 @param aUseOnce, flag which states whether the error should persist over more than one open attempt

 @return error code, if the record is malformed return KErrCorrupt (ironic, what?) else KErrNone

 */

 TInt ParseCorruptNamesRecord(TPtr aLine, TPtr& aName, TInt& aReturnCode, TBool&  aUseOnce)

 	{

 	aName.Set(NULL,0,0);

 	// Remove leading spaces

 	aLine.TrimLeft();

 	TPtr remainderPtr(aLine);

 	// collect pathname

 	TInt lenFileName=remainderPtr.Locate(',');

 	if(lenFileName<1)

 		return KErrCorrupt;

 	TPtr pathNamePtr(remainderPtr.LeftTPtr(lenFileName));

 	// Remove trailing spaces

 	pathNamePtr.TrimRight();

 	// Parse the pathname to see if it could be valid, do not allow wild cards

 	TParse fileParse;

 	TInt r=fileParse.SetNoWild(pathNamePtr,NULL,NULL);

 	if(r!=KErrNone)

 		return KErrCorrupt;

 	// move over delimiter to collect the user supplied return code

 	// see first if sufficient length in the record

 	TInt lenRemainder=remainderPtr.Length();

 	if(lenRemainder<lenFileName+2)

 		return KErrCorrupt;

 	remainderPtr.Set(remainderPtr.MidTPtr(lenFileName+1));

 	remainderPtr.TrimLeft();

 	TInt lenReturnCode=remainderPtr.Locate(',');

 	if(lenReturnCode<1)

 		return KErrCorrupt;

 	TPtr returnCodePtr(remainderPtr.LeftTPtr(lenReturnCode));

 	TLex lexLine(returnCodePtr);

 	TInt returnCode;

 	if(lexLine.Val(returnCode)!=KErrNone)

 		return KErrCorrupt;

 	lenRemainder=remainderPtr.Length();

 	if(lenRemainder<lenReturnCode+2)

 		return KErrCorrupt;

 	// collect the useOnce flag value

 	remainderPtr.Set(remainderPtr.MidTPtr(lenReturnCode+1));

 	remainderPtr.Trim();

 	TBool useOnce;

 	// This must either be "EVERY" or "ONCE"

 	if (remainderPtr.MatchF(_L("EVERY"))!=KErrNotFound)

 		useOnce=EFalse;

 	else if(remainderPtr.MatchF(_L("ONCE"))!=KErrNotFound)

 		useOnce=ETrue;

 	else

 		return KErrCorrupt;

 	// Everything has worked out, so set up output args

 	aName.Set(pathNamePtr);

 	aReturnCode=returnCode;

 	aUseOnce=useOnce;

 	return KErrNone;

 	}

 /**

 Open c:\CorruptFileNames.lst

 File contains a set of text records

 Each record has comma delimited fields and has the form:

  <filename>, <errorCode>, <[ONCE,EVERY]>

 e.g.

 c:\system\bin\bt.lst, -6,EVERY

 the filename should be fully qualified,

 errorCode should be a literal not a symbol

 EVERY means that every attempt to open the file will be failed

 ONCE means that only the first access to the file will be failed

 */

 TInt FindHitListFile(RFs aFs)

 	{

 	TFindFile finder(aFs);

 	TInt r=finder.FindByDir(KCorruptFileNamesList,_L("\\"));

 	if(r!=KErrNone)

 		{

 		r=finder.FindByDir(KCorruptFileNamesList,KSysData);

 		}

 	if(r!=KErrNone)

 		{

 		r=finder.FindByDir(KCorruptFileNamesList,KSystemData);

 		}

 	if(r==KErrNone)

 		{  // This is stored as a global because the name can be retrieved by a user api

 		gCorruptFileNamesListFile=finder.File().Alloc();

 		if(gCorruptFileNamesListFile==NULL)

 			{

 			r=KErrNoMemory;

 			}

 		}

 	return r;

 	}

 void CreateCorruptFileNamesList()

 	{

 	RFs fs;

 	fs.Connect();

 	TInt r=FindHitListFile(fs);

 	if(r!=KErrNone)

 		return;

 	RFile f;

 	r=f.Open(fs,*gCorruptFileNamesListFile,EFileShareExclusive|EFileStreamText|EFileRead);

 	if(r!=KErrNone)

 		{

 		return;

 		}

 	// Create a corrupt filenames file reader and pass it the file object. This will also result in the copying of the contents of

 	// the file into reader's buffer. Filename information read from the file will include pointers to text strings in

 	// this buffer and so the reader object must not be deleted until processing is complete.

 	__PRINT1(_L("@@@@ Using Corrupt names file %S"),gCorruptFileNamesListFile);

 	TText8FileReader* namesFile=new TText8FileReader;	

 	if (!namesFile)

 		{

 		f.Close();

 		return;

 		}

 	r=namesFile->Set(f);

 	f.Close();

 	fs.Close();

 	if(r==KErrNone)

 		{

 		// Parse each drive mapping record in turn, saving the information in an array of mapping structures - one for

 		// each valid record.

 		TPtr linePtr(NULL,0);

 		while ((r=namesFile->Read(linePtr))==KErrNone)

 			{		

 			TInt returnCode;

 			TBool useOnce;

 			TPtr namePtr(NULL,0);

 			if (ParseCorruptNamesRecord(linePtr,namePtr,returnCode,useOnce)==KErrNone)

 				{

 				// Valid corrupt filename record found

 				TCorruptNameRec* newRec=new TCorruptNameRec;

 				if(!newRec)

 					{

 					break;

 					}

 				if(newRec->Construct(&namePtr,returnCode,useOnce,gCorruptFileNameList)!=KErrNone)

 					{

 					delete newRec;

 					newRec=NULL;

 					break;

 					}

 				gCorruptFileNameList=newRec;

 				}

 			else

 				{

 				__PRINT1(_L("@@@@@ Bad Parse corrupt file name record %S\n"),&linePtr);

 				}

 			}

 		}

 	delete namesFile;

 	}

 #endif

 TInt InitCompleteThread(TAny* aPtr)

 	{

 	__PRINT(KLitInitCompleteThread);

 	RMessagePtr2 message=*(RMessagePtr2*)aPtr;

 	RThread::Rendezvous(0);

 	//

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 	CreateCorruptFileNamesList();

 #endif

 	TInt r = KErrNone;

 	message.Complete(r);

 	return(KErrNone);

 	}

 TInt TFsStartupInitComplete::DoRequestL(CFsRequest *aRequest)

 //

 // do further initialisation once necessary startup init complete outside file server

 //

 	{

 	if(StartupInitCompleted)

 		return(KErrAlreadyExists);

 	StartupInitCompleted=ETrue;

 	RMessagePtr2 msg=aRequest->Message();

 	RThread thread;

 	TInt r=thread.Create(KLitInitCompleteThread,InitCompleteThread,KDefaultStackSize,NULL,&msg);

 	if (KErrNone == r)

 		{

 		TRequestStatus s;

 		thread.Rendezvous(s);

 		if (s==KRequestPending)

 			thread.Resume();

 		else

 			thread.Kill(0);

 		thread.Close();

 		User::WaitForRequest(s);

 		r = s.Int();

 		}

 	return(KErrNone);

 	}

 TInt TFsStartupInitComplete::Initialise(CFsRequest* /*aRequest*/)

 //

 //

 //

 	{

 	return KErrNone;

 	}