#include "libmbfl/config.h"

#include "php.h"

#include "php_ini.h"

#include "php_variables.h"

#include "mbstring.h"

#include "ext/standard/php_string.h"

#include "ext/standard/php_mail.h"

#include "ext/standard/exec.h"

#include "ext/standard/url.h"

#include "main/php_output.h"

#include "ext/standard/info.h"

#include "ext/pcre/php_pcre.h"

#include "libmbfl/mbfl/mbfilter_8bit.h"

#include "libmbfl/mbfl/mbfilter_pass.h"

#include "libmbfl/mbfl/mbfilter_wchar.h"

#include "libmbfl/filters/mbfilter_base64.h"

#include "libmbfl/filters/mbfilter_qprint.h"

#include "libmbfl/filters/mbfilter_htmlent.h"

#include "libmbfl/filters/mbfilter_uuencode.h"

#include "libmbfl/filters/mbfilter_ucs4.h"

#include "libmbfl/filters/mbfilter_utf8.h"

#include "libmbfl/filters/mbfilter_tl_jisx0201_jisx0208.h"

#include "libmbfl/filters/mbfilter_singlebyte.h"

#include "php_variables.h"

#include "php_globals.h"

#include "rfc1867.h"

#include "php_content_types.h"

#include "SAPI.h"

#include "php_unicode.h"

#include "TSRM.h"

#include "mb_gpc.h"

#ifdef HAVE_MBREGEX

# include "php_mbregex.h"

#include "zend_multibyte.h"

#include "mbstring_arginfo.h"

ZEND_DECLARE_MODULE_GLOBALS(mbstring)

static PHP_GINIT_FUNCTION(mbstring);

static PHP_GSHUTDOWN_FUNCTION(mbstring);

static void php_mb_populate_current_detect_order_list(void);

static int php_mb_encoding_translation(void);

static void php_mb_gpc_get_detect_order(const zend_encoding ***list, size_t *list_size);

static void php_mb_gpc_set_input_encoding(const zend_encoding *encoding);

static inline bool php_mb_is_unsupported_no_encoding(enum mbfl_no_encoding no_enc);

static inline bool php_mb_is_no_encoding_utf8(enum mbfl_no_encoding no_enc);

typedef struct _php_mb_nls_ident_list {

} php_mb_nls_ident_list;

static const enum mbfl_no_encoding php_mb_default_identify_list_ja[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_jis,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_jp,

mbfl_no_encoding_sjis

};

static const enum mbfl_no_encoding php_mb_default_identify_list_cn[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_cn,

mbfl_no_encoding_cp936

};

static const enum mbfl_no_encoding php_mb_default_identify_list_tw_hk[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_tw,

mbfl_no_encoding_big5

};

static const enum mbfl_no_encoding php_mb_default_identify_list_kr[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_euc_kr,

mbfl_no_encoding_uhc

};

static const enum mbfl_no_encoding php_mb_default_identify_list_ru[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_koi8r,

mbfl_no_encoding_cp1251,

mbfl_no_encoding_cp866

};

static const enum mbfl_no_encoding php_mb_default_identify_list_hy[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_armscii8

};

static const enum mbfl_no_encoding php_mb_default_identify_list_tr[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_cp1254,

mbfl_no_encoding_8859_9

};

static const enum mbfl_no_encoding php_mb_default_identify_list_ua[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8,

mbfl_no_encoding_koi8u

};

static const enum mbfl_no_encoding php_mb_default_identify_list_neut[] = {

mbfl_no_encoding_ascii,

mbfl_no_encoding_utf8

};

static const php_mb_nls_ident_list php_mb_default_identify_list[] = {

{ mbfl_no_language_japanese, php_mb_default_identify_list_ja, sizeof(php_mb_default_identify_list_ja) / sizeof(php_mb_default_identify_list_ja[0]) },

{ mbfl_no_language_korean, php_mb_default_identify_list_kr, sizeof(php_mb_default_identify_list_kr) / sizeof(php_mb_default_identify_list_kr[0]) },

{ mbfl_no_language_traditional_chinese, php_mb_default_identify_list_tw_hk, sizeof(php_mb_default_identify_list_tw_hk) / sizeof(php_mb_default_identify_list_tw_hk[0]) },

{ mbfl_no_language_simplified_chinese, php_mb_default_identify_list_cn, sizeof(php_mb_default_identify_list_cn) / sizeof(php_mb_default_identify_list_cn[0]) },

{ mbfl_no_language_russian, php_mb_default_identify_list_ru, sizeof(php_mb_default_identify_list_ru) / sizeof(php_mb_default_identify_list_ru[0]) },

{ mbfl_no_language_armenian, php_mb_default_identify_list_hy, sizeof(php_mb_default_identify_list_hy) / sizeof(php_mb_default_identify_list_hy[0]) },

{ mbfl_no_language_turkish, php_mb_default_identify_list_tr, sizeof(php_mb_default_identify_list_tr) / sizeof(php_mb_default_identify_list_tr[0]) },

{ mbfl_no_language_ukrainian, php_mb_default_identify_list_ua, sizeof(php_mb_default_identify_list_ua) / sizeof(php_mb_default_identify_list_ua[0]) },

{ mbfl_no_language_neutral, php_mb_default_identify_list_neut, sizeof(php_mb_default_identify_list_neut) / sizeof(php_mb_default_identify_list_neut[0]) }

};

static const zend_module_dep mbstring_deps[] = {

ZEND_MOD_REQUIRED("pcre")

ZEND_MOD_END

};

zend_module_entry mbstring_module_entry = {

STANDARD_MODULE_HEADER_EX,

NULL,

mbstring_deps,

"mbstring",

ext_functions,

PHP_MINIT(mbstring),

PHP_MSHUTDOWN(mbstring),

PHP_RINIT(mbstring),

PHP_RSHUTDOWN(mbstring),

PHP_MINFO(mbstring),

PHP_MBSTRING_VERSION,

PHP_MODULE_GLOBALS(mbstring),

PHP_GINIT(mbstring),

PHP_GSHUTDOWN(mbstring),

NULL,

STANDARD_MODULE_PROPERTIES_EX

};

static const sapi_post_entry php_post_entries[] = {

{ DEFAULT_POST_CONTENT_TYPE, sizeof(DEFAULT_POST_CONTENT_TYPE)-1, sapi_read_standard_form_data, php_std_post_handler },

{ MULTIPART_CONTENT_TYPE, sizeof(MULTIPART_CONTENT_TYPE)-1, NULL, rfc1867_post_handler },

{ NULL, 0, NULL, NULL }

};

#ifdef COMPILE_DL_MBSTRING

#ifdef ZTS

ZEND_TSRMLS_CACHE_DEFINE()

ZEND_GET_MODULE(mbstring)

static const sapi_post_entry mbstr_post_entries[] = {

{ DEFAULT_POST_CONTENT_TYPE, sizeof(DEFAULT_POST_CONTENT_TYPE)-1, sapi_read_standard_form_data, php_mb_post_handler },

{ MULTIPART_CONTENT_TYPE, sizeof(MULTIPART_CONTENT_TYPE)-1, NULL, rfc1867_post_handler },

{ NULL, 0, NULL, NULL }

};

static const mbfl_encoding *php_mb_get_encoding(zend_string *encoding_name, uint32_t arg_num) {

if (encoding_name) {

const mbfl_encoding *encoding;

zend_string *last_encoding_name = MBSTRG(last_used_encoding_name);

if (last_encoding_name && (last_encoding_name == encoding_name

|| zend_string_equals_ci(encoding_name, last_encoding_name))) {

return MBSTRG(last_used_encoding);

}

encoding = mbfl_name2encoding(ZSTR_VAL(encoding_name));

if (!encoding) {

zend_argument_value_error(arg_num, "must be a valid encoding, \"%s\" given", ZSTR_VAL(encoding_name));

return NULL;

} else if (encoding->no_encoding <= mbfl_no_encoding_qprint) {

if (encoding == &mbfl_encoding_base64) {

php_error_docref(NULL, E_DEPRECATED, "Handling Base64 via mbstring is deprecated; use base64_encode/base64_decode instead");

} else if (encoding == &mbfl_encoding_qprint) {

php_error_docref(NULL, E_DEPRECATED, "Handling QPrint via mbstring is deprecated; use quoted_printable_encode/quoted_printable_decode instead");

} else if (encoding == &mbfl_encoding_html_ent) {

php_error_docref(NULL, E_DEPRECATED, "Handling HTML entities via mbstring is deprecated; use htmlspecialchars, htmlentities, or mb_encode_numericentity/mb_decode_numericentity instead");

} else if (encoding == &mbfl_encoding_uuencode) {

php_error_docref(NULL, E_DEPRECATED, "Handling Uuencode via mbstring is deprecated; use convert_uuencode/convert_uudecode instead");

}

}

if (last_encoding_name) {

zend_string_release(last_encoding_name);

}

MBSTRG(last_used_encoding_name) = zend_string_copy(encoding_name);

MBSTRG(last_used_encoding) = encoding;

return encoding;

} else {

return MBSTRG(current_internal_encoding);

}

}

static const mbfl_encoding *php_mb_get_encoding_or_pass(const char *encoding_name) {

if (strcmp(encoding_name, "pass") == 0) {

return &mbfl_encoding_pass;

}

return mbfl_name2encoding(encoding_name);

}

static size_t count_commas(const char *p, const char *end) {

size_t count = 0;

while ((p = memchr(p, ',', end - p))) {

count++;

p++;

}

return count;

}

static zend_result php_mb_parse_encoding_list(const char *value, size_t value_length,

const mbfl_encoding ***return_list, size_t *return_size, bool persistent, uint32_t arg_num,

bool allow_pass_encoding)

{

if (value == NULL || value_length == 0) {

*return_list = NULL;

*return_size = 0;

return SUCCESS;

} else {

bool included_auto;

size_t n, size;

char *p1, *endp, *tmpstr;

const mbfl_encoding **entry, **list;

/* copy the value string for work */

if (value[0]=='"' && value[value_length-1]=='"' && value_length>2) {

tmpstr = (char *)estrndup(value+1, value_length-2);

value_length -= 2;

} else {

tmpstr = (char *)estrndup(value, value_length);

}

endp = tmpstr + value_length;

size = 1 + count_commas(tmpstr, endp) + MBSTRG(default_detect_order_list_size);

list = (const mbfl_encoding **)pecalloc(size, sizeof(mbfl_encoding*), persistent);

entry = list;

n = 0;

included_auto = 0;

p1 = tmpstr;

while (1) {

char *comma = memchr(p1, ',', endp - p1);

char *p = comma ? comma : endp;

*p = '\0';

/* trim spaces */

while (p1 < p && (*p1 == ' ' || *p1 == '\t')) {

p1++;

}

p--;

while (p > p1 && (*p == ' ' || *p == '\t')) {

*p = '\0';

p--;

}

/* convert to the encoding number and check encoding */

if (strcasecmp(p1, "auto") == 0) {

if (!included_auto) {

const enum mbfl_no_encoding *src = MBSTRG(default_detect_order_list);

const size_t identify_list_size = MBSTRG(default_detect_order_list_size);

size_t i;

included_auto = 1;

for (i = 0; i < identify_list_size; i++) {

*entry++ = mbfl_no2encoding(*src++);

n++;

}

}

} else {

const mbfl_encoding *encoding =

allow_pass_encoding ? php_mb_get_encoding_or_pass(p1) : mbfl_name2encoding(p1);

if (!encoding) {

/* Called from an INI setting modification */

if (arg_num == 0) {

php_error_docref("ref.mbstring", E_WARNING, "INI setting contains invalid encoding \"%s\"", p1);

} else {

zend_argument_value_error(arg_num, "contains invalid encoding \"%s\"", p1);

}

efree(tmpstr);

pefree(ZEND_VOIDP(list), persistent);

return FAILURE;

}

*entry++ = encoding;

n++;

}

if (n >= size || comma == NULL) {

break;

}

p1 = comma + 1;

}

*return_list = list;

*return_size = n;

efree(tmpstr);

}

return SUCCESS;

}

static int php_mb_parse_encoding_array(HashTable *target_hash, const mbfl_encoding ***return_list,

size_t *return_size, uint32_t arg_num)

{

/* Allocate enough space to include the default detect order if "auto" is used. */

size_t size = zend_hash_num_elements(target_hash) + MBSTRG(default_detect_order_list_size);

const mbfl_encoding **list = ecalloc(size, sizeof(mbfl_encoding*));

const mbfl_encoding **entry = list;

bool included_auto = 0;

size_t n = 0;

zval *hash_entry;

ZEND_HASH_FOREACH_VAL(target_hash, hash_entry) {

zend_string *encoding_str = zval_try_get_string(hash_entry);

if (UNEXPECTED(!encoding_str)) {

efree(ZEND_VOIDP(list));

return FAILURE;

}

if (zend_string_equals_literal_ci(encoding_str, "auto")) {

if (!included_auto) {

const enum mbfl_no_encoding *src = MBSTRG(default_detect_order_list);

const size_t identify_list_size = MBSTRG(default_detect_order_list_size);

size_t j;

included_auto = 1;

for (j = 0; j < identify_list_size; j++) {

*entry++ = mbfl_no2encoding(*src++);

n++;

}

}

} else {

const mbfl_encoding *encoding = mbfl_name2encoding(ZSTR_VAL(encoding_str));

if (encoding) {

*entry++ = encoding;

n++;

} else {

zend_argument_value_error(arg_num, "contains invalid encoding \"%s\"", ZSTR_VAL(encoding_str));

zend_string_release(encoding_str);

efree(ZEND_VOIDP(list));

return FAILURE;

}

}

zend_string_release(encoding_str);

} ZEND_HASH_FOREACH_END();

*return_list = list;

*return_size = n;

return SUCCESS;

}

static const zend_encoding* php_mb_zend_encoding_fetcher(const char *encoding_name)

{

return (const zend_encoding*)mbfl_name2encoding(encoding_name);

}

static const char *php_mb_zend_encoding_name_getter(const zend_encoding *encoding)

{

return ((const mbfl_encoding *)encoding)->name;

}

static bool php_mb_zend_encoding_lexer_compatibility_checker(const zend_encoding *_encoding)

{

const mbfl_encoding *encoding = (const mbfl_encoding*)_encoding;

return !(encoding->flag & MBFL_ENCTYPE_GL_UNSAFE);

}

static const zend_encoding *php_mb_zend_encoding_detector(const unsigned char *arg_string, size_t arg_length, const zend_encoding **list, size_t list_size)

{

mbfl_string string;

if (!list) {

list = (const zend_encoding **)MBSTRG(current_detect_order_list);

list_size = MBSTRG(current_detect_order_list_size);

}

mbfl_string_init(&string);

string.val = (unsigned char *)arg_string;

string.len = arg_length;

return (const zend_encoding *) mbfl_identify_encoding(&string, (const mbfl_encoding **)list, list_size, 0);

}

static size_t php_mb_zend_encoding_converter(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length, const zend_encoding *encoding_to, const zend_encoding *encoding_from)

{

mbfl_string string, result;

mbfl_buffer_converter *convd;

/* new encoding */

/* initialize string */

string.encoding = (const mbfl_encoding*)encoding_from;

string.val = (unsigned char*)from;

string.len = from_length;

/* initialize converter */

convd = mbfl_buffer_converter_new((const mbfl_encoding *)encoding_from, (const mbfl_encoding *)encoding_to, string.len);

if (convd == NULL) {

return (size_t) -1;

}

mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode));

mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar));

/* do it */

size_t loc = mbfl_buffer_converter_feed(convd, &string);

mbfl_buffer_converter_flush(convd);

mbfl_string_init(&result);

if (!mbfl_buffer_converter_result(convd, &result)) {

mbfl_buffer_converter_delete(convd);

return (size_t)-1;

}

*to = result.val;

*to_length = result.len;

mbfl_buffer_converter_delete(convd);

return loc;

}

static zend_result php_mb_zend_encoding_list_parser(const char *encoding_list, size_t encoding_list_len, const zend_encoding ***return_list, size_t *return_size, bool persistent)

{

return php_mb_parse_encoding_list(

encoding_list, encoding_list_len,

(const mbfl_encoding ***)return_list, return_size,

persistent, /* arg_num */ 0, /* allow_pass_encoding */ 1);

}

static const zend_encoding *php_mb_zend_internal_encoding_getter(void)

{

return (const zend_encoding *)MBSTRG(internal_encoding);

}

static zend_result php_mb_zend_internal_encoding_setter(const zend_encoding *encoding)

{

MBSTRG(internal_encoding) = (const mbfl_encoding *)encoding;

return SUCCESS;

}

static zend_multibyte_functions php_mb_zend_multibyte_functions = {

"mbstring",

php_mb_zend_encoding_fetcher,

php_mb_zend_encoding_name_getter,

php_mb_zend_encoding_lexer_compatibility_checker,

php_mb_zend_encoding_detector,

php_mb_zend_encoding_converter,

php_mb_zend_encoding_list_parser,

php_mb_zend_internal_encoding_getter,

php_mb_zend_internal_encoding_setter

};

static void *_php_mb_compile_regex(const char *pattern)

{

pcre2_code *retval;

PCRE2_SIZE err_offset;

int errnum;

if (!(retval = pcre2_compile((PCRE2_SPTR)pattern, PCRE2_ZERO_TERMINATED,

PCRE2_CASELESS, &errnum, &err_offset, php_pcre_cctx()))) {

PCRE2_UCHAR err_str[128];

pcre2_get_error_message(errnum, err_str, sizeof(err_str));

php_error_docref(NULL, E_WARNING, "%s (offset=%zu): %s", pattern, err_offset, err_str);

}

return retval;

}

static int _php_mb_match_regex(void *opaque, const char *str, size_t str_len)

{

int res;

pcre2_match_data *match_data = php_pcre_create_match_data(0, opaque);

if (NULL == match_data) {

pcre2_code_free(opaque);

php_error_docref(NULL, E_WARNING, "Cannot allocate match data");

return FAILURE;

}

res = pcre2_match(opaque, (PCRE2_SPTR)str, str_len, 0, 0, match_data, php_pcre_mctx()) >= 0;

php_pcre_free_match_data(match_data);

return res;

}

static void _php_mb_free_regex(void *opaque)

{

pcre2_code_free(opaque);

}

static int php_mb_nls_get_default_detect_order_list(enum mbfl_no_language lang, enum mbfl_no_encoding **plist, size_t *plist_size)

{

size_t i;

*plist = (enum mbfl_no_encoding *) php_mb_default_identify_list_neut;

*plist_size = sizeof(php_mb_default_identify_list_neut) / sizeof(php_mb_default_identify_list_neut[0]);

for (i = 0; i < sizeof(php_mb_default_identify_list) / sizeof(php_mb_default_identify_list[0]); i++) {

if (php_mb_default_identify_list[i].lang == lang) {

*plist = (enum mbfl_no_encoding *)php_mb_default_identify_list[i].list;

*plist_size = php_mb_default_identify_list[i].list_size;

return 1;

}

}

return 0;

}

static char *php_mb_rfc1867_substring_conf(const zend_encoding *encoding, char *start, size_t len, char quote)

{

char *result = emalloc(len + 2);

char *resp = result;

size_t i;

for (i = 0; i < len && start[i] != quote; ++i) {

if (start[i] == '\\' && (start[i + 1] == '\\' || (quote && start[i + 1] == quote))) {

*resp++ = start[++i];

} else {

size_t j = php_mb_mbchar_bytes(start+i, (const mbfl_encoding *)encoding);

while (j-- > 0 && i < len) {

*resp++ = start[i++];

}

--i;

}

}

*resp = '\0';

return result;

}

static char *php_mb_rfc1867_getword(const zend_encoding *encoding, char **line, char stop) /* {{{ */

{

char *pos = *line, quote;

char *res;

while (*pos && *pos != stop) {

if ((quote = *pos) == '"' || quote == '\'') {

++pos;

while (*pos && *pos != quote) {

if (*pos == '\\' && pos[1] && pos[1] == quote) {

pos += 2;

} else {

++pos;

}

}

if (*pos) {

++pos;

}

} else {

pos += php_mb_mbchar_bytes(pos, (const mbfl_encoding *)encoding);

}

}

if (*pos == '\0') {

res = estrdup(*line);

*line += strlen(*line);

return res;

}

res = estrndup(*line, pos - *line);

while (*pos == stop) {

pos += php_mb_mbchar_bytes(pos, (const mbfl_encoding *)encoding);

}

*line = pos;

return res;

}

static char *php_mb_rfc1867_getword_conf(const zend_encoding *encoding, char *str) /* {{{ */

{

while (*str && isspace(*(unsigned char *)str)) {

++str;

}

if (!*str) {

return estrdup("");

}

if (*str == '"' || *str == '\'') {

char quote = *str;

str++;

return php_mb_rfc1867_substring_conf(encoding, str, strlen(str), quote);

} else {

char *strend = str;

while (*strend && !isspace(*(unsigned char *)strend)) {

++strend;

}

return php_mb_rfc1867_substring_conf(encoding, str, strend - str, 0);

}

}

static char *php_mb_rfc1867_basename(const zend_encoding *encoding, char *filename) /* {{{ */

{

char *s, *s2;

const size_t filename_len = strlen(filename);

/* The \ check should technically be needed for win32 systems only where

s = php_mb_safe_strrchr(filename, '\\', filename_len, (const mbfl_encoding *)encoding);

s2 = php_mb_safe_strrchr(filename, '/', filename_len, (const mbfl_encoding *)encoding);

if (s && s2) {

if (s > s2) {

return ++s;

} else {

return ++s2;

}

} else if (s) {

return ++s;

} else if (s2) {

return ++s2;

} else {

return filename;

}

}

static PHP_INI_MH(OnUpdate_mbstring_language)

{

enum mbfl_no_language no_language;

no_language = mbfl_name2no_language(ZSTR_VAL(new_value));

if (no_language == mbfl_no_language_invalid) {

MBSTRG(language) = mbfl_no_language_neutral;

return FAILURE;

}

MBSTRG(language) = no_language;

php_mb_nls_get_default_detect_order_list(no_language, &MBSTRG(default_detect_order_list), &MBSTRG(default_detect_order_list_size));

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_detect_order)

{

const mbfl_encoding **list;

size_t size;

if (!new_value) {

if (MBSTRG(detect_order_list)) {

pefree(ZEND_VOIDP(MBSTRG(detect_order_list)), 1);

}

MBSTRG(detect_order_list) = NULL;

MBSTRG(detect_order_list_size) = 0;

return SUCCESS;

}

if (FAILURE == php_mb_parse_encoding_list(ZSTR_VAL(new_value), ZSTR_LEN(new_value), &list, &size, /* persistent */ 1, /* arg_num */ 0, /* allow_pass_encoding */ 0) || size == 0) {

return FAILURE;

}

if (MBSTRG(detect_order_list)) {

pefree(ZEND_VOIDP(MBSTRG(detect_order_list)), 1);

}

MBSTRG(detect_order_list) = list;

MBSTRG(detect_order_list_size) = size;

return SUCCESS;

}

static int _php_mb_ini_mbstring_http_input_set(const char *new_value, size_t new_value_length) {

const mbfl_encoding **list;

size_t size;

if (FAILURE == php_mb_parse_encoding_list(new_value, new_value_length, &list, &size, /* persistent */ 1, /* arg_num */ 0, /* allow_pass_encoding */ 1) || size == 0) {

return FAILURE;

}

if (MBSTRG(http_input_list)) {

pefree(ZEND_VOIDP(MBSTRG(http_input_list)), 1);

}

MBSTRG(http_input_list) = list;

MBSTRG(http_input_list_size) = size;

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_http_input)

{

if (new_value) {

php_error_docref("ref.mbstring", E_DEPRECATED, "Use of mbstring.http_input is deprecated");

}

if (!new_value || !ZSTR_VAL(new_value)) {

const char *encoding = php_get_input_encoding();

MBSTRG(http_input_set) = 0;

_php_mb_ini_mbstring_http_input_set(encoding, strlen(encoding));

return SUCCESS;

}

MBSTRG(http_input_set) = 1;

return _php_mb_ini_mbstring_http_input_set(ZSTR_VAL(new_value), ZSTR_LEN(new_value));

}

static int _php_mb_ini_mbstring_http_output_set(const char *new_value) {

const mbfl_encoding *encoding = php_mb_get_encoding_or_pass(new_value);

if (!encoding) {

return FAILURE;

}

MBSTRG(http_output_encoding) = encoding;

MBSTRG(current_http_output_encoding) = encoding;

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_http_output)

{

if (new_value) {

php_error_docref("ref.mbstring", E_DEPRECATED, "Use of mbstring.http_output is deprecated");

}

if (new_value == NULL || ZSTR_LEN(new_value) == 0) {

MBSTRG(http_output_set) = 0;

_php_mb_ini_mbstring_http_output_set(php_get_output_encoding());

return SUCCESS;

}

MBSTRG(http_output_set) = 1;

return _php_mb_ini_mbstring_http_output_set(ZSTR_VAL(new_value));

}

static int _php_mb_ini_mbstring_internal_encoding_set(const char *new_value, size_t new_value_length)

{

const mbfl_encoding *encoding;

if (!new_value || !new_value_length || !(encoding = mbfl_name2encoding(new_value))) {

/* falls back to UTF-8 if an unknown encoding name is given */

if (new_value) {

php_error_docref("ref.mbstring", E_WARNING, "Unknown encoding \"%s\" in ini setting", new_value);

}

encoding = &mbfl_encoding_utf8;

}

MBSTRG(internal_encoding) = encoding;

MBSTRG(current_internal_encoding) = encoding;

#ifdef HAVE_MBREGEX

{

const char *enc_name = new_value;

if (FAILURE == php_mb_regex_set_default_mbctype(enc_name)) {

/* falls back to UTF-8 if an unknown encoding name is given */

enc_name = "UTF-8";

php_mb_regex_set_default_mbctype(enc_name);

}

php_mb_regex_set_mbctype(new_value);

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_internal_encoding)

{

if (new_value) {

php_error_docref("ref.mbstring", E_DEPRECATED, "Use of mbstring.internal_encoding is deprecated");

}

if (OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage) == FAILURE) {

return FAILURE;

}

if (new_value && ZSTR_LEN(new_value)) {

MBSTRG(internal_encoding_set) = 1;

return _php_mb_ini_mbstring_internal_encoding_set(ZSTR_VAL(new_value), ZSTR_LEN(new_value));

} else {

const char *encoding = php_get_internal_encoding();

MBSTRG(internal_encoding_set) = 0;

return _php_mb_ini_mbstring_internal_encoding_set(encoding, strlen(encoding));

}

}

static PHP_INI_MH(OnUpdate_mbstring_substitute_character)

{

int c;

char *endptr = NULL;

if (new_value != NULL) {

if (zend_string_equals_literal_ci(new_value, "none")) {

MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE;

MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE;

} else if (zend_string_equals_literal_ci(new_value, "long")) {

MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG;

MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG;

} else if (zend_string_equals_literal_ci(new_value, "entity")) {

MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY;

MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY;

} else {

MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;

MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;

if (ZSTR_LEN(new_value) > 0) {

c = strtol(ZSTR_VAL(new_value), &endptr, 0);

if (*endptr == '\0') {

MBSTRG(filter_illegal_substchar) = c;

MBSTRG(current_filter_illegal_substchar) = c;

}

}

}

} else {

MBSTRG(filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;

MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;

MBSTRG(filter_illegal_substchar) = 0x3f; /* '?' */

MBSTRG(current_filter_illegal_substchar) = 0x3f; /* '?' */

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_encoding_translation)

{

if (new_value == NULL) {

return FAILURE;

}

OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

if (MBSTRG(encoding_translation)) {

sapi_unregister_post_entry(php_post_entries);

sapi_register_post_entries(mbstr_post_entries);

} else {

sapi_unregister_post_entry(mbstr_post_entries);

sapi_register_post_entries(php_post_entries);

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdate_mbstring_http_output_conv_mimetypes)

{

zend_string *tmp;

void *re = NULL;

if (!new_value) {

new_value = entry->orig_value;

}

tmp = php_trim(new_value, NULL, 0, 3);

if (ZSTR_LEN(tmp) > 0) {

if (!(re = _php_mb_compile_regex(ZSTR_VAL(tmp)))) {

zend_string_release_ex(tmp, 0);

return FAILURE;

}

}

if (MBSTRG(http_output_conv_mimetypes)) {

_php_mb_free_regex(MBSTRG(http_output_conv_mimetypes));

}

MBSTRG(http_output_conv_mimetypes) = re;

zend_string_release_ex(tmp, 0);

return SUCCESS;

}

PHP_INI_BEGIN()

PHP_INI_ENTRY("mbstring.language", "neutral", PHP_INI_ALL, OnUpdate_mbstring_language)

PHP_INI_ENTRY("mbstring.detect_order", NULL, PHP_INI_ALL, OnUpdate_mbstring_detect_order)

PHP_INI_ENTRY("mbstring.http_input", NULL, PHP_INI_ALL, OnUpdate_mbstring_http_input)

PHP_INI_ENTRY("mbstring.http_output", NULL, PHP_INI_ALL, OnUpdate_mbstring_http_output)

STD_PHP_INI_ENTRY("mbstring.internal_encoding", NULL, PHP_INI_ALL, OnUpdate_mbstring_internal_encoding, internal_encoding_name, zend_mbstring_globals, mbstring_globals)

PHP_INI_ENTRY("mbstring.substitute_character", NULL, PHP_INI_ALL, OnUpdate_mbstring_substitute_character)

STD_PHP_INI_BOOLEAN("mbstring.encoding_translation", "0",

PHP_INI_SYSTEM | PHP_INI_PERDIR,

OnUpdate_mbstring_encoding_translation,

encoding_translation, zend_mbstring_globals, mbstring_globals)

PHP_INI_ENTRY("mbstring.http_output_conv_mimetypes",

"^(text/|application/xhtml\\+xml)",

PHP_INI_ALL,

OnUpdate_mbstring_http_output_conv_mimetypes)

STD_PHP_INI_BOOLEAN("mbstring.strict_detection", "0",

PHP_INI_ALL,

OnUpdateBool,

strict_detection, zend_mbstring_globals, mbstring_globals)

#ifdef HAVE_MBREGEX

STD_PHP_INI_ENTRY("mbstring.regex_stack_limit", "100000",PHP_INI_ALL, OnUpdateLong, regex_stack_limit, zend_mbstring_globals, mbstring_globals)

STD_PHP_INI_ENTRY("mbstring.regex_retry_limit", "1000000",PHP_INI_ALL, OnUpdateLong, regex_retry_limit, zend_mbstring_globals, mbstring_globals)

PHP_INI_END()

static void mbstring_internal_encoding_changed_hook(void) {

/* One of the internal_encoding / input_encoding / output_encoding ini settings changed. */

if (!MBSTRG(internal_encoding_set)) {

const char *encoding = php_get_internal_encoding();

_php_mb_ini_mbstring_internal_encoding_set(encoding, strlen(encoding));

}

if (!MBSTRG(http_output_set)) {

const char *encoding = php_get_output_encoding();

_php_mb_ini_mbstring_http_output_set(encoding);

}

if (!MBSTRG(http_input_set)) {

const char *encoding = php_get_input_encoding();

_php_mb_ini_mbstring_http_input_set(encoding, strlen(encoding));

}

}

static PHP_GINIT_FUNCTION(mbstring)

{

#if defined(COMPILE_DL_MBSTRING) && defined(ZTS)

ZEND_TSRMLS_CACHE_UPDATE();

mbstring_globals->language = mbfl_no_language_uni;

mbstring_globals->internal_encoding = NULL;

mbstring_globals->current_internal_encoding = mbstring_globals->internal_encoding;

mbstring_globals->http_output_encoding = &mbfl_encoding_pass;

mbstring_globals->current_http_output_encoding = &mbfl_encoding_pass;

mbstring_globals->http_input_identify = NULL;