lang/php5/patches/020-PECL-add-libevent.patch

   1 --- /dev/null
   2 +++ b/ext/libevent/CREDITS
   3 @@ -0,0 +1 @@
   4 +Antony Dovgal, Arnaud Le Blanc
   5 --- /dev/null
   6 +++ b/ext/libevent/config.m4
   7 @@ -0,0 +1,52 @@
   8 +dnl $Id: config.m4 287913 2009-08-31 08:45:42Z tony2001 $
   9 +
  10 +PHP_ARG_WITH(libevent, for libevent support,
  11 +[  --with-libevent             Include libevent support])
  12 +
  13 +if test "$PHP_LIBEVENT" != "no"; then
  14 +  SEARCH_PATH="/usr /usr/local"
  15 +  SEARCH_FOR="/include/event.h"
  16 +
  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
  21 +        LIBEVENT_DIR=$i
  22 +        AC_MSG_RESULT(found in $i)
  23 +      fi
  24 +    done
  25 +  else
  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])
  30 +    fi
  31 +  fi
  32 +
  33 +  if test -z "$LIBEVENT_DIR"; then
  34 +    AC_MSG_RESULT([not found])
  35 +    AC_MSG_ERROR([Cannot find libevent headers])
  36 +  fi
  37 +
  38 +  PHP_ADD_INCLUDE($LIBEVENT_DIR/include)
  39 +
  40 +  LIBNAME=event
  41 +  LIBSYMBOL=event_base_new
  42 +
  43 +  if test "x$PHP_LIBDIR" = "x"; then
  44 +    PHP_LIBDIR=lib
  45 +  fi
  46 +
  47 +  PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
  48 +  [
  49 +    PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $LIBEVENT_DIR/$PHP_LIBDIR, LIBEVENT_SHARED_LIBADD)
  50 +  ],[
  51 +    AC_MSG_ERROR([wrong libevent version {1.4.+ is required} or lib not found])
  52 +  ],[
  53 +    -L$LIBEVENT_DIR/$PHP_LIBDIR
  54 +  ])
  55 +
  56 +  PHP_ADD_EXTENSION_DEP(libevent, sockets, true)
  57 +  PHP_SUBST(LIBEVENT_SHARED_LIBADD)
  58 +  PHP_NEW_EXTENSION(libevent, libevent.c, $ext_shared)
  59 +fi
  60 --- /dev/null
  61 +++ b/ext/libevent/libevent.c
  62 @@ -0,0 +1,1663 @@
  63 +/*
  64 +  +----------------------------------------------------------------------+
  65 +  | PHP Version 5                                                        |
  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 +  +----------------------------------------------------------------------+
  80 +*/
  81 +
  82 +/* $Id: libevent.c 318910 2011-11-08 12:34:37Z tony2001 $ */
  83 +
  84 +#ifdef HAVE_CONFIG_H
  85 +#include "config.h"
  86 +#endif
  87 +
  88 +#include "php.h"
  89 +#include "php_ini.h"
  90 +#include "ext/standard/info.h"
  91 +#include "php_streams.h"
  92 +#include "php_network.h"
  93 +#include "php_libevent.h"
  94 +
  95 +#include <signal.h>
  96 +
  97 +#if PHP_VERSION_ID >= 50301 && (HAVE_SOCKETS || defined(COMPILE_DL_SOCKETS))
  98 +# include "ext/sockets/php_sockets.h"
  99 +# define LIBEVENT_SOCKETS_SUPPORT
 100 +#endif
 101 +
 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))
 105 +#endif
 106 +
 107 +#include <event.h>
 108 +
 109 +#if PHP_MAJOR_VERSION < 5
 110 +# ifdef PHP_WIN32
 111 +typedef SOCKET php_socket_t;
 112 +# else
 113 +typedef int php_socket_t;
 114 +# endif
 115 +
 116 +# ifdef ZTS
 117 +#  define TSRMLS_FETCH_FROM_CTX(ctx)  void ***tsrm_ls = (void ***) ctx
 118 +#  define TSRMLS_SET_CTX(ctx)     ctx = (void ***) tsrm_ls
 119 +# else
 120 +#  define TSRMLS_FETCH_FROM_CTX(ctx)
 121 +#  define TSRMLS_SET_CTX(ctx)
 122 +# endif
 123 +
 124 +# ifndef Z_ADDREF_P
 125 +#  define Z_ADDREF_P(x) (x)->refcount++
 126 +# endif
 127 +#endif
 128 +
 129 +static int le_event_base;
 130 +static int le_event;
 131 +static int le_bufferevent;
 132 +
 133 +#ifdef COMPILE_DL_LIBEVENT
 134 +ZEND_GET_MODULE(libevent)
 135 +#endif
 136 +
 137 +typedef struct _php_event_base_t { /* {{{ */
 138 +       struct event_base *base;
 139 +       int rsrc_id;
 140 +       zend_uint events;
 141 +} php_event_base_t;
 142 +/* }}} */
 143 +
 144 +typedef struct _php_event_callback_t { /* {{{ */
 145 +       zval *func;
 146 +       zval *arg;
 147 +} php_event_callback_t;
 148 +/* }}} */
 149 +
 150 +typedef struct _php_event_t { /* {{{ */
 151 +       struct event *event;
 152 +       int rsrc_id;
 153 +       int stream_id;
 154 +       php_event_base_t *base;
 155 +       php_event_callback_t *callback;
 156 +#ifdef ZTS
 157 +       void ***thread_ctx;
 158 +#endif
 159 +       int in_free;
 160 +} php_event_t;
 161 +/* }}} */
 162 +
 163 +typedef struct _php_bufferevent_t { /* {{{ */
 164 +       struct bufferevent *bevent;
 165 +       int rsrc_id;
 166 +       php_event_base_t *base;
 167 +       zval *readcb;
 168 +       zval *writecb;
 169 +       zval *errorcb;
 170 +       zval *arg;
 171 +#ifdef ZTS
 172 +       void ***thread_ctx;
 173 +#endif
 174 +} php_bufferevent_t;
 175 +/* }}} */
 176 +
 177 +#define ZVAL_TO_BASE(zval, base) \
 178 +       ZEND_FETCH_RESOURCE(base, php_event_base_t *, &zval, -1, "event base", le_event_base)
 179 +
 180 +#define ZVAL_TO_EVENT(zval, event) \
 181 +       ZEND_FETCH_RESOURCE(event, php_event_t *, &zval, -1, "event", le_event)
 182 +
 183 +#define ZVAL_TO_BEVENT(zval, bevent) \
 184 +       ZEND_FETCH_RESOURCE(bevent, php_bufferevent_t *, &zval, -1, "buffer event", le_bufferevent)
 185 +
 186 +/* {{{ internal funcs */
 187 +
 188 +static inline void _php_event_callback_free(php_event_callback_t *callback) /* {{{ */
 189 +{
 190 +       if (!callback) {
 191 +               return;
 192 +       }
 193 +
 194 +       zval_ptr_dtor(&callback->func);
 195 +       if (callback->arg) {
 196 +               zval_ptr_dtor(&callback->arg);
 197 +       }
 198 +       efree(callback);
 199 +}
 200 +/* }}} */
 201 +
 202 +static void _php_event_base_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
 203 +{
 204 +       php_event_base_t *base = (php_event_base_t*)rsrc->ptr;
 205 +
 206 +       event_base_free(base->base);
 207 +       efree(base);
 208 +}
 209 +/* }}} */
 210 +
 211 +static void _php_event_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
 212 +{
 213 +       php_event_t *event = (php_event_t*)rsrc->ptr;
 214 +       int base_id = -1;
 215 +
 216 +       if (event->in_free) {
 217 +               return;
 218 +       }
 219 +
 220 +       event->in_free = 1;
 221 +
 222 +       if (event->base) {
 223 +               base_id = event->base->rsrc_id;
 224 +               --event->base->events;
 225 +       }
 226 +       if (event->stream_id >= 0) {
 227 +               zend_list_delete(event->stream_id);
 228 +       }
 229 +       event_del(event->event);
 230 +
 231 +       _php_event_callback_free(event->callback);
 232 +       efree(event->event);
 233 +       efree(event);
 234 +
 235 +       if (base_id >= 0) {
 236 +               zend_list_delete(base_id);
 237 +       }
 238 +}
 239 +/* }}} */
 240 +
 241 +static void _php_bufferevent_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
 242 +{
 243 +       php_bufferevent_t *bevent = (php_bufferevent_t*)rsrc->ptr;
 244 +       int base_id = -1;
 245 +
 246 +       if (bevent->base) {
 247 +               base_id = bevent->base->rsrc_id;
 248 +               --bevent->base->events;
 249 +       }
 250 +       if (bevent->readcb) {
 251 +               zval_ptr_dtor(&(bevent->readcb));
 252 +       }
 253 +       if (bevent->writecb) {
 254 +               zval_ptr_dtor(&(bevent->writecb));
 255 +       }
 256 +       if (bevent->errorcb) {
 257 +               zval_ptr_dtor(&(bevent->errorcb));
 258 +       }
 259 +       if (bevent->arg) {
 260 +               zval_ptr_dtor(&(bevent->arg));
 261 +       }
 262 +
 263 +       bufferevent_free(bevent->bevent);
 264 +       efree(bevent);
 265 +
 266 +       if (base_id >= 0) {
 267 +               zend_list_delete(base_id);
 268 +       }
 269 +}
 270 +/* }}} */
 271 +
 272 +static void _php_event_callback(int fd, short events, void *arg) /* {{{ */
 273 +{
 274 +       zval *args[3];
 275 +       php_event_t *event = (php_event_t *)arg;
 276 +       php_event_callback_t *callback;
 277 +       zval retval;
 278 +       TSRMLS_FETCH_FROM_CTX(event ? event->thread_ctx : NULL);
 279 +
 280 +       if (!event || !event->callback || !event->base) {
 281 +               return;
 282 +       }
 283 +
 284 +       callback = event->callback;
 285 +
 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);
 290 +       } else {
 291 +               ZVAL_NULL(args[0]);
 292 +       }
 293 +
 294 +       MAKE_STD_ZVAL(args[1]);
 295 +       ZVAL_LONG(args[1], events);
 296 +
 297 +       args[2] = callback->arg;
 298 +       Z_ADDREF_P(callback->arg);
 299 +
 300 +       if (call_user_function(EG(function_table), NULL, callback->func, &retval, 3, args TSRMLS_CC) == SUCCESS) {
 301 +               zval_dtor(&retval);
 302 +       }
 303 +
 304 +       zval_ptr_dtor(&(args[0]));
 305 +       zval_ptr_dtor(&(args[1]));
 306 +       zval_ptr_dtor(&(args[2]));
 307 +
 308 +}
 309 +/* }}} */
 310 +
 311 +static void _php_bufferevent_readcb(struct bufferevent *be, void *arg) /* {{{ */
 312 +{
 313 +       zval *args[2];
 314 +       zval retval;
 315 +       php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
 316 +       TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
 317 +
 318 +       if (!bevent || !bevent->base || !bevent->readcb) {
 319 +               return;
 320 +       }
 321 +
 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 */
 325 +
 326 +       args[1] = bevent->arg;
 327 +       Z_ADDREF_P(args[1]);
 328 +
 329 +       if (call_user_function(EG(function_table), NULL, bevent->readcb, &retval, 2, args TSRMLS_CC) == SUCCESS) {
 330 +               zval_dtor(&retval);
 331 +       }
 332 +
 333 +       zval_ptr_dtor(&(args[0]));
 334 +       zval_ptr_dtor(&(args[1]));
 335 +
 336 +}
 337 +/* }}} */
 338 +
 339 +static void _php_bufferevent_writecb(struct bufferevent *be, void *arg) /* {{{ */
 340 +{
 341 +       zval *args[2];
 342 +       zval retval;
 343 +       php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
 344 +       TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
 345 +
 346 +       if (!bevent || !bevent->base || !bevent->writecb) {
 347 +               return;
 348 +       }
 349 +
 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 */
 353 +
 354 +       args[1] = bevent->arg;
 355 +       Z_ADDREF_P(args[1]);
 356 +
 357 +       if (call_user_function(EG(function_table), NULL, bevent->writecb, &retval, 2, args TSRMLS_CC) == SUCCESS) {
 358 +               zval_dtor(&retval);
 359 +       }
 360 +
 361 +       zval_ptr_dtor(&(args[0]));
 362 +       zval_ptr_dtor(&(args[1]));
 363 +
 364 +}
 365 +/* }}} */
 366 +
 367 +static void _php_bufferevent_errorcb(struct bufferevent *be, short what, void *arg) /* {{{ */
 368 +{
 369 +       zval *args[3];
 370 +       zval retval;
 371 +       php_bufferevent_t *bevent = (php_bufferevent_t *)arg;
 372 +       TSRMLS_FETCH_FROM_CTX(bevent ? bevent->thread_ctx : NULL);
 373 +
 374 +       if (!bevent || !bevent->base || !bevent->errorcb) {
 375 +               return;
 376 +       }
 377 +
 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 */
 381 +
 382 +       MAKE_STD_ZVAL(args[1]);
 383 +       ZVAL_LONG(args[1], what);
 384 +
 385 +       args[2] = bevent->arg;
 386 +       Z_ADDREF_P(args[2]);
 387 +
 388 +       if (call_user_function(EG(function_table), NULL, bevent->errorcb, &retval, 3, args TSRMLS_CC) == SUCCESS) {
 389 +               zval_dtor(&retval);
 390 +       }
 391 +
 392 +       zval_ptr_dtor(&(args[0]));
 393 +       zval_ptr_dtor(&(args[1]));
 394 +       zval_ptr_dtor(&(args[2]));
 395 +
 396 +}
 397 +/* }}} */
 398 +
 399 +/* }}} */
 400 +
 401 +
 402 +/* {{{ proto resource event_base_new()
 403 + */
 404 +static PHP_FUNCTION(event_base_new)
 405 +{
 406 +       php_event_base_t *base;
 407 +
 408 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) {
 409 +               return;
 410 +       }
 411 +
 412 +       base = emalloc(sizeof(php_event_base_t));
 413 +       base->base = event_base_new();
 414 +       if (!base->base) {
 415 +               efree(base);
 416 +               RETURN_FALSE;
 417 +       }
 418 +
 419 +       base->events = 0;
 420 +
 421 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
 422 +       base->rsrc_id = zend_list_insert(base, le_event_base TSRMLS_CC);
 423 +#else
 424 +       base->rsrc_id = zend_list_insert(base, le_event_base);
 425 +#endif
 426 +       RETURN_RESOURCE(base->rsrc_id);
 427 +}
 428 +/* }}} */
 429 +
 430 +/* {{{ proto void event_base_free(resource base)
 431 + */
 432 +static PHP_FUNCTION(event_base_free)
 433 +{
 434 +       zval *zbase;
 435 +       php_event_base_t *base;
 436 +
 437 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbase) != SUCCESS) {
 438 +               return;
 439 +       }
 440 +
 441 +       ZVAL_TO_BASE(zbase, base);
 442 +
 443 +       if (base->events > 0) {
 444 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "base has events attached to it and cannot be freed");
 445 +               RETURN_FALSE;
 446 +       }
 447 +
 448 +       zend_list_delete(base->rsrc_id);
 449 +}
 450 +/* }}} */
 451 +
 452 +/* {{{ proto int event_base_loop(resource base[, int flags])
 453 + */
 454 +static PHP_FUNCTION(event_base_loop)
 455 +{
 456 +       zval *zbase;
 457 +       php_event_base_t *base;
 458 +       long flags = 0;
 459 +       int ret;
 460 +
 461 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zbase, &flags) != SUCCESS) {
 462 +               return;
 463 +       }
 464 +
 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);
 469 +
 470 +       RETURN_LONG(ret);
 471 +}
 472 +/* }}} */
 473 +
 474 +/* {{{ proto bool event_base_loopbreak(resource base)
 475 + */
 476 +static PHP_FUNCTION(event_base_loopbreak)
 477 +{
 478 +       zval *zbase;
 479 +       php_event_base_t *base;
 480 +       int ret;
 481 +
 482 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbase) != SUCCESS) {
 483 +               return;
 484 +       }
 485 +
 486 +       ZVAL_TO_BASE(zbase, base);
 487 +       ret = event_base_loopbreak(base->base);
 488 +       if (ret == 0) {
 489 +               RETURN_TRUE;
 490 +       }
 491 +       RETURN_FALSE;
 492 +}
 493 +/* }}} */
 494 +
 495 +/* {{{ proto bool event_base_loopexit(resource base[, int timeout])
 496 + */
 497 +static PHP_FUNCTION(event_base_loopexit)
 498 +{
 499 +       zval *zbase;
 500 +       php_event_base_t *base;
 501 +       int ret;
 502 +       long timeout = -1;
 503 +
 504 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zbase, &timeout) != SUCCESS) {
 505 +               return;
 506 +       }
 507 +
 508 +       ZVAL_TO_BASE(zbase, base);
 509 +
 510 +       if (timeout < 0) {
 511 +               ret = event_base_loopexit(base->base, NULL);
 512 +       } else {
 513 +               struct timeval time;
 514 +
 515 +               time.tv_usec = timeout % 1000000;
 516 +               time.tv_sec = timeout / 1000000;
 517 +               ret = event_base_loopexit(base->base, &time);
 518 +       }
 519 +
 520 +       if (ret == 0) {
 521 +               RETURN_TRUE;
 522 +       }
 523 +       RETURN_FALSE;
 524 +}
 525 +/* }}} */
 526 +
 527 +/* {{{ proto bool event_base_set(resource event, resource base)
 528 + */
 529 +static PHP_FUNCTION(event_base_set)
 530 +{
 531 +       zval *zbase, *zevent;
 532 +       php_event_base_t *base, *old_base;
 533 +       php_event_t *event;
 534 +       int ret;
 535 +
 536 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &zevent, &zbase) != SUCCESS) {
 537 +               return;
 538 +       }
 539 +
 540 +       ZVAL_TO_BASE(zbase, base);
 541 +       ZVAL_TO_EVENT(zevent, event);
 542 +
 543 +       old_base = event->base;
 544 +       ret = event_base_set(base->base, event->event);
 545 +
 546 +       if (ret == 0) {
 547 +               if (base != old_base) {
 548 +                       /* make sure the base is destroyed after the event */
 549 +                       zend_list_addref(base->rsrc_id);
 550 +                       ++base->events;
 551 +               }
 552 +
 553 +               if (old_base) {
 554 +                       --old_base->events;
 555 +                       zend_list_delete(old_base->rsrc_id);
 556 +               }
 557 +
 558 +               event->base = base;
 559 +               RETURN_TRUE;
 560 +       }
 561 +       RETURN_FALSE;
 562 +}
 563 +/* }}} */
 564 +
 565 +/* {{{ proto bool event_base_priority_init(resource base, int npriorities)
 566 + */
 567 +static PHP_FUNCTION(event_base_priority_init)
 568 +{
 569 +       zval *zbase;
 570 +       php_event_base_t *base;
 571 +       long npriorities;
 572 +       int ret;
 573 +
 574 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbase, &npriorities) != SUCCESS) {
 575 +               return;
 576 +       }
 577 +
 578 +       ZVAL_TO_BASE(zbase, base);
 579 +
 580 +       if (npriorities < 0) {
 581 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "npriorities cannot be less than zero");
 582 +               RETURN_FALSE;
 583 +       }
 584 +
 585 +       ret = event_base_priority_init(base->base, npriorities);
 586 +       if (ret == 0) {
 587 +               RETURN_TRUE;
 588 +       }
 589 +       RETURN_FALSE;
 590 +}
 591 +/* }}} */
 592 +
 593 +
 594 +/* {{{ proto resource event_new()
 595 + */
 596 +static PHP_FUNCTION(event_new)
 597 +{
 598 +       php_event_t *event;
 599 +
 600 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") != SUCCESS) {
 601 +               return;
 602 +       }
 603 +
 604 +       event = emalloc(sizeof(php_event_t));
 605 +       event->event = ecalloc(1, sizeof(struct event));
 606 +
 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);
 612 +
 613 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
 614 +       event->rsrc_id = zend_list_insert(event, le_event TSRMLS_CC);
 615 +#else
 616 +       event->rsrc_id = zend_list_insert(event, le_event);
 617 +#endif
 618 +       RETURN_RESOURCE(event->rsrc_id);
 619 +}
 620 +/* }}} */
 621 +
 622 +/* {{{ proto void event_free(resource event)
 623 + */
 624 +static PHP_FUNCTION(event_free)
 625 +{
 626 +       zval *zevent;
 627 +       php_event_t *event;
 628 +
 629 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zevent) != SUCCESS) {
 630 +               return;
 631 +       }
 632 +
 633 +       ZVAL_TO_EVENT(zevent, event);
 634 +       zend_list_delete(event->rsrc_id);
 635 +}
 636 +/* }}} */
 637 +
 638 +/* {{{ proto bool event_add(resource event[, int timeout])
 639 + */
 640 +static PHP_FUNCTION(event_add)
 641 +{
 642 +       zval *zevent;
 643 +       php_event_t *event;
 644 +       int ret;
 645 +       long timeout = -1;
 646 +
 647 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zevent, &timeout) != SUCCESS) {
 648 +               return;
 649 +       }
 650 +
 651 +       ZVAL_TO_EVENT(zevent, event);
 652 +
 653 +       if (!event->base) {
 654 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add event without an event base");
 655 +               RETURN_FALSE;
 656 +       }
 657 +
 658 +       if (timeout < 0) {
 659 +               ret = event_add(event->event, NULL);
 660 +       } else {
 661 +               struct timeval time;
 662 +
 663 +               time.tv_usec = timeout % 1000000;
 664 +               time.tv_sec = timeout / 1000000;
 665 +               ret = event_add(event->event, &time);
 666 +       }
 667 +
 668 +       if (ret != 0) {
 669 +               RETURN_FALSE;
 670 +       }
 671 +
 672 +       RETURN_TRUE;
 673 +}
 674 +/* }}} */
 675 +
 676 +/* {{{ proto bool event_set(resource event, mixed fd, int events, mixed callback[, mixed arg])
 677 + */
 678 +static PHP_FUNCTION(event_set)
 679 +{
 680 +       zval *zevent, **fd, *zcallback, *zarg = NULL;
 681 +       php_event_t *event;
 682 +       long events;
 683 +       php_event_callback_t *callback, *old_callback;
 684 +       char *func_name;
 685 +       php_stream *stream;
 686 +       php_socket_t file_desc;
 687 +#ifdef LIBEVENT_SOCKETS_SUPPORT
 688 +       php_socket *php_sock;
 689 +#endif
 690 +       int ret;
 691 +
 692 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZlz|z", &zevent, &fd, &events, &zcallback, &zarg) != SUCCESS) {
 693 +               return;
 694 +       }
 695 +
 696 +       ZVAL_TO_EVENT(zevent, event);
 697 +
 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");
 704 +                       RETURN_FALSE;
 705 +               }
 706 +       } else {
 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) {
 710 +                                       RETURN_FALSE;
 711 +                               }
 712 +                       } else {
 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;
 716 +                               } else {
 717 +                                       php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be either valid PHP stream or valid PHP socket resource");
 718 +                                       RETURN_FALSE;
 719 +                               }
 720 +#else
 721 +                               php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource");
 722 +                               RETURN_FALSE;
 723 +#endif
 724 +                       }
 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");
 729 +                               RETURN_FALSE;
 730 +                       }
 731 +               } else {
 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");
 734 +#else
 735 +                       php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
 736 +#endif
 737 +                       RETURN_FALSE;
 738 +               }
 739 +       }
 740 +
 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);
 743 +               efree(func_name);
 744 +               RETURN_FALSE;
 745 +       }
 746 +       efree(func_name);
 747 +
 748 +       zval_add_ref(&zcallback);
 749 +       if (zarg) {
 750 +               zval_add_ref(&zarg);
 751 +       } else {
 752 +               ALLOC_INIT_ZVAL(zarg);
 753 +       }
 754 +
 755 +       callback = emalloc(sizeof(php_event_callback_t));
 756 +       callback->func = zcallback;
 757 +       callback->arg = zarg;
 758 +
 759 +       old_callback = event->callback;
 760 +       event->callback = callback;
 761 +       if (events & EV_SIGNAL) {
 762 +               event->stream_id = -1;
 763 +       } else {
 764 +               zend_list_addref(Z_LVAL_PP(fd));
 765 +               event->stream_id = Z_LVAL_PP(fd);
 766 +       }
 767 +
 768 +       event_set(event->event, (int)file_desc, (short)events, _php_event_callback, event);
 769 +
 770 +       if (old_callback) {
 771 +               _php_event_callback_free(old_callback);
 772 +       }
 773 +
 774 +       if (event->base) {
 775 +               ret = event_base_set(event->base->base, event->event);
 776 +               if (ret != 0) {
 777 +                       RETURN_FALSE;
 778 +               }
 779 +       }
 780 +       RETURN_TRUE;
 781 +}
 782 +/* }}} */
 783 +
 784 +/* {{{ proto bool event_del(resource event)
 785 + */
 786 +static PHP_FUNCTION(event_del)
 787 +{
 788 +       zval *zevent;
 789 +       php_event_t *event;
 790 +
 791 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zevent) != SUCCESS) {
 792 +               return;
 793 +       }
 794 +
 795 +       ZVAL_TO_EVENT(zevent, event);
 796 +
 797 +       if (!event->base) {
 798 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to delete event without an event base");
 799 +               RETURN_FALSE;
 800 +       }
 801 +
 802 +       if (event_del(event->event) == 0) {
 803 +               RETURN_TRUE;
 804 +       }
 805 +       RETURN_FALSE;
 806 +}
 807 +/* }}} */
 808 +
 809 +/* {{{ proto bool event_priority_set(resource event, int priority)
 810 + */
 811 +static PHP_FUNCTION(event_priority_set)
 812 +{
 813 +       zval *zevent;
 814 +       php_event_t *event;
 815 +       long priority;
 816 +       int ret;
 817 +
 818 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zevent, &priority) != SUCCESS) {
 819 +               return;
 820 +       }
 821 +
 822 +       ZVAL_TO_EVENT(zevent, event);
 823 +
 824 +       if (!event->base) {
 825 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set event priority without an event base");
 826 +               RETURN_FALSE;
 827 +       }
 828 +
 829 +       ret = event_priority_set(event->event, priority);
 830 +
 831 +       if (ret == 0) {
 832 +               RETURN_TRUE;
 833 +       }
 834 +       RETURN_FALSE;
 835 +}
 836 +/* }}} */
 837 +
 838 +/* {{{ proto bool event_timer_set(resource event, mixed callback[, mixed arg])
 839 + */
 840 +static PHP_FUNCTION(event_timer_set)
 841 +{
 842 +       zval *zevent, *zcallback, *zarg = NULL;
 843 +       php_event_t *event;
 844 +       php_event_callback_t *callback, *old_callback;
 845 +       char *func_name;
 846 +
 847 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &zevent, &zcallback, &zarg) != SUCCESS) {
 848 +               return;
 849 +       }
 850 +
 851 +       ZVAL_TO_EVENT(zevent, event);
 852 +
 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);
 855 +               efree(func_name);
 856 +               RETURN_FALSE;
 857 +       }
 858 +       efree(func_name);
 859 +
 860 +       zval_add_ref(&zcallback);
 861 +       if (zarg) {
 862 +               zval_add_ref(&zarg);
 863 +       } else {
 864 +               ALLOC_INIT_ZVAL(zarg);
 865 +       }
 866 +
 867 +       callback = emalloc(sizeof(php_event_callback_t));
 868 +       callback->func = zcallback;
 869 +       callback->arg = zarg;
 870 +
 871 +       old_callback = event->callback;
 872 +       event->callback = callback;
 873 +       if (event->stream_id >= 0) {
 874 +               zend_list_delete(event->stream_id);
 875 +       }
 876 +       event->stream_id = -1;
 877 +
 878 +       event_set(event->event, -1, 0, _php_event_callback, event);
 879 +
 880 +       if (old_callback) {
 881 +               _php_event_callback_free(old_callback);
 882 +       }
 883 +       RETURN_TRUE;
 884 +}
 885 +/* }}} */
 886 +
 887 +/* {{{ proto bool event_timer_pending(resource event[, int timeout])
 888 + */
 889 +static PHP_FUNCTION(event_timer_pending)
 890 +{
 891 +       zval *zevent;
 892 +       php_event_t *event;
 893 +       int ret;
 894 +       long timeout = -1;
 895 +
 896 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zevent, &timeout) != SUCCESS) {
 897 +               return;
 898 +       }
 899 +
 900 +       ZVAL_TO_EVENT(zevent, event);
 901 +
 902 +       if (timeout < 0) {
 903 +               ret = event_pending(event->event, EV_TIMEOUT, NULL);
 904 +       } else {
 905 +               struct timeval time;
 906 +
 907 +               time.tv_usec = timeout % 1000000;
 908 +               time.tv_sec = timeout / 1000000;
 909 +               ret = event_pending(event->event, EV_TIMEOUT, &time);
 910 +       }
 911 +
 912 +       if (ret != 0) {
 913 +               RETURN_FALSE;
 914 +       }
 915 +       RETURN_TRUE;
 916 +}
 917 +/* }}} */
 918 +
 919 +
 920 +
 921 +/* {{{ proto resource event_buffer_new(mixed fd, mixed readcb, mixed writecb, mixed errorcb[, mixed arg])
 922 + */
 923 +static PHP_FUNCTION(event_buffer_new)
 924 +{
 925 +       php_bufferevent_t *bevent;
 926 +       php_stream *stream;
 927 +       zval *zfd, *zreadcb, *zwritecb, *zerrorcb, *zarg = NULL;
 928 +       php_socket_t fd;
 929 +       char *func_name;
 930 +#ifdef LIBEVENT_SOCKETS_SUPPORT
 931 +       php_socket *php_sock;
 932 +#endif
 933 +
 934 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &zfd, &zreadcb, &zwritecb, &zerrorcb, &zarg) != SUCCESS) {
 935 +               return;
 936 +       }
 937 +
 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) {
 941 +                               RETURN_FALSE;
 942 +                       }
 943 +               } else {
 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;
 947 +                       } else {
 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");
 949 +                               RETURN_FALSE;
 950 +                       }
 951 +#else
 952 +                       php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
 953 +                       RETURN_FALSE;
 954 +#endif
 955 +               }
 956 +       } else if (Z_TYPE_P(zfd) == IS_LONG) {
 957 +               fd = Z_LVAL_P(zfd);
 958 +       } else {
 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");
 961 +#else
 962 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
 963 +#endif
 964 +               RETURN_FALSE;
 965 +       }
 966 +
 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);
 970 +                       efree(func_name);
 971 +                       RETURN_FALSE;
 972 +               }
 973 +               efree(func_name);
 974 +       } else {
 975 +               zreadcb = NULL;
 976 +       }
 977 +
 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);
 981 +                       efree(func_name);
 982 +                       RETURN_FALSE;
 983 +               }
 984 +               efree(func_name);
 985 +       } else {
 986 +               zwritecb = NULL;
 987 +       }
 988 +
 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);
 991 +               efree(func_name);
 992 +               RETURN_FALSE;
 993 +       }
 994 +       efree(func_name);
 995 +
 996 +       bevent = emalloc(sizeof(php_bufferevent_t));
 997 +       bevent->bevent = bufferevent_new(fd, _php_bufferevent_readcb, _php_bufferevent_writecb, _php_bufferevent_errorcb, bevent);
 998 +
 999 +       bevent->base = NULL;
1000 +
1001 +       if (zreadcb) {
1002 +               zval_add_ref(&zreadcb);
1003 +       }
1004 +       bevent->readcb = zreadcb;
1005 +
1006 +       if (zwritecb) {
1007 +               zval_add_ref(&zwritecb);
1008 +       }
1009 +       bevent->writecb = zwritecb;
1010 +
1011 +       zval_add_ref(&zerrorcb);
1012 +       bevent->errorcb = zerrorcb;
1013 +
1014 +       if (zarg) {
1015 +               zval_add_ref(&zarg);
1016 +               bevent->arg = zarg;
1017 +       } else {
1018 +               ALLOC_INIT_ZVAL(bevent->arg);
1019 +       }
1020 +
1021 +       TSRMLS_SET_CTX(bevent->thread_ctx);
1022 +
1023 +#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4
1024 +       bevent->rsrc_id = zend_list_insert(bevent, le_bufferevent TSRMLS_CC);
1025 +#else
1026 +       bevent->rsrc_id = zend_list_insert(bevent, le_bufferevent);
1027 +#endif
1028 +       RETURN_RESOURCE(bevent->rsrc_id);
1029 +}
1030 +/* }}} */
1031 +
1032 +/* {{{ proto void event_buffer_free(resource bevent)
1033 + */
1034 +static PHP_FUNCTION(event_buffer_free)
1035 +{
1036 +       zval *zbevent;
1037 +       php_bufferevent_t *bevent;
1038 +
1039 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zbevent) != SUCCESS) {
1040 +               return;
1041 +       }
1042 +
1043 +       ZVAL_TO_BEVENT(zbevent, bevent);
1044 +       zend_list_delete(bevent->rsrc_id);
1045 +}
1046 +/* }}} */
1047 +
1048 +/* {{{ proto bool event_buffer_base_set(resource bevent, resource base)
1049 + */
1050 +static PHP_FUNCTION(event_buffer_base_set)
1051 +{
1052 +       zval *zbase, *zbevent;
1053 +       php_event_base_t *base, *old_base;
1054 +       php_bufferevent_t *bevent;
1055 +       int ret;
1056 +
1057 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &zbevent, &zbase) != SUCCESS) {
1058 +               return;
1059 +       }
1060 +
1061 +       ZVAL_TO_BASE(zbase, base);
1062 +       ZVAL_TO_BEVENT(zbevent, bevent);
1063 +
1064 +       old_base = bevent->base;
1065 +       ret = bufferevent_base_set(base->base, bevent->bevent);
1066 +
1067 +       if (ret == 0) {
1068 +               if (base != old_base) {
1069 +                       /* make sure the base is destroyed after the event */
1070 +                       zend_list_addref(base->rsrc_id);
1071 +                       ++base->events;
1072 +               }
1073 +
1074 +               if (old_base) {
1075 +                       --old_base->events;
1076 +                       zend_list_delete(old_base->rsrc_id);
1077 +               }
1078 +
1079 +               bevent->base = base;
1080 +               RETURN_TRUE;
1081 +       }
1082 +       RETURN_FALSE;
1083 +}
1084 +/* }}} */
1085 +
1086 +/* {{{ proto bool event_buffer_priority_set(resource bevent, int priority)
1087 + */
1088 +static PHP_FUNCTION(event_buffer_priority_set)
1089 +{
1090 +       zval *zbevent;
1091 +       php_bufferevent_t *bevent;
1092 +       long priority;
1093 +       int ret;
1094 +
1095 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &priority) != SUCCESS) {
1096 +               return;
1097 +       }
1098 +
1099 +       ZVAL_TO_BEVENT(zbevent, bevent);
1100 +
1101 +       if (!bevent->base) {
1102 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set event priority without an event base");
1103 +               RETURN_FALSE;
1104 +       }
1105 +
1106 +       ret = bufferevent_priority_set(bevent->bevent, priority);
1107 +
1108 +       if (ret == 0) {
1109 +               RETURN_TRUE;
1110 +       }
1111 +       RETURN_FALSE;
1112 +}
1113 +/* }}} */
1114 +
1115 +/* {{{ proto bool event_buffer_write(resource bevent, string data[, int data_size])
1116 + */
1117 +static PHP_FUNCTION(event_buffer_write)
1118 +{
1119 +       zval *zbevent;
1120 +       php_bufferevent_t *bevent;
1121 +       char *data;
1122 +       int data_len;
1123 +       long data_size = -1;
1124 +       int ret;
1125 +
1126 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &zbevent, &data, &data_len, &data_size) != SUCCESS) {
1127 +               return;
1128 +       }
1129 +
1130 +       ZVAL_TO_BEVENT(zbevent, bevent);
1131 +
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");
1136 +               RETURN_FALSE;
1137 +       }
1138 +
1139 +       ret = bufferevent_write(bevent->bevent, (const void *)data, data_size);
1140 +
1141 +       if (ret == 0) {
1142 +               RETURN_TRUE;
1143 +       }
1144 +       RETURN_FALSE;
1145 +}
1146 +/* }}} */
1147 +
1148 +/* {{{ proto string event_buffer_read(resource bevent, int data_size)
1149 + */
1150 +static PHP_FUNCTION(event_buffer_read)
1151 +{
1152 +       zval *zbevent;
1153 +       php_bufferevent_t *bevent;
1154 +       char *data;
1155 +       long data_size;
1156 +       int ret;
1157 +
1158 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &data_size) != SUCCESS) {
1159 +               return;
1160 +       }
1161 +
1162 +       ZVAL_TO_BEVENT(zbevent, bevent);
1163 +
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");
1168 +               RETURN_FALSE;
1169 +       }
1170 +
1171 +       data = safe_emalloc((int)data_size, sizeof(char), 1);
1172 +
1173 +       ret = bufferevent_read(bevent->bevent, data, data_size);
1174 +       if (ret > 0) {
1175 +               if (ret > data_size) { /* paranoia */
1176 +                       ret = data_size;
1177 +               }
1178 +               data[ret] = '\0';
1179 +               RETURN_STRINGL(data, ret, 0);
1180 +       }
1181 +       efree(data);
1182 +       RETURN_EMPTY_STRING();
1183 +}
1184 +/* }}} */
1185 +
1186 +/* {{{ proto bool event_buffer_enable(resource bevent, int events)
1187 + */
1188 +static PHP_FUNCTION(event_buffer_enable)
1189 +{
1190 +       zval *zbevent;
1191 +       php_bufferevent_t *bevent;
1192 +       long events;
1193 +       int ret;
1194 +
1195 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &events) != SUCCESS) {
1196 +               return;
1197 +       }
1198 +
1199 +       ZVAL_TO_BEVENT(zbevent, bevent);
1200 +
1201 +       ret = bufferevent_enable(bevent->bevent, events);
1202 +
1203 +       if (ret == 0) {
1204 +               RETURN_TRUE;
1205 +       }
1206 +       RETURN_FALSE;
1207 +}
1208 +/* }}} */
1209 +
1210 +/* {{{ proto bool event_buffer_disable(resource bevent, int events)
1211 + */
1212 +static PHP_FUNCTION(event_buffer_disable)
1213 +{
1214 +       zval *zbevent;
1215 +       php_bufferevent_t *bevent;
1216 +       long events;
1217 +       int ret;
1218 +
1219 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zbevent, &events) != SUCCESS) {
1220 +               return;
1221 +       }
1222 +
1223 +       ZVAL_TO_BEVENT(zbevent, bevent);
1224 +
1225 +       ret = bufferevent_disable(bevent->bevent, events);
1226 +
1227 +       if (ret == 0) {
1228 +               RETURN_TRUE;
1229 +       }
1230 +       RETURN_FALSE;
1231 +}
1232 +/* }}} */
1233 +
1234 +/* {{{ proto void event_buffer_timeout_set(resource bevent, int read_timeout, int write_timeout)
1235 + */
1236 +static PHP_FUNCTION(event_buffer_timeout_set)
1237 +{
1238 +       zval *zbevent;
1239 +       php_bufferevent_t *bevent;
1240 +       long read_timeout, write_timeout;
1241 +
1242 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &zbevent, &read_timeout, &write_timeout) != SUCCESS) {
1243 +               return;
1244 +       }
1245 +
1246 +       ZVAL_TO_BEVENT(zbevent, bevent);
1247 +       bufferevent_settimeout(bevent->bevent, read_timeout, write_timeout);
1248 +}
1249 +/* }}} */
1250 +
1251 +/* {{{ proto void event_buffer_watermark_set(resource bevent, int events, int lowmark, int highmark)
1252 + */
1253 +static PHP_FUNCTION(event_buffer_watermark_set)
1254 +{
1255 +       zval *zbevent;
1256 +       php_bufferevent_t *bevent;
1257 +       long events, lowmark, highmark;
1258 +
1259 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &zbevent, &events, &lowmark, &highmark) != SUCCESS) {
1260 +               return;
1261 +       }
1262 +
1263 +       ZVAL_TO_BEVENT(zbevent, bevent);
1264 +       bufferevent_setwatermark(bevent->bevent, events, lowmark, highmark);
1265 +}
1266 +/* }}} */
1267 +
1268 +/* {{{ proto void event_buffer_fd_set(resource bevent, resource fd)
1269 + */
1270 +static PHP_FUNCTION(event_buffer_fd_set)
1271 +{
1272 +       zval *zbevent, *zfd;
1273 +       php_stream *stream;
1274 +       php_bufferevent_t *bevent;
1275 +       php_socket_t fd;
1276 +#ifdef LIBEVENT_SOCKETS_SUPPORT
1277 +       php_socket *php_sock;
1278 +#endif
1279 +
1280 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &zbevent, &zfd) != SUCCESS) {
1281 +               return;
1282 +       }
1283 +
1284 +       ZVAL_TO_BEVENT(zbevent, bevent);
1285 +
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) {
1289 +                               RETURN_FALSE;
1290 +                       }
1291 +               } else {
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;
1295 +                       } else {
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");
1297 +                               RETURN_FALSE;
1298 +                       }
1299 +#else
1300 +                       php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
1301 +                       RETURN_FALSE;
1302 +#endif
1303 +               }
1304 +       } else if (Z_TYPE_P(zfd) == IS_LONG) {
1305 +               fd = Z_LVAL_P(zfd);
1306 +       } else {
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");
1309 +#else
1310 +               php_error_docref(NULL TSRMLS_CC, E_WARNING, "fd argument must be valid PHP stream resource or a file descriptor of type long");
1311 +#endif
1312 +               RETURN_FALSE;
1313 +       }
1314 +
1315 +       bufferevent_setfd(bevent->bevent, fd);
1316 +}
1317 +/* }}} */
1318 +
1319 +/* {{{ proto resource event_buffer_set_callback(resource bevent, mixed readcb, mixed writecb, mixed errorcb[, mixed arg])
1320 + */
1321 +static PHP_FUNCTION(event_buffer_set_callback)
1322 +{
1323 +       php_bufferevent_t *bevent;
1324 +       zval *zbevent, *zreadcb, *zwritecb, *zerrorcb, *zarg = NULL;
1325 +       char *func_name;
1326 +
1327 +       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzzz|z", &zbevent, &zreadcb, &zwritecb, &zerrorcb, &zarg) != SUCCESS) {
1328 +               return;
1329 +       }
1330 +
1331 +       ZVAL_TO_BEVENT(zbevent, bevent);
1332 +
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);
1336 +                       efree(func_name);
1337 +                       RETURN_FALSE;
1338 +               }
1339 +               efree(func_name);
1340 +       } else {
1341 +               zreadcb = NULL;
1342 +       }
1343 +
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);
1347 +                       efree(func_name);
1348 +                       RETURN_FALSE;
1349 +               }
1350 +               efree(func_name);
1351 +       } else {
1352 +               zwritecb = NULL;
1353 +       }
1354 +
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);
1358 +                       efree(func_name);
1359 +                       RETURN_FALSE;
1360 +               }
1361 +               efree(func_name);
1362 +       } else {
1363 +               zerrorcb = NULL;
1364 +       }
1365 +
1366 +       if (zreadcb) {
1367 +               zval_add_ref(&zreadcb);
1368 +
1369 +               if (bevent->readcb) {
1370 +                       zval_ptr_dtor(&bevent->readcb);
1371 +               }
1372 +               bevent->readcb = zreadcb;
1373 +       } else {
1374 +               if (bevent->readcb) {
1375 +                       zval_ptr_dtor(&bevent->readcb);
1376 +               }
1377 +               bevent->readcb = NULL;
1378 +       }
1379 +
1380 +       if (zwritecb) {
1381 +               zval_add_ref(&zwritecb);
1382 +
1383 +               if (bevent->writecb) {
1384 +                       zval_ptr_dtor(&bevent->writecb);
1385 +               }
1386 +               bevent->writecb = zwritecb;
1387 +       } else {
1388 +               if (bevent->writecb) {
1389 +                       zval_ptr_dtor(&bevent->writecb);
1390 +               }
1391 +               bevent->writecb = NULL;
1392 +       }
1393 +
1394 +       if (zerrorcb) {
1395 +               zval_add_ref(&zerrorcb);
1396 +
1397 +               if (bevent->errorcb) {
1398 +                       zval_ptr_dtor(&bevent->errorcb);
1399 +               }
1400 +               bevent->errorcb = zerrorcb;
1401 +       }
1402 +
1403 +       if (zarg) {
1404 +               zval_add_ref(&zarg);
1405 +               if (bevent->arg) {
1406 +                       zval_ptr_dtor(&bevent->arg);
1407 +               }
1408 +               bevent->arg = zarg;
1409 +       }
1410 +
1411 +       RETURN_TRUE;
1412 +}
1413 +/* }}} */
1414 +
1415 +
1416 +/* {{{ PHP_MINIT_FUNCTION
1417 + */
1418 +static PHP_MINIT_FUNCTION(libevent)
1419 +{
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);
1423 +
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);
1431 +
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);
1437 +
1438 +       return SUCCESS;
1439 +}
1440 +/* }}} */
1441 +
1442 +/* {{{ PHP_MINFO_FUNCTION
1443 + */
1444 +static PHP_MINFO_FUNCTION(libevent)
1445 +{
1446 +       char buf[64];
1447 +
1448 +
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 $");
1453 +
1454 +       snprintf(buf, sizeof(buf) - 1, "%s", event_get_version());
1455 +       php_info_print_table_row(2, "libevent version", buf);
1456 +
1457 +       php_info_print_table_end();
1458 +}
1459 +/* }}} */
1460 +
1461 +#if PHP_MAJOR_VERSION >= 5
1462 +/* {{{ arginfo */
1463 +#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3) || PHP_MAJOR_VERSION > 5
1464 +# define EVENT_ARGINFO
1465 +#else
1466 +# define EVENT_ARGINFO static
1467 +#endif
1468 +
1469 +EVENT_ARGINFO
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()
1474 +
1475 +EVENT_ARGINFO
1476 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_base_loopbreak, 0, 0, 1)
1477 +       ZEND_ARG_INFO(0, base)
1478 +ZEND_END_ARG_INFO()
1479 +
1480 +EVENT_ARGINFO
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()
1485 +
1486 +EVENT_ARGINFO
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()
1491 +
1492 +EVENT_ARGINFO
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()
1497 +
1498 +EVENT_ARGINFO
1499 +ZEND_BEGIN_ARG_INFO(arginfo_event_new, 0)
1500 +ZEND_END_ARG_INFO()
1501 +
1502 +EVENT_ARGINFO
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()
1507 +
1508 +EVENT_ARGINFO
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()
1516 +
1517 +EVENT_ARGINFO
1518 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_del, 0, 0, 1)
1519 +       ZEND_ARG_INFO(0, event)
1520 +ZEND_END_ARG_INFO()
1521 +
1522 +EVENT_ARGINFO
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()
1527 +
1528 +EVENT_ARGINFO
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()
1536 +
1537 +EVENT_ARGINFO
1538 +ZEND_BEGIN_ARG_INFO_EX(arginfo_event_buffer_free, 0, 0, 1)
1539 +       ZEND_ARG_INFO(0, bevent)
1540 +ZEND_END_ARG_INFO()
1541 +
1542 +EVENT_ARGINFO
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()
1547 +
1548 +EVENT_ARGINFO
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()
1553 +
1554 +EVENT_ARGINFO
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()
1560 +
1561 +EVENT_ARGINFO
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()
1566 +
1567 +EVENT_ARGINFO
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()
1572 +
1573 +EVENT_ARGINFO
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()
1579 +
1580 +EVENT_ARGINFO
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()
1587 +
1588 +EVENT_ARGINFO
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()
1593 +
1594 +EVENT_ARGINFO
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()
1602 +
1603 +EVENT_ARGINFO
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()
1609 +
1610 +EVENT_ARGINFO
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()
1615 +/* }}} */
1616 +
1617 +/* {{{ libevent_functions[]
1618 + */
1619 +#if ZEND_MODULE_API_NO >= 20071006
1620 +const
1621 +#endif
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}
1654 +};
1655 +/* }}} */
1656 +#else
1657 +/* {{{ libevent_functions[]
1658 + */
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}
1690 +};
1691 +/* }}} */
1692 +#endif
1693 +
1694 +static const zend_module_dep libevent_deps[] = { /* {{{ */
1695 +       ZEND_MOD_OPTIONAL("sockets")
1696 +       {NULL, NULL, NULL}
1697 +};
1698 +/* }}} */
1699 +
1700 +/* {{{ libevent_module_entry
1701 + */
1702 +zend_module_entry libevent_module_entry = {
1703 +       STANDARD_MODULE_HEADER_EX,
1704 +       NULL,
1705 +       libevent_deps,
1706 +       "libevent",
1707 +       libevent_functions,
1708 +       PHP_MINIT(libevent),
1709 +       NULL,
1710 +       NULL,
1711 +       NULL,
1712 +       PHP_MINFO(libevent),
1713 +       PHP_LIBEVENT_VERSION,
1714 +       STANDARD_MODULE_PROPERTIES
1715 +};
1716 +/* }}} */
1717 +
1718 +/*
1719 + * Local variables:
1720 + * tab-width: 4
1721 + * c-basic-offset: 4
1722 + * End:
1723 + * vim600: noet sw=4 ts=4 fdm=marker
1724 + * vim<600: noet sw=4 ts=4
1725 + */
1726 --- /dev/null
1727 +++ b/ext/libevent/libevent.php
1728 @@ -0,0 +1,58 @@
1729 +<?php
1730 +
1731 +/* poll STDIN using basic API */
1732 +
1733 +function foo($fd, $events, $arg)
1734 +{
1735 +       static $i;
1736 +
1737 +       $i++;
1738 +
1739 +       if ($i == 10) {
1740 +               event_base_loopexit($arg[1]);
1741 +       }
1742 +       var_dump(fread($fd, 1000));
1743 +}
1744 +
1745 +
1746 +$base = event_base_new();
1747 +$event = event_new();
1748 +
1749 +$fd = STDIN;
1750 +
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)));
1753 +
1754 +event_base_set($event, $base);
1755 +
1756 +var_dump(event_add($event));
1757 +var_dump(event_base_loop($base));
1758 +
1759 +exit;
1760 +
1761 +/* poll STDIN using event_buffer API */
1762 +
1763 +function foo2($buf, $arg)
1764 +{
1765 +       static $i;
1766 +
1767 +       $i++;
1768 +
1769 +       if ($i == 10) {
1770 +               event_base_loopexit($arg);
1771 +       }
1772 +       var_dump($buf);
1773 +       var_dump(event_buffer_read($buf, 10));
1774 +}
1775 +
1776 +$base = event_base_new();
1777 +$b = event_buffer_new(STDIN, "foo2", NULL, "foo2", $base);
1778 +
1779 +event_buffer_base_set($b, $base);
1780 +event_buffer_enable($b, EV_READ);
1781 +
1782 +event_base_loop($base);
1783 +
1784 +
1785 +
1786 +?>
1787 --- /dev/null
1788 +++ b/ext/libevent/php_libevent.h
1789 @@ -0,0 +1,68 @@
1790 +/*
1791 +  +----------------------------------------------------------------------+
1792 +  | PHP Version 5                                                        |
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 +  +----------------------------------------------------------------------+
1807 +*/
1808 +
1809 +/* $Id: php_libevent.h 300687 2010-06-23 08:13:24Z tony2001 $ */
1810 +
1811 +#ifndef PHP_LIBEVENT_H
1812 +#define PHP_LIBEVENT_H
1813 +
1814 +#define PHP_LIBEVENT_VERSION "0.0.4"
1815 +
1816 +extern zend_module_entry libevent_module_entry;
1817 +#define phpext_libevent_ptr &libevent_module_entry
1818 +
1819 +#ifdef ZTS
1820 +#include "TSRM.h"
1821 +#endif
1822 +
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
1828 +# else
1829 +#  define zend_always_inline inline
1830 +# endif
1831 +#endif
1832 +
1833 +#ifndef Z_ADDREF_P
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;
1837 +}
1838 +#endif
1839 +
1840 +#ifndef Z_DELREF_P
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;
1844 +}
1845 +#endif
1846 +
1847 +#endif /* PHP_LIBEVENT_H */
1848 +
1849 +
1850 +/*
1851 + * Local variables:
1852 + * tab-width: 4
1853 + * c-basic-offset: 4
1854 + * End:
1855 + * vim600: noet sw=4 ts=4 fdm=marker
1856 + * vim<600: noet sw=4 ts=4
1857 + */