diff -r 7fdc9a71d314 -r 8ad140f3dd41 hti/PC_Tools/HTIGateway/ServicePlugins/HtiFtp/HtiFtp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hti/PC_Tools/HTIGateway/ServicePlugins/HtiFtp/HtiFtp.cpp	Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,790 @@
+/*
+* 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();
+			BYTE* body = (BYTE*)(handler->ReceivedHtiMessageBody());
+
+			if ( bodySize == 5 && body[0] == CMD_FTP_FILESIZE )
+			{
+				fileSize = *((DWORD*)(body + 1));
+			}
+			else
+			{
+				soap->error = soap_receiver_fault(soap,
+												"Received invalid hti message", NULL);
+				return SOAP_FAULT;
+			}
+		}
+		else
+		{
+			handler->SendSoapFaultFromReceivedHtiError();
+			return SOAP_FAULT;
+		}
+	}
+	else
+	{
+		soap->error = soap_receiver_fault(soap,
+										  "Failed receive hti message", NULL);
+		return SOAP_FAULT;
+	}
+	
+	//receive data messages
+	DWORD receivedFile = 0;
+	char* body = (char*)soap_malloc(soap, fileSize );
+
+	while ( receivedFile < fileSize )
+	{
+		if (handler->WaitForHtiMessage(g_ftpHtiTimeoutData) )
+		{
+			if ( !handler->IsReceivedHtiError() )
+			{
+				//extract response
+				DWORD bodySize = handler->ReceivedHtiMessageBodySize();
+				memcpy( body + receivedFile,
+					   (char*)(handler->ReceivedHtiMessageBody()),
+					   bodySize );
+				receivedFile += bodySize;
+			}
+			else
+			{
+				handler->SendSoapFaultFromReceivedHtiError();
+				return SOAP_FAULT;
+			}
+		}
+		else
+		{
+			soap->error = soap_receiver_fault(soap,
+											"Failed receive hti message", NULL);
+			return SOAP_FAULT;
+		}
+	}
+
+	//create attachment
+	int pLen = (int)wcslen(filePath)+1;
+	r._return.href = (char*)soap_malloc(soap, pLen );
+	WideCharToMultiByte(CP_ACP, 0, filePath, -1, r._return.href, pLen, NULL, NULL);
+
+	r._return.mimeType = (char*)soap_malloc(soap, strlen(fileMimeType)+1 );
+	strcpy( r._return.mimeType, fileMimeType );
+
+	//pass result as DIME attachment
+	soap_set_dime(soap);
+	resultCode = soap_set_dime_attachment(soap,
+								body,
+								fileSize,
+								r._return.mimeType,
+								r._return.href,
+								0, NULL);
+	if (  resultCode != SOAP_OK )
+	{
+		//Util::Debug("soap_set_dime_attachment failed");
+		soap_clr_dime(soap);
+		soap->error = soap_receiver_fault(soap,
+								"Failed create DIME attachment", NULL);
+	}
+	
+	return resultCode;
+}
+
+int ns1__cancelFileTransfer(struct soap* soap,
+							void *_,
+							struct ns1__cancelFileTransferResponse *out)
+{
+	int resultCode = sendHtiMessage( soap, CMD_FTP_CANCEL, NULL );
+	if ( resultCode != SOAP_OK )
+	{
+		return resultCode;
+	}
+	
+	return receiveFtpOk(soap, g_ftpHtiTimeoutControl);
+}
+
+int ns1__listFiles(struct soap* soap,
+				   wchar_t *targetDir,
+				   struct ArrayOfStrings &dirs)
+{
+	return sendHtiMessageAndReceiveStringArray( soap, CMD_FTP_LIST, targetDir, dirs );
+}
+
+int ns1__listFilesSizes(struct soap* soap,
+                        wchar_t *targetDir,
+                        struct ArrayOfHtiFileInfos &fileInfos)
+{
+    return sendHtiMessageAndReceiveHtiFileInfoArray( soap, CMD_FTP_LISTSIZE,
+                                                     targetDir, fileInfos );
+}
+
+int ns1__listDirs(struct soap* soap,
+				  wchar_t *targetDir,
+				  struct ArrayOfStrings &files)
+{
+	return sendHtiMessageAndReceiveStringArray( soap, CMD_FTP_LISTDIR, targetDir, files );
+}
+
+int ns1__createDir(struct soap* soap,
+				   wchar_t *targetDir,
+				   struct ns1__createDirResponse *out)
+{
+	return sendHtiMessageAndReceiveOK( soap, CMD_FTP_MKD, targetDir );
+}
+
+int ns1__deleteDir(struct soap* soap,
+				   wchar_t *targetDir,
+				   struct ns1__deleteDirResponse *out)
+{
+	return sendHtiMessageAndReceiveOK( soap, CMD_FTP_RMD, targetDir );
+}
+
+int ns1__deleteFile(struct soap* soap,
+					wchar_t *targetFile,
+					struct ns1__deleteFileResponse *out)
+{
+	return sendHtiMessageAndReceiveOK( soap, CMD_FTP_DELE, targetFile );
+}
+
+
+int send_receive_htimessage(struct soap* soap, BYTE **msgBody, int &msgBodyLen, int timeout)
+{
+	// Send the message to symbian side
+	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);
+	handler->SendHtiMessage(HTI_UID, *msgBody, msgBodyLen, CONTROL_PRIORITY);
+
+	// Clean these up for received HTI message
+	delete *msgBody;
+	*msgBody = NULL;
+	msgBodyLen = 0;
+
+	// ...and wait for OK or error msg
+	if (handler->WaitForHtiMessage(timeout))
+	{
+		if ( !handler->IsReceivedHtiError() )
+		{
+			// Get received message
+			*msgBody = (BYTE*) handler->ReceivedHtiMessageBody();
+			msgBodyLen = handler->ReceivedHtiMessageBodySize();
+			return ERROR_SUCCESS;
+		}
+		else
+		{
+			handler->SendSoapFaultFromReceivedHtiError();
+			return ERROR_GEN_FAILURE;
+		}
+	}
+	// ...or timeout
+	else
+	{
+		soap->error = soap_receiver_fault(soap, "HtiGateway", "No response from symbian side");
+		return WAIT_TIMEOUT;
+	}
+}
+
+int ns1__setForcedOperations(struct soap* soap,
+							 bool state, 
+                             struct ns1__setForcedOperationsResponse *out)
+{
+	int msgBodyLen = 1+1;
+	BYTE *msgBody = new BYTE[msgBodyLen];
+	msgBody[0] = CMD_FTP_SETFORCE;
+	msgBody[1] = (BYTE) state;
+
+	if( send_receive_htimessage(soap, &msgBody, msgBodyLen, g_ftpHtiTimeoutControl) 
+        != ERROR_SUCCESS )
+		return SOAP_FAULT;
+
+	if(msgBody[0] != CMD_FTP_OK)
+	{
+		soap->error = soap_receiver_fault(soap, "HtiError", "Operation failed. Response code not ok.");
+		return SOAP_FAULT;
+	}
+
+	return SOAP_OK;
+}
+
+int ns1__fileChecksum(struct soap* soap, 
+					  unsigned char algorithmId, 
+					  wchar_t *targetFile, 
+                      struct ArrayOfBytes &checksumByteArray)
+{
+	int targetFileLen = targetFile ? (int) wcslen(targetFile) : 0;
+	if(targetFileLen == 0)
+	{
+		soap->error = soap_receiver_fault(soap, "HtiGateway", "targetFile parameter missing");
+		return SOAP_FAULT;
+	}
+
+	int msgBodyLen = 1+1+1+targetFileLen*2;
+	BYTE *msgBody = new BYTE[msgBodyLen];
+	msgBody[0] = CMD_FTP_CHECKSUM_U;
+	msgBody[1] = algorithmId;
+	msgBody[2] = targetFileLen;
+	memcpy(msgBody+3, targetFile, targetFileLen*2);
+
+	if( send_receive_htimessage(soap, &msgBody, msgBodyLen, g_ftpHtiTimeoutControl) 
+        != ERROR_SUCCESS )
+		return SOAP_FAULT;
+
+	checksumByteArray.__size = msgBodyLen;
+	checksumByteArray.__ptr = (BYTE*)soap_malloc(soap, sizeof(BYTE)*checksumByteArray.__size );
+
+	memcpy(checksumByteArray.__ptr, msgBody, msgBodyLen);
+
+	return SOAP_OK;
+}
+
+int ns1__format(struct soap* soap,
+				unsigned char drive, 
+                unsigned char formatMode,
+                struct ns1__formatResponse *out)
+{
+	int msgBodyLen = 3;
+	BYTE *msgBody = new BYTE[msgBodyLen];
+	msgBody[0] = CMD_FTP_FORMAT;
+	msgBody[1] = (BYTE) drive;
+    msgBody[2] = (BYTE) formatMode;
+
+    // might take long with large memory cards
+	if( send_receive_htimessage(soap, &msgBody, msgBodyLen, g_ftpHtiTimeoutData) 
+        != ERROR_SUCCESS )
+		return SOAP_FAULT;
+
+	if(msgBody[0] != CMD_FTP_OK)
+	{
+		soap->error = soap_receiver_fault(soap, "HtiError", "Operation failed. Response code not ok.");
+		return SOAP_FAULT;
+	}
+
+	return SOAP_OK;
+}
+
+int ns1__listDrives(struct soap* soap,
+                    void *_,
+                    struct ArrayOfHtiDriveInfos &driveInfos)
+{
+    return sendHtiMessageAndReceiveHtiDriveInfoArray( soap, CMD_FTP_LISTDRIVES,
+                                                     driveInfos );
+}
+