/*

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

* sisregistry - client registry entry interface implementation

*

*/

/**

 @file 

 @publishedPartner

 @released

*/

#include<s32mem.h>

#include <hash.h>

#include <swi/sistruststatus.h>

#include <x509cert.h>

#include "sisregistrydependency.h"

#include "sisregistryentry.h"

#include "sisregistrysession.h"

#include "sisregistryclientserver.h"

#include "sisregistrypackage.h"

#include "sisregistryobject.h"

#include "hashcontainer.h"

#include "arrayutils.h"

#include "cleanuputils.h"

using namespace Swi;

const TInt KMinBufferSize = 20;

EXPORT_C TInt RSisRegistryEntry::Open(RSisRegistrySession& aSession, TUid aUid)

	{

	TPckgC<TUid> uid(aUid);

	return CreateSubSession(aSession, EOpenRegistryUid, TIpcArgs(&uid));

	}

EXPORT_C TInt RSisRegistryEntry::OpenL(RSisRegistrySession& aSession,

										const CSisRegistryPackage& aPackage)

	{	

	// dynamic buffer since we don't know in advance the size required

    CBufFlat* tempBuffer = CBufFlat::NewL(KDefaultBufferSize);

	CleanupStack::PushL(tempBuffer);

	RBufWriteStream stream(*tempBuffer);

	CleanupClosePushL(stream);

	aPackage.ExternalizeL(stream);

	stream.CommitL();

	// Now, create an HBufC8 from the stream buf's length, and copy 

	// the stream buffer into this descriptor

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

	TPtr8 ptr(buffer->Des());

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

	TInt err = CreateSubSession(aSession, EOpenRegistryPackage, TIpcArgs(&ptr));

	User::LeaveIfError(err);

	CleanupStack::PopAndDestroy(3, tempBuffer); // tempBuffer, stream, buffer

	return err;

	}

EXPORT_C TInt RSisRegistryEntry::Open(RSisRegistrySession &aSession, const TDesC& aPackageName, const TDesC& aVendorName)

	{

	return CreateSubSession(aSession, EOpenRegistryNames, TIpcArgs(&aPackageName, &aVendorName));

	}	

EXPORT_C void RSisRegistryEntry::Close()

	{

	CloseSubSession(ECloseRegistryEntry);

	}

EXPORT_C TBool RSisRegistryEntry::IsPresentL()

	{

	TBool isPresent = EFalse ;

	TPckg<TBool> isPresentPkg(isPresent);

	User::LeaveIfError(SendReceive(EUidPresent, TIpcArgs(&isPresentPkg)));

	return isPresent;

	}

EXPORT_C TBool RSisRegistryEntry::IsSignedL()

	{

	TBool isSigned = EFalse;

	TPckg<TBool> isSignedPkg(isSigned);

	User::LeaveIfError(SendReceive(ESigned, TIpcArgs(&isSignedPkg)));

	return isSigned;

	}

EXPORT_C TSisPackageTrust RSisRegistryEntry::TrustL() const

	{

	TSisPackageTrust trust;

	TPckg<TSisPackageTrust> trustPkg(trust);

	User::LeaveIfError(SendReceive(EGetTrust, TIpcArgs(&trustPkg)));

	return trust;

	}

EXPORT_C TTime RSisRegistryEntry::TrustTimeStampL() const

	{

	TTime trustTimeStamp;

	TPckg<TTime> timePkg(trustTimeStamp);

	User::LeaveIfError(SendReceive(ETrustTimeStamp, TIpcArgs(&timePkg)));

	return trustTimeStamp;

	}

EXPORT_C TSisTrustStatus RSisRegistryEntry::TrustStatusL() 

    {

    HBufC8* buffer = SendReceiveBufferLC((TInt)ETrustStatus);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble from the stream

	TSisTrustStatus trustStatus;

	trustStatus.InternalizeL(stream);

	CleanupStack::PopAndDestroy(2, buffer); // buffer, stream

    return trustStatus;

    } 

EXPORT_C TBool RSisRegistryEntry::IsInRomL()

	{

	TBool isInRom = EFalse;

	TPckg<TBool> isInRomPkg(isInRom);

	User::LeaveIfError(SendReceive(EInRom, TIpcArgs(&isInRomPkg)));

	return isInRom;

	}

EXPORT_C TBool RSisRegistryEntry::IsAugmentationL()

	{

	TBool isAugmentation = EFalse;

	TPckg<TBool> isAugmentationPkg(isAugmentation);

	User::LeaveIfError(SendReceive(EAugmentation, TIpcArgs(&isAugmentationPkg)));

	return isAugmentation;

	}

EXPORT_C TVersion RSisRegistryEntry::VersionL()

	{

	TVersion version;

	TPckg<TVersion> packageVersion(version);

	User::LeaveIfError(SendReceive(EVersion, TIpcArgs(&packageVersion)));

	return version;

	}

EXPORT_C TLanguage RSisRegistryEntry::LanguageL()

	{

	TLanguage language;

	TPckg<TLanguage> packageLanguage(language);

	User::LeaveIfError(SendReceive(ELanguage, TIpcArgs(&packageLanguage)));

	return language;

	}

EXPORT_C TUid RSisRegistryEntry::UidL()

	{

	TUid uid;

	TPckg<TUid> packageUid(uid);

	User::LeaveIfError(SendReceive(EUid, TIpcArgs(&packageUid)));

	return uid;

	}

EXPORT_C HBufC* RSisRegistryEntry::PackageNameL()

	{

	HBufC* buffer = HBufC::NewLC(KDefaultBufferSize);

	TPtr ptr = buffer->Des();

	User::LeaveIfError(SendReceive(EPackageName, TIpcArgs(&ptr)));

	CleanupStack::Pop(buffer);

	return buffer;

	}

EXPORT_C HBufC* RSisRegistryEntry::UniqueVendorNameL()

	{

	HBufC* buffer = HBufC::NewLC(KDefaultBufferSize);

	TPtr ptr = buffer->Des();

	User::LeaveIfError(SendReceive(EUniqueVendorName, TIpcArgs(&ptr)));

	CleanupStack::Pop(buffer);

	return buffer;

	}

EXPORT_C HBufC* RSisRegistryEntry::LocalizedVendorNameL()

	{

	HBufC* buffer = HBufC::NewLC(KDefaultBufferSize);

	TPtr ptr=buffer->Des();

	User::LeaveIfError(SendReceive(ELocalizedVendorName, TIpcArgs(&ptr)));

	CleanupStack::Pop(buffer);

	return buffer;

	}

EXPORT_C void RSisRegistryEntry::SidsL(RArray<TUid>& aSids)

	{

	HBufC8* buffer = SendReceiveBufferLC(ESids);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble the array from the stream

	InternalizeArrayL(aSids, stream);

	CleanupStack::PopAndDestroy(2, buffer);// buffer, stream

	}

EXPORT_C void RSisRegistryEntry::FilesL(RPointerArray<HBufC>& aFiles)

	{

	TInt startingFile = 0;

	TPckgBuf<TInt> filesCount;

	TStubExtractionMode operationMode = EGetCount;	

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	TPckgC<TInt> pckgStartingFile(startingFile);

#endif

	// Get the total file count.	

	TPckgC<TStubExtractionMode> packageMode(operationMode);

	TInt result = SendReceive(EFiles, TIpcArgs(&packageMode, &filesCount));

	User::LeaveIfError(result);	

	TInt totalFilesCount = filesCount();

	operationMode = EGetFiles;	

	HBufC8* buffer = HBufC8::NewLC(KDefaultBufferSize);

	TPtr8 pOutput(buffer->Des());

	while (startingFile < totalFilesCount)

		{	

		// Fetch the files.	

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		User::LeaveIfError(SendReceive(EFiles, TIpcArgs(&packageMode, &pOutput)));

#else

		User::LeaveIfError(SendReceive(EFiles, TIpcArgs(&packageMode, &pckgStartingFile, &pOutput)));

#endif

		// create a stream based on the buffer

		RDesReadStream stream(*buffer);

		CleanupClosePushL(stream);

		// reassemble the array from the stream

		InternalizePointerArrayL(aFiles, stream);

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

		startingFile = aFiles.Count();	

		}

	CleanupStack::PopAndDestroy(buffer);

	}

EXPORT_C void RSisRegistryEntry::CertificateChainsL(RPointerArray<HBufC8>& aCertificateChains)

	{

	HBufC8* buffer = SendReceiveBufferLC(ECertificateChains);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble the array from the stream

    InternalizePointerArrayL(aCertificateChains, stream);

	CleanupStack::PopAndDestroy(2, buffer);// buffer, stream

	}

EXPORT_C CHashContainer* RSisRegistryEntry::HashL(const TDesC& aFileName)

	{

	HBufC8* buffer = SendReceiveBufferLC(EHashEntry, aFileName);

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble the hash from the stream

    CHashContainer* hash = CHashContainer::NewLC(stream);

	CleanupStack::Pop(hash);

	CleanupStack::PopAndDestroy(2, buffer);// buffer, stream

	return hash;

	}

EXPORT_C TInt RSisRegistryEntry::PropertyL(TInt aKey)

	{

	TInt value;

	TPckg<TInt> propertyValuePckg(value);

	User::LeaveIfError(SendReceive(EProperty, TIpcArgs(aKey, &propertyValuePckg)));	

	return value;

	}

EXPORT_C void RSisRegistryEntry::AugmentationsL(RPointerArray<HBufC>& aPackageNames, RPointerArray<HBufC>& aVendorNames)

	{

	CleanupResetAndDestroyPushL(aPackageNames);

    CleanupResetAndDestroyPushL(aVendorNames);

	HBufC8* buffer = RSisRegistryEntry::SendReceiveBufferLC(EPackageAugmentations);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble the array from the stream

	RPointerArray<CSisRegistryPackage> packages;

	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);

	InternalizePointerArrayL(packages, stream);

	aPackageNames.ResetAndDestroy();

	aVendorNames.ResetAndDestroy();

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

		{

		HBufC* package = packages[i]->Name().AllocLC();

		HBufC* vendor = packages[i]->Vendor().AllocLC();

		aPackageNames.AppendL(package);	

		aVendorNames.AppendL(vendor);

		CleanupStack::Pop(2, vendor);	//vendor package, 

		}

	CleanupStack::PopAndDestroy(3, buffer);// buffer, stream, packages

	CleanupStack::Pop(2, &aPackageNames);

	}

EXPORT_C void RSisRegistryEntry::AugmentationsL(RPointerArray<CSisRegistryPackage>& aPackages)

	{

	HBufC8* buffer = RSisRegistryEntry::SendReceiveBufferLC(EPackageAugmentations);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// reassemble the array from the stream

	InternalizePointerArrayL(aPackages, stream);

	CleanupStack::PopAndDestroy(2, buffer); // buffer, stream

	}

EXPORT_C TInt RSisRegistryEntry::AugmentationsNumberL()

	{

	TInt numAugmentation = 0;

	TPckg<TInt> numAugmentationPkg(numAugmentation);	

	User::LeaveIfError(SendReceive(EPackageAugmentationsNumber, TIpcArgs(&numAugmentationPkg)));

	return numAugmentation;

	}

EXPORT_C CSisRegistryPackage* RSisRegistryEntry::PackageL()

	{

	HBufC8* buffer = SendReceiveBufferLC(EPackage);

	// create a stream based on the buffer

	RDesReadStream stream(*buffer);

	CleanupClosePushL(stream);

	// Create the package from the stream

    CSisRegistryPackage* package = CSisRegistryPackage::NewLC(stream);

	CleanupStack::Pop(package);

	CleanupStack::PopAndDestroy(2, buffer);// buffer, stream

	return package;

	}

EXPORT_C TInt64 RSisRegistryEntry::SizeL()

	{

	TInt64 size = 0;

	TPckg<TInt64> packageSize(size);

	User::LeaveIfError(SendReceive(ESize, TIpcArgs(&packageSize)));

	return size;

	}

EXPORT_C void RSisRegistryEntry::ControllersL(RPointerArray<HBufC8>& aControllers)

	{

	CleanupResetAndDestroyPushL(aControllers);

	HBufC8* buffer = SendReceiveBufferLC(EControllers);

	// this call returns pure data, so we don't incur the overheads of the streamstore

	TInt len(0);

	TPckg<TInt> lenPckg(len);

	TInt pos(0);

	TInt lenLen = lenPckg.Length();

	TInt bufLen = buffer->Length();

	while (pos != bufLen)

		{

		lenPckg.Copy(buffer->Mid(pos, lenLen));

		pos += lenLen;

		HBufC8* controller = buffer->Mid(pos, len).AllocLC();

		aControllers.AppendL(controller);

		CleanupStack::Pop(controller);

		pos += len;

		}

	CleanupStack::PopAndDestroy(buffer);

	CleanupStack::Pop(&aControllers);

	}

EXPORT_C TChar RSisRegistryEntry::SelectedDriveL()

	{

	TInt drive;

	TPckg<TInt> selectedDrive(drive);

	User::LeaveIfError(SendReceive(ESelectedDrive, TIpcArgs(&selectedDrive)));

	return drive;

	}

EXPORT_C TUint RSisRegistryEntry::InstalledDrivesL()

	{

	TUint drive;

	TPckg<TUint> installeddrives(drive);

	User::LeaveIfError(SendReceive(EInstalledDrives, TIpcArgs(&installeddrives)));

	return drive;

	}	

EXPORT_C TBool RSisRegistryEntry::ShutdownAllAppsL()

	{

	TBool shutdownAllApps = EFalse;

	TPckg<TBool> packageShutdownAllApps(shutdownAllApps);

	User::LeaveIfError(SendReceive(EShutdownAllApps, TIpcArgs(&packageShutdownAllApps)));

	return shutdownAllApps;

	}

EXPORT_C TBool RSisRegistryEntry::VerifyControllerSignatureL(RPointerArray<CX509Certificate>& aX509CertArray)

	{

	return VerifyControllerSignatureL(aX509CertArray, ETrue);

	}

EXPORT_C TBool RSisRegistryEntry::VerifyControllerSignatureL(RPointerArray<CX509Certificate>& aX509CertArray, TBool aCheckDateAndTime)

	{

	TInt count = aX509CertArray.Count();

	TInt bufferSize =  Max(count * KDefaultBufferSize / 2, KMinBufferSize);

	CBufFlat* tempBuffer = CBufFlat::NewL(bufferSize);

	CleanupStack::PushL(tempBuffer);

	RBufWriteStream stream(*tempBuffer);

	CleanupClosePushL(stream);

	// Externalise the pointer array  

	ExternalizePointerArrayL(aX509CertArray, stream);

	stream.CommitL();

	// Create an HBufC8 from the stream buf's length, and copy 

	// the stream buffer into this descriptor

	bufferSize = tempBuffer->Size();

	HBufC8* buffer = HBufC8::NewLC(bufferSize);

	TPtr8 pbuffer(buffer->Des());

	tempBuffer->Read(0, pbuffer, bufferSize);

	TBool isVerified = EFalse;

	TPckg<TBool> packagedResult(isVerified);

	TPckgC<TBool> packagedDateCheck(aCheckDateAndTime);

	User::LeaveIfError(SendReceive(EVerifyController, TIpcArgs(&packagedResult, &pbuffer, &packagedDateCheck)));

	CleanupStack::PopAndDestroy(3, tempBuffer); // tempBuffer, stream, buffer  

	return isVerified;	

	}

EXPORT_C TInt RSisRegistryEntry::RemoveWithLastDependentL()

	{

	TInt isRemoveWithLastDependent = 0;

	TPckg<TInt> isRemoveWithLastDependentPkg(isRemoveWithLastDependent);

	User::LeaveIfError(SendReceive(ERemoveWithLastDependent, TIpcArgs(&isRemoveWithLastDependentPkg)));

	return isRemoveWithLastDependent;

	}

EXPORT_C void RSisRegistryEntry::SetRemoveWithLastDependentL(TUid uid)

	{

	TPckg<TUid> uidPkg(uid);

	User::LeaveIfError(SendReceive(ESetRemoveWithLastDependent, TIpcArgs(&uidPkg)));

	}

EXPORT_C TBool RSisRegistryEntry::RemovableL()

	{	

	TBool isRemovable = ETrue;

	TPckg<TBool> packageIsRemovable(isRemovable);

	User::LeaveIfError(SendReceive(ENonRemovable, TIpcArgs(&packageIsRemovable)));

	return isRemovable;

	}

HBufC8* RSisRegistryEntry::SendReceiveBufferLC(TInt aMessage) 

	{

	HBufC8* output = HBufC8::NewLC(KDefaultBufferSize);

	TPtr8 pOutput(output->Des());

	TInt result=SendReceive(aMessage, TIpcArgs(&pOutput));

	if (result == KErrOverflow)

		{

		TInt sizeNeeded;

		TPckg<TInt> sizeNeededPackage(sizeNeeded);

		sizeNeededPackage.Copy(*output);

		// Re-allocate buffer

		CleanupStack::PopAndDestroy(output);

		output = HBufC8::NewLC(sizeNeeded);