void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
{
zval *retval_ptr;
zval ***args;
int status;
if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback");
zval_dtor(value);
Z_TYPE_P(value) = IS_NULL;
return;
}
args = safe_emalloc(sizeof(zval **), 1, 0);
args[0] = &value;
status = call_user_function_ex(EG(function_table), NULL, option_array, &retval_ptr, 1, args, 0, NULL TSRMLS_CC);
if (status == SUCCESS && retval_ptr != NULL) {
if (retval_ptr != value) {
zval_dtor(value);
COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
} else {
zval_ptr_dtor(&retval_ptr);
}
} else {
zval_dtor(value);
Z_TYPE_P(value) = IS_NULL;
}
efree(args);
}
/**
* Call single function which requires arbitrary number of parameters
*/
int phalcon_call_func_params(zval *return_value, char *func_name, int func_length, zend_uint param_count, zval *params[], int noreturn, int fcache_pointer TSRMLS_DC){
zval *fn = NULL;
int status = FAILURE;
//zval ***params_array;
zval *local_retval_ptr = NULL;
//int i;
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
PHALCON_ALLOC_ZVAL(fn);
ZVAL_STRINGL(fn, func_name, func_length, 1);
/*status = phalcon_cache_lookup_function(fn, fcache_pointer);
if (status == FAILURE) {
return FAILURE;
}*/
/*if(param_count){
params_array = (zval ***) emalloc(sizeof(zval **)*param_count);
for (i=0; i<param_count; i++) {
params_array[i] = ¶ms[i];
}
} else {
params_array = NULL;
}*/
status = call_user_function(CG(function_table), NULL, fn, return_value, param_count, params TSRMLS_CC);
//status = phalcon_call_user_function_ex(CG(function_table), NULL, fn, &local_retval_ptr, param_count, params_array, 1, NULL, phalcon_fcall_cache[fcache_pointer] TSRMLS_CC);
if (status == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s()", func_name);
return FAILURE;
}
zval_ptr_dtor(&fn);
if (local_retval_ptr) {
COPY_PZVAL_TO_ZVAL(*return_value, local_retval_ptr);
}
if (!noreturn) {
zval_ptr_dtor(&return_value);
}
/*if (params_array) {
efree(params_array);
}*/
return status;
}
static PHP_FUNCTION(hastur_ia_ia)
{
zval **params[2];
char *text;
int text_len;
zval *text_zval;
zval *name_zval;
zval *handler_zval;
zval *retval_ptr;
int i;
MAKE_STD_ZVAL(handler_zval);
MAKE_STD_ZVAL(name_zval);
MAKE_STD_ZVAL(text_zval);
ZVAL_STRING(handler_zval, handler, 1);
ZVAL_STRING(name_zval, god_name, 1);
params[0] = &text_zval;
params[1] = &name_zval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
RETURN_FALSE;
}
ZVAL_STRINGL(text_zval, text, text_len, 1);
char *ntext = Z_STRVAL_P(text_zval);
for (i = 0; i < text_len; i++) {
if (strncmp(ntext + i, "flag", 4) == 0) {
strncpy(ntext + i, "iaia", 4);
}
}
if (call_user_function_ex(EG(function_table), NULL, handler_zval,
&retval_ptr, 2, params, 0, NULL TSRMLS_CC) == SUCCESS) {
if (retval_ptr) {
COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
}
}
FREE_ZVAL(handler_zval);
FREE_ZVAL(name_zval);
}
/**
* This is a function to call PHP functions in a old-style secure way
*/
inline int phalcon_call_func_normal(zval *return_value, char *func_name, int func_length, int noreturn TSRMLS_DC){
zval *fn = NULL;
int status = FAILURE;
zval *local_retval_ptr = NULL;
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
PHALCON_ALLOC_ZVAL(fn);
ZVAL_STRINGL(fn, func_name, func_length, 1);
status = PHALCON_CALL_USER_FUNCTION(CG(function_table), NULL, fn, return_value, 0, NULL TSRMLS_CC);
if (status == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s()", func_name);
}
zval_ptr_dtor(&fn);
if (local_retval_ptr) {
COPY_PZVAL_TO_ZVAL(*return_value, local_retval_ptr);
}
if (!noreturn) {
zval_ptr_dtor(&return_value);
}
if (EG(exception)){
status = FAILURE;
}
if (status == FAILURE) {
phalcon_memory_restore_stack(TSRMLS_C);
}
return status;
}
/**
* Call single function which not requires parameters
*/
int phalcon_call_func(zval *return_value, char *func_name, int func_length, int noreturn, int fcache_pointer TSRMLS_DC){
zval *fn = NULL;
int status = FAILURE;
zval *local_retval_ptr = NULL;
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
PHALCON_ALLOC_ZVAL(fn);
ZVAL_STRINGL(fn, func_name, func_length, 1);
/*status = phalcon_cache_lookup_function(fn, fcache_pointer);
if (status == FAILURE) {
return FAILURE;
}*/
status = call_user_function(CG(function_table), NULL, fn, return_value, 0, NULL TSRMLS_CC);
//status = phalcon_call_user_function_ex(CG(function_table), NULL, fn, &local_retval_ptr, 0, NULL, 1, NULL, phalcon_fcall_cache[fcache_pointer] TSRMLS_CC);
if (status == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s()", func_name);
return FAILURE;
}
zval_ptr_dtor(&fn);
if (local_retval_ptr) {
COPY_PZVAL_TO_ZVAL(*return_value, local_retval_ptr);
}
if (!noreturn) {
zval_ptr_dtor(&return_value);
}
return status;
}
void __function_invoke(zend_fcall_info_cache fcc, zval *obj, zval *return_value, zend_bool dtor TSRMLS_DC, const char *params_format, ...) {
#if PHP_MAJOR_VERSION < 7
zval *retval_ptr = NULL;
zval ***params = NULL;
#else
zval retval;
zval *params = NULL;
#endif
int i;
int result;
int argc;
zend_fcall_info fci;
argc = strlen(params_format);
if (argc) {
#if PHP_MAJOR_VERSION < 7
params = safe_emalloc(sizeof(zval **), argc, 0);
va_list ap;
va_start(ap, params_format);
for (i = 0; i < argc; ++i) {
params[i] = emalloc(sizeof(zval *));
switch (params_format[i]) {
case 's': {
char *str = va_arg(ap, char *);
long len = va_arg(ap, long);
MAKE_STD_ZVAL(*params[i]);
ZVAL_STRINGL(*params[i], str, len, 0);
break;
}
case 'l': {
long l = va_arg(ap, long);
MAKE_STD_ZVAL(*params[i]);
ZVAL_LONG(*params[i], l);
break;
}
case 'd': {
double d = va_arg(ap, double);
MAKE_STD_ZVAL(*params[i]);
ZVAL_DOUBLE(*params[i], d);
break;
}
case 'n': {
MAKE_STD_ZVAL(*params[i]);
ZVAL_NULL(*params[i]);
break;
}
case 'b': {
zend_bool b = va_arg(ap, int);
MAKE_STD_ZVAL(*params[i]);
ZVAL_BOOL(*params[i], b);
break;
}
case 'z': {
zval *v = va_arg(ap, zval *);
if (v) {
Z_ADDREF_P(v);
*params[i] = v;
}
else {
MAKE_STD_ZVAL(*params[i]);
ZVAL_NULL(*params[i]);
}
break;
}
default:
zend_throw_exception_ex(
NULL, 0 TSRMLS_CC,
"Unsupported type:%c in function_invoke",
params_format[i]);
return;
}
}
va_end(ap);
#else
params = safe_emalloc(sizeof(zval), argc, 0);
va_list ap;
va_start(ap, params_format);
for (i = 0; i < argc; ++i) {
switch (params_format[i]) {
case 's': {
char *str = va_arg(ap, char *);
long len = va_arg(ap, long);
ZVAL_STRINGL(¶ms[i], str, len);
break;
}
case 'l': {
long l = va_arg(ap, long);
ZVAL_LONG(¶ms[i], l);
break;
}
case 'd': {
double d = va_arg(ap, double);
ZVAL_DOUBLE(¶ms[i], d);
break;
}
case 'n': {
ZVAL_NULL(¶ms[i]);
break;
}
case 'b': {
zend_bool b = va_arg(ap, int);
ZVAL_BOOL(¶ms[i], b);
break;
}
case 'z': {
zval *v = va_arg(ap, zval *);
if (v) {
ZVAL_COPY(¶ms[i], v);
}
else {
ZVAL_NULL(¶ms[i]);
}
break;
}
default:
zend_throw_exception_ex(
NULL, 0,
"Unsupported type:%c in function_invoke",
params_format[i]);
return;
}
}
va_end(ap);
#endif
}
fci.size = sizeof(fci);
fci.function_table = NULL;
#if PHP_MAJOR_VERSION < 7
fci.function_name = NULL;
fci.retval_ptr_ptr = &retval_ptr;
#else
ZVAL_UNDEF(&fci.function_name);
fci.retval = &retval;
#endif
fci.symbol_table = NULL;
fci.param_count = argc;
fci.params = params;
fci.no_separation = 1;
if (obj != NULL && Z_TYPE_P(obj) == IS_OBJECT) {
#if PHP_API_VERSION < 20090626
fci.object_pp = &obj;
fcc.object_pp = &obj;
#elif PHP_MAJOR_VERSION < 7
fci.object_ptr = obj;
fcc.object_ptr = obj;
#else
fci.object = Z_OBJ_P(obj);
fcc.object = Z_OBJ_P(obj);
#endif
fcc.calling_scope = Z_OBJCE_P(obj);
}
else {
#if PHP_API_VERSION < 20090626
fci.object_pp = fcc.object_pp;
#elif PHP_MAJOR_VERSION < 7
fci.object_ptr = fcc.object_ptr;
#else
fci.object = fcc.object;
#endif
}
#if PHP_MAJOR_VERSION < 7
result = zend_call_function(&fci, &fcc TSRMLS_CC);
for (i = 0; i < argc; i++) {
if (params_format[i] == 's') {
ZVAL_EMPTY_STRING(*params[i]);
}
zval_ptr_dtor(params[i]);
efree(params[i]);
}
if (argc) {
efree(params);
}
if (result == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
"Invocation of function %s() failed",
fcc.function_handler->common.function_name);
return;
}
if (retval_ptr) {
if (return_value) {
if (return_value != retval_ptr) {
if (dtor) {
zval_dtor(return_value);
}
COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
}
else {
if (dtor) {
zval_ptr_dtor(&retval_ptr);
}
}
}
else {
zval_ptr_dtor(&retval_ptr);
}
}
#else
result = zend_call_function(&fci, &fcc);
for (i = 0; i < argc; i++) {
zval_ptr_dtor(¶ms[i]);
}
if (argc) {
efree(params);
}
if (result == FAILURE) {
zend_throw_exception_ex(NULL, 0,
"Invocation of function %s() failed",
fcc.function_handler->common.function_name->val);
return;
}
if (Z_TYPE(retval) != IS_UNDEF) {
if (return_value) {
if (dtor) {
zval_ptr_dtor(return_value);
}
ZVAL_COPY_VALUE(return_value, &retval);
}
else {
zval_ptr_dtor(&retval);
}
}
#endif
}
