static HRESULT WINAPI ClDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { DocHost *This = impl_from_IDispatch(iface); TRACE("(%p)->(%s %s %d %04x %p %p %p %p)\n", This, debugstr_dispid(dispIdMember), debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); switch(dispIdMember) { case DISPID_AMBIENT_USERMODE: case DISPID_AMBIENT_DLCONTROL: case DISPID_AMBIENT_USERAGENT: case DISPID_AMBIENT_PALETTE: if(!This->client_disp) return E_FAIL; return IDispatch_Invoke(This->client_disp, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED: V_VT(pVarResult) = VT_BOOL; V_BOOL(pVarResult) = This->offline; return S_OK; case DISPID_AMBIENT_SILENT: V_VT(pVarResult) = VT_BOOL; V_BOOL(pVarResult) = This->offline; return S_OK; } FIXME("unhandled dispid %d\n", dispIdMember); return E_NOTIMPL; }
static void update_readystate(PluginHost *host) { DISPPARAMS params = {NULL,NULL,0,0}; IDispatchEx *dispex; IDispatch *disp; ULONG err = 0; VARIANT v; HRESULT hres; hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { FIXME("Use IDispatchEx\n"); IDispatchEx_Release(dispex); } hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatch, (void**)&disp); if(FAILED(hres)) return; hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, 0, DISPATCH_PROPERTYGET, ¶ms, &v, NULL, &err); IDispatch_Release(disp); if(SUCCEEDED(hres)) { /* FIXME: make plugin readystate affect document readystate */ TRACE("readystate = %s\n", debugstr_variant(&v)); VariantClear(&v); } }
static HRESULT WINAPI PHInPlaceSite_OnUIActivate(IOleInPlaceSiteEx *iface) { PluginHost *This = impl_from_IOleInPlaceSiteEx(iface); DISPPARAMS args = {NULL, NULL, 0, 0}; IDispatch *disp; ULONG err = 0; VARIANT res; HRESULT hres; TRACE("(%p)\n", This); if(!This->plugin_unk) { ERR("No plugin object\n"); return E_UNEXPECTED; } This->ui_active = TRUE; hres = IUnknown_QueryInterface(This->plugin_unk, &IID_IDispatch, (void**)&disp); if(FAILED(hres)) { FIXME("Could not get IDispatch iface: %08x\n", hres); return hres; } V_VT(&res) = VT_EMPTY; hres = IDispatch_Invoke(disp, DISPID_ENABLED, &IID_NULL, 0/*FIXME*/, DISPATCH_PROPERTYGET, &args, &res, NULL, &err); IDispatch_Release(disp); if(SUCCEEDED(hres)) { FIXME("Got enabled %s\n", debugstr_variant(&res)); VariantClear(&res); } return S_OK; }
HRESULT disp_propput(IDispatch *disp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller) { DISPID dispid = DISPID_PROPERTYPUT; DISPPARAMS dp = {val, &dispid, 1, 1}; IDispatchEx *dispex; DispatchEx *jsdisp; HRESULT hres; jsdisp = iface_to_jsdisp((IUnknown*)disp); if(jsdisp) { dispex_prop_t *prop; prop = get_prop(jsdisp, id); if(prop) hres = prop_put(jsdisp, prop, lcid, &dp, ei, caller); else hres = DISP_E_MEMBERNOTFOUND; IDispatchEx_Release(_IDispatchEx_(jsdisp)); return hres; } hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { ULONG err = 0; TRACE("using IDispatch\n"); return IDispatch_Invoke(disp, id, &IID_NULL, DISPATCH_PROPERTYPUT, lcid, &dp, NULL, &ei->ei, &err); } hres = IDispatchEx_InvokeEx(dispex, id, lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei, caller); IDispatchEx_Release(dispex); return hres; }
static BOOL check_script_safety(PluginHost *host) { DISPPARAMS params = {NULL,NULL,0,0}; DWORD policy_size, policy; struct CONFIRMSAFETY cs; BYTE *ppolicy; ULONG err = 0; VARIANT v; HRESULT hres; cs.clsid = host->clsid; cs.pUnk = host->plugin_unk; cs.dwFlags = 0; hres = IInternetHostSecurityManager_QueryCustomPolicy(&host->doc->IInternetHostSecurityManager_iface, &GUID_CUSTOM_CONFIRMOBJECTSAFETY, &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0); if(FAILED(hres)) return FALSE; policy = *(DWORD*)ppolicy; CoTaskMemFree(ppolicy); if(policy != URLPOLICY_ALLOW) return FALSE; V_VT(&v) = VT_EMPTY; hres = IDispatch_Invoke(host->disp, DISPID_SECURITYCTX, &IID_NULL, 0, DISPATCH_PROPERTYGET, ¶ms, &v, NULL, &err); if(SUCCEEDED(hres)) { FIXME("Handle security ctx %s\n", debugstr_variant(&v)); return FALSE; } return TRUE; }
HRESULT disp_propget(IDispatch *disp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller) { DISPPARAMS dp = {NULL,NULL,0,0}; IDispatchEx *dispex; DispatchEx *jsdisp; HRESULT hres; jsdisp = iface_to_jsdisp((IUnknown*)disp); if(jsdisp) { hres = jsdisp_propget(jsdisp, id, lcid, val, ei, caller); IDispatchEx_Release(_IDispatchEx_(jsdisp)); return hres; } hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { ULONG err = 0; TRACE("using IDispatch\n"); return IDispatch_Invoke(disp, id, &IID_NULL, lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, &err); } hres = IDispatchEx_InvokeEx(dispex, id, lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, caller); IDispatchEx_Release(dispex); return hres; }
static HRESULT get_doc_ready_state(DocHost *This, READYSTATE *ret) { DISPPARAMS dp = {NULL,NULL,0,0}; IDispatch *disp; EXCEPINFO ei; VARIANT var; HRESULT hres; hres = IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)&disp); if(FAILED(hres)) return hres; hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL); IDispatch_Release(disp); if(FAILED(hres)) { WARN("Invoke(DISPID_READYSTATE failed: %08x\n", hres); return hres; } if(V_VT(&var) != VT_I4) { WARN("V_VT(var) = %d\n", V_VT(&var)); VariantClear(&var); return E_FAIL; } *ret = V_I4(&var); return S_OK; }
static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, VARIANT *retv) { DISPPARAMS dp = {NULL,NULL,0,0}; ULONG argerr; EXCEPINFO ei; memset(&ei, 0, sizeof(ei)); return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr); }
void call_sink(ConnectionPoint *This, DISPID dispid, DISPPARAMS *dispparams) { DWORD i; for(i=0; i<This->sinks_size; i++) { if(This->sinks[i]) IDispatch_Invoke(This->sinks[i], dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, dispparams, NULL, NULL, NULL); } }
static HRESULT WINAPI IMediaPosition_fnInvoke(IMediaPosition* iface,DISPID DispId, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarRes, EXCEPINFO* pExcepInfo, UINT* puArgErr) { CFilterGraph_THIS(iface,mediaposition); TRACE("(%p)->()\n",This); return IDispatch_Invoke( CFilterGraph_IDispatch(This), DispId,riid,lcid,wFlags,pDispParams,pVarRes,pExcepInfo,puArgErr); }
static void httprequest_setreadystate(httprequest *This, READYSTATE state) { READYSTATE last = This->state; This->state = state; if (This->sink && last != state) { DISPPARAMS params; memset(¶ms, 0, sizeof(params)); IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, ¶ms, 0, 0, 0); } }
static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, HTMLEventObj *event_obj, VARIANT *retv) { DISPPARAMS dp = {NULL,NULL,0,0}; VARIANT event_arg; ULONG argerr; EXCEPINFO ei; if(event_obj) { V_VT(&event_arg) = VT_DISPATCH; V_DISPATCH(&event_arg) = (IDispatch*)&event_obj->IHTMLEventObj_iface; dp.rgvarg = &event_arg; dp.cArgs = 1; } memset(&ei, 0, sizeof(ei)); return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr); }
static HRESULT call_cp_func(IDispatch *disp, DISPID dispid) { DISPPARAMS dp = {NULL,NULL,0,0}; ULONG argerr; EXCEPINFO ei; VARIANT vres; HRESULT hres; V_VT(&vres) = VT_EMPTY; memset(&ei, 0, sizeof(ei)); hres = IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, &vres, &ei, &argerr); if(SUCCEEDED(hres) && V_VT(&vres) != VT_EMPTY) { FIXME("handle result %s\n", debugstr_variant(&vres)); VariantClear(&vres); } return hres; }
HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp) { IDispatchEx *dispex; EXCEPINFO ei = {0}; HRESULT hres; hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, NULL, &ei, NULL /* FIXME! */); IDispatchEx_Release(dispex); }else { ULONG err = 0; TRACE("using IDispatch\n"); hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err); } return hres; }
static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv) { IDispatchEx *dispex; EXCEPINFO ei; HRESULT hres; memset(&ei, 0, sizeof(ei)); hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL); IDispatchEx_Release(dispex); }else { TRACE("Could not get IDispatchEx interface: %08x\n", hres); hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL); } return hres; }
static HRESULT invoke_disp_value(DispatchEx *This, IDispatch *func_disp, LCID lcid, WORD flags, DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller) { DISPID named_arg = DISPID_THIS; DISPPARAMS new_dp = {NULL, &named_arg, 0, 1}; IDispatchEx *dispex; HRESULT hres; if(dp->cNamedArgs) { FIXME("named args not supported\n"); return E_NOTIMPL; } new_dp.rgvarg = heap_alloc((dp->cArgs+1)*sizeof(VARIANTARG)); if(!new_dp.rgvarg) return E_OUTOFMEMORY; new_dp.cArgs = dp->cArgs+1; memcpy(new_dp.rgvarg+1, dp->rgvarg, dp->cArgs*sizeof(VARIANTARG)); V_VT(new_dp.rgvarg) = VT_DISPATCH; V_DISPATCH(new_dp.rgvarg) = (IDispatch*)&This->IDispatchEx_iface; hres = IDispatch_QueryInterface(func_disp, &IID_IDispatchEx, (void**)&dispex); TRACE(">>>\n"); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, flags, &new_dp, res, ei, caller); IDispatchEx_Release(dispex); }else { ULONG err = 0; hres = IDispatch_Invoke(func_disp, DISPID_VALUE, &IID_NULL, lcid, flags, &new_dp, res, ei, &err); } if(SUCCEEDED(hres)) TRACE("<<< %s\n", debugstr_variant(res)); else WARN("<<< %08x\n", hres); heap_free(new_dp.rgvarg); return hres; }
static void notif_enabled(PluginHost *plugin_host) { DISPPARAMS args = {NULL, NULL, 0, 0}; IDispatch *disp; ULONG err = 0; VARIANT res; HRESULT hres; hres = IUnknown_QueryInterface(plugin_host->plugin_unk, &IID_IDispatch, (void**)&disp); if(FAILED(hres)) { FIXME("Could not get IDispatch iface: %08x\n", hres); return; } V_VT(&res) = VT_EMPTY; hres = IDispatch_Invoke(disp, DISPID_ENABLED, &IID_NULL, 0/*FIXME*/, DISPATCH_PROPERTYGET, &args, &res, NULL, &err); IDispatch_Release(disp); if(SUCCEEDED(hres)) { FIXME("Got enabled %s\n", debugstr_variant(&res)); VariantClear(&res); } }
HRESULT get_client_disp_property(IOleClientSite *client, DISPID dispid, VARIANT *res) { IDispatch *disp = NULL; DISPPARAMS dispparams = {NULL, 0}; UINT err; HRESULT hres; hres = IOleClientSite_QueryInterface(client, &IID_IDispatch, (void**)&disp); if(FAILED(hres)) { TRACE("Could not get IDispatch\n"); return hres; } VariantInit(res); hres = IDispatch_Invoke(disp, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &dispparams, res, NULL, &err); IDispatch_Release(disp); return hres; }
HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv) { const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0); IDispatchEx *dispex; EXCEPINFO ei; HRESULT hres; memset(&ei, 0, sizeof(ei)); if(retv) V_VT(retv) = VT_EMPTY; hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { UINT err = 0; TRACE("using IDispatch\n"); return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err); } hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */); IDispatchEx_Release(dispex); return hres; }
HRESULT invoke_plugin_prop(HTMLPluginContainer *plugin_container, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei) { PluginHost *host; host = plugin_container->plugin_host; if(!host || !host->disp) { FIXME("Called with no disp\n"); return E_UNEXPECTED; } if(!check_script_safety(host)) { FIXME("Insecure object\n"); return E_FAIL; } if(id < MSHTML_DISPID_CUSTOM_MIN || id > MSHTML_DISPID_CUSTOM_MIN + plugin_container->props_len) { ERR("Invalid id\n"); return E_FAIL; } return IDispatch_Invoke(host->disp, plugin_container->props[id-MSHTML_DISPID_CUSTOM_MIN], &IID_NULL, lcid, flags, params, res, ei, NULL); }
HRESULT disp_call(IDispatch *disp, DISPID id, LCID lcid, WORD flags, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller) { DispatchEx *jsdisp; IDispatchEx *dispex; HRESULT hres; jsdisp = iface_to_jsdisp((IUnknown*)disp); if(jsdisp) { hres = jsdisp_call(jsdisp, id, lcid, flags, dp, retv, ei, caller); IDispatchEx_Release(_IDispatchEx_(jsdisp)); return hres; } memset(ei, 0, sizeof(*ei)); if(retv) V_VT(retv) = VT_EMPTY; hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { UINT err = 0; if(flags == DISPATCH_CONSTRUCT) { WARN("IDispatch cannot be constructor\n"); return DISP_E_MEMBERNOTFOUND; } TRACE("using IDispatch\n"); return IDispatch_Invoke(disp, id, &IID_NULL, lcid, flags, dp, retv, &ei->ei, &err); } hres = IDispatchEx_InvokeEx(dispex, id, lcid, flags, dp, retv, &ei->ei, caller); IDispatchEx_Release(dispex); return hres; }
/* Performs an Invoke on the given com object. * returns a failure code and creates an exception if there was an error */ HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member, WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg TSRMLS_DC) { HRESULT hr; unsigned int arg_err; EXCEPINFO e = {0}; hr = IDispatch_Invoke(V_DISPATCH(&obj->v), id_member, &IID_NULL, LOCALE_SYSTEM_DEFAULT, flags, disp_params, v, &e, &arg_err); if (silent == 0 && FAILED(hr)) { char *source = NULL, *desc = NULL, *msg = NULL; int source_len, desc_len; switch (hr) { case DISP_E_EXCEPTION: if (e.bstrSource) { source = php_com_olestring_to_string(e.bstrSource, &source_len, obj->code_page TSRMLS_CC); SysFreeString(e.bstrSource); } if (e.bstrDescription) { desc = php_com_olestring_to_string(e.bstrDescription, &desc_len, obj->code_page TSRMLS_CC); SysFreeString(e.bstrDescription); } if (PG(html_errors)) { spprintf(&msg, 0, "<b>Source:</b> %s<br/><b>Description:</b> %s", source ? source : "Unknown", desc ? desc : "Unknown"); } else { spprintf(&msg, 0, "Source: %s\nDescription: %s", source ? source : "Unknown", desc ? desc : "Unknown"); } if (desc) { efree(desc); } if (source) { efree(source); } if (e.bstrHelpFile) { SysFreeString(e.bstrHelpFile); } break; case DISP_E_PARAMNOTFOUND: case DISP_E_TYPEMISMATCH: desc = php_win_err(hr); spprintf(&msg, 0, "Parameter %d: %s", arg_err, desc); LocalFree(desc); break; case DISP_E_BADPARAMCOUNT: if ((disp_params->cArgs + disp_params->cNamedArgs == 0) && (allow_noarg == 1)) { /* if getting a property and they are missing all parameters, * we want to create a proxy object for them; so lets not create an * exception here */ msg = NULL; break; } /* else fall through */ default: desc = php_win_err(hr); spprintf(&msg, 0, "Error [0x%08x] %s", hr, desc); LocalFree(desc); break; } if (msg) { php_com_throw_exception(hr, msg TSRMLS_CC); efree(msg); } } return hr; }
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { DispatchEx *This = DISPATCHEX_THIS(iface); IUnknown *unk; ITypeInfo *ti; dispex_data_t *data; UINT argerr=0; int min, max, n; HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke) return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(wFlags == DISPATCH_CONSTRUCT) { FIXME("DISPATCH_CONSTRUCT not implemented\n"); return E_NOTIMPL; } if(is_dynamic_dispid(id)) { DWORD idx = id - DISPID_DYNPROP_0; VARIANT *var; if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx) return DISP_E_UNKNOWNNAME; var = &This->dynamic_data->props[idx].var; switch(wFlags) { case INVOKE_FUNC: { DISPID named_arg = DISPID_THIS; DISPPARAMS dp = {NULL, &named_arg, 0, 1}; IDispatchEx *dispex; if(V_VT(var) != VT_DISPATCH) { FIXME("invoke vt %d\n", V_VT(var)); return E_NOTIMPL; } if(pdp->cNamedArgs) { FIXME("named args not supported\n"); return E_NOTIMPL; } dp.rgvarg = heap_alloc((pdp->cArgs+1)*sizeof(VARIANTARG)); if(!dp.rgvarg) return E_OUTOFMEMORY; dp.cArgs = pdp->cArgs+1; memcpy(dp.rgvarg+1, pdp->rgvarg, pdp->cArgs*sizeof(VARIANTARG)); V_VT(dp.rgvarg) = VT_DISPATCH; V_DISPATCH(dp.rgvarg) = (IDispatch*)DISPATCHEX(This); hres = IDispatch_QueryInterface(V_DISPATCH(var), &IID_IDispatchEx, (void**)&dispex); TRACE("%s call\n", debugstr_w(This->dynamic_data->props[idx].name)); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, wFlags, &dp, pvarRes, pei, pspCaller); IDispatchEx_Release(dispex); }else { ULONG err = 0; hres = IDispatch_Invoke(V_DISPATCH(var), DISPID_VALUE, &IID_NULL, lcid, wFlags, pdp, pvarRes, pei, &err); } TRACE("%s ret %08x\n", debugstr_w(This->dynamic_data->props[idx].name), hres); heap_free(dp.rgvarg); return hres; } case INVOKE_PROPERTYGET: return VariantCopy(pvarRes, var); case INVOKE_PROPERTYPUT: VariantClear(var); return VariantCopy(var, pdp->rgvarg); default: FIXME("unhandled wFlags %x\n", wFlags); return E_NOTIMPL; } } data = get_dispex_data(This); if(!data) return E_FAIL; min = 0; max = data->func_cnt-1; while(min <= max) { n = (min+max)/2; if(data->funcs[n].id == id) break; if(data->funcs[n].id < id) min = n+1; else max = n-1; } if(min > max) { WARN("invalid id %x\n", id); return DISP_E_UNKNOWNNAME; } hres = get_typeinfo(data->funcs[n].tid, &ti); if(FAILED(hres)) { ERR("Could not get type info: %08x\n", hres); return hres; } hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk); if(FAILED(hres)) { ERR("Could not get iface %s: %08x\n", debugstr_guid(tid_ids[data->funcs[n].tid]), hres); return E_FAIL; } hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr); IUnknown_Release(unk); return hres; }
static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **ret) { EnumeratorInstance *enumerator; HRESULT hres; IDispatch *obj; DISPPARAMS dispparams = {NULL, NULL, 0, 0}; IEnumVARIANT *enumvar = NULL; if (argv) { VARIANT varresult; if (!is_object_instance(*argv)) { FIXME("I don't know how to handle this type!\n"); return E_NOTIMPL; } obj = get_object(*argv); /* Try to get a IEnumVARIANT by _NewEnum */ VariantInit(&varresult); hres = IDispatch_Invoke(obj, DISPID_NEWENUM, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL); if (FAILED(hres)) { WARN("Enumerator: no DISPID_NEWENUM.\n"); return E_INVALIDARG; } if ((V_VT(&varresult) == VT_DISPATCH) || (V_VT(&varresult) == VT_UNKNOWN)) { hres = IUnknown_QueryInterface(V_UNKNOWN(&varresult), &IID_IEnumVARIANT, (void**)&enumvar); } else { FIXME("Enumerator: NewEnum unexpected type of varresult (%d).\n", V_VT(&varresult)); hres = E_INVALIDARG; } VariantClear(&varresult); if (FAILED(hres)) return hres; } hres = alloc_enumerator(ctx, NULL, &enumerator); if (FAILED(hres)) { if (enumvar) IEnumVARIANT_Release(enumvar); return hres; } enumerator->enumvar = enumvar; enumerator->atend = !enumvar; hres = enumvar_get_next_item(enumerator); if (FAILED(hres)) { jsdisp_release(&enumerator->dispex); return hres; } *ret = &enumerator->dispex; return S_OK; }
HRESULT __RPC_STUB IDispatch_Invoke_Stub( IDispatch* This, DISPID dispIdMember, REFIID riid, LCID lcid, DWORD dwFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* pArgErr, UINT cVarRef, UINT* rgVarRefIdx, VARIANTARG* rgVarRef) { HRESULT hr = S_OK; VARIANTARG *rgvarg, *arg; UINT u; /* initialize out parameters, so that they can be marshalled * in case the real Invoke doesn't initialize them */ VariantInit(pVarResult); memset(pExcepInfo, 0, sizeof(*pExcepInfo)); *pArgErr = 0; /* let the real Invoke operate on a copy of the in parameters, * so we don't risk losing pointers to allocated memory */ rgvarg = pDispParams->rgvarg; arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs); if (!arg) return E_OUTOFMEMORY; /* init all args so we can call VariantClear on all the args if the copy * below fails */ for (u = 0; u < pDispParams->cArgs; u++) VariantInit(&arg[u]); for (u = 0; u < pDispParams->cArgs; u++) { hr = VariantCopy(&arg[u], &rgvarg[u]); if (FAILED(hr)) break; } if (SUCCEEDED(hr)) { pDispParams->rgvarg = arg; hr = IDispatch_Invoke(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr); /* copy ref args to out list */ for (u=0; u<cVarRef; u++) { unsigned i = rgVarRefIdx[u]; VariantInit(&rgVarRef[u]); VariantCopy(&rgVarRef[u], &arg[i]); /* clear original if equal, to avoid double-free */ if (V_BYREF(&rgVarRef[u]) == V_BYREF(&rgvarg[i])) VariantClear(&rgvarg[i]); } } /* clear the duplicate argument list */ for (u=0; u<pDispParams->cArgs; u++) VariantClear(&arg[u]); pDispParams->rgvarg = rgvarg; CoTaskMemFree(arg); return hr; }
/* * Call a script. */ DWORD call_script(MSIHANDLE hPackage, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action) { HRESULT hr; IActiveScript *pActiveScript = NULL; IActiveScriptParse *pActiveScriptParse = NULL; MsiActiveScriptSite *pActiveScriptSite = NULL; IDispatch *pDispatch = NULL; DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0}; DISPID dispid; CLSID clsid; VARIANT var; /* Return success by default (if Windows Script not installed) - not native behavior. This * should be here until we implement wine scripting. */ DWORD ret = ERROR_SUCCESS; CoInitialize(NULL); /* Create MsiActiveScriptSite object */ hr = create_ActiveScriptSite(NULL, (void **)&pActiveScriptSite); if (hr != S_OK) goto done; /* Create an installer object */ hr = create_msiserver(NULL, (LPVOID *)&pActiveScriptSite->pInstaller); if (hr != S_OK) goto done; /* Create a session object */ hr = create_session(hPackage, pActiveScriptSite->pInstaller, &pActiveScriptSite->pSession); if (hr != S_OK) goto done; /* Create the scripting engine */ if ((type & 7) == msidbCustomActionTypeJScript) hr = CLSIDFromProgID(szJScript, &clsid); else if ((type & 7) == msidbCustomActionTypeVBScript) hr = CLSIDFromProgID(szVBScript, &clsid); else { ERR("Unknown script type %d\n", type); goto done; } if (FAILED(hr)) { ERR("Could not find CLSID for Windows Script\n"); goto done; } hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IActiveScript, (void **)&pActiveScript); if (FAILED(hr)) { ERR("Could not instantiate class for Windows Script\n"); goto done; } /* If we got this far, Windows Script is installed, so don't return success by default anymore */ ret = ERROR_INSTALL_FAILURE; /* Get the IActiveScriptParse engine interface */ hr = IActiveScript_QueryInterface(pActiveScript, &IID_IActiveScriptParse, (void **)&pActiveScriptParse); if (FAILED(hr)) goto done; /* Give our host to the engine */ hr = IActiveScript_SetScriptSite(pActiveScript, (IActiveScriptSite *)pActiveScriptSite); if (FAILED(hr)) goto done; /* Initialize the script engine */ hr = IActiveScriptParse64_InitNew(pActiveScriptParse); if (FAILED(hr)) goto done; /* Add the session object */ hr = IActiveScript_AddNamedItem(pActiveScript, szSession, SCRIPTITEM_ISVISIBLE); /* Pass the script to the engine */ hr = IActiveScriptParse64_ParseScriptText(pActiveScriptParse, script, NULL, NULL, NULL, 0, 0, 0L, NULL, NULL); if (FAILED(hr)) goto done; /* Start processing the script */ hr = IActiveScript_SetScriptState(pActiveScript, SCRIPTSTATE_CONNECTED); if (FAILED(hr)) goto done; /* Call a function if necessary through the IDispatch interface */ if (function != NULL && strlenW(function) > 0) { TRACE("Calling function %s\n", debugstr_w(function)); hr = IActiveScript_GetScriptDispatch(pActiveScript, NULL, &pDispatch); if (FAILED(hr)) goto done; hr = IDispatch_GetIDsOfNames(pDispatch, &IID_NULL, (WCHAR **)&function, 1,LOCALE_USER_DEFAULT, &dispid); if (FAILED(hr)) goto done; hr = IDispatch_Invoke(pDispatch, dispid, &IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparamsNoArgs, &var, NULL, NULL); if (FAILED(hr)) goto done; /* Check return value, if it's not IDOK we failed */ hr = VariantChangeType(&var, &var, 0, VT_I4); if (FAILED(hr)) goto done; if (V_I4(&var) == IDOK) ret = ERROR_SUCCESS; else ret = ERROR_INSTALL_FAILURE; VariantClear(&var); } else { /* If no function to be called, MSI behavior is to succeed */ ret = ERROR_SUCCESS; } done: /* Free everything that needs to be freed */ if (pDispatch) IDispatch_Release(pDispatch); if (pActiveScript) IActiveScriptSite_Release(pActiveScript); if (pActiveScriptSite && pActiveScriptSite->pSession) IUnknown_Release((IUnknown *)pActiveScriptSite->pSession); if (pActiveScriptSite && pActiveScriptSite->pInstaller) IUnknown_Release((IUnknown *)pActiveScriptSite->pInstaller); if (pActiveScriptSite) IUnknown_Release((IUnknown *)pActiveScriptSite); CoUninitialize(); /* must call even if CoInitialize failed */ return ret; }
zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref) { php_com_dotnet_object *obj; struct php_com_iterator *I; IEnumVARIANT *iev = NULL; DISPPARAMS dp; VARIANT v; unsigned long n_fetched; zval ptr; if (by_ref) { zend_throw_error(NULL, "An iterator cannot be used with foreach by reference"); return NULL; } obj = CDNO_FETCH(object); if (V_VT(&obj->v) != VT_DISPATCH && !V_ISARRAY(&obj->v)) { php_error_docref(NULL, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v)); return NULL; } memset(&dp, 0, sizeof(dp)); VariantInit(&v); I = (struct php_com_iterator*)ecalloc(1, sizeof(*I)); zend_iterator_init(&I->iter); I->iter.funcs = &com_iter_funcs; Z_PTR(I->iter.data) = I; I->code_page = obj->code_page; ZVAL_UNDEF(&I->zdata); VariantInit(&I->safe_array); VariantInit(&I->v); if (V_ISARRAY(&obj->v)) { LONG bound; UINT dims; dims = SafeArrayGetDim(V_ARRAY(&obj->v)); if (dims != 1) { php_error_docref(NULL, E_WARNING, "Can only handle single dimension variant arrays (this array has %d)", dims); goto fail; } /* same semantics as foreach on a PHP array; * make a copy and enumerate that copy */ VariantCopy(&I->safe_array, &obj->v); /* determine the key value for the array */ SafeArrayGetLBound(V_ARRAY(&I->safe_array), 1, &bound); SafeArrayGetUBound(V_ARRAY(&I->safe_array), 1, &I->sa_max); /* pre-fetch the element */ if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound)) { I->key = bound; ZVAL_NULL(&ptr); php_com_zval_from_variant(&ptr, &I->v, I->code_page); ZVAL_COPY_VALUE(&I->zdata, &ptr); } else { I->key = (ulong)-1; } } else { /* can we enumerate it? */ if (FAILED(IDispatch_Invoke(V_DISPATCH(&obj->v), DISPID_NEWENUM, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD|DISPATCH_PROPERTYGET, &dp, &v, NULL, NULL))) { goto fail; } /* get something useful out of it */ if (V_VT(&v) == VT_UNKNOWN) { IUnknown_QueryInterface(V_UNKNOWN(&v), &IID_IEnumVARIANT, (void**)&iev); } else if (V_VT(&v) == VT_DISPATCH) { IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IEnumVARIANT, (void**)&iev); } VariantClear(&v); if (iev == NULL) { goto fail; } I->ev = iev; /* Get the first element now */ if (SUCCEEDED(IEnumVARIANT_Next(I->ev, 1, &I->v, &n_fetched)) && n_fetched > 0) { /* indicate that we have element 0 */ I->key = 0; ZVAL_NULL(&ptr); php_com_zval_from_variant(&ptr, &I->v, I->code_page); ZVAL_COPY_VALUE(&I->zdata, &ptr); } else { /* indicate that there are no more items */ I->key = (ulong)-1; } } return &I->iter; fail: if (I) { VariantClear(&I->safe_array); VariantClear(&I->v); efree(I); } return NULL; }
static void test_wshshell(void) { static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res; BSTR str; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); if(FAILED(hr)) { win_skip("Could not create WshShell object: %08x\n", hr); return; } hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&unk); EXPECT_HR(hr, S_OK); IUnknown_Release(unk); IDispatch_Release(shortcut); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }
static void test_wshshell(void) { static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0}; static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; static const WCHAR pathW[] = {'%','P','A','T','H','%',0}; static const WCHAR sysW[] = {'S','Y','S','T','E','M',0}; static const WCHAR path2W[] = {'P','A','T','H',0}; static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0}; static const WCHAR emptyW[] = {'e','m','p','t','y',0}; IWshEnvironment *env; IWshExec *shexec; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; IWshShortcut *shcut; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res, arg2; BSTR str, ret; DWORD retval; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk); ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut); EXPECT_HR(hr, S_OK); hr = IWshShortcut_get_Arguments(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShortcut_get_IconLocation(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); IWshShortcut_Release(shcut); IDispatch_Release(shortcut); /* ExpandEnvironmentStrings */ hr = IWshShell3_ExpandEnvironmentStrings(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); str = SysAllocString(pathW); hr = IWshShell3_ExpandEnvironmentStrings(sh3, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); SysFreeString(str); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = SysAllocString(sysW); hr = IWshShell3_get_Environment(sh3, &arg, &env); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&arg); hr = IWshEnvironment_get_Item(env, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = (BSTR)0x1; hr = IWshEnvironment_get_Item(env, NULL, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && !*ret, "got %p\n", ret); SysFreeString(ret); /* invalid var name */ str = SysAllocString(lnk1W); hr = IWshEnvironment_get_Item(env, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = NULL; hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret == 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); /* valid name */ str = SysAllocString(path2W); hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret != 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); IWshEnvironment_Release(env); V_VT(&arg) = VT_I2; V_I2(&arg) = 0; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = DISP_E_PARAMNOTFOUND; str = SysAllocString(notepadW); hr = IWshShell3_Run(sh3, str, &arg, &arg2, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); retval = 10; hr = IWshShell3_Run(sh3, str, NULL, &arg2, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; hr = IWshShell3_Run(sh3, str, &arg, NULL, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = 0; hr = IWshShell3_Run(sh3, str, &arg, &arg2, &retval); ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); SysFreeString(str); /* current directory */ if (0) /* crashes on native */ hr = IWshShell3_get_CurrentDirectory(sh3, NULL); str = NULL; hr = IWshShell3_get_CurrentDirectory(sh3, &str); ok(hr == S_OK, "got 0x%08x\n", hr); ok(str && str[0] != 0, "got empty string\n"); SysFreeString(str); hr = IWshShell3_put_CurrentDirectory(sh3, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); str = SysAllocString(dummydirW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); /* Exec */ hr = IWshShell3_Exec(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShell3_Exec(sh3, NULL, &shexec); ok(hr == DISP_E_EXCEPTION, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_Exec(sh3, str, &shexec); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { DispatchEx *This = impl_from_IDispatchEx(iface); HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke) return This->data->vtbl->invoke(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(wFlags == DISPATCH_CONSTRUCT) { if(id == DISPID_VALUE) { if(This->data->vtbl && This->data->vtbl->value) { return This->data->vtbl->value(This, lcid, wFlags, pdp, pvarRes, pei, pspCaller); } FIXME("DISPATCH_CONSTRUCT flag but missing value function\n"); return E_FAIL; } FIXME("DISPATCH_CONSTRUCT flag without DISPID_VALUE\n"); return E_FAIL; } if(is_dynamic_dispid(id)) { DWORD idx = id - DISPID_DYNPROP_0; dynamic_prop_t *prop; if(!get_dynamic_data(This) || This->dynamic_data->prop_cnt <= idx) return DISP_E_UNKNOWNNAME; prop = This->dynamic_data->props+idx; switch(wFlags) { case DISPATCH_METHOD|DISPATCH_PROPERTYGET: if(!pvarRes) return E_INVALIDARG; /* fall through */ case DISPATCH_METHOD: { DISPID named_arg = DISPID_THIS; DISPPARAMS dp = {NULL, &named_arg, 0, 1}; IDispatchEx *dispex; if(V_VT(&prop->var) != VT_DISPATCH) { FIXME("invoke %s\n", debugstr_variant(&prop->var)); return E_NOTIMPL; } if(pdp->cNamedArgs) { FIXME("named args not supported\n"); return E_NOTIMPL; } dp.rgvarg = heap_alloc((pdp->cArgs+1)*sizeof(VARIANTARG)); if(!dp.rgvarg) return E_OUTOFMEMORY; dp.cArgs = pdp->cArgs+1; memcpy(dp.rgvarg+1, pdp->rgvarg, pdp->cArgs*sizeof(VARIANTARG)); V_VT(dp.rgvarg) = VT_DISPATCH; V_DISPATCH(dp.rgvarg) = (IDispatch*)&This->IDispatchEx_iface; hres = IDispatch_QueryInterface(V_DISPATCH(&prop->var), &IID_IDispatchEx, (void**)&dispex); TRACE("%s call\n", debugstr_w(This->dynamic_data->props[idx].name)); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, wFlags, &dp, pvarRes, pei, pspCaller); IDispatchEx_Release(dispex); }else { ULONG err = 0; hres = IDispatch_Invoke(V_DISPATCH(&prop->var), DISPID_VALUE, &IID_NULL, lcid, wFlags, pdp, pvarRes, pei, &err); } TRACE("%s ret %08x\n", debugstr_w(This->dynamic_data->props[idx].name), hres); heap_free(dp.rgvarg); return hres; } case DISPATCH_PROPERTYGET: if(prop->flags & DYNPROP_DELETED) return DISP_E_UNKNOWNNAME; V_VT(pvarRes) = VT_EMPTY; return variant_copy(pvarRes, &prop->var); case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: case DISPATCH_PROPERTYPUT: if(pdp->cArgs != 1 || (pdp->cNamedArgs == 1 && *pdp->rgdispidNamedArgs != DISPID_PROPERTYPUT) || pdp->cNamedArgs > 1) { FIXME("invalid args\n"); return E_INVALIDARG; } TRACE("put %s\n", debugstr_variant(pdp->rgvarg)); VariantClear(&prop->var); hres = variant_copy(&prop->var, pdp->rgvarg); if(FAILED(hres)) return hres; prop->flags &= ~DYNPROP_DELETED; return S_OK; default: FIXME("unhandled wFlags %x\n", wFlags); return E_NOTIMPL; } } return invoke_builtin_prop(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); }