HRESULT bind_to_storage(IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
{
Binding *binding = NULL, *binding_ctx;
HRESULT hres;
*ppv = NULL;
binding_ctx = get_bctx_binding(pbc);
hres = start_binding(NULL, binding_ctx, uri, pbc, FALSE, riid, &binding);
if(binding_ctx)
IBinding_Release(BINDING(binding_ctx));
if(FAILED(hres))
return hres;
if(binding->hres == S_OK && binding->stgmed_buf->init) {
if((binding->state & BINDING_STOPPED) && (binding->state & BINDING_LOCKED))
IInternetProtocol_UnlockRequest(binding->protocol);
hres = binding->stgmed_obj->vtbl->get_result(binding->stgmed_obj, binding->bindf, ppv);
} else if(binding->bindf & BINDF_ASYNCHRONOUS) {
hres = MK_S_ASYNCHRONOUS;
} else {
hres = FAILED(binding->hres) ? binding->hres : S_OK;
}
IBinding_Release(BINDING(binding));
return hres;
}
static HRESULT start_binding(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
BOOL to_obj, REFIID riid, Binding **ret)
{
Binding *binding = NULL;
HRESULT hres;
MSG msg;
hres = Binding_Create(mon, binding_ctx, uri, pbc, to_obj, riid, &binding);
if(FAILED(hres))
return hres;
hres = IBindStatusCallback_OnStartBinding(binding->callback, 0, &binding->IBinding_iface);
if(FAILED(hres)) {
WARN("OnStartBinding failed: %08x\n", hres);
stop_binding(binding, INET_E_DOWNLOAD_FAILURE, NULL);
IBinding_Release(&binding->IBinding_iface);
return hres;
}
if(binding_ctx) {
set_binding_sink(binding->protocol, &binding->IInternetProtocolSink_iface,
&binding->IInternetBindInfo_iface);
if(binding_ctx->redirect_url)
IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_REDIRECTING, binding_ctx->redirect_url);
report_data(binding, BSCF_FIRSTDATANOTIFICATION | (binding_ctx->download_state == END_DOWNLOAD ? BSCF_LASTDATANOTIFICATION : 0),
0, 0);
}else {
hres = IInternetProtocolEx_StartEx(&binding->protocol->IInternetProtocolEx_iface, uri,
&binding->IInternetProtocolSink_iface, &binding->IInternetBindInfo_iface,
PI_APARTMENTTHREADED|PI_MIMEVERIFICATION, 0);
TRACE("start ret %08x\n", hres);
if(FAILED(hres) && hres != E_PENDING) {
stop_binding(binding, hres, NULL);
IBinding_Release(&binding->IBinding_iface);
return hres;
}
}
while(!(binding->bindf & BINDF_ASYNCHRONOUS) &&
!(binding->state & BINDING_STOPPED)) {
MsgWaitForMultipleObjects(0, NULL, FALSE, 5000, QS_POSTMESSAGE);
while (PeekMessageW(&msg, binding->notif_hwnd, WM_USER, WM_USER+117, PM_REMOVE|PM_NOYIELD)) {
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
*ret = binding;
return S_OK;
}
static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
HRESULT hresult, LPCWSTR szError)
{
BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
set_status_text(This, 0, emptyW);
if(!This->doc_host)
return S_OK;
if(!This->doc_host->olecmd)
notify_download_state(This->doc_host, FALSE);
if(FAILED(hresult))
handle_navigation_error(This->doc_host, hresult, This->url, NULL);
IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
This->doc_host = NULL;
IBinding_Release(This->binding);
This->binding = NULL;
return S_OK;
}
static HRESULT WINAPI bsc_OnStopBinding(
IBindStatusCallback* iface,
HRESULT hresult,
LPCWSTR szError)
{
bsc_t *This = impl_from_IBindStatusCallback(iface);
HRESULT hr = S_OK;
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
if(This->binding) {
IBinding_Release(This->binding);
This->binding = NULL;
}
if(This->obj && SUCCEEDED(hresult)) {
HGLOBAL hglobal;
hr = GetHGlobalFromStream(This->memstream, &hglobal);
if(SUCCEEDED(hr))
{
DWORD len = GlobalSize(hglobal);
char *ptr = GlobalLock(hglobal);
hr = This->onDataAvailable(This->obj, ptr, len);
GlobalUnlock(hglobal);
}
}
return hr;
}
HRESULT bind_to_object(IMoniker *mon, IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
{
Binding *binding;
HRESULT hres;
*ppv = NULL;
hres = start_binding(mon, NULL, uri, pbc, TRUE, riid, &binding);
if(FAILED(hres))
return hres;
if(binding->hres != S_OK) {
hres = SUCCEEDED(binding->hres) ? S_OK : binding->hres;
} else if(binding->bindf & BINDF_ASYNCHRONOUS) {
hres = MK_S_ASYNCHRONOUS;
} else {
*ppv = binding->obj;
IUnknown_AddRef(binding->obj);
hres = S_OK;
}
IBinding_Release(BINDING(binding));
return hres;
}
static HRESULT WINAPI DownloadBSC_OnStopBinding(IBindStatusCallback *iface,
HRESULT hresult, LPCWSTR szError)
{
DownloadBSC *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
if(This->file_name) {
if(This->cache_file) {
BOOL b;
b = CopyFileW(This->cache_file, This->file_name, FALSE);
if(!b)
FIXME("CopyFile failed: %u\n", GetLastError());
}else {
FIXME("No cache file\n");
}
}
if(This->callback)
IBindStatusCallback_OnStopBinding(This->callback, hresult, szError);
if(This->binding) {
IBinding_Release(This->binding);
This->binding = NULL;
}
return S_OK;
}
static ULONG WINAPI XMLView_Binding_Release(IBinding *iface)
{
Binding *This = impl_from_IBinding(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p)->(%d)\n", This, ref);
if(!ref) {
IBinding_Release(This->binding);
heap_free(This);
}
return ref;
}
static HRESULT WINAPI InstallCallback_OnStopBinding(IBindStatusCallback *iface,
HRESULT hresult, LPCWSTR szError)
{
if(dwl_binding) {
IBinding_Release(dwl_binding);
dwl_binding = NULL;
}
if(FAILED(hresult)) {
if(hresult == E_ABORT)
TRACE("Binding aborted\n");
else
ERR("Binding failed %08x\n", hresult);
return S_OK;
}
if(!msi_file) {
ERR("No MSI file\n");
return E_FAIL;
}
set_status(IDS_INSTALLING);
EnableWindow(GetDlgItem(install_dialog, IDCANCEL), 0);
if(sha_check(msi_file)) {
WCHAR *cache_file_name;
install_file(msi_file);
cache_file_name = get_cache_file_name(TRUE);
if(cache_file_name) {
CopyFileW(msi_file, cache_file_name, FALSE);
heap_free(cache_file_name);
}
}else {
WCHAR message[256];
if(LoadStringW(hInst, IDS_INVALID_SHA, message, ARRAY_SIZE(message)))
MessageBoxW(NULL, message, NULL, MB_ICONERROR);
}
DeleteFileW(msi_file);
heap_free(msi_file);
msi_file = NULL;
EndDialog(install_dialog, 0);
return S_OK;
}
static ULONG WINAPI bsc_Release(
IBindStatusCallback *iface )
{
bsc_t *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref) {
if (This->binding) IBinding_Release(This->binding);
if (This->memstream) IStream_Release(This->memstream);
heap_free(This);
}
return ref;
}
static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
HRESULT hr, LPCWSTR error)
{
BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
if (This->binding)
{
IBinding_Release(This->binding);
This->binding = NULL;
}
if (hr == S_OK)
httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
return S_OK;
}
static ULONG WINAPI DownloadBSC_Release(IBindStatusCallback *iface)
{
DownloadBSC *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref = %d\n", This, ref);
if(!ref) {
if(This->callback)
IBindStatusCallback_Release(This->callback);
if(This->binding)
IBinding_Release(This->binding);
heap_free(This->file_name);
heap_free(This->cache_file);
heap_free(This);
}
return ref;
}
static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
{
BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref) {
if(This->doc_host)
IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
if(This->binding)
IBinding_Release(This->binding);
if(This->post_data)
GlobalFree(This->post_data);
SysFreeString(This->headers);
SysFreeString(This->url);
heap_free(This);
}
return ref;
}
static HRESULT WINAPI XMLView_BindStatusCallback_OnStartBinding(
IBindStatusCallback *iface, DWORD dwReserved, IBinding *pib)
{
BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
IBinding *binding;
HRESULT hres;
TRACE("(%p)->(%x %p)\n", This, dwReserved, pib);
hres = XMLView_Binding_Create(pib, &binding);
if(FAILED(hres)) {
IBinding_Abort(pib);
return hres;
}
hres = IBindStatusCallback_OnStartBinding(This->bsc, dwReserved, binding);
if(FAILED(hres)) {
IBinding_Abort(binding);
return hres;
}
IBinding_Release(binding);
return hres;
}
static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
{
Binding *This = impl_from_IInternetBindInfo(iface);
return IBinding_Release(&This->IBinding_iface);
}
/******************************************************************************
* URLMoniker_BindToStorage
******************************************************************************/
static HRESULT URLMonikerImpl_BindToStorage_hack(LPCWSTR URLName, IBindCtx* pbc, VOID** ppvObject)
{
HRESULT hres;
BINDINFO bi;
DWORD bindf;
WCHAR szFileName[MAX_PATH + 1];
Binding *bind;
int len;
WARN("(%s %p %p)\n", debugstr_w(URLName), pbc, ppvObject);
bind = heap_alloc_zero(sizeof(Binding));
bind->lpVtbl = &BindingVtbl;
bind->ref = 1;
URLMON_LockModule();
len = lstrlenW(URLName)+1;
bind->URLName = heap_alloc(len*sizeof(WCHAR));
memcpy(bind->URLName, URLName, len*sizeof(WCHAR));
hres = UMCreateStreamOnCacheFile(bind->URLName, 0, szFileName, &bind->hCacheFile, &bind->pstrCache);
if(SUCCEEDED(hres)) {
TRACE("Created stream...\n");
*ppvObject = (void *) bind->pstrCache;
IStream_AddRef((IStream *) bind->pstrCache);
hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown**)&bind->pbscb);
if(SUCCEEDED(hres)) {
TRACE("Got IBindStatusCallback...\n");
memset(&bi, 0, sizeof(bi));
bi.cbSize = sizeof(bi);
bindf = 0;
hres = IBindStatusCallback_GetBindInfo(bind->pbscb, &bindf, &bi);
if(SUCCEEDED(hres)) {
URL_COMPONENTSW url;
WCHAR *host, *path, *user, *pass;
DWORD dwService = 0;
BOOL bSuccess;
TRACE("got bindinfo. bindf = %08x extrainfo = %s bindinfof = %08x bindverb = %08x iid %s\n",
bindf, debugstr_w(bi.szExtraInfo), bi.grfBindInfoF, bi.dwBindVerb, debugstr_guid(&bi.iid));
hres = IBindStatusCallback_OnStartBinding(bind->pbscb, 0, (IBinding*)bind);
TRACE("OnStartBinding rets %08x\n", hres);
bind->expected_size = 0;
bind->total_read = 0;
memset(&url, 0, sizeof(url));
url.dwStructSize = sizeof(url);
url.dwSchemeLength = url.dwHostNameLength = url.dwUrlPathLength = url.dwUserNameLength = url.dwPasswordLength = 1;
InternetCrackUrlW(URLName, 0, ICU_ESCAPE, &url);
host = heap_alloc((url.dwHostNameLength + 1) * sizeof(WCHAR));
memcpy(host, url.lpszHostName, url.dwHostNameLength * sizeof(WCHAR));
host[url.dwHostNameLength] = '\0';
path = heap_alloc((url.dwUrlPathLength + 1) * sizeof(WCHAR));
memcpy(path, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR));
path[url.dwUrlPathLength] = '\0';
if (url.dwUserNameLength)
{
user = heap_alloc(((url.dwUserNameLength + 1) * sizeof(WCHAR)));
memcpy(user, url.lpszUserName, url.dwUserNameLength * sizeof(WCHAR));
user[url.dwUserNameLength] = 0;
}
else
{
user = 0;
}
if (url.dwPasswordLength)
{
pass = heap_alloc(((url.dwPasswordLength + 1) * sizeof(WCHAR)));
memcpy(pass, url.lpszPassword, url.dwPasswordLength * sizeof(WCHAR));
pass[url.dwPasswordLength] = 0;
}
else
{
pass = 0;
}
do {
bind->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0);
if (!bind->hinternet)
{
hres = HRESULT_FROM_WIN32(GetLastError());
break;
}
switch ((DWORD) url.nScheme)
{
case INTERNET_SCHEME_FTP:
if (!url.nPort)
url.nPort = INTERNET_DEFAULT_FTP_PORT;
dwService = INTERNET_SERVICE_FTP;
break;
case INTERNET_SCHEME_GOPHER:
if (!url.nPort)
url.nPort = INTERNET_DEFAULT_GOPHER_PORT;
dwService = INTERNET_SERVICE_GOPHER;
break;
}
bind->hconnect = InternetConnectW(bind->hinternet, host, url.nPort, user, pass,
dwService, 0, (DWORD_PTR)bind);
if (!bind->hconnect)
{
hres = HRESULT_FROM_WIN32(GetLastError());
CloseHandle(bind->hinternet);
break;
}
hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, 0x22, NULL);
hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CONNECTING, NULL);
hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL);
bSuccess = FALSE;
switch (dwService)
{
case INTERNET_SERVICE_GOPHER:
bind->hrequest = GopherOpenFileW(bind->hconnect,
path,
0,
INTERNET_FLAG_RELOAD,
0);
if (bind->hrequest)
bSuccess = TRUE;
else
hres = HRESULT_FROM_WIN32(GetLastError());
break;
case INTERNET_SERVICE_FTP:
bind->hrequest = FtpOpenFileW(bind->hconnect,
path,
GENERIC_READ,
FTP_TRANSFER_TYPE_BINARY |
INTERNET_FLAG_TRANSFER_BINARY |
INTERNET_FLAG_RELOAD,
0);
if (bind->hrequest)
bSuccess = TRUE;
else
hres = HRESULT_FROM_WIN32(GetLastError());
break;
}
if(bSuccess)
{
TRACE("res = %d gle = %u url len = %d\n", hres, GetLastError(), bind->expected_size);
IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName);
while(1) {
char buf[4096];
DWORD bufread;
if(InternetReadFile(bind->hrequest, buf, sizeof(buf), &bufread)) {
TRACE("read %d bytes %s...\n", bufread, debugstr_an(buf, 10));
if(bufread == 0) break;
hres = Binding_MoreCacheData(bind, buf, bufread);
} else
break;
}
InternetCloseHandle(bind->hrequest);
hres = S_OK;
}
InternetCloseHandle(bind->hconnect);
InternetCloseHandle(bind->hinternet);
} while(0);
Binding_FinishedDownload(bind, hres);
Binding_CloseCacheDownload(bind);
heap_free(user);
heap_free(pass);
heap_free(path);
heap_free(host);
}
}
}
IBinding_Release((IBinding*)bind);
return hres;
}
static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
{
Binding *This = SERVPROV_THIS(iface);
return IBinding_Release(BINDING(This));
}
static HRESULT Binding_Create(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
BOOL to_obj, REFIID riid, Binding **binding)
{
Binding *ret;
HRESULT hres;
URLMON_LockModule();
ret = heap_alloc_zero(sizeof(Binding));
ret->lpBindingVtbl = &BindingVtbl;
ret->lpIInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
ret->lpWinInetHttpInfoVtbl = &WinInetHttpInfoVtbl;
ret->lpServiceProviderVtbl = &ServiceProviderVtbl;
ret->ref = 1;
ret->to_object = to_obj;
ret->iid = *riid;
ret->notif_hwnd = get_notif_hwnd();
ret->report_mime = !binding_ctx;
ret->download_state = BEFORE_DOWNLOAD;
if(to_obj) {
IBindCtx_AddRef(pbc);
ret->bctx = pbc;
}
if(mon) {
IMoniker_AddRef(mon);
ret->mon = mon;
}
ret->bindinfo.cbSize = sizeof(BINDINFO);
InitializeCriticalSection(&ret->section);
ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": Binding.section");
hres = get_callback(pbc, &ret->callback);
if(FAILED(hres)) {
WARN("Could not get IBindStatusCallback\n");
IBinding_Release(BINDING(ret));
return hres;
}
IBindStatusCallback_QueryInterface(ret->callback, &IID_IServiceProvider,
(void**)&ret->service_provider);
if(binding_ctx) {
ret->protocol = binding_ctx->protocol;
IInternetProtocol_AddRef(ret->protocol);
} else {
hres = create_binding_protocol(TRUE, &ret->protocol);
if(FAILED(hres)) {
WARN("Could not get protocol handler\n");
IBinding_Release(BINDING(ret));
return hres;
}
}
hres = IBindStatusCallback_GetBindInfo(ret->callback, &ret->bindf, &ret->bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
IBinding_Release(BINDING(ret));
return hres;
}
TRACE("bindf %08x\n", ret->bindf);
dump_BINDINFO(&ret->bindinfo);
ret->bindf |= BINDF_FROMURLMON;
if(to_obj)
ret->bindinfo.dwOptions |= 0x100000;
if(!(ret->bindf & BINDF_ASYNCHRONOUS) || !(ret->bindf & BINDF_PULLDATA)) {
ret->bindf |= BINDF_NEEDFILE;
ret->use_cache_file = TRUE;
} else if(!is_urlmon_protocol(uri)) {
ret->bindf |= BINDF_NEEDFILE;
}
hres = IUri_GetDisplayUri(uri, &ret->url);
if(FAILED(hres)) {
IBinding_Release(BINDING(ret));
return hres;
}
if(binding_ctx) {
ret->stgmed_buf = binding_ctx->stgmed_buf;
IUnknown_AddRef(STGMEDUNK(ret->stgmed_buf));
ret->clipboard_format = binding_ctx->clipboard_format;
} else {
ret->stgmed_buf = create_stgmed_buf(ret->protocol);
}
if(to_obj) {
ret->stgmed_obj = NULL;
} else if(IsEqualGUID(&IID_IStream, riid)) {
ret->stgmed_obj = create_stgmed_stream(ret->stgmed_buf);
} else if(IsEqualGUID(&IID_IUnknown, riid)) {
ret->bindf |= BINDF_NEEDFILE;
ret->stgmed_obj = create_stgmed_file(ret->stgmed_buf);
} else {
FIXME("Unsupported riid %s\n", debugstr_guid(riid));
IBinding_Release(BINDING(ret));
return E_NOTIMPL;
}
*binding = ret;
return S_OK;
}
static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
{
Binding *This = BINDINF_THIS(iface);
return IBinding_Release(BINDING(This));
}
static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
{
Binding *This = INETINFO_THIS(iface);
return IBinding_Release(BINDING(This));
}
static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
{
Binding *This = PROTSINK_THIS(iface);
return IBinding_Release(BINDING(This));
}
static void report_data(Binding *This, DWORD bscf, ULONG progress, ULONG progress_max)
{
FORMATETC formatetc = {0, NULL, 1, -1, TYMED_ISTREAM};
BOOL sent_begindownloaddata = FALSE;
TRACE("(%p)->(%d %u %u)\n", This, bscf, progress, progress_max);
if(This->download_state == END_DOWNLOAD || (This->state & (BINDING_STOPPED|BINDING_ABORTED)))
return;
if(This->stgmed_buf->file != INVALID_HANDLE_VALUE)
read_protocol_data(This->stgmed_buf);
else if(This->download_state == BEFORE_DOWNLOAD)
fill_stgmed_buffer(This->stgmed_buf);
if(This->download_state == BEFORE_DOWNLOAD) {
This->download_state = DOWNLOADING;
sent_begindownloaddata = TRUE;
IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
BINDSTATUS_BEGINDOWNLOADDATA, This->url);
if(This->stgmed_buf->cache_file)
IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
BINDSTATUS_CACHEFILENAMEAVAILABLE, This->stgmed_buf->cache_file);
}
if(This->stgmed_buf->hres == S_FALSE || (bscf & BSCF_LASTDATANOTIFICATION)) {
This->download_state = END_DOWNLOAD;
IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
BINDSTATUS_ENDDOWNLOADDATA, This->url);
} else if(!sent_begindownloaddata) {
IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
BINDSTATUS_DOWNLOADINGDATA, This->url);
}
if(This->state & (BINDING_STOPPED|BINDING_ABORTED))
return;
if(This->to_object) {
if(!(This->state & BINDING_OBJAVAIL)) {
IBinding_AddRef(BINDING(This));
create_object(This);
IBinding_Release(BINDING(This));
}
} else {
STGMEDIUM stgmed;
HRESULT hres;
if(!(This->state & BINDING_LOCKED)) {
HRESULT hres = IInternetProtocol_LockRequest(This->protocol, 0);
if(SUCCEEDED(hres))
This->state |= BINDING_LOCKED;
}
hres = This->stgmed_obj->vtbl->fill_stgmed(This->stgmed_obj, &stgmed);
if(FAILED(hres)) {
stop_binding(This, hres, NULL);
return;
}
formatetc.tymed = stgmed.tymed;
formatetc.cfFormat = This->clipboard_format;
IBindStatusCallback_OnDataAvailable(This->callback, bscf, progress,
&formatetc, &stgmed);
if(This->download_state == END_DOWNLOAD)
stop_binding(This, S_OK, NULL);
}
}
static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
{
Binding *This = impl_from_IWinInetHttpInfo(iface);
return IBinding_Release(&This->IBinding_iface);
}
static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
{
Binding *This = impl_from_IServiceProvider(iface);
return IBinding_Release(&This->IBinding_iface);
}
static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
{
Binding *This = impl_from_IInternetProtocolSink(iface);
return IBinding_Release(&This->IBinding_iface);
}
static ULONG WINAPI HttpInfo_Release(IWinInetHttpInfo *iface)
{
HttpProtocol *This = INETINFO_THIS(iface);
return IBinding_Release(PROTOCOL(This));
}
static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
{
BindProtocol *This = BINDINFO_THIS(iface);
return IBinding_Release(PROTOCOL(This));
}