// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Non-Native application registration functionality for the AppArc server session

// 

// apsnnappupdates.cpp

//

#include "apsnnappupdates.h"

#include <bautils.h>

#include <f32file.h>

#include <s32file.h>

#include "APAID.H"

#include "../aplist/aplapplistitem.h"

#include "apsserv.h"

#include "APSSTD.H"

#include "../aplist/aplappregfinder.h"

#include "../apgrfx/apprivate.h"

#include "apsnnapps.h"

/**************************************************************************************************************

 * TFilePositionReset

 **************************************************************************************************************/

/**

This class is used to ensure that a RFile's read/write position is reset to its original value

if a leave occurs.

@internalComponent

*/

NONSHARABLE_CLASS(TFilePositionReset)

	{

public:

	TFilePositionReset(RFile& aFile) :

	 		iFile(aFile),

 			iOriginalFilePosition(-1)

 		{

	 	}

	void RewindToStartLC()

		{

		TInt originalFilePosition=0;

		User::LeaveIfError(iFile.Seek(ESeekCurrent, originalFilePosition)); // retrieves the current file-position

		TInt newFilePosition=0;

		User::LeaveIfError(iFile.Seek(ESeekStart, newFilePosition)); // RFile::Seek(ESeekStart,..) will not modify the TInt, but needs a reference.

		iOriginalFilePosition=originalFilePosition;

		CleanupStack::PushL(TCleanupItem(&StaticReset, this));

		}

	TInt Reset()

		{

		__ASSERT_DEBUG(iOriginalFilePosition>=0, Panic(ENonNativeAppsNegativeStoredFilePosition));

		const TInt error = iFile.Seek(ESeekStart, iOriginalFilePosition);

		iOriginalFilePosition=-1;

		return error;

		}

private:

	static void StaticReset(TAny* aThis)

		{

		// ignore the error code from this, we can't do anything about it

		static_cast<TFilePositionReset*>(aThis)->Reset();

		}

private:

	RFile& iFile;

	TInt iOriginalFilePosition;

	};

/**************************************************************************************************************

 * TFileDetails

 **************************************************************************************************************/

TFileDetails::TFileDetails() :

		iState(EStateNull) 

	{

	}

/*

Returns the real path, (aka the target location) of this file

*/

const TDesC& TFileDetails::Path()

	{

	__ASSERT_DEBUG(iPath != KNullDesC, Panic(ENonNativeAppsTFileDetailsPathNotSet));

	return iPath;

	}

/*

Sets the real path, (aka the target location) of this file

*/

void TFileDetails::SetPath(const TDesC& aPath)

	{

	__ASSERT_DEBUG(iPath == KNullDesC, Panic(ENonNativeAppsTFileDetailsPathAlreadySet));

	iPath = aPath;

	}

/*

Determines whether this TFileDetails has a real path set.

If thie object doesn't have a real path set, it is assumed to not be in use

*/

TBool TFileDetails::Exists() const

	{

	return (iPath != KNullDesC);

	}

/*

Releases whatever file handle is currently held, whether it is on the real file,

temporary file, or none at all

*/

void TFileDetails::CloseHandle()

	{

	iHandle.Close();

	}

/*

Opens a handle on a real file

*/

void TFileDetails::OpenL(RFs& aFs, const TFileName& aFileName)

	{

	__ASSERT_DEBUG(iState == EStateNull, Panic(ENonNativeAppsTFileDetailsOpenInBadState));

	__ASSERT_DEBUG(iPath == KNullDesC, Panic(ENonNativeAppsTFileDetailsOpenWithRealPathSet));

	__ASSERT_DEBUG(iTempPath == KNullDesC, Panic(ENonNativeAppsTFileDetailsOpenWithTempPathSet));

	User::LeaveIfError(iHandle.Open(aFs, aFileName, EFileShareExclusive|EFileStream|EFileWrite));

	iPath = aFileName;

	iState = EStateReal;

	}

/*

Creates a new, temporary file to write new data into

Used in the preparation of a register-application update to create new resource

and icon files before they are moved into their target locations.

*/

void TFileDetails::CreateTemporaryL(RFs& aFs, const TFileName& aDir)

	{

	__ASSERT_DEBUG(iState == EStateNull, Panic(ENonNativeAppsTFileDetailsCreateTempInBadState));

	__ASSERT_DEBUG(iTempPath == KNullDesC, Panic(ENonNativeAppsTFileDetailsCreateTempWithTempPathSet));

	RFile file;

	CleanupClosePushL(file);

	// NOTE: remove this workaround if/when RFile::Temp is fixed by base

	TInt tempErr = KErrAlreadyExists;

	/* RFile::Temp is a bit dodgy, at least on Winscw with the proxy FS */

	for(TInt tries = 0; tempErr == KErrAlreadyExists && tries < 50; ++tries)

		{

		tempErr = file.Temp(aFs, aDir, iTempPath, EFileShareExclusive|EFileStream|EFileWrite);

		}

	User::LeaveIfError(tempErr);

	CleanupStack::Pop(&file);

	iHandle = file;

	iState = EStateTemporary;

	}

/*

Makes aFile a duplicates of the file handle owned by this class.

Used to write to a file created by CreateTemporaryL()

*/

void TFileDetails::GetDuplicateHandleL(RFile& aFile)

	{

	User::LeaveIfError(aFile.Duplicate(iHandle));

	}

/*

RenameToRealL

Used to perform a register-appliction update

This uses the same code as the non-leaving

RenameToReal().

*/

void TFileDetails::RenameToRealL(RFs& aFs)

	{

	User::LeaveIfError(RenameToReal(aFs));

	}

/*

RenameToReal

Used by RenameToRealL() and RestoreReal()

@see RenameToRealL

@see RestoreReal

*/

TInt TFileDetails::RenameToReal(RFs& aFs)

	{

	__ASSERT_DEBUG(iState == EStateTemporary, Panic(ENonNativeAppsTFileDetailsRenameToRealInBadState));

	__ASSERT_DEBUG(iTempPath != KNullDesC, Panic(ENonNativeAppsTFileDetailsRenameToRealWithoutTempPath));

	__ASSERT_DEBUG(iPath != KNullDesC, Panic(ENonNativeAppsTFileDetailsRenameToRealWithoutRealPath));

	TParse parse;

	parse.SetNoWild(iPath,NULL,NULL);

	if(!BaflUtils::FolderExists(aFs,parse.DriveAndPath())) 

		{

		TInt err = aFs.MkDirAll(parse.DriveAndPath());

		if(err != KErrNone)

			{

			return err;

			}

		}

	//Check if file already exists, if it exists delete it because we might be trying to register an upgrade 

	if(BaflUtils::FileExists(aFs, iPath)) 

    	{ 

        TInt err = BaflUtils::DeleteFile(aFs, iPath); 

        if(KErrNone != err) 

        	{ 

            return err; 

            } 

		}

	TInt err = iHandle.Rename(iPath);

	if(err != KErrNone)

		{

		return err;

		}

	iTempPath.Zero();

	iState = EStateReal;

	return KErrNone;

	}

/*

RenameToTemporaryL

Used to perform a deregister-application update

*/

void TFileDetails::RenameToTemporaryL(RFs& aFs, const TFileName& aDir)

	{

	__ASSERT_DEBUG(iState == EStateReal, Panic(ENonNativeAppsTFileDetailsRenameToTempInBadState));

	__ASSERT_DEBUG(iPath != KNullDesC, Panic(ENonNativeAppsTFileDetailsRenameToTempWithoutRealPathSet));

	__ASSERT_DEBUG(iTempPath == KNullDesC, Panic(ENonNativeAppsTFileDetailsRenameToTempWithTempPathSet));

	/* create a temp file and delete it to get an unused filename */

	RFile file;

	CleanupClosePushL(file);

	// NOTE: remove this workaround if/when RFile::Temp is fixed by base

	TInt tempErr = KErrAlreadyExists;

	/* RFile::Temp is a bit dodgy, at least on Winscw with the proxy FS */

	for(TInt tries = 0; tempErr == KErrAlreadyExists && tries < 50; ++tries)

		{

		tempErr = file.Temp(aFs, aDir, iTempPath, EFileShareExclusive|EFileStream|EFileWrite);

		}

	User::LeaveIfError(tempErr);

	CleanupStack::PopAndDestroy(&file); // close the file handle

	const TInt err = aFs.Delete(iTempPath);

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

		{

		User::Leave(err);

		}

	User::LeaveIfError(iHandle.Rename(iTempPath));

	iState = EStateTemporary;

	}

/*

Delete

Whatever the state, real or temporary, delete it.

Used in the rollback phase of a register-application update.

This function releases the handle (if any) and sets the state back to EStateNull

*/

TInt TFileDetails::Delete(RFs& aFs)

	{

	__ASSERT_DEBUG(iState == EStateNull || iState == EStateReal || iState == EStateTemporary,

			Panic(ENonNativeAppsTFileDetailsDeleteInBadState));

	if(iState == EStateNull)

		{

		return KErrNone;

		}

	iHandle.Close();

	TInt err;

	if(iState == EStateReal)

		{

		err = aFs.Delete(iPath);

		}

	else if(iState == EStateTemporary)

		{

		err = aFs.Delete(iTempPath);

		}

	else

		{

		err = KErrGeneral;

		ASSERT(EFalse);

		}

	iPath.Zero();

	iTempPath.Zero();

	iState = EStateNull;

	return err;

	}

/*

DeleteTemporary

Check that the state is EStateTemporary, and delete it.

This function is used by the destructor of a deregister-application update

This function releases the handle (if any) and sets the state back to EStateNull

*/

TInt TFileDetails::DeleteTemporary(RFs& aFs)

	{

	__ASSERT_DEBUG(iState == EStateNull || iState == EStateTemporary,

			Panic(ENonNativeAppsTFileDetailsDeleteTemporaryInBadState));

	if(iState == EStateNull || iState == EStateTemporary)

		{

		return Delete(aFs);

		}

	return KErrGeneral;

	}

/*

RestoreReal

Whatever the state, real or temporary, try to move it back to the real location.

Used in the rollback phase of a deregister-application update.

This function releases the handle (if any) and sets the state back to EStateNull

*/

TInt TFileDetails::RestoreReal(RFs& aFs)

	{

	__ASSERT_DEBUG(iState == EStateNull || iState == EStateReal || iState == EStateTemporary,

		Panic(ENonNativeAppsTFileDetailsRestoreRealInBadState));

	if(iState == EStateNull)

		{

		return KErrNone;

		}

	TInt err = KErrNone;

	if(iState == EStateReal)

		{

		iHandle.Close();

		}

	else if(iState == EStateTemporary)

		{

		err = RenameToReal(aFs);

		iHandle.Close();

		}

	else

		{

		ASSERT(EFalse);

		}

	iPath.Zero();

	iTempPath.Zero();

	iState = EStateNull;

	return err;

	}

void TFileDetails::ExternalizeL(RWriteStream& aStream)

	{

	aStream.WriteUint8L(iState);

	aStream.WriteUint32L(iPath.Length());

	aStream.WriteL(iPath);

	aStream.WriteUint32L(iTempPath.Length());

	aStream.WriteL(iTempPath);

	}

void TFileDetails::ExternalizeContinuationL(RWriteStream& aStream, TInt aTag)

	{

	aStream.WriteInt8L(CApsNonNativeApplicationsUpdate::EContinuationOfUpdate);

	aStream.WriteInt8L(aTag);

	ExternalizeL(aStream);

	aStream.CommitL(); // beta stopping point

	}

TInt TFileDetails::ExternalizeContinuation(RWriteStream& aStream, TInt aTag)

	{

	TRAPD(err,ExternalizeContinuationL(aStream,aTag));

	return err;

	}

void TFileDetails::InternalizeL(RReadStream& aStream, TInt& aPosition)

	{

	TState state = static_cast<TState>(aStream.ReadUint8L());

	TUint pathLen = aStream.ReadUint32L();

	if(pathLen > KMaxFileName)

		{

		User::Leave(KErrCorrupt);

		}

	TFileName path;

	aStream.ReadL(path, pathLen);

	TUint tempPathLen = aStream.ReadUint32L();

	if(tempPathLen > KMaxFileName)

		{

		User::Leave(KErrCorrupt);

		}

	TFileName tempPath;

	aStream.ReadL(tempPath, tempPathLen);

	/* all dangerous operations are now out of the way */

	iState = state;

	iPath = path;

	iTempPath = tempPath;

	// state, length, path, length, temppath

	aPosition += sizeof(TUint8) +  sizeof(TUint32) + (pathLen * sizeof(TText)) +  sizeof(TUint32) + (tempPathLen * sizeof(TText));

	}

/*

Works out what file we had a handle on when the log was written, and try to regain it.

*/	

void TFileDetails::PostInternalizeL(RFs& aFs)

	{

	TInt err;

	switch(iState)

		{

	case EStateNull:

		if(iTempPath != KNullDesC)

			{

			User::Leave(KErrCorrupt);

			}

		break;

	case EStateTemporary:

		if(iTempPath == KNullDesC)

			{

			User::Leave(KErrCorrupt);

			}

		err = iHandle.Open(aFs, iTempPath, EFileShareExclusive|EFileStream|EFileWrite);

		if(err == KErrNotFound || err == KErrPathNotFound)

			{

			iTempPath.Zero();

			iPath.Zero();

			iState = EStateNull;

			}

		else 

			{

			User::LeaveIfError(err);

			}

		break;

	case EStateReal:

		if(iPath == KNullDesC)

			{

			User::Leave(KErrCorrupt);

			}

		err = iHandle.Open(aFs, iPath, EFileShareExclusive|EFileStream|EFileWrite);

		if(err == KErrNotFound || err == KErrPathNotFound)

			{

			iTempPath.Zero();

			iPath.Zero();

			iState = EStateNull;

			}

		else 

			{

			User::LeaveIfError(err);

			}

		break;

	default:

		User::Leave(KErrCorrupt);

		break;

		}

	}

/**************************************************************************************************************

 * CApsNonNativeApplicationsUpdate

 **************************************************************************************************************/

CApsNonNativeApplicationsUpdate::CApsNonNativeApplicationsUpdate(RFs& aFs, TUid aUid, TState aState, TLogUpdateType aType) :

		iState(aState),

		iFs(aFs),

		iType(aType),

		iUid(aUid)

	{

	}

CApsNonNativeApplicationsUpdate::~CApsNonNativeApplicationsUpdate()

	{

	}

CApsNonNativeApplicationsUpdate* CApsNonNativeApplicationsUpdate::Previous() const

	{

	return iPrevious;

	}

CApsNonNativeApplicationsUpdate* CApsNonNativeApplicationsUpdate::Next() const

	{

	return iNext;

	}

TUid CApsNonNativeApplicationsUpdate::Uid() 

	{

	return iUid;

	}

void CApsNonNativeApplicationsUpdate::PerformUpdateL(RApsUpdateLog& aUpdateLog)

	{

	ASSERT(iState == ENew);

	RWriteStream& stream = aUpdateLog.LogWriteStream();

	/* NewUpdateSection */

	stream.WriteInt8L(ENewUpdate);

	stream.WriteInt8L(iType);

	stream.WriteInt32L(iUid.iUid);

	ExternalizeL(stream);

	stream.CommitL(); // alpha stopping point

	/* PerformUpdateSection */

	stream.WriteInt8L(EPerformUpdate);

	stream.WriteInt8L(iType);

	stream.WriteInt32L(iUid.iUid);     // beta stopping points

	StateChangeL(EPerforming, stream); // ...

	DoPerformUpdateL(aUpdateLog);      // ...

	StateChangeL(EPerformed, stream);  // ...

	stream.WriteInt8L(EEndOfUpdate);

	stream.CommitL();                  // alpha stopping point

	}

void CApsNonNativeApplicationsUpdate::RollbackUpdateL(RApsUpdateLog& aUpdateLog)

	{

	ASSERT(iState == EPerforming || iState == EPerformed || iState == ERollingBack);

	RWriteStream& stream = aUpdateLog.LogWriteStream();

	stream.WriteInt8L(ERollbackUpdate);

	stream.WriteInt8L(iType);