static char * luasandbox_timer_get_cfunction_name(lua_State *L) { static char buffer[1024]; TSRMLS_FETCH(); lua_CFunction f = lua_tocfunction(L, -1); if (!f) { return NULL; } if (f != luasandbox_call_php) { return NULL; } lua_getupvalue(L, -1, 1); #if PHP_VERSION_ID < 70000 zval ** callback_pp = (zval**)lua_touserdata(L, -1); if (!callback_pp || !*callback_pp) { return NULL; } char * callback_name; zend_bool ok = zend_is_callable(*callback_pp, IS_CALLABLE_CHECK_SILENT, &callback_name TSRMLS_CC); #else zval * callback_p = (zval*)lua_touserdata(L, -1); if (!callback_p) { return NULL; } zend_string * callback_name; zend_bool ok = zend_is_callable(callback_p, IS_CALLABLE_CHECK_SILENT, &callback_name); #endif if (ok) { snprintf(buffer, sizeof(buffer), "%s", #if PHP_VERSION_ID < 70000 callback_name #else ZSTR_VAL(callback_name) #endif ); return buffer; } else { return NULL; } }
static zend_always_inline zend_string *zend_interned_string_ht_lookup_ex(zend_ulong h, const char *str, size_t size, HashTable *interned_strings) { uint32_t nIndex; uint32_t idx; Bucket *p; nIndex = h | interned_strings->nTableMask; idx = HT_HASH(interned_strings, nIndex); while (idx != HT_INVALID_IDX) { p = HT_HASH_TO_BUCKET(interned_strings, idx); if ((p->h == h) && (ZSTR_LEN(p->key) == size)) { if (!memcmp(ZSTR_VAL(p->key), str, size)) { return p->key; } } idx = Z_NEXT(p->val); } return NULL; }
PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length) /* {{{ */ { zend_ulong lp = 0; unsigned char c, *d; char *hex = "0123456789ABCDEF"; zend_string *ret; ret = zend_string_safe_alloc(3, (length + (((3 * length)/(PHP_QPRINT_MAXL-9)) + 1)), 0, 0); d = (unsigned char*)ZSTR_VAL(ret); while (length--) { if (((c = *str++) == '\015') && (*str == '\012') && length > 0) { *d++ = '\015'; *d++ = *str++; length--; lp = 0; } else { if (iscntrl (c) || (c == 0x7f) || (c & 0x80) || (c == '=') || ((c == ' ') && (*str == '\015'))) { if ((((lp+= 3) > PHP_QPRINT_MAXL) && (c <= 0x7f)) || ((c > 0x7f) && (c <= 0xdf) && ((lp + 3) > PHP_QPRINT_MAXL)) || ((c > 0xdf) && (c <= 0xef) && ((lp + 6) > PHP_QPRINT_MAXL)) || ((c > 0xef) && (c <= 0xf4) && ((lp + 9) > PHP_QPRINT_MAXL))) { *d++ = '='; *d++ = '\015'; *d++ = '\012'; lp = 3; } *d++ = '='; *d++ = hex[c >> 4]; *d++ = hex[c & 0xf]; } else { if ((++lp) > PHP_QPRINT_MAXL) { *d++ = '='; *d++ = '\015'; *d++ = '\012'; lp = 1; } *d++ = c; } } }
/** * Returns a class name into a zval result */ void zephir_get_class(zval *result, zval *object, int lower) { zend_class_entry *ce; zend_string *class_name; if (Z_TYPE_P(object) == IS_OBJECT) { ce = Z_OBJCE_P(object); //zval_ptr_dtor(result); class_name = zend_string_init(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), 0); ZVAL_STR(result, class_name); if (lower) { zend_str_tolower(Z_STRVAL_P(result), Z_STRLEN_P(result)); } } else { ZVAL_NULL(result); php_error_docref(NULL, E_WARNING, "zephir_get_class expects an object"); } }
/** * Check if an object is instance of a class */ int zephir_is_instance_of(zval *object, const char *class_name, unsigned int class_length) { zend_class_entry *ce, *temp_ce; if (Z_TYPE_P(object) == IS_OBJECT) { ce = Z_OBJCE_P(object); if (ZSTR_LEN(ce->name) == class_length) { if (!zend_binary_strcasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), class_name, class_length)) { return 1; } } temp_ce = zephir_fetch_class_str_ex(class_name, class_length, ZEND_FETCH_CLASS_DEFAULT); if (temp_ce) { return instanceof_function(ce, temp_ce); } } return 0; }
static void print_flat_hash(HashTable *ht) /* {{{ */ { zval *tmp; zend_string *string_key; zend_ulong num_key; int i = 0; ZEND_HASH_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) { if (i++ > 0) { ZEND_PUTS(","); } ZEND_PUTS("["); if (string_key) { ZEND_WRITE(ZSTR_VAL(string_key), ZSTR_LEN(string_key)); } else { zend_printf(ZEND_ULONG_FMT, num_key); } ZEND_PUTS("] => "); zend_print_flat_zval_r(tmp); } ZEND_HASH_FOREACH_END(); }
static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, uint32_t type) /* {{{ */ { char *decode = NULL; switch (type) { case IS_CV: { zend_string *var = ops->vars[EX_VAR_TO_NUM(op->var)]; asprintf(&decode, "$%.*s%c", ZSTR_LEN(var) <= 19 ? (int) ZSTR_LEN(var) : 18, ZSTR_VAL(var), ZSTR_LEN(var) <= 19 ? 0 : '+'); } break; case IS_VAR: case IS_TMP_VAR: { asprintf(&decode, "@%" PRIu32, EX_VAR_TO_NUM(op->var) - ops->last_var); } break; case IS_CONST: { zval *literal = RT_CONSTANT(ops, *op); decode = phpdbg_short_zval_print(literal, 20); } break; } return decode; } /* }}} */
int dom_attr_value_write(dom_object *obj, zval *newval) { zend_string *str; xmlAttrPtr attrp = (xmlAttrPtr) dom_object_get_node(obj); if (attrp == NULL) { php_dom_throw_error(INVALID_STATE_ERR, 0); return FAILURE; } if (attrp->children) { node_list_unlink(attrp->children); } str = zval_get_string(newval); xmlNodeSetContentLen((xmlNodePtr) attrp, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1); zend_string_release(str); return SUCCESS; }
/* This function is meant to unify the headers passed to to mail() * This means, use PCRE to transform single occurrences of \n or \r in \r\n * As a second step we also eleminate all \r\n occurrences which are: * 1) At the start of the header * 2) At the end of the header * 3) Two or more occurrences in the header are removed so only one is left * * Returns NULL on error, or the new char* buffer on success. * You have to take care and efree() the buffer on your own. */ static zend_string *php_win32_mail_trim_header(char *header) { zend_string *result, *result2; zend_string *replace; zend_string *regex; if (!header) { return NULL; } replace = zend_string_init(PHP_WIN32_MAIL_UNIFY_REPLACE, strlen(PHP_WIN32_MAIL_UNIFY_REPLACE), 0); regex = zend_string_init(PHP_WIN32_MAIL_UNIFY_PATTERN, sizeof(PHP_WIN32_MAIL_UNIFY_PATTERN)-1, 0); result = php_pcre_replace(regex, NULL, header, strlen(header), replace, -1, NULL); zend_string_release_ex(replace, 0); zend_string_release_ex(regex, 0); if (NULL == result) { return NULL; } replace = zend_string_init(PHP_WIN32_MAIL_RMVDBL_PATTERN, strlen(PHP_WIN32_MAIL_RMVDBL_PATTERN), 0); regex = zend_string_init(PHP_WIN32_MAIL_RMVDBL_PATTERN, sizeof(PHP_WIN32_MAIL_RMVDBL_PATTERN)-1, 0); result2 = php_pcre_replace(regex, result, ZSTR_VAL(result), ZSTR_LEN(result), replace, -1, NULL); zend_string_release_ex(replace, 0); zend_string_release_ex(regex, 0); zend_string_release_ex(result, 0); return result2; }
static int oauth_provider_remove_required_param(HashTable *ht, char *required_param) /* {{{ */ { zval *dest_entry; zend_string *key; ulong num_key; HashPosition hpos; if((dest_entry = zend_hash_str_find(ht, required_param, strlen(required_param))) == NULL) { return FAILURE; } else { zend_hash_internal_pointer_reset_ex(ht, &hpos); do { if(zend_hash_get_current_key_ex(ht, &key, &num_key, &hpos)!=FAILURE) { if(!strcmp(ZSTR_VAL(key), required_param)) { zend_hash_del(ht, key); return SUCCESS; } } } while(zend_hash_move_forward_ex(ht, &hpos)==SUCCESS); } return FAILURE; }
/* {{{ proto bool tidy_parse_string(string input [, mixed config_options [, string encoding]]) Parse a document stored in a string */ static PHP_FUNCTION(tidy_parse_string) { char *enc = NULL; size_t enc_len = 0; zend_string *input; zval *options = NULL; PHPTidyObj *obj; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zs", &input, &options, &enc, &enc_len) == FAILURE) { RETURN_FALSE; } tidy_instanciate(tidy_ce_doc, return_value); obj = Z_TIDY_P(return_value); TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options); if (php_tidy_parse_string(obj, ZSTR_VAL(input), ZSTR_LEN(input), enc) == FAILURE) { zval_ptr_dtor(return_value); RETURN_FALSE; } }
static void php_filter_encode_url(zval *value, const unsigned char* chars, const int char_len, int high, int low, int encode_nul) { unsigned char *p; unsigned char tmp[256]; unsigned char *s = (unsigned char *)chars; unsigned char *e = s + char_len; zend_string *str; memset(tmp, 1, sizeof(tmp)-1); while (s < e) { tmp[*s++] = '\0'; } /* XXX: This is not needed since these chars in the allowed list never include the high/low/null value if (encode_nul) { tmp[0] = 1; } if (high) { memset(tmp + 127, 1, sizeof(tmp) - 127); } if (low) { memset(tmp, 1, 32); } */ str = zend_string_safe_alloc(Z_STRLEN_P(value), 3, 0, 0); p = (unsigned char *) ZSTR_VAL(str); s = (unsigned char *) Z_STRVAL_P(value); e = s + Z_STRLEN_P(value); while (s < e) { if (tmp[*s]) { *p++ = '%'; *p++ = hexchars[(unsigned char) *s >> 4]; *p++ = hexchars[(unsigned char) *s & 15]; } else { *p++ = *s; } s++; }
void zend_dump_ht(HashTable *ht) { zend_ulong index; zend_string *key; zval *val; int first = 1; ZEND_HASH_FOREACH_KEY_VAL(ht, index, key, val) { if (first) { first = 0; } else { fprintf(stderr, ", "); } if (key) { fprintf(stderr, "\"%s\"", ZSTR_VAL(key)); } else { fprintf(stderr, ZEND_LONG_FMT, index); } fprintf(stderr, " =>"); zend_dump_const(val); } ZEND_HASH_FOREACH_END(); }
static ZEND_INI_MH(OnUpdateMemoryConsumption) { zend_long *p; zend_long memsize; #ifndef ZTS char *base = (char *) mh_arg2; #else char *base = (char *) ts_resource(*((int *) mh_arg2)); #endif /* keep the compiler happy */ (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage; p = (zend_long *) (base + (size_t)mh_arg1); memsize = atoi(ZSTR_VAL(new_value)); /* sanity check we must use at least 8 MB */ if (memsize < 8) { const char *new_new_value = "8"; zend_ini_entry *ini_entry; memsize = 8; zend_accel_error(ACCEL_LOG_WARNING, "opcache.memory_consumption is set below the required 8MB.\n"); zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal 8MB configuration.\n"); if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives), "opcache.memory_consumption", sizeof("opcache.memory_consumption")-1)) == NULL) { return FAILURE; } ini_entry->value = zend_string_init(new_new_value, 1, 1); } if (UNEXPECTED(memsize > ZEND_ULONG_MAX / (1024 * 1024))) { *p = ZEND_ULONG_MAX; } else { *p = memsize * (1024 * 1024); } return SUCCESS; }
/** see http://lxr.php.net/xref/PHP_7_0/Zend/zend_vm_def.h#2892 */ static int oop_method_call_handler(zend_execute_data *execute_data) { const zend_op *opline = execute_data->opline; zend_free_op free_op1, free_op2; zval *obj = NULL, *method = NULL; zend_class_entry *ce = NULL; zend_function *fbc = NULL; zend_execute_data *call = NULL; obj = zend_get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R); method = zend_get_zval_ptr(opline->op2_type, &opline->op2, execute_data, &free_op2, BP_VAR_R); if (Z_TYPE_P(obj) == IS_STRING) { ce = OOP_G(oop_handlers)[Z_TYPE_P(obj)]; if (!ce) { return ZEND_USER_OPCODE_DISPATCH; } fbc = zend_std_get_static_method(ce, Z_STR_P(method), NULL); if (UNEXPECTED(fbc == NULL)) { php_error(E_ERROR, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(method)); } fbc = oop_get_indirection_func(ce, fbc, method, obj); call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, fbc, opline->extended_value, ce, NULL); call->prev_execute_data = EX(call); EX(call) = call; FREE_OP(free_op2); FREE_OP_IF_VAR(free_op1); execute_data->opline++; return ZEND_USER_OPCODE_CONTINUE; } return ZEND_USER_OPCODE_DISPATCH; }
/* {{{ clone handler for TimeZone */ static zend_object *TimeZone_clone_obj(zval *object) { TimeZone_object *to_orig, *to_new; zend_object *ret_val; intl_error_reset(NULL); to_orig = Z_INTL_TIMEZONE_P(object); intl_error_reset(TIMEZONE_ERROR_P(to_orig)); ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object)); to_new = php_intl_timezone_fetch_object(ret_val); zend_objects_clone_members(&to_new->zo, &to_orig->zo); if (to_orig->utimezone != NULL) { TimeZone *newTimeZone; newTimeZone = to_orig->utimezone->clone(); to_new->should_delete = 1; if (!newTimeZone) { zend_string *err_msg; intl_errors_set_code(TIMEZONE_ERROR_P(to_orig), U_MEMORY_ALLOCATION_ERROR); intl_errors_set_custom_msg(TIMEZONE_ERROR_P(to_orig), "Could not clone IntlTimeZone", 0); err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig)); zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0); zend_string_free(err_msg); } else { to_new->utimezone = newTimeZone; } } else { zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0); } return ret_val; }
// extern TF_Buffer* TF_NewBufferFromString(const void* proto, size_t proto_len); // extern TF_Buffer* TF_NewBuffer(); static PHP_METHOD(TensorFlow_Buffer, __construct) { // arguments zend_string* buffer; ZEND_PARSE_PARAMETERS_START(0, 1) Z_PARAM_OPTIONAL Z_PARAM_STR(buffer) ZEND_PARSE_PARAMETERS_END(); // this t_tf_buffer_object* intern; t_tf_buffer* php_tf_buffer; intern = TF_BUFFER_P_ZV(getThis()); php_tf_buffer = intern->ptr; if (ZEND_NUM_ARGS() == 1) { php_tf_buffer->src = TF_NewBufferFromString(ZSTR_VAL(buffer), ZSTR_LEN(buffer)); } else { php_tf_buffer->src = TF_NewBuffer(); } }
static int phpdbg_create_recursive_ht_watch(phpdbg_watchpoint_t *watch) { zval *zv; zend_string *key; zend_long h; size_t str_len; ZEND_ASSERT(watch->type == WATCH_ON_HASHTABLE); ZEND_HASH_FOREACH_KEY_VAL(HT_WATCH_HT(watch), h, key, zv) { char *str = NULL; phpdbg_watchpoint_t *new_watch = emalloc(sizeof(phpdbg_watchpoint_t)); new_watch->flags = PHPDBG_WATCH_RECURSIVE; new_watch->parent = watch; new_watch->parent_container = HT_WATCH_HT(watch); if (key) { new_watch->name_in_parent = key; ++GC_REFCOUNT(key); } else { str_len = spprintf(&str, 0, "%lld", h); new_watch->name_in_parent = zend_string_init(str, str_len, 0); efree(str); } str_len = spprintf(&str, 0, "%.*s%s%s%s", (int) ZSTR_LEN(watch->str) - 2, ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_ARRAY) ? "[" : "->", phpdbg_get_property_key(ZSTR_VAL(new_watch->name_in_parent)), (watch->flags & PHPDBG_WATCH_ARRAY) ? "]" : ""); new_watch->str = zend_string_init(str, str_len, 0); efree(str); while (Z_TYPE_P(zv) == IS_INDIRECT) { zv = Z_INDIRECT_P(zv); } phpdbg_create_zval_watchpoint(zv, new_watch); new_watch = phpdbg_create_watchpoint(new_watch); phpdbg_create_recursive_zval_watch(new_watch); } ZEND_HASH_FOREACH_END();
static int php_ini_on_update_hosts(zend_ini_entry *entry, zend_string *new_value, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage, int type) { HashTable *hosts; char *key; char *tmp; char *lasts = NULL; if (type) { hosts = &BG(url_adapt_session_hosts_ht); } else { hosts = &BG(url_adapt_output_hosts_ht); } zend_hash_clean(hosts); /* Use user supplied host whitelist */ tmp = estrndup(ZSTR_VAL(new_value), ZSTR_LEN(new_value)); for (key = php_strtok_r(tmp, ",", &lasts); key; key = php_strtok_r(NULL, ",", &lasts)) { size_t keylen; zend_string *tmp_key; char *q; for (q = key; *q; q++) { *q = tolower(*q); } keylen = q - key; if (keylen > 0) { tmp_key = zend_string_init(key, keylen, 0); zend_hash_add_empty_element(hosts, tmp_key); zend_string_release(tmp_key); } } efree(tmp); return SUCCESS; }
/* {{{ clone handler for Calendar */ static zend_object *Calendar_clone_obj(zval *object) { Calendar_object *co_orig, *co_new; zend_object *ret_val; intl_error_reset(NULL); co_orig = Z_INTL_CALENDAR_P(object); intl_error_reset(INTL_DATA_ERROR_P(co_orig)); ret_val = Calendar_ce_ptr->create_object(Z_OBJCE_P(object)); co_new = php_intl_calendar_fetch_object(ret_val); zend_objects_clone_members(&co_new->zo, &co_orig->zo); if (co_orig->ucal != NULL) { Calendar *newCalendar; newCalendar = co_orig->ucal->clone(); if (!newCalendar) { zend_string *err_msg; intl_errors_set_code(CALENDAR_ERROR_P(co_orig), U_MEMORY_ALLOCATION_ERROR); intl_errors_set_custom_msg(CALENDAR_ERROR_P(co_orig), "Could not clone IntlCalendar", 0); err_msg = intl_error_get_message(CALENDAR_ERROR_P(co_orig)); zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0); zend_string_free(err_msg); } else { co_new->ucal = newCalendar; } } else { zend_throw_exception(NULL, "Cannot clone unconstructed IntlCalendar", 0); } return ret_val; }
static inline void phpdbg_append_individual_arg(smart_str *s, uint32_t i, zend_function *func, zval *arg) { const zend_arg_info *arginfo = func->common.arg_info; char *arg_name = NULL; if (i) { smart_str_appends(s, ", "); } if (i < func->common.num_args) { if (arginfo) { if (func->type == ZEND_INTERNAL_FUNCTION) { arg_name = (char *) ((zend_internal_arg_info *) &arginfo[i])->name; } else { arg_name = ZSTR_VAL(arginfo[i].name); } } smart_str_appends(s, arg_name ? arg_name : "?"); smart_str_appendc(s, '='); } { char *arg_print = phpdbg_short_zval_print(arg, 40); smart_str_appends(s, arg_print); efree(arg_print); } }
//is used to validate objects before serialization and after deserialization. For now, only required fields are validated. static void validate_thrift_object(zval* object) { zend_class_entry* object_class_entry = Z_OBJCE_P(object); zval* is_validate = zend_read_static_property(object_class_entry, "isValidate", sizeof("isValidate")-1, false); zval* spec = zend_read_static_property(object_class_entry, "_TSPEC", sizeof("_TSPEC")-1, false); HashPosition key_ptr; zval* val_ptr; if (Z_TYPE_INFO_P(is_validate) == IS_TRUE) { for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(spec), &key_ptr); (val_ptr = zend_hash_get_current_data_ex(Z_ARRVAL_P(spec), &key_ptr)) != nullptr; zend_hash_move_forward_ex(Z_ARRVAL_P(spec), &key_ptr)) { zend_ulong fieldno; if (zend_hash_get_current_key_ex(Z_ARRVAL_P(spec), nullptr, &fieldno, &key_ptr) != HASH_KEY_IS_LONG) { throw_tprotocolexception("Bad keytype in TSPEC (expected 'long')", INVALID_DATA); return; } HashTable* fieldspec = Z_ARRVAL_P(val_ptr); // field name zval* zvarname = zend_hash_str_find(fieldspec, "var", sizeof("var")-1); char* varname = Z_STRVAL_P(zvarname); zval* is_required = zend_hash_str_find(fieldspec, "isRequired", sizeof("isRequired")-1); zval rv; zval* prop = zend_read_property(object_class_entry, object, varname, strlen(varname), false, &rv); if (Z_TYPE_INFO_P(is_required) == IS_TRUE && Z_TYPE_P(prop) == IS_NULL) { char errbuf[128]; snprintf(errbuf, 128, "Required field %s.%s is unset!", ZSTR_VAL(object_class_entry->name), varname); throw_tprotocolexception(errbuf, INVALID_DATA); } } } }
PHP_METHOD(ngx_socket, send) { ngx_http_request_t *r; ngx_http_php_ctx_t *ctx; ngx_http_php_socket_upstream_t *u; ngx_str_t ns; ngx_buf_t *b; ngx_chain_t *cl; zend_string *buf_str; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &buf_str) == FAILURE) { RETURN_NULL(); } r = ngx_php_request; ctx = ngx_http_get_module_ctx(r, ngx_http_php_module); ns.data = (u_char *)ZSTR_VAL(buf_str); ns.len = ZSTR_LEN(buf_str); b = ngx_create_temp_buf(r->pool, ns.len + 1); cl = ngx_alloc_chain_link(r->pool); cl->buf = b; cl->next = NULL; u = ctx->upstream; u->request_bufs = cl; b->last = ngx_copy(b->last, ns.data, ns.len); ngx_http_php_socket_send(r); }
/** * Used for readdir() on an opendir()ed phar directory handle */ static size_t phar_dir_read(php_stream *stream, char *buf, size_t count) /* {{{ */ { size_t to_read; HashTable *data = (HashTable *)stream->abstract; zend_string *str_key; zend_ulong unused; if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key(data, &str_key, &unused)) { return 0; } zend_hash_move_forward(data); to_read = MIN(ZSTR_LEN(str_key), count); if (to_read == 0 || count < ZSTR_LEN(str_key)) { return 0; } memset(buf, 0, sizeof(php_stream_dirent)); memcpy(((php_stream_dirent *) buf)->d_name, ZSTR_VAL(str_key), to_read); ((php_stream_dirent *) buf)->d_name[to_read + 1] = '\0'; return sizeof(php_stream_dirent); }
static TIDY_DOC_METHOD(parseString) { char *enc = NULL; size_t enc_len = 0; zval *options = NULL; PHPTidyObj *obj; zend_string *input; TIDY_SET_CONTEXT; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zs", &input, &options, &enc, &enc_len) == FAILURE) { RETURN_FALSE; } obj = Z_TIDY_P(object); TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options); if(php_tidy_parse_string(obj, ZSTR_VAL(input), ZSTR_LEN(input), enc) == SUCCESS) { RETURN_TRUE; } RETURN_FALSE; }
static inline void php_url_scanner_session_handler_impl(char *output, size_t output_len, char **handled_output, size_t *handled_output_len, int mode, int type) { size_t len; url_adapt_state_ex_t *url_state; if (type) { url_state = &BG(url_adapt_session_ex); } else { url_state = &BG(url_adapt_output_ex); } if (ZSTR_LEN(url_state->url_app.s) != 0) { *handled_output = url_adapt_ext(output, output_len, &len, (zend_bool) (mode & (PHP_OUTPUT_HANDLER_END | PHP_OUTPUT_HANDLER_CONT | PHP_OUTPUT_HANDLER_FLUSH | PHP_OUTPUT_HANDLER_FINAL) ? 1 : 0), url_state); if (sizeof(uint32_t) < sizeof(size_t)) { if (len > UINT_MAX) len = UINT_MAX; } *handled_output_len = len; } else if (ZSTR_LEN(url_state->url_app.s) == 0) { url_adapt_state_ex_t *ctx = url_state; if (ctx->buf.s && ZSTR_LEN(ctx->buf.s)) { smart_str_append(&ctx->result, ctx->buf.s); smart_str_appendl(&ctx->result, output, output_len); *handled_output = estrndup(ZSTR_VAL(ctx->result.s), ZSTR_LEN(ctx->result.s)); *handled_output_len = ZSTR_LEN(ctx->buf.s) + output_len; smart_str_free(&ctx->buf); smart_str_free(&ctx->result); } else { *handled_output = estrndup(output, *handled_output_len = output_len); } } else { *handled_output = NULL; } }
static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { zend_long datalen; datalen = parse_iv2((*p) + 2, p); (*p) += 2; if (datalen < 0 || (max - (*p)) <= datalen) { zend_error(E_WARNING, "Insufficient data for unserializing - %pd required, %pd present", datalen, (zend_long)(max - (*p))); return 0; } if (ce->unserialize == NULL) { zend_error(E_WARNING, "Class %s has no unserializer", ZSTR_VAL(ce->name)); object_init_ex(rval, ce); } else if (ce->unserialize(rval, ce, (const unsigned char*)*p, datalen, (zend_unserialize_data *)var_hash) != SUCCESS) { return 0; } (*p) += datalen; return finish_nested_data(UNSERIALIZE_PASSTHRU); }
static inline zend_long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { zend_long elements; if( *p >= max - 2) { zend_error(E_WARNING, "Bad unserialize data"); return -1; } elements = parse_iv2((*p) + 2, p); (*p) += 2; if (ce->serialize == NULL) { object_init_ex(rval, ce); } else { /* If this class implements Serializable, it should not land here but in object_custom(). The passed string obviously doesn't descend from the regular serializer. */ zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ZSTR_VAL(ce->name)); return -1; } return elements; }
static PHP_INI_MH(OnChangeCallback) /* {{{ */ { if (EG(current_execute_data)) { if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) { zval_ptr_dtor(&ASSERTG(callback)); ZVAL_UNDEF(&ASSERTG(callback)); } if (new_value && (Z_TYPE(ASSERTG(callback)) != IS_UNDEF || ZSTR_LEN(new_value))) { ZVAL_STR_COPY(&ASSERTG(callback), new_value); } } else { if (ASSERTG(cb)) { pefree(ASSERTG(cb), 1); } if (new_value && ZSTR_LEN(new_value)) { ASSERTG(cb) = pemalloc(ZSTR_LEN(new_value) + 1, 1); memcpy(ASSERTG(cb), ZSTR_VAL(new_value), ZSTR_LEN(new_value)); ASSERTG(cb)[ZSTR_LEN(new_value)] = '\0'; } else { ASSERTG(cb) = NULL; } } return SUCCESS; }
static char *url_adapt_ext(const char *src, size_t srclen, size_t *newlen, zend_bool do_flush, url_adapt_state_ex_t *ctx) { char *retval; xx_mainloop(ctx, src, srclen); if (!ctx->result.s) { smart_str_appendl(&ctx->result, "", 0); *newlen = 0; } else { *newlen = ZSTR_LEN(ctx->result.s); } smart_str_0(&ctx->result); if (do_flush) { smart_str_append(&ctx->result, ctx->buf.s); *newlen += ZSTR_LEN(ctx->buf.s); smart_str_free(&ctx->buf); smart_str_free(&ctx->val); smart_str_free(&ctx->attr_val); } retval = estrndup(ZSTR_VAL(ctx->result.s), ZSTR_LEN(ctx->result.s)); smart_str_free(&ctx->result); return retval; }