diff -r 5cc91383ab1e -r 7333d7932ef7 installationservices/swi/source/apprscparser/apprscparser.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/source/apprscparser/apprscparser.cpp	Tue Aug 31 15:21:33 2010 +0300
@@ -0,0 +1,901 @@
+/*
+* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* apprscreader.cpp 
+*
+*/
+
+#include "apprscparser.h"
+#include "log.h"
+#include <bautils.h>
+#include <barsc2.h>
+#include <barsread2.h>
+#include <e32uid.h>
+#include "cleanuputils.h"
+
+const TUint KResourceOffsetMask = 0xFFFFF000;
+const TUid KOpenServiceUid = { 0x10208DCA };
+//const TInt KMaxOpaqueDataLength = 0x1000; TODO: Need to enforce this
+
+_LIT(KAppBinaryPathAndExtension, "\\sys\\bin\\.exe");
+_LIT(KAppResourceFileExtension,".rsc");
+_LIT(KThreeDigitSuffix,"%03d");
+_LIT(KTwoDigitSuffix,"%02d");
+_LIT(KApparcFilePath, "*10003a3f*");
+
+const TInt KAppRegistrationInfoResourceId = 1;
+// The 2nd UID that defines a resource file as being an application registration resource file.
+const TUid KUidAppRegistrationFile = {0x101F8021};
+const TInt EPanicNullPointer = 1;
+const TInt KAppUidValue16 = 0x100039CE;
+const TUid KUidApp={KAppUidValue16};
+
+CLocalizableRsc::~CLocalizableRsc()
+    {
+    delete iRscFile;
+    }
+
+CLocalizableRsc* CLocalizableRsc::NewL()
+    {
+    CLocalizableRsc *self = CLocalizableRsc::NewLC();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+CLocalizableRsc* CLocalizableRsc::NewLC()
+    {
+    CLocalizableRsc *self = new(ELeave) CLocalizableRsc();
+    CleanupStack::PushL(self);
+    return self;
+    }
+
+//
+// CAppRegInfoReader
+//
+
+EXPORT_C CAppRegInfoReader* CAppRegInfoReader::NewL(RFs& aFs, const TDesC& aRegistrationFileName)
+	{
+	CAppRegInfoReader* self = new(ELeave) CAppRegInfoReader(aFs, aRegistrationFileName);
+	return self;
+	}
+
+EXPORT_C CAppRegInfoReader* CAppRegInfoReader::NewL(RFs& aFs, const RFile& aRegistrationFile)
+    {
+    CAppRegInfoReader* self = new(ELeave) CAppRegInfoReader(aFs, aRegistrationFile);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+    return self;
+    }
+
+CAppRegInfoReader::CAppRegInfoReader(RFs& aFs, const TDesC& aRegistrationFileName) :
+	iFs(aFs),
+	iAppUid(TUid::Null()),	
+	iRegistrationFileName(&aRegistrationFileName)
+	{	
+	}
+
+CAppRegInfoReader::CAppRegInfoReader(RFs& aFs, const RFile& aRegistrationFile) :
+    iFs(aFs),
+    iAppUid(TUid::Null()),
+    iRegFileHandle(&aRegistrationFile)
+    {
+    iUseRegFileHandle = ETrue;	
+	}
+
+void CAppRegInfoReader::ConstructL()
+	{
+	TFileName fileName;
+	User::LeaveIfError(iRegFileHandle->FullName(fileName));	
+	iRegistrationFileName = fileName.AllocL();	
+	}
+
+EXPORT_C CAppRegInfoReader::~CAppRegInfoReader()
+	{
+	delete iAppBinaryFullName;		
+	iLocalizableRscArray.ResetAndDestroy();
+	iDeviceSupportedLanguages.Close();
+	
+	if (iUseRegFileHandle)
+	    delete iRegistrationFileName; // We had created the filename from the handle
+	}
+
+EXPORT_C Usif::CApplicationRegistrationData* CAppRegInfoReader::ReadL(const RArray<TLanguage>& aAppLanguages)
+    {
+	DEBUG_PRINTF(_L("Reading the application rsc file"));
+	TEntry entry;
+	if (!iUseRegFileHandle)
+	    {
+        User::LeaveIfError(iFs.Entry(*iRegistrationFileName, entry));        
+	    }
+	else
+	    {
+	    // Reading the TUidType information fron the reg rsc file header
+	    TBuf8<sizeof(TCheckedUid)> uidBuf;
+	    TInt err = iRegFileHandle->Read(0, uidBuf, sizeof(TCheckedUid));
+	    if (err != KErrNone || uidBuf.Size() != sizeof(TCheckedUid))
+	        {
+	        DEBUG_PRINTF(_L("The file is not a valid registration resource file"));
+	        User::Leave(KErrCorrupt);
+	        }
+	    TCheckedUid uid(uidBuf);
+	    entry.iType=uid.UidType();
+	    }
+	
+	if (!TypeUidIsForRegistrationFile(entry.iType))
+        {
+        DEBUG_PRINTF(_L("The resource file doesn't have any application registration information"));
+        User::Leave(KErrCorrupt); // We are only interested in application reg resource files
+        }
+	
+	TUint fileOffset = 0;
+	TInt fileLength = 0;
+	TUid firstUid(KExecutableImageUid);
+	TUid middleUid(KUidApp);
+	
+	// Read the AppUid from the rsc file
+	iAppUid = entry.iType[2];
+	if (iAppUid == TUid::Null())
+	    {
+	    DEBUG_PRINTF2(_L("Application UID in the registration resource file %S is NULL"), iRegistrationFileName);
+	    User::Leave(KErrCorrupt); // Mandatory information missing
+	    }
+	
+	// Set the TUidType for the app binary
+	iAppBinaryUidType = TUidType(firstUid, middleUid, iAppUid);
+	// Check to see if we are only interested in any localized info
+	iReadOnlyOneLocalizedRscInfo = aAppLanguages.Count()?EFalse:ETrue;
+	
+	// We need to parse for all device supported languages. Populate iDeviceSupportedLanguages.
+	if (aAppLanguages.Count()>0)
+	    {             
+        GetInstalledLanguagesL();
+	    }
+
+	DEBUG_PRINTF2(_L("Opening rsc file %S"), iRegistrationFileName); //TODO
+	CResourceFile* registrationFile = NULL;
+	if (iUseRegFileHandle)
+	    {
+	    fileLength = 0;        
+        User::LeaveIfError(iRegFileHandle->Size(fileLength));
+
+        if (fileLength > 0)
+            {
+            // Read the reg rsc file to a buffer
+            HBufC8* fileBuffer = HBufC8::NewLC(fileLength);
+            TPtr8 fileBufferPtr(fileBuffer->Des());
+            iRegFileHandle->Read(0, fileBufferPtr);
+            registrationFile = CResourceFile::NewL(*fileBuffer);
+            CleanupStack::PopAndDestroy(fileBuffer);
+            }
+	    }
+	else
+	    {
+	    registrationFile = CResourceFile::NewL(iFs, *iRegistrationFileName, fileOffset, fileLength);
+	    }
+	CleanupStack::PushL(registrationFile);
+	
+	RResourceReader	resourceReader;
+	resourceReader.OpenLC(registrationFile, KAppRegistrationInfoResourceId);	
+	DEBUG_PRINTF(_L("rsc file opened")); //TODO
+	
+	TRAPD(err, ReadMandatoryInfoL(resourceReader));
+	if (err)
+		{
+		DEBUG_PRINTF(_L("Error in ReadMandatoryInfoL"));
+		CleanupStack::PopAndDestroy(2, registrationFile); // resourceReader
+		User::Leave(err); // Might have read something, but failed to setup enough info to make it worthwhile trying to read any more
+		}
+	
+	TUint localizableResourceId = 1; // Only initialising this here to keep the compiler happy
+	TRAP(err, ReadNonLocalizableInfoL(resourceReader, localizableResourceId, iDeviceSupportedLanguages));
+
+	if (!err)
+	    {
+        // Open the localizable resource file for identified languages
+        for (TInt i=0; i < iLocalizableRscArray.Count(); ++i)
+            {
+            iLocalizableRscArray[i]->iRscFile = CResourceFile::NewL(iFs, iLocalizableRscArray[i]->iFileName, 0, 0);
+            CResourceFile* currLocalizableFile = iLocalizableRscArray[i]->iRscFile;
+	        if (currLocalizableFile && (localizableResourceId & KResourceOffsetMask))
+	            currLocalizableFile->ConfirmSignatureL();	        
+	        }	    
+		TRAP(err, ReadNonLocalizableOptionalInfoL(resourceReader, registrationFile));
+		}
+		
+	if (!err)
+	    {
+	    // Read the localized resource information the identified languages
+	    for (TInt i=0; i < iLocalizableRscArray.Count(); ++i)
+	        {
+	        CResourceFile* currLocalizableFile = iLocalizableRscArray[i]->iRscFile;
+	        TFileName fileName = iLocalizableRscArray[i]->iFileName;
+	        DEBUG_PRINTF2(_L("Reading Localizable Info from : %S"), &fileName);
+	        // The following call can leave if the localized resource file is ill formed.
+	        // We'll try to parse other loclized files (if possible) in such a case.
+	        TRAPD(errLocalized, ReadLocalizableInfoL(*currLocalizableFile, localizableResourceId, iLocalizableRscArray[i]->iLanguage));
+	        if (errLocalized)
+                DEBUG_PRINTF3(_L("Error while reading file (%S) : %d"), &fileName, errLocalized);
+	        }
+	    }
+	
+	const TBool readSuccessful = (err == KErrNone);
+	DEBUG_PRINTF2(_L("Application rsc file parsed. Status : %d"), readSuccessful);
+	CleanupStack::PopAndDestroy(2, registrationFile); // resourceReader	
+	
+	Usif::CApplicationRegistrationData* appRegInfo = NULL;
+	if (readSuccessful)
+	    {	    
+	    RPointerArray<Usif::CPropertyEntry> appPropertiesArray;	    	    
+		appRegInfo = Usif::CApplicationRegistrationData::NewL(iOwnedFileArray, iServiceArray, iLocalizableAppInfoArray, 
+                                        appPropertiesArray, iOpaqueDataArray, iAppUid, *iAppBinaryFullName, iAppCharacteristics, iDefaultScreenNumber);
+		
+		DEBUG_PRINTF2(_L("Count Languages (from client) : %d"), aAppLanguages.Count());
+		DEBUG_PRINTF2(_L("Count Languages (after reset) : %d"), iDeviceSupportedLanguages.Count());
+		DEBUG_PRINTF2(_L("Count of Loc files parsed : %d"), iLocalizableRscArray.Count());
+		DEBUG_PRINTF2(_L("Count of Loc data passed to SWI : %d"), iLocalizableAppInfoArray.Count());				
+	   }
+	else
+	    {
+        // Cleanup the member arrays
+        iOwnedFileArray.ResetAndDestroy(); 
+        iServiceArray.ResetAndDestroy();
+        iLocalizableAppInfoArray.ResetAndDestroy();
+        iOpaqueDataArray.ResetAndDestroy();
+	    }
+	
+	return appRegInfo;
+	}
+
+// This method reads the minimum information required to register an app.
+// If this fails, we say the read has been unsuccessful.
+void CAppRegInfoReader::ReadMandatoryInfoL(RResourceReader& aResourceReader)
+	{
+	DEBUG_PRINTF(_L("Reading the mandatory application info"));
+	aResourceReader.ReadUint32L(); // skip over LONG reserved_long
+	aResourceReader.ReadUint32L(); // skip over LLINK reserved_llink
+
+	// Read LTEXT app_file
+	const TPtrC appFile(aResourceReader.ReadTPtrCL());
+	// This object gets used for 2 purposes: first to check that a TParsePtrC can be created 
+	// over "appFile" without it panicking, and second to construct iAppBinaryFullName
+	TParse parse;
+	// Do this before creating a TParsePtrC, since TParsePtrC's constructor panics if it fails 
+	// (which would provide an easy way for malware to kill the Apparc server)
+	User::LeaveIfError(parse.SetNoWild(appFile, NULL, NULL)); 
+	const TParsePtrC appFileParser(appFile);
+
+	// Read LONG attributes
+	iAppCharacteristics.iAttributes = aResourceReader.ReadUint32L();
+
+	if (!appFileParser.NamePresent())
+	    {
+	    DEBUG_PRINTF2(_L("Application Name in the registration resource file %S is not present"),iRegistrationFileName);
+		User::Leave(KErrCorrupt);
+	    }
+
+	const TPtrC appNameWithoutExtension(appFileParser.Name());
+	const TPtrC registrationFileDrive(TParsePtrC(*iRegistrationFileName).Drive());
+	
+	if (iAppCharacteristics.iAttributes & ENonNative)
+		{
+        User::Leave(KErrNotSupported); // Non native apps need not have an applicaiton reg rsc file
+		}
+	else if (iAppCharacteristics.iAttributes & EBuiltAsDll)
+		{
+		User::Leave(KErrNotSupported); // Legacy dll-style app
+		}
+	else
+		{
+		// Exe-style app
+		User::LeaveIfError(parse.SetNoWild(registrationFileDrive, &KAppBinaryPathAndExtension, &appNameWithoutExtension));
+		}
+
+	iAppBinaryFullName = parse.FullName().AllocL();
+	DEBUG_PRINTF2(_L("App Binary FullName : %S"),iAppBinaryFullName); //TODO
+	DEBUG_PRINTF2(_L("AppUid : 0x%X"), iAppUid.iUid); //TODO
+	DEBUG_PRINTF2(_L("Attributes : %d"), iAppCharacteristics.iAttributes); //TODO
+	}
+
+HBufC* CAppRegInfoReader::CreateFullIconFileNameL(const TDesC& aIconFileName) const
+	{
+	HBufC* filename = NULL;
+	if (aIconFileName.Length() == 0)
+		return NULL;
+	
+	//aIconFileName may contain a valid string in some format (for eg. URI format) other than path to a regular file on disk
+	//and that can be a mbm or non-mbm file. Such a filename will be reported as invalid filename by iFs.IsValidName() method. 
+	//aIconFileName will be returned since it is a valid string. 	
+	if(!iFs.IsValidName(aIconFileName))
+		{
+		filename = aIconFileName.AllocL();
+		return filename;
+		}
+	
+	TParsePtrC parsePtr(aIconFileName);
+	if (parsePtr.IsWild() || !parsePtr.PathPresent() || !parsePtr.NamePresent())
+		return NULL;
+
+	// Check for fully qualified icon filename
+	if (parsePtr.DrivePresent() && BaflUtils::FileExists(iFs, aIconFileName))
+		filename = aIconFileName.AllocL();
+	else
+		{
+		// Check for icon file on same drive as localizable resource file
+		TParse parse;
+		TPtrC localizableResourceFileDrive = TParsePtrC(iTempLocalizableRscFileName).Drive();
+		TInt ret = parse.SetNoWild(localizableResourceFileDrive, &aIconFileName, NULL);
+		if (ret == KErrNone && BaflUtils::FileExists(iFs, parse.FullName()))
+			filename = parse.FullName().AllocL();
+		else
+			{
+			TPtrC registrationFileDrive = TParsePtrC(*iRegistrationFileName).Drive();
+			if (TInt(TDriveUnit(registrationFileDrive)) != TInt(TDriveUnit(localizableResourceFileDrive)))
+				{
+				// Check for icon file on same drive as registration file
+				ret = parse.SetNoWild(registrationFileDrive, &aIconFileName, NULL);
+				if (ret == KErrNone && BaflUtils::FileExists(iFs, parse.FullName()))
+					filename = parse.FullName().AllocL();
+				}
+			}
+		}
+	
+	return filename;
+	}
+
+void CAppRegInfoReader::ReadLocalizableInfoL(const CResourceFile& aResourceFile, TUint aResourceId, TLanguage aLanguage)
+	{
+	HBufC* caption = NULL;
+    HBufC* shortCaption = NULL;   
+    TInt numOfAppIcons = 0;
+    HBufC* iconFileName = NULL;
+	    
+	RResourceReader resourceReader;
+	resourceReader.OpenLC(&aResourceFile, aResourceId);
+
+	resourceReader.ReadUint32L(); // skip over LONG reserved_long
+	resourceReader.ReadUint32L(); // skip over LLINK reserved_llink
+		
+	// Read LTEXT short_caption
+	shortCaption = resourceReader.ReadHBufCL();
+	
+	if (shortCaption)
+        {
+        DEBUG_PRINTF2(_L("ShortCaption : %S"), shortCaption); //TODO
+        CleanupStack::PushL(shortCaption);
+        }
+    else
+        {
+        DEBUG_PRINTF(_L("ShortCaption is NULL")); //TODO
+        }
+	
+	resourceReader.ReadUint32L(); // skip over LONG reserved_long
+	resourceReader.ReadUint32L(); // skip over LLINK reserved_llink
+
+	// Read LTEXT caption	
+	caption = resourceReader.ReadHBufCL();
+	
+	if (caption)
+            {
+            DEBUG_PRINTF2(_L("Caption : %S"), caption); //TODO
+            CleanupStack::PushL(caption);
+            }
+        else
+            {
+            DEBUG_PRINTF(_L("Caption is NULL")); //TODO
+            }
+
+	// Read WORD number_of_icons
+	numOfAppIcons = resourceReader.ReadInt16L();
+	DEBUG_PRINTF2(_L("NumOfIcons : %d"), numOfAppIcons); //TODO
+	
+	// Read LTEXT icon_file
+	HBufC* iconFile = resourceReader.ReadHBufCL();
+	if (iconFile)
+	    {
+        if (iReadOnlyOneLocalizedRscInfo)
+            iconFileName = iconFile; // We do not need to check if the icon file is present
+        else
+            {
+            CleanupStack::PushL(iconFile);
+            iconFileName = CreateFullIconFileNameL(*iconFile);
+            CleanupStack::PopAndDestroy(iconFile);
+            }
+	    }
+
+	if (iconFileName)
+	    {
+	    DEBUG_PRINTF2(_L("IconFileName : %S"), iconFileName); //TODO
+	    CleanupStack::PushL(iconFileName);
+	    }
+	else
+	    {
+	    DEBUG_PRINTF(_L("IconFileName is NULL")); //TODO
+	    }
+
+	// Create CCaptionAndIconInfo for the locale
+	Usif::CCaptionAndIconInfo* captionAndIconInfo = Usif::CCaptionAndIconInfo::NewLC(caption?*caption:_L(""), iconFileName?*iconFileName:_L(""), numOfAppIcons);			
+	
+	// Read LEN WORD STRUCT view_list[]
+	const TInt numOfViews = resourceReader.ReadInt16L();
+	
+	RPointerArray<Usif::CAppViewData> viewDataList;
+	CleanupResetAndDestroyPushL(viewDataList);
+	for(TInt view = 0; view < numOfViews; ++view)
+		{
+		DEBUG_PRINTF2(_L(" *** View Details for index %d ***"), view); //TODO
+		resourceReader.ReadUint32L(); // skip over LONG reserved_long
+		resourceReader.ReadUint32L(); // skip over LLINK reserved_llink
+
+		// Read LONG uid
+		const TUid viewUid = {resourceReader.ReadInt32L()};
+		DEBUG_PRINTF2(_L("ViewUid : 0x%X"), viewUid); //TODO
+		// Read LONG screen_mode
+		const TInt screenMode = {resourceReader.ReadInt32L()};
+		DEBUG_PRINTF2(_L("ScreenMode : %d"), screenMode); //TODO
+		
+		resourceReader.ReadUint32L(); // skip over LONG reserved_long
+		resourceReader.ReadUint32L(); // skip over LLINK reserved_llink
+
+		// Read LTEXT caption
+		HBufC* viewCaption = resourceReader.ReadHBufCL();
+		if (viewCaption)
+            {
+            DEBUG_PRINTF2(_L("ViewCaption : %S"), viewCaption); //TODO
+            CleanupStack::PushL(viewCaption);
+            }
+        else
+            {
+            DEBUG_PRINTF(_L("ViewCaption is NULL")); //TODO
+            }
+		
+		// Read WORD number_of_icons
+		const TInt numOfViewIcons = resourceReader.ReadInt16L();
+		DEBUG_PRINTF2(_L("NumOfViewIcons : %d"), numOfViewIcons); //TODO
+		
+		HBufC* fullViewIconFileName = NULL;
+		// Read LTEXT icon_file
+		HBufC* viewIconFile = resourceReader.ReadHBufCL();  
+		
+        if (viewIconFile)
+		    {
+		    CleanupStack::PushL(viewIconFile);
+            fullViewIconFileName = CreateFullIconFileNameL(*viewIconFile); 
+            CleanupStack::PopAndDestroy(viewIconFile);
+            if (fullViewIconFileName)
+                {               
+                CleanupStack::PushL(fullViewIconFileName);
+                DEBUG_PRINTF2(_L("ViewIconFileName : %S"), fullViewIconFileName); //TODO
+                }
+            else
+                {
+                DEBUG_PRINTF(_L("ViewIconFileName is NULL")); //TODO
+                }            
+		    }
+				
+		// Create CCaptionAndIconInfo for the view
+		Usif::CCaptionAndIconInfo* viewCaptionAndIcon = Usif::CCaptionAndIconInfo::NewLC(viewCaption?*viewCaption:_L(""), fullViewIconFileName?*fullViewIconFileName:_L(""), numOfViewIcons);
+		// Create the view
+		Usif::CAppViewData* viewData = Usif::CAppViewData::NewLC(viewUid, screenMode, viewCaptionAndIcon);
+		
+		viewDataList.AppendL(viewData);
+		
+		CleanupStack::Pop(2, viewCaptionAndIcon); // viewData
+		if (fullViewIconFileName)
+		    CleanupStack::PopAndDestroy(fullViewIconFileName);
+		if (viewCaption)
+		    CleanupStack::PopAndDestroy(viewCaption);
+		}
+
+	// Read LTEXT group_name
+	TAppGroupName groupName;
+	TRAPD(ret, (groupName = resourceReader.ReadTPtrCL()));
+	if (ret != KErrNone)
+		{
+		 if (ret != KErrEof)
+	         User::Leave(ret);
+		}
+	
+	DEBUG_PRINTF2(_L("GroupName : %S"), &groupName); //TODO	
+	Usif::CLocalizableAppInfo* localizableAppInfo = Usif::CLocalizableAppInfo::NewLC(shortCaption?*shortCaption:_L(""), aLanguage, groupName, captionAndIconInfo, viewDataList);
+	iLocalizableAppInfoArray.AppendL(localizableAppInfo);
+	
+	CleanupStack::Pop(3, captionAndIconInfo); // localizableAppInfo, viewDataList
+	if (iconFileName)
+	    CleanupStack::PopAndDestroy(iconFileName);
+	if (caption)
+	    CleanupStack::PopAndDestroy(caption);
+	if (shortCaption)
+	    CleanupStack::PopAndDestroy(shortCaption);
+	CleanupStack::PopAndDestroy(&resourceReader);
+	}
+
+void CAppRegInfoReader::ReadOpaqueDataL(TUint aResourceId, const CResourceFile* aRegistrationFile, RPointerArray<Usif::COpaqueData>& aOpaqueDataArray)
+    {
+    if (aResourceId == 0)
+        return;
+    else
+        {
+        if (aResourceId & KResourceOffsetMask)
+            {
+            for (TInt i=0; i < iLocalizableRscArray.Count(); ++i)
+                {
+                CResourceFile* currLocalizableFile = iLocalizableRscArray[i]->iRscFile;                
+                currLocalizableFile->ConfirmSignatureL();
+                HBufC8* data = NULL;
+                TRAPD(err, data = currLocalizableFile->AllocReadL(aResourceId));                  
+                if(err == KErrNone)
+                    {
+                    DEBUG_PRINTF3(_L8("Opaque Data read (length %d) from the localizable resouce file : %S"), data->Length(), data);
+                    CleanupStack::PushL(data);
+                    Usif::COpaqueData* opaqueData = Usif::COpaqueData::NewL(*data, iLocalizableRscArray[i]->iLanguage);
+                    aOpaqueDataArray.AppendL(opaqueData);
+                    CleanupStack::PopAndDestroy(data);
+                    }
+                }            
+            }
+        else
+            {
+            // Expecting opaque data to be in the registration file
+            __ASSERT_ALWAYS(aRegistrationFile, Panic(EPanicNullPointer));
+            HBufC8* data = aRegistrationFile->AllocReadLC(aResourceId);
+            DEBUG_PRINTF3(_L8("Opaque Data read (length %d) from the registration resouce file : %S"), data->Length(), data);
+            Usif::COpaqueData* opaqueData = Usif::COpaqueData::NewL(*data, TLanguage(0));
+            aOpaqueDataArray.AppendL(opaqueData);
+            CleanupStack::PopAndDestroy(data);
+            }
+        }
+    }
+
+void CAppRegInfoReader::ReadNonLocalizableOptionalInfoL(RResourceReader& aResourceReader, const CResourceFile* aRegistrationFile)
+	{
+	DEBUG_PRINTF(_L("Reading the application non localized optional info"));
+	// Read LEN WORD STRUCT service_list[]
+	TInt serviceCount = 0;
+	// Service information was not present in the first release of the registration file
+	// APP_REGISTRATION_INFO resource struct.
+	// This method must not leave if the registration file doesn't contain service information, so the
+	// following call to ReadInt16L is trapped to ensure this method doesn't leave just because
+	// there is no more information in the resource to read (KErrEof)
+	TRAPD(err, serviceCount = aResourceReader.ReadInt16L());
+	if (err)
+		{
+		if (err == KErrEof)
+			return; // End of resource reached
+		
+		User::Leave(err);
+		}
+	DEBUG_PRINTF2(_L("Service count is : %d"), serviceCount); //TODO
+	
+	while (serviceCount--)
+		{
+		const TUid serviceUid = {aResourceReader.ReadUint32L()};
+		
+		if ((serviceUid == KOpenServiceUid) && (iLegacyDataTypesPresent))
+			{
+            __ASSERT_DEBUG( iServiceArray.Count(), Panic(EPanicNullPointer) );
+			// Deleting the legacy datatypes
+            Usif::CServiceInfo* firstElement = iServiceArray[0];
+            iServiceArray.Remove(0);
+            delete firstElement;
+            iLegacyDataTypesPresent = EFalse;
+			}
+		
+		RPointerArray<Usif::CDataType> serviceDataTypes;
+		CleanupResetAndDestroyPushL(serviceDataTypes);
+		ReadMimeTypesSupportedL(aResourceReader, serviceDataTypes);
+		
+		const TUint resourceId = aResourceReader.ReadUint32L();
+		RPointerArray<Usif::COpaqueData> serviceOpaqueDataArray;
+		CleanupResetAndDestroyPushL(serviceOpaqueDataArray);
+		ReadOpaqueDataL(resourceId, aRegistrationFile, serviceOpaqueDataArray);
+						
+		Usif::CServiceInfo* serviceInfo = Usif::CServiceInfo::NewLC(serviceUid, serviceOpaqueDataArray, serviceDataTypes);
+		iServiceArray.AppendL(serviceInfo);
+		DEBUG_PRINTF3(_L("ServiceUid (index %d) is : 0x%X "), iServiceArray.Count()-1, serviceUid.iUid); //TODO
+		
+		CleanupStack::Pop(3, &serviceDataTypes); // serviceInfo, serviceOpaqueDataArray
+		}
+	
+	// Read LLINK opaque_data
+	const TUint resourceId = aResourceReader.ReadUint32L();
+	ReadOpaqueDataL(resourceId, aRegistrationFile, iOpaqueDataArray);
+	}
+
+void CAppRegInfoReader::ReadNonLocalizableInfoL(RResourceReader& aResourceReader, TUint& aLocalizableResourceId, const RArray<TLanguage>& aAppLanguages)
+	{
+	DEBUG_PRINTF(_L("Reading the application non localized info"));
+	
+	// Read LTEXT localizable_resource_file
+	TPtrC localizableResourceFileName(aResourceReader.ReadTPtrCL());
+	if (localizableResourceFileName.Length() > 0 && iFs.IsValidName(localizableResourceFileName))
+		{
+		// Determine the language specific name of the localizable resource file
+		TParse parse;
+		TParsePtrC parsePtr(*iRegistrationFileName);
+		User::LeaveIfError(parse.SetNoWild(parsePtr.Drive(), &KAppResourceFileExtension, &localizableResourceFileName));
+		TFileName localizableRscFileName(parse.FullName());
+		DEBUG_PRINTF2(_L("Localizable filename from rsc is : %S"), &localizableRscFileName); 
+		iTempLocalizableRscFileName = localizableRscFileName; // Store the rsc filename as read (before bafl makes any changes)
+		
+		// Check if we need to read more than one localized resource file
+		if (!aAppLanguages.Count())
+		    {
+            TLanguage applicationLanguage;		    
+            BaflUtils::NearestLanguageFileV2(iFs, localizableRscFileName, applicationLanguage);
+		
+            // We are able to find a match
+            if (BaflUtils::FileExists(iFs, iTempLocalizableRscFileName))
+                {
+                // We read here only for one locale, similar to AppArc's behaviour when parsing the resource file
+                CLocalizableRsc* localizedRsc = CLocalizableRsc::NewL();
+                localizedRsc->iFileName = localizableRscFileName;
+                if (ELangNone == applicationLanguage)
+                    localizedRsc->iLanguage = TLanguage(0);
+                else
+                    localizedRsc->iLanguage = applicationLanguage;
+                iLocalizableRscArray.Append(localizedRsc);
+                }
+            else 
+                {
+                // The resource files are located in non-standard location (like in the case of GetComponentInfo).
+                // We need to find the temporary paths for localized resource files in this case.
+                // The reg file will be in some location like <path>\regfilename_reg.rsc and localized rsc file name
+                // would point to \resource\apps\localregfilename.rsc or \resource\apps\localregfilename.r01 etc.
+                // Changing the localized rsc file name to <path>\localregfilename.rsc
+                TFileName nonStdLocalizedRscFileName = parsePtr.DriveAndPath(); // Drive and path from Registration FileName
+                nonStdLocalizedRscFileName.Append(TParsePtrC(localizableRscFileName).NameAndExt()); // Name and extension of localized rsc file
+                iTempLocalizableRscFileName = nonStdLocalizedRscFileName; // For FindLocalizableResourceFilesL
+                
+                if (KErrNotFound == iTempLocalizableRscFileName.Match(KApparcFilePath))
+                    {
+                    applicationLanguage = User::Language();                
+                    FindLocalizableResourceFilesL(applicationLanguage); 
+                
+                    // If there is no match, check for default localizable rsc file
+                    if (!iLocalizableRscArray.Count())
+                        CheckForDefaultResourceFileL();
+                    }
+                }            
+		    }
+		else
+		    {
+            for (TInt i=0; i < aAppLanguages.Count(); ++i)
+                FindLocalizableResourceFilesL(aAppLanguages[i]);
+            
+            CheckForDefaultResourceFileL();
+		    }
+		}
+        
+	// Read LONG localizable_resource_id
+	aLocalizableResourceId = aResourceReader.ReadUint32L();
+	DEBUG_PRINTF3(_L("LocalizableResourceId : %d : 0x%X "), aLocalizableResourceId, aLocalizableResourceId); //TODO
+	
+	DEBUG_PRINTF(_L("Reading app characteristics")); //TODO
+	iAppCharacteristics.iAppIsHidden = aResourceReader.ReadInt8L();
+	iAppCharacteristics.iEmbeddability = (Usif::TApplicationCharacteristics::TAppEmbeddability)aResourceReader.ReadInt8L();
+	iAppCharacteristics.iSupportsNewFile = aResourceReader.ReadInt8L();
+	iAppCharacteristics.iLaunchInBackground = aResourceReader.ReadInt8L();
+	iAppCharacteristics.iGroupName = aResourceReader.ReadTPtrCL();
+	iDefaultScreenNumber = aResourceReader.ReadUint8L();
+ 	
+	DEBUG_PRINTF2(_L("iAppIsHidden : %d"), iAppCharacteristics.iAppIsHidden); //TODO
+	DEBUG_PRINTF2(_L("iEmbeddability : %d"), iAppCharacteristics.iEmbeddability); //TODO
+	DEBUG_PRINTF2(_L("iSupportsNewFile : %d"), iAppCharacteristics.iSupportsNewFile); //TODO
+	DEBUG_PRINTF2(_L("iLaunchInBackground : %d"), iAppCharacteristics.iLaunchInBackground); //TODO
+	DEBUG_PRINTF2(_L("iGroupName : %S"), &(iAppCharacteristics.iGroupName)); //TODO
+	DEBUG_PRINTF2(_L("iDefaultScreenNumber : %d"), iDefaultScreenNumber); //TODO
+	
+	// Read the datatypes
+	RPointerArray<Usif::CDataType> dataTypes;
+	CleanupResetAndDestroyPushL(dataTypes);
+	RPointerArray<Usif::COpaqueData> opaqueDataArray;
+	CleanupResetAndDestroyPushL(opaqueDataArray);
+	ReadMimeTypesSupportedL(aResourceReader, dataTypes);
+	
+	// DataTypes are deleted if 
+	//  A. There are no legacy datatypes
+	//  B. Control panel plugin apps are not allowed to register MIME types.If they happen to have any, 
+	//     these datatypes should be ignored.
+	if ((iAppCharacteristics.iAttributes & EControlPanelItem) || (dataTypes.Count() == 0))
+	    {
+	    CleanupStack::Pop(2, &dataTypes); // opaqueDataArray
+	    dataTypes.ResetAndDestroy();
+	    opaqueDataArray.ResetAndDestroy();	    
+	    }
+	else
+		{
+		DEBUG_PRINTF(_L("Reading Open Service Datatypes")); //TODO
+		
+		Usif::CServiceInfo* serviceInfo = Usif::CServiceInfo::NewLC(KOpenServiceUid, opaqueDataArray, dataTypes);
+		iServiceArray.AppendL(serviceInfo);
+		DEBUG_PRINTF2(_L("ServiceUid (index %d) is : OpenServiceUid "), iServiceArray.Count()-1); //TODO
+		
+		CleanupStack::Pop(3, &dataTypes); // serviceInfo, opaqueDataArray
+		iLegacyDataTypesPresent = ETrue;
+		}
+
+	// Read LEN WORD STRUCT file_ownership_list[]
+	const TInt fileOwnershipArraySize = aResourceReader.ReadInt16L();
+	DEBUG_PRINTF2(_L("Owned File Array Size is : %d"), fileOwnershipArraySize); //TODO
+
+	DEBUG_PRINTF(_L("Reading Owned File Array")); //TODO
+	for (TInt i=0; i < fileOwnershipArraySize; i++)
+		{
+		TPtrC fileNamePtr = aResourceReader.ReadTPtrCL();
+		iOwnedFileArray.AppendL(fileNamePtr.AllocL());
+		DEBUG_PRINTF3(_L("File (index %d) is : %S "), i, &fileNamePtr); //TODO
+		}
+	}
+	
+void CAppRegInfoReader::ReadMimeTypesSupportedL(RResourceReader& aResourceReader, RPointerArray<Usif::CDataType>& aDataTypes)
+    {
+    DEBUG_PRINTF(_L("Reading MimeTypes supported")); //TODO
+    // Read LEN WORD STRUCT datatype_list[]
+    const TInt dataTypeArraySize = aResourceReader.ReadInt16L();
+    DEBUG_PRINTF2(_L("DataType Array Size is : %d"), dataTypeArraySize); //TODO
+    if (dataTypeArraySize <= 0)
+        return;
+    
+    for (TInt i=0; i < dataTypeArraySize; i++)
+        {
+        TInt32 priority = aResourceReader.ReadInt32L();
+                   
+        TPtrC8 typePtr = aResourceReader.ReadTPtrC8L();
+        TBuf16<KMaximumDataTypeLength> buf;
+        buf.Copy(typePtr); 
+        DEBUG_PRINTF3(_L("Service Info Priority (index %d) is : %d "), i, priority); //TODO
+        DEBUG_PRINTF3(_L("Service Info Type (index %d) is : %S "), i, &buf); //TODO
+        
+        Usif::CDataType* dataType = Usif::CDataType::NewLC(priority, buf);        
+        aDataTypes.AppendL(dataType);
+        CleanupStack::Pop(dataType);
+        }
+    }
+
+void CAppRegInfoReader::CheckForDefaultResourceFileL()
+    {
+    if (BaflUtils::FileExists(iFs, iTempLocalizableRscFileName))   
+        {      
+        DEBUG_PRINTF2(_L("Default localized resource file is present : %S"), &iTempLocalizableRscFileName);
+        CLocalizableRsc* localizedRsc = CLocalizableRsc::NewL();
+        localizedRsc->iFileName = iTempLocalizableRscFileName;
+        localizedRsc->iLanguage = TLanguage(0); //Non-localized details
+        iLocalizableRscArray.Append(localizedRsc);
+        }
+    }
+
+// Find the correct localized resource file based on the given language
+void CAppRegInfoReader::FindLocalizableResourceFilesL(const TLanguage& aApplicationLanguage)
+    {
+    DEBUG_PRINTF2(_L("Finding localizable resource files for language : %d"), aApplicationLanguage);
+        
+    TLanguagePath langEquivalents;
+    RArray<TLanguage> appLanguages;
+    BaflUtils::GetEquivalentLanguageList(aApplicationLanguage, langEquivalents);
+    TInt i = 0;
+    while (langEquivalents[i] != ELangNone)
+        {
+        appLanguages.Append(langEquivalents[i]);
+        ++i;
+        }
+    
+    TInt newLength = iTempLocalizableRscFileName.Length() - 2;
+    TFileName localizedRscFileNamePrefix(iTempLocalizableRscFileName.Left(newLength));
+    DEBUG_PRINTF2(_L("FileName after trimming last digits : %S"), &localizedRscFileNamePrefix); //TODO
+            
+    for (TInt i=0; i < appLanguages.Count(); ++i)
+        {                
+        TFileName localizedRscFileName(localizedRscFileNamePrefix);
+        if (appLanguages[i] > 99)
+            localizedRscFileName.AppendFormat(KThreeDigitSuffix, appLanguages[i]);
+        else
+            localizedRscFileName.AppendFormat(KTwoDigitSuffix, appLanguages[i]);
+        
+        // Check if the file exist
+        if (BaflUtils::FileExists(iFs, localizedRscFileName))
+            {
+            // Check if language already exists
+            TInt rscCount = iLocalizableRscArray.Count();
+            TBool isExists = EFalse;
+            for(TInt j = 0; j < rscCount; j++)
+                {
+                if(appLanguages[i] == iLocalizableRscArray[j]->iLanguage)
+                    {
+                    isExists = ETrue;
+                    break;
+                    }
+                }
+            
+            if(!isExists)
+                {
+                CLocalizableRsc* localizedRsc = CLocalizableRsc::NewL();
+                localizedRsc->iFileName = localizedRscFileName;
+                localizedRsc->iLanguage = appLanguages[i];
+                iLocalizableRscArray.Append(localizedRsc);
+                DEBUG_PRINTF2(_L("Localized rsc file is : %S"), &localizedRscFileName);
+                }            
+            break;
+            }
+        } 
+    
+    appLanguages.Close();
+    }
+
+TBool CAppRegInfoReader::TypeUidIsForRegistrationFile(const TUidType& aUidType)
+    {
+    return (aUidType[1].iUid==KUidAppRegistrationFile.iUid);
+    }
+
+void CAppRegInfoReader::Panic(TInt aPanic)
+    {
+    _LIT(KSWIAppRegInfoReaderPanic,"SWIAppRegInfoReaderPanic");
+    User::Panic(KSWIAppRegInfoReaderPanic, aPanic);
+    }
+
+void CAppRegInfoReader::GetInstalledLanguagesL()
+    {
+    _LIT(KLanguagesIni, "z:\\resource\\bootdata\\languages.txt");
+    const TInt KReadBufSize = 10;
+    
+    iDeviceSupportedLanguages.Reset();
+    
+    RFile file;
+    TInt err = file.Open(iFs, KLanguagesIni, EFileRead|EFileShareReadersOnly);
+    if (KErrNone == err)
+        {
+        CleanupClosePushL(file);
+        
+        TFileText reader;
+        reader.Set(file);
+        err = reader.Seek(ESeekStart);
+        if (KErrNone == err)
+            {
+            TBuf<KReadBufSize> readBuf;
+            while(KErrNone == reader.Read(readBuf))
+                {
+                if (readBuf.Length() > 0)
+                    {
+                    TLex lex(readBuf);
+                    lex.SkipSpace();
+                    TInt language;
+                    err = lex.Val(language);
+                    if (KErrNone != err)
+                        {
+                        readBuf.Zero();
+                        continue; // Read the next line
+                        }
+                    iDeviceSupportedLanguages.AppendL((TLanguage)language);
+                    }
+                readBuf.Zero();
+                }
+            }
+        else
+            {
+            DEBUG_PRINTF3(_L("Reading %S failed with %d"), &KLanguagesIni, err);
+            }
+        
+        CleanupStack::PopAndDestroy(&file);
+        }
+    else
+        {
+        DEBUG_PRINTF3(_L("Opening %S failed with %d"), &KLanguagesIni, err);
+        }
+    
+    // If we are not able fetch the device languages, just parse for the current device language
+    if (0 == iDeviceSupportedLanguages.Count())
+        {
+        iDeviceSupportedLanguages.AppendL(User::Language());
+        }
+    }