// Copyright (c) 1998-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:

// FTP protocol engine

// Author:	Philippe Gabriel

// Implements objet controling the PI channel of the FTP protocol

// Model the PI Channel as an FSM

// Transitions between states are triggered by PI methods and events

// coming from ESOCK

// 

//

/**

 @file PICHNL.CPP

 @internalComponent

*/

//#include <in_sock.h>

//#include <c32comm.h>

#include "DEBUG.H"

#include "PICHNL.H"

#include "FTPPROT.H"

#include <e32base.h>

//#include <es_sock.h>

//#include <nifman.h>

//

// Definitions

//

CPISocketRead::CPISocketRead(MPIChannelNotifier* aNotifier,

							 CPIChannel*	aPIChannel)

							 : CActive(EPriorityStandard)

/**

CPISocketRead object

Read Write implementaion.

*/

	{

		iNotifier = aNotifier;

		iPIChannel = aPIChannel;

	};

CPISocketRead* CPISocketRead::NewL(MPIChannelNotifier* aNotifier,

									CPIChannel*	aPIChannel)

	{

	CPISocketRead* self = new(ELeave) CPISocketRead(aNotifier,aPIChannel);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	};

void CPISocketRead::ConstructL()

	{

	CActiveScheduler::Add(this);

	};

void CPISocketRead::DoCancel()

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPISocketRead::DoCancel() called"));

	iSocket->CancelAll();

	};

void CPISocketRead::RunL()

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPISocketRead::RunL() called"));

	if (iStatus == KErrNone)

		{

		// Call our notifier

		iNotifier->PIChannelRcvNotification();

		}

	else

		{

		// Uh!!! weird 

		Cancel();

		//Disconnect Pi Channel

		iPIChannel->Disconnect();

		// Notify caller

		iNotifier->PIChannelOperationError(MPIChannelNotifier::EPiConnectionReset);

		}	

	};

void CPISocketRead::IssueRead(TDes8& aBuffer)

/**

Read Data from a Stream Socket 

*/

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPISocketRead::IssueRead() called\n"));

	if (this->IsActive())

		return;

	iSocket->RecvOneOrMore(aBuffer, 0, iStatus,iRcvLen);

	SetActive();	

	FTPPROTDEBUG(_DBGPichnl,_L("CPISocketRead::IssueRead() recv triggered\n"));

	};

CPIChannel::CPIChannel(MPIChannelNotifier* aNotifier)

						:CActive(CActive::EPriorityStandard)					

/**

PI Channel object

*/

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::CPIChannel called\n"));

	//Initialise State

	iPIChannelState = EPIChannelIdle;

	iNotifier = aNotifier;

	}

CPIChannel* CPIChannel::NewL(MPIChannelNotifier* aNotifier,

							 RSocketServ& aSockServ)

	{

	CPIChannel* self = new (ELeave) CPIChannel(aNotifier);

    CleanupStack::PushL(self);

    self->ConstructL(aSockServ);

    CleanupStack::Pop();

	return self;

	} 

void CPIChannel::ConstructL(RSocketServ& aSockServ)

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::ConstructL called\n"));

	iSockServ = aSockServ;

	iReceiver = CPISocketRead::NewL(iNotifier,this);

	CActiveScheduler::Add(this);

	} 

CPIChannel::~CPIChannel()

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::~CPIChannel called\n"));

	//Abort receive 

	if ( iReceiver )

		{

		iReceiver->Cancel();

		delete iReceiver;

		}

	}

void CPIChannel::RunL()

	{

	FTPPROTDEBUG(_DBGPichnl,_L("Mytest::RunL activated for CPIChannel\n"));

	switch(iPIChannelState)

		{

		case	EPIChannelIdle:

				// Cannot be activated in that state

				__ASSERT_DEBUG(FALSE, User::Panic(_L("CPIChannel"), EPIPanicOutOfState));

				break;

		case	EPIChannelConnecting:

				FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::RunL state: Connecting\n"));

				// Check result of connecting request

				switch (iStatus.Int())

					{

					case KErrNone:

						// If succeed set state to EPIChannelConnected

						iPIChannelState = EPIChannelConnected;

						// Call notifier

						iNotifier->PIChannelOperationCompletion(MPIChannelNotifier::EPiConnectComplete);

						break;

					default:

						// Reset channel to Idle/disconnect socket

						Disconnect();

						// Notify caller

						iNotifier->PIChannelOperationError(MPIChannelNotifier::EPiConnectFailed);

						break;

					}

				break;

		case	EPIChannelDisconnecting:

				FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::RunL state: Connecting\n"));

				// Assume disconnect always work

				Disconnect();

				// Notify caller

				iNotifier->PIChannelOperationCompletion(MPIChannelNotifier::EPiDisconnectComplete);

				break;

		case	EPIChannelSending:

				FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::RunL state: EPIChannelSending\n"));

				// Check result of send request

				switch (iStatus.Int())

					{

					case KErrNone:

						// If succeed set state to EPIChannelConnected

						iPIChannelState = EPIChannelConnected;

						// Call notifier

						iNotifier->PIChannelOperationCompletion(MPIChannelNotifier::EPiSendComplete);

						break;

					default:

						// Reset channel to Idle/disconnect socket

						Disconnect();

						// Notify caller

						iNotifier->PIChannelOperationError(MPIChannelNotifier::EPiSendFailed);

						break;

					}

				break;

		default:

			__ASSERT_DEBUG(FALSE, User::Panic(_L("CPIChannel::RunL"), 0));

				break;

		}

	}

TBool CPIChannel::Connect(TSockAddr& aNetAddr)

/**

@return FALSE if a socket could not be openned

		Caller must check the result and post an error if appropriate

*/

	{

	// Check this is a valid state for this operation

	__ASSERT_DEBUG((iPIChannelState == EPIChannelIdle), User::Panic(_L("CPIChannel"), EPIPanicChannelConnected));

	// Open a socket

	if(KErrNone != iPiSocket.Open(iSockServ, KAfInet, KSockStream, KProtocolInetTcp))

		// Socket could not be openned, bail out

		return FALSE;

	// Give CPISocketRead the ref to my socket

	iReceiver->SetSocket(&iPiSocket);

	// Connect to peer

	iPiSocket.Connect(aNetAddr, iStatus);

	// Update state

	iPIChannelState = EPIChannelConnecting;

	// Activate the object

	SetActive();

	// Everything's OK

	return TRUE;

	}

void CPIChannel::GetLocalAddress(TInetAddr& aLocalAddr)

	{

	// get my local address

	// seems that LocalAddress function does not return

	// the IP address until you've connected to somewhere

	// hence I need this function to be called once the 

	// connect has succeeded to discover my IP address

	iPiSocket.LocalName(aLocalAddr);

	}

TBool CPIChannel::Busy(void) 

/**

@return The state of DTP Channel

*/

	{

	return(iPIChannelState != EPIChannelConnected);

	}

void CPIChannel::Disconnect(void)

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::Disconnect called\n"));

	//Close PI socket

	iReceiver->Cancel();

	Cancel();

	iPiSocket.Close();

	iPIChannelState = EPIChannelIdle;

	}

void CPIChannel::SendCommand(TDes8& aCommand,TUint aSomeFlags,TBool aSendCRLF)

	{

	// If I'm not connected just return don't post error

	if(iPIChannelState == EPIChannelIdle)

		{

		FTPPROTDEBUG(_DBGPichnl,_L("!!!!!Not Connected - SendCommand not triggered\n"));

		return;

		}

	//__ASSERT_DEBUG(iPIChannelState != EPIChannelIdle, User::Panic(_L("CPIChannel"), EPIPanicChannelNotConnected));

	// Update the state

	iPIChannelState = EPIChannelSending;

	// Add the Telnet terminator sequence

	// BIG BIG assumption here !! the buffer is big enough

	// but FtpProtocol is my friend I trust it

	if(aSendCRLF)

		{

		aCommand.Append(CR);

		aCommand.Append(LF);

		}

	// Send the command

	iPiSocket.Send(aCommand,aSomeFlags,iStatus);

	// Activate the object

	SetActive();

	}

void CPIChannel::GetNextAnswer(TDes8&	aBuffer)

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::GetNextAnswer called\n"));

	if(iPIChannelState != EPIChannelIdle)

		// Fetch the reply sent by the server

		iReceiver->IssueRead(aBuffer);

	}

void CPIChannel::DoCancel(void)

	{

	FTPPROTDEBUG(_DBGPichnl,_L("CPIChannel::DoCancel called\n"));

	iReceiver->Cancel();

	switch(iPIChannelState)

		{

		case EPIChannelConnecting:

			iPiSocket.CancelConnect();

			iPiSocket.Close();

			iPIChannelState = EPIChannelIdle;

			break;

		default:

			break;

		}

	}