/*

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

*/

#include "HtiFtpH.h"

#include "HtiPlugin.h"

#include <string.h>

#include "HtiSoapHandlerInterface.h"

const unsigned char CMD_FTP_STOR	    = 0x03;

const unsigned char CMD_FTP_RETR	    = 0x05;

const unsigned char CMD_FTP_LIST	    = 0x07;

const unsigned char CMD_FTP_LISTDIR	    = 0x11;

const unsigned char CMD_FTP_LISTSIZE    = 0x13;

const unsigned char CMD_FTP_LISTDRIVES  = 0x15;

const unsigned char CMD_FTP_MKD		    = 0x09;

const unsigned char CMD_FTP_RMD	    	= 0x0B;

const unsigned char CMD_FTP_DELE	    = 0x0D;

const unsigned char CMD_FTP_CANCEL	    = 0x0E;

const unsigned char CMD_FTP_FILESIZE    = 0x0F;

const unsigned char CMD_FTP_SETFORCE	= 0x20;

const unsigned char CMD_FTP_CHECKSUM	= 0x30;

const unsigned char CMD_FTP_CHECKSUM_U	= 0x31;

const unsigned char CMD_FTP_FORMAT      = 0x40;

const unsigned char CMD_FTP_OK		= 0xF0;

const unsigned char CONTROL_PRIORITY = 2;

const int MAX_HTI_MSG_SIZE = 8192;

char fileMimeType[] = "application/octet-stream"; //??

const static int g_ftpHtiTimeoutControl = 10000;

const static int g_ftpHtiTimeoutData = 60*60000;

int sendHtiMessage(struct soap *soap,

				   const char cmd,

				   const wchar_t* arg )

{

	int resultCode = SOAP_OK;

	int textLen = 0;

	int bodyLen = 0;

	if ( arg )

	{

		textLen = (int)wcslen( arg );

		if ( textLen > 0xFF )

		{

			soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

			resultCode = SOAP_FAULT;

			return resultCode;

		}

		bodyLen = 2*textLen + 2;

	}

	else

	{

        bodyLen = 1;

	}

	BYTE* msgBody = new BYTE[ bodyLen ];

	msgBody[0] = cmd;

	if ( arg )

	{

		msgBody[1] = textLen;

		memcpy( msgBody + 2, arg, 2*textLen );

	}

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	handler->SendHtiMessage(HTI_UID, msgBody, bodyLen, CONTROL_PRIORITY );

	delete[] msgBody;

	return resultCode;

}

int receiveFtpOk( struct soap *soap, DWORD waitTimeout )

{

	int resultCode = SOAP_OK;

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	if ( handler->WaitForHtiMessage( waitTimeout ) )

	{

		if ( !handler->IsReceivedHtiError() )

		{

			DWORD bodySize = handler->ReceivedHtiMessageBodySize();

			BYTE* body = (BYTE*)(handler->ReceivedHtiMessageBody());

			if ( ! ( bodySize == 1 && body[0] == CMD_FTP_OK ) )

			{

				soap->error = soap_receiver_fault(soap,

												"Received invalid hti message", NULL);

				resultCode = SOAP_FAULT;

			}

		}

		else

		{

			handler->SendSoapFaultFromReceivedHtiError();

			resultCode = SOAP_FAULT;

		}

	}

	else

	{

		soap->error = soap_receiver_fault(soap,

										  "Failed receive hti message", NULL);

		resultCode = SOAP_FAULT;

	}

	return resultCode;

}

int sendHtiMessageAndReceiveOK(struct soap *soap,

							   const char cmd,

							   const wchar_t* arg )

{

	if ( arg == NULL )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	int resultCode = sendHtiMessage( soap, cmd, arg );

	if ( resultCode != SOAP_OK )

	{

		return resultCode;

	}

	return receiveFtpOk(soap, g_ftpHtiTimeoutControl);

}

int sendHtiMessageAndReceiveStringArray(struct soap *soap,

										const char cmd,

										const wchar_t* arg,

										struct ArrayOfStrings &array )

{

	if ( arg == NULL )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	int resultCode = SOAP_OK;

	resultCode = sendHtiMessage( soap, cmd, arg );

	if ( resultCode != SOAP_OK )

	{

		return resultCode;

	}

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	if (handler->WaitForHtiMessage(g_ftpHtiTimeoutData) )

	{

		if ( !handler->IsReceivedHtiError() )

		{

            DWORD bodySize = handler->ReceivedHtiMessageBodySize();

			BYTE* body = (BYTE*)(handler->ReceivedHtiMessageBody());

			//check that body size is valid

			if ( bodySize > 0 )

			{

				//calculate number of elements

				DWORD i = 0;

				int numOfElements = 0;

				while ( i < bodySize )

				{

                    ++numOfElements;

					i += 2*body[i] + 1;

				}

				//printf("strings: %d\n", numOfElements);

				if ( i != bodySize )

				{

					soap->error = soap_receiver_fault(soap,

													"Invalid hti message", NULL);

					resultCode = SOAP_FAULT;

				}

				else

				{

					array.__size = numOfElements;

					array.__ptr = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*)*array.__size );

					int j;

					for( j=0, i=0; j<array.__size; ++j, i += 2*body[i] + 1)

					{

						//printf("%d size=%d ", j, body[i]);

						array.__ptr[j] = (wchar_t*)soap_malloc(soap, 2*body[i] + 2 );

						memcpy(array.__ptr[j],

								body + i + 1,

								2*body[i] );

						(array.__ptr[j])[body[i]] = 0; //null char

						int strLen = (int)wcslen( array.__ptr[j] );

						//wprintf(L">%S<\n", array.__ptr[j] );

						//printf("\n");

					}

				}

			}

			else

			{

				array.__size = 0;

				array.__ptr = 0;

			}

		}

		else

		{

			handler->SendSoapFaultFromReceivedHtiError();

			resultCode = SOAP_FAULT;

		}

	}

	else

	{

		soap->error = soap_receiver_fault(soap,

										  "Failed receive hti message", NULL);

		resultCode = SOAP_FAULT;

	}

	return resultCode;

}

int sendHtiMessageAndReceiveHtiFileInfoArray(struct soap *soap,

										const char cmd,

										const wchar_t* arg,

										struct ArrayOfHtiFileInfos &array )

{

	if ( arg == NULL )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	int resultCode = SOAP_OK;

	resultCode = sendHtiMessage( soap, cmd, arg );

	if ( resultCode != SOAP_OK )

	{

		return resultCode;

	}

	HtiSoapHandlerInterface* handler =

        static_cast<HtiSoapHandlerInterface*>(soap->user);

	if (handler->WaitForHtiMessage(g_ftpHtiTimeoutData) )

	{

		if ( !handler->IsReceivedHtiError() )

		{

            DWORD bodySize = handler->ReceivedHtiMessageBodySize();

			BYTE* body = (BYTE*)(handler->ReceivedHtiMessageBody());

			//check that body size is valid

			if ( bodySize > 0 )

			{

				//calculate number of elements

				DWORD i = 0;

				int numOfElements = 0;

				while ( i < bodySize )

				{

                    ++numOfElements;

					i += 2*body[i] + 1 + 4;

				}

                if ( i != bodySize )

				{

					soap->error = soap_receiver_fault(soap,

											"Invalid hti message", NULL);

					resultCode = SOAP_FAULT;

				}

				else

				{

					array.__size = numOfElements;

					array.__ptr = (ns1__HtiFileInfo*) soap_malloc(

                            soap, sizeof(ns1__HtiFileInfo)*array.__size );

					int j;

					for( j=0, i=0; j<array.__size; ++j, i += 2*body[i] + 1 + 4)

					{

						array.__ptr[j].fileName =

                            (wchar_t*)soap_malloc(soap, 2*body[i] + 2 );

						memcpy(array.__ptr[j].fileName, body + i + 1, 2*body[i]);

                        (array.__ptr[j].fileName)[body[i]] = 0; //null char

                        // the file size bytes

                        array.__ptr[j].fileSize = *(int*)(body + i + 2*body[i] + 1);

                    }

                }

            }

			else

			{

				array.__size = 0;

				array.__ptr = 0;

			}

		}

		else

		{

			handler->SendSoapFaultFromReceivedHtiError();

			resultCode = SOAP_FAULT;

		}

	}

	else

	{

		soap->error = soap_receiver_fault(soap,

										  "Failed receive hti message", NULL);

		resultCode = SOAP_FAULT;

	}

    return resultCode;

}

int sendHtiMessageAndReceiveHtiDriveInfoArray(struct soap *soap,

                                        const char cmd,

                                        struct ArrayOfHtiDriveInfos &array )

{

	int resultCode = SOAP_OK;

	resultCode = sendHtiMessage( soap, cmd, NULL );

	if ( resultCode != SOAP_OK )

	{

		return resultCode;

	}

	HtiSoapHandlerInterface* handler =

        static_cast<HtiSoapHandlerInterface*>(soap->user);

	if (handler->WaitForHtiMessage(g_ftpHtiTimeoutData) )

	{

		if (!handler->IsReceivedHtiError())

		{

			array.__size = 0;

			array.__ptr = 0;

            DWORD bodySize = handler->ReceivedHtiMessageBodySize();

			BYTE* body = (BYTE*)(handler->ReceivedHtiMessageBody());

            int offset = 0;

			//first byte is the number of elements

			int numOfElements = body[offset];

            offset++;

            array.__size = numOfElements;

			array.__ptr = (ns1__HtiDriveInfo*) soap_malloc(

                    soap, sizeof(ns1__HtiDriveInfo)*array.__size );

			int i;

			for(i=0; i<array.__size; ++i)

			{

                int rootPathLength = body[offset];

                offset++;

				array.__ptr[i].rootPath =

                    (wchar_t*)soap_malloc(soap, 2*rootPathLength + 2);

				memcpy(array.__ptr[i].rootPath, body + offset, 2*rootPathLength);

                (array.__ptr[i].rootPath)[rootPathLength] = 0; //null char

                offset += 2*rootPathLength;

                array.__ptr[i].mediaType = (ns1__driveMediaType)body[offset];

                offset++;

                array.__ptr[i].uniqueID = *(int*)(body + offset);

                offset += sizeof(int);

                array.__ptr[i].driveSize = *(ULONG64*)(body + offset);

                offset += sizeof(ULONG64);

                array.__ptr[i].freeSpace = *(ULONG64*)(body + offset);

                offset += sizeof(ULONG64);

                int nameLength = body[offset];

                offset++;

                array.__ptr[i].driveName = 

                    (wchar_t*)soap_malloc(soap, 2*nameLength + 2);

                memcpy(array.__ptr[i].driveName, body + offset, 2*nameLength);

                (array.__ptr[i].driveName)[nameLength] = 0; //null char

                offset += 2*nameLength;

            }

		}

		else

		{

			handler->SendSoapFaultFromReceivedHtiError();

			resultCode = SOAP_FAULT;

		}

	}

	else

	{

		soap->error = soap_receiver_fault(soap,

										  "Failed receive hti message", NULL);

		resultCode = SOAP_FAULT;

	}

    return resultCode;

}

int sendBinary(struct soap *soap, char* data, const DWORD dataSize )

{

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	DWORD offset = 0;

    // dataSize == 0 means that uploading empty file - we need to send one

    // empty data message, so needs to go to following while once

	while( offset < dataSize || ( offset == 0 && dataSize == 0 ) )

	{

		handler->SendHtiMessage( HTI_UID,

					data + offset,

					offset + MAX_HTI_MSG_SIZE > dataSize ? dataSize - offset : MAX_HTI_MSG_SIZE

					);

		offset += MAX_HTI_MSG_SIZE;

		//check for error messages

		if (handler->WaitForHtiMessage(0) ) 

		{

			if ( handler->IsReceivedHtiError() )

			{

				handler->SendSoapFaultFromReceivedHtiError();

			}

			else

			{

				soap->error = soap_receiver_fault(soap,

												"Not expected hti message", NULL);

			}

			return SOAP_FAULT;

		}

	}

	return SOAP_OK;

}

int sendSTOR(struct soap *soap,

             const wchar_t* arg,

			 const DWORD fileSize )

{

	int resultCode = SOAP_OK;

	int textLen = (int)wcslen( arg );

	if ( !arg || textLen > 0xFF )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		resultCode = SOAP_FAULT;

		return resultCode;

	}

	int	bodyLen = 2*textLen + 6;

	BYTE* msgBody = new BYTE[ bodyLen ];

	msgBody[0] = CMD_FTP_STOR;

	*((DWORD*)(msgBody + 1)) = fileSize;

	msgBody[5] = textLen;

	memcpy( msgBody + 6, arg, 2*textLen );

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	handler->SendHtiMessage(HTI_UID, msgBody, bodyLen, CONTROL_PRIORITY );

	delete[] msgBody;

	return resultCode;

}

int ns1__putFile(struct soap* soap,

				 struct ns1__HtiSoapAttachment *file,

				 wchar_t *targetPath,

				 struct ns1__putFileResponse *out)

{

	int resultCode;

	//send attachment as several hti ftp data messages

	if ( file == NULL || targetPath == NULL )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	else if ( file->href != NULL )

	{

		for (soap_multipart::iterator attachment = (*soap).dime.begin();

				attachment != (*soap).dime.end(); ++attachment) 

		{

			if ( (*attachment).id && strcmp((*attachment).id, file->href)==0 )

			{

				resultCode = sendSTOR(soap, targetPath, (*attachment).size );

				if ( resultCode != SOAP_OK )

				{

					return resultCode;

				}

				resultCode = receiveFtpOk(soap, g_ftpHtiTimeoutControl);

				if ( resultCode != SOAP_OK )

				{

					return resultCode;

				}

				resultCode = sendBinary( soap, (*attachment).ptr, (*attachment).size );

				if ( resultCode != SOAP_OK )

				{

					return resultCode;

				}

				return receiveFtpOk(soap, g_ftpHtiTimeoutData); 

			}

		} 

	}

	else

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	soap->error = soap_sender_fault(soap, "Invalid attachment", NULL);

	resultCode = SOAP_FAULT;

	return resultCode;

}

int ns1__getFile(struct soap* soap,

				 wchar_t *filePath,

				 struct ns1__getFileResponse &r)

{

	int resultCode = SOAP_OK;

	if ( filePath == NULL )

	{

		soap->error = soap_sender_fault(soap, "Invalid arguments", NULL);

		return SOAP_FAULT;

	}

	resultCode = sendHtiMessage( soap, CMD_FTP_RETR, filePath );

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

    //receive FILESIZE message

	DWORD fileSize = 0;

	if (handler->WaitForHtiMessage(g_ftpHtiTimeoutControl) )

	{

		if ( !handler->IsReceivedHtiError() )

		{

			DWORD bodySize = handler->ReceivedHtiMessageBodySize();