// 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 "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:
// DBMS Client/Server architecture
// 
//


#include "U32STD.H"
#include "D32SRV.H"
#include "D32DRVR.H"
#include <f32file.h>
#include <s32mem.h>
#include "D32VER.H"
#include "D32Map.h"
#include "Sd_DbProps.h"
#include "Sd_PolicyProxy.h"
#include "Sd_DriveSpace.h"

// other classes referenced
class HDbsColumns;
struct TDbProps;

// classes defined
class TDbsParam;
class RDbsObject;
class CDbsDatabase;
class CDbsIncremental;
class CDbsCursor;
class CDbsConstraint;
class CDbsNotifier;
class CDbsSource;
class RDbsSources;
class CDbsServer;
class CDbsSession;
class HDbsStream;

#if defined(_DEBUG)
/**
@internalComponent
*/
#define _SMALL_BUFFER
#endif

using namespace DBSC;

/**
@internalComponent
*/
enum TDbsPanic
	{
	EDbsUnimplemented,              //0
	EDbsInvalidColumn,
	EDbsWrongType,
	EDbsNoRowData,
	EDbsNotInUpdate,
	EDbsBadDescriptor,
	EDbsBadHandle,
	EDbsStreamMarkInvalid,
	EDbsStreamLocationInvalid,
	EDbsObserverRequestPending,
    EDbsInvalidDrive                //10
	};

/**
used by proxy classes
@internalComponent
*/
GLREF_C void Panic(TDbsPanic aPanic);	

/**
@internalComponent
*/
GLREF_C void ExternalizeL(const TDbCol& aCol,RWriteStream& aStream);
GLREF_C void ExternalizeL(const CDbColSet& aColSet,RWriteStream& aStream);
GLREF_C void InternalizeL(CDbColSet& aColSet,RReadStream& aStream);
GLREF_C void ExternalizeL(const CDbKey& aKey,RWriteStream& aStream);
GLREF_C void InternalizeL(CDbKey& aKey,RReadStream& aStream);
GLREF_C void ExternalizeL(const CDbNames& aNames,RWriteStream& aStream);
GLREF_C void InternalizeL(CDbNames& aNames,RReadStream& aStream);
GLREF_C void ExternalizeL(const CDbStrings& aNames,RWriteStream& aStream);
GLREF_C void InternalizeL(CDbStrings& aNames,RReadStream& aStream);

/**
@internalComponent
*/
_LIT(KDbsServerName,"!DBMS server");
_LIT(KDbsServerImg,"EDBSRV");		// DLL/EXE name
const TUid KDbsServerUid3={0x100012a5};


/**
@internalComponent
*/
const TInt KDbsExitDelay=4*0x100000;	// ~4 seconds
const TInt KDbsLeavePanic=~(1<<20);
const TInt KTablePolicyMaskBit = 1024;	//Used in RDbs::Get<Obj>Policy() methods

/**
shared classes
@internalComponent
*/
enum TDbsType {EDbsFree,EDbsDatabase,EDbsIncremental,EDbsCursor,EDbsConstraint,EDbsStream,EDbsObserver,EDbsMaxType=EDbsObserver,EDbsSession=EDbsFree};

/**
Make sure that KDbsFunc2SecurityPolicyMask array in SD_PolicyProxy.cpp gets updated if 
new enum items are going to be added to TDbsFunction.
@internalComponent
*/
enum TDbsFunction
	{
// Session functions
	EDbsResourceMark,					//0
	EDbsResourceCheck,
	EDbsResourceCount,
	EDbsSetHeapFailure,
	EDbsOpenDatabase,
// common functions
	EDbsClose,
// Database functions
	EDbsDatabaseAuthenticate,           //Not used in SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version
	EDbsDatabaseDestroy,
	EDbsDatabaseBegin,
	EDbsDatabaseCommit,
	EDbsDatabaseRollback,				//10
	EDbsDatabaseProperty,
	EDbsDatabaseCreateTable,
	EDbsDatabaseTables,
	EDbsDatabaseColumns,
	EDbsDatabaseIndexes,
	EDbsDatabaseKeys,
	EDbsDatabaseOpenObserver,
	EDbsDatabaseOpenUtility,
	EDbsDatabaseOpenDropTable,
	EDbsDatabaseOpenAlterTable,			//20
	EDbsDatabaseOpenCreateIndex,
	EDbsDatabaseOpenDropIndex,
	EDbsDatabaseExecute,
	EDbsDatabasePrepareView,
	EDbsDatabaseOpenTable,
// Observer functions
	EDbsObserverNotify,
	EDbsObserverCancel,
// Incremental functions
	EDbsIncrementalNext,
// Cursor functions
	EDbsCursorColumnTypes,
	EDbsCursorReset,					//30
	EDbsCursorEvaluate,
	EDbsCursorUnevaluated,
	EDbsCursorSetIndex,
	EDbsCursorSeek,
	EDbsCursorAtBeginning,
	EDbsCursorAtEnd,
	EDbsCursorAtRow,
	EDbsCursorCount,
	EDbsCursorGotoPos,
	EDbsCursorBookmark,					//40
	EDbsCursorGotoBookmark,
	EDbsCursorGet,
	EDbsCursorInsert,
	EDbsCursorUpdate,
	EDbsCursorRetrieveRow,
	EDbsCursorCancel,
	EDbsCursorPut,
	EDbsCursorDelete,
	EDbsCursorColumns,
	EDbsCursorColumnDef,				//50
	EDbsCursorSetNull,
	EDbsCursorColumnSize,
	EDbsCursorColumnSource,
	EDbsCursorColumnSink,
	EDbsCursorOpenConstraint,
	EDbsCursorMatch,
	EDbsCursorFind,
// stream functions
	EDbsStreamRead,
	EDbsStreamWrite,
	EDbsStreamSize,						//60
	EDbsStreamSynch,
// Session functions
	EDbsCreateDatabase,
	EDbsDatabaseList,
	EDbsCopyDatabase,
	EDbsDeleteDatabase,
	EDbsGetSecurityPolicy,
// reserved disk space handling functions
	EDbsReserveDriveSpace,
	EDbsFreeReservedSpace,
	EDbsReserveGetAccess,
	EDbsReserveReleaseAccess,			//70
//
	EDbsGetBackupPath,	
	EDbsGetBackupPaths,	
	//Insert new functuions here
	EDbsLast
	};

/**
@internalComponent
*/
const TInt KDbsTypeBits=4;
const TInt KDbsMagicBits=4;
const TInt KDbsIndexBits=14;
const TInt KDbsFunctionBits=9;
const TInt KDbsHandleBits=KDbsTypeBits+KDbsMagicBits+KDbsIndexBits;
const TInt KDbsTypeMask=(1<<KDbsTypeBits)-1;
const TInt KDbsMagicMask=(1<<KDbsMagicBits)-1;
const TInt KDbsHandleMask=(1<<KDbsHandleBits)-1;
const TInt KDbsObjectReturn=1<<(KDbsFunctionBits-1);
const TInt KDbsIndexLimit=1<<KDbsIndexBits;

/**
@internalComponent
*/
#define KDbsSessionHandle DbsSessionHandle()

/**
@internalComponent
*/
inline TInt DbsMessage(TInt aFunction,TInt aHandle);
inline TDbsFunction DbsFunction(TInt aMessage);
inline TInt DbsHandle(TInt aMessage);
inline TDbsType DbsType(TInt aHandle);
inline TInt DbsMagic(TInt aHandle);
inline TInt DbsObjectIndex(TInt aHandle);
inline TInt DbsMakeHandle(TInt aIndex,TInt aMagic,TDbsType aType);
inline TInt DbsSessionHandle();

#if !defined(_SMALL_BUFFER)
/**
@internalComponent
*/
const TInt KDbsStreamBufSize=0x600;		// 1.5K
const TInt KDbsStreamIoSize=0xc00;		// 3K
const TInt KDbsColumnTypesSize=0x200;	// .5K
#else
const TInt KDbsStreamBufSize=2;
const TInt KDbsStreamIoSize=32;
const TInt KDbsColumnTypesSize=2;
#endif

/**
@internalComponent
*/
class TDbsStreamBuf
	{
public:
	enum {ESize=KDbsStreamBufSize};
public:
	TInt iExt;
	TUint8 iData[ESize];
	};

/**
@internalComponent
*/
class TDbsColumns
	{
public:
	enum {EMax=KDbsColumnTypesSize};
public:
	TInt iCount;
	TUint8 iData[EMax];
	};

/**
client side classes
@internalComponent
*/
class TDbsParam
	{
public:
	inline void operator=(const TDesC8& aDes);
	inline void operator=(const TDesC16& aDes);
	inline void operator=(TInt aVal);
//
	static TPtrC8 PrepareLC(const CDbColSet& aColSet);
	static TPtrC8 PrepareLC(const CDbKey& aKey);
	static TPtrC8 PrepareLC(const TDbLookupKey& aKey);
	
private:
	union
		{
		const TAny* iPtr;
		TInt iInt;
		};
	};

/**
@internalComponent
*/
typedef TDbsParam TDbsMessage[4];

/**
@internalComponent
*/
class RDbsObject : private RDbs
	{
public:
	inline RDbsObject();
	inline void OpenL(const RDbsObject& aDbs,TDbsFunction aFunction);
	inline void OpenL(const RDbsObject& aDbs,TDbsFunction aFunction,const TIpcArgs& aArgs);
	inline void OpenL(const RDbs& aDbs,TDbsFunction aFunction,const TIpcArgs& aArgs);
	void Close();
//
	inline TInt Handle() const;
//
	TInt SendReceive(TDbsFunction aFunction) const;
	inline TInt SendReceive(TDbsFunction aFunction,const TIpcArgs& aArgs) const;
	TInt SendReceiveL(TDbsFunction aFunction) const;
	inline TInt SendReceiveL(TDbsFunction aFunction,const TIpcArgs& aArgs) const;
	inline void SendReceive(TDbsFunction aFunction,TRequestStatus& aStatus) const;
	inline void SendReceive(TDbsFunction aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;
private:
	inline RDbsObject(const RDbs& aDbs);
	void SendReceive(TDbsFunction aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
	TInt SendReceive(TDbsFunction aFunction,const TIpcArgs* aArgs) const;
	TInt SendReceiveL(TDbsFunction aFunction,const TIpcArgs* aArgs) const;
	void OpenL(const RDbsObject& aDbs,TDbsFunction aFunction,const TIpcArgs* aArgs);
private:
	TInt iHandle;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsDatabase) : public CDbDatabase
	{
	friend class CDbsSecureDatabase;
public:
	static CDbsDatabase* NewL(const RDbs& aDbs,const TDesC& aDatabase,const TDesC& aFormat);
	~CDbsDatabase();
//
private:
	inline CDbsDatabase();
	void ConstructL(const RDbs& aDbs,TIpcArgs& aArgs);
// from CDbDatabase
	TInt Destroy();
	TInt Begin();
	TInt Commit();
	void Rollback();
	TInt Property(TProperty aProperty);
	void CreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey);
	void TablesL(CDbTableNames& aNames);
	void ColumnsL(CDbColSet& aColSet,const TDesC& aName);
	void IndexesL(CDbIndexNames& aNames,const TDesC& aTable);
	void KeysL(CDbKey& aKey,const TDesC& aName,const TDesC& aTable);
	CDbNotifier* OpenNotifierL();
	CDbIncremental* OpenUtilityL(TUtility aType,TInt& aStep);
	CDbIncremental* OpenCompactL(TInt& aStep);
	CDbIncremental* OpenRecoverL(TInt& aStep);
	CDbIncremental* OpenDropTableL(const TDesC& aTable,TInt& aStep);
	CDbIncremental* OpenAlterTableL(const TDesC& aTable,const CDbColSet& aNewDef,TInt& aStep);
	CDbIncremental* OpenCreateIndexL(const TDesC& aName,const TDesC& aTable,const CDbKey& aKey,TInt& aStep);
	CDbIncremental* OpenDropIndexL(const TDesC& aName,const TDesC& aTable,TInt& aStep);
	CDbIncremental* OpenExecuteL(const TDesC& aSql,TDbTextComparison aComparison,TInt& aInit);
	CDbCursor* PrepareViewL(const TDbQuery& aQuery,const TDbWindow& aWindow,RDbRowSet::TAccess anAccess);
	CDbCursor* OpenTableL(const TDesC& aName,RDbRowSet::TAccess anAccess);
private:
	RDbsObject iObject;
	};

//Secure shared database
NONSHARABLE_CLASS(CDbsSecureDatabase) : public CDbsDatabase
	{
public:
	static CDbsSecureDatabase* NewL(const RDbs& aDbs,const TDesC& aDatabase,const TDesC& aFormat);
	virtual ~CDbsSecureDatabase();

private:
	inline CDbsSecureDatabase();
	void ConstructL(const RDbs& aDbs,TIpcArgs& aArgs);

	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsNotifier) : public CDbNotifier
	{
public:
	static CDbsNotifier* NewL(const RDbsObject& aDatabase);
private:
	inline CDbsNotifier();
	~CDbsNotifier();
// from CDbObserver
	void Notify(TType aEvent,TRequestStatus& aStatus);
	void Cancel();
private:
	RDbsObject iObject;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsIncremental) : public CDbAsyncIncremental
	{
public:
	static CDbsIncremental* NewL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs,TInt& aStep);
	~CDbsIncremental();
private:
	inline CDbsIncremental();
// from CDbAsyncIncremental
	void Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus);
private:
	RDbsObject iObject;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsCursor) : public CDbCursor
	{
public:
	static CDbsCursor* NewL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs);
	~CDbsCursor();
private:
	CDbsCursor();
	void ConstructL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs);
//
	TDbColType Type(TDbColNo aCol) const;
	void ReplaceBlobL(TDbColumn& aCol);
	TBool RetrieveL(TDbsFunction aFunction,TInt aArg0=0);
// from CDbCursor
	void Reset();
	TBool EvaluateL();
	void Evaluate(TRequestStatus& aStatus);
	TBool Unevaluated();
	void SetIndexL(const TDesC* anIndex);
	TBool SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison);
	TBool AtBeginning();
	TBool AtEnd();
	TBool AtRow();
	TInt CountL(RDbRowSet::TAccuracy aAccuracy);
	TBool GotoL(RDbRowSet::TPosition aPosition);
	void Bookmark(TDbBookmark::TMark& aMark);
	void GotoL(const TDbBookmark::TMark& aMark);
	void GetL();
	void InsertL(TInsert aClearRow);
	void UpdateL();
	void Cancel();
	void PutL();
	void DeleteL();
	TInt ColumnCount();
	void ColumnsL(CDbColSet& aColSet);
	void ColumnDef(TDbCol& aCol,TDbColNo aColNo);
	TDbColType ColumnType(TDbColNo aCol);
	RDbRow* RowBuffer();
	TDbColumnC ColumnC(TDbColNo aCol);	// non-writeable column
	TDbColumn Column(TDbColNo aCol);		// writeable column
	void SetNullL(TDbColNo aCol);
	TInt ColumnSize(TDbColNo aCol);
	MStreamBuf* ColumnSourceL(TDbColNo aCol);
	MStreamBuf* ColumnSinkL(TDbColNo aCol);
	CDbRowConstraint* OpenConstraintL(const TDbQuery& aCriteria);
	TBool MatchL(CDbRowConstraint& aCursor);
	TInt FindL(RDbRowSet::TDirection aDirection,const TDbQuery& aCriteria);
private:
	enum TState {EUnknown,EAtBeginning,EAtEnd,EAtRow,ERetrieve,ERead,EWrite};
private:
	RDbsObject iObject;
	TState iState;
	TBool iChangedBlob;
	HDbsColumns* iColumns;
	RDbRow iRow;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsConstraint) : public CDbRowConstraint
	{
	friend class CDbsCursor;
private:
	inline CDbsConstraint();
	~CDbsConstraint();
private:
	RDbsObject iObject;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(HDbsBuf) : public TStreamBuf
	{
public:
	static HDbsBuf* NewL(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs);
	static HDbsBuf* NewLC(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs);
	static HDbsBuf* NewLC(const RDbs& aDbSession, TDbsFunction aFunction, TIpcArgs& aArgs);
	virtual inline ~HDbsBuf();
private:
	inline HDbsBuf();
	void ConstructL(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs);
	void ConstructL(const RDbs& aDbSession, TDbsFunction aFunction, TIpcArgs& aArgs);
// from TStreamBuf
	TInt UnderflowL(TInt aMaxLength);
	void OverflowL();
	void DoRelease();
	void DoSynchL();
	TInt DoReadL(TAny* aPtr,TInt aMaxLength);
	void DoWriteL(const TAny* aPtr,TInt aLength);
	TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset);
private:
	inline void SetPos(TRead,TInt aPos);
	inline void SetPos(TWrite,TInt aPos);
	inline TInt Pos(TRead) const;
	inline TInt Pos(TWrite) const;
	inline TInt MovePos(TRead,TInt anOffset);
	inline TInt MovePos(TWrite,TInt anOffset);
	TInt IpcReadL(TAny* aPtr,TInt aMaxLength);
	void IpcWriteL(const TAny* aPtr,TInt aLength);
	TInt EndL();
//
	inline TInt Lag(TRead) const;
	inline TInt Lag(TWrite) const;
	inline TInt Mark(TRead) const;
	inline TInt Mark(TWrite) const;
private:
	RDbsObject iIpc;
	TInt iRPos;
	TInt iWPos;
	TDbsStreamBuf iBuf;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(HDbsReadBuf) : public TMemBuf
	{
public:
	static HDbsReadBuf* NewL(const TDesC8& aDes);
protected:
	inline HDbsReadBuf(const TDesC8& aDes);
	void DoRelease();
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsObserver) : public CActive
	{
public:
	/**
	@internalComponent
	*/
	class HObserver
		{
		friend class CDbsObserver;
	public:
		~HObserver();
		void Notify(const RMessage2& aMessage);		
		void Cancel();
	private:
		inline HObserver();
		void Complete(TInt aStatus);
		void Event(TInt aEvent);
	private:
		TDblQueLink iLink;
		TInt iPending;
		RMessagePtr2 iMessage;
		};
	friend class HObserver;
public:
	static CDbsObserver* NewL(CDbsSource& aSource);
	static CDbsObserver* Collect(CDbsObserver* aNotifier);
	HObserver* ObserverL();
private:
	inline CDbsObserver(CDbsSource& aSource);
	~CDbsObserver();
//
	void Queue();
// from CActive
	void RunL();
	void DoCancel();
private:
	CDbsSource& iSource;
	CDbNotifier* iNotifier;
	TDblQue<HObserver> iQueue;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsConnection) : public CDbContext
	{
	friend class RDbsSources;
public:
	inline CDbsSource& Source() const;
	static inline const CDbsConnection& Connection(const CDbObject& aObject);
	static inline CDbsSource& Source(const CDbObject& aObject);
private:
	inline CDbsConnection() {}
	~CDbsConnection();
	inline void Set(CDbsSource& aSource);
private:
	CDbsSource* iSource;
	};

/**
@internalComponent
*/
class CDbsDatabaseStub : public CDbObject
	{
public:
	static CDbsDatabaseStub* NewL();
	CDbDatabase* AuthenticateL();
private:
	inline CDbsDatabaseStub();
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsSource) : public CBase
	{
	friend class CDbsConnection;
	friend class CDbsObserver;
public:
	static CDbsSource* NewL(RFs& aFs,const TDesC& aSource);
//
	static inline TInt LinkOffset();
	TBool Is(const TDesC& aSource) const;
//
	inline CDbSource& Source();
	CDbsObserver::HObserver* ObserverL();
private:
	inline CDbsSource(const TDbFormat& aFormat);
	~CDbsSource();
	void Closed();
//
	inline void Open();
	void Close();
private:
	TDblQueLink iLink;
	HBufC* iName;
	const TDbFormat& iFormat;
	TInt iConnections;
	CDbSource* iSource;
	CDbsObserver* iObserver;
	};

/**
@internalComponent
*/
class RDbsSources
	{
private:
	typedef TDblQueIter<CDbsSource> TIter;
public:
	inline RDbsSources(RDbCache& aCache);
	inline void Close();
//
	CDbsConnection* OpenLC(RFs& aFs,const TDesC& aSource,const TDesC& aFormat);
private:
	TDblQue<CDbsSource> iSources;
	RDbCache iDrivers;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsServer) : public CServer2
	{
public:
	static CDbsServer* NewL();
//
	inline TDes& Name0();
	inline TDes& Name1();
	inline TDes& FileName();
	inline RDbsSources& Sources();
	inline RFs& Fs();
	inline RDriveSpaceCol& DriveSpaceCol();
	void RemoveSession();
//
	static CDbsServer* Instance();
	void Panic(const TDesC& aCategory,TInt aCode);	// .. panic client!

	inline CPolicyProxy& PolicyProxy() const;
	inline RDbPropsFactory& DbPropsFactory();

private:
	inline CDbsServer();
	~CDbsServer();
	void ConstructL();
// from CServer
	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;
private:
	enum {ECacheSize=8};
	enum {EServerPriority=0};
private:
	RDbCache iCache;
	RDbsSources iSources;
	TDbName iName0;		// used for message servicing
	TDbName iName1;
	TFileName iFileName;
	RFs iFs;
	CPolicyProxy* iPolicyProxy;
	RDbPropsFactory iDbPropsFactory;
	RDriveSpaceCol iDriveSpaceCol;
};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CDbsSession) : public CSession2
	{
private:
#if !defined(_SMALL_BUFFER)
	enum {EIndexGranularity=8};
#else
	enum {EIndexGranularity=1};
#endif
	struct TEntry
		{
		union
			{
			TAny* iObject;
			TInt iNext;
			};
		TUint8 iType;
		const MPolicy* iPolicy;
		TUint8 iMagic;
	public:
		void Release();
		DECLARE_DB_DUMP3(aFile)
	//
		inline TDbsType Type() const;
		inline CDbsDatabaseStub& DatabaseStub();
		inline CDbDatabase& Database();
		inline CDbIncremental& Incremental();
		inline CDbCursor& Cursor();
		inline CDbRowConstraint& Constraint();
		inline HDbsStream& Stream();
		inline CDbsObserver::HObserver& Observer();
		};
public:
	CDbsSession();
	virtual ~CDbsSession();
private:
//From CSession2
	virtual void CreateL();
// from CSession
	void ServiceL(const RMessage2& aMessage);	
	TInt ExtServiceL(const RMessage2& aMessage, TDbsFunction aDbsFunction);
	void ServiceError(const RMessage2& aMessage,TInt aError);
	TInt CountResources();
//
	inline CDbsServer& Server() const;
	inline RDbsSources& Sources();
//
	const TDesC& ReadName0L(TInt aIndex,const RMessage2& aMessage);
	const TDesC& ReadName1L(TInt aIndex,const RMessage2& aMessage);
	const TDesC& ReadFileNameL(TInt aIndex, const RMessage2& aMessage);
	HBufC* ReadHBufLC(TInt aIndex,const RMessage2& aMessage);
	HBufC8* ReadHBuf8LC(TInt aIndex,const RMessage2& aMessage);
	CDbColSet* ColSetLC(TInt aIndex,const RMessage2& aMessage);
	CDbKey* KeyLC(TInt aIndex,const RMessage2& aMessage);
	TDbLookupKey* LookupKeyLC(TInt aIndex,TInt aSize,const RMessage2& aMessage);
	CDbObject* DoAuthenticateL(CDbsConnection* aDbsConnection, const RMessage2& aMessage);
	TInt DoOpenDatabaseL(const RMessage2& aMessage, const TDbProps& aDbProps);

	TDbProps* ExtractDbPropsLC(const RMessage2& aMessage);
	TInt OpenDatabaseL(const RMessage2& aMessage);	
	TInt CreateDatabaseL(const RMessage2& aMessage);
	TInt DoCreateDatabaseL(const RMessage2& aMessage, const TDbProps& aDbProps);
	void CopyDatabaseL(const RMessage2& aMessage);
	void DeleteDatabaseL(const RMessage2& aMessage);
	TInt GetDatabaseListL(const RMessage2& aMessage);	
	void GetSecurityPolicyL(const RMessage2& aMessage);	
	void ReadRowL(RDbRow& aRow,TInt aSize,const RMessage2& aMessage);
	void PutRowL(CDbCursor& aCursor,const RMessage2& aMessage);
	TInt WriteRowL(const RDbRow& aRow,const RMessage2& aMessage);
	TInt RetrieveRowL(CDbCursor& aCursor,const RMessage2& aMessage);
	TInt NewCursorL(CDbCursor* aCursor,const RMessage2& aMessage,const MPolicy* aTblSecurityPolicy);
	TInt NewIncrementalL(CDbIncremental* aCursor,TInt& aInit,const RMessage2& aMessage,const MPolicy* aPolicy);
	TInt NewStreamL(MStreamBuf* aHost,const RMessage2& aMessage,const MPolicy* aPolicy,TInt aExtent=-1);
	TInt NewStreamL(TAny* aPtr,TExternalizeFunction aExter,const RMessage2& aMessage,const MPolicy* aPolicy);
	void NewDbEntryL(CDbObject* aDbObject, const TDbPolicyRequest& aDbPolicyRequest, TInt& aDbHandle);
	
#ifdef __DBDUMP__
	void Dump();
#endif	

	void ReserveDriveSpaceL(TDriveNumber aDrive);
	void FreeReservedSpace(TDriveNumber aDrive);
	void GetReserveAccessL(TDriveNumber aDrive);
	void ReleaseReserveAccess(TDriveNumber aDrive);
	
	void GetBackupPathL(const RMessage2& aMessage);
	TInt GetBackupPathsL(const RMessage2& aMessage);

	inline TInt Add(CDbIncremental* aIncremental, const MPolicy* aPolicy);
	inline TInt Add(CDbCursor* aCursor, const MPolicy* aPolicy);
	inline TInt Add(CDbRowConstraint* aConstraint, const MPolicy* aPolicy);
	inline TInt Add(HDbsStream* aStream, const MPolicy* aPolicy);
	inline TInt Add(CDbsObserver::HObserver* aObserver, const MPolicy* aPolicy);

	TEntry& Object(TInt aHandle);
	void AllocL();
	TInt DoAdd(TAny* aObject,TDbsType aType, const MPolicy* aPolicy);
	void Free(TEntry& aEntry);

private:
	TEntry* iIx;
	TInt iSize;
	TInt iFree;
	RMap<TInt, TDbPolicyRequest> iDbPolicyRqColl;
    CDbsSessDriveSpace* iSessDriveSpace;
	};

/**
@internalComponent
*/
class HDbsStream
	{
public:
	inline HDbsStream(MStreamBuf* aHost,TInt aReadPos);
	inline ~HDbsStream();
//
	TInt ReadL(const RMessage2& aMessage);	
	void WriteL(const RMessage2& aMessage);	
	inline TInt SizeL();
	inline void SynchL();
private:
	MStreamBuf& iHost;
	TInt iRPos;
	TInt iWPos;
	};

/**
@internalComponent
*/
NONSHARABLE_CLASS(HBufBuf) : public TBufBuf
	{
	enum {EGranularity=512};
public:
	static HBufBuf* NewLC();
private:
	inline HBufBuf();
	virtual inline ~HBufBuf();
	void DoRelease();
private:
	CBufBase* iBuf;
	};

#include "SD_STD.INL"