diff -r 000000000000 -r ba25891c3a9e installationservices/swi/source/sisregistry/client/sisregistryentry.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/source/sisregistry/client/sisregistryentry.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,641 @@
+/*
+* 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 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)
+	{
+	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
+	}
+
+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)
+	{
+	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);
+	}
+
+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);
+
+		TPtr8 pResizedOutput(output->Des());
+		
+		result=SendReceive(aMessage, TIpcArgs(&pResizedOutput));
+		}
+	User::LeaveIfError(result);
+	return output;
+	}
+
+HBufC8* RSisRegistryEntry::SendReceiveBufferLC(TInt aMessage, const TDesC& aInputDescriptor) 
+	{
+	HBufC8* output = HBufC8::NewLC(KDefaultBufferSize);
+	
+	TPtr8 pOutput(output->Des());
+	
+	TInt result=SendReceive(aMessage, TIpcArgs(&aInputDescriptor, &pOutput));
+	
+	if (result == KErrOverflow)
+		{
+		TInt sizeNeeded;
+		TPckg<TInt> sizeNeededPackage(sizeNeeded);
+		sizeNeededPackage.Copy(*output);
+		
+		// Re-allocate buffer
+		CleanupStack::PopAndDestroy(output);
+		output = HBufC8::NewLC(sizeNeeded);
+
+		TPtr8 pResizedOutput(output->Des());
+		
+		result=SendReceive(aMessage, TIpcArgs(&aInputDescriptor, &pResizedOutput));
+		}
+	User::LeaveIfError(result);
+	return output;
+	}
+
+EXPORT_C TBool RSisRegistryEntry::PreInstalledL()
+	{
+	TBool preInstalled = EFalse;
+	TPckg<TBool> isPreInstalled(preInstalled);
+	
+	User::LeaveIfError(SendReceive(EPreInstalled, TIpcArgs(&isPreInstalled)));
+	return preInstalled;
+	}
+
+EXPORT_C TBool RSisRegistryEntry::IsDeletablePreInstalledL()
+	{
+	TBool deletablePreInstalled = EFalse;
+	TPckg<TBool> deletablePreInstalledPckg(deletablePreInstalled);
+	
+	User::LeaveIfError(SendReceive(EDeletablePreInstalled, TIpcArgs(&deletablePreInstalledPckg)));
+	return deletablePreInstalled;
+	}
+
+
+EXPORT_C void RSisRegistryEntry::DependentPackagesL(RPointerArray<CSisRegistryPackage>& aPackages)
+	{
+	HBufC8* buffer = SendReceiveBufferLC(EDependentPackages);
+	
+	// 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 void RSisRegistryEntry::DependenciesL(RPointerArray<CSisRegistryDependency>& aDependencies)
+	{
+	HBufC8* buffer = SendReceiveBufferLC(EDependencies);
+	
+	// create a stream based on the buffer
+	RDesReadStream stream(*buffer);
+	CleanupClosePushL(stream);
+	
+	// reassemble the array from the stream
+	InternalizePointerArrayL(aDependencies, stream);
+	
+	CleanupStack::PopAndDestroy(2, buffer); // buffer, stream
+	}
+
+EXPORT_C void RSisRegistryEntry::EmbeddedPackagesL(RPointerArray<CSisRegistryPackage>& aPackages)
+	{
+	HBufC8* buffer = SendReceiveBufferLC(EEmbeddedPackages);
+	
+	// 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 void RSisRegistryEntry::EmbeddingPackagesL(RPointerArray<CSisRegistryPackage>& aEmbeddingPackages)
+	{
+	HBufC8* buffer = SendReceiveBufferLC(EEmbeddingPackages);
+	
+	// create a stream based on the buffer
+	RDesReadStream stream(*buffer);
+	CleanupClosePushL(stream);
+	
+	// reassemble the array from the stream
+	InternalizePointerArrayL(aEmbeddingPackages, stream);
+	
+	CleanupStack::PopAndDestroy(2, buffer); // buffer, stream
+	}
+
+EXPORT_C TBool RSisRegistryEntry::IsSignedBySuCertL()
+	{
+	TBool signedSuCert = EFalse;
+	TPckg<TBool> signedSuCertPckg(signedSuCert);
+	
+	User::LeaveIfError(SendReceive(ESignedBySuCert, TIpcArgs(&signedSuCertPckg)));
+	return signedSuCert;	
+	}
+