void create_struct_ex(zval *retval, Any *anyval, char *str, int str_len TSRMLS_DC)
{
Reference <XIdlReflection> *x_idl_reflec_p;
int type;
int rsrc_id;
try
{
//restore XIdlReflection resource
x_idl_reflec_p =
(Reference <XIdlReflection> *) zend_list_find(
PUNO_G(x_idl_reflec_rsrc_id),&type);
TEST_PTR(x_idl_reflec_p,);
Reference <XIdlClass> xIdlClass = (*x_idl_reflec_p)->forName(OUString(str,str_len,RTL_TEXTENCODING_ISO_8859_15,OSTRING_TO_OUSTRING_CVTFLAGS));
TEST_PTR(xIdlClass.is(),);
//Reference <XIdlField2> field (xidlfield, UNO_QUERY);
Any any_obj;
xIdlClass->createObject(any_obj);
if(anyval!=NULL)
{
any_obj.setValue((*anyval).getValue(),(*anyval).getValueType());
}
Any *any_obj_p= new Any(any_obj);
TEST_PTR(any_obj_p,);
//init object
object_init_ex (retval, ce_ptr);
puno_class_object *new_struct_p;
new_struct_p =
(puno_class_object *) zend_object_store_get_object(retval TSRMLS_CC);
TEST_PTR(new_struct_p,);
//type is Structs
new_struct_p->type = TypeClass_STRUCT;
//register and store the Any object
rsrc_id = ZEND_REGISTER_RESOURCE (
NULL, any_obj_p,
uno_any_rsrc_dtor);
TEST_PTR(rsrc_id,);
new_struct_p->this_rsrc_id = rsrc_id;
//register and store the XIdlClass Interface
Reference <XIdlClass> *x_idl_class_p=new Reference <XIdlClass> (xIdlClass);
TEST_PTR(x_idl_class_p,);
rsrc_id = ZEND_REGISTER_RESOURCE (
NULL, x_idl_class_p,
uno_refer_rsrc_dtor);
TEST_PTR(rsrc_id,);
new_struct_p->x_idl_class_rsrc_id = rsrc_id;
}
catch(Exception& e)
{
//throw PHP EXCEPTION
zend_throw_exception(zend_exception_get_default(),(char *)OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US).getStr(),0 TSRMLS_CC);
}
}
/* {{{ gmp_zval_binary_ui_op2_ex
Execute GMP binary operation which returns 2 values.
May return GMP resources or longs if operation allows this.
*/
static inline void gmp_zval_binary_ui_op2_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op2_t gmp_op, gmp_binary_ui_op2_t gmp_ui_op, int allow_ui_return, int check_b_zero TSRMLS_DC)
{
mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result1, *gmpnum_result2;
zval r;
int use_ui = 0;
unsigned long long_result = 0;
int arga_tmp = 0, argb_tmp = 0;
FETCH_GMP_ZVAL(gmpnum_a, a_arg, arga_tmp);
if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) {
/* use _ui function */
use_ui = 1;
} else {
FETCH_GMP_ZVAL(gmpnum_b, b_arg, argb_tmp);
}
if(check_b_zero) {
int b_is_zero = 0;
if(use_ui) {
b_is_zero = (Z_LVAL_PP(b_arg) == 0);
} else {
b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0);
}
if(b_is_zero) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
FREE_GMP_TEMP(arga_tmp);
FREE_GMP_TEMP(argb_tmp);
RETURN_FALSE;
}
}
INIT_GMP_NUM(gmpnum_result1);
INIT_GMP_NUM(gmpnum_result2);
if (use_ui && gmp_ui_op) {
if (allow_ui_return) {
long_result = gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
} else {
gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
}
} else {
gmp_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, *gmpnum_b);
}
FREE_GMP_TEMP(arga_tmp);
FREE_GMP_TEMP(argb_tmp);
array_init(return_value);
ZEND_REGISTER_RESOURCE(&r, gmpnum_result1, le_gmp);
add_index_resource(return_value, 0, Z_LVAL(r));
if (use_ui && allow_ui_return) {
mpz_clear(*gmpnum_result2);
add_index_long(return_value, 1, long_result);
} else {
ZEND_REGISTER_RESOURCE(&r, gmpnum_result2, le_gmp);
add_index_resource(return_value, 1, Z_LVAL(r));
}
}
void SerialPort_open_impl(const char *device, GORILLA_METHOD_PARAMETERS) {
zval *zval_win32Handle, *zval_win32CanonicalBuffer;
SerialPort_canonical_buffer *canonical_buffer;
HANDLE win32Handle = NULL;
DCB dcb;
int commError;
int serial_port_fd;
int flags = O_CREAT|O_APPEND|O_RDWR|O_BINARY;
SerialPort_canonical_buffer_alloc_init(canonical_buffer);
zval_win32CanonicalBuffer = SerialPort_property_get__win32CanonicalBuffer(GORILLA_METHOD_PARAM_PASSTHRU);
ZEND_REGISTER_RESOURCE(zval_win32CanonicalBuffer, canonical_buffer, le_CanonicalBuffer);
win32Handle = CreateFile(
device,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if (win32Handle == INVALID_HANDLE_VALUE) {
zend_throw_exception(NULL, "failed to CreateFile()", 346 TSRMLS_CC);
return;
}
zval_win32Handle = SerialPort_property_get__win32Handle(GORILLA_METHOD_PARAM_PASSTHRU);
ZEND_REGISTER_RESOURCE(zval_win32Handle, win32Handle, le_Win32Handle);
serial_port_fd = _open_osfhandle(win32Handle, flags);
if (serial_port_fd == -1) {
zend_throw_exception(NULL, strerror(errno), errno TSRMLS_CC);
return;
}
SerialPort_property_set__streamFd(serial_port_fd, GORILLA_METHOD_PARAM_PASSTHRU);
ClearCommError(win32Handle, &commError, NULL);
SetupComm(win32Handle, 4096, 4096);
if (!PurgeComm(win32Handle, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR)) {
zend_throw_exception(NULL, "failed to PurgeComm()", 3436 TSRMLS_CC);
return;
}
memset(&dcb, 0, sizeof(DCB));
GetCommState(win32Handle, &dcb);
dcb.DCBlength = sizeof(DCB);
dcb.BaudRate = BAUD_RATE_1200;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.ByteSize = 8;
dcb.XonLim = 0;
dcb.XoffLim = 0;
SET_COMM_STATE(win32Handle, &dcb);
SerialPort_setDTR_impl((zend_bool)1, GORILLA_METHOD_PARAM_PASSTHRU);
SerialPort_setRTS_impl((zend_bool)1, GORILLA_METHOD_PARAM_PASSTHRU);
return;
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
swig_object_wrapper *value=NULL;
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=newobject;
if (newobject <= 1) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
value->newobject = 0;
zval *resource;
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
zend_class_entry **ce = NULL;
zval *classname;
MAKE_STD_ZVAL(classname);
/* _p_Foo -> Foo */
ZVAL_STRING(classname, (char*)type->name+3, 1);
/* class names are stored in lowercase */
php_strtolower(Z_STRVAL_PP(&classname), Z_STRLEN_PP(&classname));
if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &ce TSRMLS_CC) != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
FREE_ZVAL(classname);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
static void *_php_create_scws(TSRMLS_D)
{
struct php_scws *ps;
char *ini_cs;
scws_t s;
s = scws_new();
if (s == NULL) {
return NULL;
}
ps = (struct php_scws *)emalloc(sizeof(struct php_scws));
ps->s = s;
ps->zt = NULL;
ps->charset[0] = '\0';
ps->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ps, le_scws);
ini_cs = INI_STR("scws.default.charset");
if (ini_cs != NULL && *ini_cs) {
memset(ps->charset, 0, sizeof(ps->charset));
strncpy(ps->charset, ini_cs, sizeof(ps->charset)-1);
scws_set_charset(s, ps->charset);
}
return ((void *)ps);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void get_item_helper(zval* zrval, CSimpleTypeVar* var, TSRMLS_D)
{
switch(var->type)
{
case CSimpleTypeVar::VAR_STRING:
ZVAL_STRINGL(zrval, var->sval.str, var->sval.str_l, 1);
break;
case CSimpleTypeVar::VAR_LONG:
ZVAL_LONG(zrval, var->lval);
break;
case CSimpleTypeVar::VAR_FLOAT:
ZVAL_DOUBLE(zrval, var->fval);
break;
case CSimpleTypeVar::VAR_ARRAY:
{
zval* zpyarrayres;
MAKE_STD_ZVAL(zpyarrayres);
object_init_ex(zrval, g_CPHPPyArray_class_entry);
ZEND_REGISTER_RESOURCE(zpyarrayres, var->aval, g_pyarrayrtype);
add_property_zval(zrval, "pyarray", zpyarrayres);
ZVAL_DELREF(zpyarrayres);
};
break;
case CSimpleTypeVar::VAR_DICT:
{
zval* zpydictres;
MAKE_STD_ZVAL(zpydictres);
object_init_ex(zrval, g_CPHPPyDict_class_entry);
ZEND_REGISTER_RESOURCE(zpydictres, var->dval, g_pydictrtype);
add_property_zval(zrval, "pydict", zpydictres);
ZVAL_DELREF(zpydictres);
};
break;
default:
ZVAL_NULL(zrval);
};
};
/* {{{ gmp_zval_binary_ui_op_ex
Execute GMP binary operation.
May return GMP resource or long if operation allows this
*/
static inline void gmp_zval_binary_ui_op_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int allow_ui_return, int check_b_zero, int use_sign TSRMLS_DC)
{
mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result;
unsigned long long_result = 0;
int use_ui = 0;
int arga_tmp = 0, argb_tmp = 0;
FETCH_GMP_ZVAL(gmpnum_a, a_arg, arga_tmp);
if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) {
use_ui = 1;
} else {
FETCH_GMP_ZVAL(gmpnum_b, b_arg, argb_tmp);
}
if(check_b_zero) {
int b_is_zero = 0;
if(use_ui) {
b_is_zero = (Z_LVAL_PP(b_arg) == 0);
} else {
b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0);
}
if(b_is_zero) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
FREE_GMP_TEMP(arga_tmp);
FREE_GMP_TEMP(argb_tmp);
RETURN_FALSE;
}
}
INIT_GMP_NUM(gmpnum_result);
if (use_ui && gmp_ui_op) {
if (allow_ui_return) {
long_result = gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
if (use_sign && mpz_sgn(*gmpnum_a) == -1) {
long_result = -long_result;
}
} else {
gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
}
} else {
gmp_op(*gmpnum_result, *gmpnum_a, *gmpnum_b);
}
FREE_GMP_TEMP(arga_tmp);
FREE_GMP_TEMP(argb_tmp);
if (use_ui && allow_ui_return) {
FREE_GMP_NUM(gmpnum_result);
RETURN_LONG((long)long_result);
} else {
ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
}
}
PHP_METHOD(Pinyin, __construct)
{
IPYNotation *pynotation = IPYFactory::getPYInstance();
zval *self = getThis();
zval *z_pinyin;
MAKE_STD_ZVAL(z_pinyin);
ZEND_REGISTER_RESOURCE(z_pinyin, pynotation, le_pinyin_notation_link);
zend_update_property(Z_OBJCE_P(self), self, ZEND_STRL("_pynotation"), z_pinyin TSRMLS_CC);
}
/* {{{ gmp_zval_unary_ui_op
*/
static inline void gmp_zval_unary_ui_op(zval *return_value, zval **a_arg, gmp_unary_ui_op_t gmp_op TSRMLS_DC)
{
mpz_t *gmpnum_result;
convert_to_long_ex(a_arg);
INIT_GMP_NUM(gmpnum_result);
gmp_op(*gmpnum_result, Z_LVAL_PP(a_arg));
ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
}
PHPAPI php_stream_context *php_stream_context_alloc(TSRMLS_D)
{
php_stream_context *context;
context = (php_stream_context*) ecalloc(1, sizeof(php_stream_context));
context->notifier = NULL;
MAKE_STD_ZVAL(context->options);
array_init(context->options);
context->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context(TSRMLS_C));
return context;
}
/* {{{ gmp_zval_unary_op
*/
static inline void gmp_zval_unary_op(zval *return_value, zval **a_arg, gmp_unary_op_t gmp_op TSRMLS_DC)
{
mpz_t *gmpnum_a, *gmpnum_result;
int temp_a;
FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
INIT_GMP_NUM(gmpnum_result);
gmp_op(*gmpnum_result, *gmpnum_a);
FREE_GMP_TEMP(temp_a);
ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
}
/* {{{ proto object _php_create_ffmpeg_frame()
creates an ffmpeg_frame object, adds a ffmpeg_frame resource to the
object, registers the resource and returns a direct pointer to the
resource.
*/
ff_frame_context* _php_create_ffmpeg_frame(INTERNAL_FUNCTION_PARAMETERS)
{
int ret;
ff_frame_context *ff_frame;
ff_frame = _php_alloc_ff_frame();
ret = ZEND_REGISTER_RESOURCE(NULL, ff_frame, le_ffmpeg_frame);
object_init_ex(return_value, ffmpeg_frame_class_entry_ptr);
add_property_resource(return_value, "ffmpeg_frame", ret);
return ff_frame;
}
/* {{{ create_mqseries_bytes_resource
* makes an mqseries_bytes reference, needed when returning message and correlation id's
*/
static zval* create_mqseries_bytes_resource(PMQBYTE bytes, size_t size TSRMLS_DC)
{
mqseries_bytes *pBytes;
zval *z_bytes;
MAKE_STD_ZVAL(z_bytes);
pBytes = (mqseries_bytes *) emalloc(sizeof(mqseries_bytes));
pBytes->bytes = (PMQBYTE) emalloc(size*sizeof(MQBYTE));
memcpy(pBytes->bytes, bytes, size);
ZEND_REGISTER_RESOURCE(z_bytes, pBytes, le_mqseries_bytes);
pBytes->id = Z_RESVAL_P(z_bytes);
return z_bytes;
}
static PHP_FUNCTION(person_create) {
char *name;
int name_len;
long age;
person *new_person;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &name, &name_len, &age) == FAILURE) {
return;
}
new_person = emalloc(sizeof(person));
new_person->name = estrndup(name, name_len);
new_person->name_len = name_len;
new_person->age = age;
ZEND_REGISTER_RESOURCE(return_value, new_person, person_len);
//RETURN_RESOURCE(zend_list_insert(new_person, person_len TSRMLS_CC));
}
/**
* Establish new redis connection
*
* @param {zval} *return_value Result handler
* @param {char*} *host Ip address
* @param {char*} *port Port number
*/
void redis_connect(zval *return_value, char* *host, int *port) {
// Establish redis connection
redisContext *context = redisConnect(*host, *port);
if (context != NULL && context->err) {
// Can not establish connection to redis
zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Connection was refused !", 10001 TSRMLS_CC);
RETURN_FALSE;
} else {
// Create new PHP resource based on redis context information
le_redis = zend_register_list_destructors_ex(NULL, NULL, REDIS_RESOURCE, REDIS_MODULE_ID);
ZEND_REGISTER_RESOURCE(return_value, context, le_redis);
}
}
int connect_pool_perisent(cpClient** cli, zval* zres, int port) {
zend_rsrc_list_entry sock_le;
int ret;
(*cli) = (cpClient*) pecalloc(sizeof (cpClient), 1, 1);
if (cpClient_create((*cli)) < 0) {
zend_error(E_ERROR, "pdo_connect_pool: create sock fail. Error: %s [%d]", strerror(errno), errno);
}
(*cli)->port = port;
ret = cpClient_connect((*cli), "127.0.0.1", (*cli)->port, (float) 100, 0); //所有的操作100s超时
if (ret < 0) {
pefree(*cli, 1);
return -1;
}
sock_le.type = le_cli_connect_pool;
sock_le.ptr = (*cli);
ZEND_REGISTER_RESOURCE(zres, (*cli), le_cli_connect_pool);
char str[100] = {0};
CON_FORMART_KEY(str, (*cli)->port);
zend_hash_update(&EG(persistent_list), str, strlen(str), (void*) &sock_le, sizeof (zend_rsrc_list_entry), NULL);
return 1;
}
static zval * cpConnect_pool_server(zval *data_source)
{
zval *zres = NULL;
cpClient *cli = NULL;
zend_rsrc_list_entry *p_sock_le;
MAKE_STD_ZVAL(zres);
if (zend_hash_find(&EG(persistent_list), Z_STRVAL_P(data_source), Z_STRLEN_P(data_source), (void **) &p_sock_le) == SUCCESS)
{
cli = (cpClient*) p_sock_le->ptr;
ZEND_REGISTER_RESOURCE(zres, cli, le_cli_connect_pool);
}
else
{//create long connect to pool_server
if (connect_pool_perisent(zres, data_source) == NULL)
{// error
efree(zres);
php_error_docref(NULL TSRMLS_CC, E_ERROR, CON_FAIL_MESSAGE);
return NULL;
}
}
return zres;
}
static void* connect_pool_perisent(zval* zres, zval* data_source)
{
// cpLog_init("/tmp/pool_client.log");
zend_rsrc_list_entry sock_le;
int ret;
cpClient* cli = (cpClient*) pecalloc(sizeof (cpClient), 1, 1);
if (cpClient_create(cli) < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "pdo_connect_pool: create sock fail. Error: %s [%d]", strerror(errno), errno);
}
ret = cpClient_connect(cli, "127.0.0.1", 6253, (float) 100, 0); //所有的操作100s超时
if (ret < 0)
{
pefree(cli, 1);
return NULL;
}
sock_le.type = le_cli_connect_pool;
sock_le.ptr = cli;
ZEND_REGISTER_RESOURCE(zres, cli, le_cli_connect_pool);
zend_hash_update(&EG(persistent_list), Z_STRVAL_P(data_source), Z_STRLEN_P(data_source), (void*) &sock_le, sizeof (zend_rsrc_list_entry), NULL);
cli->lock = cpMutexLock;
cli->unLock = cpMutexUnLock;
cpTcpEvent event = {0};
event.type = CP_TCPEVENT_GETFD;
cpClient_send(cli->sock, (char *) &event, sizeof (event), 0);
cpMasterInfo info;
ret = cpClient_recv(cli->sock, &info, sizeof (cpMasterInfo), 1);
if (ret < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "recv from pool server error [%d],%s", errno, strerror(errno));
}
cli->server_fd = info.server_fd;
cpClient_attach_mem();
CONN(cli)->release = CP_FD_RELEASED;
return cli;
}
void* connect_pool_perisent(zval* zres, int port)
{
zend_rsrc_list_entry sock_le;
int ret;
cpClient* cli = (cpClient*) pecalloc(sizeof (cpClient), 1, 1);
if (cpClient_create(cli) < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "pdo_connect_pool: create sock fail. Error: %s [%d]", strerror(errno), errno);
}
cli->port = port;
ret = cpClient_connect(cli, "127.0.0.1", cli->port, (float) 100, 0); //所有的操作100s超时
if (ret < 0)
{
pefree(cli, 1);
return NULL;
}
sock_le.type = le_cli_connect_pool;
sock_le.ptr = cli;
ZEND_REGISTER_RESOURCE(zres, cli, le_cli_connect_pool);
char str[100] = {0};
CON_FORMART_KEY(str, cli->port);
zend_hash_update(&EG(persistent_list), str, strlen(str), (void*) &sock_le, sizeof (zend_rsrc_list_entry), NULL);
return cli;
}
/*
* If type==0, only last line of output is returned (exec)
* If type==1, all lines will be printed and last lined returned (system)
* If type==2, all lines will be saved to given array (exec with &$array)
* If type==3, output will be printed binary, no lines will be saved or returned (passthru)
*
*/
int php_Exec(int type, char *cmd, pval *array, pval *return_value)
{
FILE *fp;
char *buf, *tmp=NULL;
int buflen = 0;
int t, l, output=1;
int overflow_limit, lcmd, ldir;
int rsrc_id;
char *b, *c, *d=NULL;
#if PHP_SIGCHILD
void (*sig_handler)();
#endif
PLS_FETCH();
FLS_FETCH();
buf = (char*) emalloc(EXEC_INPUT_BUF);
if (!buf) {
php_error(E_WARNING, "Unable to emalloc %d bytes for exec buffer", EXEC_INPUT_BUF);
return -1;
}
buflen = EXEC_INPUT_BUF;
if (PG(safe_mode)) {
lcmd = strlen(cmd);
ldir = strlen(PG(safe_mode_exec_dir));
l = lcmd + ldir + 2;
overflow_limit = l;
c = strchr(cmd, ' ');
if (c) *c = '\0';
if (strstr(cmd, "..")) {
php_error(E_WARNING, "No '..' components allowed in path");
efree(buf);
return -1;
}
d = emalloc(l);
strcpy(d, PG(safe_mode_exec_dir));
overflow_limit -= ldir;
b = strrchr(cmd, PHP_DIR_SEPARATOR);
if (b) {
strcat(d, b);
overflow_limit -= strlen(b);
} else {
strcat(d, "/");
strcat(d, cmd);
overflow_limit-=(strlen(cmd)+1);
}
if (c) {
*c = ' ';
strncat(d, c, overflow_limit);
}
tmp = php_escape_shell_cmd(d);
efree(d);
d = tmp;
#if PHP_SIGCHILD
sig_handler = signal (SIGCHLD, SIG_DFL);
#endif
#ifdef PHP_WIN32
fp = VCWD_POPEN(d, "rb");
#else
fp = VCWD_POPEN(d, "r");
#endif
if (!fp) {
php_error(E_WARNING, "Unable to fork [%s]", d);
efree(d);
efree(buf);
#if PHP_SIGCHILD
signal (SIGCHLD, sig_handler);
#endif
return -1;
}
} else { /* not safe_mode */
#if PHP_SIGCHILD
sig_handler = signal (SIGCHLD, SIG_DFL);
#endif
#ifdef PHP_WIN32
fp = VCWD_POPEN(cmd, "rb");
#else
fp = VCWD_POPEN(cmd, "r");
#endif
if (!fp) {
php_error(E_WARNING, "Unable to fork [%s]", cmd);
efree(buf);
#if PHP_SIGCHILD
signal (SIGCHLD, sig_handler);
#endif
return -1;
}
}
buf[0] = '\0';
if (type==2) {
if (Z_TYPE_P(array) != IS_ARRAY) {
pval_destructor(array);
array_init(array);
}
}
/* we register the resource so that case of an aborted connection the
* fd gets pclosed
*/
rsrc_id = ZEND_REGISTER_RESOURCE(NULL, fp, php_file_le_popen());
if (type != 3) {
l=0;
while ( !feof(fp) || l != 0 ) {
l = 0;
/* Read a line or fill the buffer, whichever comes first */
do {
if ( buflen <= (l+1) ) {
buf = erealloc(buf, buflen + EXEC_INPUT_BUF);
if ( buf == NULL ) {
php_error(E_WARNING, "Unable to erealloc %d bytes for exec buffer",
buflen + EXEC_INPUT_BUF);
#if PHP_SIGCHILD
signal (SIGCHLD, sig_handler);
#endif
return -1;
}
buflen += EXEC_INPUT_BUF;
}
if ( fgets(&(buf[l]), buflen - l, fp) == NULL ) {
/* eof */
break;
}
l += strlen(&(buf[l]));
} while ( (l > 0) && (buf[l-1] != '\n') );
if ( feof(fp) && (l == 0) ) {
break;
}
if (type == 1) {
if (output) PUTS(buf);
sapi_flush();
}
else if (type == 2) {
/* strip trailing whitespaces */
l = strlen(buf);
t = l;
while (l-- && isspace((int)buf[l]));
if (l < t) {
buf[l + 1] = '\0';
}
add_next_index_string(array, buf, 1);
}
}
/* strip trailing spaces */
l = strlen(buf);
t = l;
while (l && isspace((int)buf[l - 1])) {
l--;
}
if (l < t) buf[l] = '\0';
/* Return last line from the shell command */
if (PG(magic_quotes_runtime)) {
int len;
tmp = php_addslashes(buf, 0, &len, 0);
RETVAL_STRINGL(tmp,len,0);
} else {
RETVAL_STRINGL(buf,l,1);
}
} else {
int b, i;
while ((b = fread(buf, 1, buflen, fp)) > 0) {
for (i = 0; i < b; i++)
if (output) (void)PUTC(buf[i]);
}
}
/* the zend_list_delete will pclose our popen'ed process */
zend_list_delete(rsrc_id);
#if HAVE_SYS_WAIT_H
if (WIFEXITED(FG(pclose_ret))) {
FG(pclose_ret) = WEXITSTATUS(FG(pclose_ret));
}
#endif
#if PHP_SIGCHILD
signal (SIGCHLD, sig_handler);
#endif
if (d) {
efree(d);
}
efree(buf);
return FG(pclose_ret);
}
PHP_METHOD(swoole_lock, __construct)
{
long type = SW_MUTEX;
char *filelock;
int filelock_len = 0;
int ret;
#ifdef ZTS
if(sw_thread_ctx == NULL)
{
TSRMLS_SET_CTX(sw_thread_ctx);
}
#endif
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ls", &type, &filelock, &filelock_len) == FAILURE)
{
RETURN_FALSE;
}
swLock *lock = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swLock));
if (lock == NULL)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "alloc failed.");
RETURN_FALSE;
}
switch(type)
{
case SW_RWLOCK:
ret = swRWLock_create(lock, 1);
break;
case SW_FILELOCK:
if (filelock_len <= 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "filelock require lock file name.");
RETURN_FALSE;
}
int fd;
if ((fd = open(filelock, O_RDWR | O_CREAT, 0666)) < 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "open file[%s] failed. Error: %s [%d]", filelock, strerror(errno), errno);
RETURN_FALSE;
}
ret = swFileLock_create(lock, fd);
break;
case SW_SEM:
ret = swSem_create(lock, IPC_PRIVATE, 1);
break;
#ifdef HAVE_SPINLOCK
case SW_SPINLOCK:
ret = swSpinLock_create(lock, 1);
break;
#endif
case SW_MUTEX:
default:
ret = swMutex_create(lock, 1);
break;
}
if (ret < 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "create lock failed");
RETURN_FALSE;
}
zval *zres;
MAKE_STD_ZVAL(zres);
ZEND_REGISTER_RESOURCE(zres, lock, le_swoole_lock);
zend_update_property(swoole_lock_class_entry_ptr, getThis(), ZEND_STRL("_lock"), zres TSRMLS_CC);
zval_ptr_dtor(&zres);
RETURN_TRUE;
}
php_stream_filter_status_t userfilter_filter(
php_stream *stream,
php_stream_filter *thisfilter,
php_stream_bucket_brigade *buckets_in,
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
)
{
int ret = PSFS_ERR_FATAL;
zval *obj = &thisfilter->abstract;
zval func_name;
zval retval;
zval args[4];
zval zpropname;
int call_result;
/* the userfilter object probably doesn't exist anymore */
if (CG(unclean_shutdown)) {
return ret;
}
if (!zend_hash_str_exists(Z_OBJPROP_P(obj), "stream", sizeof("stream")-1)) {
zval tmp;
/* Give the userfilter class a hook back to the stream */
php_stream_to_zval(stream, &tmp);
zval_copy_ctor(&tmp);
add_property_zval(obj, "stream", &tmp);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&tmp);
}
ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1);
/* Setup calling arguments */
ZEND_REGISTER_RESOURCE(&args[0], buckets_in, le_bucket_brigade);
ZEND_REGISTER_RESOURCE(&args[1], buckets_out, le_bucket_brigade);
if (bytes_consumed) {
ZVAL_LONG(&args[2], *bytes_consumed);
} else {
ZVAL_NULL(&args[2]);
}
ZVAL_BOOL(&args[3], flags & PSFS_FLAG_FLUSH_CLOSE);
call_result = call_user_function_ex(NULL,
obj,
&func_name,
&retval,
4, args,
0, NULL);
zval_ptr_dtor(&func_name);
if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
convert_to_long(&retval);
ret = (int)Z_LVAL(retval);
} else if (call_result == FAILURE) {
php_error_docref(NULL, E_WARNING, "failed to call filter function");
}
if (bytes_consumed) {
*bytes_consumed = Z_LVAL_P(&args[2]);
}
if (buckets_in->head) {
php_stream_bucket *bucket = buckets_in->head;
php_error_docref(NULL, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
while ((bucket = buckets_in->head)) {
/* Remove unconsumed buckets from the brigade */
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
}
}
if (ret != PSFS_PASS_ON) {
php_stream_bucket *bucket = buckets_out->head;
while (bucket != NULL) {
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
bucket = buckets_out->head;
}
}
/* filter resources are cleaned up by the stream destructor,
* keeping a reference to the stream resource here would prevent it
* from being destroyed properly */
ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, NULL);
zval_ptr_dtor(&zpropname);
zval_ptr_dtor(&args[3]);
zval_ptr_dtor(&args[2]);
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
return ret;
}
ZEND_METHOD(YConsistent,consistent_init){
zval *object = getThis();
conhash *con = conhash_init();
int res_id = ZEND_REGISTER_RESOURCE(NULL,con,le_conhash);
add_property_resource(object,"conhash",res_id);
}
static php_stream_filter *user_filter_factory_create(const char *filtername,
zval *filterparams, int persistent)
{
struct php_user_filter_data *fdat = NULL;
php_stream_filter *filter;
zval obj, zfilter;
zval func_name;
zval retval;
int len;
/* some sanity checks */
if (persistent) {
php_error_docref(NULL, E_WARNING,
"cannot use a user-space filter with a persistent stream");
return NULL;
}
len = (int)strlen(filtername);
/* determine the classname/class entry */
if (NULL == (fdat = zend_hash_str_find_ptr(BG(user_filter_map), (char*)filtername, len))) {
char *period;
/* Userspace Filters using ambiguous wildcards could cause problems.
i.e.: myfilter.foo.bar will always call into myfilter.foo.*
never seeing myfilter.*
TODO: Allow failed userfilter creations to continue
scanning through the list */
if ((period = strrchr(filtername, '.'))) {
char *wildcard = emalloc(len + 3);
/* Search for wildcard matches instead */
memcpy(wildcard, filtername, len + 1); /* copy \0 */
period = wildcard + (period - filtername);
while (period) {
*period = '\0';
strncat(wildcard, ".*", 2);
if (NULL != (fdat = zend_hash_str_find_ptr(BG(user_filter_map), wildcard, strlen(wildcard)))) {
period = NULL;
} else {
*period = '\0';
period = strrchr(wildcard, '.');
}
}
efree(wildcard);
}
if (fdat == NULL) {
php_error_docref(NULL, E_WARNING,
"Err, filter \"%s\" is not in the user-filter map, but somehow the user-filter-factory was invoked for it!?", filtername);
return NULL;
}
}
/* bind the classname to the actual class */
if (fdat->ce == NULL) {
if (NULL == (fdat->ce = zend_lookup_class(fdat->classname))) {
php_error_docref(NULL, E_WARNING,
"user-filter \"%s\" requires class \"%s\", but that class is not defined",
filtername, fdat->classname->val);
return NULL;
}
}
filter = php_stream_filter_alloc(&userfilter_ops, NULL, 0);
if (filter == NULL) {
return NULL;
}
/* create the object */
object_init_ex(&obj, fdat->ce);
/* filtername */
add_property_string(&obj, "filtername", (char*)filtername);
/* and the parameters, if any */
if (filterparams) {
add_property_zval(&obj, "params", filterparams);
} else {
add_property_null(&obj, "params");
}
/* invoke the constructor */
ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1);
call_user_function_ex(NULL,
&obj,
&func_name,
&retval,
0, NULL,
0, NULL);
if (Z_TYPE(retval) != IS_UNDEF) {
if (Z_TYPE(retval) == IS_FALSE) {
/* User reported filter creation error "return false;" */
zval_ptr_dtor(&retval);
/* Kill the filter (safely) */
ZVAL_UNDEF(&filter->abstract);
php_stream_filter_free(filter);
/* Kill the object */
zval_ptr_dtor(&obj);
/* Report failure to filter_alloc */
return NULL;
}
zval_ptr_dtor(&retval);
}
zval_ptr_dtor(&func_name);
/* set the filter property, this will be used during cleanup */
ZEND_REGISTER_RESOURCE(&zfilter, filter, le_userfilters);
ZVAL_COPY_VALUE(&filter->abstract, &obj);
add_property_zval(&obj, "filter", &zfilter);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&zfilter);
return filter;
}
/* {{{ proto object ffmpeg_movie(string filename)
Constructor for ffmpeg_movie objects
*/
FFMPEG_PHP_CONSTRUCTOR(ffmpeg_movie, __construct)
{
int hashkey_length = 0, filename_len;
char *filename = NULL, *fullpath = NULL, *hashkey = NULL;
zend_bool persistent = 0;
ff_movie_context *ffmovie_ctx = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &filename_len, &persistent) != SUCCESS) {
return;
}
if (persistent && !INI_BOOL("ffmpeg.allow_persistent")) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Persistent movies have been disabled in php.ini");
RETURN_FALSE;
}
if (persistent) {
zend_rsrc_list_entry *le;
/* resolve the fully-qualified path name to use as the hash key */
fullpath = expand_filepath(filename, NULL TSRMLS_CC);
hashkey_length = sizeof("ffmpeg-php_")-1 + filename_len;
hashkey = (char *) emalloc(hashkey_length+1);
snprintf(hashkey, hashkey_length, "ffmpeg-php_%s", filename);
/* do we have an existing persistent movie? */
if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, hashkey_length+1, (void**)&le)) {
int type;
if (Z_TYPE_P(le) != le_ffmpeg_pmovie) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to retrieve persistent resource");
efree(hashkey);
RETURN_FALSE;
}
ffmovie_ctx = (ff_movie_context*)le->ptr;
/* sanity check to ensure that the resource is still a valid
* regular resource number */
if (zend_list_find(ffmovie_ctx->rsrc_id, &type) == ffmovie_ctx) {
/* add a reference to the persistent movie */
zend_list_addref(ffmovie_ctx->rsrc_id);
} else {
//php_error_docref(NULL TSRMLS_CC, E_ERROR,
//"Not a valid persistent movie resource");
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL,
ffmovie_ctx, le_ffmpeg_pmovie);
}
} else { /* no existing persistant movie, create one */
zend_rsrc_list_entry new_le;
ffmovie_ctx = _php_alloc_ffmovie_ctx(1);
if (_php_open_movie_file(ffmovie_ctx, filename)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't open movie file %s", filename);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
Z_TYPE(new_le) = le_ffmpeg_pmovie;
new_le.ptr = ffmovie_ctx;
if (FAILURE == zend_hash_update(&EG(persistent_list), hashkey,
hashkey_length+1, (void *)&new_le, sizeof(zend_rsrc_list_entry),
NULL)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent resource");
RETURN_FALSE;
}
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_pmovie);
}
} else {
ffmovie_ctx = _php_alloc_ffmovie_ctx(0);
if (_php_open_movie_file(ffmovie_ctx, filename)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't open movie file %s", filename);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
/* pass NULL for resource result since we're not returning the resource
directly, but adding it to the returned object. */
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_movie);
}
object_init_ex(getThis(), ffmpeg_movie_class_entry_ptr);
add_property_resource(getThis(), "ffmpeg_movie", ffmovie_ctx->rsrc_id);
if (fullpath) {
efree(fullpath);
}
if (hashkey) {
efree(hashkey);
}
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
swig_object_wrapper *value;
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=(newobject & 1);
if ((newobject & 2) == 0) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
zval *resource;
zend_class_entry **ce = NULL;
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
size_t type_name_len;
int result;
const char * p;
/* Namespace__Foo -> Foo */
/* FIXME: ugly and goes wrong for classes with __ in their names. */
while ((p = strstr(type_name, "__")) != NULL) {
type_name = p + 2;
}
type_name_len = strlen(type_name);
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
if (SWIG_PREFIX_LEN > 0) {
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
strcpy(classname, SWIG_PREFIX);
strcpy(classname + SWIG_PREFIX_LEN, type_name);
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
efree(classname);
} else {
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
}
if (result != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/* {{{ proto object ffmpeg_movie(string filename)
Constructor for ffmpeg_movie objects
*/
FFMPEG_PHP_CONSTRUCTOR(ffmpeg_movie, __construct)
{
int persistent = 0, hashkey_length = 0;
char *filename = NULL, *fullpath = NULL, *hashkey = NULL;
zval ***argv;
ff_movie_context *ffmovie_ctx = NULL;
/* retrieve arguments */
argv = (zval ***) safe_emalloc(sizeof(zval **), ZEND_NUM_ARGS(), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), argv) != SUCCESS) {
efree(argv);
php_error_docref(NULL TSRMLS_CC, E_ERROR,
"Error parsing arguments");
}
switch (ZEND_NUM_ARGS()) {
case 2:
convert_to_boolean_ex(argv[1]);
if (! INI_BOOL("ffmpeg.allow_persistent") && Z_LVAL_PP(argv[1])) {
zend_error(E_WARNING,
"Persistent movies have been disabled in php.ini");
break;
}
persistent = Z_LVAL_PP(argv[1]);
/* fallthru */
case 1:
convert_to_string_ex(argv[0]);
filename = Z_STRVAL_PP(argv[0]);
break;
default:
WRONG_PARAM_COUNT;
}
if (persistent) {
list_entry *le;
/* resolve the fully-qualified path name to use as the hash key */
fullpath = expand_filepath(filename, NULL TSRMLS_CC);
hashkey_length = sizeof("ffmpeg-php_")-1 +
strlen(SAFE_STRING(filename));
hashkey = (char *) emalloc(hashkey_length+1);
snprintf(hashkey, hashkey_length, "ffmpeg-php_%s",
SAFE_STRING(filename));
/* do we have an existing persistent movie? */
if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey,
hashkey_length+1, (void**)&le)) {
int type;
if (Z_TYPE_P(le) != le_ffmpeg_pmovie) {
php_error_docref(NULL TSRMLS_CC, E_ERROR,
"Failed to retrieve persistent resource");
}
ffmovie_ctx = (ff_movie_context*)le->ptr;
/* sanity check to ensure that the resource is still a valid
* regular resource number */
if (zend_list_find(ffmovie_ctx->rsrc_id, &type) == ffmovie_ctx) {
/* add a reference to the persistent movie */
zend_list_addref(ffmovie_ctx->rsrc_id);
} else {
//php_error_docref(NULL TSRMLS_CC, E_ERROR,
//"Not a valid persistent movie resource");
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL,
ffmovie_ctx, le_ffmpeg_pmovie);
}
} else { /* no existing persistant movie, create one */
list_entry new_le;
ffmovie_ctx = _php_alloc_ffmovie_ctx(1);
if (_php_open_movie_file(ffmovie_ctx, filename)) {
zend_error(E_WARNING, "Can't open movie file %s", filename);
efree(argv);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
Z_TYPE(new_le) = le_ffmpeg_pmovie;
new_le.ptr = ffmovie_ctx;
if (FAILURE == zend_hash_update(&EG(persistent_list), hashkey,
hashkey_length+1, (void *)&new_le, sizeof(list_entry),
NULL)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Failed to register persistent resource");
}
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx,
le_ffmpeg_pmovie);
}
} else {
ffmovie_ctx = _php_alloc_ffmovie_ctx(0);
if (_php_open_movie_file(ffmovie_ctx, Z_STRVAL_PP(argv[0]))) {
zend_error(E_WARNING, "Can't open movie file %s",
Z_STRVAL_PP(argv[0]));
efree(argv);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
/* pass NULL for resource result since we're not returning the resource
directly, but adding it to the returned object. */
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx,
le_ffmpeg_movie);
}
object_init_ex(getThis(), ffmpeg_movie_class_entry_ptr);
add_property_resource(getThis(), "ffmpeg_movie", ffmovie_ctx->rsrc_id);
efree(argv);
if (fullpath) {
efree(fullpath);
}
if (hashkey) {
efree(hashkey);
}
}
