/*

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

*

*/

#include "CTcFileHandlerSession.h"

#include "CTcFileHandlerServer.h"

#include "FileHandlerConstants.h"

#include <f32file.h>

CTcFileHandlerSession* CTcFileHandlerSession::NewL( 

    CTcFileHandlerServer* aServer )

	{

	CTcFileHandlerSession* self = new( ELeave ) CTcFileHandlerSession;

	CleanupStack::PushL( self );

	self->ConstructL( aServer );

	CleanupStack::Pop();

	return self;

	}

CTcFileHandlerSession::~CTcFileHandlerSession()

	{

	iFileHandlerServer->SessionRemoved();

	}

CTcFileHandlerSession::CTcFileHandlerSession()

	{

	}

void CTcFileHandlerSession::ConstructL( CTcFileHandlerServer* aServer )

	{

	iFileHandlerServer = aServer;

	iFileHandlerServer->SessionAdded();

	}

void CTcFileHandlerSession::ServiceL( const RMessage2& aMessage )

	{

	// Any leaves from this function will be catched by the Active Scheduler

	// and forwarded to CTcFileHandler::RunError().

	// Check for session related requests

	TInt status( KErrNone );

	switch( aMessage.Function() )

		{

		case ECloseSession:

			{

			// Session destruction is handled

			// by the client-server framework.

			break;

			}

		case EConfigAndStart:

			{

			// Nothing to do actually

			break;

			}

		case ECreateFile:

			{

			DoCreateFileL( aMessage );	

			break;

			}

		case ECopyFile:

			{

			DoCopyFileL( aMessage );	

			break;

			}

		case EDeleteFile:

			{

			DoDeleteFileL( aMessage );

			break;

			}

		default:

			{

			// Unknown request

			status = KErrUnknown;

			}

		}

	aMessage.Complete( status );

	}

void CTcFileHandlerSession::DoCreateFileL( const RMessage2& aMessage ) const

    {

    TFileName destinationPath;

    ReadFileNameL( 0, aMessage, destinationPath );

   	HBufC8* data = ReadLC( 1, aMessage );

   	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

	// Make sure path exists, ignore errors since path might exist already

	fs.MkDirAll( destinationPath );	

	RFile out;

	User::LeaveIfError( out.Replace( fs, destinationPath, 

						EFileWrite ) );

	CleanupClosePushL( out );

	User::LeaveIfError( out.Write( *data ) );

	CleanupStack::PopAndDestroy( 3 );	// out, fs, data

    }

void CTcFileHandlerSession::DoCopyFileL( const RMessage2& aMessage ) const

    {

    TFileName sourcePath;

    ReadFileNameL( 0, aMessage, sourcePath );

    TFileName destinationPath;

    ReadFileNameL( 1, aMessage, destinationPath );

    RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

	CFileMan* fileMan = CFileMan::NewL(fs);

	CleanupStack::PushL(fileMan); 

	// Make sure path exists, ignore errors since path might exist already

	fs.MkDirAll( destinationPath );	

	// Make the destination file writeable, ignore errors since most probably

	// file doesn't exist yet

    fileMan->Attribs( destinationPath, 0, KEntryAttReadOnly, TTime( 0 ), 0 );

	User::LeaveIfError( fileMan->Copy( sourcePath, destinationPath ) );

	CleanupStack::PopAndDestroy( 2 ); // fileMan, fs

    }

void CTcFileHandlerSession::DoDeleteFileL( const RMessage2& aMessage ) const

    {

    TFileName destinationPath;

    ReadFileNameL( 0, aMessage, destinationPath );

    // Connect to file server

	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

	// Clear read-only and system flags in order to be able to delete the file

	// Ignore errors.

	fs.SetAtt( destinationPath, 0, KEntryAttReadOnly | KEntryAttSystem );

	// Try deleting the file, report errors (typically KErrNotFound)

	User::LeaveIfError( fs.Delete( destinationPath ) );

	// Close file server session

	CleanupStack::PopAndDestroy();	// fs

    }

void CTcFileHandlerSession::ReadFileNameL( 

    TInt aItcArgIndex,

    const RMessage2& aMessage,

    TFileName& aFileName ) const

    {

   	HBufC8* fileName = ReadLC( aItcArgIndex, aMessage );

   	__ASSERT_ALWAYS( fileName->Des().Length() <= KMaxFileName, 

   	                 User::Leave( KErrArgument ) );

   	aFileName.Copy( *fileName );

   	CleanupStack::PopAndDestroy(); // fileName

    }

HBufC8* CTcFileHandlerSession::ReadLC( 

    TInt aItcArgIndex,

    const RMessage2& aMessage ) const

    {

    TInt length = aMessage.GetDesLength( aItcArgIndex );

    if ( length < 0 )

        {

        User::Leave( KErrBadDescriptor );

        }

    HBufC8* buf = HBufC8::NewLC( length );

	if ( length > 0 )

		{

		TPtr8 bufPtr( buf->Des() );

		aMessage.ReadL( aItcArgIndex, bufPtr );

		}

    return buf;

    }