static DWORD WINAPI download_proc(PVOID arg)
{
IMoniker *mon;
IBindCtx *bctx;
IStream *str = NULL;
HRESULT hres;
CreateURLMoniker(NULL, url, &mon);
heap_free(url);
url = NULL;
CreateAsyncBindCtx(0, &InstallCallback, 0, &bctx);
hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&str);
IBindCtx_Release(bctx);
if(FAILED(hres)) {
ERR("BindToStorage failed: %08x\n", hres);
return 0;
}
if(str)
IStream_Release(str);
return 0;
}
static HRESULT navigate_bsc(DocHost *This, BindStatusCallback *bsc, IMoniker *mon)
{
IBindCtx *bindctx;
VARIANT_BOOL cancel = VARIANT_FALSE;
HRESULT hres;
on_before_navigate2(This, bsc->url, bsc->post_data, bsc->post_data_len, bsc->headers, &cancel);
if(cancel) {
FIXME("Navigation canceled\n");
return S_OK;
}
if(This->document)
deactivate_document(This);
CreateAsyncBindCtx(0, BINDSC(bsc), 0, &bindctx);
if(This->frame)
IOleInPlaceFrame_EnableModeless(This->frame, FALSE);
hres = bind_to_object(This, mon, bsc->url, bindctx, BINDSC(bsc));
if(This->frame)
IOleInPlaceFrame_EnableModeless(This->frame, TRUE);
IBindCtx_Release(bindctx);
return hres;
}
HRESULT download_to_cache(IUri *uri, stop_cache_binding_proc_t proc, void *ctx, IBindStatusCallback *callback)
{
DownloadBSC *dwl_bsc;
IBindCtx *bindctx;
IMoniker *mon;
IUnknown *unk;
HRESULT hres;
hres = DownloadBSC_Create(callback, NULL, &dwl_bsc);
if(FAILED(hres))
return hres;
dwl_bsc->onstop_proc = proc;
dwl_bsc->ctx = ctx;
dwl_bsc->bindf = BINDF_ASYNCHRONOUS;
hres = CreateAsyncBindCtx(0, &dwl_bsc->IBindStatusCallback_iface, NULL, &bindctx);
IBindStatusCallback_Release(&dwl_bsc->IBindStatusCallback_iface);
if(FAILED(hres))
return hres;
hres = CreateURLMonikerEx2(NULL, uri, &mon, 0);
if(FAILED(hres)) {
IBindCtx_Release(bindctx);
return hres;
}
hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
IMoniker_Release(mon);
IBindCtx_Release(bindctx);
if(SUCCEEDED(hres) && unk)
IUnknown_Release(unk);
return hres;
}
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;
}
STDMETHODIMP CTCBindHost::MonikerBindToStorage( IMoniker* pMoniker,
IBindCtx* pBindCtx, IBindStatusCallback* pBSC, REFIID iid, void** ppObject )
{
HRESULT hResult;
IBindCtxPtr pNewBindCtx;
TCTrace( TRACELEVEL_NORMAL, "IBindHost::MonikerBindToStorage\n" );
if( ppObject == NULL )
{
return( E_POINTER );
}
*ppObject = NULL;
if( pBindCtx != NULL )
{
pNewBindCtx = pBindCtx;
if( pBSC )
{
hResult = RegisterBindStatusCallback( pBindCtx, pBSC, NULL, 0 );
if( FAILED( hResult ) )
{
return( hResult );
}
}
}
else
{
if( pBSC )
{
hResult = CreateAsyncBindCtx( 0, pBSC, NULL, &pNewBindCtx );
if( FAILED( hResult ) )
{
return( hResult );
}
}
else
{
hResult = CreateBindCtx( 0, &pNewBindCtx );
if( FAILED( hResult ) )
{
return( hResult );
}
}
}
ASSERT( pNewBindCtx != NULL );
return( pMoniker->BindToStorage( pNewBindCtx, NULL, iid, ppObject ) );
}
static HRESULT navigate_bsc(DocHost *This, BindStatusCallback *bsc, IMoniker *mon)
{
VARIANT_BOOL cancel = VARIANT_FALSE;
SAFEARRAY *post_data = NULL;
IBindCtx *bindctx;
HRESULT hres;
set_doc_state(This, READYSTATE_LOADING);
if(bsc->post_data) {
post_data = SafeArrayCreateVector(VT_UI1, 0, bsc->post_data_len);
memcpy(post_data->pvData, post_data, bsc->post_data_len);
}
on_before_navigate2(This, bsc->url, post_data, bsc->headers, &cancel);
if(post_data)
SafeArrayDestroy(post_data);
if(cancel) {
FIXME("Navigation canceled\n");
return S_OK;
}
notify_download_state(This, TRUE);
on_commandstate_change(This, CSC_NAVIGATEBACK, VARIANT_FALSE);
on_commandstate_change(This, CSC_NAVIGATEFORWARD, VARIANT_FALSE);
if(This->document)
deactivate_document(This);
CreateAsyncBindCtx(0, &bsc->IBindStatusCallback_iface, 0, &bindctx);
if(This->frame)
IOleInPlaceFrame_EnableModeless(This->frame, FALSE);
hres = bind_to_object(This, mon, bsc->url, bindctx, &bsc->IBindStatusCallback_iface);
if(This->frame)
IOleInPlaceFrame_EnableModeless(This->frame, TRUE);
IBindCtx_Release(bindctx);
return hres;
}
/***********************************************************************
* BindAsyncMoniker (URLMON.@)
*
* Bind a bind status callback to an asynchronous URL Moniker.
*
* PARAMS
* pmk [I] Moniker object to bind status callback to
* grfOpt [I] Options, seems not used
* pbsc [I] Status callback to bind
* iidResult [I] Interface to return
* ppvResult [O] Resulting asynchronous moniker object
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid, or
* E_OUTOFMEMORY if memory allocation fails.
*/
HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
{
LPBC pbc = NULL;
HRESULT hr = E_INVALIDARG;
TRACE("(%p %08x %p %s %p)\n", pmk, grfOpt, pbsc, debugstr_guid(iidResult), ppvResult);
if (pmk && ppvResult)
{
*ppvResult = NULL;
hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
if (hr == NOERROR)
{
hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
IBindCtx_Release(pbc);
}
}
return hr;
}
/***********************************************************************
* URLDownloadToFileW (URLMON.@)
*
* Downloads URL szURL to file szFileName and call lpfnCB callback to
* report progress.
*
* PARAMS
* pCaller [I] controlling IUnknown interface.
* szURL [I] URL of the file to download
* szFileName [I] file name to store the content of the URL
* dwReserved [I] reserved - set to 0
* lpfnCB [I] callback for progress report
*
* RETURNS
* S_OK on success
*/
HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller, LPCWSTR szURL, LPCWSTR szFileName,
DWORD dwReserved, LPBINDSTATUSCALLBACK lpfnCB)
{
IBindStatusCallback *callback;
IUnknown *unk;
IMoniker *mon;
IBindCtx *bindctx;
HRESULT hres;
TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
if(pCaller)
FIXME("pCaller not supported\n");
hres = DownloadBSC_Create(lpfnCB, szFileName, &callback);
if(FAILED(hres))
return hres;
hres = CreateAsyncBindCtx(0, callback, NULL, &bindctx);
IBindStatusCallback_Release(callback);
if(FAILED(hres))
return hres;
hres = CreateURLMoniker(NULL, szURL, &mon);
if(FAILED(hres)) {
IBindCtx_Release(bindctx);
return hres;
}
hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
IMoniker_Release(mon);
IBindCtx_Release(bindctx);
if(unk)
IUnknown_Release(unk);
return hres == MK_S_ASYNCHRONOUS ? S_OK : hres;
}
static BOOL start_download(void)
{
IBindCtx *bind_ctx;
IMoniker *mon;
IUnknown *tmp;
HRESULT hres;
hres = CreateURLMoniker(NULL, url, &mon);
if(FAILED(hres))
return FALSE;
hres = CreateAsyncBindCtx(0, &InstallCallback, NULL, &bind_ctx);
if(SUCCEEDED(hres)) {
hres = IMoniker_BindToStorage(mon, bind_ctx, NULL, &IID_IUnknown, (void**)&tmp);
IBindCtx_Release(bind_ctx);
}
IMoniker_Release(mon);
if(FAILED(hres))
return FALSE;
if(tmp)
IUnknown_Release(tmp);
return TRUE;
}
static HRESULT download_url(InstallEngine *This, char *id, char *display, char *url, DWORD flags, DWORD dl_size)
{
struct downloadcb *callback = NULL;
char *filename = NULL;
IUnknown *unk = NULL;
IMoniker *mon = NULL;
IBindCtx *bindctx = NULL;
HANDLE event = NULL;
HRESULT hr;
if (!This->downloaddir)
{
WARN("No download directory set\n");
return E_FAIL;
}
hr = generate_moniker(This->baseurl, url, flags, &mon);
if (FAILED(hr))
{
FIXME("Failed to create moniker\n");
return hr;
}
event = CreateEventW(NULL, TRUE, FALSE, NULL);
if (!event)
{
IMoniker_Release(mon);
return E_FAIL;
}
filename = strrchr(url, '/');
if (!filename) filename = url;
filename = merge_path(This->downloaddir, filename);
if (!filename)
{
hr = E_OUTOFMEMORY;
goto error;
}
hr = downloadcb_create(This, event, filename, id, display, dl_size, &callback);
if (FAILED(hr)) goto error;
hr = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bindctx);
if(FAILED(hr)) goto error;
hr = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
if (FAILED(hr)) goto error;
if (unk) IUnknown_Release(unk);
heap_free(filename);
IMoniker_Release(mon);
IBindCtx_Release(bindctx);
WaitForSingleObject(event, INFINITE);
hr = callback->hr;
CloseHandle(event);
IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
return hr;
error:
if (mon) IMoniker_Release(mon);
if (event) CloseHandle(event);
if (callback) IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
if (bindctx) IBindCtx_Release(bindctx);
if (filename) heap_free(filename);
return hr;
}
