/***********************************************************************
* 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 init_bindctx(IBindCtx *bindctx, DWORD options,
IBindStatusCallback *callback, IEnumFORMATETC *format)
{
BIND_OPTS bindopts;
HRESULT hres;
if(options)
FIXME("not supported options %08x\n", options);
if(format)
FIXME("format is not supported\n");
bindopts.cbStruct = sizeof(BIND_OPTS);
bindopts.grfFlags = BIND_MAYBOTHERUSER;
bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
bindopts.dwTickCountDeadline = 0;
hres = IBindCtx_SetBindOptions(bindctx, &bindopts);
if(FAILED(hres))
return hres;
if(callback) {
hres = RegisterBindStatusCallback(bindctx, callback, NULL, 0);
if(FAILED(hres))
return hres;
}
return S_OK;
}
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;
}
STDMETHODIMP CTCBindHost::MonikerBindToStorage( IMoniker* pMoniker,
IBindCtx* pBindCtx, IBindStatusCallback* pBSC, REFIID iid, void** ppObject )
{
HRESULT hResult;
IBindCtxPtr pNewBindCtx;
TCTrace( TRACELEVEL_NORMAL, "IBindHost::MonikerBindToStorage\n" );
if( ppObject == NULL )
{
return( E_POINTER );
}
*ppObject = NULL;
if( pBindCtx != NULL )
{
pNewBindCtx = pBindCtx;
if( pBSC )
{
hResult = RegisterBindStatusCallback( pBindCtx, pBSC, NULL, 0 );
if( FAILED( hResult ) )
{
return( hResult );
}
}
}
else
{
if( pBSC )
{
hResult = CreateAsyncBindCtx( 0, pBSC, NULL, &pNewBindCtx );
if( FAILED( hResult ) )
{
return( hResult );
}
}
else
{
hResult = CreateBindCtx( 0, &pNewBindCtx );
if( FAILED( hResult ) )
{
return( hResult );
}
}
}
ASSERT( pNewBindCtx != NULL );
return( pMoniker->BindToStorage( pNewBindCtx, NULL, iid, ppObject ) );
}
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;
}
HRESULT CDuiAxContainer::MonikerBindToStorage(IMoniker *pMk, IBindCtx *pBC,
IBindStatusCallback *pBSC, REFIID riid, void **ppvObj)
{
HRESULT hr = E_FAIL;
CDuiComPtr<IBindCtx> pBCCtx = pBC;
if (pBCCtx == NULL)
{
// creates it if not present
hr = CreateBindCtx(0, &pBCCtx);
}
if ( pBCCtx != NULL )
{
if ( pBSC != NULL )
{
hr = RegisterBindStatusCallback(pBCCtx, pBSC, NULL, 0);
}
hr = pMk->BindToStorage(pBCCtx, NULL, riid, ppvObj);
}
return hr;
}
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;
}
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;
}
static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
{
BindStatusCallback *bsc;
IBindCtx *pbc;
HRESULT hr;
hr = CreateBindCtx(0, &pbc);
if (hr != S_OK) return hr;
bsc = heap_alloc(sizeof(*bsc));
if (!bsc)
{
IBindCtx_Release(pbc);
return E_OUTOFMEMORY;
}
bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
bsc->ref = 1;
bsc->request = This;
bsc->binding = NULL;
bsc->stream = NULL;
bsc->body = NULL;
TRACE("created callback %p\n", bsc);
if (This->verb != BINDVERB_GET)
{
if (V_VT(body) == VT_BSTR)
{
LONG size = SysStringLen(V_BSTR(body)) * sizeof(WCHAR);
void *ptr;
bsc->body = GlobalAlloc(GMEM_FIXED, size);
if (!bsc->body)
{
heap_free(bsc);
return E_OUTOFMEMORY;
}
ptr = GlobalLock(bsc->body);
memcpy(ptr, V_BSTR(body), size);
GlobalUnlock(bsc->body);
}
else
FIXME("unsupported body data type %d\n", V_VT(body));
}
hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
if (hr == S_OK)
{
IMoniker *moniker;
hr = CreateURLMoniker(NULL, This->url, &moniker);
if (hr == S_OK)
{
IStream *stream;
hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
IMoniker_Release(moniker);
if (stream) IStream_Release(stream);
}
IBindCtx_Release(pbc);
}
if (FAILED(hr))
{
IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
bsc = NULL;
}
*obj = bsc;
return hr;
}
static HRESULT WINAPI XMLView_PersistMoniker_Load(IPersistMoniker *iface,
BOOL fFullyAvailable, IMoniker *pimkName, LPBC pibc, DWORD grfMode)
{
static const WCHAR XSLParametersW[] = {'X','S','L','P','a','r','a','m','e','t','e','r','s',0};
static const WCHAR XMLBufferStreamW[] = {'X','M','L','B','u','f','f','e','r','S','t','r','e','a','m',0};
static const WCHAR DWNBINDINFOW[] = {'_','_','D','W','N','B','I','N','D','I','N','F','O',0};
static const WCHAR HTMLLOADOPTIONSW[] = {'_','_','H','T','M','L','L','O','A','D','O','P','T','I','O','N','S',0};
static const WCHAR BSCBHolderW[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
XMLView *This = impl_from_IPersistMoniker(iface);
IPersistMoniker *html_persist_mon;
IBindStatusCallback *bsc, *bsc_html;
IBindCtx *bindctx;
IStream *stream;
IMoniker *mon;
IUnknown *unk;
HRESULT hres;
TRACE("(%p)->(%x %p %p %x)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XSLParametersW, &unk);
if(SUCCEEDED(hres)) {
FIXME("ignoring XSLParameters\n");
IUnknown_Release(unk);
}
hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XMLBufferStreamW, &unk);
if(SUCCEEDED(hres)) {
FIXME("ignoring XMLBufferStream\n");
IUnknown_Release(unk);
}
hres = CreateBindCtx(0, &bindctx);
if(FAILED(hres))
return hres;
hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)DWNBINDINFOW, &unk);
if(SUCCEEDED(hres)) {
IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)DWNBINDINFOW, unk);
IUnknown_Release(unk);
}
hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)HTMLLOADOPTIONSW, &unk);
if(SUCCEEDED(hres)) {
IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)HTMLLOADOPTIONSW, unk);
IUnknown_Release(unk);
}
hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
if(SUCCEEDED(hres)) {
IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, unk);
IUnknown_Release(unk);
}
hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
if(FAILED(hres)) {
IBindCtx_Release(bindctx);
return hres;
}
if(This->mon)
IMoniker_Release(This->mon);
This->mon = pimkName;
IMoniker_AddRef(This->mon);
hres = XMLView_Moniker_Create(This->mon, stream, &mon);
if(FAILED(hres)) {
IStream_Release(stream);
IBindCtx_Release(bindctx);
return hres;
}
hres = IUnknown_QueryInterface(This->html_doc,
&IID_IPersistMoniker, (void**)&html_persist_mon);
if(FAILED(hres)) {
IMoniker_Release(mon);
IStream_Release(stream);
IBindCtx_Release(bindctx);
return hres;
}
hres = IPersistMoniker_Load(html_persist_mon, FALSE, mon, bindctx, 0);
IPersistMoniker_Release(html_persist_mon);
IMoniker_Release(mon);
if(FAILED(hres)) {
IStream_Release(stream);
IBindCtx_Release(bindctx);
return hres;
}
hres = IBindCtx_GetObjectParam(bindctx, (LPOLESTR)BSCBHolderW, &unk);
IBindCtx_Release(bindctx);
if(FAILED(hres)) {
IStream_Release(stream);
return hres;
}
hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc_html);
IUnknown_Release(unk);
if(FAILED(hres)) {
IStream_Release(stream);
return hres;
}
hres = XMLView_BindStatusCallback_Create(bsc_html, This->mon, stream, &bsc);
IStream_Release(stream);
if(FAILED(hres)) {
IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
IBindStatusCallback_Release(bsc_html);
return hres;
}
hres = RegisterBindStatusCallback(pibc, bsc, NULL, 0);
IBindStatusCallback_Release(bsc);
if(FAILED(hres)) {
IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
IBindStatusCallback_Release(bsc_html);
return hres;
}
hres = IMoniker_BindToStorage(pimkName, pibc, NULL,
&IID_IStream, (void**)&stream);
if(FAILED(hres)) {
IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
IBindStatusCallback_Release(bsc_html);
return hres;
}
if(stream)
IStream_Release(stream);
IBindStatusCallback_Release(bsc_html);
return S_OK;
}
// Create the specified control, optionally providing properties to initialise
// it with and a name.
HRESULT CControlSite::Create(REFCLSID clsid, PropertyList &pl,
LPCWSTR szCodebase, IBindCtx *pBindContext)
{
TRACE_METHOD(CControlSite::Create);
m_CLSID = clsid;
m_ParameterList = pl;
// See if security policy will allow the control to be hosted
if (m_pSecurityPolicy && !m_pSecurityPolicy->IsClassSafeToHost(clsid))
{
return E_FAIL;
}
// See if object is script safe
BOOL checkForObjectSafety = FALSE;
if (m_pSecurityPolicy && m_bSafeForScriptingObjectsOnly)
{
BOOL bClassExists = FALSE;
BOOL bIsSafe = m_pSecurityPolicy->IsClassMarkedSafeForScripting(clsid, bClassExists);
if (!bClassExists && szCodebase)
{
// Class doesn't exist, so allow code below to fetch it
}
else if (!bIsSafe)
{
// The class is not flagged as safe for scripting, so
// we'll have to create it to ask it if its safe.
checkForObjectSafety = TRUE;
}
}
// Create the object
CComPtr<IUnknown> spObject;
HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_IUnknown, (void **) &spObject);
if (SUCCEEDED(hr) && checkForObjectSafety)
{
// Assume scripting via IDispatch
if (!m_pSecurityPolicy->IsObjectSafeForScripting(spObject, __uuidof(IDispatch)))
{
return E_FAIL;
}
// Drop through, success!
}
// Do we need to download the control?
if (FAILED(hr) && szCodebase)
{
wchar_t *szURL = NULL;
// Test if the code base ends in #version=a,b,c,d
DWORD dwFileVersionMS = 0xffffffff;
DWORD dwFileVersionLS = 0xffffffff;
const wchar_t *szHash = wcsrchr(szCodebase, wchar_t('#'));
if (szHash)
{
if (wcsnicmp(szHash, L"#version=", 9) == 0)
{
int a, b, c, d;
if (swscanf(szHash + 9, L"%d,%d,%d,%d", &a, &b, &c, &d) == 4)
{
dwFileVersionMS = MAKELONG(b,a);
dwFileVersionLS = MAKELONG(d,c);
}
}
szURL = _wcsdup(szCodebase);
// Terminate at the hash mark
if (szURL)
szURL[szHash - szCodebase] = wchar_t('\0');
}
else
{
szURL = _wcsdup(szCodebase);
}
if (!szURL)
return E_OUTOFMEMORY;
CComPtr<IBindCtx> spBindContext;
CComPtr<IBindStatusCallback> spBindStatusCallback;
CComPtr<IBindStatusCallback> spOldBSC;
// Create our own bind context or use the one provided?
BOOL useInternalBSC = FALSE;
if (!pBindContext)
{
useInternalBSC = TRUE;
hr = CreateBindCtx(0, &spBindContext);
if (FAILED(hr))
{
free(szURL);
return hr;
}
spBindStatusCallback = dynamic_cast<IBindStatusCallback *>(this);
hr = RegisterBindStatusCallback(spBindContext, spBindStatusCallback, &spOldBSC, 0);
if (FAILED(hr))
{
free(szURL);
return hr;
}
}
else
{
spBindContext = pBindContext;
}
hr = CoGetClassObjectFromURL(clsid, szURL, dwFileVersionMS, dwFileVersionLS,
NULL, spBindContext, CLSCTX_ALL, NULL, IID_IUnknown, (void **) &m_spObject);
free(szURL);
// Handle the internal binding synchronously so the object exists
// or an error code is available when the method returns.
if (useInternalBSC)
{
if (MK_S_ASYNCHRONOUS == hr)
{
m_bBindingInProgress = TRUE;
m_hrBindResult = E_FAIL;
// Spin around waiting for binding to complete
HANDLE hFakeEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
while (m_bBindingInProgress)
{
MSG msg;
// Process pending messages
while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
{
if (!::GetMessage(&msg, NULL, 0, 0))
{
m_bBindingInProgress = FALSE;
break;
}
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
if (!m_bBindingInProgress)
break;
// Sleep for a bit or the next msg to appear
::MsgWaitForMultipleObjects(1, &hFakeEvent, FALSE, 500, QS_ALLEVENTS);
}
::CloseHandle(hFakeEvent);
// Set the result
hr = m_hrBindResult;
}
// Destroy the bind status callback & context
if (spBindStatusCallback)
{
RevokeBindStatusCallback(spBindContext, spBindStatusCallback);
spBindContext.Release();
}
}
}
if (spObject)
m_spObject = spObject;
return hr;
}
