random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/omBrowser/addressEncoder.cpp

518 lines
11 KiB
C++
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink