diff -r 000000000000 -r c6b0df440bee dbgsrv/coredumpserver/cdssupport/src/optionconfig.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dbgsrv/coredumpserver/cdssupport/src/optionconfig.cpp	Tue Mar 02 10:33:16 2010 +0530
@@ -0,0 +1,675 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Implementation of class COptionConfig configuration parameter interface 
+//
+
+
+
+/**
+ @file
+ @see COptionConfig
+*/
+
+#include <debuglogging.h>
+
+#include <optionconfig.h>
+
+
+/**
+Allocates and constructs a COptionConfig object.
+@param aIndex Internal index to the component that owns the object
+@param aUID UID of the component that owns the object
+@param aSource Type of component that owns the object
+@param aType Type of parameter
+@param aPrompt Prompt to present to user 
+@param aNumOptions Number of options that the parameter can be set to. Only applies if type is ETMultiEntryEnum.
+@param aOptions Comma separated list of options. Applies to ETMultiEntryEnum and ETBool.
+@param aVal Integer value. Applies to ETInt, ETUInt, ETBool.
+@param aStrValue String value. Applies to ETString, ETFileName, ETMultiEntry, ETBool.
+*/
+EXPORT_C COptionConfig* COptionConfig::NewL( 
+										const TUint32          & aIndex, 
+										const TUint32          & aUID, 
+										const TParameterSource & aSource, 
+										const TOptionType      & aType, 
+										const TDesC            & aPrompt, 
+										const TUint32          & aNumOptions,
+										const TDesC            & aOptions,
+										const TInt32           & aVal, 
+										const TDesC            & aStrValue)
+                                        
+	{
+
+
+	const TInt size = 
+		  sizeof( TUint32 )	// iType
+		+ sizeof( TUint32 )	// iSource
+		+ sizeof( TUint32 )	// iIndex
+		+ sizeof( TUint32 )	// iInstance
+		+ sizeof( TUint32 )	// iUID
+
+		+ sizeof( TUint32 )	// When externalized, we send the name length, so must include this
+		+ 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+		+ aPrompt.Size()	// iPrompt
+
+		+ sizeof( TUint32 )	// iNumOptions
+
+		+ sizeof( TUint32 )	// When externalized, we send the name length, so must include this
+		+ 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+		+ aOptions.Size()	// iOptions
+
+		+ sizeof ( TInt32 )	// iValue
+
+		+ sizeof( TUint32 )	// When externalized, we send the name length, so must include this
+		+ 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+		+ aStrValue.Size()	// iStrValue
+
+		+ sizeof( TUint32 );// iSize itself
+
+	if( size >= MaxSize() )
+		{
+		LOG_MSG3( "COptionConfig::NewL() : Attempting to allocate %d bytes but maximum is %d\n", 
+			size, MaxSize() );
+
+		User::Leave( KErrTooBig );
+		}
+
+	COptionConfig * data = new (ELeave) COptionConfig( aType, aSource, aIndex, aUID, aNumOptions, aVal );
+	CleanupStack::PushL( data );
+
+	data->ConstructL( aPrompt, aOptions, aStrValue );
+	CleanupStack::Pop(data);
+	return (data);
+
+	}
+
+
+/**
+Allocates and constructs a COptionConfig object from a descriptor. 
+The descriptor contains an externalised version of a COptionConfig object.
+This method is typically used to obtain a COptionConfig object from a 
+descriptor returned by the core dump server.
+
+@param aStreamData Descriptor with externalised/streamed object
+@see InternalizeL
+@see ExternalizeL
+*/
+EXPORT_C COptionConfig* COptionConfig::NewL( const TDesC8 & aStreamData )
+	{
+
+	COptionConfig* data = new (ELeave) COptionConfig();
+
+	CleanupStack::PushL( data );
+	
+	// Open a read stream for the descriptor
+	RDesReadStream stream( aStreamData );
+
+	CleanupClosePushL( stream );
+
+	data->InternalizeL( stream );
+
+	CleanupStack::PopAndDestroy( &stream ); // finished with the stream
+
+	CleanupStack::Pop( data );
+
+	return (data);
+
+	}
+
+
+/**
+Destructor. Deletes descriptors.
+*/
+EXPORT_C COptionConfig::~COptionConfig()
+	{
+
+
+	if( iPrompt )
+		{
+		delete iPrompt;
+		}
+
+	if( iOptions )
+		{
+		delete iOptions;
+		}
+
+	if( iStrValue )
+		{
+		delete iStrValue;
+		}
+	}
+
+
+/**
+First phase contructor. Sets the size to 0, descriptors to NULL.
+@see COptionConfig::NewL()
+*/
+COptionConfig::COptionConfig(const TOptionType				& aType,  
+									const TParameterSource	& aSource, 
+									const TUint32			& aIndex, 
+									const TUint32			& aUID,
+									const TUint32			& aNumOptions,
+									const TInt32			& aValue ) :
+	iType			( aType ),
+	iSource			( aSource ),
+	iIndex			( aIndex ), 
+	iUID			( aUID ), 
+	iPrompt			( NULL ),
+	iNumOptions		( aNumOptions ),
+	iOptions		( NULL ),
+	iValue			( aValue ),
+	iStrValue		( NULL ),
+	iSize			( 0 ),
+	iInstance		( 0 ) 
+
+	{
+
+	
+	/*
+	LOG_MSG2( "COptionConfig::COptionConfig() : iSize=%d\n", iSize );
+	LOG_MSG4( "  iType=%d, iSource=%d, iIndex=%d", iType, iSource, iIndex );
+	LOG_MSG4( "  iUID=0x%X, iNumOpts=%d, iValue=%d\n", iUID, iNumOptions, iValue );
+	*/
+	
+	}
+
+
+
+void COptionConfig::ConstructStringL( const TDesC & aSource, HBufC ** aDest )
+	{
+
+	TInt sourceLength = aSource.Length();
+
+	if( sourceLength > 0 )
+		{
+
+		TInt newMaxLength = Align4( KCDSMaxConfigParamStr );
+		if( *aDest )
+			{
+			delete *aDest;
+			}
+
+		*aDest = HBufC::NewL( newMaxLength );
+		CleanupStack::PushL( *aDest );
+
+		TPtr destDes = (*aDest)->Des();
+
+		destDes.FillZ( newMaxLength );
+
+		if( sourceLength >= KCDSMaxConfigParamStr )
+			{
+			sourceLength = KCDSMaxConfigParamStr - 1; // We want to leave the null at the end always
+			}
+
+		destDes.Copy( aSource.Ptr(), sourceLength );
+
+		destDes.SetLength( sourceLength );
+		CleanupStack::Pop( *aDest );
+
+		}
+	else
+		{
+		*aDest = NULL;
+		}
+	 }
+
+
+
+/**
+Second phase constructor initialises the descriptors
+*/
+void COptionConfig::ConstructL( const TDesC & aPrompt, 
+								const TDesC & aOptions,
+								const TDesC & aStrValue )
+	{
+
+	ConstructStringL( aPrompt, &iPrompt );
+	ConstructStringL( aOptions, &iOptions );
+	ConstructStringL( aStrValue, &iStrValue );
+
+	}
+
+
+/**
+Initialise this object with the contents of RReadStream aStream.
+The descriptor contains an externalised version of an object.
+This method is typically used to obtain a COptionConfig object from 
+the core dump server.
+Any modifications to this method should be synchronised with ExternalizeL(). 
+Also note that the methods used from RReadStream (>> or ReadUint32L) 
+can behave differently, especially for descriptors.
+@param aStream Stream with streamed object
+@see ExternalizeL
+@see RReadStream
+@pre Call ExternaliseL to obtain the stream containing an externalised 
+version of this object.
+*/
+EXPORT_C void COptionConfig::InternalizeL( RReadStream & aStream )
+	{
+
+
+	iType = (TOptionType) aStream.ReadUint32L(); 
+
+	iSource = (TParameterSource) aStream.ReadUint32L(); 
+
+	iIndex = aStream.ReadUint32L(); 
+
+	iInstance = aStream.ReadUint32L(); 
+
+	iUID = aStream.ReadUint32L(); 
+
+	if( NULL != iPrompt )
+		{
+		delete iPrompt;
+		iPrompt = NULL;
+		}
+
+	TUint32 promptSize = aStream.ReadUint32L(); 
+
+	if ( promptSize > 0 )
+		{
+		//iPrompt = HBufC::NewL( aStream, KCDSMaxConfigParamStr ); 
+		iPrompt = HBufC::NewL( aStream, promptSize ); 
+		}
+	else
+		{
+		iPrompt  = NULL;
+		}
+
+	iNumOptions = aStream.ReadUint32L(); 
+
+	if( NULL != iOptions )
+		{
+		delete iOptions;
+		iOptions = NULL;
+		}
+
+	TUint32 optionSize = aStream.ReadUint32L(); 
+
+	if ( optionSize > 0 )
+		{
+		//iOptions = HBufC::NewL( aStream, KCDSMaxConfigParamStr ); 
+		iOptions = HBufC::NewL( aStream, optionSize ); 
+		}
+	else
+		{
+		iOptions = NULL;
+		}
+
+
+	iValue = aStream.ReadInt32L();
+
+	if( NULL != iStrValue )
+		{
+		delete iStrValue;
+		iStrValue = NULL;
+		}
+
+	TUint32 strValueSize = aStream.ReadUint32L(); 
+
+	if ( strValueSize > 0 )
+		{
+		//iStrValue = HBufC::NewL( aStream, KCDSMaxConfigParamStr ); 
+		iStrValue = HBufC::NewL( aStream, strValueSize ); 
+		}
+	else
+		{
+		iStrValue = NULL;
+		}
+
+	iSize = aStream.ReadUint32L() ;
+
+	}
+
+
+/**
+Make a streamed representation of this object to a RWriteStream.
+
+This method is typically by the core dump server when contructing a list of 
+COptionConfig for a client.
+Any modifications to this method should be synchronised with InternalizeL(). 
+Also note that the methods used from RWriteStream (>> or WriteUint32L) can behave differently,
+especially for descriptors.
+@param aStream Stream to stream object onto
+@param buf Buffer onto the same stream, used to obtain correct size of externalised object
+@see InternalizeL
+@see RReadStream
+@see RWriteStream
+@post The stream contains an externalised version of this object.
+*/
+EXPORT_C void COptionConfig::ExternalizeL( RWriteStream & aStream, CBufFlat* buf )
+	{
+
+
+	// Take the size of the buffer before we add anything to it.
+	TUint startBufSize = buf->Size();
+
+	aStream.WriteUint32L( iType ); 
+
+	aStream.WriteUint32L( iSource ); 
+
+	aStream.WriteUint32L( iIndex );
+
+	aStream.WriteUint32L( iInstance );
+
+	aStream.WriteUint32L( iUID );
+
+	TInt promptSize = 0;
+	if ( iPrompt != NULL )
+		{
+		promptSize = iPrompt->Des().Length();
+		if( promptSize > 0 )
+			{
+			aStream.WriteUint32L( promptSize ); 
+			aStream << iPrompt->Des();
+			}
+		}
+
+	if( promptSize == 0 )
+		{
+		aStream.WriteUint32L( 0 ); 
+		}
+
+	aStream.WriteUint32L( iNumOptions );
+
+	TInt optionSize = 0;
+	if ( iOptions != NULL )
+		{
+		optionSize = iOptions->Des().Length();
+		if( optionSize > 0 )
+			{
+			aStream.WriteUint32L( optionSize ); 
+			aStream << iOptions->Des();
+			}
+		}
+
+	if( optionSize == 0 )
+		{
+		aStream.WriteUint32L( 0 ); 
+		}
+
+	aStream.WriteInt32L( iValue );
+
+	TInt valueSize = 0;
+	if ( iStrValue != NULL )
+		{
+		valueSize = iStrValue->Des().Length();
+		if( valueSize > 0 )
+			{
+			aStream.WriteUint32L( valueSize ); 
+			aStream << iStrValue->Des();
+			}
+		}
+
+	if( valueSize == 0 )
+		{
+		aStream.WriteUint32L( 0 ); 
+		}
+
+	// The real exteranlized size is the size of the buffer up to here plus the 
+	// 4 bytes for the size itself
+	iSize = buf->Size() - startBufSize + 4;
+	aStream.WriteUint32L( iSize );
+
+	}
+
+
+
+/**
+Obtain the type of parameter.
+@see TOptionType
+*/
+EXPORT_C COptionConfig::TOptionType COptionConfig::Type() const 
+	 { 
+	 return ( iType ); 
+	 }
+
+/**
+Obtain the source component type of the parameter.
+@see TParameterSource
+*/
+EXPORT_C COptionConfig::TParameterSource COptionConfig::Source() const 
+	 { 
+	 return ( iSource ); 
+	 }
+
+/**
+Obtain the internal index to the component that owns the object.
+*/
+EXPORT_C TUint32 COptionConfig::Index() const 
+	 { 
+	 return ( iIndex ); 
+	 }
+
+/**
+Obtain the internal index to the component that owns the object.
+*/
+EXPORT_C TUint32 COptionConfig::Instance() const 
+	 { 
+	 return ( iInstance ); 
+	 }
+
+/**
+Set the internal index to the component that owns the object.
+*/
+EXPORT_C void COptionConfig::Instance(TInt32 aInstance)
+	 { 
+	 iInstance = aInstance; 
+	 }
+
+/**
+Obtain the UID of the component that owns the object.
+*/
+EXPORT_C TUint32 COptionConfig::Uid( ) const 
+	{ 
+	return iUID; 
+	}
+
+
+/**
+Obtain the prompt to present to the user.
+*/
+EXPORT_C const TDesC & COptionConfig::Prompt() const 
+	{ 
+	if( iPrompt )
+		{
+		return ( *iPrompt ); 
+		}
+	else
+		{
+		return KNullDesC;
+		}
+	}
+
+
+/**
+Obtain the number of options that the parameter can be set to. 
+Only applies if type is ETMultiEntryEnum.
+*/
+EXPORT_C TUint32 COptionConfig::NumOptions( ) const 
+	{ 
+	return iNumOptions; 
+	}
+
+
+/**
+Obtain the comma separated list of options. Applies to ETMultiEntryEnum and ETBool.
+*/
+EXPORT_C const TDesC & COptionConfig::Options() const 
+	{ 
+	if( iOptions )
+		{
+		return ( *iOptions ); 
+		}
+	else
+		{
+		return KNullDesC;
+		}
+	}
+
+
+/** Obtain the integer value of the parameter. */
+EXPORT_C TInt32 COptionConfig::Value() const 
+	 { 
+	 return ( iValue ); 
+	 }
+
+
+/** Obtain the value of the parameter as a Boolean. */
+EXPORT_C TBool COptionConfig::ValueAsBool() const
+	{
+	if( 0 == iValue )
+		{
+		return EFalse;
+		}
+	else
+		{
+		return ETrue;
+		}
+	}
+
+
+/** Obtain the value of the parameter as a descriptor. Does not apply to ETInt or ETUInt. */
+EXPORT_C const TDesC & COptionConfig::ValueAsDesc() const 
+	{ 
+
+	if( iStrValue )
+		{
+		return ( *iStrValue ); 
+		}
+	else
+		{
+		return KNullDesC;
+		}
+	 }
+
+/** Set the integer value of the parameter. */
+EXPORT_C void COptionConfig::Value( const TInt32 aValue ) 
+	{ 
+	iValue = aValue; 
+	}
+
+/** Set the descriptor value of the parameter. */
+EXPORT_C void COptionConfig::ValueL( const TDesC & aValue ) 
+	{ 
+
+	TInt valSize = aValue.Size();
+
+	TInt newSize = Size() + valSize ;
+
+	if( iStrValue )
+		{
+		newSize -= iStrValue->Size();
+		}
+
+	if( aValue.Length() > KCDSMaxConfigParamStr )
+		{
+		LOG_MSG( "if( aValue.Length() > KCDSMaxConfigParamStr ) -> User::Leave( KErrTooBig )\n" );
+		User::Leave( KErrTooBig );
+		}
+
+	if( newSize >= MaxSize() )
+		{
+		LOG_MSG( "if( newSize >= MaxSize() ) -> User::Leave( KErrTooBig )\n" );
+		User::Leave( KErrTooBig );
+		}
+
+
+	if( valSize == 0 )
+		{
+		iStrValue = NULL;
+		}
+	else
+		{
+		ConstructStringL( aValue, & iStrValue );
+		}
+
+	iSize = newSize;
+
+	}
+
+
+
+EXPORT_C COptionConfig::COptionConfig()
+	{
+	}
+
+
+/**
+Gets the size of the object when externalized. The sizeofs used to calculate this 
+must match the operators used in ExternalizeL and InternalizeL.
+Special attention must be paid to the name. If the object has not been 
+externalized yet then this method returns the maximum that it could take.
+The name descriptor is compressed when externalized, so it is not its Size().
+Furthermore the << operator adds two bytes to the stream when externalizing 
+a descriptor.
+*/
+EXPORT_C TInt COptionConfig::Size() const
+	{
+
+	if( iSize != 0 )
+		{
+		return iSize;
+		}
+
+	TUint extDecSize = 0;
+	if( iPrompt )
+		{
+		extDecSize += 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+					+ iPrompt->Size();	// iPrompt itself, in bytes. Worst case
+		}
+
+	if( iOptions )
+		{
+		extDecSize += 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+					+ iOptions->Size();	// iOptions itself, in bytes. Worst case
+		}
+
+	if( iStrValue )
+		{
+		extDecSize += 2					// When externalized, the << operator writes 2 bytes for the descriptor size
+					+ iStrValue->Size();	// iStrValue itself, in bytes. Worst case
+		}
+
+
+	const TInt size = 
+		  sizeof( TUint32 )	// iType
+		+ sizeof( TUint32 )	// iSource
+		+ sizeof( TUint32 )	// iIndex
+		+ sizeof( TUint32 )	// iInstance
+		+ sizeof( TUint32 )	// iUID
+		+ sizeof( TUint32 )	// iPrompt size
+		+ extDecSize		// all the descriptors and their 2 bytes due to <<
+		+ sizeof( TUint32 )	// iNumOptions
+		+ sizeof( TUint32 )	// iOptions size
+		+ sizeof( TInt32 )	// iValue 
+		+ sizeof( TUint32 )	// iStrValue size
+		+ sizeof( TUint32 );	// iSize itself
+
+	return size;
+	}
+
+
+ /**
+ Get the maximum size allowed for this object. This is needed as the object is passed  
+ across the Client Server interface.
+ */
+ EXPORT_C TInt COptionConfig::MaxSize()
+	{
+	
+	const TInt maxSize = 1024;
+	return maxSize;
+	}
+