/*

* 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: 

* SISHelper is a layer between a client (EpocInstall, Installer UI, or Control

* Panel applet) that starts [un]installation.

*

*/

#include <s32mem.h>

#include <caf/caf.h>

#include <ecom/ecom.h>

#include <bautils.h>

#include <e32math.h> // for Math::Random()

#include "swi/launcher.h"

#include "sishelper.h"

#include "filesisdataprovider.h"

#include "log.h"

#include "swi/sisparser.h"

#include "swi/siscontents.h"

#include "securitypolicy.h"

#include "cafsisdataprovider.h"

#include "sisregistrypackage.h"

#include "sisregistrysession.h"

#include "sisregistryentry.h"

namespace Swi

{

// RMessagePtr2::Panic() also completes the message. This is 

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed the second time

void PanicClient(const RMessagePtr2& aMessage, TSisHelperPanic aPanic)

	{

	aMessage.Panic(KSisHelperServerName, aPanic);

	}

//

// Swi::CSisHelperShutdown helper class implementation

//

inline CSisHelperShutdown::CSisHelperShutdown() : CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

CSisHelperShutdown::~CSisHelperShutdown()

	{

	Deque();

	}

inline void CSisHelperShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void CSisHelperShutdown::Start()

	{

	After(KShutdownDelay);

	}

// Initiate server exit when the timer expires

void CSisHelperShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

//

// CSisHelperSession

//

inline CSisHelperSession::CSisHelperSession(MSisDataProvider& aDataProvider)

:	iDataProvider(aDataProvider)

	{

	}

inline CSisHelperServer& CSisHelperSession::Server()

	{

	return *static_cast<CSisHelperServer*>(

		const_cast<CServer2*>(CSession2::Server()));

	}

inline TBool CSisHelperSession::ReceivePending() const

	{

	return !iReceiveMsg.IsNull();

	}

// Second phase constructor, called by CServer2 framework

void CSisHelperSession::CreateL()

	{

	Server().AddSession();

	}

CSisHelperSession::~CSisHelperSession()

	{

	delete iCurrentContents;

	// Ignore any leave codes from CleanupAsyncExtractionL -

	// they can't really be handled from the destructor.

	TRAP_IGNORE(CleanupAsyncExtractionL());

	Server().DropSession();

	CSecurityPolicy::ReleaseResource();

	}

// Handle a client request. Leaving is handled by 

// CSisHelperServer::ServiceError() which reports the error code to the client

void CSisHelperSession::ServiceL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF2(_L8("Sis Helper - Servicing Message Type %d."), aMessage.Function());

	TInt err = KErrNone;

	switch (aMessage.Function())

		{

		case ESisHelperGetController:

			{

			TRAP(err, GetControllerL(aMessage));

			if (err != KErrNone)

				{

				// Map unexpected KErrOverflow errors to KErrCorrupt; otherwise,

				// sishelperclient will interpret this as a signal to resize the request

				// buffer

				aMessage.Complete((err == KErrOverflow ? KErrCorrupt : err));

				}

			break;

			}

		case ESisHelperExtractFile:

			{

			TRAP(err, ExtractFileL(aMessage));

			aMessage.Complete(err);

			break;

			}

		case ESisHelperFillDrivesAndSpaces:

			{

			// calculate the likely size of the data transfer buffer

			const TInt KMaxBufSize=

				sizeof(TInt)+                 // number of entries

				KMaxDrives*sizeof(TUint)+  // drive letters stored as TUints

				KMaxDrives*sizeof(TInt64); // drive free spaces

			// allocate buffer for the returned arrays

			HBufC8* buf=HBufC8::NewMaxLC(KMaxBufSize);

			// create stream on the buffer

			TPtr8 des=buf->Des();

			RDesWriteStream outs(des);

			CleanupClosePushL(outs);

			// get drive letter and free space information

			RArray<TChar> driveLetters;

			CleanupClosePushL(driveLetters);

			RArray<TInt64> driveSpaces;

			CleanupClosePushL(driveSpaces);

			FillDrivesAndSpacesL(driveLetters, driveSpaces);

			// externalise the arrays

			TInt count=driveLetters.Count();

			outs.WriteInt32L(count);

			TInt i;

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

				{

				outs.WriteInt32L(static_cast<TUint>(driveLetters[i]));

				}

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

				{

				outs.WriteInt32L(I64LOW(driveSpaces[i]));

				outs.WriteInt32L(I64HIGH(driveSpaces[i]));

				}

			// write the buffer to the passed buffer

			outs.CommitL();

			aMessage.WriteL(0, *buf);

			// cleanup

			// driveSpaces, driveLetters, outs, buf

			CleanupStack::PopAndDestroy(4, buf);

			aMessage.Complete(KErrNone);

			break;

			}

		case ESisHelperOpenDrmContent:

			{

			ContentAccess::TIntent intent

				= static_cast<ContentAccess::TIntent>(aMessage.Int0());

			TRAPD(err, iDataProvider.OpenDrmContentL(intent));

			aMessage.Complete(err);

			break;

			}

		case ESisHelperExecuteDrmIntent:

			{

			ContentAccess::TIntent intent

				= static_cast<ContentAccess::TIntent>(aMessage.Int0());

			aMessage.Complete(iDataProvider.ExecuteDrmIntent(intent));

			break;

			}

		case ESisHelperSetupAsyncExtraction:

			SetupAsyncExtractionL(aMessage);

			break;

		case ESisHelperAsyncExtraction:

			AsyncExtractionL(aMessage);

			break;

		case ESisHelperEndAsyncExtraction:

			EndAsyncExtractionL(aMessage);

			break;

		case ESisHelperCreateSisStub:

			{

			// write stub

			TRAPD(err, CreateSisStubL(aMessage));

			// cleanup

			aMessage.Complete(err);

			break;

			}

		case ESisHelperIsStub:

			{	

			TRAPD(err,IsStubL(aMessage));

			aMessage.Complete(err);

			break;

			}

		case ESisHelperGetSisFileDrive:

			{

			TRAPD(err,GetSisFileDriveL(aMessage));	

			aMessage.Complete(err);

			break;

			}

		case ESisHelperIsSisFileReadOnly:

			{

			TRAPD(err,IsSisFileReadOnlyL(aMessage));	

			aMessage.Complete(err);

			break;

			}

		case ESisHelperGetSisFileName:

			{

			TRAP(err, GetSisFileNameL(aMessage));

			aMessage.Complete(err);

			break;

			}			

		case ESisHelperGetControllerFromSis:

			{

			TRAP(err, GetControllerFromSisL(aMessage));

			aMessage.Complete(err);

			break;

			}

		#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		case ESisHelperIsDrmProtected:

			{

			TRAP(err, IsDrmProtectedL(aMessage));

			aMessage.Complete(err);

			break;

			}

		#endif

		case ESisHelperGetEquivalentLanguages:

			{

			TRAP(err, GetEquivalentLanguagesL(aMessage));

			aMessage.Complete(err);

			break;

			}	

		default:

			{

			DEBUG_PRINTF(_L8("Sis Helper - Illegal Message Type."));

			PanicClient(aMessage, EPanicIllegalFunction);

			break;

			}

		}

	}

void CSisHelperSession::GetControllerL(const RMessage2& aMessage)

	{

	// Extract raw controller data into a buffer

	HBufC8* controllerData = CurrentContentsL().ReadControllerL();

	CleanupStack::PushL(controllerData);

	// Get the data to the client using the standard overflow protocol

	// - get the size of the supplied descriptor (parameter 0)

	TInt size=aMessage.GetDesMaxLengthL(0);

	// - see if we have enough space on the client

	if (size < controllerData->Size())

		{

		// not enough space, complete with KErrOverflow and encode the

		// required size into the passed descriptor

		TPckgC<TInt> sizePckg(controllerData->Size());

		// is there enough space for an integer?

		if (size >= sizePckg.Size())

			{

			aMessage.WriteL(0, sizePckg);

			}

		// complete the message with KErrOverflow when resizing requires

		aMessage.Complete(KErrOverflow);

		}

	else

		{

		// enough space, write the controller to the supplied buffer

		aMessage.WriteL(0, *controllerData);

		//Everything went fine so complete the message with KErrNone.

		aMessage.Complete(KErrNone);

		}

	CleanupStack::PopAndDestroy(controllerData); // controllerData				

	}

void CSisHelperSession::ExtractFileL(const RMessage2& aMessage)

	{

	RFile file;

	file.AdoptFromClient(aMessage, 0, 1);			

	CleanupClosePushL(file);

	TInt fileIndex = aMessage.Int2();

	TInt dataUnit = aMessage.Int3();

	CurrentContentsL().ReadDataL(file, fileIndex, dataUnit);

	User::LeaveIfError(file.Flush());

	CleanupStack::PopAndDestroy(&file); // file

	}

void CSisHelperSession::IsStubL(const RMessage2& aMessage)

	{

	TBool stub = CurrentContentsL().IsStub();	

	TPckg<TBool> stubPckg(stub);

	aMessage.WriteL(0, stubPckg);

	}

void CSisHelperSession::GetSisFileDriveL(const RMessage2& aMessage)

	{

	TChar drive;

	User::LeaveIfError(RFs::DriveToChar(Server().GetSisFileDrive(), drive));

	TPckg<TChar> drivePckg(drive);

	aMessage.WriteL(0, drivePckg);

	}

void CSisHelperSession::IsSisFileReadOnlyL(const RMessage2& aMessage)

	{

	TBool readOnly = Server().IsSisFileReadOnly();

	TPckg<TBool> readOnlyPckg(readOnly);

	aMessage.WriteL(0, readOnlyPckg);

	}

void CSisHelperSession::GetSisFileNameL(const RMessage2& aMessage)

	{

	TInt clientDesLength = aMessage.GetDesMaxLengthL(0);

	TPtrC filename = Server().GetSisFileNameL();

	if (clientDesLength < filename.Length())

		{

		User::Leave(KErrOverflow);

		}

	if (filename.Length() == 0)

		{

		User::Leave(KErrNotFound);

		}

	aMessage.WriteL(0, filename);

	}

void CSisHelperSession::GetControllerFromSisL(const RMessage2& aMessage)

	{

	// Get the file handle

	RFile file;

	// Adopt the file using the RFs handle from message slot 1 and the RFile handle from slot 2

	User::LeaveIfError(file.AdoptFromClient(aMessage, 1, 2));          

	CleanupClosePushL(file);

	// Create a file data provider

	MSisDataProvider* dataProvider = NULL;

	CSecurityPolicy* securityPolicy = CSecurityPolicy::GetSecurityPolicyL();

	TBool drmEnabled = securityPolicy->DrmEnabled();

	securityPolicy->ReleaseResource();

	if (drmEnabled)

		{

		dataProvider = CCafSisDataProvider::NewLC(file);

		dataProvider->OpenDrmContentL(ContentAccess::EInstall);

		User::LeaveIfError(dataProvider->ExecuteDrmIntent(ContentAccess::EUnknown));

		}

	else

		{

		dataProvider = CFileSisDataProvider::NewLC(file);

		}

	// Extract raw controller data into a buffer

	TInt64 pos(0);

	User::LeaveIfError(dataProvider->Seek(ESeekStart, pos));

	Sis::CContents *contents = Sis::Parser::ContentsL(*dataProvider);

	CleanupStack::PushL(contents);

	HBufC8* controllerData = NULL;

	TRAPD(err, controllerData = contents->ReadControllerL());

	if(err == KErrOverflow)

   		{

   		User::Leave(KErrCorrupt);			

   		}

	User::LeaveIfError(err);

	CleanupStack::PushL(controllerData);

	// Get the data to the client using the standard overflow protocol

	// - get the size of the supplied descriptor (parameter 0)

	TInt size = aMessage.GetDesMaxLengthL(0);

	// - see if we have enough space on the client

	if (size < controllerData->Size())

		{

		// Not enough space, complete with KErrOverflow and encode the

		// required size into the passed descriptor

		TPckgC<TInt> sizePckg(controllerData->Size());

		// Is there enough space for an integer?

		if (size >= sizePckg.Size())

			{

			aMessage.WriteL(0, sizePckg);

			}

		// complete the message with KErrOverflow when resizing requires

		User::Leave(KErrOverflow);

		}

	else

		{

		// Enough space, write the controller to the supplied buffer

		aMessage.WriteL(0, *controllerData);

		}

	CleanupStack::PopAndDestroy(4, &file); // dataProvider, contents, controllerData

	}

	// Functions for asynchronous extraction

void CSisHelperSession::SetupAsyncExtractionL(const RMessage2& aMessage)

	{

	// We only support extracting one file at once currently

	if (iInAsyncExtraction)

		{

		aMessage.Complete(KErrInUse);

		}

	else

		{

		// Get file and session handles

		User::LeaveIfError(iAsyncFs.Open(aMessage, 0));

		// Adopt the filehandle;

		User::LeaveIfError(iAsyncFile.Adopt(iAsyncFs, aMessage.Int1()));

		iAsyncFileIndex=aMessage.Int2();

		iAsyncDataUnit=aMessage.Int3();

		iInAsyncExtraction=ETrue;

		aMessage.Complete(KErrNone);

		}

	}

void CSisHelperSession::AsyncExtractionL(const RMessage2& aMessage)

	{

	TInt lengthHigh=aMessage.Int0();

	TInt lengthLow=aMessage.Int1();

	TInt64 length= lengthHigh;

	length=( length << 32) + lengthLow;

	CurrentContentsL().ReadDataL(iAsyncFile, iAsyncFileIndex, iAsyncDataUnit, length);

	TInt err = iAsyncFile.Flush();

	aMessage.Complete(err);

	}

void CSisHelperSession::EndAsyncExtractionL(const RMessage2& aMessage)

	{

	if (!iInAsyncExtraction)

		{

		aMessage.Complete(KErrArgument);

		}

	else

		{

		CleanupAsyncExtractionL();

		aMessage.Complete(KErrNone);

		}

	}

void CSisHelperSession::CleanupAsyncExtractionL()

	{

	if (iInAsyncExtraction)

		{

		iAsyncFile.Close();

		iAsyncFs.Close();

		iInAsyncExtraction=EFalse;

		}

	}

// Handle an error from CSisHelperSession::ServiceL(). A bad descriptor 

// error implies a badly programmed client, so panic it; otherwise use the

// default handling (report error to the client)

void CSisHelperSession::ServiceError(const RMessage2& aMessage, TInt aError)

	{

	if (aError==KErrBadDescriptor)

		{

		PanicClient(aMessage, EPanicBadDescriptor);

		}

	CSession2::ServiceError(aMessage, aError);

	}

void CSisHelperSession::FillDrivesAndSpacesL(RArray<TChar>& aDriveLetters, 

					                        RArray<TInt64>& aDriveSpaces)

	{

	// This is the LFSS free space threshold

	TInt freeSpaceAdjustment = 1024 * 128;    // Bytes	

    // get information about drives

    TDriveList driveList;

    RFs fs;

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

    CleanupClosePushL(fs);

    // List all drives in the system

    User::LeaveIfError(fs.DriveList(driveList));

	// Check all drives