1 /*
2 +----------------------------------------------------------------------+
3 | Swoole |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 2.0 of the Apache license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.apache.org/licenses/LICENSE-2.0.html |
9 | If you did not receive a copy of the Apache2.0 license and are unable|
10 | to obtain it through the world-wide-web, please send a note to |
11 | license@swoole.com so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Author: Tianfeng Han <mikan.tenny@gmail.com> |
14 +----------------------------------------------------------------------+
15 */
16 #include "php_swoole_cxx.h"
17 #include "php_swoole_library.h"
18 #include "php_swoole_process.h"
19
20 #if (HAVE_PCRE || HAVE_BUNDLED_PCRE) && !defined(COMPILE_DL_PCRE)
21 #include "ext/pcre/php_pcre.h"
22 #endif
23 #include "zend_exceptions.h"
24
25 BEGIN_EXTERN_C()
26 #ifdef SW_USE_JSON
27 #include "ext/json/php_json.h"
28 #endif
29 END_EXTERN_C()
30
31 #include "swoole_mime_type.h"
32 #include "swoole_server.h"
33 #include "swoole_util.h"
34
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37 #include <net/if.h>
38 #include <ifaddrs.h>
39 #include <sys/ioctl.h>
40
41 #if defined(__MACH__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
42 #include <net/if_dl.h>
43 #endif
44
45 #ifdef SW_HAVE_ZLIB
46 #include <zlib.h>
47 #endif
48 #ifdef SW_HAVE_BROTLI
49 #include <brotli/encode.h>
50 #include <brotli/decode.h>
51 #endif
52
53 #ifdef SW_USE_CARES
54 #include <ares.h>
55 #endif
56
57 using swoole::Server;
58 using swoole::network::Socket;
59
60 ZEND_DECLARE_MODULE_GLOBALS(swoole)
61
62 extern sapi_module_struct sapi_module;
63
64 static swoole::CallbackManager rshutdown_callbacks;
65
66 SW_EXTERN_C_BEGIN
67 static PHP_FUNCTION(swoole_version);
68 static PHP_FUNCTION(swoole_cpu_num);
69 static PHP_FUNCTION(swoole_strerror);
70 static PHP_FUNCTION(swoole_clear_error);
71 static PHP_FUNCTION(swoole_errno);
72 static PHP_FUNCTION(swoole_error_log);
73 static PHP_FUNCTION(swoole_error_log_ex);
74 static PHP_FUNCTION(swoole_ignore_error);
75 static PHP_FUNCTION(swoole_get_local_ip);
76 static PHP_FUNCTION(swoole_get_local_mac);
77 static PHP_FUNCTION(swoole_hashcode);
78 static PHP_FUNCTION(swoole_mime_type_add);
79 static PHP_FUNCTION(swoole_mime_type_set);
80 static PHP_FUNCTION(swoole_mime_type_delete);
81 static PHP_FUNCTION(swoole_mime_type_get);
82 static PHP_FUNCTION(swoole_mime_type_exists);
83 static PHP_FUNCTION(swoole_mime_type_list);
84 static PHP_FUNCTION(swoole_substr_unserialize);
85 #ifdef SW_USE_JSON
86 static PHP_FUNCTION(swoole_substr_json_decode);
87 #endif
88 static PHP_FUNCTION(swoole_internal_call_user_shutdown_begin);
89 SW_EXTERN_C_END
90
91 // clang-format off
92
93 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_void, 0, 0, 0)
94 ZEND_END_ARG_INFO()
95
96 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_async_set, 0, 0, 1)
97 ZEND_ARG_ARRAY_INFO(0, settings, 0)
98 ZEND_END_ARG_INFO()
99
100 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_async_dns_lookup_coro, 0, 0, 1)
101 ZEND_ARG_INFO(0, domain_name)
102 ZEND_ARG_INFO(0, timeout)
103 ZEND_ARG_INFO(0, type)
104 ZEND_END_ARG_INFO()
105
106 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_coroutine_create, 0, 0, 1)
107 ZEND_ARG_CALLABLE_INFO(0, func, 0)
108 ZEND_ARG_VARIADIC_INFO(0, params)
109 ZEND_END_ARG_INFO()
110
111 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_coroutine_defer, 0, 0, 1)
112 ZEND_ARG_CALLABLE_INFO(0, callback, 0)
113 ZEND_END_ARG_INFO()
114
115 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_coroutine_socketpair, 0, 0, 3)
116 ZEND_ARG_INFO(0, domain)
117 ZEND_ARG_INFO(0, type)
118 ZEND_ARG_INFO(0, protocol)
119 ZEND_END_ARG_INFO()
120
121 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_test_kernel_coroutine, 0, 0, 0)
122 ZEND_ARG_INFO(0, count)
123 ZEND_ARG_INFO(0, sleep_time)
124 ZEND_END_ARG_INFO()
125
126 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_client_select, 0, 0, 3)
127 ZEND_ARG_INFO(1, read_array)
128 ZEND_ARG_INFO(1, write_array)
129 ZEND_ARG_INFO(1, error_array)
130 ZEND_ARG_INFO(0, timeout)
131 ZEND_END_ARG_INFO()
132
133 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_substr_unserialize, 0, 0, 2)
134 ZEND_ARG_INFO(0, str)
135 ZEND_ARG_INFO(0, offset)
136 ZEND_ARG_INFO(0, length)
137 ZEND_ARG_INFO(0, options)
138 ZEND_END_ARG_INFO()
139
140 #ifdef SW_USE_JSON
141 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_substr_json_decode, 0, 0, 2)
142 ZEND_ARG_INFO(0, json)
143 ZEND_ARG_INFO(0, offset)
144 ZEND_ARG_INFO(0, length)
145 ZEND_ARG_INFO(0, associative)
146 ZEND_ARG_INFO(0, depth)
147 ZEND_ARG_INFO(0, flags)
148 ZEND_END_ARG_INFO()
149 #endif
150
151 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_set_process_name, 0, 0, 1)
152 ZEND_ARG_INFO(0, process_name)
153 ZEND_END_ARG_INFO()
154
155 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_strerror, 0, 0, 1)
156 ZEND_ARG_INFO(0, errno)
157 ZEND_ARG_INFO(0, error_type)
158 ZEND_END_ARG_INFO()
159
160 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_error_log, 0, 0, 2)
161 ZEND_ARG_INFO(0, level)
162 ZEND_ARG_INFO(0, msg)
163 ZEND_END_ARG_INFO()
164
165 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_error_log_ex, 0, 0, 3)
166 ZEND_ARG_INFO(0, level)
167 ZEND_ARG_INFO(0, error)
168 ZEND_ARG_INFO(0, msg)
169 ZEND_END_ARG_INFO()
170
171 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_ignore_error, 0, 0, 1)
172 ZEND_ARG_INFO(0, error)
173 ZEND_END_ARG_INFO()
174
175 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_hashcode, 0, 0, 1)
176 ZEND_ARG_INFO(0, data)
177 ZEND_ARG_INFO(0, type)
178 ZEND_END_ARG_INFO()
179
180 /* add/set */
181 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_mime_type_write, 0, 0, 2)
182 ZEND_ARG_INFO(0, suffix)
183 ZEND_ARG_INFO(0, mime_type)
184 ZEND_END_ARG_INFO()
185
186 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_mime_type_delete, 0, 0, 1)
187 ZEND_ARG_INFO(0, suffix)
188 ZEND_END_ARG_INFO()
189
190 /* get/exists */
191 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_mime_type_read, 0, 0, 1)
192 ZEND_ARG_INFO(0, filename)
193 ZEND_END_ARG_INFO()
194
195 #include "php_swoole_x_arginfo.h"
196
197 const zend_function_entry swoole_functions[] = {
198 PHP_FE(swoole_version, arginfo_swoole_void)
199 PHP_FE(swoole_cpu_num, arginfo_swoole_void)
200 PHP_FE(swoole_last_error, arginfo_swoole_void)
201 /*------swoole_async_io------*/
202 PHP_FE(swoole_async_dns_lookup_coro, arginfo_swoole_async_dns_lookup_coro)
203 PHP_FE(swoole_async_set, arginfo_swoole_async_set)
204 /*------swoole_coroutine------*/
205 PHP_FE(swoole_coroutine_create, arginfo_swoole_coroutine_create)
206 PHP_FE(swoole_coroutine_defer, arginfo_swoole_coroutine_defer)
207 PHP_FE(swoole_coroutine_socketpair, arginfo_swoole_coroutine_socketpair)
208 PHP_FE(swoole_test_kernel_coroutine, arginfo_swoole_test_kernel_coroutine)
209 /*------other-----*/
210 PHP_FE(swoole_client_select, arginfo_swoole_client_select)
211 PHP_FALIAS(swoole_select, swoole_client_select, arginfo_swoole_client_select)
212 PHP_FE(swoole_set_process_name, arginfo_swoole_set_process_name)
213 PHP_FE(swoole_get_local_ip, arginfo_swoole_void)
214 PHP_FE(swoole_get_local_mac, arginfo_swoole_void)
215 PHP_FE(swoole_strerror, arginfo_swoole_strerror)
216 PHP_FE(swoole_errno, arginfo_swoole_void)
217 PHP_FE(swoole_clear_error, arginfo_swoole_void)
218 PHP_FE(swoole_error_log, arginfo_swoole_error_log)
219 PHP_FE(swoole_error_log_ex, arginfo_swoole_error_log_ex)
220 PHP_FE(swoole_ignore_error, arginfo_swoole_ignore_error)
221 PHP_FE(swoole_hashcode, arginfo_swoole_hashcode)
222 PHP_FE(swoole_mime_type_add, arginfo_swoole_mime_type_write)
223 PHP_FE(swoole_mime_type_set, arginfo_swoole_mime_type_write)
224 PHP_FE(swoole_mime_type_delete, arginfo_swoole_mime_type_delete)
225 PHP_FE(swoole_mime_type_get, arginfo_swoole_mime_type_read)
226 PHP_FALIAS(swoole_get_mime_type, swoole_mime_type_get, arginfo_swoole_mime_type_read)
227 PHP_FE(swoole_mime_type_exists, arginfo_swoole_mime_type_read)
228 PHP_FE(swoole_mime_type_list, arginfo_swoole_void)
229 PHP_FE(swoole_clear_dns_cache, arginfo_swoole_void)
230 PHP_FE(swoole_substr_unserialize, arginfo_swoole_substr_unserialize)
231 #ifdef SW_USE_JSON
232 PHP_FE(swoole_substr_json_decode, arginfo_swoole_substr_json_decode)
233 #endif
234 PHP_FE(swoole_internal_call_user_shutdown_begin, arginfo_swoole_void)
235 // for admin server
236 ZEND_FE(swoole_get_objects, arginfo_swoole_get_objects)
237 ZEND_FE(swoole_get_vm_status, arginfo_swoole_get_vm_status)
238 ZEND_FE(swoole_get_object_by_handle, arginfo_swoole_get_object_by_handle)
239 PHP_FE_END /* Must be the last line in swoole_functions[] */
240 };
241
242 static const zend_module_dep swoole_deps[] = {
243 #ifdef SW_USE_JSON
244 ZEND_MOD_REQUIRED("json")
245 #endif
246 #ifdef SW_USE_MYSQLND
247 ZEND_MOD_REQUIRED("mysqlnd")
248 #endif
249 #ifdef SW_SOCKETS
250 ZEND_MOD_REQUIRED("sockets")
251 #endif
252 #ifdef SW_USE_CURL
253 ZEND_MOD_REQUIRED("curl")
254 #endif
255 ZEND_MOD_END
256 };
257
258 zend_module_entry swoole_module_entry = {
259 STANDARD_MODULE_HEADER_EX,
260 nullptr,
261 swoole_deps,
262 "swoole",
263 swoole_functions,
264 PHP_MINIT(swoole),
265 PHP_MSHUTDOWN(swoole),
266 PHP_RINIT(swoole), //RINIT
267 PHP_RSHUTDOWN(swoole), //RSHUTDOWN
268 PHP_MINFO(swoole),
269 PHP_SWOOLE_VERSION,
270 STANDARD_MODULE_PROPERTIES
271 };
272 // clang-format on
273
274 zend_class_entry *swoole_exception_ce;
275 zend_object_handlers swoole_exception_handlers;
276
277 zend_class_entry *swoole_error_ce;
278 zend_object_handlers swoole_error_handlers;
279
280 #ifdef COMPILE_DL_SWOOLE
281 ZEND_GET_MODULE(swoole)
282 #endif
283
284 // clang-format off
285 /* {{{ PHP_INI
286 */
287
PHP_INI_BEGIN()288 PHP_INI_BEGIN()
289 /**
290 * enable swoole coroutine
291 */
292 STD_ZEND_INI_BOOLEAN("swoole.enable_coroutine", "On", PHP_INI_ALL, OnUpdateBool, enable_coroutine, zend_swoole_globals, swoole_globals)
293 STD_ZEND_INI_BOOLEAN("swoole.enable_library", "On", PHP_INI_ALL, OnUpdateBool, enable_library, zend_swoole_globals, swoole_globals)
294 /**
295 * enable swoole coroutine epreemptive scheduler
296 */
297 STD_ZEND_INI_BOOLEAN("swoole.enable_preemptive_scheduler", "Off", PHP_INI_ALL, OnUpdateBool, enable_preemptive_scheduler, zend_swoole_globals, swoole_globals)
298 /**
299 * display error
300 */
301 STD_ZEND_INI_BOOLEAN("swoole.display_errors", "On", PHP_INI_ALL, OnUpdateBool, display_errors, zend_swoole_globals, swoole_globals)
302 /**
303 * use short class name
304 */
305 STD_ZEND_INI_BOOLEAN("swoole.use_shortname", "On", PHP_INI_SYSTEM, OnUpdateBool, use_shortname, zend_swoole_globals, swoole_globals)
306 /**
307 * unix socket buffer size
308 */
309 STD_PHP_INI_ENTRY("swoole.unixsock_buffer_size", ZEND_TOSTR(SW_SOCKET_BUFFER_SIZE), PHP_INI_ALL, OnUpdateLong, socket_buffer_size, zend_swoole_globals, swoole_globals)
310 PHP_INI_END()
311 // clang-format on
312
313 static void php_swoole_init_globals(zend_swoole_globals *swoole_globals) {
314 swoole_globals->enable_coroutine = 1;
315 swoole_globals->enable_library = 1;
316 swoole_globals->enable_preemptive_scheduler = 0;
317 swoole_globals->socket_buffer_size = SW_SOCKET_BUFFER_SIZE;
318 swoole_globals->display_errors = 1;
319 swoole_globals->use_shortname = 1;
320 }
321
php_swoole_register_shutdown_function(const char * function)322 void php_swoole_register_shutdown_function(const char *function) {
323 php_shutdown_function_entry shutdown_function_entry;
324 #if PHP_VERSION_ID >= 80100
325 zval function_name;
326 ZVAL_STRING(&function_name, function);
327 zend_fcall_info_init(
328 &function_name, 0, &shutdown_function_entry.fci, &shutdown_function_entry.fci_cache, NULL, NULL);
329 register_user_shutdown_function(Z_STRVAL(function_name), Z_STRLEN(function_name), &shutdown_function_entry);
330 #else
331 zval *function_name;
332 #if PHP_VERSION_ID >= 80000
333 shutdown_function_entry.arg_count = 0;
334 shutdown_function_entry.arguments = NULL;
335 function_name = &shutdown_function_entry.function_name;
336 #else
337 shutdown_function_entry.arg_count = 1;
338 shutdown_function_entry.arguments = (zval *) safe_emalloc(sizeof(zval), 1, 0);
339 function_name = &shutdown_function_entry.arguments[0];
340 #endif
341 ZVAL_STRING(function_name, function);
342 register_user_shutdown_function(Z_STRVAL_P(function_name), Z_STRLEN_P(function_name), &shutdown_function_entry);
343 #endif
344 }
345
php_swoole_set_global_option(HashTable * vht)346 void php_swoole_set_global_option(HashTable *vht) {
347 zval *ztmp;
348
349 #ifdef SW_DEBUG
350 if (php_swoole_array_get_value(vht, "debug_mode", ztmp) && zval_is_true(ztmp)) {
351 sw_logger()->set_level(0);
352 }
353 #endif
354 if (php_swoole_array_get_value(vht, "trace_flags", ztmp)) {
355 SwooleG.trace_flags = (uint32_t) SW_MAX(0, zval_get_long(ztmp));
356 }
357 if (php_swoole_array_get_value(vht, "log_file", ztmp)) {
358 sw_logger()->open(zend::String(ztmp).val());
359 }
360 if (php_swoole_array_get_value(vht, "log_level", ztmp)) {
361 sw_logger()->set_level(zval_get_long(ztmp));
362 }
363 if (php_swoole_array_get_value(vht, "log_date_format", ztmp)) {
364 sw_logger()->set_date_format(zend::String(ztmp).val());
365 }
366 if (php_swoole_array_get_value(vht, "log_date_with_microseconds", ztmp)) {
367 sw_logger()->set_date_with_microseconds(zval_is_true(ztmp));
368 }
369 if (php_swoole_array_get_value(vht, "log_rotation", ztmp)) {
370 sw_logger()->set_rotation(zval_get_long(ztmp));
371 }
372 if (php_swoole_array_get_value(vht, "display_errors", ztmp)) {
373 SWOOLE_G(display_errors) = zval_is_true(ztmp);
374 }
375 if (php_swoole_array_get_value(vht, "dns_server", ztmp)) {
376 swoole_set_dns_server(zend::String(ztmp).to_std_string());
377 }
378
379 auto timeout_format = [](zval *v) -> double {
380 double timeout = zval_get_double(v);
381 if (timeout <= 0 || timeout > INT_MAX) {
382 return INT_MAX;
383 } else {
384 return timeout;
385 }
386 };
387
388 if (php_swoole_array_get_value(vht, "socket_dns_timeout", ztmp)) {
389 Socket::default_dns_timeout = timeout_format(ztmp);
390 }
391 if (php_swoole_array_get_value(vht, "socket_connect_timeout", ztmp)) {
392 Socket::default_connect_timeout = timeout_format(ztmp);
393 }
394 if (php_swoole_array_get_value(vht, "socket_write_timeout", ztmp) ||
395 php_swoole_array_get_value(vht, "socket_send_timeout", ztmp)) {
396 Socket::default_write_timeout = timeout_format(ztmp);
397 }
398 if (php_swoole_array_get_value(vht, "socket_read_timeout", ztmp) ||
399 php_swoole_array_get_value(vht, "socket_recv_timeout", ztmp)) {
400 Socket::default_read_timeout = timeout_format(ztmp);
401 }
402 if (php_swoole_array_get_value(vht, "socket_buffer_size", ztmp)) {
403 Socket::default_buffer_size = zval_get_long(ztmp);
404 }
405 if (php_swoole_array_get_value(vht, "socket_timeout", ztmp)) {
406 Socket::default_read_timeout = Socket::default_write_timeout = timeout_format(ztmp);
407 }
408 }
409
php_swoole_register_rshutdown_callback(swoole::Callback cb,void * private_data)410 void php_swoole_register_rshutdown_callback(swoole::Callback cb, void *private_data) {
411 rshutdown_callbacks.append(cb, private_data);
412 }
413
php_swoole_is_enable_coroutine()414 SW_API bool php_swoole_is_enable_coroutine() {
415 if (sw_server()) {
416 return sw_server()->is_enable_coroutine();
417 } else {
418 return SWOOLE_G(enable_coroutine);
419 }
420 }
421
fatal_error(int code,const char * format,...)422 static void fatal_error(int code, const char *format, ...) {
423 va_list args;
424 va_start(args, format);
425 zend_object *exception =
426 zend_throw_exception(swoole_error_ce, swoole::std_string::vformat(format, args).c_str(), code);
427 va_end(args);
428
429 zend_try {
430 zend_exception_error(exception, E_ERROR);
431 }
432 zend_catch {
433 exit(255);
434 }
435 zend_end_try();
436 }
437
bug_report_message_init()438 static void bug_report_message_init() {
439 SwooleG.bug_report_message += swoole::std_string::format("PHP_VERSION : %s\n", PHP_VERSION);
440 }
441
442 /* {{{ PHP_MINIT_FUNCTION
443 */
PHP_MINIT_FUNCTION(swoole)444 PHP_MINIT_FUNCTION(swoole) {
445 ZEND_INIT_MODULE_GLOBALS(swoole, php_swoole_init_globals, nullptr);
446 REGISTER_INI_ENTRIES();
447
448 // clang-format off
449 // MUST be on the same line for the inspection tool to recognize correctly
450 SW_REGISTER_STRING_CONSTANT("SWOOLE_VERSION", SWOOLE_VERSION);
451 SW_REGISTER_LONG_CONSTANT("SWOOLE_VERSION_ID", SWOOLE_VERSION_ID);
452 SW_REGISTER_LONG_CONSTANT("SWOOLE_MAJOR_VERSION", SWOOLE_MAJOR_VERSION);
453 SW_REGISTER_LONG_CONSTANT("SWOOLE_MINOR_VERSION", SWOOLE_MINOR_VERSION);
454 SW_REGISTER_LONG_CONSTANT("SWOOLE_RELEASE_VERSION", SWOOLE_RELEASE_VERSION);
455 SW_REGISTER_STRING_CONSTANT("SWOOLE_EXTRA_VERSION", SWOOLE_EXTRA_VERSION);
456 #ifndef SW_DEBUG
457 SW_REGISTER_BOOL_CONSTANT("SWOOLE_DEBUG", 0);
458 #else
459 SW_REGISTER_BOOL_CONSTANT("SWOOLE_DEBUG", 1);
460 #endif
461
462 #ifdef SW_HAVE_COMPRESSION
463 SW_REGISTER_BOOL_CONSTANT("SWOOLE_HAVE_COMPRESSION", 1);
464 #endif
465 #ifdef SW_HAVE_ZLIB
466 SW_REGISTER_BOOL_CONSTANT("SWOOLE_HAVE_ZLIB", 1);
467 #endif
468 #ifdef SW_HAVE_BROTLI
469 SW_REGISTER_BOOL_CONSTANT("SWOOLE_HAVE_BROTLI", 1);
470 #endif
471 #ifdef SW_USE_HTTP2
472 SW_REGISTER_BOOL_CONSTANT("SWOOLE_USE_HTTP2", 1);
473 #endif
474
475 SW_REGISTER_BOOL_CONSTANT("SWOOLE_USE_SHORTNAME", SWOOLE_G(use_shortname));
476
477 /**
478 * socket type
479 */
480 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_TCP", SW_SOCK_TCP);
481 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_TCP6", SW_SOCK_TCP6);
482 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_UDP", SW_SOCK_UDP);
483 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_UDP6", SW_SOCK_UDP6);
484 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_UNIX_DGRAM", SW_SOCK_UNIX_DGRAM);
485 SW_REGISTER_LONG_CONSTANT("SWOOLE_SOCK_UNIX_STREAM", SW_SOCK_UNIX_STREAM);
486
487 /**
488 * simple socket type alias
489 */
490 SW_REGISTER_LONG_CONSTANT("SWOOLE_TCP", SW_SOCK_TCP);
491 SW_REGISTER_LONG_CONSTANT("SWOOLE_TCP6", SW_SOCK_TCP6);
492 SW_REGISTER_LONG_CONSTANT("SWOOLE_UDP", SW_SOCK_UDP);
493 SW_REGISTER_LONG_CONSTANT("SWOOLE_UDP6", SW_SOCK_UDP6);
494 SW_REGISTER_LONG_CONSTANT("SWOOLE_UNIX_DGRAM", SW_SOCK_UNIX_DGRAM);
495 SW_REGISTER_LONG_CONSTANT("SWOOLE_UNIX_STREAM", SW_SOCK_UNIX_STREAM);
496
497 /**
498 * simple api
499 */
500 SW_REGISTER_BOOL_CONSTANT("SWOOLE_SOCK_SYNC", 0);
501 SW_REGISTER_BOOL_CONSTANT("SWOOLE_SOCK_ASYNC", 1);
502
503 SW_REGISTER_LONG_CONSTANT("SWOOLE_SYNC", SW_FLAG_SYNC);
504 SW_REGISTER_LONG_CONSTANT("SWOOLE_ASYNC", SW_FLAG_ASYNC);
505 SW_REGISTER_LONG_CONSTANT("SWOOLE_KEEP", SW_FLAG_KEEP);
506
507 #ifdef SW_USE_OPENSSL
508 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL", SW_SOCK_SSL);
509
510 /**
511 * SSL methods
512 */
513 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv3_METHOD", SW_SSLv3_METHOD);
514 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv3_SERVER_METHOD", SW_SSLv3_SERVER_METHOD);
515 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv3_CLIENT_METHOD", SW_SSLv3_CLIENT_METHOD);
516
517 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_METHOD", SW_TLSv1_METHOD);
518 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_SERVER_METHOD", SW_TLSv1_SERVER_METHOD);
519 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_CLIENT_METHOD", SW_TLSv1_CLIENT_METHOD);
520
521 #ifdef TLS1_1_VERSION
522 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_1_METHOD", SW_TLSv1_1_METHOD);
523 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_1_SERVER_METHOD", SW_TLSv1_1_SERVER_METHOD);
524 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_1_CLIENT_METHOD", SW_TLSv1_1_CLIENT_METHOD);
525 #endif
526
527 #ifdef TLS1_2_VERSION
528 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_2_METHOD", SW_TLSv1_2_METHOD);
529 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_2_SERVER_METHOD", SW_TLSv1_2_SERVER_METHOD);
530 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLSv1_2_CLIENT_METHOD", SW_TLSv1_2_CLIENT_METHOD);
531 #endif
532
533 #ifdef SW_SUPPORT_DTLS
534 SW_REGISTER_LONG_CONSTANT("SWOOLE_DTLS_SERVER_METHOD", SW_DTLS_SERVER_METHOD);
535 SW_REGISTER_LONG_CONSTANT("SWOOLE_DTLS_CLIENT_METHOD", SW_DTLS_CLIENT_METHOD);
536 #endif
537
538 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv23_METHOD", SW_SSLv23_METHOD);
539 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv23_SERVER_METHOD", SW_SSLv23_SERVER_METHOD);
540 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSLv23_CLIENT_METHOD", SW_SSLv23_CLIENT_METHOD);
541 /* SSLv23_method have been renamed to TLS_method */
542 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLS_METHOD", SW_SSLv23_METHOD);
543 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLS_SERVER_METHOD", SW_SSLv23_SERVER_METHOD);
544 SW_REGISTER_LONG_CONSTANT("SWOOLE_TLS_CLIENT_METHOD", SW_SSLv23_CLIENT_METHOD);
545
546 /**
547 * SSL protocols
548 */
549 #ifdef HAVE_SSL3
550 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_SSLv3", SW_SSL_SSLv3);
551 #endif
552 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_TLSv1", SW_SSL_TLSv1);
553
554 #ifdef TLS1_1_VERSION
555 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_TLSv1_1", SW_SSL_TLSv1_1);
556 #endif
557
558 #ifdef TLS1_2_VERSION
559 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_TLSv1_2", SW_SSL_TLSv1_2);
560 #endif
561
562 #ifdef TLS1_3_VERSION
563 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_TLSv1_3", SW_SSL_TLSv1_3);
564 #endif
565
566 #ifdef SW_SUPPORT_DTLS
567 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_DTLS", SW_SSL_DTLS);
568 #endif
569
570 SW_REGISTER_LONG_CONSTANT("SWOOLE_SSL_SSLv2", SW_SSL_SSLv2);
571 #endif
572
573 SW_REGISTER_LONG_CONSTANT("SWOOLE_EVENT_READ", SW_EVENT_READ);
574 SW_REGISTER_LONG_CONSTANT("SWOOLE_EVENT_WRITE", SW_EVENT_WRITE);
575
576 /**
577 * Register ERROR types
578 */
579 SW_REGISTER_LONG_CONSTANT("SWOOLE_STRERROR_SYSTEM", SW_STRERROR_SYSTEM);
580 SW_REGISTER_LONG_CONSTANT("SWOOLE_STRERROR_GAI", SW_STRERROR_GAI);
581 SW_REGISTER_LONG_CONSTANT("SWOOLE_STRERROR_DNS", SW_STRERROR_DNS);
582 SW_REGISTER_LONG_CONSTANT("SWOOLE_STRERROR_SWOOLE", SW_STRERROR_SWOOLE);
583
584 /**
585 * Register ERROR constants
586 */
587 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_MALLOC_FAIL", SW_ERROR_MALLOC_FAIL);
588 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SYSTEM_CALL_FAIL", SW_ERROR_SYSTEM_CALL_FAIL);
589 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_PHP_FATAL_ERROR", SW_ERROR_PHP_FATAL_ERROR);
590 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_NAME_TOO_LONG", SW_ERROR_NAME_TOO_LONG);
591 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_INVALID_PARAMS", SW_ERROR_INVALID_PARAMS);
592 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_QUEUE_FULL", SW_ERROR_QUEUE_FULL);
593 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_OPERATION_NOT_SUPPORT", SW_ERROR_OPERATION_NOT_SUPPORT);
594 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_PROTOCOL_ERROR", SW_ERROR_PROTOCOL_ERROR);
595 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WRONG_OPERATION", SW_ERROR_WRONG_OPERATION);
596 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_FILE_NOT_EXIST", SW_ERROR_FILE_NOT_EXIST);
597 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_FILE_TOO_LARGE", SW_ERROR_FILE_TOO_LARGE);
598 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_FILE_EMPTY", SW_ERROR_FILE_EMPTY);
599 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DNSLOOKUP_DUPLICATE_REQUEST", SW_ERROR_DNSLOOKUP_DUPLICATE_REQUEST);
600 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DNSLOOKUP_RESOLVE_FAILED", SW_ERROR_DNSLOOKUP_RESOLVE_FAILED);
601 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DNSLOOKUP_RESOLVE_TIMEOUT", SW_ERROR_DNSLOOKUP_RESOLVE_TIMEOUT);
602 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DNSLOOKUP_UNSUPPORTED", SW_ERROR_DNSLOOKUP_UNSUPPORTED);
603 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DNSLOOKUP_NO_SERVER", SW_ERROR_DNSLOOKUP_NO_SERVER);
604 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_BAD_IPV6_ADDRESS", SW_ERROR_BAD_IPV6_ADDRESS);
605 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_UNREGISTERED_SIGNAL", SW_ERROR_UNREGISTERED_SIGNAL);
606 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_EVENT_SOCKET_REMOVED", SW_ERROR_EVENT_SOCKET_REMOVED);
607 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_CLOSED_BY_SERVER", SW_ERROR_SESSION_CLOSED_BY_SERVER);
608 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_CLOSED_BY_CLIENT", SW_ERROR_SESSION_CLOSED_BY_CLIENT);
609 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_CLOSING", SW_ERROR_SESSION_CLOSING);
610 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_CLOSED", SW_ERROR_SESSION_CLOSED);
611 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_NOT_EXIST", SW_ERROR_SESSION_NOT_EXIST);
612 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_INVALID_ID", SW_ERROR_SESSION_INVALID_ID);
613 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_DISCARD_TIMEOUT_DATA", SW_ERROR_SESSION_DISCARD_TIMEOUT_DATA);
614 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SESSION_DISCARD_DATA", SW_ERROR_SESSION_DISCARD_DATA);
615 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_OUTPUT_BUFFER_OVERFLOW", SW_ERROR_OUTPUT_BUFFER_OVERFLOW);
616 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_OUTPUT_SEND_YIELD", SW_ERROR_OUTPUT_SEND_YIELD);
617 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_NOT_READY", SW_ERROR_SSL_NOT_READY);
618 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_CANNOT_USE_SENFILE", SW_ERROR_SSL_CANNOT_USE_SENFILE);
619 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_EMPTY_PEER_CERTIFICATE", SW_ERROR_SSL_EMPTY_PEER_CERTIFICATE);
620 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_VERIFY_FAILED", SW_ERROR_SSL_VERIFY_FAILED);
621 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_BAD_CLIENT", SW_ERROR_SSL_BAD_CLIENT);
622 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_BAD_PROTOCOL", SW_ERROR_SSL_BAD_PROTOCOL);
623 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_RESET", SW_ERROR_SSL_RESET);
624 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SSL_HANDSHAKE_FAILED", SW_ERROR_SSL_HANDSHAKE_FAILED);
625 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_PACKAGE_LENGTH_TOO_LARGE", SW_ERROR_PACKAGE_LENGTH_TOO_LARGE);
626 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_PACKAGE_LENGTH_NOT_FOUND", SW_ERROR_PACKAGE_LENGTH_NOT_FOUND);
627 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_DATA_LENGTH_TOO_LARGE", SW_ERROR_DATA_LENGTH_TOO_LARGE);
628 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_PACKAGE_MALFORMED_DATA", SW_ERROR_PACKAGE_MALFORMED_DATA);
629 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_TASK_PACKAGE_TOO_BIG", SW_ERROR_TASK_PACKAGE_TOO_BIG);
630 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_TASK_DISPATCH_FAIL", SW_ERROR_TASK_DISPATCH_FAIL);
631 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_TASK_TIMEOUT", SW_ERROR_TASK_TIMEOUT);
632 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP2_STREAM_ID_TOO_BIG", SW_ERROR_HTTP2_STREAM_ID_TOO_BIG);
633 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP2_STREAM_NO_HEADER", SW_ERROR_HTTP2_STREAM_NO_HEADER);
634 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP2_STREAM_NOT_FOUND", SW_ERROR_HTTP2_STREAM_NOT_FOUND);
635 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP2_STREAM_IGNORE", SW_ERROR_HTTP2_STREAM_IGNORE);
636 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_AIO_BAD_REQUEST", SW_ERROR_AIO_BAD_REQUEST);
637 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_AIO_CANCELED", SW_ERROR_AIO_CANCELED);
638 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_AIO_TIMEOUT", SW_ERROR_AIO_TIMEOUT);
639 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CLIENT_NO_CONNECTION", SW_ERROR_CLIENT_NO_CONNECTION);
640 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKET_CLOSED", SW_ERROR_SOCKET_CLOSED);
641 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKET_POLL_TIMEOUT", SW_ERROR_SOCKET_POLL_TIMEOUT);
642 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKS5_UNSUPPORT_VERSION", SW_ERROR_SOCKS5_UNSUPPORT_VERSION);
643 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKS5_UNSUPPORT_METHOD", SW_ERROR_SOCKS5_UNSUPPORT_METHOD);
644 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKS5_AUTH_FAILED", SW_ERROR_SOCKS5_AUTH_FAILED);
645 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKS5_SERVER_ERROR", SW_ERROR_SOCKS5_SERVER_ERROR);
646 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SOCKS5_HANDSHAKE_FAILED", SW_ERROR_SOCKS5_HANDSHAKE_FAILED);
647 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP_PROXY_HANDSHAKE_ERROR", SW_ERROR_HTTP_PROXY_HANDSHAKE_ERROR);
648 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP_INVALID_PROTOCOL", SW_ERROR_HTTP_INVALID_PROTOCOL);
649 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP_PROXY_HANDSHAKE_FAILED", SW_ERROR_HTTP_PROXY_HANDSHAKE_FAILED);
650 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_HTTP_PROXY_BAD_RESPONSE", SW_ERROR_HTTP_PROXY_BAD_RESPONSE);
651 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_BAD_CLIENT", SW_ERROR_WEBSOCKET_BAD_CLIENT);
652 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_BAD_OPCODE", SW_ERROR_WEBSOCKET_BAD_OPCODE);
653 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_UNCONNECTED", SW_ERROR_WEBSOCKET_UNCONNECTED);
654 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_HANDSHAKE_FAILED", SW_ERROR_WEBSOCKET_HANDSHAKE_FAILED);
655 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_PACK_FAILED", SW_ERROR_WEBSOCKET_PACK_FAILED);
656 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_UNPACK_FAILED", SW_ERROR_WEBSOCKET_UNPACK_FAILED);
657 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_WEBSOCKET_INCOMPLETE_PACKET", SW_ERROR_WEBSOCKET_INCOMPLETE_PACKET);
658 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_MUST_CREATED_BEFORE_CLIENT", SW_ERROR_SERVER_MUST_CREATED_BEFORE_CLIENT);
659 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_TOO_MANY_SOCKET", SW_ERROR_SERVER_TOO_MANY_SOCKET);
660 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_WORKER_TERMINATED", SW_ERROR_SERVER_WORKER_TERMINATED);
661 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_INVALID_LISTEN_PORT", SW_ERROR_SERVER_INVALID_LISTEN_PORT);
662 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_TOO_MANY_LISTEN_PORT", SW_ERROR_SERVER_TOO_MANY_LISTEN_PORT);
663 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_PIPE_BUFFER_FULL", SW_ERROR_SERVER_PIPE_BUFFER_FULL);
664 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_NO_IDLE_WORKER", SW_ERROR_SERVER_NO_IDLE_WORKER);
665 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_ONLY_START_ONE", SW_ERROR_SERVER_ONLY_START_ONE);
666 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_SEND_IN_MASTER", SW_ERROR_SERVER_SEND_IN_MASTER);
667 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_INVALID_REQUEST", SW_ERROR_SERVER_INVALID_REQUEST);
668 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_CONNECT_FAIL", SW_ERROR_SERVER_CONNECT_FAIL);
669 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_INVALID_COMMAND", SW_ERROR_SERVER_INVALID_COMMAND);
670 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_WORKER_EXIT_TIMEOUT", SW_ERROR_SERVER_WORKER_EXIT_TIMEOUT);
671 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_WORKER_ABNORMAL_PIPE_DATA", SW_ERROR_SERVER_WORKER_ABNORMAL_PIPE_DATA);
672 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_SERVER_WORKER_UNPROCESSED_DATA", SW_ERROR_SERVER_WORKER_UNPROCESSED_DATA);
673 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_OUT_OF_COROUTINE", SW_ERROR_CO_OUT_OF_COROUTINE);
674 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_HAS_BEEN_BOUND", SW_ERROR_CO_HAS_BEEN_BOUND);
675 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_HAS_BEEN_DISCARDED", SW_ERROR_CO_HAS_BEEN_DISCARDED);
676 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_MUTEX_DOUBLE_UNLOCK", SW_ERROR_CO_MUTEX_DOUBLE_UNLOCK);
677 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_BLOCK_OBJECT_LOCKED", SW_ERROR_CO_BLOCK_OBJECT_LOCKED);
678 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_BLOCK_OBJECT_WAITING", SW_ERROR_CO_BLOCK_OBJECT_WAITING);
679 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_YIELD_FAILED", SW_ERROR_CO_YIELD_FAILED);
680 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_GETCONTEXT_FAILED", SW_ERROR_CO_GETCONTEXT_FAILED);
681 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_SWAPCONTEXT_FAILED", SW_ERROR_CO_SWAPCONTEXT_FAILED);
682 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_MAKECONTEXT_FAILED", SW_ERROR_CO_MAKECONTEXT_FAILED);
683 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_IOCPINIT_FAILED", SW_ERROR_CO_IOCPINIT_FAILED);
684 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_PROTECT_STACK_FAILED", SW_ERROR_CO_PROTECT_STACK_FAILED);
685 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_STD_THREAD_LINK_ERROR", SW_ERROR_CO_STD_THREAD_LINK_ERROR);
686 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_DISABLED_MULTI_THREAD", SW_ERROR_CO_DISABLED_MULTI_THREAD);
687 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_CANNOT_CANCEL", SW_ERROR_CO_CANNOT_CANCEL);
688 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_NOT_EXISTS", SW_ERROR_CO_NOT_EXISTS);
689 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_CANCELED", SW_ERROR_CO_CANCELED);
690 SW_REGISTER_LONG_CONSTANT("SWOOLE_ERROR_CO_TIMEDOUT", SW_ERROR_CO_TIMEDOUT);
691
692 /**
693 * trace log
694 */
695 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_SERVER", SW_TRACE_SERVER);
696 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CLIENT", SW_TRACE_CLIENT);
697 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_BUFFER", SW_TRACE_BUFFER);
698 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CONN", SW_TRACE_CONN);
699 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_EVENT", SW_TRACE_EVENT);
700 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_WORKER", SW_TRACE_WORKER);
701 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_MEMORY", SW_TRACE_MEMORY);
702 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_REACTOR", SW_TRACE_REACTOR);
703 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_PHP", SW_TRACE_PHP);
704 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_HTTP", SW_TRACE_HTTP);
705 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_HTTP2", SW_TRACE_HTTP2);
706 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_EOF_PROTOCOL", SW_TRACE_EOF_PROTOCOL);
707 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_LENGTH_PROTOCOL", SW_TRACE_LENGTH_PROTOCOL);
708 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CLOSE", SW_TRACE_CLOSE);
709 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_WEBSOCKET", SW_TRACE_WEBSOCKET);
710 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_REDIS_CLIENT", SW_TRACE_REDIS_CLIENT);
711 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_MYSQL_CLIENT", SW_TRACE_MYSQL_CLIENT);
712 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_HTTP_CLIENT", SW_TRACE_HTTP_CLIENT);
713 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_AIO", SW_TRACE_AIO);
714 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_SSL", SW_TRACE_SSL);
715 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_NORMAL", SW_TRACE_NORMAL);
716 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CHANNEL", SW_TRACE_CHANNEL);
717 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_TIMER", SW_TRACE_TIMER);
718 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_SOCKET", SW_TRACE_SOCKET);
719 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_COROUTINE", SW_TRACE_COROUTINE);
720 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CONTEXT", SW_TRACE_CONTEXT);
721 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CO_HTTP_SERVER", SW_TRACE_CO_HTTP_SERVER);
722 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_TABLE", SW_TRACE_TABLE);
723 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CO_CURL", SW_TRACE_CO_CURL);
724 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_CARES", SW_TRACE_CARES);
725 SW_REGISTER_LONG_CONSTANT("SWOOLE_TRACE_ALL", SW_TRACE_ALL);
726
727 /**
728 * log level
729 */
730 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_DEBUG", SW_LOG_DEBUG);
731 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_TRACE", SW_LOG_TRACE);
732 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_INFO", SW_LOG_INFO);
733 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_NOTICE", SW_LOG_NOTICE);
734 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_WARNING", SW_LOG_WARNING);
735 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ERROR", SW_LOG_ERROR);
736 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_NONE", SW_LOG_NONE);
737
738 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ROTATION_SINGLE", SW_LOG_ROTATION_SINGLE);
739 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ROTATION_MONTHLY", SW_LOG_ROTATION_MONTHLY);
740 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ROTATION_DAILY", SW_LOG_ROTATION_DAILY);
741 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ROTATION_HOURLY", SW_LOG_ROTATION_HOURLY);
742 SW_REGISTER_LONG_CONSTANT("SWOOLE_LOG_ROTATION_EVERY_MINUTE", SW_LOG_ROTATION_EVERY_MINUTE);
743
744 SW_REGISTER_LONG_CONSTANT("SWOOLE_IPC_NONE", SW_IPC_NONE);
745 SW_REGISTER_LONG_CONSTANT("SWOOLE_IPC_UNIXSOCK", SW_IPC_UNIXSOCK);
746 SW_REGISTER_LONG_CONSTANT("SWOOLE_IPC_SOCKET", SW_IPC_SOCKET);
747
748 /**
749 * limit
750 */
751 SW_REGISTER_LONG_CONSTANT("SWOOLE_IOV_MAX", IOV_MAX);
752
753 // clang-format on
754
755 if (SWOOLE_G(use_shortname)) {
756 SW_FUNCTION_ALIAS(CG(function_table), "swoole_coroutine_create", CG(function_table), "go");
757 SW_FUNCTION_ALIAS(CG(function_table), "swoole_coroutine_defer", CG(function_table), "defer");
758 }
759
760 swoole_init();
761
762 // init bug report message
763 bug_report_message_init();
764 if (strcmp("cli", sapi_module.name) == 0 || strcmp("phpdbg", sapi_module.name) == 0) {
765 SWOOLE_G(cli) = 1;
766 }
767
768 SW_INIT_CLASS_ENTRY_EX2(swoole_exception,
769 "Swoole\\Exception",
770 "swoole_exception",
771 nullptr,
772 nullptr,
773 zend_ce_exception,
774 zend_get_std_object_handlers());
775
776 SW_INIT_CLASS_ENTRY_EX2(
777 swoole_error, "Swoole\\Error", "swoole_error", nullptr, nullptr, zend_ce_error, zend_get_std_object_handlers());
778
779 /** <Sort by dependency> **/
780 php_swoole_event_minit(module_number);
781 // base
782 php_swoole_atomic_minit(module_number);
783 php_swoole_lock_minit(module_number);
784 php_swoole_process_minit(module_number);
785 php_swoole_process_pool_minit(module_number);
786 php_swoole_table_minit(module_number);
787 php_swoole_timer_minit(module_number);
788 // coroutine
789 php_swoole_coroutine_minit(module_number);
790 php_swoole_coroutine_system_minit(module_number);
791 php_swoole_coroutine_scheduler_minit(module_number);
792 php_swoole_channel_coro_minit(module_number);
793 php_swoole_runtime_minit(module_number);
794 // client
795 php_swoole_socket_coro_minit(module_number);
796 php_swoole_client_minit(module_number);
797 php_swoole_client_coro_minit(module_number);
798 php_swoole_http_client_coro_minit(module_number);
799 php_swoole_mysql_coro_minit(module_number);
800 php_swoole_redis_coro_minit(module_number);
801 #ifdef SW_USE_HTTP2
802 php_swoole_http2_client_coro_minit(module_number);
803 #endif
804 // server
805 php_swoole_server_minit(module_number);
806 php_swoole_server_port_minit(module_number);
807 php_swoole_http_request_minit(module_number);
808 php_swoole_http_response_minit(module_number);
809 php_swoole_http_server_minit(module_number);
810 php_swoole_http_server_coro_minit(module_number);
811 php_swoole_websocket_server_minit(module_number);
812 php_swoole_redis_server_minit(module_number);
813
814 SwooleG.fatal_error = fatal_error;
815 Socket::default_buffer_size = SWOOLE_G(socket_buffer_size);
816 SwooleG.dns_cache_refresh_time = 60;
817
818 // enable pcre.jit and use swoole extension on MacOS will lead to coredump, disable it temporarily
819 #if defined(PHP_PCRE_VERSION) && defined(HAVE_PCRE_JIT_SUPPORT) && PHP_VERSION_ID >= 70300 && __MACH__ && \
820 !defined(SW_DEBUG)
821 PCRE_G(jit) = 0;
822 #endif
823
824 zend::known_strings_init();
825
826 return SUCCESS;
827 }
828 /* }}} */
829
830 /* {{{ PHP_MSHUTDOWN_FUNCTION
831 */
PHP_MSHUTDOWN_FUNCTION(swoole)832 PHP_MSHUTDOWN_FUNCTION(swoole) {
833 swoole_clean();
834 zend::known_strings_dtor();
835 php_swoole_runtime_mshutdown();
836
837 return SUCCESS;
838 }
839 /* }}} */
840
841 /* {{{ PHP_MINFO_FUNCTION
842 */
PHP_MINFO_FUNCTION(swoole)843 PHP_MINFO_FUNCTION(swoole) {
844 char buf[64];
845 php_info_print_table_start();
846 php_info_print_table_header(2, "Swoole", "enabled");
847 php_info_print_table_row(2, "Author", "Swoole Team <team@swoole.com>");
848 php_info_print_table_row(2, "Version", SWOOLE_VERSION);
849 snprintf(buf, sizeof(buf), "%s %s", __DATE__, __TIME__);
850 php_info_print_table_row(2, "Built", buf);
851 #if defined(SW_USE_THREAD_CONTEXT)
852 php_info_print_table_row(2, "coroutine", "enabled with thread context");
853 #elif defined(SW_USE_ASM_CONTEXT)
854 php_info_print_table_row(2, "coroutine", "enabled with boost asm context");
855 #else
856 php_info_print_table_row(2, "coroutine", "enabled with ucontext");
857 #endif
858 #ifdef SW_DEBUG
859 php_info_print_table_row(2, "debug", "enabled");
860 #endif
861 #ifdef SW_LOG_TRACE_OPEN
862 php_info_print_table_row(2, "trace_log", "enabled");
863 #endif
864 #ifdef HAVE_EPOLL
865 php_info_print_table_row(2, "epoll", "enabled");
866 #endif
867 #ifdef HAVE_EVENTFD
868 php_info_print_table_row(2, "eventfd", "enabled");
869 #endif
870 #ifdef HAVE_KQUEUE
871 php_info_print_table_row(2, "kqueue", "enabled");
872 #endif
873 #ifdef HAVE_SIGNALFD
874 php_info_print_table_row(2, "signalfd", "enabled");
875 #endif
876 #ifdef SW_USE_ACCEPT4
877 php_info_print_table_row(2, "accept4", "enabled");
878 #endif
879 #ifdef HAVE_CPU_AFFINITY
880 php_info_print_table_row(2, "cpu_affinity", "enabled");
881 #endif
882 #ifdef HAVE_SPINLOCK
883 php_info_print_table_row(2, "spinlock", "enabled");
884 #endif
885 #ifdef HAVE_RWLOCK
886 php_info_print_table_row(2, "rwlock", "enabled");
887 #endif
888 #ifdef SW_SOCKETS
889 php_info_print_table_row(2, "sockets", "enabled");
890 #endif
891 #ifdef SW_USE_OPENSSL
892 #ifdef OPENSSL_VERSION_TEXT
893 php_info_print_table_row(2, "openssl", OPENSSL_VERSION_TEXT);
894 #else
895 php_info_print_table_row(2, "openssl", "enabled");
896 #endif
897 #ifdef SW_SUPPORT_DTLS
898 php_info_print_table_row(2, "dtls", "enabled");
899 #endif
900 #endif
901 #ifdef SW_USE_HTTP2
902 php_info_print_table_row(2, "http2", "enabled");
903 #endif
904 #ifdef SW_USE_JSON
905 php_info_print_table_row(2, "json", "enabled");
906 #endif
907 #ifdef SW_USE_CURL
908 php_info_print_table_row(2, "curl-native", "enabled");
909 #endif
910 #ifdef HAVE_PCRE
911 php_info_print_table_row(2, "pcre", "enabled");
912 #endif
913 #ifdef SW_USE_CARES
914 php_info_print_table_row(2, "c-ares", ares_version(nullptr));
915 #endif
916 #ifdef SW_HAVE_ZLIB
917 #ifdef ZLIB_VERSION
918 php_info_print_table_row(2, "zlib", ZLIB_VERSION);
919 #else
920 php_info_print_table_row(2, "zlib", "enabled");
921 #endif
922 #endif
923 #ifdef SW_HAVE_BROTLI
924 snprintf(buf, sizeof(buf), "E%u/D%u", BrotliEncoderVersion(), BrotliDecoderVersion());
925 php_info_print_table_row(2, "brotli", buf);
926 #endif
927 #ifdef HAVE_MUTEX_TIMEDLOCK
928 php_info_print_table_row(2, "mutex_timedlock", "enabled");
929 #endif
930 #ifdef HAVE_PTHREAD_BARRIER
931 php_info_print_table_row(2, "pthread_barrier", "enabled");
932 #endif
933 #ifdef HAVE_FUTEX
934 php_info_print_table_row(2, "futex", "enabled");
935 #endif
936 #ifdef SW_USE_MYSQLND
937 php_info_print_table_row(2, "mysqlnd", "enabled");
938 #endif
939 #ifdef SW_USE_JEMALLOC
940 php_info_print_table_row(2, "jemalloc", "enabled");
941 #endif
942 #ifdef SW_USE_TCMALLOC
943 php_info_print_table_row(2, "tcmalloc", "enabled");
944 #endif
945 php_info_print_table_row(2, "async_redis", "enabled");
946 #ifdef SW_USE_POSTGRESQL
947 php_info_print_table_row(2, "coroutine_postgresql", "enabled");
948 #endif
949 php_info_print_table_end();
950
951 DISPLAY_INI_ENTRIES();
952 }
953 /* }}} */
954
_sw_emalloc(size_t size)955 static void *_sw_emalloc(size_t size) {
956 return emalloc(size);
957 }
958
_sw_ecalloc(size_t nmemb,size_t size)959 static void *_sw_ecalloc(size_t nmemb, size_t size) {
960 return ecalloc(nmemb, size);
961 }
962
_sw_erealloc(void * address,size_t size)963 static void *_sw_erealloc(void *address, size_t size) {
964 return erealloc(address, size);
965 }
966
_sw_efree(void * address)967 static void _sw_efree(void *address) {
968 efree(address);
969 }
970
_sw_zend_string_malloc(size_t size)971 static void *_sw_zend_string_malloc(size_t size) {
972 zend_string *str = zend_string_alloc(size, 0);
973 if (str == nullptr) {
974 return nullptr;
975 }
976 return str->val;
977 }
978
_sw_zend_string_calloc(size_t nmemb,size_t size)979 static void *_sw_zend_string_calloc(size_t nmemb, size_t size) {
980 void *mem = _sw_zend_string_malloc(nmemb * size);
981 if (mem) {
982 sw_memset_zero(mem, size);
983 }
984 return mem;
985 }
986
_sw_zend_string_realloc(void * address,size_t size)987 static void *_sw_zend_string_realloc(void *address, size_t size) {
988 zend_string *str = zend_string_realloc(zend::fetch_zend_string_by_val(address), size, 0);
989 if (str == nullptr) {
990 return nullptr;
991 }
992 return str->val;
993 }
994
_sw_zend_string_free(void * address)995 static void _sw_zend_string_free(void *address) {
996 zend_string_free(zend::fetch_zend_string_by_val(address));
997 }
998
999 static swoole::Allocator php_allocator{
1000 _sw_emalloc,
1001 _sw_ecalloc,
1002 _sw_erealloc,
1003 _sw_efree,
1004 };
1005
1006 static swoole::Allocator zend_string_allocator{
1007 _sw_zend_string_malloc,
1008 _sw_zend_string_calloc,
1009 _sw_zend_string_realloc,
1010 _sw_zend_string_free,
1011 };
1012
sw_php_allocator()1013 const swoole::Allocator *sw_php_allocator() {
1014 return &php_allocator;
1015 }
1016
sw_zend_string_allocator()1017 const swoole::Allocator *sw_zend_string_allocator() {
1018 return &zend_string_allocator;
1019 }
1020
PHP_RINIT_FUNCTION(swoole)1021 PHP_RINIT_FUNCTION(swoole) {
1022 if (!SWOOLE_G(cli)) {
1023 return SUCCESS;
1024 }
1025
1026 SWOOLE_G(req_status) = PHP_SWOOLE_RINIT_BEGIN;
1027 SwooleG.running = 1;
1028
1029 php_swoole_register_shutdown_function("swoole_internal_call_user_shutdown_begin");
1030
1031 if (SWOOLE_G(enable_library)
1032 #ifdef ZEND_COMPILE_PRELOAD
1033 /* avoid execution of the code during RINIT of preloader */
1034 && !(CG(compiler_options) & ZEND_COMPILE_PRELOAD)
1035 #endif
1036 ) {
1037 php_swoole_load_library();
1038 }
1039
1040 #ifdef ZEND_SIGNALS
1041 /* Disable warning even in ZEND_DEBUG because we may register our own signal handlers */
1042 SIGG(check) = 0;
1043 #endif
1044
1045 php_swoole_coroutine_rinit();
1046 php_swoole_runtime_rinit();
1047
1048 SWOOLE_G(req_status) = PHP_SWOOLE_RINIT_END;
1049
1050 return SUCCESS;
1051 }
1052
PHP_RSHUTDOWN_FUNCTION(swoole)1053 PHP_RSHUTDOWN_FUNCTION(swoole) {
1054 if (!SWOOLE_G(cli)) {
1055 return SUCCESS;
1056 }
1057
1058 SWOOLE_G(req_status) = PHP_SWOOLE_RSHUTDOWN_BEGIN;
1059
1060 rshutdown_callbacks.execute();
1061
1062 swoole_event_free();
1063
1064 php_swoole_server_rshutdown();
1065 php_swoole_async_coro_rshutdown();
1066 php_swoole_redis_server_rshutdown();
1067 php_swoole_coroutine_rshutdown();
1068 php_swoole_runtime_rshutdown();
1069
1070 php_swoole_process_clean();
1071
1072 SwooleG.running = 0;
1073 SWOOLE_G(req_status) = PHP_SWOOLE_RSHUTDOWN_END;
1074
1075 #ifdef PHP_STREAM_FLAG_NO_CLOSE
1076 auto php_swoole_set_stdio_no_close = [](const char *name, size_t name_len) {
1077 zval *zstream;
1078 php_stream *stream;
1079
1080 zstream = zend_get_constant_str(name, name_len);
1081 if (!zstream) {
1082 return;
1083 }
1084 stream =
1085 (php_stream *) zend_fetch_resource2_ex((zstream), "stream", php_file_le_stream(), php_file_le_pstream());
1086 if (!stream) {
1087 return;
1088 }
1089 stream->flags |= PHP_STREAM_FLAG_NO_CLOSE;
1090 };
1091 /* do not close the stdout and stderr */
1092 php_swoole_set_stdio_no_close(ZEND_STRL("STDOUT"));
1093 php_swoole_set_stdio_no_close(ZEND_STRL("STDERR"));
1094 #endif
1095
1096 return SUCCESS;
1097 }
1098
PHP_FUNCTION(swoole_version)1099 static PHP_FUNCTION(swoole_version) {
1100 RETURN_STRING(SWOOLE_VERSION);
1101 }
1102
hashkit_one_at_a_time(const char * key,size_t key_length)1103 static uint32_t hashkit_one_at_a_time(const char *key, size_t key_length) {
1104 const char *ptr = key;
1105 uint32_t value = 0;
1106
1107 while (key_length--) {
1108 uint32_t val = (uint32_t) *ptr++;
1109 value += val;
1110 value += (value << 10);
1111 value ^= (value >> 6);
1112 }
1113 value += (value << 3);
1114 value ^= (value >> 11);
1115 value += (value << 15);
1116
1117 return value;
1118 }
1119
PHP_FUNCTION(swoole_hashcode)1120 static PHP_FUNCTION(swoole_hashcode) {
1121 char *data;
1122 size_t l_data;
1123 zend_long type = 0;
1124
1125 ZEND_PARSE_PARAMETERS_START(1, 2)
1126 Z_PARAM_STRING(data, l_data)
1127 Z_PARAM_OPTIONAL
1128 Z_PARAM_LONG(type)
1129 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1130
1131 switch (type) {
1132 case 0:
1133 RETURN_LONG(zend_hash_func(data, l_data));
1134 case 1:
1135 RETURN_LONG(hashkit_one_at_a_time(data, l_data));
1136 default:
1137 RETURN_FALSE;
1138 }
1139 }
1140
PHP_FUNCTION(swoole_clear_error)1141 static PHP_FUNCTION(swoole_clear_error) {
1142 swoole_set_last_error(0);
1143 }
1144
PHP_FUNCTION(swoole_last_error)1145 PHP_FUNCTION(swoole_last_error) {
1146 RETURN_LONG(swoole_get_last_error());
1147 }
1148
PHP_FUNCTION(swoole_cpu_num)1149 static PHP_FUNCTION(swoole_cpu_num) {
1150 RETURN_LONG(SW_CPU_NUM);
1151 }
1152
PHP_FUNCTION(swoole_strerror)1153 static PHP_FUNCTION(swoole_strerror) {
1154 zend_long swoole_errno;
1155 zend_long error_type = SW_STRERROR_SYSTEM;
1156
1157 ZEND_PARSE_PARAMETERS_START(1, 2)
1158 Z_PARAM_LONG(swoole_errno)
1159 Z_PARAM_OPTIONAL
1160 Z_PARAM_LONG(error_type)
1161 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1162
1163 if (error_type == SW_STRERROR_GAI) {
1164 RETURN_STRING(gai_strerror(swoole_errno));
1165 } else if (error_type == SW_STRERROR_DNS) {
1166 RETURN_STRING(hstrerror(swoole_errno));
1167 } else if (error_type == SW_STRERROR_SWOOLE || (swoole_errno > SW_ERROR_BEGIN && swoole_errno < SW_ERROR_END)) {
1168 RETURN_STRING(swoole_strerror(swoole_errno));
1169 } else {
1170 RETURN_STRING(strerror(swoole_errno));
1171 }
1172 }
1173
PHP_FUNCTION(swoole_error_log)1174 static PHP_FUNCTION(swoole_error_log) {
1175 char *msg;
1176 size_t l_msg;
1177 zend_long level;
1178
1179 ZEND_PARSE_PARAMETERS_START(2, 2)
1180 Z_PARAM_LONG(level)
1181 Z_PARAM_STRING(msg, l_msg)
1182 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1183
1184 sw_logger()->put(level, msg, l_msg);
1185 }
1186
PHP_FUNCTION(swoole_error_log_ex)1187 static PHP_FUNCTION(swoole_error_log_ex) {
1188 char *msg;
1189 size_t l_msg;
1190 zend_long level, error;
1191
1192 ZEND_PARSE_PARAMETERS_START(3, 3)
1193 Z_PARAM_LONG(level)
1194 Z_PARAM_LONG(error)
1195 Z_PARAM_STRING(msg, l_msg)
1196 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1197
1198 swoole_error_log(level, (int) error, "%.*s", (int) l_msg, msg);
1199 }
1200
PHP_FUNCTION(swoole_ignore_error)1201 static PHP_FUNCTION(swoole_ignore_error) {
1202 zend_long error;
1203
1204 ZEND_PARSE_PARAMETERS_START(1, 1)
1205 Z_PARAM_LONG(error)
1206 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1207
1208 swoole_ignore_error(error);
1209 }
1210
PHP_FUNCTION(swoole_mime_type_add)1211 static PHP_FUNCTION(swoole_mime_type_add) {
1212 zend_string *suffix;
1213 zend_string *mime_type;
1214
1215 ZEND_PARSE_PARAMETERS_START(2, 2)
1216 Z_PARAM_STR(suffix)
1217 Z_PARAM_STR(mime_type)
1218 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1219
1220 RETURN_BOOL(swoole::mime_type::add(ZSTR_VAL(suffix), ZSTR_VAL(mime_type)));
1221 }
1222
PHP_FUNCTION(swoole_mime_type_set)1223 static PHP_FUNCTION(swoole_mime_type_set) {
1224 zend_string *suffix;
1225 zend_string *mime_type;
1226
1227 ZEND_PARSE_PARAMETERS_START(2, 2)
1228 Z_PARAM_STR(suffix)
1229 Z_PARAM_STR(mime_type)
1230 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1231
1232 swoole::mime_type::set(ZSTR_VAL(suffix), ZSTR_VAL(mime_type));
1233 }
1234
PHP_FUNCTION(swoole_mime_type_delete)1235 static PHP_FUNCTION(swoole_mime_type_delete) {
1236 zend_string *suffix;
1237
1238 ZEND_PARSE_PARAMETERS_START(1, 1)
1239 Z_PARAM_STR(suffix)
1240 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1241
1242 RETURN_BOOL(swoole::mime_type::del(ZSTR_VAL(suffix)));
1243 }
1244
PHP_FUNCTION(swoole_mime_type_get)1245 static PHP_FUNCTION(swoole_mime_type_get) {
1246 zend_string *filename;
1247
1248 ZEND_PARSE_PARAMETERS_START(1, 1)
1249 Z_PARAM_STR(filename)
1250 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1251
1252 RETURN_STRING(swoole::mime_type::get(ZSTR_VAL(filename)).c_str());
1253 }
1254
PHP_FUNCTION(swoole_mime_type_exists)1255 static PHP_FUNCTION(swoole_mime_type_exists) {
1256 zend_string *filename;
1257
1258 ZEND_PARSE_PARAMETERS_START(1, 1)
1259 Z_PARAM_STR(filename)
1260 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
1261
1262 RETURN_BOOL(swoole::mime_type::exists(ZSTR_VAL(filename)));
1263 }
1264
PHP_FUNCTION(swoole_mime_type_list)1265 static PHP_FUNCTION(swoole_mime_type_list) {
1266 array_init(return_value);
1267 for (auto &i : swoole::mime_type::list()) {
1268 add_next_index_string(return_value, i.second.c_str());
1269 }
1270 }
1271
PHP_FUNCTION(swoole_errno)1272 static PHP_FUNCTION(swoole_errno) {
1273 RETURN_LONG(errno);
1274 }
1275
PHP_FUNCTION(swoole_set_process_name)1276 PHP_FUNCTION(swoole_set_process_name) {
1277 zend_function *cli_set_process_title =
1278 (zend_function *) zend_hash_str_find_ptr(EG(function_table), ZEND_STRL("cli_set_process_title"));
1279 if (!cli_set_process_title) {
1280 php_swoole_fatal_error(E_WARNING, "swoole_set_process_name only support in CLI mode");
1281 RETURN_FALSE;
1282 }
1283 cli_set_process_title->internal_function.handler(INTERNAL_FUNCTION_PARAM_PASSTHRU);
1284 }
1285
PHP_FUNCTION(swoole_get_local_ip)1286 static PHP_FUNCTION(swoole_get_local_ip) {
1287 struct sockaddr_in *s4;
1288 struct ifaddrs *ipaddrs, *ifa;
1289 void *in_addr;
1290 char ip[64];
1291
1292 if (getifaddrs(&ipaddrs) != 0) {
1293 php_swoole_sys_error(E_WARNING, "getifaddrs() failed");
1294 RETURN_FALSE;
1295 }
1296 array_init(return_value);
1297 for (ifa = ipaddrs; ifa != nullptr; ifa = ifa->ifa_next) {
1298 if (ifa->ifa_addr == nullptr || !(ifa->ifa_flags & IFF_UP)) {
1299 continue;
1300 }
1301
1302 switch (ifa->ifa_addr->sa_family) {
1303 case AF_INET:
1304 s4 = (struct sockaddr_in *) ifa->ifa_addr;
1305 in_addr = &s4->sin_addr;
1306 break;
1307 case AF_INET6:
1308 // struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1309 // in_addr = &s6->sin6_addr;
1310 continue;
1311 default:
1312 continue;
1313 }
1314 if (!inet_ntop(ifa->ifa_addr->sa_family, in_addr, ip, sizeof(ip))) {
1315 php_error_docref(nullptr, E_WARNING, "%s: inet_ntop failed", ifa->ifa_name);
1316 } else {
1317 // if (ifa->ifa_addr->sa_family == AF_INET && ntohl(((struct in_addr *) in_addr)->s_addr) ==
1318 // INADDR_LOOPBACK)
1319 if (strcmp(ip, "127.0.0.1") == 0) {
1320 continue;
1321 }
1322 add_assoc_string(return_value, ifa->ifa_name, ip);
1323 }
1324 }
1325 freeifaddrs(ipaddrs);
1326 }
1327
PHP_FUNCTION(swoole_get_local_mac)1328 static PHP_FUNCTION(swoole_get_local_mac) {
1329 auto add_assoc_address = [](zval *zv, const char *name, const unsigned char *addr) {
1330 char buf[32];
1331 sw_snprintf(
1332 SW_STRS(buf), "%02X:%02X:%02X:%02X:%02X:%02X", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
1333 add_assoc_string(zv, name, buf);
1334 };
1335 #ifdef SIOCGIFHWADDR
1336 struct ifconf ifc;
1337 struct ifreq buf[16];
1338
1339 int sock;
1340 int i = 0, num = 0;
1341
1342 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
1343 php_swoole_sys_error(E_WARNING, "new socket failed");
1344 RETURN_FALSE;
1345 }
1346 array_init(return_value);
1347
1348 ifc.ifc_len = sizeof(buf);
1349 ifc.ifc_buf = (caddr_t) buf;
1350 if (!ioctl(sock, SIOCGIFCONF, (char *) &ifc)) {
1351 num = ifc.ifc_len / sizeof(struct ifreq);
1352 while (i < num) {
1353 if (!(ioctl(sock, SIOCGIFHWADDR, (char *) &buf[i]))) {
1354 add_assoc_address(return_value, buf[i].ifr_name, (unsigned char *) buf[i].ifr_hwaddr.sa_data);
1355 }
1356 i++;
1357 }
1358 }
1359 close(sock);
1360 #else
1361 #ifdef LLADDR
1362 ifaddrs *ifas, *ifa;
1363 if (getifaddrs(&ifas) == 0) {
1364 array_init(return_value);
1365 for (ifa = ifas; ifa; ifa = ifa->ifa_next) {
1366 if ((ifa->ifa_addr->sa_family == AF_LINK) && ifa->ifa_addr) {
1367 add_assoc_address(
1368 return_value, ifa->ifa_name, (unsigned char *) (LLADDR((struct sockaddr_dl *) ifa->ifa_addr)));
1369 }
1370 }
1371 freeifaddrs(ifas);
1372 }
1373 #else
1374 php_error_docref(nullptr, E_WARNING, "swoole_get_local_mac is not supported");
1375 RETURN_FALSE;
1376 #endif
1377 #endif
1378 }
1379
PHP_FUNCTION(swoole_internal_call_user_shutdown_begin)1380 static PHP_FUNCTION(swoole_internal_call_user_shutdown_begin) {
1381 if (SWOOLE_G(req_status) == PHP_SWOOLE_RINIT_END) {
1382 SWOOLE_G(req_status) = PHP_SWOOLE_CALL_USER_SHUTDOWNFUNC_BEGIN;
1383 RETURN_TRUE;
1384 } else {
1385 php_error_docref(nullptr, E_WARNING, "can not call this function in user level");
1386 RETURN_FALSE;
1387 }
1388 }
1389
PHP_FUNCTION(swoole_substr_unserialize)1390 static PHP_FUNCTION(swoole_substr_unserialize) {
1391 zend_long offset, length = 0;
1392 char *buf = NULL;
1393 size_t buf_len;
1394 zval *options = NULL;
1395
1396 ZEND_PARSE_PARAMETERS_START(2, 4)
1397 Z_PARAM_STRING(buf, buf_len)
1398 Z_PARAM_LONG(offset)
1399 Z_PARAM_OPTIONAL
1400 Z_PARAM_LONG(length)
1401 Z_PARAM_ARRAY(options)
1402 ZEND_PARSE_PARAMETERS_END();
1403
1404 if (buf_len == 0) {
1405 RETURN_FALSE;
1406 }
1407 if (offset < 0) {
1408 offset = buf_len + offset;
1409 }
1410 if ((zend_long) buf_len <= offset) {
1411 RETURN_FALSE;
1412 }
1413 if (length <= 0) {
1414 length = buf_len - offset;
1415 }
1416 zend::unserialize(return_value, buf + offset, length, options ? Z_ARRVAL_P(options) : NULL);
1417 }
1418
1419 #ifdef SW_USE_JSON
PHP_FUNCTION(swoole_substr_json_decode)1420 static PHP_FUNCTION(swoole_substr_json_decode) {
1421 zend_long offset, length = 0;
1422 char *str;
1423 size_t str_len;
1424 zend_bool assoc = 0; /* return JS objects as PHP objects by default */
1425 zend_bool assoc_null = 1;
1426 zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
1427 zend_long options = 0;
1428
1429 ZEND_PARSE_PARAMETERS_START(2, 6)
1430 Z_PARAM_STRING(str, str_len)
1431 Z_PARAM_LONG(offset)
1432 Z_PARAM_OPTIONAL
1433 Z_PARAM_LONG(length)
1434 Z_PARAM_BOOL_EX(assoc, assoc_null, 1, 0)
1435 Z_PARAM_LONG(depth)
1436 Z_PARAM_LONG(options)
1437 ZEND_PARSE_PARAMETERS_END();
1438
1439 if (str_len == 0) {
1440 RETURN_FALSE;
1441 }
1442 if (offset < 0) {
1443 offset = str_len + offset;
1444 }
1445 if ((zend_long) str_len <= offset) {
1446 RETURN_FALSE;
1447 }
1448 if (length <= 0) {
1449 length = str_len - offset;
1450 }
1451 /* For BC reasons, the bool $assoc overrides the long $options bit for PHP_JSON_OBJECT_AS_ARRAY */
1452 if (!assoc_null) {
1453 if (assoc) {
1454 options |= PHP_JSON_OBJECT_AS_ARRAY;
1455 } else {
1456 options &= ~PHP_JSON_OBJECT_AS_ARRAY;
1457 }
1458 }
1459 zend::json_decode(return_value, str + offset, length, options, depth);
1460 }
1461 #endif
1462