sl@0: // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: #include <f32file.h>
sl@0: #include <f32file64.h>
sl@0: #include "SqlSrvConfig.h"
sl@0: #include "SqlSrvUtil.h"
sl@0: #include "OstTraceDefinitions.h"
sl@0: #ifdef OST_TRACE_COMPILER_IN_USE
sl@0: #include "SqlSrvConfigTraces.h"
sl@0: #endif
sl@0: #include "SqlTraceDef.h"
sl@0: 
sl@0: /**
sl@0: Initializes TSqlSrvConfigParams data members with their default values.
sl@0: */
sl@0: TSqlSrvConfigParams::TSqlSrvConfigParams() :
sl@0: 	iCacheSize(TSqlSrvConfigParams::KConfigPrmValueNotSet),
sl@0: 	iPageSize(TSqlSrvConfigParams::KConfigPrmValueNotSet),
sl@0: 	iDbEncoding(TSqlSrvConfigParams::EEncNotSet),
sl@0: 	iSoftHeapLimitKb(TSqlSrvConfigParams::KConfigPrmValueNotSet),
sl@0: 	iCompactionMode(ESqlCompactionNotSet),
sl@0: 	iFreePageThresholdKb(TSqlSrvConfigParams::KConfigPrmValueNotSet)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: "Object initialization" method.
sl@0: Opens and reads the SQL server configuration file (if it exists).
sl@0: Initializes TSqlSrvConfig data members using the data from the config file.
sl@0: If the configuration file does not exist, TSqlSrvConfig data members stay unchanged,
sl@0: except: 
sl@0:  - the soft heap limit, which default value is TSqlSrvConfigParams::KDefaultSoftHeapLimit;
sl@0:  - the free pages threshold, which default value is KSqlCompactFreePageThreshold;
sl@0: 
sl@0: @param aFs File session
sl@0: @param aFileName Config file name
sl@0: @leave KErrEof No valid config string found in the configuration file;
sl@0:                Note that the function may also leave with some other system-wide error codes.
sl@0: */
sl@0: void TSqlSrvConfig::InitL(RFs& aFs, const TDesC& aFileName)
sl@0: 	{
sl@0: 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL_ENTRY, "Entry;0;TSqlSrvConfig::InitL;aFs.Handle()=0x%X;aFileName=%S", (TUint)aFs.Handle(), __SQLPRNSTR(aFileName)));
sl@0: 	if(::FileExists(aFs, aFileName))
sl@0: 		{
sl@0:         SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL1, "0;TSqlSrvConfig::InitL;Config file found"));
sl@0: 		TBuf8<KSqlSrvMaxConfigStrLen> configFileStr;
sl@0: 		//Step 1: get the config string from the config file and store the string in configFileStr
sl@0: 		TSqlSrvConfig::GetConfigStringFromFileL(aFs, aFileName, configFileStr);
sl@0: 		__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:         SQL_TRACE_INTERNALS(OstTraceExt1(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL2, "0;TSqlSrvConfig::InitL;Config file string=%s", __SQLPRNSTR8(configFileStr, des16prnbuf)));
sl@0: 		//Step 2: extract config file parameters from the string (configFileStr)  and store them in iConfigFileParams
sl@0: 		TSqlSrvConfig::ExtractConfigParamsFromStringL(configFileStr, iConfigFileParams);
sl@0: 		}
sl@0: 	//If the soft heap limit is not set from the file or the file does not exist - then set the soft heap limit with the default value
sl@0: 	if(iConfigFileParams.iSoftHeapLimitKb == TSqlSrvConfigParams::KConfigPrmValueNotSet)
sl@0: 		{
sl@0: 		iConfigFileParams.iSoftHeapLimitKb = TSqlSrvConfigParams::KDefaultSoftHeapLimitKb;
sl@0: 		}
sl@0: 	//If the free page threshold is not set from the file or the file does not exist - then set the free page threshold with the default value
sl@0: 	if(iConfigFileParams.iFreePageThresholdKb == TSqlSrvConfigParams::KConfigPrmValueNotSet)
sl@0: 		{
sl@0: 		iConfigFileParams.iFreePageThresholdKb = KSqlCompactFreePageThresholdKb;
sl@0: 		}
sl@0: 
sl@0: #ifdef _SQL_RDEBUG_PRINT
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL_EXIT1, "Exit;0;TSqlSrvConfig::InitL;iCacheSize=%d;iPageSize=%d;iDbEncoding=%d;iSoftHeapLimit=%d", iConfigFileParams.iCacheSize, iConfigFileParams.iPageSize, iConfigFileParams.iDbEncoding, iConfigFileParams.iSoftHeapLimitKb));
sl@0: #else	
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL_EXIT2, "Exit;0;TSqlSrvConfig::InitL;iCacheSize=%d;iPageSize=%d;iDbEncoding=%{TSqlSrvConfig_TDbEncoding};iSoftHeapLimit=%d", iConfigFileParams.iCacheSize, iConfigFileParams.iPageSize, iConfigFileParams.iDbEncoding, iConfigFileParams.iSoftHeapLimitKb));
sl@0: #endif    
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLSRVCONFIGFILE_INITL_EXIT3, "Exit;0;TSqlSrvConfig::InitL;iCompactionMode=%d;iFreePageThresholdKb=%d", iConfigFileParams.iCompactionMode, iConfigFileParams.iFreePageThresholdKb));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Parses the config string parameter (aConfigStr), extracts configuration parameters values and 
sl@0: and initialises with them aConfigParams data members.
sl@0: The config string format is: "PARAM1=VALUE1;PARAM2=VALUE2;..."
sl@0: If there is unknown parameter "name=value" pair in the config string, it will be skipped - not reported as an error.
sl@0: In a case of a leave, the old content of aConfigStr is preserved.
sl@0: The rules for TSqlSrvConfigParams data members initialization are described in TSqlSrvConfig class' comments.
sl@0: 
sl@0: @see TSqlSrvConfig
sl@0: @param aConfigStr the config descriptor
sl@0: @param aConfigParams Output argument, config parameters will be stored there.
sl@0: @leave KErrArgument if the config is not good or the config string contains "soft heap limit" parameter/value pair.
sl@0: @leave KErrArgument if the config is not good or the config string contains "free page threshold" parameter/value pair.
sl@0: */
sl@0: void TSqlSrvConfig::GetConfigParamsL(const TDesC8& aConfigStr, TSqlSrvConfigParams& aConfigParams) const
sl@0: 	{
sl@0: 	__SQLTRACE_INTERNALSVAR(TBuf<100> des16prnbuf);
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt1(TRACE_INTERNALS, TSQLSRVCONFIGFILE_GETCONFIGPARAMSL_ENTRY, "Entry;0;TSqlSrvConfig::GetConfigParamsL;aConfigStr=%s", __SQLPRNSTR8(aConfigStr, des16prnbuf)));
sl@0: 	TSqlSrvConfigParams tmpConfigParams;
sl@0: 	//Step 1: extract configuration parameters from aConfigStr, store them in tmpConfigParams.
sl@0: 	TSqlSrvConfig::ExtractConfigParamsFromStringL(aConfigStr, tmpConfigParams);
sl@0: 	if(tmpConfigParams.iSoftHeapLimitKb != TSqlSrvConfigParams::KConfigPrmValueNotSet || 
sl@0: 	   tmpConfigParams.iFreePageThresholdKb != TSqlSrvConfigParams::KConfigPrmValueNotSet)
sl@0: 		{//It is not allowed the soft heap limit to be set from a config string, only from the SQL server config file.
sl@0: 		 //It is not allowed the free page threshold to be set from a config string, only from the SQL server config file.
sl@0: 		__SQLLEAVE(KErrArgument);
sl@0: 		}
sl@0: 	//Step 2: store tmpConfigParams in aConfigParams.
sl@0: 	aConfigParams = tmpConfigParams;
sl@0: 	//Step 3: replace each "not set" parameter in aConfigParams with the related parameter value from iConfigFileParams (the config file).
sl@0: 	if(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet)
sl@0: 		{
sl@0: 		aConfigParams.iPageSize = iConfigFileParams.iPageSize;
sl@0: 		}
sl@0: 	if(aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncNotSet)
sl@0: 		{
sl@0: 		aConfigParams.iDbEncoding = iConfigFileParams.iDbEncoding;
sl@0: 		}
sl@0: 	if(aConfigParams.iCompactionMode == ESqlCompactionNotSet)
sl@0: 		{
sl@0: 		aConfigParams.iCompactionMode = iConfigFileParams.iCompactionMode;
sl@0: 		}
sl@0: 	//Step 4: set the soft heap limit.
sl@0: 	aConfigParams.iSoftHeapLimitKb = iConfigFileParams.iSoftHeapLimitKb;
sl@0: 	//Step 5: set the free page threshold.
sl@0: 	aConfigParams.iFreePageThresholdKb = iConfigFileParams.iFreePageThresholdKb;
sl@0: 	//Step 6: assert the parameter values.
sl@0: 	__ASSERT_DEBUG(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iPageSize >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iCacheSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iCacheSize >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncNotSet || 
sl@0: 				aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncUtf8 || 
sl@0: 				aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncUtf16, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iSoftHeapLimitKb == TSqlSrvConfigParams::KConfigPrmValueNotSet || 
sl@0: 	            (aConfigParams.iSoftHeapLimitKb >= TSqlSrvConfigParams::KMinSoftHeapLimitKb &&
sl@0: 	             aConfigParams.iSoftHeapLimitKb <= TSqlSrvConfigParams::KMaxSoftHeapLimitKb), __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iCompactionMode == ESqlCompactionNotSet || aConfigParams.iCompactionMode == ESqlCompactionManual || 
sl@0: 				aConfigParams.iCompactionMode == ESqlCompactionBackground || aConfigParams.iCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iFreePageThresholdKb == TSqlSrvConfigParams::KConfigPrmValueNotSet || 
sl@0: 				aConfigParams.iFreePageThresholdKb >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: #ifdef _SQL_RDEBUG_PRINT
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, TSQLSRVCONFIGFILE_GETCONFIGPARAMSL_EXIT1, "Exit;0;TSqlSrvConfig::GetConfigParamsL;cacheSize=%d;pageSize=%d;dbEncoding=%d;softHeapLimit=%d", aConfigParams.iCacheSize, aConfigParams.iPageSize, aConfigParams.iDbEncoding, aConfigParams.iSoftHeapLimitKb));
sl@0: #else   
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, TSQLSRVCONFIGFILE_GETCONFIGPARAMSL_EXIT2, "Exit;0;TSqlSrvConfig::GetConfigParamsL;cacheSize=%d;pageSize=%d;dbEncoding=%{TSqlSrvConfig_TDbEncoding};softHeapLimit=%d", aConfigParams.iCacheSize, aConfigParams.iPageSize, aConfigParams.iDbEncoding, aConfigParams.iSoftHeapLimitKb));
sl@0: #endif    
sl@0:     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLSRVCONFIGFILE_GETCONFIGPARAMSL_EXIT3, "Exit;0;TSqlSrvConfig::GetConfigParamsL;compactionMode=%d;freePageThresholdKb=%d", aConfigParams.iCompactionMode, aConfigParams.iFreePageThresholdKb));
sl@0: 	}
sl@0: 
sl@0: //The function opeans the aFileName config file and reads the config string, storring it in aConfigStr argument.
sl@0: //Preconditions:
sl@0: // - The config file does exist;
sl@0: // - It is a file, containing 16-bit strings;
sl@0: // - aConfigStr max size is at least KSqlSrvMaxConfigStrLen bytes;
sl@0: //The function may leave if some of the file I/O operations (open file, read file) fails.
sl@0: void TSqlSrvConfig::GetConfigStringFromFileL(RFs& aFs, const TDesC& aFileName, TDes8& aConfigStr)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aConfigStr.MaxLength() >= KSqlSrvMaxConfigStrLen, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	RFile64 cfgFile;
sl@0: 	CleanupClosePushL(cfgFile);
sl@0: 	__SQLLEAVE_IF_ERROR2(cfgFile.Open(aFs, aFileName, EFileRead));
sl@0: 	TFileText cfgFileReader;
sl@0: 	cfgFileReader.Set(cfgFile);
sl@0: 	TBuf<KSqlSrvMaxConfigStrLen> buf;
sl@0: 	TBool cfgLineFound = EFalse;
sl@0: 	TInt err = KErrNone;
sl@0: 	//Read the configuration file line by line until get the first "non-comment" line.
sl@0: 	while((err = cfgFileReader.Read(buf)) == KErrNone)
sl@0: 		{
sl@0: 		buf.TrimAll();
sl@0: 		if(buf.Length() == 0 || buf.Locate('#') == 0)	//'#' means - this line is a comment
sl@0: 			{
sl@0: 			continue;
sl@0: 			}
sl@0: 		cfgLineFound = ETrue;
sl@0: 		break;
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(&cfgFile);
sl@0: 	if(err != KErrEof)
sl@0: 		{//The "read configuration file" operation has failed with "err" (if err != KErrNone)
sl@0: 		__SQLLEAVE_IF_ERROR2(err);	
sl@0: 		}
sl@0: 	if(!cfgLineFound)
sl@0: 		{//End of config file reached - no valid configuration line found.
sl@0: 		__SQLLEAVE2(KErrEof);	
sl@0: 		}
sl@0: 	__ASSERT_DEBUG(err == KErrNone || err == KErrEof, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	aConfigStr.Copy(buf);
sl@0: 	}
sl@0: 
sl@0: //Parses the config string parameter (aConfigStr) and stores the extracted configuration parameter values in the aConfigParams argument.
sl@0: //The config string format is: "PARAM1=VALUE1;PARAM2=VALUE2;..."
sl@0: //If there is unknown parameter name in the config string, it will be skipped - not reported as an error.
sl@0: //The function will leave with KErrArgument in a case of a bad config string (bad parameter values).
sl@0: void TSqlSrvConfig::ExtractConfigParamsFromStringL(const TDesC8& aConfigStr, TSqlSrvConfigParams& aConfigParams)
sl@0: 	{
sl@0: 	//Search iteratively the config string for "PARAM=VALUE;" pairs. If such pair is found, extract the parameter name and
sl@0: 	//parameter value. Adjust the string start ptr to point to the rest of the string.
sl@0: 	for(TPtrC8 ptr(aConfigStr);ptr.Length()>0;)
sl@0: 		{
sl@0: 		TPtrC8 prmName(KNullDesC8);
sl@0: 		TPtrC8 prmValue(KNullDesC8);
sl@0: 		if(TSqlSrvConfig::ExtractParamValuePairL(ptr, prmName, prmValue))
sl@0: 			{
sl@0: 			TSqlSrvConfig::ExtractParamValueL(prmName, prmValue, aConfigParams);
sl@0: 			}
sl@0: 		}
sl@0: 	//Assert the extracted parameter values.
sl@0: 	__ASSERT_DEBUG(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iPageSize >= 0, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iCacheSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iCacheSize >= 0, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncNotSet || 
sl@0: 				aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncUtf8 || 
sl@0: 				aConfigParams.iDbEncoding == TSqlSrvConfigParams::EEncUtf16, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iSoftHeapLimitKb == TSqlSrvConfigParams::KConfigPrmValueNotSet || 
sl@0: 	            (aConfigParams.iSoftHeapLimitKb >= TSqlSrvConfigParams::KMinSoftHeapLimitKb &&
sl@0: 	             aConfigParams.iSoftHeapLimitKb <= TSqlSrvConfigParams::KMaxSoftHeapLimitKb), __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iCompactionMode == ESqlCompactionNotSet || aConfigParams.iCompactionMode == ESqlCompactionManual || 
sl@0: 				aConfigParams.iCompactionMode == ESqlCompactionBackground || aConfigParams.iCompactionMode == ESqlCompactionAuto, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(aConfigParams.iFreePageThresholdKb == TSqlSrvConfigParams::KConfigPrmValueNotSet || 
sl@0: 			    aConfigParams.iFreePageThresholdKb >= 0, __SQLPANIC2(ESqlPanicInternalError));
sl@0: 	}
sl@0: 
sl@0: //The function searches aConfigStr arguments for "PARAM=VALUE;" pair. If such pair is found, then 
sl@0: //aParamName is set to point to the parameter name, aParamValue is set to point to the parameter value,
sl@0: //aConfigStr is set to point to the rest of the config string (skipping the just found "param=value;" pair).
sl@0: //The function leaves with KErrArgument in case of a bad config string.
sl@0: //The function returns false if a ";" string is found instead of a "param=value;" pair.
sl@0: //When the function returns true, it means that aParamName and aParamValue arguments are set to point to the
sl@0: //parameter name and parameter value.
sl@0: TBool TSqlSrvConfig::ExtractParamValuePairL(TPtrC8& aConfigStr, TPtrC8& aParamName, TPtrC8& aParamValue)
sl@0: 	{
sl@0: 	const TChar KSemiColon(';');
sl@0: 	const TChar KAssignment('=');
sl@0: 	TInt pos = aConfigStr.Locate(KSemiColon);
sl@0: 	TPtrC8 prmText(KNullDesC8);
sl@0: 	if(pos < 0)
sl@0: 		{
sl@0: 		pos = aConfigStr.Length() - 1;	
sl@0: 		prmText.Set(TSqlSrvConfig::TrimAndConstructPtr(aConfigStr.Ptr(), aConfigStr.Length()));
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		prmText.Set(TSqlSrvConfig::TrimAndConstructPtr(aConfigStr.Ptr(), pos));
sl@0: 		}
sl@0: 	//Set aConfigStr to the "point" right after the last found ';'
sl@0: 	if(pos == aConfigStr.Length() - 1)
sl@0: 		{
sl@0: 		aConfigStr.Set(NULL, 0);	
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aConfigStr.Set(aConfigStr.Ptr() + pos + 1, aConfigStr.Length() - (pos + 1));
sl@0: 		}
sl@0: 	if(prmText.Length() == 0)
sl@0: 		{//Empty ";"
sl@0: 		return EFalse;	
sl@0: 		}
sl@0: 	//Find the parameter name and parameter value
sl@0: 	pos = prmText.Locate(KAssignment);
sl@0: 	if(pos < 0 || pos >= (prmText.Length() - 1))
sl@0: 		{
sl@0: 		__SQLLEAVE2(KErrArgument);
sl@0: 		}
sl@0: 	//we've got now prmText pointing to a " PARAM = VALUE " string.
sl@0: 	aParamName.Set(TSqlSrvConfig::TrimAndConstructPtr(prmText.Ptr(), pos));
sl@0: 	aParamValue.Set(TSqlSrvConfig::TrimAndConstructPtr(prmText.Ptr() + pos + 1, prmText.Length() - (pos + 1)));
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: //The function compares aParamName argument against a set of predefined parameter names and if one of them is matched,
sl@0: //then the function converts aParamValue argument to a numerical value and assigns it to the corresponding aConfigParams data member.
sl@0: //The function may leave with KErrArgument, if the parameter value is invalid.
sl@0: void TSqlSrvConfig::ExtractParamValueL(const TDesC8& aParamName, const TDesC8& aParamValue, TSqlSrvConfigParams& aConfigParams)
sl@0: 	{
sl@0: 	if(aParamName.CompareF(KCacheSize) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iCacheSize = TSqlSrvConfig::GetCacheSizeL(aParamValue);
sl@0: 		}
sl@0: 	else if(aParamName.CompareF(KPageSize) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iPageSize = TSqlSrvConfig::GetPageSizeL(aParamValue);
sl@0: 		}
sl@0: 	else if(aParamName.CompareF(KEncoding) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iDbEncoding = TSqlSrvConfig::GetEncoding(aParamValue);
sl@0: 		}
sl@0: 	else if(aParamName.CompareF(KSoftHeapLimitKb) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iSoftHeapLimitKb = TSqlSrvConfig::GetSoftHeapLimitL(aParamValue);
sl@0: 		}
sl@0: 	else if(aParamName.CompareF(KCompactionMode) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iCompactionMode = TSqlSrvConfig::GetCompactionModeL(aParamValue);
sl@0: 		}
sl@0: 	else if(aParamName.CompareF(KFreePageThresholdKb) == 0)
sl@0: 		{
sl@0: 		aConfigParams.iFreePageThresholdKb = TSqlSrvConfig::GetFreePageThresholdL(aParamValue);
sl@0: 		}
sl@0: 	//else
sl@0: 	//	{
sl@0: 	//	Unrecognized parameter/value pair - no problem, skip it.
sl@0: 	//	}
sl@0: 	}
sl@0: 
sl@0: //The function converts aParamValue to a numerical value (the cache size in pages) and returns it.
sl@0: //If the converted numerical value is less than 0, the function leaves with KErrArgument.
sl@0: TInt TSqlSrvConfig::GetCacheSizeL(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TLex8 lex(aParamValue);
sl@0: 	TInt cacheSize = TSqlSrvConfigParams::KConfigPrmValueNotSet;
sl@0: 	TInt err = lex.Val(cacheSize);
sl@0: 	if(err != KErrNone || cacheSize < 0) 	//The correct check is for "<=0", but it has to be backward 
sl@0: 		{									//compatible with the previous implementation
sl@0: 		__SQLLEAVE2(KErrArgument);
sl@0: 		}
sl@0: 	return cacheSize;
sl@0: 	}
sl@0: 
sl@0: //The function converts aParamValue to a numerical value (the page size in bytes) and returns it.
sl@0: //If the converted numerical value is less than 0, the function leaves with KErrArgument.
sl@0: TInt TSqlSrvConfig::GetPageSizeL(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TLex8 lex(aParamValue);
sl@0: 	TInt pageSize = TSqlSrvConfigParams::KConfigPrmValueNotSet;
sl@0: 	TInt err = lex.Val(pageSize);
sl@0: 	if(err != KErrNone || pageSize < 0) 	//The correct check is for "<0", "power of 2", "between 512 and 32768",
sl@0: 		{									//but it has to be backward compatible with the previous implementation
sl@0: 		__SQLLEAVE2(KErrArgument);
sl@0: 		}
sl@0: 	return pageSize;
sl@0: 	}
sl@0: 
sl@0: //The function converts aParamValue to a numerical value (the database encoding) and returns it.
sl@0: TSqlSrvConfigParams::TDbEncoding TSqlSrvConfig::GetEncoding(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TSqlSrvConfigParams::TDbEncoding encoding = TSqlSrvConfigParams::EEncNotSet;
sl@0: 	if(aParamValue.CompareF(KUTF8) == 0 || aParamValue.CompareF(KUTF8Q) == 0)
sl@0: 		{
sl@0: 		encoding = TSqlSrvConfigParams::EEncUtf8;
sl@0: 		}
sl@0: 	else if(aParamValue.CompareF(KUTF16) == 0 || aParamValue.CompareF(KUTF16Q) == 0)
sl@0: 		{
sl@0: 		encoding = TSqlSrvConfigParams::EEncUtf16;
sl@0: 		}
sl@0: 	//else
sl@0: 	//	{
sl@0: 	//	Invalid encoding - bypass it in order to be compatible with the previous implementation
sl@0: 	//	}
sl@0: 	return encoding;
sl@0: 	}
sl@0: 
sl@0: //The function converts aParamValue to a numerical value (the soft heap limit in Kb) and returns it.
sl@0: TInt TSqlSrvConfig::GetSoftHeapLimitL(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TLex8 lex(aParamValue);
sl@0: 	TInt softHeapLimitKb = TSqlSrvConfigParams::KConfigPrmValueNotSet;
sl@0: 	TInt err = lex.Val(softHeapLimitKb);
sl@0: 	if(err != KErrNone || softHeapLimitKb < 0 || 
sl@0: 	   (softHeapLimitKb < TSqlSrvConfigParams::KMinSoftHeapLimitKb || softHeapLimitKb > TSqlSrvConfigParams::KMaxSoftHeapLimitKb))
sl@0: 		{					
sl@0: 		__SQLLEAVE2(KErrArgument);
sl@0: 		}
sl@0: 	return softHeapLimitKb;
sl@0: 	}
sl@0: 	
sl@0: //The function converts aParamValue to a numerical value (the database compaction mode) and returns it.
sl@0: TSqlCompactionMode TSqlSrvConfig::GetCompactionModeL(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TSqlCompactionMode compactionMode = ESqlCompactionNotSet;
sl@0: 	if(aParamValue.CompareF(KManual) == 0)
sl@0: 		{
sl@0: 		compactionMode = ESqlCompactionManual;
sl@0: 		}
sl@0: 	else if(aParamValue.CompareF(KBackground) == 0)
sl@0: 		{
sl@0: 		compactionMode = ESqlCompactionBackground;
sl@0: 		}
sl@0: 	else if(aParamValue.CompareF(KAuto) == 0 || aParamValue.CompareF(KSynchronous) == 0)
sl@0: 		{
sl@0: 		compactionMode = ESqlCompactionAuto;
sl@0: 		}
sl@0: 	//else
sl@0: 	//	{
sl@0: 	//	Invalid compaction mode
sl@0: 	//	}
sl@0: 	return compactionMode;
sl@0: 	}
sl@0: 
sl@0: //The function converts aParamValue to a numerical value (the free page threshold in pages) and returns it.
sl@0: TInt TSqlSrvConfig::GetFreePageThresholdL(const TDesC8& aParamValue)
sl@0: 	{
sl@0: 	TLex8 lex(aParamValue);
sl@0: 	TInt freePageThreshold = 0;
sl@0: 	TInt err = lex.Val(freePageThreshold);
sl@0: 	if(err != KErrNone || freePageThreshold < 0)
sl@0: 		{					
sl@0: 		__SQLLEAVE2(KErrArgument);
sl@0: 		}
sl@0: 	return freePageThreshold;
sl@0: 	}
sl@0: 	
sl@0: 
sl@0: //The function searches aStr for leading and trailing whitespace 
sl@0: //characters, then creates and returns TPtrC object which points to the 
sl@0: //aStr content without leading and trailing whitespace characters.
sl@0: TPtrC8 TSqlSrvConfig::TrimAndConstructPtr(const TUint8* aStr, TInt aLength)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aStr != NULL, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aLength >= 0, __SQLPANIC2(ESqlPanicBadArgument));
sl@0: 	//Trim left
sl@0: 	for(;aLength>0;--aLength,++aStr)
sl@0: 		{
sl@0: 		if(!TChar(*aStr).IsSpace())
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	//Trim right
sl@0: 	for(const TUint8* p=aStr+aLength-1;aLength>0;--aLength,--p)
sl@0: 		{
sl@0: 		if(!TChar(*p).IsSpace())
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	return TPtrC8(aStr, aLength);
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 	
sl@0: CDbConfigFiles* CDbConfigFiles::NewL(const CDir& aDirEntries)
sl@0: 	{
sl@0: 	CDbConfigFiles* self = new(ELeave) CDbConfigFiles();
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL(aDirEntries);	
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: CDbConfigFiles::CDbConfigFiles()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: void CDbConfigFiles::ConstructL(const CDir& aDirEntries)
sl@0: 	{	
sl@0: 	StoreFileNamesL(aDirEntries);
sl@0: 	}
sl@0: 	
sl@0: CDbConfigFiles::~CDbConfigFiles()
sl@0: 	{
sl@0: 	iConfigFileNames.ResetAndDestroy(); 
sl@0: 	}
sl@0: 	
sl@0: //Stores the names of the given database configuration files.
sl@0: //These files were found in the server's private data cage on 
sl@0: //the Z: drive and begin with the prefix 'cfg'
sl@0: void CDbConfigFiles::StoreFileNamesL(const CDir& aDirEntries)
sl@0: 	{
sl@0: 	//Store the file names in reverse alphabetical order so that
sl@0: 	//in FindConfigFile() if there is more than one version of the same
sl@0: 	//config file (which there shouldn't be) then the highest version
sl@0: 	//will be returned
sl@0: 	for(TInt i = aDirEntries.Count() - 1; i >= 0; --i)
sl@0: 		{
sl@0: 		const TEntry& entry = aDirEntries[i];
sl@0: 		if(!entry.IsDir())
sl@0: 			{
sl@0: 			HBufC* filename = entry.iName.AllocLC();
sl@0: 			iConfigFileNames.AppendL(filename);
sl@0: 			CleanupStack::Pop(); // filename
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: //Finds the configuration file corresponding to the given database, if one exists.
sl@0: //The database filename including the extension is passed as a parameter - for example,
sl@0: //[12345678]a.db. Note that if more than one version of a configuration file exists 
sl@0: //for the given database (which shouldn't happen) - for example, cfg[12345678]a.db.01 
sl@0: //and cfg[12345678]a.db.02 - then the highest version will be returned 
sl@0: HBufC* CDbConfigFiles::FindConfigFile(const TDesC& aDbFilename) const
sl@0: 	{	
sl@0: 	TInt count = iConfigFileNames.Count();
sl@0: 	for(TInt i = 0; i < count; ++i)
sl@0: 		{
sl@0: 		TInt offset = iConfigFileNames[i]->Des().FindF(aDbFilename);
sl@0: 		if(KErrNotFound != offset)
sl@0: 			{
sl@0: 			return iConfigFileNames[i];
sl@0: 			}
sl@0: 		}
sl@0: 	return NULL;
sl@0: 	}