static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
{
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
DWORD size;
HRESULT hres;
if(PathIsURLW(url))
return CreateURLMoniker(NULL, url, mon);
if(url[1] == ':') {
size = sizeof(new_url);
hres = UrlCreateFromPathW(url, new_url, &size, 0);
if(FAILED(hres)) {
WARN("UrlCreateFromPathW failed: %08x\n", hres);
return hres;
}
}else {
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME);
TRACE("got %s\n", debugstr_w(new_url));
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
return hres;
}
}
return CreateURLMoniker(NULL, new_url, mon);
}
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;
}
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
{
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL;
HRESULT hres = S_OK;
TRACE("navigating to %s\n", debugstr_w(url));
if((Flags && V_VT(Flags) != VT_EMPTY)
|| (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY))
FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n",
Flags, Flags ? V_VT(Flags) : -1, TargetFrameName,
TargetFrameName ? V_VT(TargetFrameName) : -1);
if(PostData && V_VT(PostData) == (VT_ARRAY | VT_UI1) && V_ARRAY(PostData)) {
SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data);
post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements;
}
if(Headers && V_VT(Headers) == VT_BSTR) {
headers = V_BSTR(Headers);
TRACE("Headers: %s\n", debugstr_w(headers));
}
set_doc_state(This, READYSTATE_LOADING);
This->ready_state = READYSTATE_LOADING;
if(This->doc_navigate) {
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
if(PathIsURLW(url)) {
new_url[0] = 0;
}else {
DWORD size;
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME);
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
new_url[0] = 0;
}
}
hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data,
post_data_len, TRUE);
}else {
task_navigate_bsc_t *task;
task = heap_alloc(sizeof(*task));
task->bsc = create_callback(This, url, post_data, post_data_len, headers);
push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL);
}
if(post_data)
SafeArrayUnaccessData(V_ARRAY(PostData));
return hres;
}
HRESULT UrlCombineUnescape(LPCWSTR pszBase, LPCWSTR pszRelative, LPWSTR pszCombined, LPDWORD pcchCombined, DWORD dwFlags)
{
HRESULT hr = S_OK;
DWORD dwSize;
LPWSTR pwzCombined = NULL;
LPWSTR pwzFileCombined = NULL;
pwzCombined = NEW(WCHAR[MAX_URL_LENGTH]);
if (!pwzCombined) {
hr = E_OUTOFMEMORY;
goto Exit;
}
// If we're just combining an absolute file path to an relative file
// path, do this by concatenating the strings, and canonicalizing it.
// This avoids UrlCombine randomness where you could end up with
// a partially escaped (and partially unescaped) resulting URL!
if (!PathIsURLW(pszBase) && PathIsRelativeWrap(pszRelative)) {
pwzFileCombined = NEW(WCHAR[MAX_URL_LENGTH]);
if (!pwzFileCombined) {
hr = E_OUTOFMEMORY;
goto Exit;
}
wnsprintfW(pwzFileCombined, MAX_URL_LENGTH, L"%ws%ws", pszBase, pszRelative);
hr = UrlCanonicalizeUnescape(pwzFileCombined, pszCombined, pcchCombined, 0);
goto Exit;
}
else {
dwSize = MAX_URL_LENGTH;
hr = UrlCombineW(pszBase, pszRelative, pwzCombined, &dwSize, dwFlags);
if (FAILED(hr)) {
goto Exit;
}
}
// Don't unescape if the relative part was already an URL because
// URLs wouldn't have been escaped during the UrlCombined.
if (UrlIsW(pwzCombined, URLIS_FILEURL)) {
hr = UrlUnescapeW(pwzCombined, pszCombined, pcchCombined, 0);
if (FAILED(hr)) {
goto Exit;
}
}
else {
if (*pcchCombined >= dwSize) {
lstrcpyW(pszCombined, pwzCombined);
}
*pcchCombined = dwSize;
}
Exit:
SAFEDELETEARRAY(pwzCombined);
SAFEDELETEARRAY(pwzFileCombined);
return hr;
}
static enum content get_content_type(LPCOLESTR name, CLSID *control_id)
{
WCHAR new_urlW[MAX_PATH];
DWORD size = MAX_PATH;
WCHAR mshtml_prefixW[] = {'m','s','h','t','m','l',':','\0'};
if (!name || !name[0])
{
WARN("name %s\n", wine_dbgstr_w(name));
return IsEmpty;
}
if (CLSIDFromString(name, control_id) == S_OK ||
CLSIDFromProgID(name, control_id) == S_OK)
return IsGUID;
if (PathIsURLW (name) ||
UrlApplySchemeW(name, new_urlW, &size, URL_APPLY_GUESSSCHEME|URL_APPLY_GUESSFILE) == S_OK)
{
*control_id = CLSID_WebBrowser;
return IsURL;
}
if (!strncmpiW(name, mshtml_prefixW, 7))
{
FIXME("mshtml prefix not implemented\n");
*control_id = CLSID_WebBrowser;
return IsHTML;
}
return IsUnknown;
}
HRESULT create_uri(const WCHAR *url, IUri **uri)
{
WCHAR fileUrl[INTERNET_MAX_URL_LENGTH];
TRACE("%s\n", debugstr_w(url));
if (!PathIsURLW(url))
{
WCHAR fullpath[MAX_PATH];
DWORD needed = ARRAY_SIZE(fileUrl);
if (!PathSearchAndQualifyW(url, fullpath, ARRAY_SIZE(fullpath)))
{
WARN("can't find path\n");
return E_FAIL;
}
if (FAILED(UrlCreateFromPathW(fullpath, fileUrl, &needed, 0)))
{
ERR("can't create url from path\n");
return E_FAIL;
}
url = fileUrl;
}
return CreateUri(url, Uri_CREATE_ALLOW_RELATIVE | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, uri);
}
static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
{
WCHAR url[INTERNET_MAX_URL_LENGTH];
IStream *stream;
IBindCtx *bctx;
IMoniker *moniker;
IPersistStreamInit *persist;
HRESULT hr;
TRACE("(%p, %s)\n", iface, debugstr_w(p));
if (!p)
return E_INVALIDARG;
if (!PathIsURLW(p))
{
WCHAR fullpath[MAX_PATH];
DWORD needed = sizeof(url) / sizeof(WCHAR);
if (!PathSearchAndQualifyW(p, fullpath, sizeof(fullpath) / sizeof(WCHAR)))
{
ERR("can't find path\n");
return E_FAIL;
}
if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
{
ERR("can't create url from path\n");
return E_FAIL;
}
p = url;
}
hr = CreateURLMoniker(NULL, p, &moniker);
if (FAILED(hr))
return hr;
CreateAsyncBindCtx(0, &xmldoc_bsc.IBindStatusCallback_iface, 0, &bctx);
hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
IBindCtx_Release(bctx);
IMoniker_Release(moniker);
if (FAILED(hr))
return hr;
hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
if (FAILED(hr))
{
IStream_Release(stream);
return hr;
}
hr = IPersistStreamInit_Load(persist, stream);
IPersistStreamInit_Release(persist);
IStream_Release(stream);
return hr;
}
/******************************************************************
* 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;
}
static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
{
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
DWORD size;
HRESULT hres;
if(PathIsURLW(url))
return CreateURLMoniker(NULL, url, mon);
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
TRACE("was %s got %s\n", debugstr_w(url), debugstr_w(new_url));
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
return hres;
}
return CreateURLMoniker(NULL, new_url, mon);
}
BOOL PathIsRelativeWrap(LPCWSTR pwzPath)
{
BOOL bRet = FALSE;
ASSERT(pwzPath);
if (pwzPath[0] == L'\\' || pwzPath[0] == L'/') {
goto Exit;
}
if (PathIsURLW(pwzPath)) {
goto Exit;
}
bRet = PathIsRelativeW(pwzPath);
Exit:
return bRet;
}
HRESULT bind_url(LPCWSTR url, HRESULT (*onDataAvailable)(void*,char*,DWORD), void *obj, bsc_t **ret)
{
WCHAR fileUrl[INTERNET_MAX_URL_LENGTH];
bsc_t *bsc;
IBindCtx *pbc;
HRESULT hr;
TRACE("%s\n", debugstr_w(url));
if(!PathIsURLW(url))
{
WCHAR fullpath[MAX_PATH];
DWORD needed = sizeof(fileUrl)/sizeof(WCHAR);
if(!PathSearchAndQualifyW(url, fullpath, sizeof(fullpath)/sizeof(WCHAR)))
{
WARN("can't find path\n");
return E_FAIL;
}
if(FAILED(UrlCreateFromPathW(url, fileUrl, &needed, 0)))
{
ERR("can't create url from path\n");
return E_FAIL;
}
url = fileUrl;
}
hr = CreateBindCtx(0, &pbc);
if(FAILED(hr))
return hr;
bsc = HeapAlloc(GetProcessHeap(), 0, sizeof(bsc_t));
bsc->lpVtbl = &bsc_vtbl;
bsc->ref = 1;
bsc->obj = obj;
bsc->onDataAvailable = onDataAvailable;
bsc->binding = NULL;
bsc->memstream = NULL;
hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&bsc->lpVtbl, NULL, 0);
if(SUCCEEDED(hr))
{
IMoniker *moniker;
hr = CreateURLMoniker(NULL, url, &moniker);
if(SUCCEEDED(hr))
{
IStream *stream;
hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
IMoniker_Release(moniker);
if(stream)
IStream_Release(stream);
}
IBindCtx_Release(pbc);
}
if(FAILED(hr))
{
IBindStatusCallback_Release((IBindStatusCallback*)&bsc->lpVtbl);
bsc = NULL;
}
*ret = bsc;
return hr;
}
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
{
SAFEARRAY *post_array = NULL;
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL;
HRESULT hres = S_OK;
TRACE("navigating to %s\n", debugstr_w(url));
if((Flags && V_VT(Flags) != VT_EMPTY && V_VT(Flags) != VT_ERROR)
|| (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY && V_VT(TargetFrameName) != VT_ERROR))
FIXME("Unsupported args (Flags %s; TargetFrameName %s)\n", debugstr_variant(Flags), debugstr_variant(TargetFrameName));
if(PostData) {
if(V_VT(PostData) & VT_ARRAY)
post_array = V_ISBYREF(PostData) ? *V_ARRAYREF(PostData) : V_ARRAY(PostData);
else
WARN("Invalid post data %s\n", debugstr_variant(PostData));
}
if(post_array) {
LONG elem_max;
SafeArrayAccessData(post_array, (void**)&post_data);
SafeArrayGetUBound(post_array, 1, &elem_max);
post_data_len = (elem_max+1) * SafeArrayGetElemsize(post_array);
}
if(Headers && V_VT(Headers) == VT_BSTR) {
headers = V_BSTR(Headers);
TRACE("Headers: %s\n", debugstr_w(headers));
}
set_doc_state(This, READYSTATE_LOADING);
This->ready_state = READYSTATE_LOADING;
if(This->doc_navigate) {
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
if(PathIsURLW(url)) {
new_url[0] = 0;
}else {
DWORD size;
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size,
URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
new_url[0] = 0;
}
}
hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data,
post_data_len, TRUE);
}else {
task_navigate_bsc_t *task;
task = heap_alloc(sizeof(*task));
task->bsc = create_callback(This, url, post_data, post_data_len, headers);
push_dochost_task(This, &task->header, navigate_bsc_proc, navigate_bsc_task_destr, This->url == NULL);
}
if(post_data)
SafeArrayUnaccessData(post_array);
return hres;
}
HRESULT CDebugLog::DumpDebugLog(DWORD dwDetailLvl, HRESULT hrLog)
{
HRESULT hr = S_OK;
HANDLE hFile = INVALID_HANDLE_VALUE;
LISTNODE pos = NULL;
LPWSTR wzUrlName=NULL;
CDebugLogElement *pLogElem = NULL;
WCHAR wzFileName[MAX_PATH];
WCHAR wzSiteName[MAX_PATH];
WCHAR wzAppLogDir[MAX_PATH];
LPWSTR wzResourceName = NULL;
DWORD dwBytes;
DWORD dwSize;
CCriticalSection cs(&g_csBindLog);
BOOL bRet;
if (!g_dwLogFailures && !g_dwForceLog) {
return S_FALSE;
}
hr = cs.Lock();
if (FAILED(hr)) {
return hr;
}
pos = _listDbgMsg.GetHeadPosition();
if (!pos) {
hr = S_FALSE;
goto Exit;
}
wzUrlName = NEW(WCHAR[MAX_URL_LENGTH+1]);
if (!wzUrlName)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
// Build the log entry URL and Wininet cache file
wnsprintfW(wzUrlName, MAX_URL_LENGTH, L"?FusionBindError!exe=%ws!name=%ws", _wzEXEName, _pwzAsmName);
{
wnsprintfW(wzAppLogDir, MAX_PATH, L"%ws\\%ws", _szLogPath, _wzEXEName);
if (GetFileAttributes(wzAppLogDir) == (DWORD) -1) {
bRet = CreateDirectory(wzAppLogDir, NULL);
if (!bRet) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
}
if (PathIsURLW(_pwzAsmName)) {
// This was a where-ref bind. We can't spit out a filename w/
// the URL of the bind because the URL has invalid filename chars.
// The best we can do is show that it was a where-ref bind, and
// give the filename, and maybe the site.
dwSize = MAX_PATH;
hr = UrlGetPartW(_pwzAsmName, wzSiteName, &dwSize, URL_PART_HOSTNAME, 0);
if (FAILED(hr)) {
goto Exit;
}
wzResourceName = PathFindFileName(_pwzAsmName);
ASSERT(wzResourceName);
if (!lstrlenW(wzSiteName)) {
lstrcpyW(wzSiteName, L"LocalMachine");
}
wnsprintfW(wzFileName, MAX_PATH, L"%ws\\FusionBindError!exe=%ws!name=WhereRefBind!Host=(%ws)!FileName=(%ws).HTM",
wzAppLogDir, _wzEXEName, wzSiteName, wzResourceName);
}
else {
wnsprintfW(wzFileName, MAX_PATH, L"%ws\\FusionBindError!exe=%ws!name=%ws.HTM", wzAppLogDir, _wzEXEName, _pwzAsmName);
}
}
// Create the and write the log file
hr = CreateLogFile(&hFile, wzFileName, _wzEXEName, hrLog);
if (FAILED(hr)) {
goto Exit;
}
pos = _listDbgMsg.GetHeadPosition();
while (pos) {
pLogElem = _listDbgMsg.GetNext(pos);
ASSERT(pLogElem);
if (pLogElem->_dwDetailLvl <= dwDetailLvl) {
pLogElem->Dump(hFile);
WriteFile(hFile, DEBUG_LOG_NEW_LINE, lstrlenW(DEBUG_LOG_NEW_LINE) * sizeof(WCHAR),
&dwBytes, NULL);
}
}
// Close the log file and commit the wininet cache entry
hr = CloseLogFile(&hFile);
if (FAILED(hr)) {
goto Exit;
}
Exit:
cs.Unlock();
SAFEDELETEARRAY(wzUrlName);
return hr;
}
BOOL IsURL(SString &urlOrPath)
{
// This is also in defined rotor pal
return PathIsURLW(urlOrPath);
}
