// 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:

// EPOC32 FTP Engine header file

// Author:	Philippe Gabriel

// Implements set of APIs simplyfying access to the FTP protocol

// 

//

/**

 @file FTPSESS.CPP

 @internalComponent

*/

#include <e32test.h>

#include "SESSION.H"

#include "DEBUG.H"

//

//					Minterface Implementation

//

void CFTPSessionDerived::SetErrorNotifier(const TInt aError)

/**

Define the CFTPSetError callback notifier

*/

{

	switch(aError)

		{

		case MFtpSessionNotifier::ESocketError:

			iFtpSessionNotifier->ConnectionError((MFtpSessionNotifier::TOpComp)aError);

			ErrorTransition(MFtpProtocolNotifier::EOpConnectionFailed);

			break;

		case MFtpSessionNotifier::EAlreadyConnected:

		case MFtpSessionNotifier::ENotConnected:

			iFtpSessionNotifier->ConnectionError((MFtpSessionNotifier::TOpComp)aError);

			//No state transition in this case

			break;

		case MFtpSessionNotifier::EFileSystemError:

		case MFtpSessionNotifier::EFileOpenFailure:

		case MFtpSessionNotifier::EFileReadError:

		case MFtpSessionNotifier::EFileWriteError:

		case MFtpSessionNotifier::EFileAlreadyExist:

		case MFtpSessionNotifier::EFileNotExist:

		case MFtpSessionNotifier::EDirAlreadyExist:

		case MFtpSessionNotifier::EDirNotExist:

			iFtpSessionNotifier->LocalFileSystemError((MFtpSessionNotifier::TOpComp)aError);

			ErrorTransition(MFtpProtocolNotifier::EOpFailed);

			break;

		case MFtpSessionNotifier::EOpCanceled:

			iFtpSessionNotifier->Cancel();

			ErrorTransition(MFtpProtocolNotifier::EOpCanceled);

			break;

		default:

			// I forgot something

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

			break;

		}

}

void CFTPSessionDerived::ErrorNotification(const TOpComp aStatus)

{

	switch(aStatus)

		{

		case MFtpProtocolNotifier::EOpConnectionReset:

			// Total mayhem, irrecoverable

			// We got a TCP RST

			// Notify upper layer

			iFtpSessionNotifier->ConnReset();

			break;

		case MFtpProtocolNotifier::EOpConnectionFailed:

			__ASSERT_DEBUG(iState == EConnecting, User::Panic(_L("CFTPSessionDerived::ErrorNotification"), 0));

			iFtpSessionNotifier->ConnectionError(MFtpSessionNotifier::EConnectionFailed);

			break;

		case MFtpProtocolNotifier::EXferReset:

			__ASSERT_DEBUG((iState == EPerformingList)

						||(iState == ERetrieveFile)

						||(iState == EStoreFile)

						||(iState == EStoreFileSendEOF),

						User::Panic(_L("CFTPSessionDerived::ErrorNotification"), 0));

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::ERemoteFileSystemError);

			break;

		case MFtpProtocolNotifier::EXferNotInitialised:

			__ASSERT_DEBUG((iState == EPerformingList)

						||(iState == ERetrieveFile)

						||(iState == EStoreFile)

						||(iState == EStoreFileSendEOF),

						User::Panic(_L("CFTPSessionDerived::ServerNegativeAnswerNotification"), 0));

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::ERemoteFileOpenFailure);

			break;

		case MFtpProtocolNotifier::EHostNotFound:

			iFtpSessionNotifier->ConnectionError(MFtpSessionNotifier::EHostNotExist);

			break;

		case MFtpProtocolNotifier::EOpCanceled:

			iFtpSessionNotifier->Cancel();

			break;

		default:

			// I forgot something

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

			iFtpSessionNotifier->EUnknownError();

			break;

		}

		ErrorTransition(aStatus);

}

void CFTPSessionDerived::ServerMessage(const TDesC8& aMessage)

{

	iFtpSessionNotifier->ServerMessage(aMessage);

}

void CFTPSessionDerived::ServerNegativeAnswerNotification(const TOpComp /*aStatus*/)

{

	// Fetch the answer

	iCFtpProtocol->FTPServerAnswer(iServerAnswer);

	// Have to discriminate on the answer to send back a meaningfull error

	// fetch a Lex object

	TLex input(iServerAnswer);

	TUint uintServerAnswer;

	// Convert 

	input.Val(uintServerAnswer,EDecimal);

	FTPPROTDEBUG1(_DBGFtpsess,_L("CFTPSessionDerived::ServerNegativeAnswerNotification Server converted answer:<%u>\n"),uintServerAnswer);

	// Check the answer is within bounds

	if ((uintServerAnswer<(TUint)100) || (uintServerAnswer>(TUint)599))

		{

		FTPPROTDEBUG2(0xffff,_L("!!!!!!!!!!!!!CFTPSessionDerived::ServerNegativeAnswerNotification Server answer:<%d> is out of bound\n"),iServerAnswer);

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

		// Set it to a generic failure code

		uintServerAnswer = 599;

		}

	// Check this is really an error

	__ASSERT_DEBUG(uintServerAnswer>199, User::Panic(_L("CFTPSessionDerived::ServerNegativeAnswerNotification"), 0));

	// Unfortunately servers do not seem to follow the RFC recommendation very well

	// And the list of messages in RFC959 p40-42 is not reliable.

	// All we can do is best guess, anything more appropriate need the user

	// to read the text meesage sent back by the server

	switch(iState)

		{

		// Intermediate State

		case EConnecting:

			// Assume server unreachable

			iFtpSessionNotifier->ConnectionError(MFtpSessionNotifier::EConnectionFailed);

			break;

		case ELoginUser:

		case ELoginPass:

			// Assume login,pass invalid

			iFtpSessionNotifier->ConnectionError(MFtpSessionNotifier::ELoginFailed);

			break;

		case ERenameFileFrom:

		case ERenameFileTo:

			// file not found or no access

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::EPermissionDenied);

			break;

		case EPerformingPortForList:

		case EPerformingPasvForList:

		case EPerformingPortForRetrieve:

		case EPerformingPasvForRetrieve:

		case EPerformingPasvForStore:

		case EPerformingPortForStore:

			// What kind of error could we have following a port?

			iFtpSessionNotifier->EUnknownError();

			break;

		case EPerformingRestForRetrieve:

			// file not found or no access

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::ERestartNotSupported);

			break;

		// Semi-Intermediate states

		case EPerformingList:

		case ERetrieveFile:

		case EStoreFile:

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::ERemoteFileSystemError);

			break;

		// Final States, call back notifier

		case EConnected:

			// Assume timeout

			iFtpSessionNotifier->ConnectionError(MFtpSessionNotifier::ETimedOut);

			break;

		case EStoreFileSendEOF:

		case EGetCurrentDirectory:

		case EChangeDirectory:

		case ECreateDirectory:

		case EDeleteDirectory:

		case EDeleteFile:

			iFtpSessionNotifier->RemoteFileSystemError(MFtpSessionNotifier::EPermissionDenied);

			break;

		case EClosing:

			// What kind of error could we have here?

			iFtpSessionNotifier->EUnknownError();

			break;

		default:

			// Invalid state

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

			break;

		}

	ErrorTransition(MFtpProtocolNotifier::EOpFailed);

}

void CFTPSessionDerived::ServerXFerNotification(const TOpComp /*aStatus*/)

{

FTPPROTDEBUG(_DBGFtpsess,_L("CFTPSessionDerived::ServerXFerNotification called - State:"));

TDes8& currentBuf = iFileXferBuffer[iCurrentXferBuffer];

iCurrentXferBuffer = !iCurrentXferBuffer; //swap buffers;

	switch(iState)

		{

		// Semi-Intermediate states

		case EPerformingList:

			FTPPROTDEBUG(_DBGFtpsess,_L("EPerformingList \n"));

			iFtpSessionNotifier->MoreData();

			break;

		case ERetrieveFile:

			FTPPROTDEBUG(_DBGFtpsess,_L("ERetrieveFile \n"));

			// Reissue the read request

 			iCFtpProtocol->RecvBuffer(&iFileXferBuffer[iCurrentXferBuffer]);

			// Save packet in the open file

			if(iFileOpErrorOccured || (KErrNone != iFile.Write(currentBuf)))

				{

				// Notify error

				if(!iFileOpErrorOccured)

					//1st time, notify

					iFtpSessionNotifier->LocalFileSystemError(MFtpSessionNotifier::EFileWriteError);

				iFileOpErrorOccured = TRUE;

			//	__ASSERT_DEBUG(fileOpReturn==KErrNone, User::Panic(_L("CFTPSessionDerived::ServerXFerNotification"), 0));

				}

			// Just to be sure

			if(iFileOpErrorOccured || (KErrNone != iFile.Flush()))

				{

				// Notify error

				if(!iFileOpErrorOccured)

					//1st time, notify

					iFtpSessionNotifier->LocalFileSystemError(MFtpSessionNotifier::EFileWriteError);

				iFileOpErrorOccured = TRUE;

			//	__ASSERT_DEBUG(fileOpReturn==KErrNone, User::Panic(_L("CFTPSessionDerived::ServerXFerNotification"), 0));

				}

			// Call the Progress notifier

			iFtpSessionNotifier->TransferProgress(currentBuf.Length());

			break;

		case EStoreFile:

			FTPPROTDEBUG(_DBGFtpsess,_L("EStoreFile \n"));

			// Call the Progress notifier

			if((iFileOpErrorOccured || (currentBuf.Length() == 0)) && !iFirstRun)

 				{

 				// Send an EOF

 				iState = EStoreFileSendEOF;

 				iCFtpProtocol->SendEOF();

 				}

 			else {

 				// Reissue the Send request

 				iCFtpProtocol->SendBuffer(&currentBuf);

 				iFirstRun=EFalse;

			}

			iFtpSessionNotifier->TransferProgress(currentBuf.Length());

			// Construct a packet from the open file

			if(iFileOpErrorOccured || (KErrNone != iFile.Read(iFileXferBuffer[iCurrentXferBuffer])))

				{

				// Notify error

				if(!iFileOpErrorOccured)

					//1st time, notify

					iFtpSessionNotifier->LocalFileSystemError(MFtpSessionNotifier::EFileWriteError);

				iFileOpErrorOccured = ETrue;

				}	

			break;

		case EAbortingStore:

			FTPPROTDEBUG(_DBGFtpsess,_L("EAbortingStore \n"));

			// Shutdown the DTP channel

			iCFtpProtocol->SendEOF();

			break;

		case EAbortingRetrieve:

		case EAbortingList:

			FTPPROTDEBUG(_DBGFtpsess,_L("EAbortingRetrieve - EAbortingList\n"));

			// Reissue the read request to flush the recv buffer

			iCFtpProtocol->RecvBuffer(&currentBuf);

			break;

		default:

			FTPPROTDEBUG(_DBGFtpsess,_L("INVALID \n"));

			// Invalid state

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

			break;

		}

}

void CFTPSessionDerived::ServerPositiveAnswerNotification(const TOpComp /*aStatus*/)

/**

Define the CFtpProtocol callback notifiers

*/

{

	FTPPROTDEBUG(_DBGFtpsess,_L("CFTPSessionDerived::ServerPositiveAnswerNotification called\n"));

	// Fetch the answer

	// PG 200898 Don't need the answer just now, maybe in the future

	// iCFtpProtocol->FTPServerAnswer(iServerAnswer);

	// Just do a normal transition

	NormalTransition();

}

//

//							State Transition functions

//

void CFTPSessionDerived::NormalTransition(void)

/**

NormalTransition

Called when an operation has been positively acknowledged

and we progress to the next operation

No input parameter, only operates on global member data

*/

{

FTPPROTDEBUG(_DBGFtpsess,_L("CFTPSessionDerived::NormalTransition called\n"));

TBool loopAgain;

	do

	{

		// Do Pre State update action

		switch(iState)

			{

			case ERetrieveFile:

			case EStoreFileSendEOF:

				//Finished, replace the old local file with the temp one 

				//and delete the temp file

				if(iTempStore)

				{

                    iTempStore = FALSE;

					if(iFs.Delete(iRenamedLocalFileName)!=KErrNone)

					{

						iCFTPSetError->SetError(MFtpSessionNotifier::EFileSystemError);

						return;

					}	

				}

				iFile.Close();

				break;

			case EPerformingTypeForRetrieve:

			case EPerformingTypeForStore:

				iCurrentRepresentationType = iNewRepresentationType;

				break;

			case EAbortingStore:

			case EAbortingRetrieve:

			case EAbortingList:

				iFtpSessionNotifier->Cancel();

				break;

			case EConnected:

				// We should never get here

				// BUT WE DO, reason is:

				// during xfers, some ftp servers don't ack the abort

				// where we (the client) enter an abort state and wait for the server to

				// send us either

				// 4 (xfer canceled) - 2 (abort ack)

				// or just 2 (abort ack)

				// but some lame servers send us:

				// 2 (xfer finished) - 2 (abort ack)

				// Don't report a completion to the client just bail out

				return;

			default:

				break;

			}

		// Update the state

		iState = UpdateState(iState,MFtpProtocolNotifier::EOpComplete);

		// Do some action according to the new state

		loopAgain = FALSE;

		switch(iState)

			{

			// Intermediate State

			// Don't callback notifier

			case EInitiateListOperation:

			case EInitiateRetrieveOperation:

			case EInitiateStoreOperation:

				// These are just a bunch of dummy states

				// allowing to streamline the code a bit

				loopAgain = TRUE;

				break;

			case ELoginUser:

				iCFtpProtocol->User(iBuffer1);

				break;

			case ELoginPass:

				iCFtpProtocol->Pass(iBuffer2);

				break;

			case ERenameFileTo:

				iCFtpProtocol->Rnto(iBuffer1);

				break;

			case EPerformingTypeForRetrieve:

			case EPerformingTypeForStore:

				if(iNewRepresentationType != iCurrentRepresentationType)

					{

					// New type differs from the old, tell the server to change it

					if(iNewRepresentationType == EASCII)

						iCFtpProtocol->Type(_L8("A"));

					else 

						iCFtpProtocol->Type(_L8("I"));

					break;

					}

				else

					// New type same as the old, do nothing

					loopAgain = TRUE;

				break;

			case EPerformingPasvForList:

			case EPerformingPasvForRetrieve:

			case EPerformingPasvForStore:

				iCFtpProtocol->Pasv();

				break;

			case EPerformingPortForList:

			case EPerformingPortForRetrieve:

			case EPerformingPortForStore:

				iCFtpProtocol->Port();

				break;

			case EPerformingList:

				// Set buffer 

				iCFtpProtocol->RecvBuffer(iFileList);

				iCFtpProtocol->List(iBuffer1);

				break;

			case EPerformingRestForStore:

			case EPerformingRestForRetrieve:

				// Do I really need to send a restart?

				if(iRESTOffset !=0 )

					{

					//Send a REST command

					iBuffer2.Num(iRESTOffset,EDecimal);

					// Reset immediately the RESTOffset

					iRESTOffset = 0;

					iCFtpProtocol->Rest(iBuffer2);

					}

				else

					loopAgain = TRUE;

				break;

			case ERetrieveFile:

				// Set buffer 

				iCFtpProtocol->RecvBuffer(&iFileXferBuffer[iCurrentXferBuffer]);

				iCFtpProtocol->Retr(iBuffer1);

				break;

			case EStoreFile:

				// Set buffer 

				iCFtpProtocol->Stor(iBuffer1);

				// Construct a packet from the open file

				iFileXferBuffer[iCurrentXferBuffer].SetLength(0);

 				iCurrentXferBuffer = !iCurrentXferBuffer;

 				iFile.Read(iFileXferBuffer[iCurrentXferBuffer]);

 				//Don't send yet, just bump the notifier

 				iFirstRun=ETrue;

 				ServerXFerNotification(EOpComplete);

				break;

			// Final States, call back notifier

			case EConnected:

			case EIdle:

				iFtpSessionNotifier->Complete();

				break;

			default:

				// Invalid state

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

				break;

			}

	}while(loopAgain);

}

void CFTPSessionDerived::ErrorTransition(const TOpComp aStatus)

/**

ErrorTransition

Called when an operation has failed

need to do some clearup

and determine what the next state is gonna be

*/

{

	// Close local file

	iFile.Close();

    if ( iTempStore )

    {//rename orig file back iRenamedLocalFileName contains original file name as well

        iTempStore = FALSE;

    	TBuf<256> fileName;

        fileName.Copy( iRenamedLocalFileName.Ptr(), iRenamedLocalFileName.Length() - 1 );

		iFs.Delete( fileName ); //just in case

        iFs.Rename( iRenamedLocalFileName, fileName );

        //should i report a possible error to anyone?

    }

	// Trust the lower layer to cleanup the connection mess

	// just find out what the next state is

	iState = UpdateState(iState,aStatus);

}

CFTPSessionDerived::TState	CFTPSessionDerived::UpdateState(CFTPSessionDerived::TState aState,MFtpProtocolNotifier::TOpComp aStatus)

	{

	CFTPSessionDerived::TState returnValue;

	FTPPROTDEBUG(_DBGFtpsess,_L("CFTPSessionDerived::UpdateState called\n"));

	switch(aStatus)

		{

		case MFtpProtocolNotifier::EOpComplete:

			switch(aState)

				{

				case EConnecting:

					returnValue = ELoginUser;

					break;

				case ELoginUser:

					returnValue = ELoginPass;

					break;

				case ERenameFileFrom:

					returnValue = ERenameFileTo;

					break;

				case 	EInitiateListOperation:

					if(iPASVMode)

						returnValue = EPerformingPasvForList;

					else

						returnValue = EPerformingPortForList;

					break;

				case	EInitiateRetrieveOperation:

					returnValue = EPerformingTypeForRetrieve;

					break;

				case	EInitiateStoreOperation:

					returnValue = EPerformingTypeForStore;

					break;

				case EPerformingTypeForRetrieve:

					if(iPASVMode)

						returnValue = EPerformingPasvForRetrieve;

					else

						returnValue = EPerformingPortForRetrieve;

					break;

				case EPerformingTypeForStore:

					if(iPASVMode)

						returnValue = EPerformingPasvForStore;

					else

						returnValue = EPerformingPortForStore;

					break;

				case EPerformingPortForList: