X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Fmodule.c;h=873d56bc10192521c211dd55cde3de1e0e6f42f2;hp=0994630984786b3205d33ce08a77cece05c313e7;hb=756a2c4350162a9a7f930bdc0ec7718ff13ea48c;hpb=5d54598329a4d04dd0080bc1252d1de85a7befef diff --git a/src/module.c b/src/module.c index 0994630..873d56b 100644 --- a/src/module.c +++ b/src/module.c @@ -6,6 +6,9 @@ #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" +#include "zend_exceptions.h" +#include "zend_constants.h" +#include "zend_operators.h" #include "php_psi.h" #include "parser.h" @@ -28,6 +31,9 @@ PHP_INI_BEGIN() STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals) PHP_INI_END(); +static zend_object_handlers psi_object_handlers; +static zend_class_entry *psi_class_entry; + void psi_error(int type, const char *msg, ...) { char buf[0x1000]; @@ -151,6 +157,11 @@ size_t psi_num_min_args(impl *impl) return n; } +void psi_to_void(zval *return_value, set_value *set, impl_val *ret_val) +{ + RETVAL_NULL(); +} + void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val) { psi_to_int(return_value, set, ret_val); @@ -263,6 +274,7 @@ void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val) token_t t = real_decl_type(var->arg->type)->type; switch (t) { + case PSI_T_VOID: case PSI_T_INT8: case PSI_T_UINT8: if (!var->arg->var->pointer_level) { @@ -450,15 +462,36 @@ void psi_to_array(zval *return_value, set_value *set, impl_val *r_val) } else { ZEND_ASSERT(0); } +} + +void psi_to_object(zval *return_value, set_value *set, impl_val *r_val) +{ + decl_var *var = set->vars->vars[0]; + impl_val *ret_val = deref_impl_val(r_val, var); + psi_object *obj; + if (ret_val->ptr) { + object_init_ex(return_value, psi_class_entry); + obj = PSI_OBJ(return_value, NULL); + obj->data = ret_val->ptr; + } else { + RETVAL_NULL(); + } } static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl) { impl_arg *iarg; + zend_error_handling zeh; + + zend_replace_error_handling(EH_THROW, zend_exception_get_default(), &zeh); if (!impl->func->args->count) { - return zend_parse_parameters_none(); + ZEND_RESULT_CODE rv; + + rv = zend_parse_parameters_none(); + zend_restore_error_handling(&zeh); + return rv; } ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count) @@ -497,7 +530,9 @@ static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, i } } else if (PSI_T_ARRAY == iarg->type->type) { /* handled as _zv in let or set */ - Z_PARAM_PROLOGUE(0); + Z_PARAM_ARRAY_EX(iarg->_zv, 1, 0); + } else if (PSI_T_OBJECT == iarg->type->type) { + Z_PARAM_OBJECT_EX(iarg->_zv, 1, 0); } else { error_code = ZPP_ERROR_FAILURE; break; @@ -506,24 +541,21 @@ static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, i if (_i < _max_num_args) { goto nextarg; } - ZEND_PARSE_PARAMETERS_END_EX(return FAILURE); + ZEND_PARSE_PARAMETERS_END_EX( + zend_restore_error_handling(&zeh); + return FAILURE + ); + zend_restore_error_handling(&zeh); return SUCCESS; } static inline void *psi_do_calloc(let_calloc *alloc) { - decl_type *type = real_decl_type(alloc->type); - size_t size; - - if (type->type == PSI_T_STRUCT) { - /* psi_do_clean expects at least one NULL pointer after the struct */ - size = type->strct->size + sizeof(void *); - } else { - size = psi_t_size(type->type); - } - - return ecalloc(alloc->n, size); + zend_long n = psi_long_num_exp(alloc->nmemb), s = psi_long_num_exp(alloc->size); + void *mem = safe_emalloc(n, s, sizeof(void *)); + memset(mem, 0, n * s + sizeof(void *)); + return mem; } static inline void *psi_do_let(decl_arg *darg) @@ -565,6 +597,7 @@ static inline void *psi_do_let(decl_arg *darg) arg_val->lval = zval_get_long(iarg->_zv); } break; + case PSI_T_PATHVAL: case PSI_T_STRVAL: if (iarg->type->type == PSI_T_STRING) { arg_val->ptr = estrdup(iarg->val.zend.str->val); @@ -576,6 +609,12 @@ static inline void *psi_do_let(decl_arg *darg) darg->let->mem = arg_val->ptr; zend_string_release(zs); } + if (PSI_T_PATHVAL == darg->let->val->func->type) { + if (SUCCESS != php_check_open_basedir(arg_val->ptr)) { + efree(arg_val->ptr); + return NULL; + } + } break; case PSI_T_STRLEN: if (iarg->type->type == PSI_T_STRING) { @@ -599,6 +638,18 @@ static inline void *psi_do_let(decl_arg *darg) } } break; + case PSI_T_OBJVAL: + if (iarg->type->type == PSI_T_OBJECT) { + psi_object *obj; + + if (!instanceof_function(Z_OBJCE_P(iarg->_zv), psi_class_entry)) { + return NULL; + } + + obj = PSI_OBJ(iarg->_zv, NULL); + arg_val->ptr = obj->data; + } + break; EMPTY_SWITCH_DEFAULT_CASE(); } } @@ -678,6 +729,134 @@ static inline void psi_do_clean(impl *impl) } } + +#define PSI_CALC_OP(var) res->var = PSI_CALC(v1->var, v2->var) +#define PSI_CALC_OP2(vres, var1, var2) res->vres = PSI_CALC(v1->var1, v2->var2) + +int psi_calc_plus(unsigned char t1, impl_val *v1, unsigned char t2, impl_val *v2, impl_val *res) +{ +#undef PSI_CALC +#define PSI_CALC(var1, var2) (var1) + (var2) + if (t1 == t2) { + switch (t1) { + case PSI_T_FLOAT: PSI_CALC_OP(fval); break; + case PSI_T_DOUBLE: PSI_CALC_OP(dval); break; + case PSI_T_INT8: PSI_CALC_OP(i8); break; + case PSI_T_UINT8: PSI_CALC_OP(u8); break; + case PSI_T_INT16: PSI_CALC_OP(i16); break; + case PSI_T_UINT16: PSI_CALC_OP(u16); break; + case PSI_T_INT32: PSI_CALC_OP(i32); break; + case PSI_T_UINT32: PSI_CALC_OP(u32); break; + case PSI_T_INT64: PSI_CALC_OP(i64); break; + case PSI_T_UINT64: PSI_CALC_OP(u64); break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return t1; + } else if (t1 == PSI_T_DOUBLE) { + switch (t2) { + case PSI_T_FLOAT: PSI_CALC_OP2(dval, dval, fval); break; + case PSI_T_INT8: PSI_CALC_OP2(dval, dval, i8); break; + case PSI_T_UINT8: PSI_CALC_OP2(dval, dval, u8); break; + case PSI_T_INT16: PSI_CALC_OP2(dval, dval, i16); break; + case PSI_T_UINT16: PSI_CALC_OP2(dval, dval, u16); break; + case PSI_T_INT32: PSI_CALC_OP2(dval, dval, i32); break; + case PSI_T_UINT32: PSI_CALC_OP2(dval, dval, u32); break; + case PSI_T_INT64: PSI_CALC_OP2(dval, dval, i64); break; + case PSI_T_UINT64: PSI_CALC_OP2(dval, dval, u64); break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return t1; + } else if (t2 == PSI_T_DOUBLE) { + switch (t1) { + case PSI_T_FLOAT: PSI_CALC_OP2(dval, fval, dval); break; + case PSI_T_INT8: PSI_CALC_OP2(dval, i8, dval); break; + case PSI_T_UINT8: PSI_CALC_OP2(dval, u8, dval); break; + case PSI_T_INT16: PSI_CALC_OP2(dval, i16, dval); break; + case PSI_T_UINT16: PSI_CALC_OP2(dval, u16, dval); break; + case PSI_T_INT32: PSI_CALC_OP2(dval, i32, dval); break; + case PSI_T_UINT32: PSI_CALC_OP2(dval, u32, dval); break; + case PSI_T_INT64: PSI_CALC_OP2(dval, i64, dval); break; + case PSI_T_UINT64: PSI_CALC_OP2(dval, u64, dval); break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return t2; + } else if (t1 == PSI_T_FLOAT) { + switch (t2) { + case PSI_T_DOUBLE: PSI_CALC_OP2(dval, fval, dval); return t2; + case PSI_T_INT8: PSI_CALC_OP2(fval, fval, i8); break; + case PSI_T_UINT8: PSI_CALC_OP2(fval, fval, u8); break; + case PSI_T_INT16: PSI_CALC_OP2(fval, fval, i16); break; + case PSI_T_UINT16: PSI_CALC_OP2(fval, fval, u16); break; + case PSI_T_INT32: PSI_CALC_OP2(fval, fval, i32); break; + case PSI_T_UINT32: PSI_CALC_OP2(fval, fval, u32); break; + case PSI_T_INT64: PSI_CALC_OP2(fval, fval, i64); break; + case PSI_T_UINT64: PSI_CALC_OP2(fval, fval, u64); break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return t1; + } else if (t2 == PSI_T_FLOAT) { + switch (t1) { + case PSI_T_DOUBLE: PSI_CALC_OP2(dval, dval, fval); return t1; + case PSI_T_INT8: PSI_CALC_OP2(fval, i8, fval); break; + case PSI_T_UINT8: PSI_CALC_OP2(fval, u8, fval); break; + case PSI_T_INT16: PSI_CALC_OP2(fval, i16, fval); break; + case PSI_T_UINT16: PSI_CALC_OP2(fval, u16, fval); break; + case PSI_T_INT32: PSI_CALC_OP2(fval, i32, fval); break; + case PSI_T_UINT32: PSI_CALC_OP2(fval, u32, fval); break; + case PSI_T_INT64: PSI_CALC_OP2(fval, i64, fval); break; + case PSI_T_UINT64: PSI_CALC_OP2(fval, u64, fval); break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return t2; + } else { + int64_t sval1 = v1->i64, sval2 = v2->i64; + uint64_t uval1 = v1->u64, uval2 = v2->u64; + + switch (t1) { + case PSI_T_INT8: sval1 >>= 8; + case PSI_T_INT16: sval1 >>= 8; + case PSI_T_INT32: sval1 >>= 8; + case PSI_T_INT64: + switch (t2) { + case PSI_T_INT8: sval2 >>= 8; + case PSI_T_INT16: sval2 >>= 8; + case PSI_T_INT32: sval2 >>= 8; + case PSI_T_INT64: + res->i64 = PSI_CALC(sval1 , sval2); + return PSI_T_INT64; + case PSI_T_UINT8: uval2 >>= 8; + case PSI_T_UINT16: uval2 >>= 8; + case PSI_T_UINT32: uval2 >>= 8; + case PSI_T_UINT64: + res->i64 = PSI_CALC(sval1, uval2); + return PSI_T_INT64; + } + break; + case PSI_T_UINT8: uval1 >>= 8; + case PSI_T_UINT16: uval1 >>= 8; + case PSI_T_UINT32: uval1 >>= 8; + case PSI_T_UINT64: + switch (t2) { + case PSI_T_INT8: sval2 >>= 8; + case PSI_T_INT16: sval2 >>= 8; + case PSI_T_INT32: sval2 >>= 8; + case PSI_T_INT64: + res->i64 = PSI_CALC(uval1, sval2); + return PSI_T_INT64; + case PSI_T_UINT8: uval2 >>= 8; + case PSI_T_UINT16: uval2 >>= 8; + case PSI_T_UINT32: uval2 >>= 8; + case PSI_T_UINT64: + res->u64 = PSI_CALC(uval1, uval2); + return PSI_T_UINT64; + } + break; + } + } + ZEND_ASSERT(0); + return 0; +} + void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl) { impl_val ret_val; @@ -691,7 +870,9 @@ void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl) for (i = 0; i < impl->decl->args->count; ++i) { decl_arg *darg = impl->decl->args->args[i]; - impl->decl->call.args[i] = psi_do_let(darg); + if (!(impl->decl->call.args[i] = psi_do_let(darg))) { + goto cleanup; + } } } @@ -713,16 +894,52 @@ void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl) psi_do_free(fre); } + psi_do_clean(impl); + return; +cleanup: + memset(&ret_val, 0, sizeof(ret_val)); + psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val); psi_do_clean(impl); } +static void psi_object_free(zend_object *o) +{ + psi_object *obj = PSI_OBJ(NULL, o); + + if (obj->data) { + // free(obj->data); + obj->data = NULL; + } + zend_object_std_dtor(o); +} + +static zend_object *psi_object_init(zend_class_entry *ce) +{ + psi_object *o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce)); + + zend_object_std_init(&o->std, ce); + object_properties_init(&o->std, ce); + o->std.handlers = &psi_object_handlers; + return &o->std; +} + PHP_MINIT_FUNCTION(psi) { PSI_ContextOps *ops = NULL; + zend_class_entry ce = {0}; REGISTER_INI_ENTRIES(); + INIT_NS_CLASS_ENTRY(ce, "psi", "object", NULL); + psi_class_entry = zend_register_internal_class_ex(&ce, NULL); + psi_class_entry->create_object = psi_object_init; + + memcpy(&psi_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + psi_object_handlers.offset = XtOffsetOf(psi_object, std); + psi_object_handlers.free_obj = psi_object_free; + psi_object_handlers.clone_obj = NULL; + #ifdef HAVE_LIBJIT if (!strcasecmp(PSI_G(engine), "jit")) { ops = PSI_Libjit(); @@ -740,7 +957,7 @@ PHP_MINIT_FUNCTION(psi) PSI_ContextInit(&PSI_G(context), ops, psi_error); PSI_ContextBuild(&PSI_G(context), PSI_G(directory)); - if (getenv("PSI_DUMP")) { + if (psi_check_env("PSI_DUMP")) { PSI_ContextDump(&PSI_G(context), STDOUT_FILENO); }