/***********************************************************************
* RegisterBindStatusCallback (urlmon.@)
*
* Register a bind status callback.
*
* PARAMS
* pbc [I] Binding context
* pbsc [I] Callback to register
* ppbscPrevious [O] Destination for previous callback
* dwReserved [I] Reserved, must be 0.
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid, or
* E_OUTOFMEMORY if memory allocation fails.
*/
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
{
BindStatusCallback *holder;
IBindStatusCallback *bsc, *prev = NULL;
IUnknown *unk;
HRESULT hres;
TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
if (!pbc || !pbsc)
return E_INVALIDARG;
hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
if(SUCCEEDED(hres)) {
hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc);
IUnknown_Release(unk);
if(SUCCEEDED(hres)) {
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(SUCCEEDED(hres)) {
if(ppbscPrevious) {
IBindStatusCallback_AddRef(holder->callback);
*ppbscPrevious = holder->callback;
}
set_callback(holder, pbsc);
IBindStatusCallback_Release(bsc);
IBindStatusCallback_Release(STATUSCLB(holder));
return S_OK;
}else {
prev = bsc;
}
}
IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
}
hres = wrap_callback(pbsc, &bsc);
if(SUCCEEDED(hres)) {
hres = IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown*)bsc);
IBindStatusCallback_Release(bsc);
}
if(FAILED(hres)) {
if(prev)
IBindStatusCallback_Release(prev);
return hres;
}
if(ppbscPrevious)
*ppbscPrevious = prev;
return S_OK;
}
/***********************************************************************
* RegisterBindStatusCallback (urlmon.@)
*
* Register a bind status callback.
*
* PARAMS
* pbc [I] Binding context
* pbsc [I] Callback to register
* ppbscPrevious [O] Destination for previous callback
* dwReserved [I] Reserved, must be 0.
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid, or
* E_OUTOFMEMORY if memory allocation fails.
*/
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
{
BindStatusCallback *holder;
IBindStatusCallback *bsc, *prev = NULL;
HRESULT hres;
TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
if (!pbc || !pbsc)
return E_INVALIDARG;
bsc = bsch_from_bctx(pbc);
if(bsc) {
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(SUCCEEDED(hres)) {
if(ppbscPrevious) {
IBindStatusCallback_AddRef(holder->callback);
*ppbscPrevious = holder->callback;
}
set_callback(holder, pbsc);
IBindStatusCallback_Release(bsc);
IBindStatusCallbackEx_Release(&holder->IBindStatusCallbackEx_iface);
return S_OK;
}else {
prev = bsc;
}
IBindCtx_RevokeObjectParam(pbc, bscb_holderW);
}
hres = wrap_callback(pbsc, &bsc);
if(SUCCEEDED(hres)) {
hres = IBindCtx_RegisterObjectParam(pbc, bscb_holderW, (IUnknown*)bsc);
IBindStatusCallback_Release(bsc);
}
if(FAILED(hres)) {
if(prev)
IBindStatusCallback_Release(prev);
return hres;
}
if(ppbscPrevious)
*ppbscPrevious = prev;
return S_OK;
}
static ULONG WINAPI Binding_Release(IBinding* iface)
{
Binding *This = (Binding*)iface;
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref=%d\n",This, ref);
if(!ref) {
heap_free(This->URLName);
if (This->hCacheFile)
CloseHandle(This->hCacheFile);
if (This->pstrCache)
{
UMCloseCacheFileStream(This->pstrCache);
IStream_Release((IStream *)This->pstrCache);
}
if (This->pbscb)
IBindStatusCallback_Release(This->pbscb);
heap_free(This);
URLMON_UnlockModule();
}
return ref;
}
static void navigate_bsc_task_destr(task_header_t *t)
{
task_navigate_bsc_t *task = (task_navigate_bsc_t*)t;
IBindStatusCallback_Release(&task->bsc->IBindStatusCallback_iface);
heap_free(task);
}
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;
}
void detach_bsc(bsc_t *bsc)
{
if(bsc->binding)
IBinding_Abort(bsc->binding);
bsc->obj = NULL;
IBindStatusCallback_Release((IBindStatusCallback*)&bsc->lpVtbl);
}
void BindStatusCallback_Detach(BindStatusCallback *bsc)
{
if (bsc)
{
if (bsc->binding) IBinding_Abort(bsc->binding);
bsc->request = NULL;
IBindStatusCallback_Release((IBindStatusCallback*)bsc);
}
}
static void BindStatusCallback_Detach(BindStatusCallback *bsc)
{
if (bsc)
{
if (bsc->binding) IBinding_Abort(bsc->binding);
bsc->request = NULL;
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
}
}
static void release_install_ctx(install_ctx_t *ctx)
{
if(ctx->uri)
IUri_Release(ctx->uri);
if(ctx->callback)
IBindStatusCallback_Release(ctx->callback);
heap_free(ctx->install_file);
heap_free(ctx);
}
static void navigate_bsc_proc(DocHost *This, task_header_t *t)
{
task_navigate_bsc_t *task = (task_navigate_bsc_t*)t;
if(!This->hwnd)
create_doc_view_hwnd(This);
navigate_bsc(This, task->bsc, NULL);
IBindStatusCallback_Release(&task->bsc->IBindStatusCallback_iface);
}
static HRESULT navigate_hlink(DocHost *This, IMoniker *mon, IBindCtx *bindctx,
IBindStatusCallback *callback)
{
IHttpNegotiate *http_negotiate;
BindStatusCallback *bsc;
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL, url;
BINDINFO bindinfo;
DWORD bindf = 0;
HRESULT hres;
TRACE("\n");
hres = IMoniker_GetDisplayName(mon, 0, NULL, &url);
if(FAILED(hres))
FIXME("GetDisplayName failed: %08x\n", hres);
hres = IBindStatusCallback_QueryInterface(callback, &IID_IHttpNegotiate,
(void**)&http_negotiate);
if(SUCCEEDED(hres)) {
static const WCHAR null_string[] = {0};
IHttpNegotiate_BeginningTransaction(http_negotiate, null_string, null_string, 0,
&headers);
IHttpNegotiate_Release(http_negotiate);
}
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(bindinfo);
hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo);
dump_BINDINFO(&bindinfo);
if(bindinfo.dwBindVerb == BINDVERB_POST) {
post_data_len = bindinfo.cbstgmedData;
if(post_data_len)
post_data = bindinfo.stgmedData.u.hGlobal;
}
if(This->doc_navigate) {
hres = async_doc_navigate(This, url, headers, post_data, post_data_len, FALSE);
}else {
bsc = create_callback(This, url, post_data, post_data_len, headers);
hres = navigate_bsc(This, bsc, mon);
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
}
CoTaskMemFree(url);
CoTaskMemFree(headers);
ReleaseBindInfo(&bindinfo);
return hres;
}
HRESULT detach_bsc(bsc_t *bsc)
{
HRESULT hres;
if(bsc->binding)
IBinding_Abort(bsc->binding);
bsc->obj = NULL;
hres = bsc->hres;
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
return hres;
}
HRESULT create_default_callback(IBindStatusCallback **ret)
{
IBindStatusCallback *callback;
HRESULT hres;
hres = DownloadBSC_Create(NULL, NULL, &callback);
if(FAILED(hres))
return hres;
hres = wrap_callback(callback, ret);
IBindStatusCallback_Release(callback);
return hres;
}
/***********************************************************************
* RevokeBindStatusCallback (URLMON.@)
*
* Unregister a bind status callback.
*
* pbc [I] Binding context
* pbsc [I] Callback to unregister
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid
*/
HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
{
BindStatusCallback *holder;
IBindStatusCallback *callback;
IUnknown *unk;
BOOL dorevoke = FALSE;
HRESULT hres;
TRACE("(%p %p)\n", pbc, pbsc);
if (!pbc || !pbsc)
return E_INVALIDARG;
hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
if(FAILED(hres))
return S_OK;
hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback);
IUnknown_Release(unk);
if(FAILED(hres))
return S_OK;
hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(SUCCEEDED(hres)) {
if(pbsc == holder->callback)
dorevoke = TRUE;
IBindStatusCallback_Release(STATUSCLB(holder));
}else if(pbsc == callback) {
dorevoke = TRUE;
}
IBindStatusCallback_Release(callback);
if(dorevoke)
IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
return S_OK;
}
static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallbackEx *iface)
{
BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref = %d\n", This, ref);
if(!ref) {
if(This->serv_prov)
IServiceProvider_Release(This->serv_prov);
IBindStatusCallback_Release(This->callback);
heap_free(This);
}
return ref;
}
static void set_callback(BindStatusCallback *This, IBindStatusCallback *bsc)
{
IServiceProvider *serv_prov;
HRESULT hres;
if(This->callback)
IBindStatusCallback_Release(This->callback);
if(This->serv_prov)
IServiceProvider_Release(This->serv_prov);
IBindStatusCallback_AddRef(bsc);
This->callback = bsc;
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IServiceProvider, (void**)&serv_prov);
This->serv_prov = hres == S_OK ? serv_prov : NULL;
}
static ULONG WINAPI XMLView_BindStatusCallback_Release(
IBindStatusCallback *iface)
{
BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p)->(%d)\n", This, ref);
if(!ref) {
if(This->stream)
IStream_Release(This->stream);
IBindStatusCallback_Release(This->bsc);
IMoniker_Release(This->mon);
heap_free(This);
}
return ref;
}
static ULONG WINAPI DownloadBSC_Release(IBindStatusCallback *iface)
{
DownloadBSC *This = STATUSCLB_THIS(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref = %d\n", This, ref);
if(!ref) {
if(This->callback)
IBindStatusCallback_Release(This->callback);
heap_free(This->file_name);
heap_free(This->cache_file);
heap_free(This);
}
return ref;
}
/***********************************************************************
* RevokeBindStatusCallback (URLMON.@)
*
* Unregister a bind status callback.
*
* pbc [I] Binding context
* pbsc [I] Callback to unregister
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid
*/
HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
{
IBindStatusCallback *callback;
TRACE("(%p %p)\n", pbc, pbsc);
if (!pbc || !pbsc)
return E_INVALIDARG;
callback = bsc_from_bctx(pbc);
if(!callback)
return S_OK;
if(callback == pbsc)
IBindCtx_RevokeObjectParam(pbc, bscb_holderW);
IBindStatusCallback_Release(callback);
return S_OK;
}
static void Binding_FinishedDownload(Binding *This, HRESULT hr)
{
STGMEDIUM stg;
FORMATETC fmt;
fmt.ptd = NULL;
fmt.dwAspect = 0;
fmt.lindex = -1;
fmt.tymed = TYMED_ISTREAM;
stg.tymed = TYMED_ISTREAM;
stg.u.pstm = (IStream *)This->pstrCache;
stg.pUnkForRelease = NULL;
IBindStatusCallback_OnProgress(This->pbscb, This->total_read, This->expected_size,
BINDSTATUS_ENDDOWNLOADDATA, This->URLName);
IBindStatusCallback_OnDataAvailable(This->pbscb, BSCF_LASTDATANOTIFICATION, This->total_read, &fmt, &stg);
if (hr != S_OK)
{
WCHAR *pwchError = 0;
FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_ALLOCATE_BUFFER,
NULL, (DWORD) hr,
0, (LPWSTR) &pwchError,
0, NULL);
if (!pwchError)
{
static const WCHAR achFormat[] = { '%', '0', '8', 'x', 0 };
pwchError =(WCHAR *) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * 9);
wsprintfW(pwchError, achFormat, hr);
}
IBindStatusCallback_OnStopBinding(This->pbscb, hr, pwchError);
LocalFree(pwchError);
}
else
{
IBindStatusCallback_OnStopBinding(This->pbscb, hr, NULL);
}
IBindStatusCallback_Release(This->pbscb);
This->pbscb = 0;
}
HRESULT bind_url(IMoniker *mon, HRESULT (*onDataAvailable)(void*,char*,DWORD),
void *obj, bsc_t **ret)
{
bsc_t *bsc;
IBindCtx *pbc;
HRESULT hr;
TRACE("%p\n", mon);
hr = CreateBindCtx(0, &pbc);
if(FAILED(hr))
return hr;
bsc = heap_alloc(sizeof(bsc_t));
bsc->IBindStatusCallback_iface.lpVtbl = &bsc_vtbl;
bsc->ref = 1;
bsc->obj = obj;
bsc->onDataAvailable = onDataAvailable;
bsc->binding = NULL;
bsc->memstream = NULL;
bsc->hres = S_OK;
hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
if(SUCCEEDED(hr))
{
IStream *stream;
hr = IMoniker_BindToStorage(mon, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
if(stream)
IStream_Release(stream);
IBindCtx_Release(pbc);
}
if(FAILED(hr))
{
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
bsc = NULL;
}
*ret = bsc;
return hr;
}
static ULONG WINAPI Binding_Release(IBinding *iface)
{
Binding *This = BINDING_THIS(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref) {
if(This->notif_hwnd)
release_notif_hwnd(This->notif_hwnd);
if(This->mon)
IMoniker_Release(This->mon);
if(This->callback)
IBindStatusCallback_Release(This->callback);
if(This->protocol)
IInternetProtocol_Release(This->protocol);
if(This->service_provider)
IServiceProvider_Release(This->service_provider);
if(This->stgmed_buf)
IUnknown_Release(STGMEDUNK(This->stgmed_buf));
if(This->stgmed_obj)
This->stgmed_obj->vtbl->release(This->stgmed_obj);
if(This->obj)
IUnknown_Release(This->obj);
if(This->bctx)
IBindCtx_Release(This->bctx);
ReleaseBindInfo(&This->bindinfo);
This->section.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&This->section);
heap_free(This->mime);
heap_free(This->redirect_url);
heap_free(This->url);
heap_free(This);
URLMON_UnlockModule();
}
return ref;
}
static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
{
BindStatusCallback *This = STATUSCLB_THIS(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref = %d\n", This, ref);
if(!ref) {
if(This->serv_prov)
IServiceProvider_Release(This->serv_prov);
if(This->http_negotiate)
IHttpNegotiate_Release(This->http_negotiate);
if(This->http_negotiate2)
IHttpNegotiate2_Release(This->http_negotiate2);
if(This->authenticate)
IAuthenticate_Release(This->authenticate);
IBindStatusCallback_Release(This->callback);
heap_free(This);
}
return ref;
}
/***********************************************************************
* 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;
}
IBindStatusCallback *bsc_from_bctx(IBindCtx *bctx)
{
BindStatusCallback *holder;
IBindStatusCallback *bsc;
HRESULT hres;
bsc = bsch_from_bctx(bctx);
if(!bsc)
return NULL;
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(FAILED(hres))
return bsc;
if(holder->callback) {
IBindStatusCallback_Release(bsc);
bsc = holder->callback;
IBindStatusCallback_AddRef(bsc);
}
IBindStatusCallbackEx_Release(&holder->IBindStatusCallbackEx_iface);
return bsc;
}
static int
download_file(IN LPCTSTR pszUrl,
IN LPCTSTR pszFile OPTIONAL)
{
TCHAR szScheme[INTERNET_MAX_SCHEME_LENGTH + 1];
TCHAR szHostName[INTERNET_MAX_HOST_NAME_LENGTH + 1];
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1];
TCHAR szPassWord[INTERNET_MAX_PASSWORD_LENGTH + 1];
TCHAR szUrlPath[INTERNET_MAX_PATH_LENGTH + 1];
TCHAR szExtraInfo[INTERNET_MAX_PATH_LENGTH + 1];
TCHAR szUrl[INTERNET_MAX_URL_LENGTH + 1];
DWORD dwUrlLen;
LPTSTR pszFilePart;
URL_COMPONENTS urlc;
IBindStatusCallback *pbsc;
int iRet;
if (pszFile != NULL && pszFile[0] == _T('\0'))
pszFile = NULL;
urlc.dwStructSize = sizeof(urlc);
urlc.lpszScheme = szScheme;
urlc.dwSchemeLength = sizeof(szScheme) / sizeof(szScheme[0]);
urlc.lpszHostName = szHostName;
urlc.dwHostNameLength = sizeof(szHostName) / sizeof(szHostName[0]);
urlc.lpszUserName = szUserName;
urlc.dwUserNameLength = sizeof(szUserName) / sizeof(szUserName[0]);
urlc.lpszPassword = szPassWord;
urlc.dwPasswordLength = sizeof(szPassWord) / sizeof(szPassWord[0]);
urlc.lpszUrlPath = szUrlPath;
urlc.dwUrlPathLength = sizeof(szUrlPath) / sizeof(szUrlPath[0]);
urlc.lpszExtraInfo = szExtraInfo;
urlc.dwExtraInfoLength = sizeof(szExtraInfo) / sizeof(szExtraInfo[0]);
if (!InternetCrackUrl(pszUrl, _tcslen(pszUrl), ICU_ESCAPE, &urlc))
return DWNL_E_LASTERROR;
if (urlc.nScheme != INTERNET_SCHEME_FTP &&
urlc.nScheme != INTERNET_SCHEME_GOPHER &&
urlc.nScheme != INTERNET_SCHEME_HTTP &&
urlc.nScheme != INTERNET_SCHEME_HTTPS)
{
return DWNL_E_UNSUPPORTEDSCHEME;
}
if (urlc.nScheme == INTERNET_SCHEME_FTP && urlc.dwUserNameLength == 0 && urlc.dwPasswordLength == 0)
{
_tcscpy(szUserName, _T("anonymous"));
urlc.dwUserNameLength = _tcslen(szUserName);
}
/* FIXME: Get file name from server */
if (urlc.dwUrlPathLength == 0 && pszFile == NULL)
return DWNL_E_NEEDTARGETFILENAME;
pszFilePart = _tcsrchr(szUrlPath, _T('/'));
if (pszFilePart != NULL)
pszFilePart++;
if (pszFilePart == NULL && pszFile == NULL)
return DWNL_E_NEEDTARGETFILENAME;
if (pszFile == NULL)
pszFile = pszFilePart;
if (urlc.dwUserNameLength == 0)
urlc.lpszUserName = NULL;
if (urlc.dwPasswordLength == 0)
urlc.lpszPassword = NULL;
/* Generate the URL to be displayed (without a password) */
dwUrlLen = sizeof(szUrl) / sizeof(szUrl[0]);
iRet = get_display_url(&urlc, szUrl, &dwUrlLen);
if (iRet <= 0)
return iRet;
_tprintf(_T("Download `%s\'\n\t=> `%s\'\n"), szUrl, pszFile);
/* Generate the URL to download */
dwUrlLen = sizeof(szUrl) / sizeof(szUrl[0]);
if (!InternetCreateUrl(&urlc, ICU_ESCAPE, szUrl, &dwUrlLen))
return DWNL_E_LASTERROR;
pbsc = CreateBindStatusCallback();
if (pbsc == NULL)
return DWNL_E_LASTERROR;
if(!SUCCEEDED(URLDownloadToFile(NULL, szUrl, pszFile, 0, pbsc)))
{
IBindStatusCallback_Release(pbsc);
return DWNL_E_LASTERROR; /* FIXME */
}
IBindStatusCallback_Release(pbsc);
return 1;
}
static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate *iface)
{
BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}
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 set_moniker(HTMLOuterWindow *window, IMoniker *mon, IUri *nav_uri, IBindCtx *pibc, nsChannelBSC *async_bsc,
BOOL set_download)
{
download_proc_task_t *download_task;
HTMLDocumentObj *doc_obj = NULL;
nsChannelBSC *bscallback;
nsWineURI *nsuri;
LPOLESTR url;
IUri *uri;
HRESULT hres;
if(window->doc_obj && window->doc_obj->basedoc.window == window)
doc_obj = window->doc_obj;
hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
if(FAILED(hres)) {
WARN("GetDiaplayName failed: %08x\n", hres);
return hres;
}
if(nav_uri) {
uri = nav_uri;
}else {
hres = create_uri(url, 0, &uri);
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
}
TRACE("got url: %s\n", debugstr_w(url));
set_ready_state(window, READYSTATE_LOADING);
hres = create_doc_uri(window, uri, &nsuri);
if(!nav_uri)
IUri_Release(uri);
if(SUCCEEDED(hres)) {
if(async_bsc)
bscallback = async_bsc;
else
hres = create_channelbsc(mon, NULL, NULL, 0, TRUE, &bscallback);
}
if(SUCCEEDED(hres)) {
if(window->base.inner_window->doc)
remove_target_tasks(window->base.inner_window->task_magic);
abort_window_bindings(window->base.inner_window);
hres = load_nsuri(window, nsuri, bscallback, LOAD_FLAGS_BYPASS_CACHE);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres)) {
hres = create_pending_window(window, bscallback);
TRACE("pending window for %p %p %p\n", window, bscallback, window->pending_window);
}
if(bscallback != async_bsc)
IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
}
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
if(doc_obj) {
HTMLDocument_LockContainer(doc_obj, TRUE);
if(doc_obj->frame) {
docobj_task_t *task;
task = heap_alloc(sizeof(docobj_task_t));
task->doc = doc_obj;
hres = push_task(&task->header, set_progress_proc, NULL, doc_obj->basedoc.task_magic);
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
}
download_task = heap_alloc(sizeof(download_proc_task_t));
download_task->doc = doc_obj;
download_task->set_download = set_download;
download_task->url = url;
return push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, doc_obj->basedoc.task_magic);
}
return S_OK;
}
static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface)
{
BindStatusCallback *This = impl_from_IHttpSecurity(iface);
return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}
