// 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;