// Copyright (c) 1995-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_dat.cpp
// 
//

#include "sf_std.h"


CFsObjectConIx* TheContainer;
CFsObjectCon* FileSystems;
CFsObjectCon* Files;
CFsObjectCon* FileShares;
CFsObjectCon* Dirs;
CFsObjectCon* Formats;
CFsObjectCon* RawDisks;
CFsObjectCon* Extensions;
CFsObjectCon* ProxyDrives;

CServerFs* TheFileServer;
TDrive TheDrives[KMaxDrives];

//#ifndef __SECURE_API__
TFileName TheDefaultPath;
//#endif

HBufC* TheDriveNames[KMaxDrives];


SCapabilitySet AllCapabilities;
SCapabilitySet DisabledCapabilities;

RThread TheServerThread;
RAllocator* ServerThreadAllocator;
TBool OpenOnDriveZOnly;
TBool LocalFileSystemInitialized;
TBool RefreshZDriveCache;
TBool CompFsMounted;
TBool CompFsSync;
TBool StartupInitCompleted;
TBool LocalDriveMappingSet;
CKernEventNotifier* TheKernEventNotifier;
RFTrace TheFtrace;


GLDEF_D TCodePageUtils TheCodePage;

TBool FatUtilityFunctionsSet = EFalse;              //-- Flag. Is set to ETrue when LoadLocale() sets a pointer to TFatUtilityFunctions
TBool FatUtilitiesUpdateDrivesNotified = EFalse;    //-- Flag. Is set to ETrue when all drives get a notification about locale change



#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TInt ErrorCondition;
TInt ErrorCount;
TUint32 DebugReg;
TInt UserHeapAllocFailCount;
TInt KernHeapAllocFailCount;
TInt DebugNCNotifier=0;
TCorruptNameRec* gCorruptFileNameList=NULL;
TCorruptLogRec* gCorruptLogRecordList=NULL;
TInt gNumberOfCorruptHits=0;
HBufC* gCorruptFileNamesListFile=NULL;

#endif

TBool F32Properties::iInitialised = 0;
TInt  F32Properties::iRomAddress  = 0;
TInt  F32Properties::iRomLength   = 0;

EXPORT_C TBusLocalDrive& GetLocalDrive(TInt aDrive)
//
// Export localdrives
//
	{
	return(LocalDrives::GetLocalDrive(aDrive));
	}

EXPORT_C TInt GetProxyDrive(TInt aDrive, CProxyDrive*& aProxyDrive)
//
// Export proxy drives
//
	{
	return TheDrives[aDrive].CurrentMount().ProxyDrive(aProxyDrive);
	}

EXPORT_C CExtProxyDrive* GetProxyDrive(TInt aDrive)
	{
	return (LocalDrives::GetProxyDrive(aDrive));
	}

EXPORT_C TBool IsProxyDrive(TInt aDrive)
	{
	return (LocalDrives::IsProxyDrive(aDrive));
	}

EXPORT_C TBool IsValidLocalDriveMapping(TInt aDrive)
//
// Is the drive number to local drive mapping valid?
//
	{
	return(LocalDrives::IsValidDriveMapping(aDrive));
	}

EXPORT_C TInt DriveNumberToLocalDriveNumber(TInt aDrive)
//
// Get the mapping from drive number to local drive
//
	{
	return(LocalDrives::DriveNumberToLocalDriveNumber(aDrive));
	}

EXPORT_C TInt GetLocalDriveNumber(TBusLocalDrive* aLocDrv)
//
// Get the local drive number from local drive
//
	{
	return(LocalDrives::GetLocalDriveNumber(aLocDrv));
	}

struct TFatUtilityFunctions;
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TBool EnableFatUtilityFunctions = ETrue;
#endif
EXPORT_C const TFatUtilityFunctions* GetFatUtilityFunctions()
	{
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
	if (!EnableFatUtilityFunctions)
		{
		return NULL; // Bypass Locale Dll/Codepage FAT converions, use default implementation
		}
#endif
	switch(TheCodePage.CodepageLoaded())
		{
		case TCodePageUtils::ECodePageDll:
			return ((TFatUtilityFunctions*)(TheCodePage.CodepageFatUtilityFunctions().iConvertFromUnicodeL));
		case TCodePageUtils::ELocaleDll:
			return TheCodePage.LocaleFatUtilityFunctions();
		default:
			return NULL; // if no Locale Dll/Codepage Dll is loaded, use default implementation
		}
	}

EXPORT_C const TCodePageUtils& GetCodePage()
	{
	return TheCodePage;
	}

/**
@internalTechnology
Helper class for parsing F32 INI files
*/
class TIniFileReader
	{
public:
	TIniFileReader(const TPtrC8& aData);
	TInt Next();
	TBool IsSection(const TDesC8& aSection = KNullDesC8);
	TBool IsProperty(const TDesC8& aProperty, TBool& aPropVal);
	TBool IsProperty(const TDesC8& aProperty, TInt32& aPropVal);
	TBool IsProperty(const TDesC8& aProperty, TDes8& aPropVal);
public:
	const TPtrC8& iData;
	TPtr8 iCurrentLine;
	TInt iCurrentPos;
	};	


/**
@internalTechnology
TIniFileReader constructor
*/
TIniFileReader::TIniFileReader(const TPtrC8& aData)
  : iData(aData),
	iCurrentLine(NULL,0,256),
    iCurrentPos(0)
	{
	}

/**
@internalTechnology

Reads the next line from an F32 INI file.
	- On exit, iCurrentLine represents the current line
	- On exit, iCurrentPos points to the next line in the INI file
*/
TInt TIniFileReader::Next()
	{
	// Check if we have run into the end of the file	
	TInt bufRemainder = (iData.Length()-iCurrentPos);
	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
	iCurrentLine.Set(((TUint8*)iData.Ptr()+iCurrentPos),bufRemainder,bufRemainder);
	TInt len = iCurrentLine.Locate('\n');
	if (len != KErrNotFound)
		{
		iCurrentPos += len;
		// Check for DOS line ending to support both DOS and Unix formats
		if ((len != 0) && (((TUint8*)iData.Ptr())[iCurrentPos-1] == '\r'))
			{
			len--;
			}
		iCurrentLine.SetLength(len);
		}
	else
		{
		iCurrentPos=iData.Length();
		}
	
	// Point iCurrentPos to the next non-empty line
	while (iCurrentPos<iData.Length() && (((TUint8*)iData.Ptr())[iCurrentPos]=='\n' || ((TUint8*)iData.Ptr())[iCurrentPos]=='\r'))
		{
		iCurrentPos++;
		}
	
	// iCurrentLine now describes a single line of the INI file
	return(KErrNone);
	}

/**
@internalTechnology

Examines the current INI line, returning ETrue if the line contains the requested INI section
	- An INI section must be of the form [section_name]
	- Passing KNullDesC as an argument returns ETrue if the line describes any INI section
*/
TBool TIniFileReader::IsSection(const TDesC8& aSection)
	{
	TInt sectionStart = iCurrentLine.Locate('[');
	TInt sectionEnd   = iCurrentLine.Locate(']');
	if(sectionStart == 0 && sectionEnd > 1)
		{
		if(aSection == KNullDesC8)
			{
			return(ETrue);
			} 

		const TInt sectionLength = sectionEnd-sectionStart-1;
		// Found a start of section marker - does it match what we're interested in?
		TPtr8 sectionPtr(&iCurrentLine[1+sectionStart], sectionLength, sectionLength);
		if(sectionPtr == aSection)
			{
			return(ETrue);
			}
		}
	return(EFalse);
	}

/**
@internalTechnology

Examines the current INI line, returning ETrue if the line contains the requested property
*/
TBool TIniFileReader::IsProperty(const TDesC8& aProperty, TBool& aPropVal)
	{
	TPtrC8 token;
	TLex8 lex(iCurrentLine);
	token.Set(lex.NextToken());
	if (token.Length() == 0 || token != aProperty)
		{
		return(EFalse);
		}

	lex.SkipSpace();

	TInt32 propVal;
	if (lex.BoundedVal(propVal, 1) == KErrNone)
		{
		aPropVal = propVal;
		return(ETrue);
		}

	// allow "on" or "off" strings if no integer found
	_LIT8(KBoolOn,"ON");
	_LIT8(KBoolOff,"OFF");

	if (lex.Remainder().Left(KBoolOn().Length()).CompareF(KBoolOn) == KErrNone)
		{
		aPropVal = ETrue;
		return(ETrue);
		}
	if (lex.Remainder().Left(KBoolOff().Length()).CompareF(KBoolOff) == KErrNone)
		{
		aPropVal = EFalse;
		return(ETrue);
		}

	return(EFalse);
	}

/**
@internalTechnology

Examines the current INI line, returning ETrue if the line contains the requested property
*/
TBool TIniFileReader::IsProperty(const TDesC8& aProperty, TInt32& aPropVal)
	{
	TPtrC8 token;
	TLex8 lex(iCurrentLine);
	token.Set(lex.NextToken());
	if (token.Length() == 0 || token != aProperty)
		{
		return(EFalse);
		}

	lex.SkipSpace();

	TInt32 propVal;
	if (lex.Val(propVal) != KErrNone)
		{
		return(EFalse);
		}

	aPropVal = propVal;

	return(ETrue);
	}

/**
@internalTechnology

Examines the current INI line, returning ETrue if the line contains the requested property
*/
TBool TIniFileReader::IsProperty(const TDesC8& aProperty, TDes8& aPropVal)
	{
	TPtrC8 token;
	TLex8 lex(iCurrentLine);
	token.Set(lex.NextToken());
	if (token.Length() == 0 || token != aProperty)
		{
		return(EFalse);
		}

	lex.SkipSpace();

	aPropVal = lex.Remainder().Left(aPropVal.MaxLength());

	return(ETrue);
	}

/**
@internalTechnology

Initialises the F32 properties with a ROM address representing the INI file in ROM

@return KErrNone on success
@return KErrAlreadyExists if the properties have already been initialised
*/
EXPORT_C TInt F32Properties::Initialise(TInt aRomAddress, TInt aLength)
	{
	if(iInitialised)
		{
		// F32 properties have already been initialised
		return(KErrAlreadyExists);
		}

	iInitialised = ETrue;
	iRomAddress  = aRomAddress;
	iRomLength   = aLength;

	return(KErrNone);
	}

/**
@internalTechnology

Returns the requested F32 property string

@param aSection  The name of the F32 INI section
@param aProperty The name of the F32 propery within the section
@param aPropVal  Returns the requested property value (unchanged if the property does not exist)

@return ETrue if the property exists, EFalse otherwise
*/
EXPORT_C TBool F32Properties::GetString(const TDesC8& aSection, const TDesC8& aProperty, TDes8& aPropVal)
	{
	if(!iInitialised)
		{
		return(EFalse);
		}

	TPtrC8 iniPtr((TUint8*)iRomAddress, iRomLength);
	TIniFileReader iniReader(iniPtr);

	FOREVER
		{
		// Read the next line of the INI file
		if(iniReader.Next() == KErrEof)
			{
			break;
			}		

		if(iniReader.IsSection(aSection))
			{
			// Found the section we're interested in
			//  - look for the property, until we get to EOF or the next section
			FOREVER
				{
				if(iniReader.Next() == KErrEof)
					{
					return(EFalse);
					}
				
				if(iniReader.IsSection())
					{
					return(EFalse);
					}

				if(iniReader.IsProperty(aProperty, aPropVal))
					{
					return(ETrue);
					}
				}
			}
		}

	// No section found...
	return(EFalse);
	}

/**
@internalTechnology

Returns the requested integer F32 property value

@param aSection  The name of the F32 INI section
@param aProperty The name of the F32 propery within the section
@param aPropVal  Returns the requested property value (unchanged if the property does not exist)

@return ETrue if the property exists, EFalse otherwise
*/
EXPORT_C TBool F32Properties::GetInt(const TDesC8& aSection, const TDesC8& aProperty, TInt32& aPropVal)
	{
	if(!iInitialised)
		{
		return(EFalse);
		}

	TPtrC8 iniPtr((TUint8*)iRomAddress, iRomLength);
	TIniFileReader iniReader(iniPtr);

	FOREVER
		{
		// Read the next line of the INI file
		if(iniReader.Next() == KErrEof)
			{
			break;
			}		

		if(iniReader.IsSection(aSection))
			{
			// Found the section we're interested in
			//  - look for the property, until we get to EOF or the next section
			FOREVER
				{
				if(iniReader.Next() == KErrEof)
					{
					return(EFalse);
					}
				
				
				if(iniReader.IsSection())
					{
					return(EFalse);
					}

				if(iniReader.IsProperty(aProperty, aPropVal))
					{
					return(ETrue);
					}
				}
			}
		}

	// No section found...
	return(EFalse);
	}

/**
@internalTechnology

Returns the requested boolean F32 property value

@param aSection  The name of the F32 INI section
@param aProperty The name of the F32 propery within the section
@param aPropVal  Returns the requested property value (unchanged if the property does not exist)

@return ETrue if the property exists, EFalse otherwise
*/
EXPORT_C TBool F32Properties::GetBool(const TDesC8& aSection, const TDesC8& aProperty, TBool& aPropVal)
	{
	if(!iInitialised)
		{
		return(EFalse);
		}

	TPtrC8 iniPtr((TUint8*)iRomAddress, iRomLength);
	TIniFileReader iniReader(iniPtr);

	FOREVER
		{
		// Read the next line of the INI file
		if(iniReader.Next() == KErrEof)
			{
			break;
			}		

		if(iniReader.IsSection(aSection))
			{
			// Found the section we're interested in
			//  - look for the property, until we get to EOF or the next section
			FOREVER
				{
				if(iniReader.Next() == KErrEof)
					{
					return(EFalse);
					}
				if(iniReader.IsSection())
					{
					return(EFalse);
					}

				if(iniReader.IsProperty(aProperty, aPropVal))
					{
					return(ETrue);
					}
				}
			}
		}

	// No section found...
	return(EFalse);
	}

/**
    Obtain drive information. This function is called by the default implementation of CFileSystem::DriveInfo().
    @param  anInfo       out: drive information
    @param  aDriveNumber drive number
*/
EXPORT_C void GetDriveInfo(TDriveInfo& anInfo, TInt aDriveNumber)
    {
	if(!IsValidLocalDriveMapping(aDriveNumber))
		return;

    TLocalDriveCapsBuf localDriveCaps;

	TInt r = KErrNone;

	// is the drive local?
	if (!IsProxyDrive(aDriveNumber))
		{
		// if not valid local drive, use default values in localDriveCaps
		// if valid local drive and not locked, use TBusLocalDrive::Caps() values
		// if valid drive and locked, hard-code attributes
		r = GetLocalDrive(aDriveNumber).Caps(localDriveCaps);
		}
	else
		{
		CExtProxyDrive* pD = GetProxyDrive(aDriveNumber);
        __ASSERT_ALWAYS(pD != NULL,User::Panic(_L("GetDriveInfo - pProxyDrive == NULL"), -999));
		r = pD->Caps(localDriveCaps);
		}

    TLocalDriveCaps& caps = localDriveCaps();
	if (r != KErrLocked)
		{
		anInfo.iMediaAtt=caps.iMediaAtt;
		}
	else
		{
		anInfo.iMediaAtt = KMediaAttLocked | KMediaAttLockable | KMediaAttHasPassword;
		}

	anInfo.iType=caps.iType;
	anInfo.iDriveAtt=caps.iDriveAtt;
    anInfo.iConnectionBusType=caps.iConnectionBusType;
    }




