// 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 "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:

// aplappinforeader.cpp

//

#include "aplapplist.h"

#include "aplapplistitem.h"

#include "aplappinforeader.h"

#include <apgaplst.h>

#include <bautils.h>

#include "APGICNFL.H" 

#include "APFDEF.H"

#include "../apgrfx/apprivate.h"		// KUidPrefixedNonNativeRegistrationResourceFile

#include <barsc2.h>

#include <barsread2.h>

#include <e32uid.h>

#include "../apgrfx/APGSTD.H"			// EPanicNullPointer

#include "../apgrfx/apsecutils.h"		// CApaSecurityUtils

const TUint KResourceOffsetMask = 0xFFFFF000;

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

const TInt KAppRegistrationInfoResourceId = 1;

// The 2nd UID that defines a resource file as being an application registration resource file.

const TUid KUidAppRegistrationFile = {0x101F8021};

//

// Local functions

//

extern void CleanupServiceArray(TAny* aServiceArray);	// Implemented in AplAppList.cpp

// ApaUtils

TBool ApaUtils::TypeUidIsForRegistrationFile(const TUidType& aUidType)

	{ // static

	return (aUidType[1].iUid==KUidAppRegistrationFile.iUid ||

		   aUidType[0].iUid==KUidPrefixedNonNativeRegistrationResourceFile);

	}

//

// CApaAppInfoReader

//

// The behaviour of the Take-methods of this class is a little non-standard, as it

// transfers ownership of the pointer owned by a CApaAppInfoReader derived 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).

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

	iFs(aFs),

	iAppUid(aAppUid),

	iTimeStamp(0),

	iDefaultScreenNumber(0),

	iNonMbmIconFile(EFalse),

	iLocalisableResourceFileTimeStamp(0),

	iApplicationLanguage(ELangNone),

	iIndexOfFirstOpenService(KErrNotFound),

	iRegistrationFileName(aRegistrationFileName)

	{

	}

void CApaAppInfoReader::ConstructL()

	{

	iIconLoader = CApaIconLoader::NewL(iFs);

	}

CApaAppInfoReader::~CApaAppInfoReader()

	{

	delete iAppBinaryFullName;

	delete iCaption;

	delete iShortCaption;

	delete iIcons;

	if (iViewDataArray)

		iViewDataArray->ResetAndDestroy();

	delete iViewDataArray;

	delete iOwnedFileArray;

	delete iIconFileName;

	delete iLocalisableResourceFileName;

	if (iServiceArray)

 		{

 		CleanupServiceArray(iServiceArray);

 		iServiceArray = NULL;

  		}

	delete iOpaqueData;

	delete iIconLoader;

	}

HBufC* CApaAppInfoReader::AppBinaryFullName()

	{

	HBufC* fileName = iAppBinaryFullName;

	iAppBinaryFullName = NULL; // ownership transferred to caller

	return fileName;

	}

TUidType CApaAppInfoReader::AppBinaryUidType() const

	{

	return iAppBinaryUidType;

	}

TTime CApaAppInfoReader::TimeStamp() const

	{

	return iTimeStamp;

	}

TTime CApaAppInfoReader::IconFileTimeStamp() const

     {

     return iIconFileTimeStamp;

     }

void CApaAppInfoReader::Capability(TDes8& aCapabilityBuf) const

	{

	TApaAppCapabilityBuf buf(iCapability);

	TApaAppCapability::CopyCapability(aCapabilityBuf, buf);

	}

TUint CApaAppInfoReader::DefaultScreenNumber() const

	{

	return iDefaultScreenNumber;

	}

HBufC* CApaAppInfoReader::Caption()

	{

	HBufC* caption = iCaption;

	iCaption = NULL; // ownership transferred to caller

	return caption;

	}

HBufC* CApaAppInfoReader::ShortCaption()

	{

	HBufC* shortCaption = iShortCaption;

	iShortCaption = NULL; // ownership transferred to caller

	return shortCaption;

	}

CApaAppIconArray* CApaAppInfoReader::Icons()

	{

	CApaAppIconArray* icons = iIcons;

	iIcons = NULL; // ownership transferred to caller

	return icons;

	}

TInt CApaAppInfoReader::NumOfAppIcons() const

	{

	return iNumOfAppIcons;

	}

CArrayPtrFlat<CApaAppViewData>* CApaAppInfoReader::Views()

	{

	CArrayPtrFlat<CApaAppViewData>* viewDataArray = iViewDataArray;

	iViewDataArray = NULL; // ownership transferred to caller

	return viewDataArray;

	}

CDesCArray* CApaAppInfoReader::OwnedFiles()

	{

	CDesCArray* ownedFileArray = iOwnedFileArray;

	iOwnedFileArray = NULL; // ownership transferred to caller

	return ownedFileArray;

	}

HBufC* CApaAppInfoReader::IconFileName()

	{

	HBufC* iconFileName = iIconFileName;

	iIconFileName = NULL; // ownership transferred to caller

	return iconFileName;

	}

TBool CApaAppInfoReader::NonMbmIconFile() const

	{

	return iNonMbmIconFile;

	}

HBufC* CApaAppInfoReader::LocalisableResourceFileName()

	{

	HBufC* localisableResourceFileName = iLocalisableResourceFileName;

	iLocalisableResourceFileName = NULL; // ownership transferred to caller

	return localisableResourceFileName;

	}

TTime CApaAppInfoReader::LocalisableResourceFileTimeStamp() const

	{

	return iLocalisableResourceFileTimeStamp;

	}

TLanguage CApaAppInfoReader::AppLanguage() const

	{

	return iApplicationLanguage;

	}

CArrayFixFlat<TApaAppServiceInfo>* CApaAppInfoReader::ServiceArray(TInt& aIndexOfFirstOpenService)

	{

	CArrayFixFlat<TApaAppServiceInfo>* serviceArray = iServiceArray;

	iServiceArray = NULL;

	aIndexOfFirstOpenService = iIndexOfFirstOpenService;

	return serviceArray;

	}

HBufC8* CApaAppInfoReader::OpaqueData()

	{

	HBufC8* opaqueData = iOpaqueData;

	iOpaqueData = NULL;

	return opaqueData;

	}

CApaIconLoader* CApaAppInfoReader::IconLoader()

	{

	CApaIconLoader* iconLoader = iIconLoader;

	iIconLoader = NULL; // ownership transferred to caller

	return iconLoader;

	}

// 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 CApaAppInfoReader::ReadL()

	{

	TEntry entry;

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

	iTimeStamp = entry.iModified;

	TUint fileOffset = 0;

	TInt fileLength = 0;

	TUid firstUid(KExecutableImageUid);

	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;

		firstUid = KNullUid;

		middleUid = entry[1];

		if (middleUid == KNullUid)

			User::Leave(KErrCorrupt);

		}

	// 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);	

	CResourceFile* registrationFile = CResourceFile::NewLC(iFs, iRegistrationFileName, fileOffset, fileLength);

	RResourceReader	resourceReader;

	resourceReader.OpenLC(registrationFile, KAppRegistrationInfoResourceId);	

	TRAPD(err, ReadMandatoryInfoL(resourceReader));

	if (err)

		{

		CleanupStack::PopAndDestroy();	// resourceReader

		CleanupStack::PopAndDestroy(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(err, ReadNonLocalisableInfoL(resourceReader, localisableFile, localisableResourceId));

	if (!err)

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

	TBool useDefaultIcons = ETrue;

	if (!err && localisableFile)

		TRAP(err, ReadLocalisableInfoL(*localisableFile, localisableResourceId, useDefaultIcons));

	delete localisableFile;

	localisableFile = NULL;

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

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

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

	const TBool readSuccessful = (err == KErrNone);

	if (useDefaultIcons)

		{

		delete iIcons;

		iIcons = NULL;

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

		}

	CleanupStack::PopAndDestroy();	// resourceReader

	CleanupStack::PopAndDestroy(registrationFile);

	return readSuccessful;

	}

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

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

void CApaAppInfoReader::ReadMandatoryInfoL(RResourceReader& aResourceReader)

	{

	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());

	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));

		}

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

		{

		User::Leave(KErrNotSupported); // legacy dll-style app

		}

	else

		{

		// exe-style app

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

		}

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

	}

HBufC* CApaAppInfoReader::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 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 CApaAppInfoReader::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();

	iNumOfAppIcons = numOfIcons;

	// read LTEXT icon_file

	TPtrC iconFile = resourceReader.ReadTPtrCL();

	ASSERT(!iIconFileName);

	iIconFileName = CreateFullIconFileNameL(iconFile);

	if (iIconFileName)

		{

		TEntry entry;

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

		if (KErrNone == ret)

			iIconFileTimeStamp = entry.iModified;

		aUseDefaultIcons = EFalse;

		if (iFs.IsValidName(*iIconFileName))

			{

			RFile file;

            TInt fileSize( 0 );

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

            CleanupClosePushL( file );

            User::LeaveIfError( file.Size( fileSize ) );

            CleanupStack::PopAndDestroy();//file

            if ( fileSize > 0  )

                {

				if(FileIsMbmWithGenericExtensionL(*iIconFileName))

					{

					if (numOfIcons > 0)

						{

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

						delete iIcons;

						iIcons = iconArray;

						}

					else

						{

						aUseDefaultIcons = ETrue;		

						}

					}

				else

					{

					iNonMbmIconFile = ETrue;

					}

				}

				            //File is of size 0 with Valid filename 

			else

                {

                aUseDefaultIcons = 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();

		viewData->SetNumOfViewIcons(numOfViewIcons);

		// read LTEXT icon_file

		TPtrC viewIconFile = resourceReader.ReadTPtrCL();

		HBufC* const fullViewIconFileName = CreateFullIconFileNameL(viewIconFile);

		if (fullViewIconFileName)

			{

			CleanupStack::PushL(fullViewIconFileName);

			viewIconFile.Set(*fullViewIconFileName);

			viewData->SetIconFileNameL(viewIconFile);

			if (iFs.IsValidName(viewIconFile))

				{

				if(!FileIsMbmWithGenericExtensionL(viewIconFile))

					viewData->SetNonMbmIconFile(ETrue);