/* {{{ php_stream_bucket_attach */ static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS) { zval *zbrigade, *zobject; zval *pzbucket, *pzdata; php_stream_bucket_brigade *brigade; php_stream_bucket *bucket; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_RESOURCE(zbrigade) Z_PARAM_OBJECT(zobject) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); if (NULL == (pzbucket = zend_hash_str_find(Z_OBJPROP_P(zobject), "bucket", sizeof("bucket")-1))) { php_error_docref(NULL, E_WARNING, "Object has no bucket property"); RETURN_FALSE; } if ((brigade = (php_stream_bucket_brigade*)zend_fetch_resource( Z_RES_P(zbrigade), PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade)) == NULL) { RETURN_FALSE; } if ((bucket = (php_stream_bucket *)zend_fetch_resource_ex(pzbucket, PHP_STREAM_BUCKET_RES_NAME, le_bucket)) == NULL) { RETURN_FALSE; } if (NULL != (pzdata = zend_hash_str_find(Z_OBJPROP_P(zobject), "data", sizeof("data")-1)) && Z_TYPE_P(pzdata) == IS_STRING) { if (!bucket->own_buf) { bucket = php_stream_bucket_make_writeable(bucket); } if (bucket->buflen != Z_STRLEN_P(pzdata)) { bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent); bucket->buflen = Z_STRLEN_P(pzdata); } memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen); } if (append) { php_stream_bucket_append(brigade, bucket); } else { php_stream_bucket_prepend(brigade, bucket); } /* This is a hack necessary to accommodate situations where bucket is appended to the stream * multiple times. See bug35916.phpt for reference. */ if (bucket->refcount == 1) { bucket->refcount++; } }
static inline int msgpack_convert_string_to_properties(zval *object, zend_string *key, zval *val, HashTable *var)/* {{{ */ { zend_class_entry *ce = Z_OBJCE_P(object); HashTable *propers = Z_OBJPROP_P(object); zend_string *prot_name, *priv_name; zval pub_name; int return_code; ZVAL_STR(&pub_name, key); priv_name = zend_mangle_property_name(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(key), ZSTR_LEN(key), 1); prot_name = zend_mangle_property_name("*", 1, ZSTR_VAL(key), ZSTR_LEN(key), 1); if (zend_hash_find(propers, priv_name) != NULL) { zend_update_property_ex(ce, object, key, val); return_code = SUCCESS; } else if (zend_hash_find(propers, prot_name) != NULL) { zend_update_property_ex(ce, object, key, val); return_code = SUCCESS; } else { zend_std_write_property(object, &pub_name, val, NULL); return_code = FAILURE; } zend_hash_add(var, Z_STR(pub_name), val); zend_string_release(priv_name); zend_string_release(prot_name); return return_code; }
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements) { zval retval; zval fname; HashTable *ht; if (Z_TYPE_P(rval) != IS_OBJECT) { return 0; } ht = Z_OBJPROP_P(rval); zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED)); if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) { return 0; } ZVAL_DEREF(rval); if (Z_OBJCE_P(rval) != PHP_IC_ENTRY && zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) { ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1); BG(serialize_lock)++; call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL); BG(serialize_lock)--; zval_dtor(&fname); zval_dtor(&retval); } if (EG(exception)) { return 0; } return finish_nested_data(UNSERIALIZE_PASSTHRU); }
/* {{{ proto ProtocolBuffers\EnumDescriptor ProtocolBuffersDescriptorBuilder::build() */ PHP_METHOD(protocolbuffers_enum_descriptor_builder, build) { zval *result, *container, **fields, **entry, *key, *value; char *property; int property_len; HashPosition pos; MAKE_STD_ZVAL(result); object_init_ex(result, php_protocol_buffers_enum_descriptor_class_entry); MAKE_STD_ZVAL(container); array_init(container); zend_mangle_property_name(&property, &property_len, (char*)"*", 1, (char*)ZEND_STRS("values"), 0); if (zend_hash_find(Z_OBJPROP_P(getThis()), property, property_len, (void **)&fields) == SUCCESS) { zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(fields), &pos); while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(fields), (void **)&entry, &pos) == SUCCESS) { zval *tmp = NULL; MAKE_STD_ZVAL(tmp); php_protocolbuffers_read_protected_property(*entry, ZEND_STRS("name"), &key TSRMLS_CC); php_protocolbuffers_read_protected_property(*entry, ZEND_STRS("value"), &value TSRMLS_CC); ZVAL_ZVAL(tmp, value, 1, 0); zend_hash_update(Z_ARRVAL_P(container), Z_STRVAL_P(key), Z_STRLEN_P(key), &tmp, sizeof(zval), NULL); zend_hash_move_forward_ex(Z_ARRVAL_PP(fields), &pos); } } efree(property); php_protocolbuffers_set_protected_property(result, ZEND_STRS("values"), container TSRMLS_CC); RETURN_ZVAL(result, 0, 1); }
/* {{{ proto ProtocolBuffers_DescriptorBuilder ProtocolBuffers_DescriptorBuilder::__construct() */ PHP_METHOD(berg_buffers, __construct) { zval *instance = getThis(); zval fields,options,extension_ranges,*tmp; array_init(&fields); add_next_index_double(&fields,42.00); add_next_index_long(&fields,42); php_var_dump(&fields,1); zend_update_property(Z_OBJCE_P(instance),instance,ZEND_STRL("fields"),&fields); zval_ptr_dtor(&fields); // array_init(&options); // zend_update_property(berg_buffers_class_entry,instance,ZEND_STRL("options"),&options); // zval_ptr_dtor(&options); // // array_init(&extension_ranges); // zend_update_property(berg_buffers_class_entry,instance,ZEND_STRL("extension_ranges"),&extension_ranges); // zval_ptr_dtor(&extension_ranges); zend_string *key = zend_string_init(ZEND_STRL("fields"),0); if((tmp=zend_hash_find(Z_OBJPROP_P(instance), key))!=NULL){ php_var_dump(tmp,1); } zend_string_release(key); //>gdb //(gdb) p fields1->u2 //$1 = {var_flags = 4294967295, next = 4294967295, cache_slot = 4294967295, lineno = 4294967295, num_args = 4294967295, fe_pos = 4294967295, fe_iter_idx = 4294967295} //(gdb) p fields1->value->arr->nNumUsed //$4 = 1 //(gdb) p fields1->value->arr->nTableSize //$5 = 4294956704 //(gdb) p fields1->value->arr->nNumOfElements //$6 = 0 }
SharedValue KPHPObject::Get(const char *name) { zval** zPropertyPtr; unsigned int nameLength = strlen(name); TSRMLS_FETCH(); // First try to get the property via the read_property handler. if (this->PropertyExists(name TSRMLS_CC) && Z_OBJ_HANDLER_P(object, read_property)) { zval zname; ZVAL_STRINGL(&zname, name, nameLength, 0); // Use the read_property handler in the class. zval* zProperty = Z_OBJ_HANDLER_P(object, read_property)( object, &zname, 2 TSRMLS_CC); return PHPUtils::ToKrollValue(zProperty TSRMLS_CC); } // Next just try reading it from the properties hash. else if (zend_hash_find(Z_OBJPROP_P(object), name, nameLength + 1, (void**) &zPropertyPtr) != FAILURE) { return PHPUtils::ToKrollValue(*zPropertyPtr TSRMLS_CC); } // Check if the method exists on the object else if (this->MethodExists(name TSRMLS_CC)) { return Value::NewMethod(new KPHPMethod(object, name)); } else { return Value::Undefined; } }
/* {{{ proto void ProtocolBuffersDescriptorBuilder::addValue(ProtocolBuffers\EnumValueDescriptor $value[, bool $force = false]) */ PHP_METHOD(protocolbuffers_enum_descriptor_builder, addValue) { zval *instance = getThis(); zval *value, **fields, *name; zend_bool force = 0; char *property; int property_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &value, php_protocol_buffers_enum_value_descriptor_class_entry, &force) == FAILURE) { return; } zend_mangle_property_name(&property, &property_len, (char*)"*", 1, (char*)ZEND_STRS("values"), 0); if (zend_hash_find(Z_OBJPROP_P(instance), property, property_len, (void **)&fields) == SUCCESS) { if (php_protocolbuffers_read_protected_property(value, ZEND_STRS("name"), &name TSRMLS_CC)) { if (zend_hash_exists(Z_ARRVAL_PP(fields), Z_STRVAL_P(name), Z_STRLEN_P(name))) { if (force < 1) { zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "name `%s` has already registered.", Z_STRVAL_P(name)); } efree(property); return; } } Z_ADDREF_P(value); zend_hash_update(Z_ARRVAL_PP(fields), Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &value, sizeof(zval), NULL); } efree(property); }
/* {{{ proto ProtocolBuffers\EnumDescriptor ProtocolBuffersDescriptorBuilder::build() */ PHP_METHOD(protocolbuffers_enum_descriptor_builder, build) { zval *result, *container, *fields, *entry, *key, *value; char *property; int property_len; HashPosition pos; // MAKE_STD_ZVAL(result); object_init_ex(result, php_protocol_buffers_enum_descriptor_class_entry); // MAKE_STD_ZVAL(container); array_init(container); zend_string *property_key = zend_mangle_property_name((char*)"*", 1, ZEND_STRL("values"), 0); if ((fields=zend_hash_find(Z_OBJPROP_P(getThis()), property_key)) != NULL) { zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(fields), &pos); while ((entry=zend_hash_get_current_data_ex(Z_ARRVAL_P(fields), &pos)) != NULL) { zval *tmp = NULL; // MAKE_STD_ZVAL(tmp); php_protocolbuffers_read_protected_property(entry, ZEND_STRL("name"), &key TSRMLS_CC); php_protocolbuffers_read_protected_property(entry, ZEND_STRL("value"), &value TSRMLS_CC); ZVAL_ZVAL(tmp, value, 1, 0); zend_string *key_name = zend_string_init(Z_STRVAL_P(key),Z_STRLEN_P(key),0); zend_hash_update(Z_ARRVAL_P(container), key_name, tmp); zend_hash_move_forward_ex(Z_ARRVAL_P(fields), &pos); } } efree(property); php_protocolbuffers_set_protected_property(result, ZEND_STRL("values"), container TSRMLS_CC); RETURN_ZVAL(result, 0, 1); }
/* {{{ proto void ProtocolBuffersDescriptorBuilder::addValue(ProtocolBuffers\EnumValueDescriptor $value[, bool $force = false]) */ PHP_METHOD(protocolbuffers_enum_descriptor_builder, addValue) { zval *instance = getThis(); zval *value, *fields, *name; zend_bool force = 0; // char *property; int property_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &value, php_protocol_buffers_enum_value_descriptor_class_entry, &force) == FAILURE) { return; } zend_string *property_key = zend_mangle_property_name((char*)"*", 1, (char*)ZEND_STRL("values"), 0); if ((fields=zend_hash_find(Z_OBJPROP_P(instance), property_key)) != NULL) { if (php_protocolbuffers_read_protected_property(value, ZEND_STRL("name"), &name TSRMLS_CC)) { zend_string *name_key = zend_string_init(Z_STRVAL_P(name), Z_STRLEN_P(name),0); if (zend_hash_exists(Z_ARRVAL_P(fields), name_key)) { if (force < 1) { zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "name `%s` has already registered.", Z_STRVAL_P(name)); } zend_string_release(property_key); zend_string_release(name_key); return; } } Z_ADDREF_P(value); zend_string *name_key = zend_string_init(Z_STRVAL_P(name), Z_STRLEN_P(name)+1,0); zend_hash_update(Z_ARRVAL_P(fields), name_key, value); zend_string_release(name_key); } zend_string_release(property_key); }
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements) { zval retval; zval fname; if (Z_TYPE_P(rval) != IS_OBJECT) { return 0; } //??? TODO: resize before if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_P(rval), elements, 1)) { return 0; } ZVAL_DEREF(rval); if (Z_OBJCE_P(rval) != PHP_IC_ENTRY && zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) { ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1); BG(serialize_lock)++; call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL); BG(serialize_lock)--; zval_dtor(&fname); zval_dtor(&retval); } if (EG(exception)) { return 0; } return finish_nested_data(UNSERIALIZE_PASSTHRU); }
/* {{{ php_store_class_name */ PHPAPI void php_store_class_name(zval *object, const char *name, size_t len) { zval val; ZVAL_STRINGL(&val, name, len); zend_hash_str_update(Z_OBJPROP_P(object), MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1, &val); }
ZEND_METHOD (Msg, __construct2) { zval *hdr = 0; ALLOC_ZVAL (hdr); object_init_ex (hdr, msghdr_ce); if (zend_hash_update (Z_OBJPROP_P (getThis ()), "hdr", sizeof ("hdr"), &hdr, sizeof (hdr), 0) == FAILURE) BUG_ON (1); }
/* {{{ php_stream_bucket_attach */ static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS) { zval *zbrigade, *zobject; zval *pzbucket, *pzdata; php_stream_bucket_brigade *brigade; php_stream_bucket *bucket; if (zend_parse_parameters(ZEND_NUM_ARGS(), "zo", &zbrigade, &zobject) == FAILURE) { RETURN_FALSE; } if (NULL == (pzbucket = zend_hash_str_find(Z_OBJPROP_P(zobject), "bucket", sizeof("bucket")-1))) { php_error_docref(NULL, E_WARNING, "Object has no bucket property"); RETURN_FALSE; } ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade); ZEND_FETCH_RESOURCE(bucket, php_stream_bucket *, pzbucket, -1, PHP_STREAM_BUCKET_RES_NAME, le_bucket); if (NULL != (pzdata = zend_hash_str_find(Z_OBJPROP_P(zobject), "data", sizeof("data")-1)) && Z_TYPE_P(pzdata) == IS_STRING) { if (!bucket->own_buf) { bucket = php_stream_bucket_make_writeable(bucket); } if ((int)bucket->buflen != Z_STRLEN_P(pzdata)) { bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent); bucket->buflen = Z_STRLEN_P(pzdata); } memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen); } if (append) { php_stream_bucket_append(brigade, bucket); } else { php_stream_bucket_prepend(brigade, bucket); } /* This is a hack necessary to accommodate situations where bucket is appended to the stream * multiple times. See bug35916.phpt for reference. */ if (bucket->refcount == 1) { bucket->refcount++; } }
ZEND_METHOD(YConsistent,consistent_end){ zval *object = getThis(); zval **conhash_prop; if(zend_hash_find(Z_OBJPROP_P(object),"conhash",sizeof("conhash"),(void **)&conhash_prop) == FAILURE){ RETURN_NULL(); } if(zend_list_delete(Z_LVAL_PP(conhash_prop)) == FAILURE){ RETURN_FALSE; } RETURN_TRUE; }
/** * @zobject: swoole_client object */ static int php_swoole_client_close(zval *zobject, int fd TSRMLS_DC) { zval *zcallback = NULL; zval *retval; zval **args[1]; swClient *cli; zval **zres; if (zend_hash_find(Z_OBJPROP_P(zobject), SW_STRL("_client"), (void **) &zres) == SUCCESS) { ZEND_FETCH_RESOURCE_NO_RETURN(cli, swClient*, zres, -1, SW_RES_CLIENT_NAME, le_swoole_client); }
ZEND_METHOD (Msghdr, __destruct) { int rc; zval **hdr = 0; char *ptr; if (zend_hash_find (Z_OBJPROP_P (getThis ()), "__ptr", sizeof("__ptr"), (void **) &hdr) == FAILURE) return; if ((ptr = Z_STRVAL_PP (hdr)) && (ptr = * (char **) ptr)) { ubuf_free (ptr); } }
/* {{{ php_lookup_class_name */ PHPAPI zend_string *php_lookup_class_name(zval *object) { zval *val; HashTable *object_properties; object_properties = Z_OBJPROP_P(object); if ((val = zend_hash_str_find(object_properties, MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1)) != NULL) { return zend_string_copy(Z_STR_P(val)); } return NULL; }
/* {{{ proto void ProtocolBuffersPHPMessageOptions::setSinglePropertyName(string $name) */ PHP_METHOD(protocolbuffers_php_message_options, setSinglePropertyName) { zval *instance = getThis(); zval **target; char *value; long value_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE) { return; } if (zend_hash_find(Z_OBJPROP_P(instance), "single_property_name", sizeof("single_property_name"), (void **)&target) == SUCCESS) { zval *tmp; MAKE_STD_ZVAL(tmp); ZVAL_STRING(tmp, value, 1); zend_hash_update(Z_OBJPROP_P(instance), "single_property_name", sizeof("single_property_name"), (void **)&tmp, sizeof(zval*), NULL); } }
ZEND_METHOD(YConsistent,add_server){ char *host; int host_len,port,weight; zval *object = getThis(); zval **conhash_prop; if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"sll",&host,&host_len,&port,&weight) == FAILURE){ return; } if(zend_hash_find(Z_OBJPROP_P(object),"conhash",sizeof("conhash"),(void **)&conhash_prop) == FAILURE){ RETURN_NULL(); } conhash *con = zend_list_find(Z_LVAL_PP(conhash_prop),&le_conhash); conhash_add_server(host,port,weight,con); }
ZEND_API void zend_print_flat_zval_r(zval *expr) /* {{{ */ { switch (Z_TYPE_P(expr)) { case IS_ARRAY: ZEND_PUTS("Array ("); if (Z_REFCOUNTED_P(expr)) { if (Z_IS_RECURSIVE_P(expr)) { ZEND_PUTS(" *RECURSION*"); return; } Z_PROTECT_RECURSION_P(expr); } print_flat_hash(Z_ARRVAL_P(expr)); ZEND_PUTS(")"); if (Z_REFCOUNTED_P(expr)) { Z_UNPROTECT_RECURSION_P(expr); } break; case IS_OBJECT: { HashTable *properties = NULL; zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr)); zend_printf("%s Object (", ZSTR_VAL(class_name)); zend_string_release(class_name); if (Z_IS_RECURSIVE_P(expr)) { ZEND_PUTS(" *RECURSION*"); return; } if (Z_OBJ_HANDLER_P(expr, get_properties)) { properties = Z_OBJPROP_P(expr); } if (properties) { Z_PROTECT_RECURSION_P(expr); print_flat_hash(properties); Z_UNPROTECT_RECURSION_P(expr); } ZEND_PUTS(")"); break; } case IS_REFERENCE: zend_print_flat_zval_r(Z_REFVAL_P(expr)); break; default: zend_print_variable(expr); break; } }
/* {{{ proto void ProtocolBuffersPHPMessageOptions::setProcessUnknownFields(boolean $use) */ PHP_METHOD(protocolbuffers_php_message_options, setProcessUnknownFields) { zval *instance = getThis(); zval **target; long value; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &value) == FAILURE) { return; } if (zend_hash_find(Z_OBJPROP_P(instance), "process_unknown_fields", sizeof("process_unknown_fields"), (void **)&target) == SUCCESS) { ZVAL_BOOL(*target, value); } }
ZEND_API void zend_print_flat_zval_r(zval *expr) /* {{{ */ { switch (Z_TYPE_P(expr)) { case IS_ARRAY: ZEND_PUTS("Array ("); if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr)) && ++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) { ZEND_PUTS(" *RECURSION*"); Z_ARRVAL_P(expr)->u.v.nApplyCount--; return; } print_flat_hash(Z_ARRVAL_P(expr)); ZEND_PUTS(")"); if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr))) { Z_ARRVAL_P(expr)->u.v.nApplyCount--; } break; case IS_OBJECT: { HashTable *properties = NULL; zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr)); zend_printf("%s Object (", ZSTR_VAL(class_name)); zend_string_release(class_name); if (Z_OBJ_APPLY_COUNT_P(expr) > 0) { ZEND_PUTS(" *RECURSION*"); return; } if (Z_OBJ_HANDLER_P(expr, get_properties)) { properties = Z_OBJPROP_P(expr); } if (properties) { Z_OBJ_INC_APPLY_COUNT_P(expr); print_flat_hash(properties); Z_OBJ_DEC_APPLY_COUNT_P(expr); } ZEND_PUTS(")"); break; } case IS_REFERENCE: zend_print_flat_zval_r(Z_REFVAL_P(expr)); break; default: zend_print_variable(expr); break; } }
/* {{{ proto void ProtocolBuffersPHPMessageOptions::setUseSingleProperty(boolean $use) */ PHP_METHOD(protocolbuffers_php_message_options, setUseSingleProperty) { zval *instance = getThis(); zval **target; long value; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &value) == FAILURE) { return; } if (zend_hash_find(Z_OBJPROP_P(instance), "use_single_property", sizeof("use_single_property"), (void **)&target) == SUCCESS) { ZVAL_BOOL(*target, value); } }
PHP_METHOD(pdo_connect_pool_PDOStatement, __call) { zval *z_args; zval *object; zval *pass_data; zval **zres, **source_zval; char *cmd; int cmd_len; if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osa", &object, pdo_connect_pool_PDOStatement_class_entry_ptr, &cmd, &cmd_len, &z_args) == FAILURE) { RETURN_FALSE; } cpClient *cli; if (zend_hash_find(Z_OBJPROP_P(getThis()), ZEND_STRS("cli"), (void **) &zres) == SUCCESS) { ZEND_FETCH_RESOURCE(cli, cpClient*, zres, -1, CP_RES_CLIENT_NAME, le_cli_connect_pool); } else {
ZEND_METHOD(YConsistent,find_server){ char *key; char *return_key; int key_len; zval *object = getThis(); zval **conhash_prop; if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"s",&key,&key_len) == FAILURE){ return; } if(zend_hash_find(Z_OBJPROP_P(object),"conhash",sizeof("conhash"),(void **)&conhash_prop) == FAILURE){ RETURN_NULL(); } conhash *con = zend_list_find(Z_LVAL_PP(conhash_prop),&le_conhash); cnode *node = conhash_find_server(key,key_len,con); array_init(return_value); add_assoc_string(return_value,"host",node->server.host,1); add_assoc_long(return_value,"port",node->server.port); }
static void release_worker(zval *object) { zend_rsrc_list_entry *p_sock_le; zval **data_source; if (zend_hash_find(Z_OBJPROP_P(object), ZEND_STRS("data_source"), (void **) &data_source) == SUCCESS) { if (zend_hash_find(&EG(persistent_list), Z_STRVAL_PP(data_source), Z_STRLEN_PP(data_source), (void **) &p_sock_le) == SUCCESS) { send_oob2proxy(p_sock_le); } else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "p_sock_le can not find"); } } else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "data_source can not find"); } }
static void release_worker(zval *object) { zend_rsrc_list_entry *p_sock_le; zval **pool_port; if (zend_hash_find(Z_OBJPROP_P(object), ZEND_STRS("pool_port"), (void **) &pool_port) == SUCCESS) { char str[100] = {0}; CON_FORMART_KEY(str, (int) Z_LVAL_PP(pool_port)); if (zend_hash_find(&EG(persistent_list), str, strlen(str), (void **) &p_sock_le) == SUCCESS) { send_oob2proxy(p_sock_le); } else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "p_sock_le can not find"); } } else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "pool_port can not find"); } }
/* {{{ pip_pyobject_to_zobject(PyObject *obj) Convert Python object to a PHP (Zend) object */ zval * pip_pyobject_to_zobject(PyObject *obj) { pval *ret; zval *handle; TSRMLS_FETCH(); /* Create a PHP Python object */ MAKE_STD_ZVAL(ret); object_init_ex(ret, &python_class_entry); ret->is_ref = 1; ret->refcount = 1; /* Assign the current PyObject to the new PHP Python object */ ALLOC_ZVAL(handle); ZVAL_RESOURCE(handle, zend_list_insert(obj, le_pyobject)); zval_copy_ctor(handle); INIT_PZVAL(handle); zend_hash_index_update(Z_OBJPROP_P(ret), 0, &handle, sizeof(zval *), NULL); return ret; }
static void php_bencode_encode_array(smart_str *buf, zval *val) /* {{{ */ { int num_elements = 0; char mode; HashTable *ht; if (Z_TYPE_P(val) == IS_ARRAY) { ht = Z_ARRVAL_P(val); } else { ht = Z_OBJPROP_P(val); mode = PHP_BENCODE_TYPE_DICTIONARY; } if (ht && ZEND_HASH_GET_APPLY_COUNT(ht) > 1) { zend_error(E_WARNING, "recursion detected"); return; } num_elements = ht ? zend_hash_num_elements(ht) : 0; if (Z_TYPE_P(val) == IS_ARRAY) { if (num_elements > 0) { zend_string *key; zend_ulong index, idx; idx = 0; mode = PHP_BENCODE_TYPE_LIST; ZEND_HASH_FOREACH_KEY(ht, index, key) { if (key) { mode = PHP_BENCODE_TYPE_DICTIONARY; break; } else { if (index != idx) { mode = PHP_BENCODE_TYPE_DICTIONARY; break; } } idx++; } ZEND_HASH_FOREACH_END(); }else{
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements) { HashTable *ht; zend_bool has_wakeup; if (Z_TYPE_P(rval) != IS_OBJECT) { return 0; } has_wakeup = Z_OBJCE_P(rval) != PHP_IC_ENTRY && zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1); ht = Z_OBJPROP_P(rval); if (elements >= (zend_long)(HT_MAX_SIZE - zend_hash_num_elements(ht))) { return 0; } zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED)); if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) { if (has_wakeup) { ZVAL_DEREF(rval); GC_FLAGS(Z_OBJ_P(rval)) |= IS_OBJ_DESTRUCTOR_CALLED; } return 0; } ZVAL_DEREF(rval); if (has_wakeup) { /* Delay __wakeup call until end of serialization */ zval *wakeup_var = var_tmp_var(var_hash); ZVAL_COPY(wakeup_var, rval); Z_EXTRA_P(wakeup_var) = VAR_WAKEUP_FLAG; } return finish_nested_data(UNSERIALIZE_PASSTHRU); }