static PHP_METHOD(SQLite, sqliteCreateAggregate)
{
struct pdo_sqlite_func *func;
zval *step_callback, *fini_callback;
char *func_name;
size_t func_name_len;
zend_long argc = -1;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(3, 4)
Z_PARAM_STRING(func_name, func_name_len)
Z_PARAM_ZVAL_DEREF(step_callback)
Z_PARAM_ZVAL_DEREF(fini_callback)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(argc)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(step_callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
if (!zend_is_callable(fini_callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
func, NULL, php_sqlite3_func_step_callback, php_sqlite3_func_final_callback);
if (ret == SQLITE_OK) {
func->funcname = estrdup(func_name);
ZVAL_COPY(&func->step, step_callback);
ZVAL_COPY(&func->fini, fini_callback);
func->argc = argc;
func->next = H->funcs;
H->funcs = func;
RETURN_TRUE;
}
efree(func);
RETURN_FALSE;
}
/* {{{ bool SQLite::sqliteCreateFunction(string name, mixed callback [, int argcount, int flags])
Registers a UDF with the sqlite db handle */
static PHP_METHOD(SQLite, sqliteCreateFunction)
{
struct pdo_sqlite_func *func;
zval *callback;
char *func_name;
size_t func_name_len;
zend_long argc = -1;
zend_long flags = 0;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(2, 4)
Z_PARAM_STRING(func_name, func_name_len)
Z_PARAM_ZVAL(callback)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(argc)
Z_PARAM_LONG(flags)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(callback, 0, NULL)) {
zend_string *cbname = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release_ex(cbname, 0);
RETURN_FALSE;
}
H = (pdo_sqlite_db_handle *)dbh->driver_data;
func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
ret = sqlite3_create_function(H->db, func_name, argc, flags | SQLITE_UTF8,
func, php_sqlite3_func_callback, NULL, NULL);
if (ret == SQLITE_OK) {
func->funcname = estrdup(func_name);
ZVAL_COPY(&func->func, callback);
func->argc = argc;
func->next = H->funcs;
H->funcs = func;
RETURN_TRUE;
}
efree(func);
RETURN_FALSE;
}
/* {{{ proto mixed json_decode(string json [, bool assoc [, long depth]])
Decodes the JSON representation into a PHP value */
static PHP_FUNCTION(json_decode)
{
char *str;
size_t str_len;
zend_bool assoc = 0; /* return JS objects as PHP objects by default */
zend_bool assoc_null = 1;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
zend_long options = 0;
ZEND_PARSE_PARAMETERS_START(1, 4)
Z_PARAM_STRING(str, str_len)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL_EX(assoc, assoc_null, 1, 0)
Z_PARAM_LONG(depth)
Z_PARAM_LONG(options)
ZEND_PARSE_PARAMETERS_END();
if (!(options & PHP_JSON_THROW_ON_ERROR)) {
JSON_G(error_code) = PHP_JSON_ERROR_NONE;
}
if (!str_len) {
if (!(options & PHP_JSON_THROW_ON_ERROR)) {
JSON_G(error_code) = PHP_JSON_ERROR_SYNTAX;
} else {
zend_throw_exception(php_json_exception_ce, php_json_get_error_msg(PHP_JSON_ERROR_SYNTAX), PHP_JSON_ERROR_SYNTAX);
}
RETURN_NULL();
}
if (depth <= 0) {
php_error_docref(NULL, E_WARNING, "Depth must be greater than zero");
RETURN_NULL();
}
if (depth > INT_MAX) {
php_error_docref(NULL, E_WARNING, "Depth must be lower than %d", INT_MAX);
RETURN_NULL();
}
/* For BC reasons, the bool $assoc overrides the long $options bit for PHP_JSON_OBJECT_AS_ARRAY */
if (!assoc_null) {
if (assoc) {
options |= PHP_JSON_OBJECT_AS_ARRAY;
} else {
options &= ~PHP_JSON_OBJECT_AS_ARRAY;
}
}
php_json_decode_ex(return_value, str, str_len, options, depth);
}
static PHP_METHOD(swoole_coroutine_util, readFile)
{
coro_check(TSRMLS_C);
char *filename = NULL;
size_t l_filename = 0;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_STRING(filename, l_filename)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &l_filename) == FAILURE)
{
return;
}
#endif
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
php_context *context = emalloc(sizeof(php_context));
ev.type = SW_AIO_READ_FILE;
ev.object = context;
ev.handler = swAio_handler_read_file;
ev.callback = aio_onReadFileCompleted;
ev.req = estrndup(filename, l_filename);
if (!SwooleAIO.init)
{
php_swoole_check_reactor();
swAio_init();
}
swTrace("readFile(%s)", filename);
int ret = swAio_dispatch(&ev);
if (ret < 0)
{
efree(context);
RETURN_FALSE;
}
context->state = SW_CORO_CONTEXT_RUNNING;
coro_save(context);
coro_yield();
}
/* {{{ bool SQLite::sqliteCreateCollation(string name, mixed callback)
Registers a collation with the sqlite db handle */
static PHP_METHOD(SQLite, sqliteCreateCollation)
{
struct pdo_sqlite_collation *collation;
zval *callback;
char *collation_name;
size_t collation_name_len;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_STRING(collation_name, collation_name_len)
Z_PARAM_ZVAL_DEREF(callback)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
collation = (struct pdo_sqlite_collation*)ecalloc(1, sizeof(*collation));
ret = sqlite3_create_collation(H->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_collation_callback);
if (ret == SQLITE_OK) {
collation->name = estrdup(collation_name);
ZVAL_COPY(&collation->callback, callback);
collation->next = H->collations;
H->collations = collation;
RETURN_TRUE;
}
efree(collation);
RETURN_FALSE;
}
static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
{
char *cmd;
size_t cmd_len;
zval *ret_code=NULL, *ret_array=NULL;
int ret;
ZEND_PARSE_PARAMETERS_START(1, (mode ? 2 : 3))
Z_PARAM_STRING(cmd, cmd_len)
Z_PARAM_OPTIONAL
if (!mode) {
Z_PARAM_ZVAL(ret_array)
}
Z_PARAM_ZVAL(ret_code)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (!cmd_len) {
php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
RETURN_FALSE;
}
if (strlen(cmd) != cmd_len) {
php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack");
RETURN_FALSE;
}
if (!ret_array) {
ret = php_exec(mode, cmd, NULL, return_value);
} else {
if (Z_TYPE_P(Z_REFVAL_P(ret_array)) == IS_ARRAY) {
ZVAL_DEREF(ret_array);
SEPARATE_ARRAY(ret_array);
} else {
ret_array = zend_try_array_init(ret_array);
if (!ret_array) {
return;
}
}
ret = php_exec(2, cmd, ret_array, return_value);
}
if (ret_code) {
ZEND_TRY_ASSIGN_LONG(ret_code, ret);
}
}
/* {{{ proto int dl(string extension_filename)
Load a PHP extension at runtime */
PHPAPI PHP_FUNCTION(dl)
{
char *filename;
size_t filename_len;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STRING(filename, filename_len)
ZEND_PARSE_PARAMETERS_END();
if (!PG(enable_dl)) {
php_error_docref(NULL, E_WARNING, "Dynamically loaded extensions aren't enabled");
RETURN_FALSE;
}
if (filename_len >= MAXPATHLEN) {
php_error_docref(NULL, E_WARNING, "File name exceeds the maximum allowed length of %d characters", MAXPATHLEN);
RETURN_FALSE;
}
php_dl(filename, MODULE_TEMPORARY, return_value, 0);
if (Z_TYPE_P(return_value) == IS_TRUE) {
EG(full_tables_cleanup) = 1;
}
}
static PHP_METHOD(swoole_coroutine_util, writeFile)
{
coro_check(TSRMLS_C);
char *filename = NULL;
size_t l_filename = 0;
char *data = NULL;
size_t l_data = 0;
zend_long flags = 0;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(2, 3)
Z_PARAM_STRING(filename, l_filename)
Z_PARAM_STRING(data, l_data)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(flags)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &filename, &l_filename, &data, &l_data, &flags) == FAILURE)
{
return;
}
#endif
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
ev.nbytes = l_data;
ev.buf = data;
php_context *context = emalloc(sizeof(php_context));
ev.type = SW_AIO_WRITE_FILE;
ev.object = context;
ev.handler = swAio_handler_write_file;
ev.callback = aio_onWriteFileCompleted;
ev.req = estrndup(filename, l_filename);
ev.flags = O_CREAT | O_WRONLY;
if (flags & PHP_FILE_APPEND)
{
ev.flags |= O_APPEND;
}
else
{
ev.flags |= O_TRUNC;
}
if (!SwooleAIO.init)
{
php_swoole_check_reactor();
swAio_init();
}
swTrace("writeFile(%s, %ld)", filename, ev.nbytes);
int ret = swAio_dispatch(&ev);
if (ret < 0)
{
efree(context);
RETURN_FALSE;
}
context->state = SW_CORO_CONTEXT_RUNNING;
coro_save(context);
coro_yield();
}
static PHP_METHOD(swoole_coroutine_util, fwrite)
{
coro_check(TSRMLS_C);
zval *handle;
char *str;
zend_size_t l_str;
zend_long length = 0;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(2, 3)
Z_PARAM_RESOURCE(handle)
Z_PARAM_STRING(str, l_str)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(length)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &handle, &str, &l_str, &length) == FAILURE)
{
return;
}
#endif
int async;
int fd = swoole_convert_to_fd_ex(handle, &async TSRMLS_CC);
if (fd < 0)
{
RETURN_FALSE;
}
if (async)
{
co_socket_write(fd, str, (length < 0 && length < l_str) ? length : l_str, INTERNAL_FUNCTION_PARAM_PASSTHRU);
return;
}
off_t _seek = lseek(fd, 0, SEEK_CUR);
if (_seek < 0)
{
SwooleG.error = errno;
RETURN_FALSE;
}
if (length <= 0 || length > l_str)
{
length = l_str;
}
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
ev.nbytes = length;
ev.buf = estrndup(str, length);
if (!ev.buf)
{
RETURN_FALSE;
}
php_context *context = emalloc(sizeof(php_context));
ev.flags = 0;
ev.type = SW_AIO_WRITE;
ev.object = context;
ev.handler = swAio_handler_write;
ev.callback = aio_onWriteCompleted;
ev.fd = fd;
ev.offset = _seek;
php_swoole_check_aio();
swTrace("fd=%d, offset=%jd, length=%ld", fd, (intmax_t) ev.offset, ev.nbytes);
int ret = swAio_dispatch(&ev);
if (ret < 0)
{
efree(context);
RETURN_FALSE;
}
context->state = SW_CORO_CONTEXT_RUNNING;
coro_save(context);
coro_yield();
}
static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
char *host;
size_t host_len;
zend_long port = -1;
zval *zerrno = NULL, *zerrstr = NULL;
double timeout = (double)FG(default_socket_timeout);
#ifndef PHP_WIN32
time_t conv;
#else
long conv;
#endif
struct timeval tv;
char *hashkey = NULL;
php_stream *stream = NULL;
int err;
char *hostname = NULL;
size_t hostname_len;
zend_string *errstr = NULL;
RETVAL_FALSE;
ZEND_PARSE_PARAMETERS_START(1, 5)
Z_PARAM_STRING(host, host_len)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(port)
Z_PARAM_ZVAL(zerrno)
Z_PARAM_ZVAL(zerrstr)
Z_PARAM_DOUBLE(timeout)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (persistent) {
spprintf(&hashkey, 0, "pfsockopen__%s:" ZEND_LONG_FMT, host, port);
}
if (port > 0) {
hostname_len = spprintf(&hostname, 0, "%s:" ZEND_LONG_FMT, host, port);
} else {
hostname_len = host_len;
hostname = host;
}
/* prepare the timeout value for use */
#ifndef PHP_WIN32
conv = (time_t) (timeout * 1000000.0);
tv.tv_sec = conv / 1000000;
#else
conv = (long) (timeout * 1000000.0);
tv.tv_sec = conv / 1000000;
#endif
tv.tv_usec = conv % 1000000;
stream = php_stream_xport_create(hostname, hostname_len, REPORT_ERRORS,
STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT, hashkey, &tv, NULL, &errstr, &err);
if (port > 0) {
efree(hostname);
}
if (stream == NULL) {
php_error_docref(NULL, E_WARNING, "unable to connect to %s:" ZEND_LONG_FMT " (%s)", host, port, errstr == NULL ? "Unknown error" : ZSTR_VAL(errstr));
}
if (hashkey) {
efree(hashkey);
}
if (stream == NULL) {
if (zerrno) {
ZEND_TRY_ASSIGN_LONG(zerrno, err);
}
if (errstr) {
if (zerrstr) {
ZEND_TRY_ASSIGN_STR(zerrstr, errstr);
} else {
zend_string_release(errstr);
}
}
RETURN_FALSE;
}
if (zerrno) {
ZEND_TRY_ASSIGN_LONG(zerrno, 0);
}
if (zerrstr) {
ZEND_TRY_ASSIGN_EMPTY_STRING(zerrstr);
}
if (errstr) {
zend_string_release_ex(errstr, 0);
}
php_stream_to_zval(stream, return_value);
}