/** {{{ 从文件载入js代码 */
PHP_METHOD(HyperMobile, loadjsfromfile) {
char *filename;
int filename_len;
char *contents;//,*err;
php_stream *stream;
int len;
zval *self,*value;
/* Parse arguments */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
return;
}
self=getThis();
if (strlen(filename) != filename_len) {
RETURN_FALSE;
}
stream = php_stream_open_wrapper(filename, "rb",
ENFORCE_SAFE_MODE | REPORT_ERRORS,
NULL);
if (!stream) {
RETURN_FALSE;
}
if ((len = php_stream_copy_to_mem(stream, &contents, PHP_STREAM_COPY_ALL, 0)) > 0) {
if (PG(magic_quotes_runtime)) {
contents = php_addslashes(contents, len, &len, 1 TSRMLS_CC); /* 1 = free source string */
}
php_stream_close(stream);
//
MAKE_STD_ZVAL(value);
ZVAL_STRING(value,contents,0);
zend_update_property(Z_OBJCE_P(self),self,ZEND_STRL("js_content"),value TSRMLS_CC);
RETURN_TRUE;
} else if (len == 0) {
php_stream_close(stream);
MAKE_STD_ZVAL(value);
// err = ;
ZVAL_STRING(value,"file content is empty",0);
zend_update_property(Z_OBJCE_P(self),self,ZEND_STRL("err_msg"),value TSRMLS_CC);
zend_update_property_bool(Z_OBJCE_P(self),self,ZEND_STRL("error"),1 TSRMLS_CC);
RETURN_FALSE;
} else {
php_stream_close(stream);
MAKE_STD_ZVAL(value);
ZVAL_STRING(value,"unknown error",0);
zend_update_property(Z_OBJCE_P(self),self,ZEND_STRL("err_msg"),value TSRMLS_CC);
zend_update_property_bool(Z_OBJCE_P(self),self,ZEND_STRL("error"),1 TSRMLS_CC);
RETURN_FALSE;
}
}
/* {{{ proto AMQPExchange::setFlags(long bitmask)
Set the exchange parameters */
static PHP_METHOD(amqp_exchange_class, setFlags)
{
PHP5to7_param_long_type_t flagBitmask;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flagBitmask) == FAILURE) {
return;
}
/* Set the flags based on the bitmask we were given */
flagBitmask = flagBitmask ? flagBitmask & PHP_AMQP_EXCHANGE_FLAGS : flagBitmask;
zend_update_property_bool(this_ce, getThis(), ZEND_STRL("passive"), IS_PASSIVE(flagBitmask) TSRMLS_CC);
zend_update_property_bool(this_ce, getThis(), ZEND_STRL("durable"), IS_DURABLE(flagBitmask) TSRMLS_CC);
zend_update_property_bool(this_ce, getThis(), ZEND_STRL("auto_delete"), IS_AUTODELETE(flagBitmask) TSRMLS_CC);
zend_update_property_bool(this_ce, getThis(), ZEND_STRL("internal"), IS_INTERNAL(flagBitmask) TSRMLS_CC);
}
/* {{{ proto void Riak\BucketProperties->__construct(int $nVal, bool $allowMult)
Creates a new RiakBucketProperties */
PHP_METHOD(RiakBucketProperties, __construct)
{
long nVal;
zend_bool allowMult;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lb", &nVal, &allowMult) == FAILURE) {
return;
}
zend_update_property_long(riak_bucket_properties_ce, getThis(), "nVal", sizeof("nVal")-1, nVal TSRMLS_CC);
zend_update_property_bool(riak_bucket_properties_ce, getThis(), "allowMult", sizeof("allowMult")-1, allowMult TSRMLS_CC);
}
static PHP_METHOD(Hello, updateProperties) {
zval *obj;
obj = getThis();
zend_update_property_string(hello_ce, obj, "name", sizeof("name") -1, "name-update" TSRMLS_CC);//更新属性值, $this->name = name
zend_update_property_long(hello_ce, obj, "age", sizeof("age") -1, 10 TSRMLS_CC); //this->age = age
zend_update_property_string(hello_ce, obj, "last_name", sizeof("last_name") -1, "leon-update" TSRMLS_CC);//this->last_name = "leon"
zend_update_property_null(hello_ce, obj, "first_name", sizeof("first_name") - 1 TSRMLS_CC); //this->first_name = null;
zend_update_property_bool(hello_ce, obj, "sex", sizeof("sex") -1, 0 TSRMLS_CC); //this->sex = true
zend_update_property_double(hello_ce, obj, "score", sizeof("score") -1, 15.50 TSRMLS_CC); //this->score = 12.50
}
int swoole_websocket_onMessage(swEventData *req)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
int fd = req->info.fd;
zval *zdata;
SW_MAKE_STD_ZVAL(zdata);
char frame_header[2];
php_swoole_get_recv_data(zdata, req, frame_header, 2);
long finish = frame_header[0] ? 1 : 0;
long opcode = frame_header[1];
zval *zframe;
SW_MAKE_STD_ZVAL(zframe);
object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr);
zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC);
zend_update_property_bool(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC);
zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC);
zend_update_property(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), zdata TSRMLS_CC);
swServer *serv = SwooleG.serv;
zval *zserv = (zval *) serv->ptr2;
zval **args[2];
args[0] = &zserv;
args[1] = &zframe;
zval *retval = NULL;
zval *zcallback = php_swoole_server_get_callback(serv, req->info.from_fd, SW_SERVER_CB_onMessage);
if (sw_call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "onMessage handler error");
}
if (EG(exception))
{
zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
}
if (retval)
{
sw_zval_ptr_dtor(&retval);
}
sw_zval_ptr_dtor(&zdata);
sw_zval_ptr_dtor(&zframe);
return SW_OK;
}
static PHP_METHOD(swoole_mysql, close)
{
mysql_client *client = swoole_get_object(getThis());
if (!client)
{
swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_mysql.");
RETURN_FALSE;
}
if (!client->cli)
{
swoole_php_fatal_error(E_WARNING, "mysql connection#%d is closed.", client->fd);
RETURN_FALSE;
}
zend_update_property_bool(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("connected"), 0 TSRMLS_CC);
SwooleG.main_reactor->del(SwooleG.main_reactor, client->fd);
swConnection *socket = swReactor_get(SwooleG.main_reactor, client->fd);
socket->object = NULL;
zend_bool is_destroyed = client->cli->destroyed;
//close the connection
client->cli->close(client->cli);
//release client object memory
swClient_free(client->cli);
efree(client->cli);
client->cli = NULL;
zval *retval = NULL;
zval **args[1];
zval *object = getThis();
if (client->onClose)
{
args[0] = &object;
if (sw_call_user_function_ex(EG(function_table), NULL, client->onClose, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS)
{
swoole_php_fatal_error(E_WARNING, "swoole_mysql onClose callback error.");
}
if (retval)
{
sw_zval_ptr_dtor(&retval);
}
}
if (!is_destroyed)
{
sw_zval_ptr_dtor(&object);
}
}
/* {{{ proto void Riak\MapReduce\Phase\MapPhase->__construct(Riak\MapReduce\Function\Function $function [, bool $keep [, array $arguments]])
Create a new MapPhase */
PHP_METHOD(Riak_MapReduce_Phase_MapPhase, __construct)
{
zval *zfunction, *zargs;
zend_bool keep;
keep = 0;
zargs = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|ba", &zfunction, &keep, &zargs) == FAILURE) {
return;
}
zend_update_property(riak_mr_mapphase_ce, getThis(), "function", sizeof("function")-1, zfunction TSRMLS_CC);
zend_update_property_bool(riak_mr_mapphase_ce, getThis(), "keep", sizeof("keep")-1, keep TSRMLS_CC);
if (zargs) {
zend_update_property(riak_mr_mapphase_ce, getThis(), "arg", sizeof("arg")-1, zargs TSRMLS_CC);
}
}
yaf_route_t * yaf_route_map_instance(yaf_route_t *this_ptr, zend_bool controller_prefer, zend_string *delim) /* {{{ */{
if (Z_ISUNDEF_P(this_ptr)) {
object_init_ex(this_ptr, yaf_route_map_ce);
}
if (controller_prefer) {
zend_update_property_bool(yaf_route_map_ce, this_ptr,
ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_CTL_PREFER), 1);
}
if (delim && ZSTR_LEN(delim)) {
zend_update_property_str(yaf_route_map_ce, this_ptr, ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_DELIMETER), delim);
}
return this_ptr;
}
/* {{{ PHP_SOLR_API void solr_set_response_object_properties(zend_class_entry *scope, zval *response_object, const solr_client_t *client, const solr_string_t *request_url, zend_bool success TSRMLS_DC) */
PHP_SOLR_API void solr_set_response_object_properties(zend_class_entry *scope, zval *response_object, const solr_client_t *client, const solr_string_t *request_url, zend_bool success TSRMLS_DC)
{
const solr_curl_t *handle = &(client->handle);
const solr_string_t *raw_request_headers = &(handle->request_header.buffer);
const solr_string_t *raw_request = &(handle->request_body_debug.buffer);
const solr_string_t *raw_response_headers = &(handle->response_header.buffer);
const solr_string_t *raw_response = &(handle->response_body.buffer);
const solr_string_t *response_writer = &(client->options.response_writer);
long int http_status = handle->response_header.response_code;
zend_update_property_long(scope, response_object, "http_status", sizeof("http_status")-1, http_status TSRMLS_CC);
zend_update_property_bool(scope, response_object, "success", sizeof("success")-1, success TSRMLS_CC);
if (response_writer->str)
{
zend_update_property_stringl(scope, response_object, "response_writer", sizeof("response_writer")-1, (char *)response_writer->str, response_writer->len TSRMLS_CC);
}
if (request_url->str)
{
zend_update_property_stringl(scope, response_object, "http_request_url", sizeof("http_request_url")-1, (char *)request_url->str, request_url->len TSRMLS_CC);
}
if (raw_request_headers->str)
{
zend_update_property_stringl(scope, response_object, "http_raw_request_headers", sizeof("http_raw_request_headers")-1, (char *)raw_request_headers->str, raw_request_headers->len TSRMLS_CC);
}
if (raw_request->str)
{
zend_update_property_stringl(scope, response_object, "http_raw_request", sizeof("http_raw_request")-1, (char *)raw_request->str, raw_request->len TSRMLS_CC);
}
if (raw_response_headers->str)
{
zend_update_property_stringl(scope, response_object, "http_raw_response_headers", sizeof("http_raw_response_headers")-1, (char *)raw_response_headers->str, raw_response_headers->len TSRMLS_CC);
}
if (raw_response->str)
{
zend_update_property_stringl(scope, response_object, "http_raw_response", sizeof("http_raw_response")-1, (char *)raw_response->str, raw_response->len TSRMLS_CC);
}
}
zval *jz_data_instance(zval *this_ptr, zval *values, zval *readonly)
{
switch (Z_TYPE_P(values)) {
case IS_ARRAY:
if (Z_ISUNDEF_P(this_ptr)) {
object_init_ex(this_ptr, jz_data_class_entry);
}
zend_update_property(jz_data_class_entry, this_ptr, ZEND_STRL(JZ_DATA_PROPERT_NAME), values);
if (readonly) {
convert_to_boolean(readonly);
zend_update_property_bool(jz_data_class_entry, this_ptr, ZEND_STRL(JZ_DATA_PROPERT_NAME_READONLY), Z_TYPE_P(readonly) == IS_TRUE ? 1 : 0);
}
return this_ptr;
default:
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid parameters provided, must be an array");
return NULL;
}
}
yaf_config_t *yaf_config_simple_instance(yaf_config_t *this_ptr, zval *values, zval *readonly) /* {{{ */ {
switch (Z_TYPE_P(values)) {
case IS_ARRAY:
if (Z_ISUNDEF_P(this_ptr)) {
object_init_ex(this_ptr, yaf_config_simple_ce);
}
zend_update_property(yaf_config_simple_ce, this_ptr, ZEND_STRL(YAF_CONFIG_PROPERT_NAME), values);
if (readonly) {
convert_to_boolean(readonly);
zend_update_property_bool(yaf_config_simple_ce, this_ptr, ZEND_STRL(YAF_CONFIG_PROPERT_NAME_READONLY),
Z_TYPE_P(readonly) == IS_TRUE ? 1 : 0);
}
return this_ptr;
default:
yaf_trigger_error(YAF_ERR_TYPE_ERROR, "Invalid parameters provided, must be an array");
return NULL;
}
}
/* {{{ yaf_route_t * yaf_route_map_instance(yaf_route_t *this_ptr, zend_bool controller_prefer, char *delim, uint len TSRMLS_DC)
*/
yaf_route_t * yaf_route_map_instance(yaf_route_t *this_ptr, zend_bool controller_prefer, char *delim, uint len TSRMLS_DC) {
yaf_route_t *instance;
if (this_ptr) {
instance = this_ptr;
} else {
MAKE_STD_ZVAL(instance);
object_init_ex(instance, yaf_route_map_ce);
}
if (controller_prefer) {
zend_update_property_bool(yaf_route_map_ce, instance,
ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_CTL_PREFER), 1 TSRMLS_CC);
}
if (delim && len) {
zend_update_property_stringl(yaf_route_map_ce, instance,
ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_DELIMETER), delim, len TSRMLS_CC);
}
return instance;
}
static PHP_METHOD(swoole_mysql, query)
{
zval *callback;
swString sql;
bzero(&sql, sizeof(sql));
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &sql.str, &sql.length, &callback) == FAILURE)
{
return;
}
if (sql.length <= 0)
{
swoole_php_fatal_error(E_WARNING, "Query is empty.");
RETURN_FALSE;
}
mysql_client *client = swoole_get_object(getThis());
if (!client)
{
swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_mysql.");
RETURN_FALSE;
}
if (!client->cli)
{
swoole_php_fatal_error(E_WARNING, "mysql connection#%d is closed.", client->fd);
RETURN_FALSE;
}
if (client->state != SW_MYSQL_STATE_QUERY)
{
swoole_php_fatal_error(E_WARNING, "mysql client is waiting response, cannot send new sql query.");
RETURN_FALSE;
}
sw_zval_add_ref(&callback);
client->callback = sw_zval_dup(callback);
swString_clear(mysql_request_buffer);
if (mysql_request(&sql, mysql_request_buffer) < 0)
{
RETURN_FALSE;
}
//send query
if (SwooleG.main_reactor->write(SwooleG.main_reactor, client->fd, mysql_request_buffer->str, mysql_request_buffer->length) < 0)
{
//connection is closed
if (swConnection_error(errno) == SW_CLOSE)
{
zend_update_property_bool(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("connected"), 0 TSRMLS_CC);
zend_update_property_bool(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("errno"), 2006 TSRMLS_CC);
}
RETURN_FALSE;
}
else
{
client->state = SW_MYSQL_STATE_READ_START;
RETURN_TRUE;
}
}
int swoole_websocket_onMessage(swEventData *req)
{
#if PHP_MAJOR_VERSION < 7
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
#endif
int fd = req->info.fd;
zval *zdata;
SW_MAKE_STD_ZVAL(zdata);
char frame_header[2];
php_swoole_get_recv_data(zdata, req, frame_header, 2);
long finish = frame_header[0] ? 1 : 0;
long opcode = frame_header[1];
zval *zframe;
SW_MAKE_STD_ZVAL(zframe);
object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr);
zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC);
zend_update_property_bool(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC);
zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC);
zend_update_property(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), zdata TSRMLS_CC);
swServer *serv = SwooleG.serv;
zval *zserv = (zval *) serv->ptr2;
#ifndef SW_COROUTINE
zval **args[2];
args[0] = &zserv;
args[1] = &zframe;
#else
zval *args[2];
args[0] = zserv;
args[1] = zframe;
#endif
zval *retval = NULL;
#ifndef SW_COROUTINE
zend_fcall_info_cache *fci_cache = php_swoole_server_get_cache(serv, req->info.from_fd, SW_SERVER_CB_onMessage);
zval *zcallback = php_swoole_server_get_callback(SwooleG.serv, req->info.from_fd, SW_SERVER_CB_onMessage);
if (sw_call_user_function_fast(zcallback, fci_cache, &retval, 2, args TSRMLS_CC) == FAILURE)
{
swoole_php_error(E_WARNING, "onMessage handler error");
}
#else
zend_fcall_info_cache *cache = php_swoole_server_get_cache(serv, req->info.from_fd, SW_SERVER_CB_onMessage);
int ret = coro_create(cache, args, 2, &retval, NULL, NULL);
if (ret != 0)
{
sw_zval_ptr_dtor(&zdata);
sw_zval_ptr_dtor(&zframe);
if (ret == CORO_LIMIT)
{
SwooleG.serv->factory.end(&SwooleG.serv->factory, fd);
}
return SW_OK;
}
#endif
if (EG(exception))
{
zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
}
if (retval)
{
sw_zval_ptr_dtor(&retval);
}
sw_zval_ptr_dtor(&zdata);
sw_zval_ptr_dtor(&zframe);
return SW_OK;
}
static PHP_METHOD(swoole_mysql, __construct)
{
if (!mysql_request_buffer)
{
mysql_request_buffer = swString_new(SW_MYSQL_QUERY_INIT_SIZE);
if (!mysql_request_buffer)
{
swoole_php_fatal_error(E_ERROR, "[1] swString_new(%d) failed.", SW_HTTP_RESPONSE_INIT_SIZE);
RETURN_FALSE;
}
}
char *unixsocket = NULL;
zend_size_t unixsocket_len = 0;
mysql_connector connector;
connector.port = SW_MYSQL_DEFAULT_PORT;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "ssss|ls", &connector.host, &connector.host_len,
&connector.user, &connector.user_len, &connector.password, &connector.password_len, &connector.database,
&connector.database_len, &connector.port, &unixsocket, &unixsocket_len) == FAILURE)
{
RETURN_FALSE;
}
swClient *cli = emalloc(sizeof(swClient));
int type = SW_SOCK_TCP;
if (unixsocket)
{
type = SW_SOCK_UNIX_STREAM;
connector.host = unixsocket;
connector.host_len = unixsocket_len;
}
if (swClient_create(cli, type, 0) < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "swClient_create failed.", 1 TSRMLS_CC);
RETURN_FALSE;
}
if (cli->connect(cli, connector.host, connector.port, SW_MYSQL_CONNECT_TIMEOUT, 0) < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "connect to mysql server[%s:%d] failed.", 2 TSRMLS_CC);
RETURN_FALSE;
}
int tcp_nodelay = 1;
if (setsockopt(cli->socket->fd, IPPROTO_TCP, TCP_NODELAY, (const void *) &tcp_nodelay, sizeof(int)) == -1)
{
swoole_php_sys_error(E_WARNING, "setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) failed.", cli->socket->fd);
}
char buf[2048];
int n = cli->recv(cli, buf, sizeof(buf), 0);
if (n < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "recvfrom mysql server failed.", 3 TSRMLS_CC);
RETURN_FALSE;
}
if (mysql_handshake(&connector, buf, n) == SW_ERR)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "handshake with mysql server failed.", 4 TSRMLS_CC);
RETURN_FALSE;
}
if (cli->send(cli, connector.buf, connector.packet_length + 4, 0) < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "sendto mysql server failed.", 5 TSRMLS_CC);
RETURN_FALSE;
}
if (cli->recv(cli, buf, sizeof(buf), 0) < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "recvfrom mysql server failed.", 6 TSRMLS_CC);
RETURN_FALSE;
}
mysql_client *client = emalloc(sizeof(mysql_client));
bzero(client, sizeof(mysql_client));
client->buffer = swString_new(SW_BUFFER_SIZE_BIG);
client->fd = cli->socket->fd;
client->object = getThis();
client->cli = cli;
sw_copy_to_stack(client->object, client->_object);
zend_update_property_bool(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("connected"), 1 TSRMLS_CC);
swoole_set_object(getThis(), client);
php_swoole_check_reactor();
swSetNonBlock(cli->socket->fd);
if (!isset_event_callback)
{
SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_READ, swoole_mysql_onRead);
SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_ERROR, swoole_mysql_onError);
}
swConnection *socket = swReactor_get(SwooleG.main_reactor, cli->socket->fd);
socket->active = 1;
socket->object = client;
}
