Use known zend_string instead of C string

Girgias · Girgias · commit 2034bc5a0c02 · 2023-06-06T17:01:30.000+01:00
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -4560,7 +4560,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry
 		}
 	}
 
-	if (zend_string_equals_literal_ci(name, "class")) {
+	if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_CLASS))) {
 		zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR,
 				"A class constant must not be called 'class'; it is reserved for class name fetching");
 	}
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
@@ -101,7 +101,7 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_constant(zend_string *name, ze
 
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_class_const_or_name(zend_ast *class_name, zend_ast *name) {
 	zend_string *name_str = zend_ast_get_str(name);
-	if (zend_string_equals_literal_ci(name_str, "class")) {
+	if (zend_string_equals_ci(name_str, ZSTR_KNOWN(ZEND_STR_CLASS))) {
 		zend_string_release(name_str);
 		return zend_ast_create(ZEND_AST_CLASS_NAME, class_name);
 	} else {
diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c
@@ -114,7 +114,7 @@ ZEND_METHOD(SensitiveParameterValue, __construct)
 		Z_PARAM_ZVAL(value)
 	ZEND_PARSE_PARAMETERS_END();
 
-	zend_update_property(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), "value", strlen("value"), value);
+	zend_update_property_ex(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), ZSTR_KNOWN(ZEND_STR_VALUE), value);
 }
 
 ZEND_METHOD(SensitiveParameterValue, getValue)
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
@@ -1322,7 +1322,7 @@ ZEND_FUNCTION(get_defined_functions)
 	} ZEND_HASH_FOREACH_END();
 
 	zend_hash_str_add_new(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal);
-	zend_hash_str_add_new(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user);
+	zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_USER), &user);
 }
 /* }}} */
 
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -1429,7 +1429,7 @@ ZEND_API zend_string *zend_type_to_string(zend_type type) {
 }
 
 static bool is_generator_compatible_class_type(zend_string *name) {
-	return zend_string_equals_literal_ci(name, "Traversable")
+	return zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_TRAVERSABLE))
 		|| zend_string_equals_literal_ci(name, "Iterator")
 		|| zend_string_equals_literal_ci(name, "Generator");
 }
diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c
@@ -62,12 +62,12 @@ static void zend_verify_enum_properties(zend_class_entry *ce)
 	zend_property_info *property_info;
 
 	ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, property_info) {
-		if (zend_string_equals_literal(property_info->name, "name")) {
+		if (zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_NAME))) {
 			continue;
 		}
 		if (
 			ce->enum_backing_type != IS_UNDEF
-			&& zend_string_equals_literal(property_info->name, "value")
+			&& zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_VALUE))
 		) {
 			continue;
 		}
diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c
@@ -344,8 +344,8 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry
 		&class_type->function_table, "rewind", sizeof("rewind") - 1);
 	funcs_ptr->zf_valid = zend_hash_str_find_ptr(
 		&class_type->function_table, "valid", sizeof("valid") - 1);
-	funcs_ptr->zf_key = zend_hash_str_find_ptr(
-		&class_type->function_table, "key", sizeof("key") - 1);
+	funcs_ptr->zf_key = zend_hash_find_ptr(
+		&class_type->function_table, ZSTR_KNOWN(ZEND_STR_KEY));
 	funcs_ptr->zf_current = zend_hash_str_find_ptr(
 		&class_type->function_table, "current", sizeof("current") - 1);
 	funcs_ptr->zf_next = zend_hash_str_find_ptr(
diff --git a/ext/curl/interface.c b/ext/curl/interface.c
@@ -1377,7 +1377,7 @@ static inline zend_result build_mime_structure_from_hash(php_curl *ch, zval *zpo
 			curl_seek_callback seekfunc = seek_cb;
 #endif
 
-			prop = zend_read_property(curl_CURLFile_class, Z_OBJ_P(current), "name", sizeof("name")-1, 0, &rv);
+			prop = zend_read_property_ex(curl_CURLFile_class, Z_OBJ_P(current), ZSTR_KNOWN(ZEND_STR_NAME), /* silent */ false, &rv);
 			ZVAL_DEREF(prop);
 			if (Z_TYPE_P(prop) != IS_STRING) {
 				php_error_docref(NULL, E_WARNING, "Invalid filename for key %s", ZSTR_VAL(string_key));
diff --git a/ext/dom/node.c b/ext/dom/node.c
@@ -1622,7 +1622,8 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
 		zval *tmp;
 		char *xquery;
 
-		tmp = zend_hash_str_find(ht, "query", sizeof("query")-1);
+		/* Find "query" key */
+		tmp = zend_hash_find(ht, ZSTR_KNOWN(ZEND_STR_QUERY));
 		if (!tmp) {
 			/* if mode == 0 then $xpath arg is 3, if mode == 1 then $xpath is 4 */
 			zend_argument_value_error(3 + mode, "must have a \"query\" key");
diff --git a/ext/ftp/ftp.c b/ext/ftp/ftp.c
@@ -708,7 +708,7 @@ ftp_mlsd_parse_line(HashTable *ht, const char *input) {
 
 	/* Extract pathname */
 	ZVAL_STRINGL(&zstr, sp + 1, end - sp - 1);
-	zend_hash_str_update(ht, "name", sizeof("name")-1, &zstr);
+	zend_hash_update(ht, ZSTR_KNOWN(ZEND_STR_NAME), &zstr);
 	end = sp;
 
 	while (input < end) {
diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
@@ -412,7 +412,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 	struct berval control_value = { 0L, NULL };
 	int control_value_alloc = 0;
 
-	if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "value", sizeof("value") - 1)) != NULL) {
+	if ((val = zend_hash_find(Z_ARRVAL_P(array), ZSTR_KNOWN(ZEND_STR_VALUE))) != NULL) {
 		if (Z_TYPE_P(val) != IS_ARRAY) {
 			tmpstring = zval_get_string(val);
 			if (EG(exception)) {
diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
@@ -4822,7 +4822,7 @@ ZEND_EXT_API int zend_jit_config(zend_string *jit, int stage)
 		JIT_G(trigger) = ZEND_JIT_ON_HOT_TRACE;
 		JIT_G(opt_flags) = ZEND_JIT_REG_ALLOC_GLOBAL | ZEND_JIT_CPU_AVX;
 		return SUCCESS;
-	} else if (zend_string_equals_literal_ci(jit, "function")) {
+	} else if (zend_string_equals_ci(jit, ZSTR_KNOWN(ZEND_STR_FUNCTION))) {
 		JIT_G(enabled) = 1;
 		JIT_G(on) = 1;
 		JIT_G(opt_level) = ZEND_JIT_LEVEL_OPT_SCRIPT;
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
@@ -1121,7 +1121,7 @@ void zend_update_parent_ce(zend_class_entry *ce)
 			if (zend_class_implements_interface(ce, zend_ce_iterator)) {
 				ce->iterator_funcs_ptr->zf_rewind = zend_hash_str_find_ptr(&ce->function_table, "rewind", sizeof("rewind") - 1);
 				ce->iterator_funcs_ptr->zf_valid = zend_hash_str_find_ptr(&ce->function_table, "valid", sizeof("valid") - 1);
-				ce->iterator_funcs_ptr->zf_key = zend_hash_str_find_ptr(&ce->function_table, "key", sizeof("key") - 1);
+				ce->iterator_funcs_ptr->zf_key = zend_hash_find_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_KEY));
 				ce->iterator_funcs_ptr->zf_current = zend_hash_str_find_ptr(&ce->function_table, "current", sizeof("current") - 1);
 				ce->iterator_funcs_ptr->zf_next = zend_hash_str_find_ptr(&ce->function_table, "next", sizeof("next") - 1);
 			}
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -7137,7 +7137,7 @@ ZEND_METHOD(ReflectionFiber, getCallable)
 static zval *_reflection_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot)
 {
 	if (zend_hash_exists(&object->ce->properties_info, name)
-		&& (zend_string_equals_literal(name, "name") || zend_string_equals_literal(name, "class")))
+		&& (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_NAME)) || zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_CLASS))))
 	{
 		zend_throw_exception_ex(reflection_exception_ptr, 0,
 			"Cannot set read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name));
diff --git a/ext/session/session.c b/ext/session/session.c
@@ -1927,7 +1927,7 @@ PHP_FUNCTION(session_module_name)
 	}
 
 	if (name) {
-		if (zend_string_equals_literal_ci(name, "user")) {
+		if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_USER))) {
 			zend_argument_value_error(1, "cannot be \"user\"");
 			RETURN_THROWS();
 		}
@@ -1967,7 +1967,7 @@ static inline void set_user_save_handler_ini(void) {
 	zend_string *ini_name, *ini_val;
 
 	ini_name = ZSTR_INIT_LITERAL("session.save_handler", 0);
-	ini_val = ZSTR_INIT_LITERAL("user", 0);
+	ini_val = ZSTR_KNOWN(ZEND_STR_USER);
 	PS(set_handler) = 1;
 	zend_alter_ini_entry(ini_name, ini_val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
 	PS(set_handler) = 0;
diff --git a/ext/soap/soap.c b/ext/soap/soap.c
@@ -584,8 +584,8 @@ PHP_METHOD(SoapFault, __toString)
 	this_ptr = ZEND_THIS;
 	faultcode = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "faultcode", sizeof("faultcode")-1, 1, &rv1);
 	faultstring = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "faultstring", sizeof("faultstring")-1, 1, &rv2);
-	file = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr) ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv));
-	line = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr), ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv));
+	file = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr), ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv3);
+	line = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr), ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv4);
 
 	zend_call_method_with_0_params(
 		Z_OBJ_P(ZEND_THIS), Z_OBJCE_P(ZEND_THIS), NULL, "gettraceasstring", &trace);
@@ -1943,7 +1943,7 @@ PHP_METHOD(SoapClient, __construct)
 				php_stream_context_set_option(context, "ssl", "passphrase", tmp);
 			}
 		}
-		if ((tmp = zend_hash_str_find(ht, "trace", sizeof("trace")-1)) != NULL &&
+		if ((tmp = zend_hash_find(ht, ZSTR_KNOWN(ZEND_STR_TRACE))) != NULL &&
 		    (Z_TYPE_P(tmp) == IS_TRUE ||
 		     (Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) == 1))) {
 			ZVAL_TRUE(Z_CLIENT_TRACE_P(this_ptr));
diff --git a/ext/sodium/libsodium.c b/ext/sodium/libsodium.c
@@ -125,12 +125,12 @@ ZEND_GET_MODULE(sodium)
 /* Remove argument information from backtrace to prevent information leaks */
 static void sodium_remove_param_values_from_backtrace(zend_object *obj) {
 	zval rv;
-	zval *trace = zend_read_property(zend_get_exception_base(obj), obj, "trace", sizeof("trace")-1, 0, &rv);
+	zval *trace = zend_read_property_ex(zend_get_exception_base(obj), obj, ZSTR_KNOWN(ZEND_STR_TRACE), /* silent */ false, &rv);
 	if (trace && Z_TYPE_P(trace) == IS_ARRAY) {
 		zval *frame;
 		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(trace), frame) {
 			if (Z_TYPE_P(frame) == IS_ARRAY) {
-				zval *args = zend_hash_str_find(Z_ARRVAL_P(frame), "args", sizeof("args")-1);
+				zval *args = zend_hash_find(Z_ARRVAL_P(frame), ZSTR_KNOWN(ZEND_STR_ARGS));
 				if (args) {
 					zval_ptr_dtor(args);
 					ZVAL_EMPTY_ARRAY(args);
diff --git a/ext/xml/xml.c b/ext/xml/xml.c
@@ -762,7 +762,7 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 	if (parser->lastwasopen) {
 		zval *myval;
 		/* check if the current tag already has a value - if yes append to that! */
-		if ((myval = zend_hash_str_find(Z_ARRVAL_P(parser->ctag), "value", sizeof("value") - 1))) {
+		if ((myval = zend_hash_find(Z_ARRVAL_P(parser->ctag), ZSTR_KNOWN(ZEND_STR_VALUE)))) {
 			size_t newlen = Z_STRLEN_P(myval) + ZSTR_LEN(decoded_value);
 			Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
 			strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
@@ -781,7 +781,7 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 		ZEND_HASH_REVERSE_FOREACH_VAL(Z_ARRVAL(parser->data), curtag) {
 			if ((mytype = zend_hash_str_find(Z_ARRVAL_P(curtag),"type", sizeof("type") - 1))) {
 				if (zend_string_equals_literal(Z_STR_P(mytype), "cdata")) {
-					if ((myval = zend_hash_str_find(Z_ARRVAL_P(curtag), "value", sizeof("value") - 1))) {
+					if ((myval = zend_hash_find(Z_ARRVAL_P(curtag), ZSTR_KNOWN(ZEND_STR_VALUE)))) {
 						size_t newlen = Z_STRLEN_P(myval) + ZSTR_LEN(decoded_value);
 						Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
 						strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
diff --git a/main/main.c b/main/main.c
@@ -169,7 +169,7 @@ static PHP_INI_MH(OnSetFacility)
 	}
 #endif
 #ifdef LOG_USER
-	if (zend_string_equals_literal(facility, "LOG_USER") || zend_string_equals_literal(facility, "user")) {
+	if (zend_string_equals(facility, ZSTR_KNOWN(ZEND_STR_USER)) || zend_string_equals_literal(facility, "LOG_USER")) {
 		PG(syslog_facility) = LOG_USER;
 		return SUCCESS;
 	}
diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c
@@ -361,7 +361,7 @@ static void append_essential_headers(smart_str* buffer, php_cli_server_client *c
 	zval *val;
 	struct timeval tv = {0};
 
-	if (NULL != (val = zend_hash_str_find(&client->request.headers, "host", sizeof("host")-1))) {
+	if (NULL != (val = zend_hash_find(&client->request.headers, ZSTR_KNOWN(ZEND_STR_HOST)))) {
 		smart_str_appends_ex(buffer, "Host: ", persistent);
 		smart_str_append_ex(buffer, Z_STR_P(val), persistent);
 		smart_str_appends_ex(buffer, "\r\n", persistent);
diff --git a/sapi/phpdbg/phpdbg_frame.c b/sapi/phpdbg/phpdbg_frame.c
@@ -171,24 +171,24 @@ static void phpdbg_dump_prototype(zval *tmp) /* {{{ */
 {
 	zval *funcname, *class, class_zv, *args, *argstmp;
 
-	funcname = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("function"));
+	funcname = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_FUNCTION));
 
-	if ((class = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("object")))) {
+	if ((class = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_OBJECT)))) {
 		ZVAL_NEW_STR(&class_zv, Z_OBJCE_P(class)->name);
 		class = &class_zv;
 	} else {
-		class = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("class"));
+		class = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_CLASS));
 	}
 
 	if (class) {
-		zval *type = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("type"));
+		zval *type = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_TYPE));
 
 		phpdbg_out("%s%s%s(", Z_STRVAL_P(class), Z_STRVAL_P(type), Z_STRVAL_P(funcname));
 	} else {
 		phpdbg_out("%s(", Z_STRVAL_P(funcname));
 	}
 
-	args = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("args"));
+	args = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_ARGS));
 
 	if (args) {
 		const zend_function *func = NULL;

Original file line number	Diff line number	Diff line change
`@@ -4560,7 +4560,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry`
`4560`	`4560`	`}`
`4561`	`4561`	`}`
`4562`	`4562`
`4563`		`- if (zend_string_equals_literal_ci(name, "class")) {`
	`4563`	`+ if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_CLASS))) {`
`4564`	`4564`	`zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR,`
`4565`	`4565`	`"A class constant must not be called 'class'; it is reserved for class name fetching");`
`4566`	`4566`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ ZEND_METHOD(SensitiveParameterValue, __construct)`
`114`	`114`	`Z_PARAM_ZVAL(value)`
`115`	`115`	`ZEND_PARSE_PARAMETERS_END();`
`116`	`116`
`117`		`- zend_update_property(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), "value", strlen("value"), value);`
	`117`	`+ zend_update_property_ex(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), ZSTR_KNOWN(ZEND_STR_VALUE), value);`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`ZEND_METHOD(SensitiveParameterValue, getValue)`
Original file line number	Diff line number	Diff line change
`@@ -1322,7 +1322,7 @@ ZEND_FUNCTION(get_defined_functions)`
`1322`	`1322`	`} ZEND_HASH_FOREACH_END();`
`1323`	`1323`
`1324`	`1324`	`zend_hash_str_add_new(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal);`
`1325`		`- zend_hash_str_add_new(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user);`
	`1325`	`+ zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_USER), &user);`
`1326`	`1326`	`}`
`1327`	`1327`	`/* }}} */`
`1328`	`1328`
Original file line number	Diff line number	Diff line change
`@@ -1429,7 +1429,7 @@ ZEND_API zend_string *zend_type_to_string(zend_type type) {`
`1429`	`1429`	`}`
`1430`	`1430`
`1431`	`1431`	`static bool is_generator_compatible_class_type(zend_string *name) {`
`1432`		`- return zend_string_equals_literal_ci(name, "Traversable")`
	`1432`	`+ return zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_TRAVERSABLE))`
`1433`	`1433`	`\|\| zend_string_equals_literal_ci(name, "Iterator")`
`1434`	`1434`	`\|\| zend_string_equals_literal_ci(name, "Generator");`
`1435`	`1435`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,12 @@ static void zend_verify_enum_properties(zend_class_entry *ce)`
`62`	`62`	`zend_property_info *property_info;`
`63`	`63`
`64`	`64`	`ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, property_info) {`
`65`		`- if (zend_string_equals_literal(property_info->name, "name")) {`
	`65`	`+ if (zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_NAME))) {`
`66`	`66`	`continue;`
`67`	`67`	`}`
`68`	`68`	`if (`
`69`	`69`	`ce->enum_backing_type != IS_UNDEF`
`70`		`- && zend_string_equals_literal(property_info->name, "value")`
	`70`	`+ && zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_VALUE))`
`71`	`71`	`) {`
`72`	`72`	`continue;`
`73`	`73`	`}`