/**************************************************************************
* WsGetServiceProxyProperty [webservices.@]
*/
HRESULT WINAPI WsGetServiceProxyProperty( WS_SERVICE_PROXY *handle, WS_PROXY_PROPERTY_ID id,
void *buf, ULONG size, WS_ERROR *error )
{
struct proxy *proxy = (struct proxy *)handle;
HRESULT hr = S_OK;
TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
if (error) FIXME( "ignoring error parameter\n" );
if (!proxy) return E_INVALIDARG;
EnterCriticalSection( &proxy->cs );
if (proxy->magic != PROXY_MAGIC)
{
LeaveCriticalSection( &proxy->cs );
return E_INVALIDARG;
}
switch (id)
{
case WS_PROXY_PROPERTY_STATE:
if (!buf || size != sizeof(proxy->state)) hr = E_INVALIDARG;
else *(WS_SERVICE_PROXY_STATE *)buf = proxy->state;
break;
default:
hr = prop_get( proxy->prop, proxy->prop_count, id, buf, size );
}
LeaveCriticalSection( &proxy->cs );
return hr;
}
HRESULT init_dispex_from_constr(DispatchEx *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, DispatchEx *constr)
{
DispatchEx *prot = NULL;
dispex_prop_t *prop;
HRESULT hres;
static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
hres = find_prop_name_prot(constr, prototypeW, FALSE, &prop);
if(SUCCEEDED(hres) && prop) {
jsexcept_t jsexcept;
VARIANT var;
V_VT(&var) = VT_EMPTY;
memset(&jsexcept, 0, sizeof(jsexcept));
hres = prop_get(constr, prop, ctx->lcid, NULL, &var, &jsexcept, NULL/*FIXME*/);
if(FAILED(hres)) {
ERR("Could not get prototype\n");
return hres;
}
if(V_VT(&var) == VT_DISPATCH)
prot = iface_to_jsdisp((IUnknown*)V_DISPATCH(&var));
VariantClear(&var);
}
hres = init_dispex(dispex, ctx, builtin_info, prot);
if(prot)
IDispatchEx_Release(_IDispatchEx_(prot));
return hres;
}
/**************************************************************************
* WsGetChannelProperty [webservices.@]
*/
HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, void *buf,
ULONG size, WS_ERROR *error )
{
struct channel *channel = (struct channel *)handle;
TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
if (error) FIXME( "ignoring error parameter\n" );
return prop_get( channel->prop, channel->prop_count, id, buf, size );
}
/**************************************************************************
* WsGetServiceProxyProperty [webservices.@]
*/
HRESULT WINAPI WsGetServiceProxyProperty( WS_SERVICE_PROXY *handle, WS_PROXY_PROPERTY_ID id,
void *buf, ULONG size, WS_ERROR *error )
{
struct proxy *proxy = (struct proxy *)handle;
TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
if (error) FIXME( "ignoring error parameter\n" );
return prop_get( proxy->prop, proxy->prop_count, id, buf, size );
}
HRESULT jsdisp_propget(DispatchEx *jsdisp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei,
IServiceProvider *caller)
{
DISPPARAMS dp = {NULL,NULL,0,0};
dispex_prop_t *prop;
prop = get_prop(jsdisp, id);
if(!prop)
return DISP_E_MEMBERNOTFOUND;
V_VT(val) = VT_EMPTY;
return prop_get(jsdisp, prop, lcid, &dp, val, ei, caller);
}
HRESULT jsdisp_propget_name(DispatchEx *obj, const WCHAR *name, LCID lcid, VARIANT *var,
jsexcept_t *ei, IServiceProvider *caller)
{
DISPPARAMS dp = {NULL, NULL, 0, 0};
dispex_prop_t *prop;
HRESULT hres;
hres = find_prop_name_prot(obj, name, FALSE, &prop);
if(FAILED(hres))
return hres;
V_VT(var) = VT_EMPTY;
if(!prop)
return S_OK;
return prop_get(obj, prop, lcid, &dp, var, ei, caller);
}
/**************************************************************************
* WsGetMessageProperty [webservices.@]
*/
HRESULT WINAPI WsGetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, void *buf,
ULONG size, WS_ERROR *error )
{
struct msg *msg = (struct msg *)handle;
TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
if (error) FIXME( "ignoring error parameter\n" );
if (!handle) return E_INVALIDARG;
switch (id)
{
case WS_MESSAGE_PROPERTY_STATE:
if (!buf || size != sizeof(msg->state)) return E_INVALIDARG;
*(WS_MESSAGE_STATE *)buf = msg->state;
return S_OK;
case WS_MESSAGE_PROPERTY_HEAP:
if (!buf || size != sizeof(msg->heap)) return E_INVALIDARG;
*(WS_HEAP **)buf = msg->heap;
return S_OK;
case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
if (!buf || size != sizeof(msg->version_env)) return E_INVALIDARG;
*(WS_ENVELOPE_VERSION *)buf = msg->version_env;
return S_OK;
case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
if (!buf || size != sizeof(msg->version_addr)) return E_INVALIDARG;
*(WS_ADDRESSING_VERSION *)buf = msg->version_addr;
return S_OK;
case WS_MESSAGE_PROPERTY_HEADER_BUFFER:
if (!buf || size != sizeof(msg->buf)) return E_INVALIDARG;
*(WS_XML_BUFFER **)buf = msg->buf;
return S_OK;
case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
*(BOOL *)buf = msg->is_addressed;
return S_OK;
default:
return prop_get( msg->prop, msg->prop_count, id, buf, size );
}
}
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);
dispex_prop_t *prop;
jsexcept_t jsexcept;
HRESULT hres;
TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
if(pvarRes)
V_VT(pvarRes) = VT_EMPTY;
prop = get_prop(This, id);
if(!prop || prop->type == PROP_DELETED) {
TRACE("invalid id\n");
return DISP_E_MEMBERNOTFOUND;
}
memset(&jsexcept, 0, sizeof(jsexcept));
switch(wFlags) {
case DISPATCH_METHOD:
case DISPATCH_CONSTRUCT:
hres = invoke_prop_func(This, This, prop, lcid, wFlags, pdp, pvarRes, &jsexcept, pspCaller);
break;
case DISPATCH_PROPERTYGET:
hres = prop_get(This, prop, lcid, pdp, pvarRes, &jsexcept, pspCaller);
break;
case DISPATCH_PROPERTYPUT:
hres = prop_put(This, prop, lcid, pdp, &jsexcept, pspCaller);
break;
default:
FIXME("Unimplemented flags %x\n", wFlags);
return E_INVALIDARG;
}
if(pei)
*pei = jsexcept.ei;
return hres;
}
static HRESULT prop_get(DispatchEx *This, dispex_prop_t *prop, LCID lcid, DISPPARAMS *dp,
VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
{
HRESULT hres;
switch(prop->type) {
case PROP_BUILTIN:
if(prop->u.p->flags & PROPF_METHOD) {
DispatchEx *obj;
hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->flags, NULL, &obj);
if(FAILED(hres))
break;
prop->type = PROP_VARIANT;
V_VT(&prop->u.var) = VT_DISPATCH;
V_DISPATCH(&prop->u.var) = (IDispatch*)_IDispatchEx_(obj);
hres = VariantCopy(retv, &prop->u.var);
}else {
hres = prop->u.p->invoke(This, lcid, DISPATCH_PROPERTYGET, dp, retv, ei, caller);
}
break;
case PROP_PROTREF:
hres = prop_get(This->prototype, This->prototype->props+prop->u.ref, lcid, dp, retv, ei, caller);
break;
case PROP_VARIANT:
hres = VariantCopy(retv, &prop->u.var);
break;
default:
ERR("type %d\n", prop->type);
return E_FAIL;
}
if(FAILED(hres)) {
TRACE("fail %08x\n", hres);
return hres;
}
TRACE("%s ret %s\n", debugstr_w(prop->name), debugstr_variant(retv));
return hres;
}
/*
* topo_prop_getprop() and topo_prop_getprops() are private project functions
* for fmtopo
*/
int
topo_prop_getprop(tnode_t *node, const char *pgname, const char *pname,
nvlist_t *args, nvlist_t **prop, int *err)
{
topo_hdl_t *thp = node->tn_hdl;
topo_propval_t *pv;
topo_node_lock(node);
if ((pv = prop_get(node, pgname, pname, args, err)) == NULL) {
(void) get_properror(node, err, *err);
return (-1);
}
if (topo_hdl_nvdup(thp, pv->tp_val, prop) != 0) {
(void) get_properror(node, err, ETOPO_NOMEM);
return (-1);
}
topo_node_unlock(node);
return (0);
}
static int
prop_getval(tnode_t *node, const char *pgname, const char *pname, void *val,
topo_type_t type, uint_t *nelems, int *err)
{
int i, j, ret = 0;
topo_hdl_t *thp = node->tn_hdl;
topo_propval_t *pv;
topo_node_lock(node);
if ((pv = prop_get(node, pgname, pname, NULL, err))
== NULL)
return (get_properror(node, err, *err));
if (pv->tp_type != type)
return (get_properror(node, err, ETOPO_PROP_TYPE));
switch (type) {
case TOPO_TYPE_INT32:
ret = nvlist_lookup_int32(pv->tp_val, TOPO_PROP_VAL_VAL,
(int32_t *)val);
break;
case TOPO_TYPE_UINT32:
ret = nvlist_lookup_uint32(pv->tp_val,
TOPO_PROP_VAL_VAL, (uint32_t *)val);
break;
case TOPO_TYPE_INT64:
ret = nvlist_lookup_int64(pv->tp_val, TOPO_PROP_VAL_VAL,
(int64_t *)val);
break;
case TOPO_TYPE_UINT64:
ret = nvlist_lookup_uint64(pv->tp_val,
TOPO_PROP_VAL_VAL, (uint64_t *)val);
break;
case TOPO_TYPE_DOUBLE:
ret = nvlist_lookup_double(pv->tp_val,
TOPO_PROP_VAL_VAL, (double *)val);
break;
case TOPO_TYPE_STRING: {
char *str;
ret = nvlist_lookup_string(pv->tp_val,
TOPO_PROP_VAL_VAL, &str);
if (ret == 0) {
char *s2;
if ((s2 = topo_hdl_strdup(thp, str)) == NULL)
ret = -1;
else
*(char **)val = s2;
}
break;
}
case TOPO_TYPE_FMRI: {
nvlist_t *nvl;
ret = nvlist_lookup_nvlist(pv->tp_val,
TOPO_PROP_VAL_VAL, &nvl);
if (ret == 0)
ret = topo_hdl_nvdup(thp, nvl,
(nvlist_t **)val);
break;
}
case TOPO_TYPE_INT32_ARRAY: {
int32_t *a1, *a2;
if ((ret = nvlist_lookup_int32_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (int32_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(int32_t **)val = a1;
break;
}
case TOPO_TYPE_UINT32_ARRAY: {
uint32_t *a1, *a2;
if ((ret = nvlist_lookup_uint32_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (uint32_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(uint32_t **)val = a1;
break;
}
case TOPO_TYPE_INT64_ARRAY: {
int64_t *a1, *a2;
if ((ret = nvlist_lookup_int64_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (int64_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(int64_t **)val = a1;
break;
}
case TOPO_TYPE_UINT64_ARRAY: {
uint64_t *a1, *a2;
if ((ret = nvlist_lookup_uint64_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (uint64_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(uint64_t **)val = a1;
break;
}
case TOPO_TYPE_STRING_ARRAY: {
char **a1, **a2;
if ((ret = nvlist_lookup_string_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (char *) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i) {
if ((a1[i] = topo_hdl_strdup(thp, a2[i]))
== NULL) {
for (j = 0; j < i; ++j)
topo_hdl_free(thp, a1[j],
sizeof (char *));
topo_hdl_free(thp, a1,
sizeof (char *) * *nelems);
break;
}
}
*(char ***)val = a1;
break;
}
case TOPO_TYPE_FMRI_ARRAY: {
nvlist_t **a1, **a2;
if ((ret = nvlist_lookup_nvlist_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (nvlist_t *) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i) {
if (topo_hdl_nvdup(thp, a2[i], &a1[i]) < 0) {
for (j = 0; j < i; ++j)
nvlist_free(a1[j]);
topo_hdl_free(thp, a1,
sizeof (nvlist_t *) * *nelems);
break;
}
}
*(nvlist_t ***)val = a1;
break;
}
default:
ret = ETOPO_PROP_NOENT;
}
if (ret != 0)
if (ret == ENOENT)
return (get_properror(node, err, ETOPO_PROP_NOENT));
else if (ret < ETOPO_UNKNOWN)
return (get_properror(node, err, ETOPO_PROP_NVL));
else
return (get_properror(node, err, ret));
topo_node_unlock(node);
return (0);
}
