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; }
/****************************************************************************** * FileMoniker_IsEqual */ static HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) { FileMonikerImpl *This = impl_from_IMoniker(iface); CLSID clsid; LPOLESTR filePath; IBindCtx* bind; HRESULT res; TRACE("(%p,%p)\n",iface,pmkOtherMoniker); if (pmkOtherMoniker==NULL) return S_FALSE; IMoniker_GetClassID(pmkOtherMoniker,&clsid); if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker)) return S_FALSE; res = CreateBindCtx(0,&bind); if (FAILED(res)) return res; res = S_FALSE; if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) { if (!lstrcmpiW(filePath, This->filePathName)) res = S_OK; CoTaskMemFree(filePath); } IBindCtx_Release(bind); return res; }
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; }
static HRESULT WINAPI URLMoniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker) { URLMoniker *This = impl_from_IMoniker(iface); CLSID clsid; LPOLESTR urlPath; IBindCtx* bind; HRESULT res; TRACE("(%p,%p)\n",This, pmkOtherMoniker); if(pmkOtherMoniker==NULL) return E_INVALIDARG; IMoniker_GetClassID(pmkOtherMoniker,&clsid); if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker)) return S_FALSE; res = CreateBindCtx(0,&bind); if(FAILED(res)) return res; res = S_FALSE; if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) { int result = lstrcmpiW(urlPath, This->URLName); CoTaskMemFree(urlPath); if(result == 0) res = S_OK; } IBindCtx_Release(bind); return res; }
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; }
/*********************************************************************** * CreateURLMonikerEx (URLMON.@) * * Create a url moniker. * * PARAMS * pmkContext [I] Context * szURL [I] Url to create the moniker for * ppmk [O] Destination for created moniker. * dwFlags [I] Flags. * * RETURNS * Success: S_OK. ppmk contains the created IMoniker object. * Failure: MK_E_SYNTAX if szURL is not a valid url, or * E_OUTOFMEMORY if memory allocation fails. */ HRESULT WINAPI CreateURLMonikerEx(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk, DWORD dwFlags) { URLMonikerImpl *obj; HRESULT hres; LPOLESTR lefturl = NULL; TRACE("(%p, %s, %p, %08x)\n", pmkContext, debugstr_w(szURL), ppmk, dwFlags); if (dwFlags & URL_MK_UNIFORM) FIXME("ignoring flag URL_MK_UNIFORM\n"); if(!(obj = heap_alloc(sizeof(*obj)))) return E_OUTOFMEMORY; if(pmkContext) { IBindCtx* bind; DWORD dwMksys = 0; IMoniker_IsSystemMoniker(pmkContext, &dwMksys); if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) { IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl); TRACE("lefturl = %s\n", debugstr_w(lefturl)); IBindCtx_Release(bind); } } hres = URLMonikerImpl_Construct(obj, lefturl, szURL); CoTaskMemFree(lefturl); if(SUCCEEDED(hres)) hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &IID_IMoniker, (void**)ppmk); else heap_free(obj); return hres; }
static HRESULT WINAPI IHlink_fnGetFriendlyName (IHlink* iface, DWORD grfHLFNAMEF, LPWSTR* ppwzFriendlyName) { HlinkImpl *This = impl_from_IHlink(iface); TRACE("(%p) -> (%i %p)\n", This, grfHLFNAMEF, ppwzFriendlyName); /* FIXME: Only using explicitly set and cached friendly names */ if (This->FriendlyName) *ppwzFriendlyName = hlink_co_strdupW( This->FriendlyName ); else { IMoniker *moniker; HRESULT hres = __GetMoniker(This, &moniker, HLINKGETREF_DEFAULT); if (FAILED(hres)) { *ppwzFriendlyName = NULL; return hres; } if (moniker) { IBindCtx *bcxt; CreateBindCtx(0, &bcxt); IMoniker_GetDisplayName(moniker, bcxt, NULL, ppwzFriendlyName); IBindCtx_Release(bcxt); IMoniker_Release(moniker); } else *ppwzFriendlyName = NULL; } return S_OK; }
/*********************************************************************** * HlinkResolveMonikerForData (HLINK.@) */ HRESULT WINAPI HlinkResolveMonikerForData(LPMONIKER pimkReference, DWORD reserved, LPBC pibc, ULONG cFmtetc, FORMATETC *rgFmtetc, IBindStatusCallback *pibsc, LPMONIKER pimkBase) { LPOLESTR name = NULL; IBindCtx *bctx; DWORD mksys = 0; void *obj = NULL; HRESULT hres; TRACE("(%p %x %p %d %p %p %p)\n", pimkReference, reserved, pibc, cFmtetc, rgFmtetc, pibsc, pimkBase); if(cFmtetc || rgFmtetc || pimkBase) FIXME("Unsupported args\n"); hres = RegisterBindStatusCallback(pibc, pibsc, NULL /* FIXME */, 0); if(FAILED(hres)) return hres; hres = IMoniker_IsSystemMoniker(pimkReference, &mksys); if(SUCCEEDED(hres) && mksys != MKSYS_URLMONIKER) WARN("sysmk = %x\n", mksys); /* FIXME: What is it for? */ CreateBindCtx(0, &bctx); hres = IMoniker_GetDisplayName(pimkReference, bctx, NULL, &name); IBindCtx_Release(bctx); if(SUCCEEDED(hres)) { TRACE("got display name %s\n", debugstr_w(name)); CoTaskMemFree(name); } return IMoniker_BindToStorage(pimkReference, pibc, NULL, &IID_IUnknown, &obj); }
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; }
static HRESULT WINAPI IHlink_fnNavigate(IHlink* iface, DWORD grfHLNF, LPBC pbc, IBindStatusCallback *pbsc, IHlinkBrowseContext *phbc) { HlinkImpl *This = impl_from_IHlink(iface); IMoniker *mon = NULL; HRESULT r; FIXME("Semi-Stub:(%p)->(%i %p %p %p)\n", This, grfHLNF, pbc, pbsc, phbc); r = __GetMoniker(This, &mon, HLINKGETREF_ABSOLUTE); TRACE("Moniker %p\n", mon); if (SUCCEEDED(r)) { IBindCtx *bcxt; IUnknown *unk = NULL; IHlinkTarget *target; CreateBindCtx(0, &bcxt); RegisterBindStatusCallback(bcxt, pbsc, NULL, 0); r = IMoniker_BindToObject(mon, bcxt, NULL, &IID_IUnknown, (void**)&unk); if (r == S_OK) { r = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&target); IUnknown_Release(unk); } if (r == S_OK) { IHlinkTarget_SetBrowseContext(target, phbc); r = IHlinkTarget_Navigate(target, grfHLNF, This->Location); IHlinkTarget_Release(target); } else { static const WCHAR szOpen[] = {'o','p','e','n',0}; LPWSTR target = NULL; r = IHlink_GetStringReference(iface, HLINKGETREF_DEFAULT, &target, NULL); if (SUCCEEDED(r) && target) { ShellExecuteW(NULL, szOpen, target, NULL, NULL, SW_SHOW); CoTaskMemFree(target); } } RevokeBindStatusCallback(bcxt, pbsc); IBindCtx_Release(bcxt); IMoniker_Release(mon); } if (This->Site) IHlinkSite_OnNavigationComplete(This->Site, This->SiteData, 0, r, NULL); TRACE("Finished Navigation\n"); return r; }
static NTSTATUS EnumRunningObjectTable( _In_ PVOID ThreadParam ) { IRunningObjectTable* iRunningObjectTable = NULL; IEnumMoniker* iEnumMoniker = NULL; IMoniker* iMoniker = NULL; IBindCtx* iBindCtx = NULL; IMalloc* iMalloc = NULL; ULONG count = 0; HWND listViewHandle = (HWND)ThreadParam; if (!SUCCEEDED(CoGetMalloc(1, &iMalloc))) return STATUS_INSUFFICIENT_RESOURCES; // Query the running object table address if (SUCCEEDED(GetRunningObjectTable(0, &iRunningObjectTable))) { // Enum the objects registered if (SUCCEEDED(IRunningObjectTable_EnumRunning(iRunningObjectTable, &iEnumMoniker))) { while (IEnumMoniker_Next(iEnumMoniker, 1, &iMoniker, &count) == S_OK) { if (SUCCEEDED(CreateBindCtx(0, &iBindCtx))) { OLECHAR* displayName = NULL; // Query the object name if (SUCCEEDED(IMoniker_GetDisplayName(iMoniker, iBindCtx, NULL, &displayName))) { // Set the items name column PhAddListViewItem(listViewHandle, MAXINT, displayName, NULL); // Free the object name IMalloc_Free(iMalloc, displayName); } IBindCtx_Release(iBindCtx); } IEnumMoniker_Release(iMoniker); } IEnumMoniker_Release(iEnumMoniker); } IRunningObjectTable_Release(iRunningObjectTable); } IMalloc_Release(iMalloc); return STATUS_SUCCESS; }
/*********************************************************************** * 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 ULONG WINAPI AsyncBindCtx_Release(IBindCtx *iface) { AsyncBindCtx *This = impl_from_IBindCtx(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { IBindCtx_Release(This->bindctx); heap_free(This); } return ref; }
static HRESULT URLStartDownload(LPCWSTR szURL, LPSTREAM *ppStream, IBindStatusCallback *pBSC) { HRESULT hr; IMoniker *pMoniker; IBindCtx *pbc; *ppStream = NULL; hr = CreateURLMoniker(NULL, szURL, &pMoniker); if (FAILED(hr)) return hr; hr = CreateBindCtx(0, &pbc); if (FAILED(hr)) { IMoniker_Release(pMoniker); return hr; } hr = RegisterBindStatusCallback(pbc, pBSC, NULL, 0); if (FAILED(hr)) { IBindCtx_Release(pbc); IMoniker_Release(pMoniker); return hr; } hr = IMoniker_BindToStorage(pMoniker, pbc, NULL, &IID_IStream, (void **)ppStream); /* BindToStorage returning E_PENDING because it's asynchronous is not an error */ if (hr == E_PENDING) hr = S_OK; IBindCtx_Release(pbc); IMoniker_Release(pMoniker); return hr; }
/****************************************************************************** * BindMoniker [OLE32.@] * * Binds to a moniker. * * PARAMS * pmk [I] Moniker to bind to. * grfOpt [I] Reserved option flags. Set to 0. * riid [I] ID of the interface to bind to. * pvResult [O] Address that receives the interface of the object that was bound to. * * RETURNS * Success: S_OK. * Failure: Any HRESULT code. */ HRESULT WINAPI BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID riid, LPVOID * ppvResult) { HRESULT res; IBindCtx * pbc; TRACE("(%p, %x, %s, %p)\n", pmk, grfOpt, debugstr_guid(riid), ppvResult); res = CreateBindCtx(grfOpt, &pbc); if (SUCCEEDED(res)) { res = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppvResult); IBindCtx_Release(pbc); } return res; }
static HRESULT WINAPI IHlink_fnGetStringReference (IHlink* iface, DWORD dwWhichRef, LPWSTR *ppwzTarget, LPWSTR *ppwzLocation) { HlinkImpl *This = impl_from_IHlink(iface); TRACE("(%p) -> (%i %p %p)\n", This, dwWhichRef, ppwzTarget, ppwzLocation); if(dwWhichRef != -1 && dwWhichRef & ~(HLINKGETREF_DEFAULT | HLINKGETREF_ABSOLUTE | HLINKGETREF_RELATIVE)) { if(ppwzTarget) *ppwzTarget = NULL; if(ppwzLocation) *ppwzLocation = NULL; return E_INVALIDARG; } if (ppwzTarget) { IMoniker* mon; HRESULT hres = __GetMoniker(This, &mon, dwWhichRef); if (FAILED(hres)) { if (ppwzLocation) *ppwzLocation = NULL; return hres; } if (mon) { IBindCtx *pbc; CreateBindCtx( 0, &pbc); IMoniker_GetDisplayName(mon, pbc, NULL, ppwzTarget); IBindCtx_Release(pbc); IMoniker_Release(mon); } else *ppwzTarget = NULL; } if (ppwzLocation) *ppwzLocation = hlink_co_strdupW( This->Location ); TRACE("(Target: %s Location: %s)\n", (ppwzTarget)?debugstr_w(*ppwzTarget):"<NULL>", (ppwzLocation)?debugstr_w(*ppwzLocation):"<NULL>"); return S_OK; }
static void test_SHCreateQueryCancelAutoPlayMoniker(void) { IBindCtx *ctxt; IMoniker *mon; IUnknown *unk; CLSID clsid; HRESULT hr; DWORD sys; if (!pSHCreateQueryCancelAutoPlayMoniker) { win_skip("SHCreateQueryCancelAutoPlayMoniker is not available, skipping tests.\n"); return; } hr = pSHCreateQueryCancelAutoPlayMoniker(NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = pSHCreateQueryCancelAutoPlayMoniker(&mon); ok(hr == S_OK, "got 0x%08x\n", hr); sys = -1; hr = IMoniker_IsSystemMoniker(mon, &sys); ok(hr == S_OK, "got 0x%08x\n", hr); ok(sys == MKSYS_CLASSMONIKER, "got %d\n", sys); memset(&clsid, 0, sizeof(clsid)); hr = IMoniker_GetClassID(mon, &clsid); ok(hr == S_OK, "got 0x%08x\n", hr); ok(IsEqualGUID(&clsid, &CLSID_ClassMoniker), "got %s\n", wine_dbgstr_guid(&clsid)); /* extract used CLSID that implements this hook */ SET_EXPECT(autoplay_BindToObject); SET_EXPECT(autoplay_GetClassObject); CreateBindCtx(0, &ctxt); hr = IMoniker_BindToObject(mon, ctxt, &test_moniker, &IID_IQueryCancelAutoPlay, (void**)&unk); ok(hr == E_NOTIMPL, "got 0x%08x\n", hr); IBindCtx_Release(ctxt); CHECK_CALLED(autoplay_BindToObject); CHECK_CALLED(autoplay_GetClassObject); IMoniker_Release(mon); }
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; }
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 void load_doc_mon(Binding *binding, IPersistMoniker *persist) { IBindCtx *bctx; HRESULT hres; hres = CreateAsyncBindCtxEx(binding->bctx, 0, NULL, NULL, &bctx, 0); if(FAILED(hres)) { WARN("CreateAsyncBindCtxEx failed: %08x\n", hres); return; } IBindCtx_RevokeObjectParam(bctx, bscb_holderW); IBindCtx_RegisterObjectParam(bctx, cbinding_contextW, (IUnknown*)BINDING(binding)); hres = IPersistMoniker_Load(persist, binding->download_state == END_DOWNLOAD, binding->mon, bctx, 0x12); IBindCtx_RevokeObjectParam(bctx, cbinding_contextW); IBindCtx_Release(bctx); if(FAILED(hres)) FIXME("Load failed: %08x\n", 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; }
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 IHTMLDocument2 *create_doc_from_url(const char *start_url) { BSTR url; IBindCtx *bc; IMoniker *url_mon; IPersistMoniker *persist_mon; IHTMLDocument2 *doc; HRESULT hres; hres = CreateBindCtx(0, &bc); ok(hres == S_OK, "CreateBindCtx failed: 0x%08x\n", hres); url = a2bstr(start_url); hres = CreateURLMoniker(NULL, url, &url_mon); ok(hres == S_OK, "CreateURLMoniker failed: 0x%08x\n", hres); hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER, &IID_IHTMLDocument2, (void**)&doc); ok(hres == S_OK, "CoCreateInstance failed: 0x%08x\n", hres); hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist_mon); ok(hres == S_OK, "IHTMLDocument2_QueryInterface failed: 0x%08x\n", hres); hres = IPersistMoniker_Load(persist_mon, FALSE, url_mon, bc, STGM_SHARE_EXCLUSIVE | STGM_READWRITE); ok(hres == S_OK, "IPersistMoniker_Load failed: 0x%08x\n", hres); IPersistMoniker_Release(persist_mon); IMoniker_Release(url_mon); IBindCtx_Release(bc); SysFreeString(url); doc_complete = FALSE; notif_doc = doc; do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink); pump_msgs(&doc_complete); return doc; }
static void test_HlinkResolveMonikerForData(void) { IBindCtx *bctx; HRESULT hres; CreateBindCtx(0, &bctx); _bctx = bctx; SET_EXPECT(IsSystemMoniker); SET_EXPECT(GetDisplayName); SET_EXPECT(BindToStorage); hres = HlinkResolveMonikerForData(&Moniker, 0, bctx, 0, NULL, &BindStatusCallback, NULL); ok(hres == S_OK, "HlinkResolveMonikerForData failed: %08x\n", hres); CHECK_CALLED(IsSystemMoniker); CHECK_CALLED(GetDisplayName); CHECK_CALLED(BindToStorage); IBindCtx_Release(bctx); }
/*********************************************************************** * CreateAsyncBindCtxEx (urlmon.@) * * Create an asynchronous bind context. */ HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind, DWORD reserved) { AsyncBindCtx *ret; IBindCtx *bindctx; HRESULT hres; TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved); if(!pbind) return E_INVALIDARG; if(reserved) WARN("reserved=%d\n", reserved); if(ibind) { IBindCtx_AddRef(ibind); bindctx = ibind; }else { hres = CreateBindCtx(0, &bindctx); if(FAILED(hres)) return hres; } ret = heap_alloc(sizeof(AsyncBindCtx)); ret->IBindCtx_iface.lpVtbl = &AsyncBindCtxVtbl; ret->ref = 1; ret->bindctx = bindctx; hres = init_bindctx(&ret->IBindCtx_iface, options, callback, format); if(FAILED(hres)) { IBindCtx_Release(&ret->IBindCtx_iface); return hres; } *pbind = &ret->IBindCtx_iface; return S_OK; }
static HRESULT WINAPI IHlink_fnSetMonikerReference( IHlink* iface, DWORD rfHLSETF, IMoniker *pmkTarget, LPCWSTR pwzLocation) { HlinkImpl *This = impl_from_IHlink(iface); TRACE("(%p)->(%i %p %s)\n", This, rfHLSETF, pmkTarget, debugstr_w(pwzLocation)); if(rfHLSETF == 0) return E_INVALIDARG; if(!(rfHLSETF & (HLINKSETF_TARGET | HLINKSETF_LOCATION))) return rfHLSETF; if(rfHLSETF & HLINKSETF_TARGET){ if (This->Moniker) IMoniker_Release(This->Moniker); This->Moniker = pmkTarget; if (This->Moniker) { IBindCtx *pbc; LPOLESTR display_name; IMoniker_AddRef(This->Moniker); CreateBindCtx( 0, &pbc); IMoniker_GetDisplayName(This->Moniker, pbc, NULL, &display_name); IBindCtx_Release(pbc); This->absolute = display_name && strchrW(display_name, ':'); CoTaskMemFree(display_name); } } if(rfHLSETF & HLINKSETF_LOCATION){ heap_free(This->Location); This->Location = hlink_strdupW( pwzLocation ); } return S_OK; }
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; }
/*********************************************************************** * CreateAsyncBindCtx (urlmon.@) */ HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx **pbind) { IBindCtx *bindctx; HRESULT hres; TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind); if(!pbind || !callback) return E_INVALIDARG; hres = CreateBindCtx(0, &bindctx); if(FAILED(hres)) return hres; hres = init_bindctx(bindctx, 0, callback, format); if(FAILED(hres)) { IBindCtx_Release(bindctx); return hres; } *pbind = bindctx; return S_OK; }
static HRESULT WINAPI IHlink_fnSetStringReference(IHlink* iface, DWORD grfHLSETF, LPCWSTR pwzTarget, LPCWSTR pwzLocation) { HlinkImpl *This = impl_from_IHlink(iface); TRACE("(%p)->(%i %s %s)\n", This, grfHLSETF, debugstr_w(pwzTarget), debugstr_w(pwzLocation)); if(grfHLSETF > (HLINKSETF_TARGET | HLINKSETF_LOCATION) && grfHLSETF < -(HLINKSETF_TARGET | HLINKSETF_LOCATION)) return grfHLSETF; if (grfHLSETF & HLINKSETF_TARGET) { if (This->Moniker) { IMoniker_Release(This->Moniker); This->Moniker = NULL; } if (pwzTarget && *pwzTarget) { IMoniker *pMon; IBindCtx *pbc = NULL; ULONG eaten; HRESULT r; r = CreateBindCtx(0, &pbc); if (FAILED(r)) return E_OUTOFMEMORY; r = MkParseDisplayName(pbc, pwzTarget, &eaten, &pMon); IBindCtx_Release(pbc); if (FAILED(r)) { LPCWSTR p = strchrW(pwzTarget, ':'); if (p && (p - pwzTarget > 1)) r = CreateURLMoniker(NULL, pwzTarget, &pMon); else r = CreateFileMoniker(pwzTarget, &pMon); if (FAILED(r)) { ERR("couldn't create moniker for %s, failed with error 0x%08x\n", debugstr_w(pwzTarget), r); return r; } } IHlink_SetMonikerReference(iface, HLINKSETF_TARGET, pMon, NULL); IMoniker_Release(pMon); } } if (grfHLSETF & HLINKSETF_LOCATION) { heap_free(This->Location); This->Location = NULL; if (pwzLocation && *pwzLocation) This->Location = hlink_strdupW( pwzLocation ); } return S_OK; }
/** * Cycle through available devices using the device enumerator devenum, * retrieve the device with type specified by devtype and return the * pointer to the object found in *pfilter. * If pfilter is NULL, list all device names. */ static int dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum, enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype, IBaseFilter **pfilter) { struct dshow_ctx *ctx = avctx->priv_data; IBaseFilter *device_filter = NULL; IEnumMoniker *classenum = NULL; IMoniker *m = NULL; const char *device_name = ctx->device_name[devtype]; int skip = (devtype == VideoDevice) ? ctx->video_device_number : ctx->audio_device_number; int r; const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory, &CLSID_AudioInputDeviceCategory }; const char *devtypename = (devtype == VideoDevice) ? "video" : "audio only"; const char *sourcetypename = (sourcetype == VideoSourceDevice) ? "video" : "audio"; r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[sourcetype], (IEnumMoniker **) &classenum, 0); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices (or none found).\n", devtypename); return AVERROR(EIO); } while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) { IPropertyBag *bag = NULL; char *friendly_name = NULL; char *unique_name = NULL; VARIANT var; IBindCtx *bind_ctx = NULL; LPOLESTR olestr = NULL; LPMALLOC co_malloc = NULL; int i; r = CoGetMalloc(1, &co_malloc); if (r != S_OK) goto fail1; r = CreateBindCtx(0, &bind_ctx); if (r != S_OK) goto fail1; /* GetDisplayname works for both video and audio, DevicePath doesn't */ r = IMoniker_GetDisplayName(m, bind_ctx, NULL, &olestr); if (r != S_OK) goto fail1; unique_name = dup_wchar_to_utf8(olestr); /* replace ':' with '_' since we use : to delineate between sources */ for (i = 0; i < strlen(unique_name); i++) { if (unique_name[i] == ':') unique_name[i] = '_'; } r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag); if (r != S_OK) goto fail1; var.vt = VT_BSTR; r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL); if (r != S_OK) goto fail1; friendly_name = dup_wchar_to_utf8(var.bstrVal); if (pfilter) { if (strcmp(device_name, friendly_name) && strcmp(device_name, unique_name)) goto fail1; if (!skip--) { r = IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Unable to BindToObject for %s\n", device_name); goto fail1; } } } else { av_log(avctx, AV_LOG_INFO, " \"%s\"\n", friendly_name); av_log(avctx, AV_LOG_INFO, " Alternative name \"%s\"\n", unique_name); } fail1: if (olestr && co_malloc) IMalloc_Free(co_malloc, olestr); if (bind_ctx) IBindCtx_Release(bind_ctx); av_free(friendly_name); av_free(unique_name); if (bag) IPropertyBag_Release(bag); IMoniker_Release(m); } IEnumMoniker_Release(classenum); if (pfilter) { if (!device_filter) { av_log(avctx, AV_LOG_ERROR, "Could not find %s device with name [%s] among source devices of type %s.\n", devtypename, device_name, sourcetypename); return AVERROR(EIO); } *pfilter = device_filter; } return 0; }