/* {{{ php_ini_displayer
*/
static int php_ini_displayer(zval *el, void *arg)
{
zend_ini_entry *ini_entry = (zend_ini_entry*)Z_PTR_P(el);
int module_number = *(int *)arg;
if (ini_entry->module_number != module_number) {
return 0;
}
if (!sapi_module.phpinfo_as_text) {
PUTS("<tr>");
PUTS("<td class=\"e\">");
PHPWRITE(ini_entry->name->val, ini_entry->name->len);
PUTS("</td><td class=\"v\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE);
PUTS("</td><td class=\"v\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG);
PUTS("</td></tr>\n");
} else {
PHPWRITE(ini_entry->name->val, ini_entry->name->len);
PUTS(" => ");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE);
PUTS(" => ");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG);
PUTS("\n");
}
return 0;
}
static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
{
const char *prop_name, *class_name;
if (key == NULL) { /* numeric key */
php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
} else { /* string key */
int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
php_printf("%*c[", level + 1, ' ');
if (class_name && unmangle == SUCCESS) {
if (class_name[0] == '*') {
php_printf("\"%s\":protected", prop_name);
} else {
php_printf("\"%s\":\"%s\":private", prop_name, class_name);
}
} else {
php_printf("\"");
PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
php_printf("\"");
}
ZEND_PUTS("]=>\n");
}
php_var_dump(zv, level + 2);
}
static void php_ini_displayer_cb(zend_ini_entry *ini_entry, int type)
{
if (ini_entry->displayer) {
ini_entry->displayer(ini_entry, type);
} else {
char *display_string;
uint display_string_length, esc_html=0;
if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
if (ini_entry->orig_value) {
display_string = ini_entry->orig_value;
display_string_length = ini_entry->orig_value_length;
esc_html=1;
} else {
display_string = "<i>no value</i>";
display_string_length = sizeof("<i>no value</i>")-1;
}
} else if (ini_entry->value && ini_entry->value[0]) {
display_string = ini_entry->value;
display_string_length = ini_entry->value_length;
esc_html=1;
} else {
display_string = "<i>no value</i>";
display_string_length = sizeof("<i>no value</i>")-1;
}
if(esc_html) {
zend_html_puts(display_string, display_string_length);
} else {
PHPWRITE(display_string, display_string_length);
}
}
}
/* {{{ proto null Runkit_Sandbox_Parent::echo(mixed var[, mixed var[, ... ]])
Echo through out of the sandbox
Avoid the sandbox's output handler */
PHP_METHOD(Runkit_Sandbox_Parent,echo)
{
php_runkit_sandbox_parent_object *objval;
zval **argv;
int i, argc = ZEND_NUM_ARGS();
if (zend_get_parameters_array_ex(argc, &argv) == FAILURE) {
/* Big problems... */
RETURN_NULL();
}
for(i = 0; i < argc; i++) {
/* Prepare for output */
convert_to_string(argv[i]);
}
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (!objval->self->parent_echo) {
php_error_docref(NULL, E_WARNING, "Access to echo data in the parent context is not enabled");
RETURN_FALSE;
}
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
for(i = 0; i < argc; i++) {
PHPWRITE(Z_STRVAL_P(argv[i]),Z_STRLEN_P(argv[i]));
}
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
RETURN_NULL();
}
static PHP_FUNCTION(params_array) {
HashTable *options = NULL;
zval *v;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &v) == FAILURE) {
RETURN_FALSE;
}
options = Z_ARRVAL_P(v);//读取array类型的值
//zend_hash_internal_pointer_reset
//zend_hash_has_more_elements 判断HashTable是否有元素
//zend_hash_move_forward 移动HashTable到顶端
//zend_hash_get_current_key_ex 读取HashTable当前的key，HashTable的key有两种，一种是指定字符串，另一种是顺序的0-n下标
//zend_hash_get_current_data 读取HashTable当前的值到zval
//zend_hash_get_current_key_type 获取当前key的类型
for(zend_hash_internal_pointer_reset(options); SUCCESS == zend_hash_has_more_elements(options); zend_hash_move_forward(options)) {
char *k1;
ulong nkey = -1, keylen;
zval **z;
zend_hash_get_current_key_ex(options, &k1, &keylen, &nkey, 0, NULL);
zend_hash_get_current_data(options, (void **)&z);
php_printf(" key: ");
if (HASH_KEY_IS_STRING == zend_hash_get_current_key_type(options)) {
PHPWRITE(k1, keylen);
}else{
php_printf("%ld", nkey);
}
php_printf(" value: ");
if (Z_TYPE_P(*z) == IS_STRING) {
//php_printf("string(%d)\n", Z_STRLEN_P(*z));
PHPWRITE(Z_STRVAL_P(*z), Z_STRLEN_P(*z));
}else{
zend_print_zval_r((*z), 0 TSRMLS_CC);
}
php_printf("\n");
}
RETURN_TRUE;
}
static void php_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level TSRMLS_DC) /* {{{ */
{
if (key == NULL) { /* numeric key */
php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
} else { /* string key */
php_printf("%*c[\"", level + 1, ' ');
PHPWRITE(key->val, key->len);
php_printf("\"]=>\n");
}
php_var_dump(zv, level + 2 TSRMLS_CC);
}
static void php_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
{
if (key == NULL) { /* numeric key */
php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
} else { /* string key */
php_printf("%*c[\"", level + 1, ' ');
PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
php_printf("\"]=>\n");
}
php_var_dump(zv, level + 2);
}
int php_print_r_zval_and_key(zval **val,int num_args,va_list args,zend_hash_key *hash_key)
{
//重新copy一个zval，防止破坏原数据
zval tmpcopy = **val;
zval *tmpcopy_ptr = &tmpcopy;
/* tsrm_ls is needed by output functions */
TSRMLS_FETCH();
zval_copy_ctor(&tmpcopy);
INIT_PZVAL(&tmpcopy);
//执行输出
php_printf("The value of ");
if (hash_key->nKeyLength){
//如果是字符串类型的key
PHPWRITE(hash_key->arKey, hash_key->nKeyLength);
}else{
//如果是数字类型的key
php_printf("%ld", hash_key->h);
}
php_printf(" is: ");
//调用print_r函数
zval *function,*ret = NULL;
//函数名
MAKE_STD_ZVAL(function);
ZVAL_STRING(function, "print_r", 0);
//参数是一个zval* 数组
zval **params[1] = {&tmpcopy_ptr};
zend_fcall_info fci = {
sizeof(fci),
EG(function_table),
function,
NULL,
&ret,
1,
(zval ***)params,
NULL,
1
};
zend_call_function(&fci, NULL TSRMLS_CC);
php_printf("\n");
zval_dtor(function);
//毁尸灭迹
zval_dtor(&tmpcopy);
/* continue; */
return ZEND_HASH_APPLY_KEEP;
}
static inline void _http_flush(void *nothing, const char *data, size_t data_len TSRMLS_DC)
{
PHPWRITE(data, data_len);
/* we really only need to flush when throttling is enabled,
because we push the data as fast as possible anyway if not */
if (HTTP_G->send.throttle_delay >= HTTP_DIFFSEC) {
if (OG(ob_nesting_level)) {
php_end_ob_buffer(1, 1 TSRMLS_CC);
}
if (!OG(implicit_flush)) {
sapi_flush(TSRMLS_C);
}
http_sleep(HTTP_G->send.throttle_delay);
}
}
static PHP_FUNCTION(params_str) {
char *str = "";
int str_len = 0;
long i = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sl", &str, &str_len, &i) == FAILURE) {
return;
}
php_printf("string(%d) value:", str_len);
PHPWRITE(str, str_len);
php_printf("\n");
php_printf("int(%d)\n", i);
php_printf("\n");
}
/* {{{ php_ini_displayer
*/
static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number TSRMLS_DC)
{
if (ini_entry->module_number != module_number) {
return 0;
}
if (!sapi_module.phpinfo_as_text) {
PUTS("<tr>");
PUTS("<td class=\"e\">");
PHPWRITE(ini_entry->name, ini_entry->name_length - 1);
PUTS("</td><td class=\"v\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE TSRMLS_CC);
PUTS("</td><td class=\"v\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG TSRMLS_CC);
PUTS("</td></tr>\n");
} else {
PHPWRITE(ini_entry->name, ini_entry->name_length - 1);
PUTS(" => ");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE TSRMLS_CC);
PUTS(" => ");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG TSRMLS_CC);
PUTS("\n");
}
return 0;
}
static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number)
{
if (ini_entry->module_number != module_number) {
return 0;
}
PUTS("<TR VALIGN=\"baseline\" BGCOLOR=\"" PHP_CONTENTS_COLOR "\">");
PUTS("<TD BGCOLOR=\"" PHP_ENTRY_NAME_COLOR "\"><B>");
PHPWRITE(ini_entry->name, ini_entry->name_length-1);
PUTS("</B><BR></TD><TD ALIGN=\"center\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE);
PUTS("</TD><TD ALIGN=\"center\">");
php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG);
PUTS("</TD></TR>\n");
return 0;
}
int diff_printf(const char *format, ...)
{
va_list args;
int ret;
char *buffer;
int size;
TSRMLS_FETCH();
va_start(args, format);
size = vspprintf(&buffer, 0, format, args);
ret = PHPWRITE(buffer, size);
efree(buffer);
va_end(args);
return ret;
}
static void php_jam_display_error_page(char *filename)
{
php_stream *stream = php_stream_open_wrapper(filename, "r", ENFORCE_SAFE_MODE & ~REPORT_ERRORS, NULL);
if (stream) {
char *buff;
size_t buff_size;
buff_size = php_stream_copy_to_mem(stream, &buff, PHP_STREAM_COPY_ALL, 0);
php_stream_close(stream);
if (buff_size) {
PHPWRITE(buff, buff_size);
efree(buff);
}
}
}
/* {{{ php_ini_displayer_cb
*/
static void php_ini_displayer_cb(zend_ini_entry *ini_entry, int type)
{
if (ini_entry->displayer) {
ini_entry->displayer(ini_entry, type);
} else {
char *display_string;
size_t display_string_length;
int esc_html=0;
if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
if (ini_entry->orig_value && ini_entry->orig_value->val[0]) {
display_string = ini_entry->orig_value->val;
display_string_length = ini_entry->orig_value->len;
esc_html = !sapi_module.phpinfo_as_text;
} else {
if (!sapi_module.phpinfo_as_text) {
display_string = "<i>no value</i>";
display_string_length = sizeof("<i>no value</i>") - 1;
} else {
display_string = "no value";
display_string_length = sizeof("no value") - 1;
}
}
} else if (ini_entry->value && ini_entry->value->val[0]) {
display_string = ini_entry->value->val;
display_string_length = ini_entry->value->len;
esc_html = !sapi_module.phpinfo_as_text;
} else {
if (!sapi_module.phpinfo_as_text) {
display_string = "<i>no value</i>";
display_string_length = sizeof("<i>no value</i>") - 1;
} else {
display_string = "no value";
display_string_length = sizeof("no value") - 1;
}
}
if (esc_html) {
php_html_puts(display_string, display_string_length);
} else {
PHPWRITE(display_string, display_string_length);
}
}
}
static PHP_FUNCTION(params_dump) {
zval *arg;//定义参数值,zval可以表示所有的参数的值
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
return;
}
switch(Z_TYPE_P(arg)) {
case IS_NULL://arg is null
php_printf("NULL\n");
break;
case IS_BOOL://arg is true, false
php_printf("bool(%s)\n", Z_BVAL_P(arg)?"true":"false");
break;
case IS_LONG:
php_printf("int(%d)\n", Z_LVAL_P(arg));
break;
case IS_DOUBLE:
php_printf("float(%f)\n", Z_DVAL_P(arg));
break;
case IS_STRING:
php_printf("string(%d)\n", Z_STRLEN_P(arg));
PHPWRITE(Z_STRVAL_P(arg), Z_STRLEN_P(arg));
php_printf("\n");
break;
case IS_ARRAY:
php_printf("array(%d){...}\n", zend_hash_num_elements(Z_ARRVAL_P(arg)));
break;
case IS_RESOURCE:{
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RESVAL_P(arg) TSRMLS_CC);
php_printf("resource#%ld(%s)\n", Z_RESVAL_P(arg), type_name?type_name:"Unknown");
break;
}
case IS_OBJECT:{
const zend_class_entry *ce = Z_OBJCE_P(arg);
php_printf("object#%u(%s)\n", Z_OBJ_HANDLE_P(arg), (ce && ce->name)?ce->name:"Unknown");
break;
}
default:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown type: %d\n", Z_TYPE_P(arg));
}
}
/* {{{ proto void Runkit_Sandbox_Parent::die(mixed message)
MALIAS(exit)
PATRICIDE!!!!!!!! */
PHP_METHOD(Runkit_Sandbox_Parent,die)
{
php_runkit_sandbox_parent_object *objval;
zval *message = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &message) == FAILURE) {
RETURN_FALSE;
}
RETVAL_NULL();
if (message && Z_TYPE_P(message) != IS_LONG) {
convert_to_string(message);
}
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (!objval->self->parent_die) {
php_error_docref(NULL, E_WARNING, "Patricide is disabled. Shame on you Oedipus.");
/* Sent as a warning, but we'll really implement it as an E_ERROR */
objval->self->active = 0;
RETURN_FALSE;
}
CG(unclean_shutdown) = 1;
CG(in_compilation) = EG(in_execution) = 0;
EG(current_execute_data) = NULL;
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
if (message) {
if (Z_TYPE_P(message) == IS_LONG) {
EG(exit_status) = Z_LVAL_P(message);
} else {
PHPWRITE(Z_STRVAL_P(message), Z_STRLEN_P(message));
}
}
zend_bailout();
/* More of a murder-suicide really... */
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
}
/* {{{ proto bool Runkit_Sandbox_Parent::print(mixed var)
Echo through the sandbox
Avoid the sandbox's output_handler */
PHP_METHOD(Runkit_Sandbox_Parent,print)
{
php_runkit_sandbox_parent_object *objval;
char *str;
int len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len) == FAILURE) {
RETURN_FALSE;
}
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (!objval->self->parent_echo) {
php_error_docref(NULL, E_WARNING, "Access to echo data in the parent context is not enabled");
RETURN_FALSE;
}
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
PHPWRITE(str,len);
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
RETURN_BOOL(len > 1 || (len == 1 && str[0] != '0'));
}
static void php_object_property_dump(zend_property_info *prop_info, zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
{
const char *prop_name, *class_name;
if (key == NULL) { /* numeric key */
php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
} else { /* string key */
int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
php_printf("%*c[", level + 1, ' ');
if (class_name && unmangle == SUCCESS) {
if (class_name[0] == '*') {
php_printf("\"%s\":protected", prop_name);
} else {
php_printf("\"%s\":\"%s\":private", prop_name, class_name);
}
} else {
php_printf("\"");
PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
php_printf("\"");
}
ZEND_PUTS("]=>\n");
}
if (Z_TYPE_P(zv) == IS_UNDEF) {
ZEND_ASSERT(prop_info->type);
php_printf("%*cuninitialized(%s%s)\n",
level + 1, ' ',
ZEND_TYPE_ALLOW_NULL(prop_info->type) ? "?" : "",
ZEND_TYPE_IS_CLASS(prop_info->type) ?
ZSTR_VAL(ZEND_TYPE_IS_CE(prop_info->type) ? ZEND_TYPE_CE(prop_info->type)->name : ZEND_TYPE_NAME(prop_info->type)) :
zend_get_type_by_const(ZEND_TYPE_CODE(prop_info->type)));
} else {
php_var_dump(zv, level + 2);
}
}
PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
{
HashTable *myht;
zend_string *class_name;
int is_temp;
int is_ref = 0;
zend_ulong num;
zend_string *key;
zval *val;
uint32_t count;
if (level > 1) {
php_printf("%*c", level - 1, ' ');
}
again:
switch (Z_TYPE_P(struc)) {
case IS_FALSE:
php_printf("%sbool(false)\n", COMMON);
break;
case IS_TRUE:
php_printf("%sbool(true)\n", COMMON);
break;
case IS_NULL:
php_printf("%sNULL\n", COMMON);
break;
case IS_LONG:
php_printf("%sint(" ZEND_LONG_FMT ")\n", COMMON, Z_LVAL_P(struc));
break;
case IS_DOUBLE:
php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
break;
case IS_STRING:
php_printf("%sstring(%zd) \"", COMMON, Z_STRLEN_P(struc));
PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
PUTS("\"\n");
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && ++myht->u.v.nApplyCount > 1) {
PUTS("*RECURSION*\n");
--myht->u.v.nApplyCount;
return;
}
count = zend_array_count(myht);
php_printf("%sarray(%d) {\n", COMMON, count);
is_temp = 0;
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
php_array_element_dump(val, num, key, level);
} ZEND_HASH_FOREACH_END();
if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) {
--myht->u.v.nApplyCount;
}
if (is_temp) {
zend_hash_destroy(myht);
efree(myht);
}
if (level > 1) {
php_printf("%*c", level-1, ' ');
}
PUTS("}\n");
break;
case IS_OBJECT:
if (Z_OBJ_APPLY_COUNT_P(struc) > 0) {
PUTS("*RECURSION*\n");
return;
}
Z_OBJ_INC_APPLY_COUNT_P(struc);
myht = Z_OBJDEBUG_P(struc, is_temp);
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
php_printf("%sobject(%s)#%d (%d) {\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0);
zend_string_release(class_name);
if (myht) {
zend_ulong num;
zend_string *key;
zval *val;
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
php_object_property_dump(val, num, key, level);
} ZEND_HASH_FOREACH_END();
if (is_temp) {
zend_hash_destroy(myht);
efree(myht);
}
}
int shurrik_hash_apply_for_array(zval **val,int num_args,va_list args,zend_hash_key *hash_key)
{
TSRMLS_FETCH();
php_printf(" ");
if (hash_key->nKeyLength)
{
//如果是字符串类型的key
PHPWRITE(hash_key->arKey, hash_key->nKeyLength);
}
else
{
//如果是数字类型的key
php_printf("%ld", hash_key->h);
}
php_printf("=>");
if(Z_TYPE_PP(val) == IS_ARRAY){
//php_printf("%d",(**tmp).type);
//zend_hash_apply((**val).value.ht,shurrik_hash_apply_for_zval, 0);
/*if(Z_TYPE_PP(tmp) == IS_STRING){
php_printf("%s",(**tmp).value.str.val);
}*/
Bucket *p;
zval **tmp;
p = (**val).value.ht->pListHead;
if(p == NULL){
return ZEND_HASH_APPLY_STOP;
}
php_printf("array(\n");
while (p != NULL) {
php_printf(" ");
tmp = p->pData;
if(p->nKeyLength){
php_printf("%s=>",p->arKey);
}else {
php_printf("%ld=>",p->h);
}
if(Z_TYPE_PP(tmp) == IS_STRING){
php_printf("%s\n",(**tmp).value.str.val);
}
if(Z_TYPE_PP(tmp) == IS_ARRAY){
//php_printf("array()\n");
//shurrik_apply_array(tmp);
//zend_hash_apply_with_arguments(((**tmp).value.ht)->pListHead->pData,shurrik_hash_apply_for_array, 0);
//shurrik_hash_apply(tmp,p);
//return shurrik_hash_apply_for_zval(tmp TSRMLS_CC);
}
p = p->pListNext;
}
php_printf(" );\n");
}
if(Z_TYPE_PP(val) == IS_STRING){
php_printf("%s",(**val).value.str.val);
}
php_printf("\n");
//返回，继续遍历下一个～
return ZEND_HASH_APPLY_KEEP;
}
/* {{{ php_exec
* If type==0, only last line of output is returned (exec)
* If type==1, all lines will be printed and last lined returned (system)
* If type==2, all lines will be saved to given array (exec with &$array)
* If type==3, output will be printed binary, no lines will be saved or returned (passthru)
*
*/
PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value)
{
FILE *fp;
char *buf;
size_t l = 0;
int pclose_return;
char *b, *d=NULL;
php_stream *stream;
size_t buflen, bufl = 0;
#if PHP_SIGCHILD
void (*sig_handler)() = NULL;
#endif
#if PHP_SIGCHILD
sig_handler = signal (SIGCHLD, SIG_DFL);
#endif
#ifdef PHP_WIN32
fp = VCWD_POPEN(cmd, "rb");
#else
fp = VCWD_POPEN(cmd, "r");
#endif
if (!fp) {
php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd);
goto err;
}
stream = php_stream_fopen_from_pipe(fp, "rb");
buf = (char *) emalloc(EXEC_INPUT_BUF);
buflen = EXEC_INPUT_BUF;
if (type != 3) {
b = buf;
while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl)) {
/* no new line found, let's read some more */
if (b[bufl - 1] != '\n' && !php_stream_eof(stream)) {
if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF)) {
bufl += b - buf;
buflen = bufl + EXEC_INPUT_BUF;
buf = erealloc(buf, buflen);
b = buf + bufl;
} else {
b += bufl;
}
continue;
} else if (b != buf) {
bufl += b - buf;
}
if (type == 1) {
PHPWRITE(buf, bufl);
if (php_output_get_level() < 1) {
sapi_flush();
}
} else if (type == 2) {
/* strip trailing whitespaces */
l = bufl;
while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
add_next_index_stringl(array, buf, bufl);
}
b = buf;
}
if (bufl) {
/* strip trailing whitespaces if we have not done so already */
if ((type == 2 && buf != b) || type != 2) {
l = bufl;
while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
if (type == 2) {
add_next_index_stringl(array, buf, bufl);
}
}
/* Return last line from the shell command */
RETVAL_STRINGL(buf, bufl);
} else { /* should return NULL, but for BC we return "" */
RETVAL_EMPTY_STRING();
}
} else {
while((bufl = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0) {
PHPWRITE(buf, bufl);
}
}
pclose_return = php_stream_close(stream);
efree(buf);
done:
#if PHP_SIGCHILD
if (sig_handler) {
signal(SIGCHLD, sig_handler);
}
#endif
if (d) {
efree(d);
}
return pclose_return;
err:
pclose_return = -1;
goto done;
}
static size_t gv_channel_writer (GVJ_t *job, const char *s, size_t len)
{
return PHPWRITE(s, len);
}
static size_t php_stream_output_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC) /* {{{ */
{
PHPWRITE(buf, count);
return count;
}
static zval * php_yar_client_parse_response(char *ret, size_t len, int throw_exception TSRMLS_DC) /* {{{ */ {
zval *retval, *response;
yar_header_t *header;
char *err_msg;
MAKE_STD_ZVAL(retval);
ZVAL_FALSE(retval);
if (!(header = php_yar_protocol_parse(&ret, &len, &err_msg TSRMLS_CC))) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, YAR_ERR_PROTOCOL, "%s", err_msg);
if (YAR_G(debug)) {
php_yar_debug_client("0: malformed response '%s'", ret);
}
efree(err_msg);
return retval;
}
if (!len || !header->body_len) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, 0, "server responsed empty body");
return retval;
}
if (YAR_G(debug)) {
php_yar_debug_client("%ld: server responsed: packager '%s', len '%ld', content '%s'", header->id, ret, len - 8, ret + 8);
}
if (!(response = php_yar_packager_unpack(ret, len, &err_msg TSRMLS_CC))) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, YAR_ERR_PACKAGER, "%s", err_msg);
efree(err_msg);
return retval;
}
if (response && IS_ARRAY == Z_TYPE_P(response)) {
zval **ppzval;
uint status;
HashTable *ht = Z_ARRVAL_P(response);
if (zend_hash_find(ht, ZEND_STRS("s"), (void **)&ppzval) == FAILURE) {
}
convert_to_long(*ppzval);
status = Z_LVAL_PP(ppzval);
if (status == YAR_ERR_OKEY) {
if (zend_hash_find(ht, ZEND_STRS("o"), (void **)&ppzval) == SUCCESS) {
PHPWRITE(Z_STRVAL_PP(ppzval), Z_STRLEN_PP(ppzval));
}
} else if (status == YAR_ERR_EXCEPTION) {
if (zend_hash_find(ht, ZEND_STRS("e"), (void **)&ppzval) == SUCCESS) {
if (throw_exception) {
zval *ex, **property;
MAKE_STD_ZVAL(ex);
object_init_ex(ex, yar_server_exception_ce);
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("message"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("message"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("code"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("code"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("file"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("file"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("line"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("line"), *property TSRMLS_CC);
}
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("_type"), (void **)&property) == SUCCESS) {
zend_update_property(yar_server_exception_ce, ex, ZEND_STRL("_type"), *property TSRMLS_CC);
}
zend_throw_exception_object(ex TSRMLS_CC);
} else {
zval **msg, **code;
if (zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("message"), (void **)&msg) == SUCCESS
&& zend_hash_find(Z_ARRVAL_PP(ppzval), ZEND_STRS("code"), (void **)&code) == SUCCESS) {
convert_to_string_ex(msg);
convert_to_long_ex(code);
php_yar_client_trigger_error(0 TSRMLS_CC, Z_LVAL_PP(code), "server threw an exception with message `%s`", Z_STRVAL_PP(msg));
}
}
}
} else if (zend_hash_find(ht, ZEND_STRS("e"), (void **)&ppzval) == SUCCESS
&& IS_STRING == Z_TYPE_PP(ppzval)) {
php_yar_client_trigger_error(throw_exception TSRMLS_CC, status, "%s", Z_STRVAL_PP(ppzval));
}
if (zend_hash_find(ht, ZEND_STRS("r"), (void **)&ppzval) == SUCCESS) {
ZVAL_ZVAL(retval, *ppzval, 1, 0);
}
zval_ptr_dtor(&response);
} else if (response) {
zval_ptr_dtor(&response);
}
return retval;
} /* }}} */
PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
{
HashTable *myht;
zend_string *class_name;
int is_ref = 0;
zend_ulong num;
zend_string *key;
zval *val;
uint32_t count;
if (level > 1) {
php_printf("%*c", level - 1, ' ');
}
again:
switch (Z_TYPE_P(struc)) {
case IS_FALSE:
php_printf("%sbool(false)\n", COMMON);
break;
case IS_TRUE:
php_printf("%sbool(true)\n", COMMON);
break;
case IS_NULL:
php_printf("%sNULL\n", COMMON);
break;
case IS_LONG:
php_printf("%sint(" ZEND_LONG_FMT ")\n", COMMON, Z_LVAL_P(struc));
break;
case IS_DOUBLE:
php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
break;
case IS_STRING:
php_printf("%sstring(%zd) \"", COMMON, Z_STRLEN_P(struc));
PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
PUTS("\"\n");
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
if (level > 1 && !(GC_FLAGS(myht) & GC_IMMUTABLE)) {
if (GC_IS_RECURSIVE(myht)) {
PUTS("*RECURSION*\n");
return;
}
GC_PROTECT_RECURSION(myht);
}
count = zend_array_count(myht);
php_printf("%sarray(%d) {\n", COMMON, count);
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
php_array_element_dump(val, num, key, level);
} ZEND_HASH_FOREACH_END();
if (level > 1 && !(GC_FLAGS(myht) & GC_IMMUTABLE)) {
GC_UNPROTECT_RECURSION(myht);
}
if (level > 1) {
php_printf("%*c", level-1, ' ');
}
PUTS("}\n");
break;
case IS_OBJECT:
if (Z_IS_RECURSIVE_P(struc)) {
PUTS("*RECURSION*\n");
return;
}
Z_PROTECT_RECURSION_P(struc);
myht = zend_get_properties_for(struc, ZEND_PROP_PURPOSE_DEBUG);
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
php_printf("%sobject(%s)#%d (%d) {\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0);
zend_string_release_ex(class_name, 0);
if (myht) {
zend_ulong num;
zend_string *key;
zval *val;
ZEND_HASH_FOREACH_KEY_VAL(myht, num, key, val) {
zend_property_info *prop_info = NULL;
if (Z_TYPE_P(val) == IS_INDIRECT) {
val = Z_INDIRECT_P(val);
if (key) {
prop_info = zend_get_typed_property_info_for_slot(Z_OBJ_P(struc), val);
}
}
if (!Z_ISUNDEF_P(val) || prop_info) {
php_object_property_dump(prop_info, val, num, key, level);
}
} ZEND_HASH_FOREACH_END();
zend_release_properties(myht);
}