/*

* Copyright (c) 2007-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 "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: 

*

*/

#include <s32file.h>

#include "pkgremovererrors.h"

#include "siscontroller.h"

#include "sisinstallblock.h"

#include "sisinfo.h"

#include "sisstring.h"

#include "packageremover.h"

#include "sisuid.h"

#include "sisversion.h"

#include "sisfieldtypes.h"

#include "cleanuputils.h"

#include "securitycheckutil.h"

#include "secutils.h"

#include "log.h"

#include "sissupportedlanguages.h"

#include <hash.h>

using namespace Swi;

using namespace Swi::Sis;

// SIS registry main path

_LIT(KRegistryPath, "\\sys\\install\\sisregistry\\");

// SWI daemon private directory

_LIT(KSwiDaemonPrivateDirectory, "\\private\\10202dce\\");

// Controller and SIS file extensions

_LIT(KControllerFileExt, ".ctl");

_LIT(KSisFileExt, ".sis");

_LIT(KSisXFileExt, ".sisx");

// Maximum embedding depth allowed in SIS files

const TInt KMaximumEmbeddingDepth = 8;

// Length of UIDs in hex

const TInt KUidHexLength = 8;

//

// Implementation of class CUninstalledPkgEntry

//

CUninstalledPkgEntry* CUninstalledPkgEntry::NewLC(const TUid& aUid, const TDesC& aPackageName,

	const TDesC& aVendorName, const TVersion& aVersion, const TPackageType aPackageType,

	const TDesC& aSisCtlFileName, const TDesC& aAssociatedStubSisName, const TDesC8& aControllerHash)

 	{

 	CUninstalledPkgEntry* self = new(ELeave) CUninstalledPkgEntry();

 	CleanupStack::PushL(self);

 	self->ConstructL(aUid, aPackageName, aVendorName, aVersion, aPackageType,

 					aSisCtlFileName, aAssociatedStubSisName, aControllerHash);

 	return self;

 	}

CUninstalledPkgEntry::CUninstalledPkgEntry()

	{

	}

CUninstalledPkgEntry::~CUninstalledPkgEntry()

	{

	delete iVendorName;

	delete iPackageName;

	delete iSisCtlFileName;

	delete iAssociatedStubSisName;

	delete iHashController;

	}

// Constructs the objects using the property values

void CUninstalledPkgEntry::ConstructL(const TUid& aUid, const TDesC& aPackageName,

	const TDesC& aVendorName, const TVersion& aVersion, const TPackageType aPackageType,

	const TDesC& aSisCtlFileName, const TDesC& aAssociatedStubSisName, const TDesC8& aControllerHash)

	{

	iUid = aUid;

	iPackageName = aPackageName.AllocL();

	iVendorName = aVendorName.AllocL();

	iVersion = aVersion;

	iPackageType = aPackageType;

	iSisCtlFileName = aSisCtlFileName.AllocL();

	iAssociatedStubSisName = aAssociatedStubSisName.AllocL();	

	iHashController = aControllerHash.AllocL();

	}

void CUninstalledPkgEntry::SetAssociatedStubSisNameL(const TDesC& aAssociatedStubSisName)

	{

	delete iAssociatedStubSisName;

	iAssociatedStubSisName = NULL;

	iAssociatedStubSisName = aAssociatedStubSisName.AllocL();

	}

//

// Implementation of class CPackageRemover

//

CPackageRemover* CPackageRemover::NewLC(const RMessage2& aMessage)

	{

	CPackageRemover* self=new(ELeave) CPackageRemover(aMessage);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CPackageRemover* CPackageRemover::NewL(const RMessage2& aMessage)

	{

	CPackageRemover* self=NewLC(aMessage);

	CleanupStack::Pop(self);

	return self;

	}

// Constructor

CPackageRemover::CPackageRemover(const RMessage2& aMessage) :

	iMessage(aMessage)

	{

	}

void CPackageRemover::ConstructL()

	{

	DEBUG_PRINTF(_L8("Constructing CPackageRemover"));

	// connect to SIS helper 

	User::LeaveIfError(iSisHelper.Connect());

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFs.ShareProtected());

	// connect to SIS registry

	User::LeaveIfError(iSisRegistry.Connect());

	}

// Delete objects, close connection to the servers

CPackageRemover::~CPackageRemover()

	{	

	iFs.Close();

	iSisHelper.Close(); 

	iSisRegistry.Close();

	iUninstalledPkgEntry.ResetAndDestroy();

	iFileList.ResetAndDestroy();

	iControllerList.ResetAndDestroy();

	delete iMainController;

	delete iControllerData;

	}

// Logic for finding uninstalled packages:

// FIRST : Controller file path processed and added the entries into the array

// SECOND: Stub sis path processed and verified with already added enties, if

// not-added, then add this as new entry. 

// There are following possibilities:

// 1. Autopropagation enabled then both sis file and ctl file will exist - (ctl added and sis won't added)

// In this case ctl files added into array and also the sis file path is 

// referened from the same array entry.

// 2. Autopropagation disabled then only ctl file exist - ctl added.

// 3. For PA and PP type, only stub sis file exist - sis file added

void CPackageRemover::ListL()

	{

	TInt driveNumber = iMessage.Int0();

	TDriveInfo info;

	User::LeaveIfError(iFs.Drive(info, driveNumber));

	if (!(info.iDriveAtt & KDriveAttRemovable) || (info.iDriveAtt & KDriveAttSubsted))

		{

		User::Leave(KErrNotRemovable);

		}

	TPath stubSisPath;

	TPath ControllerFilePath;

	TChar drive;

	CDir* dir = NULL;

	User::LeaveIfError(RFs::DriveToChar(driveNumber, drive));

	// Construct the Controller file path

	ControllerFilePath.Append(drive);

	ControllerFilePath.Append(KDriveDelimiter);

	ControllerFilePath.Append(KRegistryPath);

	// Get the list of controller file

	// List the directory contents including directories

	TInt err = KErrNone;

	err = iFs.GetDir(ControllerFilePath, KEntryAttDir, ESortByName, dir);

	if (err == KErrNone)

		{

		CleanupStack::PushL(dir);

		TInt count(dir->Count());

		for (TInt i = 0; i < count; ++i)

			{

			const TDesC& directoryName = (*dir)[i].iName;

			// we expect uid directories to be 8 characters long, ignore others

			if (directoryName.Length() != KUidHexLength)

				{

				continue;

				}

			else if (!((*dir)[i].IsDir()))

				{

				continue;

				}

			else

				{

				TPath ctlPath;

				CDir* ctlFileList = NULL;

				ctlPath.Append(ControllerFilePath);

				ctlPath.Append((*dir)[i].iName);

				ctlPath.Append(KPathDelimiter);

				// List the directory contents, excluding directories, system and hidden files.

				// i.e. just normal files

				err = iFs.GetDir(ctlPath, KEntryAttMatchExclude | KEntryAttDir, ESortByName, ctlFileList);

				if (err == KErrNone)

					{

					CleanupStack::PushL(ctlFileList);

					// Add the un-installed controller file into an array

					AddIfUninstalledL(*ctlFileList, ctlPath);

					CleanupStack::PopAndDestroy(ctlFileList);

					}

				}

			}

		CleanupStack::PopAndDestroy(dir); 

		}

	if (err == KErrNone || err == KErrNotFound || err == KErrPathNotFound)

		{

		// Construct the Stub sis file path

		stubSisPath.Append(drive);

		stubSisPath.Append(KDriveDelimiter);

		stubSisPath.Append(KSwiDaemonPrivateDirectory);

		// Get the list of stub sis file 

		CDir* stubFileList = NULL;

		// List the directory contents, excluding directories, system and hidden files.

		// i.e. just normal files

		err = iFs.GetDir(stubSisPath, KEntryAttMatchExclude | KEntryAttDir, ESortByName, stubFileList);

		if (err == KErrNone)

			{

			CleanupStack::PushL(stubFileList);

			// Add the un-installed stub sis file into an array

			AddIfUninstalledL(*stubFileList, stubSisPath);

			CleanupStack::PopAndDestroy(stubFileList);

			}

		}

	if (err == KErrNone || err == KErrNotFound || err == KErrPathNotFound)

		{

		// write the array entries into the buffer

		HBufC8* buffer = WriteListToBufferLC();

		TPtr8 pBuffer = buffer->Des();

		if (iMessage.GetDesMaxLengthL(1) < pBuffer.Length())

			{

			TInt bufferSize = pBuffer.Size();

			TPckgC<TInt> bufferSizePackage(bufferSize);

			iMessage.WriteL(1, bufferSizePackage);

			err = KErrOverflow;

			}

		else

			{

			iMessage.WriteL(1, pBuffer);

			err = KErrNone;

			}

		CleanupStack::PopAndDestroy(buffer); //buffer

		}

	iMessage.Complete(err);

	}

void CPackageRemover::AddIfUninstalledL(const CDir& aDirName, const TDesC& aPathName)

	{

	TInt fileCount = aDirName.Count();

	if(fileCount)

		{

		for(TInt i = 0; i < fileCount; i++)

			{

			const TEntry &entry = (aDirName)[i];

			HBufC* fileName = HBufC::NewLC(aPathName.Length() + entry.iName.Length());

			TPtr localFilename = fileName->Des();

			localFilename.Copy(aPathName);

			localFilename.Append(entry.iName);

 			// Sanity check the filename

 			TParsePtrC fileParser(*fileName);

			TBool isControllerFile = (fileParser.Ext().CompareF(KControllerFileExt)) ? EFalse : ETrue;

			TBool isSisFile = EFalse;

			if ((fileParser.Ext().CompareF(KSisFileExt)) ||

				(fileParser.Ext().CompareF(KSisXFileExt)))

				{

				isSisFile = ETrue;

				}

			if (!isSisFile && !isControllerFile)

				{

				// ctl and sis file only processed other files skipped

				CleanupStack::PopAndDestroy(fileName);

 				continue;

				}

			// Get hold of the controller

			HBufC8* bufController = NULL;

			TInt err = KErrNone;

			if (isControllerFile)

   				{

				// Get the controller data from the file

				TRAP(err, bufController = GetControllerFromControllerFileLC(*fileName);

							CleanupStack::Pop(bufController));

   				}

   			else 

   				{

   				// Get controller data from sishelper (may need to deflate controller)

				TRAP(err, bufController = iSisHelper.GetControllerFromSisFileLC(*fileName);

							CleanupStack::Pop(bufController));

   				}

			if (err != KErrNone)

				{

				CleanupStack::PopAndDestroy(fileName);

 				continue;

				}

			CleanupStack::PushL(bufController);

			// Ensure the application is not installed

			// Discard the 4 byte type field for consistency with

			// all other registry entries

			TPtrC8 typeController(bufController->Mid(4));

			if (iSisRegistry.IsInstalledL(typeController))

				{

				CleanupStack::PopAndDestroy(2, fileName); //fileName, bufcontroller

				continue;

				}

			HBufC8* hashController = ComputeHashL(typeController);

			CleanupStack::PushL(hashController);

			TPtrC8 hashControllerPtr(hashController->Des());

			if (IsAlreadyAddedL(hashControllerPtr, *fileName))

				{

				CleanupStack::PopAndDestroy(3, fileName); //fileName, bufcontroller, hashController

				continue;

				}

			// Create controller

			TPtrProvider provider(bufController->Des());

			CController* currentController = NULL;

			TRAP(err, currentController = CController::NewL(provider));

			if (err != KErrNone)

				{

				CleanupStack::PopAndDestroy(3, fileName); // filename , bufController, hashController

 				continue;

				}

			CleanupStack::PushL(currentController);

			TUid pkgUid = currentController->Info().Uid().Uid();

			if (isControllerFile)

   				{

   				// Determine the uid from the directory name

	   			TLex lex(aPathName.Right(9).Left(8));

   				TUint uidValue;

   				User::LeaveIfError(lex.Val(uidValue, EHex));

   				TUid uuid = TUid::Uid(uidValue);

				if (uuid != pkgUid)

					{

					// shouldn't add this entry as it may be malware

					// where ctl file is placed under  a uid different from the controller'S UID

					CleanupStack::PopAndDestroy(4, fileName); //fileName, bufcontroller, hashController, currentController

					continue;

					}

   				}

			Sis::TInstallType installType = currentController->Info().InstallType();

			CUninstalledPkgEntry::TPackageType pkgType = CUninstalledPkgEntry::ESaPackage; // to suppress warning

			switch(installType)

				{

				case EInstInstallation:

					pkgType = CUninstalledPkgEntry::ESaPackage;

					break;

				case EInstAugmentation:

					pkgType = CUninstalledPkgEntry::ESpPackage;

					break;

				case EInstPartialUpgrade:

					pkgType = CUninstalledPkgEntry::EPuPackage;

					break;

				case EInstPreInstalledApp:

					pkgType = CUninstalledPkgEntry::EPaPackage;

					break;

				case EInstPreInstalledPatch:

					pkgType = CUninstalledPkgEntry::EPpPackage;

					break;

				default:

					// shouldn't come here

					User::Leave(KErrNotSupported);							

				}

			// Localise dependency name

			TLanguage systemLanguage = User::Language();    // Language of the current locale

    		// Check whether the current locale is in the list of languages in the SIS file

    		const CSupportedLanguages& languages = currentController->SupportedLanguages();

			TInt langIndex = 0;

			for (TInt i = 0; i < languages.Count(); i++)

				{

				if (systemLanguage == languages[i])

					{

					langIndex = i;

					break;

					}

				}

			HBufC* pkgName = currentController->Info().Names()[langIndex]->Data().AllocLC();

			HBufC* pkgVendor = currentController->Info().VendorNames()[langIndex]->Data().AllocLC();

			TInt major = currentController->Info().Version().Major();

			TInt minor = currentController->Info().Version().Minor();

			TInt build = currentController->Info().Version().Build();

			TVersion pkgVersion(major,minor,build);

			HBufC* associateStubFile = KNullDesC().AllocLC(); // later this will be set

			CUninstalledPkgEntry* PkgEntry = CUninstalledPkgEntry::NewLC(pkgUid, *pkgName,

					*pkgVendor, pkgVersion, pkgType, *fileName, *associateStubFile, *hashController);

			iUninstalledPkgEntry.AppendL(PkgEntry); // ownership is transfered to array.

			CleanupStack::Pop(PkgEntry); 			// PkgEntry

			// associateStubFile, pkgVendor, pkgName ,currentController, bufController, hashController and fileName

			CleanupStack::PopAndDestroy(7, fileName); 	

			}

		}

	}

HBufC8* CPackageRemover::ComputeHashL(TDesC8& aController)

	{

	// calculate the controller hash

	CMessageDigest* digest = CMessageDigestFactory::NewDigestLC(CMessageDigest::ESHA1);

	digest->Update(aController);

	TPtrC8 hash = digest->Final();	

	HBufC8* hashBuffer = hash.AllocL();

	CleanupStack::PopAndDestroy(digest);

	return hashBuffer;

	}

TBool CPackageRemover::IsAlreadyAddedL(TDesC8& aHashController, const TDesC& aFileName)

	{

	// Ensure this entry is not already added into the array using ctl files.

	// check with existing RArray<TUninstalledAppEntry> which contains 

	// a list of uninstalled entries.

	TInt count = iUninstalledPkgEntry.Count();

	TBool same = EFalse;

	for (TInt j = 0; j < count; ++j)

		{

		const TDesC8& existingHash = iUninstalledPkgEntry[j]->HashController();

		if (aHashController.CompareF(existingHash) == 0)

			{

			TBool isSisFile = EFalse;

			if ( (aFileName.Right(4).CompareF(KSisFileExt)) || 

				 (aFileName.Right(4).CompareF(KSisXFileExt)))

				{

				isSisFile = ETrue;

				}

			if (!isSisFile)

				{

				// already a ctl file added in the array

				// it may happen as copy - paste the ctl file with different name

				// e.g copy 00000000_0000.ctl  and paste it as 00000000_1000.ctl or abc.ctl....

				same = ETrue;

				break;

				}

			if (iUninstalledPkgEntry[j]->AssociatedStubSisName() == KNullDesC)

				{

				iUninstalledPkgEntry[j]->SetAssociatedStubSisNameL(aFileName); 

				}

			same = ETrue;

			break;

			}

		}

	return same;

	}

HBufC8* CPackageRemover::WriteListToBufferLC()

	{

	TInt fileCount = iUninstalledPkgEntry.Count();

	TInt length = (fileCount + 1) * sizeof (CUninstalledPkgEntry);

	// Write the object out to a buffer, send to client

	CBufSeg* buf = CBufSeg::NewL(length);

	CleanupStack::PushL(buf);

	// create write stream

	RBufWriteStream writeStream(*buf);

	CleanupClosePushL(writeStream);

	// write the files to the stream

	writeStream.WriteInt32L(fileCount);

	for(TInt i = 0; i < fileCount; i++)

		{

		writeStream.WriteInt32L(iUninstalledPkgEntry[i]->Uid().iUid);

		const TDesC& pkgName = iUninstalledPkgEntry[i]->PackageName();

		writeStream.WriteInt32L(pkgName.Length());

		writeStream.WriteL(pkgName);

		const TDesC& vendorName = iUninstalledPkgEntry[i]->VendorName();

		writeStream.WriteInt32L(vendorName.Length());

		writeStream.WriteL(vendorName);

		writeStream.WriteInt32L(iUninstalledPkgEntry[i]->Version().iMajor);

		writeStream.WriteInt32L(iUninstalledPkgEntry[i]->Version().iMinor);

		writeStream.WriteInt32L(iUninstalledPkgEntry[i]->Version().iBuild);

		writeStream.WriteInt32L(iUninstalledPkgEntry[i]->PackageType());	

		const TDesC& sisCtlFileName = iUninstalledPkgEntry[i]->SisCtlFileName();

		writeStream.WriteInt32L(sisCtlFileName.Length());

		writeStream.WriteL(sisCtlFileName);

		const TDesC& assocatedStubName = iUninstalledPkgEntry[i]->AssociatedStubSisName();

		writeStream.WriteInt32L(assocatedStubName.Length());

		writeStream.WriteL(assocatedStubName);

		}

	HBufC8* buffer = HBufC8::NewLC(buf->Size());

	TPtr8 ptr(buffer->Des());

	buf->Read(0, ptr, buf->Size());

	CleanupStack::Pop(buffer);

	CleanupStack::PopAndDestroy(2, buf); // writeStream , buf