path: root/Src/omBrowser/addressEncoder.cpp

#include "main.h"
#include "./addressEncoder.h"


#include <wininet.h>
#include <strsafe.h>


typedef struct __ENCODEBUFFER
{
	LPWSTR buffer;
	size_t bufferMax;
	LPWSTR cursor;
	size_t remaining; 
} ENCODEBUFFER;

HRESULT AddressEncoder_ReAllocBuffer(ENCODEBUFFER *decoder, size_t cchBufferSize)
{
	if (NULL == decoder) 
		return E_INVALIDARG;

	if (cchBufferSize == decoder->bufferMax)
		return S_FALSE;

	if (cchBufferSize < decoder->bufferMax)
		return E_FAIL;

	LPWSTR test = Plugin_ReAllocString(decoder->buffer, cchBufferSize);
	if (NULL == test)
		return E_OUTOFMEMORY;
		
	decoder->cursor = test  + (decoder->cursor - decoder->buffer);
	decoder->remaining += (cchBufferSize - decoder->bufferMax); 
	decoder->buffer = test;
	decoder->bufferMax = cchBufferSize;
	
	return S_OK;
}
HRESULT AddressEncoder_AppendAnsiString(ENCODEBUFFER *decoder, LPCSTR pszString, size_t cchString)
{
	if (NULL == decoder)
		return E_INVALIDARG;

	INT cchConverted; 
	while(0 ==(cchConverted = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, pszString, (int)cchString, decoder->cursor, (int)decoder->remaining)))
	{
		DWORD errorCode = GetLastError();
		if (ERROR_INSUFFICIENT_BUFFER == errorCode)
		{
			INT cchNeed = MultiByteToWideChar(CP_UTF8, 0, pszString, (int)cchString, NULL, 0) - (INT)decoder->remaining;
			if (cchNeed < 32) cchNeed = 32;
			HRESULT hr = AddressEncoder_ReAllocBuffer(decoder, decoder->bufferMax + cchNeed);
			if (FAILED(hr)) 
				return hr;
		}
		else
		{
			return HRESULT_FROM_WIN32(errorCode);
		}
	}

	if (0 != cchConverted)
	{
		decoder->cursor += cchConverted;
		decoder->remaining -= cchConverted;
	}

	return S_OK;
}

HRESULT AddressEncoder_AppendString(ENCODEBUFFER *decoder, LPCWSTR pszString, size_t cchString)
{
	if (NULL == decoder)
		return E_INVALIDARG;

	LPWSTR cursor;
	size_t remaining;

	HRESULT hr;
	if (cchString >= decoder->remaining)
	{
		hr = AddressEncoder_ReAllocBuffer(decoder, decoder->bufferMax + (cchString - decoder->remaining) + 1);
		if (FAILED(hr)) return hr;
	}

	hr = StringCchCopyNEx(decoder->cursor, decoder->remaining, pszString, cchString, &cursor, &remaining, 0);
	if (SUCCEEDED(hr))
	{
		decoder->cursor = cursor;
		decoder->remaining = remaining;
	}
	return hr;
}

HRESULT AddressEncoder_GetEscapeBlock(LPCWSTR pszEscape, LPCWSTR *ppszEnd, size_t *pcchEscapeLen, LPSTR pszBuffer, UINT *pcbBufferMax)
{
	if (NULL == pszEscape || (NULL != pszBuffer && NULL == pcbBufferMax))
		return E_INVALIDARG;

	UINT cbBinary = 0;
	WORD charInfo;
	WCHAR szDigit[3] = {0};

	HRESULT hr = S_OK;

	LPCWSTR cursor = pszEscape;
	while (L'%' == *cursor)
	{
		LPCWSTR testChar = CharNext(cursor);
		if (L'\0' == *testChar || 
			FALSE == GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, testChar, 1, &charInfo) ||
			0 == (C1_XDIGIT & charInfo))
		{
			break;
		}
		szDigit[0] = *testChar;

		testChar = CharNext(testChar);
		if (L'\0' == *testChar || 
			FALSE == GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, testChar, 1, &charInfo) ||
			0 == (C1_XDIGIT & charInfo))
		{
			break;
		}

		szDigit[1] = *testChar;
		CharUpperBuff(szDigit, 2);

		BYTE binaryData = ((szDigit[0] - ((szDigit[0] <= L'9' ? L'0' : L'A' - 10))) << 4) & 0xf0;
		binaryData += (szDigit[1] - ((szDigit[1] <= L'9' ? L'0' : L'A' - 10))) & 0x0f;
		if (NULL != pszBuffer)
		{
			if (cbBinary < *pcbBufferMax)
				pszBuffer[cbBinary] = binaryData;
			else
				hr = E_OUTOFMEMORY;
		}
		cbBinary++;

		cursor = CharNext(testChar);
	}

	if (cursor == pszEscape)
		hr = HRESULT_FROM_WIN32(ERROR_INVALID_BLOCK_LENGTH);

	if (NULL != ppszEnd)
		*ppszEnd = cursor;
	
	if (NULL != pcchEscapeLen)
		*pcchEscapeLen = (size_t)(cursor - pszEscape);

	if (NULL != pcbBufferMax)
		*pcbBufferMax = cbBinary;
	
	return hr;
}

HRESULT AddressEncoder_DecodeString(LPCWSTR pszUrl, LPWSTR *ppResult)
{	
	if (NULL == pszUrl)
	{
		*ppResult = NULL;
		return S_FALSE;
	}

	UINT cchUrl = 0;
	UINT escapeSize  = 0;
	UINT escapeBlockSize,escapeBlockMaxSize = 0;
	LPCWSTR escapeBlockEnd;
	for (LPCWSTR cursor = pszUrl; L'\0' != *cursor;)
	{		
		if (L'%' == *cursor && SUCCEEDED(AddressEncoder_GetEscapeBlock(cursor, &escapeBlockEnd, NULL, NULL, &escapeBlockSize)))
		{
			escapeSize += escapeBlockSize;
			if (escapeBlockSize > escapeBlockMaxSize)
				escapeBlockMaxSize = escapeBlockSize;

			cursor = escapeBlockEnd;
		}
		else
		{
			cchUrl++;
			cursor = CharNext(cursor);
		}
	}

	if (0 == escapeSize)
	{
		*ppResult = Plugin_CopyString(pszUrl);
		if (NULL == *ppResult) return E_OUTOFMEMORY;
		return S_FALSE;
	}

	HRESULT hr = S_OK;
		
	ENCODEBUFFER decoder;
	ZeroMemory(&decoder, sizeof(decoder));
	
	LPSTR escapeBuffer = Plugin_MallocAnsiString(escapeBlockMaxSize);
	if (NULL == escapeBuffer)
	{
		hr = E_OUTOFMEMORY;
	}
	else
	{
		hr = AddressEncoder_ReAllocBuffer(&decoder, cchUrl + (escapeSize + 1)* sizeof(WCHAR));
		if (SUCCEEDED(hr))
		{
			LPCWSTR cursor = pszUrl; 
			LPCWSTR copyBlock =  cursor;
			
			for (;;)
			{		
				escapeBlockSize = escapeBlockMaxSize;
				if (L'%' == *cursor && SUCCEEDED(AddressEncoder_GetEscapeBlock(cursor, &escapeBlockEnd, NULL, escapeBuffer, &escapeBlockSize)))
				{
					if (copyBlock != cursor)
					{
						hr = AddressEncoder_AppendString(&decoder, copyBlock, cursor - copyBlock);
						if (FAILED(hr)) 
							break;
						copyBlock = cursor;
					}

					HRESULT convertResult = AddressEncoder_AppendAnsiString(&decoder, escapeBuffer, escapeBlockSize);
					if (L'\0' == *cursor)
						break;
					
					cursor = escapeBlockEnd;
					if (SUCCEEDED(convertResult))
					{
						copyBlock = cursor;
					}
					
					
					
					continue;
				}
				
				if (L'\0' == *cursor)
				{
					if (copyBlock != cursor)
						hr = AddressEncoder_AppendString(&decoder, copyBlock, cursor - copyBlock);
					break;
				}
				else
					cursor = CharNext(cursor);
			}

		}

	}

	if (NULL != escapeBuffer)
		Plugin_FreeAnsiString(escapeBuffer);

	if (FAILED(hr))
	{
		Plugin_FreeString(decoder.buffer);
		decoder.buffer = NULL;
	}
	else
	{
		*decoder.cursor = L'\0';
	}

	*ppResult = decoder.buffer;
	
	return hr;
}
HRESULT AddressEncoder_GetWideBlock(LPCWSTR pszWide, LPCWSTR *pszEnd, LPWSTR pszBuffer, size_t *pcchBufferMax)
{
	LPCWSTR cursor = pszWide;
	if (NULL == pszWide) 
		return E_INVALIDARG;
	
	if (NULL != pszBuffer && NULL == pcchBufferMax) 
		return E_INVALIDARG;
	
	while (L'\0' == *cursor || *cursor > 0xFF)
	{
		if (L'\0' == *cursor)
			break;
		cursor = CharNext(cursor);
	}

	if (NULL != pszEnd)
		*pszEnd = cursor;

	HRESULT hr = S_OK;
	size_t cchBuffer = 0;

	if (cursor == pszWide)
	{
		hr = S_FALSE;
	}
	else
	{
		size_t bytesCount = WideCharToMultiByte(CP_UTF8, 0, pszWide, (int)(cursor - pszWide), NULL, 0, NULL, NULL);
		if (0 == bytesCount)
		{
			DWORD errorCode = GetLastError();
			if (ERROR_SUCCESS != errorCode)
				hr = HRESULT_FROM_WIN32(errorCode);
		}
		else
		{
			cchBuffer = 3 * bytesCount;
			if (NULL != pszBuffer)
			{
				if (*pcchBufferMax >= cchBuffer)
				{
					LPWSTR p = pszBuffer;
					BYTE *bytes = ((BYTE*)(pszBuffer + *pcchBufferMax)) - bytesCount;
					WideCharToMultiByte(CP_UTF8, 0, pszWide,  (int)(cursor - pszWide), (LPSTR)bytes, (int)bytesCount, NULL, NULL);
					for (size_t i = 0; i < bytesCount; i++)
					{
						BYTE b = bytes[i];
						*p++ = L'%';
						BYTE c = (b >> 4) & 0x0F;
						*p++ = (c < 10) ? (L'0' + c) : (L'A' + (c -10));
						c = b & 0x0F;
						*p++ = (c < 10) ? (L'0' + c) : (L'A' + (c -10));
					}

				}
				else
				{
					hr = E_OUTOFMEMORY;
				}
			}
		}
	}

	if (NULL != pcchBufferMax)
	{
		*pcchBufferMax = cchBuffer;
	}


	return hr;
}
HRESULT AddressEncoder_EncodeWideChars(LPCWSTR pszAddress, size_t cchAddress, LPWSTR *ppResult)
{
	if (NULL == ppResult)
		return E_POINTER;
	
	if (NULL == pszAddress)
	{
		*ppResult = NULL;
		return S_FALSE;
	}

	LPCWSTR blockEnd;
	size_t blockSize;
	size_t cchResultMax = 0;
	BOOL needEncode = FALSE;
	for (LPCWSTR cursor = pszAddress; L'\0' != *cursor;)
	{
		if (*cursor > 0xFF && SUCCEEDED(AddressEncoder_GetWideBlock(cursor, &blockEnd, NULL, &blockSize)))
		{
			cursor = blockEnd;
			cchResultMax += blockSize;
			needEncode = TRUE;
		}
		else
		{
			cursor = CharNext(cursor);
			cchResultMax++;
		}
	}

	if (FALSE == needEncode)
	{
		*ppResult = NULL;
		return S_FALSE;
	}

	HRESULT hr;
	cchResultMax++;
	LPWSTR result = Plugin_MallocString(cchResultMax);
	if (NULL == result)
		hr = E_OUTOFMEMORY;
	else
	{
		LPWSTR cursor = result;
		size_t remaining = cchResultMax;
		LPCWSTR address = pszAddress;
		LPCWSTR addressBlock = address;	

		for (;;)
		{		
			if (*address > 0xFF)
			{
				if (addressBlock != address)
				{
					hr = StringCchCopyNEx(cursor, remaining, addressBlock, (size_t)(address - addressBlock), &cursor, &remaining, 0);
					if (FAILED(hr))	break;
				}

				blockSize = remaining;
				hr = AddressEncoder_GetWideBlock(address, &address, cursor, &blockSize);
				if (FAILED(hr)) break;

				cursor += blockSize;
				remaining -= blockSize;

				addressBlock = address;
				continue;
			}
			
			if (L'\0' == *address)
			{
				if (addressBlock != address)
				{
					hr = StringCchCopyNEx(cursor, remaining, addressBlock, (size_t)(address - addressBlock), &cursor, &remaining, 0);
				}
				break;
			}
			else
				address = CharNext(address);
		}

		*cursor = L'\0';
	}

	

	if (FAILED(hr))
	{
		Plugin_FreeString(result);
		result = NULL;
	}

	*ppResult = result;
	return hr;
}

HRESULT AddressEncoder_EncodeString(LPCWSTR pszAddress, LPWSTR pszBuffer, size_t *pcchBufferMax, UINT flags)
{
	if (NULL == pszBuffer || NULL == pcchBufferMax) 
		return E_INVALIDARG;
	
	if (NULL == pszAddress || L'\0' == *pszAddress)
	{
		*pszBuffer = L'\0';
		*pcchBufferMax = 0;
		return S_OK;
	}

	INT cchAddress = lstrlen(pszAddress);
	LPCWSTR begin, end;
	begin = pszAddress;
	end = pszAddress + cchAddress;
	WORD charType;
	while (L'\0' != *begin &&
		FALSE != GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, begin, 1, &charType) && 0 != (C1_SPACE & charType))
	{
		begin = CharNext(begin);
	}
	while (begin != end && 
		FALSE != GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, begin, 1, &charType) && 0 != (C1_SPACE & charType))
	{
		end = CharPrev(begin, end);
	}

	if (end <= begin)
	{
		*pszBuffer = L'\0';
		*pcchBufferMax = 0;
		return S_OK;
	}

	LPWSTR encoded;
	HRESULT hr = AddressEncoder_EncodeWideChars(begin, (end - begin), &encoded);
	if (FAILED(hr)) return hr;

	if (S_OK == hr)
	{
		begin = encoded;
		end = begin + lstrlen(begin);
	}
	
	DWORD bufferLen = (DWORD)(*pcchBufferMax);
	if (FALSE == InternetCanonicalizeUrl(begin, pszBuffer, &bufferLen, flags))
	{
		DWORD errorCode = GetLastError();
		if (ERROR_INSUFFICIENT_BUFFER == errorCode)
		{
			*pcchBufferMax = bufferLen;
			hr = ENC_E_INSUFFICIENT_BUFFER;	
		}
		else 
		{
			size_t cchNeeded = (end - begin);
			if (cchNeeded < *pcchBufferMax)
			{
				hr = StringCchCopyN(pszBuffer, *pcchBufferMax, begin, cchNeeded);
				if (STRSAFE_E_INSUFFICIENT_BUFFER == hr)
				{ 
					hr = ENC_E_INSUFFICIENT_BUFFER;
				}
			}
			else
			{
				hr = ENC_E_INSUFFICIENT_BUFFER;
			}
			*pcchBufferMax = cchNeeded + 1;
		}
	}

	else
		hr = S_OK;
	
	
	Plugin_FreeString(encoded);
	return hr;
}