2 +++ b/ext/libevent/CREDITS
4 +Antony Dovgal, Arnaud Le Blanc
6 +++ b/ext/libevent/config.m4
8 +dnl $Id: config.m4 287913 2009-08-31 08:45:42Z tony2001 $
10 +PHP_ARG_WITH(libevent, for libevent support,
11 +[ --with-libevent Include libevent support])
13 +if test "$PHP_LIBEVENT" != "no"; then
14 + SEARCH_PATH="/usr /usr/local"
15 + SEARCH_FOR="/include/event.h"
17 + if test "$PHP_LIBEVENT" = "yes"; then
18 + AC_MSG_CHECKING([for libevent headers in default path])
19 + for i in $SEARCH_PATH ; do
20 + if test -r $i/$SEARCH_FOR; then
22 + AC_MSG_RESULT(found in $i)
26 + AC_MSG_CHECKING([for libevent headers in $PHP_LIBEVENT])
27 + if test -r $PHP_LIBEVENT/$SEARCH_FOR; then
28 + LIBEVENT_DIR=$PHP_LIBEVENT
29 + AC_MSG_RESULT([found])
33 + if test -z "$LIBEVENT_DIR"; then
34 + AC_MSG_RESULT([not found])
35 + AC_MSG_ERROR([Cannot find libevent headers])
38 + PHP_ADD_INCLUDE($LIBEVENT_DIR/include)
41 + LIBSYMBOL=event_base_new
43 + if test "x$PHP_LIBDIR" = "x"; then
47 + PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
49 + PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $LIBEVENT_DIR/$PHP_LIBDIR, LIBEVENT_SHARED_LIBADD)
51 + AC_MSG_ERROR([wrong libevent version {1.4.+ is required} or lib not found])
53 + -L$LIBEVENT_DIR/$PHP_LIBDIR
56 + PHP_ADD_EXTENSION_DEP(libevent, sockets, true)
57 + PHP_SUBST(LIBEVENT_SHARED_LIBADD)
58 + PHP_NEW_EXTENSION(libevent, libevent.c, $ext_shared)
61 +++ b/ext/libevent/libevent.c
64 + +----------------------------------------------------------------------+
66 + +----------------------------------------------------------------------+
67 + | Copyright (c) 1997-2008 The PHP Group |
68 + +----------------------------------------------------------------------+
69 + | This source file is subject to version 3.01 of the PHP license, |
70 + | that is bundled with this package in the file LICENSE, and is |
71 + | available through the world-wide-web at the following url: |
72 + | http://www.php.net/license/3_01.txt |
73 + | If you did not receive a copy of the PHP license and are unable to |
74 + | obtain it through the world-wide-web, please send a note to |
75 + | license@php.net so we can mail you a copy immediately. |
76 + +----------------------------------------------------------------------+
77 + | Author: Antony Dovgal <tony@daylessday.org> |
78 + | Arnaud Le Blanc <lbarnaud@php.net> |
79 + +----------------------------------------------------------------------+
82 +/* $Id: libevent.c 318910 2011-11-08 12:34:37Z tony2001 $ */
90 +#include "ext/standard/info.h"
91 +#include "php_streams.h"
92 +#include "php_network.h"
93 +#include "php_libevent.h"
97 +#if PHP_VERSION_ID >= 50301 && (HAVE_SOCKETS || defined(COMPILE_DL_SOCKETS))
98 +# include "ext/sockets/php_sockets.h"
99 +# define LIBEVENT_SOCKETS_SUPPORT
102 +#ifndef ZEND_FETCH_RESOURCE_NO_RETURN
103 +# define ZEND_FETCH_RESOURCE_NO_RETURN(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type) \
104 + (rsrc = (rsrc_type) zend_fetch_resource(passed_id TSRMLS_CC, default_id, resource_type_name, NULL, 1, resource_type))
109 +#if PHP_MAJOR_VERSION < 5
111 +typedef SOCKET php_socket_t;
113 +typedef int php_socket_t;
117 +# define TSRMLS_FETCH_FROM_CTX(ctx) void ***tsrm_ls = (void ***) ctx
118 +# define TSRMLS_SET_CTX(ctx) ctx = (void ***) tsrm_ls
120 +# define TSRMLS_FETCH_FROM_CTX(ctx)
121 +# define TSRMLS_SET_CTX(ctx)
125 +# define Z_ADDREF_P(x) (x)->refcount++
129 +static int le_event_base;
130 +static int le_event;
131 +static int le_bufferevent;
133 +#ifdef COMPILE_DL_LIBEVENT
134 +ZEND_GET_MODULE(libevent)
137 +typedef struct _php_event_base_t { /* {{{ */
138 + struct event_base *base;
144 +typedef struct _php_event_callback_t { /* {{{ */
147 +} php_event_callback_t;
150 +typedef struct _php_event_t { /* {{{ */
151 + struct event *event;
154 + php_event_base_t *base;
155 + php_event_callback_t *callback;
157 + void ***thread_ctx;
163 +typedef struct _php_bufferevent_t { /* {{{ */
164 + struct bufferevent *bevent;
166 + php_event_base_t *base;
172 + void ***thread_ctx;
174 +} php_bufferevent_t;
177 +#define ZVAL_TO_BASE(zval, base) \
178 + ZEND_FETCH_RESOURCE(base, php_event_base_t *, &zval, -1, "event base", le_event_base)
180 +#define ZVAL_TO_EVENT(zval, event) \
181 + ZEND_FETCH_RESOURCE(event, php_event_t *, &zval, -1, "event", le_event)
183 +#define ZVAL_TO_BEVENT(zval, bevent) \
184 + ZEND_FETCH_RESOURCE(bevent, php_bufferevent_t *, &zval, -1, "buffer event", le_bufferevent)
186 +/* {{{ internal funcs */
188 +static inline void _php_event_callback_free(php_event_callback_t *callback) /* {{{ */
194 + zval_ptr_dtor(&callback->func);
195 + if (callback->arg) {
196 + zval_ptr_dtor(&callback->arg);
202 +static void _php_event_base_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
204 + php_event_base_t *base = (php_event_base_t*)rsrc->ptr;
206 + event_base_free(base->base);
211 +static void _php_event_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
213 + php_event_t *event = (php_event_t*)rsrc->ptr;
216 + if (event->in_free) {
220 + event->in_free = 1;
223 + base_id = event->base->rsrc_id;
224 + --event->base->events;
226 + if (event->stream_id >= 0) {
227 + zend_list_delete(event->stream_id);
229 + event_del(event->event);
231 + _php_event_callback_free(event->callback);
232 + efree(event->event);
235 + if (base_id >= 0) {
236 + zend_list_delete(base_id);
241 +static void _php_bufferevent_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
243 + php_bufferevent_t *bevent = (php_bufferevent_t*)rsrc->ptr;
246 + if (bevent->base) {
247 + base_id = bevent->base->rsrc_id;
248 + --bevent->base->events;
250 + if (bevent->readcb) {
251 + zval_ptr_dtor(&(bevent->readcb));
253 + if (bevent->writecb) {
254 + zval_ptr_dtor(&(bevent->writecb));
256 + if (bevent->errorcb) {
257 + zval_ptr_dtor(&(bevent->errorcb));
260 + zval_ptr_dtor(&(bevent->arg));
263 + bufferevent_free(bevent->bevent);
266 + if (base_id >= 0) {
267 + zend_list_delete(base_id);
272 +static void _php_event_callback(int fd, short events, void *arg) /* {{{ */
275 + php_event_t *event = (php_event_t *)arg;
276 + php_event_callback_t *callback;
278 + TSRMLS_FETCH_FROM_CTX(event ? event->thread_ctx : NULL);
280 + if (!event || !event->callback || !event->base) {
284 + callback = event->callback;
286 + MAKE_STD_ZVAL(args[0]);
287 + if (event->stream_id >= 0) {
288 + ZVAL_RESOURCE(args[0], event->stream_id);
289 + zend_list_addref(event->stream_id);
291 + ZVAL_NULL(args[0]);
294 + MAKE_STD_ZVAL(args[1]);
295 + ZVAL_LONG(args[1], events);
297 + args[2] = callback->arg;
298 + Z_ADDREF_P(callback->arg);
300 + if (call_user_function(EG(function_table), NULL, callback->func, &retval, 3, args TSRMLS_CC) == SUCCESS) {
301 + zval_dtor(&retval);
304 + zval_ptr_dtor(&(args[0]));
305 + zval_ptr_dtor(&(args[1]));
306 + zval_ptr_dtor(&(args[2]));
311 +static void _php_bufferevent_readcb(struct bufferevent *be, void *arg) /* {{{ */
315 + php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
316 + TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
318 + if (!bevent || !bevent->base || !bevent->readcb) {
322 + MAKE_STD_ZVAL(args[0]);
323 + ZVAL_RESOURCE(args[0], bevent->rsrc_id);
324 + zend_list_addref(bevent->rsrc_id); /* we do refcount-- later in zval_ptr_dtor */
326 + args[1] = bevent->arg;
327 + Z_ADDREF_P(args[1]);
329 + if (call_user_function(EG(function_table), NULL, bevent->readcb, &retval, 2, args TSRMLS_CC) == SUCCESS) {
330 + zval_dtor(&retval);
333 + zval_ptr_dtor(&(args[0]));
334 + zval_ptr_dtor(&(args[1]));
339 +static void _php_bufferevent_writecb(struct bufferevent *be, void *arg) /* {{{ */
343 + php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
344 + TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
346 + if (!bevent || !bevent->base || !bevent->writecb) {
350 + MAKE_STD_ZVAL(args[0]);
351 + ZVAL_RESOURCE(args[0], bevent->rsrc_id);
352 + zend_list_addref(bevent->rsrc_id); /* we do refcount-- later in zval_ptr_dtor */
354 + args[1] = bevent->arg;
355 + Z_ADDREF_P(args[1]);
357 + if (call_user_function(EG(function_table), NULL, bevent->writecb, &retval, 2, args TSRMLS_CC) == SUCCESS) {
358 + zval_dtor(&retval);
361 + zval_ptr_dtor(&(args[0]));
362 + zval_ptr_dtor(&(args[1]));
367 +static void _php_bufferevent_errorcb(struct bufferevent *be, short what, void *arg) /* {{{ */
371 + php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
372 + TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
374 + if (!bevent || !bevent->base || !bevent->errorcb) {
378 + MAKE_STD_ZVAL(args[0]);
379 + ZVAL_RESOURCE(args[0], bevent->rsrc_id);
380 + zend_list_addref(bevent->rsrc_id); /* we do refcount-- later in zval_ptr_dtor */
382 + MAKE_STD_ZVAL(args[1]);
383 + ZVAL_LONG(args[1], what);
385 + args[2] = bevent->arg;
386 + Z_ADDREF_P(args[2]);
388 + if (call_user_function(EG(function_table), NULL, bevent->errorcb, &retval, 3, args TSRMLS_CC) == SUCCESS) {
389 + zval_dtor(&retval);
392 + zval_ptr_dtor(&(args[0]));
393 + zval_ptr_dtor(&(args[1]));
394 + zval_ptr_dtor(&(args[2]));
402 +/* {{{ proto resource event_base_new()
404 +static PHP_FUNCTION(event_base_new)
406 + php_event_base_t *base;
408 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) {
412 + base = emalloc(sizeof(php_event_base_t));
413 + base->base = event_base_new();
421 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
422 + base->rsrc_id = zend_list_insert(base, le_event_base TSRMLS_CC);
424 + base->rsrc_id = zend_list_insert(base, le_event_base);
426 + RETURN_RESOURCE(base->rsrc_id);
430 +/* {{{ proto void event_base_free(resource base)
432 +static PHP_FUNCTION(event_base_free)
435 + php_event_base_t *base;
437 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbase) != SUCCESS) {
441 + ZVAL_TO_BASE(zbase, base);
443 + if (base->events > 0) {
444 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "base has events attached to it and cannot be freed");
448 + zend_list_delete(base->rsrc_id);
452 +/* {{{ proto int event_base_loop(resource base[, int flags])
454 +static PHP_FUNCTION(event_base_loop)
457 + php_event_base_t *base;
461 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zbase, &flags) != SUCCESS) {
465 + ZVAL_TO_BASE(zbase, base);
466 + zend_list_addref(base->rsrc_id); /* make sure the base cannot be destroyed during the loop */
467 + ret = event_base_loop(base->base, flags);
468 + zend_list_delete(base->rsrc_id);
474 +/* {{{ proto bool event_base_loopbreak(resource base)
476 +static PHP_FUNCTION(event_base_loopbreak)
479 + php_event_base_t *base;
482 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbase) != SUCCESS) {
486 + ZVAL_TO_BASE(zbase, base);
487 + ret = event_base_loopbreak(base->base);
495 +/* {{{ proto bool event_base_loopexit(resource base[, int timeout])
497 +static PHP_FUNCTION(event_base_loopexit)
500 + php_event_base_t *base;
504 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zbase, &timeout) != SUCCESS) {
508 + ZVAL_TO_BASE(zbase, base);
511 + ret = event_base_loopexit(base->base, NULL);
513 + struct timeval time;
515 + time.tv_usec = timeout % 1000000;
516 + time.tv_sec = timeout / 1000000;
517 + ret = event_base_loopexit(base->base, &time);
527 +/* {{{ proto bool event_base_set(resource event, resource base)
529 +static PHP_FUNCTION(event_base_set)
531 + zval *zbase, *zevent;
532 + php_event_base_t *base, *old_base;
533 + php_event_t *event;
536 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &zevent, &zbase) != SUCCESS) {
540 + ZVAL_TO_BASE(zbase, base);
541 + ZVAL_TO_EVENT(zevent, event);
543 + old_base = event->base;
544 + ret = event_base_set(base->base, event->event);
547 + if (base != old_base) {
548 + /* make sure the base is destroyed after the event */
549 + zend_list_addref(base->rsrc_id);
554 + --old_base->events;
555 + zend_list_delete(old_base->rsrc_id);
558 + event->base = base;
565 +/* {{{ proto bool event_base_priority_init(resource base, int npriorities)
567 +static PHP_FUNCTION(event_base_priority_init)
570 + php_event_base_t *base;
574 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbase, &npriorities) != SUCCESS) {
578 + ZVAL_TO_BASE(zbase, base);
580 + if (npriorities < 0) {
581 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "npriorities cannot be less than zero");
585 + ret = event_base_priority_init(base->base, npriorities);
594 +/* {{{ proto resource event_new()
596 +static PHP_FUNCTION(event_new)
598 + php_event_t *event;
600 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) {
604 + event = emalloc(sizeof(php_event_t));
605 + event->event = ecalloc(1, sizeof(struct event));
607 + event->stream_id = -1;
608 + event->callback = NULL;
609 + event->base = NULL;
610 + event->in_free = 0;
611 + TSRMLS_SET_CTX(event->thread_ctx);
613 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
614 + event->rsrc_id = zend_list_insert(event, le_event TSRMLS_CC);
616 + event->rsrc_id = zend_list_insert(event, le_event);
618 + RETURN_RESOURCE(event->rsrc_id);
622 +/* {{{ proto void event_free(resource event)
624 +static PHP_FUNCTION(event_free)
627 + php_event_t *event;
629 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zevent) != SUCCESS) {
633 + ZVAL_TO_EVENT(zevent, event);
634 + zend_list_delete(event->rsrc_id);
638 +/* {{{ proto bool event_add(resource event[, int timeout])
640 +static PHP_FUNCTION(event_add)
643 + php_event_t *event;
647 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zevent, &timeout) != SUCCESS) {
651 + ZVAL_TO_EVENT(zevent, event);
653 + if (!event->base) {
654 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add event without an event base");
659 + ret = event_add(event->event, NULL);
661 + struct timeval time;
663 + time.tv_usec = timeout % 1000000;
664 + time.tv_sec = timeout / 1000000;
665 + ret = event_add(event->event, &time);
676 +/* {{{ proto bool event_set(resource event, mixed fd, int events, mixed callback[, mixed arg])
678 +static PHP_FUNCTION(event_set)
680 + zval *zevent, **fd, *zcallback, *zarg = NULL;
681 + php_event_t *event;
683 + php_event_callback_t *callback, *old_callback;
685 + php_stream *stream;
686 + php_socket_t file_desc;
687 +#ifdef LIBEVENT_SOCKETS_SUPPORT
688 + php_socket *php_sock;
692 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZlz|z", &zevent, &fd, &events, &zcallback, &zarg) != SUCCESS) {
696 + ZVAL_TO_EVENT(zevent, event);
698 + if (events & EV_SIGNAL) {
699 + /* signal support */
700 + convert_to_long_ex(fd);
701 + file_desc = Z_LVAL_PP(fd);
702 + if (file_desc < 0 || file_desc >= NSIG) {
703 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid signal passed");
707 + if (Z_TYPE_PP(fd) == IS_RESOURCE) {
708 + if (ZEND_FETCH_RESOURCE_NO_RETURN(stream, php_stream *, fd, -1, NULL, php_file_le_stream())) {
709 + if (php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&file_desc, 1) != SUCCESS || file_desc < 0) {
713 +#ifdef LIBEVENT_SOCKETS_SUPPORT
714 + if (ZEND_FETCH_RESOURCE_NO_RETURN(php_sock, php_socket *, fd, -1, NULL, php_sockets_le_socket())) {
715 + file_desc = php_sock->bsd_socket;
717 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be either valid PHP stream or valid PHP socket resource");
721 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource");
725 + } else if (Z_TYPE_PP(fd) == IS_LONG) {
726 + file_desc = Z_LVAL_PP(fd);
727 + if (file_desc < 0) {
728 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid file descriptor passed");
732 +#ifdef LIBEVENT_SOCKETS_SUPPORT
733 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream or socket resource or a file descriptor of type long");
735 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
741 + if (!zend_is_callable(zcallback, 0, &func_name TSRMLS_CC)) {
742 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid callback", func_name);
748 + zval_add_ref(&zcallback);
750 + zval_add_ref(&zarg);
752 + ALLOC_INIT_ZVAL(zarg);
755 + callback = emalloc(sizeof(php_event_callback_t));
756 + callback->func = zcallback;
757 + callback->arg = zarg;
759 + old_callback = event->callback;
760 + event->callback = callback;
761 + if (events & EV_SIGNAL) {
762 + event->stream_id = -1;
764 + zend_list_addref(Z_LVAL_PP(fd));
765 + event->stream_id = Z_LVAL_PP(fd);
768 + event_set(event->event, (int)file_desc, (short)events, _php_event_callback, event);
770 + if (old_callback) {
771 + _php_event_callback_free(old_callback);
775 + ret = event_base_set(event->base->base, event->event);
784 +/* {{{ proto bool event_del(resource event)
786 +static PHP_FUNCTION(event_del)
789 + php_event_t *event;
791 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zevent) != SUCCESS) {
795 + ZVAL_TO_EVENT(zevent, event);
797 + if (!event->base) {
798 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to delete event without an event base");
802 + if (event_del(event->event) == 0) {
809 +/* {{{ proto bool event_priority_set(resource event, int priority)
811 +static PHP_FUNCTION(event_priority_set)
814 + php_event_t *event;
818 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zevent, &priority) != SUCCESS) {
822 + ZVAL_TO_EVENT(zevent, event);
824 + if (!event->base) {
825 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set event priority without an event base");
829 + ret = event_priority_set(event->event, priority);
838 +/* {{{ proto bool event_timer_set(resource event, mixed callback[, mixed arg])
840 +static PHP_FUNCTION(event_timer_set)
842 + zval *zevent, *zcallback, *zarg = NULL;
843 + php_event_t *event;
844 + php_event_callback_t *callback, *old_callback;
847 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &zevent, &zcallback, &zarg) != SUCCESS) {
851 + ZVAL_TO_EVENT(zevent, event);
853 + if (!zend_is_callable(zcallback, 0, &func_name TSRMLS_CC)) {
854 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid callback", func_name);
860 + zval_add_ref(&zcallback);
862 + zval_add_ref(&zarg);
864 + ALLOC_INIT_ZVAL(zarg);
867 + callback = emalloc(sizeof(php_event_callback_t));
868 + callback->func = zcallback;
869 + callback->arg = zarg;
871 + old_callback = event->callback;
872 + event->callback = callback;
873 + if (event->stream_id >= 0) {
874 + zend_list_delete(event->stream_id);
876 + event->stream_id = -1;
878 + event_set(event->event, -1, 0, _php_event_callback, event);
880 + if (old_callback) {
881 + _php_event_callback_free(old_callback);
887 +/* {{{ proto bool event_timer_pending(resource event[, int timeout])
889 +static PHP_FUNCTION(event_timer_pending)
892 + php_event_t *event;
896 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zevent, &timeout) != SUCCESS) {
900 + ZVAL_TO_EVENT(zevent, event);
903 + ret = event_pending(event->event, EV_TIMEOUT, NULL);
905 + struct timeval time;
907 + time.tv_usec = timeout % 1000000;
908 + time.tv_sec = timeout / 1000000;
909 + ret = event_pending(event->event, EV_TIMEOUT, &time);
921 +/* {{{ proto resource event_buffer_new(mixed fd, mixed readcb, mixed writecb, mixed errorcb[, mixed arg])
923 +static PHP_FUNCTION(event_buffer_new)
925 + php_bufferevent_t *bevent;
926 + php_stream *stream;
927 + zval *zfd, *zreadcb, *zwritecb, *zerrorcb, *zarg = NULL;
930 +#ifdef LIBEVENT_SOCKETS_SUPPORT
931 + php_socket *php_sock;
934 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &zfd, &zreadcb, &zwritecb, &zerrorcb, &zarg) != SUCCESS) {
938 + if (Z_TYPE_P(zfd) == IS_RESOURCE) {
939 + if (ZEND_FETCH_RESOURCE_NO_RETURN(stream, php_stream *, &zfd, -1, NULL, php_file_le_stream())) {
940 + if (php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&fd, 1) != SUCCESS || fd < 0) {
944 +#ifdef LIBEVENT_SOCKETS_SUPPORT
945 + if (ZEND_FETCH_RESOURCE_NO_RETURN(php_sock, php_socket *, &zfd, -1, NULL, php_sockets_le_socket())) {
946 + fd = php_sock->bsd_socket;
948 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream or socket resource or a file descriptor of type long");
952 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
956 + } else if (Z_TYPE_P(zfd) == IS_LONG) {
957 + fd = Z_LVAL_P(zfd);
959 +#ifdef LIBEVENT_SOCKETS_SUPPORT
960 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream or socket resource or a file descriptor of type long");
962 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
967 + if (Z_TYPE_P(zreadcb) != IS_NULL) {
968 + if (!zend_is_callable(zreadcb, 0, &func_name TSRMLS_CC)) {
969 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid read callback", func_name);
978 + if (Z_TYPE_P(zwritecb) != IS_NULL) {
979 + if (!zend_is_callable(zwritecb, 0, &func_name TSRMLS_CC)) {
980 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid write callback", func_name);
989 + if (!zend_is_callable(zerrorcb, 0, &func_name TSRMLS_CC)) {
990 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid error callback", func_name);
996 + bevent = emalloc(sizeof(php_bufferevent_t));
997 + bevent->bevent = bufferevent_new(fd, _php_bufferevent_readcb, _php_bufferevent_writecb, _php_bufferevent_errorcb, bevent);
999 + bevent->base = NULL;
1002 + zval_add_ref(&zreadcb);
1004 + bevent->readcb = zreadcb;
1007 + zval_add_ref(&zwritecb);
1009 + bevent->writecb = zwritecb;
1011 + zval_add_ref(&zerrorcb);
1012 + bevent->errorcb = zerrorcb;
1015 + zval_add_ref(&zarg);
1016 + bevent->arg = zarg;
1018 + ALLOC_INIT_ZVAL(bevent->arg);
1021 + TSRMLS_SET_CTX(bevent->thread_ctx);
1023 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
1024 + bevent->rsrc_id = zend_list_insert(bevent, le_bufferevent TSRMLS_CC);
1026 + bevent->rsrc_id = zend_list_insert(bevent, le_bufferevent);
1028 + RETURN_RESOURCE(bevent->rsrc_id);
1032 +/* {{{ proto void event_buffer_free(resource bevent)
1034 +static PHP_FUNCTION(event_buffer_free)
1037 + php_bufferevent_t *bevent;
1039 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbevent) != SUCCESS) {
1043 + ZVAL_TO_BEVENT(zbevent, bevent);
1044 + zend_list_delete(bevent->rsrc_id);
1048 +/* {{{ proto bool event_buffer_base_set(resource bevent, resource base)
1050 +static PHP_FUNCTION(event_buffer_base_set)
1052 + zval *zbase, *zbevent;
1053 + php_event_base_t *base, *old_base;
1054 + php_bufferevent_t *bevent;
1057 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &zbevent, &zbase) != SUCCESS) {
1061 + ZVAL_TO_BASE(zbase, base);
1062 + ZVAL_TO_BEVENT(zbevent, bevent);
1064 + old_base = bevent->base;
1065 + ret = bufferevent_base_set(base->base, bevent->bevent);
1068 + if (base != old_base) {
1069 + /* make sure the base is destroyed after the event */
1070 + zend_list_addref(base->rsrc_id);
1075 + --old_base->events;
1076 + zend_list_delete(old_base->rsrc_id);
1079 + bevent->base = base;
1086 +/* {{{ proto bool event_buffer_priority_set(resource bevent, int priority)
1088 +static PHP_FUNCTION(event_buffer_priority_set)
1091 + php_bufferevent_t *bevent;
1095 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &priority) != SUCCESS) {
1099 + ZVAL_TO_BEVENT(zbevent, bevent);
1101 + if (!bevent->base) {
1102 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set event priority without an event base");
1106 + ret = bufferevent_priority_set(bevent->bevent, priority);
1115 +/* {{{ proto bool event_buffer_write(resource bevent, string data[, int data_size])
1117 +static PHP_FUNCTION(event_buffer_write)
1120 + php_bufferevent_t *bevent;
1123 + long data_size = -1;
1126 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &zbevent, &data, &data_len, &data_size) != SUCCESS) {
1130 + ZVAL_TO_BEVENT(zbevent, bevent);
1132 + if (ZEND_NUM_ARGS() < 3 || data_size < 0) {
1133 + data_size = data_len;
1134 + } else if (data_size > data_len) {
1135 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "data_size out of range");
1139 + ret = bufferevent_write(bevent->bevent, (const void *)data, data_size);
1148 +/* {{{ proto string event_buffer_read(resource bevent, int data_size)
1150 +static PHP_FUNCTION(event_buffer_read)
1153 + php_bufferevent_t *bevent;
1158 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &data_size) != SUCCESS) {
1162 + ZVAL_TO_BEVENT(zbevent, bevent);
1164 + if (data_size == 0) {
1165 + RETURN_EMPTY_STRING();
1166 + } else if (data_size < 0) {
1167 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "data_size cannot be less than zero");
1171 + data = safe_emalloc((int)data_size, sizeof(char), 1);
1173 + ret = bufferevent_read(bevent->bevent, data, data_size);
1175 + if (ret > data_size) { /* paranoia */
1179 + RETURN_STRINGL(data, ret, 0);
1182 + RETURN_EMPTY_STRING();
1186 +/* {{{ proto bool event_buffer_enable(resource bevent, int events)
1188 +static PHP_FUNCTION(event_buffer_enable)
1191 + php_bufferevent_t *bevent;
1195 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &events) != SUCCESS) {
1199 + ZVAL_TO_BEVENT(zbevent, bevent);
1201 + ret = bufferevent_enable(bevent->bevent, events);
1210 +/* {{{ proto bool event_buffer_disable(resource bevent, int events)
1212 +static PHP_FUNCTION(event_buffer_disable)
1215 + php_bufferevent_t *bevent;
1219 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &events) != SUCCESS) {
1223 + ZVAL_TO_BEVENT(zbevent, bevent);
1225 + ret = bufferevent_disable(bevent->bevent, events);
1234 +/* {{{ proto void event_buffer_timeout_set(resource bevent, int read_timeout, int write_timeout)
1236 +static PHP_FUNCTION(event_buffer_timeout_set)
1239 + php_bufferevent_t *bevent;
1240 + long read_timeout, write_timeout;
1242 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &zbevent, &read_timeout, &write_timeout) != SUCCESS) {
1246 + ZVAL_TO_BEVENT(zbevent, bevent);
1247 + bufferevent_settimeout(bevent->bevent, read_timeout, write_timeout);
1251 +/* {{{ proto void event_buffer_watermark_set(resource bevent, int events, int lowmark, int highmark)
1253 +static PHP_FUNCTION(event_buffer_watermark_set)
1256 + php_bufferevent_t *bevent;
1257 + long events, lowmark, highmark;
1259 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &zbevent, &events, &lowmark, &highmark) != SUCCESS) {
1263 + ZVAL_TO_BEVENT(zbevent, bevent);
1264 + bufferevent_setwatermark(bevent->bevent, events, lowmark, highmark);
1268 +/* {{{ proto void event_buffer_fd_set(resource bevent, resource fd)
1270 +static PHP_FUNCTION(event_buffer_fd_set)
1272 + zval *zbevent, *zfd;
1273 + php_stream *stream;
1274 + php_bufferevent_t *bevent;
1276 +#ifdef LIBEVENT_SOCKETS_SUPPORT
1277 + php_socket *php_sock;
1280 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &zbevent, &zfd) != SUCCESS) {
1284 + ZVAL_TO_BEVENT(zbevent, bevent);
1286 + if (Z_TYPE_P(zfd) == IS_RESOURCE) {
1287 + if (ZEND_FETCH_RESOURCE_NO_RETURN(stream, php_stream *, &zfd, -1, NULL, php_file_le_stream())) {
1288 + if (php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&fd, 1) != SUCCESS || fd < 0) {
1292 +#ifdef LIBEVENT_SOCKETS_SUPPORT
1293 + if (ZEND_FETCH_RESOURCE_NO_RETURN(php_sock, php_socket *, &zfd, -1, NULL, php_sockets_le_socket())) {
1294 + fd = php_sock->bsd_socket;
1296 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream or socket resource or a file descriptor of type long");
1300 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
1304 + } else if (Z_TYPE_P(zfd) == IS_LONG) {
1305 + fd = Z_LVAL_P(zfd);
1307 +#ifdef LIBEVENT_SOCKETS_SUPPORT
1308 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream or socket resource or a file descriptor of type long");
1310 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
1315 + bufferevent_setfd(bevent->bevent, fd);
1319 +/* {{{ proto resource event_buffer_set_callback(resource bevent, mixed readcb, mixed writecb, mixed errorcb[, mixed arg])
1321 +static PHP_FUNCTION(event_buffer_set_callback)
1323 + php_bufferevent_t *bevent;
1324 + zval *zbevent, *zreadcb, *zwritecb, *zerrorcb, *zarg = NULL;
1327 + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzzz|z", &zbevent, &zreadcb, &zwritecb, &zerrorcb, &zarg) != SUCCESS) {
1331 + ZVAL_TO_BEVENT(zbevent, bevent);
1333 + if (Z_TYPE_P(zreadcb) != IS_NULL) {
1334 + if (!zend_is_callable(zreadcb, 0, &func_name TSRMLS_CC)) {
1335 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid read callback", func_name);
1344 + if (Z_TYPE_P(zwritecb) != IS_NULL) {
1345 + if (!zend_is_callable(zwritecb, 0, &func_name TSRMLS_CC)) {
1346 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid write callback", func_name);
1355 + if (Z_TYPE_P(zerrorcb) != IS_NULL) {
1356 + if (!zend_is_callable(zerrorcb, 0, &func_name TSRMLS_CC)) {
1357 + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid error callback", func_name);
1367 + zval_add_ref(&zreadcb);
1369 + if (bevent->readcb) {
1370 + zval_ptr_dtor(&bevent->readcb);
1372 + bevent->readcb = zreadcb;
1374 + if (bevent->readcb) {
1375 + zval_ptr_dtor(&bevent->readcb);
1377 + bevent->readcb = NULL;
1381 + zval_add_ref(&zwritecb);
1383 + if (bevent->writecb) {
1384 + zval_ptr_dtor(&bevent->writecb);
1386 + bevent->writecb = zwritecb;
1388 + if (bevent->writecb) {
1389 + zval_ptr_dtor(&bevent->writecb);
1391 + bevent->writecb = NULL;
1395 + zval_add_ref(&zerrorcb);
1397 + if (bevent->errorcb) {
1398 + zval_ptr_dtor(&bevent->errorcb);
1400 + bevent->errorcb = zerrorcb;
1404 + zval_add_ref(&zarg);
1405 + if (bevent->arg) {
1406 + zval_ptr_dtor(&bevent->arg);
1408 + bevent->arg = zarg;
1416 +/* {{{ PHP_MINIT_FUNCTION
1418 +static PHP_MINIT_FUNCTION(libevent)
1420 + le_event_base = zend_register_list_destructors_ex(_php_event_base_dtor, NULL, "event base", module_number);
1421 + le_event = zend_register_list_destructors_ex(_php_event_dtor, NULL, "event", module_number);
1422 + le_bufferevent = zend_register_list_destructors_ex(_php_bufferevent_dtor, NULL, "buffer event", module_number);
1424 + REGISTER_LONG_CONSTANT("EV_TIMEOUT", EV_TIMEOUT, CONST_CS | CONST_PERSISTENT);
1425 + REGISTER_LONG_CONSTANT("EV_READ", EV_READ, CONST_CS | CONST_PERSISTENT);
1426 + REGISTER_LONG_CONSTANT("EV_WRITE", EV_WRITE, CONST_CS | CONST_PERSISTENT);
1427 + REGISTER_LONG_CONSTANT("EV_SIGNAL", EV_SIGNAL, CONST_CS | CONST_PERSISTENT);
1428 + REGISTER_LONG_CONSTANT("EV_PERSIST", EV_PERSIST, CONST_CS | CONST_PERSISTENT);
1429 + REGISTER_LONG_CONSTANT("EVLOOP_NONBLOCK", EVLOOP_NONBLOCK, CONST_CS | CONST_PERSISTENT);
1430 + REGISTER_LONG_CONSTANT("EVLOOP_ONCE", EVLOOP_ONCE, CONST_CS | CONST_PERSISTENT);
1432 + REGISTER_LONG_CONSTANT("EVBUFFER_READ", EVBUFFER_READ, CONST_CS | CONST_PERSISTENT);
1433 + REGISTER_LONG_CONSTANT("EVBUFFER_WRITE", EVBUFFER_WRITE, CONST_CS | CONST_PERSISTENT);
1434 + REGISTER_LONG_CONSTANT("EVBUFFER_EOF", EVBUFFER_EOF, CONST_CS | CONST_PERSISTENT);
1435 + REGISTER_LONG_CONSTANT("EVBUFFER_ERROR", EVBUFFER_ERROR, CONST_CS | CONST_PERSISTENT);
1436 + REGISTER_LONG_CONSTANT("EVBUFFER_TIMEOUT", EVBUFFER_TIMEOUT, CONST_CS | CONST_PERSISTENT);
1442 +/* {{{ PHP_MINFO_FUNCTION
1444 +static PHP_MINFO_FUNCTION(libevent)
1449 + php_info_print_table_start();
1450 + php_info_print_table_header(2, "libevent support", "enabled");
1451 + php_info_print_table_row(2, "extension version", PHP_LIBEVENT_VERSION);
1452 + php_info_print_table_row(2, "Revision", "$Revision: 318910 $");
1454 + snprintf(buf, sizeof(buf) - 1, "%s", event_get_version());
1455 + php_info_print_table_row(2, "libevent version", buf);
1457 + php_info_print_table_end();
1461 +#if PHP_MAJOR_VERSION >= 5
1463 +#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3) || PHP_MAJOR_VERSION > 5
1464 +# define EVENT_ARGINFO
1466 +# define EVENT_ARGINFO static
1470 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_loop, 0, 0, 1)
1471 + ZEND_ARG_INFO(0, base)
1472 + ZEND_ARG_INFO(0, flags)
1473 +ZEND_END_ARG_INFO()
1476 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_loopbreak, 0, 0, 1)
1477 + ZEND_ARG_INFO(0, base)
1478 +ZEND_END_ARG_INFO()
1481 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_loopexit, 0, 0, 1)
1482 + ZEND_ARG_INFO(0, base)
1483 + ZEND_ARG_INFO(0, timeout)
1484 +ZEND_END_ARG_INFO()
1487 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_set, 0, 0, 2)
1488 + ZEND_ARG_INFO(0, event)
1489 + ZEND_ARG_INFO(0, base)
1490 +ZEND_END_ARG_INFO()
1493 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_priority_init, 0, 0, 2)
1494 + ZEND_ARG_INFO(0, base)
1495 + ZEND_ARG_INFO(0, npriorities)
1496 +ZEND_END_ARG_INFO()
1499 +ZEND_BEGIN_ARG_INFO(arginfo_event_new, 0)
1500 +ZEND_END_ARG_INFO()
1503 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_add, 0, 0, 1)
1504 + ZEND_ARG_INFO(0, event)
1505 + ZEND_ARG_INFO(0, timeout)
1506 +ZEND_END_ARG_INFO()
1509 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_set, 0, 0, 4)
1510 + ZEND_ARG_INFO(0, event)
1511 + ZEND_ARG_INFO(0, fd)
1512 + ZEND_ARG_INFO(0, events)
1513 + ZEND_ARG_INFO(0, callback)
1514 + ZEND_ARG_INFO(0, arg)
1515 +ZEND_END_ARG_INFO()
1518 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_del, 0, 0, 1)
1519 + ZEND_ARG_INFO(0, event)
1520 +ZEND_END_ARG_INFO()
1523 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_priority_set, 0, 0, 2)
1524 + ZEND_ARG_INFO(0, event)
1525 + ZEND_ARG_INFO(0, priority)
1526 +ZEND_END_ARG_INFO()
1529 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_new, 0, 0, 4)
1530 + ZEND_ARG_INFO(0, stream)
1531 + ZEND_ARG_INFO(0, readcb)
1532 + ZEND_ARG_INFO(0, writecb)
1533 + ZEND_ARG_INFO(0, errorcb)
1534 + ZEND_ARG_INFO(0, arg)
1535 +ZEND_END_ARG_INFO()
1538 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_free, 0, 0, 1)
1539 + ZEND_ARG_INFO(0, bevent)
1540 +ZEND_END_ARG_INFO()
1543 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_base_set, 0, 0, 2)
1544 + ZEND_ARG_INFO(0, bevent)
1545 + ZEND_ARG_INFO(0, base)
1546 +ZEND_END_ARG_INFO()
1549 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_priority_set, 0, 0, 2)
1550 + ZEND_ARG_INFO(0, bevent)
1551 + ZEND_ARG_INFO(0, priority)
1552 +ZEND_END_ARG_INFO()
1555 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_write, 0, 0, 2)
1556 + ZEND_ARG_INFO(0, bevent)
1557 + ZEND_ARG_INFO(0, data)
1558 + ZEND_ARG_INFO(0, data_size)
1559 +ZEND_END_ARG_INFO()
1562 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_read, 0, 0, 2)
1563 + ZEND_ARG_INFO(0, bevent)
1564 + ZEND_ARG_INFO(0, data_size)
1565 +ZEND_END_ARG_INFO()
1568 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_disable, 0, 0, 2)
1569 + ZEND_ARG_INFO(0, bevent)
1570 + ZEND_ARG_INFO(0, events)
1571 +ZEND_END_ARG_INFO()
1574 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_timeout_set, 0, 0, 3)
1575 + ZEND_ARG_INFO(0, bevent)
1576 + ZEND_ARG_INFO(0, read_timeout)
1577 + ZEND_ARG_INFO(0, write_timeout)
1578 +ZEND_END_ARG_INFO()
1581 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_watermark_set, 0, 0, 4)
1582 + ZEND_ARG_INFO(0, bevent)
1583 + ZEND_ARG_INFO(0, events)
1584 + ZEND_ARG_INFO(0, lowmark)
1585 + ZEND_ARG_INFO(0, highmark)
1586 +ZEND_END_ARG_INFO()
1589 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_fd_set, 0, 0, 2)
1590 + ZEND_ARG_INFO(0, bevent)
1591 + ZEND_ARG_INFO(0, fd)
1592 +ZEND_END_ARG_INFO()
1595 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_set_callback, 0, 0, 4)
1596 + ZEND_ARG_INFO(0, bevent)
1597 + ZEND_ARG_INFO(0, readcb)
1598 + ZEND_ARG_INFO(0, writecb)
1599 + ZEND_ARG_INFO(0, errorcb)
1600 + ZEND_ARG_INFO(0, arg)
1601 +ZEND_END_ARG_INFO()
1604 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_timer_set, 0, 0, 2)
1605 + ZEND_ARG_INFO(0, event)
1606 + ZEND_ARG_INFO(0, callback)
1607 + ZEND_ARG_INFO(0, arg)
1608 +ZEND_END_ARG_INFO()
1611 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_timer_pending, 0, 0, 1)
1612 + ZEND_ARG_INFO(0, event)
1613 + ZEND_ARG_INFO(0, timeout)
1614 +ZEND_END_ARG_INFO()
1617 +/* {{{ libevent_functions[]
1619 +#if ZEND_MODULE_API_NO >= 20071006
1622 +zend_function_entry libevent_functions[] = {
1623 + PHP_FE(event_base_new, arginfo_event_new)
1624 + PHP_FE(event_base_free, arginfo_event_base_loopbreak)
1625 + PHP_FE(event_base_loop, arginfo_event_base_loop)
1626 + PHP_FE(event_base_loopbreak, arginfo_event_base_loopbreak)
1627 + PHP_FE(event_base_loopexit, arginfo_event_base_loopexit)
1628 + PHP_FE(event_base_set, arginfo_event_base_set)
1629 + PHP_FE(event_base_priority_init, arginfo_event_base_priority_init)
1630 + PHP_FE(event_new, arginfo_event_new)
1631 + PHP_FE(event_free, arginfo_event_del)
1632 + PHP_FE(event_add, arginfo_event_add)
1633 + PHP_FE(event_set, arginfo_event_set)
1634 + PHP_FE(event_del, arginfo_event_del)
1635 + PHP_FE(event_priority_set, arginfo_event_priority_set)
1636 + PHP_FE(event_buffer_new, arginfo_event_buffer_new)
1637 + PHP_FE(event_buffer_free, arginfo_event_buffer_free)
1638 + PHP_FE(event_buffer_base_set, arginfo_event_buffer_base_set)
1639 + PHP_FE(event_buffer_priority_set, arginfo_event_buffer_priority_set)
1640 + PHP_FE(event_buffer_write, arginfo_event_buffer_write)
1641 + PHP_FE(event_buffer_read, arginfo_event_buffer_read)
1642 + PHP_FE(event_buffer_enable, arginfo_event_buffer_disable)
1643 + PHP_FE(event_buffer_disable, arginfo_event_buffer_disable)
1644 + PHP_FE(event_buffer_timeout_set, arginfo_event_buffer_timeout_set)
1645 + PHP_FE(event_buffer_watermark_set, arginfo_event_buffer_watermark_set)
1646 + PHP_FE(event_buffer_fd_set, arginfo_event_buffer_fd_set)
1647 + PHP_FE(event_buffer_set_callback, arginfo_event_buffer_set_callback)
1648 + PHP_FALIAS(event_timer_new, event_new, arginfo_event_new)
1649 + PHP_FE(event_timer_set, arginfo_event_timer_set)
1650 + PHP_FE(event_timer_pending, arginfo_event_timer_pending)
1651 + PHP_FALIAS(event_timer_add, event_add, arginfo_event_add)
1652 + PHP_FALIAS(event_timer_del, event_del, arginfo_event_del)
1653 + {NULL, NULL, NULL}
1657 +/* {{{ libevent_functions[]
1659 +zend_function_entry libevent_functions[] = {
1660 + PHP_FE(event_base_new, NULL)
1661 + PHP_FE(event_base_free, NULL)
1662 + PHP_FE(event_base_loop, NULL)
1663 + PHP_FE(event_base_loopbreak, NULL)
1664 + PHP_FE(event_base_loopexit, NULL)
1665 + PHP_FE(event_base_set, NULL)
1666 + PHP_FE(event_base_priority_init, NULL)
1667 + PHP_FE(event_new, NULL)
1668 + PHP_FE(event_free, NULL)
1669 + PHP_FE(event_add, NULL)
1670 + PHP_FE(event_set, NULL)
1671 + PHP_FE(event_del, NULL)
1672 + PHP_FE(event_priority_set, NULL)
1673 + PHP_FE(event_buffer_new, NULL)
1674 + PHP_FE(event_buffer_free, NULL)
1675 + PHP_FE(event_buffer_base_set, NULL)
1676 + PHP_FE(event_buffer_priority_set, NULL)
1677 + PHP_FE(event_buffer_write, NULL)
1678 + PHP_FE(event_buffer_read, NULL)
1679 + PHP_FE(event_buffer_enable, NULL)
1680 + PHP_FE(event_buffer_disable, NULL)
1681 + PHP_FE(event_buffer_timeout_set, NULL)
1682 + PHP_FE(event_buffer_watermark_set, NULL)
1683 + PHP_FE(event_buffer_fd_set, NULL)
1684 + PHP_FALIAS(event_timer_new, event_new, NULL)
1685 + PHP_FE(event_timer_set, NULL)
1686 + PHP_FE(event_timer_pending, NULL)
1687 + PHP_FALIAS(event_timer_add, event_add, NULL)
1688 + PHP_FALIAS(event_timer_del, event_del, NULL)
1689 + {NULL, NULL, NULL}
1694 +static const zend_module_dep libevent_deps[] = { /* {{{ */
1695 + ZEND_MOD_OPTIONAL("sockets")
1696 + {NULL, NULL, NULL}
1700 +/* {{{ libevent_module_entry
1702 +zend_module_entry libevent_module_entry = {
1703 + STANDARD_MODULE_HEADER_EX,
1707 + libevent_functions,
1708 + PHP_MINIT(libevent),
1712 + PHP_MINFO(libevent),
1713 + PHP_LIBEVENT_VERSION,
1714 + STANDARD_MODULE_PROPERTIES
1719 + * Local variables:
1721 + * c-basic-offset: 4
1723 + * vim600: noet sw=4 ts=4 fdm=marker
1724 + * vim<600: noet sw=4 ts=4
1727 +++ b/ext/libevent/libevent.php
1731 +/* poll STDIN using basic API */
1733 +function foo($fd, $events, $arg)
1740 + event_base_loopexit($arg[1]);
1742 + var_dump(fread($fd, 1000));
1746 +$base = event_base_new();
1747 +$event = event_new();
1751 +var_dump(event_set($event, $fd, EV_READ | EV_PERSIST, "foo", array($event, $base)));
1752 +var_dump(event_set($event, $fd, EV_READ | EV_PERSIST, "foo", array($event, $base)));
1754 +event_base_set($event, $base);
1756 +var_dump(event_add($event));
1757 +var_dump(event_base_loop($base));
1761 +/* poll STDIN using event_buffer API */
1763 +function foo2($buf, $arg)
1770 + event_base_loopexit($arg);
1773 + var_dump(event_buffer_read($buf, 10));
1776 +$base = event_base_new();
1777 +$b = event_buffer_new(STDIN, "foo2", NULL, "foo2", $base);
1779 +event_buffer_base_set($b, $base);
1780 +event_buffer_enable($b, EV_READ);
1782 +event_base_loop($base);
1788 +++ b/ext/libevent/php_libevent.h
1791 + +----------------------------------------------------------------------+
1793 + +----------------------------------------------------------------------+
1794 + | Copyright (c) 1997-2008 The PHP Group |
1795 + +----------------------------------------------------------------------+
1796 + | This source file is subject to version 3.01 of the PHP license, |
1797 + | that is bundled with this package in the file LICENSE, and is |
1798 + | available through the world-wide-web at the following url: |
1799 + | http://www.php.net/license/3_01.txt |
1800 + | If you did not receive a copy of the PHP license and are unable to |
1801 + | obtain it through the world-wide-web, please send a note to |
1802 + | license@php.net so we can mail you a copy immediately. |
1803 + +----------------------------------------------------------------------+
1804 + | Author: Antony Dovgal <tony@daylessday.org> |
1805 + | Arnaud Le Blanc <lbarnaud@php.net> |
1806 + +----------------------------------------------------------------------+
1809 +/* $Id: php_libevent.h 300687 2010-06-23 08:13:24Z tony2001 $ */
1811 +#ifndef PHP_LIBEVENT_H
1812 +#define PHP_LIBEVENT_H
1814 +#define PHP_LIBEVENT_VERSION "0.0.4"
1816 +extern zend_module_entry libevent_module_entry;
1817 +#define phpext_libevent_ptr &libevent_module_entry
1823 +#ifndef zend_always_inline
1824 +# if defined(__GNUC__)
1825 +# define zend_always_inline inline __attribute__((always_inline))
1826 +# elif defined(_MSC_VER)
1827 +# define zend_always_inline __forceinline
1829 +# define zend_always_inline inline
1834 +#define Z_ADDREF_P(pz) zval_addref_p(pz)
1835 +static zend_always_inline zend_uint zval_addref_p(zval* pz) {
1836 + return ++pz->refcount;
1841 +#define Z_DELREF_P(pz) zval_delref_p(pz)
1842 +static zend_always_inline zend_uint zval_delref_p(zval* pz) {
1843 + return --pz->refcount;
1847 +#endif /* PHP_LIBEVENT_H */
1851 + * Local variables:
1853 + * c-basic-offset: 4
1855 + * vim600: noet sw=4 ts=4 fdm=marker
1856 + * vim<600: noet sw=4 ts=4