char * get_set_var_name_string (char * s, char * index, char * file, int line)
{
return get_set_var_name_int (s, convert_to_long (index, file, line),
file, line);
}
static PHP_METHOD(swoole_mysql, connect)
{
zval *server_info;
zval *callback;
char buf[2048];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az", &server_info, &callback) == FAILURE)
{
RETURN_FALSE;
}
HashTable *_ht = Z_ARRVAL_P(server_info);
zval *value;
mysql_client *client = swoole_get_object(getThis());
mysql_connector *connector = &client->connector;
if (php_swoole_array_get_value(_ht, "host", value))
{
convert_to_string(value);
connector->host = Z_STRVAL_P(value);
connector->host_len = Z_STRLEN_P(value);
}
else
{
zend_throw_exception(swoole_mysql_exception_class_entry, "HOST parameter is required.", 11 TSRMLS_CC);
RETURN_FALSE;
}
if (php_swoole_array_get_value(_ht, "port", value))
{
convert_to_long(value);
connector->port = Z_LVAL_P(value);
}
else
{
connector->port = SW_MYSQL_DEFAULT_PORT;
}
if (php_swoole_array_get_value(_ht, "user", value))
{
convert_to_string(value);
connector->user = Z_STRVAL_P(value);
connector->user_len = Z_STRLEN_P(value);
}
else
{
zend_throw_exception(swoole_mysql_exception_class_entry, "USER parameter is required.", 11 TSRMLS_CC);
RETURN_FALSE;
}
if (php_swoole_array_get_value(_ht, "password", value))
{
convert_to_string(value);
connector->password = Z_STRVAL_P(value);
connector->password_len = Z_STRLEN_P(value);
}
else
{
zend_throw_exception(swoole_mysql_exception_class_entry, "PASSWORD parameter is required.", 11 TSRMLS_CC);
RETURN_FALSE;
}
if (php_swoole_array_get_value(_ht, "database", value))
{
convert_to_string(value);
connector->database = Z_STRVAL_P(value);
connector->database_len = Z_STRLEN_P(value);
}
else
{
zend_throw_exception(swoole_mysql_exception_class_entry, "DATABASE parameter is required.", 11 TSRMLS_CC);
RETURN_FALSE;
}
if (php_swoole_array_get_value(_ht, "timeout", value))
{
convert_to_double(value);
connector->timeout = Z_DVAL_P(value);
}
else
{
connector->timeout = SW_MYSQL_CONNECT_TIMEOUT;
}
if (php_swoole_array_get_value(_ht, "charset", value))
{
convert_to_string(value);
connector->character_set = mysql_get_charset(Z_STRVAL_P(value));
if (connector->character_set < 0)
{
snprintf(buf, sizeof(buf), "unknown charset [%s].", Z_STRVAL_P(value));
zend_throw_exception(swoole_mysql_exception_class_entry, buf, 11 TSRMLS_CC);
RETURN_FALSE;
}
}
else
{
connector->character_set = SW_MYSQL_DEFAULT_CHARSET;
}
swClient *cli = emalloc(sizeof(swClient));
int type = SW_SOCK_TCP;
if (strncasecmp(connector->host, ZEND_STRL("unix:/")) == 0)
{
connector->host = connector->host + 5;
connector->host_len = connector->host_len - 5;
type = SW_SOCK_UNIX_STREAM;
}
else if (strchr(connector->host, ':'))
{
type = SW_SOCK_TCP6;
}
php_swoole_check_reactor();
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_WRITE, swoole_mysql_onWrite);
SwooleG.main_reactor->setHandle(SwooleG.main_reactor, PHP_SWOOLE_FD_MYSQL | SW_EVENT_ERROR, swoole_mysql_onError);
}
if (swClient_create(cli, type, 0) < 0)
{
zend_throw_exception(swoole_mysql_exception_class_entry, "swClient_create failed.", 1 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);
}
int ret = cli->connect(cli, connector->host, connector->port, connector->timeout, 1);
if ((ret < 0 && errno == EINPROGRESS) || ret == 0)
{
if (SwooleG.main_reactor->add(SwooleG.main_reactor, cli->socket->fd, PHP_SWOOLE_FD_MYSQL | SW_EVENT_WRITE) < 0)
{
RETURN_FALSE;
}
}
else
{
snprintf(buf, sizeof(buf), "connect to mysql server[%s:%d] failed.", connector->host, connector->port);
zend_throw_exception(swoole_mysql_exception_class_entry, buf, 2 TSRMLS_CC);
RETURN_FALSE;
}
zend_update_property(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("onConnect"), callback TSRMLS_CC);
zend_update_property(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("serverInfo"), server_info TSRMLS_CC);
zend_update_property_long(swoole_mysql_class_entry_ptr, getThis(), ZEND_STRL("sock"), cli->socket->fd TSRMLS_CC);
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);
sw_zval_add_ref(&client->object);
swConnection *_socket = swReactor_get(SwooleG.main_reactor, cli->socket->fd);
_socket->object = client;
_socket->active = 0;
RETURN_TRUE;
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
long i;
zval *type, *result, *rows, *position;
zval *pointer, *is_different;
HashTable *ah0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBS_VAR(pointer);
phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC);
/**
* We only seek the records if the current position is diferent than the passed one
*/
PHALCON_INIT_VAR(is_different);
is_not_equal_function(is_different, pointer, position TSRMLS_CC);
if (PHALCON_IS_TRUE(is_different)) {
PHALCON_OBS_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
/**
* Here, the resultset is fetched one by one because is large
*/
PHALCON_OBS_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
phalcon_call_method_p1_noret(result, "dataseek", position);
} else {
/**
* Here, the resultset is a small array
*/
PHALCON_OBS_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
/**
* We need to fetch the records because rows is null
*/
if (Z_TYPE_P(rows) == IS_NULL) {
PHALCON_OBS_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_NVAR(rows);
phalcon_call_method(rows, result, "fetchall");
phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC);
}
}
convert_to_long(position);
if(Z_TYPE_P(rows) == IS_ARRAY){
ah0 = Z_ARRVAL_P(rows);
zend_hash_internal_pointer_reset(ah0);
i = 0;
while (1) {
if (i >= Z_LVAL_P(position)) {
break;
}
zend_hash_move_forward(ah0);
i++;
}
}
phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC);
}
}
PHALCON_MM_RESTORE();}
/* {{{ proto mixed com_invoke(int module, string handler_name [, mixed arg [, ...]])
Invokes a COM module */
void php3_COM_invoke(INTERNAL_FUNCTION_PARAMETERS)
{
pval **arguments;
IDispatch *i_dispatch;
int type;
DISPID dispid;
HRESULT hr;
OLECHAR *funcname;
char *error_message;
VARIANTARG *variant_args;
int arg_count = ARG_COUNT(ht), current_arg, current_variant;
DISPPARAMS dispparams;
VARIANTARG var_result;
if (arg_count<2) {
WRONG_PARAM_COUNT;
}
arguments = (pval **) emalloc(sizeof(pval *) * arg_count);
if (getParametersArray(ht, arg_count, arguments)==FAILURE) {
efree(arguments);
RETURN_FALSE;
}
/* obtain i_dispatch interface */
convert_to_long(arguments[0]);
i_dispatch = php3_list_find(arguments[0]->value.lval,&type);
if (!i_dispatch || (type!=le_idispatch)) {
php3_error(E_WARNING,"%d is not a COM object handler", arguments[0]->value.lval);
efree(arguments);
RETURN_FALSE;
}
/* obtain property/method handler */
convert_to_string(arguments[1]);
funcname = _php3_C_str_to_unicode(arguments[1]->value.str.val, arguments[1]->value.str.len);
hr = i_dispatch->lpVtbl->GetIDsOfNames(i_dispatch, &IID_NULL, &funcname,
1, LOCALE_SYSTEM_DEFAULT, &dispid);
if (FAILED(hr)) {
error_message = _php3_COM_error_message(hr);
php3_error(E_WARNING,"Unable to lookup %s: %s\n", arguments[1]->value.str.val, error_message);
LocalFree(error_message);
efree(funcname);
efree(arguments);
RETURN_FALSE;
}
arg_count -= 2;
variant_args = (VARIANTARG *) emalloc(sizeof(VARIANTARG)*arg_count);
for (current_arg=0; current_arg<arg_count; current_arg++) {
current_variant = arg_count - current_arg - 1;
_php3_pval_to_variant(arguments[2+current_arg], &variant_args[current_variant]);
}
dispparams.rgvarg = variant_args;
dispparams.rgdispidNamedArgs = NULL;
dispparams.cArgs = arg_count;
dispparams.cNamedArgs = 0;
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
&dispparams, &var_result, NULL, 0);
if (FAILED(hr)) {
error_message = _php3_COM_error_message(hr);
php3_error(E_WARNING,"Invoke() failed: %s\n", error_message);
LocalFree(error_message);
efree(funcname);
efree(arguments);
efree(variant_args);
RETURN_FALSE;
}
_php3_variant_to_pval(&var_result, return_value);
efree(arguments);
efree(variant_args);
efree(funcname);
}
/* {{{ proto MongoGridFS::__construct(MongoDB db [, string prefix = "fs"])
Creates a new MongoGridFS object */
PHP_METHOD(MongoGridFS, __construct)
{
zval *zdb, *files = NULL, *chunks = NULL, *zchunks;
zval *z_w = NULL;
/* chunks is deprecated */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|zz", &zdb, mongo_ce_DB, &files, &chunks) == FAILURE) {
zval *object = getThis();
ZVAL_NULL(object);
return;
}
if (chunks) {
php_error_docref(NULL TSRMLS_CC, MONGO_E_DEPRECATED, "The 'chunks' argument is deprecated and ignored");
}
if (files) {
zval *temp_file;
char *temp;
if (Z_TYPE_P(files) != IS_STRING || Z_STRLEN_P(files) == 0 ) {
zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 2 TSRMLS_CC, "MongoGridFS::__construct(): invalid prefix");
return;
}
MAKE_STD_ZVAL(chunks);
spprintf(&temp, 0, "%s.chunks", Z_STRVAL_P(files));
ZVAL_STRING(chunks, temp, 0);
MAKE_STD_ZVAL(temp_file);
spprintf(&temp, 0, "%s.files", Z_STRVAL_P(files));
ZVAL_STRING(temp_file, temp, 0);
files = temp_file;
} else {
MAKE_STD_ZVAL(files);
ZVAL_STRING(files, "fs.files", 1);
MAKE_STD_ZVAL(chunks);
ZVAL_STRING(chunks, "fs.chunks", 1);
}
/* create files collection */
MONGO_METHOD2(MongoCollection, __construct, return_value, getThis(), zdb, files);
/* create chunks collection */
MAKE_STD_ZVAL(zchunks);
object_init_ex(zchunks, mongo_ce_Collection);
MONGO_METHOD2(MongoCollection, __construct, return_value, zchunks, zdb, chunks);
/* add chunks collection as a property */
zend_update_property(mongo_ce_GridFS, getThis(), "chunks", strlen("chunks"), zchunks TSRMLS_CC);
zend_update_property(mongo_ce_GridFS, getThis(), "filesName", strlen("filesName"), files TSRMLS_CC);
zend_update_property(mongo_ce_GridFS, getThis(), "chunksName", strlen("chunksName"), chunks TSRMLS_CC);
/* GridFS is forced in our codebase to be w=1 so this property doesn't actually mean
* anything, but we can't lie to the user so we have to overwrite it if the MongoDB
* object that created this object was w=0.
* This property is initialized in the MongoCollection (which we extend) ctor */
z_w = zend_read_property(mongo_ce_GridFS, getThis(), "w", strlen("w"), NOISY TSRMLS_CC);
if (Z_TYPE_P(z_w) != IS_STRING) {
convert_to_long(z_w);
if (Z_LVAL_P(z_w) < 2) {
zend_update_property_long(mongo_ce_GridFS, getThis(), "w", strlen("w"), 1 TSRMLS_CC);
}
}
/* cleanup */
zval_ptr_dtor(&zchunks);
zval_ptr_dtor(&files);
zval_ptr_dtor(&chunks);
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name, *lifetime = NULL;
zval *options, *prefix, *prefixed_key, *cache_dir;
zval *cache_file, *tmp = NULL;
zval *modified_time;
zval *cached_content, *exception_message;
long int now, ttl, mtime, diff;
int expired;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
zval *frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
/**
* Check if the file has expired
*/
now = (long int)time(NULL);
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *last_lifetime = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(last_lifetime) == IS_NULL) {
PHALCON_CALL_METHOD(&tmp, frontend, "getlifetime");
ttl = phalcon_get_intval(tmp);
} else {
ttl = phalcon_get_intval(last_lifetime);
}
} else {
ttl = phalcon_get_intval(lifetime);
}
PHALCON_INIT_VAR(modified_time);
phalcon_filemtime(modified_time, cache_file TSRMLS_CC);
if (unlikely(Z_TYPE_P(modified_time) != IS_LONG)) {
convert_to_long(modified_time);
}
mtime = Z_LVAL_P(modified_time);
diff = now - ttl;
expired = diff > mtime;
/**
* The content is only retrieved if the content has not expired
*/
if (!expired) {
/**
* Use file-get-contents to control that the openbase_dir can't be skipped
*/
PHALCON_INIT_VAR(cached_content);
phalcon_file_get_contents(cached_content, cache_file TSRMLS_CC);
if (PHALCON_IS_FALSE(cached_content)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Cache file ", cache_file, " could not be opened");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cache_exception_ce, exception_message);
return;
}
if (phalcon_is_numeric(cached_content)) {
RETURN_CCTOR(cached_content);
} else {
/**
* Use the frontend to process the content of the cache
*/
PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content);
}
RETURN_MM();
}
}
RETURN_MM_NULL();
}
/* {{{ proto string MongoGridFSFile::getBytes()
Returns this file's contents as a string of bytes */
PHP_METHOD(MongoGridFSFile, getBytes)
{
zval *file, *gridfs, *chunks, *query, *cursor, *sort, *temp;
zval **id, **size;
char *str, *str_ptr;
int len;
mongo_cursor *cursorobj;
zval *flags;
file = zend_read_property(mongo_ce_GridFSFile, getThis(), "file", strlen("file"), NOISY TSRMLS_CC);
zend_hash_find(HASH_P(file), "_id", strlen("_id") + 1, (void**)&id);
if (zend_hash_find(HASH_P(file), "length", strlen("length") + 1, (void**)&size) == FAILURE) {
zend_throw_exception(mongo_ce_GridFSException, "couldn't find file size", 14 TSRMLS_CC);
return;
}
/* make sure that there's an index on chunks so we can sort by chunk num */
gridfs = zend_read_property(mongo_ce_GridFSFile, getThis(), "gridfs", strlen("gridfs"), NOISY TSRMLS_CC);
chunks = zend_read_property(mongo_ce_GridFS, gridfs, "chunks", strlen("chunks"), NOISY TSRMLS_CC);
MAKE_STD_ZVAL(temp);
php_mongo_ensure_gridfs_index(temp, chunks TSRMLS_CC);
zval_dtor(temp);
/* query for chunks */
MAKE_STD_ZVAL(query);
array_init(query);
zval_add_ref(id);
add_assoc_zval(query, "files_id", *id);
MAKE_STD_ZVAL(cursor);
MONGO_METHOD1(MongoCollection, find, cursor, chunks, query);
/* Copy the flags from the original cursor and apply it to this one */
flags = zend_read_property(mongo_ce_GridFSFile, getThis(), "flags", strlen("flags"), NOISY TSRMLS_CC);
cursorobj = (mongo_cursor*)zend_object_store_get_object(cursor TSRMLS_CC);
convert_to_long(flags);
cursorobj->opts = Z_LVAL_P(flags);
MAKE_STD_ZVAL(sort);
array_init(sort);
add_assoc_long(sort, "n", 1);
MONGO_METHOD1(MongoCursor, sort, temp, cursor, sort);
zval_ptr_dtor(&temp);
zval_ptr_dtor(&query);
zval_ptr_dtor(&sort);
if (Z_TYPE_PP(size) == IS_DOUBLE) {
len = (int)Z_DVAL_PP(size);
} else if (Z_TYPE_PP(size) == IS_LONG) {
len = Z_LVAL_PP(size);
} else if (Z_TYPE_PP(size) == IS_OBJECT && (Z_OBJCE_PP(size) == mongo_ce_Int32 || Z_OBJCE_PP(size) == mongo_ce_Int64)) {
zval *sizet = zend_read_property(mongo_ce_Int64, *size, "value", strlen("value"), NOISY TSRMLS_CC);
if (Z_TYPE_P(sizet) != IS_STRING) {
zval_ptr_dtor(&cursor);
zend_throw_exception(mongo_ce_GridFSException, "couldn't find file size, value object broken", 0 TSRMLS_CC);
return;
}
len = atoi(Z_STRVAL_P(sizet));
} else {
zval_ptr_dtor(&cursor);
zend_throw_exception(mongo_ce_GridFSException, "couldn't find file size, property invalid", 0 TSRMLS_CC);
return;
}
str = (char *)ecalloc(len + 1, 1);
str_ptr = str;
if (apply_to_cursor(cursor, copy_bytes, &str, len + 1 TSRMLS_CC) == FAILURE) {
zval_ptr_dtor(&cursor);
efree(str_ptr);
if (EG(exception)) {
return;
}
zend_throw_exception(mongo_ce_GridFSException, "error reading chunk of file", 17 TSRMLS_CC);
return;
}
zval_ptr_dtor(&cursor);
str_ptr[len] = '\0';
RETURN_STRINGL(str_ptr, len, 0);
}
/**
* Reads an item from an array using a zval as index
*/
int phalcon_array_fetch(zval **return_value, zval *arr, zval *index, int silent TSRMLS_DC){
zval **zv;
int result = FAILURE, type;
if (Z_TYPE_P(index) == IS_ARRAY || Z_TYPE_P(index) == IS_OBJECT) {
ZVAL_NULL(*return_value);
if (silent == PH_NOISY) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type");
}
return FAILURE;
}
if (Z_TYPE_P(index) == IS_NULL) {
convert_to_string(index);
}
ZVAL_NULL(*return_value);
if (Z_TYPE_P(arr) == IS_NULL || Z_TYPE_P(arr) == IS_BOOL) {
return FAILURE;
}
if (Z_TYPE_P(index) != IS_STRING && Z_TYPE_P(index) != IS_LONG && Z_TYPE_P(index) != IS_DOUBLE) {
if (silent == PH_NOISY) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type");
}
return FAILURE;
}
if (Z_TYPE_P(index) == IS_STRING) {
if((type = is_numeric_string(Z_STRVAL_P(index), Z_STRLEN_P(index), NULL, NULL, 0))){
if (type == IS_LONG) {
convert_to_long(index);
}
}
} else {
if (Z_TYPE_P(index) == IS_DOUBLE) {
convert_to_long(index);
}
}
if (Z_TYPE_P(index) == IS_STRING) {
if((result = zend_hash_find(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1, (void**) &zv)) == SUCCESS){
zval_ptr_dtor(return_value);
*return_value = *zv;
Z_ADDREF_PP(return_value);
return SUCCESS;
}
}
if (Z_TYPE_P(index) == IS_LONG) {
if ((result = zend_hash_index_find(Z_ARRVAL_P(arr), Z_LVAL_P(index), (void**) &zv)) == SUCCESS) {
zval_ptr_dtor(return_value);
*return_value = *zv;
Z_ADDREF_PP(return_value);
return SUCCESS;
}
}
if (silent == PH_NOISY) {
if (Z_TYPE_P(index) == IS_LONG) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %ld", Z_LVAL_P(index));
} else {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %s", Z_STRVAL_P(index));
}
}
return FAILURE;
}
/* {{{ proto ZMQSocket ZMQSocket::setSockOpt(integer $SOCKOPT, mixed $value)
Set a socket option
*/
PHP_METHOD(zmqsocket, setsockopt)
{
php_zmq_socket_object *intern;
long key;
zval *pz_value;
int status;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz/", &key, &pz_value) == FAILURE) {
return;
}
intern = PHP_ZMQ_SOCKET_OBJECT;
if (!intern->socket) {
zend_throw_exception(php_zmq_socket_exception_sc_entry_get (), "The socket has not been initialized yet", PHP_ZMQ_INTERNAL_ERROR TSRMLS_CC);
return;
}
switch (key) {
case ZMQ_SNDHWM:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_SNDHWM option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RCVHWM:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RCVHWM option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_AFFINITY:
{
uint64_t value;
convert_to_long(pz_value);
value = (uint64_t) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(uint64_t));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_AFFINITY option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_IDENTITY:
{
convert_to_string(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, Z_STRVAL_P(pz_value), Z_STRLEN_P(pz_value));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_IDENTITY option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RATE:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RATE option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RECOVERY_IVL:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RECOVERY_IVL option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_SNDBUF:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_SNDBUF option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RCVBUF:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RCVBUF option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_LINGER:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_LINGER option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RECONNECT_IVL:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RECONNECT_IVL option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RECONNECT_IVL_MAX:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RECONNECT_IVL_MAX option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_BACKLOG:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_BACKLOG option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_MAXMSGSIZE:
{
int64_t value;
convert_to_long(pz_value);
value = (int64_t) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int64_t));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_MAXMSGSIZE option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_SUBSCRIBE:
{
convert_to_string(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, Z_STRVAL_P(pz_value), Z_STRLEN_P(pz_value));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_SUBSCRIBE option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_UNSUBSCRIBE:
{
convert_to_string(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, Z_STRVAL_P(pz_value), Z_STRLEN_P(pz_value));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_UNSUBSCRIBE option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_TYPE:
{
zend_throw_exception(php_zmq_socket_exception_sc_entry_get (), "Setting ZMQ::SOCKOPT_TYPE is not supported", PHP_ZMQ_INTERNAL_ERROR TSRMLS_CC);
return;
}
break;
case ZMQ_RCVMORE:
{
zend_throw_exception(php_zmq_socket_exception_sc_entry_get (), "Setting ZMQ::SOCKOPT_RCVMORE is not supported", PHP_ZMQ_INTERNAL_ERROR TSRMLS_CC);
return;
}
break;
case ZMQ_SNDTIMEO:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_SNDTIMEO option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_RCVTIMEO:
{
int value;
convert_to_long(pz_value);
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, key, &value, sizeof(int));
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_RCVTIMEO option: %s", zmq_strerror(errno));
return;
}
}
break;
case ZMQ_HWM:
{
int value;
convert_to_long(pz_value);
if (Z_LVAL_P(pz_value) < 0) {
zend_throw_exception(php_zmq_socket_exception_sc_entry_get (), "The option value must be zero or larger", PHP_ZMQ_INTERNAL_ERROR TSRMLS_CC);
return;
}
value = (int) Z_LVAL_P(pz_value);
status = zmq_setsockopt(intern->socket->z_socket, ZMQ_SNDHWM, &value, sizeof(int));
if (status == 0) {
status = zmq_setsockopt(intern->socket->z_socket, ZMQ_RCVHWM, &value, sizeof(int));
}
if (status != 0) {
zend_throw_exception_ex(php_zmq_socket_exception_sc_entry_get (), errno TSRMLS_CC, "Failed to set socket ZMQ::SOCKOPT_HWM option: %s", zmq_strerror(errno));
return;
}
}
break;
default:
{
zend_throw_exception(php_zmq_socket_exception_sc_entry_get (), "Unknown option key", PHP_ZMQ_INTERNAL_ERROR TSRMLS_CC);
return;
}
break;
}
ZMQ_RETURN_THIS;
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *char_size = NULL, *numeric_size = NULL, *numeric_scale = NULL, *column_type = NULL;
zval *attribute = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema || !zend_is_true(schema)) {
schema = phalcon_fetch_nproperty_this(this_ptr, SL("_schema"), PH_NOISY TSRMLS_CC);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, PDO_FETCH_NUM);
PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:name, 1:type, 2:size, 3:numeric size, 4:numeric scale, 5: null, 6: key, 7: extra, 8: position, 9: element type
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(char_size);
phalcon_array_fetch_long(&char_size, field, 2, PH_NOISY);
if (Z_TYPE_P(char_size) != IS_NULL) {
convert_to_long(char_size);
}
PHALCON_OBS_NVAR(numeric_size);
phalcon_array_fetch_long(&numeric_size, field, 3, PH_NOISY);
if (phalcon_is_numeric(numeric_size)) {
convert_to_long(numeric_size);
}
PHALCON_OBS_NVAR(numeric_scale);
phalcon_array_fetch_long(&numeric_scale, field, 4, PH_NOISY);
if (phalcon_is_numeric(numeric_scale)) {
convert_to_long(numeric_scale);
}
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Tinyint(1) is boolean
*/
if (phalcon_memnstr_str(column_type, SL("smallint(1)"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("int"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY);
break;
}
/**
* Varchar
*/
if (phalcon_memnstr_str(column_type, SL("varying"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Special type for datetime
*/
if (phalcon_memnstr_str(column_type, SL("date"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Numeric
*/
if (phalcon_memnstr_str(column_type, SL("numeric"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
if (phalcon_is_numeric(numeric_size)) {
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(numeric_size) * 8, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY);
}
if (phalcon_is_numeric(numeric_scale)) {
phalcon_array_update_string(&definition, SL("scale"), numeric_scale, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY);
}
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("char"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Date
*/
if (phalcon_memnstr_str(column_type, SL("timestamp"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATETIME, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("float"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Boolean
*/
if (phalcon_memnstr_str(column_type, SL("bool"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* UUID
*/
if (phalcon_memnstr_str(column_type, SL("uuid"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_COPY);
break;
}
/**
* JSON
*/
if (phalcon_memnstr_str(column_type, SL("json"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_JSON, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* ARRAY
*/
if (phalcon_memnstr_str(column_type, SL("ARRAY"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_ARRAY, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_OTHER, PH_COPY);
break;
}
if (phalcon_memnstr_str(column_type, SL("unsigned"))) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_COPY);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY);
} else {
phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY);
}
/**
* Check if the column is auto increment
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_COPY);
} else if (!PHALCON_IS_EMPTY(attribute)) {
phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_COPY);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
void cpServer_init(zval *conf, char *ini_file)
{
size_t group_num = 0;
cpShareMemory shm = {0};
shm.size = sizeof (cpServerGS);
strncpy(shm.mmap_name, CP_SERVER_MMAP_FILE, strlen(CP_SERVER_MMAP_FILE));
if (cp_create_mmap_file(&shm) == 0)
{
CPGS = (cpServerGS*) cp_mmap_calloc_with_file(&shm);
cpKillClient();
bzero(CPGS, shm.size);
if (CPGS == NULL)
{
php_printf("calloc[1] fail\n");
return;
}
}
else
{
php_printf("calloc[1] fail\n");
return;
}
bzero(&CPGL, sizeof (cpServerG));
CPGC.backlog = CP_BACKLOG;
// CPGC.reactor_num = CP_CPU_NUM;
CPGC.reactor_num = 1;
CPGC.timeout_sec = CP_REACTOR_TIMEO_SEC;
CPGC.timeout_usec = CP_REACTOR_TIMEO_USEC;
CPGC.max_conn = CP_MAX_FDS;
CPGC.max_request = CP_MAX_REQUEST;
CPGC.idel_time = CP_IDEL_TIME;
CPGC.recycle_num = CP_RECYCLE_NUM;
CPGC.max_read_len = CP_DEF_MAX_READ_LEN;
CPGC.ser_fail_hits = 1;
CPGC.max_fail_num = 2;
strcpy(CPGC.ini_file, ini_file);
// MAKE_STD_ZVAL(CPGS->group);
// array_init(CPGS->group);
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(conf)); zend_hash_has_more_elements(Z_ARRVAL_P(conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(conf)))
{
zval **config;
zend_hash_get_current_data(Z_ARRVAL_P(conf), (void**) &config);
char *name;
uint keylen;
zend_hash_get_current_key_ex(Z_ARRVAL_P(conf), &name, &keylen, NULL, 0, NULL);
if (strcmp(name, "common") == 0)
{//common config
cpServer_init_common(*config);
}
else
{
zval **v;
strcpy(CPGS->G[group_num].name, name);
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGS->G[group_num].worker_num = CPGS->G[group_num].worker_min = Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGS->G[group_num].worker_max = Z_LVAL_PP(v);
}
CPGS->max_buffer_len = CPGC.max_read_len;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
if (pthread_mutex_init(&CPGS->G[group_num].mutex_lock, &attr) < 0)
{
cpLog("pthread_mutex_init error!. Error: %s [%d]", strerror(errno), errno);
return;
}
CPGS->G[group_num].lock = cpMutexLock;
CPGS->G[group_num].unLock = cpMutexUnLock;
CPGS->G[group_num].tryLock = cpMutexTryLock;
// CPGS->G[group_num].WaitList = CPGS->G[group_num].WaitTail = NULL;
CPGS->group_num++;
group_num++;
}
}
}
static void _timecop_gettimeofday(INTERNAL_FUNCTION_PARAMETERS, int mode)
{
zend_bool get_as_float = 0;
long fixed_sec = 0, fixed_usec = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &get_as_float) == FAILURE) {
return;
}
switch (TIMECOP_G(timecop_mode)) {
case TIMECOP_MODE_FREEZE:
fixed_sec = TIMECOP_G(freezed_timestamp);
fixed_usec = 0;
break;
case TIMECOP_MODE_TRAVEL:
{
zval timeofday, *zv_sec, *zv_usec;
timecop_call_orig_method_with_0_params(NULL, NULL, NULL, "gettimeofday", &timeofday);
zv_sec = zend_hash_str_find(Z_ARR(timeofday), "sec", sizeof("sec")-1);
if (zv_sec) {
fixed_sec = Z_LVAL_P(zv_sec) + TIMECOP_G(travel_offset);
}
zv_usec = zend_hash_str_find(Z_ARR(timeofday), "usec", sizeof("usec")-1);
if (zv_sec) {
fixed_usec = Z_LVAL_P(zv_usec);
}
zval_ptr_dtor(&timeofday);
}
break;
default:
{
const char *func_name;
size_t func_name_len;
zval *arg1 = NULL, tmp;
int param_count = 0;
if (mode) {
func_name = ORIG_FUNC_NAME("gettimeofday");
func_name_len = ORIG_FUNC_NAME_SIZEOF("gettimeofday")-1;
} else {
func_name = ORIG_FUNC_NAME("microtime");
func_name_len = ORIG_FUNC_NAME_SIZEOF("microtime")-1;
}
if (get_as_float) {
ZVAL_TRUE(&tmp);
arg1 = &tmp;
param_count = 1;
}
zend_call_method(NULL, NULL, NULL, func_name, func_name_len, return_value, param_count, arg1, NULL);
return;
}
}
if (get_as_float) {
RETURN_DOUBLE((double)(fixed_sec + fixed_usec / MICRO_IN_SEC));
}
if (mode) {
zval zv_offset, zv_dst, format, timestamp;
long offset = 0, is_dst = 0;
ZVAL_LONG(×tamp, fixed_sec);
/* offset */
ZVAL_STRING(&format, "Z");
timecop_call_orig_method_with_2_params(NULL, NULL, NULL, "date", &zv_offset, &format, ×tamp);
convert_to_long(&zv_offset);
offset = Z_LVAL(zv_offset);
zval_ptr_dtor(&zv_offset);
zval_ptr_dtor(&format);
/* is_dst */
ZVAL_STRING(&format, "I");
timecop_call_orig_method_with_2_params(NULL, NULL, NULL, "date", &zv_dst, &format, ×tamp);
convert_to_long(&zv_dst);
is_dst = Z_LVAL(zv_dst);
zval_ptr_dtor(&zv_dst);
zval_ptr_dtor(&format);
array_init(return_value);
add_assoc_long(return_value, "sec", fixed_sec);
add_assoc_long(return_value, "usec", fixed_usec);
add_assoc_long(return_value, "minuteswest", -offset / SEC_IN_MIN);
add_assoc_long(return_value, "dsttime", is_dst);
} else {
char ret[100];
snprintf(ret, 100, "%.8F %ld", fixed_usec / MICRO_IN_SEC, fixed_sec);
RETURN_STRING(ret);
}
}
static
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval* value, HashTable* fieldspec) {
// At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
if (Z_TYPE_P(value) != IS_OBJECT) {
throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA);
}
zval* spec = zend_read_static_property(Z_OBJCE_P(value), "_TSPEC", sizeof("_TSPEC")-1, false);
if (Z_TYPE_P(spec) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send non-Thrift object as a T_STRUCT", INVALID_DATA);
}
binary_serialize_spec(value, transport, Z_ARRVAL_P(spec));
} return;
case T_BOOL:
if (!zval_is_bool(value)) convert_to_boolean(value);
transport.writeI8(Z_TYPE_INFO_P(value) == IS_TRUE ? 1 : 0);
return;
case T_BYTE:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI8(Z_LVAL_P(value));
return;
case T_I16:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI16(Z_LVAL_P(value));
return;
case T_I32:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI32(Z_LVAL_P(value));
return;
case T_I64:
case T_U64: {
int64_t l_data;
#if defined(_LP64) || defined(_WIN64)
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
l_data = Z_LVAL_P(value);
#else
if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value);
l_data = (int64_t)Z_DVAL_P(value);
#endif
transport.writeI64(l_data);
} return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value);
a.d = Z_DVAL_P(value);
transport.writeI64(a.c);
} return;
case T_UTF8:
case T_UTF16:
case T_STRING:
if (Z_TYPE_P(value) != IS_STRING) convert_to_string(value);
transport.writeString(Z_STRVAL_P(value), Z_STRLEN_P(value));
return;
case T_MAP: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "ktype", sizeof("ktype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t keytype = Z_LVAL_P(val_ptr);
transport.writeI8(keytype);
val_ptr = zend_hash_str_find(fieldspec, "vtype", sizeof("vtype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t valtype = Z_LVAL_P(val_ptr);
transport.writeI8(valtype);
val_ptr = zend_hash_str_find(fieldspec, "val", sizeof("val")-1);
HashTable* valspec = Z_ARRVAL_P(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
binary_serialize(valtype, transport, val_ptr, valspec);
}
} return;
case T_LIST: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t valtype = Z_LVAL_P(val_ptr);
transport.writeI8(valtype);
val_ptr = zend_hash_str_find(fieldspec, "elem", sizeof("elem")-1);
HashTable* valspec = Z_ARRVAL_P(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize(valtype, transport, val_ptr, valspec);
}
} return;
case T_SET: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t keytype = Z_LVAL_P(val_ptr);
transport.writeI8(keytype);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
}
} return;
};
char errbuf[128];
snprintf(errbuf, 128, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(errbuf, INVALID_DATA);
}
void zend_optimizer_pass2(zend_op_array *op_array)
{
zend_op *opline;
zend_op *end = op_array->opcodes + op_array->last;
opline = op_array->opcodes;
while (opline < end) {
switch (opline->opcode) {
case ZEND_ADD:
case ZEND_SUB:
case ZEND_MUL:
case ZEND_DIV:
case ZEND_POW:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
convert_scalar_to_number(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally* - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_ADD:
case ZEND_ASSIGN_SUB:
case ZEND_ASSIGN_MUL:
case ZEND_ASSIGN_DIV:
case ZEND_ASSIGN_POW:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
convert_scalar_to_number(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_MOD:
case ZEND_SL:
case ZEND_SR:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
convert_to_long(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_MOD:
case ZEND_ASSIGN_SL:
case ZEND_ASSIGN_SR:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
convert_to_long(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_CONCAT:
case ZEND_FAST_CONCAT:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_CONCAT:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_JMPZ_EX:
case ZEND_JMPNZ_EX:
/* convert Ti = JMPZ_EX(Ti, L) to JMPZ(Ti, L) */
if (0 && /* FIXME: temporary disable unsafe pattern */
ZEND_OP1_TYPE(opline) == IS_TMP_VAR &&
ZEND_RESULT_TYPE(opline) == IS_TMP_VAR &&
ZEND_OP1(opline).var == ZEND_RESULT(opline).var) {
opline->opcode -= 3;
/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
in case we know it wouldn't jump */
} else if (ZEND_OP1_TYPE(opline) == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ_EX) {
should_jmp = !should_jmp;
}
if (!should_jmp) {
opline->opcode = ZEND_QM_ASSIGN;
SET_UNUSED(opline->op2);
}
}
break;
case ZEND_JMPZ:
case ZEND_JMPNZ:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp;
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_OP1_TYPE(opline) = IS_UNUSED;
if (should_jmp) {
opline->opcode = ZEND_JMP;
COPY_NODE(opline->op1, opline->op2);
} else {
MAKE_NOP(opline);
}
break;
}
if ((opline + 1)->opcode == ZEND_JMP) {
/* JMPZ(X, L1), JMP(L2) => JMPZNZ(X, L1, L2) */
/* JMPNZ(X, L1), JMP(L2) => JMPZNZ(X, L2, L1) */
if (ZEND_OP2_JMP_ADDR(opline) == ZEND_OP1_JMP_ADDR(opline + 1)) {
/* JMPZ(X, L1), JMP(L1) => NOP, JMP(L1) */
MAKE_NOP(opline);
} else {
if (opline->opcode == ZEND_JMPZ) {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP1_JMP_ADDR(opline + 1));
} else {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP2_JMP_ADDR(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP1_JMP_ADDR(opline + 1));
}
opline->opcode = ZEND_JMPZNZ;
}
}
break;
case ZEND_JMPZNZ:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
zend_op *target_opline;
if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
target_opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); /* JMPNZ */
} else {
target_opline = ZEND_OP2_JMP_ADDR(opline); /* JMPZ */
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, target_opline);
ZEND_OP1_TYPE(opline) = IS_UNUSED;
opline->opcode = ZEND_JMP;
}
break;
}
opline++;
}
}
static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
enum pdo_param_event event_type)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
zval *parameter;
switch (event_type) {
case PDO_PARAM_EVT_EXEC_PRE:
if (stmt->executed && !S->done) {
sqlite3_reset(S->stmt);
S->done = 1;
}
if (param->is_param) {
if (param->paramno == -1) {
param->paramno = sqlite3_bind_parameter_index(S->stmt, ZSTR_VAL(param->name)) - 1;
}
switch (PDO_PARAM_TYPE(param->param_type)) {
case PDO_PARAM_STMT:
return 0;
case PDO_PARAM_NULL:
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
pdo_sqlite_error_stmt(stmt);
return 0;
case PDO_PARAM_INT:
case PDO_PARAM_BOOL:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
} else {
convert_to_long(parameter);
#if ZEND_LONG_MAX > 2147483647
if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
return 1;
}
#else
if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
return 1;
}
#endif
}
pdo_sqlite_error_stmt(stmt);
return 0;
case PDO_PARAM_LOB:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
if (Z_TYPE_P(parameter) == IS_RESOURCE) {
php_stream *stm = NULL;
php_stream_from_zval_no_verify(stm, parameter);
if (stm) {
zend_string *mem = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
zval_ptr_dtor(parameter);
ZVAL_STR(parameter, mem ? mem : ZSTR_EMPTY_ALLOC());
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
return 0;
}
} else if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
pdo_sqlite_error_stmt(stmt);
return 0;
} else {
convert_to_string(parameter);
}
if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
Z_STRVAL_P(parameter),
Z_STRLEN_P(parameter),
SQLITE_STATIC)) {
return 1;
}
return 0;
case PDO_PARAM_STR:
default:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
} else {
convert_to_string(parameter);
if (SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
Z_STRVAL_P(parameter),
Z_STRLEN_P(parameter),
SQLITE_STATIC)) {
return 1;
}
}
pdo_sqlite_error_stmt(stmt);
return 0;
}
}
break;
default:
;
}
return 1;
}
static PHP_METHOD(swoole_server_port, set)
{
zval *zset = NULL;
HashTable *vht;
zval *v;
vht = Z_ARRVAL_P(zset);
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "z", &zset) == FAILURE)
{
return;
}
swListenPort *port = swoole_get_object(getThis());
if (port == NULL)
{
swoole_php_fatal_error(E_ERROR, "Please use the swoole_server->listen method.");
return;
}
//backlog
if (sw_zend_hash_find(vht, ZEND_STRS("backlog"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->backlog = (int) Z_LVAL_P(v);
}
//tcp_nodelay
if (sw_zend_hash_find(vht, ZEND_STRS("open_tcp_nodelay"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->open_tcp_nodelay = Z_BVAL_P(v);
}
//tcp_defer_accept
if (sw_zend_hash_find(vht, ZEND_STRS("tcp_defer_accept"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->tcp_defer_accept = (uint8_t) Z_LVAL_P(v);
}
//port reuse
if (sw_zend_hash_find(vht, ZEND_STRS("enable_port_reuse"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
SwooleG.reuse_port = Z_BVAL_P(v);
}
//tcp_keepalive
if (sw_zend_hash_find(vht, ZEND_STRS("open_tcp_keepalive"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->open_tcp_keepalive = Z_BVAL_P(v);
}
//buffer: split package with eof
if (sw_zend_hash_find(vht, ZEND_STRS("open_eof_split"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->protocol.split_by_eof = Z_BVAL_P(v);
port->open_eof_check = 1;
}
//package eof
if (sw_zend_hash_find(vht, ZEND_STRS("package_eof"), (void **) &v) == SUCCESS)
{
convert_to_string(v);
port->protocol.package_eof_len = Z_STRLEN_P(v);
if (port->protocol.package_eof_len > SW_DATA_EOF_MAXLEN)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "pacakge_eof max length is %d", SW_DATA_EOF_MAXLEN);
RETURN_FALSE;
}
bzero(port->protocol.package_eof, SW_DATA_EOF_MAXLEN);
memcpy(port->protocol.package_eof, Z_STRVAL_P(v), Z_STRLEN_P(v));
}
//buffer: http_protocol
if (sw_zend_hash_find(vht, ZEND_STRS("open_http_protocol"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->open_http_protocol = Z_BVAL_P(v);
}
//buffer: mqtt protocol
if (sw_zend_hash_find(vht, ZEND_STRS("open_mqtt_protocol"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->open_mqtt_protocol = Z_BVAL_P(v);
}
//tcp_keepidle
if (sw_zend_hash_find(vht, ZEND_STRS("tcp_keepidle"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->tcp_keepidle = (uint16_t) Z_LVAL_P(v);
}
//tcp_keepinterval
if (sw_zend_hash_find(vht, ZEND_STRS("tcp_keepinterval"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->tcp_keepinterval = (uint16_t) Z_LVAL_P(v);
}
//tcp_keepcount
if (sw_zend_hash_find(vht, ZEND_STRS("tcp_keepcount"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->tcp_keepcount = (uint16_t) Z_LVAL_P(v);
}
//open length check
if (sw_zend_hash_find(vht, ZEND_STRS("open_length_check"), (void **) &v) == SUCCESS)
{
convert_to_boolean(v);
port->open_length_check = Z_BVAL_P(v);
}
//package length size
if (sw_zend_hash_find(vht, ZEND_STRS("package_length_type"), (void **)&v) == SUCCESS)
{
convert_to_string(v);
port->protocol.package_length_type = Z_STRVAL_P(v)[0];
port->protocol.package_length_size = swoole_type_size(port->protocol.package_length_type);
if (port->protocol.package_length_size == 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "unknow package_length_type, see pack(). Link: http://php.net/pack");
RETURN_FALSE;
}
}
//package length offset
if (sw_zend_hash_find(vht, ZEND_STRS("package_length_offset"), (void **)&v) == SUCCESS)
{
convert_to_long(v);
port->protocol.package_length_offset = (int)Z_LVAL_P(v);
}
//package body start
if (sw_zend_hash_find(vht, ZEND_STRS("package_body_offset"), (void **) &v) == SUCCESS
|| sw_zend_hash_find(vht, ZEND_STRS("package_body_start"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->protocol.package_body_offset = (int) Z_LVAL_P(v);
}
/**
* package max length
*/
if (sw_zend_hash_find(vht, ZEND_STRS("package_max_length"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->protocol.package_max_length = (int) Z_LVAL_P(v);
}
/**
* swoole_packet_mode
*/
if (SwooleG.serv->packet_mode == 1)
{
port->protocol.package_max_length = 64 * 1024 * 1024;
port->open_length_check = 1;
port->protocol.package_length_offset = 0;
port->protocol.package_body_offset = 4;
port->protocol.package_length_type = 'N';
port->open_eof_check = 0;
}
#ifdef SW_USE_OPENSSL
if (sw_zend_hash_find(vht, ZEND_STRS("ssl_cert_file"), (void **) &v) == SUCCESS)
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl cert file[%s] not found.", Z_STRVAL_P(v));
return;
}
port->ssl_cert_file = strdup(Z_STRVAL_P(v));
port->open_ssl_encrypt = 1;
}
if (sw_zend_hash_find(vht, ZEND_STRS("ssl_key_file"), (void **) &v) == SUCCESS)
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl key file[%s] not found.", Z_STRVAL_P(v));
return;
}
port->ssl_key_file = strdup(Z_STRVAL_P(v));
}
if (sw_zend_hash_find(vht, ZEND_STRS("ssl_method"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->ssl_method = (int) Z_LVAL_P(v);
}
//verify client cert
if (sw_zend_hash_find(vht, ZEND_STRS("ssl_client_cert_file"), (void **) &v) == SUCCESS)
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl cert file[%s] not found.", port->ssl_cert_file);
return;
}
port->ssl_client_cert_file = strdup(Z_STRVAL_P(v));
}
if (sw_zend_hash_find(vht, ZEND_STRS("ssl_verify_depth"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->ssl_verify_depth = (int) Z_LVAL_P(v);
}
if (port->open_ssl_encrypt && !port->ssl_key_file)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "ssl require key file.");
return;
}
#endif
}
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval** value, HashTable* fieldspec) {
// At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
TSRMLS_FETCH();
if (Z_TYPE_PP(value) != IS_OBJECT) {
throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA);
}
zval* spec = zend_read_static_property(zend_get_class_entry(*value TSRMLS_CC), "_TSPEC", 6, false TSRMLS_CC);
binary_serialize_spec(*value, transport, Z_ARRVAL_P(spec));
}
return;
case T_BOOL:
if (Z_TYPE_PP(value) != IS_BOOL) convert_to_boolean(*value);
transport.writeI8(Z_BVAL_PP(value) ? 1 : 0);
return;
case T_BYTE:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI8(Z_LVAL_PP(value));
return;
case T_I16:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI16(Z_LVAL_PP(value));
return;
case T_I32:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI32(Z_LVAL_PP(value));
return;
case T_I64:
case T_U64:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI64(Z_LVAL_PP(value));
return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
if (Z_TYPE_PP(value) != IS_DOUBLE) convert_to_double(*value);
a.d = Z_DVAL_PP(value);
transport.writeI64(a.c);
}
return;
//case T_UTF7:
case T_UTF8:
case T_UTF16:
case T_STRING:
if (Z_TYPE_PP(value) != IS_STRING) convert_to_string(*value);
transport.writeString(Z_STRVAL_PP(value), Z_STRLEN_PP(value));
return;
case T_MAP: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "ktype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t keytype = Z_LVAL_PP(val_ptr);
transport.writeI8(keytype);
zend_hash_find(fieldspec, "vtype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t valtype = Z_LVAL_PP(val_ptr);
transport.writeI8(valtype);
zend_hash_find(fieldspec, "val", 4, (void**)&val_ptr);
HashTable* valspec = Z_ARRVAL_PP(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
binary_serialize(valtype, transport, val_ptr, valspec);
}
}
return;
case T_LIST: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t valtype = Z_LVAL_PP(val_ptr);
transport.writeI8(valtype);
zend_hash_find(fieldspec, "elem", 5, (void**)&val_ptr);
HashTable* valspec = Z_ARRVAL_PP(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize(valtype, transport, val_ptr, valspec);
}
}
return;
case T_SET: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t keytype = Z_LVAL_PP(val_ptr);
transport.writeI8(keytype);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
}
}
return;
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(errbuf, INVALID_DATA);
}
/**
* Resize the image to the given size. Either the width or the height can
* be omitted and the image will be resized proportionally.
*
* @param int $width new width
* @param int $height new height
* @param int $master master dimension, if $master is TENSILE, the width and height must be specified
* @return Phalcon\Image\Adapter
*/
PHP_METHOD(Phalcon_Image_Adapter, resize) {
zval *width = NULL, *height = NULL, *zmaster = NULL;
zval *image_width, *image_height;
long tmp_image_width, tmp_image_height, tmp_width = 0, tmp_height = 0, master;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 3, &width, &height, &zmaster);
if (!zmaster) {
master = PHALCON_IMAGE_AUTO;
} else {
master = phalcon_get_intval(zmaster);
}
if (PHALCON_IMAGE_TENSILE == master) {
if (!width || !height) {
PHALCON_THROW_EXCEPTION_STR(phalcon_image_exception_ce, "width and height parameters must be specified");
return;
}
if (Z_TYPE_P(width) != IS_LONG) {
PHALCON_SEPARATE_PARAM(width);
convert_to_long(width);
}
if (Z_TYPE_P(height) != IS_LONG) {
convert_to_long(height);
}
} else {
if (!width) {
PHALCON_INIT_VAR(width);
} else {
PHALCON_SEPARATE_PARAM(width);
}
if (!height) {
PHALCON_INIT_VAR(height);
} else {
PHALCON_SEPARATE_PARAM(height);
}
image_width = phalcon_fetch_nproperty_this(this_ptr, SL("_width"), PH_NOISY TSRMLS_CC);
image_height = phalcon_fetch_nproperty_this(this_ptr, SL("_height"), PH_NOISY TSRMLS_CC);
tmp_image_width = phalcon_get_intval(image_width);
tmp_image_height = phalcon_get_intval(image_height);
if ((master == PHALCON_IMAGE_WIDTH && Z_TYPE_P(width) == IS_LONG) || (master == PHALCON_IMAGE_HEIGHT && Z_TYPE_P(height) == IS_LONG)) {
master = PHALCON_IMAGE_AUTO;
}
if (Z_TYPE_P(width) != IS_LONG) {
if (master == PHALCON_IMAGE_NONE) {
tmp_width = tmp_image_width;
} else {
master = PHALCON_IMAGE_HEIGHT;
}
} else {
tmp_width = Z_LVAL_P(width);
}
if (Z_TYPE_P(height) != IS_LONG) {
if (master == PHALCON_IMAGE_NONE) {
tmp_height = tmp_image_height;
} else {
master = PHALCON_IMAGE_WIDTH;
}
} else {
tmp_height = Z_LVAL_P(height);
}
if (tmp_width <= 0) {
tmp_width = 1;
}
if (tmp_height <= 0) {
tmp_height = 1;
}
switch (master) {
case PHALCON_IMAGE_AUTO:
if ((tmp_image_width / tmp_width) > (tmp_image_height / tmp_height)) {
master = PHALCON_IMAGE_WIDTH;
} else {
master = PHALCON_IMAGE_HEIGHT;
}
break;
case PHALCON_IMAGE_INVERSE:
if ((tmp_image_width / tmp_width) > (tmp_image_height / tmp_height)) {
master = PHALCON_IMAGE_HEIGHT;
} else {
master = PHALCON_IMAGE_WIDTH;
}
break;
}
if (tmp_image_width <= 0) {
tmp_image_width = 1;
}
if (tmp_image_height <= 0) {
tmp_image_height = 1;
}
switch (master) {
case PHALCON_IMAGE_WIDTH:
tmp_height = (int)((tmp_image_height * tmp_width / tmp_image_width) + 0.5);
break;
case PHALCON_IMAGE_HEIGHT:
tmp_width = (int)((tmp_image_width * tmp_height / tmp_image_height) + 0.5);
break;
case PHALCON_IMAGE_PRECISE:
if ((tmp_width / tmp_height) > (tmp_image_width / tmp_image_height)) {
tmp_height = (int)((tmp_image_height * tmp_width / tmp_image_width) + 0.5);
} else {
tmp_width = (int)((tmp_image_width * tmp_height / tmp_image_height) + 0.5);
}
break;
}
if (tmp_width <= 0) {
tmp_width = 1;
}
if (tmp_height <= 0) {
tmp_height = 1;
}
PHALCON_INIT_NVAR(width);
ZVAL_LONG(width, tmp_width);
PHALCON_INIT_NVAR(height);
ZVAL_LONG(height, tmp_height);
}
PHALCON_CALL_METHOD(NULL, this_ptr, "_resize", width, height);
RETURN_THIS();
}
PDO_API int pdo_parse_params(pdo_stmt_t *stmt, char *inquery, size_t inquery_len,
char **outquery, size_t *outquery_len)
{
Scanner s;
char *ptr, *newbuffer;
int t;
int bindno = 0;
int ret = 0;
size_t newbuffer_len;
HashTable *params;
struct pdo_bound_param_data *param;
int query_type = PDO_PLACEHOLDER_NONE;
struct placeholder *placeholders = NULL, *placetail = NULL, *plc = NULL;
ptr = *outquery;
s.cur = inquery;
s.end = inquery + inquery_len + 1;
/* phase 1: look for args */
while((t = scan(&s)) != PDO_PARSER_EOI) {
if (t == PDO_PARSER_BIND || t == PDO_PARSER_BIND_POS) {
if (t == PDO_PARSER_BIND) {
int len = s.cur - s.tok;
if ((inquery < (s.cur - len)) && isalnum(*(s.cur - len - 1))) {
continue;
}
query_type |= PDO_PLACEHOLDER_NAMED;
} else {
query_type |= PDO_PLACEHOLDER_POSITIONAL;
}
plc = emalloc(sizeof(*plc));
memset(plc, 0, sizeof(*plc));
plc->next = NULL;
plc->pos = s.tok;
plc->len = s.cur - s.tok;
plc->bindno = bindno++;
if (placetail) {
placetail->next = plc;
} else {
placeholders = plc;
}
placetail = plc;
}
}
if (bindno == 0) {
/* nothing to do; good! */
return 0;
}
/* did the query make sense to me? */
if (query_type == (PDO_PLACEHOLDER_NAMED|PDO_PLACEHOLDER_POSITIONAL)) {
/* they mixed both types; punt */
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "mixed named and positional parameters");
ret = -1;
goto clean_up;
}
if (stmt->supports_placeholders == query_type && !stmt->named_rewrite_template) {
/* query matches native syntax */
ret = 0;
goto clean_up;
}
if (stmt->named_rewrite_template) {
/* magic/hack.
* We we pretend that the query was positional even if
* it was named so that we fall into the
* named rewrite case below. Not too pretty,
* but it works. */
query_type = PDO_PLACEHOLDER_POSITIONAL;
}
params = stmt->bound_params;
/* Do we have placeholders but no bound params */
if (bindno && !params && stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "no parameters were bound");
ret = -1;
goto clean_up;
}
if (params && bindno != zend_hash_num_elements(params) && stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
/* extra bit of validation for instances when same params are bound more than once */
if (query_type != PDO_PLACEHOLDER_POSITIONAL && bindno > zend_hash_num_elements(params)) {
int ok = 1;
for (plc = placeholders; plc; plc = plc->next) {
if ((param = zend_hash_str_find_ptr(params, plc->pos, plc->len)) == NULL) {
ok = 0;
break;
}
}
if (ok) {
goto safe;
}
}
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "number of bound variables does not match number of tokens");
ret = -1;
goto clean_up;
}
safe:
/* what are we going to do ? */
if (stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
/* query generation */
newbuffer_len = inquery_len;
/* let's quote all the values */
for (plc = placeholders; plc; plc = plc->next) {
if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
param = zend_hash_index_find_ptr(params, plc->bindno);
} else {
param = zend_hash_str_find_ptr(params, plc->pos, plc->len);
}
if (param == NULL) {
/* parameter was not defined */
ret = -1;
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined");
goto clean_up;
}
if (stmt->dbh->methods->quoter) {
zval *parameter;
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
if (param->param_type == PDO_PARAM_LOB && Z_TYPE_P(parameter) == IS_RESOURCE) {
php_stream *stm;
php_stream_from_zval_no_verify(stm, parameter);
if (stm) {
zend_string *buf;
buf = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
if (!buf) {
buf = ZSTR_EMPTY_ALLOC();
}
if (!stmt->dbh->methods->quoter(stmt->dbh, ZSTR_VAL(buf), ZSTR_LEN(buf), &plc->quoted, &plc->qlen,
param->param_type)) {
/* bork */
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
if (buf) {
zend_string_release(buf);
}
goto clean_up;
}
if (buf) {
zend_string_release(buf);
}
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
ret = -1;
goto clean_up;
}
plc->freeq = 1;
} else {
zval tmp_param;
ZVAL_DUP(&tmp_param, parameter);
switch (Z_TYPE(tmp_param)) {
case IS_NULL:
plc->quoted = "NULL";
plc->qlen = sizeof("NULL")-1;
plc->freeq = 0;
break;
case IS_FALSE:
case IS_TRUE:
convert_to_long(&tmp_param);
/* fall through */
case IS_LONG:
case IS_DOUBLE:
convert_to_string(&tmp_param);
plc->qlen = Z_STRLEN(tmp_param);
plc->quoted = estrdup(Z_STRVAL(tmp_param));
plc->freeq = 1;
break;
default:
convert_to_string(&tmp_param);
if (!stmt->dbh->methods->quoter(stmt->dbh, Z_STRVAL(tmp_param),
Z_STRLEN(tmp_param), &plc->quoted, &plc->qlen,
param->param_type)) {
/* bork */
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
goto clean_up;
}
plc->freeq = 1;
}
zval_dtor(&tmp_param);
}
} else {
zval *parameter;
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
plc->quoted = Z_STRVAL_P(parameter);
plc->qlen = Z_STRLEN_P(parameter);
}
newbuffer_len += plc->qlen;
}
rewrite:
/* allocate output buffer */
newbuffer = emalloc(newbuffer_len + 1);
*outquery = newbuffer;
/* and build the query */
plc = placeholders;
ptr = inquery;
do {
t = plc->pos - ptr;
if (t) {
memcpy(newbuffer, ptr, t);
newbuffer += t;
}
memcpy(newbuffer, plc->quoted, plc->qlen);
newbuffer += plc->qlen;
ptr = plc->pos + plc->len;
plc = plc->next;
} while (plc);
t = (inquery + inquery_len) - ptr;
if (t) {
memcpy(newbuffer, ptr, t);
newbuffer += t;
}
*newbuffer = '\0';
*outquery_len = newbuffer - *outquery;
ret = 1;
goto clean_up;
} else if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
/* rewrite ? to :pdoX */
char *name, *idxbuf;
const char *tmpl = stmt->named_rewrite_template ? stmt->named_rewrite_template : ":pdo%d";
int bind_no = 1;
newbuffer_len = inquery_len;
if (stmt->bound_param_map == NULL) {
ALLOC_HASHTABLE(stmt->bound_param_map);
zend_hash_init(stmt->bound_param_map, 13, NULL, free_param_name, 0);
}
for (plc = placeholders; plc; plc = plc->next) {
int skip_map = 0;
char *p;
name = estrndup(plc->pos, plc->len);
/* check if bound parameter is already available */
if (!strcmp(name, "?") || (p = zend_hash_str_find_ptr(stmt->bound_param_map, name, plc->len)) == NULL) {
spprintf(&idxbuf, 0, tmpl, bind_no++);
} else {
idxbuf = estrdup(p);
skip_map = 1;
}
plc->quoted = idxbuf;
plc->qlen = strlen(plc->quoted);
plc->freeq = 1;
newbuffer_len += plc->qlen;
if (!skip_map && stmt->named_rewrite_template) {
/* create a mapping */
zend_hash_str_update_mem(stmt->bound_param_map, name, plc->len, idxbuf, plc->qlen + 1);
}
/* map number to name */
zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1);
efree(name);
}
goto rewrite;
} else {
/* rewrite :name to ? */
newbuffer_len = inquery_len;
if (stmt->bound_param_map == NULL) {
ALLOC_HASHTABLE(stmt->bound_param_map);
zend_hash_init(stmt->bound_param_map, 13, NULL, free_param_name, 0);
}
for (plc = placeholders; plc; plc = plc->next) {
char *name;
name = estrndup(plc->pos, plc->len);
zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, name, plc->len + 1);
efree(name);
plc->quoted = "?";
plc->qlen = 1;
}
goto rewrite;
}
clean_up:
while (placeholders) {
plc = placeholders;
placeholders = plc->next;
if (plc->freeq) {
efree(plc->quoted);
}
efree(plc);
}
return ret;
}
/**
* Crop an image to the given size. Either the width or the height can be
* omitted and the current width or height will be used.
*
* @param int $width new width
* @param int $height new height
* @param int $offset_x offset from the left, if it's true then will center
* @param int $offset_y offset from the top, if it's true then will middle
* @return Phalcon\Image\Adapter
*/
PHP_METHOD(Phalcon_Image_Adapter, crop) {
zval **w, **h, **ofs_x = NULL, **ofs_y = NULL;
zval *image_width, *image_height;
zval *width, *height, *offset_x, *offset_y;
long tmp_max_width, tmp_max_height, tmp_width, tmp_height, tmp_image_width, tmp_image_height, tmp_offset_x, tmp_offset_y;
phalcon_fetch_params_ex(2, 2, &w, &h, &ofs_x, &ofs_y);
PHALCON_ENSURE_IS_LONG(w);
PHALCON_ENSURE_IS_LONG(h);
PHALCON_MM_GROW();
image_width = phalcon_fetch_nproperty_this(this_ptr, SL("_width"), PH_NOISY TSRMLS_CC);
image_height = phalcon_fetch_nproperty_this(this_ptr, SL("_height"), PH_NOISY TSRMLS_CC);
SEPARATE_ZVAL_IF_NOT_REF(w);
if (Z_TYPE_PP(w) != IS_LONG) {
convert_to_long(*w);
}
SEPARATE_ZVAL_IF_NOT_REF(h);
if (Z_TYPE_PP(h) != IS_LONG) {
convert_to_long(*h);
}
if (ofs_x && Z_TYPE_PP(ofs_x) != IS_NULL && Z_TYPE_PP(ofs_x) != IS_BOOL && Z_TYPE_PP(ofs_x) != IS_LONG) {
SEPARATE_ZVAL_IF_NOT_REF(ofs_x);
convert_to_long(*ofs_x);
}
if (ofs_y && Z_TYPE_PP(ofs_y) != IS_NULL && Z_TYPE_PP(ofs_y) != IS_BOOL && Z_TYPE_PP(ofs_x) != IS_LONG) {
SEPARATE_ZVAL_IF_NOT_REF(ofs_y);
convert_to_long(*ofs_y);
}
tmp_width = Z_LVAL_PP(w);
tmp_height = Z_LVAL_PP(h);
tmp_image_width = phalcon_get_intval(image_width);
tmp_image_height = phalcon_get_intval(image_height);
if (tmp_width > tmp_image_width) {
tmp_width = tmp_image_width;
}
if (tmp_height > tmp_image_height) {
tmp_height = tmp_image_height;
}
if (!ofs_x) {
tmp_offset_x = (int)(((tmp_image_width - tmp_width) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_x) == IS_BOOL && PHALCON_IS_TRUE(*ofs_x)) {
tmp_offset_x = tmp_image_width - tmp_width;
} else if (Z_TYPE_PP(ofs_x) == IS_LONG) {
if (Z_LVAL_PP(ofs_x) < 0) {
tmp_offset_x = (int)(tmp_image_width - tmp_width + Z_LVAL_PP(ofs_x) + 0.5);
} else {
tmp_offset_x = Z_LVAL_PP(ofs_x);
}
} else {
tmp_offset_x = (int)(((tmp_image_width - tmp_width) / 2) + 0.5);
}
if (!ofs_y) {
tmp_offset_y = (int)(((tmp_image_height - tmp_height) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_x) == IS_BOOL && PHALCON_IS_TRUE(*ofs_y)) {
tmp_offset_y = tmp_image_height - tmp_height;
} else if (Z_TYPE_PP(ofs_y) == IS_LONG) {
if (Z_LVAL_PP(ofs_y) < 0) {
tmp_offset_y = tmp_image_height - tmp_height + Z_LVAL_PP(ofs_y);
} else {
tmp_offset_y = Z_LVAL_PP(ofs_y);
}
} else {
tmp_offset_y = (int)(((tmp_image_height - tmp_height) / 2) + 0.5);
}
tmp_max_width = tmp_image_width - tmp_offset_x;
tmp_max_height = tmp_image_height - tmp_offset_y;
if (tmp_width > tmp_max_width) {
tmp_width = tmp_max_width;
}
if (tmp_height > tmp_max_height) {
tmp_height = tmp_max_height;
}
PHALCON_ALLOC_GHOST_ZVAL(width);
PHALCON_ALLOC_GHOST_ZVAL(height);
PHALCON_ALLOC_GHOST_ZVAL(offset_x);
PHALCON_ALLOC_GHOST_ZVAL(offset_y);
ZVAL_LONG(width, tmp_width);
ZVAL_LONG(height, tmp_height);
ZVAL_LONG(offset_x, tmp_offset_x);
ZVAL_LONG(offset_y, tmp_offset_y);
PHALCON_CALL_METHOD(NULL, this_ptr, "_crop", width, height, offset_x, offset_y);
RETURN_THIS();
}
php_stream_filter_status_t userfilter_filter(
php_stream *stream,
php_stream_filter *thisfilter,
php_stream_bucket_brigade *buckets_in,
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
)
{
int ret = PSFS_ERR_FATAL;
zval *obj = &thisfilter->abstract;
zval func_name;
zval retval;
zval args[4];
zval zpropname;
int call_result;
/* the userfilter object probably doesn't exist anymore */
if (CG(unclean_shutdown)) {
return ret;
}
if (!zend_hash_str_exists(Z_OBJPROP_P(obj), "stream", sizeof("stream")-1)) {
zval tmp;
/* Give the userfilter class a hook back to the stream */
php_stream_to_zval(stream, &tmp);
zval_copy_ctor(&tmp);
add_property_zval(obj, "stream", &tmp);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&tmp);
}
ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1);
/* Setup calling arguments */
ZVAL_RES(&args[0], zend_register_resource(buckets_in, le_bucket_brigade));
ZVAL_RES(&args[1], zend_register_resource(buckets_out, le_bucket_brigade));
if (bytes_consumed) {
ZVAL_LONG(&args[2], *bytes_consumed);
} else {
ZVAL_NULL(&args[2]);
}
ZVAL_BOOL(&args[3], flags & PSFS_FLAG_FLUSH_CLOSE);
call_result = call_user_function_ex(NULL,
obj,
&func_name,
&retval,
4, args,
0, NULL);
zval_ptr_dtor(&func_name);
if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
convert_to_long(&retval);
ret = (int)Z_LVAL(retval);
} else if (call_result == FAILURE) {
php_error_docref(NULL, E_WARNING, "failed to call filter function");
}
if (bytes_consumed) {
*bytes_consumed = zval_get_long(&args[2]);
}
if (buckets_in->head) {
php_stream_bucket *bucket = buckets_in->head;
php_error_docref(NULL, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
while ((bucket = buckets_in->head)) {
/* Remove unconsumed buckets from the brigade */
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
}
}
if (ret != PSFS_PASS_ON) {
php_stream_bucket *bucket = buckets_out->head;
while (bucket != NULL) {
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
bucket = buckets_out->head;
}
}
/* filter resources are cleaned up by the stream destructor,
* keeping a reference to the stream resource here would prevent it
* from being destroyed properly */
ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, NULL);
zval_ptr_dtor(&zpropname);
zval_ptr_dtor(&args[3]);
zval_ptr_dtor(&args[2]);
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
return ret;
}
void zend_optimizer_pass2(zend_op_array *op_array)
{
zend_op *opline;
zend_op *end = op_array->opcodes + op_array->last;
opline = op_array->opcodes;
while (opline < end) {
switch (opline->opcode) {
case ZEND_ADD:
case ZEND_SUB:
case ZEND_MUL:
case ZEND_DIV:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
convert_scalar_to_number(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally* - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_ADD:
case ZEND_ASSIGN_SUB:
case ZEND_ASSIGN_MUL:
case ZEND_ASSIGN_DIV:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
convert_scalar_to_number(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_MOD:
case ZEND_SL:
case ZEND_SR:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
convert_to_long(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_MOD:
case ZEND_ASSIGN_SL:
case ZEND_ASSIGN_SR:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
convert_to_long(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_CONCAT:
case ZEND_FAST_CONCAT:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_CONCAT:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (ZEND_OP2_TYPE(opline) == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_JMPZ_EX:
case ZEND_JMPNZ_EX:
/* convert Ti = JMPZ_EX(Ti, L) to JMPZ(Ti, L) */
if (0 && /* FIXME: temporary disable unsafe pattern */
ZEND_OP1_TYPE(opline) == IS_TMP_VAR &&
ZEND_RESULT_TYPE(opline) == IS_TMP_VAR &&
ZEND_OP1(opline).var == ZEND_RESULT(opline).var) {
opline->opcode -= 3;
/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
in case we know it wouldn't jump */
} else if (ZEND_OP1_TYPE(opline) == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ_EX) {
should_jmp = !should_jmp;
}
if (!should_jmp) {
opline->opcode = ZEND_QM_ASSIGN;
SET_UNUSED(opline->op2);
}
}
break;
case ZEND_JMPZ:
case ZEND_JMPNZ:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp;
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_OP1_TYPE(opline) = IS_UNUSED;
if (should_jmp) {
opline->opcode = ZEND_JMP;
COPY_NODE(opline->op1, opline->op2);
} else {
MAKE_NOP(opline);
}
break;
}
if ((opline + 1)->opcode == ZEND_JMP) {
/* JMPZ(X, L1), JMP(L2) => JMPZNZ(X, L1, L2) */
/* JMPNZ(X, L1), JMP(L2) => JMPZNZ(X, L2, L1) */
if (ZEND_OP2(opline).opline_num == ZEND_OP1(opline + 1).opline_num) {
/* JMPZ(X, L1), JMP(L1) => NOP, JMP(L1) */
MAKE_NOP(opline);
} else {
if (opline->opcode == ZEND_JMPZ) {
opline->extended_value = ZEND_OP1(opline + 1).opline_num;
} else {
opline->extended_value = ZEND_OP2(opline).opline_num;
COPY_NODE(opline->op2, (opline + 1)->op1);
}
opline->opcode = ZEND_JMPZNZ;
}
}
break;
case ZEND_JMPZNZ:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
int opline_num;
if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
opline_num = opline->extended_value; /* JMPNZ */
} else {
opline_num = ZEND_OP2(opline).opline_num; /* JMPZ */
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_OP1(opline).opline_num = opline_num;
ZEND_OP1_TYPE(opline) = IS_UNUSED;
opline->opcode = ZEND_JMP;
}
break;
case ZEND_BRK:
case ZEND_CONT:
{
zend_brk_cont_element *jmp_to;
int array_offset;
int nest_levels;
int dont_optimize = 0;
ZEND_ASSERT(ZEND_OP2_TYPE(opline) == IS_CONST);
ZEND_ASSERT(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_LONG);
nest_levels = Z_LVAL(ZEND_OP2_LITERAL(opline));
array_offset = ZEND_OP1(opline).opline_num;
while (1) {
if (array_offset == -1) {
dont_optimize = 1; /* don't optimize this bogus break/continue, let the executor shout */
break;
}
jmp_to = &op_array->brk_cont_array[array_offset];
array_offset = jmp_to->parent;
if (--nest_levels > 0) {
if (op_array->opcodes[jmp_to->brk].opcode == ZEND_FREE ||
op_array->opcodes[jmp_to->brk].opcode == ZEND_FE_FREE ||
op_array->opcodes[jmp_to->brk].opcode == ZEND_END_SILENCE) {
dont_optimize = 1;
break;
}
} else {
break;
}
}
if (dont_optimize) {
break;
}
/* optimize - convert to a JMP */
switch (opline->opcode) {
case ZEND_BRK:
MAKE_NOP(opline);
ZEND_OP1(opline).opline_num = jmp_to->brk;
break;
case ZEND_CONT:
MAKE_NOP(opline);
ZEND_OP1(opline).opline_num = jmp_to->cont;
break;
}
opline->opcode = ZEND_JMP;
/* MAKE_NOP() already set op1 and op2 to IS_UNUSED */
}
break;
}
opline++;
}
}
/* {{{ proto bool com_propput(int module, string property_name, mixed value)
Puts the properties for a module */
void php3_COM_propput(INTERNAL_FUNCTION_PARAMETERS)
{
pval *arg_idispatch, *arg_property, *arg_new_value;
IDispatch *i_dispatch;
int type;
DISPID dispid;
HRESULT hr;
OLECHAR *funcname;
char *error_message;
VARIANTARG new_value;
DISPPARAMS dispparams;
DISPID mydispid = DISPID_PROPERTYPUT;
if (ARG_COUNT(ht)!=3 || getParameters(ht, 3, &arg_idispatch, &arg_property, &arg_new_value)==FAILURE) {
WRONG_PARAM_COUNT;
}
/* obtain i_dispatch interface */
convert_to_long(arg_idispatch);
i_dispatch = php3_list_find(arg_idispatch->value.lval,&type);
if (!i_dispatch || (type!=le_idispatch)) {
php3_error(E_WARNING,"%d is not a COM object handler", arg_idispatch->value.lval);
}
/* obtain property/method handler */
convert_to_string(arg_property);
funcname = _php3_C_str_to_unicode(arg_property->value.str.val, arg_property->value.str.len);
hr = i_dispatch->lpVtbl->GetIDsOfNames(i_dispatch, &IID_NULL, &funcname,
1, LOCALE_SYSTEM_DEFAULT, &dispid);
if (FAILED(hr)) {
error_message = _php3_COM_error_message(hr);
php3_error(E_WARNING,"Unable to lookup %s: %s\n", arg_property->value.str.val, error_message);
LocalFree(error_message);
efree(funcname);
RETURN_FALSE;
}
_php3_pval_to_variant(arg_new_value, &new_value);
dispparams.rgvarg = &new_value;
dispparams.rgdispidNamedArgs = &mydispid;
dispparams.cArgs = 1;
dispparams.cNamedArgs = 1;
hr = i_dispatch->lpVtbl->Invoke(i_dispatch, dispid, &IID_NULL,
LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT,
&dispparams, NULL, NULL, 0);
if (FAILED(hr)) {
error_message = _php3_COM_error_message(hr);
php3_error(E_WARNING,"Invoke() failed: %s\n", error_message);
LocalFree(error_message);
efree(funcname);
RETURN_FALSE;
}
efree(funcname);
RETURN_TRUE;
}
void cpServer_init(zval *conf, char *title, char *ini_file, int group_id)
{
CPGS = (cpServerGS*) cp_mmap_calloc(sizeof (cpServerGS));
if (CPGS == NULL)
{
php_printf("calloc[1] fail\n");
return;
}
bzero(&CPGL, sizeof (cpServerG));
CPGC.backlog = CP_BACKLOG;
CPGC.reactor_num = CP_CPU_NUM;
CPGC.timeout_sec = CP_REACTOR_TIMEO_SEC;
CPGC.timeout_usec = CP_REACTOR_TIMEO_USEC;
CPGC.max_conn = CP_MAX_FDS;
CPGC.max_request = CP_MAX_REQUEST;
CPGC.idel_time = CP_IDEL_TIME;
CPGC.recycle_num = CP_RECYCLE_NUM;
CPGC.max_read_len = CP_DEF_MAX_READ_LEN;
CPGC.group_id = group_id;
CPGS->worker_max = CP_MAX_WORKER;
CPGC.worker_min = CP_MIN_WORKER;
CPGC.ser_fail_hits = 1;
CPGC.max_fail_num = 2;
strcpy(CPGC.title, title);
strcpy(CPGC.ini_file, ini_file);
cpSettitle(title);
zval **v;
//daemonize，守护进程化
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("daemonize"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.daemonize = (int) Z_LVAL_PP(v);
}
//pool_max
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGS->worker_max = (int) Z_LVAL_PP(v);
}
//pool_min
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.worker_min = (int) Z_LVAL_PP(v);
}
//pool_min
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("recycle_num"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.recycle_num = (int) Z_LVAL_PP(v);
}
//error_file
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("log_file"), (void **) &v) == SUCCESS)
{
memcpy(CPGC.log_file, Z_STRVAL_PP(v), Z_STRLEN_PP(v));
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("max_read_len"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.max_read_len = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("port"), (void **) &v) == SUCCESS)
{//todo check null
convert_to_long(*v);
CPGC.port = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("idel_time"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.idel_time = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("use_wait_queue"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.use_wait_queue = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("ser_fail_hits"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.ser_fail_hits = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_P(conf), ZEND_STRS("max_fail_num"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.max_fail_num = (int) Z_LVAL_PP(v);
}
}
static xmlDocPtr php_xsl_apply_stylesheet(zval *id, xsl_object *intern, xsltStylesheetPtr style, zval *docp) /* {{{ */
{
xmlDocPtr newdocp = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
xsltTransformContextPtr ctxt;
php_libxml_node_object *object;
char **params = NULL;
int clone;
zval *doXInclude, member, rv;
zend_object_handlers *std_hnd;
FILE *f;
int secPrefsError = 0;
int secPrefsValue;
xsltSecurityPrefsPtr secPrefs = NULL;
node = php_libxml_import_node(docp);
if (node) {
doc = node->doc;
}
if (doc == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid Document");
return NULL;
}
if (style == NULL) {
php_error_docref(NULL, E_WARNING, "No stylesheet associated to this object");
return NULL;
}
if (intern->profiling) {
if (php_check_open_basedir(intern->profiling)) {
f = NULL;
} else {
f = VCWD_FOPEN(intern->profiling, "w");
}
} else {
f = NULL;
}
if (intern->parameter) {
params = php_xsl_xslt_make_params(intern->parameter, 0);
}
intern->doc = emalloc(sizeof(php_libxml_node_object));
memset(intern->doc, 0, sizeof(php_libxml_node_object));
if (intern->hasKeys == 1) {
doc = xmlCopyDoc(doc, 1);
} else {
object = Z_LIBXML_NODE_P(docp);
intern->doc->document = object->document;
}
php_libxml_increment_doc_ref(intern->doc, doc);
ctxt = xsltNewTransformContext(style, doc);
ctxt->_private = (void *) intern;
std_hnd = zend_get_std_object_handlers();
ZVAL_STRING(&member, "doXInclude");
doXInclude = std_hnd->read_property(id, &member, BP_VAR_IS, NULL, &rv);
if (Z_TYPE_P(doXInclude) != IS_NULL) {
convert_to_long(doXInclude);
ctxt->xinclude = Z_LVAL_P(doXInclude);
}
zval_ptr_dtor(&member);
secPrefsValue = intern->securityPrefs;
/* if securityPrefs is set to NONE, we don't have to do any checks, but otherwise... */
if (secPrefsValue != XSL_SECPREF_NONE) {
secPrefs = xsltNewSecurityPrefs();
if (secPrefsValue & XSL_SECPREF_READ_FILE ) {
if (0 != xsltSetSecurityPrefs(secPrefs, XSLT_SECPREF_READ_FILE, xsltSecurityForbid)) {
secPrefsError = 1;
}
}
if (secPrefsValue & XSL_SECPREF_WRITE_FILE ) {
if (0 != xsltSetSecurityPrefs(secPrefs, XSLT_SECPREF_WRITE_FILE, xsltSecurityForbid)) {
secPrefsError = 1;
}
}
if (secPrefsValue & XSL_SECPREF_CREATE_DIRECTORY ) {
if (0 != xsltSetSecurityPrefs(secPrefs, XSLT_SECPREF_CREATE_DIRECTORY, xsltSecurityForbid)) {
secPrefsError = 1;
}
}
if (secPrefsValue & XSL_SECPREF_READ_NETWORK) {
if (0 != xsltSetSecurityPrefs(secPrefs, XSLT_SECPREF_READ_NETWORK, xsltSecurityForbid)) {
secPrefsError = 1;
}
}
if (secPrefsValue & XSL_SECPREF_WRITE_NETWORK) {
if (0 != xsltSetSecurityPrefs(secPrefs, XSLT_SECPREF_WRITE_NETWORK, xsltSecurityForbid)) {
secPrefsError = 1;
}
}
if (0 != xsltSetCtxtSecurityPrefs(secPrefs, ctxt)) {
secPrefsError = 1;
}
}
if (secPrefsError == 1) {
php_error_docref(NULL, E_WARNING, "Can't set libxslt security properties, not doing transformation for security reasons");
} else {
newdocp = xsltApplyStylesheetUser(style, doc, (const char**) params, NULL, f, ctxt);
}
if (f) {
fclose(f);
}
xsltFreeTransformContext(ctxt);
if (secPrefs) {
xsltFreeSecurityPrefs(secPrefs);
}
if (intern->node_list != NULL) {
zend_hash_destroy(intern->node_list);
FREE_HASHTABLE(intern->node_list);
intern->node_list = NULL;
}
php_libxml_decrement_doc_ref(intern->doc);
efree(intern->doc);
intern->doc = NULL;
if (params) {
clone = 0;
while(params[clone]) {
efree(params[clone++]);
}
efree(params);
}
return newdocp;
}
void zend_optimizer_pass2(zend_op_array *op_array)
{
zend_op *opline;
zend_op *end = op_array->opcodes + op_array->last;
opline = op_array->opcodes;
while (opline < end) {
switch (opline->opcode) {
case ZEND_ADD:
case ZEND_SUB:
case ZEND_MUL:
case ZEND_DIV:
case ZEND_POW:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */
if (is_numeric_string(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), NULL, NULL, 0)) {
convert_scalar_to_number(&ZEND_OP1_LITERAL(opline));
}
}
}
/* break missing *intentionally* - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_ADD:
case ZEND_ASSIGN_SUB:
case ZEND_ASSIGN_MUL:
case ZEND_ASSIGN_DIV:
case ZEND_ASSIGN_POW:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */
if (is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0)) {
convert_scalar_to_number(&ZEND_OP2_LITERAL(opline));
}
}
}
break;
case ZEND_MOD:
case ZEND_SL:
case ZEND_SR:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING
&& !is_numeric_string(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), NULL, NULL, 0))) {
convert_to_long(&ZEND_OP1_LITERAL(opline));
}
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_MOD:
case ZEND_ASSIGN_SL:
case ZEND_ASSIGN_SR:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING
&& !is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0))) {
convert_to_long(&ZEND_OP2_LITERAL(opline));
}
}
}
break;
case ZEND_CONCAT:
case ZEND_FAST_CONCAT:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_CONCAT:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_JMPZ_EX:
case ZEND_JMPNZ_EX:
/* convert Ti = JMPZ_EX(Ti, L) to JMPZ(Ti, L) */
#if 0
/* Disabled unsafe pattern: in conjunction with
* ZEND_VM_SMART_BRANCH() this may improperly eliminate
* assignment to Ti.
*/
if (opline->op1_type == IS_TMP_VAR &&
opline->result_type == IS_TMP_VAR &&
opline->op1.var == opline->result.var) {
opline->opcode -= 3;
SET_UNUSED(opline->result);
} else
#endif
/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
in case we know it wouldn't jump */
if (opline->op1_type == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ_EX) {
should_jmp = !should_jmp;
}
if (!should_jmp) {
opline->opcode = ZEND_QM_ASSIGN;
SET_UNUSED(opline->op2);
}
}
break;
case ZEND_JMPZ:
case ZEND_JMPNZ:
if (opline->op1_type == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp;
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
opline->op1_type = IS_UNUSED;
if (should_jmp) {
opline->opcode = ZEND_JMP;
COPY_NODE(opline->op1, opline->op2);
} else {
MAKE_NOP(opline);
}
break;
}
if ((opline + 1)->opcode == ZEND_JMP) {
/* JMPZ(X, L1), JMP(L2) => JMPZNZ(X, L1, L2) */
/* JMPNZ(X, L1), JMP(L2) => JMPZNZ(X, L2, L1) */
if (ZEND_OP2_JMP_ADDR(opline) == ZEND_OP1_JMP_ADDR(opline + 1)) {
/* JMPZ(X, L1), JMP(L1) => NOP, JMP(L1) */
if (opline->op1_type == IS_CV) {
opline->opcode = ZEND_CHECK_VAR;
opline->op2.num = 0;
} else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
opline->opcode = ZEND_FREE;
opline->op2.num = 0;
} else {
MAKE_NOP(opline);
}
} else {
if (opline->opcode == ZEND_JMPZ) {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP1_JMP_ADDR(opline + 1));
} else {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP2_JMP_ADDR(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP1_JMP_ADDR(opline + 1));
}
opline->opcode = ZEND_JMPZNZ;
}
}
break;
case ZEND_JMPZNZ:
if (opline->op1_type == IS_CONST) {
zend_op *target_opline;
if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
target_opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); /* JMPNZ */
} else {
target_opline = ZEND_OP2_JMP_ADDR(opline); /* JMPZ */
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, target_opline);
opline->op1_type = IS_UNUSED;
opline->opcode = ZEND_JMP;
}
break;
}
opline++;
}
}
/* php_formatted_print() {{{
* New sprintf implementation for PHP.
*
* Modifiers:
*
* " " pad integers with spaces
* "-" left adjusted field
* n field size
* "."n precision (floats only)
* "+" Always place a sign (+ or -) in front of a number
*
* Type specifiers:
*
* "%" literal "%", modifiers are ignored.
* "b" integer argument is printed as binary
* "c" integer argument is printed as a single character
* "d" argument is an integer
* "f" the argument is a float
* "o" integer argument is printed as octal
* "s" argument is a string
* "x" integer argument is printed as lowercase hexadecimal
* "X" integer argument is printed as uppercase hexadecimal
*
*/
static char *
php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC)
{
zval ***args, **z_format;
int argc, size = 240, inpos = 0, outpos = 0, temppos;
int alignment, currarg, adjusting, argnum, width, precision;
char *format, *result, padding;
int always_sign;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
return NULL;
}
/* verify the number of args */
if ((use_array && argc != (2 + format_offset))
|| (!use_array && argc < (1 + format_offset))) {
efree(args);
WRONG_PARAM_COUNT_WITH_RETVAL(NULL);
}
if (use_array) {
int i = 1;
zval ***newargs;
zval **array;
z_format = args[format_offset];
array = args[1 + format_offset];
SEPARATE_ZVAL(array);
convert_to_array_ex(array);
argc = 1 + zend_hash_num_elements(Z_ARRVAL_PP(array));
newargs = (zval ***)safe_emalloc(argc, sizeof(zval *), 0);
newargs[0] = z_format;
for (zend_hash_internal_pointer_reset(Z_ARRVAL_PP(array));
zend_hash_get_current_data(Z_ARRVAL_PP(array), (void **)&newargs[i++]) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_PP(array)));
efree(args);
args = newargs;
format_offset = 0;
}
convert_to_string_ex(args[format_offset]);
format = Z_STRVAL_PP(args[format_offset]);
result = emalloc(size);
currarg = 1;
while (inpos<Z_STRLEN_PP(args[format_offset])) {
int expprec = 0, multiuse = 0;
zval *tmp;
PRINTF_DEBUG(("sprintf: format[%d]='%c'\n", inpos, format[inpos]));
PRINTF_DEBUG(("sprintf: outpos=%d\n", outpos));
if (format[inpos] != '%') {
php_sprintf_appendchar(&result, &outpos, &size, format[inpos++] TSRMLS_CC);
} else if (format[inpos + 1] == '%') {
php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC);
inpos += 2;
} else {
/* starting a new format specifier, reset variables */
alignment = ALIGN_RIGHT;
adjusting = 0;
padding = ' ';
always_sign = 0;
inpos++; /* skip the '%' */
PRINTF_DEBUG(("sprintf: first looking at '%c', inpos=%d\n",
format[inpos], inpos));
if (isascii((int)format[inpos]) && !isalpha((int)format[inpos])) {
/* first look for argnum */
temppos = inpos;
while (isdigit((int)format[temppos])) temppos++;
if (format[temppos] == '$') {
argnum = php_sprintf_getnumber(format, &inpos);
if (argnum <= 0) {
efree(result);
efree(args);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument number must be greater than zero");
return NULL;
}
multiuse = 1;
inpos++; /* skip the '$' */
} else {
argnum = currarg++;
}
argnum += format_offset;
/* after argnum comes modifiers */
PRINTF_DEBUG(("sprintf: looking for modifiers\n"
"sprintf: now looking at '%c', inpos=%d\n",
format[inpos], inpos));
for (;; inpos++) {
if (format[inpos] == ' ' || format[inpos] == '0') {
padding = format[inpos];
} else if (format[inpos] == '-') {
alignment = ALIGN_LEFT;
/* space padding, the default */
} else if (format[inpos] == '+') {
always_sign = 1;
} else if (format[inpos] == '\'') {
padding = format[++inpos];
} else {
PRINTF_DEBUG(("sprintf: end of modifiers\n"));
break;
}
}
PRINTF_DEBUG(("sprintf: padding='%c'\n", padding));
PRINTF_DEBUG(("sprintf: alignment=%s\n",
(alignment == ALIGN_LEFT) ? "left" : "right"));
/* after modifiers comes width */
if (isdigit((int)format[inpos])) {
PRINTF_DEBUG(("sprintf: getting width\n"));
if ((width = php_sprintf_getnumber(format, &inpos)) < 0) {
efree(result);
efree(args);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Width must be greater than zero and less than %d", INT_MAX);
return NULL;
}
adjusting |= ADJ_WIDTH;
} else {
width = 0;
}
PRINTF_DEBUG(("sprintf: width=%d\n", width));
/* after width and argnum comes precision */
if (format[inpos] == '.') {
inpos++;
PRINTF_DEBUG(("sprintf: getting precision\n"));
if (isdigit((int)format[inpos])) {
if ((precision = php_sprintf_getnumber(format, &inpos)) < 0) {
efree(result);
efree(args);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Precision must be greater than zero and less than %d", INT_MAX);
return NULL;
}
adjusting |= ADJ_PRECISION;
expprec = 1;
} else {
precision = 0;
}
} else {
precision = 0;
}
PRINTF_DEBUG(("sprintf: precision=%d\n", precision));
} else {
width = precision = 0;
argnum = currarg++ + format_offset;
}
if (argnum >= argc) {
efree(result);
efree(args);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too few arguments");
return NULL;
}
if (format[inpos] == 'l') {
inpos++;
}
PRINTF_DEBUG(("sprintf: format character='%c'\n", format[inpos]));
/* now we expect to find a type specifier */
if (multiuse) {
MAKE_STD_ZVAL(tmp);
*tmp = **(args[argnum]);
INIT_PZVAL(tmp);
zval_copy_ctor(tmp);
} else {
SEPARATE_ZVAL(args[argnum]);
tmp = *(args[argnum]);
}
switch (format[inpos]) {
case 's': {
zval *var, var_copy;
int use_copy;
zend_make_printable_zval(tmp, &var_copy, &use_copy);
if (use_copy) {
var = &var_copy;
} else {
var = tmp;
}
php_sprintf_appendstring(&result, &outpos, &size,
Z_STRVAL_P(var),
width, precision, padding,
alignment,
Z_STRLEN_P(var),
0, expprec, 0);
if (use_copy) {
zval_dtor(&var_copy);
}
break;
}
case 'd':
convert_to_long(tmp);
php_sprintf_appendint(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment,
always_sign);
break;
case 'u':
convert_to_long(tmp);
php_sprintf_appenduint(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment);
break;
case 'g':
case 'G':
case 'e':
case 'E':
case 'f':
case 'F':
convert_to_double(tmp);
php_sprintf_appenddouble(&result, &outpos, &size,
Z_DVAL_P(tmp),
width, padding, alignment,
precision, adjusting,
format[inpos], always_sign
TSRMLS_CC);
break;
case 'c':
convert_to_long(tmp);
php_sprintf_appendchar(&result, &outpos, &size,
(char) Z_LVAL_P(tmp) TSRMLS_CC);
break;
case 'o':
convert_to_long(tmp);
php_sprintf_append2n(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment, 3,
hexchars, expprec);
break;
case 'x':
convert_to_long(tmp);
php_sprintf_append2n(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment, 4,
hexchars, expprec);
break;
case 'X':
convert_to_long(tmp);
php_sprintf_append2n(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment, 4,
HEXCHARS, expprec);
break;
case 'b':
convert_to_long(tmp);
php_sprintf_append2n(&result, &outpos, &size,
Z_LVAL_P(tmp),
width, padding, alignment, 1,
hexchars, expprec);
break;
case '%':
php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC);
break;
default:
break;
}
if (multiuse) {
zval_ptr_dtor(&tmp);
}
inpos++;
}
}
efree(args);
/* possibly, we have to make sure we have room for the terminating null? */
result[outpos]=0;
*len = outpos;
return result;
}
void *php_array_to_c_array(zval *param,int type,int size,int *array_size)
{
HashTable *param_ht = param->value.ht;
zval **cur;
void *params;
int i,tmp_size = zend_hash_num_elements(param_ht);
zend_hash_internal_pointer_reset(param_ht);
params = (void *)emalloc(size * tmp_size);
i = 0;
while(zend_hash_get_current_data(param_ht,(void **)&cur) == SUCCESS)
{
if((*cur)->type == IS_ARRAY)
{
int new_array_size;
void *array = php_array_to_c_array(*cur,type,size,&new_array_size);
params = erealloc(params, (tmp_size + new_array_size) * size);
memcpy(&((char*)params)[i*size],array,new_array_size * size);
i += (new_array_size - 1);
efree(array);
}
else
{
switch(type)
{
case TO_C_FLOAT:
convert_to_double(*cur);
((float*)params)[i] = (float)Z_DVAL_P(*cur);
break;
case TO_C_DOUBLE:
convert_to_double(*cur);
((double*)params)[i] = Z_DVAL_P(*cur);
break;
case TO_C_INT:
convert_to_long(*cur);
((int*)params)[i] = (int)Z_LVAL_P(*cur);
break;
case TO_C_LONG:
convert_to_long(*cur);
((long*)params)[i] = Z_LVAL_P(*cur);
break;
case TO_C_UCHAR:
convert_to_long(*cur);
((unsigned char*)params)[i] = (unsigned char)Z_LVAL_P(*cur);
break;
case TO_C_SCHAR:
convert_to_long(*cur);
((signed char*)params)[i] = (signed char)Z_LVAL_P(*cur);
break;
case TO_C_USHORT:
convert_to_long(*cur);
((unsigned short*)params)[i] = (unsigned short)Z_LVAL_P(*cur);
break;
case TO_C_SHORT:
convert_to_long(*cur);
((short*)params)[i] = (short)Z_LVAL_P(*cur);
break;
case TO_C_UINT:
convert_to_long(*cur);
((unsigned int*)params)[i] = (unsigned int)Z_LVAL_P(*cur);
break;
case TO_C_STRING:
convert_to_string(*cur);
((char **)params)[i] = estrdup(Z_STRVAL_P(*cur));
}
}
zend_hash_move_forward(param_ht);
i++;
}
if(array_size != NULL)
*array_size = i;
return (void *)params;
}
PHP_METHOD(jsonrpc_server, execute)
{
zval *object;
zval *func;
zval **func_params, **exec_params;
zval *data, *payload, *error, *response;
zval **payload_method, **payload_params;
zval **id = NULL;
sapi_header_line ctr = {0};
smart_str buf = {0};
zend_bool response_type = 0; // type:0 =>json type:1 => array
object = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b",
&response_type) == FAILURE)
{
return ;
}
payload = zend_read_property(
php_jsonrpc_server_entry, getThis(), "payload", sizeof("payload")-1, 0 TSRMLS_CC
);
MAKE_STD_ZVAL(error);
array_init(error);
MAKE_STD_ZVAL(func);
ZVAL_STRINGL(func, "jsonformat", sizeof("jsonformat") - 1, 0);
if (call_user_function(NULL, &object, func, return_value, 0, NULL TSRMLS_CC) == FAILURE){
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed calling Jsonrpc_Server::jsonformat()");
return ;
}
if (!Z_BVAL_P(return_value)){
add_assoc_long(error, "code", -32700);
add_assoc_string(error, "message", "Parse error", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}
ZVAL_STRINGL(func, "rpcformat", sizeof("rpcformat") - 1, 0);
if (call_user_function(NULL, &object, func, return_value, 0, NULL TSRMLS_CC) == FAILURE){
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed calling Jsonrpc_Server::rpcformat()");
return ;
}
if (Z_LVAL_P(return_value) == -32600){
add_assoc_long(error, "code", -32600);
add_assoc_string(error, "message", "Invalid Request", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}else if (Z_LVAL_P(return_value) == -32601){
add_assoc_long(error, "code", -32601);
add_assoc_string(error, "message", "Method not found", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}else if (Z_LVAL_P(return_value) == -32602){
add_assoc_long(error, "code", -32602);
add_assoc_string(error, "message", "Invalid params", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}else if (Z_LVAL_P(return_value) == -32603){
add_assoc_long(error, "code", -32603);
add_assoc_string(error, "message", "Internal error", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}
exec_params = emalloc(sizeof(zval *) * 2);
payload = zend_read_property(
php_jsonrpc_server_entry, getThis(), "payload", sizeof("payload")-1, 0 TSRMLS_CC
);
if (zend_hash_find(Z_ARRVAL_P(payload), "method", strlen("method")+1, (void **)&payload_method) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "method is not find");
return ;
}
//jsr_dump_zval(*payload_method);
exec_params[0] = *payload_method;
if (zend_hash_find(Z_ARRVAL_P(payload), "params", strlen("params")+1, (void **)&payload_params) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "params is not find");
return ;
}
//shurrik_dump_zval(*payload_params);
exec_params[1] = *payload_params;
MAKE_STD_ZVAL(data);
ZVAL_STRINGL(func, "executeprocedure", sizeof("executeprocedure") - 1, 0);
if (call_user_function(NULL, &object, func, data, 2, exec_params TSRMLS_CC) == FAILURE){
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed calling Jsonrpc_Server::executeprocedure()");
return ;
}
efree(exec_params);
if (Z_LVAL_P(data) == -32601){
add_assoc_long(error, "code", -32601);
add_assoc_string(error, "message", "Method not found", 1);
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "error", error);
goto getresponse;
}
zval_dtor(return_value);
array_init(return_value);
add_assoc_string(return_value, "jsonrpc", "2.0", 1);
add_assoc_zval(return_value, "result", data);
goto getresponse;
return ;
getresponse:
if (Z_TYPE_P(payload) == IS_ARRAY){
if (!zend_symtable_exists(Z_ARRVAL_P(payload), "id", strlen("id")+1))
{
}else {
if (zend_hash_find(Z_ARRVAL_P(payload), "id", strlen("id")+1, (void **)&id ) == FAILURE)
{
//php_error_docref(NULL TSRMLS_CC, E_WARNING, "closeure is not expected to be a valid callback");
//return ;
}
if (Z_TYPE_PP(id) == IS_NULL){
add_assoc_null(return_value, "id");
}else if(Z_TYPE_PP(id) == IS_STRING){
convert_to_string(*id);
add_assoc_string(return_value, "id", Z_STRVAL_PP(id), 0);
}else if (Z_TYPE_PP(id) == IS_LONG){
convert_to_long(*id);
add_assoc_long(return_value, "id", Z_LVAL_PP(id));
}
}
}else {
add_assoc_null(return_value, "id");
}
ctr.line = "Content-Type: application/json";
ctr.line_len = strlen(ctr.line);
sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
/*if (!response_type){
php_json_encode(&buf, return_value, 0 TSRMLS_CC);
zval_dtor(return_value);
zval_dtor(error);
ZVAL_STRINGL(return_value, buf.c, buf.len, 1);
smart_str_free(&buf);
}*/
if (!response_type){
exec_params = emalloc(sizeof(zval *) * 1);
exec_params[0] = return_value;
ZVAL_STRINGL(func, "Jsonrpc_Yajl::generate", sizeof("Jsonrpc_Yajl::generate") - 1, 0);
if (call_user_function(EG(function_table), NULL, func, return_value, 1, exec_params TSRMLS_CC) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed calling Jsonrpc_Yajl::generate()");
return ;
}
//ZVAL_STRINGL(return_value, Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), 1);
zval_dtor(error);
efree(exec_params);
}
efree(func);
return ;
}
static PHP_METHOD(swoole_server_port, set)
{
zval *zset = NULL;
HashTable *vht;
zval *v;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "z", &zset) == FAILURE)
{
return;
}
vht = Z_ARRVAL_P(zset);
swListenPort *port = swoole_get_object(getThis());
swoole_server_port_property *property = swoole_get_property(getThis(), 0);
if (port == NULL || property == NULL)
{
swoole_php_fatal_error(E_ERROR, "Please use the swoole_server->listen method.");
return;
}
property->setting = zset;
//backlog
if (php_swoole_array_get_value(vht, "backlog", v))
{
convert_to_long(v);
port->backlog = (int) Z_LVAL_P(v);
}
//tcp_nodelay
if (php_swoole_array_get_value(vht, "open_tcp_nodelay", v))
{
convert_to_boolean(v);
port->open_tcp_nodelay = Z_BVAL_P(v);
}
//tcp_defer_accept
if (php_swoole_array_get_value(vht, "tcp_defer_accept", v))
{
convert_to_long(v);
port->tcp_defer_accept = (uint8_t) Z_LVAL_P(v);
}
//tcp_keepalive
if (php_swoole_array_get_value(vht, "open_tcp_keepalive", v))
{
convert_to_boolean(v);
port->open_tcp_keepalive = Z_BVAL_P(v);
}
//buffer: split package with eof
if (php_swoole_array_get_value(vht, "open_eof_split", v))
{
convert_to_boolean(v);
port->protocol.split_by_eof = Z_BVAL_P(v);
if (port->protocol.split_by_eof)
{
port->open_eof_check = 1;
}
}
//package eof
if (php_swoole_array_get_value(vht, "package_eof", v))
{
convert_to_string(v);
port->protocol.package_eof_len = Z_STRLEN_P(v);
if (port->protocol.package_eof_len > SW_DATA_EOF_MAXLEN)
{
swoole_php_fatal_error(E_ERROR, "pacakge_eof max length is %d", SW_DATA_EOF_MAXLEN);
RETURN_FALSE;
}
bzero(port->protocol.package_eof, SW_DATA_EOF_MAXLEN);
memcpy(port->protocol.package_eof, Z_STRVAL_P(v), Z_STRLEN_P(v));
}
//http_protocol
if (php_swoole_array_get_value(vht, "open_http_protocol", v))
{
convert_to_boolean(v);
port->open_http_protocol = Z_BVAL_P(v);
}
//websocket protocol
if (php_swoole_array_get_value(vht, "open_websocket_protocol", v))
{
convert_to_boolean(v);
port->open_websocket_protocol = Z_BVAL_P(v);
}
#ifdef SW_USE_HTTP2
//http2 protocol
if (php_swoole_array_get_value(vht, "open_http2_protocol", v))
{
convert_to_boolean(v);
port->open_http2_protocol = Z_BVAL_P(v);
}
#endif
//buffer: mqtt protocol
if (php_swoole_array_get_value(vht, "open_mqtt_protocol", v))
{
convert_to_boolean(v);
port->open_mqtt_protocol = Z_BVAL_P(v);
}
//tcp_keepidle
if (php_swoole_array_get_value(vht, "tcp_keepidle", v))
{
convert_to_long(v);
port->tcp_keepidle = (uint16_t) Z_LVAL_P(v);
}
//tcp_keepinterval
if (php_swoole_array_get_value(vht, "tcp_keepinterval", v))
{
convert_to_long(v);
port->tcp_keepinterval = (uint16_t) Z_LVAL_P(v);
}
//tcp_keepcount
if (sw_zend_hash_find(vht, ZEND_STRS("tcp_keepcount"), (void **) &v) == SUCCESS)
{
convert_to_long(v);
port->tcp_keepcount = (uint16_t) Z_LVAL_P(v);
}
//open length check
if (php_swoole_array_get_value(vht, "open_length_check", v))
{
convert_to_boolean(v);
port->open_length_check = Z_BVAL_P(v);
}
//package length size
if (php_swoole_array_get_value(vht, "package_length_type", v))
{
convert_to_string(v);
port->protocol.package_length_type = Z_STRVAL_P(v)[0];
port->protocol.package_length_size = swoole_type_size(port->protocol.package_length_type);
if (port->protocol.package_length_size == 0)
{
swoole_php_fatal_error(E_ERROR, "unknow package_length_type, see pack(). Link: http://php.net/pack");
RETURN_FALSE;
}
}
//package length offset
if (php_swoole_array_get_value(vht, "package_length_offset", v))
{
convert_to_long(v);
port->protocol.package_length_offset = (int) Z_LVAL_P(v);
}
//package body start
if (php_swoole_array_get_value(vht, "package_body_offset", v) || php_swoole_array_get_value(vht, "package_body_start", v))
{
convert_to_long(v);
port->protocol.package_body_offset = (int) Z_LVAL_P(v);
}
/**
* package max length
*/
if (php_swoole_array_get_value(vht, "package_max_length", v))
{
convert_to_long(v);
port->protocol.package_max_length = (int) Z_LVAL_P(v);
}
/**
* swoole_packet_mode
*/
if (SwooleG.serv->packet_mode == 1)
{
port->protocol.package_max_length = 64 * 1024 * 1024;
port->open_length_check = 1;
port->protocol.package_length_offset = 0;
port->protocol.package_body_offset = 4;
port->protocol.package_length_type = 'N';
port->open_eof_check = 0;
}
#ifdef SW_USE_OPENSSL
if (port->ssl)
{
if (php_swoole_array_get_value(vht, "ssl_cert_file", v))
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl cert file[%s] not found.", Z_STRVAL_P(v));
return;
}
port->ssl_cert_file = strdup(Z_STRVAL_P(v));
port->open_ssl_encrypt = 1;
}
if (php_swoole_array_get_value(vht, "ssl_key_file", v))
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl key file[%s] not found.", Z_STRVAL_P(v));
return;
}
port->ssl_key_file = strdup(Z_STRVAL_P(v));
}
if (php_swoole_array_get_value(vht, "ssl_method", v))
{
convert_to_long(v);
port->ssl_method = (int) Z_LVAL_P(v);
}
//verify client cert
if (php_swoole_array_get_value(vht, "ssl_client_cert_file", v))
{
convert_to_string(v);
if (access(Z_STRVAL_P(v), R_OK) < 0)
{
swoole_php_fatal_error(E_ERROR, "ssl cert file[%s] not found.", port->ssl_cert_file);
return;
}
port->ssl_client_cert_file = strdup(Z_STRVAL_P(v));
}
if (php_swoole_array_get_value(vht, "ssl_verify_depth", v))
{
convert_to_long(v);
port->ssl_verify_depth = (int) Z_LVAL_P(v);
}
if (port->open_ssl_encrypt && !port->ssl_key_file)
{
swoole_php_fatal_error(E_ERROR, "ssl require key file.");
return;
}
if (php_swoole_array_get_value(vht, "ssl_prefer_server_ciphers", v))
{
convert_to_boolean(v);
port->ssl_config.prefer_server_ciphers = Z_BVAL_P(v);
}
// if (sw_zend_hash_find(vht, ZEND_STRS("ssl_session_tickets"), (void **) &v) == SUCCESS)
// {
// convert_to_boolean(v);
// port->ssl_config.session_tickets = Z_BVAL_P(v);
// }
// if (sw_zend_hash_find(vht, ZEND_STRS("ssl_stapling"), (void **) &v) == SUCCESS)
// {
// convert_to_boolean(v);
// port->ssl_config.stapling = Z_BVAL_P(v);
// }
// if (sw_zend_hash_find(vht, ZEND_STRS("ssl_stapling_verify"), (void **) &v) == SUCCESS)
// {
// convert_to_boolean(v);
// port->ssl_config.stapling_verify = Z_BVAL_P(v);
// }
if (php_swoole_array_get_value(vht, "ssl_ciphers", v))
{
convert_to_string(v);
port->ssl_config.ciphers = strdup(Z_STRVAL_P(v));
}
if (php_swoole_array_get_value(vht, "ssl_ecdh_curve", v))
{
convert_to_string(v);
port->ssl_config.ecdh_curve = strdup(Z_STRVAL_P(v));
}
// if (sw_zend_hash_find(vht, ZEND_STRS("ssl_session_cache"), (void **) &v) == SUCCESS)
// {
// convert_to_string(v);
// port->ssl_config.session_cache = strdup(Z_STRVAL_P(v));
// }
}
#endif
zend_update_property(swoole_server_port_class_entry_ptr, getThis(), ZEND_STRL("setting"), zset TSRMLS_CC);
}
