static zval *oauth_provider_call_cb(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
{
php_oauth_provider *sop;
php_oauth_provider_fcall *cb = NULL;
zval args, *pthis;
char *errstr = "";
zend_string *callable = NULL;
pthis = getThis();
sop = fetch_sop_object(pthis);
switch(type) {
case OAUTH_PROVIDER_CONSUMER_CB:
cb = sop->consumer_handler;
errstr = "Consumer key/secret handler not specified, did you set a valid callback via OAuthProvider::consumerHandler()?";
break;
case OAUTH_PROVIDER_TOKEN_CB:
cb = sop->token_handler;
errstr = "Token handler not specified, did you set a valid callback via OAuthProvider::tokenHandler()?";
break;
case OAUTH_PROVIDER_TSNONCE_CB:
cb = sop->tsnonce_handler;
errstr = "Timestamp/nonce handler not specified, did you set a valid callback via OAuthProvider::timestampNonceHandler()?";
break;
default:
php_error_docref(NULL, E_ERROR, "Invalid callback type for OAuthProvider");
return NULL;
}
if(!cb) {
php_error_docref(NULL, E_ERROR, "%s", errstr);
return NULL;
}
array_init(&args);
add_next_index_zval(&args, pthis);
Z_ADDREF_P(pthis);
Z_ADDREF(args);
errstr = NULL;
if (!zend_is_callable(&cb->fcall_info->function_name, 0, &callable)) {
if (errstr) {
php_error_docref(NULL, E_WARNING, "Invalid callback: %s, %s", Z_STRVAL(cb->fcall_info->function_name), errstr);
efree(errstr);
} else {
php_error_docref(NULL, E_WARNING, "Invalid callback: %s.", Z_STRVAL(cb->fcall_info->function_name));
}
} else if (errstr) {
php_error_docref(NULL, E_WARNING, "%s", errstr);
efree(errstr);
}
if (zend_fcall_info_call(cb->fcall_info, &cb->fcall_info_cache, return_value, &args)!=SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed calling callback %s", Z_STRVAL(cb->fcall_info->function_name));
}
zval_ptr_dtor(&args);
return return_value;
}
int wkhtmltox_set_object_params(void *settings, fp set_function, zval *params, zval *input)
{
zval **data;
HashTable *params_hash;
HashPosition pointer;
int params_count;
char *key;
int key_len;
long index;
int page = 0;
int html = 0;
params_hash = Z_ARRVAL_P(params);
params_count = zend_hash_num_elements(params_hash);
for(zend_hash_internal_pointer_reset_ex(params_hash, &pointer);
zend_hash_get_current_data_ex(params_hash, (void **)&data, &pointer) == SUCCESS;
zend_hash_move_forward_ex(params_hash, &pointer)) {
zval temp = **data;
zval_copy_ctor(&temp);
if (zend_hash_get_current_key_ex(params_hash, &key, &key_len, &index, 0, &pointer) == HASH_KEY_IS_STRING) {
switch (Z_TYPE(temp)) {
case IS_BOOL:
set_function(settings, key, Z_BVAL(temp) ? "true" : "false");
break;
default:
convert_to_string(&temp);
case IS_STRING:
if (strcmp(key, "page") == 0 || strcmp(key, "out") == 0) {
//TODO do checking of page/out url/file according to php security settings like open_basedir, allow_url_fopen a.s.o
// php main fopenwrapper ?! php_check_specific_open_basedir php_check_open_basedir
//php_printf("key: %s, val: %s\n", key, Z_STRVAL(temp));
}
if (strcmp(key, "page") == 0 && Z_STRLEN(temp) > 0) {
page = 1;
}
if (strcmp(key, "html") == 0 && Z_STRLEN(temp) > 0) {
ZVAL_STRING(input, Z_STRVAL(temp), 1);
html = 1;
}
set_function(settings, key, Z_STRVAL(temp));
break;
}
}
zval_dtor(&temp);
}
if (page == 1) {
return 0;
} else if (page == 0 && html == 1) {
return 1;
} else {
return 2;
}
}
/**
* Convert a php Array to a map
*
* @param t the php Array to convert
* @return the created map
*/
map* php_map_from_HasTable(HashTable* t){
#ifdef DEBUG
fprintf(stderr,"mapsFromPHPArray start\n");
#endif
map* final_res=(map*)malloc(MAP_SIZE);
final_res=NULL;
char key[1024];
for(zend_hash_internal_pointer_reset(t);
zend_hash_has_more_elements(t) == SUCCESS;
zend_hash_move_forward(t)) {
char *key;
uint keylen;
ulong idx;
int type;
int len;
zval **ppzval, tmpcopy;
type = zend_hash_get_current_key_ex(t, &key, &keylen, &idx, 0, NULL);
if (zend_hash_get_current_data(t, (void**)&ppzval) == FAILURE) {
/* Should never actually fail * since the key is known to exist. */
continue;
}
/**
* Duplicate the zval so that * the orignal’s contents are not destroyed
*/
tmpcopy = **ppzval;
zval_copy_ctor(&tmpcopy);
/**
* Reset refcount & Convert
*/
INIT_PZVAL(&tmpcopy);
convert_to_string(&tmpcopy);
if(strncmp(key,"value",5)==0){
len=Z_STRLEN_P(&tmpcopy);
final_res = addToMapWithSize(final_res,key,Z_STRVAL_P(&tmpcopy),len);
}
else{
if(final_res==NULL){
#ifdef DEBUG
fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy));
#endif
final_res=createMap(key,Z_STRVAL(tmpcopy));
}
else{
#ifdef DEBUG
fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy));
#endif
addToMap(final_res,key,Z_STRVAL(tmpcopy));
}
}
/* Toss out old copy */
zval_dtor(&tmpcopy);
}
return final_res;
}
static int ZEND_DECLARE_INHERITED_CLASS_DELAYED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_class_entry **pce, **pce_orig;
if (zend_hash_find(EG(class_table), Z_STRVAL(EX(opline)->op2.u.constant), Z_STRLEN(EX(opline)->op2.u.constant) + 1, (void **)&pce) == FAILURE ||
(zend_hash_find(EG(class_table), Z_STRVAL(EX(opline)->op1.u.constant), Z_STRLEN(EX(opline)->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
*pce != *pce_orig)) {
do_bind_inherited_class(EX(opline), EG(class_table), EX_T(EX(opline)->extended_value).class_entry, 0 TSRMLS_CC);
}
EX(opline)++;
return ZEND_USER_OPCODE_CONTINUE;
}
char *
get_constant_string(char *key)
{
zval zkey;
zval zvalue;
ZVAL_STRING(&zkey, key, 0);
if (!zend_get_constant(Z_STRVAL(zkey), Z_STRLEN(zkey), &zvalue TSRMLS_CC)) {
zend_error(E_ERROR, "get_constant_long(): Cannot find symbol %s, is this function called inside an initialized Phorum environment?", key);
}
convert_to_string(&zvalue);
return Z_STRVAL(zvalue);
}
/* Lookup a key from the $PHORUM["args"] array. */
zval *
get_PHORUM_args(char *key)
{
HashTable *args = NULL;
zval zkey;
zval **P;
/* Lookup the $PHORUM["args"] variable. */
zval *A = get_PHORUM("args");
if (A == NULL) {
zend_error(E_ERROR, "PHORUM(): Cannot find symbol $PHORUM[args]");
}
args = Z_ARRVAL_P(A);
/* Lookup the key in the args table. */
ZVAL_STRING(&zkey, key, 1);
if (zend_hash_find(args, Z_STRVAL(zkey), Z_STRLEN(zkey)+1, (void**)&P) == FAILURE) {
convert_to_long(&zkey);
if (zend_hash_index_find(args, Z_LVAL(zkey), (void**)&P) == FAILURE) {
return NULL;
}
}
return *P;
}
int GetString(structlpsolvecaller *lpsolvecaller, pMatrix ppm, int element, char *buf, int size, int ShowError)
{
int size1;
zval arg;
ZVAL_UNDEF(&arg);
if (ppm != NULL) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
arg = GetpMatrix(lpsolvecaller, element);
if ((!Z_ISUNDEF(arg)) && (Z_TYPE(arg) != IS_STRING)) {
ZVAL_UNDEF(&arg);
}
if (Z_ISUNDEF(arg)) {
if (ShowError)
ErrMsgTxt(lpsolvecaller, "Expecting a character element");
return(FALSE);
}
size1 = Z_STRLEN(arg);
if (size1 < size)
size = size1;
memcpy(buf, Z_STRVAL(arg), size);
buf[size] = 0;
return(TRUE);
}
/**
* Load config file
*
* @param string $filePath
*/
PHP_METHOD(Phalcon_Config_Adapter_Php, read){
zval *file_path, *absolute_path = NULL, config_dir_path = {}, *base_path, config = {};
phalcon_fetch_params(0, 1, 1, &file_path, &absolute_path);
PHALCON_ENSURE_IS_STRING(file_path);
if (absolute_path == NULL) {
absolute_path = &PHALCON_GLOBAL(z_false);
}
if (zend_is_true(absolute_path)) {
PHALCON_CPY_WRT(&config_dir_path, file_path);
} else {
base_path = phalcon_read_static_property_ce(phalcon_config_adapter_ce, SL("_basePath"));
PHALCON_CONCAT_VV(&config_dir_path, base_path, file_path);
}
if (phalcon_require_ret(&config, Z_STRVAL(config_dir_path)) == FAILURE) {
zend_throw_exception_ex(phalcon_config_exception_ce, 0, "Configuration file '%s' cannot be read", Z_STRVAL(config_dir_path));
PHALCON_PTR_DTOR(&config_dir_path);
return;
}
PHALCON_PTR_DTOR(&config_dir_path);
if (Z_TYPE(config) == IS_ARRAY) {
PHALCON_CALL_METHODW(NULL, getThis(), "val", &config);
}
PHALCON_PTR_DTOR(&config);
RETURN_THISW();
}
void refill() {
assert(buffer_used == 0);
zval retval;
zval args[1];
zval funcname;
ZVAL_NULL(&retval);
ZVAL_LONG(&args[0], buffer_size);
ZVAL_STRING(&funcname, "read");
call_user_function(EG(function_table), &(this->t), &funcname, &retval, 1, args);
zval_dtor(&args[0]);
zval_dtor(&funcname);
if (EG(exception)) {
zval_dtor(&retval);
zend_object *ex = EG(exception);
EG(exception) = nullptr;
throw PHPExceptionWrapper(ex);
}
buffer_used = Z_STRLEN(retval);
memcpy(buffer, Z_STRVAL(retval), buffer_used);
zval_dtor(&retval);
buffer_ptr = buffer;
}
/**
* Execute a render.
*
* @param string $type
* @param int $quality
* @return string
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, _render) {
zval *extension, *quality = NULL, *interlacing = NULL, ret = {}, type = {}, mime = {}, image = {}, tmp = {};
const char *func_name = "imagegif";
char *ext;
phalcon_fetch_params(0, 1, 2, &extension, &quality, &interlacing);
phalcon_fast_strtolower(&ret, extension);
ext = Z_STRVAL(ret);
if (strcmp(ext, "gif") == 0) {
ZVAL_LONG(&type, 1);
func_name = "imagegif";
} else if (strcmp(ext, "jpg") == 0 || strcmp(ext, "jpeg") == 0) {
ZVAL_LONG(&type, 2);
func_name = "imagejpeg";
} else if (strcmp(ext, "png") == 0) {
ZVAL_LONG(&type, 3);
func_name = "imagepng";
} else {
zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support '%s' images", Z_STRVAL_P(extension));
return;
}
phalcon_return_property(&image, getThis(), SL("_image"));
if (interlacing && Z_TYPE_P(interlacing) >= IS_NULL && Z_LVAL(type) > 1) {
if (zend_is_true(interlacing)) {
PHALCON_CALL_FUNCTIONW(NULL, "imageinterlace", &image, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CALL_FUNCTIONW(NULL, "imageinterlace", &image, &PHALCON_GLOBAL(z_zero));
}
}
phalcon_ob_start();
if (Z_LVAL(type) == 1 || !quality || Z_TYPE_P(quality) == IS_NULL) {
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image);
} else {
if (Z_LVAL(type) == 3) {
ZVAL_LONG(&tmp, ceil(Z_LVAL_P(quality)/100*9));
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, &PHALCON_GLOBAL(z_null), &tmp);
} else {
PHALCON_CALL_FUNCTIONW(&ret, func_name, &image, &PHALCON_GLOBAL(z_null), quality);
}
}
phalcon_ob_get_contents(return_value);
phalcon_ob_end_clean();
if (zend_is_true(&ret)) {
phalcon_update_property_zval(getThis(), SL("_type"), &type);
PHALCON_CALL_FUNCTIONW(&mime, "image_type_to_mime_type", &type);
phalcon_update_property_zval(getThis(), SL("_mime"), &mime);
}
return;
}
/**
* Checks whether put has certain index
*
* @param string $name
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Request, hasPut)
{
zval *name, is_put = {}, put = {}, raw = {}, new_put = {};
char *tmp;
phalcon_fetch_params(0, 1, 0, &name);
PHALCON_CALL_METHODW(&is_put, getThis(), "isput");
if (!zend_is_true(&is_put)) {
phalcon_read_global_str(&new_put, SL("_PUT"));
} else {
phalcon_read_property(&put, getThis(), SL("_put"), PH_NOISY);
if (Z_TYPE(put) != IS_ARRAY) {
PHALCON_CALL_METHODW(&raw, getThis(), "getrawbody");
array_init(&new_put);
PHALCON_ENSURE_IS_STRING(&raw);
tmp = estrndup(Z_STRVAL(raw), Z_STRLEN(raw));
sapi_module.treat_data(PARSE_STRING, tmp, &new_put);
phalcon_update_property_zval(getThis(), SL("_put"), &new_put);
} else {
PHALCON_CPY_WRT(&new_put, &put);
}
}
RETVAL_BOOL(phalcon_array_isset(&new_put, name));
}
/**
* Decrypt a text that is coded as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decryptBase64){
zval *text, *key = NULL, *safe = NULL, decrypt_text = {}, decrypt_value = {};
phalcon_fetch_params(0, 1, 2, &text, &key, &safe);
PHALCON_ENSURE_IS_STRING(text);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = &PHALCON_GLOBAL(z_false);
}
if (zend_is_true(safe)) {
ZVAL_NEW_STR(&decrypt_text, zend_string_dup(Z_STR_P(text), 0));
php_strtr(Z_STRVAL(decrypt_text), Z_STRLEN(decrypt_text), "-_", "+/", 2);
} else {
PHALCON_CPY_WRT_CTOR(&decrypt_text, text);
}
phalcon_base64_decode(&decrypt_value, &decrypt_text);
PHALCON_RETURN_CALL_METHODW(getThis(), "decrypt", &decrypt_value, key);
}
/* call userland key extraction function */
char *
ra_call_extractor(RedisArray *ra, const char *key, int key_len, int *out_len) {
char *out;
zval z_ret;
zval z_argv0;
/* check that we can call the extractor function */
if (!zend_is_callable_ex(&ra->z_fun, NULL, 0, NULL, NULL, NULL)) {
php_error_docref(NULL, E_ERROR, "Could not call extractor function");
return NULL;
}
//convert_to_string(ra->z_fun);
/* call extraction function */
ZVAL_STRINGL(&z_argv0, key, key_len);
call_user_function(EG(function_table), NULL, &ra->z_fun, &z_ret, 1, &z_argv0);
efree(&z_argv0);
if (Z_TYPE(z_ret) != IS_STRING) {
zval_dtor(&z_ret);
return NULL;
}
*out_len = Z_STRLEN(z_ret);
out = emalloc(*out_len + 1);
out[*out_len] = 0;
memcpy(out, Z_STRVAL(z_ret), *out_len);
zval_dtor(&z_ret);
return out;
}
/* {{{ zend_user_serialize */
ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data)
{
zend_class_entry * ce = Z_OBJCE_P(object);
zval retval;
int result;
zend_call_method_with_0_params(object, ce, &ce->serialize_func, "serialize", &retval);
if (Z_TYPE(retval) == IS_UNDEF || EG(exception)) {
result = FAILURE;
} else {
switch(Z_TYPE(retval)) {
case IS_NULL:
/* we could also make this '*buf_len = 0' but this allows to skip variables */
zval_ptr_dtor(&retval);
return FAILURE;
case IS_STRING:
*buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
*buf_len = Z_STRLEN(retval);
result = SUCCESS;
break;
default: /* failure */
result = FAILURE;
break;
}
zval_ptr_dtor(&retval);
}
if (result == FAILURE && !EG(exception)) {
zend_throw_exception_ex(NULL, 0, "%s::serialize() must return a string or NULL", ce->name->val);
}
return result;
}
void refill() {
assert(buffer_used == 0);
zval retval;
ZVAL_NULL(&retval);
zval *args[1];
MAKE_STD_ZVAL(args[0]);
ZVAL_LONG(args[0], buffer_size);
TSRMLS_FETCH();
zval funcname;
ZVAL_STRING(&funcname, "read", 0);
call_user_function(EG(function_table), &t, &funcname, &retval, 1, args TSRMLS_CC);
zval_ptr_dtor(args);
if (EG(exception)) {
zval_dtor(&retval);
zval* ex = EG(exception);
EG(exception) = NULL;
throw PHPExceptionWrapper(ex);
}
buffer_used = Z_STRLEN(retval);
memcpy(buffer, Z_STRVAL(retval), buffer_used);
zval_dtor(&retval);
buffer_ptr = buffer;
}
static isc_callback _php_ibase_callback(ibase_event *event, /* {{{ */
unsigned short buffer_size, char *result_buf)
{
zval *res;
/* this function is called asynchronously by the Interbase client library. */
TSRMLS_FETCH_FROM_CTX(event->thread_ctx);
/**
* The callback function is called when the event is first registered and when the event
* is cancelled. I consider this is a bug. By clearing event->callback first and setting
* it to -1 later, we make sure nothing happens if no event was actually posted.
*/
switch (event->state) {
unsigned short i;
unsigned long occurred_event[15];
zval return_value, args[2];
default: /* == DEAD */
break;
case ACTIVE:
/* copy the updated results into the result buffer */
memcpy(event->result_buffer, result_buf, buffer_size);
res = zend_hash_index_find(&EG(regular_list), event->link_res_id);
ZVAL_RES(&args[1], Z_RES_P(res));
/* find out which event occurred */
isc_event_counts(occurred_event, buffer_size, event->event_buffer, event->result_buffer);
for (i = 0; i < event->event_count; ++i) {
if (occurred_event[i]) {
ZVAL_STRING(&args[0], event->events[i]);
efree(event->events[i]);
break;
}
}
/* call the callback provided by the user */
if (SUCCESS != call_user_function(EG(function_table), NULL,
&event->callback, &return_value, 2, args)) {
_php_ibase_module_error("Error calling callback %s", Z_STRVAL(event->callback));
break;
}
if (Z_TYPE(return_value) == IS_FALSE) {
event->state = DEAD;
break;
}
case NEW:
/* re-register the event */
if (isc_que_events(IB_STATUS, &event->link->handle, &event->event_id, buffer_size,
event->event_buffer,(isc_callback)_php_ibase_callback, (void *)event)) {
_php_ibase_error();
}
event->state = ACTIVE;
}
return 0;
}
inline int sw_zend_hash_get_current_key(HashTable *ht, char **key, uint32_t *keylen, ulong *num)
{
zval str_key;
int type = zend_hash_get_current_key(ht, &Z_STR(str_key), (zend_ulong* ) num);
*key = Z_STRVAL(str_key);
*keylen = Z_STRLEN(str_key);
return type;
}
/* CONVERSIONS for integers */
static zend_long from_zval_integer_common(const zval *arr_value, ser_context *ctx)
{
zend_long ret = 0;
zval lzval;
ZVAL_NULL(&lzval);
if (Z_TYPE_P(arr_value) != IS_LONG) {
ZVAL_COPY(&lzval, (zval *)arr_value);
arr_value = &lzval;
}
switch (Z_TYPE_P(arr_value)) {
case IS_LONG:
long_case:
ret = Z_LVAL_P(arr_value);
break;
/* if not long we're operating on lzval */
case IS_DOUBLE:
double_case:
convert_to_long(&lzval);
goto long_case;
case IS_OBJECT:
case IS_STRING: {
zend_long lval;
double dval;
convert_to_string(&lzval);
switch (is_numeric_string(Z_STRVAL(lzval), Z_STRLEN(lzval), &lval, &dval, 0)) {
case IS_DOUBLE:
zval_dtor(&lzval);
ZVAL_DOUBLE(&lzval, dval);
goto double_case;
case IS_LONG:
zval_dtor(&lzval);
ZVAL_LONG(&lzval, lval);
goto long_case;
}
/* if we get here, we don't have a numeric string */
do_from_zval_err(ctx, "expected an integer, but got a non numeric "
"string (possibly from a converted object): '%s'", Z_STRVAL_P(arr_value));
break;
}
default:
do_from_zval_err(ctx, "%s", "expected an integer, either of a PHP "
"integer type or of a convertible type");
break;
}
zval_dtor(&lzval);
return ret;
}
/* {{{ proto Closure Closure::bind(Closure $old, object $to [, mixed $scope = "static" ] )
Create a closure from another one and bind to another object and scope */
ZEND_METHOD(Closure, bind) /* {{{ */
{
zval *newthis, *zclosure, *scope_arg = NULL;
zend_closure *closure;
zend_class_entry *ce, **ce_p;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {
RETURN_NULL();
}
closure = (zend_closure *)zend_object_store_get_object(zclosure TSRMLS_CC);
if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {
zend_error(E_WARNING, "Cannot bind an instance to a static closure");
}
if (scope_arg != NULL) { /* scope argument was given */
if (IS_ZEND_STD_OBJECT(*scope_arg)) {
ce = Z_OBJCE_P(scope_arg);
} else if (Z_TYPE_P(scope_arg) == IS_NULL) {
ce = NULL;
} else {
char *class_name;
int class_name_len;
zval tmp_zval;
INIT_ZVAL(tmp_zval);
if (Z_TYPE_P(scope_arg) == IS_STRING) {
class_name = Z_STRVAL_P(scope_arg);
class_name_len = Z_STRLEN_P(scope_arg);
} else {
tmp_zval = *scope_arg;
zval_copy_ctor(&tmp_zval);
convert_to_string(&tmp_zval);
class_name = Z_STRVAL(tmp_zval);
class_name_len = Z_STRLEN(tmp_zval);
}
if ((class_name_len == sizeof("static") - 1) &&
(memcmp("static", class_name, sizeof("static") - 1) == 0)) {
ce = closure->func.common.scope;
}
else if (zend_lookup_class_ex(class_name, class_name_len, NULL, 1, &ce_p TSRMLS_CC) == FAILURE) {
zend_error(E_WARNING, "Class '%s' not found", class_name);
zval_dtor(&tmp_zval);
RETURN_NULL();
} else {
ce = *ce_p;
}
zval_dtor(&tmp_zval);
}
} else { /* scope argument not given; do not change the scope by default */
ce = closure->func.common.scope;
}
zend_create_closure(return_value, &closure->func, ce, newthis TSRMLS_CC);
}
static int accel_file_in_cache(INTERNAL_FUNCTION_PARAMETERS)
{
zval zfilename;
if (ZEND_NUM_ARGS() != 1 ||
zend_get_parameters_array_ex(1, &zfilename) == FAILURE ||
Z_TYPE(zfilename) != IS_STRING ||
Z_STRLEN(zfilename) == 0) {
return 0;
}
return filename_is_in_cache(Z_STRVAL(zfilename), Z_STRLEN(zfilename) TSRMLS_CC);
}
/**
* Gets a variable from put request
*
*<code>
* $userEmail = $request->getPut("user_email");
*
* $userEmail = $request->getPut("user_email", "email");
*</code>
*
* @param string $name
* @param string|array $filters
* @param mixed $defaultValue
* @param boolean $notAllowEmpty
* @param boolean $noRecursive
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, getPut)
{
zval *name = NULL, *filters = NULL, *default_value = NULL, *not_allow_empty = NULL, *norecursive = NULL, is_put = {}, put = {}, raw = {}, new_put = {};
char *tmp;
phalcon_fetch_params(0, 0, 5, &name, &filters, &default_value, ¬_allow_empty, &norecursive);
if (!name) {
name = &PHALCON_GLOBAL(z_null);
}
if (!filters) {
filters = &PHALCON_GLOBAL(z_null);
}
if (!default_value) {
default_value = &PHALCON_GLOBAL(z_null);
}
if (!not_allow_empty) {
not_allow_empty = &PHALCON_GLOBAL(z_false);
}
if (!norecursive) {
norecursive = &PHALCON_GLOBAL(z_false);
}
PHALCON_CALL_METHODW(&is_put, getThis(), "isput");
if (!zend_is_true(&is_put)) {
RETURN_EMPTY_ARRAY();
} else {
phalcon_read_property(&put, getThis(), SL("_put"), PH_NOISY);
if (Z_TYPE(put) != IS_ARRAY) {
PHALCON_CALL_METHODW(&raw, getThis(), "getrawbody");
array_init(&new_put);
PHALCON_ENSURE_IS_STRING(&raw);
tmp = estrndup(Z_STRVAL(raw), Z_STRLEN(raw));
sapi_module.treat_data(PARSE_STRING, tmp, &new_put);
phalcon_update_property_zval(getThis(), SL("_put"), &new_put);
} else {
PHALCON_CPY_WRT(&new_put, &put);
}
}
PHALCON_RETURN_CALL_SELFW("_get", &new_put, name, filters, default_value, not_allow_empty, norecursive);
}
static void php_bencode_decode_dict(zval *return_value, char *str, size_t *pos, size_t *str_len) /* {{{ */
{
array_init(return_value);
(*pos)++;
while (*pos < *str_len && str[*pos] != PHP_BENCODE_END_STRUCTURE) {
zval dict_key, dict_value;
php_bencode_decode_str(&dict_key, str, pos, str_len);
php_bencode_decode(&dict_value, str, pos, str_len);
if (Z_TYPE(dict_key) == IS_NULL) break;
if (Z_TYPE(dict_value) != IS_NULL) {
add_assoc_zval(return_value, Z_STRVAL(dict_key), &dict_value);
}
}
(*pos)++;
}
static void _breakiterator_parts_move_forward(zend_object_iterator *iter)
{
zoi_break_iter_parts *zoi_bit = (zoi_break_iter_parts*)iter;
BreakIterator_object *bio = zoi_bit->bio;
iter->funcs->invalidate_current(iter);
int32_t cur,
next;
cur = bio->biter->current();
if (cur == BreakIterator::DONE) {
return;
}
next = bio->biter->next();
if (next == BreakIterator::DONE) {
return;
}
if (zoi_bit->key_type == PARTS_ITERATOR_KEY_LEFT) {
iter->index = cur;
} else if (zoi_bit->key_type == PARTS_ITERATOR_KEY_RIGHT) {
iter->index = next;
}
/* else zoi_bit->key_type == PARTS_ITERATOR_KEY_SEQUENTIAL
* No need to do anything, the engine increments ->index */
const char *s = Z_STRVAL(bio->text);
size_t slen = Z_STRLEN(bio->text);
zend_string *res;
if (next == BreakIterator::DONE) {
next = (int32_t)slen;
}
assert(next <= slen && next >= cur);
res = zend_string_alloc(next - cur, 0);
memcpy(res->val, &s[cur], res->len);
res->val[res->len] = '\0';
ZVAL_STR(&zoi_bit->zoi_cur.current, res);
}
/**
* Reads parsed annotations from files
*
* @param string $key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Files, read){
zval *key, annotations_dir = {}, virtual_key = {}, path = {};
phalcon_fetch_params(0, 1, 0, &key);
PHALCON_ENSURE_IS_STRING(key);
phalcon_return_property(&annotations_dir, getThis(), SL("_annotationsDir"));
/**
* Paths must be normalized before be used as keys
*/
phalcon_prepare_virtual_path_ex(&virtual_key, Z_STRVAL_P(key), Z_STRLEN_P(key), '_');
PHALCON_CONCAT_VVS(&path, &annotations_dir, &virtual_key, ".php");
if (phalcon_file_exists(&path) == SUCCESS) {
RETURN_ON_FAILURE(phalcon_require_ret(return_value, Z_STRVAL(path)));
return;
}
}
void wkhtmltox_set_params(void *settings, fp set_function, zval *params)
{
zval **data;
HashTable *params_hash;
HashPosition pointer;
int params_count;
char *key;
int key_len;
long index;
params_hash = Z_ARRVAL_P(params);
params_count = zend_hash_num_elements(params_hash);
for(zend_hash_internal_pointer_reset_ex(params_hash, &pointer);
zend_hash_get_current_data_ex(params_hash, (void **)&data, &pointer) == SUCCESS;
zend_hash_move_forward_ex(params_hash, &pointer)) {
zval temp = **data;
zval_copy_ctor(&temp);
if (zend_hash_get_current_key_ex(params_hash, &key, &key_len, &index, 0, &pointer) == HASH_KEY_IS_STRING) {
switch (Z_TYPE(temp)) {
case IS_BOOL:
set_function(settings, key, Z_BVAL(temp) ? "true" : "false");
break;
default:
convert_to_string(&temp);
case IS_STRING:
set_function(settings, key, Z_STRVAL(temp));
break;
}
/*
convert_to_string(&temp);
php_printf("%s => %s\n", key, Z_STRVAL(temp));
*/
}
zval_dtor(&temp);
}
}
/* {{{ php_dba_myke_key */
static size_t php_dba_make_key(zval *key, char **key_str, char **key_free)
{
if (Z_TYPE_P(key) == IS_ARRAY) {
zval *group, *name;
HashPosition pos;
size_t len;
if (zend_hash_num_elements(Z_ARRVAL_P(key)) != 2) {
php_error_docref(NULL, E_RECOVERABLE_ERROR, "Key does not have exactly two elements: (key, name)");
return 0;
}
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(key), &pos);
group = zend_hash_get_current_data_ex(Z_ARRVAL_P(key), &pos);
zend_hash_move_forward_ex(Z_ARRVAL_P(key), &pos);
name = zend_hash_get_current_data_ex(Z_ARRVAL_P(key), &pos);
convert_to_string_ex(group);
convert_to_string_ex(name);
if (Z_STRLEN_P(group) == 0) {
*key_str = Z_STRVAL_P(name);
*key_free = NULL;
return Z_STRLEN_P(name);
}
len = spprintf(key_str, 0, "[%s]%s", Z_STRVAL_P(group), Z_STRVAL_P(name));
*key_free = *key_str;
return len;
} else {
zval tmp;
int len;
ZVAL_COPY(&tmp, key);
convert_to_string(&tmp);
len = Z_STRLEN(tmp);
if (len) {
*key_free = *key_str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
}
zval_ptr_dtor(&tmp);
return len;
}
}
/**
* Executes the internal PHQL parser/tokenizer
*/
int phql_parse_phql(zval *result, zval *phql) {
zval error_msg = {};
if (Z_TYPE_P(phql) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_mvc_model_exception_ce, "PHQL is must be string");
return FAILURE;
}
if (phql_internal_parse_phql(result, Z_STRVAL_P(phql), Z_STRLEN_P(phql), &error_msg) == FAILURE) {
if (Z_TYPE(error_msg) > IS_NULL) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_mvc_model_exception_ce, Z_STRVAL(error_msg));
}
else {
PHALCON_THROW_EXCEPTION_STRW(phalcon_mvc_model_exception_ce, "There was an error parsing PHQL");
}
return FAILURE;
}
return SUCCESS;
}
/* Lookup a key from the $PHORUM["DATA"] array. */
zval *
get_PHORUM_DATA(char *key)
{
HashTable *data = NULL;
zval zkey;
zval **P;
/* Lookup the $PHORUM["DATA"] variable. If there is no such variable,
* then return NULL. */
zval *A = get_PHORUM("DATA");
if (A == NULL) return NULL;
data = Z_ARRVAL_P(A);
/* Lookup the key in the DATA table. */
ZVAL_STRING(&zkey, key, 1);
if (zend_hash_find(data, Z_STRVAL(zkey), Z_STRLEN(zkey)+1, (void**)&P) == FAILURE) {
convert_to_long(&zkey);
if (zend_hash_index_find(data, Z_LVAL(zkey), (void**)&P) == FAILURE) {
return NULL;
}
}
return *P;
}
static void call_php(char *name, PARAMDSC *r, int argc, PARAMDSC **argv)
{
do {
zval callback, args[4], *argp[4], return_value;
PARAMVARY *res = (PARAMVARY*)r->dsc_address;
int i;
INIT_ZVAL(callback);
ZVAL_STRING(&callback,name,0);
LOCK();
/* check if the requested function exists */
if (!zend_is_callable(&callback, 0, NULL TSRMLS_CC)) {
break;
}
UNLOCK();
/* create the argument array */
for (i = 0; i < argc; ++i) {
INIT_ZVAL(args[i]);
argp[i] = &args[i];
/* test arg for null */
if (argv[i]->dsc_flags & DSC_null) {
ZVAL_NULL(argp[i]);
continue;
}
switch (argv[i]->dsc_dtype) {
ISC_INT64 l;
struct tm t;
char const *fmt;
char d[64];
case dtype_cstring:
ZVAL_STRING(argp[i], (char*)argv[i]->dsc_address,0);
break;
case dtype_text:
ZVAL_STRINGL(argp[i], (char*)argv[i]->dsc_address, argv[i]->dsc_length,0);
break;
case dtype_varying:
ZVAL_STRINGL(argp[i], ((PARAMVARY*)argv[i]->dsc_address)->vary_string,
((PARAMVARY*)argv[i]->dsc_address)->vary_length,0);
break;
case dtype_short:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(short*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(short*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_long:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(ISC_LONG*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(ISC_LONG*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_int64:
l = *(ISC_INT64*)argv[i]->dsc_address;
if (argv[i]->dsc_scale == 0 && l <= LONG_MAX && l >= LONG_MIN) {
ZVAL_LONG(argp[i], (long)l);
} else {
ZVAL_DOUBLE(argp[i], ((double)l)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_real:
ZVAL_DOUBLE(argp[i], *(float*)argv[i]->dsc_address);
break;
case dtype_double:
ZVAL_DOUBLE(argp[i], *(double*)argv[i]->dsc_address);
break;
case dtype_sql_date:
isc_decode_sql_date((ISC_DATE*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.dateformat"), &t),1);
break;
case dtype_sql_time:
isc_decode_sql_time((ISC_TIME*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timeformat"), &t),1);
break;
case dtype_timestamp:
isc_decode_timestamp((ISC_TIMESTAMP*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timestampformat"), &t),1);
break;
}
}
LOCK();
/* now call the function */
if (FAILURE == call_user_function(EG(function_table), NULL,
&callback, &return_value, argc, argp TSRMLS_CC)) {
UNLOCK();
break;
}
UNLOCK();
for (i = 0; i < argc; ++i) {
switch (argv[i]->dsc_dtype) {
case dtype_sql_date:
case dtype_sql_time:
case dtype_timestamp:
zval_dtor(argp[i]);
}
}
/* return whatever type we got back from the callback: let DB handle conversion */
switch (Z_TYPE(return_value)) {
case IS_LONG:
r->dsc_dtype = dtype_long;
*(long*)r->dsc_address = Z_LVAL(return_value);
r->dsc_length = sizeof(long);
break;
case IS_DOUBLE:
r->dsc_dtype = dtype_double;
*(double*)r->dsc_address = Z_DVAL(return_value);
r->dsc_length = sizeof(double);
break;
case IS_NULL:
r->dsc_flags |= DSC_null;
break;
default:
convert_to_string(&return_value);
case IS_STRING:
r->dsc_dtype = dtype_varying;
memcpy(res->vary_string, Z_STRVAL(return_value),
(res->vary_length = min(r->dsc_length-2,Z_STRLEN(return_value))));
r->dsc_length = res->vary_length+2;
break;
}
zval_dtor(&return_value);
return;
} while (0);
/**
* If we end up here, we should report an error back to the DB engine, but
* that's not possible. We can however report it back to PHP.
*/
LOCK();
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling function '%s' from database", name);
UNLOCK();
}
/* {{{ _php_array_to_envp */
static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent TSRMLS_DC)
{
zval **element;
php_process_env_t env;
char *string_key, *data;
#ifndef PHP_WIN32
char **ep;
#endif
char *p;
uint string_length, cnt, l, sizeenv=0, el_len;
ulong num_key;
HashTable *target_hash;
HashPosition pos;
memset(&env, 0, sizeof(env));
if (!environment) {
return env;
}
cnt = zend_hash_num_elements(Z_ARRVAL_P(environment));
if (cnt < 1) {
#ifndef PHP_WIN32
env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent);
#endif
env.envp = (char *) pecalloc(4, 1, is_persistent);
return env;
}
target_hash = HASH_OF(environment);
if (!target_hash) {
return env;
}
/* first, we have to get the size of all the elements in the hash */
for (zend_hash_internal_pointer_reset_ex(target_hash, &pos);
zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS;
zend_hash_move_forward_ex(target_hash, &pos)) {
if (Z_TYPE_PP(element) != IS_STRING) {
zval tmp;
MAKE_COPY_ZVAL(element, &tmp);
convert_to_string(&tmp);
el_len = Z_STRLEN(tmp);
zval_dtor(&tmp);
} else {
el_len = Z_STRLEN_PP(element);
}
if (el_len == 0) {
continue;
}
sizeenv += el_len+1;
switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
if (string_length == 0) {
continue;
}
sizeenv += string_length;
break;
}
}
#ifndef PHP_WIN32
ep = env.envarray = (char **) pecalloc(cnt + 1, sizeof(char *), is_persistent);
#endif
p = env.envp = (char *) pecalloc(sizeenv + 4, 1, is_persistent);
for (zend_hash_internal_pointer_reset_ex(target_hash, &pos);
zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS;
zend_hash_move_forward_ex(target_hash, &pos)) {
zval tmp;
if (Z_TYPE_PP(element) != IS_STRING) {
MAKE_COPY_ZVAL(element, &tmp);
convert_to_string(&tmp);
} else {
tmp = **element;
}
el_len = Z_STRLEN(tmp);
if (el_len == 0) {
goto next_element;
}
data = Z_STRVAL(tmp);
switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
if (string_length == 0) {
goto next_element;
}
l = string_length + el_len + 1;
memcpy(p, string_key, string_length);
strncat(p, "=", 1);
strncat(p, data, el_len);
#ifndef PHP_WIN32
*ep = p;
++ep;
#endif
p += l;
break;
case HASH_KEY_IS_LONG:
memcpy(p,data,el_len);
#ifndef PHP_WIN32
*ep = p;
++ep;
#endif
p += el_len + 1;
break;
case HASH_KEY_NON_EXISTENT:
break;
}
next_element:
if (Z_TYPE_PP(element) != IS_STRING) {
zval_dtor(&tmp);
}
}
assert((uint)(p - env.envp) <= sizeenv);
zend_hash_internal_pointer_reset_ex(target_hash, &pos);
return env;
}
