// Copyright (c) 2002-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:

// \e32\kernel\sproperty.cpp

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#define __PS_ASSERT(aCond) \

	__ASSERT_DEBUG( (aCond), ( \

						Kern::Printf("Assertion '" #aCond "' failed;\nFile: '" \

						__FILE__ "' Line: %d\n", __LINE__), \

						Kern::Fault("Pub&Sub", 0)) )

inline DProcess* CurProcess()

	{

	return TheCurrentThread->iOwningProcess;

	}

class TProperty 

	{

public:

	static TInt Init();

	static TInt Attach(TUint aCategory, TUint aKey, TProperty** aProp);

	static TInt Open(TUint aCategory, TUint aKey, TProperty** aProp);

	void Close();

	TInt Define(const TPropertyInfo*, DProcess*);

	TInt Delete(DProcess*);

	TInt Subscribe(TPropertySubsRequest* aSubs, DProcess*);

	void Cancel(TPropertySubsRequest* aSubs);

	TInt GetI(TInt* aValue, DProcess*);

	TInt GetB(TUint8* aBuf, TInt* aSize, DProcess*, TBool aUser); 

	TInt SetI(TInt aValue, DProcess*);

	TInt SetB(const TUint8*, TInt aSize, DProcess*, TBool aUser);

	static TInt FindGetI(TUint aCategory, TUint aKey, TInt* aValue, DProcess*);

	static TInt FindSetI(TUint aCategory, TUint aKey, TInt aValue, DProcess*);

	// Called with system or feature locked

	TBool IsDefined()

		{

		return iType != RProperty::ETypeLimit;

		}

	// Called with system or feature locked

	RProperty::TType Type()

		{

		return (RProperty::TType) iType;

		}

	// Called with system or feature locked

	TInt BufSize()

		{

		__PS_ASSERT(iType == RProperty::EByteArray || iType == RProperty::ELargeByteArray);

		return iBuf ? iBuf->iBufSize : 0;

		}

	// The property attributes.

	// Meaningful for defined properties only (ie. iType != RProperty::ETypeLimit)

	// Constant while the property is defined

	TUint32	Owner()

		{ return iOwner; }

	/// Ensure pages in the source buffer are paged in and lock them

	static TInt LockSourcePages(const TUint8* aBuf, TInt aSize);

	/// Unlock source pages again

	static void UnlockSourcePages();

#ifdef _DEBUG

	static TBool IsLocked()

		// used in assertions only

		{ return FeatureLock->iCleanup.iThread == TheCurrentThread; }

#endif

public:

	const TUint		iCategory;

	const TUint		iKey;

private:

	// Acquire the feature lock

	// Called in CS

	static void Lock()

		{

		Kern::MutexWait(*FeatureLock);

		}

	// Release the feature lock

	// Called in CS

	static void Unlock()

		{

		Kern::MutexSignal(*FeatureLock);

		}

	static void CompleteRequest(TPropertySubsRequest*, TInt aReason);	

	static void CompleteQue(SDblQue* aQue, TInt aReason);	

	static void CompleteDfc(TAny* aQue);

	static TUint Hash(TUint aCategory, TUint aKey);

	static TProperty** Lookup(TUint aCategory, TUint aKey);

	static TInt LookupOrCreate(TUint aCategory, TUint aKey, TProperty**);

	TAny* operator new(TUint aSize) __NO_THROW

		{ return Kern::AllocZ(aSize); }

	TProperty(TUint aCategory, TUint aKey);

	void SetNotDefined()

		{ iType = RProperty::ETypeLimit; }

	inline void Use();

	void Release();

	void CompleteByDfc();

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	TBool DoCheckDeleteRights(DProcess* aProcess, const char* aDiagnostic);

	TBool DoCheckDefineRights(DProcess* aProcess, const char* aDiagnostic);

	TBool DoCheckGetRights(DProcess* aProcess, const char* aDiagnostic);

	TBool DoCheckSetRights(DProcess* aProcess, const char* aDiagnostic);

#endif //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	TBool DoCheckDeleteRights(DProcess* aProcess);

	TBool DoCheckDefineRights(DProcess* aProcess);

	TBool DoCheckGetRights(DProcess* aProcess);

	TBool DoCheckSetRights(DProcess* aProcess);

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	inline TBool CheckDeleteRights(DProcess* aProcess, const char* aDiagnostic=0)

		{

		return DoCheckDeleteRights(aProcess, aDiagnostic);

		}

	inline TBool CheckDefineRights(DProcess* aProcess, const char* aDiagnostic=0)

		{

		return DoCheckDefineRights(aProcess, aDiagnostic);

		}

	inline TBool CheckGetRights(DProcess* aProcess, const char* aDiagnostic=0)

		{

		return DoCheckGetRights(aProcess, aDiagnostic);

		}

	inline TBool CheckSetRights(DProcess* aProcess, const char* aDiagnostic=0)

		{

		return DoCheckSetRights(aProcess, aDiagnostic);

		}

#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	// Only available to NULL arguments

	inline TBool CheckDeleteRights(DProcess* aProcess, OnlyCreateWithNull /*aDiagnostic*/=NULL)

		{

		return DoCheckDeleteRights(aProcess);

		}

	inline TBool CheckDefineRights(DProcess* aProcess, OnlyCreateWithNull /*aDiagnostic*/=NULL)

		{

		return DoCheckDefineRights(aProcess);

		}

	inline TBool CheckGetRights(DProcess* aProcess, OnlyCreateWithNull /*aDiagnostic*/=NULL)

		{

		return DoCheckGetRights(aProcess);

		}

	inline TBool CheckSetRights(DProcess* aProcess, OnlyCreateWithNull /*aDiagnostic*/=NULL)

		{

		return DoCheckSetRights(aProcess);

		}

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	enum { KCompletionDfcPriority = 2 };

	static TDfc		CompletionDfc;

	// subscriptions to be completed by the DFC

	static SDblQue	CompletionQue;		// protected by the system lock

	static DMutex*	FeatureLock;			///< Order KMutexOrdPubSub

	// hash table collision lists

	enum { KHashTableLimit = 32 };	// must be power of 2

	static TProperty*	Table[KHashTableLimit];	// protected by the feature lock

#ifdef __DEMAND_PAGING__

	static DMutex*	PagingLockMutex;		///< Mutex used to protect demand paging lock, order KMutexOrdPubSub2

	static DDemandPagingLock* PagingLock; 	///< Locks user memory when copying large properties

#endif

	// iType == RProperty::ETypeLimit means not defined

	TUint8	iType;	// updates require the system lock AND the feature lock 

					// reads require only one of them

	// The property attributes.

	// Meaningful for defined properties only (ie. iType != RProperty::ETypeLimit)

	// Constant while the property is defined

	TUint8	iAttr;

	TCompiledSecurityPolicy iReadPolicy;

	TCompiledSecurityPolicy iWritePolicy;

	TUint32	iOwner;

	TUint		iRefCount;	// protected by the feature lock

	TProperty*	iNext;		// hash table collision list link -

							//		protected by the feature lock

	class TBuf

		{ // Viraiable-size buffer for  byte array property values

	public:

		static TBuf* New(TInt aSize);

		TUint16	iBufSize;		// buffer size - constant

		TUint16	iSize;			// actual property size - protected by the system lock

		TUint8	iBytes[1];		// byte array - protected by the system lock

		};

	// The property value

	// Meaningful for defined properties only (ie. iType != RProperty::ETypeLimit)

	union	// the value (ie. iValue or iBuf->iBytes) is protected by the system lock

		{ 

		TBuf*	iBuf;   // pointer updates of a defined property (eg. buffer 

						//   reallocation) require the system AND the feature locks;

						// pointer reads (eg to get/set byte values) require any of them

		TInt	iValue;

		};

	// Called with system or feature locked

	TInt Size()

		{

		__PS_ASSERT(iType == RProperty::EByteArray || iType == RProperty::ELargeByteArray);

		return iBuf ? iBuf->iSize : 0;

		}

	// Called with system or feature locked

	TUint8* Buf()

		{

		__PS_ASSERT(iType == RProperty::EByteArray || iType == RProperty::ELargeByteArray);

		return iBuf ? iBuf->iBytes : NULL;

		}

	// Called with system or feature locked

	void SetSize(TInt aSize)

		{

		__PS_ASSERT(TUint(aSize) <= TUint(BufSize()));

		if (iBuf)

			iBuf->iSize = TUint16(aSize);

		}

	TInt _GetB(TUint8* aBuf, TInt* aSize, DProcess* aProcess, TBool aUser);

	TInt _SetB(const TUint8*, TInt aSize, DProcess*, TBool aUser, TBuf** aNewBufHdr);

	SDblQue	iPendingQue;	// pending subscriptions - protected by the system lock

	};

TDfc		TProperty::CompletionDfc(TProperty::CompleteDfc, &TProperty::CompletionQue, KCompletionDfcPriority);

SDblQue		TProperty::CompletionQue;

DMutex*		TProperty::FeatureLock;	

TProperty*	TProperty::Table[KHashTableLimit];

#ifdef __DEMAND_PAGING__

DMutex*		TProperty::PagingLockMutex;

DDemandPagingLock* TProperty::PagingLock;

_LIT(KPubSubMutexName2, "PropertyPagingLockMutex");

#endif

TInt PubSubPropertyInit()

	{ return TProperty::Init(); }

_LIT(KPubSubMutexName, "PropertyLock");

TInt TProperty::Init()

	{ // static

	TInt r = Kern::MutexCreate(FeatureLock, KPubSubMutexName, KMutexOrdPubSub);

	if (r != KErrNone)

		return r;

	CompletionDfc.SetDfcQ(K::SvMsgQ);

#ifdef __DEMAND_PAGING__	

	r = Kern::MutexCreate(PagingLockMutex, KPubSubMutexName2, KMutexOrdPubSub2);

	if (r != KErrNone)

		return r;

	PagingLock = new DDemandPagingLock();

	if (!PagingLock)

		return KErrNoMemory;

	r = PagingLock->Alloc(RProperty::KMaxLargePropertySize);

	if (r != KErrNone)

		return r;

#endif

	return KErrNone;

	}

TProperty::TProperty(TUint aCategory, TUint aKey) : iCategory(aCategory), iKey(aKey)

	{ SetNotDefined(); }

TUint TProperty::Hash(TUint aCategory, TUint aKey)

	{ // a naive hash function 

	TUint code = (aCategory ^ aKey) & (KHashTableLimit - 1);

	__PS_ASSERT(code < KHashTableLimit);	// KHashTableLimit must be a power of 2

	return code;

	}

// Called feature locked.

TProperty** TProperty::Lookup(TUint aCategory, TUint aKey)

	{ // static

	TProperty** propP = &Table[Hash(aCategory, aKey)];

	for (;;)

		{

		TProperty* prop = *propP;

		if (!prop) break;

		if ((prop->iCategory == aCategory) && (prop->iKey == aKey)) break;

		propP = &prop->iNext;

		}

	return propP;

	}

// Called feature locked.

TInt TProperty::LookupOrCreate(TUint aCategory, TUint aKey, TProperty** aProp)

	{ // static

	TProperty** propP = Lookup(aCategory, aKey);

	TProperty* prop = *propP;

	if (!prop)

		{

		prop = new TProperty(aCategory, aKey);

		if (!prop)

			{

			return KErrNoMemory;

			}

		*propP = prop;			

		}

	*aProp = prop;

	return KErrNone;

	}

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TBool TProperty::DoCheckDefineRights(DProcess* aProcess, const char* aDiagnostic)

	{

	TUint32 cat=iCategory;

	if(cat==aProcess->iS.iSecureId)

		return ETrue;

	if(cat<(TUint32)KUidSecurityThresholdCategoryValue)

		return aProcess->HasCapability(ECapabilityWriteDeviceData, aDiagnostic);

	PlatSec::SecureIdCheckFail(aProcess, cat, aDiagnostic);

	return EFalse;

	}

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TBool TProperty::DoCheckDefineRights(DProcess* aProcess)

	{

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return DoCheckDefineRights(aProcess, NULL);

#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	TUint32 cat=iCategory;

	if(cat==aProcess->iS.iSecureId)

		return ETrue;

	if(cat<(TUint32)KUidSecurityThresholdCategoryValue)

		return aProcess->HasCapability(ECapabilityWriteDeviceData);

	return EFalse;

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	}

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

// Called feature locked

TBool TProperty::DoCheckDeleteRights(DProcess* aProcess, const char* aDiagnostic)

	{

	__ASSERT_MUTEX(FeatureLock);

	if(aProcess->iS.iSecureId == Owner())

		{

		return ETrue;

		}

	PlatSec::SecureIdCheckFail(aProcess, Owner(), aDiagnostic);

	return EFalse;

	}

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TBool TProperty::DoCheckDeleteRights(DProcess* aProcess)

	{

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return DoCheckDeleteRights(aProcess, NULL);

#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	__ASSERT_MUTEX(FeatureLock);

	if(aProcess->iS.iSecureId == Owner())

		{

		return ETrue;

		}

	return EFalse;

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	}

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

// Called system locked

TBool TProperty::DoCheckGetRights(DProcess* aProcess, const char* aDiagnostic)

	{

	return iReadPolicy.CheckPolicy(aProcess, aDiagnostic);

	}

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TBool TProperty::DoCheckGetRights(DProcess* aProcess)

	{

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return DoCheckGetRights(aProcess, NULL);

#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return iReadPolicy.CheckPolicy(aProcess);

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	}

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

// Called system locked

TBool TProperty::DoCheckSetRights(DProcess* aProcess, const char* aDiagnostic)

	{

	return iWritePolicy.CheckPolicy(aProcess, aDiagnostic);

	}

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TBool TProperty::DoCheckSetRights(DProcess* aProcess)

	{

#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return DoCheckSetRights(aProcess, NULL);

#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	return iWritePolicy.CheckPolicy(aProcess);

#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

	}

// Called in CS

TProperty::TBuf* TProperty::TBuf::New(TInt aSize)

	{ // static

	__ASSERT_CRITICAL;

	TBuf* buf = (TBuf*) Kern::Alloc(_FOFF(TBuf, iBytes) + aSize);

	if (!buf)

		{

		return NULL;

		}

	buf->iBufSize = TUint16(aSize);

	buf->iSize = 0;

	return buf;

	}

// Called in CS

TInt TProperty::Define(const TPropertyInfo* aInfo, DProcess* aProcess)

	{

	__ASSERT_CRITICAL;

	if (aProcess && !CheckDefineRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Define a Publish and Subscribe Property")))

		{

		return KErrPermissionDenied;

		}

	TCompiledSecurityPolicy readPolicy;

	TInt r = readPolicy.Set((aInfo->iReadPolicy));

	if(r != KErrNone)

		{

		return r;

		}

	TCompiledSecurityPolicy writePolicy;

	r = writePolicy.Set((aInfo->iWritePolicy));

	if(r != KErrNone)

		{

		return r;

		}

	if ((aInfo->iType < 0) || (RProperty::ETypeLimit <= aInfo->iType) ||

		((aInfo->iType == RProperty::EInt) && aInfo->iSize) ||

		(aInfo->iAttr != 0))

		{

		return KErrArgument;

		}

	if ((aInfo->iType == RProperty::EByteArray && aInfo->iSize > RProperty::KMaxPropertySize))

		{

		return KErrTooBig;

		}

	Lock();

	if (IsDefined())

		{

		Unlock();

		return KErrAlreadyExists;

		}

	if (aInfo->iSize)

		{

		__PS_ASSERT((aInfo->iType == RProperty::EByteArray) || (aInfo->iType == RProperty::ELargeByteArray));

		__PS_ASSERT(iBuf == NULL);

		iBuf = TBuf::New(aInfo->iSize);

		}

	iReadPolicy = readPolicy;

	iWritePolicy = writePolicy;

	iOwner = CurProcess()->iS.iSecureId;

	iAttr = 0;

	// We need to check all pending requests for read access rights and 

	// complete those that havn't.

	// We have the following constraints:

	//	- we don't want to hold the system lock iterating through 'iPendingQue' list.

	//	- as soon as the system lock is released new entries can be added by 

	//    'Subscribe()' and existing entries can be removed by 'Cancel()'.

	//	- we don't want to complete a request holding the feature lock

	// To deal with these issues we move all  'iPendingQue' entries to one of 

	// two temporary queues:

	//	'localPendingQue' for entries that will remain pending

	//	'localCompletionQue' for entries that will be completed

	// We move entries one by one dropping and reacquiring the system lock on each 

	// iteration; we get (move) always the first 'iPendingQue' entry until the 

	// queue becomes empty.

	//

	SDblQue localPendingQue;	// protected by the system lock

	SDblQue localCompletionQue;	// protected by the system lock

	NKern::LockSystem();

	while (!iPendingQue.IsEmpty())

		{

		TPropertySubsRequest* subs = (TPropertySubsRequest*) iPendingQue.GetFirst();

		DProcess* process = subs->iProcess;

		subs->iProcess = NULL;

		if (process && !CheckGetRights(process, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Subscribe to a Publish and Subscribe Property")))

			{ // Check fails - will complete the subscription with an error

			localCompletionQue.Add(subs);

			}

		else

			{ // Check OK - will leave in the pending queue