/*
* Copyright (c) 2008-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: 
* filemerger.cpp
*
*/


#include <e32cons.h>
#include <scs/cleanuputils.h>
#include <apmstd.h> 
#include <apgcli.h>
#include "usiflog.h"
#include "sifrefbinpkgextractor.h"

_LIT8(KCompoundPackageHeader, "_SifReferenceInstallerPackageHeader_");
_LIT8(KCompoundPackageFooter, "_SifReferenceInstallerPackageFooter_");
_LIT(KPkgFileExt, ".sifrefpkg");
_LIT(KRefBinPkgMimeType, "binary/sif-refpkg");
_LIT(KEmbCompMidDir, "children\\");
_LIT(KDirSeparator, "\\");

const TInt KBufferLength = 0x3FFC; // 16kB
const TInt KMaxNumFiles = 16;
const TInt KMaxEmbCompSize = 0xFFFFFF; // 16MB

using namespace Usif;

namespace
	{
	TInt ReadInt32L(RFile& file)
		{
		TBuf8<4> buf;
		User::LeaveIfError(file.Read(buf, sizeof(TInt)));
		return buf[0] | buf[1]<<8 | buf[2]<<16 | buf[3]<<24;
		}

	HBufC* BuildPkgFileNameLC(const TDesC& aTempDir, const TDesC& aBinPkgPath)
		{
		TParsePtrC parser(aBinPkgPath);
		TPtrC binPkgfileName = parser.Name();
		HBufC* pkgfileName = HBufC::NewLC(aTempDir.Length() + binPkgfileName.Length() + KPkgFileExt.iTypeLength);
		TPtr pkgfileNamePtr =  pkgfileName->Des();
		pkgfileNamePtr += aTempDir;
		pkgfileNamePtr += binPkgfileName;
		pkgfileNamePtr += KPkgFileExt;
		
		return pkgfileName;
		}

	HBufC* BuildPkgFileNameLC(const TDesC& aTempDir, const RFile& aFile)
		{
		HBufC* name = HBufC::NewLC(KMaxFileName);
		TPtr namePtr(name->Des());
		User::LeaveIfError(aFile.Name(namePtr));
		
		HBufC* pkgName = BuildPkgFileNameLC(aTempDir, *name);
		
		CleanupStack::Pop(pkgName);
		CleanupStack::PopAndDestroy(name);
		CleanupStack::PushL(pkgName);
		
		return pkgName;
		}

	void ExtractBinPkgFileL(RStsSession& aSts, RFile& aInFile, const TDesC& aOutPath, RPointerArray<HBufC>& aOutFiles)
		{
		// Check file size
		TInt size(0);
		User::LeaveIfError(aInFile.Size(size));
		if (size < KCompoundPackageHeader.iTypeLength+KCompoundPackageFooter.iTypeLength+sizeof(TInt))
			{
			User::Leave(KErrCorrupt);
			}
		
		// Create a buffer
		HBufC8* buffer = HBufC8::NewLC(KBufferLength);
		TPtr8 bufPtr = buffer->Des();
		
		// Read header
		User::LeaveIfError(aInFile.Read(bufPtr, KCompoundPackageHeader.iTypeLength));
		if (bufPtr != KCompoundPackageHeader)
			{
			User::Leave(KErrCorrupt);
			}
		bufPtr.Zero();
		
		// Read the size of a pkg content
		const TInt pkgSize = ReadInt32L(aInFile);
		if (pkgSize > KBufferLength)
			{
			User::Leave(KErrCorrupt);
			}

		// Build the name of the pkg file
		HBufC* inFileNameWithExt = HBufC::NewLC(KMaxFileName);
		TPtr inFileNameWithExtPtr = inFileNameWithExt->Des();
		User::LeaveIfError(aInFile.Name(inFileNameWithExtPtr));
		HBufC* pkgFileName = BuildPkgFileNameLC(aOutPath, *inFileNameWithExt);

		// Create the pkg file
		RFile pkgFile;
		aSts.CreateTemporaryL(*pkgFileName, pkgFile, EFileWrite);
		CleanupClosePushL(pkgFile);
		
		// Copy the content of the pkg file
		User::LeaveIfError(aInFile.Read(bufPtr, pkgSize));
		User::LeaveIfError(pkgFile.Write(bufPtr));
		CleanupStack::PopAndDestroy(&pkgFile);
		bufPtr.Zero();
		
		// Read the number of embedded components
		const TInt numEmbComps = ReadInt32L(aInFile);
		if (numEmbComps > KMaxNumFiles)
			{
			User::Leave(KErrCorrupt);
			}
		
		// Create a directory for embedded components
		HBufC* embCompPath = NULL;
		if (numEmbComps > 0)
			{
			embCompPath = HBufC::NewLC(aOutPath.Length() + KEmbCompMidDir.iTypeLength);
			embCompPath->Des().Copy(aOutPath);
			embCompPath->Des().Append(KEmbCompMidDir);
			}
		
		// Iterate over the components and extract them
		for (TInt i=0; i<numEmbComps; ++i)
			{
			// Read the length of the name of an embedded component
			const TInt strLen = ReadInt32L(aInFile);
			if (strLen > KMaxPath)
				{
				User::Leave(KErrCorrupt);
				}
			
			// Read the name of an embedded component and build its target path
			User::LeaveIfError(aInFile.Read(bufPtr, strLen));
			HBufC* embFileName = ConvertBufferTo16bitL(bufPtr);
			CleanupStack::PushL(embFileName);
			bufPtr.Zero();
			HBufC* embFileTargetPath = HBufC::NewLC(embCompPath->Length() + 2*embFileName->Length() + KDirSeparator.iTypeLength);
			TPtr embFileTargetPathPtr(embFileTargetPath->Des());
			embFileTargetPathPtr.Copy(*embCompPath);
			embFileTargetPathPtr += *embFileName;
			embFileTargetPathPtr += KDirSeparator;
			embFileTargetPathPtr += *embFileName;
			
			// Read the size of an embedded component
			const TInt fileSize = ReadInt32L(aInFile);
			if (fileSize > KMaxEmbCompSize)
				{
				User::Leave(KErrCorrupt);
				}
			
			// Create an output file
			RFile outFile;
			aSts.CreateTemporaryL(*embFileTargetPath, outFile, EFileWrite);
			CleanupClosePushL(outFile);
			
			// Copy the content of the output file
			const TInt numChunks = fileSize / KBufferLength;
			for (TInt c=0; c<numChunks; ++c)
				{
				User::LeaveIfError(aInFile.Read(bufPtr, KBufferLength));
				User::LeaveIfError(outFile.Write(bufPtr));
				bufPtr.Zero();
				}
			const TInt remainder = fileSize % KBufferLength;
			User::LeaveIfError(aInFile.Read(bufPtr, remainder));
			User::LeaveIfError(outFile.Write(bufPtr));
			bufPtr.Zero();
			
			CleanupStack::PopAndDestroy(&outFile);
			aOutFiles.AppendL(embFileTargetPath);
			CleanupStack::Pop(embFileTargetPath);
			CleanupStack::PopAndDestroy(embFileName);
			}
		
		if (embCompPath != NULL)
			{
			CleanupStack::PopAndDestroy(embCompPath);
			}
		
		// Read footer
		User::LeaveIfError(aInFile.Read(bufPtr, KCompoundPackageFooter.iTypeLength));
		if (bufPtr != KCompoundPackageFooter)
			{
			User::Leave(KErrCorrupt);
			}
		bufPtr.Zero();
		
		CleanupStack::PopAndDestroy(3, buffer); // inFileNameWithExt, pkgFileName
		}
		
	void ExtractBinPkgFileL(RStsSession& aSts, const TDesC& aInFileName, const TDesC& aOutPath, RPointerArray<HBufC>& aOutFiles)
		{
		RFs fs;
		RFile file;
		User::LeaveIfError(fs.Connect());
		CleanupClosePushL(fs);
		TInt err = file.Open(fs, aInFileName, EFileShareReadersOnly);
		if (err != KErrNone)
			{
			DEBUG_PRINTF3(_L8("Failed to open file: %S with error: %d"), &aInFileName, err);
			User::Leave(err);
			}
		CleanupClosePushL(file);
		
		ExtractBinPkgFileL(aSts, file, aOutPath, aOutFiles);
		
		CleanupStack::PopAndDestroy(2, &fs);
		}

	TBool IsForeignL(RFile& aFileHandle)
		{
		// Get the MIME type of the component to be installed from AppArc
		TDataType dataType;
		RApaLsSession apa;
		User::LeaveIfError(apa.Connect());
		CleanupClosePushL(apa);
		TUid appUid = TUid::Null();
		User::LeaveIfError(apa.AppForDocument(aFileHandle, appUid, dataType));
		// A possible problem with recognizers is returning a successful result, but forgetting to set the MIME type
		if (dataType.Des8().Ptr() == NULL) 
			{
			User::Leave(KErrCompletion);
			}
		CleanupStack::PopAndDestroy(&apa);
		
		return dataType.Des() != KRefBinPkgMimeType;
		}

	TBool IsForeignL(const TDesC& aFileName)
		{
		RFs fs;
		RFile file;
		User::LeaveIfError(fs.Connect());
		CleanupClosePushL(fs);
		User::LeaveIfError(fs.ShareProtected());
		TInt err = file.Open(fs, aFileName, EFileShareReadersOnly);
		if (err != KErrNone)
			{
			DEBUG_PRINTF3(_L8("Failed to open file: %S with error: %d"), &aFileName, err);
			User::Leave(err);
			}
		CleanupClosePushL(file);
		
		const TBool result = IsForeignL(file);

		CleanupStack::PopAndDestroy(2, &fs); // file

		return result;
		}
	}

namespace Usif
	{
	namespace SifRefBinPkgExtractor
		{
		CAuxNode* CAuxNode::NewLC(const TDesC& aFileName, TBool aForeign, CAuxNode& aParent)
			{
			CAuxNode* self = new (ELeave) CAuxNode;
			CleanupStack::PushL(self);
			
			self->iFileName = aFileName.AllocL();
			self->iForeign = aForeign;
			self->iParent = &aParent;
			
			return self;
			}
		CAuxNode* CAuxNode::NewLC(const RFile& aFile, TBool aForeign, CAuxNode& aParent)
		    {
	        CAuxNode* self = new (ELeave) CAuxNode;
	        CleanupStack::PushL(self);
	                    
	        HBufC* name = HBufC::NewLC(KMaxFileName);
	        TPtr namePtr(name->Des());
	        User::LeaveIfError(aFile.Name(namePtr));
	                    
	        self->iFileName = name->AllocL();
	        self->iForeign = aForeign;
	        self->iParent = &aParent;
	        
	        CleanupStack::PopAndDestroy(name); 
	        return self;
	        }

		CAuxNode::CAuxNode()
			{
			}
		
		CAuxNode::~CAuxNode()
			{
			delete iFileName;
			delete iNode;
			delete iCompInfo;
			}

		void CAuxNode::SetNodeL(CComponentInfo::CNode* aNode)
			{
			if (iNode != NULL)
				{
				User::Leave(KErrAlreadyExists);
				}
			iNode = aNode;
			}

		void CAuxNode::SetCompInfoL(CComponentInfo* aCompInfo)
			{
			if (iCompInfo != NULL)
				{
				User::Leave(KErrAlreadyExists);
				}
			iCompInfo = aCompInfo;
			}
		
		void CAuxNode::RegisterChildToParentL()
			{
			ASSERT (iCompInfo != NULL || iNode != NULL);
			
			if (iCompInfo != NULL)
				{
				iCompInfo->SetRootNodeAsChildL(*iParent->iNode);
				delete iCompInfo;
				iCompInfo = NULL;
				}
			else
				{
				iParent->iNode->AddChildL(iNode);
				iNode = NULL;
				}
			}
		
		void CAuxNode::SetAsRootNodeL(CComponentInfo& aCompInfo)
			{
			if (iNode == NULL)
				{
				User::Leave(KErrNotFound);
				}
			aCompInfo.SetRootNodeL(iNode);
			iNode = NULL;
			}

//-------------------------------------------------------------------------------------------------------

		void BuildPkgTreeImplL(RStsSession& aSts, const TDesC* aInFileName, RFile* aInFile, const TDesC& aTempDir, RPointerArray<CAuxNode>& aFlatTree, CAuxNode* aParent)
			{
			__ASSERT_ALWAYS(aInFileName != NULL || aInFile != NULL, User::Leave(KErrArgument));
			
			RCPointerArray<HBufC> embFiles;
			CleanupClosePushL(embFiles);
			CAuxNode* node = NULL;
			HBufC* pkgFileName = NULL;
			const TBool foreign = aInFile ? IsForeignL(*aInFile) : IsForeignL(*aInFileName);
			if (!foreign)
				{
				if (aInFile != NULL)
					{
					ExtractBinPkgFileL(aSts, *aInFile, aTempDir, embFiles);
					}
				else
					{
					ExtractBinPkgFileL(aSts, *aInFileName, aTempDir, embFiles);
					}
				
				pkgFileName = aInFile ? BuildPkgFileNameLC(aTempDir, *aInFile) : BuildPkgFileNameLC(aTempDir, *aInFileName);
				node = CAuxNode::NewLC(*pkgFileName, EFalse, *aParent);
				aFlatTree.AppendL(node);
				CleanupStack::Pop(node);
				for (TInt i=0; i<embFiles.Count(); ++i)
					{
					const TDesC& fileName = *embFiles[i];
					TParsePtrC parser(fileName);
					BuildPkgTreeImplL(aSts, &fileName, NULL, parser.DriveAndPath(), aFlatTree, node);
					}
				}
			else
				{
				if (aParent == NULL)
					{
					User::Leave(KErrCorrupt);
					}
				if (aInFileName != NULL)
				    {
				    node = CAuxNode::NewLC(*aInFileName, ETrue, *aParent);
				    }
				else
				    {
				    node = CAuxNode::NewLC(*aInFile, ETrue, *aParent);
				    }			
				aFlatTree.AppendL(node);
				CleanupStack::Pop(node);
				}
			
				if (pkgFileName != NULL)
					{
					CleanupStack::PopAndDestroy(pkgFileName);
					}
			
			CleanupStack::PopAndDestroy(&embFiles);
			}
		
		void BuildPkgTreeL(RStsSession& aSts, RFile& aInFile, const TDesC& aTempDir, RPointerArray<CAuxNode>& aFlatTree, CAuxNode* aParent)
			{
			BuildPkgTreeImplL(aSts, NULL, &aInFile, aTempDir, aFlatTree, aParent);
			}
		
		void BuildPkgTreeL(RStsSession& aSts, const TDesC& aInFileName, const TDesC& aTempDir, RPointerArray<CAuxNode>& aFlatTree, CAuxNode* aParent)
			{
			BuildPkgTreeImplL(aSts, &aInFileName, NULL, aTempDir, aFlatTree, aParent);
			}
		} // namespace SifRefBinPkgExtractor
	} //namespace Usif