--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/sdbms/SD_STD.H	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,860 @@
+// 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"
+
+
+