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;
}
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;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l",
&func_name, &func_name_len, &step_callback, &fini_callback, &argc)) {
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;
}
static char * luasandbox_timer_get_cfunction_name(lua_State *L)
{
static char buffer[1024];
TSRMLS_FETCH();
lua_CFunction f = lua_tocfunction(L, -1);
if (!f) {
return NULL;
}
if (f != luasandbox_call_php) {
return NULL;
}
lua_getupvalue(L, -1, 1);
zval ** callback_pp = lua_touserdata(L, -1);
if (!callback_pp || !*callback_pp) {
return NULL;
}
char * callback_name;
if (zend_is_callable(*callback_pp, IS_CALLABLE_CHECK_SILENT, &callback_name TSRMLS_CC)) {
snprintf(buffer, sizeof(buffer), "%s", callback_name);
return buffer;
} else {
return NULL;
}
}
static zval *oauth_provider_call_cb(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
{
php_oauth_provider *sop;
php_oauth_provider_fcall *cb = NULL;
zval args, *pthis;
char *errstr = "";
zend_string *callable = NULL;
pthis = getThis();
sop = fetch_sop_object(pthis);
switch(type) {
case OAUTH_PROVIDER_CONSUMER_CB:
cb = sop->consumer_handler;
errstr = "Consumer key/secret handler not specified, did you set a valid callback via OAuthProvider::consumerHandler()?";
break;
case OAUTH_PROVIDER_TOKEN_CB:
cb = sop->token_handler;
errstr = "Token handler not specified, did you set a valid callback via OAuthProvider::tokenHandler()?";
break;
case OAUTH_PROVIDER_TSNONCE_CB:
cb = sop->tsnonce_handler;
errstr = "Timestamp/nonce handler not specified, did you set a valid callback via OAuthProvider::timestampNonceHandler()?";
break;
default:
php_error_docref(NULL, E_ERROR, "Invalid callback type for OAuthProvider");
return NULL;
}
if(!cb) {
php_error_docref(NULL, E_ERROR, "%s", errstr);
return NULL;
}
array_init(&args);
add_next_index_zval(&args, pthis);
Z_ADDREF_P(pthis);
Z_ADDREF(args);
errstr = NULL;
if (!zend_is_callable(&cb->fcall_info->function_name, 0, &callable)) {
if (errstr) {
php_error_docref(NULL, E_WARNING, "Invalid callback: %s, %s", Z_STRVAL(cb->fcall_info->function_name), errstr);
efree(errstr);
} else {
php_error_docref(NULL, E_WARNING, "Invalid callback: %s.", Z_STRVAL(cb->fcall_info->function_name));
}
} else if (errstr) {
php_error_docref(NULL, E_WARNING, "%s", errstr);
efree(errstr);
}
if (zend_fcall_info_call(cb->fcall_info, &cb->fcall_info_cache, return_value, &args)!=SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed calling callback %s", Z_STRVAL(cb->fcall_info->function_name));
}
zval_ptr_dtor(&args);
return return_value;
}
void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
{
zval *retval_ptr;
zval ***args;
int status;
if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback");
zval_dtor(value);
Z_TYPE_P(value) = IS_NULL;
return;
}
args = safe_emalloc(sizeof(zval **), 1, 0);
args[0] = &value;
status = call_user_function_ex(EG(function_table), NULL, option_array, &retval_ptr, 1, args, 0, NULL TSRMLS_CC);
if (status == SUCCESS && retval_ptr != NULL) {
if (retval_ptr != value) {
zval_dtor(value);
COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
} else {
zval_ptr_dtor(&retval_ptr);
}
} else {
zval_dtor(value);
Z_TYPE_P(value) = IS_NULL;
}
efree(args);
}
SKYRAY_METHOD(stream_client, __construct)
{
zval *protocol_creator = NULL;
zval *reactor = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|zz", &protocol_creator, &reactor) == FAILURE) {
return;
}
if (protocol_creator && Z_TYPE_P(protocol_creator) != IS_NULL && !zend_is_callable(protocol_creator, 0, NULL)) {
skyray_throw_exception("The parameter $protocolCreator is not a valid callable");
return;
}
skyray_stream_client_t *intern = skyray_stream_client_from_obj(Z_OBJ_P(getThis()));
if (protocol_creator && Z_TYPE_P(protocol_creator) != IS_NULL) {
intern->protocol_creator = emalloc(sizeof(zval));
ZVAL_COPY(intern->protocol_creator, protocol_creator);
}
if (reactor && Z_TYPE_P(reactor) != IS_NULL) {
intern->reactor = emalloc(sizeof(zval));
ZVAL_COPY(intern->reactor, reactor);
}
}
void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
{
zval retval;
zval args[1];
int status;
if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL)) {
php_error_docref(NULL, E_WARNING, "First argument is expected to be a valid callback");
zval_ptr_dtor(value);
ZVAL_NULL(value);
return;
}
ZVAL_COPY(&args[0], value);
status = call_user_function_ex(EG(function_table), NULL, option_array, &retval, 1, args, 0, NULL);
if (status == SUCCESS && !Z_ISUNDEF(retval)) {
zval_ptr_dtor(value);
ZVAL_COPY_VALUE(value, &retval);
} else {
zval_ptr_dtor(value);
ZVAL_NULL(value);
}
zval_ptr_dtor(&args[0]);
}
static PHP_METHOD(swoole_process, signal)
{
zval *callback = NULL;
long signo = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &signo, &callback) == FAILURE)
{
return;
}
if (!SWOOLE_G(cli))
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "cannot use swoole_process::signal here.");
RETURN_FALSE;
}
if (SwooleGS->start)
{
if (signo == SIGTERM || signo == SIGALRM)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use swoole_process::signal in swoole_server.");
RETURN_FALSE;
}
}
if (callback == NULL || ZVAL_IS_NULL(callback))
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "no callback.");
RETURN_FALSE;
}
char *func_name;
if (!zend_is_callable(callback, 0, &func_name TSRMLS_CC))
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "function '%s' is not callable", func_name);
efree(func_name);
RETURN_FALSE;
}
efree(func_name);
zval_add_ref(&callback);
signal_callback[signo] = callback;
#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
SwooleG.use_signalfd = 1;
#else
SwooleG.use_signalfd = 0;
#endif
php_swoole_check_reactor();
/**
* for swSignalfd_setup
*/
SwooleG.main_reactor->check_signalfd = 1;
swSignal_add(signo, php_swoole_onSignal);
RETURN_TRUE;
}
inline int sw_zend_is_callable(zval *cb, int a, char **name) {
zend_string *key;
int ret = zend_is_callable(cb, a, &key);
char * tmp = (char *)emalloc(key->len);
memcpy(tmp, key->val, key->len);
*name = tmp;
return ret;
}
/* {{{ php_ssh2_set_callback
* Try to set a method if it's passed in with the hash table
*/
static int php_ssh2_set_callback(LIBSSH2_SESSION *session, HashTable *ht, char *callback, int callback_len, int callback_type, php_ssh2_session_data *data)
{
zval *handler, *copyval;
void *internal_handler;
zend_string *callback_zstring;
callback_zstring = zend_string_init(callback, callback_len, 0);
if ((handler = zend_hash_find(ht, callback_zstring)) == NULL) {
zend_string_release(callback_zstring);
return 0;
}
zend_string_release(callback_zstring);
if (!zend_is_callable(handler, 0, NULL)) {
return -1;
}
copyval = handler;
zval_copy_ctor(copyval);
switch (callback_type) {
case LIBSSH2_CALLBACK_IGNORE:
internal_handler = php_ssh2_ignore_cb;
if (data->ignore_cb) {
zval_ptr_dtor(data->ignore_cb);
}
data->ignore_cb = copyval;
break;
case LIBSSH2_CALLBACK_DEBUG:
internal_handler = php_ssh2_debug_cb;
if (data->debug_cb) {
zval_ptr_dtor(data->debug_cb);
}
data->debug_cb = copyval;
break;
case LIBSSH2_CALLBACK_MACERROR:
internal_handler = php_ssh2_macerror_cb;
if (data->macerror_cb) {
zval_ptr_dtor(data->macerror_cb);
}
data->macerror_cb = copyval;
break;
case LIBSSH2_CALLBACK_DISCONNECT:
internal_handler = php_ssh2_disconnect_cb;
if (data->disconnect_cb) {
zval_ptr_dtor(data->disconnect_cb);
}
data->disconnect_cb = copyval;
break;
default:
zval_ptr_dtor(copyval);
return -1;
}
libssh2_session_callback_set(session, callback_type, internal_handler);
return 0;
}
/* {{{ _php_bbcode_callback_handler
Common code for content and parameter handlers */
static int _php_bbcode_callback_handler(int cb_type, bstring content, bstring param, zval *func_name)
{
zval *retval = NULL;
zval ***zargs = NULL;
char *callable = NULL;
int i, res;
bstring target;
char *cb_name = "";
TSRMLS_FETCH();
switch (cb_type) {
case PHP_BBCODE_CONTENT_CB:
target = content;
break;
case PHP_BBCODE_PARAM_CB:
target = param;
break;
}
zargs = (zval ***) emalloc(sizeof(zval **) * 2);
zargs[0] = emalloc(sizeof(zval *));
MAKE_STD_ZVAL(*zargs[0]);
ZVAL_STRINGL(*zargs[0], bdata(content), blength(content), 1);
zargs[1] = emalloc(sizeof(zval *));
MAKE_STD_ZVAL(*zargs[1]);
ZVAL_STRINGL(*zargs[1], bdata(param), blength(param), 1);
res = call_user_function_ex(EG(function_table), NULL, func_name, &retval, 2, zargs, 1, NULL TSRMLS_CC);
if (res != SUCCESS) {
if (!zend_is_callable(func_name, 0, &callable TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "function `%s' is not callable", callable);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "callback function %s() failed", callable);
}
efree(callable);
} else if (&retval != NULL) {
convert_to_string_ex(&retval);
if (Z_STRLEN_P(retval)) {
bassignblk(target, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
} else {
bdelete(target, 0, blength(target));
}
zval_ptr_dtor(&retval);
}
/* Free zargs */
for (i = 0; i < 2; i++) {
zval_ptr_dtor(zargs[i]);
efree(zargs[i]);
}
efree(zargs);
return 0;
}
static PHP_METHOD(swoole_process, __construct)
{
zend_bool redirect_stdin_and_stdout = 0;
zend_bool create_pipe = 1;
zval *callback;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bb", &callback, &redirect_stdin_and_stdout, &create_pipe) == FAILURE)
{
RETURN_FALSE;
}
char *func_name = NULL;
if (!zend_is_callable(callback, 0, &func_name TSRMLS_CC))
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "function '%s' is not callable", func_name);
efree(func_name);
RETURN_FALSE;
}
efree(func_name);
swWorker *process = emalloc(sizeof(swWorker));
bzero(process, sizeof(swWorker));
process->id = php_swoole_worker_round_id++;
if (php_swoole_worker_round_id == 0)
{
php_swoole_worker_round_id = 1;
}
if (redirect_stdin_and_stdout)
{
process->redirect_stdin = 1;
process->redirect_stdout = 1;
create_pipe = 1;
}
if (create_pipe)
{
swPipe *_pipe = emalloc(sizeof(swWorker));
if (swPipeUnsock_create(_pipe, 1, SOCK_STREAM) < 0)
{
RETURN_FALSE;
}
process->pipe_object = _pipe;
process->pipe_master = _pipe->getFd(_pipe, SW_PIPE_MASTER);
process->pipe_worker = _pipe->getFd(_pipe, SW_PIPE_WORKER);
process->pipe = process->pipe_master;
zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("pipe"), process->pipe_master TSRMLS_CC);
}
swoole_set_object(getThis(), process);
zend_update_property(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("callback"), callback TSRMLS_CC);
}
static char * luasandbox_timer_get_cfunction_name(lua_State *L)
{
static char buffer[1024];
TSRMLS_FETCH();
lua_CFunction f = lua_tocfunction(L, -1);
if (!f) {
return NULL;
}
if (f != luasandbox_call_php) {
return NULL;
}
lua_getupvalue(L, -1, 1);
#if PHP_VERSION_ID < 70000
zval ** callback_pp = (zval**)lua_touserdata(L, -1);
if (!callback_pp || !*callback_pp) {
return NULL;
}
char * callback_name;
zend_bool ok = zend_is_callable(*callback_pp, IS_CALLABLE_CHECK_SILENT, &callback_name TSRMLS_CC);
#else
zval * callback_p = (zval*)lua_touserdata(L, -1);
if (!callback_p) {
return NULL;
}
zend_string * callback_name;
zend_bool ok = zend_is_callable(callback_p, IS_CALLABLE_CHECK_SILENT, &callback_name);
#endif
if (ok) {
snprintf(buffer, sizeof(buffer), "%s",
#if PHP_VERSION_ID < 70000
callback_name
#else
ZSTR_VAL(callback_name)
#endif
);
return buffer;
} else {
return NULL;
}
}
PHP_METHOD(swoole_http_server, on)
{
zval *callback;
zval *event_name;
swServer *serv;
if (SwooleGS->start > 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server is running. Unable to set event callback now.");
RETURN_FALSE;
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_name, &callback) == FAILURE)
{
return;
}
SWOOLE_GET_SERVER(getThis(), serv);
char *func_name = NULL;
if (!zend_is_callable(callback, 0, &func_name TSRMLS_CC))
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Function '%s' is not callable", func_name);
efree(func_name);
RETURN_FALSE;
}
efree(func_name);
if (strncasecmp("request", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[0] = callback;
}
else if (strncasecmp("message", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[1] = callback;
}
else if (strncasecmp("handshake", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[2] = callback;
}
else if (strncasecmp("open", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[3] = callback;
}
else
{
zend_call_method_with_2_params(&getThis(), swoole_server_class_entry_ptr, NULL, "on", &return_value, event_name, callback);
}
}
/* {{{ 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;
}
SKYRAY_METHOD(HttpServer, setUpgrader)
{
zval *upgrader = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &upgrader) == FAILURE) {
return;
}
if (!zend_is_callable(upgrader, 0, NULL)) {
zend_throw_exception_ex(skyray_ce_InvalidParamException, 0, "The upgrader is not a valid callable");
return;
}
skyray_http_server_t *intern = skyray_http_server_from_obj(Z_OBJ_P(getThis()));
ZVAL_COPY(&intern->upgrader, upgrader);
}
SKYRAY_METHOD(HttpServer, setWsFactory)
{
zval *factory = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &factory) == FAILURE) {
return;
}
if (!zend_is_callable(factory, 0, NULL)) {
zend_throw_exception_ex(skyray_ce_InvalidParamException, 0, "The factory is not a valid callable");
return;
}
skyray_http_server_t *intern = skyray_http_server_from_obj(Z_OBJ_P(getThis()));
ZVAL_COPY(&intern->ws_factory, factory);
}
PHP_METHOD(swoole_http_server, on)
{
zval *callback;
char *event_name;
swServer *serv;
int len;
if (SwooleGS->start > 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server is running. Unable to set event callback now.");
RETURN_FALSE;
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &event_name, &len, &callback) == FAILURE)
{
return;
}
SWOOLE_GET_SERVER(getThis(), serv);
char *func_name = NULL;
if (!zend_is_callable(callback, 0, &func_name TSRMLS_CC))
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Function '%s' is not callable", func_name);
efree(func_name);
RETURN_FALSE;
}
efree(func_name);
if (strncasecmp("request", event_name, len) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[0] = callback;
}
else if (strncasecmp("message", event_name, len) == 0)
{
zval_add_ref(&callback);
php_sw_http_server_callbacks[1] = callback;
}
else
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Unknown event types[%s]", event_name);
RETURN_FALSE;
}
}
/* {{{ 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;
}
/* {{{ proto Router Router::setDefault(Callable handler)
Throws RoutingException on failure
The default route is invoked for web requests that match no other route */
static PHP_METHOD(Router, setDefault) {
zval *callable;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &callable) != SUCCESS) {
return;
}
{
char *callable_name = NULL;
if (zend_is_callable(callable, 0, &callable_name TSRMLS_CC)) {
route_t route = {ROUTER_ROUTE_DEFAULT};
route.callable = callable;
Z_ADDREF_P(route.callable);
{
router_t *router = getRouter();
zend_hash_update(
&router->routes,
Default_Route, Default_Route_Size,
(void**)&route, sizeof(route_t), (void**)&router->fallback);
}
} else {
zend_throw_exception(
RoutingException, "handler is not callable", 0 TSRMLS_CC);
}
if (callable_name) {
efree(callable_name);
}
}
RETURN_CHAIN();
} /* }}} */
static void phpg_closure_marshal(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
phpg_closure_t *phpg_closure = (phpg_closure_t *)closure;
char *callback_name;
zval ***params = NULL;
zval *retval = NULL;
uint n_params = 0, i;
#ifdef ZTS
TSRMLS_D = phpg_closure->TSRMLS_C;
#endif
if (!zend_is_callable(phpg_closure->callback, 0, &callback_name PHPGTK_ZEND_IS_CALLABLE)) {
if (phpg_closure->src_filename)
php_error(E_WARNING,
"Unable to invoke signal callback '%s' specified in %s on line %d",
callback_name, phpg_closure->src_filename, phpg_closure->src_lineno);
else
php_error(E_WARNING, "Unable to invoke signal callback '%s'", callback_name);
efree(callback_name);
return;
}
if (phpg_closure->connect_type == PHPG_CONNECT_SIMPLE) {
/* we don't use any signal params for simple connections */
n_param_values = 0;
} else {
if (phpg_closure->connect_type == PHPG_CONNECT_OBJECT) {
/* skip first parameter */
n_param_values--;
param_values++;
}
n_params = n_param_values;
}
if (phpg_closure->user_args) {
n_params += zend_hash_num_elements(Z_ARRVAL_P(phpg_closure->user_args));
}
params = (zval ***)emalloc(n_params * sizeof(zval **));
i = 0;
if (phpg_closure->connect_type == PHPG_CONNECT_REPLACE) {
params[i++] = &phpg_closure->replace_object;
}
for ( ; i < n_param_values; i++) {
params[i] = (zval **) emalloc(sizeof(zval *));
*(params[i]) = NULL;
if (phpg_gvalue_to_zval(¶m_values[i], params[i], FALSE, TRUE TSRMLS_CC) != SUCCESS) {
goto err_marshal;
}
}
if (phpg_closure->user_args) {
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(phpg_closure->user_args));
zend_hash_get_current_data(Z_ARRVAL_P(phpg_closure->user_args), (void **)¶ms[i]) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(phpg_closure->user_args)), i++);
/* empty body */
}
assert(i == n_params);
call_user_function_ex(EG(function_table), NULL, phpg_closure->callback,
&retval, n_params, params, 0, NULL TSRMLS_CC);
if (retval) {
if (return_value) {
if (phpg_gvalue_from_zval(return_value, &retval, TRUE TSRMLS_CC) == FAILURE) {
php_error(E_WARNING, "Could not convert return value of signal callback '%s' to '%s'",
callback_name, g_type_name(G_VALUE_TYPE(return_value)));
}
}
zval_ptr_dtor(&retval);
}
err_marshal:
efree(callback_name);
i = (phpg_closure->connect_type == PHPG_CONNECT_REPLACE) ? 1 : 0;
for ( ; i < n_param_values; i++) {
zval_ptr_dtor(params[i]);
efree(params[i]);
}
efree(params);
phpg_handle_marshaller_exception(TSRMLS_C);
}
PHP_COUCHBASE_LOCAL
void php_couchbase_get_delayed_impl(INTERNAL_FUNCTION_PARAMETERS, int oo) /* {{{ */
{
zval *res, *akeys;
long with_cas = 0;
lcb_time_t exp = {0};
long expiry = 0;
zend_bool lock = 0;
int argflags = PHP_COUCHBASE_ARG_F_ASYNC;
php_couchbase_res *couchbase_res;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
zend_fcall_info fci = {0};
zend_fcall_info_cache fci_cache = {0};
if (oo) {
argflags |= PHP_COUCHBASE_ARG_F_OO;
} else {
argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL;
}
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"a|lf!lb",
&akeys, &with_cas, &fci, &fci_cache, &expiry, &lock);
#else
if (oo) {
argflags |= PHP_COUCHBASE_ARG_F_OO;
} else {
argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL;
}
zval *callback = NULL;
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"a|lzlb", &akeys, &with_cas, &callback, &expiry, &lock);
if (callback && Z_TYPE_P(callback) != IS_NULL
&& !zend_is_callable(callback, 0, NULL)) {
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_exception,
"third argument is expected to be a valid callback");
return;
}
#endif
{
zval **ppzval;
lcb_error_t retval;
php_couchbase_ctx *ctx;
char **keys;
long nkey, *klens, i;
nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys));
keys = ecalloc(nkey, sizeof(char *));
klens = ecalloc(nkey, sizeof(long));
for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));
zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) {
if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) {
nkey--;
continue;
}
if (IS_ARRAY != Z_TYPE_PP(ppzval)) {
convert_to_string_ex(ppzval);
}
if (!Z_STRLEN_PP(ppzval)) {
nkey--;
continue;
}
if (couchbase_res->prefix_key_len) {
klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval));
} else {
keys[i] = Z_STRVAL_PP(ppzval);
klens[i] = Z_STRLEN_PP(ppzval);
}
}
if (!nkey) {
efree(keys);
efree(klens);
return;
}
couchbase_res->seqno += nkey;
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->flags = with_cas;
{
lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *));
int ii;
if (expiry) {
exp = pcbc_check_expiry(expiry);
}
for (ii = 0; ii < nkey; ++ii) {
lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t));
commands[ii] = cmd;
cmd->v.v0.key = keys[ii];
cmd->v.v0.nkey = klens[ii];
cmd->v.v0.lock = (int)lock;
cmd->v.v0.exptime = exp; /* NB: this assumes that sizeof(lcb_time_t) == sizeof(long) */
}
retval = lcb_get(couchbase_res->handle, ctx,
nkey, (const lcb_get_cmd_t * const *)commands);
for (ii = 0; ii < nkey; ++ii) {
efree(commands[ii]);
}
efree(commands);
}
if (LCB_SUCCESS != retval) {
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
efree(keys);
efree(klens);
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_lcb_exception,
"Failed to schedule delayed get request: %s",
lcb_strerror(couchbase_res->handle, retval));
return;
}
couchbase_res->async = 1;
couchbase_res->async_ctx = ctx;
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
efree(keys);
efree(klens);
if (
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
fci.size
#else
callback
#endif
) {
zval *result, **ppzval, *retval_ptr = NULL;
zval **params[2];
MAKE_STD_ZVAL(result);
array_init(result);
ctx->rv = result;
pcbc_start_loop(couchbase_res);
couchbase_res->async = 0;
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(result));
zend_hash_has_more_elements(Z_ARRVAL_P(result)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(result))) {
if (zend_hash_get_current_data(Z_ARRVAL_P(result), (void **)&ppzval) == FAILURE) {
continue;
}
params[0] = &res;
params[1] = ppzval;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = 2;
fci.params = params;
zend_call_function(&fci, &fci_cache TSRMLS_CC);
#else
call_user_function_ex(EG(function_table), NULL, callback, &retval_ptr, 2, params, 0, NULL TSRMLS_CC);
#endif
if (retval_ptr != NULL) {
zval_ptr_dtor(&retval_ptr);
}
}
zval_ptr_dtor(&result);
efree(ctx);
}
}
RETURN_TRUE;
}
static void call_php(char *name, PARAMDSC *r, int argc, PARAMDSC **argv)
{
do {
zval callback, args[4], *argp[4], return_value;
PARAMVARY *res = (PARAMVARY*)r->dsc_address;
int i;
INIT_ZVAL(callback);
ZVAL_STRING(&callback,name,0);
LOCK();
/* check if the requested function exists */
if (!zend_is_callable(&callback, 0, NULL TSRMLS_CC)) {
break;
}
UNLOCK();
/* create the argument array */
for (i = 0; i < argc; ++i) {
INIT_ZVAL(args[i]);
argp[i] = &args[i];
/* test arg for null */
if (argv[i]->dsc_flags & DSC_null) {
ZVAL_NULL(argp[i]);
continue;
}
switch (argv[i]->dsc_dtype) {
ISC_INT64 l;
struct tm t;
char const *fmt;
char d[64];
case dtype_cstring:
ZVAL_STRING(argp[i], (char*)argv[i]->dsc_address,0);
break;
case dtype_text:
ZVAL_STRINGL(argp[i], (char*)argv[i]->dsc_address, argv[i]->dsc_length,0);
break;
case dtype_varying:
ZVAL_STRINGL(argp[i], ((PARAMVARY*)argv[i]->dsc_address)->vary_string,
((PARAMVARY*)argv[i]->dsc_address)->vary_length,0);
break;
case dtype_short:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(short*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(short*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_long:
if (argv[i]->dsc_scale == 0) {
ZVAL_LONG(argp[i], *(ISC_LONG*)argv[i]->dsc_address);
} else {
ZVAL_DOUBLE(argp[i],
((double)*(ISC_LONG*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_int64:
l = *(ISC_INT64*)argv[i]->dsc_address;
if (argv[i]->dsc_scale == 0 && l <= LONG_MAX && l >= LONG_MIN) {
ZVAL_LONG(argp[i], (long)l);
} else {
ZVAL_DOUBLE(argp[i], ((double)l)/scales[-argv[i]->dsc_scale]);
}
break;
case dtype_real:
ZVAL_DOUBLE(argp[i], *(float*)argv[i]->dsc_address);
break;
case dtype_double:
ZVAL_DOUBLE(argp[i], *(double*)argv[i]->dsc_address);
break;
case dtype_sql_date:
isc_decode_sql_date((ISC_DATE*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.dateformat"), &t),1);
break;
case dtype_sql_time:
isc_decode_sql_time((ISC_TIME*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timeformat"), &t),1);
break;
case dtype_timestamp:
isc_decode_timestamp((ISC_TIMESTAMP*)argv[i]->dsc_address, &t);
ZVAL_STRINGL(argp[i], d, strftime(d, sizeof(d), INI_STR("ibase.timestampformat"), &t),1);
break;
}
}
LOCK();
/* now call the function */
if (FAILURE == call_user_function(EG(function_table), NULL,
&callback, &return_value, argc, argp TSRMLS_CC)) {
UNLOCK();
break;
}
UNLOCK();
for (i = 0; i < argc; ++i) {
switch (argv[i]->dsc_dtype) {
case dtype_sql_date:
case dtype_sql_time:
case dtype_timestamp:
zval_dtor(argp[i]);
}
}
/* return whatever type we got back from the callback: let DB handle conversion */
switch (Z_TYPE(return_value)) {
case IS_LONG:
r->dsc_dtype = dtype_long;
*(long*)r->dsc_address = Z_LVAL(return_value);
r->dsc_length = sizeof(long);
break;
case IS_DOUBLE:
r->dsc_dtype = dtype_double;
*(double*)r->dsc_address = Z_DVAL(return_value);
r->dsc_length = sizeof(double);
break;
case IS_NULL:
r->dsc_flags |= DSC_null;
break;
default:
convert_to_string(&return_value);
case IS_STRING:
r->dsc_dtype = dtype_varying;
memcpy(res->vary_string, Z_STRVAL(return_value),
(res->vary_length = min(r->dsc_length-2,Z_STRLEN(return_value))));
r->dsc_length = res->vary_length+2;
break;
}
zval_dtor(&return_value);
return;
} while (0);
/**
* If we end up here, we should report an error back to the DB engine, but
* that's not possible. We can however report it back to PHP.
*/
LOCK();
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling function '%s' from database", name);
UNLOCK();
}
/* {{{ proto Router Router::addRoute(string method, string uri, Callable handler)
proto Router Router::addRoute(Route route)
Throws RoutingException on failure */
static PHP_METHOD(Router, addRoute) {
const char *request_method = NULL;
size_t request_method_length = 0L;
const char *request_uri = NULL;
size_t request_uri_length = 0L;
zval *callable = NULL;
zend_class_entry *ce = NULL;
router_t *router = getRouter();
switch (ZEND_NUM_ARGS()) {
case 3: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "ssz",
&request_method, &request_method_length,
&request_uri, &request_uri_length, &callable) != SUCCESS) {
return;
} break;
case 1: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "O",
&callable, ce) != SUCCESS) {
return;
} break;
default:
zend_throw_exception(
RoutingException, "Router::addRoute expects one or three arguments, please see documentation", 0 TSRMLS_CC);
return;
}
{
route_t route = {ROUTER_ROUTE_NORMAL};
route.callable = callable;
if (ZEND_NUM_ARGS() == 1) {
zval *pmethod = NULL,
*puri = NULL;
zend_call_method_with_0_params(
&callable, ce, NULL, "getMethod", &pmethod);
if (Z_TYPE_P(pmethod) != IS_STRING) {
zend_throw_exception(
RoutingException, "getMethod returned a non-string value", 0 TSRMLS_CC);
zval_ptr_dtor(&pmethod);
return;
}
zend_call_method_with_0_params(
&callable, ce, NULL, "getURI", &puri);
if (Z_TYPE_P(puri) != IS_STRING) {
zend_throw_exception(
RoutingException, "getURI returned a non-string value", 0 TSRMLS_CC);
zval_ptr_dtor(&pmethod);
zval_ptr_dtor(&puri);
return;
}
ZVAL_STRINGL(&route.method, Z_STRVAL_P(pmethod), Z_STRLEN_P(pmethod), 1);
ZVAL_STRINGL(&route.uri, Z_STRVAL_P(puri), Z_STRLEN_P(puri), 1);
Z_ADDREF_P(route.callable);
zend_hash_next_index_insert(
&router->routes,
(void**) &route, sizeof(route_t), NULL);
zval_ptr_dtor(&pmethod);
zval_ptr_dtor(&puri);
} else {
char *callable_name = NULL;
if (!zend_is_callable(callable, 0, &callable_name TSRMLS_CC)) {
zend_throw_exception(
RoutingException, "handler is not callable", 0 TSRMLS_CC);
if (callable_name)
efree(callable_name);
return;
}
ZVAL_STRINGL(&route.method, request_method, request_method_length, 1);
ZVAL_STRINGL(&route.uri, request_uri, request_uri_length, 1);
Z_ADDREF_P(route.callable);
zend_hash_next_index_insert(
&router->routes,
(void**) &route, sizeof(route_t), NULL);
if (callable_name)
efree(callable_name);
}
}
RETURN_CHAIN();
} /* }}} */
