Commit: 190e1b19f7b48bbf636b2a0a5e7b71d01929def5 - ffftp (git)

FFFTPのソースコードです。

Commit MetaInfo

• Revision: 190e1b19f7b48bbf636b2a0a5e7b71d01929def5 (tree)
• Zeit: 2011-12-26 21:51:51
• Autor: s_kawamoto <s_kawamoto@user...>
• Commiter: s_kawamoto

Log Message

Add test code for SFTP (still useless).

Ändern Zusammenfassung

• modified: FFFTP_Eng_Release/FFFTP.exe
• modified: Release/FFFTP.exe
• modified: connect.c
• modified: getput.c
• modified: hostman.c
• modified: main.c
• modified: mbswrapper.c
• modified: putty/PUTTY.H
• modified: putty/PuTTY.vc90.vcproj
• modified: putty/PuTTY.vcproj
• modified: putty/Release/PuTTY.dll
• modified: putty/WINDOWS/WINSFTP.C
• add: putty/dllinterface.c
• add: putty/dllinterface.h
• add: putty/iowrapper.c
• add: putty/iowrapper.h
• add: putty/mbswrapper.c
• add: putty/mbswrapper.h
• modified: remote.c
• modified: socket.c
• modified: socketwrapper.c
• modified: socketwrapper.h

Diff

Binary files a/FFFTP_Eng_Release/FFFTP.exe and b/FFFTP_Eng_Release/FFFTP.exe differ

Binary files a/Release/FFFTP.exe and b/Release/FFFTP.exe differ

--- a/connect.c
+++ b/connect.c
@@ -1699,6 +1699,61 @@ static SOCKET DoConnectCrypt(int CryptMode, HOSTDATA* HostData, char *Host, char
 	}
 	else if(CryptMode == CRYPT_SFTP)
 	{
+		// TODO:
+		// テストコード
+		// ログイン成功を確認
+#define strrcmp(_Str1, _Str2) (strcmp(strstr(_Str1, _Str2) ? strstr(_Str1, _Str2) : "", _Str2))
+		size_t r;
+		ContSock = SFTP_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+		SFTP_SetTimeoutCallback(ContSock, SSLTimeoutCallback);
+		while(1)
+		{
+			r = SFTP_recv(ContSock, Reply, 1024, 0);
+			if(r == SOCKET_ERROR)
+				break;
+			if(r <= 0)
+				continue;
+			Reply[r] = '\0';
+			SetTaskMsg("%s", Reply);
+			if(strrcmp(Reply, "psftp> ") == 0)
+				break;
+		}
+		r = SFTP_send(ContSock, "open \"", strlen("open \""), 0);
+		r = SFTP_send(ContSock, Host, strlen(Host), 0);
+		r = SFTP_send(ContSock, "\"\r\n", strlen("\"\r\n"), 0);
+		while(1)
+		{
+			r = SFTP_recv(ContSock, Reply, 1024, 0);
+			if(r == SOCKET_ERROR)
+				break;
+			if(r <= 0)
+				continue;
+			Reply[r] = '\0';
+			SetTaskMsg("%s", Reply);
+			if(strrcmp(Reply, "Store key in cache? (y/n) ") == 0)
+			{
+				r = SFTP_send(ContSock, "n\r\n", strlen("n\r\n"), 0);
+			}
+			if(strrcmp(Reply, "Update cached key? (y/n, Return cancels connection) ") == 0)
+			{
+				r = SFTP_send(ContSock, "\r\n", strlen("\r\n"), 0);
+			}
+			if(strrcmp(Reply, "login as: ") == 0)
+			{
+				r = SFTP_send(ContSock, User, strlen(User), 0);
+				r = SFTP_send(ContSock, "\r\n", strlen("\r\n"), 0);
+			}
+			if(strrcmp(Reply, "password: ") == 0)
+			{
+				r = SFTP_send(ContSock, Pass, strlen(Pass), 0);
+				r = SFTP_send(ContSock, "\r\n", strlen("\r\n"), 0);
+			}
+			if(strrcmp(Reply, "psftp> ") == 0)
+				break;
+			Sleep(1);
+		}
+		SFTP_closesocket(ContSock);
+		ContSock = INVALID_SOCKET;
 	}
 
 	return(ContSock);
@@ -1711,12 +1766,12 @@ static SOCKET DoConnect(HOSTDATA* HostData, char *Host, char *User, char *Pass,
 	SOCKET ContSock;
 	ContSock = INVALID_SOCKET;
 	*CancelCheckWork = NO;
-//	if(*CancelCheckWork == NO && ContSock == INVALID_SOCKET && HostData->UseSFTP == YES)
-//	{
-//		SetTaskMsg(MSGJPN317);
-//		if((ContSock = DoConnectCrypt(CRYPT_SFTP, HostData, Host, User, Pass, Acct, Port, Fwall, SavePass, Security, CancelCheckWork)) != INVALID_SOCKET)
-//			HostData->CryptMode = CRYPT_SFTP;
-//	}
+	if(*CancelCheckWork == NO && ContSock == INVALID_SOCKET && HostData->UseSFTP == YES)
+	{
+		SetTaskMsg(MSGJPN317);
+		if((ContSock = DoConnectCrypt(CRYPT_SFTP, HostData, Host, User, Pass, Acct, Port, Fwall, SavePass, Security, CancelCheckWork)) != INVALID_SOCKET)
+			HostData->CryptMode = CRYPT_SFTP;
+	}
 	if(*CancelCheckWork == NO && ContSock == INVALID_SOCKET && HostData->UseFTPIS == YES)
 	{
 		SetTaskMsg(MSGJPN316);

--- a/getput.c
+++ b/getput.c
@@ -1320,7 +1320,13 @@ int DoDownLoad(SOCKET cSkt, TRANSPACKET *Pkt, int DirList, int *CancelCheckWork)
 					DispTransFileInfo(Pkt, MSGJPN087, FALSE, NO);
 			}
 
-			if(BackgrndMessageProc() == NO)
+			// SFTP対応
+//			if(BackgrndMessageProc() == NO)
+			if(IsSFTPAttached(Pkt->ctrl_skt))
+			{
+				// TODO:
+			}
+			else if(BackgrndMessageProc() == NO)
 			{
 				if(AskPasvMode() != YES)
 					iRetCode = DownLoadNonPassive(Pkt, CancelCheckWork);
@@ -2550,7 +2556,13 @@ static int DoUpLoad(SOCKET cSkt, TRANSPACKET *Pkt)
 				if(Pkt->hWndTrans != NULL)
 					DispTransFileInfo(Pkt, MSGJPN104, TRUE, YES);
 
-				if(BackgrndMessageProc() == NO)
+				// SFTP対応
+//				if(BackgrndMessageProc() == NO)
+				if(IsSFTPAttached(Pkt->ctrl_skt))
+				{
+					// TODO:
+				}
+				else if(BackgrndMessageProc() == NO)
 				{
 					if(AskPasvMode() != YES)
 						iRetCode = UpLoadNonPassive(Pkt);

--- a/hostman.c
+++ b/hostman.c
@@ -2236,13 +2236,18 @@ static INT_PTR CALLBACK CryptSettingProc(HWND hDlg, UINT iMessage, WPARAM wParam
 				SendDlgItemMessage(hDlg, HSET_FTPIS, BM_SETCHECK, BST_UNCHECKED, 0);
 				EnableWindow(GetDlgItem(hDlg, HSET_FTPIS), FALSE);
 			}
-			SendDlgItemMessage(hDlg, HSET_SFTP, BM_SETCHECK, TmpHost.UseSFTP, 0);
-			SendDlgItemMessage(hDlg, HSET_PRIVATE_KEY, WM_SETTEXT, 0, (LPARAM)TmpHost.PrivateKey);
-			// TODO: SFTP対応
-			SendDlgItemMessage(hDlg, HSET_SFTP, BM_SETCHECK, BST_UNCHECKED, 0);
-			EnableWindow(GetDlgItem(hDlg, HSET_SFTP), FALSE);
-			EnableWindow(GetDlgItem(hDlg, PKEY_FILE_BR), FALSE);
-			EnableWindow(GetDlgItem(hDlg, HSET_PRIVATE_KEY), FALSE);
+			if(IsPuTTYLoaded())
+			{
+				SendDlgItemMessage(hDlg, HSET_SFTP, BM_SETCHECK, TmpHost.UseSFTP, 0);
+				SendDlgItemMessage(hDlg, HSET_PRIVATE_KEY, WM_SETTEXT, 0, (LPARAM)TmpHost.PrivateKey);
+			}
+			else
+			{
+				SendDlgItemMessage(hDlg, HSET_SFTP, BM_SETCHECK, BST_UNCHECKED, 0);
+				EnableWindow(GetDlgItem(hDlg, HSET_SFTP), FALSE);
+				EnableWindow(GetDlgItem(hDlg, PKEY_FILE_BR), FALSE);
+				EnableWindow(GetDlgItem(hDlg, HSET_PRIVATE_KEY), FALSE);
+			}
 			return(TRUE);
 
 		case WM_NOTIFY:
@@ -2256,9 +2261,11 @@ static INT_PTR CALLBACK CryptSettingProc(HWND hDlg, UINT iMessage, WPARAM wParam
 						TmpHost.UseFTPES = SendDlgItemMessage(hDlg, HSET_FTPES, BM_GETCHECK, 0, 0);
 						TmpHost.UseFTPIS = SendDlgItemMessage(hDlg, HSET_FTPIS, BM_GETCHECK, 0, 0);
 					}
-					// TODO: SFTP対応
-//					TmpHost.UseSFTP = SendDlgItemMessage(hDlg, HSET_SFTP, BM_GETCHECK, 0, 0);
-					SendDlgItemMessage(hDlg, HSET_PRIVATE_KEY, WM_GETTEXT, PRIVATE_KEY_LEN+1, (LPARAM)TmpHost.PrivateKey);
+					if(IsPuTTYLoaded())
+					{
+						TmpHost.UseSFTP = SendDlgItemMessage(hDlg, HSET_SFTP, BM_GETCHECK, 0, 0);
+						SendDlgItemMessage(hDlg, HSET_PRIVATE_KEY, WM_GETTEXT, PRIVATE_KEY_LEN+1, (LPARAM)TmpHost.PrivateKey);
+					}
 					Apply = YES;
 					break;
 

--- a/main.c
+++ b/main.c
@@ -339,6 +339,9 @@ int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLi
 	LoadOpenSSL();
 #endif
 
+	// SFTP対応
+	LoadPuTTY();
+
 	Ret = FALSE;
 	hWndFtp = NULL;
 	hInstFtp = hInstance;
@@ -374,6 +377,8 @@ int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLi
 #ifdef USE_OPENSSL
 	FreeOpenSSL();
 #endif
+	// SFTP対応
+	FreePuTTY();
 	OleUninitialize();
 	return(Ret);
 }

--- a/mbswrapper.c
+++ b/mbswrapper.c
@@ -1895,7 +1895,6 @@ END_ROUTINE
 	return r;
 }
 
-
 BOOL AppendMenuM(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem)
 {
 	int r = 0;

--- a/putty/PUTTY.H
+++ b/putty/PUTTY.H
@@ -1303,4 +1303,8 @@ void timer_change_notify(long next);
 #define remove_session_from_jumplist(x) ((void)0)
 #endif
 
+// FFFTP
+#include "mbswrapper.h"
+#include "iowrapper.h"
+
 #endif

--- a/putty/PuTTY.vc90.vcproj
+++ b/putty/PuTTY.vc90.vcproj
@@ -50,7 +50,7 @@
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				DebugInformationFormat="4"
+				DebugInformationFormat="3"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -197,7 +197,7 @@
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				DebugInformationFormat="4"
+				DebugInformationFormat="3"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -334,6 +334,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\dllinterface.c"
+				>
+			</File>
+			<File
 				RelativePath=".\dllmain.c"
 				>
 			</File>
@@ -342,10 +346,18 @@
 				>
 			</File>
 			<File
+				RelativePath=".\iowrapper.c"
+				>
+			</File>
+			<File
 				RelativePath=".\LOGGING.C"
 				>
 			</File>
 			<File
+				RelativePath=".\mbswrapper.c"
+				>
+			</File>
+			<File
 				RelativePath=".\MISC.C"
 				>
 			</File>

--- a/putty/PuTTY.vcproj
+++ b/putty/PuTTY.vcproj
@@ -49,7 +49,7 @@
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				DebugInformationFormat="4"
+				DebugInformationFormat="3"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -196,7 +196,7 @@
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				DebugInformationFormat="4"
+				DebugInformationFormat="3"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -333,6 +333,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\dllinterface.c"
+				>
+			</File>
+			<File
 				RelativePath=".\dllmain.c"
 				>
 			</File>
@@ -341,10 +345,18 @@
 				>
 			</File>
 			<File
+				RelativePath=".\iowrapper.c"
+				>
+			</File>
+			<File
 				RelativePath=".\LOGGING.C"
 				>
 			</File>
 			<File
+				RelativePath=".\mbswrapper.c"
+				>
+			</File>
+			<File
 				RelativePath=".\MISC.C"
 				>
 			</File>

Binary files a/putty/Release/PuTTY.dll and b/putty/Release/PuTTY.dll differ

--- a/putty/WINDOWS/WINSFTP.C
+++ b/putty/WINDOWS/WINSFTP.C
@@ -93,6 +93,9 @@ RFile *open_existing_file(char *name, uint64 *size,
     HANDLE h;
     RFile *ret;
 
+	// FFFTP
+	return snew(RFile);
+
     h = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL,
 		   OPEN_EXISTING, 0, 0);
     if (h == INVALID_HANDLE_VALUE)
@@ -120,6 +123,8 @@ int read_from_file(RFile *f, void *buffer, int length)
 {
     int ret;
     DWORD read;
+	// FFFTP
+	return (int)SFTP_ReadThreadDataIO(buffer, length);
     ret = ReadFile(f->h, buffer, length, &read, NULL);
     if (!ret)
 	return -1;		       /* error */
@@ -129,7 +134,8 @@ int read_from_file(RFile *f, void *buffer, int length)
 
 void close_rfile(RFile *f)
 {
-    CloseHandle(f->h);
+	// FFFTP
+//    CloseHandle(f->h);
     sfree(f);
 }
 
@@ -142,6 +148,9 @@ WFile *open_new_file(char *name)
     HANDLE h;
     WFile *ret;
 
+	// FFFTP
+	return snew(WFile);
+
     h = CreateFile(name, GENERIC_WRITE, 0, NULL,
 		   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
     if (h == INVALID_HANDLE_VALUE)
@@ -158,6 +167,9 @@ WFile *open_existing_wfile(char *name, uint64 *size)
     HANDLE h;
     WFile *ret;
 
+	// FFFTP
+	return snew(WFile);
+
     h = CreateFile(name, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 		   OPEN_EXISTING, 0, 0);
     if (h == INVALID_HANDLE_VALUE)
@@ -176,6 +188,8 @@ int write_to_file(WFile *f, void *buffer, int length)
 {
     int ret;
     DWORD written;
+	// FFFTP
+	return (int)SFTP_WriteThreadDataIO(buffer, length);
     ret = WriteFile(f->h, buffer, length, &written, NULL);
     if (!ret)
 	return -1;		       /* error */
@@ -186,6 +200,8 @@ int write_to_file(WFile *f, void *buffer, int length)
 void set_file_times(WFile *f, unsigned long mtime, unsigned long atime)
 {
     FILETIME actime, wrtime;
+	// FFFTP
+	return;
     TIME_POSIX_TO_WIN(atime, actime);
     TIME_POSIX_TO_WIN(mtime, wrtime);
     SetFileTime(f->h, NULL, &actime, &wrtime);
@@ -193,7 +209,8 @@ void set_file_times(WFile *f, unsigned long mtime, unsigned long atime)
 
 void close_wfile(WFile *f)
 {
-    CloseHandle(f->h);
+	// FFFTP
+//    CloseHandle(f->h);
     sfree(f);
 }
 
@@ -203,6 +220,9 @@ int seek_file(WFile *f, uint64 offset, int whence)
 {
     DWORD movemethod;
 
+	// FFFTP
+	return 0;
+
     switch (whence) {
     case FROM_START:
 	movemethod = FILE_BEGIN;
@@ -229,6 +249,10 @@ uint64 get_file_posn(WFile *f)
 {
     uint64 ret;
 
+	// FFFTP
+	SFTP_GetThreadFilePositon((DWORD*)&ret.lo, (LONG*)&ret.hi);
+	return ret;
+
     ret.hi = 0L;
     ret.lo = SetFilePointer(f->h, 0L, &(ret.hi), FILE_CURRENT);
 
@@ -680,6 +704,9 @@ char *ssh_sftp_get_cmdline(char *prompt, int no_fds_ok)
     fputs(prompt, stdout);
     fflush(stdout);
 
+	// FFFTP
+	return fgetline(stdin);
+
     if ((sftp_ssh_socket == INVALID_SOCKET && no_fds_ok) ||
 	p_WSAEventSelect == NULL) {
 	return fgetline(stdin);	       /* very simple */

--- /dev/null
+++ b/putty/dllinterface.c
@@ -0,0 +1,90 @@
+// dllinterface.c
+// Copyright (C) 2011 Suguru Kawamoto
+// 標準入出力APIラッパー
+
+#include <stdio.h>
+#include <windows.h>
+
+#include "iowrapper.h"
+#include "dllinterface.h"
+
+__declspec(dllexport) SFTPSTATUS* SFTP_Create()
+{
+	SFTPSTATUS* p;
+	if(p = FindSFTPStatus(0))
+	{
+		p->ThreadId = GetCurrentThreadId();
+		p->bExit = FALSE;
+		SFTP_InitializeIOBuffer(&p->InBuffer, 65536);
+		SFTP_InitializeIOBuffer(&p->OutBuffer, 65536);
+		SFTP_InitializeIOBuffer(&p->DataInBuffer, 1048576);
+		SFTP_InitializeIOBuffer(&p->DataOutBuffer, 1048576);
+		memset(&p->FilePosition, 0, sizeof(LARGE_INTEGER));
+		CreateThread(NULL, 0, SFTP_ThreadProc, NULL, 0, &p->ThreadId);
+	}
+	return p;
+}
+
+__declspec(dllexport) void SFTP_Destroy(SFTPSTATUS* pSFTP)
+{
+	if(pSFTP)
+	{
+		SFTP_UninitializeIOBuffer(&pSFTP->InBuffer);
+		SFTP_UninitializeIOBuffer(&pSFTP->OutBuffer);
+		SFTP_UninitializeIOBuffer(&pSFTP->DataInBuffer);
+		SFTP_UninitializeIOBuffer(&pSFTP->DataOutBuffer);
+		pSFTP->ThreadId = 0;
+	}
+}
+
+__declspec(dllexport) BOOL SFTP_IsExited(SFTPSTATUS* pSFTP)
+{
+	return pSFTP->bExit;
+}
+
+__declspec(dllexport) BOOL SFTP_SetTimeoutCallback(SFTPSTATUS* pSFTP, LPSFTPTIMEOUTCALLBACK pCallback)
+{
+	pSFTP->pCallback = pCallback;
+	pSFTP->InBuffer.pCallback = pCallback;
+	pSFTP->OutBuffer.pCallback = pCallback;
+	pSFTP->DataInBuffer.pCallback = pCallback;
+	pSFTP->DataOutBuffer.pCallback = pCallback;
+	return TRUE;
+}
+
+__declspec(dllexport) size_t SFTP_PeekStdOut(SFTPSTATUS* pSFTP, void* pData, size_t Size)
+{
+	return SFTP_PeekIOBuffer(&pSFTP->OutBuffer, pData, Size);
+}
+
+__declspec(dllexport) size_t SFTP_ReadStdOut(SFTPSTATUS* pSFTP, void* pData, size_t Size)
+{
+	return SFTP_ReadIOBuffer(&pSFTP->OutBuffer, pData, Size);
+}
+
+__declspec(dllexport) size_t SFTP_WriteStdIn(SFTPSTATUS* pSFTP, const void* pData, size_t Size)
+{
+	return SFTP_WriteIOBuffer(&pSFTP->InBuffer, pData, Size);
+}
+
+__declspec(dllexport) size_t SFTP_PeekDataOut(SFTPSTATUS* pSFTP, void* pData, size_t Size)
+{
+	return SFTP_PeekIOBuffer(&pSFTP->DataOutBuffer, pData, Size);
+}
+
+__declspec(dllexport) size_t SFTP_ReadDataOut(SFTPSTATUS* pSFTP, void* pData, size_t Size)
+{
+	return SFTP_ReadIOBuffer(&pSFTP->DataOutBuffer, pData, Size);
+}
+
+__declspec(dllexport) size_t SFTP_WriteDataIn(SFTPSTATUS* pSFTP, const void* pData, size_t Size)
+{
+	return SFTP_WriteIOBuffer(&pSFTP->DataInBuffer, pData, Size);
+}
+
+__declspec(dllexport) BOOL SFTP_SetFilePosition(SFTPSTATUS* pSFTP, LONGLONG Position)
+{
+	pSFTP->FilePosition.QuadPart = Position;
+	return TRUE;
+}
+

--- /dev/null
+++ b/putty/dllinterface.h
@@ -0,0 +1,12 @@
+// dllinterface.h
+// Copyright (C) 2011 Suguru Kawamoto
+// 標準入出力APIラッパー
+
+#ifndef __DLLINTERFACE_H__
+#define __DLLINTERFACE_H__
+
+#include <stdio.h>
+#include <windows.h>
+
+#endif
+

--- /dev/null
+++ b/putty/iowrapper.c
@@ -0,0 +1,434 @@
+// iowrapper.c
+// Copyright (C) 2011 Suguru Kawamoto
+// 標準入出力APIラッパー
+
+#define UNICODE
+#define _UNICODE
+
+#include <stdio.h>
+#include <windows.h>
+
+#define DO_NOT_REPLACE
+#include "iowrapper.h"
+#include "psftp.h"
+
+#define MAX_SFTPSTATUS 16
+
+SFTPSTATUS g_SFTPData[MAX_SFTPSTATUS];
+HANDLE g_hStdIn;
+HANDLE g_hStdOut;
+HANDLE g_hStdErr;
+
+BOOL __stdcall DefaultIOBufferCallback(BOOL* pbAborted)
+{
+	Sleep(1);
+	return *pbAborted;
+}
+
+DWORD WINAPI SFTP_ThreadProc(LPVOID lpParameter)
+{
+	char* p[1] = {"PSFTP"};
+	SFTPSTATUS* pSFTP;
+	psftp_main(1, p);
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		pSFTP->bExit = TRUE;
+	return 0;
+}
+
+SFTPSTATUS* FindSFTPStatus(DWORD ThreadId)
+{
+	int i;
+	for(i = 0; i < MAX_SFTPSTATUS; i++)
+	{
+		if(g_SFTPData[i].ThreadId == ThreadId)
+			return &g_SFTPData[i];
+	}
+	return NULL;
+}
+
+CRITICAL_SECTION g_DummyLock;
+
+BOOL SFTP_InitializeIOBuffer(SFTPIOBUFFER* pIO, size_t Length)
+{
+	memset(pIO, 0, sizeof(SFTPIOBUFFER));
+//	InitializeCriticalSection(&pIO->Lock);
+	if(memcmp(&pIO->Lock, &g_DummyLock, sizeof(CRITICAL_SECTION)) == 0)
+	{
+		InitializeCriticalSection(&pIO->Lock);
+		EnterCriticalSection(&pIO->Lock);
+	}
+	if(!(pIO->pBuffer = (BYTE*)malloc(Length + 1)))
+		return FALSE;
+	memset(pIO->pBuffer + Length, 0, 1);
+	pIO->Length = Length;
+	pIO->Written = 0;
+	pIO->Read = 0;
+	pIO->bAborted = FALSE;
+	pIO->pCallback = DefaultIOBufferCallback;
+	LeaveCriticalSection(&pIO->Lock);
+	return TRUE;
+}
+
+void SFTP_UninitializeIOBuffer(SFTPIOBUFFER* pIO)
+{
+//	DeleteCriticalSection(&pIO->Lock);
+	EnterCriticalSection(&pIO->Lock);
+	free(pIO->pBuffer);
+//	memset(pIO, 0, sizeof(SFTPIOBUFFER));
+}
+
+void SFTP_AbortIOBuffer(SFTPIOBUFFER* pIO, BOOL bAborted)
+{
+	EnterCriticalSection(&pIO->Lock);
+	pIO->bAborted = bAborted;
+	LeaveCriticalSection(&pIO->Lock);
+}
+
+size_t SFTP_PeekIOBuffer(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size)
+{
+	size_t Copied;
+	size_t Pos;
+	size_t Count;
+	size_t Read;
+	Copied = 0;
+	EnterCriticalSection(&pIO->Lock);
+	if(pBuffer)
+	{
+		Read = pIO->Read;
+		while(!pIO->bAborted && pIO->Written - Read > 0 && Copied < Size)
+		{
+			Pos = Read % pIO->Length;
+			Count = min(Size - Copied, min(pIO->Written - Read, pIO->Length - Pos));
+			memcpy((BYTE*)pBuffer + Copied, pIO->pBuffer + Pos, Count);
+			Read += Count;
+			Copied += Count;
+		}
+	}
+	else
+		Copied = pIO->Written - pIO->Read;
+	LeaveCriticalSection(&pIO->Lock);
+	return Copied;
+}
+
+size_t SFTP_ReadIOBuffer(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size)
+{
+	size_t Copied;
+	size_t Pos;
+	size_t Count;
+	Copied = 0;
+	EnterCriticalSection(&pIO->Lock);
+	while(!pIO->bAborted && pIO->Written - pIO->Read > 0 && Copied < Size)
+	{
+		Pos = pIO->Read % pIO->Length;
+		Count = min(Size - Copied, min(pIO->Written - pIO->Read, pIO->Length - Pos));
+		memcpy((BYTE*)pBuffer + Copied, pIO->pBuffer + Pos, Count);
+		pIO->Read += Count;
+		Copied += Count;
+	}
+	LeaveCriticalSection(&pIO->Lock);
+	return Copied;
+}
+
+size_t SFTP_WriteIOBuffer(SFTPIOBUFFER* pIO, const void* pBuffer, size_t Size)
+{
+	size_t Copied;
+	size_t Pos;
+	size_t Count;
+	Copied = 0;
+	EnterCriticalSection(&pIO->Lock);
+	while(!pIO->bAborted && Copied < Size)
+	{
+		if(pIO->Written - pIO->Read < pIO->Length)
+		{
+			Pos = pIO->Written % pIO->Length;
+			Count = min(Size - Copied, min(pIO->Length + pIO->Read - pIO->Written, pIO->Length - Pos));
+			memcpy(pIO->pBuffer + Pos, (BYTE*)pBuffer + Copied, Count);
+			pIO->Written += Count;
+			Copied += Count;
+		}
+		else
+		{
+			LeaveCriticalSection(&pIO->Lock);
+			if(pIO->pCallback(&pIO->bAborted))
+				Size = 0;
+			EnterCriticalSection(&pIO->Lock);
+		}
+	}
+	LeaveCriticalSection(&pIO->Lock);
+	return Copied;
+}
+
+size_t SFTP_ReadIOBufferLine(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size)
+{
+	size_t Copied;
+	size_t Pos;
+	size_t Count;
+	char* p;
+	Copied = 0;
+	EnterCriticalSection(&pIO->Lock);
+	while(!pIO->bAborted && Copied < Size)
+	{
+		if(pIO->Written - pIO->Read > 0)
+		{
+			Pos = pIO->Read % pIO->Length;
+			Count = min(Size - Copied, min(pIO->Written - pIO->Read, pIO->Length - Pos));
+			if(p = strchr((char*)(pIO->pBuffer + Pos), '\n'))
+			{
+				p++;
+				Count = min(Count, (size_t)p - (size_t)(pIO->pBuffer + Pos));
+				Size = 0;
+			}
+			memcpy((BYTE*)pBuffer + Copied, pIO->pBuffer + Pos, Count);
+			pIO->Read += Count;
+			Copied += Count;
+		}
+		else
+		{
+			LeaveCriticalSection(&pIO->Lock);
+			if(pIO->pCallback(&pIO->bAborted))
+				Size = 0;
+			EnterCriticalSection(&pIO->Lock);
+		}
+	}
+	LeaveCriticalSection(&pIO->Lock);
+	return Copied;
+}
+
+size_t SFTP_PeekThreadIO(void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_PeekIOBuffer(&pSFTP->InBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_ReadThreadIO(void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_ReadIOBuffer(&pSFTP->InBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_WriteThreadIO(const void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_WriteIOBuffer(&pSFTP->OutBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_ReadThreadIOLine(void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_ReadIOBufferLine(&pSFTP->InBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_PeekThreadDataIO(void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_PeekIOBuffer(&pSFTP->DataInBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_ReadThreadDataIO(void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_ReadIOBuffer(&pSFTP->DataInBuffer, pBuffer, Size);
+	return 0;
+}
+
+size_t SFTP_WriteThreadDataIO(const void* pBuffer, size_t Size)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+		return SFTP_WriteIOBuffer(&pSFTP->DataOutBuffer, pBuffer, Size);
+	return 0;
+}
+
+BOOL SFTP_GetThreadFilePositon(DWORD* pLow, LONG* pHigh)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+	{
+		*pLow = pSFTP->FilePosition.LowPart;
+		*pHigh = pSFTP->FilePosition.HighPart;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+// 以下ラッパー
+
+HANDLE GetStdHandleX(DWORD nStdHandle)
+{
+	HANDLE r = INVALID_HANDLE_VALUE;
+	if(!g_hStdIn)
+		g_hStdIn = (HANDLE)1;
+	if(!g_hStdOut)
+		g_hStdOut = (HANDLE)2;
+	if(!g_hStdErr)
+		g_hStdErr = (HANDLE)3;
+	if(nStdHandle == STD_INPUT_HANDLE)
+		r = g_hStdIn;
+	if(nStdHandle == STD_OUTPUT_HANDLE)
+		r = g_hStdOut;
+	if(nStdHandle == STD_ERROR_HANDLE)
+		r = g_hStdErr;
+	return r;
+}
+
+BOOL GetConsoleModeX(HANDLE hConsoleHandle, LPDWORD lpMode)
+{
+	BOOL r = FALSE;
+	return r;
+}
+
+BOOL SetConsoleModeX(HANDLE hConsoleHandle, DWORD dwMode)
+{
+	BOOL r = FALSE;
+	return r;
+}
+
+BOOL ReadFileX(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
+{
+	BOOL r = FALSE;
+	if(hFile == g_hStdIn)
+	{
+		*lpNumberOfBytesRead = (DWORD)SFTP_ReadThreadIOLine(lpBuffer, nNumberOfBytesToRead);
+		if(*lpNumberOfBytesRead > 0)
+			r = TRUE;
+	}
+	else if(hFile == g_hStdOut)
+	{
+	}
+	else if(hFile == g_hStdErr)
+	{
+	}
+	return r;
+}
+
+BOOL WriteFileX(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
+{
+	BOOL r = FALSE;
+	if(hFile == g_hStdIn)
+	{
+	}
+	else if(hFile == g_hStdOut)
+	{
+		*lpNumberOfBytesWritten = (DWORD)SFTP_WriteThreadIO(lpBuffer, nNumberOfBytesToWrite);
+		if(*lpNumberOfBytesWritten == nNumberOfBytesToWrite)
+			r = TRUE;
+	}
+	else if(hFile == g_hStdErr)
+	{
+		*lpNumberOfBytesWritten = (DWORD)SFTP_WriteThreadIO(lpBuffer, nNumberOfBytesToWrite);
+		if(*lpNumberOfBytesWritten == nNumberOfBytesToWrite)
+			r = TRUE;
+	}
+	return r;
+}
+
+int printfX(const char * _Format, ...)
+{
+	int r = 0;
+	va_list v;
+	char Temp[1024];
+	va_start(v, _Format);
+	vsprintf(Temp, _Format, v);
+	r = (int)SFTP_WriteThreadIO(Temp, strlen(Temp));
+	va_end(v);
+	return r;
+}
+
+int putsX(const char * _Str)
+{
+	int r = 0;
+	r = (int)SFTP_WriteThreadIO(_Str, strlen(_Str));
+	return r;
+}
+
+int fprintfX(FILE * _File, const char * _Format, ...)
+{
+	int r = 0;
+	va_list v;
+	char Temp[1024];
+	va_start(v, _Format);
+	if(_File == stdout)
+	{
+		vsprintf(Temp, _Format, v);
+		r = (int)SFTP_WriteThreadIO(Temp, strlen(Temp));
+	}
+	else if(_File == stderr)
+	{
+		vsprintf(Temp, _Format, v);
+		r = (int)SFTP_WriteThreadIO(Temp, strlen(Temp));
+	}
+	else
+		r = vfprintf(_File, _Format, v);
+	va_end(v);
+	return r;
+}
+
+char * fgetsX(char * _Buf, int _MaxCount, FILE * _File)
+{
+	char * r = NULL;
+	if(_File == stdin)
+	{
+		memset(_Buf, 0, _MaxCount);
+		SFTP_ReadThreadIOLine(_Buf, _MaxCount - 1);
+		r = _Buf;
+	}
+	else
+		r = fgets(_Buf, _MaxCount, _File);
+	return r;
+}
+
+int fputsX(const char * _Str, FILE * _File)
+{
+	int r = 0;
+	if(_File == stdout)
+	{
+		r = (int)SFTP_WriteThreadIO(_Str, strlen(_Str));
+	}
+	else if(_File == stderr)
+	{
+		r = (int)SFTP_WriteThreadIO(_Str, strlen(_Str));
+	}
+	else
+		r = fputs(_Str, _File);
+	return r;
+}
+
+int fflushX(FILE * _File)
+{
+	int r = 0;
+	if(_File == stdout)
+	{
+	}
+	else if(_File == stderr)
+	{
+	}
+	else
+		r = fflush(_File);
+	return r;
+}
+
+void exitX(int _Code)
+{
+	SFTPSTATUS* pSFTP;
+	if(pSFTP = FindSFTPStatus(GetCurrentThreadId()))
+	{
+		pSFTP->bExit = TRUE;
+		SFTP_AbortIOBuffer(&pSFTP->InBuffer, TRUE);
+		SFTP_AbortIOBuffer(&pSFTP->OutBuffer, TRUE);
+		SFTP_AbortIOBuffer(&pSFTP->DataInBuffer, TRUE);
+		SFTP_AbortIOBuffer(&pSFTP->DataOutBuffer, TRUE);
+	}
+	TerminateThread(GetCurrentThread(), (DWORD)_Code);
+}
+

--- /dev/null
+++ b/putty/iowrapper.h
@@ -0,0 +1,96 @@
+// iowrapper.h
+// Copyright (C) 2011 Suguru Kawamoto
+// 標準入出力APIラッパー
+
+#ifndef __IOWRAPPER_H__
+#define __IOWRAPPER_H__
+
+#include <stdio.h>
+#include <windows.h>
+
+#ifndef DO_NOT_REPLACE
+
+#undef GetStdHandle
+#define GetStdHandle GetStdHandleX
+HANDLE GetStdHandleX(DWORD nStdHandle);
+#undef GetConsoleMode
+#define GetConsoleMode GetConsoleModeX
+BOOL GetConsoleModeX(HANDLE hConsoleHandle, LPDWORD lpMode);
+#undef SetConsoleMode
+#define SetConsoleMode SetConsoleModeX
+BOOL SetConsoleModeX(HANDLE hConsoleHandle, DWORD dwMode);
+#undef ReadFile
+#define ReadFile ReadFileX
+BOOL ReadFileX(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
+#undef WriteFile
+#define WriteFile WriteFileX
+BOOL WriteFileX(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
+#undef printf
+#define printf printfX
+int printfX(const char * _Format, ...);
+#undef gets
+#define gets getsX
+char * getsX(char * _Buffer);
+#undef puts
+#define puts putsX
+int putsX(const char * _Str);
+#undef fprintf
+#define fprintf fprintfX
+int fprintfX(FILE * _File, const char * _Format, ...);
+#undef fgets
+#define fgets fgetsX
+char * fgetsX(char * _Buf, int _MaxCount, FILE * _File);
+#undef fputs
+#define fputs fputsX
+int fputsX(const char * _Str, FILE * _File);
+#undef exit
+#define exit exitX
+void exitX(int _Code);
+
+#endif
+
+typedef BOOL (__stdcall* LPSFTPTIMEOUTCALLBACK)(BOOL*);
+
+typedef struct
+{
+	CRITICAL_SECTION Lock;
+	BYTE* pBuffer;
+	size_t Length;
+	size_t Written;
+	size_t Read;
+	BOOL bAborted;
+	LPSFTPTIMEOUTCALLBACK pCallback;
+} SFTPIOBUFFER;
+
+typedef struct
+{
+	DWORD ThreadId;
+	BOOL bExit;
+	LPSFTPTIMEOUTCALLBACK pCallback;
+	SFTPIOBUFFER InBuffer;
+	SFTPIOBUFFER OutBuffer;
+	SFTPIOBUFFER DataInBuffer;
+	SFTPIOBUFFER DataOutBuffer;
+	LARGE_INTEGER FilePosition;
+} SFTPSTATUS;
+
+DWORD WINAPI SFTP_ThreadProc(LPVOID lpParameter);
+SFTPSTATUS* FindSFTPStatus(DWORD ThreadId);
+BOOL SFTP_InitializeIOBuffer(SFTPIOBUFFER* pIO, size_t Length);
+void SFTP_UninitializeIOBuffer(SFTPIOBUFFER* pIO);
+void SFTP_AbortIOBuffer(SFTPIOBUFFER* pIO, BOOL bAborted);
+size_t SFTP_PeekIOBuffer(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size);
+size_t SFTP_ReadIOBuffer(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size);
+size_t SFTP_WriteIOBuffer(SFTPIOBUFFER* pIO, const void* pBuffer, size_t Size);
+size_t SFTP_ReadIOBufferLine(SFTPIOBUFFER* pIO, void* pBuffer, size_t Size);
+size_t SFTP_PeekThreadIO(void* pBuffer, size_t Size);
+size_t SFTP_ReadThreadIO(void* pBuffer, size_t Size);
+size_t SFTP_WriteThreadIO(const void* pBuffer, size_t Size);
+size_t SFTP_ReadThreadIOLine(void* pBuffer, size_t Size);
+size_t SFTP_PeekThreadDataIO(void* pBuffer, size_t Size);
+size_t SFTP_ReadThreadDataIO(void* pBuffer, size_t Size);
+size_t SFTP_WriteThreadDataIO(const void* pBuffer, size_t Size);
+BOOL SFTP_GetThreadFilePositon(DWORD* pLow, LONG* pHigh);
+
+#endif
+

--- /dev/null
+++ b/putty/mbswrapper.c
@@ -0,0 +1,955 @@
+// mbswrapper.c
+// Copyright (C) 2011 Suguru Kawamoto
+// マルチバイト文字ワイド文字APIラッパー
+// マルチバイト文字はUTF-8、ワイド文字はUTF-16であるものとする
+// 全ての制御用の文字はASCIIの範囲であるため、Shift_JISとUTF-8間の変換は不要
+
+#define UNICODE
+#define _UNICODE
+
+#include <stdio.h>
+#include <tchar.h>
+#include <direct.h>
+#include <windows.h>
+#include <commctrl.h>
+#include <shlobj.h>
+#include <htmlhelp.h>
+
+#define DO_NOT_REPLACE
+#include "mbswrapper.h"
+
+// マルチバイト文字列からワイド文字列へ変換
+int MtoW(LPWSTR pDst, int size, LPCSTR pSrc, int count)
+{
+	if(pSrc < (LPCSTR)0x00010000 || pSrc == (LPCSTR)~0)
+		return 0;
+	if(pDst)
+		return MultiByteToWideChar(CP_UTF8, 0, pSrc, count, pDst, size);
+	return MultiByteToWideChar(CP_UTF8, 0, pSrc, count, NULL, 0);
+}
+
+// ワイド文字列からマルチバイト文字列へ変換
+int WtoM(LPSTR pDst, int size, LPCWSTR pSrc, int count)
+{
+	if(pSrc < (LPCWSTR)0x00010000 || pSrc == (LPCWSTR)~0)
+		return 0;
+	if(pDst)
+		return WideCharToMultiByte(CP_UTF8, 0, pSrc, count, pDst, size, NULL, NULL);
+	return WideCharToMultiByte(CP_UTF8, 0, pSrc, count, NULL, 0, NULL, NULL);
+}
+
+// Shift_JIS文字列からワイド文字列へ変換
+int AtoW(LPWSTR pDst, int size, LPCSTR pSrc, int count)
+{
+	if(pSrc < (LPCSTR)0x00010000 || pSrc == (LPCSTR)~0)
+		return 0;
+	if(pDst)
+		return MultiByteToWideChar(CP_ACP, 0, pSrc, count, pDst, size);
+	return MultiByteToWideChar(CP_ACP, 0, pSrc, count, NULL, 0);
+}
+
+// ワイド文字列からShift_JIS文字列へ変換
+int WtoA(LPSTR pDst, int size, LPCWSTR pSrc, int count)
+{
+	if(pSrc < (LPCWSTR)0x00010000 || pSrc == (LPCWSTR)~0)
+		return 0;
+	if(pDst)
+		return WideCharToMultiByte(CP_ACP, 0, pSrc, count, pDst, size, NULL, NULL);
+	return WideCharToMultiByte(CP_ACP, 0, pSrc, count, NULL, 0, NULL, NULL);
+}
+
+// マルチバイト文字列バッファ終端を強制的にNULLで置換
+int TerminateStringM(LPSTR lpString, int size)
+{
+	int i;
+	if(lpString < (LPSTR)0x00010000 || lpString == (LPSTR)~0)
+		return 0;
+	for(i = 0; i < size; i++)
+	{
+		if(lpString[i] == '\0')
+			return i;
+	}
+	i--;
+	lpString[i] = '\0';
+	return i;
+}
+
+// ワイド文字列バッファ終端を強制的にNULLで置換
+int TerminateStringW(LPWSTR lpString, int size)
+{
+	int i;
+	if(lpString < (LPWSTR)0x00010000 || lpString == (LPWSTR)~0)
+		return 0;
+	for(i = 0; i < size; i++)
+	{
+		if(lpString[i] == L'\0')
+			return i;
+	}
+	i--;
+	lpString[i] = L'\0';
+	return i;
+}
+
+// Shift_JIS文字列バッファ終端を強制的にNULLで置換
+int TerminateStringA(LPSTR lpString, int size)
+{
+	int i;
+	if(lpString < (LPSTR)0x00010000 || lpString == (LPSTR)~0)
+		return 0;
+	for(i = 0; i < size; i++)
+	{
+		if(lpString[i] == '\0')
+			return i;
+	}
+	i--;
+	lpString[i] = '\0';
+	return i;
+}
+
+// NULL区切り複数マルチバイト文字列の長さを取得
+size_t GetMultiStringLengthM(LPCSTR lpString)
+{
+	size_t i;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return 0;
+	i = 0;
+	while(lpString[i] != '\0' || lpString[i + 1] != '\0')
+	{
+		i++;
+	}
+	i++;
+	return i;
+}
+
+// NULL区切り複数ワイド文字列の長さを取得
+size_t GetMultiStringLengthW(LPCWSTR lpString)
+{
+	size_t i;
+	if(lpString < (LPCWSTR)0x00010000 || lpString == (LPCWSTR)~0)
+		return 0;
+	i = 0;
+	while(lpString[i] != L'\0' || lpString[i + 1] != L'\0')
+	{
+		i++;
+	}
+	i++;
+	return i;
+}
+
+// NULL区切り複数Shift_JIS文字列の長さを取得
+size_t GetMultiStringLengthA(LPCSTR lpString)
+{
+	size_t i;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return 0;
+	i = 0;
+	while(lpString[i] != '\0' || lpString[i + 1] != '\0')
+	{
+		i++;
+	}
+	i++;
+	return i;
+}
+
+// NULL区切りマルチバイト文字列からワイド文字列へ変換
+int MtoWMultiString(LPWSTR pDst, int size, LPCSTR pSrc)
+{
+	int i;
+	if(pSrc < (LPCSTR)0x00010000 || pSrc == (LPCSTR)~0)
+		return 0;
+	if(!pDst)
+		return GetMultiStringLengthM(pSrc);
+	i = 0;
+	while(*pSrc != '\0')
+	{
+		i += MultiByteToWideChar(CP_UTF8, 0, pSrc, -1, pDst + i, size - i - 1);
+		pSrc += strlen(pSrc) + 1;
+	}
+	pDst[i] = L'\0';
+	return i;
+}
+
+// NULL区切りワイド文字列からマルチバイト文字列へ変換
+int WtoMMultiString(LPSTR pDst, int size, LPCWSTR pSrc)
+{
+	int i;
+	if(pSrc < (LPCWSTR)0x00010000 || pSrc == (LPCWSTR)~0)
+		return 0;
+	if(!pDst)
+		return GetMultiStringLengthW(pSrc);
+	i = 0;
+	while(*pSrc != L'\0')
+	{
+		i += WideCharToMultiByte(CP_UTF8, 0, pSrc, -1, pDst + i, size - i - 1, NULL, NULL);
+		pSrc += wcslen(pSrc) + 1;
+	}
+	pDst[i] = '\0';
+	return i;
+}
+
+// NULL区切りShift_JIS文字列からワイド文字列へ変換
+int AtoWMultiString(LPWSTR pDst, int size, LPCSTR pSrc)
+{
+	int i;
+	if(pSrc < (LPCSTR)0x00010000 || pSrc == (LPCSTR)~0)
+		return 0;
+	if(!pDst)
+		return GetMultiStringLengthA(pSrc);
+	i = 0;
+	while(*pSrc != '\0')
+	{
+		i += MultiByteToWideChar(CP_ACP, 0, pSrc, -1, pDst + i, size - i - 1);
+		pSrc += strlen(pSrc) + 1;
+	}
+	pDst[i] = L'\0';
+	return i;
+}
+
+// NULL区切りワイド文字列からShift_JIS文字列へ変換
+int WtoAMultiString(LPSTR pDst, int size, LPCWSTR pSrc)
+{
+	int i;
+	if(pSrc < (LPCWSTR)0x00010000 || pSrc == (LPCWSTR)~0)
+		return 0;
+	if(!pDst)
+		return GetMultiStringLengthW(pSrc);
+	i = 0;
+	while(*pSrc != L'\0')
+	{
+		i += WideCharToMultiByte(CP_ACP, 0, pSrc, -1, pDst + i, size - i - 1, NULL, NULL);
+		pSrc += wcslen(pSrc) + 1;
+	}
+	pDst[i] = '\0';
+	return i;
+}
+
+// マルチバイト文字列用のメモリを確保
+char* AllocateStringM(int size)
+{
+	char* p;
+	// 0が指定される場合があるため1文字分追加
+	p = (char*)malloc(sizeof(char) * (size + 1));
+	// 念のため先頭にNULL文字を代入
+	if(p)
+		*p = '\0';
+	return p;
+}
+
+// ワイド文字列用のメモリを確保
+wchar_t* AllocateStringW(int size)
+{
+	wchar_t* p;
+	// 0が指定される場合があるため1文字分追加
+	p = (wchar_t*)malloc(sizeof(wchar_t) * (size + 1));
+	// 念のため先頭にNULL文字を代入
+	if(p)
+		*p = L'\0';
+	return p;
+}
+
+// Shift_JIS文字列用のメモリを確保
+char* AllocateStringA(int size)
+{
+	char* p;
+	// 0が指定される場合があるため1文字分追加
+	p = (char*)malloc(sizeof(char) * (size + 1));
+	// 念のため先頭にNULL文字を代入
+	if(p)
+		*p = '\0';
+	return p;
+}
+
+// メモリを確保してマルチバイト文字列からワイド文字列へ変換
+// リソースIDならば元の値を返す
+wchar_t* DuplicateMtoW(LPCSTR lpString, int c)
+{
+	wchar_t* p;
+	int i;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return (wchar_t*)lpString;
+	if(c < 0)
+		c = strlen(lpString);
+	p = AllocateStringW(MtoW(NULL, 0, lpString, c) + 1);
+	if(p)
+	{
+		i = MtoW(p, 65535, lpString, c);
+		p[i] = L'\0';
+	}
+	return p;
+}
+
+// 指定したサイズのメモリを確保してマルチバイト文字列からワイド文字列へ変換
+// リソースIDならば元の値を返す
+wchar_t* DuplicateMtoWBuffer(LPCSTR lpString, int c, int size)
+{
+	wchar_t* p;
+	int i;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return (wchar_t*)lpString;
+	if(c < 0)
+		c = strlen(lpString);
+	p = AllocateStringW(size);
+	if(p)
+	{
+		i = MtoW(p, size, lpString, c);
+		p[i] = L'\0';
+	}
+	return p;
+}
+
+// メモリを確保してNULL区切りマルチバイト文字列からワイド文字列へ変換
+// リソースIDならば元の値を返す
+wchar_t* DuplicateMtoWMultiString(LPCSTR lpString)
+{
+	int count;
+	wchar_t* p;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return (wchar_t*)lpString;
+	count = GetMultiStringLengthM(lpString) + 1;
+	p = AllocateStringW(count);
+	if(p)
+		MtoW(p, count, lpString, count);
+	return p;
+}
+
+// 指定したサイズのメモリを確保してNULL区切りマルチバイト文字列からワイド文字列へ変換
+// リソースIDならば元の値を返す
+wchar_t* DuplicateMtoWMultiStringBuffer(LPCSTR lpString, int size)
+{
+	int count;
+	wchar_t* p;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return (wchar_t*)lpString;
+	count = GetMultiStringLengthM(lpString) + 1;
+	p = AllocateStringW(size);
+	if(p)
+	{
+		MtoW(p, size, lpString, count);
+		p[size - 2] = L'\0';
+		p[size - 1] = L'\0';
+	}
+	return p;
+}
+
+// メモリを確保してワイド文字列からマルチバイト文字列へ変換
+// リソースIDならば元の値を返す
+char* DuplicateWtoM(LPCWSTR lpString, int c)
+{
+	char* p;
+	int i;
+	if(lpString < (LPCWSTR)0x00010000 || lpString == (LPCWSTR)~0)
+		return (char*)lpString;
+	if(c < 0)
+		c = wcslen(lpString);
+	p = AllocateStringM(WtoM(NULL, 0, lpString, c) + 1);
+	if(p)
+	{
+		i = WtoM(p, 65535, lpString, c);
+		p[i] = L'\0';
+	}
+	return p;
+}
+
+// メモリを確保してShift_JIS文字列からワイド文字列へ変換
+// リソースIDならば元の値を返す
+wchar_t* DuplicateAtoW(LPCSTR lpString, int c)
+{
+	wchar_t* p;
+	int i;
+	if(lpString < (LPCSTR)0x00010000 || lpString == (LPCSTR)~0)
+		return (wchar_t*)lpString;
+	if(c < 0)
+		c = strlen(lpString);
+	p = AllocateStringW(AtoW(NULL, 0, lpString, c) + 1);
+	if(p)
+	{
+		i = AtoW(p, 65535, lpString, c);
+		p[i] = L'\0';
+	}
+	return p;
+}
+
+// メモリを確保してワイド文字列からShift_JIS文字列へ変換
+// リソースIDならば元の値を返す
+char* DuplicateWtoA(LPCWSTR lpString, int c)
+{
+	char* p;
+	int i;
+	if(lpString < (LPCWSTR)0x00010000 || lpString == (LPCWSTR)~0)
+		return (char*)lpString;
+	if(c < 0)
+		c = wcslen(lpString);
+	p = AllocateStringA(WtoA(NULL, 0, lpString, c) + 1);
+	if(p)
+	{
+		i = WtoA(p, 65535, lpString, c);
+		p[i] = L'\0';
+	}
+	return p;
+}
+
+// マルチバイト文字列からコードポイントと次のポインタを取得
+// エンコードが不正な場合は0x80000000を返す
+DWORD GetNextCharM(LPCSTR lpString, LPCSTR* ppNext)
+{
+	DWORD Code;
+	int i;
+	Code = 0;
+	if((*lpString & 0xfe) == 0xfc)
+	{
+		i = 5;
+		Code |= (DWORD)*lpString & 0x01;
+	}
+	else if((*lpString & 0xfc) == 0xf8)
+	{
+		i = 4;
+		Code |= (DWORD)*lpString & 0x03;
+	}
+	else if((*lpString & 0xf8) == 0xf0)
+	{
+		i = 3;
+		Code |= (DWORD)*lpString & 0x07;
+	}
+	else if((*lpString & 0xf0) == 0xe0)
+	{
+		i = 2;
+		Code |= (DWORD)*lpString & 0x0f;
+	}
+	else if((*lpString & 0xe0) == 0xc0)
+	{
+		i = 1;
+		Code |= (DWORD)*lpString & 0x1f;
+	}
+	else if((*lpString & 0x80) == 0x00)
+	{
+		i = 0;
+		Code |= (DWORD)*lpString & 0x7f;
+	}
+	else
+		i = -1;
+	lpString++;
+	while((*lpString & 0xc0) == 0x80)
+	{
+		i--;
+		Code = Code << 6;
+		Code |= (DWORD)*lpString & 0x3f;
+		lpString++;
+	}
+	if(i != 0)
+		Code = 0x80000000;
+	if(ppNext)
+		*ppNext = lpString;
+	return Code;
+}
+
+// マルチバイト文字列の冗長表現を修正
+// 修正があればTRUEを返す
+// 修正後の文字列の長さは元の文字列の長さ以下のためpDstとpSrcに同じ値を指定可能
+BOOL FixStringM(LPSTR pDst, LPCSTR pSrc)
+{
+	BOOL bResult;
+	char* p;
+	DWORD Code;
+	int i;
+	char c;
+	bResult = FALSE;
+	p = (char*)pSrc;
+	while(*pSrc != '\0')
+	{
+		Code = GetNextCharM(pSrc, &pSrc);
+		if(Code & 0x80000000)
+			continue;
+		else if(Code & 0x7c000000)
+		{
+			i = 5;
+			c = (char)(0xfc | (Code >> (6 * i)));
+		}
+		else if(Code & 0x03e00000)
+		{
+			i = 4;
+			c = (char)(0xf8 | (Code >> (6 * i)));
+		}
+		else if(Code & 0x001f0000)
+		{
+			i = 3;
+			c = (char)(0xf0 | (Code >> (6 * i)));
+		}
+		else if(Code & 0x0000f800)
+		{
+			i = 2;
+			c = (char)(0xe0 | (Code >> (6 * i)));
+		}
+		else if(Code & 0x00000780)
+		{
+			i = 1;
+			c = (char)(0xc0 | (Code >> (6 * i)));
+		}
+		else
+		{
+			i = 0;
+			c = (char)Code;
+		}
+		if(c != *p)
+			bResult = TRUE;
+		p++;
+		*pDst = c;
+		pDst++;
+		while(i > 0)
+		{
+			i--;
+			c = (char)(0x80 | ((Code >> (6 * i)) & 0x3f));
+			if(c != *p)
+				bResult = TRUE;
+			p++;
+			*pDst = c;
+			pDst++;
+		}
+	}
+	if(*p != '\0')
+		bResult = TRUE;
+	*pDst = '\0';
+	return bResult;
+}
+
+// NULL区切りマルチバイト文字列の冗長表現を修正
+// 修正があればTRUEを返す
+// 修正後の文字列の長さは元の文字列の長さ以下のためpDstとpSrcに同じ値を指定可能
+BOOL FixMultiStringM(LPSTR pDst, LPCSTR pSrc)
+{
+	BOOL bResult;
+	int Length;
+	bResult = FALSE;
+	while(*pSrc != '\0')
+	{
+		Length = strlen(pSrc) + 1;
+		bResult = bResult | FixStringM(pDst, pSrc);
+		pSrc += Length;
+		pDst += strlen(pDst) + 1;
+	}
+	*pDst = '\0';
+	return bResult;
+}
+
+// マルチバイト文字列の冗長表現を確認
+// 冗長表現があればTRUEを返す
+BOOL CheckStringM(LPCSTR lpString)
+{
+	BOOL bResult;
+	char* p;
+	bResult = FALSE;
+	p = AllocateStringM(strlen(lpString) + 1);
+	if(p)
+	{
+		bResult = FixStringM(p, lpString);
+		FreeDuplicatedString(p);
+	}
+	return bResult;
+}
+
+// NULL区切りマルチバイト文字列の冗長表現を確認
+// 冗長表現があればTRUEを返す
+BOOL CheckMultiStringM(LPCSTR lpString)
+{
+	BOOL bResult;
+	char* p;
+	bResult = FALSE;
+	p = AllocateStringM(GetMultiStringLengthM(lpString) + 1);
+	if(p)
+	{
+		bResult = FixMultiStringM(p, lpString);
+		FreeDuplicatedString(p);
+	}
+	return bResult;
+}
+
+// 文字列用に確保したメモリを開放
+// リソースIDならば何もしない
+void FreeDuplicatedString(void* p)
+{
+	if(p < (void*)0x00010000 || p == (void*)~0)
+		return;
+	free(p);
+}
+
+// 以下ラッパー
+// 戻り値バッファ r
+// ワイド文字バッファ pw%d
+// マルチバイト文字バッファ pm%d
+// 引数バッファ a%d
+
+#pragma warning(disable:4102)
+#define START_ROUTINE					do{
+#define END_ROUTINE						}while(0);end_of_routine:
+#define QUIT_ROUTINE					goto end_of_routine;
+
+HANDLE CreateFileM(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
+{
+	HANDLE r = INVALID_HANDLE_VALUE;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(lpFileName, -1);
+	r = CreateFileW(pw0, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+HANDLE FindFirstFileM(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData)
+{
+	HANDLE r = INVALID_HANDLE_VALUE;
+	wchar_t* pw0 = NULL;
+	WIN32_FIND_DATAW a0;
+START_ROUTINE
+	pw0 = DuplicateMtoW(lpFileName, -1);
+	r = FindFirstFileW(pw0, &a0);
+	if(r != INVALID_HANDLE_VALUE)
+	{
+		lpFindFileData->dwFileAttributes = a0.dwFileAttributes;
+		lpFindFileData->ftCreationTime = a0.ftCreationTime;
+		lpFindFileData->ftLastAccessTime = a0.ftLastAccessTime;
+		lpFindFileData->ftLastWriteTime = a0.ftLastWriteTime;
+		lpFindFileData->nFileSizeHigh = a0.nFileSizeHigh;
+		lpFindFileData->nFileSizeLow = a0.nFileSizeLow;
+		lpFindFileData->dwReserved0 = a0.dwReserved0;
+		lpFindFileData->dwReserved1 = a0.dwReserved1;
+		WtoM(lpFindFileData->cFileName, sizeof(lpFindFileData->cFileName), a0.cFileName, -1);
+		WtoM(lpFindFileData->cAlternateFileName, sizeof(lpFindFileData->cAlternateFileName), a0.cAlternateFileName, -1);
+	}
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+BOOL FindNextFileM(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
+{
+	BOOL r = FALSE;
+	WIN32_FIND_DATAW a0;
+START_ROUTINE
+	r = FindNextFileW(hFindFile, &a0);
+	if(r)
+	{
+		lpFindFileData->dwFileAttributes = a0.dwFileAttributes;
+		lpFindFileData->ftCreationTime = a0.ftCreationTime;
+		lpFindFileData->ftLastAccessTime = a0.ftLastAccessTime;
+		lpFindFileData->ftLastWriteTime = a0.ftLastWriteTime;
+		lpFindFileData->nFileSizeHigh = a0.nFileSizeHigh;
+		lpFindFileData->nFileSizeLow = a0.nFileSizeLow;
+		lpFindFileData->dwReserved0 = a0.dwReserved0;
+		lpFindFileData->dwReserved1 = a0.dwReserved1;
+		WtoM(lpFindFileData->cFileName, sizeof(lpFindFileData->cFileName), a0.cFileName, -1);
+		WtoM(lpFindFileData->cAlternateFileName, sizeof(lpFindFileData->cAlternateFileName), a0.cAlternateFileName, -1);
+	}
+END_ROUTINE
+	return r;
+}
+
+DWORD GetCurrentDirectoryM(DWORD nBufferLength, LPSTR lpBuffer)
+{
+	DWORD r = 0;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	// TODO: バッファが不十分な場合に必要なサイズを返す
+	pw0 = AllocateStringW(nBufferLength * 4);
+	GetCurrentDirectoryW(nBufferLength * 4, pw0);
+	WtoM(lpBuffer, nBufferLength, pw0, -1);
+	r = TerminateStringM(lpBuffer, nBufferLength);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+BOOL SetCurrentDirectoryM(LPCSTR lpPathName)
+{
+	BOOL r = FALSE;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(lpPathName, -1);
+	r = SetCurrentDirectoryW(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+DWORD GetTempPathM(DWORD nBufferLength, LPSTR lpBuffer)
+{
+	DWORD r = 0;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = AllocateStringW(nBufferLength * 4);
+	GetTempPathW(nBufferLength * 4, pw0);
+	WtoM(lpBuffer, nBufferLength, pw0, -1);
+	r = TerminateStringM(lpBuffer, nBufferLength);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+DWORD GetFileAttributesM(LPCSTR lpFileName)
+{
+	DWORD r = FALSE;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(lpFileName, -1);
+	r = GetFileAttributesW(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+DWORD GetModuleFileNameM(HMODULE hModule, LPCH lpFilename, DWORD nSize)
+{
+	DWORD r = 0;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = AllocateStringW(nSize * 4);
+	GetModuleFileNameW(hModule, pw0, nSize * 4);
+	WtoM(lpFilename, nSize, pw0, -1);
+	r = TerminateStringM(lpFilename, nSize);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+BOOL CopyFileM(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists)
+{
+	BOOL r = FALSE;
+	wchar_t* pw0 = NULL;
+	wchar_t* pw1 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(lpExistingFileName, -1);
+	pw1 = DuplicateMtoW(lpNewFileName, -1);
+	r = CopyFileW(pw0, pw1, bFailIfExists);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	FreeDuplicatedString(pw1);
+	return r;
+}
+
+int mkdirM(const char * _Path)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Path, -1);
+	r = _wmkdir(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int _mkdirM(const char * _Path)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Path, -1);
+	r = _wmkdir(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int rmdirM(const char * _Path)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Path, -1);
+	r = _wrmdir(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int _rmdirM(const char * _Path)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Path, -1);
+	r = _wrmdir(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int removeM(const char * _Filename)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Filename, -1);
+	r = _wremove(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int _removeM(const char * _Filename)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Filename, -1);
+	r = _wremove(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+int _unlinkM(const char * _Filename)
+{
+	int r = -1;
+	wchar_t* pw0 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Filename, -1);
+	r = _wunlink(pw0);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	return r;
+}
+
+size_t _mbslenM(const unsigned char * _Str)
+{
+	size_t r = 0;
+START_ROUTINE
+	while(GetNextCharM(_Str, &_Str) > 0)
+	{
+		r++;
+	}
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbschrM(const unsigned char * _Str, unsigned int _Ch)
+{
+	unsigned char* r = NULL;
+	unsigned int c;
+	unsigned char* p;
+START_ROUTINE
+	while((c = GetNextCharM(_Str, &p)) > 0)
+	{
+		if(c == _Ch)
+			break;
+		_Str = p;
+	}
+	if(c == _Ch)
+		r = (unsigned char*)_Str;
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbsrchrM(const unsigned char * _Str, unsigned int _Ch)
+{
+	unsigned char* r = NULL;
+	unsigned int c;
+	unsigned char* p;
+START_ROUTINE
+	while((c = GetNextCharM(_Str, &p)) > 0)
+	{
+		if(c == _Ch)
+			r = (unsigned char*)_Str;
+		_Str = p;
+	}
+	if(c == _Ch)
+		r = (unsigned char*)_Str;
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbsstrM(const unsigned char * _Str, const unsigned char * _Substr)
+{
+	unsigned char* r = NULL;
+START_ROUTINE
+	r = strstr(_Str, _Substr);
+END_ROUTINE
+	return r;
+}
+
+int _mbscmpM(const unsigned char * _Str1, const unsigned char * _Str2)
+{
+	int r = 0;
+START_ROUTINE
+	r = strcmp(_Str1, _Str2);
+END_ROUTINE
+	return r;
+}
+
+int _mbsicmpM(const unsigned char * _Str1, const unsigned char * _Str2)
+{
+	int r = 0;
+START_ROUTINE
+	r = _stricmp(_Str1, _Str2);
+END_ROUTINE
+	return r;
+}
+
+int _mbsncmpM(const unsigned char * _Str1, const unsigned char * _Str2, size_t _MaxCount)
+{
+	int r = 0;
+	DWORD c1;
+	DWORD c2;
+START_ROUTINE
+	c1 = 0;
+	c2 = 0;
+	while(_MaxCount > 0)
+	{
+		c1 = GetNextCharM(_Str1, &_Str1);
+		c2 = GetNextCharM(_Str2, &_Str2);
+		if(c1 != c2)
+			break;
+		_MaxCount--;
+		if(c1 == 0 || c2 == 0)
+			break;
+	}
+	r = c1 - c2;
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbslwrM(unsigned char * _String)
+{
+	unsigned char* r = NULL;
+START_ROUTINE
+	r = _strlwr(_String);
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbsuprM(unsigned char * _String)
+{
+	unsigned char* r = NULL;
+START_ROUTINE
+	r = _strupr(_String);
+END_ROUTINE
+	return r;
+}
+
+unsigned char * _mbsnincM(const unsigned char * _Str, size_t _Count)
+{
+	unsigned char* r = NULL;
+START_ROUTINE
+	while(_Count > 0 && GetNextCharM(_Str, &_Str) > 0)
+	{
+		_Count--;
+	}
+	r = (unsigned char*)_Str;
+END_ROUTINE
+	return r;
+}
+
+FILE * fopenM(const char * _Filename, const char * _Mode)
+{
+	FILE* r = NULL;
+	wchar_t* pw0 = NULL;
+	wchar_t* pw1 = NULL;
+START_ROUTINE
+	pw0 = DuplicateMtoW(_Filename, -1);
+	pw1 = DuplicateMtoW(_Mode, -1);
+	r = _wfopen(pw0, pw1);
+END_ROUTINE
+	FreeDuplicatedString(pw0);
+	FreeDuplicatedString(pw1);
+	return r;
+}
+

--- /dev/null
+++ b/putty/mbswrapper.h
@@ -0,0 +1,130 @@
+// mbswrapper.h
+// Copyright (C) 2011 Suguru Kawamoto
+// マルチバイト文字ワイド文字APIラッパー
+
+#ifndef __MBSWRAPPER_H__
+#define __MBSWRAPPER_H__
+
+#include <stdio.h>
+#include <windows.h>
+#include <shlobj.h>
+
+#ifndef DO_NOT_REPLACE
+
+#undef CreateFile
+#define CreateFile CreateFileM
+HANDLE CreateFileM(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
+#undef FindFirstFile
+#define FindFirstFile FindFirstFileM
+HANDLE FindFirstFileM(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData);
+#undef FindNextFile
+#define FindNextFile FindNextFileM
+BOOL FindNextFileM(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData);
+#undef GetCurrentDirectory
+#define GetCurrentDirectory GetCurrentDirectoryM
+DWORD GetCurrentDirectoryM(DWORD nBufferLength, LPSTR lpBuffer);
+#undef SetCurrentDirectory
+#define SetCurrentDirectory SetCurrentDirectoryM
+BOOL SetCurrentDirectoryM(LPCSTR lpPathName);
+#undef GetTempPath
+#define GetTempPath GetTempPathM
+DWORD GetTempPathM(DWORD nBufferLength, LPSTR lpBuffer);
+#undef GetFileAttributes
+#define GetFileAttributes GetFileAttributesM
+DWORD GetFileAttributesM(LPCSTR lpFileName);
+#undef GetModuleFileName
+#define GetModuleFileName GetModuleFileNameM
+DWORD GetModuleFileNameM(HMODULE hModule, LPCH lpFilename, DWORD nSize);
+#undef CopyFile
+#define CopyFile CopyFileM
+BOOL CopyFileM(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists);
+#undef mkdir
+#define mkdir _mkdirM
+int mkdirM(const char * _Path);
+#undef _mkdir
+#define _mkdir _mkdirM
+int _mkdirM(const char * _Path);
+#undef rmdir
+#define rmdir rmdirM
+int rmdirM(const char * _Path);
+#undef _rmdir
+#define _rmdir _rmdirM
+int _rmdirM(const char * _Path);
+#undef remove
+#define remove removeM
+int removeM(const char * _Filename);
+#undef _remove
+#define _remove _removeM
+int _removeM(const char * _Filename);
+#undef _unlink
+#define _unlink _unlinkM
+int _unlinkM(const char * _Filename);
+#undef _mbslen
+#define _mbslen _mbslenM
+size_t _mbslenM(const unsigned char * _Str);
+#undef _mbschr
+#define _mbschr _mbschrM
+unsigned char * _mbschrM(const unsigned char * _Str, unsigned int _Ch);
+#undef _mbsrchr
+#define _mbsrchr _mbsrchrM
+unsigned char * _mbsrchrM(const unsigned char * _Str, unsigned int _Ch);
+#undef _mbsstr
+#define _mbsstr _mbsstrM
+unsigned char * _mbsstrM(const unsigned char * _Str, const unsigned char * _Substr);
+#undef _mbscmp
+#define _mbscmp _mbscmpM
+int _mbscmpM(const unsigned char * _Str1, const unsigned char * _Str2);
+#undef _mbsicmp
+#define _mbsicmp _mbsicmpM
+int _mbsicmpM(const unsigned char * _Str1, const unsigned char * _Str2);
+#undef _mbsncmp
+#define _mbsncmp _mbsncmpM
+int _mbsncmpM(const unsigned char * _Str1, const unsigned char * _Str2, size_t _MaxCount);
+#undef _mbslwr
+#define _mbslwr _mbslwrM
+unsigned char * _mbslwrM(unsigned char * _String);
+#undef _mbsupr
+#define _mbsupr _mbsuprM
+unsigned char * _mbsuprM(unsigned char * _String);
+#undef _mbsninc
+#define _mbsninc _mbsnincM
+unsigned char * _mbsnincM(const unsigned char * _Str, size_t _Count);
+#undef fopen
+#define fopen fopenM
+FILE * fopenM(const char * _Filename, const char * _Mode);
+
+#endif
+
+int MtoW(LPWSTR pDst, int size, LPCSTR pSrc, int count);
+int WtoM(LPSTR pDst, int size, LPCWSTR pSrc, int count);
+int AtoW(LPWSTR pDst, int size, LPCSTR pSrc, int count);
+int WtoA(LPSTR pDst, int size, LPCWSTR pSrc, int count);
+int TerminateStringM(LPSTR lpString, int size);
+int TerminateStringW(LPWSTR lpString, int size);
+int TerminateStringA(LPSTR lpString, int size);
+size_t GetMultiStringLengthM(LPCSTR lpString);
+size_t GetMultiStringLengthW(LPCWSTR lpString);
+size_t GetMultiStringLengthA(LPCSTR lpString);
+int MtoWMultiString(LPWSTR pDst, int size, LPCSTR pSrc);
+int WtoMMultiString(LPSTR pDst, int size, LPCWSTR pSrc);
+int AtoWMultiString(LPWSTR pDst, int size, LPCSTR pSrc);
+int WtoAMultiString(LPSTR pDst, int size, LPCWSTR pSrc);
+char* AllocateStringM(int size);
+wchar_t* AllocateStringW(int size);
+char* AllocateStringA(int size);
+wchar_t* DuplicateMtoW(LPCSTR lpString, int c);
+wchar_t* DuplicateMtoWBuffer(LPCSTR lpString, int c, int size);
+wchar_t* DuplicateMtoWMultiString(LPCSTR lpString);
+wchar_t* DuplicateMtoWMultiStringBuffer(LPCSTR lpString, int size);
+char* DuplicateWtoM(LPCWSTR lpString, int c);
+wchar_t* DuplicateAtoW(LPCSTR lpString, int c);
+char* DuplicateWtoA(LPCWSTR lpString, int c);
+DWORD GetNextCharM(LPCSTR lpString, LPCSTR* ppNext);
+BOOL FixStringM(LPSTR pDst, LPCSTR pSrc);
+BOOL FixMultiStringM(LPSTR pDst, LPCSTR pSrc);
+BOOL CheckStringM(LPCSTR lpString);
+BOOL CheckMultiStringM(LPCSTR lpString);
+void FreeDuplicatedString(void* p);
+
+#endif
+

--- a/remote.c
+++ b/remote.c
@@ -742,6 +742,93 @@ int CommandProcTrn(SOCKET cSkt, char *Reply, int* CancelCheckWork, char *fmt, ..
 //#pragma aaa
 //static int cntcnt = 0;
 
+// SFTP対応
+int ConvertFTPCommandToPuTTYSFTP(SOCKET cSkt, char *Reply, int *CancelCheckWork, char *Cmd)
+{
+	// TODO:
+	// 未実装
+	int Sts;
+	char NewCmd[FMAX_PATH*2];
+	static char RenameFrom[FMAX_PATH+1];
+	Sts = 429;
+	Reply[0] = '\0';
+	if(strcmp(Cmd, "QUIT") == 0)
+	{
+		sprintf(NewCmd, "ls\r\n");
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	if(strcmp(Cmd, "LIST") == 0)
+	{
+		sprintf(NewCmd, "ls\r\n");
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "REST ", 5) == 0)
+	{
+		SFTP_SetFilePosition(cSkt, (LONGLONG)_strtoi64(&Cmd[5], NULL, 10));
+	}
+	else if(strncmp(Cmd, "RETR ", 5) == 0)
+	{
+		sprintf(NewCmd, "get \"%s\"\r\n", &Cmd[5]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "STOR ", 5) == 0)
+	{
+		sprintf(NewCmd, "put \"%s\"\r\n", &Cmd[5]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "APPE ", 5) == 0)
+	{
+		sprintf(NewCmd, "reput \"%s\"\r\n", &Cmd[5]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "DELE ", 5) == 0)
+	{
+		sprintf(NewCmd, "rm \"%s\"\r\n", &Cmd[5]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "CWD ", 4) == 0)
+	{
+		sprintf(NewCmd, "cd \"%s\"\r\n", &Cmd[4]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strcmp(Cmd, "PWD") == 0)
+	{
+		sprintf(NewCmd, "pwd\r\n");
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strcmp(Cmd, "XPWD") == 0)
+	{
+		sprintf(NewCmd, "pwd\r\n");
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "MKD ", 4) == 0)
+	{
+		sprintf(NewCmd, "mkdir \"%s\"\r\n", &Cmd[4]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "RMD ", 4) == 0)
+	{
+		sprintf(NewCmd, "rmdir \"%s\"\r\n", &Cmd[4]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "RNFR ", 5) == 0)
+	{
+		strcpy(RenameFrom, &Cmd[5]);
+	}
+	else if(strncmp(Cmd, "RNTO ", 5) == 0)
+	{
+		sprintf(NewCmd, "mv \"%s\" \"%s\"\r\n", RenameFrom, &Cmd[5]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	else if(strncmp(Cmd, "SITE CHMOD ", 11) == 0)
+	{
+		Cmd[14] = '\0';
+		sprintf(NewCmd, "chmod %s \"%s\"\r\n", &Cmd[11], &Cmd[15]);
+		SFTP_send(cSkt, NewCmd, strlen(NewCmd), 0);
+	}
+	return Sts;
+}
+
 int command(SOCKET cSkt, char *Reply, int *CancelCheckWork, char *fmt, ...)
 {
 	va_list Args;
@@ -755,6 +842,10 @@ int command(SOCKET cSkt, char *Reply, int *CancelCheckWork, char *fmt, ...)
 		wvsprintf(Cmd, fmt, Args);
 		va_end(Args);
 
+		// SFTP対応
+		if(IsSFTPAttached(cSkt))
+			return ConvertFTPCommandToPuTTYSFTP(cSkt, Reply, CancelCheckWork, Cmd);
+
 		if(strncmp(Cmd, "PASS ", 5) == 0)
 			SetTaskMsg(">PASS [xxxxxx]");
 		else if((strncmp(Cmd, "USER ", 5) == 0) ||

--- a/socket.c
+++ b/socket.c
@@ -772,7 +772,7 @@ int do_closesocket(SOCKET s)
 	UnRegistAsyncTable(s);
 	// FTPS対応
 //	Ret = closesocket(s);
-	Ret = closesocketS(s);
+	Ret = FTPS_closesocket(s);
 	if(Ret == SOCKET_ERROR)
 	{
 		Error = 0;
@@ -1029,7 +1029,7 @@ int do_recv(SOCKET s, char *buf, int len, int flags, int *TimeOutErr, int *Cance
 
 			// FTPS対応
 //			Ret = recv(s, buf, len, flags);
-			Ret = recvS(s, buf, len, flags);
+			Ret = FTPS_recv(s, buf, len, flags);
 			if(Ret != SOCKET_ERROR)
 				break;
 			Error = WSAGetLastError();
@@ -1139,7 +1139,7 @@ int do_send(SOCKET s, const char *buf, int len, int flags, int *TimeOutErr, int
 
 			// FTPS対応
 //			Ret = send(s, buf, len, flags);
-			Ret = sendS(s, buf, len, flags);
+			Ret = FTPS_send(s, buf, len, flags);
 			if(Ret != SOCKET_ERROR)
 			{
 #if DBG_MSG
@@ -1191,10 +1191,10 @@ void RemoveReceivedData(SOCKET s)
 	char buf[1024];
 	int len;
 	int Error;
-	while((len = recvS(s, buf, sizeof(buf), MSG_PEEK)) >= 0)
+	while((len = FTPS_recv(s, buf, sizeof(buf), MSG_PEEK)) >= 0)
 	{
 		AskAsyncDone(s, &Error, FD_READ);
-		recvS(s, buf, len, 0);
+		FTPS_recv(s, buf, len, 0);
 	}
 }
 

--- a/socketwrapper.c
+++ b/socketwrapper.c
@@ -16,6 +16,8 @@
 #include "mbswrapper.h"
 #include "punycode.h"
 
+// FTPS対応
+
 typedef void (__cdecl* _SSL_load_error_strings)();
 typedef int (__cdecl* _SSL_library_init)();
 typedef SSL_METHOD* (__cdecl* _SSLv23_method)();
@@ -556,24 +558,24 @@ BOOL IsSSLAttached(SOCKET s)
 	return TRUE;
 }
 
-SOCKET socketS(int af, int type, int protocol)
+SOCKET FTPS_socket(int af, int type, int protocol)
 {
 	return socket(af, type, protocol);
 }
 
-int bindS(SOCKET s, const struct sockaddr *addr, int namelen)
+int FTPS_bind(SOCKET s, const struct sockaddr *addr, int namelen)
 {
 	return bind(s, addr, namelen);
 }
 
-int listenS(SOCKET s, int backlog)
+int FTPS_listen(SOCKET s, int backlog)
 {
 	return listen(s, backlog);
 }
 
 // accept相当の関数
 // ただし初めからSSLのネゴシエーションを行う
-SOCKET acceptS(SOCKET s, struct sockaddr *addr, int *addrlen)
+SOCKET FTPS_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
 {
 	SOCKET r;
 	BOOL bAborted;
@@ -589,7 +591,7 @@ SOCKET acceptS(SOCKET s, struct sockaddr *addr, int *addrlen)
 
 // connect相当の関数
 // ただし初めからSSLのネゴシエーションを行う
-int connectS(SOCKET s, const struct sockaddr *name, int namelen)
+int FTPS_connect(SOCKET s, const struct sockaddr *name, int namelen)
 {
 	int r;
 	BOOL bAborted;
@@ -601,14 +603,14 @@ int connectS(SOCKET s, const struct sockaddr *name, int namelen)
 }
 
 // closesocket相当の関数
-int closesocketS(SOCKET s)
+int FTPS_closesocket(SOCKET s)
 {
 	DetachSSL(s);
 	return closesocket(s);
 }
 
 // send相当の関数
-int sendS(SOCKET s, const char * buf, int len, int flags)
+int FTPS_send(SOCKET s, const char * buf, int len, int flags)
 {
 	SSL** ppSSL;
 	if(!g_bOpenSSLLoaded)
@@ -622,7 +624,7 @@ int sendS(SOCKET s, const char * buf, int len, int flags)
 }
 
 // recv相当の関数
-int recvS(SOCKET s, char * buf, int len, int flags)
+int FTPS_recv(SOCKET s, char * buf, int len, int flags)
 {
 	SSL** ppSSL;
 	if(!g_bOpenSSLLoaded)
@@ -989,3 +991,340 @@ HANDLE WSAAsyncGetHostByNameIPv6M(HWND hWnd, u_int wMsg, const char * name, char
 	return r;
 }
 
+// SFTP対応
+
+typedef void* (__cdecl* _SFTP_Create)();
+typedef void (__cdecl* _SFTP_Destroy)(void*);
+typedef BOOL (__cdecl* _SFTP_IsExited)(void*);
+typedef BOOL (__cdecl* _SFTP_SetTimeoutCallback)(void*, void*);
+typedef size_t (__cdecl* _SFTP_PeekStdOut)(void*, void*, size_t);
+typedef size_t (__cdecl* _SFTP_ReadStdOut)(void*, void*, size_t);
+typedef size_t (__cdecl* _SFTP_WriteStdIn)(void*, const void*, size_t);
+typedef size_t (__cdecl* _SFTP_PeekDataOut)(void*, void*, size_t);
+typedef size_t (__cdecl* _SFTP_ReadDataOut)(void*, void*, size_t);
+typedef size_t (__cdecl* _SFTP_WriteDataIn)(void*, const void*, size_t);
+typedef BOOL (__cdecl* _SFTP_SetFilePosition)(void*, LONGLONG);
+
+_SFTP_Create p_SFTP_Create;
+_SFTP_Destroy p_SFTP_Destroy;
+_SFTP_IsExited p_SFTP_IsExited;
+_SFTP_SetTimeoutCallback p_SFTP_SetTimeoutCallback;
+_SFTP_PeekStdOut p_SFTP_PeekStdOut;
+_SFTP_ReadStdOut p_SFTP_ReadStdOut;
+_SFTP_WriteStdIn p_SFTP_WriteStdIn;
+_SFTP_PeekDataOut p_SFTP_PeekDataOut;
+_SFTP_ReadDataOut p_SFTP_ReadDataOut;
+_SFTP_WriteDataIn p_SFTP_WriteDataIn;
+_SFTP_SetFilePosition p_SFTP_SetFilePosition;
+
+typedef struct
+{
+	SOCKET Control;
+	SOCKET Data;
+	void* Handle;
+	char Host[1024];
+	int Port;
+	char User[1024];
+	char Password[1024];
+} SFTPDATA;
+
+#define MAX_SFTP_SOCKET 16
+
+BOOL g_bPuTTYLoaded;
+HMODULE g_hPuTTY;
+CRITICAL_SECTION g_PuTTYLock;
+SFTPDATA g_SFTPData[MAX_SFTP_SOCKET];
+
+// PuTTYを初期化
+BOOL LoadPuTTY()
+{
+	int i;
+	if(g_bPuTTYLoaded)
+		return FALSE;
+#ifdef ENABLE_PROCESS_PROTECTION
+	// ビルドしたputty.dllに合わせてSHA1ハッシュ値を変更すること
+	RegisterTrustedModuleSHA1Hash("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
+#endif
+//	g_hPuTTY = LoadLibrary("putty.dll");
+	g_hPuTTY = LoadLibrary("C:\\SourceForge\\ffftp\\putty\\Debug\\PuTTY.dll");
+	if(!g_hPuTTY
+		|| !(p_SFTP_Create = (_SFTP_Create)GetProcAddress(g_hPuTTY, "SFTP_Create"))
+		|| !(p_SFTP_Destroy = (_SFTP_Destroy)GetProcAddress(g_hPuTTY, "SFTP_Destroy"))
+		|| !(p_SFTP_IsExited = (_SFTP_IsExited)GetProcAddress(g_hPuTTY, "SFTP_IsExited"))
+		|| !(p_SFTP_SetTimeoutCallback = (_SFTP_SetTimeoutCallback)GetProcAddress(g_hPuTTY, "SFTP_SetTimeoutCallback"))
+		|| !(p_SFTP_PeekStdOut = (_SFTP_PeekStdOut)GetProcAddress(g_hPuTTY, "SFTP_PeekStdOut"))
+		|| !(p_SFTP_ReadStdOut = (_SFTP_ReadStdOut)GetProcAddress(g_hPuTTY, "SFTP_ReadStdOut"))
+		|| !(p_SFTP_WriteStdIn = (_SFTP_WriteStdIn)GetProcAddress(g_hPuTTY, "SFTP_WriteStdIn"))
+		|| !(p_SFTP_PeekDataOut = (_SFTP_PeekDataOut)GetProcAddress(g_hPuTTY, "SFTP_PeekDataOut"))
+		|| !(p_SFTP_ReadDataOut = (_SFTP_ReadDataOut)GetProcAddress(g_hPuTTY, "SFTP_ReadDataOut"))
+		|| !(p_SFTP_WriteDataIn = (_SFTP_WriteDataIn)GetProcAddress(g_hPuTTY, "SFTP_WriteDataIn"))
+		|| !(p_SFTP_SetFilePosition = (_SFTP_SetFilePosition)GetProcAddress(g_hPuTTY, "SFTP_SetFilePosition")))
+	{
+		if(g_hPuTTY)
+			FreeLibrary(g_hPuTTY);
+		g_hPuTTY = NULL;
+		return FALSE;
+	}
+	for(i = 0; i < MAX_SFTP_SOCKET; i++)
+	{
+		g_SFTPData[i].Control = INVALID_SOCKET;
+		g_SFTPData[i].Data = INVALID_SOCKET;
+	}
+	InitializeCriticalSection(&g_PuTTYLock);
+	g_bPuTTYLoaded = TRUE;
+	return TRUE;
+}
+
+// PuTTYを解放
+void FreePuTTY()
+{
+	int i;
+	if(!g_bPuTTYLoaded)
+		return;
+	EnterCriticalSection(&g_PuTTYLock);
+	for(i = 0; i < MAX_SFTP_SOCKET; i++)
+	{
+		if(g_SFTPData[i].Control != INVALID_SOCKET)
+		{
+			closesocket(g_SFTPData[i].Control);
+			g_SFTPData[i].Control = INVALID_SOCKET;
+			p_SFTP_Destroy(g_SFTPData[i].Handle);
+		}
+		if(g_SFTPData[i].Data != INVALID_SOCKET)
+		{
+			closesocket(g_SFTPData[i].Data);
+			g_SFTPData[i].Data = INVALID_SOCKET;
+		}
+	}
+	FreeLibrary(g_hPuTTY);
+	g_hPuTTY = NULL;
+	LeaveCriticalSection(&g_PuTTYLock);
+	DeleteCriticalSection(&g_PuTTYLock);
+	g_bPuTTYLoaded = FALSE;
+}
+
+// PuTTYが使用可能かどうか確認
+BOOL IsPuTTYLoaded()
+{
+	return g_bPuTTYLoaded;
+}
+
+SFTPDATA* GetUnusedSFTPData()
+{
+	int i;
+	for(i = 0; i < MAX_SFTP_SOCKET; i++)
+	{
+		if(g_SFTPData[i].Control == INVALID_SOCKET)
+		{
+			memset(&g_SFTPData[i], 0, sizeof(SFTPDATA));
+			return &g_SFTPData[i];
+		}
+	}
+	return NULL;
+}
+
+SFTPDATA* FindSFTPDataFromSocket(SOCKET s)
+{
+	int i;
+	for(i = 0; i < MAX_SFTP_SOCKET; i++)
+	{
+		if(g_SFTPData[i].Control == s || g_SFTPData[i].Data == s)
+			return &g_SFTPData[i];
+	}
+	return NULL;
+}
+
+// SFTPとしてマークされているか確認
+// マークされていればTRUEを返す
+BOOL IsSFTPAttached(SOCKET s)
+{
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return FALSE;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return FALSE;
+	return TRUE;
+}
+
+// コントロール用の仮想的なソケットを取得
+// 識別子としてダミーのソケットを返す
+SOCKET SFTP_socket(int af, int type, int protocol)
+{
+	SOCKET r;
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return INVALID_SOCKET;
+	r = INVALID_SOCKET;
+	EnterCriticalSection(&g_PuTTYLock);
+	if(pSFTPData = GetUnusedSFTPData())
+	{
+		r = socket(af, type, protocol);
+		pSFTPData->Control = r;
+		pSFTPData->Data = INVALID_SOCKET;
+		pSFTPData->Handle = p_SFTP_Create();
+	}
+	LeaveCriticalSection(&g_PuTTYLock);
+	return r;
+}
+
+int SFTP_bind(SOCKET s, const struct sockaddr *addr, int namelen)
+{
+	return SOCKET_ERROR;
+}
+
+int SFTP_listen(SOCKET s, int backlog)
+{
+	return SOCKET_ERROR;
+}
+
+// accept相当の関数
+SOCKET SFTP_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
+{
+	return INVALID_SOCKET;
+}
+
+// connect相当の関数
+int SFTP_connect(SOCKET s, const struct sockaddr *name, int namelen)
+{
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return SOCKET_ERROR;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return SOCKET_ERROR;
+	if(namelen == sizeof(struct sockaddr_in))
+	{
+	}
+	else if(namelen == sizeof(struct sockaddr_in6))
+	{
+	}
+	else
+		return SOCKET_ERROR;
+	return 0;
+}
+
+// closesocket相当の関数
+int SFTP_closesocket(SOCKET s)
+{
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return SOCKET_ERROR;
+	EnterCriticalSection(&g_PuTTYLock);
+	if(pSFTPData = FindSFTPDataFromSocket(s))
+	{
+		if(pSFTPData->Control == s)
+		{
+			pSFTPData->Control = INVALID_SOCKET;
+			p_SFTP_Destroy(pSFTPData->Handle);
+		}
+		if(pSFTPData->Data == s)
+			pSFTPData->Data = INVALID_SOCKET;
+	}
+	LeaveCriticalSection(&g_PuTTYLock);
+	return closesocket(s);
+}
+
+// send相当の関数
+int SFTP_send(SOCKET s, const char * buf, int len, int flags)
+{
+	int r;
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return SOCKET_ERROR;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return SOCKET_ERROR;
+	if(p_SFTP_IsExited(pSFTPData->Handle))
+		return SOCKET_ERROR;
+	r = SOCKET_ERROR;
+	if(pSFTPData->Control == s)
+		r = (int)p_SFTP_WriteStdIn(pSFTPData->Handle, buf, len);
+	else if(pSFTPData->Data == s)
+		r = (int)p_SFTP_WriteDataIn(pSFTPData->Handle, buf, len);
+	return r;
+}
+
+// recv相当の関数
+int SFTP_recv(SOCKET s, char * buf, int len, int flags)
+{
+	int r;
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return SOCKET_ERROR;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return SOCKET_ERROR;
+	if(p_SFTP_IsExited(pSFTPData->Handle))
+		return SOCKET_ERROR;
+	r = SOCKET_ERROR;
+	if(pSFTPData->Control == s)
+	{
+		if(flags & MSG_PEEK)
+			r = (int)p_SFTP_PeekStdOut(pSFTPData->Handle, buf, len);
+		else
+			r = (int)p_SFTP_ReadStdOut(pSFTPData->Handle, buf, len);
+	}
+	else if(pSFTPData->Data == s)
+	{
+		if(flags & MSG_PEEK)
+			r = (int)p_SFTP_PeekDataOut(pSFTPData->Handle, buf, len);
+		else
+			r = (int)p_SFTP_ReadDataOut(pSFTPData->Handle, buf, len);
+	}
+	return r;
+}
+
+BOOL SFTP_SetTimeoutCallback(SOCKET s, void* pCallback)
+{
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return FALSE;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return FALSE;
+	return p_SFTP_SetTimeoutCallback(pSFTPData->Handle, pCallback);
+}
+
+// データ用の仮想的なソケットを取得
+// 識別子としてダミーのソケットを返す
+SOCKET SFTP_GetDataHandle(SOCKET s, int af, int type, int protocol)
+{
+	SOCKET r;
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return INVALID_SOCKET;
+	r = INVALID_SOCKET;
+	EnterCriticalSection(&g_PuTTYLock);
+	if(pSFTPData = FindSFTPDataFromSocket(s))
+	{
+		r = socket(af, type, protocol);
+		pSFTPData->Data = r;
+	}
+	LeaveCriticalSection(&g_PuTTYLock);
+	return r;
+}
+
+BOOL SFTP_SetFilePosition(SOCKET s, LONGLONG Position)
+{
+	SFTPDATA* pSFTPData;
+	if(!g_bPuTTYLoaded)
+		return FALSE;
+	EnterCriticalSection(&g_PuTTYLock);
+	pSFTPData = FindSFTPDataFromSocket(s);
+	LeaveCriticalSection(&g_PuTTYLock);
+	if(!pSFTPData)
+		return FALSE;
+	return p_SFTP_SetFilePosition(pSFTPData->Handle, Position);
+}
+

--- a/socketwrapper.h
+++ b/socketwrapper.h
@@ -23,14 +23,14 @@ BOOL IsHostNameMatched(LPCSTR HostName, LPCSTR CommonName);
 BOOL AttachSSL(SOCKET s, SOCKET parent, BOOL* pbAborted);
 BOOL DetachSSL(SOCKET s);
 BOOL IsSSLAttached(SOCKET s);
-SOCKET socketS(int af, int type, int protocol);
-int bindS(SOCKET s, const struct sockaddr *addr, int namelen);
-int listenS(SOCKET s, int backlog);
-SOCKET acceptS(SOCKET s, struct sockaddr *addr, int *addrlen);
-int connectS(SOCKET s, const struct sockaddr *name, int namelen);
-int closesocketS(SOCKET s);
-int sendS(SOCKET s, const char * buf, int len, int flags);
-int recvS(SOCKET s, char * buf, int len, int flags);
+SOCKET FTPS_socket(int af, int type, int protocol);
+int FTPS_bind(SOCKET s, const struct sockaddr *addr, int namelen);
+int FTPS_listen(SOCKET s, int backlog);
+SOCKET FTPS_accept(SOCKET s, struct sockaddr *addr, int *addrlen);
+int FTPS_connect(SOCKET s, const struct sockaddr *name, int namelen);
+int FTPS_closesocket(SOCKET s);
+int FTPS_send(SOCKET s, const char * buf, int len, int flags);
+int FTPS_recv(SOCKET s, char * buf, int len, int flags);
 
 HANDLE WSAAsyncGetHostByNameIPv6(HWND hWnd, u_int wMsg, const char * name, char * buf, int buflen, short Family);
 int WSACancelAsyncRequestIPv6(HANDLE hAsyncTaskHandle);
@@ -40,5 +40,21 @@ struct in6_addr inet6_addr(const char* cp);
 HANDLE WSAAsyncGetHostByNameM(HWND hWnd, u_int wMsg, const char * name, char * buf, int buflen);
 HANDLE WSAAsyncGetHostByNameIPv6M(HWND hWnd, u_int wMsg, const char * name, char * buf, int buflen, short Family);
 
+BOOL LoadPuTTY();
+void FreePuTTY();
+BOOL IsPuTTYLoaded();
+BOOL IsSFTPAttached(SOCKET s);
+SOCKET SFTP_socket(int af, int type, int protocol);
+int SFTP_bind(SOCKET s, const struct sockaddr *addr, int namelen);
+int SFTP_listen(SOCKET s, int backlog);
+SOCKET SFTP_accept(SOCKET s, struct sockaddr *addr, int *addrlen);
+int SFTP_connect(SOCKET s, const struct sockaddr *name, int namelen);
+int SFTP_closesocket(SOCKET s);
+int SFTP_send(SOCKET s, const char * buf, int len, int flags);
+int SFTP_recv(SOCKET s, char * buf, int len, int flags);
+BOOL SFTP_SetTimeoutCallback(SOCKET s, void* pCallback);
+SOCKET SFTP_GetDataHandle(SOCKET s, int af, int type, int protocol);
+BOOL SFTP_SetFilePosition(SOCKET s, LONGLONG Position);
+
 #endif