/* +----------------------------------------------------------------------+ | Swoole | +----------------------------------------------------------------------+ | This source file is subject to version 2.0 of the Apache license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | http://www.apache.org/licenses/LICENSE-2.0.html | | If you did not receive a copy of the Apache2.0 license and are unable| | to obtain it through the world-wide-web, please send a note to | | license@swoole.com so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: Tianfeng Han | +----------------------------------------------------------------------+ */ #include "php_swoole.h" #include "Connection.h" #ifdef SW_COROUTINE #include "swoole_coroutine.h" #endif #include "ext/standard/php_var.h" #if PHP_MAJOR_VERSION < 7 #include "ext/standard/php_smart_str.h" #else #include "zend_smart_str.h" #endif #ifdef HAVE_PCRE typedef struct { int current_fd; int max_fd; uint32_t session_id; swServer *serv; swListenPort *port; int end; int index; } swConnectionIterator; #endif static int php_swoole_task_id = 0; static int udp_server_socket; static int dgram_server_socket; static struct { zval *zobjects[SW_MAX_LISTEN_PORT]; zval *zports; uint8_t num; } server_port_list; zval *php_sw_server_callbacks[PHP_SERVER_CALLBACK_NUM]; zend_fcall_info_cache *php_sw_server_caches[PHP_SERVER_CALLBACK_NUM]; static swHashMap *task_callbacks = NULL; #ifdef SW_COROUTINE static swHashMap *task_coroutine_map = NULL; static swHashMap *send_coroutine_map = NULL; #endif #ifdef SW_COROUTINE typedef struct { php_context context; int *list; int count; zval *result; swTimer_node *timer; } swTaskCo; #endif #if PHP_MAJOR_VERSION >= 7 zval _php_sw_server_callbacks[PHP_SERVER_CALLBACK_NUM]; #endif static int php_swoole_task_finish(swServer *serv, zval *data TSRMLS_DC); static void php_swoole_onPipeMessage(swServer *serv, swEventData *req); static void php_swoole_onStart(swServer *); static void php_swoole_onShutdown(swServer *); static void php_swoole_onWorkerStart(swServer *, int worker_id); static void php_swoole_onWorkerStop(swServer *, int worker_id); static void php_swoole_onWorkerExit(swServer *serv, int worker_id); static void php_swoole_onUserWorkerStart(swServer *serv, swWorker *worker); static int php_swoole_onTask(swServer *, swEventData *task); static int php_swoole_onFinish(swServer *, swEventData *task); static void php_swoole_onWorkerError(swServer *serv, int worker_id, pid_t worker_pid, int exit_code, int signo); static void php_swoole_onManagerStart(swServer *serv); static void php_swoole_onManagerStop(swServer *serv); #ifdef SW_COROUTINE static void php_swoole_onConnect_finish(void *param); static void php_swoole_onSendTimeout(swTimer *timer, swTimer_node *tnode); static void php_swoole_server_send_resume(swServer *serv, php_context *context, int fd); #endif static zval* php_swoole_server_add_port(swServer *serv, swListenPort *port TSRMLS_DC); static int php_swoole_create_dir(const char* path, size_t length TSRMLS_DC) { if (access(path, F_OK) == 0) { return 0; } #if 1 return php_stream_mkdir(path, 0777, PHP_STREAM_MKDIR_RECURSIVE | REPORT_ERRORS, NULL) ? 0 : -1; #else int startpath; int endpath; int i = 0; int pathlen = length; char curpath[128] = {0}; if ('/' != path[0]) { if (getcwd(curpath, sizeof(curpath)) == NULL) { swoole_php_sys_error(E_WARNING, "getcwd() failed."); return -1; } strcat(curpath, "/"); startpath = strlen(curpath); strcat(curpath, path); if (path[pathlen] != '/') { strcat(curpath, "/"); } endpath = strlen(curpath); } else { strcpy(curpath, path); if (path[pathlen] != '/') { strcat(curpath, "/"); } startpath = 1; endpath = strlen(curpath); } for (i = startpath; i < endpath ; i++ ) { if ('/' == curpath[i]) { curpath[i] = '\0'; if (access(curpath, F_OK) != 0) { if (mkdir(curpath, 0755) == -1) { swoole_php_sys_error(E_WARNING, "mkdir(%s, 0755).", path); return -1; } } curpath[i] = '/'; } } return 0; #endif } int php_swoole_task_pack(swEventData *task, zval *data TSRMLS_DC) { smart_str serialized_data = { 0 }; php_serialize_data_t var_hash; #if PHP_MAJOR_VERSION >= 7 zend_string *serialized_string = NULL; #endif task->info.type = SW_EVENT_TASK; //field fd save task_id task->info.fd = php_swoole_task_id++; if (unlikely(php_swoole_task_id >= SW_MAX_INT)) { php_swoole_task_id = 0; } //field from_id save the worker_id task->info.from_id = SwooleWG.id; swTask_type(task) = 0; char *task_data_str; int task_data_len = 0; //need serialize if (SW_Z_TYPE_P(data) != IS_STRING) { //serialize swTask_type(task) |= SW_TASK_SERIALIZE; #if PHP_MAJOR_VERSION >= 7 if (SWOOLE_G(fast_serialize)) { serialized_string = php_swoole_serialize(data); task_data_str = serialized_string->val; task_data_len = serialized_string->len; } else #endif { PHP_VAR_SERIALIZE_INIT(var_hash); sw_php_var_serialize(&serialized_data, data, &var_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(var_hash); #if PHP_MAJOR_VERSION < 7 task_data_str = serialized_data.c; task_data_len = serialized_data.len; #else if (!serialized_data.s) { return -1; } task_data_str = serialized_data.s->val; task_data_len = serialized_data.s->len; #endif } } else { task_data_str = Z_STRVAL_P(data); task_data_len = Z_STRLEN_P(data); } if (task_data_len >= SW_IPC_MAX_SIZE - sizeof(task->info)) { if (swTaskWorker_large_pack(task, task_data_str, task_data_len) < 0) { swoole_php_fatal_error(E_WARNING, "large task pack failed."); task->info.fd = SW_ERR; task->info.len = 0; } } else { memcpy(task->data, task_data_str, task_data_len); task->info.len = task_data_len; } #if PHP_MAJOR_VERSION >= 7 if (SWOOLE_G(fast_serialize) && serialized_string) { zend_string_release(serialized_string); } else #endif { smart_str_free(&serialized_data); } return task->info.fd; } void php_swoole_get_recv_data(zval *zdata, swEventData *req, char *header, uint32_t header_length) { char *data_ptr = NULL; int data_len; #ifdef SW_USE_RINGBUFFER swPackage package; if (req->info.type == SW_EVENT_PACKAGE) { memcpy(&package, req->data, sizeof (package)); data_ptr = package.data; data_len = package.length; } #else if (req->info.type == SW_EVENT_PACKAGE_END) { swString *worker_buffer = swWorker_get_buffer(SwooleG.serv, req->info.from_id); data_ptr = worker_buffer->str; data_len = worker_buffer->length; } #endif else { data_ptr = req->data; data_len = req->info.len; } if (header_length >= data_len) { SW_ZVAL_STRING(zdata, "", 1); } else { SW_ZVAL_STRINGL(zdata, data_ptr + header_length, data_len - header_length, 1); } if (header_length > 0) { memcpy(header, data_ptr, header_length); } #ifdef SW_USE_RINGBUFFER if (req->info.type == SW_EVENT_PACKAGE) { swReactorThread *thread = swServer_get_thread(SwooleG.serv, req->info.from_id); thread->buffer_input->free(thread->buffer_input, data_ptr); } #endif } int php_swoole_get_send_data(zval *zdata, char **str TSRMLS_DC) { int length; if (SW_Z_TYPE_P(zdata) == IS_OBJECT) { if (!instanceof_function(Z_OBJCE_P(zdata), swoole_buffer_class_entry_ptr TSRMLS_CC)) { goto convert; } swString *str_buffer = swoole_get_object(zdata); if (!str_buffer->str) { swoole_php_fatal_error(E_WARNING, "swoole_buffer object is empty."); return SW_ERR; } length = str_buffer->length - str_buffer->offset; *str = str_buffer->str + str_buffer->offset; } else { convert: convert_to_string(zdata); length = Z_STRLEN_P(zdata); *str = Z_STRVAL_P(zdata); } return length; } static sw_inline int php_swoole_check_task_param(swServer *serv, int dst_worker_id TSRMLS_DC) { if (serv->task_worker_num < 1) { swoole_php_fatal_error(E_WARNING, "task method can't be executed, please set 'task_worker_num' > 0."); return SW_ERR; } if (dst_worker_id >= serv->task_worker_num) { swoole_php_fatal_error(E_WARNING, "worker_id must be less than serv->task_worker_num."); return SW_ERR; } if (!swIsWorker()) { swoole_php_fatal_error(E_WARNING, "task method can only be used in the worker process."); return SW_ERR; } return SW_OK; } zval* php_swoole_task_unpack(swEventData *task_result TSRMLS_DC) { zval *result_data, *result_unserialized_data; char *result_data_str; int result_data_len = 0; php_unserialize_data_t var_hash; swString *large_packet; /** * Large result package */ if (swTask_type(task_result) & SW_TASK_TMPFILE) { large_packet = swTaskWorker_large_unpack(task_result); /** * unpack failed */ if (large_packet == NULL) { return NULL; } result_data_str = large_packet->str; result_data_len = large_packet->length; } else { result_data_str = task_result->data; result_data_len = task_result->info.len; } if (swTask_type(task_result) & SW_TASK_SERIALIZE) { SW_ALLOC_INIT_ZVAL(result_unserialized_data); #if PHP_MAJOR_VERSION >= 7 if (SWOOLE_G(fast_serialize)) { if (php_swoole_unserialize(result_data_str, result_data_len, result_unserialized_data, NULL, 0)) { result_data = result_unserialized_data; } else { SW_ALLOC_INIT_ZVAL(result_data); SW_ZVAL_STRINGL(result_data, result_data_str, result_data_len, 1); } } else #endif { PHP_VAR_UNSERIALIZE_INIT(var_hash); //unserialize success if (sw_php_var_unserialize(&result_unserialized_data, (const unsigned char ** ) &result_data_str, (const unsigned char * ) (result_data_str + result_data_len), &var_hash TSRMLS_CC)) { result_data = result_unserialized_data; } //failed else { SW_ALLOC_INIT_ZVAL(result_data); SW_ZVAL_STRINGL(result_data, result_data_str, result_data_len, 1); } PHP_VAR_UNSERIALIZE_DESTROY(var_hash); } } else { SW_ALLOC_INIT_ZVAL(result_data); SW_ZVAL_STRINGL(result_data, result_data_str, result_data_len, 1); } return result_data; } #ifdef SW_COROUTINE static void php_swoole_task_onTimeout(swTimer *timer, swTimer_node *tnode) { swTaskCo *task_co = (swTaskCo *) tnode->data; int i; zval *retval = NULL; zval *result = task_co->result; for (i = 0; i < task_co->count; i++) { if (!zend_hash_index_exists(Z_ARRVAL_P(result), i)) { add_index_bool(result, i, 0); swHashMap_del_int(task_coroutine_map, task_co->list[i]); } } php_context *context = &task_co->context; int ret = coro_resume(context, result, &retval); if (ret == CORO_END && retval) { sw_zval_ptr_dtor(&retval); } sw_zval_free(result); efree(task_co); } #endif static zval* php_swoole_server_add_port(swServer *serv, swListenPort *port TSRMLS_DC) { zval *port_object; SW_ALLOC_INIT_ZVAL(port_object); object_init_ex(port_object, swoole_server_port_class_entry_ptr); server_port_list.zobjects[server_port_list.num++] = port_object; swoole_server_port_property *property = emalloc(sizeof(swoole_server_port_property)); bzero(property, sizeof(swoole_server_port_property)); swoole_set_property(port_object, 0, property); swoole_set_object(port_object, port); property->serv = serv; zend_update_property_string(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("host"), port->host TSRMLS_CC); zend_update_property_long(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("port"), port->port TSRMLS_CC); zend_update_property_long(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("type"), port->type TSRMLS_CC); zend_update_property_long(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("sock"), port->sock TSRMLS_CC); #ifdef HAVE_PCRE zval *connection_iterator; SW_MAKE_STD_ZVAL(connection_iterator); object_init_ex(connection_iterator, swoole_connection_iterator_class_entry_ptr); zend_update_property(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("connections"), connection_iterator TSRMLS_CC); swConnectionIterator *i = emalloc(sizeof(swConnectionIterator)); bzero(i, sizeof(swConnectionIterator)); i->port = port; i->serv = serv; swoole_set_object(connection_iterator, i); #endif add_next_index_zval(server_port_list.zports, port_object); return port_object; } void php_swoole_server_before_start(swServer *serv, zval *zobject TSRMLS_DC) { /** * create swoole server */ if (swServer_create(serv) < 0) { swoole_php_fatal_error(E_ERROR, "failed to create the server. Error: %s", sw_error); return; } swTrace("Create swoole_server host=%s, port=%d, mode=%d, type=%d", serv->listen_list->host, (int) serv->listen_list->port, serv->factory_mode, (int) serv->listen_list->type); sw_zval_add_ref(&zobject); serv->ptr2 = sw_zval_dup(zobject); #ifdef SW_COROUTINE coro_init(TSRMLS_C); if (serv->send_yield) { send_coroutine_map = swHashMap_new(SW_HASHMAP_INIT_BUCKET_N, NULL); if (send_coroutine_map == NULL) { swoole_php_fatal_error(E_ERROR, "failed to create send_coroutine_map. Error: %s", sw_error); } if (serv->onClose == NULL) { serv->onClose = php_swoole_onClose; } } #endif /** * Master Process ID */ zend_update_property_long(swoole_server_class_entry_ptr, zobject, ZEND_STRL("master_pid"), getpid() TSRMLS_CC); zval *zsetting = sw_zend_read_property(swoole_server_class_entry_ptr, zobject, ZEND_STRL("setting"), 1 TSRMLS_CC); if (zsetting == NULL || ZVAL_IS_NULL(zsetting)) { SW_ALLOC_INIT_ZVAL(zsetting); array_init(zsetting); #ifdef HT_ALLOW_COW_VIOLATION HT_ALLOW_COW_VIOLATION(Z_ARRVAL_P(zsetting)); #endif zend_update_property(swoole_server_class_entry_ptr, zobject, ZEND_STRL("setting"), zsetting TSRMLS_CC); } if (!zend_hash_str_exists(Z_ARRVAL_P(zsetting), ZEND_STRL("worker_num"))) { add_assoc_long(zsetting, "worker_num", serv->worker_num); } if (!zend_hash_str_exists(Z_ARRVAL_P(zsetting), ZEND_STRL("task_worker_num"))) { add_assoc_long(zsetting, "task_worker_num", serv->task_worker_num); } if (!zend_hash_str_exists(Z_ARRVAL_P(zsetting), ZEND_STRL("buffer_output_size"))) { add_assoc_long(zsetting, "buffer_output_size", serv->buffer_output_size); } if (!zend_hash_str_exists(Z_ARRVAL_P(zsetting), ZEND_STRL("max_connection"))) { add_assoc_long(zsetting, "max_connection", serv->max_connection); } #ifdef HAVE_PTRACE //trace request if (serv->request_slowlog_file && (serv->trace_event_worker || serv->task_worker_num > 0)) { serv->manager_alarm = serv->request_slowlog_timeout; if (swServer_add_hook(serv, SW_SERVER_HOOK_MANAGER_TIMER, php_swoole_trace_check, 1) < 0) { swoole_php_fatal_error(E_ERROR, "Unable to add server hook."); return; } } #endif int i; zval *retval = NULL; zval *port_object; zval *port_setting; for (i = 1; i < server_port_list.num; i++) { port_object = server_port_list.zobjects[i]; port_setting = sw_zend_read_property(swoole_server_port_class_entry_ptr, port_object, ZEND_STRL("setting"), 1 TSRMLS_CC); //use swoole_server->setting if (port_setting == NULL || ZVAL_IS_NULL(port_setting)) { sw_zval_add_ref(&port_setting); sw_zval_add_ref(&port_object); sw_zend_call_method_with_1_params(&port_object, swoole_server_port_class_entry_ptr, NULL, "set", &retval, zsetting); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } } } void php_swoole_register_callback(swServer *serv) { /* * optional callback */ if (php_sw_server_callbacks[SW_SERVER_CB_onStart] != NULL) { serv->onStart = php_swoole_onStart; } serv->onShutdown = php_swoole_onShutdown; /** * require callback, set the master/manager/worker PID */ serv->onWorkerStart = php_swoole_onWorkerStart; if (php_sw_server_callbacks[SW_SERVER_CB_onWorkerStop] != NULL) { serv->onWorkerStop = php_swoole_onWorkerStop; } if (php_sw_server_callbacks[SW_SERVER_CB_onWorkerExit] != NULL) { serv->onWorkerExit = php_swoole_onWorkerExit; } /** * UDP Packet */ if (php_sw_server_callbacks[SW_SERVER_CB_onPacket] != NULL) { serv->onPacket = php_swoole_onPacket; } /** * Task Worker */ if (php_sw_server_callbacks[SW_SERVER_CB_onTask] != NULL) { serv->onTask = php_swoole_onTask; } if (php_sw_server_callbacks[SW_SERVER_CB_onFinish] != NULL) { serv->onFinish = php_swoole_onFinish; } if (php_sw_server_callbacks[SW_SERVER_CB_onWorkerError] != NULL) { serv->onWorkerError = php_swoole_onWorkerError; } if (php_sw_server_callbacks[SW_SERVER_CB_onManagerStart] != NULL) { serv->onManagerStart = php_swoole_onManagerStart; } if (php_sw_server_callbacks[SW_SERVER_CB_onManagerStop] != NULL) { serv->onManagerStop = php_swoole_onManagerStop; } if (php_sw_server_callbacks[SW_SERVER_CB_onPipeMessage] != NULL) { serv->onPipeMessage = php_swoole_onPipeMessage; } if (php_sw_server_callbacks[SW_SERVER_CB_onBufferFull] != NULL) { serv->onBufferFull = php_swoole_onBufferFull; } if (php_sw_server_callbacks[SW_SERVER_CB_onBufferEmpty] != NULL || serv->send_yield) { serv->onBufferEmpty = php_swoole_onBufferEmpty; } } static int php_swoole_task_finish(swServer *serv, zval *data TSRMLS_DC) { int flags = 0; smart_str serialized_data = {0}; php_serialize_data_t var_hash; char *data_str; int data_len = 0; int ret; #if PHP_MAJOR_VERSION >= 7 zend_string *serialized_string = NULL; #endif //need serialize if (SW_Z_TYPE_P(data) != IS_STRING) { //serialize flags |= SW_TASK_SERIALIZE; #if PHP_MAJOR_VERSION >= 7 if (SWOOLE_G(fast_serialize)) { serialized_string = php_swoole_serialize(data); data_str = serialized_string->val; data_len = serialized_string->len; } else #endif { PHP_VAR_SERIALIZE_INIT(var_hash); sw_php_var_serialize(&serialized_data, data, &var_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(var_hash); #if PHP_MAJOR_VERSION<7 data_str = serialized_data.c; data_len = serialized_data.len; #else data_str = serialized_data.s->val; data_len = serialized_data.s->len; #endif } } else { data_str = Z_STRVAL_P(data); data_len = Z_STRLEN_P(data); } ret = swTaskWorker_finish(serv, data_str, data_len, flags); #if PHP_MAJOR_VERSION >= 7 if (SWOOLE_G(fast_serialize) && serialized_string) { zend_string_release(serialized_string); } else #endif { smart_str_free(&serialized_data); } return ret; } static void php_swoole_onPipeMessage(swServer *serv, swEventData *req) { SWOOLE_GET_TSRMLS; zval *zserv = (zval *) serv->ptr2; zval *zworker_id; zval *retval = NULL; SW_MAKE_STD_ZVAL(zworker_id); ZVAL_LONG(zworker_id, (long) req->info.from_id); zval *zdata = php_swoole_task_unpack(req TSRMLS_CC); if (zdata == NULL) { return; } if (SwooleG.enable_coroutine) { zval *args[3]; args[0] = zserv; args[1] = zworker_id; args[2] = zdata; zend_fcall_info_cache *cache = php_sw_server_caches[SW_SERVER_CB_onPipeMessage]; int ret = coro_create(cache, args, 3, &retval, NULL, NULL); if (ret < 0) { sw_zval_ptr_dtor(&zworker_id); sw_zval_free(zdata); if (ret == CORO_LIMIT) { swWarn("Failed to handle onPipeMessage. Coroutine limited"); } return; } } else { zval **args[3]; args[0] = &zserv; args[1] = &zworker_id; args[2] = &zdata; swTrace("PipeMessage: fd=%d|len=%d|from_id=%d|data=%s\n", req->info.fd, req->info.len, req->info.from_id, req->data); if (sw_call_user_function_fast(php_sw_server_callbacks[SW_SERVER_CB_onPipeMessage], php_sw_server_caches[SW_SERVER_CB_onPipeMessage], &retval, 3, args TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onPipeMessage handler error."); } } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zworker_id); sw_zval_free(zdata); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } int php_swoole_onReceive(swServer *serv, swEventData *req) { swFactory *factory = &serv->factory; zval *zserv = (zval *) serv->ptr2; zval *zfd; zval *zfrom_id; zval *zdata; zval *retval = NULL; SWOOLE_GET_TSRMLS; php_swoole_udp_t udp_info; swDgramPacket *packet; SW_MAKE_STD_ZVAL(zfd); SW_MAKE_STD_ZVAL(zfrom_id); SW_MAKE_STD_ZVAL(zdata); //dgram if (swEventData_is_dgram(req->info.type)) { swoole_php_error(E_DEPRECATED, "The udp onReceive callback is deprecated, use onPacket instead."); swString *buffer = swWorker_get_buffer(serv, req->info.from_id); packet = (swDgramPacket*) buffer->str; //udp ipv4 if (req->info.type == SW_EVENT_UDP) { udp_info.from_fd = req->info.from_fd; udp_info.port = packet->port; memcpy(&udp_server_socket, &udp_info, sizeof(udp_server_socket)); factory->last_from_id = udp_server_socket; swTrace("SendTo: from_id=%d|from_fd=%d", (uint16_t) req->info.from_id, req->info.from_fd); SW_ZVAL_STRINGL(zdata, packet->data, packet->length, 1); ZVAL_LONG(zfrom_id, (long ) udp_server_socket); ZVAL_LONG(zfd, (long ) packet->addr.v4.s_addr); } //udp ipv6 else if (req->info.type == SW_EVENT_UDP6) { udp_info.from_fd = req->info.from_fd; udp_info.port = packet->port; memcpy(&dgram_server_socket, &udp_info, sizeof(udp_server_socket)); factory->last_from_id = dgram_server_socket; swTrace("SendTo: from_id=%d|from_fd=%d", (uint16_t) req->info.from_id, req->info.from_fd); ZVAL_LONG(zfrom_id, (long ) dgram_server_socket); char tmp[INET6_ADDRSTRLEN]; inet_ntop(AF_INET6, &packet->addr.v6, tmp, sizeof(tmp)); SW_ZVAL_STRING(zfd, tmp, 1); SW_ZVAL_STRINGL(zdata, packet->data, packet->length, 1); } //unix dgram else { SW_ZVAL_STRINGL(zfd, packet->data, packet->addr.un.path_length, 1); SW_ZVAL_STRINGL(zdata, packet->data + packet->addr.un.path_length, packet->length - packet->addr.un.path_length, 1); ZVAL_LONG(zfrom_id, (long ) req->info.from_fd); dgram_server_socket = req->info.from_fd; } } //stream else { ZVAL_LONG(zfrom_id, (long ) req->info.from_id); ZVAL_LONG(zfd, (long ) req->info.fd); php_swoole_get_recv_data(zdata, req, NULL, 0); } if (SwooleG.enable_coroutine) { zval *args[4]; args[0] = zserv; args[1] = zfd; args[2] = zfrom_id; args[3] = zdata; zend_fcall_info_cache *cache = php_swoole_server_get_cache(serv, req->info.from_fd, SW_SERVER_CB_onReceive); int ret = coro_create(cache, args, 4, &retval, NULL, NULL); if (ret < 0) { sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); sw_zval_ptr_dtor(&zdata); if (ret == CORO_LIMIT) { serv->factory.end(&SwooleG.serv->factory, req->info.fd); } return SW_OK; } } else { zval **args[4]; zval *callback = php_swoole_server_get_callback(serv, req->info.from_fd, SW_SERVER_CB_onReceive); if (callback == NULL || ZVAL_IS_NULL(callback)) { swoole_php_fatal_error(E_WARNING, "onReceive callback is null."); return SW_OK; } args[0] = &zserv; args[1] = &zfd; args[2] = &zfrom_id; args[3] = &zdata; zend_fcall_info_cache *fci_cache = php_swoole_server_get_cache(serv, req->info.from_fd, SW_SERVER_CB_onReceive); if (sw_call_user_function_fast(callback, fci_cache, &retval, 4, args TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onReceive handler error."); } } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); sw_zval_ptr_dtor(&zdata); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } return SW_OK; } int php_swoole_onPacket(swServer *serv, swEventData *req) { zval *zserv = (zval *) serv->ptr2; zval *zdata; zval *zaddr; zval *retval = NULL; swDgramPacket *packet; SWOOLE_GET_TSRMLS; SW_MAKE_STD_ZVAL(zdata); SW_MAKE_STD_ZVAL(zaddr); array_init(zaddr); swString *buffer = swWorker_get_buffer(serv, req->info.from_id); packet = (swDgramPacket*) buffer->str; add_assoc_long(zaddr, "server_socket", req->info.from_fd); swConnection *from_sock = swServer_connection_get(serv, req->info.from_fd); if (from_sock) { add_assoc_long(zaddr, "server_port", swConnection_get_port(from_sock)); } char address[INET6_ADDRSTRLEN]; //udp ipv4 if (req->info.type == SW_EVENT_UDP) { inet_ntop(AF_INET, &packet->addr.v4, address, sizeof(address)); sw_add_assoc_string(zaddr, "address", address, 1); add_assoc_long(zaddr, "port", packet->port); SW_ZVAL_STRINGL(zdata, packet->data, packet->length, 1); } //udp ipv6 else if (req->info.type == SW_EVENT_UDP6) { inet_ntop(AF_INET6, &packet->addr.v6, address, sizeof(address)); sw_add_assoc_string(zaddr, "address", address, 1); add_assoc_long(zaddr, "port", packet->port); SW_ZVAL_STRINGL(zdata, packet->data, packet->length, 1); } //unix dgram else if (req->info.type == SW_EVENT_UNIX_DGRAM) { sw_add_assoc_stringl(zaddr, "address", packet->data, packet->addr.un.path_length, 1); SW_ZVAL_STRINGL(zdata, packet->data + packet->addr.un.path_length, packet->length - packet->addr.un.path_length, 1); dgram_server_socket = req->info.from_fd; } if (SwooleG.enable_coroutine) { zval *args[3]; args[0] = zserv; args[1] = zdata; args[2] = zaddr; zend_fcall_info_cache *cache = php_swoole_server_get_cache(serv, req->info.from_fd, SW_SERVER_CB_onPacket); int ret = coro_create(cache, args, 3, &retval, NULL, NULL); if (ret < 0) { sw_zval_ptr_dtor(&zaddr); sw_zval_ptr_dtor(&zdata); return SW_OK; } } else { zval **args[3]; args[0] = &zserv; args[1] = &zdata; args[2] = &zaddr; zval *callback = php_swoole_server_get_callback(serv, req->info.from_fd, SW_SERVER_CB_onPacket); if (callback == NULL || ZVAL_IS_NULL(callback)) { swoole_php_fatal_error(E_WARNING, "onPacket callback is null."); return SW_OK; } if (sw_call_user_function_ex(EG(function_table), NULL, callback, &retval, 3, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onPacket handler error."); } } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zaddr); sw_zval_ptr_dtor(&zdata); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } return SW_OK; } static int php_swoole_onTask(swServer *serv, swEventData *req) { zval *zserv = (zval *) serv->ptr2; zval **args[4]; zval *zfd; zval *zfrom_id; sw_atomic_fetch_sub(&serv->stats->tasking_num, 1); zval *retval = NULL; SWOOLE_GET_TSRMLS; SW_MAKE_STD_ZVAL(zfd); ZVAL_LONG(zfd, (long) req->info.fd); SW_MAKE_STD_ZVAL(zfrom_id); ZVAL_LONG(zfrom_id, (long) req->info.from_id); zval *zdata = php_swoole_task_unpack(req TSRMLS_CC); if (zdata == NULL) { return SW_ERR; } args[0] = &zserv; args[1] = &zfd; args[2] = &zfrom_id; args[3] = &zdata; zend_fcall_info_cache *fci_cache = php_sw_server_caches[SW_SERVER_CB_onTask]; if (sw_call_user_function_fast(php_sw_server_callbacks[SW_SERVER_CB_onTask], fci_cache, &retval, 4, args TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onTask handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); sw_zval_free(zdata); if (retval) { if (SW_Z_TYPE_P(retval) != IS_NULL) { php_swoole_task_finish(serv, retval TSRMLS_CC); } sw_zval_ptr_dtor(&retval); } return SW_OK; } static int php_swoole_onFinish(swServer *serv, swEventData *req) { zval *zserv = (zval *) serv->ptr2; zval **args[3]; zval *ztask_id; zval *zdata; zval *retval = NULL; SWOOLE_GET_TSRMLS; SW_MAKE_STD_ZVAL(ztask_id); ZVAL_LONG(ztask_id, (long) req->info.fd); zdata = php_swoole_task_unpack(req TSRMLS_CC); if (zdata == NULL) { return SW_ERR; } #ifdef SW_COROUTINE if (swTask_type(req) & SW_TASK_COROUTINE) { int task_id = req->info.fd; swTaskCo *task_co = swHashMap_find_int(task_coroutine_map, task_id); if (task_co == NULL) { swoole_php_fatal_error(E_WARNING, "task[%d] has expired.", task_id); fail: sw_zval_free(zdata); return SW_OK; } int i, task_index = -1; zval *result = task_co->result; for (i = 0; i < task_co->count; i++) { if (task_co->list[i] == task_id) { task_index = i; break; } } if (task_index < 0) { swoole_php_fatal_error(E_WARNING, "task[%d] is invalid.", task_id); goto fail; } add_index_zval(result, task_index, zdata); #if PHP_MAJOR_VERSION >= 7 efree(zdata); #endif swHashMap_del_int(task_coroutine_map, task_id); if (php_swoole_array_length(result) == task_co->count) { if (task_co->timer) { swTimer_del(&SwooleG.timer, task_co->timer); task_co->timer = NULL; } php_context *context = &task_co->context; int ret = coro_resume(context, result, &retval); if (ret == CORO_END && retval) { sw_zval_ptr_dtor(&retval); } sw_zval_free(result); efree(task_co); } return SW_OK; } #endif args[0] = &zserv; args[1] = &ztask_id; args[2] = &zdata; zval *callback = NULL; if (swTask_type(req) & SW_TASK_CALLBACK) { callback = swHashMap_find_int(task_callbacks, req->info.fd); if (callback == NULL) { swTask_type(req) = swTask_type(req) & (~SW_TASK_CALLBACK); } } if (callback == NULL) { callback = php_sw_server_callbacks[SW_SERVER_CB_onFinish]; } if (sw_call_user_function_ex(EG(function_table), NULL, callback, &retval, 3, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onFinish handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&ztask_id); sw_zval_free(zdata); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } if (swTask_type(req) & SW_TASK_CALLBACK) { swHashMap_del_int(task_callbacks, req->info.fd); sw_zval_free(callback); } return SW_OK; } static void php_swoole_onStart(swServer *serv) { SwooleG.lock.lock(&SwooleG.lock); SWOOLE_GET_TSRMLS; zval *zserv = (zval *) serv->ptr2; zval **args[1]; zval *retval = NULL; pid_t manager_pid = serv->factory_mode == SW_MODE_PROCESS ? serv->gs->manager_pid : 0; zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("master_pid"), serv->gs->master_pid TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("manager_pid"), manager_pid TSRMLS_CC); args[0] = &zserv; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onStart], &retval, 1, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onStart handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval != NULL) { sw_zval_ptr_dtor(&retval); } SwooleG.lock.unlock(&SwooleG.lock); } static void php_swoole_onManagerStart(swServer *serv) { SWOOLE_GET_TSRMLS; zval *zserv = (zval *) serv->ptr2; zval **args[1]; zval *retval = NULL; pid_t manager_pid = serv->factory_mode == SW_MODE_PROCESS ? serv->gs->manager_pid : 0; zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("master_pid"), serv->gs->master_pid TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("manager_pid"), manager_pid TSRMLS_CC); args[0] = &zserv; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onManagerStart], &retval, 1, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onManagerStart handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onManagerStop(swServer *serv) { SWOOLE_GET_TSRMLS; zval *zserv = (zval *) serv->ptr2; zval **args[1]; zval *retval = NULL; args[0] = &zserv; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onManagerStop], &retval, 1, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onManagerStop handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onShutdown(swServer *serv) { SwooleG.lock.lock(&SwooleG.lock); zval *zserv = (zval *) serv->ptr2; zval **args[1]; zval *retval = NULL; args[0] = &zserv; SWOOLE_GET_TSRMLS; if (php_sw_server_callbacks[SW_SERVER_CB_onShutdown] != NULL) { if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onShutdown], &retval, 1, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onShutdown handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } SwooleG.lock.unlock(&SwooleG.lock); } static void php_swoole_onWorkerStart_coroutine(zval *zserv, zval *zworker_id) { zval *retval = NULL; zval *args[2]; args[0] = zserv; args[1] = zworker_id; zend_fcall_info_cache *cache = php_sw_server_caches[SW_SERVER_CB_onWorkerStart]; int ret = coro_create(cache, args, 2, &retval, NULL, NULL); if (ret < 0) { sw_zval_ptr_dtor(&zworker_id); if (ret == CORO_LIMIT) { swWarn("Failed to handle onWorkerStart. Coroutine limited."); } return; } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onWorkerStart_callback(zval *zserv, zval *zworker_id) { zval *retval = NULL; zval **args[2]; args[0] = &zserv; args[1] = &zworker_id; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onWorkerStart], &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onWorkerStart handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onWorkerStart(swServer *serv, int worker_id) { zval *zserv = (zval *) serv->ptr2; zval *zworker_id; SW_MAKE_STD_ZVAL(zworker_id); ZVAL_LONG(zworker_id, worker_id); /** * Master Process ID */ zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("master_pid"), serv->gs->master_pid TSRMLS_CC); /** * Manager Process ID */ zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("manager_pid"), serv->gs->manager_pid TSRMLS_CC); /** * Worker ID */ zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("worker_id"), worker_id TSRMLS_CC); /** * Is a task worker? */ if (worker_id >= serv->worker_num) { zend_update_property_bool(swoole_server_class_entry_ptr, zserv, ZEND_STRL("taskworker"), 1 TSRMLS_CC); } else { zend_update_property_bool(swoole_server_class_entry_ptr, zserv, ZEND_STRL("taskworker"), 0 TSRMLS_CC); } /** * Worker Process ID */ zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("worker_pid"), getpid() TSRMLS_CC); /** * Have not set the event callback */ if (php_sw_server_callbacks[SW_SERVER_CB_onWorkerStart] == NULL) { return; } if (SwooleG.enable_coroutine && worker_id < serv->worker_num) { php_swoole_onWorkerStart_coroutine(zserv, zworker_id); } else { php_swoole_onWorkerStart_callback(zserv, zworker_id); } } static void php_swoole_onWorkerStop(swServer *serv, int worker_id) { if (SwooleWG.shutdown) { return; } SwooleWG.shutdown = 1; zval *zobject = (zval *) serv->ptr2; zval *zworker_id; zval **args[2]; zval *retval = NULL; SW_MAKE_STD_ZVAL(zworker_id); ZVAL_LONG(zworker_id, worker_id); SWOOLE_GET_TSRMLS; args[0] = &zobject; args[1] = &zworker_id; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onWorkerStop], &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onWorkerStop handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zworker_id); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onWorkerExit(swServer *serv, int worker_id) { zval *zobject = (zval *) serv->ptr2; zval *zworker_id; zval **args[2]; zval *retval = NULL; SW_MAKE_STD_ZVAL(zworker_id); ZVAL_LONG(zworker_id, worker_id); SWOOLE_GET_TSRMLS; args[0] = &zobject; args[1] = &zworker_id; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onWorkerExit], &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onWorkerStop handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zworker_id); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } static void php_swoole_onUserWorkerStart(swServer *serv, swWorker *worker) { SWOOLE_GET_TSRMLS; zval *object = worker->ptr; zend_update_property_long(swoole_process_class_entry_ptr, object, ZEND_STRL("id"), SwooleWG.id TSRMLS_CC); zval *zserv = (zval *) serv->ptr2; zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("master_pid"), serv->gs->master_pid TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, zserv, ZEND_STRL("manager_pid"), serv->gs->manager_pid TSRMLS_CC); php_swoole_process_start(worker, object TSRMLS_CC); } static void php_swoole_onWorkerError(swServer *serv, int worker_id, pid_t worker_pid, int exit_code, int signo) { zval *zobject = (zval *) serv->ptr2; zval *zworker_id, *zworker_pid, *zexit_code, *zsigno; zval **args[5]; zval *retval = NULL; SW_MAKE_STD_ZVAL(zworker_id); ZVAL_LONG(zworker_id, worker_id); SW_MAKE_STD_ZVAL(zworker_pid); ZVAL_LONG(zworker_pid, worker_pid); SW_MAKE_STD_ZVAL(zexit_code); ZVAL_LONG(zexit_code, exit_code); SW_MAKE_STD_ZVAL(zsigno); ZVAL_LONG(zsigno, signo); SWOOLE_GET_TSRMLS; args[0] = &zobject; args[1] = &zworker_id; args[2] = &zworker_pid; args[3] = &zexit_code; args[4] = &zsigno; if (sw_call_user_function_ex(EG(function_table), NULL, php_sw_server_callbacks[SW_SERVER_CB_onWorkerError], &retval, 5, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_fatal_error(E_WARNING, "onWorkerError handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zworker_id); sw_zval_ptr_dtor(&zworker_pid); sw_zval_ptr_dtor(&zexit_code); sw_zval_ptr_dtor(&zsigno); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } #ifdef SW_COROUTINE static void php_swoole_onConnect_finish(void *param) { swServer *serv = SwooleG.serv; swTrace("onConnect finish and send confirm"); swServer_tcp_feedback(serv, (uint32_t) (long) param, SW_EVENT_CONFIRM); } #endif void php_swoole_onConnect(swServer *serv, swDataHead *info) { zval *zserv = (zval *) serv->ptr2; zval *zfd; zval *zfrom_id; zval *retval = NULL; SWOOLE_GET_TSRMLS; SW_MAKE_STD_ZVAL(zfd); ZVAL_LONG(zfd, info->fd); SW_MAKE_STD_ZVAL(zfrom_id); ZVAL_LONG(zfrom_id, info->from_id); if (SwooleG.enable_coroutine) { zval *args[3]; args[0] = zserv; args[1] = zfd; args[2] = zfrom_id; int ret; zend_fcall_info_cache *cache = php_swoole_server_get_cache(serv, info->from_fd, SW_SERVER_CB_onConnect); if (cache == NULL) { return; } if (serv->enable_delay_receive) { ret = coro_create(cache, args, 3, &retval, php_swoole_onConnect_finish, (void*) (long) info->fd); } else { ret = coro_create(cache, args, 3, &retval, NULL, NULL); } if (ret < 0) { sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); return; } } else { zval **args[3]; args[0] = &zserv; args[1] = &zfd; args[2] = &zfrom_id; zval *callback = php_swoole_server_get_callback(serv, info->from_fd, SW_SERVER_CB_onConnect); if (callback == NULL || ZVAL_IS_NULL(callback)) { return; } if (sw_call_user_function_ex(EG(function_table), NULL, callback, &retval, 3, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_error(E_WARNING, "onConnect handler error."); } } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } void php_swoole_onClose(swServer *serv, swDataHead *info) { zval *zserv = (zval *) serv->ptr2; zval *zfd; zval *zfrom_id; zval *retval = NULL; SWOOLE_GET_TSRMLS; if (SwooleG.enable_coroutine && serv->send_yield) { swLinkedList *coros_list = swHashMap_find_int(send_coroutine_map, info->fd); if (coros_list) { php_context *context = swLinkedList_shift(coros_list); if (context == NULL) { swoole_php_fatal_error(E_WARNING, "Nothing can coroResume."); } else { SwooleG.error = ECONNRESET; zval_ptr_dtor(&context->coro_params); ZVAL_NULL(&context->coro_params); //resume coroutine php_swoole_server_send_resume(serv, context, info->fd); //free memory swLinkedList_free(coros_list); swHashMap_del_int(send_coroutine_map, info->fd); } } } SW_MAKE_STD_ZVAL(zfd); ZVAL_LONG(zfd, info->fd); SW_MAKE_STD_ZVAL(zfrom_id); ZVAL_LONG(zfrom_id, info->from_id); if (SwooleG.enable_coroutine) { zval *args[3]; args[0] = zserv; args[1] = zfd; args[2] = zfrom_id; zend_fcall_info_cache *cache = php_swoole_server_get_cache(serv, info->from_fd, SW_SERVER_CB_onClose); if (cache == NULL) { return; } int ret = coro_create(cache, args, 3, &retval, NULL, NULL); sw_zval_ptr_dtor(&zfd); sw_zval_ptr_dtor(&zfrom_id); if (ret < 0) { return; } } else { zval **args[3]; args[0] = &zserv; args[1] = &zfd; args[2] = &zfrom_id; zval *callback = php_swoole_server_get_callback(serv, info->from_fd, SW_SERVER_CB_onClose); if (callback == NULL || ZVAL_IS_NULL(callback)) { return; } if (sw_call_user_function_ex(EG(function_table), NULL, callback, &retval, 3, args, 0, NULL TSRMLS_CC) == FAILURE) { swoole_php_error(E_WARNING, "onClose handler error."); } } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } void php_swoole_onBufferFull(swServer *serv, swDataHead *info) { zval *zserv = (zval *) serv->ptr2; zval *zfd; zval **args[2]; zval *retval = NULL; zval *callback = php_swoole_server_get_callback(serv, info->from_fd, SW_SERVER_CB_onBufferFull); if (!callback) { return; } SWOOLE_GET_TSRMLS; SW_MAKE_STD_ZVAL(zfd); ZVAL_LONG(zfd, info->fd); args[0] = &zserv; args[1] = &zfd; zend_fcall_info_cache *fci_cache = php_swoole_server_get_cache(serv, info->from_fd, SW_SERVER_CB_onBufferFull); if (sw_call_user_function_fast(callback, fci_cache, &retval, 2, args TSRMLS_CC) == FAILURE) { swoole_php_error(E_WARNING, "onBufferFull handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zfd); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } #ifdef SW_COROUTINE static void php_swoole_onSendTimeout(swTimer *timer, swTimer_node *tnode) { php_context *context = (php_context *) tnode->data; zval *zdata = &context->coro_params; zval *result; zval *retval = NULL; SW_MAKE_STD_ZVAL(result); SwooleG.error = EAGAIN; ZVAL_BOOL(result, 0); context->private_data = NULL; int ret = coro_resume(context, result, &retval); if (ret == CORO_END && retval) { sw_zval_ptr_dtor(&retval); } sw_zval_ptr_dtor(&result); sw_zval_ptr_dtor(&zdata); efree(context); } static void php_swoole_server_send_resume(swServer *serv, php_context *context, int fd) { char *data; zval *zdata = &context->coro_params; zval *result; zval *retval = NULL; SW_MAKE_STD_ZVAL(result); if (context->private_data) { swTimer_del(&SwooleG.timer, (swTimer_node *) context->private_data); context->private_data = NULL; } if (ZVAL_IS_NULL(zdata)) { _fail: ZVAL_BOOL(result, 0); } else { int length = php_swoole_get_send_data(zdata, &data TSRMLS_CC); if (length <= 0) { goto _fail; } ZVAL_BOOL(result, swServer_tcp_send(serv, fd, data, length) == SW_OK); } int ret = coro_resume(context, result, &retval); if (ret == CORO_END && retval) { sw_zval_ptr_dtor(&retval); } sw_zval_ptr_dtor(&result); sw_zval_ptr_dtor(&zdata); efree(context); } void php_swoole_server_send_yield(swServer *serv, int fd, zval *zdata, zval *return_value) { swLinkedList *coros_list = swHashMap_find_int(send_coroutine_map, fd); if (coros_list == NULL) { coros_list = swLinkedList_new(2, NULL); if (coros_list == NULL) { RETURN_FALSE; } if (swHashMap_add_int(send_coroutine_map, fd, (void*) coros_list) == SW_ERR) { swLinkedList_free(coros_list); RETURN_FALSE; } } php_context *context = emalloc(sizeof(php_context)); if (swLinkedList_append(coros_list, (void *) context) == SW_ERR) { efree(context); RETURN_FALSE; } if (serv->send_timeout > 0) { php_swoole_check_timer((int) (serv->send_timeout * 1000)); context->private_data = SwooleG.timer.add(&SwooleG.timer, (int) (serv->send_timeout * 1000), 0, context, php_swoole_onSendTimeout); } else { context->private_data = NULL; } context->coro_params = *zdata; coro_save(context); coro_yield(); } #endif void php_swoole_onBufferEmpty(swServer *serv, swDataHead *info) { SWOOLE_GET_TSRMLS; zval *zserv = (zval *) serv->ptr2; zval *zfd; zval **args[2]; zval *retval = NULL; zval *callback; #ifdef SW_COROUTINE if (serv->send_yield == 0) { goto _callback; } swLinkedList *coros_list = swHashMap_find_int(send_coroutine_map, info->fd); if (coros_list) { php_context *context = swLinkedList_shift(coros_list); if (context == NULL) { swoole_php_fatal_error(E_WARNING, "Nothing can coroResume."); goto _callback; } //resume coroutine php_swoole_server_send_resume(serv, context, info->fd); //free memory if (coros_list->num == 0) { swLinkedList_free(coros_list); swHashMap_del_int(send_coroutine_map, info->fd); } } #endif #ifdef SW_COROUTINE _callback: #endif callback = php_swoole_server_get_callback(serv, info->from_fd, SW_SERVER_CB_onBufferEmpty); if (!callback) { return; } SW_MAKE_STD_ZVAL(zfd); ZVAL_LONG(zfd, info->fd); args[0] = &zserv; args[1] = &zfd; zend_fcall_info_cache *fci_cache = php_swoole_server_get_cache(serv, info->from_fd, SW_SERVER_CB_onBufferEmpty); if (sw_call_user_function_fast(callback, fci_cache, &retval, 2, args TSRMLS_CC) == FAILURE) { swoole_php_error(E_WARNING, "onBufferEmpty handler error."); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } sw_zval_ptr_dtor(&zfd); if (retval != NULL) { sw_zval_ptr_dtor(&retval); } } PHP_METHOD(swoole_server, __construct) { zend_size_t host_len = 0; char *serv_host; long sock_type = SW_SOCK_TCP; long serv_port = 0; long serv_mode = SW_MODE_PROCESS; //only cli env if (strcasecmp("cli", sapi_module.name) != 0) { swoole_php_fatal_error(E_ERROR, "swoole_server only can be used in PHP CLI mode."); RETURN_FALSE; } if (SwooleG.main_reactor != NULL) { swoole_php_fatal_error(E_ERROR, "eventLoop has already been created. unable to create swoole_server."); RETURN_FALSE; } if (SwooleG.serv != NULL) { swoole_php_fatal_error(E_WARNING, "server is running. unable to create swoole_server."); RETURN_FALSE; } swServer *serv = sw_malloc(sizeof (swServer)); swServer_init(serv); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lll", &serv_host, &host_len, &serv_port, &serv_mode, &sock_type) == FAILURE) { swoole_php_fatal_error(E_ERROR, "invalid swoole_server parameters."); return; } #ifdef __CYGWIN__ serv_mode = SW_MODE_SINGLE; #elif !defined(SW_USE_THREAD) if (serv_mode == SW_MODE_THREAD || serv_mode == SW_MODE_BASE) { serv_mode = SW_MODE_SINGLE; swoole_php_fatal_error(E_WARNING, "can't use multi-threading in PHP. reset server mode to be SWOOLE_MODE_BASE"); } #endif serv->factory_mode = serv_mode; if (serv->factory_mode == SW_MODE_SINGLE) { serv->worker_num = 1; serv->max_request = 0; } bzero(php_sw_server_callbacks, sizeof (zval*) * PHP_SERVER_CALLBACK_NUM); if (serv_port == 0 && strcasecmp(serv_host, "SYSTEMD") == 0) { if (swserver_add_systemd_socket(serv) <= 0) { swoole_php_fatal_error(E_ERROR, "failed to add systemd socket."); return; } } else { swListenPort *port = swServer_add_port(serv, sock_type, serv_host, serv_port); if (!port) { zend_throw_exception_ex(swoole_exception_class_entry_ptr, errno TSRMLS_CC, "failed to listen server port[%s:%d]. Error: %s[%d].", serv_host, serv_port, strerror(errno), errno); return; } } zval *server_object = getThis(); #ifdef HAVE_PCRE zval *connection_iterator_object; SW_MAKE_STD_ZVAL(connection_iterator_object); object_init_ex(connection_iterator_object, swoole_connection_iterator_class_entry_ptr); zend_update_property(swoole_server_class_entry_ptr, server_object, ZEND_STRL("connections"), connection_iterator_object TSRMLS_CC); swConnectionIterator *i = emalloc(sizeof(swConnectionIterator)); bzero(i, sizeof(swConnectionIterator)); i->serv = serv; swoole_set_object(connection_iterator_object, i); #endif zend_update_property_stringl(swoole_server_class_entry_ptr, server_object, ZEND_STRL("host"), serv_host, host_len TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, server_object, ZEND_STRL("port"), (long) serv->listen_list->port TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, server_object, ZEND_STRL("mode"), serv->factory_mode TSRMLS_CC); zend_update_property_long(swoole_server_class_entry_ptr, server_object, ZEND_STRL("type"), sock_type TSRMLS_CC); swoole_set_object(server_object, serv); zval *ports; SW_ALLOC_INIT_ZVAL(ports); array_init(ports); server_port_list.zports = ports; #ifdef HT_ALLOW_COW_VIOLATION HT_ALLOW_COW_VIOLATION(Z_ARRVAL_P(ports)); #endif swListenPort *ls; LL_FOREACH(serv->listen_list, ls) { php_swoole_server_add_port(serv, ls TSRMLS_CC); } zend_update_property(swoole_server_class_entry_ptr, server_object, ZEND_STRL("ports"), ports TSRMLS_CC); } PHP_METHOD(swoole_server, __destruct) { #if SW_DEBUG_SERVER_DESTRUCT int i; for (i = 0; i < PHP_SERVER_CALLBACK_NUM; i++) { #ifdef PHP_SWOOLE_ENABLE_FASTCALL if (php_sw_server_caches[i]) { efree(php_sw_server_caches[i]); php_sw_server_caches[i] = NULL; } #endif } zval *port_object; for (i = 0; i < server_port_list.num; i++) { port_object = server_port_list.zobjects[i]; efree(port_object); server_port_list.zobjects[i] = NULL; } efree(server_port_list.zports); server_port_list.zports = NULL; #endif } PHP_METHOD(swoole_server, set) { zval *zset = NULL; zval *zobject = getThis(); HashTable *vht; zval *v; swServer *serv = swoole_get_object(zobject); if (serv->gs->start > 0) { swoole_php_fatal_error(E_WARNING, "server is running. unable to execute function 'swoole_server_set'."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zset) == FAILURE) { return; } if (Z_TYPE_P(zset) != IS_ARRAY) { RETURN_FALSE; } php_swoole_array_separate(zset); vht = Z_ARRVAL_P(zset); //chroot if (php_swoole_array_get_value(vht, "chroot", v)) { convert_to_string(v); if (SwooleG.chroot) { sw_free(SwooleG.chroot); } SwooleG.chroot = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } //user if (php_swoole_array_get_value(vht, "user", v)) { convert_to_string(v); if (SwooleG.user) { sw_free(SwooleG.user); } SwooleG.user = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } //group if (php_swoole_array_get_value(vht, "group", v)) { convert_to_string(v); if (SwooleG.group) { sw_free(SwooleG.group); } SwooleG.group = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } //daemonize if (php_swoole_array_get_value(vht, "daemonize", v)) { convert_to_boolean(v); serv->daemonize = Z_BVAL_P(v); } #ifdef SW_DEBUG //debug if (php_swoole_array_get_value(vht, "debug_mode", v)) { convert_to_boolean(v); if (Z_BVAL_P(v)) { SwooleG.log_level = 0; } } #endif if (php_swoole_array_get_value(vht, "trace_flags", v)) { convert_to_long(v); SwooleG.trace_flags = (int32_t) Z_LVAL_P(v); } //pid file if (php_swoole_array_get_value(vht, "pid_file", v)) { convert_to_string(v); if (serv->pid_file) { sw_free(serv->pid_file); } serv->pid_file = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } //reactor thread num if (php_swoole_array_get_value(vht, "reactor_num", v)) { convert_to_long(v); serv->reactor_num = (int) Z_LVAL_P(v); if (serv->reactor_num <= 0) { serv->reactor_num = SwooleG.cpu_num; } } //worker_num if (php_swoole_array_get_value(vht, "worker_num", v)) { convert_to_long(v); serv->worker_num = (int) Z_LVAL_P(v); if (serv->worker_num <= 0) { serv->worker_num = SwooleG.cpu_num; } } //max wait time if (php_swoole_array_get_value(vht, "max_wait_time", v)) { convert_to_long(v); serv->max_wait_time = (uint32_t) Z_LVAL_P(v); } #ifdef SW_COROUTINE if (php_swoole_array_get_value(vht, "enable_coroutine", v)) { convert_to_double(v); SwooleG.enable_coroutine = Z_DVAL_P(v); } if (php_swoole_array_get_value(vht, "max_coro_num", v) || php_swoole_array_get_value(vht, "max_coroutine", v)) { convert_to_long(v); COROG.max_coro_num = (int) Z_LVAL_P(v); if (COROG.max_coro_num <= 0) { COROG.max_coro_num = SW_DEFAULT_MAX_CORO_NUM; } else if (COROG.max_coro_num >= SW_MAX_CORO_NUM_LIMIT) { COROG.max_coro_num = SW_MAX_CORO_NUM_LIMIT; } } if (php_swoole_array_get_value(vht, "send_yield", v)) { convert_to_boolean(v); serv->send_yield = Z_BVAL_P(v); } if (php_swoole_array_get_value(vht, "send_timeout", v)) { convert_to_double(v); serv->send_timeout = Z_DVAL_P(v); } #endif //dispatch_mode if (php_swoole_array_get_value(vht, "dispatch_mode", v)) { convert_to_long(v); serv->dispatch_mode = (int) Z_LVAL_P(v); } //dispatch function if (php_swoole_array_get_value(vht, "dispatch_func", v)) { swServer_dispatch_function func = NULL; while(1) { if (Z_TYPE_P(v) == IS_STRING) { func = swoole_get_function(Z_STRVAL_P(v), Z_STRLEN_P(v)); break; } char *func_name = NULL; if (!sw_zend_is_callable(v, 0, &func_name TSRMLS_CC)) { swoole_php_fatal_error(E_ERROR, "function '%s' is not callable", func_name); efree(func_name); return; } efree(func_name); sw_zval_add_ref(&v); serv->private_data_3 = sw_zval_dup(v); func = php_swoole_dispatch_func; break; } if (func) { serv->dispatch_mode = SW_DISPATCH_USERFUNC; serv->dispatch_func = func; } } //log_file if (php_swoole_array_get_value(vht, "log_file", v)) { convert_to_string(v); if (SwooleG.log_file) { sw_free(SwooleG.log_file); } SwooleG.log_file = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } //log_level if (php_swoole_array_get_value(vht, "log_level", v)) { convert_to_long(v); SwooleG.log_level = (int) Z_LVAL_P(v); } /** * for dispatch_mode = 1/3 */ if (php_swoole_array_get_value(vht, "discard_timeout_request", v)) { convert_to_boolean(v); serv->discard_timeout_request = Z_BVAL_P(v); } //onConnect/onClose event if (php_swoole_array_get_value(vht, "enable_unsafe_event", v)) { convert_to_boolean(v); serv->enable_unsafe_event = Z_BVAL_P(v); } //delay receive if (php_swoole_array_get_value(vht, "enable_delay_receive", v)) { convert_to_boolean(v); serv->enable_delay_receive = Z_BVAL_P(v); } //task_worker_num if (php_swoole_array_get_value(vht, "task_worker_num", v)) { convert_to_long(v); serv->task_worker_num = (int) Z_LVAL_P(v); if (task_callbacks == NULL) { task_callbacks = swHashMap_new(1024, NULL); } #ifdef SW_COROUTINE if (task_coroutine_map == NULL) { task_coroutine_map = swHashMap_new(1024, NULL); } #endif } //slowlog if (php_swoole_array_get_value(vht, "trace_event_worker", v)) { convert_to_boolean(v); serv->trace_event_worker = Z_BVAL_P(v); } if (php_swoole_array_get_value(vht, "request_slowlog_timeout", v)) { convert_to_long(v); serv->request_slowlog_timeout = (uint8_t) Z_LVAL_P(v); } if (php_swoole_array_get_value(vht, "request_slowlog_file", v)) { convert_to_string(v); serv->request_slowlog_file = fopen(Z_STRVAL_P(v), "a+"); if (serv->request_slowlog_file == NULL) { swoole_php_fatal_error(E_ERROR, "Unable to open request_slowlog_file[%s].", Z_STRVAL_P(v)); return; } if (serv->request_slowlog_timeout == 0) { serv->request_slowlog_timeout = 1; } } //task ipc mode, 1,2,3 if (php_swoole_array_get_value(vht, "task_ipc_mode", v)) { convert_to_long(v); serv->task_ipc_mode = (int) Z_LVAL_P(v); } /** * Temporary file directory for task_worker */ if (php_swoole_array_get_value(vht, "task_tmpdir", v)) { convert_to_string(v); if (php_swoole_create_dir(Z_STRVAL_P(v), Z_STRLEN_P(v) TSRMLS_CC) < 0) { swoole_php_fatal_error(E_ERROR, "Unable to create task_tmpdir[%s].", Z_STRVAL_P(v)); return; } if (SwooleG.task_tmpdir) { sw_free(SwooleG.task_tmpdir); } SwooleG.task_tmpdir = sw_malloc(Z_STRLEN_P(v) + sizeof(SW_TASK_TMP_FILE) + 1); SwooleG.task_tmpdir_len = snprintf(SwooleG.task_tmpdir, SW_TASK_TMPDIR_SIZE, "%s/swoole.task.XXXXXX", Z_STRVAL_P(v)) + 1; } //task_max_request if (php_swoole_array_get_value(vht, "task_max_request", v)) { convert_to_long(v); serv->task_max_request = (int) Z_LVAL_P(v); } //max_connection if (php_swoole_array_get_value(vht, "max_connection", v) || php_swoole_array_get_value(vht, "max_conn", v)) { convert_to_long(v); serv->max_connection = (int) Z_LVAL_P(v); } //heartbeat_check_interval if (php_swoole_array_get_value(vht, "heartbeat_check_interval", v)) { convert_to_long(v); serv->heartbeat_check_interval = (int) Z_LVAL_P(v); } //heartbeat idle time if (php_swoole_array_get_value(vht, "heartbeat_idle_time", v)) { convert_to_long(v); serv->heartbeat_idle_time = (int) Z_LVAL_P(v); if (serv->heartbeat_check_interval > serv->heartbeat_idle_time) { swoole_php_fatal_error(E_WARNING, "heartbeat_idle_time must be greater than heartbeat_check_interval."); serv->heartbeat_check_interval = serv->heartbeat_idle_time / 2; } } else if (serv->heartbeat_check_interval > 0) { serv->heartbeat_idle_time = serv->heartbeat_check_interval * 2; } //max_request if (php_swoole_array_get_value(vht, "max_request", v)) { convert_to_long(v); serv->max_request = (int) Z_LVAL_P(v); } //reload async if (php_swoole_array_get_value(vht, "reload_async", v)) { convert_to_boolean(v); serv->reload_async = Z_BVAL_P(v); } //cpu affinity if (php_swoole_array_get_value(vht, "open_cpu_affinity", v)) { convert_to_boolean(v); serv->open_cpu_affinity = Z_BVAL_P(v); } //cpu affinity set if (php_swoole_array_get_value(vht, "cpu_affinity_ignore", v)) { int ignore_num = zend_hash_num_elements(Z_ARRVAL_P(v)); if (ignore_num >= SW_CPU_NUM) { swoole_php_fatal_error(E_ERROR, "cpu_affinity_ignore num must be less than cpu num (%d)", SW_CPU_NUM); RETURN_FALSE; } int available_num = SW_CPU_NUM - ignore_num; int *available_cpu = (int *) sw_malloc(sizeof(int) * available_num); int flag, i, available_i = 0; zval *zval_core = NULL; for (i = 0; i < SW_CPU_NUM; i++) { flag = 1; SW_HASHTABLE_FOREACH_START(Z_ARRVAL_P(v), zval_core) int core = (int) Z_LVAL_P(zval_core); if (i == core) { flag = 0; break; } SW_HASHTABLE_FOREACH_END(); if (flag) { available_cpu[available_i] = i; available_i++; } } serv->cpu_affinity_available_num = available_num; serv->cpu_affinity_available = available_cpu; } //paser x-www-form-urlencoded form data if (php_swoole_array_get_value(vht, "http_parse_post", v)) { convert_to_boolean(v); serv->http_parse_post = Z_BVAL_P(v); } //temporary directory for HTTP uploaded file. if (php_swoole_array_get_value(vht, "upload_tmp_dir", v)) { convert_to_string(v); if (php_swoole_create_dir(Z_STRVAL_P(v), Z_STRLEN_P(v) TSRMLS_CC) < 0) { swoole_php_fatal_error(E_ERROR, "Unable to create upload_tmp_dir[%s].", Z_STRVAL_P(v)); return; } if (serv->upload_tmp_dir) { sw_free(serv->upload_tmp_dir); } serv->upload_tmp_dir = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } /** * http static file handler */ if (php_swoole_array_get_value(vht, "enable_static_handler", v)) { convert_to_boolean(v); serv->enable_static_handler = Z_BVAL_P(v); } if (php_swoole_array_get_value(vht, "document_root", v)) { convert_to_string(v); if (serv->document_root) { sw_free(serv->document_root); } serv->document_root = sw_strndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); if (serv->document_root[Z_STRLEN_P(v) - 1] == '/') { serv->document_root[Z_STRLEN_P(v) - 1] = 0; serv->document_root_len = Z_STRLEN_P(v) - 1; } else { serv->document_root_len = Z_STRLEN_P(v); } } /** * buffer input size */ if (php_swoole_array_get_value(vht, "buffer_input_size", v)) { convert_to_long(v); serv->buffer_input_size = (int) Z_LVAL_P(v); } /** * buffer output size */ if (php_swoole_array_get_value(vht, "buffer_output_size", v)) { convert_to_long(v); serv->buffer_output_size = (int) Z_LVAL_P(v); } //message queue key if (php_swoole_array_get_value(vht, "message_queue_key", v)) { convert_to_long(v); serv->message_queue_key = (int) Z_LVAL_P(v); } zval *retval = NULL; zval *port_object = server_port_list.zobjects[0]; sw_zval_add_ref(&port_object); sw_zval_add_ref(&zset); sw_zend_call_method_with_1_params(&port_object, swoole_server_port_class_entry_ptr, NULL, "set", &retval, zset); zval *zsetting = php_swoole_read_init_property(swoole_server_class_entry_ptr, getThis(), ZEND_STRL("setting") TSRMLS_CC); sw_php_array_merge(Z_ARRVAL_P(zsetting), Z_ARRVAL_P(zset)); sw_zval_ptr_dtor(&zset); RETURN_TRUE; } PHP_METHOD(swoole_server, on) { zval *name; zval *cb; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start > 0) { swoole_php_fatal_error(E_WARNING, "server is running. unable to register event callback function."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "zz", &name, &cb) == FAILURE) { return; } char *func_name = NULL; zend_fcall_info_cache *func_cache = emalloc(sizeof(zend_fcall_info_cache)); if (!sw_zend_is_callable_ex(cb, NULL, 0, &func_name, NULL, func_cache, NULL TSRMLS_CC)) { swoole_php_fatal_error(E_ERROR, "function '%s' is not callable", func_name); efree(func_name); return; } efree(func_name); convert_to_string(name); char *callback_name[PHP_SERVER_CALLBACK_NUM] = { "Connect", "Receive", "Close", "Packet", "Start", "Shutdown", "WorkerStart", "WorkerStop", "Task", "Finish", "WorkerExit", "WorkerError", "ManagerStart", "ManagerStop", "PipeMessage", NULL, NULL, NULL, NULL, "BufferFull", "BufferEmpty", }; int i; char property_name[128]; int l_property_name = 0; memcpy(property_name, "on", 2); for (i = 0; i < PHP_SERVER_CALLBACK_NUM; i++) { if (callback_name[i] == NULL) { continue; } if (strncasecmp(callback_name[i], Z_STRVAL_P(name), Z_STRLEN_P(name)) == 0) { memcpy(property_name + 2, callback_name[i], Z_STRLEN_P(name)); l_property_name = Z_STRLEN_P(name) + 2; property_name[l_property_name] = '\0'; zend_update_property(swoole_server_class_entry_ptr, getThis(), property_name, l_property_name, cb TSRMLS_CC); php_sw_server_callbacks[i] = sw_zend_read_property(swoole_server_class_entry_ptr, getThis(), property_name, l_property_name, 0 TSRMLS_CC); php_sw_server_caches[i] = func_cache; sw_copy_to_stack(php_sw_server_callbacks[i], _php_sw_server_callbacks[i]); break; } } if (l_property_name == 0) { swoole_php_error(E_WARNING, "unknown event types[%s]", Z_STRVAL_P(name)); efree(func_cache); RETURN_FALSE; } if (i < SW_SERVER_CB_onStart) { zval *port_object = server_port_list.zobjects[0]; zval *retval = NULL; sw_zval_add_ref(&port_object); sw_zend_call_method_with_2_params(&port_object, swoole_server_port_class_entry_ptr, NULL, "on", &retval, name, cb); } else { RETURN_TRUE; } } PHP_METHOD(swoole_server, listen) { char *host; zend_size_t host_len; long sock_type; long port; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start > 0) { swoole_php_fatal_error(E_WARNING, "server is running. can't add listener."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll", &host, &host_len, &port, &sock_type) == FAILURE) { return; } swListenPort *ls = swServer_add_port(serv, (int) sock_type, host, (int) port); if (!ls) { RETURN_FALSE; } zval *port_object = php_swoole_server_add_port(serv, ls TSRMLS_CC); RETURN_ZVAL(port_object, 1, NULL); } PHP_METHOD(swoole_server, addProcess) { swServer *serv = swoole_get_object(getThis()); if (serv->gs->start > 0) { swoole_php_fatal_error(E_WARNING, "server is running. can't add process."); RETURN_FALSE; } zval *process = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &process) == FAILURE) { return; } if (ZVAL_IS_NULL(process)) { swoole_php_fatal_error(E_WARNING, "the first parameter can't be empty."); RETURN_FALSE; } if (!instanceof_function(Z_OBJCE_P(process), swoole_process_class_entry_ptr TSRMLS_CC)) { swoole_php_fatal_error(E_ERROR, "object is not instanceof swoole_process."); RETURN_FALSE; } if (serv->onUserWorkerStart == NULL) { serv->onUserWorkerStart = php_swoole_onUserWorkerStart; } #if PHP_MAJOR_VERSION >= 7 zval *tmp_process = emalloc(sizeof(zval)); memcpy(tmp_process, process, sizeof(zval)); process = tmp_process; #endif sw_zval_add_ref(&process); swWorker *worker = swoole_get_object(process); worker->ptr = process; int id = swServer_add_worker(serv, worker); if (id < 0) { swoole_php_fatal_error(E_WARNING, "swServer_add_worker failed."); RETURN_FALSE; } zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("id"), id TSRMLS_CC); RETURN_LONG(id); } PHP_METHOD(swoole_server, start) { zval *zobject = getThis(); int ret; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start > 0) { swoole_php_fatal_error(E_WARNING, "server is running. unable to execute swoole_server->start."); RETURN_FALSE; } php_swoole_register_callback(serv); if (php_sw_server_callbacks[SW_SERVER_CB_onReceive] == NULL && php_sw_server_callbacks[SW_SERVER_CB_onPacket] == NULL) { swoole_php_fatal_error(E_ERROR, "require onReceive/onPacket callback"); RETURN_FALSE; } //------------------------------------------------------------- serv->onReceive = php_swoole_onReceive; php_swoole_server_before_start(serv, zobject TSRMLS_CC); ret = swServer_start(serv); if (ret < 0) { swoole_php_fatal_error(E_ERROR, "failed to start server. Error: %s", sw_error); RETURN_LONG(ret); } RETURN_TRUE; } PHP_METHOD(swoole_server, send) { int ret; zval *zfd; zval *zdata; zend_long server_socket = -1; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (swIsMaster()) { swoole_php_fatal_error(E_WARNING, "can't send data to the connections in master process."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(2, 3) Z_PARAM_ZVAL(zfd) Z_PARAM_ZVAL(zdata) Z_PARAM_OPTIONAL Z_PARAM_LONG(server_socket) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|l", &zfd, &zdata, &server_socket) == FAILURE) { return; } #endif char *data; int length = php_swoole_get_send_data(zdata, &data TSRMLS_CC); if (length < 0) { RETURN_FALSE; } else if (length == 0) { swoole_php_fatal_error(E_WARNING, "data is empty."); RETURN_FALSE; } if (serv->have_udp_sock && SW_Z_TYPE_P(zfd) == IS_STRING) { if (server_socket == -1) { server_socket = dgram_server_socket; } //UDP IPv6 if (strchr(Z_STRVAL_P(zfd), ':')) { php_swoole_udp_t udp_info; memcpy(&udp_info, &server_socket, sizeof(udp_info)); ret = swSocket_udp_sendto6(udp_info.from_fd, Z_STRVAL_P(zfd), udp_info.port, data, length); } //UNIX DGRAM else if (Z_STRVAL_P(zfd)[0] == '/') { struct sockaddr_un addr_un; memcpy(addr_un.sun_path, Z_STRVAL_P(zfd), Z_STRLEN_P(zfd)); addr_un.sun_family = AF_UNIX; addr_un.sun_path[Z_STRLEN_P(zfd)] = 0; ret = swSocket_sendto_blocking(server_socket, data, length, 0, (struct sockaddr *) &addr_un, sizeof(addr_un)); } else { goto convert; } SW_CHECK_RETURN(ret); } convert: convert_to_long(zfd); uint32_t fd = (uint32_t) Z_LVAL_P(zfd); //UDP if (swServer_is_udp(fd)) { if (server_socket == -1) { server_socket = udp_server_socket; } php_swoole_udp_t udp_info; memcpy(&udp_info, &server_socket, sizeof(udp_info)); struct sockaddr_in addr_in; addr_in.sin_family = AF_INET; addr_in.sin_port = htons(udp_info.port); addr_in.sin_addr.s_addr = fd; ret = swSocket_sendto_blocking(udp_info.from_fd, data, length, 0, (struct sockaddr *) &addr_in, sizeof(addr_in)); SW_CHECK_RETURN(ret); } //TCP else { ret = swServer_tcp_send(serv, fd, data, length); #ifdef SW_COROUTINE if (ret < 0 && SwooleG.error == SW_ERROR_OUTPUT_BUFFER_OVERFLOW && serv->send_yield) { zval_add_ref(zdata); php_swoole_server_send_yield(serv, fd, zdata, return_value); } else #endif { SW_CHECK_RETURN(ret); } } } PHP_METHOD(swoole_server, sendto) { char *ip; char *data; zend_size_t len, ip_len; zend_long port; zend_long server_socket = -1; zend_bool ipv6 = 0; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(3, 4) Z_PARAM_STRING(ip, ip_len) Z_PARAM_LONG(port) Z_PARAM_STRING(data, len) Z_PARAM_OPTIONAL Z_PARAM_LONG(server_socket) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sls|l", &ip, &ip_len, &port, &data, &len, &server_socket) == FAILURE) { return; } #endif if (len <= 0) { swoole_php_fatal_error(E_WARNING, "data is empty."); RETURN_FALSE; } if (strchr(ip, ':')) { ipv6 = 1; } if (ipv6 == 0 && serv->udp_socket_ipv4 <= 0) { swoole_php_fatal_error(E_WARNING, "UDP listener has to be added before executing sendto."); RETURN_FALSE; } else if (ipv6 == 1 && serv->udp_socket_ipv6 <= 0) { swoole_php_fatal_error(E_WARNING, "UDP6 listener has to be added before executing sendto."); RETURN_FALSE; } if (server_socket < 0) { server_socket = ipv6 ? serv->udp_socket_ipv6 : serv->udp_socket_ipv4; } int ret; if (ipv6) { ret = swSocket_udp_sendto6(server_socket, ip, port, data, len); } else { ret = swSocket_udp_sendto(server_socket, ip, port, data, len); } SW_CHECK_RETURN(ret); } PHP_METHOD(swoole_server, sendfile) { zend_size_t len; char *filename; long fd; long offset = 0; long length = 0; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls|ll", &fd, &filename, &len, &offset, &length) == FAILURE) { return; } if (swIsMaster()) { swoole_php_fatal_error(E_WARNING, "can't sendfile[%s] to the connections in master process.", filename); RETURN_FALSE; } SW_CHECK_RETURN(swServer_tcp_sendfile(serv, (int) fd, filename, len, offset, length)); } PHP_METHOD(swoole_server, close) { zend_bool reset = SW_FALSE; zend_long fd; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (swIsMaster()) { swoole_php_fatal_error(E_WARNING, "can't close the connections in master process."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(1, 2) Z_PARAM_LONG(fd) Z_PARAM_OPTIONAL Z_PARAM_BOOL(reset) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &fd, &reset) == FAILURE) { return; } #endif SW_CHECK_RETURN(serv->close(serv, (int )fd, (int )reset)); } PHP_METHOD(swoole_server, confirm) { long fd; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (swIsMaster()) { swoole_php_fatal_error(E_WARNING, "can't confirm the connections in master process."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fd) == FAILURE) { return; } SW_CHECK_RETURN(swServer_tcp_feedback(serv, fd, SW_EVENT_CONFIRM)); } PHP_METHOD(swoole_server, pause) { long fd; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fd) == FAILURE) { return; } SW_CHECK_RETURN(swServer_tcp_feedback(serv, fd, SW_EVENT_PAUSE_RECV)); } PHP_METHOD(swoole_server, resume) { long fd; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fd) == FAILURE) { return; } SW_CHECK_RETURN(swServer_tcp_feedback(serv, fd, SW_EVENT_RESUME_RECV)); } PHP_METHOD(swoole_server, stats) { swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } array_init(return_value); sw_add_assoc_long_ex(return_value, ZEND_STRS("start_time"), serv->stats->start_time); sw_add_assoc_long_ex(return_value, ZEND_STRS("connection_num"), serv->stats->connection_num); sw_add_assoc_long_ex(return_value, ZEND_STRS("accept_count"), serv->stats->accept_count); sw_add_assoc_long_ex(return_value, ZEND_STRS("close_count"), serv->stats->close_count); sw_add_assoc_long_ex(return_value, ZEND_STRS("tasking_num"), serv->stats->tasking_num); sw_add_assoc_long_ex(return_value, ZEND_STRS("request_count"), serv->stats->request_count); if (SwooleWG.worker) { sw_add_assoc_long_ex(return_value, ZEND_STRS("worker_request_count"), SwooleWG.worker->request_count); } if (serv->task_ipc_mode > SW_TASK_IPC_UNIXSOCK && serv->gs->task_workers.queue) { int queue_num = -1; int queue_bytes = -1; if (swMsgQueue_stat(serv->gs->task_workers.queue, &queue_num, &queue_bytes) == 0) { sw_add_assoc_long_ex(return_value, ZEND_STRS("task_queue_num"), queue_num); sw_add_assoc_long_ex(return_value, ZEND_STRS("task_queue_bytes"), queue_bytes); } } #ifdef SW_COROUTINE sw_add_assoc_long_ex(return_value, ZEND_STRS("coroutine_num"), COROG.coro_num); #endif } PHP_METHOD(swoole_server, reload) { zend_bool only_reload_taskworker = 0; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &only_reload_taskworker) == FAILURE) { return; } int sig = only_reload_taskworker ? SIGUSR2 : SIGUSR1; if (kill(serv->gs->manager_pid, sig) < 0) { swoole_php_fatal_error(E_WARNING, "failed to send the reload signal. Error: %s[%d]", strerror(errno), errno); RETURN_FALSE; } RETURN_TRUE; } PHP_METHOD(swoole_server, heartbeat) { zend_bool close_connection = 0; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &close_connection) == FAILURE) { return; } if (serv->heartbeat_idle_time < 1) { RETURN_FALSE; } int serv_max_fd = swServer_get_maxfd(serv); int serv_min_fd = swServer_get_minfd(serv); array_init(return_value); int fd; int checktime = (int) serv->gs->now - serv->heartbeat_idle_time; swConnection *conn; for (fd = serv_min_fd; fd <= serv_max_fd; fd++) { swTrace("heartbeat check fd=%d", fd); conn = &serv->connection_list[fd]; if (1 == conn->active && conn->last_time < checktime) { conn->close_force = 1; /** * Close the connection */ if (close_connection) { serv->factory.end(&serv->factory, fd); } #ifdef SW_REACTOR_USE_SESSION add_next_index_long(return_value, conn->session_id); #else add_next_index_long(return_value, fd); #endif } } } PHP_METHOD(swoole_server, taskwait) { swEventData buf; zval *data; double timeout = SW_TASKWAIT_TIMEOUT; long dst_worker_id = -1; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|dl", &data, &timeout, &dst_worker_id) == FAILURE) { return; } if (php_swoole_check_task_param(serv, dst_worker_id TSRMLS_CC) < 0) { RETURN_FALSE; } if (php_swoole_task_pack(&buf, data TSRMLS_CC) < 0) { RETURN_FALSE; } int task_id = buf.info.fd; uint64_t notify; swEventData *task_result = &(serv->task_result[SwooleWG.id]); bzero(task_result, sizeof(swEventData)); swPipe *task_notify_pipe = &serv->task_notify[SwooleWG.id]; int efd = task_notify_pipe->getFd(task_notify_pipe, 0); //clear history task while (read(efd, ¬ify, sizeof(notify)) > 0); int _dst_worker_id = (int) dst_worker_id; if (swProcessPool_dispatch_blocking(&serv->gs->task_workers, &buf, &_dst_worker_id) >= 0) { sw_atomic_fetch_add(&serv->stats->tasking_num, 1); task_notify_pipe->timeout = timeout; while(1) { if (task_notify_pipe->read(task_notify_pipe, ¬ify, sizeof(notify)) > 0) { if (task_result->info.fd != task_id) { continue; } zval *task_notify_data = php_swoole_task_unpack(task_result TSRMLS_CC); if (task_notify_data == NULL) { RETURN_FALSE; } else { RETVAL_ZVAL(task_notify_data, 0, 0); efree(task_notify_data); return; } break; } else { swoole_php_error(E_WARNING, "taskwait failed. Error: %s[%d]", strerror(errno), errno); break; } } } RETURN_FALSE; } PHP_METHOD(swoole_server, taskWaitMulti) { swEventData buf; zval *tasks; zval *task; double timeout = SW_TASKWAIT_TIMEOUT; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|d", &tasks, &timeout) == FAILURE) { return; } array_init(return_value); int dst_worker_id; int task_id; int i = 0; int n_task = Z_ARRVAL_P(tasks)->nNumOfElements; if (n_task >= SW_MAX_CONCURRENT_TASK) { swoole_php_fatal_error(E_WARNING, "too many concurrent tasks."); RETURN_FALSE; } int list_of_id[SW_MAX_CONCURRENT_TASK]; uint64_t notify; swEventData *task_result = &(serv->task_result[SwooleWG.id]); bzero(task_result, sizeof(swEventData)); swPipe *task_notify_pipe = &serv->task_notify[SwooleWG.id]; swWorker *worker = swServer_get_worker(serv, SwooleWG.id); char _tmpfile[sizeof(SW_TASK_TMP_FILE)] = SW_TASK_TMP_FILE; int _tmpfile_fd = swoole_tmpfile(_tmpfile); if (_tmpfile_fd < 0) { RETURN_FALSE; } close(_tmpfile_fd); int *finish_count = (int *) task_result->data; worker->lock.lock(&worker->lock); *finish_count = 0; memcpy(task_result->data + 4, _tmpfile, sizeof(_tmpfile)); worker->lock.unlock(&worker->lock); //clear history task int efd = task_notify_pipe->getFd(task_notify_pipe, 0); while (read(efd, ¬ify, sizeof(notify)) > 0); SW_HASHTABLE_FOREACH_START(Z_ARRVAL_P(tasks), task) task_id = php_swoole_task_pack(&buf, task TSRMLS_CC); if (task_id < 0) { swoole_php_fatal_error(E_WARNING, "task pack failed."); goto fail; } swTask_type(&buf) |= SW_TASK_WAITALL; dst_worker_id = -1; if (swProcessPool_dispatch_blocking(&serv->gs->task_workers, &buf, &dst_worker_id) < 0) { swoole_php_fatal_error(E_WARNING, "taskwait failed. Error: %s[%d]", strerror(errno), errno); task_id = -1; fail: add_index_bool(return_value, i, 0); n_task --; } sw_atomic_fetch_add(&serv->stats->tasking_num, 1); list_of_id[i] = task_id; i++; SW_HASHTABLE_FOREACH_END(); if (n_task == 0) { SwooleG.error = SW_ERROR_TASK_DISPATCH_FAIL; RETURN_FALSE; } double _now = swoole_microtime(); while (n_task > 0) { task_notify_pipe->timeout = timeout; int ret = task_notify_pipe->read(task_notify_pipe, ¬ify, sizeof(notify)); if (ret > 0 && *finish_count < n_task) { if (swoole_microtime() - _now < timeout) { continue; } } break; } worker->lock.lock(&worker->lock); swString *content = swoole_file_get_contents(_tmpfile); worker->lock.unlock(&worker->lock); if (content == NULL) { RETURN_FALSE; } swEventData *result; zval *zdata; int j; do { result = (swEventData *) (content->str + content->offset); task_id = result->info.fd; zdata = php_swoole_task_unpack(result TSRMLS_CC); if (zdata == NULL) { goto next; } for (j = 0; j < Z_ARRVAL_P(tasks)->nNumOfElements; j++) { if (list_of_id[j] == task_id) { break; } } add_index_zval(return_value, j, zdata); efree(zdata); next: content->offset += sizeof(swDataHead) + result->info.len; } while(content->offset < content->length); //free memory swString_free(content); //delete tmp file unlink(_tmpfile); } #ifdef SW_COROUTINE PHP_METHOD(swoole_server, taskCo) { swEventData buf; zval *tasks; zval *task; double timeout = SW_TASKWAIT_TIMEOUT; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|d", &tasks, &timeout) == FAILURE) { return; } int dst_worker_id = -1; int task_id; int i = 0; int n_task = Z_ARRVAL_P(tasks)->nNumOfElements; if (n_task >= SW_MAX_CONCURRENT_TASK) { swoole_php_fatal_error(E_WARNING, "too many concurrent tasks."); RETURN_FALSE; } if (php_swoole_check_task_param(serv, dst_worker_id TSRMLS_CC) < 0) { RETURN_FALSE; } int *list = ecalloc(n_task, sizeof(int)); if (list == NULL) { RETURN_FALSE; } swTaskCo *task_co = emalloc(sizeof(swTaskCo)); if (task_co == NULL) { efree(list); RETURN_FALSE; } zval *result; SW_ALLOC_INIT_ZVAL(result); array_init(result); SW_HASHTABLE_FOREACH_START(Z_ARRVAL_P(tasks), task) task_id = php_swoole_task_pack(&buf, task TSRMLS_CC); if (task_id < 0) { swoole_php_fatal_error(E_WARNING, "failed to pack task."); goto fail; } swTask_type(&buf) |= (SW_TASK_NONBLOCK | SW_TASK_COROUTINE); dst_worker_id = -1; sw_atomic_fetch_add(&serv->stats->tasking_num, 1); if (swProcessPool_dispatch(&serv->gs->task_workers, &buf, &dst_worker_id) < 0) { sw_atomic_fetch_sub(&serv->stats->tasking_num, 1); task_id = -1; fail: add_index_bool(result, i, 0); n_task --; } else { swHashMap_add_int(task_coroutine_map, buf.info.fd, task_co); } list[i] = task_id; i++; SW_HASHTABLE_FOREACH_END(); if (n_task == 0) { SwooleG.error = SW_ERROR_TASK_DISPATCH_FAIL; RETURN_FALSE; } int ms = (int) (timeout * 1000); task_co->result = result; task_co->list = list; task_co->count = n_task; task_co->context.onTimeout = NULL; task_co->context.state = SW_CORO_CONTEXT_RUNNING; php_swoole_check_timer(ms); swTimer_node *timer = SwooleG.timer.add(&SwooleG.timer, ms, 0, task_co, php_swoole_task_onTimeout); if (timer) { task_co->timer = timer; } coro_save(&task_co->context); coro_yield(); } #endif PHP_METHOD(swoole_server, task) { swEventData buf; zval *data; zval *callback = NULL; zend_long dst_worker_id = -1; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(1, 3) Z_PARAM_ZVAL(data) Z_PARAM_OPTIONAL Z_PARAM_LONG(dst_worker_id) Z_PARAM_ZVAL(callback) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|lz", &data, &dst_worker_id, &callback) == FAILURE) { return; } #endif if (php_swoole_check_task_param(serv, dst_worker_id TSRMLS_CC) < 0) { RETURN_FALSE; } if (php_swoole_task_pack(&buf, data TSRMLS_CC) < 0) { RETURN_FALSE; } if (callback && !ZVAL_IS_NULL(callback)) { #ifdef PHP_SWOOLE_CHECK_CALLBACK char *func_name = NULL; if (!sw_zend_is_callable(callback, 0, &func_name TSRMLS_CC)) { swoole_php_fatal_error(E_WARNING, "function '%s' is not callable", func_name); efree(func_name); return; } efree(func_name); #endif swTask_type(&buf) |= SW_TASK_CALLBACK; sw_zval_add_ref(&callback); swHashMap_add_int(task_callbacks, buf.info.fd, sw_zval_dup(callback)); } swTask_type(&buf) |= SW_TASK_NONBLOCK; int _dst_worker_id = (int) dst_worker_id; if (swProcessPool_dispatch(&serv->gs->task_workers, &buf, &_dst_worker_id) >= 0) { sw_atomic_fetch_add(&serv->stats->tasking_num, 1); RETURN_LONG(buf.info.fd); } else { RETURN_FALSE; } } PHP_METHOD(swoole_server, sendMessage) { swEventData buf; zval *message; long worker_id = -1; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &message, &worker_id) == FAILURE) { return; } if (worker_id == SwooleWG.id) { swoole_php_fatal_error(E_WARNING, "can't send messages to self."); RETURN_FALSE; } if (worker_id >= serv->worker_num + serv->task_worker_num) { swoole_php_fatal_error(E_WARNING, "worker_id[%d] is invalid.", (int) worker_id); RETURN_FALSE; } if (!serv->onPipeMessage) { swoole_php_fatal_error(E_WARNING, "onPipeMessage is null, can't use sendMessage."); RETURN_FALSE; } if (php_swoole_task_pack(&buf, message TSRMLS_CC) < 0) { RETURN_FALSE; } buf.info.type = SW_EVENT_PIPE_MESSAGE; buf.info.from_id = SwooleWG.id; swWorker *to_worker = swServer_get_worker(serv, worker_id); SW_CHECK_RETURN(swWorker_send2worker(to_worker, &buf, sizeof(buf.info) + buf.info.len, SW_PIPE_MASTER | SW_PIPE_NONBLOCK)); } PHP_METHOD(swoole_server, finish) { zval *data; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_ZVAL(data) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { return; } #endif SW_CHECK_RETURN(php_swoole_task_finish(serv, data TSRMLS_CC)); } PHP_METHOD(swoole_server, bind) { long fd = 0; long uid = 0; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &fd, &uid) == FAILURE) { return; } swConnection *conn = swWorker_get_connection(serv, fd); if (conn == NULL || conn->active == 0) { RETURN_FALSE; } sw_spinlock(&conn->lock); if (conn->uid != 0) { RETVAL_FALSE; } else { conn->uid = (uint32_t) uid; RETVAL_TRUE; } sw_spinlock_release(&conn->lock); } #ifdef SWOOLE_SOCKETS_SUPPORT PHP_METHOD(swoole_server, getSocket) { long port = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &port) == FAILURE) { return; } zval *zobject = getThis(); swServer *serv = swoole_get_object(zobject); int sock = swServer_get_socket(serv, port); php_socket *socket_object = swoole_convert_to_socket(sock); if (!socket_object) { RETURN_FALSE; } SW_ZEND_REGISTER_RESOURCE(return_value, (void *) socket_object, php_sockets_le_socket()); zval *zsocket = sw_zval_dup(return_value); sw_zval_add_ref(&zsocket); } #endif PHP_METHOD(swoole_server, connection_info) { zval *zobject = getThis(); zend_bool noCheckConnection = 0; zval *zfd; long from_id = -1; swServer *serv = swoole_get_object(zobject); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|lb", &zfd, &from_id, &noCheckConnection) == FAILURE) { return; } zend_long fd = 0; zend_bool ipv6_udp = 0; //ipv6 udp if (SW_Z_TYPE_P(zfd) == IS_STRING) { if (is_numeric_string(Z_STRVAL_P(zfd), Z_STRLEN_P(zfd), &fd, NULL, 0)) { ipv6_udp = 0; } else { fd = 0; ipv6_udp = 1; } } else { convert_to_long(zfd); fd = Z_LVAL_P(zfd); } //udp if (ipv6_udp || swServer_is_udp(fd)) { array_init(return_value); swoole_php_error(E_DEPRECATED, "The UDP connection_info is deprecated, use onPacket instead."); if (ipv6_udp) { add_assoc_zval(return_value, "remote_ip", zfd); } else { struct in_addr sin_addr; sin_addr.s_addr = fd; sw_add_assoc_string(return_value, "remote_ip", inet_ntoa(sin_addr), 1); } if (from_id == 0) { return; } php_swoole_udp_t udp_info; memcpy(&udp_info, &from_id, sizeof(udp_info)); //server socket swConnection *from_sock = swServer_connection_get(serv, udp_info.from_fd); if (from_sock) { add_assoc_long(return_value, "server_fd", from_sock->fd); add_assoc_long(return_value, "socket_type", from_sock->socket_type); add_assoc_long(return_value, "server_port", swConnection_get_port(from_sock)); } add_assoc_long(return_value, "remote_port", udp_info.port); return; } swConnection *conn = swServer_connection_verify(serv, fd); if (!conn) { RETURN_FALSE; } //connection is closed if (conn->active == 0 && !noCheckConnection) { RETURN_FALSE; } else { array_init(return_value); if (conn->uid > 0 || serv->dispatch_mode == SW_DISPATCH_UIDMOD) { add_assoc_long(return_value, "uid", conn->uid); } swListenPort *port = swServer_get_port(serv, conn->fd); if (port && port->open_websocket_protocol) { add_assoc_long(return_value, "websocket_status", conn->websocket_status); } #ifdef SW_USE_OPENSSL if (conn->ssl_client_cert.length > 0) { sw_add_assoc_stringl(return_value, "ssl_client_cert", conn->ssl_client_cert.str, conn->ssl_client_cert.length - 1, 1); } #endif //server socket swConnection *from_sock = swServer_connection_get(serv, conn->from_fd); if (from_sock) { add_assoc_long(return_value, "server_port", swConnection_get_port(from_sock)); } add_assoc_long(return_value, "server_fd", conn->from_fd); add_assoc_long(return_value, "socket_fd", conn->fd); add_assoc_long(return_value, "socket_type", conn->socket_type); add_assoc_long(return_value, "remote_port", swConnection_get_port(conn)); sw_add_assoc_string(return_value, "remote_ip", swConnection_get_ip(conn), 1); add_assoc_long(return_value, "reactor_id", conn->from_id); add_assoc_long(return_value, "connect_time", conn->connect_time); add_assoc_long(return_value, "last_time", conn->last_time); add_assoc_long(return_value, "close_errno", conn->close_errno); } } PHP_METHOD(swoole_server, connection_list) { long start_fd = 0; long find_count = 10; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &start_fd, &find_count) == FAILURE) { return; } //超过最大查找数量 if (find_count > SW_MAX_FIND_COUNT) { swoole_php_fatal_error(E_WARNING, "swoole_connection_list max_find_count=%d", SW_MAX_FIND_COUNT); RETURN_FALSE; } //复制出来避免被其他进程改写 int serv_max_fd = swServer_get_maxfd(serv); if (start_fd == 0) { start_fd = swServer_get_minfd(serv); } #ifdef SW_REACTOR_USE_SESSION else { swConnection *conn = swWorker_get_connection(serv, start_fd); if (!conn) { RETURN_FALSE; } start_fd = conn->fd; } #endif //达到最大，表示已经取完了 if ((int) start_fd >= serv_max_fd) { RETURN_FALSE; } array_init(return_value); int fd = start_fd + 1; swConnection *conn; for (; fd <= serv_max_fd; fd++) { swTrace("maxfd=%d, fd=%d, find_count=%ld, start_fd=%ld", serv_max_fd, fd, find_count, start_fd); conn = &serv->connection_list[fd]; if (conn->active && !conn->closed) { #ifdef SW_USE_OPENSSL if (conn->ssl && conn->ssl_state != SW_SSL_STATE_READY) { continue; } #endif #ifdef SW_REACTOR_USE_SESSION add_next_index_long(return_value, conn->session_id); #else add_next_index_long(return_value, fd); #endif find_count--; } //finish fetch if (find_count <= 0) { break; } } } PHP_METHOD(swoole_server, sendwait) { long fd; zval *zdata; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &fd, &zdata) == FAILURE) { return; } char *data; int length = php_swoole_get_send_data(zdata, &data TSRMLS_CC); if (length < 0) { RETURN_FALSE; } else if (length == 0) { swoole_php_fatal_error(E_WARNING, "data is empty."); RETURN_FALSE; } if (serv->factory_mode != SW_MODE_SINGLE || swIsTaskWorker()) { swoole_php_fatal_error(E_WARNING, "can't sendwait."); RETURN_FALSE; } //UDP if (swServer_is_udp(fd)) { swoole_php_fatal_error(E_WARNING, "can't sendwait."); RETURN_FALSE; } //TCP else { SW_CHECK_RETURN(swServer_tcp_sendwait(serv, fd, data, length)); } } PHP_METHOD(swoole_server, exist) { zend_long fd; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } #ifdef FAST_ZPP ZEND_PARSE_PARAMETERS_START(1, 1) Z_PARAM_LONG(fd) ZEND_PARSE_PARAMETERS_END(); #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fd) == FAILURE) { return; } #endif swConnection *conn = swWorker_get_connection(serv, fd); if (!conn) { RETURN_FALSE; } //connection is closed if (conn->active == 0 || conn->closed) { RETURN_FALSE; } else { RETURN_TRUE; } } PHP_METHOD(swoole_server, protect) { long fd; zend_bool value = 1; swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &fd, &value) == FAILURE) { return; } swConnection *conn = swWorker_get_connection(serv, fd); if (!conn) { RETURN_FALSE; } //connection is closed if (conn->active == 0 || conn->closed) { RETURN_FALSE; } else { conn->protect = value; RETURN_TRUE; } } #ifdef SW_BUFFER_RECV_TIME PHP_METHOD(swoole_server, getReceivedTime) { swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (serv->last_receive_usec > 0) { RETURN_DOUBLE(serv->last_receive_usec); } else { RETURN_FALSE; } } #endif PHP_METHOD(swoole_server, shutdown) { swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } if (kill(serv->gs->master_pid, SIGTERM) < 0) { swoole_php_sys_error(E_WARNING, "failed to shutdown. kill(%d, SIGTERM) failed.", serv->gs->master_pid); RETURN_FALSE; } else { RETURN_TRUE; } } PHP_METHOD(swoole_server, stop) { swServer *serv = swoole_get_object(getThis()); if (serv->gs->start == 0) { swoole_php_fatal_error(E_WARNING, "server is not running."); RETURN_FALSE; } zend_bool wait_reactor = 0; long worker_id = SwooleWG.id; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &worker_id, &wait_reactor) == FAILURE) { return; } if (worker_id == SwooleWG.id && wait_reactor == 0) { SwooleG.main_reactor->running = 0; SwooleG.running = 0; } else { swWorker *worker = swServer_get_worker(SwooleG.serv, worker_id); if (worker == NULL) { RETURN_FALSE; } else if (kill(worker->pid, SIGTERM) < 0) { swoole_php_sys_error(E_WARNING, "kill(%d, SIGTERM) failed.", worker->pid); RETURN_FALSE; } } RETURN_TRUE; } #ifdef HAVE_PCRE PHP_METHOD(swoole_connection_iterator, rewind) { swConnectionIterator *itearator = swoole_get_object(getThis()); itearator->current_fd = swServer_get_minfd(SwooleG.serv); } PHP_METHOD(swoole_connection_iterator, valid) { swConnectionIterator *itearator = swoole_get_object(getThis()); int fd = itearator->current_fd; swConnection *conn; int max_fd = swServer_get_maxfd(itearator->serv); for (; fd <= max_fd; fd++) { conn = &SwooleG.serv->connection_list[fd]; if (conn->active && !conn->closed) { #ifdef SW_USE_OPENSSL if (conn->ssl && conn->ssl_state != SW_SSL_STATE_READY) { continue; } #endif if (itearator->port && conn->from_fd != itearator->port->sock) { continue; } itearator->session_id = conn->session_id; itearator->current_fd = fd; itearator->index++; RETURN_TRUE; } } RETURN_FALSE; } PHP_METHOD(swoole_connection_iterator, current) { swConnectionIterator *itearator = swoole_get_object(getThis()); RETURN_LONG(itearator->session_id); } PHP_METHOD(swoole_connection_iterator, next) { swConnectionIterator *itearator = swoole_get_object(getThis()); itearator->current_fd++; } PHP_METHOD(swoole_connection_iterator, key) { swConnectionIterator *itearator = swoole_get_object(getThis()); RETURN_LONG(itearator->index); } PHP_METHOD(swoole_connection_iterator, count) { swConnectionIterator *i = swoole_get_object(getThis()); if (i->port) { RETURN_LONG(i->port->connection_num); } else { RETURN_LONG(i->serv->stats->connection_num); } } PHP_METHOD(swoole_connection_iterator, offsetExists) { zval *zobject = (zval *) SwooleG.serv->ptr2; zval *retval = NULL; zval *zfd; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zfd) == FAILURE) { return; } sw_zend_call_method_with_1_params(&zobject, swoole_server_class_entry_ptr, NULL, "exist", &retval, zfd); if (retval) { RETVAL_BOOL(Z_BVAL_P(retval)); sw_zval_ptr_dtor(&retval); } } PHP_METHOD(swoole_connection_iterator, offsetGet) { zval *zobject = (zval *) SwooleG.serv->ptr2; zval *retval = NULL; zval *zfd; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zfd) == FAILURE) { return; } sw_zend_call_method_with_1_params(&zobject, swoole_server_class_entry_ptr, NULL, "connection_info", &retval, zfd); if (retval) { RETVAL_ZVAL(retval, 0, 0); } } PHP_METHOD(swoole_connection_iterator, offsetSet) { return; } PHP_METHOD(swoole_connection_iterator, offsetUnset) { return; } PHP_METHOD(swoole_connection_iterator, __destruct) { swConnectionIterator *i = swoole_get_object(getThis()); efree(i); swoole_set_object(getThis(), NULL); } #endif /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim600: noet sw=4 ts=4 fdm=marker * vim<600: noet sw=4 ts=4 */