git.m6w6.name Git - m6w6/ext-http/blob - php_http_client_pool.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: http                                                       |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2004-2011, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #include "php_http_api.h"
  14
  15 PHP_HTTP_API php_http_client_pool_t *php_http_client_pool_init(php_http_client_pool_t *h, php_http_client_pool_ops_t *ops, php_http_resource_factory_t *rf, void *init_arg TSRMLS_DC)
  16 {
  17         php_http_client_pool_t *free_h = NULL;
  18
  19         if (!h) {
  20                 free_h = h = emalloc(sizeof(*h));
  21         }
  22         memset(h, 0, sizeof(*h));
  23
  24         h->ops = ops;
  25         if (rf) {
  26                 h->rf = rf;
  27         } else if (ops->rsrc) {
  28                 h->rf = php_http_resource_factory_init(NULL, h->ops->rsrc, h, NULL);
  29         }
  30         zend_llist_init(&h->clients.attached, sizeof(zval *), (llist_dtor_func_t) ZVAL_PTR_DTOR, 0);
  31         zend_llist_init(&h->clients.finished, sizeof(zval *), (llist_dtor_func_t) ZVAL_PTR_DTOR, 0);
  32         TSRMLS_SET_CTX(h->ts);
  33
  34         if (h->ops->init) {
  35                 if (!(h = h->ops->init(h, init_arg))) {
  36                         php_http_error(HE_WARNING, PHP_HTTP_E_CLIENT_POOL, "Could not initialize request pool");
  37                         if (free_h) {
  38                                 efree(h);
  39                         }
  40                 }
  41         }
  42
  43         return h;
  44 }
  45
  46 PHP_HTTP_API php_http_client_pool_t *php_http_client_pool_copy(php_http_client_pool_t *from, php_http_client_pool_t *to)
  47 {
  48         if (from->ops->copy) {
  49                 return from->ops->copy(from, to);
  50         }
  51
  52         return NULL;
  53 }
  54
  55 PHP_HTTP_API void php_http_client_pool_dtor(php_http_client_pool_t *h)
  56 {
  57         if (h->ops->dtor) {
  58                 h->ops->dtor(h);
  59         }
  60
  61         zend_llist_clean(&h->clients.finished);
  62         zend_llist_clean(&h->clients.attached);
  63
  64         php_http_resource_factory_free(&h->rf);
  65 }
  66
  67 PHP_HTTP_API void php_http_client_pool_free(php_http_client_pool_t **h) {
  68         if (*h) {
  69                 php_http_client_pool_dtor(*h);
  70                 efree(*h);
  71                 *h = NULL;
  72         }
  73 }
  74
  75 PHP_HTTP_API STATUS php_http_client_pool_attach(php_http_client_pool_t *h, zval *client)
  76 {
  77         TSRMLS_FETCH_FROM_CTX(h->ts);
  78
  79         if (h->ops->attach) {
  80                 zval *zreq = NULL;
  81                 php_http_client_object_t *obj;
  82                 php_http_message_object_t *msg_obj;
  83
  84                 if (SUCCESS != php_http_client_object_handle_request(client, &zreq TSRMLS_CC)) {
  85                         return FAILURE;
  86                 }
  87
  88                 obj = zend_object_store_get_object(client TSRMLS_CC);
  89                 msg_obj = zend_object_store_get_object(zreq TSRMLS_CC);
  90
  91                 if (SUCCESS == h->ops->attach(h, obj->client, msg_obj->message)) {
  92                         Z_ADDREF_P(client);
  93                         zend_llist_add_element(&h->clients.attached, &client);
  94                         return SUCCESS;
  95                 }
  96         }
  97
  98         return FAILURE;
  99 }
 100
 101 static int php_http_client_pool_compare_handles(void *h1, void *h2)
 102 {
 103         return (Z_OBJ_HANDLE_PP((zval **) h1) == Z_OBJ_HANDLE_P((zval *) h2));
 104 }
 105
 106
 107 PHP_HTTP_API STATUS php_http_client_pool_detach(php_http_client_pool_t *h, zval *client)
 108 {
 109         TSRMLS_FETCH_FROM_CTX(h->ts);
 110
 111         if (h->ops->detach) {
 112                 php_http_client_object_t *obj = zend_object_store_get_object(client TSRMLS_CC);
 113
 114                 if (SUCCESS == h->ops->detach(h, obj->client)) {
 115                         zend_llist_del_element(&h->clients.finished, client, php_http_client_pool_compare_handles);
 116                         zend_llist_del_element(&h->clients.attached, client, php_http_client_pool_compare_handles);
 117                         return SUCCESS;
 118                 }
 119         }
 120
 121         return FAILURE;
 122 }
 123
 124 PHP_HTTP_API STATUS php_http_client_pool_wait(php_http_client_pool_t *h, struct timeval *custom_timeout)
 125 {
 126         if (h->ops->wait) {
 127                 return h->ops->wait(h, custom_timeout);
 128         }
 129
 130         return FAILURE;
 131 }
 132
 133 PHP_HTTP_API int php_http_client_pool_once(php_http_client_pool_t *h)
 134 {
 135         if (h->ops->once) {
 136                 return h->ops->once(h);
 137         }
 138
 139         return FAILURE;
 140 }
 141
 142 PHP_HTTP_API STATUS php_http_client_pool_exec(php_http_client_pool_t *h)
 143 {
 144         if (h->ops->exec) {
 145                 return h->ops->exec(h);
 146         }
 147
 148         return FAILURE;
 149 }
 150
 151 static void detach(void *r, void *h TSRMLS_DC)
 152 {
 153         ((php_http_client_pool_t *) h)->ops->detach(h, ((php_http_client_object_t *) zend_object_store_get_object(*((zval **) r) TSRMLS_CC))->client);
 154 }
 155
 156 PHP_HTTP_API void php_http_client_pool_reset(php_http_client_pool_t *h)
 157 {
 158         if (h->ops->reset) {
 159                 h->ops->reset(h);
 160         } else if (h->ops->detach) {
 161                 TSRMLS_FETCH_FROM_CTX(h->ts);
 162
 163                 zend_llist_apply_with_argument(&h->clients.attached, detach, h TSRMLS_CC);
 164         }
 165
 166         zend_llist_clean(&h->clients.attached);
 167         zend_llist_clean(&h->clients.finished);
 168 }
 169
 170 PHP_HTTP_API STATUS php_http_client_pool_setopt(php_http_client_pool_t *h, php_http_client_pool_setopt_opt_t opt, void *arg)
 171 {
 172         if (h->ops->setopt) {
 173                 return h->ops->setopt(h, opt, arg);
 174         }
 175
 176         return FAILURE;
 177 }
 178
 179 PHP_HTTP_API void php_http_client_pool_requests(php_http_client_pool_t *h, zval ***attached, zval ***finished)
 180 {
 181         zval **handle;
 182         int i, count;
 183
 184         if (attached) {
 185                 if ((count = zend_llist_count(&h->clients.attached))) {
 186                         *attached = ecalloc(count + 1 /* terminating NULL */, sizeof(zval *));
 187
 188                         for (i = 0, handle = zend_llist_get_first(&h->clients.attached); handle; handle = zend_llist_get_next(&h->clients.attached)) {
 189                                 Z_ADDREF_PP(handle);
 190                                 (*attached)[i++] = *handle;
 191                         }
 192                 } else {
 193                         *attached = NULL;
 194                 }
 195         }
 196
 197         if (finished) {
 198                 if ((count = zend_llist_count(&h->clients.finished))) {
 199                         *finished = ecalloc(count + 1 /* terminating NULL */, sizeof(zval *));
 200
 201                         for (i = 0, handle = zend_llist_get_first(&h->clients.finished); handle; handle = zend_llist_get_next(&h->clients.finished)) {
 202                                 Z_ADDREF_PP(handle);
 203                                 (*finished)[i++] = *handle;
 204                         }
 205                 } else {
 206                         *finished = NULL;
 207                 }
 208         }
 209 }
 210
 211 /*#*/
 212
 213 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpClientPool, method, 0, req_args)
 214 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpClientPool, method, 0)
 215 #define PHP_HTTP_CLIENT_POOL_ME(method, visibility)     PHP_ME(HttpClientPool, method, PHP_HTTP_ARGS(HttpClientPool, method), visibility)
 216
 217 PHP_HTTP_EMPTY_ARGS(__destruct);
 218 PHP_HTTP_EMPTY_ARGS(reset);
 219
 220 PHP_HTTP_BEGIN_ARGS(attach, 1)
 221         PHP_HTTP_ARG_OBJ(http\\Client\\AbstractClient, request, 0)
 222 PHP_HTTP_END_ARGS;
 223
 224 PHP_HTTP_BEGIN_ARGS(detach, 1)
 225         PHP_HTTP_ARG_OBJ(http\\Client\\AbstractClient, request, 0)
 226 PHP_HTTP_END_ARGS;
 227
 228 PHP_HTTP_EMPTY_ARGS(send);
 229 PHP_HTTP_EMPTY_ARGS(once);
 230 PHP_HTTP_BEGIN_ARGS(wait, 0)
 231         PHP_HTTP_ARG_VAL(timeout, 0)
 232 PHP_HTTP_END_ARGS;
 233
 234 PHP_HTTP_EMPTY_ARGS(valid);
 235 PHP_HTTP_EMPTY_ARGS(current);
 236 PHP_HTTP_EMPTY_ARGS(key);
 237 PHP_HTTP_EMPTY_ARGS(next);
 238 PHP_HTTP_EMPTY_ARGS(rewind);
 239
 240 PHP_HTTP_EMPTY_ARGS(count);
 241
 242 PHP_HTTP_EMPTY_ARGS(getAttached);
 243 PHP_HTTP_EMPTY_ARGS(getFinished);
 244
 245 PHP_HTTP_BEGIN_ARGS(enablePipelining, 0)
 246         PHP_HTTP_ARG_VAL(enable, 0)
 247 PHP_HTTP_END_ARGS;
 248
 249 PHP_HTTP_BEGIN_ARGS(enableEvents, 0)
 250         PHP_HTTP_ARG_VAL(enable, 0)
 251 PHP_HTTP_END_ARGS;
 252
 253 static zend_class_entry *php_http_client_pool_class_entry;
 254
 255 zend_class_entry *php_http_client_pool_get_class_entry(void)
 256 {
 257         return php_http_client_pool_class_entry;
 258 }
 259
 260 static zend_function_entry php_http_client_pool_method_entry[] = {
 261         PHP_HTTP_CLIENT_POOL_ME(__destruct, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR)
 262         PHP_HTTP_CLIENT_POOL_ME(attach, ZEND_ACC_PUBLIC)
 263         PHP_HTTP_CLIENT_POOL_ME(detach, ZEND_ACC_PUBLIC)
 264         PHP_HTTP_CLIENT_POOL_ME(send, ZEND_ACC_PUBLIC)
 265         PHP_HTTP_CLIENT_POOL_ME(reset, ZEND_ACC_PUBLIC)
 266
 267         PHP_HTTP_CLIENT_POOL_ME(once, ZEND_ACC_PROTECTED)
 268         PHP_HTTP_CLIENT_POOL_ME(wait, ZEND_ACC_PROTECTED)
 269
 270         /* implements Iterator */
 271         PHP_HTTP_CLIENT_POOL_ME(valid, ZEND_ACC_PUBLIC)
 272         PHP_HTTP_CLIENT_POOL_ME(current, ZEND_ACC_PUBLIC)
 273         PHP_HTTP_CLIENT_POOL_ME(key, ZEND_ACC_PUBLIC)
 274         PHP_HTTP_CLIENT_POOL_ME(next, ZEND_ACC_PUBLIC)
 275         PHP_HTTP_CLIENT_POOL_ME(rewind, ZEND_ACC_PUBLIC)
 276
 277         /* implmenents Countable */
 278         PHP_HTTP_CLIENT_POOL_ME(count, ZEND_ACC_PUBLIC)
 279
 280         PHP_HTTP_CLIENT_POOL_ME(getAttached, ZEND_ACC_PUBLIC)
 281         PHP_HTTP_CLIENT_POOL_ME(getFinished, ZEND_ACC_PUBLIC)
 282
 283         PHP_HTTP_CLIENT_POOL_ME(enablePipelining, ZEND_ACC_PUBLIC)
 284         PHP_HTTP_CLIENT_POOL_ME(enableEvents, ZEND_ACC_PUBLIC)
 285
 286         EMPTY_FUNCTION_ENTRY
 287 };
 288
 289 static zend_object_handlers php_http_client_pool_object_handlers;
 290
 291 extern zend_object_handlers *php_http_client_pool_get_object_handlers(void)
 292 {
 293         return &php_http_client_pool_object_handlers;
 294 }
 295
 296 static php_http_client_pool_ops_t php_http_client_pool_user_ops = {
 297         NULL,
 298         NULL,
 299         NULL,
 300         NULL,
 301         NULL,
 302         NULL,
 303         NULL,
 304         NULL,
 305         NULL,
 306         NULL,
 307         NULL,
 308         (php_http_new_t) php_http_client_pool_object_new_ex,
 309         php_http_client_pool_get_class_entry
 310 };
 311
 312 zend_object_value php_http_client_pool_object_new(zend_class_entry *ce TSRMLS_DC)
 313 {
 314         return php_http_client_pool_object_new_ex(ce, NULL, NULL TSRMLS_CC);
 315 }
 316
 317 zend_object_value php_http_client_pool_object_new_ex(zend_class_entry *ce, php_http_client_pool_t *p, php_http_client_pool_object_t **ptr TSRMLS_DC)
 318 {
 319         zend_object_value ov;
 320         php_http_client_pool_object_t *o;
 321
 322         o = ecalloc(1, sizeof(php_http_client_pool_object_t));
 323         zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
 324         object_properties_init((zend_object *) o, ce);
 325
 326         if (!(o->pool = p)) {
 327                 o->pool = php_http_client_pool_init(NULL, &php_http_client_pool_user_ops, NULL, NULL TSRMLS_CC);
 328         }
 329
 330         if (ptr) {
 331                 *ptr = o;
 332         }
 333
 334         ov.handle = zend_objects_store_put(o, NULL, php_http_client_pool_object_free, NULL TSRMLS_CC);
 335         ov.handlers = &php_http_client_pool_object_handlers;
 336
 337         return ov;
 338 }
 339
 340 void php_http_client_pool_object_free(void *object TSRMLS_DC)
 341 {
 342         php_http_client_pool_object_t *o = (php_http_client_pool_object_t *) object;
 343
 344         php_http_client_pool_free(&o->pool);
 345         zend_object_std_dtor((zend_object *) o TSRMLS_CC);
 346         efree(o);
 347 }
 348
 349 static void php_http_client_pool_object_llist2array(zval **req, zval *array TSRMLS_DC)
 350 {
 351         Z_ADDREF_P(*req);
 352         add_next_index_zval(array, *req);
 353 }
 354
 355 PHP_METHOD(HttpClientPool, __destruct)
 356 {
 357         php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 358
 359         if (SUCCESS != zend_parse_parameters_none()) {
 360                 ; /* we always want to clean up */
 361         }
 362         /* FIXME: move to php_http_client_pool_dtor */
 363         php_http_client_pool_reset(obj->pool);
 364 }
 365
 366 PHP_METHOD(HttpClientPool, reset)
 367 {
 368         if (SUCCESS == zend_parse_parameters_none()) {
 369                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 370
 371                 obj->iterator.pos = 0;
 372                 php_http_client_pool_reset(obj->pool);
 373         }
 374         RETVAL_ZVAL(getThis(), 1, 0);
 375 }
 376
 377 PHP_METHOD(HttpClientPool, attach)
 378 {
 379         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 380                 zval *request;
 381
 382                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &request, php_http_client_get_class_entry())) {
 383                         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 384                                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 385
 386                                 if (obj->iterator.pos > 0 && obj->iterator.pos < zend_llist_count(&obj->pool->clients.attached)) {
 387                                         php_http_error(HE_THROW, PHP_HTTP_E_CLIENT_POOL, "Cannot attach to the HttpClientPool while the iterator is active");
 388                                 } else {
 389                                         php_http_client_pool_attach(obj->pool, request);
 390                                 }
 391                         } end_error_handling();
 392                 }
 393         } end_error_handling();
 394
 395         RETVAL_ZVAL(getThis(), 1, 0);
 396 }
 397
 398 PHP_METHOD(HttpClientPool, detach)
 399 {
 400         RETVAL_FALSE;
 401
 402         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 403                 zval *request;
 404
 405                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &request, php_http_client_get_class_entry())) {
 406                         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 407                                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 408
 409                                 obj->iterator.pos = -1;
 410                                 php_http_client_pool_detach(obj->pool, request);
 411                         } end_error_handling();
 412                 }
 413         } end_error_handling();
 414
 415         RETVAL_ZVAL(getThis(), 1, 0);
 416 }
 417
 418 PHP_METHOD(HttpClientPool, send)
 419 {
 420         RETVAL_FALSE;
 421
 422         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 423                 if (SUCCESS == zend_parse_parameters_none()) {
 424                         with_error_handling(EH_THROW, php_http_exception_class_entry) {
 425                                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 426
 427                                 php_http_client_pool_exec(obj->pool);
 428                         } end_error_handling();
 429                 }
 430         } end_error_handling();
 431
 432         RETVAL_ZVAL(getThis(), 1, 0);
 433 }
 434
 435 PHP_METHOD(HttpClientPool, once)
 436 {
 437         if (SUCCESS == zend_parse_parameters_none()) {
 438                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 439
 440                 if (0 < php_http_client_pool_once(obj->pool)) {
 441                         RETURN_TRUE;
 442                 }
 443         }
 444         RETURN_FALSE;
 445 }
 446
 447 PHP_METHOD(HttpClientPool, wait)
 448 {
 449         double timeout = 0;
 450
 451         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|d", &timeout)) {
 452                 struct timeval timeout_val;
 453                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 454
 455                 timeout_val.tv_sec = (time_t) timeout;
 456                 timeout_val.tv_usec = PHP_HTTP_USEC(timeout) % PHP_HTTP_MCROSEC;
 457
 458                 RETURN_SUCCESS(php_http_client_pool_wait(obj->pool, timeout > 0 ? &timeout_val : NULL));
 459         }
 460         RETURN_FALSE;
 461 }
 462
 463 PHP_METHOD(HttpClientPool, valid)
 464 {
 465         if (SUCCESS == zend_parse_parameters_none()) {
 466                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 467
 468                 RETURN_BOOL(obj->iterator.pos >= 0 && obj->iterator.pos < zend_llist_count(&obj->pool->clients.attached));
 469         }
 470         RETURN_FALSE;
 471 }
 472
 473 PHP_METHOD(HttpClientPool, current)
 474 {
 475         if (SUCCESS == zend_parse_parameters_none()) {
 476                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 477
 478                 if (obj->iterator.pos < zend_llist_count(&obj->pool->clients.attached)) {
 479                         long pos = 0;
 480                         zval **current = NULL;
 481                         zend_llist_position lpos;
 482
 483                         for (   current = zend_llist_get_first_ex(&obj->pool->clients.attached, &lpos);
 484                                         current && obj->iterator.pos != pos++;
 485                                         current = zend_llist_get_next_ex(&obj->pool->clients.attached, &lpos));
 486                         if (current) {
 487                                 RETURN_OBJECT(*current, 1);
 488                         }
 489                 }
 490         }
 491         RETURN_FALSE;
 492 }
 493
 494 PHP_METHOD(HttpClientPool, key)
 495 {
 496         if (SUCCESS == zend_parse_parameters_none()) {
 497                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 498
 499                 RETURN_LONG(obj->iterator.pos);
 500         }
 501         RETURN_FALSE;
 502 }
 503
 504 PHP_METHOD(HttpClientPool, next)
 505 {
 506         if (SUCCESS == zend_parse_parameters_none()) {
 507                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 508
 509                 ++obj->iterator.pos;
 510         }
 511 }
 512
 513 PHP_METHOD(HttpClientPool, rewind)
 514 {
 515         if (SUCCESS == zend_parse_parameters_none()) {
 516                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 517
 518                 obj->iterator.pos = 0;
 519         }
 520 }
 521
 522 PHP_METHOD(HttpClientPool, count)
 523 {
 524         if (SUCCESS == zend_parse_parameters_none()) {
 525                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 526
 527                 RETURN_LONG((long) zend_llist_count(&obj->pool->clients.attached));
 528         }
 529 }
 530
 531 PHP_METHOD(HttpClientPool, getAttached)
 532 {
 533         if (SUCCESS == zend_parse_parameters_none()) {
 534                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 535
 536                 array_init(return_value);
 537                 zend_llist_apply_with_argument(&obj->pool->clients.attached,
 538                         (llist_apply_with_arg_func_t) php_http_client_pool_object_llist2array,
 539                         return_value TSRMLS_CC);
 540                 return;
 541         }
 542         RETURN_FALSE;
 543 }
 544
 545 PHP_METHOD(HttpClientPool, getFinished)
 546 {
 547         if (SUCCESS == zend_parse_parameters_none()) {
 548                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 549
 550                 array_init(return_value);
 551                 zend_llist_apply_with_argument(&obj->pool->clients.finished,
 552                                 (llist_apply_with_arg_func_t) php_http_client_pool_object_llist2array,
 553                                 return_value TSRMLS_CC);
 554                 return;
 555         }
 556         RETURN_FALSE;
 557 }
 558
 559 PHP_METHOD(HttpClientPool, enablePipelining)
 560 {
 561         zend_bool enable = 1;
 562
 563         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enable)) {
 564                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 565
 566                 php_http_client_pool_setopt(obj->pool, PHP_HTTP_CLIENT_POOL_OPT_ENABLE_PIPELINING, &enable);
 567         }
 568         RETVAL_ZVAL(getThis(), 1, 0);
 569 }
 570
 571 PHP_METHOD(HttpClientPool, enableEvents)
 572 {
 573         zend_bool enable = 1;
 574
 575         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enable)) {
 576                 php_http_client_pool_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 577
 578                 php_http_client_pool_setopt(obj->pool, PHP_HTTP_CLIENT_POOL_OPT_USE_EVENTS, &enable);
 579         }
 580         RETVAL_ZVAL(getThis(), 1, 0);
 581 }
 582
 583 PHP_MINIT_FUNCTION(http_client_pool)
 584 {
 585         PHP_HTTP_REGISTER_CLASS(http\\Client\\Pool, AbstractPool, http_client_pool, php_http_object_class_entry, 0);
 586         php_http_client_pool_class_entry->create_object = php_http_client_pool_object_new;
 587         memcpy(&php_http_client_pool_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 588         php_http_client_pool_object_handlers.clone_obj = NULL;
 589
 590         zend_class_implements(php_http_client_pool_class_entry TSRMLS_CC, 2, spl_ce_Countable, zend_ce_iterator);
 591
 592         return SUCCESS;
 593 }
 594
 595
 596 /*
 597  * Local variables:
 598  * tab-width: 4
 599  * c-basic-offset: 4
 600  * End:
 601  * vim600: noet sw=4 ts=4 fdm=marker
 602  * vim<600: noet sw=4 ts=4
 603  */
 604