static void test_url_canonicalize(int index, const char *szUrl, DWORD dwFlags, HRESULT dwExpectReturn, const char *szExpectUrl, BOOL todo)
{
CHAR szReturnUrl[INTERNET_MAX_URL_LENGTH];
WCHAR wszReturnUrl[INTERNET_MAX_URL_LENGTH];
LPWSTR wszUrl = GetWideString(szUrl);
LPWSTR wszExpectUrl = GetWideString(szExpectUrl);
LPWSTR wszConvertedUrl;
DWORD dwSize;
dwSize = INTERNET_MAX_URL_LENGTH;
ok(UrlCanonicalizeA(szUrl, NULL, &dwSize, dwFlags) != dwExpectReturn, "Unexpected return for NULL buffer, index %d\n", index);
ok(UrlCanonicalizeA(szUrl, szReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeA didn't return 0x%08x, index %d\n", dwExpectReturn, index);
if (todo)
todo_wine
ok(strcmp(szReturnUrl,szExpectUrl)==0, "UrlCanonicalizeA dwFlags 0x%08x url '%s' Expected \"%s\", but got \"%s\", index %d\n", dwFlags, szUrl, szExpectUrl, szReturnUrl, index);
else
ok(strcmp(szReturnUrl,szExpectUrl)==0, "UrlCanonicalizeA dwFlags 0x%08x url '%s' Expected \"%s\", but got \"%s\", index %d\n", dwFlags, szUrl, szExpectUrl, szReturnUrl, index);
dwSize = INTERNET_MAX_URL_LENGTH;
ok(UrlCanonicalizeW(wszUrl, NULL, &dwSize, dwFlags) != dwExpectReturn, "Unexpected return for NULL buffer, index %d\n", index);
ok(UrlCanonicalizeW(wszUrl, wszReturnUrl, &dwSize, dwFlags) == dwExpectReturn, "UrlCanonicalizeW didn't return 0x%08x, index %d\n", dwExpectReturn, index);
wszConvertedUrl = GetWideString(szReturnUrl);
ok(lstrcmpW(wszReturnUrl, wszConvertedUrl)==0, "Strings didn't match between ascii and unicode UrlCanonicalize, index %d!\n", index);
FreeWideString(wszConvertedUrl);
FreeWideString(wszUrl);
FreeWideString(wszExpectUrl);
}
HRESULT UrlCanonicalizeUnescape(LPCWSTR pszUrl, LPWSTR pszCanonicalized, LPDWORD pcchCanonicalized, DWORD dwFlags)
{
HRESULT hr = S_OK;
DWORD dwSize;
WCHAR wzCanonical[MAX_URL_LENGTH];
if (UrlIsW(pszUrl, URLIS_FILEURL) || !PathIsURLW(pszUrl)) {
dwSize = MAX_URL_LENGTH;
hr = UrlCanonicalizeW(pszUrl, wzCanonical, &dwSize, dwFlags);
if (FAILED(hr)) {
goto Exit;
}
hr = UrlUnescapeW(wzCanonical, pszCanonicalized, pcchCanonicalized, 0);
if (FAILED(hr)) {
goto Exit;
}
}
else {
hr = UrlCanonicalizeW(pszUrl, pszCanonicalized, pcchCanonicalized, dwFlags /*| URL_ESCAPE_PERCENT*/);
}
Exit:
return hr;
}
static HRESULT parse_canonicalize_url(LPCWSTR url, DWORD flags, LPWSTR result,
DWORD size, DWORD *rsize)
{
IInternetProtocolInfo *protocol_info;
DWORD prsize = size;
HRESULT hres;
TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
protocol_info = get_protocol_info(url);
if(protocol_info) {
hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_CANONICALIZE,
flags, result, size, rsize, 0);
IInternetProtocolInfo_Release(protocol_info);
if(SUCCEEDED(hres))
return hres;
}
hres = UrlCanonicalizeW(url, result, &prsize, flags);
if(rsize)
*rsize = prsize;
return hres;
}
/******************************************************************
* ParseURLFromOutsideSourceW (SHDOCVW.170)
*/
DWORD WINAPI ParseURLFromOutsideSourceW(LPCWSTR url, LPWSTR out, LPDWORD plen, LPDWORD unknown)
{
WCHAR buffer_in[INTERNET_MAX_URL_LENGTH];
WCHAR buffer_out[INTERNET_MAX_URL_LENGTH];
LPCWSTR ptr = url;
HRESULT hr;
DWORD needed;
DWORD len;
DWORD res = 0;
TRACE("(%s, %p, %p, %p) len: %d, unknown: 0x%x\n", debugstr_w(url), out, plen, unknown,
plen ? *plen : 0, unknown ? *unknown : 0);
if (!PathIsURLW(ptr)) {
len = sizeof(buffer_in) / sizeof(buffer_in[0]);
buffer_in[0] = 0;
hr = UrlApplySchemeW(ptr, buffer_in, &len, URL_APPLY_GUESSSCHEME);
TRACE("got 0x%x with %s\n", hr, debugstr_w(buffer_in));
if (hr != S_OK) {
/* when we can't guess the scheme, use the default scheme */
len = sizeof(buffer_in) / sizeof(buffer_in[0]);
hr = UrlApplySchemeW(ptr, buffer_in, &len, URL_APPLY_DEFAULT);
}
if (hr == S_OK) {
/* we parsed the url to buffer_in */
ptr = buffer_in;
}
else
{
FIXME("call search hook for %s\n", debugstr_w(ptr));
}
}
len = sizeof(buffer_out) / sizeof(buffer_out[0]);
buffer_out[0] = '\0';
hr = UrlCanonicalizeW(ptr, buffer_out, &len, URL_ESCAPE_SPACES_ONLY);
needed = lstrlenW(buffer_out)+1;
TRACE("got 0x%x with %s (need %d)\n", hr, debugstr_w(buffer_out), needed);
if (*plen >= needed) {
if (out != NULL) {
lstrcpyW(out, buffer_out);
res++;
}
needed--;
}
*plen = needed;
TRACE("=> %d\n", res);
return res;
}
wstring inet_canonicalize_url(const wstring& url)
{
if(!url.length())
return L"";
wstring s;
s.resize(url.length()*6);
DWORD canned=(DWORD)s.length();
UrlCanonicalizeW(url.c_str(),(wchar_t*)s.c_str(),&canned,URL_ESCAPE_UNSAFE);
s.resize(canned);
return s;
}
HRESULT RemoveDirectoryAndChildren(LPWSTR szDir)
{
HRESULT hr = S_OK;
HANDLE hf = INVALID_HANDLE_VALUE;
TCHAR szBuf[MAX_PATH];
WIN32_FIND_DATA fd;
LPWSTR wzCanonicalized=NULL;
WCHAR wzPath[MAX_PATH];
DWORD dwSize;
if (!szDir || !lstrlenW(szDir)) {
hr = E_INVALIDARG;
goto Exit;
}
wzPath[0] = L'\0';
wzCanonicalized = NEW(WCHAR[MAX_URL_LENGTH+1]);
if (!wzCanonicalized)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
dwSize = MAX_URL_LENGTH;
hr = UrlCanonicalizeW(szDir, wzCanonicalized, &dwSize, 0);
if (FAILED(hr)) {
goto Exit;
}
dwSize = MAX_PATH;
hr = PathCreateFromUrlW(wzCanonicalized, wzPath, &dwSize, 0);
if (FAILED(hr)) {
goto Exit;
}
// Cannot delete root. Path must have greater length than "x:\"
if (lstrlenW(wzPath) < 4) {
ASSERT(0);
hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
goto Exit;
}
if (RemoveDirectory(wzPath)) {
goto Exit;
}
// ha! we have a case where the directory is probbaly not empty
StrCpy(szBuf, wzPath);
StrCat(szBuf, TEXT("\\*"));
if ((hf = FindFirstFile(szBuf, &fd)) == INVALID_HANDLE_VALUE) {
hr = FusionpHresultFromLastError();
goto Exit;
}
do {
if ( (StrCmp(fd.cFileName, TEXT(".")) == 0) ||
(StrCmp(fd.cFileName, TEXT("..")) == 0))
continue;
wnsprintf(szBuf, MAX_PATH-1, TEXT("%s\\%s"), wzPath, fd.cFileName);
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
SetFileAttributes(szBuf,
FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_NORMAL);
if (FAILED((hr=RemoveDirectoryAndChildren(szBuf)))) {
goto Exit;
}
} else {
SetFileAttributes(szBuf, FILE_ATTRIBUTE_NORMAL);
if (!DeleteFile(szBuf)) {
hr = FusionpHresultFromLastError();
#ifdef DEBUG
if((hr != HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
&& (hr != HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)))
{
WCHAR szMsgBuf[MAX_PATH*2 + 1];
wnsprintf( szMsgBuf, MAX_PATH*2, L" RemoveDirectoryAndChildren: DeleteFile(<%s>) failed hr = <%x>\r\n",
szBuf, hr);
WriteToLogFile(szMsgBuf);
}
#endif // DEBUG
goto Exit;
}
}
} while (FindNextFile(hf, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES) {
hr = FusionpHresultFromLastError();
goto Exit;
}
if (hf != INVALID_HANDLE_VALUE) {
FindClose(hf);
hf = INVALID_HANDLE_VALUE;
}
// here if all subdirs/children removed
/// re-attempt to remove the main dir
if (!RemoveDirectory(wzPath)) {
hr = FusionpHresultFromLastError();
#ifdef DEBUG
WCHAR szMsgBuf[MAX_PATH*2 + 1];
wnsprintf( szMsgBuf, MAX_PATH*2, L" RemoveDirectoryAndChildren: RemoveDirectory(<%s>) failed hr = <%x>\r\n",
wzPath, hr);
WriteToLogFile(szMsgBuf);
#endif // DEBUG
goto Exit;
}
Exit:
if(hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
hr = HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION);
if (hf != INVALID_HANDLE_VALUE)
FindClose(hf);
SAFEDELETEARRAY(wzCanonicalized);
return hr;
}
