// 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\euser\us_property.cpp

 // 

 //

 #include "us_std.h"

 /**

 Defines a property with the specified category ID.  This method should only be

 used to specify a category different from the creating process's secure ID in 

 exceptional circumstances.  In most cases the overload:

 RProperty::Define(TUint aKey, TInt aAttr, const TSecurityPolicy& aReadPolicy, const TSecurityPolicy& aWritePolicy, TInt aPreallocate)

 should be used.  For details see the document located at:

 Symbian OS guide » Base » Using User Library (E32) » Publish and Subscribe » Security issues

 Defines the attributes and access control for a property. This can only be done 

 once for each property. Subsequent attempts to define the same property will return

 KErrAlreadyExists.

 Only processes with the write-system-data capability are allowed to define 

 properties either in the system category (KUidSystemCategory) or with 

 aCategory < KUidSecurityThresholdCategoryValue. Any attempt to define 

 a property with these categories by a process with insufficient capabilities 

 will fail with a KErrPermissionDenied error.

 Following the property's definition, it will have a default value, 0 for integer

 properties and 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 aCategory    The UID that identifies the property category.

 					This must either be the current process's Secure ID, or

 					KUidSystemCategoryValue.

 @param aKey         The property sub-key, i.e. the key that identifies the

                     specific property within the category.

 @param aAttr        This describes the property type, a TType value;

                     persistence, as defined by the KPersistent bit, may

                     be ORed in.

 @param aReadPolicy	A security policy defining the security attributes a

 					process must have in order to read this value.

 @param aWritePolicy	A security policy defining the security attributes a

 					process must have in order to write this value.

 @param aPreallocate The number of bytes to be pre-allocated for variable

                     sized properties. Pre-allocating enough space ensures that

                     a variable sized property can be set in 'real-time', 

                     (i.e. the time to set the property is bounded). 

 @return KErrNone, if successful;

         KErrArgument, if the wrong type or attribute was specified;

         KErrArgument, if aType is TInt and aPreallocate is not 0;

         KErrTooBig, if aPreallocate is greater than KMaxPropertySize;

         KErrPermissionDenied, if an attempt is made to define a property in

         the system category by a process with insufficient capabilities, or

 		the category secified wasn't the same as the current process's Secure ID.

 @capability WriteDeviceData if aCategory==KUidSystemCategoryValue.

 @capability WriteDeviceData if aCategory not equal to the current process's

 			Secure ID and aCategory<KUidSecurityThresholdCategoryValue.

 @see KUidSecurityThresholdCategoryValue

 @publishedPartner

 @released

 */

 EXPORT_C TInt RProperty::Define(TUid aCategory, TUint aKey, TInt aAttr, const TSecurityPolicy& aReadPolicy, const TSecurityPolicy& aWritePolicy, TInt aPreallocate)

 	{

 	if(aPreallocate < 0)

 		return KErrArgument;

 	if(aPreallocate > 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(Exec::PropertyDefine(TUint(aCategory.iUid), aKey, &info));

 	}

 /**

 Defines a property.

 Defines the attributes and access control for a property. This can only be done 

 once for each property. Subsequent attempts to define the same property will return

 KErrAlreadyExists.

 The category ID for the property will be the same as the current processes Secure ID.

 Following the property's definition, it will have a default value, 0 for integer

 properties and 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 aKey         The property sub-key, i.e. the key that identifies the

                     specific property within the category.

 @param aAttr        This describes the property type, a TType value;

                     persistence, as defined by the KPersistent bit, may

                     be ORed in.

 @param aReadPolicy	A security policy defining the security attributes a

 					process must have in order to read this value.

 @param aWritePolicy	A security policy defining the security attributes a

 					process must have in order to write this value.

 @param aPreallocate The number of bytes to be pre-allocated for variable

                     sized properties. Pre-allocating enough space ensures that

                     a variable sized property can be set in 'real-time', 

                     (i.e. the time to set the property is bounded). 

 @return KErrNone, if successful;

         KErrArgument, if the wrong type or attribute was specified;

         KErrArgument, if aType is TInt and aPreallocate is not 0;

         KErrTooBig, if aPreallocate is greater than KMaxPropertySize;

 @publishedPartner

 @released

 */

 EXPORT_C TInt RProperty::Define(TUint aKey, TInt aAttr, const TSecurityPolicy& aReadPolicy, const TSecurityPolicy& aWritePolicy, TInt aPreallocate)

 	{

 	TUid category = {-1}; 

 	return Define(category, aKey, aAttr, aReadPolicy, aWritePolicy, aPreallocate);

 	}

 /**

 NOTE - The use of this method is deprecated.

 Defines a property with the specified category ID.  This method should only be

 used to specify a category different from the creating process's secure ID in 

 exceptional circumstances.  In most cases the overload:

 RProperty::Define(TUint aKey, TInt aAttr, const TSecurityPolicy& aReadPolicy, const TSecurityPolicy& aWritePolicy, TInt aPreallocate)

 should be used.  For details see the document located at:

 Symbian OS guide » Base » Using User Library (E32) » Publish and Subscribe » Security issues

 Defines the attributes and access control for a property. This can only be done

 once for each property. Subsequent attempts to define the same property will 

 return KErrAlreadyExists.

 Only processes with the write-system-data capability are allowed to define 

 properties either in the system category (KUidSystemCategory) or with 

 aCategory < KUidSecurityThresholdCategoryValue. Any attempt to define 

 a property with these categories by a process with insufficient capabilities 

 will fail with a KErrPermissionDenied error.

 Following the property's definition, it will have a default value, 0 for integer

 properties and 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 aCategory    The UID that identifies the property category.

 @param aKey         The property sub-key, i.e. the key that identifies the

                     specific property within the category.

 @param aAttr        This describes the property type, a TType value;

                     persistence, as defined by the KPersistent bit, may

                     be ORed in.

 @param aPreallocate The number of bytes to be pre-allocated for variable

                     sized properties. Pre-allocating enough space ensures that

                     a variable sized property can be set in 'real-time', 

                     (i.e. the time to set the property is bounded). 

 @return KErrNone, if successful;

         KErrArgument, if the wrong type or attribute was specified;

         KErrArgument, if aType is TInt and aPreallocate is not 0;

         KErrTooBig, if aPreallocate is greater than KMaxPropertySize;

         KErrPermissionDenied, if an attempt is made to define a property in

         the system category by a process with insufficient capabilities. 

 @capability WriteDeviceData if aCategory==KUidSystemCategoryValue.

 @capability WriteDeviceData if aCategory not equal to the current process's

 			Secure ID and aCategory<KUidSecurityThresholdCategoryValue.

 @see KUidSecurityThresholdCategoryValue

 @publishedAll

 @deprecated Use RProperty::Define(TUint aKey, TInt aAttr, const TSecurityPolicy &aReadPolicy, const TSecurityPolicy &aWritePolicy, TInt aPreallocated=0)

 			instead.

 */

 EXPORT_C TInt RProperty::Define(TUid aCategory, TUint aKey, TInt aAttr, TInt aPreallocate)

 	{

 	TPropertyInfo info;

 	info.iType = (RProperty::TType)(aAttr & RProperty::ETypeMask);

 	info.iAttr = (aAttr & ~RProperty::ETypeMask);

 	info.iSize = (TUint16) aPreallocate;

 	info.iReadPolicy = TSecurityPolicy(TSecurityPolicy::EAlwaysPass);

 	info.iWritePolicy = TSecurityPolicy(TSecurityPolicy::EAlwaysPass);

 	return(Exec::PropertyDefine(TUint(aCategory.iUid), aKey, &info));

 	}

 /**

 Deletes a property.

 This can only be called by the property owner, as defined by

 the process Security ID; any attempt by another process to delete

 the property will fail.

 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 aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @return KErrNone, if successful;

         KErrPermissionDenied, if a process that is not the owner of

         the property attempts to delete it.

         KErrNotFound, if the property has not been defined.

 */

 EXPORT_C TInt RProperty::Delete(TUid aCategory, TUint aKey)

 	{

 	return(Exec::PropertyDelete(TUint(aCategory.iUid), aKey));

 	}

 /**

 Deletes a property.

 The category ID for the property will be the same as the current processes Secure ID.

 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 aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @return KErrNone, if successful;

         KErrNotFound, if the property has not been defined.

 */

 EXPORT_C TInt RProperty::Delete(TUint aKey)

 	{

 	return(Exec::PropertyDelete(KMaxTUint, aKey));

 	}

 /**

 Gets an integer property.

 The function gets the integer value of the specified property.

 The Platform Security attributes of the current process are checked against

 the Read Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aValue    A reference to the variable where the property value will

                  be reported.

 @return KErrNone, if successful;

 	    KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not of integral type.

 */

 EXPORT_C TInt RProperty::Get(TUid aCategory, TUint aKey, TInt& aValue)

 	{

 	return(Exec::PropertyFindGetI(TUint(aCategory.iUid), aKey, &aValue));

 	}

 /**

 Gets a binary property.

 The function gets the byte-array (binary) value of the specified property.

 The Platform Security attributes of the current process are checked against

 the Read Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aDes      A reference to the buffer descriptor where the property value

                  will be reported.

 @return KErrNone if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a byte-array (binary) type;

 		KErrOverflow, if the supplied buffer is too small to contain the full

 		property value, and note that the buffer aDes contains the

 		truncated property value.

 */

 EXPORT_C TInt RProperty::Get(TUid aCategory, TUint aKey, TDes8& aDes)

 	{

 	TInt size = aDes.MaxSize();

 	TInt r = Exec::PropertyFindGetB(TUint(aCategory.iUid), aKey, (TUint8*) aDes.Ptr(), size);

 	if (r < 0)

 		{

 		if (r == KErrOverflow)

 			{

 			aDes.SetLength(size);

 			}

 		return r;

 		}

 	aDes.SetLength(r);

 	return KErrNone;

 	}

 /**

 Gets a text property.

 The function gets the text value of the specified property.

 The Platform Security attributes of the current process are checked against

 the Read Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aDes      A reference to the buffer descriptor where the property value

                  will be reported.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a text type;

 		KErrOverflow, if the supplied buffer is too small to contain the full

 		property value, and note that the buffer aDes contains the

 		truncated property value.

 */

 EXPORT_C TInt RProperty::Get(TUid aCategory, TUint aKey, TDes16& aDes)

 	{

 	TInt size = aDes.MaxSize();

 	TInt r = Exec::PropertyFindGetB(TUint(aCategory.iUid), aKey, (TUint8*) aDes.Ptr(), size);

 	if (r < 0)

 		{

 		if (r == KErrOverflow)

 			{

 			aDes.SetLength(size >> 1);

 			}

 		return r;

 		}

 	aDes.SetLength(r >> 1);

 	return KErrNone;

 	}

 /**

 Sets an integer property.

 The function publishes a new integral property value.

 Any pending subscriptions for this property will be completed.

 The Platform Security attributes of the current process are checked against

 the Write Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aValue    The new property value. 

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not of integral type.

 */

 EXPORT_C TInt RProperty::Set(TUid aCategory, TUint aKey, TInt aValue)

 	{

 	return(Exec::PropertyFindSetI(TUint(aCategory.iUid), aKey, aValue));

 	}

 /**

 Sets a binary property.

 The function Publishes a new byte-array (binary) value for

 the specified property.

 Any pending subscriptions for this property will be completed.

 Note that if the new property value requires more storage space than is

 currently allocated, then memory allocation will be required.

 This invalidates any real-time guarantee, i.e. the guarantee that the operation

 will complete within a bounded time.

 The Platform Security attributes of the current process are checked against

 the Write Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aDes      A reference to the descriptor containing the

                  new property value.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a byte-array (binary) type;

 	    KErrNoMemory, if memory allocation is required, and there is

 	                  insufficient available.

 */

 EXPORT_C TInt RProperty::Set(TUid aCategory, TUint aKey, const TDesC8& aDes)

 	{

 	return(Exec::PropertyFindSetB(TUint(aCategory.iUid), aKey, (TUint8*) aDes.Ptr(), aDes.Size()));

 	}

 /**

 Sets a text property.

 The function publishes a new text value for the specified property.

 Any pending subscriptions for this property will be completed.

 Note that if the new property value requires more storage space than is

 currently allocated, then memory allocation will be required.

 This invalidates any real-time guarantee, i.e. the guarantee that the operation

 will complete within a bounded time.

 The Platform Security attributes of the current process are checked against

 the Write Policy which was specified when the property was defined.

 If this check fails the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then this function will return KErrNone even though the

 check failed.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aDes      A reference to the descriptor containing the

                  new property value.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a text type;

 	    KErrNoMemory, if memory allocation is required, and there is

 	                  insufficient available;

         KErrTooBig, if the property is larger than KMaxPropertySize;

 */

 EXPORT_C TInt RProperty::Set(TUid aCategory, TUint aKey, const TDesC16& aDes)

 	{

 	return(Exec::PropertyFindSetB(TUint(aCategory.iUid), aKey, (TUint8*) aDes.Ptr(), aDes.Size()));

 	}

 /**

 Attaches to the specified property.

 The function creates a handle (this object) to the specified property.

 This allows the caller to subscribe for notification of changes to this

 property, and to faster and real-time property access methods.

 If the specified property does not exist, then this operation will

 still succeed. However, memory allocation will be required.

 Note that this invalidates any real-time guarantee, i.e. the guarantee that

 the operation completes within a bounded time.

 @param aCategory The UID that identifies the property category.

 @param aKey      The property sub-key, i.e. the key that identifies the

                  specific property within the category.

 @param aType     The ownership of this property handle. 

 				 By default, ownership is vested in the current process,

 				 but can be vested in the current thread by

 				 specifying EOwnerThread.

 @return KErrNone, if successful;

 	    KErrNoMemory, if memory allocation is required, and there is

 	                  insufficient available.

 */

 EXPORT_C TInt RProperty::Attach(TUid aCategory, TUint aKey, TOwnerType aType)

 	{

 	TInt r = Exec::PropertyAttach(TUint(aCategory.iUid), aKey, aType);

 	if (r < 0) 

 		{ // error

 		iHandle = 0;

 		return r;

 		}

 	iHandle = r;

 	return KErrNone;

 	}

 /**

 Subscribes to a property.

 The function issues an asynchronous request to be notified when the property

 is changed. The calling thread is signalled, and the specified request status

 object is updated when the property is next changed.

 The property may change several times before the subscribing thread can deal

 with a notification request completion. To ensure that the subscriber does not

 miss updates, it should re-issue a subscription request before retrieving

 the current value and acting on it.

 If the property has not been defined, the request does not complete until

 the property is subsequently defined and published. When defined, if the caller

 process doesn't pass the Read Policy, then the request completes with KErrPermissionDenied.

 If the property is already defined, and the caller process doesn't pass the Read Policy,

 then the request completes immediately with KErrPermissionDenied.

 When Read Policy checks fail the action taken is determined by the system wide Platform Security

 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.

 If PlatSecEnforcement is OFF, then the request will complete successfully even though the

 check failed.

 If an outstanding request is cancelled through a call to Cancel(), then it

 completes with KErrCancel.

 @param aRequest The request status object to be signalled on update.

 @panic KERN-EXEC 9 if there is already a subscription on this property handle;

        only one subscription per RProperty is allowed.

 */

 EXPORT_C void RProperty::Subscribe(TRequestStatus& aRequest)

 	{

 	aRequest = KRequestPending;

 	Exec::PropertySubscribe(iHandle, &aRequest);

 	}

 /**

 Cancels an outstanding subscription request for this property handle.

 If the request has not already completed, then it completes with KErrCancel.

 */

 EXPORT_C void RProperty::Cancel()

 	{

 	Exec::PropertyCancel(iHandle);

 	}

 /**

 Gets the integer value of this property.

 The implementation guarantees that this call has a bounded response time.

 @param aValue A reference to the variable where the property value

               will be reported.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not of integral type.

 */

 EXPORT_C TInt RProperty::Get(TInt& aValue)

 	{

 	return(Exec::PropertyGetI(iHandle, &aValue));

 	}

 /**

 Gets the byte-array (binary) value of this property.

 The implementation guarantees that this call has a bounded response time.

 @param aDes A reference to the buffer descriptor where the property value

             will be reported.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a byte-array (binary) type.

 		KErrOverflow, if the supplied buffer is too small to contain the full

 		property value, and note that the buffer aDes contains the

 		truncated property value.

 */

 EXPORT_C TInt RProperty::Get(TDes8& aDes)

 	{

 	TInt size = aDes.MaxSize();

 	TInt r = Exec::PropertyGetB(iHandle, (TUint8*) aDes.Ptr(), size);

 	if (r < 0)

 		{

 		if (r == KErrOverflow)

 			{

 			aDes.SetLength(size);

 			}

 		return r;

 		}

 	aDes.SetLength(r);

 	return KErrNone;

 	}

 /**

 Gets the text value of this property.

 The implementation guarantees that this call has a bounded response time.

 @param aDes A reference to the buffer descriptor where the property value

             will be reported.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Read Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a text type;

 		KErrOverflow, if the supplied buffer is too small to contain the full

 		property value, and note that the buffer aDes contains the

 		truncated property value.

 */

 EXPORT_C TInt RProperty::Get(TDes16& aDes)

 	{

 	TInt size = aDes.MaxSize();

 	TInt r = Exec::PropertyGetB(iHandle, (TUint8*) aDes.Ptr(), size);

 	if (r < 0)

 		{

 		if (r == KErrOverflow)

 			{

 			aDes.SetLength(size >> 1);

 			}

 		return r;

 		}

 	aDes.SetLength(r >> 1);

 	return KErrNone;

 	}

 /**

 Sets a new integer value for this property.

 The function publishes the attached new integral property value, and any

 pending subscriptions for this property are completed.

 The implementation guarantees that this call has a bounded response time.

 @param aValue The property new value.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not of integral type.

 */	

 EXPORT_C TInt RProperty::Set(TInt aValue)

 	{

 	return(Exec::PropertySetI(iHandle, aValue));

 	}

 /**

 Sets the byte-array (binary) property.

 The function publishes the attached new binary property value, and any

 pending subscriptions for this property are completed.

 The implementation guarantees that this call has a bounded response time only

 if the new property value requires no more storage space than is

 currently allocated. If more memory needs to be allocated, then this

 invalidates the real-time guarantee.

 @param aDes A reference to the descriptor containing the property new value.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a byte-array (binary) type;

 	    KErrNoMemory, if memory allocation is required, and there is

 	                  insufficient available.

     	KMaxPropertySize, if the property is larger than KErrTooBig.

 */

 EXPORT_C TInt RProperty::Set(const TDesC8& aDes)

 	{

 	return(Exec::PropertySetB(iHandle, (TUint8*) aDes.Ptr(), aDes.Size()));

 	}

 /**

 Sets the text property

 The function publishes the attached new text property value, and any

 pending subscriptions for this property are completed.

 The implementation guarantees that this call has a bounded response time only

 if the new property value requires no more storage space than is

 currently allocated. If more memory needs to be allocated, then this

 invalidates the real-time guarantee.

 @param aDes A reference to the descriptor containing the property new value.

 @return KErrNone, if successful;

         KErrPermissionDenied, if the caller process doesn't pass the Write Policy;

 		KErrNotFound, if the property has not been defined;

 		KErrArgument, if the property is not a byte-array (binary) type;

 	    KErrNoMemory, if memory allocation is required, and there is

 	                  insufficient available.

     	KMaxPropertySize, if the property is larger than KErrTooBig.

 */

 EXPORT_C TInt RProperty::Set(const TDesC16& aDes)

 	{

 	return(Exec::PropertySetB(iHandle, (TUint8*) aDes.Ptr(), aDes.Size()));

 	}