用Php扩展实现的简单框架 - 3

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"
#include "ext/standard/url.h"
#include "SAPI.h"
#include "php_kiss.h"

#include "kiss_const.c"
#include "kiss_inner.c"

// #define KISS_DEPS /** HAVE_SIMPLEXML */

#ifdef KISS_DEPS /** HAVE_SIMPLEXML */
static zend_module_dep kiss_deps[] = {
// ZEND_MOD_REQUIRED("libxml")

// ZEND_MOD_REQUIRED("simplexml")

{NULL, NULL, NULL}
};
#endif

/* True global resources - no need for thread safety here */
// static HashTable hosts_rw;

ZEND_DECLARE_MODULE_GLOBALS(kiss)

zend_function_entry action_mtds[] = {

PHP_ME(KissAction, __construct, NULL, ZEND_ACC_PUBLIC)

// PHP_ME(KissAction, init, NULL, ZEND_ACC_PUBLIC)

// PHP_ABSTRACT_ME(KissAction, init, NULL)

{NULL, NULL, NULL}

};

zend_function_entry listener_mtds[] = {

PHP_ME(KissListener, __construct, NULL, ZEND_ACC_PUBLIC)

PHP_ME(KissListener, preDispatch, NULL, ZEND_ACC_PUBLIC)

PHP_ME(KissListener, postDispatch, NULL, ZEND_ACC_PUBLIC)

{NULL, NULL, NULL}

};

zend_function_entry kiss_functions[] = {

PHP_FE(kiss_cli_test,    NULL)
PHP_FE(kiss_status,    NULL)

PHP_FE(kiss_front_start,    NULL)
PHP_FE(kiss_eval, NULL)
PHP_FE(kiss_forward, NULL)
PHP_FE(kiss_redirect, NULL)
PHP_FE(kiss_request_get, NULL)
PHP_FE(kiss_request_query, NULL)
PHP_FE(kiss_request_post, NULL)
PHP_FE(kiss_request_params, NULL)
PHP_FE(kiss_set_rule, NULL)
PHP_FE(kiss_clear_rules, NULL)
PHP_FE(kiss_set_listener, NULL)
{NULL, NULL, NULL}
};

zend_module_entry kiss_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
#ifdef KISS_DEPS /** HAVE_SIMPLEXML */
STANDARD_MODULE_HEADER_EX, NULL,
kiss_deps,
#else
STANDARD_MODULE_HEADER,
#endif
#endif
"kiss",
kiss_functions,
PHP_MINIT(kiss),
PHP_MSHUTDOWN(kiss),
PHP_RINIT(kiss),
PHP_RSHUTDOWN(kiss),
PHP_MINFO(kiss),
#if ZEND_MODULE_API_NO >= 20010901
KISS_VERSION,
#endif
STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_KISS
ZEND_GET_MODULE(kiss)
#endif

PHP_INI_BEGIN()
STD_PHP_INI_ENTRY(CFG_FILE_ENTRY, DEFAULT_CFG_FILE, PHP_INI_SYSTEM, /
OnUpdateString, cfg_file, zend_kiss_globals, kiss_globals)
PHP_INI_END()

/** co: zval **, var: global-var, type of zval* */
#define clear_var_pzval(co, var) { /
(co) = &KISS_G(var); if(*(co)) zval_ptr_dtor((co)); *(co) = NULL; /
}

static void php_kiss_init_globals(zend_kiss_globals *kiss_globals)
{
zend_hash_init(&kiss_globals->hosts_rw, 0 , NULL, (void (*)(void *)) kiss_rule_free, 1);
zend_hash_init(&kiss_globals->hosts_ls, 0 , NULL, NULL/*(void (*)(void *)) kiss_ls_free*/, 1);
}
static void php_kiss_destroy_globals(zend_kiss_globals *kiss_globals)
{
zend_hash_destroy(&kiss_globals->hosts_rw);
zend_hash_destroy(&kiss_globals->hosts_ls);
}

PHP_MINIT_FUNCTION(kiss)
{

zend_class_entry ce;
zval * pzv;

ZEND_INIT_MODULE_GLOBALS(kiss, php_kiss_init_globals, NULL);
/* 第三个参数传入NULL将导致在非多线程的平台产生段错误，
* 传入php_kiss_destroy_globals导致段错误。
*/
REGISTER_INI_ENTRIES();

KISS_EXPORT_CONST

MAKE_STD_ZVAL(pzv);
if(!zend_get_constant(DIR_SEP, DIR_SEP_LEN, pzv TSRMLS_CC)) {
KISS_G(dir_sep) = Z_STRVAL_P(pzv)[0];
zval_ptr_dtor(&pzv);
} else KISS_G(dir_sep) = DEFAULT_DIR_SEP;

INIT_CLASS_ENTRY(ce, "KissAction", action_mtds);

KISS_G(action_ce) = zend_register_internal_class(&ce TSRMLS_CC);

//KISS_G(action_ce)->ce_flags != ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;

INIT_CLASS_ENTRY(ce, "KissListener", listener_mtds);

KISS_G(listener_ce) = zend_register_internal_class(&ce TSRMLS_CC);

//KISS_G(listener_ce)->ce_flags != ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;

KISS_G(cfg_inited) = 0;
#ifndef PHP_WIN32
kiss_init_cfg(KISS_G(cfg_file) TSRMLS_CC);
#endif

return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(kiss)
{
UNREGISTER_INI_ENTRIES();
#ifdef ZTS
zend_hash_destroy(&KISS_G(hosts_rw));
zend_hash_destroy(&KISS_G(hosts_ls));
#else
php_kiss_destroy_globals(&kiss_globals TSRMLS_CC);
#endif
return SUCCESS;
}

PHP_RINIT_FUNCTION(kiss)
{
zval **co;

KISS_G(status) = kiss_status_init();
if(!KISS_G(status)) return FAILURE;
co = &KISS_G(obj_cache); MAKE_STD_ZVAL(*co); array_init(*co);
co = &KISS_G(ls_called); MAKE_STD_ZVAL(*co); array_init(*co);
KISS_G(ls_pre_disp) = NULL;
KISS_G(ls_post_disp) = NULL;
KISS_G(request) = NULL;
// KISS_G(response) = NULL;

return SUCCESS;
}

PHP_RSHUTDOWN_FUNCTION(kiss)
{
char ** path;
zval ** co;
kiss_request ** req;
// kiss_response ** resp;

kiss_status_free(KISS_G(status));
clear_var_pzval(co, obj_cache);
clear_var_pzval(co, ls_called);
clear_var_pzval(co, ls_pre_disp);
clear_var_pzval(co, ls_post_disp);
req = &KISS_G(request); if(*req) { kiss_request_free(*req); *req = NULL; }
// resp = &KISS_G(response); if(*resp) { kiss_response_free(*resp); *resp = NULL; }

return SUCCESS;
}

PHP_MINFO_FUNCTION(kiss)
{
php_info_print_table_start();
php_info_print_table_header(2, "kiss support", "enabled");
php_info_print_table_end();

// DISPLAY_INI_ENTRIES();

}

PHP_METHOD(KissAction, __construct) { }

// PHP_METHOD(KissAction, init) { }

PHP_METHOD(KissListener, __construct) { }

PHP_METHOD(KissListener, preDispatch) { }

PHP_METHOD(KissListener, postDispatch) { }

/** 包含并执行文件，参考include。
* proto mixed kiss_eval(string src[, long type])
* arg1 - 文件，
* arg2 - eval的类型，缺省是KISS_REQUIRE，
* return - 参考include，如有问题则返回NULL，
* throw Exception(文件不存在) */
PHP_FUNCTION(kiss_eval) {
zval * ret, * source;
ulong type;

type = KISS_REQUIRE;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l!", &source, &type) == FAILURE) {
RETURN_NULL();
}
if(Z_TYPE_P(source) != IS_STRING) RETURN_NULL();

if(!kiss_eval(type, source, &ret TSRMLS_CC)) {
zend_throw_exception_ex(NULL, KISS_E_READFILE TSRMLS_CC, "文件%s不存在或不可读。", Z_STRVAL_P(source));
RETURN_NULL();
}

if(ret) {
RETURN_ZVAL(ret, 0, 1);
} else {
RETURN_NULL();
}
}

/** 设定运行状态，必须在kiss_front_start之前调用。
* proto mixed kiss_status(long key[, zval * value])
* arg1 - 代表状态字段的常量，
* arg2 - 新值，
* return - 旧值。 */
PHP_FUNCTION(kiss_status) {
ulong k;
zval * v = NULL;
kiss_status * ks;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z", &k, &v)==FAILURE) {
return;
}
ks = KISS_G(status);
#define status_bool(k) { /
RETVAL_BOOL(ks->k); /
if(v) ks->k = Z_BVAL_P(v); /
return; /
}
#define status_string(k) { /
if(ks->k) { /
RETVAL_STRING(ks->k, 1); /
efree(ks->k); /
} /
if(v) ks->k = estrdup(Z_STRVAL_P(v)); /
return; /
}
switch(k) {
case KISS_STATUS_PREFIX_CTL: status_bool(prefix_ctl);
case KISS_STATUS_SHARE_GP: status_bool(share_gp);
case KISS_STATUS_USE_PORT: status_bool(use_port);
case KISS_STATUS_USE_CACHE: status_bool(use_cache);
case KISS_STATUS_DISPATCH_TYPE:
RETVAL_LONG(ks->dispatch_type);
if(v) ks->dispatch_type = Z_LVAL_P(v);
return;
case KISS_STATUS_CLI_ROOT: status_string(cli_root);
case KISS_STATUS_EXT_PROC: status_string(ext_proc);
case KISS_STATUS_EXT_PATH: status_string(ext_path);
case KISS_STATUS_DEFAULT_MDL: status_string(default_mdl);
case KISS_STATUS_DEFAULT_CTL: status_string(default_ctl);
case KISS_STATUS_DEFAULT_ACT: status_string(default_act);
case KISS_STATUS_POSTFIX_CTL: status_string(postfix_ctl);
case KISS_STATUS_POSTFIX_ACT: status_string(postfix_act);
default:
return;
}
}

/** 手工设定模块分发目录。
* proto bool kiss_set_rule(string ctl_dir[, string mdl])
* arg1 - 控制器目录，
* arg2 - 模块名，不提供或NULL表示缺省（全局）模块（空字符串表示），
* return - 是否成功。 */
PHP_FUNCTION(kiss_set_rule) {
char * mdl_name = "", * ctl_dir;
uint mdl_name_len = 0, ctl_dir_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!",
&ctl_dir, &ctl_dir_len, &mdl_name, &mdl_name_len) == FAILURE) {
RETURN_BOOL(0);
}

RETURN_BOOL(kiss_set_rule(mdl_name, ctl_dir, ctl_dir_len TSRMLS_CC));
}

/** 清除模块分发目录设置。
* proto void kiss_clear_rules(void)
* TODO: 需要有对应的init函数。 */
PHP_FUNCTION(kiss_clear_rules) {
zend_hash_destroy(&KISS_G(hosts_rw));
}

/** 用于terminal调试。 */
PHP_FUNCTION(kiss_cli_test) {
char * uri;
uint uri_len;
char * path = NULL;
zend_bool flag;

if(!sapi_module.name || strncmp(sapi_module.name, "cli", 3)) {
kiss_e_throw("该函数只能用于CLI模式。", KISS_E_ONLYCLI);
RETURN_FALSE;
}

if(!KISS_G(status)->cli_root || '/0'==*(KISS_G(status)->cli_root)) {
kiss_e_throw("CLI模式需要kiss_status()提供基本目录。", KISS_E_NEEDROOT);
RETURN_FALSE;
}
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &uri, &uri_len)==FAILURE) {
RETURN_FALSE;
}
if(!uri || !uri_len) {
kiss_e_throw("必须提供测试用的URI！", KISS_E_NEEDURI);
RETURN_BOOL(0);
}

#ifdef PHP_WIN32
if(!KISS_G(cfg_inited)) kiss_init_cfg(KISS_G(cfg_file) TSRMLS_CC);
#endif
if(!KISS_G(cfg_inited)) {
kiss_e_throw("配置文件解析失败！", KISS_E_CFGFILE);
RETURN_BOOL(0);
}

flag = kiss_request_init(uri, &path TSRMLS_CC);
if(!flag) {
if(path) efree(path);
kiss_e_throw("初始化请求失败！", KISS_E_INITREQ);
RETURN_BOOL(0);
}

flag = kiss_route_layer(path TSRMLS_CC);
if(path) efree(path);
if(!flag) {
kiss_e_throw("路由失败！", KISS_E_ROUTE);
RETURN_BOOL(0);
}

flag = kiss_dispatch(TSRMLS_C);
if(!flag) {
kiss_e_throw("分发失败！", KISS_E_DISPATCH);
RETURN_BOOL(0);
}

RETURN_BOOL(1);
}

/** 启动前端控制器，如果未初始化，则用当前参数初始化。
* proto bool kiss_front_start(void)
* throws Exception
* return - 是否成功，
* throws - 配置文件解析或路由或分发失败，
* TODO: 加入更多的路由。 */

PHP_FUNCTION(kiss_front_start)

{
zend_bool flag;
char * path = NULL;

#ifdef PHP_WIN32
if(!KISS_G(cfg_inited)) kiss_init_cfg(KISS_G(cfg_file) TSRMLS_CC);
#endif
if(!KISS_G(cfg_inited)) {
kiss_e_throw("配置文件解析失败！", KISS_E_CFGFILE);
RETURN_BOOL(0);
}

flag = kiss_request_init(NULL, &path TSRMLS_CC);
if(!flag) {
if(path) efree(path);
kiss_e_throw("初始化请求失败！", KISS_E_INITREQ);
RETURN_BOOL(0);
}

flag = kiss_route_layer(path TSRMLS_CC);
if(path) efree(path);
if(!flag) {
kiss_e_throw("路由失败！", KISS_E_ROUTE);
RETURN_BOOL(0);
}

flag = kiss_dispatch(TSRMLS_C);
if(!flag) {
kiss_e_throw("分发失败！", KISS_E_DISPATCH);
RETURN_BOOL(0);
}

RETURN_BOOL(1);
}

/** 设定Action或Controller的监听器，如果未初始化，则用当前参数初始化。
* NOTE: 在Controller调用。
* proto bool kiss_set_listener(string listener[, string item[, long type]])
* arg1 - 监听器类的名字，
* arg2 - 监听目标，应是Action，空表示对整个Controller，
* arg3 - 监听器类型（现在只有分发前和分发后），缺省是分发前，
* return - 是否成功。*/
PHP_FUNCTION(kiss_set_listener) {
char * item = NULL, * ls = NULL;
uint item_len, ls_len, str_len;
ulong ls_type;
zval ** lsco, * mco, * cco, * aco, ** value;
kiss_request * req;

ls_type = KISS_LS_PRE_DISPATCH;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl!",
&ls, &ls_len, &item, &item_len, &ls_type) == FAILURE) {
RETURN_FALSE;
}
if(!ls || 0==ls_len) RETURN_BOOL(0);

req = KISS_G(request);
lsco = KISS_LS_PRE_DISPATCH==ls_type ?
&KISS_G(ls_pre_disp) : &KISS_G(ls_post_disp);
if(!*lsco) {
MAKE_STD_ZVAL(*lsco);
array_init(*lsco);
}

str_len = strlen(req->module);
if(zend_hash_find(Z_ARRVAL_PP(lsco), req->module, str_len+1, (void**)&value) == FAILURE) {
MAKE_STD_ZVAL(mco);
array_init(mco);
add_assoc_zval(*lsco, req->module, mco);
} else mco = *value;
str_len = strlen(req->controller);
if(zend_hash_find(Z_ARRVAL_P(mco), req->controller, str_len+1, (void**)&value) == FAILURE) {
MAKE_STD_ZVAL(cco);
array_init(cco);
add_assoc_zval(mco, req->controller, cco);
} else cco = *value;
if(!item || '/0' == *item) { // controller

item = "";
item_len = 0;
}
if(zend_hash_find(Z_ARRVAL_P(cco), item, item_len+1, (void**)&value) == FAILURE) {
MAKE_STD_ZVAL(aco);
array_init(aco);
add_assoc_zval(cco, item, aco);
} else aco = *value;
if(!zend_hash_exists(Z_ARRVAL_P(aco), ls, ls_len+1)) {
add_assoc_long(aco, ls, 0);
}

RETURN_BOOL(1);
}

/** 服务器内跳转到其他的Action，如果是相同的控制器，则不再初始化，使用同一实利。
* 因为是函数调用方式，所以会返回调用点。
* proto bool kiss_forward(string action[, string controller[, string module[, array params]]])
* throws Exception
* arg1 - Action，
* arg2 - Controller，缺省为当前的控制器，
* arg3 - Module，缺省为当前模块，
* arg4 - 参数数组，
* return - 是否成功，
* throws - Action初始化或分发失败。 */
PHP_FUNCTION(kiss_forward) {
char * action = NULL, * controller = NULL, * module = NULL;
char * action2 = NULL, * controller2 = NULL, * module2 = NULL;
uint act_len, ctl_len, mdl_len;
zval * params = NULL;
kiss_request * req;
zval ** co;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ssz",
&action, &act_len, &controller, &ctl_len, &module, &mdl_len, ¶ms) == FAILURE) {
RETURN_FALSE;
}
if(!action || '/0' == action[0]) RETURN_BOOL(0);

req = KISS_G(request);
// efree(req->action);

action2 = req->action;
req->action = estrdup(action);

if(controller && '/0' != controller[0]) {
// efree(req->controller);

controller2 = req->controller;
req->controller = estrdup(controller);
}

if(module) {
// efree(req->module);

module2 = req->module;
req->module = estrdup(module);
}

if(params && IS_ARRAY == Z_TYPE_P(params))
php_array_merge(Z_ARRVAL_P(req->query), Z_ARRVAL_P(params), 0 TSRMLS_CC);

kiss_dispatch(TSRMLS_C);
if(module2) { efree(req->module); req->module = module2; }
if(controller2) { efree(req->controller); req->controller = controller2; }
efree(req->action); req->action = action2;
}

/** 重定向到其他的地址。
* proto bool kiss_redirect(string action[, string controller[, string module[, long code]]])
* throws Exception
* arg1 - Action或绝对路径，
* arg2 - Controller，缺省为当前的控制器，
* arg3 - Module，缺省为当前模块，
* arg4 - 响应代码，
* return - 是否成功，
* throws - Action初始化或分发失败。
* TODO: 对于相对路径，需要加入参数。 */
PHP_FUNCTION(kiss_redirect) {
// zend_bool replace = 1;

sapi_header_line ctr = {0};
char * act = NULL, * ctl = NULL, * mdl = NULL, * lc_word;
char * p1 = "http://", * p2 = "https://"/*, * protocol, url[1024]*/;
uint a_len, c_len = 0, m_len = 0;
kiss_request * req;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ssl",
&act, &a_len, &ctl, &c_len, &mdl, &m_len, &ctr.response_code) == FAILURE) {
RETURN_FALSE;
}
if(!act || !a_len) RETURN_BOOL(0);

req = KISS_G(request);
/*protocol = zend_getenv(SERVER_PROTOCOL, sizeof(SERVER_PROTOCOL)-1 TSRMLS_CC);
if(!protocol || !*protocol) protocol = DEFAULT_SERVER_PROTOCOL;*/

lc_word = (char*)do_alloca(a_len + 1);
zend_str_tolower_copy(lc_word, act, a_len);
if(PATH_SEP == *act || !strncmp(p1, lc_word, sizeof(p1)) || !strncmp(p2, lc_word, sizeof(p2))) {
// 绝对路径

ctr.line_len = spprintf(&(ctr.line), 0, "Location: %s", act);
} else { // 相对路径

if(!mdl || !m_len) {
mdl = req->module;
}
if(!ctl || !c_len) {
ctl = req->controller;
}
ctr.line_len = spprintf(&(ctr.line), 0, "Location: /%s/%s/%s", mdl, ctl, act);
}
free_alloca(lc_word);
sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
efree(ctr.line);
RETURN_BOOL(1);
}

/** 获取查询参数。
* proto mixed kiss_request_query([string key])
* arg1 - 参数的键，不提供则返回全部参数数组，
* return - 键对应的值。 */
PHP_FUNCTION(kiss_request_query) {
char * key = NULL;
uint key_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &key, &key_len) == FAILURE) {
RETURN_FALSE;
}

kiss_request_query(key, KISS_G(request)->query, &return_value TSRMLS_CC);
}

/** 获取POST参数。
* proto mixed kiss_request_post([string key])
* arg1 - 参数的键，不提供则返回全部参数数组，
* return - 键对应的值。 */
PHP_FUNCTION(kiss_request_post) {
char * key = NULL;
uint key_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &key, &key_len) == FAILURE) {
RETURN_FALSE;
}

kiss_request_query(key, KISS_G(request)->post, &return_value TSRMLS_CC);
}

/** 获取请求（QUERY+POST）参数，QUERY优先。
* proto mixed kiss_request_params([string key])
* arg1 - 参数的键，不提供则返回全部参数数组，
* return - 键对应的值。 */
PHP_FUNCTION(kiss_request_params) {
char * key = NULL;
uint key_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &key, &key_len) == FAILURE) {
RETURN_FALSE;
}

kiss_request_query(key, KISS_G(request)->query, &return_value TSRMLS_CC);
if(key && IS_NULL != Z_TYPE_P(return_value)) return;
kiss_request_query(key, KISS_G(request)->post, &return_value TSRMLS_CC);
//PHP_FN(kiss_request_query)(INTERNAL_FUNCTION_PARAM_PASSTHRU);

//if(IS_NULL != Z_TYPE_P(return_value)) return;

//PHP_FN(kiss_request_post)(INTERNAL_FUNCTION_PARAM_PASSTHRU);

}

/** 获取请求的信息。
* proto mixed kiss_request_query([long type])
* arg1 - 所需信息的类型常量，可组合，
* return - 信息的数组，如需要的项不存在则为空字符串或空数组。
* TODO: 以后考虑接受任意数量参数。 */
PHP_FUNCTION(kiss_request_get) {
ulong arg1;
zval * ret;
kiss_request * req;

arg1 = KISS_REQ_ALL;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &arg1) == FAILURE) {
RETURN_FALSE;
}

req = KISS_G(request);

array_init(return_value);
ret = return_value;
if(KISS_REQ_METHOD & arg1) {
add_assoc_string(ret, "method", req->method?req->method:"", 1);
}
if(KISS_REQ_HOST & arg1) {
add_assoc_string(ret, "host", req->host?req->host:"", 1);
}
if(KISS_REQ_MODULE & arg1) {
add_assoc_string(ret, "module", req->module?req->module:"", 1);
}
if(KISS_REQ_CONTROLLER & arg1) {
add_assoc_string(ret, "controller", req->controller?req->controller:"", 1);
}
if(KISS_REQ_ACTION & arg1) {
add_assoc_string(ret, "action", req->action?req->action:"", 1);
}
if(KISS_REQ_FRAGMENT & arg1) {
add_assoc_string(ret, "fragment", req->fragment?req->fragment:"", 1);
}
if(KISS_REQ_QUERY & arg1) {
ZVAL_ADDREF(req->query); // 引用

add_assoc_zval(ret, "query", req->query);
}
if(KISS_REQ_POST & arg1) {
ZVAL_ADDREF(req->post); // 引用

add_assoc_zval(ret, "post", req->post);
}
}