sftp/Test.cpp

#include "StdAfx.h"
#include "Test.h"
#include "UnixPath.h"

#include <format>

_Check_return_ HRESULT CTest::Initialize()
{
	const auto hr{ m_Connection.CoCreateInstance(__uuidof(sfFTPLib::SSHConnection)) };
	if (SUCCEEDED(hr))
	{
		return S_OK;
	}
	Log(L"Failed to create SFTPConnection instance. hr=0x%x.\nTry to register sfFTPLib.dll again.", hr);
	ATLASSERT(false);

	ATL::CComPtr<sfFTPLib::IGlobal> global;
	ATLENSURE_SUCCEEDED(global.CoCreateInstance(__uuidof(sfFTPLib::Global)));
	// If LoadLicense is not called a trial license is automatically obtained from the activation server. The FTP Library uses WinHTTP to access
	// the activation server at www.smartftp.com (TLS, port 443). Ensure that your application is not blocked by any firewall.
	// TODO: insert the provided serial after the purchase of a license
	//ATLENSURE_SUCCEEDED(global->LoadLicense(ATL::CComBSTR(L"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")));

	return hr;
}

_Check_return_ HRESULT CTest::Uninitialize()
{
	m_Connection.Release();
	return S_OK;
}

void CTest::ReportLastStatus()
{
	sfFTPLib::SFTPStatus statusCode;
	ATLENSURE_SUCCEEDED(m_SFTP->get_LastStatusCode(&statusCode));
	Log(L"LastStatusCode = %d.", statusCode);
	ATL::CComBSTR statusMessage;
	ATLENSURE_SUCCEEDED(m_SFTP->get_LastStatusMessage(&statusMessage));
	Log(L"LastStatusMessage = \"%s\".", (PCWSTR)statusMessage);
}

// Purpose: Converts FILETIME to ISO8601 string
_Check_return_ HRESULT CTest::FILETIMEToISO8601(const FILETIME& ft, std::wstring& retval)
{
	SYSTEMTIME st;
	if (::FileTimeToSystemTime(&ft, &st))
	{
		retval.resize(255);
		retval.resize(std::swprintf(retval.data(), retval.size() + 1, L"%04hu-%02hu-%02huT%02hu:%02hu:%02huZ", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond));
		return S_OK;
	}
	return E_FAIL;
}

void CTest::Run()
{
	const wchar_t host []{ L"localhost" };
	const long port{ 22 };
	const wchar_t username []{ L"user" };
	const wchar_t password []{ L"pass" };

	//m_Connection->Async = VARIANT_FALSE;
	ATLENSURE_SUCCEEDED(m_Connection->put_Host(ATL::CComBSTR(host)));
	ATLENSURE_SUCCEEDED(m_Connection->put_Port(port));
	ATLENSURE_SUCCEEDED(m_Connection->put_Username(ATL::CComBSTR(username)));
	ATLENSURE_SUCCEEDED(m_Connection->put_Password(ATL::CComBSTR(password)));

	ATL::CComPtr<sfFTPLib::IFileLogger> fileLogger;
	ATLENSURE_SUCCEEDED(fileLogger.CoCreateInstance(__uuidof(sfFTPLib::FileLogger)));
	ATLENSURE_SUCCEEDED(fileLogger->put_File(ATL::CComBSTR(L"ssh.log")));

	ATL::CComQIPtr<sfFTPLib::ILogger> logger{ fileLogger };
	ATLENSURE_SUCCEEDED(m_Connection->put_Logger(logger));

	// Authentication
	// Notes:
	// - Titan FTP Server: If "publickey" authentication fails the server disconnects without accepting any further methods. e.g. password
	ATL::CComSafeArray<VARIANT> authentications(2);
	//authentications.SetAt(0, ATL::CComVariant(sfFTPLib::ftpSSHAuthenticationNone));
	authentications.SetAt(0, ATL::CComVariant(sfFTPLib::ftpSSHAuthenticationPassword));
	authentications.SetAt(1, ATL::CComVariant(sfFTPLib::ftpSSHAuthenticationPublicKey));
	//ATLENSURE_SUCCEEDED(m_Connection->put_Authentications(&ATL::CComVariant(authentications)));

	// Disable Compression
	// Uncomment to disable compression
	ATL::CComSafeArray<VARIANT> compressions(2);
	compressions.SetAt(0, ATL::CComVariant(sfFTPLib::ftpSSHCompressionzlibopenssh));
	compressions.SetAt(0, ATL::CComVariant(sfFTPLib::ftpSSHCompressionNone));
	//m_Connection->put_Compressions(&ATL::CComVariant(compressions));

	// Limit Encryptions
	ATL::CComSafeArray<VARIANT> encryptions(4);
	encryptions.SetAt(0, ATL::CComVariant(sfFTPLib::ftpEncryptionAES256CTR));
	encryptions.SetAt(1, ATL::CComVariant(sfFTPLib::ftpEncryptionAES192CTR));
	encryptions.SetAt(2, ATL::CComVariant(sfFTPLib::ftpEncryptionAES128CTR));
	encryptions.SetAt(3, ATL::CComVariant(sfFTPLib::ftpEncryption3DES));
	//m_Connection->put_Encryptions(&ATL::CComVariant(encryptions));

	// Limit KeyExchange Algorithms
	ATL::CComSafeArray<VARIANT> keyexchanges(2);
	keyexchanges.SetAt(0, ATL::CComVariant(sfFTPLib::ftpKeyExchangeDiffieHellmanGroup14SHA1));
	//m_Connection->put_KeyExchanges(&ATL::CComVariant(keyexchanges));

	ATL::CComPtr<sfFTPLib::IKeyManager> keyManager;
	ATLENSURE_SUCCEEDED(keyManager.CoCreateInstance(__uuidof(sfFTPLib::KeyManager)));
	
	// Uncomment to generate new key
	ATL::CComBSTR bstrFilePrivate(L"Identity");
	ATL::CComBSTR bstrFilePublic(L"Identity.pub");
	ATL::CComBSTR bstrPassword(L"");

#if 0
	// Uncomment to create private key
	// -> broken
	// For VShell copy public key (Identity.pub) to user's folder: C:\Program Files\VShell\PublicKey\<user>
	ATL::CComPtr<sfFTPLib::OpenSSLKey> pRSA;
	ATLENSURE_SUCCEEDED(pRSA.CoCreateInstance(__uuidof(sfFTPLib::OpenSSLKey)));

	// Generate 2048-bit RSA key
	pRSA->Generate(2048);
	// Save private key in PKCS12 format (.p12)
	ATLENSURE_SUCCEEDED(keyManager->SaveFile(sfFTPLib::ftpKeyFileFormatPKCS12, pRSA, sfFTPLib::ftpKeyTypePrivateKey, bstrFilePrivate, bstrPassword));
	// Save public key. Password is ignored.
	ATLENSURE_SUCCEEDED(keyManager->SaveFile(sfFTPLib::ftpKeyFileFormatSSH, pRSA, sfFTPLib::ftpKeyTypePublicKey, bstrFilePublic, bstrPassword));
	// Save public key (for OpenSSH only). Password is ignored.
	//ATLENSURE_SUCCEEDED(keyManager->SaveFile(sfFTPLib::ftpKeyFileFormatOpenSSH, pRSA, sfFTPLib::ftpKeyTypePublicKey, bstrFilePublic, bstrPassword);
#endif

	Log(L"Loading private key \"%s\".", (PCWSTR) bstrFilePrivate);
	ATL::CComPtr<sfFTPLib::IKey> key;
	if (keyManager->LoadFile(bstrFilePrivate, bstrPassword, &key) == S_OK)
	{
		sfFTPLib::KeyType keyType;
		ATLENSURE_SUCCEEDED(key->get_Type(&keyType));
		if (keyType == sfFTPLib::ftpKeyTypePrivateKey)
		{
			m_Connection->put_PrivateKey(key);
			Log(L"Private key successfully loaded from \"%s\".", (PCWSTR) bstrFilePrivate);
		}
	}
	else
	{
		Log(L"Failed to load key.");
	}

	Log(L"Connecting to %s Port: %u", (PCWSTR)host, port);
	ATLENSURE_SUCCEEDED(m_Connection->Connect());

	ATL::CComPtr<sfFTPLib::ISSHServerState> serverState;
	ATLENSURE_SUCCEEDED(m_Connection->get_ServerState(&serverState));
	ATL::CComBSTR remoteId;
	ATLENSURE_SUCCEEDED(serverState->get_RemoteId(&remoteId));
	Log(L"%s", (PCWSTR) remoteId);

	SFTPTest();

	// Disconnect
	Log(L"Disconnect");
	ATLENSURE_SUCCEEDED(m_Connection->Disconnect());
}

void CTest::SFTPTest()
{
	ATLENSURE_SUCCEEDED(m_Connection->CreateSFTPConnection(&m_SFTP));

	ATL::CComPtr<sfFTPLib::IFileLogger> fileLogger;
	ATLENSURE_SUCCEEDED(fileLogger.CoCreateInstance(__uuidof(sfFTPLib::FileLogger)));
	fileLogger->put_File(ATL::CComBSTR(L"sftp.log"));

	ATL::CComQIPtr<sfFTPLib::ILogger> logger{ fileLogger };
	ATLENSURE_SUCCEEDED(m_SFTP->put_Logger(logger));

	ATLENSURE_SUCCEEDED(m_SFTP->Connect());

	Log(L"SFTP channel successfully opened.");

	// get current folder
	ATL::CComBSTR realPath = L".";
	Log(L"RealPath \"%s\"", (PCWSTR)realPath);

	ATL::CComBSTR currentFolder;
	ATLENSURE_SUCCEEDED(m_SFTP->RealPath(realPath, &currentFolder));
	Log(L"Home Folder = %s", (PCWSTR)currentFolder);

	// overriding currentFolder for debug purpose
	//currentFolder = L"/c/archive";
	//Log(L"Overriding current folder. \"%s\"", (PCWSTR)currentFolder);

	Log(L"Reading Directory \"%s\"", (PCWSTR)currentFolder);

	ATL::CComPtr<sfFTPLib::IFTPItems> items;
	ATLENSURE_SUCCEEDED(m_SFTP->ReadDirectory(currentFolder, &items));

	long count;
	ATLENSURE_SUCCEEDED(items->get_Count(&count));
	Log(L"Count = %d", count);

	// Enum
	if (count > 0)
	{
		ATL::CComPtr<IUnknown> unkEnum;
		ATLENSURE_SUCCEEDED(items->get__NewEnum(&unkEnum));
		ATL::CComQIPtr<IEnumVARIANT> pEnum(unkEnum);

		ULONG fetched;
		ATL::CComVariant variant;
		while (pEnum->Next(1, &variant, &fetched) == S_OK)
		{
			if (variant.vt == VT_DISPATCH
				|| variant.vt == VT_UNKNOWN)
			{
				ATL::CComQIPtr<sfFTPLib::IFTPItem> ftpItem{ variant.pdispVal };

				// TODO: Check for valid attributes (IsValidAttribute())
				sfFTPLib::ItemType itemType;
				ATLENSURE_SUCCEEDED(ftpItem->get_Type(&itemType));
				ATL::CComBSTR itemName;
				ATLENSURE_SUCCEEDED(ftpItem->get_Name(&itemName));
				ULONGLONG itemSize{ 0 };
				// ignore result
				ftpItem->get_Size(&itemSize);

				auto str{ std::format(L"Type={:#x}; Name={}; Size={}", static_cast<unsigned int>(itemType), itemName.operator LPWSTR(), itemSize)};

				VARIANT_BOOL isValidAttribute;
				ATLENSURE_SUCCEEDED(ftpItem->IsValidAttribute(sfFTPLib::ftpFTPItemAttributeModifyTime, &isValidAttribute));
				if (isValidAttribute)
				{
					FILETIME modifyTime;
					ATLENSURE_SUCCEEDED(ftpItem->get_ModifyTime(&modifyTime));
					std::wstring modifyTimeAsString;
					if (FILETIMEToISO8601(modifyTime, modifyTimeAsString) == S_OK)
					{
						str += L"; ModifyTime=";
						str += modifyTimeAsString;
					}
				}

				Log(str.c_str());
			}

			variant.Clear();
		}
	}

	// MakeDirectory
	CUnixPath makeDirectory{ (PCWSTR) currentFolder };
	makeDirectory.Append(L"testfolder");
	Log(L"MakeDirectory \"%s\"", (PCWSTR)makeDirectory);
	ATLENSURE_SUCCEEDED(m_SFTP->MakeDirectory(ATL::CComBSTR(makeDirectory)));
	Log(L"Directory \"%s\" created.", (PCWSTR)makeDirectory);

	// Rename
	CUnixPath renameFrom{ makeDirectory };
	CUnixPath renameTo{ (PCWSTR)currentFolder };
	renameTo.Append(L"testfolder2");
	Log(L"Rename \"%s\" to \"%s\"", (PCWSTR)renameFrom, (PCWSTR)renameTo);
	ATLENSURE_SUCCEEDED(m_SFTP->Rename(ATL::CComBSTR(renameFrom), ATL::CComBSTR(renameTo), 0));

	// RemoveDirectory
	CUnixPath directoryToRemove{ renameTo };
	Log(L"RemoveDirectory \"%s\"", (PCWSTR) directoryToRemove);
	ATLENSURE_SUCCEEDED(m_SFTP->RemoveDirectory(ATL::CComBSTR(directoryToRemove)));
	Log(L"Directory \"%s\" removed.", (PCWSTR) directoryToRemove);

	// Creating temporary memory file
	ATL::CComPtr<IStream> memFile;
	static const DWORD dwSize{ 1000 * 1024 }; // 1000 KiB
	ATLENSURE_SUCCEEDED(CreateMemFile(dwSize, 0, &memFile));

	// Upload File
	CUnixPath UploadFile((PCWSTR) currentFolder);
	UploadFile.Append(L"memfile");
	ATL::CComBSTR bstrUploadFile{ (PCWSTR) UploadFile };

	Log(L"UploadFile to \"%s\"", (PCWSTR) bstrUploadFile);
	ATLENSURE_SUCCEEDED(m_SFTP->UploadFileEx(ATL::CComVariant(memFile.p), bstrUploadFile, sfFTPLib::ftpDataTransferTypeImage, 0, nullptr));
	Log(L"File successfully uploaded.");

	// Stat. Stat doesn't follow symbolic links.
	ATL::CComBSTR bstrStat = bstrUploadFile;
	Log(L"Stat \"%s\"", (PCWSTR) bstrStat);
	ATL::CComPtr<sfFTPLib::IFTPItem> item;
	ATLENSURE_SUCCEEDED(m_SFTP->Stat(bstrStat, sfFTPLib::ftpFTPItemAttributeSize, &item));
	VARIANT_BOOL isValidAttribute;
	ATLENSURE_SUCCEEDED(item->IsValidAttribute(sfFTPLib::ftpFTPItemAttributeSize, &isValidAttribute));
	if (isValidAttribute)
	{
		ULONGLONG size;
		ATLENSURE_SUCCEEDED(item->get_Size(&size));
		Log(L"File Size = %I64u.", size);
	}
	// DownloadFile to memory file
	ATL::CComPtr<IStream> pDownloadMemFile;
	if (CreateMemFile(dwSize, 0, &pDownloadMemFile) == S_OK)
	{
		ATL::CComBSTR bstrDownloadFile{ bstrUploadFile };
		Log(L"DownloadFile \"%s\" to memfile", (PCWSTR) bstrDownloadFile);
		ATLENSURE_SUCCEEDED(m_SFTP->DownloadFileEx(bstrDownloadFile, ATL::CComVariant(pDownloadMemFile.p), sfFTPLib::ftpDataTransferTypeImage, 0, 0, sfFTPLib::ftpDownloadFlagReadBeyondEnd, nullptr));
		Log(L"File successfully downloaded.");
	}

	// DownloadFile to physical file
	ATL::CComBSTR bstrDownloadFile{ bstrUploadFile };
	wchar_t szCurrentDirectory[MAX_PATH]{};
	::GetCurrentDirectoryW(ARRAYSIZE(szCurrentDirectory), szCurrentDirectory);
	::PathAppendW(szCurrentDirectory, L"Download");
	::SHCreateDirectoryExW(nullptr, szCurrentDirectory, nullptr);
	::PathAppendW(szCurrentDirectory, L"memfile");
	ATL::CComBSTR downloadLocalFile{ szCurrentDirectory };
	Log(L"DownloadFile \"%s\" to \"%s\"", (PCWSTR) bstrDownloadFile, (PCWSTR) downloadLocalFile);
	ATLENSURE_SUCCEEDED(m_SFTP->DownloadFileEx(bstrDownloadFile, ATL::CComVariant(szCurrentDirectory), sfFTPLib::ftpDataTransferTypeImage, 0, MAXULONGLONG, sfFTPLib::ftpDownloadFlagReadBeyondEnd, nullptr));
	Log(L"File successfully downloaded.");

	Log(L"Closing channel.");
	ATLENSURE_SUCCEEDED(m_SFTP->Disconnect());
}

void CTest::Log(_In_z_ PCWSTR format, ...)
{
	// max limit of log message set to 4096. Increase if message gets cut.
	const int LOG_EVENT_MSG_SIZE = 4096;

	wchar_t chMsg[LOG_EVENT_MSG_SIZE];
	va_list pArg;

	va_start(pArg, format);
	_vsntprintf_s(chMsg, LOG_EVENT_MSG_SIZE, LOG_EVENT_MSG_SIZE-1, format, pArg);

	std::wstring message{ chMsg };
	message += L"\n";
	ATLTRACE(message.c_str());
	_tprintf(message.c_str());
}

// Purpose: Creates memory file with Global Memory (GlobalAlloc)
// nFillMethod: 0: zero data, 1: fill with 0-255
_Check_return_ HRESULT CTest::CreateMemFile(DWORD nSize, int fillMethod, _COM_Outptr_ IStream **retval)
{
	*retval = nullptr;

	const auto hMem{ ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, static_cast<SIZE_T>(nSize)) };
	if (!hMem)
	{
		return E_OUTOFMEMORY;
	}

	const auto pImage{ reinterpret_cast<BYTE*>(::GlobalLock(hMem)) };
	if (pImage)
	{
		if (fillMethod == 1)
		{
			// fill with 0-255
			for (DWORD i = 0; i < nSize; i++)
			{
				pImage[i] = static_cast<BYTE>(i);
			}
		}
		::GlobalUnlock(hMem);

		// Create Stream from hMem. Automatically release hMem
		return ::CreateStreamOnHGlobal(hMem, TRUE, retval);
	}
	return E_FAIL;
}