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

// Used by a thread to schedule cancelation of Subscribe request in Supervisor thread.
class TCancelQ: public SDblQueLink
{
public:
    TPropertySubsRequest* iPropSubRequest;//The request to be cancelled, can be NULL
    NFastSemaphore iFSemaphore;//Semafore to be signalled by Supervisor thread after the request is cancelled.
};

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 void CompleteDfcByKErrPermissionDenied(TAny* aQue);
	static void CompleteDfcByKErrNotFound(TAny* aQue);
	static void CompleteCancellationQDfc(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 { KCancellationDfcPriority = 1, KCompletionDfcPriority = 2  };
	static TDfc		CompletionDfc;
	static TDfc		CompletionDfcPermissionDenied;
	static TDfc		CompletionDfcNotFound;
	static TDfc		CancellationDfc;
	
	// subscriptions to be completed by the DFCs, protected by system lock
	static SDblQue	CompletionQue; // to be completed by KerrNone
	static SDblQue	CompletionQuePermissionDenied;
	static SDblQue	CompletionQueNotFound;
	static SDblQue	CancellationQue;		

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


// Completion/Cancelation DFCs and their corresponding queues.
// All subscribe requests are completed in Supervisor thread.
TDfc		TProperty::CompletionDfc(TProperty::CompleteDfc, &TProperty::CompletionQue, KCompletionDfcPriority);
SDblQue		TProperty::CompletionQue;

TDfc		TProperty::CompletionDfcPermissionDenied(TProperty::CompleteDfcByKErrPermissionDenied, &TProperty::CompletionQuePermissionDenied, KCompletionDfcPriority);
SDblQue		TProperty::CompletionQuePermissionDenied;

TDfc		TProperty::CompletionDfcNotFound(TProperty::CompleteDfcByKErrNotFound, &TProperty::CompletionQueNotFound, KCompletionDfcPriority);
SDblQue		TProperty::CompletionQueNotFound;

TDfc		TProperty::CancellationDfc(TProperty::CompleteCancellationQDfc, &TProperty::CancellationQue, KCancellationDfcPriority);
SDblQue		TProperty::CancellationQue;

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);
	CompletionDfcPermissionDenied.SetDfcQ(K::SvMsgQ);
	CompletionDfcNotFound.SetDfcQ(K::SvMsgQ);
	CancellationDfc.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;    // Will hold requests with sufficient capabilities. 
	TInt accessDeniedCounter = 0;// Will count requests with no sufficient capabilities.
	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
			CompletionQuePermissionDenied.Add(subs);
			accessDeniedCounter++;
			}
		else
			{ // Check OK - will leave in the pending queue 
			localPendingQue.Add(subs);
			}
		NKern::FlashSystem();	// preemption point
		}
	iPendingQue.MoveFrom(&localPendingQue);
	iType = (TUint8) aInfo->iType;
	NKern::UnlockSystem();
	// Now the property can be accessed by other threads.
	Use();
	Unlock();

	// Schedule DFC to complete requests of those with insufficient capabilities.
	if (accessDeniedCounter)
		CompletionDfcPermissionDenied.Enque();
	return KErrNone;
	}

// Called in CS
TInt TProperty::Attach(TUint aCategory, TUint aKey, TProperty** aProp)
	{ //static 
	Lock();
	TProperty* prop;
	// Attach can create a non defined property.
	TInt r = LookupOrCreate(aCategory, aKey, &prop);
	if (r != KErrNone) 
		{
		Unlock();
		return r;
		}
	prop->Use();
	*aProp = prop;
	Unlock();
	return KErrNone;
	}

// Called in CS
TInt TProperty::Open(TUint aCategory, TUint aKey, TProperty** aProp)
	{ //static 
	Lock();
	TProperty* prop = *Lookup(aCategory, aKey);
	if (!prop) 
		{
		Unlock();
		return KErrNotFound;
		}
	prop->Use();
	*aProp = prop;
	Unlock();
	return KErrNone;
	}

// Called in CS
void TProperty::Close()
	{
	Lock();
	Release();
	// '*this' may do not exist any more
	Unlock();
	}

// Called in CS
TInt TProperty::Delete(DProcess* aProcess)
	{
	Lock();
	if (!IsDefined())
		{
		Unlock();
		return KErrNotFound;
		}
	if (aProcess && !CheckDeleteRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Delete a Publish and Subscribe Property")))
		{
		Unlock();
		return KErrPermissionDenied;
		}
	NKern::LockSystem();
	// Remember that iType is the tag of iBuf and iValue union
	TBuf* buf = (iType != RProperty::EInt) ? iBuf : NULL;
	SetNotDefined();
	// Down from here nobody can access the property value

	// Move all pending requests to completion queue (to be completed by KErrNotFound).
	TBool pendingQueEmpty = iPendingQue.IsEmpty();
	if(!pendingQueEmpty)
		CompletionQueNotFound.MoveFrom(&iPendingQue);

	NKern::UnlockSystem();

	iBuf = NULL;
	iValue = 0;
	delete buf;
	Release();
	// '*this' may do not exist any more
	Unlock();

	 // Schedule Svc Dfc to complete all requests from CompletionQueNotFound.
	if (!pendingQueEmpty)
		CompletionDfcNotFound.Enque();
	return KErrNone;
	}

// Enter feature locked.
// Return feature locked.
inline void TProperty::Use()
	{
	__ASSERT_MUTEX(FeatureLock);
	++iRefCount;
	}

// Enter feature locked.
// Return feature locked.
void TProperty::Release()
	{
	__ASSERT_MUTEX(FeatureLock);
	__PS_ASSERT(iRefCount);
	if (--iRefCount == 0)
		{
		__PS_ASSERT(!IsDefined()); // property must not be defined.
		// Lookup to find the previous element in the simply linked collision list.
		TProperty** propP = Lookup(iCategory, iKey);
		*propP = iNext;
		delete this;
		}
	}

// Enter system locked.
// Return system unlocked.
TInt TProperty::Subscribe(TPropertySubsRequest* aSubs, DProcess* aProcess)
	{
	__ASSERT_SYSTEM_LOCK;
	if (aSubs->iNext)
		{ // already pending - will Panic
		NKern::UnlockSystem();
		return KErrInUse;
		}
	TBool defined = IsDefined();
	if (defined)
		{ // property is defined - check access now
		aSubs->iProcess = NULL;	
		if (aProcess && !CheckGetRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Subscribe to a Publish and Subscribe Property")))
			{
			CompletionQuePermissionDenied.Add(aSubs);
			CompletionDfcPermissionDenied.Enque(SYSTEM_LOCK);
			return KErrNone;
			}
		}	
	else
		{ // will check when defined
		aSubs->iProcess = aProcess;
		}
	iPendingQue.Add(aSubs);
	NKern::UnlockSystem();
	return KErrNone;
	}

// Enter system locked.
// Return system unlocked.
void TProperty::Cancel(TPropertySubsRequest* aSubs)
	{
	__ASSERT_SYSTEM_LOCK;

	// This is set if the request is about to be completed (in SVC thread). In that case, a 'dummy' CancelationDFC
	// will be scheduled here. This will just ensure that we don't return from Cancel before ongoing completion has finished.  
	TBool scheduledForCompletition = (TInt)(aSubs->iProcess) & TPropertySubsRequest::KScheduledForCompletion;

	if (!aSubs->iNext && !scheduledForCompletition)
		{ // Neither in any queue nor scheduled for completion.
		  // The request is not active - silently return.
		NKern::UnlockSystem();
		return;
		}

	if (aSubs->iNext)
		{
		// Take it out from the current queue. It is usually pending queue of a property but could
		// also be one of the completion queues.
		aSubs->Deque();
		aSubs->iNext = NULL;
		}
	
	// Set process to NULL (leave KScheduledForCompletion bit as it is)
	aSubs->iProcess = (DProcess*)((TInt)aSubs->iProcess & ~TPropertySubsRequest::KProcessPtrMask);
	
	if (&Kern::CurrentThread() == K::SvThread)
		{   // Complete the request immediatelly if already running in supervisor thread...
		if (!scheduledForCompletition)
			CompleteRequest(aSubs, KErrCancel); //This will also release system lock.
		else
			NKern::UnlockSystem();              // Nothing to be done here. Just release system lock.
		}
	else
		{   //... or schedule DFC in supervisor thread to complete the request.
		TCancelQ linkQ;
		if (!scheduledForCompletition)
			linkQ.iPropSubRequest = aSubs;      // CancelationDFC will complete this request with KErrCancel.
		else
			linkQ.iPropSubRequest = NULL;       // Schedule 'dummy' CancelationDFC (no request will be completed).
		linkQ.iFSemaphore.iOwningThread = NKern::CurrentThread();
		CancellationQue.Add(&linkQ);
		CancellationDfc.Enque(SYSTEM_LOCK);     // This will also release system lock.

		NKern::FSWait(&linkQ.iFSemaphore);      // Wait for CancellationDfc to finish.
		}
	}

// Enter system locked.
// Return system unlocked.
// Executed in supervisor thread.
void TProperty::CompleteRequest(TPropertySubsRequest* aSubs, TInt aResult)
	{ // static
	__ASSERT_SYSTEM_LOCK;
	__PS_ASSERT(&Kern::CurrentThread() == K::SvThread);
	TPropertyCompleteFn	fn = aSubs->iCompleteFn;
	TAny* ptr = aSubs->iPtr;
	// Mark that this request is about to be completed.
	aSubs->iProcess = (DProcess*)((TInt)aSubs->iProcess | TPropertySubsRequest::KScheduledForCompletion);
	NKern::UnlockSystem();
	(*fn)(ptr, aResult);
	}

// Executed in supervisor thread.
void TProperty::CompleteQue(SDblQue* aQue, TInt aReason)
	{ // static
	__PS_ASSERT(&Kern::CurrentThread() == K::SvThread);
	NKern::LockSystem();
	while (!aQue->IsEmpty())
		{ 
		TPropertySubsRequest* subs = (TPropertySubsRequest*) aQue->First();
		subs->Deque();
		subs->iNext = NULL;
		CompleteRequest(subs, aReason);
		NKern::LockSystem();
		}	 
	NKern::UnlockSystem();
	}

// Executed in supervisor thread. Completes requests with KErrNone.
void TProperty::CompleteDfc(TAny* aQue)
	{ // static
	CompleteQue((SDblQue*) aQue, KErrNone);
	}

// Executed in supervisor thread.
void TProperty::CompleteDfcByKErrPermissionDenied(TAny* aQue)
	{ // static
	CompleteQue((SDblQue*) aQue, KErrPermissionDenied);
	}

// Executed in supervisor thread.
void TProperty::CompleteDfcByKErrNotFound(TAny* aQue)
	{ // static
	CompleteQue((SDblQue*) aQue, KErrNotFound);
	}

// Executed in supervisor thread.
void TProperty::CompleteCancellationQDfc(TAny* aAny)
	{ // static
	SDblQue* aQue = (SDblQue*)aAny;
	NKern::LockSystem();
	while (!aQue->IsEmpty() )
		{
        TCancelQ* first = static_cast<TCancelQ*>(aQue->First());
        first->Deque();
        first->iNext = NULL;

        if( first->iPropSubRequest)
        	{
            CompleteRequest(first->iPropSubRequest, KErrCancel); // This will also release system lock.
            NKern::LockSystem();
        	}
        else
        	{
        	// Do not complete the request.
        	// It was already just about to be completed when Cancel request was issued.
			// As all complitions (this method included) run is Svc thread, we can here be sure that
			// the request is now completed.
			NKern::FlashSystem();	// Preemption point
        	}
        NKern::FSSignal( &first->iFSemaphore ); // Issue the signal that the request is now completed.
        }
    NKern::UnlockSystem();
	}

// Enter system locked.
// Return system unlocked.
void TProperty::CompleteByDfc()
	{
	__ASSERT_SYSTEM_LOCK;
	// Append elements from the pending queue to the completion queue
	if (!iPendingQue.IsEmpty())
		{
		CompletionQue.MoveFrom(&iPendingQue);
		CompletionDfc.Enque(SYSTEM_LOCK);
		}
	else 
		{
		NKern::UnlockSystem();
		}
	}
	
// Enter system locked.
// Return system unlocked.
TInt TProperty::GetI(TInt* aValue, DProcess* aProcess)
	{
	__ASSERT_SYSTEM_LOCK;
	if (!IsDefined())
		{
		NKern::UnlockSystem();
		return KErrNotFound;
		}
	if (aProcess && !CheckGetRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Get a Publish and Subscribe Property")))
		{
		NKern::UnlockSystem();
		return KErrPermissionDenied;
		}
	if (iType != RProperty::EInt)
		{
		NKern::UnlockSystem();
		return KErrArgument;
		}
	*aValue = iValue;
	NKern::UnlockSystem();
	return KErrNone;
	}

TInt TProperty::FindGetI(TUint aCategory, TUint aKey, TInt* aValue, DProcess* aProcess)
	{
	Lock();
	TProperty* prop = *TProperty::Lookup(aCategory, aKey);
	TInt r;
	if (!prop) 
		r = KErrNotFound;
	else
		{
		NKern::LockSystem();
		r = prop->GetI(aValue, aProcess);
		}
	Unlock();
	return r;
	}

TInt TProperty::FindSetI(TUint aCategory, TUint aKey, TInt aValue, DProcess* aProcess)
	{
	Lock();
	TProperty* prop = *TProperty::Lookup(aCategory, aKey);
	TInt r;
	if (!prop) 
		r = KErrNotFound;
	else
		{
		NKern::LockSystem();
		r = prop->SetI(aValue, aProcess);
		}
	Unlock();
	return r;
	}

#ifdef __EPOC32__
extern "C" { extern void kumemput_no_paging_assert(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/); }
#else
inline void kumemput_no_paging_assert(TAny* aAddr, const TAny* aKernAddr, TInt aLength)
	{kumemput(aAddr,aKernAddr,aLength);}
#endif

// Enter system locked.
// Return system unlocked.
TInt TProperty::_GetB(TUint8* aBuf, TInt* aSize, DProcess* aProcess, TBool aUser)
	{
	if (!IsDefined())
		{
		NKern::UnlockSystem();
		return KErrNotFound;
		}
	if (aProcess && !CheckGetRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Get a Publish and Subscribe Property")))
		{
		NKern::UnlockSystem();
		return KErrPermissionDenied;
		}
	if (iType == RProperty::EInt)
		{
		NKern::UnlockSystem();
		return KErrArgument;
		}
	if (iType == RProperty::ELargeByteArray)
		{
		// copy with system lock released
		__ASSERT_MUTEX(FeatureLock);
		NKern::UnlockSystem();
		}
	TInt bufSize = *aSize;
	TInt size = Size();
	TInt r = KErrNone;
	if (bufSize < size) 
		{
		size = bufSize;
		r = KErrOverflow;
		}
	TUint8* buf = Buf();
	if (aUser)
		{ // Don't use 'r' to preserve possible KErrOverflow condition
		XTRAPD(res, XT_DEFAULT, kumemput_no_paging_assert(aBuf, buf, size));
		if (res != KErrNone)
			r = KErrBadDescriptor;
		}
	else
		{ 
		memcpy(aBuf, buf, size); 
		}
	*aSize = size;
	if (iType != RProperty::ELargeByteArray)
		{
		NKern::UnlockSystem();
		}
	return r;
	}

// Enter system locked.
// Return system unlocked.
TInt TProperty::GetB(TUint8* aBuf, TInt* aSize, DProcess* aProcess, TBool aUser)
	{
	__ASSERT_SYSTEM_LOCK;
	if (iType != RProperty::ELargeByteArray)
		return _GetB(aBuf,aSize,aProcess,aUser);

	// Acquire feature lock for accessing large properties
	NKern::ThreadEnterCS();
	FeatureLock->Wait();	// returns with system lock still held
	TInt r = _GetB(aBuf,aSize,aProcess,aUser);
	Unlock();
	NKern::ThreadLeaveCS();
	return r;
	}

// Enter system locked.
// Return system unlocked.
TInt TProperty::SetI(TInt aValue, DProcess* aProcess)
	{
	__ASSERT_SYSTEM_LOCK;
	if (!IsDefined())
		{
		NKern::UnlockSystem();
		return KErrNotFound;
		}
	if (aProcess && !CheckSetRights(aProcess, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Set a Publish and Subscribe Property")))
		{
		NKern::UnlockSystem();
		return KErrPermissionDenied;
		}
	if (iType != RProperty::EInt)
		{
		NKern::UnlockSystem();
		return KErrArgument;
		}
	iValue = aValue;
	CompleteByDfc(); //This will also release system lock.
	return KErrNone;
	}


#ifdef __EPOC32__
extern "C" { extern void kumemget_no_paging_assert(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/); }
#else
inline void kumemget_no_paging_assert(TAny* aKernAddr, const TAny* aAddr, TInt aLength)
	{kumemget(aKernAddr,aAddr,aLength);}
#endif

// Enter with system locked.
// Return system unlocked.
TInt TProperty::_SetB(const TUint8* aBuf, TInt aSize, DProcess* aProcess, TBool aUser, TBuf** aNewBuf)
	{
	if (!IsDefined())
		{
		NKern::UnlockSystem();
		return KErrNotFound;
		}
	if (aProcess && !CheckSetRights(aProcess, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Set a Publish and Subscribe Property")))
		{
		NKern::UnlockSystem();
		return KErrPermissionDenied;
		}
	if (iType == RProperty::EInt)
		{
		NKern::UnlockSystem();
		return KErrArgument;
		}
	else if (iType == RProperty::EByteArray)
		{
		if (aSize > RProperty::KMaxPropertySize)
			{
			NKern::UnlockSystem();
			return KErrTooBig;
			}
		}
	else if (iType == RProperty::ELargeByteArray)
		{
		__ASSERT_MUTEX(FeatureLock);
		NKern::UnlockSystem();
		if (aSize > RProperty::KMaxLargePropertySize)
			{
			return KErrTooBig;
			}
		}
	if (aSize > BufSize())
		{
		if (aNewBuf == NULL || *aNewBuf == NULL)
			{
			if (iType != RProperty::ELargeByteArray)
				{
				NKern::UnlockSystem();
				}
			return KErrOverflow;
			}
		// New buffer is provided by the caller - switch on it
		TBuf* oldBuf = iBuf;
		iBuf = *aNewBuf;
		// Caller will deallocate the old buffer out of the system lock context
		*aNewBuf = oldBuf;
		}
	if (aUser)
		{
		__NK_ASSERT_DEBUG(iType==RProperty::ELargeByteArray);
		XTRAPD(r, XT_DEFAULT, kumemget_no_paging_assert(Buf(), aBuf, aSize));
		if (r != KErrNone)
			return KErrBadDescriptor;
		}
	else
		{
		memcpy(Buf(), aBuf, aSize); 
		}
	SetSize(aSize);
	if (iType == RProperty::ELargeByteArray)
		{
		NKern::LockSystem();
		}
	CompleteByDfc();
	return KErrNone;
	}

// Enter system locked.
// Return system unlocked.
TInt TProperty::SetB(const TUint8* aBuf, TInt aSize, DProcess* aProcess, TBool aUser)
	{ // static
	__ASSERT_SYSTEM_LOCK;
	TBuf* nBuf = 0;
	if (iType != RProperty::ELargeByteArray)
		{
		// Try to set without buffer reallocation (ie. "RT") first
		TInt r = _SetB(aBuf, aSize, aProcess, aUser, NULL);
		if (r != KErrOverflow)
			return r;

		// Needs buffer reallocation
		NKern::ThreadEnterCS();
		// Allocate a new buffer
		nBuf = TBuf::New(aSize);
		if (!nBuf)
			{
			NKern::ThreadLeaveCS();
			return KErrNoMemory;
			}
		NKern::LockSystem();
		
		r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);
		// May be the old buffer (or NULL), may be the new one (if wasn't used)
		delete nBuf;
		NKern::ThreadLeaveCS();
		return r;
		}
	
	NKern::ThreadEnterCS();

	// Large property - need feature lock
	FeatureLock->Wait();
	TInt r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);
	if (r == KErrOverflow)
		{
		// Allocate a new buffer
		nBuf = TBuf::New(aSize);
		if (!nBuf)
			r = KErrNoMemory;
		else
			{
			NKern::LockSystem();
			r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);
			}
		}
	Unlock();
	// May be the old buffer (or NULL), may be the new one (if wasn't used)
	delete nBuf;
	NKern::ThreadLeaveCS();
	return r;
	}

#ifdef __DEMAND_PAGING__

TInt TProperty::LockSourcePages(const TUint8* aBuf, TInt aSize)
	{
	// When copying from user RAM we must lock the source data in case it is demand paged, otherwise
	// we could get a mutex ordering voliation when waiting on the demand paging mutex
	__ASSERT_CRITICAL;
	Kern::MutexWait(*PagingLockMutex);
	TInt r = PagingLock->Lock(TheCurrentThread, (TLinAddr)aBuf, aSize);
	if(r>=0)
		return KErrNone;
	Kern::MutexSignal(*PagingLockMutex);
	return r;
	}

void TProperty::UnlockSourcePages()
	{
	__ASSERT_CRITICAL;
	PagingLock->Unlock();
	Kern::MutexSignal(*PagingLockMutex);
	}

#else

TInt TProperty::LockSourcePages(const TUint8*, TInt)
	{
	return KErrNone;
	}

void TProperty::UnlockSourcePages()
	{
	}

#endif

//
// User Interface
//
	
class DPropertyRef : public DObject
	{
public:

	static TInt Define(TUint aCategory, TUint aKey, const TPropertyInfo*);
	static TInt Delete(TUint aCategory, TUint aKey);
	static TInt Attach(TUint aCategory, TUint aKey, TOwnerType aType);

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

	DPropertyRef();
	~DPropertyRef();

	TInt Subscribe(TRequestStatus* aStatus);
	inline void Cancel();

	inline TInt GetI(TInt* aValue);
	inline TInt GetB(TUint8* aBuf, TInt* aSize, TBool aUser);
	inline TInt SetI(TInt aValue);
	TInt SetB(const TUint8* aBuf, TInt aSize, TBool aUser);

	inline RProperty::TType Type()
		{ return iProp->Type(); }
private:

	static void CompleteFn(TAny* aPtr, TInt aReason);

	TProperty*				iProp;
	TClientRequest*			iRequest;
	DThread*				iClient;
	TPropertySubsRequest	iSubs;
	};

DPropertyRef::DPropertyRef() : iSubs(CompleteFn, this)
	{
	}

// Called in CS
TInt DPropertyRef::Define(TUint aCategory, TUint aKey, const TPropertyInfo* aInfo)
	{ // static
	__ASSERT_CRITICAL;
	TProperty* prop;
	TInt r = TProperty::Attach(aCategory, aKey, &prop);
	if (r != KErrNone)
		{
		return r;
		}
	r = prop->Define(aInfo, CurProcess());
	prop->Close();
	return r;
	}

// Called in CS
TInt DPropertyRef::Delete(TUint aCategory, TUint aKey)
	{ // static
	__ASSERT_CRITICAL;
	TProperty* prop;
	TInt r = TProperty::Open(aCategory, aKey, &prop);
	if (r != KErrNone)
		{
		return r;
		}
	r = prop->Delete(CurProcess());
	prop->Close();
	return r;
	}

// Called in CS
TInt DPropertyRef::Attach(TUint aCategory, TUint aKey, TOwnerType aType)
	{ // static
	__ASSERT_CRITICAL;
	DPropertyRef* ref = new DPropertyRef();
	if (ref == NULL)
		{
		return KErrNoMemory;
		}
	TInt r = Kern::CreateClientRequest(ref->iRequest);
	if (r != KErrNone)
		{
		ref->Close(NULL);
		return r;
		}
	r = TProperty::Attach(aCategory, aKey, &ref->iProp);
	if (r != KErrNone)
		{
		ref->Close(NULL);
		return r;
		}
	r = K::AddObject(ref, EPropertyRef);
	if (r != KErrNone)
		{
		ref->Close(NULL);
		return r;
		}
	r = K::MakeHandle(aType, ref);
	if (r < 0)
		{ // error
		ref->Close(NULL);
		}
	return r;
	}

// Enter system locked.
// Return system unlocked.
TInt DPropertyRef::Subscribe(TRequestStatus* aStatus)
	{
	__ASSERT_SYSTEM_LOCK;
	if (iRequest->SetStatus(aStatus) != KErrNone)
		{ // already pending - will Panic
		NKern::UnlockSystem();
		return KErrInUse;
		}
	iClient = TheCurrentThread;
	iClient->Open();
	return iProp->Subscribe(&iSubs, CurProcess());
	}

// Called in CS or a DFC context
void DPropertyRef::CompleteFn(TAny* ptr, TInt aReason)
	{ // static
	__ASSERT_CRITICAL;
	DPropertyRef* self = (DPropertyRef*) ptr;
	// Local 'client' variable is necessary because after we call Kern::QueueRequestComplete the
	// structure may be reused for another subscription
	DThread* client = self->iClient;
	__PS_ASSERT(client);
	self->iClient = NULL;
	Kern::QueueRequestComplete(client, self->iRequest, aReason);
	client->Close(NULL);
	}

// Enter system locked.
// Return system unlocked.
inline void DPropertyRef::Cancel()
	{
	__ASSERT_SYSTEM_LOCK;
	iProp->Cancel(&iSubs);
	}

// Enter system locked.
// Return system unlocked.
inline TInt DPropertyRef::GetI(TInt* aValue)
	{
	return iProp->GetI(aValue, CurProcess());
	}

// Enter system locked.
// Return system unlocked.
inline TInt DPropertyRef::GetB(TUint8* aBuf, TInt* aSize, TBool aUser)
	{
	return iProp->GetB(aBuf, aSize, CurProcess(), aUser);
	}

// Enter system locked.
// Return system unlocked.
inline TInt DPropertyRef::SetI(TInt aValue)
	{
	return iProp->SetI(aValue, CurProcess());
	}

// Called in CS
inline TInt DPropertyRef::FindGetI(TUint aCategory, TUint aKey, TInt* aValue)
	{
	return TProperty::FindGetI(aCategory, aKey, aValue, CurProcess());
	}

// Called in CS
inline TInt DPropertyRef::FindSetI(TUint aCategory, TUint aKey, TInt aValue)
	{
	return TProperty::FindSetI(aCategory, aKey, aValue, CurProcess());
	}


// Enter system locked.
// Return system unlocked.
TInt DPropertyRef::SetB(const TUint8* aBuf, TInt aSize, TBool aUser)
	{
	TBool open = 
		(iProp->Type() == RProperty::EByteArray) && (iProp->BufSize() < aSize);
	if (open)
		{
		// The buffer extension will release the system lock. 
		// We need to increment the DObject count to protect our-self against 
		// a concurrent DPropertyRef deletion by DObject::Close().
		if (Open() != KErrNone)
			{ // Too late - destruction in progress ....
			NKern::UnlockSystem();
			return KErrNotFound;
			}
		}
	TInt r = iProp->SetB(aBuf, aSize, CurProcess(), aUser);
	if (open)
		{
		Close(NULL);
		}
	return r;
	}

//
// User interface entry points
//

// Called in CS
DPropertyRef::~DPropertyRef()
	{
	__ASSERT_CRITICAL;
	if (iProp)
		{
		NKern::LockSystem();
		Cancel();
		iProp->Close();
		iProp = NULL;
		}
	Kern::DestroyClientRequest(iRequest);
	}

TInt ExecHandler::PropertyDefine(TUint aCategory, TUint aKey, TPropertyInfo* aInfo)
	{
	TPropertyInfo info;
	kumemget(&info, aInfo, sizeof(info));
	if (aCategory == KMaxTUint)
		aCategory = TUint(Kern::CurrentProcess().iS.iSecureId);
	NKern::ThreadEnterCS();
	TInt r = DPropertyRef::Define(aCategory, aKey, &info);
	NKern::ThreadLeaveCS();
	return r;
	}

TInt ExecHandler::PropertyDelete(TUint aCategory, TUint aKey)
	{
	if (aCategory == KMaxTUint)
		aCategory = TUint(Kern::CurrentProcess().iS.iSecureId);
	NKern::ThreadEnterCS();
	TInt r = DPropertyRef::Delete(aCategory, aKey);
	NKern::ThreadLeaveCS();
	return r;
	}

TInt ExecHandler::PropertyAttach(TUint aCategory, TUint aKey, TOwnerType aType)
	{
	NKern::ThreadEnterCS();
	TInt r = DPropertyRef::Attach(aCategory, aKey, aType);
	NKern::ThreadLeaveCS();
	return r;
	}

// Enter system locked.
// Return system unlocked.
void ExecHandler::PropertySubscribe(DPropertyRef* aRef, TRequestStatus* aStatus)
	{
	TInt r = aRef->Subscribe(aStatus);
	if (r != KErrNone)
		{
		__PS_ASSERT(r == KErrInUse);
		K::PanicKernExec(ERequestAlreadyPending);
		}
	}

// Enter system locked.
// Return system unlocked.
void ExecHandler::PropertyCancel(DPropertyRef* aRef)
	{
	aRef->Cancel();
	}

// Enter system locked.
// Return system unlocked.
TInt ExecHandler::PropertyGetI(DPropertyRef* aRef, TInt* aValue)
	{
	TInt value;
	TInt r = aRef->GetI(&value);
	if (r != KErrNone)
		{
		return r;
		}
	kumemput32(aValue, &value, sizeof(value));
	return KErrNone;
	}


// Enter system locked.
// Return system unlocked.
TInt ExecHandler::PropertyGetB(DPropertyRef* aRef, TUint8* aBuf, TInt aSize)
	{
	TInt r;

	if(aRef->Type()!=RProperty::ELargeByteArray)
		{
		// Use intermediate kernel buffer for small properties
		TUint8 sbuf[RProperty::KMaxPropertySize];
		if(aSize > (TInt)sizeof(sbuf))
			aSize = sizeof(sbuf);
		r = aRef->GetB(sbuf, &aSize, EFalse);
		if(r==KErrNone || r==KErrOverflow)
			kumemput(aBuf,sbuf,aSize);
		}
	else
		{
		// For large properties we must pin user memory to prevent demand paging.
		aRef->CheckedOpen();
		NKern::ThreadEnterCS();
		NKern::UnlockSystem();

		if(aSize>RProperty::KMaxLargePropertySize)
			aSize = RProperty::KMaxLargePropertySize;
		r = TProperty::LockSourcePages(aBuf, aSize);
		if(r>=0)
			{
			NKern::LockSystem();
			r = aRef->GetB(aBuf, &aSize, ETrue);
			TProperty::UnlockSourcePages();
			}

		aRef->Close(0);
		NKern::ThreadLeaveCS();
		}

	if (r == KErrBadDescriptor)
		{
		K::PanicKernExec(ECausedException);
		}
	else if (r != KErrNone)
		{
		return r;
		}
	return aSize;
	}

// Enter system locked.
// Return system unlocked.
TInt ExecHandler::PropertySetI(DPropertyRef* aRef, TInt aValue)
	{
	return aRef->SetI(aValue);
	}

// Enter and return system unlocked.
TInt ExecHandler::PropertySetB(TInt aPropertyRefHandle, const TUint8* aBuf, TInt aSize)
	{
	// If property small enough then copy it to local buffer
	TBool user = ETrue;
	TUint8 sbuf[RProperty::KMaxPropertySize];
	if(aSize<=RProperty::KMaxPropertySize)
		{
		kumemget(sbuf,aBuf,aSize);
		aBuf = sbuf;
		user = EFalse;
		}
	
	NKern::ThreadEnterCS();

	TInt r = KErrNone;
	if (user)
		r = TProperty::LockSourcePages(aBuf, aSize);
	
	// Set the property
	if(r>=0)
		{
		NKern::LockSystem();
		DPropertyRef* propertyRef = (DPropertyRef*)TheCurrentThread->ObjectFromHandle(aPropertyRefHandle,EPropertyRef);
		if (propertyRef)
			{
			r = propertyRef->SetB(aBuf, aSize, user);
			// unlocks system lock
			}
		else
			{
			r = KErrBadHandle;
			NKern::UnlockSystem();
			}

		if (user)
			TProperty::UnlockSourcePages();
		}
	
	NKern::ThreadLeaveCS();
	
	if (r == KErrBadDescriptor)
		K::PanicKernExec(ECausedException);
	if (r == KErrBadHandle)
		K::PanicKernExec(EBadHandle);
	return r;
	}

TInt ExecHandler::PropertyFindGetI(TUint aCategory, TUint aKey, TInt* aValue)
	{
	TInt value;
	NKern::ThreadEnterCS();
	TInt r = DPropertyRef::FindGetI(aCategory, aKey, &value);
	NKern::ThreadLeaveCS();
	if (r != KErrNone)
		{
		return r;
		}
	kumemput32(aValue, &value, sizeof(value));
	return KErrNone;
	}

TInt ExecHandler::PropertyFindGetB(TUint aCategory, TUint aKey, TUint8* aBuf, 
								   TInt aSize)
	{
	NKern::ThreadEnterCS();

	TProperty* prop;
	TInt r = TProperty::Open(aCategory, aKey, &prop);
	if (r == KErrNone)
		{
		if(prop->Type()!=RProperty::ELargeByteArray)
			{
			// Use intermediate kernel buffer for small properties
			TUint8 sbuf[RProperty::KMaxPropertySize];
			if(aSize > (TInt)sizeof(sbuf))
				aSize = sizeof(sbuf);
			NKern::LockSystem();
			r = prop->GetB(sbuf, &aSize, CurProcess(), EFalse);
			if(r==KErrNone || r==KErrOverflow)
				kumemput(aBuf,sbuf,aSize);
			}
		else
			{
			// For large properties we must pin the use memory to prevent demand paging.
			if(aSize>RProperty::KMaxLargePropertySize)
				aSize = RProperty::KMaxLargePropertySize;
			r = TProperty::LockSourcePages(aBuf, aSize);
			if(r>=0)
				{
				NKern::LockSystem();
				r = prop->GetB(aBuf, &aSize, CurProcess(), ETrue);
				TProperty::UnlockSourcePages();
				}
			}
		prop->Close();
		}

	NKern::ThreadLeaveCS();

	if (r == KErrBadDescriptor)
		{
		K::PanicKernExec(ECausedException);
		}
	else if (r != KErrNone)
		{
		return r;
		}
	return aSize;
	}

TInt ExecHandler::PropertyFindSetI(TUint aCategory, TUint aKey, TInt aValue)
	{
	NKern::ThreadEnterCS();
	TInt r = DPropertyRef::FindSetI(aCategory, aKey, aValue);
	NKern::ThreadLeaveCS();
	return r;
	}

TInt ExecHandler::PropertyFindSetB(TUint aCategory, TUint aKey, TUint8* aBuf, 
								   TInt aSize)
	{
	// If property small enough then copy it to local buffer
	TBool user = ETrue;
	TUint8 sbuf[RProperty::KMaxPropertySize];
	if(aSize<=RProperty::KMaxPropertySize)
		{
		kumemget(sbuf,aBuf,aSize);
		aBuf = sbuf;
		user = EFalse;
		}

	NKern::ThreadEnterCS();

	TInt r = KErrNone;
	if (user)
		r = TProperty::LockSourcePages(aBuf, aSize);
	
	// Find and open property
	if(r>=0)
		{
		TProperty* prop;
		r = TProperty::Open(aCategory, aKey, &prop);
		if (r == KErrNone)
			{
			// Set the property
			NKern::LockSystem();
			r = prop->SetB(aBuf, aSize, CurProcess(), user);
			prop->Close();
			}
		
		if (user)
			TProperty::UnlockSourcePages();
		}

	NKern::ThreadLeaveCS();
	if (r == KErrBadDescriptor)
		K::PanicKernExec(ECausedException);
	return r;
	}

/** Attaches to a property.

	This performs the same action as RPropertyRef::Open(). However, if the property does
	not exist then it is created first.
	
  	@param aCategory The property category.
	@param aKey The property sub-key.
	
	@return KErrNone, if successful;
	        KErrNoMemory, if insufficient memory.
	
	@pre Calling thread must be in a critical section.
	@pre Property has not been opened.
	@pre Call in a thread context.
	@pre Kernel must be unlocked.
	@pre interrupts enabled
	@pre No fast mutex can be held

	@post Calling thread is in a critical section.

	@see RPropertyRef::Open()
*/
EXPORT_C TInt RPropertyRef::Attach(TUid aCategory, TInt aKey)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPropertyRef::Attach");			
	__PS_ASSERT(iProp == NULL);
	return TProperty::Attach(TUint(aCategory.iUid), aKey, &iProp);
	}
	
/** Opens a property.

 	Once opened:
 	 - the property can be defined, deleted, and  subscribed to
 	 - the property value can be retrieved (read) and published (written)
	using the appropriate member-functions in the appropriate order.
	
	Note that the property must already exist. If it does not exist,
	the function will not create it - it will return an error.
	Use RPropertyRef::Attach() if you need to create the property.

	@param aCategory The property category.
	@param aKey The property sub-key.
	
	@return	KErrNotFound, if the property does not exist;
			KErrNone, if successful;
			Otherwise, one of the other system-wide error codes.

	@pre Calling thread must be in a critical section.
	@pre Property has not been opened.
	@pre Call in a thread context.
	@pre Kernel must be unlocked.
	@pre interrupts enabled
	@pre No fast mutex can be held

	@post Calling thread is in a critical section.
*/
EXPORT_C TInt RPropertyRef::Open(TUid aCategory, TInt aKey)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPropertyRef::Open");			
	__PS_ASSERT(iProp == NULL);
	return TProperty::Open(TUint(aCategory.iUid), aKey, &iProp);
	}

/** Releases the property.

	@pre Calling thread must be in a critical section.
	@pre Call in a thread context.
	@pre Kernel must be unlocked.
	@pre interrupts enabled
	@pre No fast mutex can be held

	@post Calling thread is in a critical section.
*/
EXPORT_C void RPropertyRef::Close()
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPropertyRef::Close");			
	if (iProp)
		{
		iProp->Close();
		iProp = NULL;
		}
	}

/** Defines the attributes and access control for a property.

    This can only be done once for each property.

	Following defintion, the property has a default value:
	- 0 for integer properties
	- zero-length data for byte-array and text properties.
	
	Pending subscriptions for this property will not be completed
	until a new value is published.

	@param aAttr		Bits 0-7 define the property type.
						Upper bits contain additional property attributes.
	@param aReadPolicy  Read policy. Defines the set capabilities that a process 
	                    will require before being allowed to retrieve (read) the
	                    property value.
	@param aWritePolicy Write policy. Defines the set capabilities that a process 
	                    will require before being allowed to publish (write) the
	                    property value.
	@param aPreallocate Pre-allocated buffer size for EByteArray or ELargeByteArray 
	                    property types.
	@param aProcess		If defining a property within the 'system services' category, 
	                    as defined by the KUidSystemCategoryValue UId, then this
	                    is the process whose security attributes will be checked
	                    to see whether it has sufficient authority to perform
	                    this define operation.
						If NULL, these security checks will NOT be performed.

	@return	KErrPermissionDenied, if aProcess doesn't have rights to define this property;
			KErrArgument, if aPreallocate is negative,
			              OR the property type passed to the aAttr argument
			              is greater than or equal to RProperty::ETypeLimit,
			              OR aPreallocate has a non-zero value when the property
			              type is an integer;
			KErrTooBig, if aPreallocate is greater than RProperty::KMaxPropertySize
			            when the property type is RProperty::EByteArray,
			            OR if aPreallocate is greater than RProperty::KMaxLargePropertySize
			            when the property type is RProperty::ELargeByteArray;
			KErrAlreadyExists, if the property has already been defined.

	@pre Calling thread must be in a critical section.
	@pre Property has been opened.
	@pre Call in a thread context.
	@pre Kernel must be unlocked.
	@pre interrupts enabled
	@pre No fast mutex can be held

	@post Calling thread is in a critical section.
	
	@see  RProperty::TType
*/
EXPORT_C TInt RPropertyRef::Define(TInt aAttr, const TSecurityPolicy& aReadPolicy, const TSecurityPolicy& aWritePolicy, TInt aPreallocate, DProcess* aProcess)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPropertyRef::Define");			
	__PS_ASSERT(iProp);
	
	if(aPreallocate < 0)
		return KErrArgument;
	if(aPreallocate > RProperty::KMaxLargePropertySize)
		return KErrTooBig;

	TPropertyInfo info;
	info.iType = (RProperty::TType)(aAttr & RProperty::ETypeMask);
	info.iAttr = (aAttr & ~RProperty::ETypeMask);
	info.iSize = (TUint16) aPreallocate;
	info.iReadPolicy = aReadPolicy;
	info.iWritePolicy = aWritePolicy;
	return iProp->Define(&info, aProcess);
	}

/** Deletes the property.

	Any pending subscriptions for this property will be completed with KErrNotFound.
	Any new request will not complete until the property is defined and published again.

	@param aProcess The process whoes security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNone, if the delete succeeds;
            KErrNotFound, if the property has not been defined;
			KErrPermissionDenied, if aProcess is specified and is not the owner
			of the process.
			
	@pre Calling thread must be in a critical section.
	@pre Property has been opened.
	@pre Call in a thread context.
	@pre Kernel must be unlocked.
	@pre interrupts enabled
	@pre No fast mutex can be held

	@post Calling thread is in a critical section.
*/
	
EXPORT_C TInt RPropertyRef::Delete(DProcess* aProcess)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPropertyRef::Delete");			
	__PS_ASSERT(iProp);
	return iProp->Delete(aProcess);
	}

/** Requests notification when the property is changed.

	If the property has not been defined, the request will not complete until the property
	is defined and published.

	Only one subscription per TPropertySubsRequest object is allowed.

	@param aReq Specifies this request.
	@param aProcess The process whoes security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNone, if the subcribe action succeeds.

	@pre Property has been opened.
*/
EXPORT_C TInt RPropertyRef::Subscribe(TPropertySubsRequest& aReq, DProcess* aProcess)
	{
	__PS_ASSERT(iProp);
	NKern::LockSystem();
	TInt r = iProp->Subscribe(&aReq, aProcess);
	__PS_ASSERT(r != KErrInUse);
	return r;
	}

/** Cancels a subscription request originally made with RPropertyRef::Subscribe().

	@param aReq The TPropertySubsRequest object used in the original subscribe request.

	@pre Property has been opened.

	@see RPropertyRef::Subscribe()
*/
EXPORT_C void RPropertyRef::Cancel(TPropertySubsRequest& aReq)
	{
	__PS_ASSERT(iProp);
	NKern::LockSystem();
	iProp->Cancel(&aReq);
	}

/** Retrieves (reads) the value of an integer property.

	@param aValue An integer to hold the returned property value
	@param aProcess The process whose security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNotFound, if the property has not been defined;
			KErrPermissionDenied, if aProcess does not have the read capabilities;
			KErrArgument, if the property is not of type EInt;
			KErrNone, if the property was read succesfully.

	@pre Property has been opened.

	@realtime
*/
EXPORT_C TInt RPropertyRef::Get(TInt& aValue, DProcess* aProcess)
	{
	__PS_ASSERT(iProp);
	NKern::LockSystem();
	return iProp->GetI(&aValue, aProcess);
	}

/** Publishes (writes) the value of an integer property.

	@param aValue The new value for the property.
	@param aProcess The process whose security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNotFound, if the property has not been defined;
			KErrPermissionDenied, if aProcess does not have the write capabilities;
			KErrArgument, if the property is not of type EInt;
			KErrNone, if the property was set succesfully.

	@pre Property has been opened.

	@realtime
*/
EXPORT_C TInt RPropertyRef::Set(TInt aValue, DProcess* aProcess)
	{
	__PS_ASSERT(iProp);
	NKern::LockSystem();
	return iProp->SetI(aValue, aProcess);
	}
	
/** Retrieves (reads) the value of a binary property.

	@param aDes A descriptor to hold the returned property value.
	@param aProcess The process whose security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNotFound, if the property has not been defined;
			KErrPermissionDenied, if aProcess does not have the read capabilities;
			KErrArgument, if the property is not of type EByteArray;
			KErrOverflow, if the property is larger than the maximum size of aDes,
            in which case aDes is filled with as much of the property value that will fit;
			KErrNone, if the property was read succesfully.

	@pre Property has been opened.

	@realtime There are real time guarantees if the property is not large.
*/
EXPORT_C TInt RPropertyRef::Get(TDes8& aDes, DProcess* aProcess)
	{
	__PS_ASSERT(iProp);
	TInt size = aDes.MaxSize();
	NKern::LockSystem();
	TInt r = iProp->GetB((TUint8*) aDes.Ptr(), &size, aProcess, EFalse);
	if ((r == KErrNone) || (r == KErrOverflow))
		{
		aDes.SetLength(size);
		}
	return r;
	}

/** Publishes (writes) the value of a binary property.

	@param aDes The new value for the property.
	@param aProcess The process whoes security attributes will be used for security checks.
					If NULL the security checks will not be performed.

	@return KErrNotFound, if the property has not been defined;
			KErrPermissionDenied, if aProcess does not have the write capabilities;
			KErrArgument, if the property is not of type EByteArray;
			KErrTooBig, if the property is larger than KMaxPropertySize;
			KErrNone, if the property was set succesfully.

	@pre Property has been opened.

	@realtime There are realtime guarantees if the property is not large
	          and the size is not greater than the previously published value.
*/
EXPORT_C TInt RPropertyRef::Set(const TDesC8& aDes, DProcess* aProcess)
	{
	__PS_ASSERT(iProp);
	NKern::LockSystem();
	return iProp->SetB((TUint8*) aDes.Ptr(), aDes.Size(), aProcess, EFalse);
	}

/** Gets property status information.
	
	@param aStatus property status output.

	@return ETrue if the property is defined; otherwise, EFalse.

	@pre System must be locked.
	@pre Property has been opened.

	@post System is locked.
*/
EXPORT_C TBool RPropertyRef::GetStatus(TPropertyStatus& aStatus)
	{
	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"RPropertyRef::GetStatus");			
	__PS_ASSERT(iProp);
	aStatus.iType			= iProp->Type();
	aStatus.iAttr			= 0;
	aStatus.iOwner			= iProp->Owner();
	return iProp->IsDefined();
	}
