// 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_std.h

// 

//

#ifndef SF_STD_H

#define SF_STD_H

#include "common.h"

#include "message.h"

#include <f32fsys.h>

#include <f32ver.h>

#include <f32dbg.h>

#include <e32svr.h>

#include <e32hal.h>

#include <e32uid.h>

#include <e32std_private.h>

#include <e32def_private.h>

#include <e32const_private.h>

#include "sf_plugin.h"

#include "sf_func.h"

#include "f32trace.h"

#include <utraceefile.h>

#define __PRINT1TEMP_ALWAYS(t,a) {{TBuf<KMaxFileName>temp(a);RDebug::Print(t,&temp);}}

#define __PRINT2TEMP_ALWAYS(t,a,b) {{TBuf<KMaxFileName>temp(b);RDebug::Print(t,a,&temp);}}

#define __PRINT3TEMP_ALWAYS(t,a,b,c) {{TBuf<KMaxFileName>temp(c);RDebug::Print(t,a,b,&temp);}}

#define __PRINT4TEMP_ALWAYS(t,a,b,c,d) {{TBuf<KMaxFileName>temp(d);RDebug::Print(t,a,b,c,&temp);}}

#define _THRD_BUF() (_L("thread id 0x"));buf.AppendNum(RThread().Id(),EHex);buf.Append(_L(" "))

#define __THRD_PRINT_ALWAYS(t) {{TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf);}}

#define __THRD_PRINT1_ALWAYS(t,a) {{TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a);}}

#define __THRD_PRINT2_ALWAYS(t,a,b) {{TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b);}}

#define __THRD_PRINT3_ALWAYS(t,a,b,c) {{TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b,c);}}

#define __THRD_PRINT4_ALWAYS(t,a,b,c,d) {{TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b,c,d);}}

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

#define __PRINT(t) {if (DebugReg&KFSERV) RDebug::Print(t);}

#define __PRINT1(t,a) {if (DebugReg&KFSERV) RDebug::Print(t,a);}

#define __PRINT2(t,a,b) {if (DebugReg&KFSERV) RDebug::Print(t,a,b);}

#define __PRINT3(t,a,b,c) {if (DebugReg&KFSERV) RDebug::Print(t,a,b,c);}

#define __PRINT4(t,a,b,c,d) {if (DebugReg&KFSERV) RDebug::Print(t,a,b,c,d);}

#define __IF_DEBUG(t) {if (DebugReg&KFLDR) RDebug::t;}

#define __LDRTRACE(t) {if (DebugReg&KFLDR) t;}

#define __PRINTALLOC(t,a,b,c) {if (DebugReg&KALLOC) RDebug::Print(t,a,b,c);}

#define __PRINT1TEMP(t,a) {if (DebugReg&KFSERV) {TBuf<KMaxFileName>temp(a);RDebug::Print(t,&temp);}}

#define __PRINT2TEMP(t,a,b) {if (DebugReg&KFSERV) {TBuf<KMaxFileName>temp(b);RDebug::Print(t,a,&temp);}}

#define __PRINT3TEMP(t,a,b,c) {if (DebugReg&KFSERV) {TBuf<KMaxFileName>temp(c);RDebug::Print(t,a,b,&temp);}}

#define __PRINT4TEMP(t,a,b,c,d) {if (DebugReg&KFSERV) {TBuf<KMaxFileName>temp(d);RDebug::Print(t,a,b,c,&temp);}}

#define __CALL(t) {t;}

#define __THRD_PRINT(t) {if (DebugReg&KTHRD) {TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf);}}

#define __THRD_PRINT1(t,a) {if (DebugReg&KTHRD) {TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a);}}

#define __THRD_PRINT2(t,a,b) {if (DebugReg&KTHRD) {TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b);}}

#define __THRD_PRINT3(t,a,b,c) {if (DebugReg&KTHRD) {TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b,c);}}

#define __THRD_PRINT4(t,a,b,c,d) {if (DebugReg&KTHRD) {TBuf<KMaxFileName> buf=_THRD_BUF();buf.Append(t);RDebug::Print(buf,a,b,c,d);}}

#define __CACHE_PRINT(t) {if (DebugReg&KCACHE) RDebug::Print(t);}

#define __CACHE_PRINT1(t,a) {if (DebugReg&KCACHE) RDebug::Print(t,a);}

#define __CACHE_PRINT2(t,a,b) {if (DebugReg&KCACHE) RDebug::Print(t,a,b);}

#define __CACHE_PRINT3(t,a,b,c) {if (DebugReg&KCACHE) RDebug::Print(t,a,b,c);}

#define __CACHE_PRINT4(t,a,b,c,d) {if (DebugReg&KCACHE) RDebug::Print(t,a,b,c,d);}

#define __CACHE_PRINT5(t,a,b,c,d,e) {if (DebugReg&KCACHE) RDebug::Print(t,a,b,c,d,e);}

#define __CACHE_PRINT6(t,a,b,c,d,e,f) {if (DebugReg&KCACHE) RDebug::Print(t,a,b,c,d,e,f);}

#define __CACHE_PRINT7(t,a,b,c,d,e,f,g) {if (DebugReg&KCACHE) RDebug::Print(t,a,b,c,d,e,f,g);}

#define __PLUGIN_PRINT(t) {if (DebugReg&KPLUGIN) RDebug::Print(t);}

#define __PLUGIN_PRINT1(t,a) {if (DebugReg&KPLUGIN) RDebug::Print(t,a);}

#define __PLUGIN_PRINT2(t,a,b) {if (DebugReg&KPLUGIN) RDebug::Print(t,a,b);}

#define __PLUGIN_PRINT3(t,a,b,c) {if (DebugReg&KPLUGIN) RDebug::Print(t,a,b,c);}

#else

#define __PRINT(t)

#define __PRINT1(t,a)

#define __PRINT2(t,a,b)

#define __PRINT3(t,a,b,c)

#define __PRINT4(t,a,b,c,d)

#define __IF_DEBUG(t)

#define __LDRTRACE(t)

#define __PRINTALLOC(t,a,b,c) {if (DebugReg&KALLOC) RDebug::Print(t,a,b,c);}

#define __PRINT1TEMP(t,a)

#define __PRINT2TEMP(t,a,b)

#define __PRINT3TEMP(t,a,b,c)

#define __PRINT4TEMP(t,a,b,c,d)

#define __CALL(t)

#define __THRD_PRINT(t)

#define __THRD_PRINT1(t,a)

#define __THRD_PRINT2(t,a,b)

#define __THRD_PRINT3(t,a,b,c)

#define __THRD_PRINT4(t,a,b,c,d)

#define __CACHE_PRINT(t)

#define __CACHE_PRINT1(t,a)

#define __CACHE_PRINT2(t,a,b)

#define __CACHE_PRINT3(t,a,b,c)

#define __CACHE_PRINT4(t,a,b,c,d)

#define __CACHE_PRINT5(t,a,b,c,d,e)

#define __CACHE_PRINT6(t,a,b,c,d,e,f)

#define __CACHE_PRINT7(t,a,b,c,d,e,f,g)

#define __PLUGIN_PRINT(t)

#define __PLUGIN_PRINT1(t,a)

#define __PLUGIN_PRINT2(t,a,b)

#define __PLUGIN_PRINT3(t,a,b,c)

#endif

const TInt KMaxTotalDriveReserved	=0x100000;

const TInt KMaxSessionDriveReserved	=0x10000;

// If TFsFileDuplciate::DoRequestL() is called a new sub-session is created and 

// the new sub-session handle is returned, mangled by KSubSessionMangleBit - 

// this is to discourage use of the duplicated handle.

// If TFsFileAdopt::DoRequestL() is called then the passed sub-session handle is 

// assumed to be already mangled by KSubSessionMangleBit and the same sub-session 

// handle is returned de-mangled.

const TInt KSubSessionMangleBit = 0x4000;

#define __CHECK_DRIVETHREAD(d) {__ASSERT_DEBUG(FsThreadManager::IsDriveThread(d,ETrue),Fault(EFsDriveThreadError));}

#define __CHECK_MAINTHREAD() {__ASSERT_DEBUG(FsThreadManager::IsMainThread(),Fault(EFsMainThreadError));}

#define __LAZY_DLL_UNLOAD

const TInt KMaxTempNameAttempts=50;

const TInt KHeapMinSize=0x1000;

const TInt KHeapMaxSize=0x400000;

const TInt KLoaderStackSize=0x8000;

//-- maximum file size that was supported before introducing File Server 64-bit addressing support.

//-- It is 2G-1. Used in legacy code that does not understand RFile64

const TUint64 KMaxLegacyFileSize    = 0x7fffffff;

//-- absolute maximum file size that file server supports

const TUint64 KMaxSupportedFileSize = KMaxTUint64;

//-- this is a speculative value of a min. amount of free space on the volume necessary to create a file, directory etc.

//-- it is used mostly in "reserve drive space" functionality, which is, actually, fundamentally flawed.

//-- the problem is that the file server can't know exactly how much space is required to create some fs object on the volume, 

//-- so, it has to guess. This is a default "sector size" value; the file system can round it up internally to its cluster size if any.

const TInt KMinFsCreateObjTreshold = KDefaultVolumeBlockSize;

//__DATA_CAGING__

const TUint SHA1_LBLOCK=16;

const TUint SHA1_HASH=20;

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

class TCorruptNameRec;

class TCorruptLogRec

	{

public:

	TCorruptLogRec();

	~TCorruptLogRec();

	TInt Construct(TCorruptNameRec* aNameRec, TPtrC* aProcessName, TCorruptLogRec* aChain);

	inline TPtrC ProcessName(){return iProcessName->Des();};

	static TInt GetLogRecord(TFsDebugCorruptLogRecordBuf& aLogRecord,TInt aLogRecNum);

	static void DestroyList();

private:

	HBufC* iProcessName;

	TCorruptNameRec* iNameRec;

	TCorruptLogRec* iNext;

	};

TInt OutputTraceInfo(TCorruptNameRec* aNameRec, CFsRequest* aRequest);

class TText8FileReader

	{

	enum {EMaxLine=1024};

public:

	TText8FileReader();

	~TText8FileReader();

	TInt Set(RFile& aFile);

	TInt Read(TPtr& aPtr);	

public:

	RFile iFile;

	TBuf8<EMaxLine> iBuf;

	TInt iBufPos;

	TText* iFileDataBuf;

	TInt iFileSize;	

	};	

class TCorruptNameRec

	{

public:

	TCorruptNameRec();

	TInt Construct(TPtr* aName,TInt aReturnCode, TBool aUseOnce, TCorruptNameRec* aChain);

	static void ResetListConsumed();

	inline TPtrC Name(){return iName->Des();};

	inline TInt ReturnCode(){return iReturnCode;};

	inline TBool Consumed(){return iConsumed;};

	inline void SetConsumed(){iConsumed=iUseOnce;};

	inline TCorruptNameRec* Next(){return iNext;};

private:

	HBufC*	iName;

	TInt	iReturnCode;

	TBool	iUseOnce;

	TBool	iConsumed;

	TCorruptNameRec* iNext;

	};

#endif

//

//

_LIT(KFsClient,"FSCLIENT");

NONSHARABLE_CLASS(CSHA1) : public CBase

	{

public:

	static CSHA1* NewL(void);

	void Update(const TDesC8& aMessage);

	TPtrC8 Final(void);

	~CSHA1(void);

	void Reset(void);

private:

	CSHA1(void);

	TUint iA;

	TUint iB;

	TUint iC;

	TUint iD;

	TUint iE;

	TBuf8<SHA1_HASH> iHash;

	TUint iNl;

	TUint iNh;

	TUint iData[SHA1_LBLOCK*5];

	void DoUpdate(const TUint8* aData,TUint aLength);

	void DoFinal(void);

	void Block();

	void ConstructL(void);

	TUint8* iTempData;

	};

enum TFsPanic

	{

	ELdrImportedOrdinalDoesNotExist,

	ELdrHeapCorruptionOnRemove

	};

//

enum TFsFault

	{

	EDrvIllegalShareValue,			//0

	EMainCreateScheduler,

	EMainCreateServer,

	EMainStartServer,

	EMainCreateResources1,

	EMainGetLocalFileSystem,

	EMainGetLocalDefaultPath,

	EInitConnectLocalDrive,

	EMainCreateStartupThread1,

	EInitDriveMappingDriveInfo,

	EInitCreateDriveName,			//10

	EMainStartupNoEStart,

	ESesPathBadDrive,

	EFileDuplicateLock,

	ESysDefaultPathNotSupported,

	ESysAddLocalFileSystem,

	ESvrBadSessionIndex,

	EGetLocalDrive1,

	EGetLocalDrive2,

	ELdrRestartInit,

	ELdrRestartSemaphore,			//20

	EStripBackSlashBadName,

	EIsSubDirBadDes,

	ERawDiskBadAccessCount2,

	ERawDiskBadAccessCount1,

	ERawDiskBadAccessCount,

	EDriveNoDiskMounted,

	ESvrNotifierIsNULL,

	EMainCreateResources5,

	EMainCreateStartupThread2,

	EMainCreateStartupThread3,		//30

	EMainCreateStartupThread4,

	EMainStartupWriteToDiskSemaphore,	

	EMainCreateResources6,

	EMainScanMediaDriversMem1,

	EMainScanMediaDriversLocation,

	EMainScanMediaDriversMem2,

	EMainScanMediaDriverConnect,

	EMainScanMediaDriverDirOpen,

	EMainScanMediaDriverDirRead,

	EMainLoadMediaDriver,			//40

	EInitCreateMediaChangeNotifier,

	ELdrCleanupCreate,

	ELdrSchedulerCreate,

	ELdrServerCreate,

	ELdrFsConnect,

	ELdrFsSetPath,

	ELdrCacheInit,

	ELdrSchedulerStopped,

	ESvrFormatOpenFailed,

	ESvrRawDiskOpenFailed,			//50

	EProxyDriveConstruction,

	ELocDrvInitLocalDrive,

	ELocDrvDismountedLocalDrive,

	EBaseExtConstruction,

	ECreateProxyDriveL,

	EExtensionInfoCount0,

	EExtensionInfoCount1,

	EExtensionInfoCount2,

	EStdChangeRequestType,

	EExtChangeNameLength,			//60

	EDiskSpaceThreshold,

	EDebugChangeType,

	EBaseQueConstruction,

	EChangeQueType,

	EDiskSpaceQueType1,

	EDiskSpaceQueType2,

	EBaseQueCancel,

	EDebugQueType,

	EBaseRequestSrc,

	EBaseRequestDest,			//70

	EBaseRequestDrive,

	EBaseRequestSubstedDrive,

	EBaseRequestSetDrive,

	EBaseRequestSetSubstedDrive,

	EBaseRequestMessage,

	EBaseRequestSet1,

	EBaseRequestSet2,

	EDiskSpaceQueDrive,

	ENotifyInfoDestructor,

	EChangeBadIndex,			//80

	EBadDiskNotifyType,

	EBadDebugNotifyType,

	EDiskChangeDrive,

	EBadChangeNotifyType,

	EDiskBadIndex1,

	EDiskBadIndex2,

	EDiskBadIndex3,

	ESvrFreeDiskSpace,

	EFsThreadBadDrvNum,

	EFsThreadConstructor,			//90

	EFsThreadDriveClose1,

	EFsThreadDriveClose2,

	EFsThreadGetThread,

	EMainInitialiseRomFs,

	EFsDriveThreadError,

	EFsMainThreadError,

	ETFsSetSubstNotNull,

	EMountFileSystemFSys,

	EDisMountFileSystemFSys,

	EIsValidDriveMapping,			//100

	EInitDriveMappingSocketNo,

	ECompleteNotifSocketNo,

	EObjRemoveContainerNotFound,

	EObjDestructorAccessCount,

	EObjDestructorContainer,

	EObjRemoveBadHandle,

	EArrayIndexOutOfRange,

	EObjFindBadHandle,

	EObjRemoveObjectNotFound,

	EObjFindIndexOutOfRange,			//110

	ESubOpenBadHandle,

	EMainDisconnectThread,

	EInternalRequestProcess,

	EInternalRequestComplete1,

	EInternalRequestComplete2,

	EInternalRequestComplete3,

	ERequestThreadDestructor,

	EThreadManagerInitDrive,

	EDriveCurrentWriteFunction,

	EDriveGetNotifyUser,				//120

	EDriveThreadWriteable,

	EDriveThreadNotifyUser1,

	EDriveThreadNotifyUser2,

	ERequestDestructorFree,

	ESessionDisconnectThread1,

	ESessionDisconnectThread2,

	EDismountFsDriveThread,

	EDisconnectRequestDispatch1,

	EDisconnectRequestDispatch2,

	EDisonncectRequestProcess,			//130

	EDispatchObjectDispatch,

	EDispatchObjectThread,

	EInternalRequestDispatch1,

	EInternalRequestDispatch2,

	EInternalRequestDispatch3,

	EFsObjectIxDestructor,

	EDisconnectRequestComplete,

	EMountExtensionFSys,

	EObjectConDestructor,

	EParseSubstSession,					//140

	ELdrGetKernelInfoFailed,

	EObjectIxMainThread,

	ESwapFileSystemNull,

	ESwapFileSystemMount,

	ESwapFileSystemRom,

	EReserveSpaceArithmetic,

	ECloseSubBadMessage,

	EFsCacheLockFailure,

	EFsPluginThreadError,				

	EBadDismountNotifyType,				//150

	ENotifyDismount,

	EAllowDismount,

	ENotifyDismountCancel,

	EFileDuplicateAsyncReadRequest,

	EFileFailedToServiceAsyncReadRequest,

	ELdrCsIdWrap,

	EFileShareBadPromoteCount,

	EInternalRequestDispatchCancelPlugin,

	EMainCreateStartupThread0,

	ERequestAllocatorOpenSubFailed,		//160

	ETParsePoolGet,

	EInvalidDrive,

	ELocDrvInvalidLocalDrive,

	ELdrReaperCreate,

	ELdrReaperCleanupTimerCreate,

	EFsParsePoolLockFailure,

	ELdrReaperCantGetDriveList,

	EFileCacheCreateFailed,

	EBadOperationIndex,

	EBadOperationCompletionCode,		//170

	EReadOffsetNonZero,

	ETooManyOperations,

	EInvalidOperationIndex,

	EInvalidReadLength,

	EInvalidWriteLength,

	ERequestThreadNotInitialised,

	EMemoryInfoFailed,

	EMsgRestartBadFunction,

	EPushOpNoCallback,

	EFreeingMsgWithMsgOp,				//180

	ENotUnused,

	ELdrFileDataAllocInit,

	ELdrFileDataAllocError,

	EDismountLocked,

	EInvalidMsgState,

	EGetProxyDriveMapping1,

	EGetProxyDriveMapping2,

	EExtProxyDriveCaps,

	EIsProxyDrive,

	EClearProxyDriveMapping1,			//190

	EClearProxyDriveMapping2,

	ERequestQueueNotEmpty,

	ESetupMediaChange,

	ECancelNotifyChange,

	EPluginOpError,

	EBadMessageSlotIndex,

	EInvalidCompletionFlags,

	ECacheMemoryManagerCreateFailed,

	EFileBodyIsNull,

	ETraceLddLoadFailure,				//200

	ETooManyDrivesPerSocket,

	ENotificationFault,

	EFsObjectOpen

	};

NONSHARABLE_CLASS(CFsObjectConIx) : public CBase

	{

public:

	static CFsObjectConIx* NewL();

	~CFsObjectConIx();

	CFsObjectCon* CreateL();

	void Remove(CFsObjectCon* aCon);

protected:

	CFsObjectConIx();

	void CreateContainerL(CFsObjectCon*& anObject);

private:

	TInt iCount;

	TInt iAllocated;

	TInt iNextUniqueID;

	CFsObjectCon** iContainers;

	};

struct SFsObjectIxRec

	{

	TInt16 instance;

	TInt16 uniqueID;

	CFsObject* obj;

	};

NONSHARABLE_CLASS(CFsObjectIx) : public CBase

	{

public:

	static CFsObjectIx* NewL();

	~CFsObjectIx();

	TInt AddL(CFsObject* anObj,TBool aLock);

	void Remove(TInt aHandle,TBool aLock);

	CFsObject* At(TInt aHandle,TInt aUniqueID,TBool aLock);	

	CFsObject* At(TInt aHandle,TBool aLock);

	TInt At(const CFsObject* anObj,TBool aLock);

	CFsObject* operator[](TInt anIndex);

	void CloseMainThreadObjects();

	inline TInt Count() const;

	inline TInt ActiveCount() const;

	inline void Lock();

	inline void Unlock();

protected:

	CFsObjectIx();

private:

	TInt iNumEntries;		// number of actual entries in the index

	TInt iHighWaterMark;	// 1+highest active index

	TInt iAllocated;		// max entries before realloc needed

	TInt iNextInstance;

	SFsObjectIxRec *iObjects;

	RFastLock iLock;

	};

NONSHARABLE_CLASS(CFsObjectCon) : public CBase

	{

protected:

	enum {ENotOwnerID};

public:

	static CFsObjectCon* NewL();

	~CFsObjectCon();

	void AddL(CFsObject* anObj,TBool aLock);

	void Remove(CFsObject* anObj,TBool aLock);

	CFsObject* operator[](TInt anIndex);

	CFsObject* At(TInt aFindHandle) const;

	CFsObject* AtL(TInt aFindHandle) const;	

	TInt FindByName(TInt& aFindHandle,const TDesC& aMatch) const;

	inline void Lock();

	inline void Unlock();

	inline TInt UniqueID() const;