1999-04-21 23:11:20 +00:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
1999-07-16 13:13:16 +00:00
|
|
|
| PHP version 4.0 |
|
1999-04-21 23:11:20 +00:00
|
|
|
+----------------------------------------------------------------------+
|
2000-01-01 01:32:05 +00:00
|
|
|
| Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
|
1999-04-21 23:11:20 +00:00
|
|
|
+----------------------------------------------------------------------+
|
2000-02-19 23:21:46 +00:00
|
|
|
| This source file is subject to version 2.01 of the PHP license, |
|
1999-07-16 13:13:16 +00:00
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
|
|
| available at through the world-wide-web at |
|
2000-02-19 23:21:46 +00:00
|
|
|
| http://www.php.net/license/2_01.txt. |
|
1999-07-16 13:13:16 +00:00
|
|
|
| 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. |
|
1999-04-21 23:11:20 +00:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Author: Zeev Suraski <zeev@zend.com> |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This module implements support for COM components that support the IDispatch
|
|
|
|
* interface. Both local (COM) and remote (DCOM) components can be accessed.
|
|
|
|
*
|
|
|
|
* Type libraries can be loaded (in order for PHP to recognize automation constants)
|
|
|
|
* by specifying a typelib_file in the PHP .ini file. That file should contain
|
|
|
|
* paths to type libraries, one in every line. By default, constants are registered
|
|
|
|
* as case-sensitive. If you want them to be defined as case-insensitive, add
|
|
|
|
* #case_insensitive or #cis at the end of the type library path.
|
|
|
|
*
|
|
|
|
* This is also the first module to demonstrate Zend's OO syntax overloading
|
|
|
|
* capabilities. CORBA coders are invited to write a CORBA module as well!
|
|
|
|
*
|
|
|
|
* Zeev
|
|
|
|
*/
|
|
|
|
|
2000-05-05 07:18:50 +00:00
|
|
|
#ifdef PHP_WIN32
|
1999-04-21 23:11:20 +00:00
|
|
|
|
|
|
|
#define _WIN32_DCOM
|
|
|
|
|
|
|
|
#include "php.h"
|
1999-10-20 19:16:17 +00:00
|
|
|
#include "php_COM.h"
|
1999-04-21 23:11:20 +00:00
|
|
|
#include "zend_compile.h"
|
|
|
|
#include "php_ini.h"
|
2000-05-05 07:18:50 +00:00
|
|
|
#include "php_reentrancy.h"
|
1999-04-21 23:11:20 +00:00
|
|
|
|
|
|
|
#include "objbase.h"
|
|
|
|
#include "olestd.h"
|
|
|
|
#include <ctype.h>
|
|
|
|
|
|
|
|
|
|
|
|
static int le_idispatch;
|
|
|
|
|
1999-12-03 02:25:22 +00:00
|
|
|
static zend_class_entry com_class_entry;
|
|
|
|
|
1999-04-21 23:11:20 +00:00
|
|
|
function_entry COM_functions[] = {
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_FE(COM_load, NULL)
|
|
|
|
PHP_FE(COM_invoke, NULL)
|
1999-04-21 23:11:20 +00:00
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_FE(com_propget, NULL)
|
|
|
|
PHP_FE(com_propput, NULL)
|
1999-04-21 23:11:20 +00:00
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_FALIAS(com_get, com_propget, NULL)
|
|
|
|
PHP_FALIAS(com_propset, com_propput, NULL)
|
|
|
|
PHP_FALIAS(com_set, com_propput, NULL)
|
1999-04-21 23:11:20 +00:00
|
|
|
|
|
|
|
{NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
|
1999-05-09 08:48:05 +00:00
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
static PHP_MINFO_FUNCTION(COM)
|
1999-05-09 08:48:05 +00:00
|
|
|
{
|
|
|
|
DISPLAY_INI_ENTRIES();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
zend_module_entry COM_module_entry = {
|
2000-03-06 18:44:01 +00:00
|
|
|
"com", COM_functions, PHP_MINIT(COM), PHP_MSHUTDOWN(COM), NULL, NULL, PHP_MINFO(COM), STANDARD_MODULE_PROPERTIES
|
1999-04-21 23:11:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void php_register_COM_class();
|
|
|
|
|
|
|
|
static int php_COM_load_typelib(char *typelib_name, int mode);
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
static char *php_COM_error_message(HRESULT hr)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
void *pMsgBuf;
|
|
|
|
|
|
|
|
if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
|
|
|
|
hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &pMsgBuf, 0, NULL)) {
|
|
|
|
char error_string[] = "No description available";
|
|
|
|
|
|
|
|
pMsgBuf = LocalAlloc(LMEM_FIXED, sizeof(error_string));
|
|
|
|
memcpy(pMsgBuf, error_string, sizeof(error_string));
|
|
|
|
}
|
|
|
|
|
|
|
|
return pMsgBuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static OLECHAR *php_char_to_OLECHAR(char *C_str, uint strlen)
|
|
|
|
{
|
|
|
|
OLECHAR *unicode_str = (OLECHAR *) emalloc(sizeof(OLECHAR)*(strlen+1));
|
|
|
|
OLECHAR *unicode_ptr = unicode_str;
|
|
|
|
|
|
|
|
while (*C_str) {
|
|
|
|
*unicode_ptr++ = (unsigned short) *C_str++;
|
|
|
|
}
|
|
|
|
*unicode_ptr = 0;
|
|
|
|
|
|
|
|
return unicode_str;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
char *php_OLECHAR_to_char(OLECHAR *unicode_str, uint *out_length, int persistent)
|
|
|
|
{
|
|
|
|
uint length = OLESTRLEN(unicode_str);
|
|
|
|
char *C_str = (char *) pemalloc(length+1, persistent), *p = C_str;
|
|
|
|
|
|
|
|
while (*unicode_str) {
|
|
|
|
*p++ = (char) *unicode_str++;
|
|
|
|
}
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
if (out_length) {
|
|
|
|
*out_length = length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return C_str;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
static char *php_string_from_clsid(CLSID *clsid)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
LPOLESTR ole_clsid;
|
|
|
|
char *clsid_str;
|
|
|
|
|
|
|
|
StringFromCLSID(clsid, &ole_clsid);
|
|
|
|
//s_clsid = OLE2A(ole_clsid);
|
|
|
|
clsid_str = php_OLECHAR_to_char(ole_clsid, NULL, 0);
|
|
|
|
LocalFree(ole_clsid);
|
|
|
|
|
|
|
|
return clsid_str;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
static void php_idispatch_destructor(IDispatch *i_dispatch)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
i_dispatch->lpVtbl->Release(i_dispatch);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PHP_INI_MH(OnTypelibFileChange)
|
|
|
|
{
|
|
|
|
FILE *typelib_file;
|
|
|
|
char *typelib_name_buffer;
|
1999-11-26 16:51:57 +00:00
|
|
|
char *strtok_buf = NULL;
|
1999-04-21 23:11:20 +00:00
|
|
|
#if SUPPORT_INTERACTIVE
|
|
|
|
int interactive;
|
|
|
|
ELS_FETCH();
|
|
|
|
|
|
|
|
interactive = EG(interactive);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2000-04-15 14:20:01 +00:00
|
|
|
if (!new_value || (typelib_file=V_FOPEN(new_value, "r"))==NULL) {
|
1999-04-21 23:11:20 +00:00
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if SUPPORT_INTERACTIVE
|
|
|
|
if (interactive) {
|
|
|
|
printf("Loading type libraries...");
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typelib_name_buffer = (char *) malloc(sizeof(char)*1024);
|
|
|
|
|
|
|
|
while (fgets(typelib_name_buffer, 1024, typelib_file)) {
|
|
|
|
char *typelib_name;
|
|
|
|
char *modifier;
|
|
|
|
int mode = CONST_PERSISTENT|CONST_CS;
|
|
|
|
|
|
|
|
if (typelib_name_buffer[0]==';') {
|
|
|
|
continue;
|
|
|
|
}
|
2000-05-05 07:18:50 +00:00
|
|
|
typelib_name = php_strtok_r(typelib_name_buffer, "\r\n", &strtok_buf); /* get rid of newlines */
|
|
|
|
typelib_name = php_strtok_r(typelib_name, "#", &strtok_buf);
|
|
|
|
modifier = php_strtok_r(NULL, "#", &strtok_buf);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (modifier) {
|
|
|
|
if (!strcmp(modifier, "cis") || !strcmp(modifier, "case_insensitive")) {
|
|
|
|
mode &= ~CONST_CS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if SUPPORT_INTERACTIVE
|
|
|
|
if (interactive) {
|
|
|
|
printf("\rLoading %-60s\r", typelib_name);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
php_COM_load_typelib(typelib_name, mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(typelib_name_buffer);
|
|
|
|
fclose(typelib_file);
|
|
|
|
|
|
|
|
#if SUPPORT_INTERACTIVE
|
|
|
|
if (interactive) {
|
|
|
|
printf("\r%70s\r", "");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PHP_INI_BEGIN()
|
1999-05-09 08:48:05 +00:00
|
|
|
PHP_INI_ENTRY1_EX("allow_dcom", "0", PHP_INI_SYSTEM, NULL, NULL, php_ini_boolean_displayer_cb)
|
1999-04-28 20:26:33 +00:00
|
|
|
PHP_INI_ENTRY1("typelib_file", NULL, PHP_INI_SYSTEM, OnTypelibFileChange, NULL)
|
1999-04-21 23:11:20 +00:00
|
|
|
PHP_INI_END()
|
|
|
|
|
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_MINIT_FUNCTION(COM)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
CoInitialize(NULL);
|
2000-04-10 21:54:15 +00:00
|
|
|
le_idispatch = register_list_destructors(php_idispatch_destructor, NULL);
|
1999-04-21 23:11:20 +00:00
|
|
|
php_register_COM_class();
|
|
|
|
REGISTER_INI_ENTRIES();
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_MSHUTDOWN_FUNCTION(COM)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
CoUninitialize();
|
|
|
|
UNREGISTER_INI_ENTRIES();
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-05-21 10:06:25 +00:00
|
|
|
PHP_FUNCTION(COM_load)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
pval *module_name, *server_name=NULL;
|
|
|
|
CLSID clsid;
|
|
|
|
HRESULT hr;
|
|
|
|
OLECHAR *ProgID;
|
|
|
|
IDispatch FAR *i_dispatch = NULL;
|
|
|
|
char *error_message;
|
|
|
|
char *clsid_str;
|
|
|
|
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
|
|
case 1:
|
|
|
|
getParameters(ht, 1, &module_name);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (!INI_INT("allow_dcom")) {
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING, "DCOM is disabled");
|
1999-04-21 23:11:20 +00:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
getParameters(ht, 2, &module_name, &server_name);
|
|
|
|
convert_to_string(server_name);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_string(module_name);
|
|
|
|
ProgID = php_char_to_OLECHAR(module_name->value.str.val, module_name->value.str.len);
|
|
|
|
hr=CLSIDFromProgID(ProgID, &clsid);
|
|
|
|
efree(ProgID);
|
|
|
|
|
|
|
|
// obtain CLSID
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Invalid ProgID: %s\n", error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// obtain IDispatch
|
|
|
|
if (!server_name) {
|
|
|
|
hr=CoCreateInstance(&clsid, NULL, CLSCTX_SERVER, &IID_IDispatch, (void **) &i_dispatch);
|
|
|
|
} else {
|
|
|
|
COSERVERINFO server_info;
|
|
|
|
MULTI_QI pResults;
|
|
|
|
|
|
|
|
server_info.dwReserved1=0;
|
|
|
|
server_info.dwReserved2=0;
|
|
|
|
server_info.pwszName = php_char_to_OLECHAR(server_name->value.str.val, server_name->value.str.len);
|
|
|
|
server_info.pAuthInfo=NULL;
|
|
|
|
|
|
|
|
pResults.pIID = &IID_IDispatch;
|
|
|
|
pResults.pItf = NULL;
|
|
|
|
pResults.hr = S_OK;
|
|
|
|
hr=CoCreateInstanceEx(&clsid, NULL, CLSCTX_SERVER, &server_info, 1, &pResults);
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
|
|
hr = pResults.hr;
|
|
|
|
i_dispatch = (IDispatch *) pResults.pItf;
|
|
|
|
}
|
|
|
|
efree(server_info.pwszName);
|
|
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
|
|
|
clsid_str = php_string_from_clsid(&clsid);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Unable to obtain IDispatch interface for CLSID %s: %s",clsid_str,error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(clsid_str);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-17 19:51:39 +00:00
|
|
|
RETURN_LONG(zend_list_insert(i_dispatch,le_idispatch));
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void php_variant_to_pval(VARIANTARG *var_arg, pval *pval_arg, int persistent)
|
|
|
|
{
|
1999-11-06 10:01:55 +00:00
|
|
|
|
|
|
|
switch (var_arg->vt & ~VT_BYREF) {
|
1999-04-21 23:11:20 +00:00
|
|
|
case VT_EMPTY:
|
|
|
|
var_uninit(pval_arg);
|
|
|
|
break;
|
|
|
|
case VT_UI1:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = (long) var_arg->bVal;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = (long)*(var_arg->pbVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_LONG;
|
|
|
|
break;
|
|
|
|
case VT_I2:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = (long) var_arg->iVal;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = (long )*(var_arg->piVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_LONG;
|
|
|
|
break;
|
|
|
|
case VT_I4:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = var_arg->lVal;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.lval = *(var_arg->plVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_LONG;
|
|
|
|
break;
|
|
|
|
case VT_R4:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.dval = (double) var_arg->fltVal;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.dval = (double)*(var_arg->pfltVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_DOUBLE;
|
|
|
|
break;
|
|
|
|
case VT_R8:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.dval = var_arg->dblVal;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.dval = *(var_arg->pdblVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_DOUBLE;
|
|
|
|
break;
|
|
|
|
case VT_BOOL:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
if (var_arg->boolVal & 0xFFFF) {
|
|
|
|
pval_arg->value.lval = 1;
|
|
|
|
} else {
|
|
|
|
pval_arg->value.lval = 0;
|
|
|
|
}
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
if (*(var_arg->pboolVal) & 0xFFFF) {
|
|
|
|
pval_arg->value.lval = 1;
|
|
|
|
} else {
|
|
|
|
pval_arg->value.lval = 0;
|
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
pval_arg->type = IS_BOOL;
|
|
|
|
break;
|
|
|
|
case VT_BSTR:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.str.val = php_OLECHAR_to_char(var_arg->bstrVal, &pval_arg->value.str.len, persistent);
|
|
|
|
SysFreeString(var_arg->bstrVal);
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
pval_arg->value.str.val = php_OLECHAR_to_char(*(var_arg->pbstrVal), &pval_arg->value.str.len, persistent);
|
|
|
|
SysFreeString(*(var_arg->pbstrVal));
|
|
|
|
efree(var_arg->pbstrVal);
|
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
pval_arg->type = IS_STRING;
|
|
|
|
break;
|
2000-04-10 21:32:19 +00:00
|
|
|
case VT_DATE: {
|
|
|
|
SYSTEMTIME wintime;
|
|
|
|
struct tm phptime;
|
|
|
|
|
|
|
|
VariantTimeToSystemTime(var_arg->date, &wintime);
|
|
|
|
phptime.tm_year = wintime.wYear-1900;
|
|
|
|
phptime.tm_mon = wintime.wMonth-1;
|
|
|
|
phptime.tm_mday = wintime.wDay;
|
|
|
|
phptime.tm_hour = wintime.wHour;
|
|
|
|
phptime.tm_min = wintime.wMinute;
|
|
|
|
phptime.tm_sec = wintime.wSecond;
|
|
|
|
phptime.tm_isdst= -1;
|
|
|
|
|
|
|
|
tzset();
|
|
|
|
pval_arg->value.lval = mktime(&phptime);
|
|
|
|
pval_arg->type = IS_LONG;
|
1999-12-03 02:25:22 +00:00
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
break;
|
2000-04-10 21:32:19 +00:00
|
|
|
case VT_DISPATCH: {
|
|
|
|
pval *handle;
|
|
|
|
|
|
|
|
pval_arg->type=IS_OBJECT;
|
|
|
|
pval_arg->value.obj.ce=&com_class_entry;
|
|
|
|
pval_arg->value.obj.properties = (HashTable *) emalloc(sizeof(HashTable));
|
|
|
|
pval_arg->is_ref=1;
|
|
|
|
pval_arg->refcount=1;
|
|
|
|
zend_hash_init(pval_arg->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
|
|
|
|
|
|
|
|
ALLOC_ZVAL(handle);
|
|
|
|
handle->type = IS_LONG;
|
|
|
|
handle->value.lval = zend_list_insert(var_arg->pdispVal, le_idispatch);
|
|
|
|
pval_copy_constructor(handle);
|
|
|
|
INIT_PZVAL(handle);
|
|
|
|
zend_hash_index_update(pval_arg->value.obj.properties, 0, &handle, sizeof(pval *), NULL);
|
1999-12-03 02:25:22 +00:00
|
|
|
}
|
2000-04-10 21:32:19 +00:00
|
|
|
break;
|
1999-12-03 02:25:22 +00:00
|
|
|
case VT_UNKNOWN:
|
|
|
|
var_arg->pdispVal->lpVtbl->Release(var_arg->pdispVal);
|
|
|
|
/* fallthru */
|
1999-04-21 23:11:20 +00:00
|
|
|
default:
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Unsupported variant type");
|
1999-04-21 23:11:20 +00:00
|
|
|
var_reset(pval_arg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
static void php_pval_to_variant(pval *pval_arg, VARIANTARG *var_arg)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
OLECHAR *unicode_str;
|
|
|
|
|
|
|
|
switch (pval_arg->type) {
|
|
|
|
case IS_OBJECT:
|
|
|
|
case IS_ARRAY:
|
|
|
|
var_arg->vt = VT_EMPTY;
|
|
|
|
break;
|
|
|
|
case IS_LONG:
|
|
|
|
case IS_BOOL:
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0) {
|
1999-11-06 10:01:55 +00:00
|
|
|
var_arg->vt = VT_I4; // assuming 32-bit platform
|
|
|
|
var_arg->lVal = pval_arg->value.lval;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
var_arg->vt = VT_I4 | VT_BYREF; // assuming 32-bit platform
|
|
|
|
var_arg->plVal = &(pval_arg->value.lval);
|
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
break;
|
|
|
|
case IS_DOUBLE:
|
|
|
|
var_arg->vt = VT_R8; // assuming 64-bit double precision
|
|
|
|
var_arg->dblVal = pval_arg->value.dval;
|
|
|
|
break;
|
|
|
|
case IS_STRING:
|
|
|
|
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len);
|
2000-04-10 21:32:19 +00:00
|
|
|
if (pval_arg->is_ref == 0) {
|
1999-11-06 10:01:55 +00:00
|
|
|
var_arg->bstrVal = SysAllocString(unicode_str);
|
|
|
|
var_arg->vt = VT_BSTR;
|
2000-04-10 21:32:19 +00:00
|
|
|
} else {
|
1999-11-06 10:01:55 +00:00
|
|
|
var_arg->pbstrVal = (BSTR *)emalloc(sizeof(BSTR *));
|
|
|
|
*(var_arg->pbstrVal) = SysAllocString(unicode_str);
|
|
|
|
var_arg->vt = VT_BSTR | VT_BYREF;
|
|
|
|
break;
|
|
|
|
}
|
1999-04-21 23:11:20 +00:00
|
|
|
efree(unicode_str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int do_COM_invoke(IDispatch *i_dispatch, pval *function_name, VARIANTARG *var_result, pval **arguments, int arg_count)
|
|
|
|
{
|
|
|
|
DISPID dispid;
|
|
|
|
HRESULT hr;
|
|
|
|
OLECHAR *funcname;
|
|
|
|
char *error_message;
|
|
|
|
VARIANTARG *variant_args;
|
|
|
|
int current_arg, current_variant;
|
|
|
|
DISPPARAMS dispparams;
|
|
|
|
|
|
|
|
funcname = php_char_to_OLECHAR(function_name->value.str.val, function_name->value.str.len);
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->GetIDsOfNames(i_dispatch, &IID_NULL, &funcname,
|
|
|
|
1, LOCALE_SYSTEM_DEFAULT, &dispid);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Unable to lookup %s: %s\n", function_name->value.str.val, error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(funcname);
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
variant_args = (VARIANTARG *) emalloc(sizeof(VARIANTARG)*arg_count);
|
|
|
|
|
|
|
|
for (current_arg=0; current_arg<arg_count; current_arg++) {
|
|
|
|
current_variant = arg_count - current_arg - 1;
|
1999-11-06 10:01:55 +00:00
|
|
|
php_pval_to_variant(arguments[current_arg], &variant_args[current_variant]);
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
dispparams.rgvarg = variant_args;
|
|
|
|
dispparams.rgdispidNamedArgs = NULL;
|
|
|
|
dispparams.cArgs = arg_count;
|
|
|
|
dispparams.cNamedArgs = 0;
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
|
2000-04-10 21:54:15 +00:00
|
|
|
LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
|
1999-04-21 23:11:20 +00:00
|
|
|
&dispparams, var_result, NULL, 0);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Invoke() failed: %s\n", error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(funcname);
|
|
|
|
efree(variant_args);
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
// variant_args = dispparams.rgvarg;
|
|
|
|
|
|
|
|
for (current_arg=0; current_arg<arg_count; current_arg++) {
|
|
|
|
current_variant = arg_count - current_arg - 1;
|
2000-04-10 21:25:09 +00:00
|
|
|
zval_dtor(arguments[current_arg]);
|
1999-11-06 10:01:55 +00:00
|
|
|
php_variant_to_pval(&variant_args[current_variant], arguments[current_arg], 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-04-21 23:11:20 +00:00
|
|
|
efree(variant_args);
|
|
|
|
efree(funcname);
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-05-21 10:06:25 +00:00
|
|
|
PHP_FUNCTION(COM_invoke)
|
1999-04-21 23:11:20 +00:00
|
|
|
{
|
|
|
|
pval **arguments;
|
|
|
|
pval *object, *function_name;
|
|
|
|
IDispatch *i_dispatch;
|
|
|
|
int type;
|
|
|
|
int arg_count = ARG_COUNT(ht);
|
|
|
|
VARIANTARG var_result;
|
|
|
|
|
|
|
|
if (arg_count<2) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
arguments = (pval **) emalloc(sizeof(pval *)*arg_count);
|
|
|
|
if (getParametersArray(ht, arg_count, arguments)==FAILURE) {
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
object = arguments[0];
|
|
|
|
function_name = arguments[1];
|
|
|
|
|
|
|
|
/* obtain i_dispatch interface */
|
|
|
|
convert_to_long(object);
|
1999-12-17 19:51:39 +00:00
|
|
|
i_dispatch = zend_list_find(object->value.lval, &type);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!i_dispatch || (type!=le_idispatch)) {
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"%d is not a COM object handler", function_name->value.str.val);
|
1999-04-21 23:11:20 +00:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* obtain property/method handler */
|
|
|
|
convert_to_string(function_name);
|
|
|
|
|
|
|
|
if (do_COM_invoke(i_dispatch, function_name, &var_result, arguments+2, arg_count-2)==FAILURE) {
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
efree(arguments);
|
|
|
|
|
|
|
|
php_variant_to_pval(&var_result, return_value, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int do_COM_offget(VARIANTARG *var_result, VARIANTARG *array, pval *arg_property, int cleanup)
|
|
|
|
{
|
|
|
|
switch (array->vt) {
|
|
|
|
case VT_DISPATCH: { /* a Collection, possibly */
|
|
|
|
pval function_name;
|
|
|
|
IDispatch *i_dispatch = array->pdispVal;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
function_name.value.str.val = "Item";
|
|
|
|
function_name.value.str.len = 4;
|
|
|
|
function_name.type = IS_STRING;
|
|
|
|
retval = do_COM_invoke(i_dispatch, &function_name, var_result, &arg_property, 1);
|
|
|
|
if (cleanup) {
|
|
|
|
i_dispatch->lpVtbl->Release(i_dispatch);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int do_COM_propget(VARIANTARG *var_result, IDispatch *i_dispatch, pval *arg_property, int cleanup)
|
|
|
|
{
|
|
|
|
DISPID dispid;
|
|
|
|
HRESULT hr;
|
|
|
|
OLECHAR *propname;
|
|
|
|
char *error_message;
|
|
|
|
DISPPARAMS dispparams;
|
|
|
|
|
|
|
|
|
|
|
|
/* obtain property handler */
|
|
|
|
propname = php_char_to_OLECHAR(arg_property->value.str.val, arg_property->value.str.len);
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->GetIDsOfNames(i_dispatch, &IID_NULL, &propname,
|
|
|
|
1, LOCALE_SYSTEM_DEFAULT, &dispid);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Unable to lookup %s: %s\n", arg_property->value.str.val, error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(propname);
|
|
|
|
if (cleanup) {
|
|
|
|
i_dispatch->lpVtbl->Release(i_dispatch);
|
|
|
|
}
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dispparams.cArgs = 0;
|
|
|
|
dispparams.cNamedArgs = 0;
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
|
|
|
|
LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET,
|
|
|
|
&dispparams, var_result, NULL, 0);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"PropGet() failed: %s\n", error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(propname);
|
|
|
|
if (cleanup) {
|
|
|
|
i_dispatch->lpVtbl->Release(i_dispatch);
|
|
|
|
}
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
efree(propname);
|
|
|
|
if (cleanup) {
|
|
|
|
i_dispatch->lpVtbl->Release(i_dispatch);
|
|
|
|
}
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void do_COM_propput(pval *return_value, IDispatch *i_dispatch, pval *arg_property, pval *value)
|
|
|
|
{
|
|
|
|
DISPID dispid;
|
|
|
|
HRESULT hr;
|
|
|
|
OLECHAR *propname;
|
|
|
|
char *error_message;
|
|
|
|
VARIANTARG var_result;
|
|
|
|
DISPPARAMS dispparams;
|
|
|
|
VARIANTARG new_value;
|
|
|
|
DISPID mydispid = DISPID_PROPERTYPUT;
|
|
|
|
|
|
|
|
|
|
|
|
/* obtain property handler */
|
|
|
|
propname = php_char_to_OLECHAR(arg_property->value.str.val, arg_property->value.str.len);
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->GetIDsOfNames(i_dispatch, &IID_NULL, &propname,
|
|
|
|
1, LOCALE_SYSTEM_DEFAULT, &dispid);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"Unable to lookup %s: %s\n", arg_property->value.str.val, error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(propname);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 10:01:55 +00:00
|
|
|
php_pval_to_variant(value, &new_value);
|
1999-04-21 23:11:20 +00:00
|
|
|
dispparams.rgvarg = &new_value;
|
|
|
|
dispparams.rgdispidNamedArgs = &mydispid;
|
|
|
|
dispparams.cArgs = 1;
|
|
|
|
dispparams.cNamedArgs = 1;
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
|
|
|
|
LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT,
|
|
|
|
&dispparams, NULL, NULL, 0);
|
|
|
|
|
|
|
|
dispparams.cArgs = 0;
|
|
|
|
dispparams.cNamedArgs = 0;
|
|
|
|
|
|
|
|
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
|
|
|
|
LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET,
|
|
|
|
&dispparams, &var_result, NULL, 0);
|
|
|
|
|
|
|
|
if (FAILED(hr)) {
|
1999-11-06 10:01:55 +00:00
|
|
|
error_message = php_COM_error_message(hr);
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"PropPut() failed: %s\n", error_message);
|
1999-04-21 23:11:20 +00:00
|
|
|
LocalFree(error_message);
|
|
|
|
efree(propname);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
php_variant_to_pval(&var_result, return_value, 0);
|
|
|
|
|
|
|
|
efree(propname);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PHP_FUNCTION(com_propget)
|
|
|
|
{
|
|
|
|
pval *arg_idispatch, *arg_property;
|
|
|
|
int type;
|
|
|
|
IDispatch *i_dispatch;
|
|
|
|
VARIANTARG var_result;
|
|
|
|
|
|
|
|
if (ARG_COUNT(ht)!=2 || getParameters(ht, 2, &arg_idispatch, &arg_property)==FAILURE) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* obtain i_dispatch interface */
|
|
|
|
convert_to_long(arg_idispatch);
|
|
|
|
/* obtain i_dispatch interface */
|
1999-12-17 19:51:39 +00:00
|
|
|
i_dispatch = zend_list_find(arg_idispatch->value.lval,&type);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!i_dispatch || (type!=le_idispatch)) {
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"%d is not a COM object handler", arg_idispatch->value.lval);
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
convert_to_string(arg_property);
|
|
|
|
|
|
|
|
if (do_COM_propget(&var_result, i_dispatch, arg_property, 0)==FAILURE) {
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
php_variant_to_pval(&var_result, return_value, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PHP_FUNCTION(com_propput)
|
|
|
|
{
|
|
|
|
pval *arg_idispatch, *arg_property, *arg_value;
|
|
|
|
int type;
|
|
|
|
IDispatch *i_dispatch;
|
|
|
|
|
|
|
|
if (ARG_COUNT(ht)!=3 || getParameters(ht, 3, &arg_idispatch, &arg_property, &arg_value)==FAILURE) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* obtain i_dispatch interface */
|
|
|
|
convert_to_long(arg_idispatch);
|
|
|
|
/* obtain i_dispatch interface */
|
1999-12-17 19:51:39 +00:00
|
|
|
i_dispatch = zend_list_find(arg_idispatch->value.lval,&type);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!i_dispatch || (type!=le_idispatch)) {
|
1999-08-02 19:17:14 +00:00
|
|
|
php_error(E_WARNING,"%d is not a COM object handler", arg_idispatch->value.lval);
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
convert_to_string(arg_property);
|
|
|
|
|
|
|
|
do_COM_propput(return_value, i_dispatch, arg_property, arg_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
VARIANTARG _php_COM_get_property_handler(zend_property_reference *property_reference)
|
|
|
|
{
|
|
|
|
zend_overloaded_element *overloaded_property;
|
|
|
|
zend_llist_element *element;
|
|
|
|
pval **idispatch_handle;
|
1999-07-26 16:57:06 +00:00
|
|
|
pval *object = property_reference->object;
|
1999-04-21 23:11:20 +00:00
|
|
|
IDispatch *i_dispatch;
|
|
|
|
int type;
|
|
|
|
VARIANTARG var_result;
|
|
|
|
|
|
|
|
|
|
|
|
/* fetch the IDispatch interface */
|
|
|
|
zend_hash_index_find(object->value.obj.properties, 0, (void **) &idispatch_handle);
|
1999-12-17 19:51:39 +00:00
|
|
|
i_dispatch = zend_list_find((*idispatch_handle)->value.lval,&type);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!i_dispatch || (type!=le_idispatch)) {
|
2000-04-10 21:54:15 +00:00
|
|
|
var_result.vt = VT_EMPTY;
|
|
|
|
return var_result;
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var_result.vt = VT_DISPATCH;
|
|
|
|
var_result.pdispVal = i_dispatch;
|
|
|
|
|
2000-04-10 20:21:02 +00:00
|
|
|
for (element=property_reference->elements_list->head; element; element=element->next) {
|
1999-04-21 23:11:20 +00:00
|
|
|
overloaded_property = (zend_overloaded_element *) element->data;
|
|
|
|
switch (overloaded_property->type) {
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_ARRAY:
|
2000-04-10 20:21:02 +00:00
|
|
|
if (do_COM_offget(&var_result, &var_result, &overloaded_property->element, element!=property_reference->elements_list->head)==FAILURE) {
|
2000-04-10 21:54:15 +00:00
|
|
|
var_result.vt = VT_EMPTY;
|
|
|
|
return var_result;
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
/*printf("Array offset: ");*/
|
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_OBJECT:
|
1999-04-21 23:11:20 +00:00
|
|
|
if (var_result.vt != VT_DISPATCH) {
|
2000-04-10 21:54:15 +00:00
|
|
|
var_result.vt = VT_EMPTY;
|
|
|
|
return var_result;
|
1999-04-21 23:11:20 +00:00
|
|
|
} else {
|
2000-04-10 20:21:02 +00:00
|
|
|
if (do_COM_propget(&var_result, var_result.pdispVal, &overloaded_property->element, element!=property_reference->elements_list->head)==FAILURE) {
|
2000-04-10 21:54:15 +00:00
|
|
|
var_result.vt = VT_EMPTY;
|
|
|
|
return var_result;
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
/*printf("Object property: ");*/
|
|
|
|
}
|
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_METHOD:
|
1999-04-21 23:11:20 +00:00
|
|
|
return var_result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
switch (overloaded_property->element.type) {
|
|
|
|
case IS_LONG:
|
|
|
|
printf("%d (numeric)\n", overloaded_property->element.value.lval);
|
|
|
|
break;
|
|
|
|
case IS_STRING:
|
|
|
|
printf("'%s'\n", overloaded_property->element.value.str.val);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
pval_destructor(&overloaded_property->element);
|
|
|
|
}
|
|
|
|
return var_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pval php_COM_get_property_handler(zend_property_reference *property_reference)
|
|
|
|
{
|
|
|
|
pval result;
|
|
|
|
VARIANTARG var_result = _php_COM_get_property_handler(property_reference);
|
|
|
|
|
|
|
|
php_variant_to_pval(&var_result, &result, 0);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int php_COM_set_property_handler(zend_property_reference *property_reference, pval *value)
|
|
|
|
{
|
|
|
|
pval result;
|
|
|
|
zend_overloaded_element *overloaded_property;
|
|
|
|
zend_llist_element *element;
|
|
|
|
pval **idispatch_handle;
|
1999-07-26 16:57:06 +00:00
|
|
|
pval *object = property_reference->object;
|
1999-04-21 23:11:20 +00:00
|
|
|
IDispatch *i_dispatch;
|
|
|
|
int type;
|
|
|
|
VARIANTARG var_result;
|
|
|
|
|
|
|
|
|
|
|
|
/* fetch the IDispatch interface */
|
|
|
|
zend_hash_index_find(object->value.obj.properties, 0, (void **) &idispatch_handle);
|
1999-12-17 19:51:39 +00:00
|
|
|
i_dispatch = zend_list_find((*idispatch_handle)->value.lval,&type);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!i_dispatch || (type!=le_idispatch)) {
|
2000-04-10 21:54:15 +00:00
|
|
|
return FAILURE;
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
var_result.vt = VT_DISPATCH;
|
|
|
|
var_result.pdispVal = i_dispatch;
|
|
|
|
|
2000-04-10 20:21:02 +00:00
|
|
|
for (element=property_reference->elements_list->head; element && element!=property_reference->elements_list->tail; element=element->next) {
|
1999-04-21 23:11:20 +00:00
|
|
|
overloaded_property = (zend_overloaded_element *) element->data;
|
|
|
|
switch (overloaded_property->type) {
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_ARRAY:
|
1999-04-21 23:11:20 +00:00
|
|
|
/*printf("Array offset: ");*/
|
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_OBJECT:
|
1999-04-21 23:11:20 +00:00
|
|
|
if (var_result.vt != VT_DISPATCH) {
|
2000-04-10 21:54:15 +00:00
|
|
|
return FAILURE;
|
1999-04-21 23:11:20 +00:00
|
|
|
} else {
|
2000-04-10 20:21:02 +00:00
|
|
|
do_COM_propget(&var_result, i_dispatch, &overloaded_property->element, element!=property_reference->elements_list->head);
|
1999-04-21 23:11:20 +00:00
|
|
|
/*printf("Object property: ");*/
|
|
|
|
}
|
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_METHOD:
|
1999-04-21 23:11:20 +00:00
|
|
|
/* this shouldn't happen */
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
switch (overloaded_property->element.type) {
|
|
|
|
case IS_LONG:
|
1999-12-03 02:25:22 +00:00
|
|
|
printf("%d (numeric)\n", overloaded_property->element.valuepval_arglval);
|
1999-04-21 23:11:20 +00:00
|
|
|
break;
|
|
|
|
case IS_STRING:
|
|
|
|
printf("'%s'\n", overloaded_property->element.value.str.val);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
pval_destructor(&overloaded_property->element);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (var_result.vt != VT_DISPATCH) {
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
overloaded_property = (zend_overloaded_element *) element->data;
|
|
|
|
do_COM_propput(&result, var_result.pdispVal, &overloaded_property->element, value);
|
|
|
|
pval_destructor(&overloaded_property->element);
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void php_COM_call_function_handler(INTERNAL_FUNCTION_PARAMETERS, zend_property_reference *property_reference)
|
|
|
|
{
|
|
|
|
zend_overloaded_element *overloaded_property;
|
1999-07-26 16:57:06 +00:00
|
|
|
pval *object = property_reference->object;
|
2000-04-10 20:21:02 +00:00
|
|
|
zend_overloaded_element *function_name = (zend_overloaded_element *) property_reference->elements_list->tail->data;
|
1999-04-21 23:11:20 +00:00
|
|
|
|
2000-04-10 20:21:02 +00:00
|
|
|
if (zend_llist_count(property_reference->elements_list)==1
|
1999-04-21 23:11:20 +00:00
|
|
|
&& !strcmp(function_name->element.value.str.val, "com")) { /* constructor */
|
|
|
|
pval *object_handle;
|
|
|
|
|
1999-07-26 20:09:08 +00:00
|
|
|
PHP_FN(COM_load)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
1999-04-21 23:11:20 +00:00
|
|
|
if (!zend_is_true(return_value)) {
|
|
|
|
var_reset(object);
|
|
|
|
return;
|
|
|
|
}
|
1999-12-26 21:21:33 +00:00
|
|
|
ALLOC_ZVAL(object_handle);
|
1999-04-21 23:11:20 +00:00
|
|
|
*object_handle = *return_value;
|
|
|
|
pval_copy_constructor(object_handle);
|
1999-07-09 20:45:55 +00:00
|
|
|
INIT_PZVAL(object_handle);
|
1999-04-21 23:11:20 +00:00
|
|
|
zend_hash_index_update(object->value.obj.properties, 0, &object_handle, sizeof(pval *), NULL);
|
|
|
|
pval_destructor(&function_name->element);
|
|
|
|
} else {
|
|
|
|
VARIANTARG object_handle = _php_COM_get_property_handler(property_reference);
|
|
|
|
pval **arguments;
|
|
|
|
int arg_count = ARG_COUNT(ht);
|
|
|
|
VARIANTARG var_result;
|
|
|
|
|
|
|
|
if (object_handle.vt != VT_DISPATCH) {
|
|
|
|
/* that shouldn't happen */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
arguments = (pval **) emalloc(sizeof(pval *)*arg_count);
|
|
|
|
getParametersArray(ht, arg_count, arguments);
|
|
|
|
|
|
|
|
if (do_COM_invoke((IDispatch *) object_handle.pdispVal, &function_name->element, &var_result, arguments, arg_count)==FAILURE) {
|
|
|
|
RETVAL_FALSE;
|
|
|
|
}
|
|
|
|
pval_destructor(&function_name->element);
|
|
|
|
efree(arguments);
|
|
|
|
php_variant_to_pval(&var_result, return_value, 0);
|
|
|
|
}
|
|
|
|
|
2000-04-10 20:21:02 +00:00
|
|
|
for (overloaded_property = (zend_overloaded_element *) zend_llist_get_first(property_reference->elements_list);
|
1999-04-21 23:11:20 +00:00
|
|
|
overloaded_property;
|
2000-04-10 20:21:02 +00:00
|
|
|
overloaded_property = (zend_overloaded_element *) zend_llist_get_next(property_reference->elements_list)) {
|
1999-04-21 23:11:20 +00:00
|
|
|
switch (overloaded_property->type) {
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_ARRAY:
|
1999-04-21 23:11:20 +00:00
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_OBJECT:
|
1999-04-21 23:11:20 +00:00
|
|
|
break;
|
2000-01-04 13:56:13 +00:00
|
|
|
case OE_IS_METHOD:
|
1999-04-21 23:11:20 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void php_register_COM_class()
|
|
|
|
{
|
1999-05-28 11:09:39 +00:00
|
|
|
INIT_OVERLOADED_CLASS_ENTRY(com_class_entry, "COM", NULL,
|
|
|
|
php_COM_call_function_handler,
|
|
|
|
php_COM_get_property_handler,
|
|
|
|
php_COM_set_property_handler);
|
1999-04-21 23:11:20 +00:00
|
|
|
|
1999-05-28 11:09:39 +00:00
|
|
|
register_internal_class(&com_class_entry);
|
1999-04-21 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int php_COM_load_typelib(char *typelib_name, int mode)
|
|
|
|
{
|
|
|
|
ITypeLib *TypeLib;
|
|
|
|
ITypeComp *TypeComp;
|
|
|
|
OLECHAR *p;
|
|
|
|
int i;
|
|
|
|
int interfaces;
|
|
|
|
ELS_FETCH();
|
|
|
|
|
|
|
|
p = php_char_to_OLECHAR(typelib_name, strlen(typelib_name));
|
|
|
|
|
|
|
|
if (FAILED(LoadTypeLib(p, &TypeLib))) {
|
|
|
|
efree(p);
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
interfaces = TypeLib->lpVtbl->GetTypeInfoCount(TypeLib);
|
|
|
|
|
|
|
|
TypeLib->lpVtbl->GetTypeComp(TypeLib, &TypeComp);
|
|
|
|
for (i=0; i<interfaces; i++) {
|
|
|
|
TYPEKIND pTKind;
|
|
|
|
|
|
|
|
TypeLib->lpVtbl->GetTypeInfoType(TypeLib, i, &pTKind);
|
|
|
|
if (pTKind==TKIND_ENUM) {
|
|
|
|
ITypeInfo *TypeInfo;
|
|
|
|
VARDESC *pVarDesc;
|
|
|
|
UINT NameCount;
|
|
|
|
int j;
|
|
|
|
#if 0
|
|
|
|
BSTR bstr_EnumId;
|
|
|
|
char *EnumId;
|
|
|
|
|
|
|
|
TypeLib->lpVtbl->GetDocumentation(TypeLib, i, &bstr_EnumId, NULL, NULL, NULL);
|
|
|
|
EnumId = php_OLECHAR_to_char(bstr_EnumId, NULL, 0);
|
|
|
|
printf("Enumeration %d - %s:\n", i, EnumId);
|
|
|
|
efree(EnumId);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
TypeLib->lpVtbl->GetTypeInfo(TypeLib, i, &TypeInfo);
|
|
|
|
|
|
|
|
j=0;
|
|
|
|
while (TypeInfo->lpVtbl->GetVarDesc(TypeInfo, j, &pVarDesc)==S_OK) {
|
|
|
|
BSTR bstr_ids;
|
|
|
|
char *ids;
|
|
|
|
zend_constant c;
|
|
|
|
|
|
|
|
TypeInfo->lpVtbl->GetNames(TypeInfo, pVarDesc->memid, &bstr_ids, 1, &NameCount);
|
|
|
|
if (NameCount!=1) {
|
|
|
|
j++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
LocalFree(bstr_ids);
|
|
|
|
ids = php_OLECHAR_to_char(bstr_ids, NULL, 1);
|
|
|
|
c.name_len = strlen(ids)+1;
|
|
|
|
c.name = ids;
|
|
|
|
php_variant_to_pval(pVarDesc->lpvarValue, &c.value, 1);
|
|
|
|
c.flags = mode;
|
|
|
|
|
|
|
|
zend_register_constant(&c ELS_CC);
|
|
|
|
//printf("%s -> %ld\n", ids, pVarDesc->lpvarValue->lVal);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
TypeInfo->lpVtbl->Release(TypeInfo);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TypeLib->lpVtbl->Release(TypeLib);
|
|
|
|
efree(p);
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|