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

// Entry point in the DLL

// Implements the interface to the FTP protocol

// through FTP commands defined as per RFC 959

// Drives the DTP and PI channels

// 

//

/**

 @file FTPPROT.CPP

 @internalComponent

*/

#include <es_sock.h>

#include <c32comm.h>

#include "DEBUG.H"

#include "PROTOCOL.H"

#include "PICHNL.H"

#include "ANSPARSE.H"

#include "PASVANS.H"

#include "DTPCHNL.H"

#include "SETERROR.H"

//

//					Definitions

//

//

//					Minterface Implementation

//

void CFtpProtocolDerived::PIChannelOperationCompletion(const TPiOperationCompletion aCompletionStatus)

/**

Define the PIChannel callback notifiers

These notifiers are called from PIChannel, but the event source

can be quite different:

PIChannelOperationCompletion, PIChannelOperationError and PIChannelReset

come from an error signaled at the TCP/IP level

where PIChannelRcvNotification is called whenever the server sent us a message

*/

	{

	switch (aCompletionStatus)

		{

		case MPIChannelNotifier::EPiConnectComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("PIChannelNotifierClass::PIChannelOperationCompletion(EPiConnectComplete) called\n"));

			// Get my IP address for future use

			iPiChannel->GetLocalAddress(iLocalAddress);

			// Get welcome message from server 

			iPiChannel->GetNextAnswer(iServerAnswerBuffer);

			UpdateState(EPiChannelConnectComplete);

			break;

		case MPIChannelNotifier::EPiSendComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("PIChannelNotifierClass::PIChannelOperationCompletion(EPiSendComplete) called\n"));

			UpdateState(EPiChannelSendComplete);

			break;

		default:

			FTPPROTDEBUG(_DBGFtpprot,_L("PIChannelNotifierClass::PIChannelOperationCompletion() called\n"));

			break;

		}

	return;

	}

void CFtpProtocolDerived::PIChannelOperationError(const TPiOperationError aErrorStatus)

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("PIChannelNotifier::PIChannelOperationError called\n"));

		//Close DTP Channel

		iDtpChannel->Disconnect();

		//Reset state

		iState = EIdle;

		switch (aErrorStatus)

			{

			case MPIChannelNotifier::EPiConnectionReset:

				//ARGHH this is serious and not recoverable

				// Notify upper layer

				iNotifier->ErrorNotification(MFtpProtocolNotifier::EOpConnectionReset);

				break;

			case MPIChannelNotifier::EPiConnectFailed:

				// Notify upper layer

				iNotifier->ErrorNotification(MFtpProtocolNotifier::EOpConnectionFailed);

				break;

			default:

				break;

			}

	return;

	}

void CFtpProtocolDerived::PIChannelRcvNotification(void)

	{

	// Must call upper level client before issuing another read, otherwise

	// I lose my buffer

	FTPPROTDEBUG(_DBGFtpprot,_L("PIChannelNotifier::PIChannelRcvNotification called\n"));

	// At this point need to parse the incoming buffer to decide if 

	// more data is to be fetched

	// 2 cases

	// - 1 line message

	// - multiline message

	// Parse the buffer 

	// it may contain several answers

	for(;;)

		{

		TBool answer;

		// Parse an answer

		answer = iFTPServerAnswerParser->Parse(iServerAnswerBuffer);

		// If I'm performing a PASV

		// Parse an address

		if(	iState == EPerformingPasv)		

			iFtpPASVAnswerParser->Parse(iServerAnswerBuffer, iRemoteAddress);

		//Passes the server text to upper layer

		iNotifier->ServerMessage(iServerAnswerBuffer.Left(iFTPServerAnswerParser->NChars()));

		// Remove what's already parsed from buffer

		iServerAnswerBuffer.Delete(0,iFTPServerAnswerParser->NChars());

		if(answer)

			{

			// if I parsed an answer succesfully, notify upper layer

			// of answer code

			UpdateState(EFtpCodeReply);

			}

		//If buffer empty, stop parsing

		if(iServerAnswerBuffer.Length()==0)

			break;

		}

	// Fetch next answer, if there's more to come

	// PG 2808 Always fetch next, potential hanging on close bug here

	//if (iState != EPerformingQuit)

		// Get ready to fetch next answer from server 

		iPiChannel->GetNextAnswer(iServerAnswerBuffer);

	return;

	}

void CFtpProtocolDerived::DTPChannelOperationCompletion(const TDtpOperationCompletion aCompletionStatus)

/**

Define the DTPChannel callback notifiers

Notify of normal completion of an operation

*/

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::DTPChannelOperationCompletion called "));

	switch(aCompletionStatus)

		{

		case MDTPChannelNotifier::EDtpAcceptComplete:

		case MDTPChannelNotifier::EDtpConnectComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("Connected \n"));

			switch(iState)

				{

				case EPerformingList:

				case EPerformingNlst:

				case EPerformingRetr:

					iDtpChannel->Recv(*iIOBuffer);

					break;

				case EPerformingStor:

				case EPerformingStou:

					iDtpChannel->Send(*iIOBuffer);

					break;

				}

			break;

		default:

			break;

		}

	}

void CFtpProtocolDerived::DTPChannelOperationError(const TDtpOperationError aErrorStatus)

/**

Notify of error performing an operation

*/

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::DTPChannelOperationError called\n"));

		switch (aErrorStatus)

			{

			case MDTPChannelNotifier::EDtpConnectFailed:

				// 

				iNotifier->ErrorNotification(MFtpProtocolNotifier::EXferNotInitialised);

				break;

			case MDTPChannelNotifier::EDtpRecvAborted:

			case MDTPChannelNotifier::EDtpSendAborted:

				switch(iState)

					{

					// Some bad behaved ftp server (microsoft)

					// reset the DTP connection on abort

					case EPerformingAbor:

						UpdateState(EDtpChannelClosed);

						break;

					default:

						//Close PI Channel

						iPiChannel->Disconnect();

						//Reset state

						iState = EIdle;

						iNotifier->ErrorNotification(MFtpProtocolNotifier::EXferReset);

						break;

					}

				break;

			default:

				// Cannot come here

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

				break;

			}

	return;

	}

void CFtpProtocolDerived::DTPChannelXferNotification(const TDtpOperationCompletion aCompletionStatus)

/**

Notify of reception 

*/

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::DTPChannelRcvNotification called\n"));

	// notify upper layer a packet is ready

	switch(aCompletionStatus)

		{

		case MDTPChannelNotifier::EDtpRcvMoreData:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpRcvMoreData\n"));

			iNotifier->ServerXFerNotification(MFtpProtocolNotifier::EPacketReceived);

			break;

		case MDTPChannelNotifier::EDtpSendEOFComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpSendEOFComplete\n"));

			UpdateState(EDtpChannelClosed);

			break;

		case MDTPChannelNotifier::EDtpRcvComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpRecvEOFComplete\n"));

			UpdateState(EDtpChannelClosed);

			break;

		case MDTPChannelNotifier::EDtpSendComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpSendComplete\n"));

			iNotifier->ServerXFerNotification(MFtpProtocolNotifier::EPacketSent);

			break;

		default:

			FTPPROTDEBUG(_DBGFtpprot,_L("WARNING !!!!! Unrecognised event\n"));

			break;

		}

	}

void CFtpProtocolDerived::FTPResolverNotifier(const TFTPResolverNotificationCode aCompletionStatus)

/**

Resolver callback

*/

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::DFTPResolverNotifier called"));

	__ASSERT_DEBUG(iState == ELookingUp, User::Panic(_L("CFtpProtocolDerived"), EPIPanicMegaOI));

	switch(aCompletionStatus)

		{

		case MFTPResolverNotifier::EDtpLookupComplete:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpLookupComplete\n"));

			iState = EConnecting;

			iResolver->SetAddress(iRemoteAddress);

			Connect(iRemoteAddress);

			break;

		case MFTPResolverNotifier::EDtpLookupFailed:

			FTPPROTDEBUG(_DBGFtpprot,_L("EDtpLookupFailed\n"));

			//

			iNotifier->ErrorNotification(MFtpProtocolNotifier::EHostNotFound);

			iState = EIdle;

			break;

		}

	}

void CFtpProtocolDerived::SetErrorNotifier(const TInt aError)

/**

Define the CFTPSetError callback notifier

*/

{

	switch(aError)

		{

		case MFtpProtocolNotifier::ESocketError:

			iNotifier->ErrorNotification(MFtpProtocolNotifier::ESocketError);

			break;

		case MFtpProtocolNotifier::EOpCanceled:

			iNotifier->ErrorNotification(MFtpProtocolNotifier::EOpCanceled);

			break;

		default:

			__ASSERT_DEBUG(FALSE, User::Panic(_L("CFtpProtocolDerived"), EPIPanicMegaOI));

			break;

		}

}

//

//					FTP Private methods implementation 

//

void CFtpProtocolDerived::UpdateState(const TInternalEvents aEvent)

	{

#if defined(__FTPPROTDEBUG__)

	TBuf<4> debugBuffer;	//Placeholder for the answer I got from the FTP server

#endif

	FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::UpdateState\n"));

	// Do some preprocessing according to the event

	switch(aEvent)

		{

		case EFtpCodeReply:

			// Called when an answer has been parsed 

			FTPPROTDEBUG(_DBGFtpprot,_L("CFtpProtocolDerived::UpdateState called aEvent==EFtpCodeReply\n"));

			// Fetch the answer

			iFTPServerAnswerParser->ServerAnswer(iAnswer);

			//Display the answer for debug purpose

#if defined(__FTPPROTDEBUG__)

			debugBuffer.Copy(iAnswer);

			debugBuffer.Append(0);

			FTPPROTDEBUG(_DBGFtpprot,_L("Parsed server answer: <"));

			FTPPROTDEBUG(_DBGFtpprot,debugBuffer);

			FTPPROTDEBUG(_DBGFtpprot,_L(">\n"));

#endif

			// Check the answer to keep it in the allowed bounds

			if((iAnswer[0]<'1') || (iAnswer[0]>'5'))

				{

				// Answer out of bounds

				FTPPROTDEBUG(0xffff,_L("!!!!!!SERVER ANSWER OUT OF BOUND\n"));

				}

			break;

		default:

			break;

		}

	// Completion callback can only be sent when 

	// - PI Channel has been notified of success for the send operation

	// - An answer has been received and parsed

	// Accordingly, we bail out if any of these conditions is not

	// completed yet

	if (iAnswer.Length()<3)

		{

		FTPPROTDEBUG(_DBGFtpprot,_L("iAnswer.Length()<3\n"));

		return;

		}

	if (iPiChannel->Busy()) 

		{

		FTPPROTDEBUG(_DBGFtpprot,_L("iPiChannel->Busy()) \n"));

		return;

		}

	// Execute the next sequence of operations depending on our current state

	switch(iState)

		{

		// Simple commands as per FSM page 54 of RFC 959

		case EConnecting:

		case EPerformingAllo:

		case EPerformingDele:

		case EPerformingCwd:

		case EPerformingCdup:

		case EPerformingSmnt:

		case EPerformingHelp:

		case EPerformingMode:

		case EPerformingNoop:

		case EPerformingSite:

		case EPerformingPort:

		case EPerformingSyst:

		case EPerformingStat:

		case EPerformingRmd:

		case EPerformingMkd:

		case EPerformingPwd:

		case EPerformingStru:

		case EPerformingType:

			// Only allow a "2" answer

				if (iAnswer[0]=='2')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		case EPerformingQuit:

			// In any case close the PI Channel

			iPiChannel->Disconnect();

			// Only allow a "2" answer

				if (iAnswer[0]=='2')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		case EPerformingAbor:

			// rfc says, I might get a 426

			// then I'll get a 2xx to ack the ABORT

			// Just wait for a "2"

			// Note: Not checking for error here

			// If the server nack my abort, I'll hang and the user has to reset me

				if (iAnswer[0]=='2')

					{

					// Check the DtpChannel has been closed

					if(!iDtpChannel->Closed())

						{

						FTPPROTDEBUG(_DBGFtpprot,_L("!iDtpChannel->Closed()\n"));

						return;

						}

					// Channel closed and 2 answer - notify completion

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

					}

				else if (iAnswer[0]=='4')

					// Assume that if the server acknowledged my abort

					// request with a 4, it has already issued a FIN

					// I just reset the connection, otherwise I might have to 

					// wait for a long time to flush the queud packets

					iDtpChannel->Disconnect();

			break;

		case EPerformingPasv:

			// Only allow a "2" answer, verify we got a valid address to connect to

				if ((iAnswer[0]=='2') && (iFtpPASVAnswerParser->Fetch(iFTPDTPAddress)))

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		// Commands defined as per 1st FSM page 55 of RFC 959

		case EPerformingList:

		case EPerformingNlst:

		case EPerformingRetr:

		case EPerformingStor:

		case EPerformingStou:

		// If We get an error close DTP channel, notify error and bail out

			switch(iAnswer[0])

				{

				case '1':

					// Ignore a 1 answer

					break;

				case '2':

					// Check the DtpChannel has been closed

					if(!iDtpChannel->Closed())

						{

						FTPPROTDEBUG(_DBGFtpprot,_L("!iDtpChannel->Closed()\n"));

						return;

						}

					// Channel closed and 2 answer - notify completion

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

					break;

				case '3':

				case '4':

				case '5':

				default:

					// If something else than 1-5 it really screwed up!!

					iDtpChannel->Disconnect();

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

					break;

				}

			break;

		case EPerformingAppe:

		case EPerformingRein:

		// Not much to do, just ignore any "1" answer

			if (iAnswer[0]=='1')

				break;

			if (iAnswer[0]=='2')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		// rename sequence defined as per 2nd FSM page 55 of RFC 959

		case EPerformingRnfr:

				if (iAnswer[0]=='3')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		case EPerformingRnto:

				if (iAnswer[0]=='2')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		// Rest sequence as defined per FSM page 56 of RFC 959 

		case EPerformingRest:

				if (iAnswer[0]=='3')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		// Login sequence as defined by FSM page 57 of RFC 959 

		case EPerformingUser:

				if ((iAnswer[0]=='3') || 

					(iAnswer[0]=='2')) // Slight divergence from the RFC here, but some servers

					// allow disabling the passwd check and send back a 2 answer at this stage

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		case EPerformingPass:

				if (iAnswer[0]=='2')

					iNotifier->ServerPositiveAnswerNotification(MFtpProtocolNotifier::EOpComplete);

				else

					iNotifier->ServerNegativeAnswerNotification(MFtpProtocolNotifier::EOpFailed);

			break;

		case EIdle:

			// Can't be here in Idle state

			__ASSERT_DEBUG(FALSE, User::Panic(_L("CFtpProtocolDerived"), EPIPanicMegaOI));

			break;

		default:

			// OOps, forgot something

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

		}

	}

//

//					FTP Command interface implementation 

//

void CFtpProtocolDerived::SendBuffer(TDes8* aBuffer)

/**

Set a buffer for reception and initiate reception 

if the dtp channel is connected

*/

	{

	iIOBuffer = aBuffer;

	if(iDtpChannel->Connected())

		{

		iDtpChannel->Send(*iIOBuffer);

		}

	}

void CFtpProtocolDerived::SendEOF(void)

/**

Terminates the connection with the peer to mark the end of transfer.

*/

	{

	FTPPROTDEBUG(_DBGFtpprot,_L("***CFtpProtocolDerived::SendEOF called\n"));

	iDtpChannel->SendEOF();

	}

void CFtpProtocolDerived::RecvBuffer(TDes8* aBuffer)

/**

Set a buffer for reception and initiate reception if the dtp channel is connected.

*/

	{

	iIOBuffer = aBuffer;

	if(iDtpChannel->Connected())

		{

		iDtpChannel->Recv(*iIOBuffer);