/*

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

* SWIS implementation

*

*/

/**

 @file

*/

#include "installserver.h"

#include "installclientserver.h"

#include "installmachine.h"

#include "uninstallmachine.h"

#include "swispubsubdefs.h"

#include "restoremachine.h"

#include "log.h"

#include "packageremover.h"

#include <connect/sbdefs.h>

#include <swi/pkgremover.h>

namespace Swi

{

/**

 * Local function to panic an offending client

 * @internalTechnology

 * @released

 */

static void PanicClient(const RMessagePtr2& aMessage,

	TInstallServerPanic aPanic)

	{

	aMessage.Panic(KInstallServerName, aPanic);

	}

//

// CInstallSession

//

// 2nd phase construction, called by the server framework

void CInstallSession::CreateL()

	{

	Server().AddSession();

#ifdef __WINSCW__

	// For 2 minutes after initial boot, DLLs are not unloaded. If we are doing an

	// install/uninstall/restore, we need to make sure any pending unloadeds are actioned,

	// otherwise a previously loaded DLL could cause the rollback to fail on windows (on

	// arm it is legal to delete a loaded DLL/EXE, whilst on windows it is not).

	RLoader loader;

	TInt r = loader.Connect();

	if(r == KErrNone)

		{

		(void)loader.CancelLazyDllUnload();

		loader.Close();

		}

#endif

	}

CInstallSession::~CInstallSession()

	{

	delete iMachine;

	delete iRestoreMachine;

	delete iRemover;

	Server().ListRemoveInProgress(EFalse);

	RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, ESwisNone);

	Server().DropSession();

	}

CInstallServer& CInstallSession::Server()

	{

	return *static_cast<CInstallServer*>(const_cast<CServer2*>(

		CSession2::Server()));

	}

// Handle a client request. Leaving is handled by ServiceError() which reports 

// the error code to the client

void CInstallSession::ServiceL(const RMessage2& aMessage)

	{

	// Handle the cancel message first

	if (aMessage.Function()==ECancel)

		{

		DEBUG_PRINTF(_L8("CInstallSession::ServiceL() cancel function called"));

		// Set status as aborted

		TInt property;

		if (RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property) == KErrNone)

			{

			RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, property | ESwisStatusAborted);

			}	

		if (iMachine)

			{

			iMachine->CancelInstallation();

			}	

		aMessage.Complete(KErrNone);

		return;

		}

	TInt property = 0;

	TInt err = RProperty::Get(KUidSystemCategory, conn::KUidBackupRestoreKey, property);

	if (err != KErrNone && err != KErrNotFound)

		{

		User::Leave(err);

		}

	if (iMachine != NULL)

		{

		DEBUG_PRINTF2(_L8("Install Server Message %d refused. Install/Uninstall in progress"), aMessage.Function());

		aMessage.Complete(KErrInUse);

		}

	/*

	 * We must return KErrInUse if:

	 * 1) The Connect P&S property indicates we are doing a backup/restore

	 * 2) We are not servicing that restore operation with this request

	 * 3) A list/remove operation is in progress

	 *

	 */

	else if ((iRemover != NULL) || Server().IsListRemoveInProgress())

		{

		// Remove operation in progress

		DEBUG_PRINTF2(_L8("Install Server Message '%d' refused. List/Remove in progress"), aMessage.Function());

		aMessage.Complete(KErrInUse);

		}

	else if (err != KErrNotFound && (property & (conn::KBURPartTypeMask^conn::EBURNormal)) 

				&& aMessage.Function() != ERestore && !iRestoreMachine)

		{

		DEBUG_PRINTF2(_L8("Install Server Message '%d' refused. Backup/Restore in progress"), aMessage.Function());

		aMessage.Complete(KErrInUse);

		}

	else

		{

		switch (aMessage.Function())

			{

			case EInstall:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() install function called"));

				err = RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, ESwisInstall);

				User::LeaveIfError(err);

				iMachine=CInstallMachine::NewL(aMessage);

				User::LeaveIfError(iMachine->Start());

				// The state machine will complete the client once the work 

				// is done.

				break;

				}

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			case EGetComponentInfo:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() get component info function called"));

				iMachine=CInstallMachine::NewL(aMessage, ETrue);

				// Set the install machine to run on comp info collection mode.

				User::LeaveIfError(iMachine->Start());

				// The state machine will complete the client once the work 

				// is done.

				break;

				}			

			#endif

			case EUninstall:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() uninstall function called"));

				err = RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, ESwisUninstall);

				User::LeaveIfError(err);

				iMachine=CUninstallMachine::NewL(aMessage);

				User::LeaveIfError(iMachine->Start());

				// The state machine will complete the client once the work 

				// is done.

				break;

				}

			case ERestore:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() restore function called"));

				err = RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, ESwisRestore);

				User::LeaveIfError(err);

				if (iRestoreMachine && !iRestoreMachine->IsComplete())

					{

					aMessage.Complete(KErrInUse);

					}

				if (iRestoreMachine)

					{

					delete iRestoreMachine;

					iRestoreMachine = NULL;

					}

				iRestoreMachine = CRestoreMachine::NewL(aMessage);

				break;

				}

			case ERestoreFile:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() restore file function called"));

				if (iRestoreMachine == NULL)

					{

					// Should never be reached

					aMessage.Panic(KInstallServerName, KErrNotReady);

					}

				else

					{

					iRestoreMachine->ServiceFileRequestL(aMessage);

					}

				break;

				}

			case ERestoreCommit:

				{

				DEBUG_PRINTF(_L8("CInstallSession::ServiceL() commit function called"));

				if (iRestoreMachine == NULL)

					{

					// Should never be reached

					aMessage.Panic(KInstallServerName, KErrNotReady);

					}

				else

					{

					iRestoreMachine->ServiceCommitRequestL(aMessage);

					}

				break;

				}

			case EListUnInstalledPkgs:

				{

				Server().ListRemoveInProgress(ETrue);

				iRemover = CPackageRemover::NewL(aMessage);

				iRemover->ListL();

				// The state will complete the client once the work 

				// is done.

				break;	

				}

			case ERemoveUnInstalledPkg:

				{

				Server().ListRemoveInProgress(ETrue);

				iRemover = CPackageRemover::NewL(aMessage);

				iRemover->RemoveL();

				// The state will complete the client once the work 

				// is done.

				break;	

				}

			default:

				{

				DEBUG_PRINTF2(_L8("CInstallSession::ServiceL() unknown function called (%d)"), aMessage.Function());

				PanicClient(aMessage, Swi::EPanicInstallServerIllegalFunction);

				break;

				}

			}

		}

	}

// Handle an error from ServiceL(). A bad descriptor error implies a badly 

// programmed client, so panic it. Otherwise use the default handling (report 

// the error to the client).

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

	{

	// set the pubsub flag to aborted status

	TInt property = 0;

	TInt err = RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property);

	if (err == KErrNone)

		{

		RProperty::Set(KUidSystemCategory, KUidSoftwareInstallKey, property | ESwisStatusAborted);

		}

	if (aError==KErrBadDescriptor)

		PanicClient(aMessage, EPanicInstallServerBadDescriptor);

	CSession2::ServiceError(aMessage, aError);

	}

//

// CInstallServerShutdown

//

inline CInstallServerShutdown::CInstallServerShutdown()

:	CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

CInstallServerShutdown::~CInstallServerShutdown()

	{

	Cancel();

	}

inline void CInstallServerShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void CInstallServerShutdown::Start()

	{

	After(KShutdownDelay);

	}

// Initiate server exit when the timer expires

void CInstallServerShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

//

// CInstallServer

//

// All functions require TrustedUI capability

const TInt CInstallServer::iRanges[iRangeCount] = 

                {

                0 // All connect attempts

                };

const TUint8 CInstallServer::iElementsIndex[iRangeCount] = 

                {

                CPolicyServer::ECustomCheck // Custom check polices for TrustedUI or SID from connect.

                };

const CPolicyServer::TPolicy CInstallServer::iPolicy =

                {

                CPolicyServer::ECustomCheck,					// specifies all connect attempts

                iRangeCount,

                iRanges,

                iElementsIndex,

                NULL,

                };

CInstallServer* CInstallServer::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CInstallServer::~CInstallServer()

	{

	DEBUG_PRINTF(_L8("Install Server Shutdown"));

	CSecurityPolicy::ReleaseResource();

	delete iShutdown;

	iShutdown = NULL; //required in case the server dies before the session

	}

// This server does not offer sharable sessions

CInstallServer::CInstallServer()

: 	CPolicyServer(EPriorityMore, iPolicy, EUnsharableSessions),

	iListRemoveInProgress(EFalse)

	{

	}

// Ensure the timer and server objects are running

void CInstallServer::ConstructL()

	{

	DEBUG_PRINTF(_L8("Install Server Created"));

	StartL(KInstallServerName);

	iShutdown = new(ELeave) CInstallServerShutdown;

	iShutdown->ConstructL();

	// Ensure that the server still exits even if the 1st client fails to

	// connect

	iShutdown->Start();

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	// Create the property used to publish SWI Progress Bar Value. Since this property is not needed

	// if the SWI component doesn't exist, it is created here.

	TInt err = RProperty::Define(KUidInstallServerCategory, KUidSwiProgressBarValueKey, RProperty::EInt);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		DEBUG_PRINTF2(_L8("Progress Bar Property couldn't be created. Error=%d."), err);

		User::Leave(err);

		}

#endif	

	}

CPolicyServer::TCustomResult CInstallServer::CustomSecurityCheckL(const RMessage2& aMsg, 

	TInt& /*aAction*/, TSecurityInfo& aMissing)

	{

	_LIT_SECURE_ID(secureBackupClientSID, 0x10202D56);

	if (aMsg.SecureId().iId == secureBackupClientSID.iId)

		{

		return CPolicyServer::EPass;

		}

	else if (aMsg.HasCapability(ECapabilityTrustedUI, 

		__PLATSEC_DIAGNOSTIC_STRING("CInstallServer::CustomSecurityTest client process does not have Trusted UI Capability")))

		{

		// Check additional capability for listing and removing "uninstalled" packages

		if ((aMsg.Function() == EListUnInstalledPkgs) && !aMsg.HasCapability(ECapabilityReadDeviceData, 

			__PLATSEC_DIAGNOSTIC_STRING("CInstallServer::CustomSecurityTest client process does not have ReadDeviceData Capability")))

			{

			aMissing.iCaps.Set(ECapabilityReadDeviceData);

			return CPolicyServer::EFail;

			}

		if ((aMsg.Function() == ERemoveUnInstalledPkg) && !aMsg.HasCapability(ECapabilityWriteDeviceData, 

			__PLATSEC_DIAGNOSTIC_STRING("CInstallServer::CustomSecurityTest client process does not have WriteDeviceData Capability")))

			{

			aMissing.iCaps.Set(ECapabilityWriteDeviceData);

			return CPolicyServer::EFail;

			}

		return CPolicyServer::EPass;

		}

	else

		{

		// Missing connect SID or TrustedUI capability, cannot complete connection

		aMissing.iCaps.Set(ECapabilityTrustedUI);

		return CPolicyServer::EFail;

		}

	}

CSession2* CInstallServer::NewSessionL(const TVersion& aClientVersion, 

	const RMessage2&) const

	{

	// Currently there is only one version of the InstallServer		

	const TVersion serverVersion(KInstallServerVersionMajor,KInstallServerVersionMinor,KInstallServerVersionBuild);  

	// Check that the version of the server requested is not greater than 

	// that available. 	

	if (!User::QueryVersionSupported(serverVersion, aClientVersion))

		{

		User::Leave(KErrNotSupported);

		}

	return new(ELeave) CInstallSession();	

	}

void CInstallServer::AddSession()

	{

	++iSessionCount;

	DEBUG_PRINTF2(_L8("Install Server Session Created (%d sessions active)"), iSessionCount);

	iShutdown->Cancel();

	}

void CInstallServer::DropSession()

	{

	// if last session is dropped and server still alive start shutdown timer

	if (--iSessionCount==0 && iShutdown)

		{

		iShutdown->Start();

		DEBUG_PRINTF(_L8("Install Server Starting Shutdown Timer"));

		}

	DEBUG_PRINTF2(_L8("Install Server Session Destroyed (%d sessions active)"), iSessionCount);

	}

} // namespace Swi