Symaptic: os/persistentdata/persistentstorage/centralrepository/common/src/inifile.cpp@260cb5ec6c19 (annotated)

sl@0	1	// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15
sl@0	16	#define __INCLUDE_CAPABILITY_NAMES__
sl@0	17	#include <utf.h>
sl@0	18	#include "inifile.h"
sl@0	19	#include "datatype.h"
sl@0	20	#include "log.h"
sl@0	21
sl@0	22	#define MAX(a,b) ((a)<(b)?(b):(a))
sl@0	23	#define MAX3(a,b,c) MAX(MAX(a,b),c)
sl@0	24	#define MAX4(a,b,c,d) MAX(MAX(a,b),MAX(c,d))
sl@0	25
sl@0	26	//Unicode text file prefix - FE,FF bytes.
sl@0	27	static const TUint16 KUcs2Bom = 0xfeff;
sl@0	28
sl@0	29	//Repository (ini) file - signature
sl@0	30	_LIT(KSignature, "cenrep");
sl@0	31	static const TInt KSignatureLen = 6;
sl@0	32
sl@0	33	//Repository (ini) file - version string and version number
sl@0	34	_LIT(KVersion, "version");
sl@0	35	static const TInt KVersionLen = 7;
sl@0	36	static const TUint KCurrentVersion = 1;
sl@0	37
sl@0	38	//Repository (ini) file - supported types names
sl@0	39	_LIT(KTypeInt, "int");
sl@0	40	_LIT(KTypeReal, "real");
sl@0	41	_LIT(KTypeString, "string");
sl@0	42	_LIT(KTypeString8, "string8");
sl@0	43	_LIT(KTypeBinary, "binary");
sl@0	44
sl@0	45	//Max type name length
sl@0	46	static const TInt KMaxTypeLen = 9;
sl@0	47
sl@0	48	//The symbol used in repository (ini) files to note null data
sl@0	49	static const TChar KNullDataIndicator = '-';
sl@0	50
sl@0	51	// Section identifiers in the repository (ini) file
sl@0	52	_LIT(KPlatSecSection, "[platsec]");
sl@0	53	static const TInt KPlatSecSectionLen = 9;
sl@0	54
sl@0	55	_LIT(KOwnerSection, "[owner]");
sl@0	56	static const TInt KOwnerSectionLen = 7;
sl@0	57
sl@0	58	_LIT(KTimeStampSection, "[timestamp]");
sl@0	59	static const TInt KTimeStampSectionLen = 11;
sl@0	60
sl@0	61	_LIT(KMainSection, "[main]");
sl@0	62	static const TInt KMainSectionLen = 6;
sl@0	63
sl@0	64	_LIT(KDefaultMetaSection, "[defaultmeta]");
sl@0	65	static const TInt KDefaultMetaSectionLen = 13 ;
sl@0	66
sl@0	67	static const TInt KIniFileSectionLen = MAX4(KPlatSecSectionLen,KMainSectionLen,KTimeStampSectionLen, KDefaultMetaSectionLen);
sl@0	68
sl@0	69	// Other useful string constants
sl@0	70	_LIT(KMaskString, "mask");
sl@0	71	static const TInt KMaskLen = 4;
sl@0	72
sl@0	73	_LIT(KReadAccessSidString, "sid_rd");
sl@0	74	_LIT(KReadAccessCapString, "cap_rd");
sl@0	75	_LIT(KWriteAccessSidString, "sid_wr");
sl@0	76	_LIT(KWriteAccessCapString, "cap_wr");
sl@0	77	_LIT(KAccessAlwaysPass, "alwayspass");
sl@0	78	_LIT(KAccessAlwaysFail, "alwaysfail");
sl@0	79	// could do max of _LITs above
sl@0	80	static const TInt KMaxAccessTypeLen = 6;
sl@0	81
sl@0	82	// longest capability string from CapabilityNames is 15
sl@0	83	static const TInt KMaxCapabilityStringLen = 20;
sl@0	84
sl@0	85	static const TInt KBufLen = MAX3(KVersionLen, KSignatureLen, KIniFileSectionLen);
sl@0	86
sl@0	87
sl@0	88
sl@0	89	const TUint KCr = '\r';
sl@0	90	const TUint KTab = '\t';
sl@0	91	const TUint KSpace = ' ';
sl@0	92
sl@0	93	#ifdef CENTREP_CONV_TOOL
sl@0	94	_LIT(KTransactFileName, "transact");
sl@0	95	_LIT(KCrNl, "\r\n");
sl@0	96	_LIT(KHexIntFormat, "0x%X");
sl@0	97	_LIT(KUidFormat, "0x%08X");
sl@0	98	_LIT(KRangeMetaFmt, "0x%X 0x%X 0x%08X");
sl@0	99	_LIT(KMaskMetaFmt, "0x%X mask = 0x%X 0x%08X");
sl@0	100
sl@0	101	_LIT(KRangePrefix, "0x%X 0x%X");
sl@0	102	_LIT(KMaskPrefix, "0x%08X mask = 0x%08X");
sl@0	103	#endif
sl@0	104
sl@0	105	/////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	106	// Local functions
sl@0	107
sl@0	108	/**
sl@0	109	The function checks if the file with aFile name exists.
sl@0	110	@param aFile File name, including the full path.
sl@0	111	@return 0, if the file does not exist, non-zero value otherwise.
sl@0	112	@internalComponent
sl@0	113	*/
sl@0	114	/**
sl@0	115	#ifdef CENTREP_CONV_TOOL
sl@0	116	static TBool FileExists(const TDesC& aFile)
sl@0	117	{
sl@0	118	TEntry entry;
sl@0	119	return TServerResources::iFs.Entry(aFile, entry) == KErrNone;
sl@0	120	}
sl@0	121	#endif
sl@0	122	*/
sl@0	123
sl@0	124	/**
sl@0	125	@internalComponent
sl@0	126	*/
sl@0	127	static TInt ReadFileL(RFile aFile, HBufC16*& aBuf)
sl@0	128	{
sl@0	129	TInt size;
sl@0	130	TInt r = aFile.Size(size);
sl@0	131	if(r!=KErrNone)
sl@0	132	return r;
sl@0	133	if(size<2)
sl@0	134	return KErrCorrupt;
sl@0	135
sl@0	136	TInt len = size/2-1;
sl@0	137	aBuf = HBufC16::NewL(len);
sl@0	138	TPtr16 ptr16 = aBuf->Des();
sl@0	139	TPtr8 ptr8((TUint8*)ptr16.Ptr(), 0, 2);
sl@0	140	r = aFile.Read(ptr8, 2);
sl@0	141	if(r!=KErrNone)
sl@0	142	return r;
sl@0	143
sl@0	144	if(*ptr16.Ptr()!=KUcs2Bom)
sl@0	145	{
sl@0	146	__CENTREP_TRACE("File not Ucs2. No BOM");
sl@0	147	return KErrCorrupt;
sl@0	148	}
sl@0	149	ptr8.Set((TUint8*)ptr16.Ptr(), 0, size-2);
sl@0	150	r = aFile.Read(ptr8);
sl@0	151	if(r!=KErrNone)
sl@0	152	return r;
sl@0	153	ptr16.SetLength(len);
sl@0	154
sl@0	155	return KErrNone;
sl@0	156	}
sl@0	157
sl@0	158	static TBool IsNegativeNumber(TLex& aLex)
sl@0	159	{
sl@0	160	if (aLex.Peek()=='-')
sl@0	161	return ETrue;
sl@0	162	else
sl@0	163	return EFalse;
sl@0	164	}
sl@0	165
sl@0	166	/**
sl@0	167	@internalComponent
sl@0	168	*/
sl@0	169	static TInt ReadNumberL(TLex& aLex, TUint32& aVal)
sl@0	170	{
sl@0	171	TRadix radix = EDecimal;
sl@0	172	if(aLex.Peek()=='0')
sl@0	173	{
sl@0	174	aLex.Inc();
sl@0	175	if(aLex.Peek().GetLowerCase()=='x')
sl@0	176	{
sl@0	177	aLex.Inc();
sl@0	178	radix = EHex;
sl@0	179	}
sl@0	180	else
sl@0	181	aLex.UnGet();
sl@0	182	}
sl@0	183
sl@0	184	if(aLex.Val(aVal, radix)!=KErrNone)
sl@0	185	return KErrCorrupt;
sl@0	186
sl@0	187	return KErrNone;
sl@0	188	}
sl@0	189
sl@0	190	#ifdef CENTREP_CONV_TOOL
sl@0	191	/**
sl@0	192	@internalComponent
sl@0	193	*/
sl@0	194	static void WriteBinary(TDes& aBuf, const HBufC8* aString)
sl@0	195	{
sl@0	196	if(aString)
sl@0	197	{
sl@0	198	TInt len = aString->Length();
sl@0	199	if(len==0)
sl@0	200	aBuf.Append(KNullDataIndicator);
sl@0	201	else
sl@0	202	{
sl@0	203	TPtr8 ptr8 = const_cast<HBufC8*>(aString)->Des();
sl@0	204	for(TInt i=0;i<len;i++)
sl@0	205	aBuf.AppendNumFixedWidth(ptr8[i], EHex, 2);
sl@0	206	}
sl@0	207	}
sl@0	208	else
sl@0	209	{
sl@0	210	aBuf.Append(KNullDataIndicator);
sl@0	211	}
sl@0	212	}
sl@0	213
sl@0	214	/**
sl@0	215	The function writes setting value into the supplied buffer (aBuf).
sl@0	216	@param aBuf The buffer where the setting value will be appended.
sl@0	217	@param aSetting Reference to the setting object
sl@0	218	@leave KErrGeneral If the supplied setting object has unknown type.
sl@0	219	@internalComponent
sl@0	220	*/
sl@0	221	static void AddSettingValueL(TDes& aBuf, const TServerSetting& aSetting)
sl@0	222	{
sl@0	223	switch(aSetting.Type())
sl@0	224	{
sl@0	225	case TServerSetting::EInt:
sl@0	226	aBuf.Append(KTypeInt);
sl@0	227	aBuf.Append(KSpace);
sl@0	228	aBuf.AppendNum(aSetting.GetIntValue());
sl@0	229	break;
sl@0	230	case TServerSetting::EReal:
sl@0	231	aBuf.Append(KTypeReal);
sl@0	232	aBuf.Append(KSpace);
sl@0	233	aBuf.AppendNum(aSetting.GetRealValue(), TRealFormat());
sl@0	234	break;
sl@0	235	case TServerSetting::EString:
sl@0	236	aBuf.Append(KTypeBinary);
sl@0	237	aBuf.Append(KSpace);
sl@0	238	WriteBinary(aBuf, aSetting.GetStrValue());
sl@0	239	break;
sl@0	240	default:
sl@0	241	User::Leave(KErrGeneral); //unknown setting type
sl@0	242	break;
sl@0	243	}
sl@0	244	}
sl@0	245	#endif
sl@0	246
sl@0	247	/////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	248	// CIniFileIn class
sl@0	249
sl@0	250	TInt CIniFileIn::NewLC(RFs& aFs,CIniFileIn*& aIniFile,const TDesC& aFullFileName)
sl@0	251	{
sl@0	252	aIniFile = new(ELeave) CIniFileIn(aFs);
sl@0	253	CleanupStack::PushL(aIniFile);
sl@0	254	RFile file;
sl@0	255	CleanupClosePushL(file);
sl@0	256	TInt r = file.Open(aFs, aFullFileName, EFileRead\|EFileStreamText);
sl@0	257	if(r==KErrNone)
sl@0	258	{
sl@0	259
sl@0	260	#ifdef CENTREP_TRACE
sl@0	261	aIniFile->iFullName = HBufC::NewL(aFullFileName.Length());
sl@0	262	TPtr filename = aIniFile->iFullName->Des();
sl@0	263	filename.Copy(aFullFileName);
sl@0	264	#endif
sl@0	265	TInt rReadFile = ReadFileL(file,aIniFile->iBuf);
sl@0	266	CleanupStack::PopAndDestroy(); //file
sl@0	267	TInt rReadHeader=KErrNone;
sl@0	268	if(rReadFile==KErrNone)
sl@0	269	{
sl@0	270	aIniFile->iLex.Assign(aIniFile->iBuf->Des());
sl@0	271	rReadHeader=aIniFile->ReadHeaderL();
sl@0	272	}
sl@0	273
sl@0	274	if((rReadFile==KErrCorrupt) \|\| ( rReadHeader==KErrCorrupt))
sl@0	275	{
sl@0	276	return KErrCorrupt;
sl@0	277	}
sl@0	278	}
sl@0	279	else
sl@0	280	{
sl@0	281	CleanupStack::Pop();//file
sl@0	282	}
sl@0	283	return r;
sl@0	284
sl@0	285
sl@0	286	}
sl@0	287
sl@0	288	CIniFileIn::~CIniFileIn()
sl@0	289	{
sl@0	290	delete iBuf;
sl@0	291	#ifdef CENTREP_TRACE
sl@0	292	delete iFullName;
sl@0	293	#endif
sl@0	294	}
sl@0	295
sl@0	296
sl@0	297	TInt CIniFileIn::ReadHeaderL()
sl@0	298	{
sl@0	299	TBuf<KBufLen> buf;
sl@0	300
sl@0	301	//
sl@0	302	// Check file signature
sl@0	303	//
sl@0	304
sl@0	305	SkipComments();
sl@0	306
sl@0	307	iLex.Mark();
sl@0	308	iLex.SkipCharacters();
sl@0	309
sl@0	310	if(iLex.TokenLength()>KSignatureLen)
sl@0	311	{
sl@0	312	__CENTREP_TRACE1("[%S] Invalid header signature",iFullName);
sl@0	313	return(KErrCorrupt);
sl@0	314	}
sl@0	315	buf.CopyLC(iLex.MarkedToken());
sl@0	316	if(buf.Compare(KSignature)!=0)
sl@0	317	{
sl@0	318	__CENTREP_TRACE1("[%S] Invalid header signature",iFullName);
sl@0	319	return(KErrCorrupt);
sl@0	320	}
sl@0	321	//
sl@0	322	// Check file version
sl@0	323	//
sl@0	324
sl@0	325	SkipComments();
sl@0	326
sl@0	327	iLex.Mark();
sl@0	328	iLex.SkipCharacters();
sl@0	329
sl@0	330	if(iLex.TokenLength()>KVersionLen)
sl@0	331	{
sl@0	332	__CENTREP_TRACE1("[%S] Missing version keyword",iFullName);
sl@0	333	return(KErrCorrupt);
sl@0	334	}
sl@0	335	buf.CopyLC(iLex.MarkedToken());
sl@0	336	if(buf.Compare(KVersion)!=0)
sl@0	337	{
sl@0	338	__CENTREP_TRACE1("[%S] Missing version keyword",iFullName);
sl@0	339	return(KErrCorrupt);
sl@0	340	}
sl@0	341	iLex.SkipSpace();
sl@0	342
sl@0	343	TUint version;
sl@0	344	iLex.Val(version);
sl@0	345	if(version>KCurrentVersion)
sl@0	346	{
sl@0	347	__CENTREP_TRACE1("[%S] Invalid version number",iFullName);
sl@0	348	return(KErrNotSupported);
sl@0	349	}
sl@0	350	return( KErrNone);
sl@0	351	}
sl@0	352
sl@0	353	void CIniFileIn::SkipComments()
sl@0	354	{
sl@0	355	for(;;)
sl@0	356	{
sl@0	357	iLex.SkipSpace();
sl@0	358
sl@0	359	if(iLex.Peek()!='#')
sl@0	360	break;
sl@0	361
sl@0	362	while(iLex.Get()!='\n' && !iLex.Eos()) {}
sl@0	363	}
sl@0	364	}
sl@0	365
sl@0	366	void CIniFileIn::SkipEqualSign()
sl@0	367	{
sl@0	368	iLex.SkipSpace();
sl@0	369	if(iLex.Peek()=='=')
sl@0	370	iLex.Get();
sl@0	371
sl@0	372	iLex.SkipSpace();
sl@0	373	}
sl@0	374
sl@0	375	TInt CIniFileIn::ReadSettingOnlyL(TServerSetting& aSetting,TBool& aSingleMetaFound)
sl@0	376	{
sl@0	377	TInt ret = KErrNone;
sl@0	378
sl@0	379	aSingleMetaFound=EFalse;
sl@0	380
sl@0	381	SkipComments();
sl@0	382	iLex.SkipSpace();
sl@0	383
sl@0	384	if(iLex.Eos())
sl@0	385	return KErrNotFound;
sl@0	386
sl@0	387	TUint32 key;
sl@0	388	TInt r=ReadNumberL(iLex, key);
sl@0	389	if(r!=KErrNone)
sl@0	390	{
sl@0	391	// returns either KErrCorrupt or KErrNone
sl@0	392	__CENTREP_TRACE1("[%S] Invalid single setting id",iFullName);
sl@0	393	return r;
sl@0	394	}
sl@0	395	aSetting.SetKey(key);
sl@0	396
sl@0	397	iLex.SkipSpaceAndMark();
sl@0	398	iLex.SkipCharacters();
sl@0	399
sl@0	400	if(iLex.TokenLength()>KMaxTypeLen)
sl@0	401	{
sl@0	402	__CENTREP_TRACE1("[%S] Invalid key type, must be one of: [int,real,string,string8,binary]",iFullName);
sl@0	403	return KErrCorrupt;
sl@0	404	}
sl@0	405	TBuf<KMaxTypeLen> type;
sl@0	406	type.CopyLC(iLex.MarkedToken());
sl@0	407
sl@0	408	iLex.SkipSpace();
sl@0	409
sl@0	410	if(type.Compare(KTypeInt)==0)
sl@0	411	{
sl@0	412	if (IsNegativeNumber(iLex))
sl@0	413	{
sl@0	414	TInt i;
sl@0	415	if(iLex.Val(i)!=KErrNone)
sl@0	416	{
sl@0	417	__CENTREP_TRACE1("[%S] Invalid negative integer value",iFullName);
sl@0	418	return(KErrCorrupt);
sl@0	419	}
sl@0	420	aSetting.SetIntValue(i);
sl@0	421	}
sl@0	422	else
sl@0	423	{
sl@0	424	TUint32 i;
sl@0	425	TInt r=ReadNumberL(iLex, i);
sl@0	426	if(r!=KErrNone)
sl@0	427	{
sl@0	428	__CENTREP_TRACE1("[%S] Invalid integer value",iFullName);
sl@0	429	return r;
sl@0	430	}
sl@0	431	aSetting.SetIntValue(i);
sl@0	432	}
sl@0	433	}
sl@0	434	else if(type.Compare(KTypeReal)==0)
sl@0	435	{
sl@0	436	TReal r;
sl@0	437	ret=iLex.Val(r,'.');
sl@0	438	//iLex.Val with TReal can return KErrNoMemory
sl@0	439	if (ret!=KErrNone)
sl@0	440	{
sl@0	441	if (ret==KErrNoMemory)
sl@0	442	User::LeaveNoMemory();
sl@0	443	else
sl@0	444	{
sl@0	445	__CENTREP_TRACE1("[%S] Invalid real value",iFullName);
sl@0	446	return KErrCorrupt;
sl@0	447	}
sl@0	448	}
sl@0	449	TReal* temp = new(ELeave)TReal(r);
sl@0	450	aSetting.SetRealValue(temp);
sl@0	451	temp = NULL;
sl@0	452	}
sl@0	453	else if(type.Compare(KTypeString)==0)
sl@0	454	{
sl@0	455	HBufC8* s;
sl@0	456	ret = ReadStringL(s);
sl@0	457	if(ret != KErrNone)
sl@0	458	{
sl@0	459	__CENTREP_TRACE1("[%S] Invalid string value",iFullName);
sl@0	460	return KErrCorrupt;
sl@0	461	}
sl@0	462	aSetting.SetStrValue(s);
sl@0	463	}
sl@0	464
sl@0	465	else if(type.Compare(KTypeString8)==0)
sl@0	466	{
sl@0	467	HBufC8* s;
sl@0	468	ret = ReadString16To8L(s);
sl@0	469	if(ret != KErrNone)
sl@0	470	{
sl@0	471	__CENTREP_TRACE1("[%S] Invalid string8 value",iFullName);
sl@0	472	return KErrCorrupt;
sl@0	473	}
sl@0	474	aSetting.SetStrValue(s);
sl@0	475	}
sl@0	476
sl@0	477	else if(type.Compare(KTypeBinary)==0)
sl@0	478	{
sl@0	479	HBufC8* s = NULL;
sl@0	480	ret = ReadBinaryL(s);
sl@0	481	if(ret != KErrNone)
sl@0	482	{
sl@0	483	__CENTREP_TRACE1("[%S] Invalid binary value",iFullName);
sl@0	484	return KErrCorrupt;
sl@0	485	}
sl@0	486	aSetting.SetStrValue(s);
sl@0	487	}
sl@0	488	else
sl@0	489	{
sl@0	490	__CENTREP_TRACE1("[%S] Invalid key type, must be one of: [int,real,string,string8,binary]",iFullName);
sl@0	491	return KErrCorrupt;
sl@0	492	}
sl@0	493	//skip any spaces or tabs
sl@0	494	while(iLex.Peek()==KSpace \|\| iLex.Peek()==KTab)
sl@0	495	{
sl@0	496	iLex.Inc();
sl@0	497	}
sl@0	498
sl@0	499	TUint32 meta;
sl@0	500
sl@0	501	/**
sl@0	502	carriage return reached which means that there is no meta AND capabilities
sl@0	503	defined for this key. Thus setting meta to NULL to be able to set a value
sl@0	504	from default section later.
sl@0	505	*/
sl@0	506	if (iLex.Peek()==KCr)
sl@0	507	{
sl@0	508	meta = 0;
sl@0	509	}
sl@0	510	else
sl@0	511	{
sl@0	512	r=ReadNumberL(iLex, meta);
sl@0	513	/**
sl@0	514	If meta can not be read, it is not neccessary an error.
sl@0	515	It might be not present for an individual key and it will be taken
sl@0	516	from a default section.
sl@0	517	If single meta is present, we need to remember so we can recognise a single
sl@0	518	meta of 0 as distinct from no meta ( also sets meta to 0 ).
sl@0	519	*/
sl@0	520	if(r!=KErrNone)
sl@0	521	meta = 0;
sl@0	522	else
sl@0	523	aSingleMetaFound=ETrue;
sl@0	524	}
sl@0	525
sl@0	526	aSetting.SetMeta(meta);
sl@0	527
sl@0	528	return KErrNone;
sl@0	529	}
sl@0	530
sl@0	531	/**
sl@0	532	Read an entire DefaultMeta section from ini file
sl@0	533	and create FDefault metadata entries
sl@0	534
sl@0	535	@internalTechnology
sl@0	536	@return KErrNone, KErrCorrupt or KErrNotFound
sl@0	537	*/
sl@0	538	TInt CIniFileIn::ReadDefaultMetaSecSectionL(TUint32& aDefaultMeta, RDefaultMetaArray& aDefaultMetaRanges)
sl@0	539	{
sl@0	540	TBuf<KBufLen> buf;
sl@0	541
sl@0	542	//
sl@0	543	// Check if a DefaultMeta section is present
sl@0	544	//
sl@0	545
sl@0	546	SkipComments();
sl@0	547
sl@0	548	// we will need this section later to write the out file...
sl@0	549	iLex.Mark(iMainSectionMark);
sl@0	550
sl@0	551	iLex.Mark();
sl@0	552	iLex.SkipCharacters();
sl@0	553
sl@0	554	if( iLex.TokenLength()!=KDefaultMetaSectionLen \|\|
sl@0	555	(buf.CopyLC( iLex.MarkedToken() ), buf.Compare( KDefaultMetaSection )!=0) )
sl@0	556	{
sl@0	557	// Meta not available
sl@0	558	iLex.UnGetToMark();
sl@0	559	return KErrNotFound;
sl@0	560	}
sl@0	561
sl@0	562	//
sl@0	563	// Lets read Meta settings
sl@0	564	//
sl@0	565
sl@0	566	SkipComments();
sl@0	567
sl@0	568	// we might have a default Meta section first
sl@0	569	if(KErrNone != ReadNumber(aDefaultMeta))
sl@0	570	{
sl@0	571	// should we log that no default read policy?
sl@0	572	}
sl@0	573
sl@0	574
sl@0	575	// now lets try range policies
sl@0	576	TInt r=ReadRangeMetaDefaultsL(aDefaultMetaRanges);
sl@0	577	if(r!=KErrNone)
sl@0	578	{
sl@0	579	__CENTREP_TRACE1("[%S] Error parsing [defaultMeta]",iFullName);
sl@0	580	return r;
sl@0	581	}
sl@0	582	iLex.Mark(iMainSectionMark);
sl@0	583	return KErrNone;
sl@0	584	}
sl@0	585
sl@0	586
sl@0	587	/**
sl@0	588	Reads Meta defaults as defined for range of indexes
sl@0	589
sl@0	590	@internalTechnology
sl@0	591	@return KErrNone, KErrCorrupt
sl@0	592	*/
sl@0	593	TInt CIniFileIn::ReadRangeMetaDefaultsL(RDefaultMetaArray& aDefaultMetaRanges)
sl@0	594	{
sl@0	595	TUint32 lowKey = 0;
sl@0	596	TBuf<KBufLen> buf;
sl@0	597
sl@0	598	SkipComments();
sl@0	599	while(KErrNone == ReadNumber(lowKey))
sl@0	600	{
sl@0	601	// highKey and mask needs to be zero'd every cycle...
sl@0	602	TUint32 highKey = 0;
sl@0	603	TUint32 mask = 0;
sl@0	604	TUint32 defaultMeta = 0 ;
sl@0	605
sl@0	606	iLex.SkipSpace();
sl@0	607	// may be not range but key & mask so lets check 'mask' keyword
sl@0	608	if(!iLex.Peek().IsDigit())
sl@0	609	{
sl@0	610	//so should be mask then...
sl@0	611	iLex.Mark();
sl@0	612	while((iLex.Peek()!='=')&&(!iLex.Eos()))
sl@0	613	{
sl@0	614	iLex.Inc();
sl@0	615
sl@0	616	if(iLex.TokenLength() >= KMaskLen)
sl@0	617	{
sl@0	618	// so no '=' there
sl@0	619	// not necessarily bad thing... could be space there first
sl@0	620	break;
sl@0	621	}
sl@0	622
sl@0	623	}
sl@0	624
sl@0	625	// check if KMaskLen is < buf length?
sl@0	626	buf.CopyLC(iLex.MarkedToken());
sl@0	627	if(buf.Compare(KMaskString)!=0)
sl@0	628	{
sl@0	629	__CENTREP_TRACE1("[%S] Missing 'mask' keyword [defaultMeta]",iFullName);
sl@0	630	return KErrCorrupt;
sl@0	631	}
sl@0	632
sl@0	633	iLex.SkipSpace();
sl@0	634	if('=' != iLex.Get())
sl@0	635	{
sl@0	636	__CENTREP_TRACE1("[%S] Missing '=' for 'mask' keyword [defaultMeta]",iFullName);
sl@0	637	return KErrCorrupt;
sl@0	638	}
sl@0	639	iLex.SkipSpace();
sl@0	640	TInt r=ReadNumberL(iLex,mask);
sl@0	641	if(r!=KErrNone)
sl@0	642	{
sl@0	643	__CENTREP_TRACE1("[%S] Invalid 'mask' for keyspace range [defaultMeta]",iFullName);
sl@0	644	return KErrCorrupt;
sl@0	645	}
sl@0	646	}
sl@0	647	else
sl@0	648	{
sl@0	649	TInt r = ReadNumberL(iLex,highKey);
sl@0	650	if(r!=KErrNone)
sl@0	651	{
sl@0	652	__CENTREP_TRACE1("[%S] Invalid end of range [defaultMeta]",iFullName);
sl@0	653	return KErrCorrupt;
sl@0	654	}
sl@0	655	}
sl@0	656
sl@0	657
sl@0	658	if(KErrNone == ReadNumber(defaultMeta))
sl@0	659	{
sl@0	660	TSettingsDefaultMeta metaDefault(defaultMeta,lowKey, highKey, mask);
sl@0	661	aDefaultMetaRanges.AppendL(metaDefault);
sl@0	662	}
sl@0	663	else
sl@0	664	{
sl@0	665	// unfortunately, we can't tell if we got here because the default
sl@0	666	// meta was bad or because there was an invalid start value for the range.
sl@0	667	__CENTREP_TRACE1("[%S] Range defined without default or bad start of range [defaultMeta]",iFullName);
sl@0	668	// range specified with no default Meta!
sl@0	669	return KErrCorrupt;
sl@0	670	}
sl@0	671	SkipComments();
sl@0	672	}
sl@0	673	return KErrNone;
sl@0	674	}
sl@0	675
sl@0	676	/**
sl@0	677	Read Owner section from ini file and extract owner UID
sl@0	678
sl@0	679	@internalTechnology
sl@0	680	@return KErrNone, KErrCorrupt or KErrNotFound
sl@0	681	*/
sl@0	682	TInt CIniFileIn::ReadOwnerSectionL(TUint32 &aOwnerUID)
sl@0	683	{
sl@0	684	TBuf<KBufLen> buf;
sl@0	685
sl@0	686
sl@0	687
sl@0	688	SkipComments();
sl@0	689
sl@0	690	// we will need this section later to write the out file...
sl@0	691	iLex.Mark(iMainSectionMark);
sl@0	692
sl@0	693	iLex.Mark();
sl@0	694	iLex.SkipCharacters();
sl@0	695
sl@0	696	if( iLex.TokenLength()!=KOwnerSectionLen \|\|
sl@0	697	(buf.CopyLC( iLex.MarkedToken() ), buf.Compare( KOwnerSection )!=0) )
sl@0	698	{
sl@0	699	// Owner section not available
sl@0	700	iLex.UnGetToMark();
sl@0	701	return KErrNotFound;
sl@0	702	}
sl@0	703	else
sl@0	704	{
sl@0	705	// Found an "owner" section - must be followed by a UID (hex number
sl@0	706	// in format 0xnnnnn) to be valid!
sl@0	707	iLex.SkipSpace() ;
sl@0	708	if(iLex.Peek()=='0')
sl@0	709	{
sl@0	710	iLex.Inc();
sl@0	711	if(iLex.Peek().GetLowerCase()=='x')
sl@0	712	{
sl@0	713	iLex.Inc();
sl@0	714	if(iLex.Val(aOwnerUID, EHex)!=KErrNone)
sl@0	715	{
sl@0	716	__CENTREP_TRACE1("[%S] Invalid owner UID not valid hex digit [owner]",iFullName);
sl@0	717	return KErrCorrupt;
sl@0	718	}
sl@0	719	}
sl@0	720	else
sl@0	721	{
sl@0	722	__CENTREP_TRACE1("[%S] Invalid owner UID not valid hex digit [owner]",iFullName);
sl@0	723	return KErrCorrupt;
sl@0	724	}
sl@0	725	}
sl@0	726	else
sl@0	727	{
sl@0	728	__CENTREP_TRACE1("[%S] Invalid owner UID not valid hex digit [owner]",iFullName);
sl@0	729	return KErrCorrupt;
sl@0	730	}
sl@0	731	}
sl@0	732
sl@0	733	iLex.Mark(iMainSectionMark);
sl@0	734
sl@0	735	return KErrNone;
sl@0	736	}
sl@0	737
sl@0	738	/**
sl@0	739	Read Timestamp section from ini file and extract value as a TTime
sl@0	740
sl@0	741	@internalTechnology
sl@0	742	@return KErrNone, KErrCorrupt or KErrNotFound
sl@0	743	*/
sl@0	744	TInt CIniFileIn::ReadTimeStampSectionL(TTime &aTimeStamp)
sl@0	745	{
sl@0	746	TBuf<25> buf;
sl@0	747	SkipComments();
sl@0	748
sl@0	749	// we will need this section later to write the out file...
sl@0	750	iLex.Mark(iMainSectionMark);
sl@0	751
sl@0	752	iLex.Mark();
sl@0	753	iLex.SkipCharacters();
sl@0	754
sl@0	755	buf.CopyLC( iLex.MarkedToken());
sl@0	756
sl@0	757	if( iLex.TokenLength()!=KTimeStampSectionLen \|\|
sl@0	758	(buf.Compare( KTimeStampSection )!=0) )
sl@0	759	{
sl@0	760	// Timestamp section not available
sl@0	761	iLex.UnGetToMark();
sl@0	762	return KErrNotFound;
sl@0	763	}
sl@0	764	else
sl@0	765	{
sl@0	766	// Found a "timestamp" section - must be followed by a a timestamp
sl@0	767	// either in format...
sl@0	768	//
sl@0	769	// YYYYMMDD:HHMMSS.MMMMMM where:
sl@0	770	// YYYY = 4 digit year
sl@0	771	// MM = 2 digit numeric month
sl@0	772	// DD = 2 digit numeric date
sl@0	773	// HH = 2 digit hour
sl@0	774	// MM = 2 digit minute
sl@0	775	// SS = 2 digit second
sl@0	776	// MMMMMM = 6 digit microseconds
sl@0	777	// Note that this is the format used for constructing/initialising
sl@0	778	// a TTime from a string.
sl@0	779	//
sl@0	780	// ...or a 64-bit integer which can be converted to
sl@0	781	// to a TTime to be considered valid!
sl@0	782	//
sl@0	783	iLex.SkipSpace();
sl@0	784	iLex.Mark();
sl@0	785	iLex.SkipCharacters() ;
sl@0	786
sl@0	787	buf.CopyLC(iLex.MarkedToken()) ;
sl@0	788	if (aTimeStamp.Set(buf) !=KErrNone)
sl@0	789	{
sl@0	790	TInt64 intTimeStamp ;
sl@0	791	iLex.UnGetToMark();
sl@0	792	if (iLex.Val(intTimeStamp) != KErrNone)
sl@0	793	{
sl@0	794	__CENTREP_TRACE1("[%S] Invalid time stamp [timestamp]",iFullName);
sl@0	795	return KErrCorrupt;
sl@0	796	}
sl@0	797	else
sl@0	798	{
sl@0	799	aTimeStamp = intTimeStamp;
sl@0	800	}
sl@0	801	}
sl@0	802	}
sl@0	803	iLex.Mark(iMainSectionMark);
sl@0	804	return KErrNone;
sl@0	805	}
sl@0	806
sl@0	807	/**
sl@0	808	Read a setting and it's single policy ( if it exists )
sl@0	809
sl@0	810	@internalTechnology
sl@0	811	@return KErrNone, KErrCorrupt
sl@0	812	aSetting setting read from ini file
sl@0	813	aSingleReadPolicy single read policy if any
sl@0	814	aSingleWritePolicy single write policy if any
sl@0	815	aSingleReadPolicyFound ETrue if single read policy found with this key, EFalse if not
sl@0	816	aSingleWritePolicyFound ETrue if single write policy found with this key, EFalse if not
sl@0	817	aSingleMetaFound ETrue if single metadata found with this key, EFalse if not
sl@0	818	*/
sl@0	819	TInt CIniFileIn::ReadSettingL(TServerSetting& aSetting,TSecurityPolicy& aSingleReadPolicy,TSecurityPolicy& aSingleWritePolicy, TBool& aSingleReadPolicyFound, TBool& aSingleWritePolicyFound, TBool& aSingleMetaFound)
sl@0	820	{
sl@0	821	aSingleReadPolicyFound = EFalse;
sl@0	822	aSingleWritePolicyFound = EFalse;
sl@0	823
sl@0	824	TInt error = ReadSettingOnlyL(aSetting, aSingleMetaFound);
sl@0	825	if(KErrNone == error)
sl@0	826	{
sl@0	827	//Need to push into cleanupstack for string setting
sl@0	828	aSetting.PushL();
sl@0	829	// when multiple policies enabled then read in a loop
sl@0	830
sl@0	831	if (iLex.Peek() !=KCr)
sl@0	832	{
sl@0	833	// if neither read/write policy found we do not create TSettingsAccessPolicy at all...
sl@0	834	TInt err=ReadRdPolicyL(aSingleReadPolicy);
sl@0	835	if (err==KErrNone)
sl@0	836	aSingleReadPolicyFound=ETrue;
sl@0	837	else
sl@0	838	{
sl@0	839	//we need to return error code rather than assuming no single policy is found
sl@0	840	if (err==KErrCorrupt \|\| err==KErrNoMemory)
sl@0	841	{
sl@0	842	#ifdef CENTREP_TRACE
sl@0	843	if (err == KErrCorrupt)
sl@0	844	{
sl@0	845	__CENTREP_TRACE1("[%S] Invalid read setting",iFullName);
sl@0	846	}
sl@0	847	#endif
sl@0	848	aSetting.PopAndDestroy();
sl@0	849	return err;
sl@0	850	}
sl@0	851	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	852	//the state of the writePolicyFound to EFalse
sl@0	853	}
sl@0	854
sl@0	855	err=ReadWrPolicyL(aSingleWritePolicy);
sl@0	856	if (err==KErrNone)
sl@0	857	aSingleWritePolicyFound=ETrue;
sl@0	858	else
sl@0	859	{
sl@0	860	//we need to return error code rather than assuming no single policy is found
sl@0	861	if (err==KErrCorrupt \|\| err==KErrNoMemory)
sl@0	862	{
sl@0	863	#ifdef CENTREP_TRACE
sl@0	864	if (err == KErrCorrupt)
sl@0	865	{
sl@0	866	__CENTREP_TRACE1("[%S] Invalid write setting",iFullName);
sl@0	867	}
sl@0	868	#endif
sl@0	869	aSetting.PopAndDestroy();
sl@0	870	return err;
sl@0	871	}
sl@0	872	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	873	//the state of the writePolicyFound to EFalse
sl@0	874	}
sl@0	875	}
sl@0	876
sl@0	877	//Need to pop back the setting
sl@0	878	aSetting.Pop();
sl@0	879	}
sl@0	880	return error;
sl@0	881	}
sl@0	882
sl@0	883	TInt CIniFileIn::SkipPlatSecSectionL()
sl@0	884	{
sl@0	885	HBufC* platSecSection;
sl@0	886	TInt r=GetPlatSecSectionLC(platSecSection);
sl@0	887	if(platSecSection)
sl@0	888	CleanupStack::PopAndDestroy(platSecSection);
sl@0	889	return r;
sl@0	890	}
sl@0	891
sl@0	892	TInt CIniFileIn::SkipOwnerSectionL()
sl@0	893	{
sl@0	894	HBufC* ownerSection;
sl@0	895	TInt r=GetOwnerSectionLC(ownerSection);
sl@0	896	if(ownerSection)
sl@0	897	CleanupStack::PopAndDestroy(ownerSection);
sl@0	898	return r;
sl@0	899	}
sl@0	900
sl@0	901	TInt CIniFileIn::SkipDefaultMetaSectionL()
sl@0	902	{
sl@0	903	HBufC* section;
sl@0	904	TInt r=GetDefaultMetaSectionLC(section);
sl@0	905	if(section)
sl@0	906	CleanupStack::PopAndDestroy(section);
sl@0	907	return r;
sl@0	908	}
sl@0	909
sl@0	910	TInt CIniFileIn::SkipTimeStampSectionL()
sl@0	911	{
sl@0	912	HBufC* timeStampSection;
sl@0	913	TInt r=GetTimeStampSectionLC(timeStampSection);
sl@0	914	if(timeStampSection)
sl@0	915	CleanupStack::PopAndDestroy(timeStampSection);
sl@0	916	return r;
sl@0	917	}
sl@0	918
sl@0	919	/**
sl@0	920	Read an entire PlatSec section from ini file
sl@0	921	and create TSecurityPolicy for default access and for range of indexes
sl@0	922
sl@0	923	@internalTechnology
sl@0	924	@return KErrNone, KErrCorrupt or KErrNotFound
sl@0	925	*/
sl@0	926	TInt CIniFileIn::ReadPlatSecSectionL(TSecurityPolicy& aDefaultReadPolicy, TBool& aGotDefaultReadPolicy,
sl@0	927	TSecurityPolicy& aDefaultWritePolicy, TBool& aGotDefaultWritePolicy,
sl@0	928	RRangePolicyArray& aRangePolicies)
sl@0	929
sl@0	930	{
sl@0	931	TBuf<KBufLen> buf;
sl@0	932
sl@0	933	aGotDefaultReadPolicy = EFalse ;
sl@0	934	aGotDefaultWritePolicy = EFalse ;
sl@0	935
sl@0	936	//
sl@0	937	// Check if the PlatSec section is present
sl@0	938	//
sl@0	939	SkipComments();
sl@0	940
sl@0	941	// we will need this section later to write the out file...
sl@0	942	iLex.Mark(iMainSectionMark);
sl@0	943
sl@0	944	iLex.Mark();
sl@0	945	iLex.SkipCharacters();
sl@0	946
sl@0	947	if( iLex.TokenLength()!=KPlatSecSectionLen \|\|
sl@0	948	(buf.CopyLC( iLex.MarkedToken() ), buf.Compare( KPlatSecSection )!=0) )
sl@0	949	{
sl@0	950	// PlatSec section not available
sl@0	951	iLex.UnGetToMark();
sl@0	952	return KErrNotFound;
sl@0	953	}
sl@0	954
sl@0	955	//
sl@0	956	// Lets read the policies
sl@0	957	//
sl@0	958
sl@0	959	SkipComments();
sl@0	960	TInt r=KErrNone;
sl@0	961	// we might have a default policies first
sl@0	962	// check for default read policy
sl@0	963	r=ReadRdPolicyL(aDefaultReadPolicy);
sl@0	964	if (r==KErrNone)
sl@0	965	aGotDefaultReadPolicy=ETrue;
sl@0	966	else
sl@0	967	{
sl@0	968	//we need to return error code rather than assuming no default policy is found
sl@0	969	if (r==KErrCorrupt \|\| r==KErrNoMemory)
sl@0	970	{
sl@0	971	#ifdef CENTREP_TRACE
sl@0	972	if (r == KErrCorrupt)
sl@0	973	{
sl@0	974	__CENTREP_TRACE1("[%S] Invalid read policy [platsec]",iFullName);
sl@0	975	}
sl@0	976	#endif
sl@0	977	return r;
sl@0	978	}
sl@0	979	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	980	//the state of the writePolicyFound to EFalse
sl@0	981	}
sl@0	982	// check for default write policy
sl@0	983	r=ReadWrPolicyL(aDefaultWritePolicy);
sl@0	984	if (r==KErrNone)
sl@0	985	aGotDefaultWritePolicy=ETrue;
sl@0	986	else
sl@0	987	{
sl@0	988	//we need to return error code rather than assuming no default policy is found
sl@0	989	if (r==KErrCorrupt \|\| r==KErrNoMemory)
sl@0	990	{
sl@0	991	#ifdef CENTREP_TRACE
sl@0	992	if (r == KErrCorrupt)
sl@0	993	{
sl@0	994	__CENTREP_TRACE1("[%S] Invalid write policy [platsec]",iFullName);
sl@0	995	}
sl@0	996	#endif
sl@0	997	return r;
sl@0	998	}
sl@0	999	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	1000	//the state of the writePolicyFound to EFalse
sl@0	1001	}
sl@0	1002	// now lets try range policies
sl@0	1003	r = ReadRangePoliciesL(aDefaultReadPolicy,aDefaultWritePolicy,aRangePolicies);
sl@0	1004	if(r!=KErrNone)
sl@0	1005	{
sl@0	1006	__CENTREP_TRACE1("[%S] Invalid range policy [platsec]",iFullName);
sl@0	1007	return KErrCorrupt;
sl@0	1008	}
sl@0	1009	// it must be the main section now so lets check
sl@0	1010	SkipComments();
sl@0	1011	iLex.Mark();
sl@0	1012	iLex.SkipCharacters();
sl@0	1013
sl@0	1014	if(iLex.TokenLength()>KBufLen)
sl@0	1015	return KErrCorrupt;
sl@0	1016
sl@0	1017	buf.CopyLC(iLex.MarkedToken());
sl@0	1018	if(buf.Compare(KMainSection)!=0)
sl@0	1019	{
sl@0	1020	return KErrCorrupt;
sl@0	1021	}
sl@0	1022
sl@0	1023	iLex.Mark(iMainSectionMark);
sl@0	1024
sl@0	1025	return KErrNone;
sl@0	1026	}
sl@0	1027
sl@0	1028	/**
sl@0	1029	Reads TSecurityPolicy as defined for range of indexes
sl@0	1030
sl@0	1031	@internalTechnology
sl@0	1032	@return KErrNone, KErrCorrupt
sl@0	1033	@leave KErrNotFound
sl@0	1034	*/
sl@0	1035	TInt CIniFileIn::ReadRangePoliciesL(const TSecurityPolicy& aDefaultReadPolicy,
sl@0	1036	const TSecurityPolicy& aDefaultWritePolicy,
sl@0	1037	RRangePolicyArray& aRangePolicies)
sl@0	1038	{
sl@0	1039	TUint32 lowKey = 0;
sl@0	1040	TBuf<KBufLen> buf;
sl@0	1041
sl@0	1042	SkipComments();
sl@0	1043	while(KErrNone == ReadNumber(lowKey))
sl@0	1044	{
sl@0	1045	// highKey and mask needs to be zero'd every cycle...
sl@0	1046	TUint32 highKey = 0;
sl@0	1047	TUint32 mask = 0;
sl@0	1048	iLex.SkipSpace();
sl@0	1049	// may be not range but key & mask so lets check 'mask' keyword
sl@0	1050	if(!iLex.Peek().IsDigit())
sl@0	1051	{
sl@0	1052	//so should be mask then...
sl@0	1053	iLex.Mark();
sl@0	1054	while((iLex.Peek()!='=')&&(!iLex.Eos()))
sl@0	1055	{
sl@0	1056	iLex.Inc();
sl@0	1057
sl@0	1058	if(iLex.TokenLength() >= KMaskLen)
sl@0	1059	{
sl@0	1060	// so no '=' there
sl@0	1061	// not necessarily bad thing... could be space there first
sl@0	1062	break;
sl@0	1063	}
sl@0	1064
sl@0	1065	}
sl@0	1066
sl@0	1067	// check if KMaskLen is < buf length?
sl@0	1068	buf.CopyLC(iLex.MarkedToken());
sl@0	1069	if(buf.Compare(KMaskString)!=0)
sl@0	1070	{
sl@0	1071	__CENTREP_TRACE1("[%S] Missing 'mask' keyword for range [platsec]",iFullName);
sl@0	1072	return KErrCorrupt;
sl@0	1073	}
sl@0	1074
sl@0	1075	iLex.SkipSpace();
sl@0	1076	if('=' != iLex.Get())
sl@0	1077	{
sl@0	1078	__CENTREP_TRACE1("[%S] Missing '=' for 'mask' keyword for range [platsec]",iFullName);
sl@0	1079	return KErrCorrupt;
sl@0	1080	}
sl@0	1081	iLex.SkipSpace();
sl@0	1082	TInt r = ReadNumberL(iLex,mask);
sl@0	1083	if(r!=KErrNone)
sl@0	1084	{
sl@0	1085	__CENTREP_TRACE1("[%S] Invalid value for 'mask' keyword [platsec]",iFullName);
sl@0	1086	return KErrCorrupt;
sl@0	1087	}
sl@0	1088	}
sl@0	1089	else
sl@0	1090	{
sl@0	1091	TInt r = ReadNumberL(iLex,highKey);
sl@0	1092	if(r!=KErrNone)
sl@0	1093	{
sl@0	1094	__CENTREP_TRACE1("[%S] Invalid end of range [platsec]",iFullName);
sl@0	1095	return KErrCorrupt;
sl@0	1096	}
sl@0	1097	}
sl@0	1098	TBool writePolicyFound = EFalse;
sl@0	1099	TBool readPolicyFound= EFalse;
sl@0	1100	TSecurityPolicy readPolicy;
sl@0	1101	TSecurityPolicy writePolicy;
sl@0	1102
sl@0	1103	TInt ret=KErrNone;
sl@0	1104	ret=ReadRdPolicyL(readPolicy);
sl@0	1105	if (ret==KErrNone)
sl@0	1106	readPolicyFound=ETrue;
sl@0	1107	else
sl@0	1108	{
sl@0	1109	if (ret==KErrCorrupt \|\| ret==KErrNoMemory)
sl@0	1110	{
sl@0	1111	#ifdef CENTREP_TRACE
sl@0	1112	if (ret == KErrCorrupt)
sl@0	1113	{
sl@0	1114	__CENTREP_TRACE1("[%S] Invalid read policy for range [platsec]",iFullName);
sl@0	1115	}
sl@0	1116	#endif
sl@0	1117	return ret;
sl@0	1118	}
sl@0	1119	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	1120	//the state of the writePolicyFound to EFalse
sl@0	1121	}
sl@0	1122	ret=ReadWrPolicyL(writePolicy);
sl@0	1123	if (ret==KErrNone)
sl@0	1124	writePolicyFound=ETrue;
sl@0	1125	else
sl@0	1126	{
sl@0	1127	if (ret==KErrCorrupt \|\| ret==KErrNoMemory)
sl@0	1128	{
sl@0	1129	#ifdef CENTREP_TRACE
sl@0	1130	if (ret == KErrCorrupt)
sl@0	1131	{
sl@0	1132	__CENTREP_TRACE1("[%S] Invalid write policy for range [platsec]",iFullName);
sl@0	1133	}
sl@0	1134	#endif
sl@0	1135	return ret;
sl@0	1136	}
sl@0	1137	//else if ret!=KErrNone very likely it is KErrNotFound so leave
sl@0	1138	//the state of the writePolicyFound to EFalse
sl@0	1139	}
sl@0	1140	//If only one of the policy is specified,need to set the other one to default value
sl@0	1141	//to prevent it from being uninitialized
sl@0	1142	if(readPolicyFound \|\| writePolicyFound)
sl@0	1143	{
sl@0	1144	if (!readPolicyFound)
sl@0	1145	readPolicy=aDefaultReadPolicy;
sl@0	1146	if (!writePolicyFound)
sl@0	1147	writePolicy=aDefaultWritePolicy;
sl@0	1148	TSettingsAccessPolicy settingsPolicy(readPolicy,writePolicy,
sl@0	1149	lowKey, highKey, mask);
sl@0	1150	aRangePolicies.AppendL(settingsPolicy);
sl@0	1151	}
sl@0	1152	else
sl@0	1153	{
sl@0	1154	// range specified with no policies!
sl@0	1155	__CENTREP_TRACE1("[%S] Range specified with no policies [platsec]",iFullName);
sl@0	1156	return KErrCorrupt;
sl@0	1157	}
sl@0	1158	SkipComments();
sl@0	1159	}
sl@0	1160	return KErrNone;
sl@0	1161	}
sl@0	1162
sl@0	1163	/**
sl@0	1164	@internalTechnology
sl@0	1165	@return TCapability as converted from string description
sl@0	1166	@leave KErrNotFound
sl@0	1167	*/
sl@0	1168	TInt CIniFileIn::ReadCapabilityL(TCapability& aCapability)
sl@0	1169	{
sl@0	1170	iLex.SkipSpace();
sl@0	1171
sl@0	1172	if(iLex.Eos())
sl@0	1173	User::Leave(KErrNotFound);
sl@0	1174
sl@0	1175	// check if '=' still there and skip
sl@0	1176	SkipEqualSign();
sl@0	1177
sl@0	1178	iLex.Mark();
sl@0	1179
sl@0	1180	// potentially comma separated list of capabilities
sl@0	1181	// we read just one at the time
sl@0	1182	while(!iLex.Peek().IsSpace() && (iLex.Peek() != ',') && !iLex.Eos())
sl@0	1183	{
sl@0	1184	iLex.Inc();
sl@0	1185	if(iLex.TokenLength()>KMaxCapabilityStringLen)
sl@0	1186	{
sl@0	1187	__CENTREP_TRACE1("[%S] Invalid capability [platsec]",iFullName);
sl@0	1188	return KErrCorrupt;
sl@0	1189	}
sl@0	1190	}
sl@0	1191
sl@0	1192	TBuf<KMaxCapabilityStringLen> string;
sl@0	1193	string.CopyLC(iLex.MarkedToken());
sl@0	1194
sl@0	1195	// lets check against list of capabilities
sl@0	1196	TInt capability;
sl@0	1197
sl@0	1198	// descriptors...desriptors - we need it for conversion from const char[] to TPtr
sl@0	1199	HBufC *cap = HBufC::NewLC(KMaxCapabilityStringLen);
sl@0	1200	TPtr capPtr = cap->Des() ;
sl@0	1201	HBufC8 *capNarrow = HBufC8::NewLC(KMaxCapabilityStringLen) ;
sl@0	1202	for(capability=0; capability<ECapability_Limit; capability++)
sl@0	1203	{
sl@0	1204	// CapabilityNames is const char[]
sl@0	1205	capNarrow = (const TUint8 )CapabilityNames[capability];
sl@0	1206
sl@0	1207	capPtr.Copy(*capNarrow);
sl@0	1208	capPtr.LowerCase();
sl@0	1209	if(0 == string.Compare(capPtr))
sl@0	1210	{
sl@0	1211	aCapability=static_cast<TCapability>(capability);
sl@0	1212	CleanupStack::PopAndDestroy(capNarrow);
sl@0	1213	CleanupStack::PopAndDestroy(cap);
sl@0	1214	return KErrNone;
sl@0	1215	}
sl@0	1216	}
sl@0	1217	CleanupStack::PopAndDestroy(capNarrow);
sl@0	1218	CleanupStack::PopAndDestroy(cap);
sl@0	1219
sl@0	1220	// to satisfy compiler
sl@0	1221	aCapability=ECapability_Limit;
sl@0	1222
sl@0	1223	__CENTREP_TRACE1("[%S] Invalid capability [platsec]",iFullName);
sl@0	1224	// we didn't find anything
sl@0	1225	return KErrCorrupt;
sl@0	1226
sl@0	1227	}
sl@0	1228
sl@0	1229	/**
sl@0	1230	@internalTechnology
sl@0	1231	@param aAlwaysPass will be true if the first capability is AlwaysPass
sl@0	1232	aAlwaysFail will be true if the first capability is AlwaysFail
sl@0	1233	*/
sl@0	1234	void CIniFileIn::CheckForAlwaysPassOrFailL(TBool& aAlwaysPass,TBool& aAlwaysFail)
sl@0	1235	{
sl@0	1236	iLex.SkipSpace();
sl@0	1237
sl@0	1238	if(iLex.Eos())
sl@0	1239	User::Leave(KErrNotFound);
sl@0	1240
sl@0	1241	// check if '=' still there and skip
sl@0	1242	SkipEqualSign();
sl@0	1243
sl@0	1244	iLex.Mark();
sl@0	1245	// we are just checking if AlwaysPass has been set
sl@0	1246	while(!iLex.Peek().IsSpace() && !iLex.Eos())
sl@0	1247	{
sl@0	1248	iLex.Inc();
sl@0	1249	if(iLex.TokenLength()>KMaxCapabilityStringLen)
sl@0	1250	{
sl@0	1251	iLex.UnGetToMark();
sl@0	1252	return;
sl@0	1253	}
sl@0	1254
sl@0	1255	}
sl@0	1256
sl@0	1257	TBuf<KMaxCapabilityStringLen> string;
sl@0	1258	string.CopyLC(iLex.MarkedToken());
sl@0	1259
sl@0	1260	aAlwaysPass=(string.Compare(KAccessAlwaysPass)==0);
sl@0	1261	aAlwaysFail=(string.Compare(KAccessAlwaysFail)==0);
sl@0	1262	//if not either AlwaysPass or AlwaysFail reset the Lex position to Mark
sl@0	1263	if(!(aAlwaysPass \|\| aAlwaysFail))
sl@0	1264	iLex.UnGetToMark();
sl@0	1265	}
sl@0	1266
sl@0	1267	TInt CIniFileIn::ReadCapabilitiesL(TSecurityPolicy& aPolicy)
sl@0	1268	{
sl@0	1269	// we can have 0-7 capabilities
sl@0	1270	const TInt maxCapWithoutSid = 7;
sl@0	1271	TCapability capabilities[maxCapWithoutSid];
sl@0	1272	TInt index = 0;
sl@0	1273	// initialise
sl@0	1274	for(index=0;index<maxCapWithoutSid;index++)
sl@0	1275	capabilities[index] = ECapability_None;
sl@0	1276
sl@0	1277	index = 0;
sl@0	1278
sl@0	1279	// lets read the first capability... there must be at least one!
sl@0	1280	TBool isAlwaysPass=EFalse;
sl@0	1281	TBool isAlwaysFail=EFalse;
sl@0	1282	CheckForAlwaysPassOrFailL(isAlwaysPass,isAlwaysFail);
sl@0	1283	if(isAlwaysPass \|\| isAlwaysFail)
sl@0	1284	{
sl@0	1285	//default is set to EAlwaysFail
sl@0	1286	TSecurityPolicy policy;
sl@0	1287	if (isAlwaysPass)
sl@0	1288	policy=TSecurityPolicy(TSecurityPolicy::EAlwaysPass);
sl@0	1289	aPolicy.Set(policy.Package());
sl@0	1290	}
sl@0	1291	else
sl@0	1292	{
sl@0	1293	TInt r=ReadCapabilityL(capabilities[index]);
sl@0	1294	if(r!=KErrNone)
sl@0	1295	return r;
sl@0	1296
sl@0	1297	// do we have more?
sl@0	1298	iLex.SkipSpace();
sl@0	1299	index++;
sl@0	1300	while((iLex.Peek() == ','))
sl@0	1301	{
sl@0	1302	//if capabilities supplied is more than allowed return KErrCorrupt
sl@0	1303	if (index>=maxCapWithoutSid)
sl@0	1304	{
sl@0	1305	__CENTREP_TRACE1("[%S] Too many read capabilities [platsec]",iFullName);
sl@0	1306	return KErrCorrupt;
sl@0	1307	}
sl@0	1308	// skip comma
sl@0	1309	iLex.SkipAndMark(1);
sl@0	1310	r=ReadCapabilityL(capabilities[index]);
sl@0	1311	if(r!=KErrNone)
sl@0	1312	return r;
sl@0	1313	// do we have yet more?
sl@0	1314	iLex.SkipSpace();
sl@0	1315	index++;
sl@0	1316	}
sl@0	1317	TSecurityPolicy policy(static_cast<TCapability>(capabilities[0]),
sl@0	1318	static_cast<TCapability>(capabilities[1]),
sl@0	1319	static_cast<TCapability>(capabilities[2]),
sl@0	1320	static_cast<TCapability>(capabilities[3]),
sl@0	1321	static_cast<TCapability>(capabilities[4]),
sl@0	1322	static_cast<TCapability>(capabilities[5]),
sl@0	1323	static_cast<TCapability>(capabilities[6]));
sl@0	1324	aPolicy.Set(policy.Package());
sl@0	1325	}
sl@0	1326	return KErrNone;
sl@0	1327	}
sl@0	1328
sl@0	1329	TInt CIniFileIn::ReadSidAndCapabilitiesL(TSecurityPolicy& aPolicy,const TDesC& aPolicyType,
sl@0	1330	TSecureId& aSid)
sl@0	1331	{
sl@0	1332	//SID was specified we can have 0-3 capabilities
sl@0	1333	const TInt maxCapWithSid = 3;
sl@0	1334
sl@0	1335	TCapability capabilities[maxCapWithSid];
sl@0	1336	TInt index = 0;
sl@0	1337	for(index=0;index<maxCapWithSid;index++)
sl@0	1338	capabilities[index] = ECapability_None;
sl@0	1339
sl@0	1340	// lets see what we have here...
sl@0	1341	iLex.SkipSpaceAndMark();
sl@0	1342
sl@0	1343	// we are looking for a string terminated by '='
sl@0	1344	// up to a certain length....
sl@0	1345	while((iLex.Peek()!='=')&&(!iLex.Eos()))
sl@0	1346	{
sl@0	1347	iLex.Inc();
sl@0	1348
sl@0	1349	if(iLex.TokenLength() >= KMaxAccessTypeLen)
sl@0	1350	{
sl@0	1351	// so no '=' there
sl@0	1352	// not necessarily bad thing... could be space there first
sl@0	1353	break;
sl@0	1354	}
sl@0	1355
sl@0	1356	}
sl@0	1357
sl@0	1358	TBuf<KMaxAccessTypeLen> string;
sl@0	1359	string.CopyLC(iLex.MarkedToken());
sl@0	1360
sl@0	1361	index = 0;
sl@0	1362	// lets check if there are any capabilities specified and if of correct type
sl@0	1363	if(0 == string.Compare(aPolicyType))
sl@0	1364	{
sl@0	1365	//Need to check for AlwaysPass or AlwaysFail
sl@0	1366	TBool isAlwaysPass=EFalse;
sl@0	1367	TBool isAlwaysFail=EFalse;
sl@0	1368	CheckForAlwaysPassOrFailL(isAlwaysPass,isAlwaysFail);
sl@0	1369	if(isAlwaysPass \|\| isAlwaysFail)
sl@0	1370	{
sl@0	1371	//default is set to EAlwaysFail
sl@0	1372	TSecurityPolicy policy;
sl@0	1373	if (isAlwaysPass)
sl@0	1374	policy=TSecurityPolicy(TSecurityPolicy::EAlwaysPass);
sl@0	1375	aPolicy.Set(policy.Package());
sl@0	1376	}
sl@0	1377	else
sl@0	1378	{
sl@0	1379	// so we have some capabilities to read
sl@0	1380	TInt r = ReadCapabilityL(capabilities[index]);
sl@0	1381	if(r!=KErrNone)
sl@0	1382	return r;
sl@0	1383	// do we have more?
sl@0	1384	iLex.SkipSpace();
sl@0	1385	index++;
sl@0	1386	while((iLex.Peek() == ','))
sl@0	1387	{
sl@0	1388	//cannot permit more than 3 capabilities when followed by a SID
sl@0	1389	if (index>=maxCapWithSid)
sl@0	1390	{
sl@0	1391	__CENTREP_TRACE1("[%S] Too many read capabilities [platsec]",iFullName);
sl@0	1392	return KErrCorrupt;
sl@0	1393	}
sl@0	1394	// skip comma
sl@0	1395	iLex.SkipAndMark(1);
sl@0	1396	TInt r= ReadCapabilityL(capabilities[index]);
sl@0	1397	if(r!=KErrNone)
sl@0	1398	return r;
sl@0	1399	// do we have yet more?
sl@0	1400	iLex.SkipSpace();
sl@0	1401	index++;
sl@0	1402	}
sl@0	1403	TSecurityPolicy policy(aSid,static_cast<TCapability>(capabilities[0]),
sl@0	1404	static_cast<TCapability>(capabilities[1]),
sl@0	1405	static_cast<TCapability>(capabilities[2]));
sl@0	1406	aPolicy.Set(policy.Package());
sl@0	1407	}
sl@0	1408	}
sl@0	1409	else
sl@0	1410	{
sl@0	1411	// so no capabilities just SID
sl@0	1412	// and the token wasn't for us either
sl@0	1413	iLex.UnGetToMark();
sl@0	1414	TSecurityPolicy policy(aSid);
sl@0	1415	aPolicy.Set(policy.Package());
sl@0	1416	}
sl@0	1417	return KErrNone;
sl@0	1418	}
sl@0	1419
sl@0	1420
sl@0	1421	TInt CIniFileIn::ReadPolicyL(TSecurityPolicy& aPolicy,TInt aPolicyType)
sl@0	1422	{
sl@0	1423
sl@0	1424	// lets check if there a SID is specified
sl@0	1425	iLex.SkipSpaceAndMark();
sl@0	1426
sl@0	1427	if(iLex.Eos())
sl@0	1428	return KErrNotFound;
sl@0	1429
sl@0	1430	while((iLex.Peek()!='=')&&(!iLex.Eos()))
sl@0	1431	{
sl@0	1432	iLex.Inc();
sl@0	1433
sl@0	1434	if(iLex.TokenLength() >= KMaxAccessTypeLen)
sl@0	1435	{
sl@0	1436	// so no '=' there
sl@0	1437	// not necessarily bad thing... could be space there first
sl@0	1438	break;
sl@0	1439	}
sl@0	1440
sl@0	1441	}
sl@0	1442
sl@0	1443	// we are looking for either KReadAccessSid, KReadAccessCap, KWriteAccessSid,KWriteAccessCap
sl@0	1444	TBuf<KMaxAccessTypeLen> accessString;
sl@0	1445	accessString.CopyLC(iLex.MarkedToken());
sl@0	1446	iLex.SkipSpace();
sl@0	1447	TInt returnCode = KErrNotFound;
sl@0	1448	// we expect a combination of sid_rd1 cap_rd1 sid_wr1 cap_wr1
sl@0	1449	if(accessString.Compare(KReadAccessSidString)==0)
sl@0	1450	{
sl@0	1451	// we've got read - either SID or SID+CAP! Are we expecting read?
sl@0	1452	if(KReadPolicy == aPolicyType)
sl@0	1453	{
sl@0	1454	TUint32 sid;
sl@0	1455	SkipEqualSign();
sl@0	1456	if (ReadNumber(sid) != KErrNone)
sl@0	1457	{
sl@0	1458	__CENTREP_TRACE1("[%S] Invalid SID (read)[platsec]",iFullName);
sl@0	1459	return KErrCorrupt;
sl@0	1460	}
sl@0	1461	TSecureId sidId(sid);
sl@0	1462	// so we read sid and now we expect cap_rd1=cap1,cap2,..
sl@0	1463	// lets assume it's a SID+CAP for now
sl@0	1464	returnCode= ReadSidAndCapabilitiesL(aPolicy,KReadAccessCapString,sidId);
sl@0	1465	}
sl@0	1466	}
sl@0	1467	else if(accessString.Compare(KReadAccessCapString)==0)
sl@0	1468	{
sl@0	1469	// we've got read CAP only! Are we expecting read?
sl@0	1470	if(KReadPolicy == aPolicyType)
sl@0	1471	{
sl@0	1472	returnCode=ReadCapabilitiesL(aPolicy);
sl@0	1473	}
sl@0	1474	}
sl@0	1475	else if(accessString.Compare(KWriteAccessSidString)==0)
sl@0	1476	{
sl@0	1477	// we've got write - either SID or SID+CAP! Are we expecting read?
sl@0	1478	if(KWritePolicy == aPolicyType)
sl@0	1479	{
sl@0	1480	TUint32 sid;
sl@0	1481	SkipEqualSign();
sl@0	1482	if(ReadNumber(sid)!=KErrNone)
sl@0	1483	{
sl@0	1484	__CENTREP_TRACE1("[%S] Invalid SID (write)[platsec]",iFullName);
sl@0	1485	return KErrCorrupt;
sl@0	1486	}
sl@0	1487	TSecureId sidId(sid);
sl@0	1488	// lets assume SID+CAP for now
sl@0	1489	returnCode= ReadSidAndCapabilitiesL(aPolicy,KWriteAccessCapString,sidId);
sl@0	1490	}
sl@0	1491	}
sl@0	1492	else if(accessString.Compare(KWriteAccessCapString)==0)
sl@0	1493	{
sl@0	1494	// we've got write CAP only! Are we expecting write?
sl@0	1495	if(KWritePolicy == aPolicyType)
sl@0	1496	{
sl@0	1497	returnCode=ReadCapabilitiesL(aPolicy);
sl@0	1498	}
sl@0	1499	}
sl@0	1500	if(KErrNone != returnCode)
sl@0	1501	iLex.UnGetToMark();
sl@0	1502
sl@0	1503	return returnCode;
sl@0	1504	}
sl@0	1505
sl@0	1506	TInt CIniFileIn::ReadRdPolicyL(TSecurityPolicy& aReadPolicy)
sl@0	1507	{
sl@0	1508	return ReadPolicyL(aReadPolicy,KReadPolicy);
sl@0	1509	}
sl@0	1510
sl@0	1511	TInt CIniFileIn::ReadWrPolicyL(TSecurityPolicy& aReadPolicy)
sl@0	1512	{
sl@0	1513	return ReadPolicyL(aReadPolicy,KWritePolicy);
sl@0	1514	}
sl@0	1515
sl@0	1516	TInt CIniFileIn::ReadStringL(HBufC8*& aString)
sl@0	1517	{
sl@0	1518	iLex.Mark();
sl@0	1519
sl@0	1520	TChar c = iLex.Peek();
sl@0	1521	TChar quote = 0;
sl@0	1522	if(c=='\'' \|\| c=='\"')
sl@0	1523	{
sl@0	1524	iLex.SkipAndMark(1);
sl@0	1525	quote = c;
sl@0	1526	}
sl@0	1527
sl@0	1528	TBool complete = EFalse;
sl@0	1529
sl@0	1530	TInt len;
sl@0	1531	for(len=0;!iLex.Eos();len++)
sl@0	1532	{
sl@0	1533	c = iLex.Get();
sl@0	1534
sl@0	1535	if(quote ? c==quote : c.IsSpace())
sl@0	1536	{
sl@0	1537	complete = ETrue;
sl@0	1538	break;
sl@0	1539	}
sl@0	1540
sl@0	1541	if(c=='\\')
sl@0	1542	iLex.Get();
sl@0	1543	}
sl@0	1544
sl@0	1545	if(!complete \|\| len>KMaxUnicodeStringLength)
sl@0	1546	return KErrCorrupt;
sl@0	1547
sl@0	1548	aString = HBufC8::NewL(len*2);
sl@0	1549	TPtr8 ptr8 = aString->Des();
sl@0	1550	ptr8.SetLength(len*2);
sl@0	1551	TPtr16 ptr16((TUint16*)ptr8.Ptr(), len, len);
sl@0	1552
sl@0	1553
sl@0	1554	iLex.UnGetToMark();
sl@0	1555
sl@0	1556	_LIT(KSpecialChars, "abfnrvt0");
sl@0	1557	static TUint8 specialChars[] = { '\a', '\b', '\f', '\n', '\r', '\v', '\t', '\0' };
sl@0	1558	for(TInt i=0;i<len;i++)
sl@0	1559	{
sl@0	1560	c = iLex.Get();
sl@0	1561
sl@0	1562	if(c=='\\')
sl@0	1563	{
sl@0	1564	c = iLex.Get();
sl@0	1565	TInt i = KSpecialChars().Locate(c);
sl@0	1566	if(i>=0)
sl@0	1567	c = specialChars[i];
sl@0	1568	}
sl@0	1569
sl@0	1570	ptr16[i] = (TUint16)c;
sl@0	1571
sl@0	1572	}
sl@0	1573
sl@0	1574	if(quote)
sl@0	1575	iLex.Inc(); // trailing quote
sl@0	1576
sl@0	1577	return KErrNone;
sl@0	1578	}
sl@0	1579
sl@0	1580
sl@0	1581
sl@0	1582	TInt CIniFileIn::ReadString16To8L(HBufC8*& aString)
sl@0	1583	{
sl@0	1584	iLex.Mark();
sl@0	1585
sl@0	1586	TChar c = iLex.Peek();
sl@0	1587	TChar quote = 0;
sl@0	1588	if(c=='\'' \|\| c=='\"')
sl@0	1589	{
sl@0	1590	iLex.SkipAndMark(1);
sl@0	1591	quote = c;
sl@0	1592	}
sl@0	1593
sl@0	1594	TBool complete = EFalse;
sl@0	1595
sl@0	1596	TInt len;
sl@0	1597	for(len=0;!iLex.Eos();len++)
sl@0	1598	{
sl@0	1599	c = iLex.Get();
sl@0	1600
sl@0	1601	if(quote ? c==quote : c.IsSpace())
sl@0	1602	{
sl@0	1603	complete = ETrue;
sl@0	1604	break;
sl@0	1605	}
sl@0	1606
sl@0	1607	if(c=='\\')
sl@0	1608	iLex.Get();
sl@0	1609	}
sl@0	1610
sl@0	1611	if(!complete \|\| len>KMaxUnicodeStringLength)
sl@0	1612	return KErrCorrupt;
sl@0	1613
sl@0	1614	aString = HBufC8::NewLC(len*2);
sl@0	1615
sl@0	1616	HBufC16* tempBuffer = HBufC16::NewLC(len);
sl@0	1617
sl@0	1618	TPtr16 ptr16 = tempBuffer->Des();
sl@0	1619	TPtr8 ptr8 = aString->Des();
sl@0	1620	ptr8.SetLength(len*2);
sl@0	1621
sl@0	1622
sl@0	1623
sl@0	1624	iLex.UnGetToMark();
sl@0	1625
sl@0	1626	_LIT(KSpecialChars, "abfnrvt0");
sl@0	1627	static TUint8 specialChars[] = { '\a', '\b', '\f', '\n', '\r', '\v', '\t', '\0' };
sl@0	1628	for(TInt i=0;i<len;i++)
sl@0	1629	{
sl@0	1630	c = iLex.Get();
sl@0	1631
sl@0	1632	if(c=='\\')
sl@0	1633	{
sl@0	1634	c = iLex.Get();
sl@0	1635	TInt i = KSpecialChars().Locate(c);
sl@0	1636	if(i>=0)
sl@0	1637	c = specialChars[i];
sl@0	1638	}
sl@0	1639
sl@0	1640	ptr16.Append(c);
sl@0	1641
sl@0	1642	}
sl@0	1643
sl@0	1644	const TInt returnValue = CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr8, ptr16);
sl@0	1645	if (returnValue==CnvUtfConverter::EErrorIllFormedInput)
sl@0	1646	{
sl@0	1647	CleanupStack::PopAndDestroy(tempBuffer);
sl@0	1648	CleanupStack::PopAndDestroy(aString);
sl@0	1649	return KErrCorrupt;
sl@0	1650	}
sl@0	1651	else if(returnValue<0)
sl@0	1652	User::Leave(KErrGeneral);
sl@0	1653
sl@0	1654	CleanupStack::PopAndDestroy(tempBuffer);
sl@0	1655	CleanupStack::Pop(aString);
sl@0	1656
sl@0	1657	if(quote)
sl@0	1658	iLex.Inc(); // trailing quote
sl@0	1659
sl@0	1660	return KErrNone;
sl@0	1661	}
sl@0	1662
sl@0	1663	TInt CIniFileIn::ReadBinaryL(HBufC8*& aString)
sl@0	1664	{
sl@0	1665	iLex.Mark();
sl@0	1666	iLex.SkipCharacters();
sl@0	1667	TInt len = iLex.TokenLength();
sl@0	1668	iLex.UnGetToMark();
sl@0	1669
sl@0	1670	if(len==1 && iLex.Peek()==KNullDataIndicator)
sl@0	1671	{
sl@0	1672	iLex.Get();
sl@0	1673	aString = HBufC8::NewL(0);
sl@0	1674	TPtr8 ptr8 = aString->Des();
sl@0	1675	ptr8.SetLength(0);
sl@0	1676	return KErrNone;
sl@0	1677	}
sl@0	1678
sl@0	1679	if(len>KMaxBinaryLength*2 \|\| len%2)
sl@0	1680	{
sl@0	1681	delete aString;
sl@0	1682	return KErrCorrupt;
sl@0	1683	}
sl@0	1684
sl@0	1685	len /= 2;
sl@0	1686	aString = HBufC8::NewL(len);
sl@0	1687	TPtr8 ptr8 = aString->Des();
sl@0	1688	ptr8.SetLength(len);
sl@0	1689
sl@0	1690	TBuf<2> buf(2);
sl@0	1691	for(TInt i=0;i<len;i++)
sl@0	1692	{
sl@0	1693	buf[0] = (TUint8)iLex.Get();
sl@0	1694	buf[1] = (TUint8)iLex.Get();
sl@0	1695	TLex lex(buf);
sl@0	1696	if(lex.Val(ptr8[i], EHex)!=KErrNone)
sl@0	1697	{
sl@0	1698	delete aString;
sl@0	1699	return KErrCorrupt;
sl@0	1700	}
sl@0	1701	}
sl@0	1702	return KErrNone;
sl@0	1703	}
sl@0	1704
sl@0	1705	TInt CIniFileIn::ReadNumber(TUint32& aVal)
sl@0	1706	{
sl@0	1707	iLex.SkipSpace();
sl@0	1708
sl@0	1709	if(iLex.Eos())
sl@0	1710	return KErrNotFound;
sl@0	1711
sl@0	1712	TRadix radix = EDecimal;
sl@0	1713	if(iLex.Peek()=='0')
sl@0	1714	{
sl@0	1715	iLex.Inc();
sl@0	1716	if(iLex.Peek().GetLowerCase()=='x')
sl@0	1717	{
sl@0	1718	iLex.Inc();
sl@0	1719	radix = EHex;
sl@0	1720	}
sl@0	1721	else
sl@0	1722	iLex.UnGet();
sl@0	1723	}
sl@0	1724
sl@0	1725	return iLex.Val(aVal, radix);
sl@0	1726	}
sl@0	1727
sl@0	1728
sl@0	1729	TInt CIniFileIn::GetOwnerSectionLC(HBufC*& aSection)
sl@0	1730	{
sl@0	1731	return( GetSectionLC(KOwnerSection(), aSection));
sl@0	1732	}
sl@0	1733
sl@0	1734	TInt CIniFileIn::GetDefaultMetaSectionLC(HBufC*& aSection)
sl@0	1735	{
sl@0	1736	return( GetSectionLC(KDefaultMetaSection(), aSection));
sl@0	1737	}
sl@0	1738
sl@0	1739	TInt CIniFileIn::GetTimeStampSectionLC(HBufC*& aSection)
sl@0	1740	{
sl@0	1741	return( GetSectionLC(KTimeStampSection(), aSection));
sl@0	1742	}
sl@0	1743
sl@0	1744	TInt CIniFileIn::GetPlatSecSectionLC(HBufC*& aSection)
sl@0	1745	{
sl@0	1746	return( GetSectionLC(KPlatSecSection(), aSection));
sl@0	1747	}
sl@0	1748
sl@0	1749	TInt CIniFileIn::GetSectionLC(const TDesC16& aSectionId, HBufC*& aSection)
sl@0	1750	{
sl@0	1751	TBuf<KBufLen> buf;
sl@0	1752	TLexMark sectionMark;
sl@0	1753	aSection=NULL;
sl@0	1754
sl@0	1755	SkipComments();
sl@0	1756
sl@0	1757	iLex.Mark(sectionMark);
sl@0	1758
sl@0	1759	iLex.Mark();
sl@0	1760	iLex.SkipCharacters();
sl@0	1761
sl@0	1762	if( (iLex.TokenLength() != aSectionId.Length()) &&
sl@0	1763	(buf.CopyLC(iLex.MarkedToken()), buf.Compare( aSectionId )!=0) )
sl@0	1764	{
sl@0	1765	// Expected section not found at this point in the file
sl@0	1766	// Note that this is not an error
sl@0	1767	iLex.UnGetToMark();
sl@0	1768	return KErrNone;
sl@0	1769	}
sl@0	1770
sl@0	1771	//
sl@0	1772	// Read in the section by grabbing text until we reach
sl@0	1773	// the start of another section.
sl@0	1774	//
sl@0	1775	while(!iLex.Eos())
sl@0	1776	{
sl@0	1777	// Wait for any other section marker
sl@0	1778	SkipComments();
sl@0	1779
sl@0	1780	iLex.Mark();
sl@0	1781
sl@0	1782	iLex.SkipCharacters();
sl@0	1783
sl@0	1784	if(iLex.TokenLength() <= KBufLen)
sl@0	1785	{
sl@0	1786	buf.CopyLC(iLex.MarkedToken());
sl@0	1787	if((buf.Compare(KMainSection) == 0) \|\|
sl@0	1788	(buf.Compare(KOwnerSection) == 0) \|\|
sl@0	1789	(buf.Compare(KPlatSecSection) == 0) \|\|
sl@0	1790	(buf.Compare(KTimeStampSection) == 0) \|\|
sl@0	1791	(buf.Compare(KDefaultMetaSection) == 0))
sl@0	1792	{
sl@0	1793	iLex.Mark(iMainSectionMark);
sl@0	1794	iLex.UnGetToMark() ;
sl@0	1795	TPtrC lex = iLex.MarkedToken(sectionMark);
sl@0	1796	HBufC* section = HBufC::NewMaxLC(lex.Length()); //'\n'
sl@0	1797	TPtr ptr = section->Des();
sl@0	1798	ptr.Copy(lex);
sl@0	1799	aSection=section;
sl@0	1800	return KErrNone;
sl@0	1801	}
sl@0	1802	}
sl@0	1803	}
sl@0	1804	return KErrCorrupt;
sl@0	1805	}
sl@0	1806
sl@0	1807	TInt CIniFileIn::FindMainSectionL(void)
sl@0	1808	{
sl@0	1809	TBuf<KBufLen> buf;
sl@0	1810
sl@0	1811	//
sl@0	1812	// Check if a Main section is present
sl@0	1813	//
sl@0	1814
sl@0	1815	SkipComments();
sl@0	1816
sl@0	1817	// we will need this section later to write the out file...
sl@0	1818	iLex.Mark(iMainSectionMark);
sl@0	1819
sl@0	1820	iLex.Mark();
sl@0	1821	iLex.SkipCharacters();
sl@0	1822
sl@0	1823	if( iLex.TokenLength()!=KMainSectionLen \|\|
sl@0	1824	(buf.CopyLC( iLex.MarkedToken() ), buf.Compare( KMainSection )!=0) )
sl@0	1825	{
sl@0	1826	// Meta not available
sl@0	1827	iLex.UnGetToMark();
sl@0	1828	return KErrNotFound;
sl@0	1829	}
sl@0	1830
sl@0	1831	iLex.Mark(iMainSectionMark);
sl@0	1832	return KErrNone ;
sl@0	1833	}
sl@0	1834
sl@0	1835	#ifdef CENTREP_TRACE
sl@0	1836	HBufC* CIniFileIn::FullName()
sl@0	1837	{
sl@0	1838	return(iFullName);
sl@0	1839	}
sl@0	1840	#endif
sl@0	1841
sl@0	1842	#ifdef CENTREP_CONV_TOOL
sl@0	1843	//===================================================================
sl@0	1844	// TCompiledSecurityPolicy class
sl@0	1845	// Used for accessing private data members of TSecurityPolicy. It
sl@0	1846	// uses the fact that TSecurityPolicy class has a friend whose name
sl@0	1847	// is TCompiledSecurityPolicy.
sl@0	1848	// See dbms/tdbms/securitypolicy.h for similar strategy.
sl@0	1849	//
sl@0	1850
sl@0	1851	// The longest possible security string is one that has 7 capabilities.
sl@0	1852	static const TInt KSecPolicyStrSize = KMaxCapabilityStringLen * 7 + 10;
sl@0	1853
sl@0	1854	class TCompiledSecurityPolicy
sl@0	1855	{
sl@0	1856	public:
sl@0	1857	TCompiledSecurityPolicy(const TSecurityPolicy& aSecurityPolicy) :
sl@0	1858	iSecurityPolicy(aSecurityPolicy) { }
sl@0	1859	const TDesC& TextualizePolicyL(TCapAccessMode aMode);
sl@0	1860
sl@0	1861	private:
sl@0	1862	enum THeaderType
sl@0	1863	{
sl@0	1864	EHdrSecureId,
sl@0	1865	EHdrCapability
sl@0	1866	};
sl@0	1867
sl@0	1868	TCapability CapabilityAt(TInt aIndex) const;
sl@0	1869	void DoCapabilitySection(TInt aMaxNumCaps);
sl@0	1870	void AppendModeHeader(TCapAccessMode aAccessMode, THeaderType aType);
sl@0	1871
sl@0	1872	private:
sl@0	1873	const TSecurityPolicy& iSecurityPolicy;
sl@0	1874	TBuf<KSecPolicyStrSize> iBuf;
sl@0	1875	};
sl@0	1876
sl@0	1877	/////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1878	// CIniFileOut class
sl@0	1879	/**
sl@0	1880	Standard, phase-one CIniFileOut instance creation method.
sl@0	1881	The created CIniFileOut instance will use a temporary text file to store the repository settings.
sl@0	1882	CIniFileOut::CommitL() should be called at the end to finalize the changes.
sl@0	1883	@return A pointer to a fully constructed CIniFileOut instance.
sl@0	1884	@leave System-wide error codes, including KErrNoMemory.
sl@0	1885	*/
sl@0	1886	CIniFileOut* CIniFileOut::NewLC(RFs& aFs,const TDesC& aOutFileName)
sl@0	1887	{
sl@0	1888	CIniFileOut* inifile = new(ELeave) CIniFileOut(aFs);
sl@0	1889	CleanupStack::PushL(inifile);
sl@0	1890	inifile->ConstructL(aOutFileName);
sl@0	1891	return inifile;
sl@0	1892	}
sl@0	1893
sl@0	1894	CIniFileOut::CIniFileOut(RFs& aFs)
sl@0	1895	: iCommited(EFalse), iTransFileBuf(4 * 1024),iFs(aFs)// 4K buffer size
sl@0	1896	{
sl@0	1897	}
sl@0	1898
sl@0	1899	/**
sl@0	1900	Standard, phase-two CIniFileOut instance creation method.
sl@0	1901	Creates the transaction file.
sl@0	1902	Initializes transaction file buffer - iTransFileBuf instance.
sl@0	1903	@leave System-wide error codes, including KErrNoMemory.
sl@0	1904	*/
sl@0	1905	void CIniFileOut::ConstructL(const TDesC& aOutFileName)
sl@0	1906	{
sl@0	1907	iOutFileName=aOutFileName.AllocL();
sl@0	1908	_LIT(KTmpExtension,"tmp");
sl@0	1909	User::LeaveIfError(iTransFilePath.Set(aOutFileName, NULL, &(KTmpExtension())));
sl@0	1910	User::LeaveIfError(iTransFile.Replace(iFs, iTransFilePath.FullName(), EFileWrite \| EFileStreamText));
sl@0	1911	iTransFileBuf.Attach(iTransFile, 0);
sl@0	1912	}
sl@0	1913
sl@0	1914	/**
sl@0	1915	Closes and deletes the transaction file.
sl@0	1916	If CIniFileOut::CommitL() has not been called prior the destructor call, all the changes
sl@0	1917	will be lost.
sl@0	1918	*/
sl@0	1919	CIniFileOut::~CIniFileOut()
sl@0	1920	{
sl@0	1921	if (!iCommited)
sl@0	1922	{
sl@0	1923	iTransFileBuf.Close();
sl@0	1924	// If a debug build - record error
sl@0	1925	TInt fileDeleteErr=iFs.Delete(iTransFilePath.FullName());
sl@0	1926	#ifdef _DEBUG
sl@0	1927	if (fileDeleteErr != KErrNone)
sl@0	1928	{
sl@0	1929	RDebug::Print(_L("CIniFileOut::~CIniFileOut - Failed to delete file. Error = %d"), fileDeleteErr);
sl@0	1930	}
sl@0	1931	#else
sl@0	1932	(void)fileDeleteErr;
sl@0	1933	#endif
sl@0	1934
sl@0	1935	}
sl@0	1936	delete iOutFileName;
sl@0	1937	}
sl@0	1938
sl@0	1939	/**
sl@0	1940	The method writes supplied setting value to the output file.
sl@0	1941	@param aSetting Setting instance, which value has to be written to the output file.
sl@0	1942	@param accessPolicies A string descriptor, referencing related to aSetting access policies.
sl@0	1943	@leave System-wide error codes, including KErrNoMemory.
sl@0	1944	*/
sl@0	1945	void CIniFileOut::WriteSettingL(const TServerSetting& aSetting
sl@0	1946	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1947	,TUint32 aCreVersion
sl@0	1948	#endif
sl@0	1949	)
sl@0	1950	{
sl@0	1951	iBuf.Zero();
sl@0	1952	DoSettingL(aSetting
sl@0	1953	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1954	,aCreVersion
sl@0	1955	#endif
sl@0	1956	);
sl@0	1957	WriteLineL(iBuf);
sl@0	1958	}
sl@0	1959
sl@0	1960	void CIniFileOut::WriteSettingL(const TServerSetting& aSetting,
sl@0	1961	const TSettingsAccessPolicy& aAccessPolicy
sl@0	1962	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1963	,TUint32 aCreVersion
sl@0	1964	#endif
sl@0	1965	)
sl@0	1966	{
sl@0	1967	iBuf.Zero();
sl@0	1968	DoSettingL(aSetting
sl@0	1969	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1970	,aCreVersion
sl@0	1971	#endif
sl@0	1972	);
sl@0	1973	iBuf.Append(KSpace);
sl@0	1974	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1975	if (aCreVersion<2 \|\| (aCreVersion>=2 && aAccessPolicy.iHighKey!=0))
sl@0	1976	#endif
sl@0	1977	AppendSecurityPolicyL(aAccessPolicy.iReadAccessPolicy, ECapReadAccess);
sl@0	1978	iBuf.Append(KSpace);
sl@0	1979	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1980	if (aCreVersion<2 \|\| (aCreVersion>=2 && aAccessPolicy.iKeyMask!=0))
sl@0	1981	#endif
sl@0	1982	AppendSecurityPolicyL(aAccessPolicy.iWriteAccessPolicy, ECapWriteAccess);
sl@0	1983	WriteLineL(iBuf);
sl@0	1984	}
sl@0	1985
sl@0	1986	void CIniFileOut::DoSettingL(const TServerSetting& aSetting
sl@0	1987	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	1988	,TUint32 aCreVersion
sl@0	1989	#endif
sl@0	1990	)
sl@0	1991	{
sl@0	1992	iBuf.AppendNum(aSetting.Key(), EDecimal);
sl@0	1993	iBuf.Append(KSpace);
sl@0	1994
sl@0	1995	::AddSettingValueL(iBuf, aSetting);
sl@0	1996
sl@0	1997	iBuf.Append(KSpace);
sl@0	1998
sl@0	1999	if (!aSetting.Meta())
sl@0	2000	{
sl@0	2001	iBuf.AppendNum(0, EDecimal);
sl@0	2002	}
sl@0	2003	else
sl@0	2004	{
sl@0	2005	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	2006	//need to check on the CRE Version too
sl@0	2007	TBool isClean=const_cast<TServerSetting&>(aSetting).IsClean();
sl@0	2008	if (aCreVersion<2 \|\| (aCreVersion>=2 && (aSetting.IsIndividualMeta() \|\| (!aSetting.IsIndividualMeta() && isClean ))))
sl@0	2009	{
sl@0	2010	TUint32 metaToWrite=aSetting.Meta();
sl@0	2011	//special case
sl@0	2012	if (aCreVersion>=2 && isClean && aSetting.IsIndividualMeta())
sl@0	2013	{
sl@0	2014	metaToWrite\|=KMetaIndividual;
sl@0	2015	}
sl@0	2016	iBuf.AppendFormat(KHexIntFormat, metaToWrite);
sl@0	2017	}
sl@0	2018	#else
sl@0	2019	iBuf.AppendFormat(KHexIntFormat, aSetting.Meta());
sl@0	2020	#endif
sl@0	2021	}
sl@0	2022	}
sl@0	2023
sl@0	2024	/**
sl@0	2025	The method commits settings file changes.
sl@0	2026	If the commit operation fails, the existing settings file will stay unchanged.
sl@0	2027	@leave System-wide error codes.
sl@0	2028	*/
sl@0	2029	void CIniFileOut::CommitL()
sl@0	2030	{
sl@0	2031	iTransFileBuf.SynchL();
sl@0	2032	iTransFileBuf.Close();
sl@0	2033
sl@0	2034	User::LeaveIfError(iFs.Replace(iTransFilePath.FullName(),*iOutFileName));
sl@0	2035
sl@0	2036	iCommited = ETrue;
sl@0	2037	}
sl@0	2038
sl@0	2039	void CIniFileOut::WriteMainSectionHeaderL()
sl@0	2040	{
sl@0	2041	WriteLineL(KMainSection());
sl@0	2042	}
sl@0	2043
sl@0	2044	/**
sl@0	2045	Writes a text line to the repository file.
sl@0	2046	@param aData The string which will be written to the file as a single text line
sl@0	2047	@leave System-wide error codes
sl@0	2048	*/
sl@0	2049	void CIniFileOut::WriteLineL(const TDesC& aData)
sl@0	2050	{
sl@0	2051	iTransFileBuf.WriteL(reinterpret_cast <const TUint8*> (aData.Ptr()), aData.Size());
sl@0	2052	iTransFileBuf.WriteL(reinterpret_cast <const TUint8*> (KCrNl().Ptr()), KCrNl().Size());
sl@0	2053	}
sl@0	2054
sl@0	2055	/**
sl@0	2056	Writes repository file header.
sl@0	2057	@leave System-wide error codes
sl@0	2058	*/
sl@0	2059	void CIniFileOut::WriteHeaderL()
sl@0	2060	{
sl@0	2061	TBuf<64> buf;
sl@0	2062
sl@0	2063	buf.Append(KUcs2Bom);
sl@0	2064	buf.Append(KSignature);
sl@0	2065	WriteLineL(buf);
sl@0	2066
sl@0	2067	buf.Zero();
sl@0	2068	buf.Append(KVersion);
sl@0	2069	buf.Append(KSpace);
sl@0	2070	buf.AppendNum(KCurrentVersion);
sl@0	2071	buf.Append(KCrNl);
sl@0	2072	WriteLineL(buf);
sl@0	2073	}
sl@0	2074
sl@0	2075	/**
sl@0	2076	Writes owner section to repository file.
sl@0	2077	*/
sl@0	2078	void CIniFileOut::WriteOwnerSectionL(TUid aOwner)
sl@0	2079	{
sl@0	2080	if (aOwner.iUid != 0)
sl@0	2081	{
sl@0	2082	WriteLineL(KOwnerSection());
sl@0	2083	TBuf<32> buf;
sl@0	2084	buf.Format(KUidFormat, aOwner.iUid);
sl@0	2085	buf.Append(KCrNl);
sl@0	2086	WriteLineL(buf);
sl@0	2087	}
sl@0	2088	}
sl@0	2089
sl@0	2090	/**
sl@0	2091	Writes time stamp to repository file.
sl@0	2092	@param aTime Time stamp
sl@0	2093	@leave System-wide error codes
sl@0	2094	*/
sl@0	2095	void CIniFileOut::WriteTimeStampL(const TTime& aTime)
sl@0	2096	{
sl@0	2097	if(aTime.Int64() != 0)
sl@0	2098	{
sl@0	2099	WriteLineL(KTimeStampSection());
sl@0	2100	TBuf<32> buf;
sl@0	2101	buf.Num(aTime.Int64());
sl@0	2102	buf.Append(KCrNl);
sl@0	2103	WriteLineL(buf);
sl@0	2104	}
sl@0	2105	}
sl@0	2106
sl@0	2107	/**
sl@0	2108	Writes meta data to repository file.
sl@0	2109	@param aFileIn Input repository file
sl@0	2110	@leave System-wide error codes
sl@0	2111	*/
sl@0	2112	void CIniFileOut::WriteMetaDataL(TUint32 aDefaultMeta,
sl@0	2113	const RDefaultMetaArray& aDefaultMetaRanges)
sl@0	2114	{
sl@0	2115	if (!aDefaultMeta && !aDefaultMetaRanges.Count())
sl@0	2116	{
sl@0	2117	return;
sl@0	2118	}
sl@0	2119
sl@0	2120	WriteLineL(KDefaultMetaSection);
sl@0	2121
sl@0	2122	if (aDefaultMeta)
sl@0	2123	{
sl@0	2124	iBuf.Format(KHexIntFormat, aDefaultMeta);
sl@0	2125	WriteLineL(iBuf);
sl@0	2126	}
sl@0	2127
sl@0	2128	for (TInt i = 0; i<aDefaultMetaRanges.Count(); i++)
sl@0	2129	{
sl@0	2130	const TSettingsDefaultMeta& entry = aDefaultMetaRanges[i];
sl@0	2131	if (entry.HighKey())
sl@0	2132	{
sl@0	2133	iBuf.Format(KRangeMetaFmt, entry.LowKey(), entry.HighKey(),
sl@0	2134	entry.GetDefaultMetadata());
sl@0	2135	}
sl@0	2136	else
sl@0	2137	{
sl@0	2138	iBuf.Format(KMaskMetaFmt, entry.LowKey(), entry.KeyMask(),
sl@0	2139	entry.GetDefaultMetadata());
sl@0	2140	}
sl@0	2141	WriteLineL(iBuf);
sl@0	2142	}
sl@0	2143
sl@0	2144	WriteLineL(KCrNl());
sl@0	2145	}
sl@0	2146
sl@0	2147	/**
sl@0	2148	Writes platsec info to repository file.
sl@0	2149	@param aFileIn Input repository file
sl@0	2150	@leave System-wide error codes
sl@0	2151	*/
sl@0	2152	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	2153	void CIniFileOut::WritePlatSecL(const TSettingsAccessPolicy& aDefaultAccessPolicy,
sl@0	2154	const RRangePolicyArray& aRangePolicies,TUint32 aCreVersion)
sl@0	2155	#else
sl@0	2156	void CIniFileOut::WritePlatSecL(const TSecurityPolicy& aDefaultReadPolicy,
sl@0	2157	const TSecurityPolicy& aDefaultWritePolicy,
sl@0	2158	const RRangePolicyArray& aRangePolicies)
sl@0	2159	#endif
sl@0	2160	{
sl@0	2161	WriteLineL(KPlatSecSection);
sl@0	2162
sl@0	2163	iBuf.Zero();
sl@0	2164	#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0	2165	if (aCreVersion<2 \|\| (aCreVersion>=2 && aDefaultAccessPolicy.iHighKey!=0))
sl@0	2166	AppendSecurityPolicyL(*(aDefaultAccessPolicy.GetReadAccessPolicy()), ECapReadAccess);
sl@0	2167	iBuf.Append(KSpace);
sl@0	2168	if (aCreVersion<2 \|\| (aCreVersion>=2 && aDefaultAccessPolicy.iKeyMask!=0))
sl@0	2169	AppendSecurityPolicyL(*(aDefaultAccessPolicy.GetWriteAccessPolicy()), ECapWriteAccess);
sl@0	2170	#else
sl@0	2171	AppendSecurityPolicyL(aDefaultReadPolicy, ECapReadAccess);
sl@0	2172	iBuf.Append(KSpace);
sl@0	2173	AppendSecurityPolicyL(aDefaultWritePolicy, ECapWriteAccess);
sl@0	2174	#endif
sl@0	2175	WriteLineL(iBuf);
sl@0	2176
sl@0	2177	for(TInt i=0; i < aRangePolicies.Count(); i++)
sl@0	2178	{
sl@0	2179	const TSettingsAccessPolicy& e = aRangePolicies[i];
sl@0	2180	if (e.iHighKey != 0)
sl@0	2181	{
sl@0	2182	iBuf.Format(KRangePrefix, e.iLowKey, e.iHighKey);
sl@0	2183	}
sl@0	2184	else
sl@0	2185	{
sl@0	2186	iBuf.Format(KMaskPrefix, e.iLowKey, e.iKeyMask);
sl@0	2187	}
sl@0	2188
sl@0	2189	iBuf.Append(KSpace);
sl@0	2190
sl@0	2191	AppendSecurityPolicyL(e.iReadAccessPolicy, ECapReadAccess);
sl@0	2192	iBuf.Append(KSpace);
sl@0	2193	AppendSecurityPolicyL(e.iWriteAccessPolicy, ECapWriteAccess);
sl@0	2194	WriteLineL(iBuf);
sl@0	2195	}
sl@0	2196
sl@0	2197	WriteLineL(KCrNl());
sl@0	2198	}
sl@0	2199
sl@0	2200	void CIniFileOut::AppendSecurityPolicyL(const TSecurityPolicy& aPolicy,
sl@0	2201	TCapAccessMode aRdWrMode)
sl@0	2202	{
sl@0	2203	TCompiledSecurityPolicy policy(aPolicy);
sl@0	2204	iBuf.Append(policy.TextualizePolicyL(aRdWrMode));
sl@0	2205	}
sl@0	2206
sl@0	2207	/////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	2208	const TDesC& TCompiledSecurityPolicy::TextualizePolicyL(TCapAccessMode aMode)
sl@0	2209	{
sl@0	2210	iBuf.Zero();
sl@0	2211	AppendModeHeader(aMode, EHdrCapability);
sl@0	2212
sl@0	2213	switch (static_cast<TSecurityPolicy::TType>(iSecurityPolicy.iType))
sl@0	2214	{
sl@0	2215	case TSecurityPolicy::ETypeFail:
sl@0	2216	iBuf.Append(KAccessAlwaysFail);
sl@0	2217	break;
sl@0	2218	case TSecurityPolicy::ETypePass:
sl@0	2219	iBuf.Append(KAccessAlwaysPass);
sl@0	2220	break;
sl@0	2221	case TSecurityPolicy::ETypeC3:
sl@0	2222	DoCapabilitySection(3);
sl@0	2223	break;
sl@0	2224	case TSecurityPolicy::ETypeC7:
sl@0	2225	DoCapabilitySection(7);
sl@0	2226	break;
sl@0	2227	case TSecurityPolicy::ETypeS3:
sl@0	2228	iBuf.Zero(); // erase the "cap_rd", replace with sid_rd
sl@0	2229	AppendModeHeader(aMode, EHdrSecureId);
sl@0	2230	iBuf.AppendNum(iSecurityPolicy.iSecureId);
sl@0	2231
sl@0	2232	if (ECapability_HardLimit != iSecurityPolicy.iCaps[0])
sl@0	2233	{
sl@0	2234	iBuf.Append(KSpace);
sl@0	2235	AppendModeHeader(aMode, EHdrCapability);
sl@0	2236	DoCapabilitySection(3);
sl@0	2237	}
sl@0	2238	break;
sl@0	2239
sl@0	2240	default:
sl@0	2241	User::Leave(KErrCorrupt);
sl@0	2242	} // switch
sl@0	2243
sl@0	2244	return iBuf;
sl@0	2245	}
sl@0	2246
sl@0	2247	TCapability TCompiledSecurityPolicy::CapabilityAt(TInt aIndex) const
sl@0	2248	{
sl@0	2249	if (aIndex < 3)
sl@0	2250	{
sl@0	2251	return static_cast <TCapability> (iSecurityPolicy.iCaps[aIndex]);
sl@0	2252	}
sl@0	2253	else if(aIndex < 7)
sl@0	2254	{
sl@0	2255	return static_cast <TCapability> (iSecurityPolicy.iExtraCaps[aIndex - 3]);
sl@0	2256	}
sl@0	2257	return ECapability_None;
sl@0	2258	}
sl@0	2259
sl@0	2260	//
sl@0	2261	void TCompiledSecurityPolicy::DoCapabilitySection(TInt aMaxNumCaps)
sl@0	2262	{
sl@0	2263	for (TInt i = 0; i < aMaxNumCaps; i++)
sl@0	2264	{
sl@0	2265	TCapability cap = CapabilityAt(i);
sl@0	2266
sl@0	2267	if (cap<0 \|\| cap>= ECapability_Limit)
sl@0	2268	{
sl@0	2269	return;
sl@0	2270	}
sl@0	2271	if (i > 0)
sl@0	2272	{
sl@0	2273	iBuf.Append(',');
sl@0	2274	}
sl@0	2275
sl@0	2276	for (const char* p=CapabilityNames[cap]; *p; p++)
sl@0	2277	{
sl@0	2278	iBuf.Append((TUint16)*p);
sl@0	2279	}
sl@0	2280	} // for i
sl@0	2281	}
sl@0	2282
sl@0	2283	void TCompiledSecurityPolicy::AppendModeHeader(TCapAccessMode aAccessMode,
sl@0	2284	THeaderType aType)
sl@0	2285	{
sl@0	2286	if (aAccessMode == ECapReadAccess)
sl@0	2287	{
sl@0	2288	if (aType == EHdrSecureId)
sl@0	2289	{
sl@0	2290	iBuf.Append(KReadAccessSidString); // "sid_rd"
sl@0	2291	}
sl@0	2292	else
sl@0	2293	{
sl@0	2294	iBuf.Append(KReadAccessCapString); // "cap_rd"
sl@0	2295	}
sl@0	2296	}
sl@0	2297	else
sl@0	2298	{
sl@0	2299	if (aType == EHdrSecureId)
sl@0	2300	{
sl@0	2301	iBuf.Append(KWriteAccessSidString); // "sid_wr"
sl@0	2302	}
sl@0	2303	else
sl@0	2304	{
sl@0	2305	iBuf.Append(KWriteAccessCapString); // "cap_wr"
sl@0	2306	}
sl@0	2307	}
sl@0	2308	iBuf.Append('=');
sl@0	2309	}
sl@0	2310	#endif //CENTREP_CONV_TOOL

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--