mirror of
https://github.com/php/php-src.git
synced 2026-03-24 00:02:20 +01:00
b14076a4e6
First, we fix the long standing issue that property access throws a
`com_exception` ("0x80020003: member not found), because the `HRESULT`
was not properly set after accessing the property.
Next, we fix an issue introduced as of PHP 7.0.0, where the string
length for write access had been properly adapted, but the string
length for read access had been overlooked.
Then we fix an issue introduced as of PHP 8.0.0, where new `HashTable`s
no longer set `nNextFreeElement` to zero, but to `ZEND_LONG_MIN`. This
doesn't work well with the `DISPID` lookup, which is a `LONG`.
Finally we fix a potential double-free due to erroneously destroying
the return value of `zend_read_property()`.
Closes GH-16331.
610 lines
15 KiB
C
610 lines
15 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| https://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Author: Wez Furlong <wez@thebrainroom.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
/* This module exports a PHP object as a COM object by wrapping it
|
|
* using IDispatchEx */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include "php.h"
|
|
#include "php_ini.h"
|
|
#include "ext/standard/info.h"
|
|
#include "php_com_dotnet.h"
|
|
#include "php_com_dotnet_internal.h"
|
|
|
|
typedef struct {
|
|
/* This first part MUST match the declaration
|
|
* of interface IDispatchEx */
|
|
CONST_VTBL struct IDispatchExVtbl *lpVtbl;
|
|
|
|
/* now the PHP stuff */
|
|
|
|
DWORD engine_thread; /* for sanity checking */
|
|
zval object; /* the object exported */
|
|
LONG refcount; /* COM reference count */
|
|
|
|
HashTable *dispid_to_name; /* keep track of dispid -> name mappings */
|
|
HashTable *name_to_dispid; /* keep track of name -> dispid mappings */
|
|
|
|
GUID sinkid; /* iid that we "implement" for event sinking */
|
|
} php_dispatchex;
|
|
|
|
static void disp_destructor(php_dispatchex *disp);
|
|
|
|
|
|
/* {{{ trace */
|
|
static inline void trace(char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
char buf[4096];
|
|
|
|
snprintf(buf, sizeof(buf), "T=%08lx ", GetCurrentThreadId());
|
|
OutputDebugString(buf);
|
|
|
|
va_start(ap, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
|
|
OutputDebugString(buf);
|
|
|
|
va_end(ap);
|
|
}
|
|
/* }}} */
|
|
|
|
#define FETCH_DISP(methname) \
|
|
php_dispatchex *disp = (php_dispatchex*)This; \
|
|
if (COMG(rshutdown_started)) { \
|
|
trace(" PHP Object:%p (name:unknown) %s\n", Z_OBJ(disp->object), methname); \
|
|
} else { \
|
|
trace(" PHP Object:%p (name:%s) %s\n", Z_OBJ(disp->object), ZSTR_VAL(Z_OBJCE(disp->object)->name), methname); \
|
|
} \
|
|
if (GetCurrentThreadId() != disp->engine_thread) { \
|
|
return RPC_E_WRONG_THREAD; \
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_queryinterface(
|
|
IDispatchEx *This,
|
|
/* [in] */ REFIID riid,
|
|
/* [iid_is][out] */ void **ppvObject)
|
|
{
|
|
FETCH_DISP("QueryInterface");
|
|
|
|
if (IsEqualGUID(&IID_IUnknown, riid) ||
|
|
IsEqualGUID(&IID_IDispatch, riid) ||
|
|
IsEqualGUID(&IID_IDispatchEx, riid) ||
|
|
IsEqualGUID(&disp->sinkid, riid)) {
|
|
*ppvObject = This;
|
|
InterlockedIncrement(&disp->refcount);
|
|
return S_OK;
|
|
}
|
|
|
|
*ppvObject = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE disp_addref(IDispatchEx *This)
|
|
{
|
|
FETCH_DISP("AddRef");
|
|
|
|
return InterlockedIncrement(&disp->refcount);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE disp_release(IDispatchEx *This)
|
|
{
|
|
ULONG ret;
|
|
FETCH_DISP("Release");
|
|
|
|
ret = InterlockedDecrement(&disp->refcount);
|
|
trace("-- refcount now %lu\n", ret);
|
|
if (ret == 0) {
|
|
/* destroy it */
|
|
disp_destructor(disp);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_gettypeinfocount(
|
|
IDispatchEx *This,
|
|
/* [out] */ UINT *pctinfo)
|
|
{
|
|
FETCH_DISP("GetTypeInfoCount");
|
|
|
|
*pctinfo = 0;
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_gettypeinfo(
|
|
IDispatchEx *This,
|
|
/* [in] */ UINT iTInfo,
|
|
/* [in] */ LCID lcid,
|
|
/* [out] */ ITypeInfo **ppTInfo)
|
|
{
|
|
FETCH_DISP("GetTypeInfo");
|
|
|
|
*ppTInfo = NULL;
|
|
return DISP_E_BADINDEX;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getidsofnames(
|
|
IDispatchEx *This,
|
|
/* [in] */ REFIID riid,
|
|
/* [size_is][in] */ LPOLESTR *rgszNames,
|
|
/* [in] */ UINT cNames,
|
|
/* [in] */ LCID lcid,
|
|
/* [size_is][out] */ DISPID *rgDispId)
|
|
{
|
|
UINT i;
|
|
HRESULT ret = S_OK;
|
|
FETCH_DISP("GetIDsOfNames");
|
|
|
|
for (i = 0; i < cNames; i++) {
|
|
zend_string *name;
|
|
zval *tmp;
|
|
|
|
name = php_com_olestring_to_string(rgszNames[i], COMG(code_page));
|
|
|
|
/* Lookup the name in the hash */
|
|
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) == NULL) {
|
|
ret = DISP_E_UNKNOWNNAME;
|
|
rgDispId[i] = 0;
|
|
} else {
|
|
rgDispId[i] = (DISPID)Z_LVAL_P(tmp);
|
|
}
|
|
|
|
zend_string_release_ex(name, /* persistent */ false);
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_invoke(
|
|
IDispatchEx *This,
|
|
/* [in] */ DISPID dispIdMember,
|
|
/* [in] */ REFIID riid,
|
|
/* [in] */ LCID lcid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [out][in] */ DISPPARAMS *pDispParams,
|
|
/* [out] */ VARIANT *pVarResult,
|
|
/* [out] */ EXCEPINFO *pExcepInfo,
|
|
/* [out] */ UINT *puArgErr)
|
|
{
|
|
return This->lpVtbl->InvokeEx(This, dispIdMember,
|
|
lcid, wFlags, pDispParams,
|
|
pVarResult, pExcepInfo, NULL);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getdispid(
|
|
IDispatchEx *This,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ DWORD grfdex,
|
|
/* [out] */ DISPID *pid)
|
|
{
|
|
HRESULT ret = DISP_E_UNKNOWNNAME;
|
|
zend_string *name;
|
|
zval *tmp;
|
|
FETCH_DISP("GetDispID");
|
|
|
|
name = php_com_olestring_to_string(bstrName, COMG(code_page));
|
|
|
|
trace("Looking for %s, namelen=%lu in %p\n", ZSTR_VAL(name), ZSTR_LEN(name), disp->name_to_dispid);
|
|
|
|
/* Lookup the name in the hash */
|
|
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) != NULL) {
|
|
trace("found it\n");
|
|
*pid = (DISPID)Z_LVAL_P(tmp);
|
|
ret = S_OK;
|
|
}
|
|
|
|
zend_string_release_ex(name, /* persistent */ false);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_invokeex(
|
|
IDispatchEx *This,
|
|
/* [in] */ DISPID id,
|
|
/* [in] */ LCID lcid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [in] */ DISPPARAMS *pdp,
|
|
/* [out] */ VARIANT *pvarRes,
|
|
/* [out] */ EXCEPINFO *pei,
|
|
/* [unique][in] */ IServiceProvider *pspCaller)
|
|
{
|
|
zval *name;
|
|
UINT i;
|
|
zval rv, *retval = NULL;
|
|
zval *params = NULL;
|
|
HRESULT ret = DISP_E_MEMBERNOTFOUND;
|
|
FETCH_DISP("InvokeEx");
|
|
|
|
if (NULL != (name = zend_hash_index_find(disp->dispid_to_name, id))) {
|
|
/* TODO: add support for overloaded objects */
|
|
|
|
trace("-- Invoke: %ld %20s [%lu] flags=%08x args=%u\n", id, Z_STRVAL_P(name), Z_STRLEN_P(name), wFlags, pdp->cArgs);
|
|
|
|
/* convert args into zvals.
|
|
* Args are in reverse order */
|
|
if (pdp->cArgs) {
|
|
params = (zval *)safe_emalloc(sizeof(zval), pdp->cArgs, 0);
|
|
for (i = 0; i < pdp->cArgs; i++) {
|
|
VARIANT *arg;
|
|
|
|
arg = &pdp->rgvarg[ pdp->cArgs - 1 - i];
|
|
|
|
trace("alloc zval for arg %u VT=%08x\n", i, V_VT(arg));
|
|
|
|
php_com_wrap_variant(¶ms[i], arg, COMG(code_page));
|
|
}
|
|
}
|
|
|
|
trace("arguments processed, prepare to do some work\n");
|
|
|
|
/* TODO: if PHP raises an exception here, we should catch it
|
|
* and expose it as a COM exception */
|
|
|
|
if (wFlags & DISPATCH_PROPERTYGET) {
|
|
retval = zend_read_property(Z_OBJCE(disp->object), Z_OBJ(disp->object), Z_STRVAL_P(name), Z_STRLEN_P(name), 1, &rv);
|
|
ret = S_OK;
|
|
} else if (wFlags & DISPATCH_PROPERTYPUT) {
|
|
zend_update_property(Z_OBJCE(disp->object), Z_OBJ(disp->object), Z_STRVAL_P(name), Z_STRLEN_P(name), ¶ms[0]);
|
|
ret = S_OK;
|
|
} else if (wFlags & DISPATCH_METHOD) {
|
|
zend_try {
|
|
retval = &rv;
|
|
if (SUCCESS == call_user_function(NULL, &disp->object, name,
|
|
retval, pdp->cArgs, params)) {
|
|
ret = S_OK;
|
|
trace("function called ok\n");
|
|
|
|
/* Copy any modified values to callers copy of variant*/
|
|
for (i = 0; i < pdp->cArgs; i++) {
|
|
php_com_dotnet_object *obj = CDNO_FETCH(¶ms[i]);
|
|
VARIANT *srcvar = &obj->v;
|
|
VARIANT *dstvar = &pdp->rgvarg[ pdp->cArgs - 1 - i];
|
|
if ((V_VT(dstvar) & VT_BYREF) && obj->modified ) {
|
|
trace("percolate modified value for arg %u VT=%08x\n", i, V_VT(dstvar));
|
|
php_com_copy_variant(dstvar, srcvar);
|
|
}
|
|
}
|
|
} else {
|
|
trace("failed to call func\n");
|
|
ret = DISP_E_EXCEPTION;
|
|
}
|
|
} zend_catch {
|
|
trace("something blew up\n");
|
|
ret = DISP_E_EXCEPTION;
|
|
} zend_end_try();
|
|
} else {
|
|
trace("Don't know how to handle this invocation %08x\n", wFlags);
|
|
}
|
|
|
|
/* release arguments */
|
|
if (params) {
|
|
for (i = 0; i < pdp->cArgs; i++) {
|
|
zval_ptr_dtor(¶ms[i]);
|
|
}
|
|
efree(params);
|
|
}
|
|
|
|
/* return value */
|
|
if (retval) {
|
|
if (pvarRes) {
|
|
VariantInit(pvarRes);
|
|
php_com_variant_from_zval(pvarRes, retval, COMG(code_page));
|
|
}
|
|
// zval_ptr_dtor(retval); // TODO needed for function calls?
|
|
} else if (pvarRes) {
|
|
VariantInit(pvarRes);
|
|
}
|
|
|
|
} else {
|
|
trace("InvokeEx: I don't support DISPID=%ld\n", id);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_deletememberbyname(
|
|
IDispatchEx *This,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ DWORD grfdex)
|
|
{
|
|
FETCH_DISP("DeleteMemberByName");
|
|
|
|
/* TODO: unset */
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_deletememberbydispid(
|
|
IDispatchEx *This,
|
|
/* [in] */ DISPID id)
|
|
{
|
|
FETCH_DISP("DeleteMemberByDispID");
|
|
|
|
/* TODO: unset */
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getmemberproperties(
|
|
IDispatchEx *This,
|
|
/* [in] */ DISPID id,
|
|
/* [in] */ DWORD grfdexFetch,
|
|
/* [out] */ DWORD *pgrfdex)
|
|
{
|
|
FETCH_DISP("GetMemberProperties");
|
|
|
|
return DISP_E_UNKNOWNNAME;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getmembername(
|
|
IDispatchEx *This,
|
|
/* [in] */ DISPID id,
|
|
/* [out] */ BSTR *pbstrName)
|
|
{
|
|
zval *name;
|
|
FETCH_DISP("GetMemberName");
|
|
|
|
if (NULL != (name = zend_hash_index_find(disp->dispid_to_name, id))) {
|
|
OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRLEN_P(name), COMG(code_page));
|
|
*pbstrName = SysAllocString(olestr);
|
|
efree(olestr);
|
|
return S_OK;
|
|
} else {
|
|
return DISP_E_UNKNOWNNAME;
|
|
}
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getnextdispid(
|
|
IDispatchEx *This,
|
|
/* [in] */ DWORD grfdex,
|
|
/* [in] */ DISPID id,
|
|
/* [out] */ DISPID *pid)
|
|
{
|
|
zend_ulong next = id+1;
|
|
FETCH_DISP("GetNextDispID");
|
|
|
|
while(!zend_hash_index_exists(disp->dispid_to_name, next))
|
|
next++;
|
|
|
|
if (zend_hash_index_exists(disp->dispid_to_name, next)) {
|
|
*pid = next;
|
|
return S_OK;
|
|
}
|
|
return S_FALSE;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE disp_getnamespaceparent(
|
|
IDispatchEx *This,
|
|
/* [out] */ IUnknown **ppunk)
|
|
{
|
|
FETCH_DISP("GetNameSpaceParent");
|
|
|
|
*ppunk = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static struct IDispatchExVtbl php_dispatch_vtbl = {
|
|
disp_queryinterface,
|
|
disp_addref,
|
|
disp_release,
|
|
disp_gettypeinfocount,
|
|
disp_gettypeinfo,
|
|
disp_getidsofnames,
|
|
disp_invoke,
|
|
disp_getdispid,
|
|
disp_invokeex,
|
|
disp_deletememberbyname,
|
|
disp_deletememberbydispid,
|
|
disp_getmemberproperties,
|
|
disp_getmembername,
|
|
disp_getnextdispid,
|
|
disp_getnamespaceparent
|
|
};
|
|
|
|
|
|
/* enumerate functions and properties of the object and assign
|
|
* dispatch ids */
|
|
static void generate_dispids(php_dispatchex *disp)
|
|
{
|
|
HashPosition pos;
|
|
zend_string *name = NULL;
|
|
zval *tmp, tmp2;
|
|
int keytype;
|
|
zend_long pid;
|
|
|
|
if (disp->dispid_to_name == NULL) {
|
|
ALLOC_HASHTABLE(disp->dispid_to_name);
|
|
ALLOC_HASHTABLE(disp->name_to_dispid);
|
|
zend_hash_init(disp->name_to_dispid, 0, NULL, ZVAL_PTR_DTOR, 0);
|
|
zend_hash_init(disp->dispid_to_name, 0, NULL, ZVAL_PTR_DTOR, 0);
|
|
}
|
|
|
|
/* properties */
|
|
if (Z_OBJPROP(disp->object)) {
|
|
zend_hash_internal_pointer_reset_ex(Z_OBJPROP(disp->object), &pos);
|
|
while (HASH_KEY_NON_EXISTENT != (keytype =
|
|
zend_hash_get_current_key_ex(Z_OBJPROP(disp->object), &name,
|
|
&pid, &pos))) {
|
|
char namebuf[32];
|
|
if (keytype == HASH_KEY_IS_LONG) {
|
|
snprintf(namebuf, sizeof(namebuf), ZEND_ULONG_FMT, pid);
|
|
name = zend_string_init(namebuf, strlen(namebuf), 0);
|
|
} else {
|
|
zend_string_addref(name);
|
|
}
|
|
|
|
zend_hash_move_forward_ex(Z_OBJPROP(disp->object), &pos);
|
|
|
|
/* Find the existing id */
|
|
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) != NULL) {
|
|
zend_string_release_ex(name, 0);
|
|
continue;
|
|
}
|
|
|
|
/* add the mappings */
|
|
ZVAL_STR_COPY(&tmp2, name);
|
|
zend_hash_next_index_insert(disp->dispid_to_name, &tmp2);
|
|
pid = zend_hash_next_free_element(disp->dispid_to_name) - 1;
|
|
|
|
ZVAL_LONG(&tmp2, pid);
|
|
zend_hash_update(disp->name_to_dispid, name, &tmp2);
|
|
|
|
zend_string_release_ex(name, 0);
|
|
}
|
|
}
|
|
|
|
/* functions */
|
|
if (Z_OBJCE(disp->object)) {
|
|
zend_hash_internal_pointer_reset_ex(&Z_OBJCE(disp->object)->function_table, &pos);
|
|
while (HASH_KEY_NON_EXISTENT != (keytype =
|
|
zend_hash_get_current_key_ex(&Z_OBJCE(disp->object)->function_table,
|
|
&name, &pid, &pos))) {
|
|
|
|
char namebuf[32];
|
|
if (keytype == HASH_KEY_IS_LONG) {
|
|
snprintf(namebuf, sizeof(namebuf), ZEND_ULONG_FMT, pid);
|
|
name = zend_string_init(namebuf, strlen(namebuf), 0);
|
|
} else {
|
|
zend_string_addref(name);
|
|
}
|
|
|
|
zend_hash_move_forward_ex(&Z_OBJCE(disp->object)->function_table, &pos);
|
|
|
|
/* Find the existing id */
|
|
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) != NULL) {
|
|
zend_string_release_ex(name, 0);
|
|
continue;
|
|
}
|
|
|
|
/* add the mappings */
|
|
ZVAL_STR_COPY(&tmp2, name);
|
|
zend_hash_next_index_insert(disp->dispid_to_name, &tmp2);
|
|
pid = zend_hash_next_free_element(disp->dispid_to_name) - 1;
|
|
|
|
ZVAL_LONG(&tmp2, pid);
|
|
zend_hash_update(disp->name_to_dispid, name, &tmp2);
|
|
|
|
zend_string_release_ex(name, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static php_dispatchex *disp_constructor(zval *object)
|
|
{
|
|
php_dispatchex *disp = (php_dispatchex*)CoTaskMemAlloc(sizeof(php_dispatchex));
|
|
|
|
trace("constructing a COM wrapper for PHP object %p (%s)\n", object, ZSTR_VAL(Z_OBJCE_P(object)->name));
|
|
|
|
if (disp == NULL)
|
|
return NULL;
|
|
|
|
memset(disp, 0, sizeof(php_dispatchex));
|
|
|
|
disp->engine_thread = GetCurrentThreadId();
|
|
disp->lpVtbl = &php_dispatch_vtbl;
|
|
disp->refcount = 1;
|
|
|
|
|
|
if (object) {
|
|
ZVAL_COPY(&disp->object, object);
|
|
} else {
|
|
ZVAL_UNDEF(&disp->object);
|
|
}
|
|
|
|
return disp;
|
|
}
|
|
|
|
static void disp_destructor(php_dispatchex *disp)
|
|
{
|
|
zend_hash_destroy(disp->dispid_to_name);
|
|
zend_hash_destroy(disp->name_to_dispid);
|
|
FREE_HASHTABLE(disp->dispid_to_name);
|
|
FREE_HASHTABLE(disp->name_to_dispid);
|
|
|
|
zval_ptr_dtor(&disp->object);
|
|
|
|
CoTaskMemFree(disp);
|
|
}
|
|
|
|
PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid,
|
|
HashTable *id_to_name)
|
|
{
|
|
php_dispatchex *disp = disp_constructor(val);
|
|
HashPosition pos;
|
|
zend_string *name = NULL;
|
|
zval tmp, *ntmp;
|
|
int keytype;
|
|
zend_ulong pid;
|
|
|
|
disp->dispid_to_name = id_to_name;
|
|
|
|
memcpy(&disp->sinkid, sinkid, sizeof(disp->sinkid));
|
|
|
|
/* build up the reverse mapping */
|
|
ALLOC_HASHTABLE(disp->name_to_dispid);
|
|
zend_hash_init(disp->name_to_dispid, 0, NULL, ZVAL_PTR_DTOR, 0);
|
|
|
|
zend_hash_internal_pointer_reset_ex(id_to_name, &pos);
|
|
while (HASH_KEY_NON_EXISTENT != (keytype =
|
|
zend_hash_get_current_key_ex(id_to_name, &name, &pid, &pos))) {
|
|
|
|
if (keytype == HASH_KEY_IS_LONG) {
|
|
|
|
ntmp = zend_hash_get_current_data_ex(id_to_name, &pos);
|
|
|
|
ZVAL_LONG(&tmp, pid);
|
|
zend_hash_update(disp->name_to_dispid, Z_STR_P(ntmp), &tmp);
|
|
}
|
|
|
|
zend_hash_move_forward_ex(id_to_name, &pos);
|
|
}
|
|
|
|
return (IDispatch*)disp;
|
|
}
|
|
|
|
PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val)
|
|
{
|
|
php_dispatchex *disp = NULL;
|
|
|
|
if (Z_TYPE_P(val) != IS_OBJECT) {
|
|
return NULL;
|
|
}
|
|
|
|
if (php_com_is_valid_object(val)) {
|
|
/* pass back its IDispatch directly */
|
|
php_com_dotnet_object *obj = CDNO_FETCH(val);
|
|
|
|
if (obj == NULL)
|
|
return NULL;
|
|
|
|
if (V_VT(&obj->v) == VT_DISPATCH && V_DISPATCH(&obj->v)) {
|
|
IDispatch_AddRef(V_DISPATCH(&obj->v));
|
|
return V_DISPATCH(&obj->v);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
disp = disp_constructor(val);
|
|
generate_dispids(disp);
|
|
|
|
return (IDispatch*)disp;
|
|
}
|