/*********************************************************************** * 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); }