// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "APGAIR.H"

#include <apgaplst.h>

#include <bautils.h>

#include "APGICNFL.H" 

#include "APFDEF.H"

#include "apprivate.h"

#include <barsc2.h>

#include <barsread2.h>

#include <e32uid.h>

#include "APGSTD.H"

#include "apsecutils.h"

const TUint KResourceOffsetMask = 0xFFFFF000;

_LIT(KAppBinaryPathAndExtension,"\\sys\\bin\\.exe");

_LIT(KV1AppPathAndExtension, "\\system\\apps\\.app");

const TInt KAppRegistrationInfoResourceId = 1;

#ifndef SYMBIAN_APPARC_APPINFO_CACHE

CApaAppInfoReaderV2* CApaAppInfoReaderV2::NewL(RFs& aFs, const TDesC& aRegistrationFileName, const TUid aAppUid,const TDesC& aDefaultAppIconFileName)

	{

	CApaAppInfoReaderV2* self = new(ELeave) CApaAppInfoReaderV2(aFs, aRegistrationFileName, aAppUid,aDefaultAppIconFileName);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CApaAppInfoReaderV2::CApaAppInfoReaderV2(RFs& aFs, const TDesC& aRegistrationFileName, const TUid aAppUid,const TDesC& aDefaultAppIconFileName)

	: CApaAppInfoReader(aFs, aAppUid),

	iRegistrationFileName(aRegistrationFileName),iDefaultAppIconFileName(aDefaultAppIconFileName)

	{

	}

#else

CApaAppInfoReaderV2* CApaAppInfoReaderV2::NewL(RFs& aFs, const TDesC& aRegistrationFileName, const TUid aAppUid)

	{

	CApaAppInfoReaderV2* self = new(ELeave) CApaAppInfoReaderV2(aFs, aRegistrationFileName, aAppUid);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CApaAppInfoReaderV2::CApaAppInfoReaderV2(RFs& aFs, const TDesC& aRegistrationFileName, const TUid aAppUid)

	: CApaAppInfoReader(aFs, aAppUid),

	iRegistrationFileName(aRegistrationFileName)

	{

	}

#endif // SYMBIAN_APPARC_APPINFO_CACHE

void CApaAppInfoReaderV2::ConstructL()

	{

	iIconLoader = CApaIconLoader::NewL(iFs);

	}

CApaAppInfoReaderV2::~CApaAppInfoReaderV2()

	{

	delete iIconLoader;

	}

#ifdef SYMBIAN_APPARC_APPINFO_CACHE

// The behaviour of the following function is a little non-standard, as it

// transfers ownership of the pointer owned by a CApaAppInfoReaderV2 object

// to the caller. This means that this function is only designed to be called once.

// Doing things this way provides a small performance optimisation by enabling the caller

// to delete it's stored pointer, and replace it with one returned by this function,

// instead of having to copy the object (copying could be expensive for the methods

// of this class that need to return arrays).

CApaIconLoader* CApaAppInfoReaderV2::IconLoader()

	{

	CApaIconLoader* iconLoader = iIconLoader;

	iIconLoader = NULL; // ownership transferred to caller

	return iconLoader;

	}

#endif // SYMBIAN_APPARC_APPINFO_CACHE

// this method reads the minimum information required to register an app

// if this fails (Leaves), we say the read has been unsuccessful

void CApaAppInfoReaderV2::ReadMandatoryInfoL(CResourceFile*& aRegistrationFile, RResourceReader& aResourceReader)

	{

	TEntry entry;

	User::LeaveIfError(iFs.Entry(iRegistrationFileName, entry));

	iTimeStamp = entry.iModified;

	TUint fileOffset = 0;

	TInt fileLength = 0;

	TUid middleUid(KUidApp);

	// in the case of a non-native application, the resource file

	// has been padded with the application type uid

	if (TParsePtrC(iRegistrationFileName).Path().CompareF(KLitPathForNonNativeResourceAndIconFiles)==0)

		{

		fileOffset=sizeof(TCheckedUid);

		fileLength=entry.iSize-fileOffset;

		middleUid=entry[1];

		if (middleUid.iUid==KNullUid.iUid)

			{

			User::Leave(KErrCorrupt);

			}

		}

	aRegistrationFile = CResourceFile::NewL(iFs, iRegistrationFileName, fileOffset, fileLength);

	aResourceReader.OpenL(aRegistrationFile, KAppRegistrationInfoResourceId);

	aResourceReader.ReadUint32L(); // skip over LONG reserved_long

	aResourceReader.ReadUint32L(); // skip over LLINK reserved_llink

	// read LTEXT app_file

	const TPtrC appFile(aResourceReader.ReadTPtrCL());

	TParse parse; // 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

	User::LeaveIfError(parse.SetNoWild(appFile, NULL, NULL)); // 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)

	const TParsePtrC appFileParser(appFile);

	// read LONG attributes

	iCapability.iAttributes = aResourceReader.ReadUint32L();

	if (!appFileParser.NamePresent())

		{

		User::Leave(KErrCorrupt);

		}

	const TPtrC appNameWithoutExtension(appFileParser.Name());

	const TPtrC registrationFileDrive(TParsePtrC(iRegistrationFileName).Drive());

	TUid firstUid(TUid::Null());

	if (iCapability.iAttributes & TApaAppCapability::ENonNative)

		{

		if (!appFileParser.PathPresent() || !appFileParser.ExtPresent())

			{

			User::Leave(KErrCorrupt);

			}

		const TPtrC appFilePath(appFileParser.Path());

		const TPtrC appFileNameAndExt(appFileParser.NameAndExt());

		TPtrC appFileDrive(registrationFileDrive);

		if (appFileParser.DrivePresent())

			{

			appFileDrive.Set(appFileParser.Drive());

			}

		User::LeaveIfError(parse.SetNoWild(appFileDrive, &appFilePath, &appFileNameAndExt));

		// keep firstUid as TUid::Null()

		}

	else if (iCapability.iAttributes & TApaAppCapability::EBuiltAsDll)

		{

		// legacy dll-style app

		User::LeaveIfError(parse.SetNoWild(registrationFileDrive, &KV1AppPathAndExtension, &appNameWithoutExtension));

		User::LeaveIfError(parse.AddDir(appNameWithoutExtension));

		firstUid = KDynamicLibraryUid;

		}

	else

		{

		// exe-style app

		User::LeaveIfError(parse.SetNoWild(registrationFileDrive, &KAppBinaryPathAndExtension, &appNameWithoutExtension));

		firstUid = KExecutableImageUid;

		}

	iAppBinaryFullName = parse.FullName().AllocL();

	// set the TUidType for the app binary

	// cannot read the TEntry info from the app binary because it's in \sys\bin

	iAppBinaryUidType = TUidType(firstUid, middleUid, iAppUid);

	}

// reads as much info as it can

// at least captions and icons must be setup on return from this method (using defaults if necessary)

TBool CApaAppInfoReaderV2::Read()

	{

	CResourceFile* registrationFile = NULL;

	RResourceReader resourceReader;

	TRAPD(ret, ReadMandatoryInfoL(registrationFile, resourceReader));

	if (ret != KErrNone)

		{

		resourceReader.Close();

		delete registrationFile;

		return EFalse; // might have read something, but failed to setup enough info to make it worthwhile trying to read any more

		}

	CResourceFile* localisableFile = NULL;

	TUint localisableResourceId = 1; // only initialising this here to keep the compiler happy, as it's concerned that the variable might be used without having been initialised. The variable should be initialised later, before it's used

	TRAP(ret, ReadNonLocalisableInfoL(resourceReader, localisableFile, localisableResourceId));

	if (ret == KErrNone)

		{

		TRAP(ret, ReadNonLocalisableOptionalInfoL(resourceReader, registrationFile, localisableFile));

		}

	TBool useDefaultIcons=ETrue;

	if (ret == KErrNone && localisableFile)

		{

		TRAP(ret, ReadLocalisableInfoL(localisableFile, localisableResourceId, useDefaultIcons));

		}

	delete localisableFile;

	resourceReader.Close();

	delete registrationFile;

	// if anything went wrong, we tell the caller that the read was unsuccessful. Some

	// of the members of this class may not contain complete data, but this doesn't matter

	// because the caller shouldn't try to access the data if the read was unsuccessful

	TBool readSuccessful = (ret == KErrNone);

	if (useDefaultIcons)

		{

		delete iIcons;

		iIcons = NULL;

		TRAP_IGNORE(iIcons = CApaAppIconArray::NewDefaultIconsL());

		}

	return readSuccessful;

	}

HBufC* CApaAppInfoReaderV2::FullIconFileNameL(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 localisable resource file

		TParse parse;

		TPtrC localisableResourceFileDrive = TParsePtrC(*iLocalisableResourceFileName).Drive();

		TInt ret = parse.SetNoWild(localisableResourceFileDrive, &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(localisableResourceFileDrive)))

				{

				// 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 CApaAppInfoReaderV2::ReadLocalisableInfoL(const CResourceFile* aResourceFile, TUint aResourceId, TBool& aUseDefaultIcons)

	{

	RResourceReader resourceReader;

	resourceReader.OpenLC(aResourceFile, aResourceId);

	resourceReader.ReadUint32L(); // skip over LONG reserved_long

	resourceReader.ReadUint32L(); // skip over LLINK reserved_llink

	// read LTEXT short_caption

	iShortCaption = resourceReader.ReadHBufCL();

	resourceReader.ReadUint32L(); // skip over LONG reserved_long

	resourceReader.ReadUint32L(); // skip over LLINK reserved_llink

	// read LTEXT caption

	iCaption = resourceReader.ReadHBufCL();

	// read WORD number_of_icons

	const TInt numOfIcons = resourceReader.ReadInt16L();

#ifdef SYMBIAN_APPARC_APPINFO_CACHE

	iNumOfAppIcons = numOfIcons;

#endif // SYMBIAN_APPARC_APPINFO_CACHE

	// read LTEXT icon_file

	TPtrC iconFile = resourceReader.ReadTPtrCL();

	iIconFileName = FullIconFileNameL(iconFile);

	if (iIconFileName)

		{

		TEntry entry;

		TInt ret = iFs.Entry(*iIconFileName, entry);

		if (KErrNone == ret)

			{

			iIconFileTimeStamp = entry.iModified;

			}

		aUseDefaultIcons = EFalse;

		if (iFs.IsValidName(*iIconFileName))

			{

			if(FileIsMbmWithGenericExtensionL(*iIconFileName))

				{

				if (numOfIcons > 0)

					{

					CApaAppIconArray* iconArray = CApaAppIconArray::NewAppIconsL(numOfIcons, *iIconFileName, *iIconLoader);

					delete iIcons;

					iIcons = iconArray;

					}

				else

					{

					aUseDefaultIcons = ETrue;		

					}

				}

			else

				{

				iNonMbmIconFile = ETrue;

				}

			}

		//If the filename is not a valid name then the file is treated as a non-mbm file.

		else

			{

			iNonMbmIconFile = ETrue;

			}

		}

	// read LEN WORD STRUCT view_list[]

	const TInt numOfViews = resourceReader.ReadInt16L();

	if (numOfViews > 0)

		{

		iViewDataArray = new(ELeave) CArrayPtrFlat<CApaAppViewData>(1);

		}

	for(TInt view = 0; view < numOfViews; ++view)

		{

		CApaAppViewData* viewData=CApaAppViewData::NewLC();

		resourceReader.ReadUint32L(); // skip over LONG reserved_long

		resourceReader.ReadUint32L(); // skip over LLINK reserved_llink

		// read LONG uid

		const TUid viewUid = {resourceReader.ReadInt32L()};

		viewData->SetUid(viewUid);

		// read LONG screen_mode

		const TInt screenMode = {resourceReader.ReadInt32L()};

		viewData->SetScreenMode(screenMode);

		resourceReader.ReadUint32L(); // skip over LONG reserved_long

		resourceReader.ReadUint32L(); // skip over LLINK reserved_llink

		// read LTEXT caption

		TPtrC viewCaption = resourceReader.ReadTPtrCL();

		viewData->SetCaptionL(viewCaption);

		// read WORD number_of_icons

		const TInt numOfViewIcons = resourceReader.ReadInt16L();

#ifdef SYMBIAN_APPARC_APPINFO_CACHE

		viewData->SetNumOfViewIcons(numOfViewIcons);

#endif // SYMBIAN_APPARC_APPINFO_CACHE

		// read LTEXT icon_file

		TPtrC viewIconFile = resourceReader.ReadTPtrCL();

		HBufC* const fullViewIconFileName = FullIconFileNameL(viewIconFile);

		if (fullViewIconFileName)

			{

			CleanupStack::PushL(fullViewIconFileName);

			viewIconFile.Set(*fullViewIconFileName);

			viewData->SetIconFileNameL(viewIconFile);

			if (iFs.IsValidName(viewIconFile))

				{

				if(!FileIsMbmWithGenericExtensionL(viewIconFile))

					{

					viewData->SetNonMbmIconFile(ETrue);

					}

				}

			//If the filename is not a valid name then the file is treated as a non-mbm file.

			else

				{

				viewData->SetNonMbmIconFile(ETrue);

				}

			}

		else

			{

			viewIconFile.Set(KNullDesC);

			if (numOfViewIcons > 0 && iIconFileName)

				{

				viewIconFile.Set(*iIconFileName); // default to app icon filename

				}

			}

		if (numOfViewIcons > 0 && iFs.IsValidName(viewIconFile) && (FileIsMbmWithGenericExtensionL(viewIconFile)))

			{

			CApaAppIconArray* iconArray = CApaAppIconArray::NewViewIconsL(numOfViewIcons, viewIconFile, *iIconLoader);

			viewData->SetIconArray(iconArray);

			iconArray = NULL;

			}

		if (fullViewIconFileName)

			{

			CleanupStack::PopAndDestroy(fullViewIconFileName);

			}

		iViewDataArray->AppendL(viewData);

		CleanupStack::Pop(viewData);

		}

#ifndef SYMBIAN_APPARC_APPINFO_CACHE

	iIconLoader->LoadAllIconsL();

#endif // SYMBIAN_APPARC_APPINFO_CACHE

	// Read LTEXT group_name

	// If a localised group name has been specified, it overrides

	// The group name (if any), specified by APP_REGISTRATION_INFO

	TApaAppGroupName groupName;

	TRAPD(ret, (groupName = resourceReader.ReadTPtrCL()));

	if (ret != KErrNone)

		{

		 if (ret != KErrEof)

			 {

	         User::Leave(ret);

			 }

		}

	else

		{

	     if (groupName.Length() > 0)

			 {

			 iCapability.iGroupName = groupName;

			 }

		}

	CleanupStack::PopAndDestroy(&resourceReader);

	}

TBool CApaAppInfoReaderV2::FileIsMbm(const TDesC& aFileName)

	{ // static

	if (aFileName.Length() > 0)

		{

		TParsePtrC parsePtr(aFileName);

		_LIT(KFileExtensionMBM, ".MBM");

		if (parsePtr.Ext().CompareF(KFileExtensionMBM) == 0)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

/*An MBM file may have a generic icon extension. In this case, as a way to check whether the file is an MBM one, 

it is necessary to read the content of the fist four 32bit words of it and find out whether these words correspond to 

KWriteonceFileStoreUid, KMultiBitmapFileImageUid, zero and KMultiBitmapFileImageChecksum respectively (defined in graphics/gditools/bmconv/bmconv.h).

So the file is opened and the first 4 32 bit words are extracted and compared with the header information of standard MBM file.

If they match, the function returns ETrue, else it returns EFalse */

TBool CApaAppInfoReaderV2::FileIsMbmWithGenericExtensionL(const TDesC& aFileName) const 

      { 

      if (aFileName.Length() > 0) 

            { 

            //open a file in Share mode - this will allow other methods to access it too

            RFile file;

            User::LeaveIfError(file.Open(iFs,aFileName,EFileShareReadersOnly));

            //this is done beacuse the file can also be accessed by applist at the same time

            //buffer stores the 16 bytes of the file

            CleanupClosePushL(file);

            TBuf8<16> buffer;

            User::LeaveIfError(file.Read(buffer,16));

            CleanupStack::PopAndDestroy();//file

            //we use a constant pointer to the buffer to read header info

        	TPtrC8 filePointer(buffer);

            /*The first 16 bytes of an MBM file are the same for any generic MBM file.

            These are :

            KWriteOnceFileStoreUid = 0x10000037(Emulator MBM file) 0x10000041(ROM image)	

            KMultiBitMapFileImageUid = 0x10000042(Emulator MBM file) 	0x00000001(ROM image)

            Zero = 0x00000000(Emulator MBM file) 0x0000000C(ROM image)

            checksum = 0x47396439(Emulator MBM file) 0x10000040(ROM image)

            The first 16 bytes of the given file is compared with these standard values to ascertain it is MBM file*/

        	if((filePointer[3]==0x10)&&(filePointer[2]==0x00)&&(filePointer[1]==0x00)&&(filePointer[0]==0x37))

        		{//KWriteOnceFileStoreUid = 0x10000037

        		if((filePointer[7]==0x10)&&(filePointer[6]==0x00)&&(filePointer[5]==0x00)&&(filePointer[4]==0x42))

        			{//KMultiBitMapFileImageUid = 0x10000042

        			if((filePointer[11]==0x00)&&(filePointer[10]==0x00)&&(filePointer[9]==0x00)&&(filePointer[8]==0x00))

        				{//Zero = 0x00000000)

        				if((filePointer[15]==0x47)&&(filePointer[14]==0x39)&&(filePointer[13]==0x64)&&(filePointer[12]==0x39))

        					{//checksum = 0x47396439

        					return ETrue;

        					}

        				}

        			}

        		}

        	//Else Check for ROM Image MBM file's header

        	else if((filePointer[3]==0x10)&&(filePointer[2]==0x00)&&(filePointer[1]==0x00)&&(filePointer[0]==0x41))

        		{//KWriteOnceFileStoreUid = 0x10000041

        		if((filePointer[7]==0x00)&&(filePointer[6]==0x00)&&(filePointer[5]==0x00)&&(filePointer[4]==0x01))

        			{//KMultiBitMapFileImageUid = 0x00000001

        			if((filePointer[11]==0x00)&&(filePointer[10]==0x00)&&(filePointer[9]==0x00)&&(filePointer[8]==0x0C))

        				{//Zero = 0x0000000C)

        				if((filePointer[15]==0x10)&&(filePointer[14]==0x00)&&(filePointer[13]==0x00)&&(filePointer[12]==0x40))

        					{//checksum = 0x10000040

        					return ETrue;

        					}

        				}

        			}

        		}

        	}

      return EFalse;

      }

HBufC8* CApaAppInfoReaderV2::ReadOpaqueDataL(TUint aResourceId, const CResourceFile* aRegistrationFile, CResourceFile* aLocalisableResourceFile)

	{ // static

	HBufC8* opaqueData = NULL;

	if (aResourceId == 0)

		{

		opaqueData = HBufC8::NewL(0);