1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // \e32\kernel\sproperty.cpp

    15 // 

    16 //

    17 

    18 #include <kernel/kern_priv.h>

    19 #include "execs.h"

    20 

    21 #define __PS_ASSERT(aCond) \

    22 	__ASSERT_DEBUG( (aCond), ( \

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

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

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

    26 

    27 inline DProcess* CurProcess()

    28 	{

    29 	return TheCurrentThread->iOwningProcess;

    30 	}

    31 

    32 class TProperty 

    33 	{

    34 public:

    35 	static TInt Init();

    36 

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

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

    39 	void Close();

    40 

    41 	TInt Define(const TPropertyInfo*, DProcess*);

    42 	TInt Delete(DProcess*);

    43 

    44 	TInt Subscribe(TPropertySubsRequest* aSubs, DProcess*);

    45 	void Cancel(TPropertySubsRequest* aSubs);

    46 

    47 	TInt GetI(TInt* aValue, DProcess*);

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

    49 	TInt SetI(TInt aValue, DProcess*);

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

    51 

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

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

    54 

    55 	// Called with system or feature locked

    56 	TBool IsDefined()

    57 		{

    58 		return iType != RProperty::ETypeLimit;

    59 		}

    60 

    61 	// Called with system or feature locked

    62 	RProperty::TType Type()

    63 		{

    64 		return (RProperty::TType) iType;

    65 		}

    66 

    67 	// Called with system or feature locked

    68 	TInt BufSize()

    69 		{

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

    71 		return iBuf ? iBuf->iBufSize : 0;

    72 		}

    73 

    74 

    75 	// The property attributes.

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

    77 	// Constant while the property is defined

    78 	TUint32	Owner()

    79 		{ return iOwner; }

    80 

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

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

    83 

    84 	/// Unlock source pages again

    85 	static void UnlockSourcePages();

    86 

    87 #ifdef _DEBUG

    88 	static TBool IsLocked()

    89 		// used in assertions only

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

    91 #endif

    92 

    93 public:

    94 	const TUint		iCategory;

    95 	const TUint		iKey;

    96 

    97 private:

    98 	// Acquire the feature lock

    99 	// Called in CS

   100 	static void Lock()

   101 		{

   102 		Kern::MutexWait(*FeatureLock);

   103 		}

   104 

   105 	// Release the feature lock

   106 	// Called in CS

   107 	static void Unlock()

   108 		{

   109 		Kern::MutexSignal(*FeatureLock);

   110 		}

   111 

   112 	static void CompleteRequest(TPropertySubsRequest*, TInt aReason);	

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

   114 	static void CompleteDfc(TAny* aQue);

   115 

   116 	static TUint Hash(TUint aCategory, TUint aKey);

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

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

   119 

   120 	TAny* operator new(TUint aSize) __NO_THROW

   121 		{ return Kern::AllocZ(aSize); }

   122 

   123 	TProperty(TUint aCategory, TUint aKey);

   124 

   125 	void SetNotDefined()

   126 		{ iType = RProperty::ETypeLimit; }

   127 

   128 	inline void Use();

   129 	void Release();

   130 

   131 	void CompleteByDfc();

   132 

   133 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

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

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

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

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

   138 #endif //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   139 	TBool DoCheckDeleteRights(DProcess* aProcess);

   140 	TBool DoCheckDefineRights(DProcess* aProcess);

   141 	TBool DoCheckGetRights(DProcess* aProcess);

   142 	TBool DoCheckSetRights(DProcess* aProcess);

   143 

   144 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

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

   146 		{

   147 		return DoCheckDeleteRights(aProcess, aDiagnostic);

   148 		}

   149 

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

   151 		{

   152 		return DoCheckDefineRights(aProcess, aDiagnostic);

   153 		}

   154 

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

   156 		{

   157 		return DoCheckGetRights(aProcess, aDiagnostic);

   158 		}

   159 

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

   161 		{

   162 		return DoCheckSetRights(aProcess, aDiagnostic);

   163 		}

   164 

   165 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   166 	// Only available to NULL arguments

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

   168 		{

   169 		return DoCheckDeleteRights(aProcess);

   170 		}

   171 

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

   173 		{

   174 		return DoCheckDefineRights(aProcess);

   175 		}

   176 

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

   178 		{

   179 		return DoCheckGetRights(aProcess);

   180 		}

   181 

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

   183 		{

   184 		return DoCheckSetRights(aProcess);

   185 		}

   186 

   187 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   188 

   189 	enum { KCompletionDfcPriority = 2 };

   190 	static TDfc		CompletionDfc;

   191 	// subscriptions to be completed by the DFC

   192 	static SDblQue	CompletionQue;		// protected by the system lock

   193 

   194 	static DMutex*	FeatureLock;			///< Order KMutexOrdPubSub

   195 

   196 	// hash table collision lists

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

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

   199 	

   200 #ifdef __DEMAND_PAGING__

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

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

   203 #endif

   204 	

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

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

   207 					// reads require only one of them

   208 	// The property attributes.

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

   210 	// Constant while the property is defined

   211 	TUint8	iAttr;

   212 	TCompiledSecurityPolicy iReadPolicy;

   213 	TCompiledSecurityPolicy iWritePolicy;

   214 	TUint32	iOwner;

   215 

   216 	TUint		iRefCount;	// protected by the feature lock

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

   218 							//		protected by the feature lock

   219 

   220 	class TBuf

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

   222 	public:

   223 		static TBuf* New(TInt aSize);

   224 

   225 		TUint16	iBufSize;		// buffer size - constant

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

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

   228 		};

   229 

   230 	// The property value

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

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

   233 		{ 

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

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

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

   237 		TInt	iValue;

   238 		};

   239 

   240 	// Called with system or feature locked

   241 	TInt Size()

   242 		{

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

   244 		return iBuf ? iBuf->iSize : 0;

   245 		}

   246 

   247 	// Called with system or feature locked

   248 	TUint8* Buf()

   249 		{

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

   251 		return iBuf ? iBuf->iBytes : NULL;

   252 		}

   253 

   254 	// Called with system or feature locked

   255 	void SetSize(TInt aSize)

   256 		{

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

   258 		if (iBuf)

   259 			iBuf->iSize = TUint16(aSize);

   260 		}

   261 

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

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

   264 

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

   266 	};

   267 

   268 

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

   270 SDblQue		TProperty::CompletionQue;

   271 DMutex*		TProperty::FeatureLock;	

   272 TProperty*	TProperty::Table[KHashTableLimit];

   273 

   274 #ifdef __DEMAND_PAGING__

   275 DMutex*		TProperty::PagingLockMutex;

   276 DDemandPagingLock* TProperty::PagingLock;

   277 _LIT(KPubSubMutexName2, "PropertyPagingLockMutex");

   278 #endif

   279 

   280 TInt PubSubPropertyInit()

   281 	{ return TProperty::Init(); }

   282 

   283 _LIT(KPubSubMutexName, "PropertyLock");

   284 

   285 TInt TProperty::Init()

   286 	{ // static

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

   288 	if (r != KErrNone)

   289 		return r;

   290 	CompletionDfc.SetDfcQ(K::SvMsgQ);

   291 	

   292 #ifdef __DEMAND_PAGING__	

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

   294 	if (r != KErrNone)

   295 		return r;

   296 	PagingLock = new DDemandPagingLock();

   297 	if (!PagingLock)

   298 		return KErrNoMemory;

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

   300 	if (r != KErrNone)

   301 		return r;

   302 #endif

   303 	

   304 	return KErrNone;

   305 	}

   306 

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

   308 	{ SetNotDefined(); }

   309 

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

   311 	{ // a naive hash function 

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

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

   314 	return code;

   315 	}

   316 

   317 // Called feature locked.

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

   319 	{ // static

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

   321 	for (;;)

   322 		{

   323 		TProperty* prop = *propP;

   324 		if (!prop) break;

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

   326 		propP = &prop->iNext;

   327 		}

   328 	return propP;

   329 	}

   330 

   331 // Called feature locked.

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

   333 	{ // static

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

   335 	TProperty* prop = *propP;

   336 	if (!prop)

   337 		{

   338 		prop = new TProperty(aCategory, aKey);

   339 		if (!prop)

   340 			{

   341 			return KErrNoMemory;

   342 			}

   343 		*propP = prop;			

   344 		}

   345 	*aProp = prop;

   346 	return KErrNone;

   347 	}

   348 

   349 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

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

   351 	{

   352 	TUint32 cat=iCategory;

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

   354 		return ETrue;

   355 	if(cat<(TUint32)KUidSecurityThresholdCategoryValue)

   356 		return aProcess->HasCapability(ECapabilityWriteDeviceData, aDiagnostic);

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

   358 	return EFalse;

   359 	}

   360 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   361 

   362 TBool TProperty::DoCheckDefineRights(DProcess* aProcess)

   363 	{

   364 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   365 	return DoCheckDefineRights(aProcess, NULL);

   366 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   367 	TUint32 cat=iCategory;

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

   369 		return ETrue;

   370 	if(cat<(TUint32)KUidSecurityThresholdCategoryValue)

   371 		return aProcess->HasCapability(ECapabilityWriteDeviceData);

   372 	return EFalse;

   373 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   374 	}

   375 

   376 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   377 // Called feature locked

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

   379 	{

   380 	__ASSERT_MUTEX(FeatureLock);

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

   382 		{

   383 		return ETrue;

   384 		}

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

   386 	return EFalse;

   387 	}

   388 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   389 

   390 TBool TProperty::DoCheckDeleteRights(DProcess* aProcess)

   391 	{

   392 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   393 	return DoCheckDeleteRights(aProcess, NULL);

   394 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   395 	__ASSERT_MUTEX(FeatureLock);

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

   397 		{

   398 		return ETrue;

   399 		}

   400 	return EFalse;

   401 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   402 	}

   403 

   404 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   405 // Called system locked

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

   407 	{

   408 	return iReadPolicy.CheckPolicy(aProcess, aDiagnostic);

   409 	}

   410 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   411 

   412 TBool TProperty::DoCheckGetRights(DProcess* aProcess)

   413 	{

   414 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   415 	return DoCheckGetRights(aProcess, NULL);

   416 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   417 	return iReadPolicy.CheckPolicy(aProcess);

   418 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   419 	}

   420 

   421 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   422 // Called system locked

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

   424 	{

   425 	return iWritePolicy.CheckPolicy(aProcess, aDiagnostic);

   426 	}

   427 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   428 

   429 TBool TProperty::DoCheckSetRights(DProcess* aProcess)

   430 	{

   431 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   432 	return DoCheckSetRights(aProcess, NULL);

   433 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   434 	return iWritePolicy.CheckPolicy(aProcess);

   435 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

   436 	}

   437 

   438 // Called in CS

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

   440 	{ // static

   441 	__ASSERT_CRITICAL;

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

   443 	if (!buf)

   444 		{

   445 		return NULL;

   446 		}

   447 	buf->iBufSize = TUint16(aSize);

   448 	buf->iSize = 0;

   449 	return buf;

   450 	}

   451 

   452 // Called in CS

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

   454 	{

   455 	__ASSERT_CRITICAL;

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

   457 		{

   458 		return KErrPermissionDenied;

   459 		}

   460 	TCompiledSecurityPolicy readPolicy;

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

   462 	if(r != KErrNone)

   463 		{

   464 		return r;

   465 		}

   466 	TCompiledSecurityPolicy writePolicy;

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

   468 	if(r != KErrNone)

   469 		{

   470 		return r;

   471 		}

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

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

   474 		(aInfo->iAttr != 0))

   475 		{

   476 		return KErrArgument;

   477 		}

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

   479 		{

   480 		return KErrTooBig;

   481 		}

   482 	Lock();

   483 	if (IsDefined())

   484 		{

   485 		Unlock();

   486 		return KErrAlreadyExists;

   487 		}

   488 	if (aInfo->iSize)

   489 		{

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

   491 		__PS_ASSERT(iBuf == NULL);

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

   493 		}

   494 

   495 	iReadPolicy = readPolicy;

   496 	iWritePolicy = writePolicy;

   497 	iOwner = CurProcess()->iS.iSecureId;

   498 	iAttr = 0;

   499 

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

   501 	// complete those that havn't.

   502 	// We have the following constraints:

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

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

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

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

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

   508 	// two temporary queues:

   509 	//	'localPendingQue' for entries that will remain pending

   510 	//	'localCompletionQue' for entries that will be completed

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

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

   513 	// queue becomes empty.

   514 	//

   515 	SDblQue localPendingQue;	// protected by the system lock

   516 	SDblQue localCompletionQue;	// protected by the system lock

   517 	NKern::LockSystem();

   518 	while (!iPendingQue.IsEmpty())

   519 		{

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

   521 		DProcess* process = subs->iProcess;

   522 		subs->iProcess = NULL;

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

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

   525 			localCompletionQue.Add(subs);

   526 			}

   527 		else

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

   529 			localPendingQue.Add(subs);

   530 			}

   531 		NKern::FlashSystem();	// preemption point

   532 		}

   533 	iPendingQue.MoveFrom(&localPendingQue);

   534 	iType = (TUint8) aInfo->iType;

   535 	NKern::UnlockSystem();

   536 	// Now the property can be accessed by other threads.

   537 	Use();

   538 	Unlock();

   539 	// Now we can complete requests.

   540 	CompleteQue(&localCompletionQue, KErrPermissionDenied);

   541 	return KErrNone;

   542 	}

   543 

   544 // Called in CS

   545 TInt TProperty::Attach(TUint aCategory, TUint aKey, TProperty** aProp)

   546 	{ //static 

   547 	Lock();

   548 	TProperty* prop;

   549 	// Attach can create a non defined property.

   550 	TInt r = LookupOrCreate(aCategory, aKey, &prop);

   551 	if (r != KErrNone) 

   552 		{

   553 		Unlock();

   554 		return r;

   555 		}

   556 	prop->Use();

   557 	*aProp = prop;

   558 	Unlock();

   559 	return KErrNone;

   560 	}

   561 

   562 // Called in CS

   563 TInt TProperty::Open(TUint aCategory, TUint aKey, TProperty** aProp)

   564 	{ //static 

   565 	Lock();

   566 	TProperty* prop = *Lookup(aCategory, aKey);

   567 	if (!prop) 

   568 		{

   569 		Unlock();

   570 		return KErrNotFound;

   571 		}

   572 	prop->Use();

   573 	*aProp = prop;

   574 	Unlock();

   575 	return KErrNone;

   576 	}

   577 

   578 // Called in CS

   579 void TProperty::Close()

   580 	{

   581 	Lock();

   582 	Release();

   583 	// '*this' may do not exist any more

   584 	Unlock();

   585 	}

   586 

   587 // Called in CS

   588 TInt TProperty::Delete(DProcess* aProcess)

   589 	{

   590 	Lock();

   591 	if (!IsDefined())

   592 		{

   593 		Unlock();

   594 		return KErrNotFound;

   595 		}

   596 	if (aProcess && !CheckDeleteRights(aProcess,__PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Delete a Publish and Subscribe Property")))

   597 		{

   598 		Unlock();

   599 		return KErrPermissionDenied;

   600 		}

   601 	NKern::LockSystem();

   602 	// Remember that iType is the tag of iBuf and iValue union

   603 	TBuf* buf = (iType != RProperty::EInt) ? iBuf : NULL;

   604 	SetNotDefined();

   605 	// Down from here nobody can access the property value

   606 

   607 	// We don't want to complete requests holding the feature lock. 

   608 	SDblQue localQue;

   609 	localQue.MoveFrom(&iPendingQue);

   610 

   611 	NKern::UnlockSystem();

   612 

   613 	iBuf = NULL;

   614 	iValue = 0;

   615 	delete buf;

   616 	Release();

   617 	// '*this' may do not exist any more

   618 	Unlock();

   619 	 // Now we can complete.

   620 	CompleteQue(&localQue, KErrNotFound);

   621 	return KErrNone;

   622 	}

   623 

   624 // Enter feature locked.

   625 // Return feature locked.

   626 inline void TProperty::Use()

   627 	{

   628 	__ASSERT_MUTEX(FeatureLock);

   629 	++iRefCount;

   630 	}

   631 

   632 // Enter feature locked.

   633 // Return feature locked.

   634 void TProperty::Release()

   635 	{

   636 	__ASSERT_MUTEX(FeatureLock);

   637 	__PS_ASSERT(iRefCount);

   638 	if (--iRefCount == 0)

   639 		{

   640 		__PS_ASSERT(!IsDefined()); // property must not be defined.

   641 		// Lookup to find the previous element in the simply linked collision list.

   642 		TProperty** propP = Lookup(iCategory, iKey);

   643 		*propP = iNext;

   644 		delete this;

   645 		}

   646 	}

   647 

   648 // Enter system locked.

   649 // Return system unlocked.

   650 TInt TProperty::Subscribe(TPropertySubsRequest* aSubs, DProcess* aProcess)

   651 	{

   652 	__ASSERT_SYSTEM_LOCK;

   653 	if (aSubs->iNext)

   654 		{ // already pending - will Panic

   655 		NKern::UnlockSystem();

   656 		return KErrInUse;

   657 		}

   658 	TBool defined = IsDefined();

   659 	if (defined)

   660 		{ // property is defined - check access now

   661 		aSubs->iProcess = NULL;	

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

   663 			{

   664 			NKern::ThreadEnterCS();

   665 			CompleteRequest(aSubs, KErrPermissionDenied);

   666 			NKern::ThreadLeaveCS();

   667 			return KErrNone;

   668 			}

   669 		}	

   670 	else

   671 		{ // will check when defined

   672 		aSubs->iProcess = aProcess;

   673 		}

   674 	iPendingQue.Add(aSubs);

   675 	NKern::UnlockSystem();

   676 	return KErrNone;

   677 	}

   678 

   679 // Enter system locked.

   680 // Return system unlocked.

   681 void TProperty::Cancel(TPropertySubsRequest* aSubs)

   682 	{

   683 	__ASSERT_SYSTEM_LOCK;

   684 	if (!aSubs->iNext)

   685 		{ // not pending - silently return

   686 		NKern::UnlockSystem();	

   687 		return;

   688 		}

   689 	aSubs->Deque();

   690 	aSubs->iNext = NULL;

   691 	aSubs->iProcess = NULL;

   692 	NKern::ThreadEnterCS();

   693 	CompleteRequest(aSubs, KErrCancel);

   694 	NKern::ThreadLeaveCS();

   695 	}

   696 

   697 // Enter system locked.

   698 // Return system unlocked.

   699 // Called in CS or a DFC context

   700 void TProperty::CompleteRequest(TPropertySubsRequest* aSubs, TInt aResult)

   701 	{ // static

   702 	__ASSERT_SYSTEM_LOCK;

   703 	__ASSERT_CRITICAL;

   704 	TPropertyCompleteFn	fn = aSubs->iCompleteFn;

   705 	TAny* ptr = aSubs->iPtr;

   706 	NKern::UnlockSystem();

   707 	(*fn)(ptr, aResult);

   708 	}

   709 

   710 // Called in CS or a DFC context

   711 void TProperty::CompleteQue(SDblQue* aQue, TInt aReason)

   712 	{ // static

   713 	__ASSERT_CRITICAL;

   714 	NKern::LockSystem();

   715 	while (!aQue->IsEmpty())

   716 		{ 

   717 		TPropertySubsRequest* subs = (TPropertySubsRequest*) aQue->First();

   718 		subs->Deque();

   719 		subs->iNext = NULL;

   720 		CompleteRequest(subs, aReason);

   721 		NKern::LockSystem();

   722 		}	 

   723 	NKern::UnlockSystem();

   724 	}

   725 

   726 // Executed in DFC context

   727 void TProperty::CompleteDfc(TAny* aQue)

   728 	{ // static

   729 	CompleteQue((SDblQue*) aQue, KErrNone);

   730 	}

   731 

   732 // Enter system locked.

   733 // Return system unlocked.

   734 void TProperty::CompleteByDfc()

   735 	{

   736 	__ASSERT_SYSTEM_LOCK;

   737 	// Append elements from the pending queue to the completion queue

   738 	if (!iPendingQue.IsEmpty())

   739 		{

   740 		CompletionQue.MoveFrom(&iPendingQue);

   741 		CompletionDfc.Enque(SYSTEM_LOCK);

   742 		}

   743 	else 

   744 		{

   745 		NKern::UnlockSystem();

   746 		}

   747 	}

   748 	

   749 // Enter system locked.

   750 // Return system unlocked.

   751 TInt TProperty::GetI(TInt* aValue, DProcess* aProcess)

   752 	{

   753 	__ASSERT_SYSTEM_LOCK;

   754 	if (!IsDefined())

   755 		{

   756 		NKern::UnlockSystem();

   757 		return KErrNotFound;

   758 		}

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

   760 		{

   761 		NKern::UnlockSystem();

   762 		return KErrPermissionDenied;

   763 		}

   764 	if (iType != RProperty::EInt)

   765 		{

   766 		NKern::UnlockSystem();

   767 		return KErrArgument;

   768 		}

   769 	*aValue = iValue;

   770 	NKern::UnlockSystem();

   771 	return KErrNone;

   772 	}

   773 

   774 TInt TProperty::FindGetI(TUint aCategory, TUint aKey, TInt* aValue, DProcess* aProcess)

   775 	{

   776 	Lock();

   777 	TProperty* prop = *TProperty::Lookup(aCategory, aKey);

   778 	TInt r;

   779 	if (!prop) 

   780 		r = KErrNotFound;

   781 	else

   782 		{

   783 		NKern::LockSystem();

   784 		r = prop->GetI(aValue, aProcess);

   785 		}

   786 	Unlock();

   787 	return r;

   788 	}

   789 

   790 TInt TProperty::FindSetI(TUint aCategory, TUint aKey, TInt aValue, DProcess* aProcess)

   791 	{

   792 	Lock();

   793 	TProperty* prop = *TProperty::Lookup(aCategory, aKey);

   794 	TInt r;

   795 	if (!prop) 

   796 		r = KErrNotFound;

   797 	else

   798 		{

   799 		NKern::LockSystem();

   800 		r = prop->SetI(aValue, aProcess);

   801 		}

   802 	Unlock();

   803 	return r;

   804 	}

   805 

   806 #ifdef __EPOC32__

   807 extern "C" { extern void kumemput_no_paging_assert(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/); }

   808 #else

   809 inline void kumemput_no_paging_assert(TAny* aAddr, const TAny* aKernAddr, TInt aLength)

   810 	{kumemput(aAddr,aKernAddr,aLength);}

   811 #endif

   812 

   813 // Enter system locked.

   814 // Return system unlocked.

   815 TInt TProperty::_GetB(TUint8* aBuf, TInt* aSize, DProcess* aProcess, TBool aUser)

   816 	{

   817 	if (!IsDefined())

   818 		{

   819 		NKern::UnlockSystem();

   820 		return KErrNotFound;

   821 		}

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

   823 		{

   824 		NKern::UnlockSystem();

   825 		return KErrPermissionDenied;

   826 		}

   827 	if (iType == RProperty::EInt)

   828 		{

   829 		NKern::UnlockSystem();

   830 		return KErrArgument;

   831 		}

   832 	if (iType == RProperty::ELargeByteArray)

   833 		{

   834 		// copy with system lock released

   835 		__ASSERT_MUTEX(FeatureLock);

   836 		NKern::UnlockSystem();

   837 		}

   838 	TInt bufSize = *aSize;

   839 	TInt size = Size();

   840 	TInt r = KErrNone;

   841 	if (bufSize < size) 

   842 		{

   843 		size = bufSize;

   844 		r = KErrOverflow;

   845 		}

   846 	TUint8* buf = Buf();

   847 	if (aUser)

   848 		{ // Don't use 'r' to preserve possible KErrOverflow condition

   849 		XTRAPD(res, XT_DEFAULT, kumemput_no_paging_assert(aBuf, buf, size));

   850 		if (res != KErrNone)

   851 			r = KErrBadDescriptor;

   852 		}

   853 	else

   854 		{ 

   855 		memcpy(aBuf, buf, size); 

   856 		}

   857 	*aSize = size;

   858 	if (iType != RProperty::ELargeByteArray)

   859 		{

   860 		NKern::UnlockSystem();

   861 		}

   862 	return r;

   863 	}

   864 

   865 // Enter system locked.

   866 // Return system unlocked.

   867 TInt TProperty::GetB(TUint8* aBuf, TInt* aSize, DProcess* aProcess, TBool aUser)

   868 	{

   869 	__ASSERT_SYSTEM_LOCK;

   870 	if (iType != RProperty::ELargeByteArray)

   871 		return _GetB(aBuf,aSize,aProcess,aUser);

   872 

   873 	// Acquire feature lock for accessing large properties

   874 	NKern::ThreadEnterCS();

   875 	FeatureLock->Wait();	// returns with system lock still held

   876 	TInt r = _GetB(aBuf,aSize,aProcess,aUser);

   877 	Unlock();

   878 	NKern::ThreadLeaveCS();

   879 	return r;

   880 	}

   881 

   882 // Enter system locked.

   883 // Return system unlocked.

   884 TInt TProperty::SetI(TInt aValue, DProcess* aProcess)

   885 	{

   886 	__ASSERT_SYSTEM_LOCK;

   887 	if (!IsDefined())

   888 		{

   889 		NKern::UnlockSystem();

   890 		return KErrNotFound;

   891 		}

   892 	if (aProcess && !CheckSetRights(aProcess, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Set a Publish and Subscribe Property")))

   893 		{

   894 		NKern::UnlockSystem();

   895 		return KErrPermissionDenied;

   896 		}

   897 	if (iType != RProperty::EInt)

   898 		{

   899 		NKern::UnlockSystem();

   900 		return KErrArgument;

   901 		}

   902 	iValue = aValue;

   903 	CompleteByDfc();

   904 	return KErrNone;

   905 	}

   906 

   907 

   908 #ifdef __EPOC32__

   909 extern "C" { extern void kumemget_no_paging_assert(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/); }

   910 #else

   911 inline void kumemget_no_paging_assert(TAny* aKernAddr, const TAny* aAddr, TInt aLength)

   912 	{kumemget(aKernAddr,aAddr,aLength);}

   913 #endif

   914 

   915 // Enter with system locked.

   916 // Return system unlocked.

   917 TInt TProperty::_SetB(const TUint8* aBuf, TInt aSize, DProcess* aProcess, TBool aUser, TBuf** aNewBuf)

   918 	{

   919 	if (!IsDefined())

   920 		{

   921 		NKern::UnlockSystem();

   922 		return KErrNotFound;

   923 		}

   924 	if (aProcess && !CheckSetRights(aProcess, __PLATSEC_DIAGNOSTIC_STRING("Checked whilst trying to Set a Publish and Subscribe Property")))

   925 		{

   926 		NKern::UnlockSystem();

   927 		return KErrPermissionDenied;

   928 		}

   929 	if (iType == RProperty::EInt)

   930 		{

   931 		NKern::UnlockSystem();

   932 		return KErrArgument;

   933 		}

   934 	else if (iType == RProperty::EByteArray)

   935 		{

   936 		if (aSize > RProperty::KMaxPropertySize)

   937 			{

   938 			NKern::UnlockSystem();

   939 			return KErrTooBig;

   940 			}

   941 		}

   942 	else if (iType == RProperty::ELargeByteArray)

   943 		{

   944 		__ASSERT_MUTEX(FeatureLock);

   945 		NKern::UnlockSystem();

   946 		if (aSize > RProperty::KMaxLargePropertySize)

   947 			{

   948 			return KErrTooBig;

   949 			}

   950 		}

   951 	if (aSize > BufSize())

   952 		{

   953 		if (aNewBuf == NULL || *aNewBuf == NULL)

   954 			{

   955 			if (iType != RProperty::ELargeByteArray)

   956 				{

   957 				NKern::UnlockSystem();

   958 				}

   959 			return KErrOverflow;

   960 			}

   961 		// New buffer is provided by the caller - switch on it

   962 		TBuf* oldBuf = iBuf;

   963 		iBuf = *aNewBuf;

   964 		// Caller will deallocate the old buffer out of the system lock context

   965 		*aNewBuf = oldBuf;

   966 		}

   967 	if (aUser)

   968 		{

   969 		__NK_ASSERT_DEBUG(iType==RProperty::ELargeByteArray);

   970 		XTRAPD(r, XT_DEFAULT, kumemget_no_paging_assert(Buf(), aBuf, aSize));

   971 		if (r != KErrNone)

   972 			return KErrBadDescriptor;

   973 		}

   974 	else

   975 		{

   976 		memcpy(Buf(), aBuf, aSize); 

   977 		}

   978 	SetSize(aSize);

   979 	if (iType == RProperty::ELargeByteArray)

   980 		{

   981 		NKern::LockSystem();

   982 		}

   983 	CompleteByDfc();

   984 	return KErrNone;

   985 	}

   986 

   987 // Enter system locked.

   988 // Return system unlocked.

   989 TInt TProperty::SetB(const TUint8* aBuf, TInt aSize, DProcess* aProcess, TBool aUser)

   990 	{ // static

   991 	__ASSERT_SYSTEM_LOCK;

   992 	TBuf* nBuf = 0;

   993 	if (iType != RProperty::ELargeByteArray)

   994 		{

   995 		// Try to set without buffer reallocation (ie. "RT") first

   996 		TInt r = _SetB(aBuf, aSize, aProcess, aUser, NULL);

   997 		if (r != KErrOverflow)

   998 			return r;

   999 

  1000 		// Needs buffer reallocation

  1001 		NKern::ThreadEnterCS();

  1002 		// Allocate a new buffer

  1003 		nBuf = TBuf::New(aSize);

  1004 		if (!nBuf)

  1005 			{

  1006 			NKern::ThreadLeaveCS();

  1007 			return KErrNoMemory;

  1008 			}

  1009 		NKern::LockSystem();

  1010 		

  1011 		r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);

  1012 		// May be the old buffer (or NULL), may be the new one (if wasn't used)

  1013 		delete nBuf;

  1014 		NKern::ThreadLeaveCS();

  1015 		return r;

  1016 		}

  1017 	

  1018 	NKern::ThreadEnterCS();

  1019 

  1020 	// Large property - need feature lock

  1021 	FeatureLock->Wait();

  1022 	TInt r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);

  1023 	if (r == KErrOverflow)

  1024 		{

  1025 		// Allocate a new buffer

  1026 		nBuf = TBuf::New(aSize);

  1027 		if (!nBuf)

  1028 			r = KErrNoMemory;

  1029 		else

  1030 			{

  1031 			NKern::LockSystem();

  1032 			r = _SetB(aBuf, aSize, aProcess, aUser, &nBuf);

  1033 			}

  1034 		}

  1035 	Unlock();

  1036 	// May be the old buffer (or NULL), may be the new one (if wasn't used)

  1037 	delete nBuf;

  1038 	NKern::ThreadLeaveCS();

  1039 	return r;

  1040 	}

  1041 

  1042 #ifdef __DEMAND_PAGING__

  1043 

  1044 TInt TProperty::LockSourcePages(const TUint8* aBuf, TInt aSize)

  1045 	{

  1046 	// When copying from user RAM we must lock the source data in case it is demand paged, otherwise

  1047 	// we could get a mutex ordering voliation when waiting on the demand paging mutex

  1048 	__ASSERT_CRITICAL;

  1049 	Kern::MutexWait(*PagingLockMutex);

  1050 	TInt r = PagingLock->Lock(TheCurrentThread, (TLinAddr)aBuf, aSize);

  1051 	if(r>=0)

  1052 		return KErrNone;

  1053 	Kern::MutexSignal(*PagingLockMutex);

  1054 	return r;

  1055 	}

  1056 

  1057 void TProperty::UnlockSourcePages()

  1058 	{

  1059 	__ASSERT_CRITICAL;

  1060 	PagingLock->Unlock();

  1061 	Kern::MutexSignal(*PagingLockMutex);

  1062 	}

  1063 

  1064 #else

  1065 

  1066 TInt TProperty::LockSourcePages(const TUint8*, TInt)

  1067 	{

  1068 	return KErrNone;

  1069 	}

  1070 

  1071 void TProperty::UnlockSourcePages()

  1072 	{

  1073 	}

  1074 

  1075 #endif

  1076 

  1077 //

  1078 // User Interface

  1079 //

  1080 	

  1081 class DPropertyRef : public DObject

  1082 	{

  1083 public:

  1084 

  1085 	static TInt Define(TUint aCategory, TUint aKey, const TPropertyInfo*);

  1086 	static TInt Delete(TUint aCategory, TUint aKey);

  1087 	static TInt Attach(TUint aCategory, TUint aKey, TOwnerType aType);

  1088 

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

  1090 	static TInt FindSetI(TUint aCategory, TUint aKey, TInt aValue);

  1091 

  1092 	DPropertyRef();

  1093 	~DPropertyRef();

  1094 

  1095 	TInt Subscribe(TRequestStatus* aStatus);

  1096 	inline void Cancel();

  1097 

  1098 	inline TInt GetI(TInt* aValue);

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

  1100 	inline TInt SetI(TInt aValue);

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

  1102 

  1103 	inline RProperty::TType Type()

  1104 		{ return iProp->Type(); }

  1105 private:

  1106 

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

  1108 

  1109 	TProperty*				iProp;

  1110 	TClientRequest*			iRequest;

  1111 	DThread*				iClient;

  1112 	TPropertySubsRequest	iSubs;

  1113 	};

  1114 

  1115 DPropertyRef::DPropertyRef() : iSubs(CompleteFn, this)

  1116 	{

  1117 	}

  1118 

  1119 // Called in CS

  1120 TInt DPropertyRef::Define(TUint aCategory, TUint aKey, const TPropertyInfo* aInfo)

  1121 	{ // static

  1122 	__ASSERT_CRITICAL;

  1123 	TProperty* prop;

  1124 	TInt r = TProperty::Attach(aCategory, aKey, &prop);

  1125 	if (r != KErrNone)

  1126 		{

  1127 		return r;

  1128 		}

  1129 	r = prop->Define(aInfo, CurProcess());

  1130 	prop->Close();

  1131 	return r;

  1132 	}

  1133 

  1134 // Called in CS