git.m6w6.name Git - m6w6/ext-raphf/blob - src/php_raphf_api.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: raphf                                                      |
   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) 2013, Michael Wallner <mike@php.net>                 |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #       include "config.h"
  15 #endif
  16
  17 #include "php.h"
  18 #include "php_ini.h"
  19 #include "ext/standard/info.h"
  20 #include "php_raphf.h"
  21
  22 #ifndef PHP_RAPHF_TEST
  23 #       define PHP_RAPHF_TEST 0
  24 #endif
  25
  26 struct php_persistent_handle_globals {
  27         ulong limit;
  28         HashTable hash;
  29 };
  30
  31 ZEND_BEGIN_MODULE_GLOBALS(raphf)
  32         struct php_persistent_handle_globals persistent_handle;
  33 ZEND_END_MODULE_GLOBALS(raphf)
  34
  35 #ifdef ZTS
  36 #       define PHP_RAPHF_G ((zend_raphf_globals *) \
  37                 (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(raphf_globals_id)])
  38 #else
  39 #       define PHP_RAPHF_G (&raphf_globals)
  40 #endif
  41
  42 ZEND_DECLARE_MODULE_GLOBALS(raphf)
  43
  44 #ifndef PHP_RAPHF_DEBUG_PHANDLES
  45 #       define PHP_RAPHF_DEBUG_PHANDLES 0
  46 #endif
  47 #if PHP_RAPHF_DEBUG_PHANDLES
  48 #       undef inline
  49 #       define inline
  50 #endif
  51
  52 php_resource_factory_t *php_resource_factory_init(php_resource_factory_t *f,
  53                 php_resource_factory_ops_t *fops, void *data, void (*dtor)(void *data))
  54 {
  55         if (!f) {
  56                 f = emalloc(sizeof(*f));
  57         }
  58         memset(f, 0, sizeof(*f));
  59
  60         memcpy(&f->fops, fops, sizeof(*fops));
  61
  62         f->data = data;
  63         f->dtor = dtor;
  64
  65         f->refcount = 1;
  66
  67         return f;
  68 }
  69
  70 unsigned php_resource_factory_addref(php_resource_factory_t *rf)
  71 {
  72         return ++rf->refcount;
  73 }
  74
  75 void php_resource_factory_dtor(php_resource_factory_t *f)
  76 {
  77         if (!--f->refcount) {
  78                 if (f->dtor) {
  79                         f->dtor(f->data);
  80                 }
  81         }
  82 }
  83
  84 void php_resource_factory_free(php_resource_factory_t **f)
  85 {
  86         if (*f) {
  87                 php_resource_factory_dtor(*f);
  88                 if (!(*f)->refcount) {
  89                         efree(*f);
  90                         *f = NULL;
  91                 }
  92         }
  93 }
  94
  95 void *php_resource_factory_handle_ctor(php_resource_factory_t *f, void *init_arg)
  96 {
  97         if (f->fops.ctor) {
  98                 return f->fops.ctor(f->data, init_arg);
  99         }
 100         return NULL;
 101 }
 102
 103 void *php_resource_factory_handle_copy(php_resource_factory_t *f, void *handle)
 104 {
 105         if (f->fops.copy) {
 106                 return f->fops.copy(f->data, handle);
 107         }
 108         return NULL;
 109 }
 110
 111 void php_resource_factory_handle_dtor(php_resource_factory_t *f, void *handle)
 112 {
 113         if (f->fops.dtor) {
 114                 f->fops.dtor(f->data, handle);
 115         }
 116 }
 117
 118 php_resource_factory_t *php_persistent_handle_resource_factory_init(
 119                 php_resource_factory_t *a, php_persistent_handle_factory_t *pf)
 120 {
 121         return php_resource_factory_init(a,
 122                         php_persistent_handle_get_resource_factory_ops(), pf,
 123                         (void(*)(void*)) php_persistent_handle_abandon);
 124 }
 125
 126 zend_bool php_resource_factory_is_persistent(php_resource_factory_t *a)
 127 {
 128         return a->dtor == (void(*)(void *)) php_persistent_handle_abandon;
 129 }
 130
 131 static inline php_persistent_handle_list_t *php_persistent_handle_list_init(
 132                 php_persistent_handle_list_t *list)
 133 {
 134         if (!list) {
 135                 list = pemalloc(sizeof(*list), 1);
 136         }
 137         list->used = 0;
 138         zend_hash_init(&list->free, 0, NULL, NULL, 1);
 139
 140         return list;
 141 }
 142
 143 static int php_persistent_handle_apply_stat(zval *p, int argc, va_list argv,
 144                 zend_hash_key *key)
 145 {
 146         php_persistent_handle_list_t *list = Z_PTR_P(p);
 147         zval zsubentry, *zentry = va_arg(argv, zval *);
 148
 149         array_init(&zsubentry);
 150         add_assoc_long_ex(&zsubentry, ZEND_STRL("used"), list->used);
 151         add_assoc_long_ex(&zsubentry, ZEND_STRL("free"),
 152                         zend_hash_num_elements(&list->free));
 153         if (key->key) {
 154                 add_assoc_zval_ex(zentry, key->key->val, key->key->len, &zsubentry);
 155         } else {
 156                 add_index_zval(zentry, key->h, &zsubentry);
 157         }
 158         return ZEND_HASH_APPLY_KEEP;
 159 }
 160
 161 static int php_persistent_handle_apply_statall(zval *p, int argc, va_list argv,
 162                 zend_hash_key *key)
 163 {
 164         php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 165         HashTable *ht = va_arg(argv, HashTable *);
 166         zval zentry;
 167
 168         array_init(&zentry);
 169
 170         zend_hash_apply_with_arguments(&provider->list.free,
 171                         php_persistent_handle_apply_stat, 1, &zentry);
 172
 173         if (key->key) {
 174                 zend_hash_update(ht, key->key, &zentry);
 175         } else {
 176                 zend_hash_index_update(ht, key->h, &zentry);
 177         }
 178
 179         return ZEND_HASH_APPLY_KEEP;
 180 }
 181
 182 static int php_persistent_handle_apply_cleanup_ex(zval *p, void *arg)
 183 {
 184         php_resource_factory_t *rf = arg;
 185         void *handle = Z_PTR_P(p);
 186
 187 #if PHP_RAPHF_DEBUG_PHANDLES
 188         fprintf(stderr, "DESTROY: %p\n", handle);
 189 #endif
 190         php_resource_factory_handle_dtor(rf, handle);
 191         return ZEND_HASH_APPLY_REMOVE;
 192 }
 193
 194 static int php_persistent_handle_apply_cleanup(zval *p, void *arg)
 195 {
 196         php_resource_factory_t *rf = arg;
 197         php_persistent_handle_list_t *list = Z_PTR_P(p);
 198
 199         zend_hash_apply_with_argument(&list->free,
 200                         php_persistent_handle_apply_cleanup_ex, rf);
 201         if (list->used) {
 202                 return ZEND_HASH_APPLY_KEEP;
 203         }
 204         zend_hash_destroy(&list->free);
 205 #if PHP_RAPHF_DEBUG_PHANDLES
 206         fprintf(stderr, "LSTFREE: %p\n", list);
 207 #endif
 208         pefree(list, 1);
 209         return ZEND_HASH_APPLY_REMOVE;
 210 }
 211
 212 static inline void php_persistent_handle_list_dtor(
 213                 php_persistent_handle_list_t *list,
 214                 php_persistent_handle_provider_t *provider)
 215 {
 216 #if PHP_RAPHF_DEBUG_PHANDLES
 217         fprintf(stderr, "LSTDTOR: %p\n", list);
 218 #endif
 219         zend_hash_apply_with_argument(&list->free,
 220                         php_persistent_handle_apply_cleanup_ex, &provider->rf);
 221         zend_hash_destroy(&list->free);
 222 }
 223
 224 static inline void php_persistent_handle_list_free(
 225                 php_persistent_handle_list_t **list,
 226                 php_persistent_handle_provider_t *provider)
 227 {
 228         php_persistent_handle_list_dtor(*list, provider);
 229 #if PHP_RAPHF_DEBUG_PHANDLES
 230         fprintf(stderr, "LSTFREE: %p\n", *list);
 231 #endif
 232         pefree(*list, 1);
 233         *list = NULL;
 234 }
 235
 236 static int php_persistent_handle_list_apply_dtor(zval *p, void *provider)
 237 {
 238         php_persistent_handle_list_t *list = Z_PTR_P(p);
 239
 240         php_persistent_handle_list_free(&list, provider );
 241         ZVAL_PTR(p, NULL);
 242         return ZEND_HASH_APPLY_REMOVE;
 243 }
 244
 245 static inline php_persistent_handle_list_t *php_persistent_handle_list_find(
 246                 php_persistent_handle_provider_t *provider, zend_string *ident)
 247 {
 248         php_persistent_handle_list_t *list;
 249         zval *zlist = zend_symtable_find(&provider->list.free, ident);
 250
 251         if (zlist && (list = Z_PTR_P(zlist))) {
 252 #if PHP_RAPHF_DEBUG_PHANDLES
 253                 fprintf(stderr, "LSTFIND: %p\n", list);
 254 #endif
 255                 return list;
 256         }
 257
 258         if ((list = php_persistent_handle_list_init(NULL))) {
 259                 zval p, *rv;
 260                 zend_string *id;
 261
 262                 ZVAL_PTR(&p, list);
 263                 id = zend_string_init(ident->val, ident->len, 1);
 264                 rv = zend_symtable_update(&provider->list.free, id, &p);
 265                 zend_string_release(id);
 266
 267                 if (rv) {
 268 #if PHP_RAPHF_DEBUG_PHANDLES
 269                         fprintf(stderr, "LSTFIND: %p (new)\n", list);
 270 #endif
 271                         return list;
 272                 }
 273                 php_persistent_handle_list_free(&list, provider);
 274         }
 275
 276         return NULL;
 277 }
 278
 279 static int php_persistent_handle_apply_cleanup_all(zval *p, int argc,
 280                 va_list argv, zend_hash_key *key)
 281 {
 282         php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 283         zend_string *ident = va_arg(argv, zend_string *);
 284         php_persistent_handle_list_t *list;
 285
 286         if (ident && ident->len) {
 287                 if ((list = php_persistent_handle_list_find(provider, ident))) {
 288                         zend_hash_apply_with_argument(&list->free,
 289                                         php_persistent_handle_apply_cleanup_ex,
 290                                         &provider->rf);
 291                 }
 292         } else {
 293                 zend_hash_apply_with_argument(&provider->list.free,
 294                                 php_persistent_handle_apply_cleanup, &provider->rf);
 295         }
 296
 297         return ZEND_HASH_APPLY_KEEP;
 298 }
 299
 300 static void php_persistent_handle_hash_dtor(zval *p)
 301 {
 302         php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 303
 304         zend_hash_apply_with_argument(&provider->list.free,
 305                         php_persistent_handle_list_apply_dtor, provider);
 306         zend_hash_destroy(&provider->list.free);
 307         php_resource_factory_dtor(&provider->rf);
 308         pefree(provider, 1);
 309 }
 310
 311 ZEND_RESULT_CODE php_persistent_handle_provide(zend_string *name,
 312                 php_resource_factory_ops_t *fops, void *data, void (*dtor)(void *))
 313 {
 314         php_persistent_handle_provider_t *provider = pemalloc(sizeof(*provider), 1);
 315
 316         if (php_persistent_handle_list_init(&provider->list)) {
 317                 if (php_resource_factory_init(&provider->rf, fops, data, dtor)) {
 318                         zval p, *rv;
 319                         zend_string *ns;
 320
 321 #if PHP_RAPHF_DEBUG_PHANDLES
 322                         fprintf(stderr, "PROVIDE: %p %s\n", PHP_RAPHF_G, name_str);
 323 #endif
 324
 325                         ZVAL_PTR(&p, provider);
 326                         ns = zend_string_init(name->val, name->len, 1);
 327                         rv = zend_symtable_update(&PHP_RAPHF_G->persistent_handle.hash, ns, &p);
 328                         zend_string_release(ns);
 329
 330                         if (rv) {
 331                                 return SUCCESS;
 332                         }
 333                         php_resource_factory_dtor(&provider->rf);
 334                 }
 335         }
 336
 337         return FAILURE;
 338 }
 339
 340
 341 php_persistent_handle_factory_t *php_persistent_handle_concede(
 342                 php_persistent_handle_factory_t *a,
 343                 zend_string *name, zend_string *ident,
 344                 php_persistent_handle_wakeup_t wakeup,
 345                 php_persistent_handle_retire_t retire)
 346 {
 347         zval *zprovider = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash, name);
 348
 349         if (zprovider) {
 350                 zend_bool free_a = 0;
 351
 352                 if ((free_a = !a)) {
 353                         a = emalloc(sizeof(*a));
 354                 }
 355                 memset(a, 0, sizeof(*a));
 356
 357                 a->provider = Z_PTR_P(zprovider);
 358                 a->ident = zend_string_copy(ident);
 359                 a->wakeup = wakeup;
 360                 a->retire = retire;
 361                 a->free_on_abandon = free_a;
 362         } else {
 363                 a = NULL;
 364         }
 365
 366 #if PHP_RAPHF_DEBUG_PHANDLES
 367         fprintf(stderr, "CONCEDE: %p %p (%s) (%s)\n", PHP_RAPHF_G,
 368                         a ? a->provider : NULL, name->val, ident->val);
 369 #endif
 370
 371         return a;
 372 }
 373
 374 void php_persistent_handle_abandon(php_persistent_handle_factory_t *a)
 375 {
 376         zend_bool f = a->free_on_abandon;
 377
 378 #if PHP_RAPHF_DEBUG_PHANDLES
 379         fprintf(stderr, "ABANDON: %p\n", a->provider);
 380 #endif
 381
 382         zend_string_release(a->ident);
 383         memset(a, 0, sizeof(*a));
 384         if (f) {
 385                 efree(a);
 386         }
 387 }
 388
 389 void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a, void *init_arg)
 390 {
 391         int key;
 392         zval *p;
 393         zend_ulong index;
 394         void *handle = NULL;
 395         php_persistent_handle_list_t *list;
 396
 397         list = php_persistent_handle_list_find(a->provider, a->ident);
 398         if (list) {
 399                 zend_hash_internal_pointer_end(&list->free);
 400                 key = zend_hash_get_current_key(&list->free, NULL, &index);
 401                 p = zend_hash_get_current_data(&list->free);
 402                 if (p && HASH_KEY_NON_EXISTENT != key) {
 403                         handle = Z_PTR_P(p);
 404                         if (a->wakeup) {
 405                                 a->wakeup(a, &handle);
 406                         }
 407                         zend_hash_index_del(&list->free, index);
 408                 } else {
 409                         handle = php_resource_factory_handle_ctor(&a->provider->rf, init_arg);
 410                 }
 411 #if PHP_RAPHF_DEBUG_PHANDLES
 412                 fprintf(stderr, "CREATED: %p\n", handle);
 413 #endif
 414                 if (handle) {
 415                         ++a->provider->list.used;
 416                         ++list->used;
 417                 }
 418         }
 419
 420         return handle;
 421 }
 422
 423 void *php_persistent_handle_accrete(php_persistent_handle_factory_t *a, void *handle)
 424 {
 425         void *new_handle = NULL;
 426         php_persistent_handle_list_t *list;
 427
 428         new_handle = php_resource_factory_handle_copy(&a->provider->rf, handle);
 429         if (handle) {
 430                 list = php_persistent_handle_list_find(a->provider, a->ident);
 431                 if (list) {
 432                         ++list->used;
 433                 }
 434                 ++a->provider->list.used;
 435         }
 436
 437         return new_handle;
 438 }
 439
 440 void php_persistent_handle_release(php_persistent_handle_factory_t *a, void *handle)
 441 {
 442         php_persistent_handle_list_t *list;
 443
 444         list = php_persistent_handle_list_find(a->provider, a->ident);
 445         if (list) {
 446                 if (a->provider->list.used >= PHP_RAPHF_G->persistent_handle.limit) {
 447 #if PHP_RAPHF_DEBUG_PHANDLES
 448                         fprintf(stderr, "DESTROY: %p\n", handle);
 449 #endif
 450                         php_resource_factory_handle_dtor(&a->provider->rf, handle);
 451                 } else {
 452                         if (a->retire) {
 453                                 a->retire(a, &handle);
 454                         }
 455                         zend_hash_next_index_insert_ptr(&list->free, handle);
 456                 }
 457
 458                 --a->provider->list.used;
 459                 --list->used;
 460         }
 461 }
 462
 463 void php_persistent_handle_cleanup(zend_string *name, zend_string *ident)
 464 {
 465         php_persistent_handle_provider_t *provider;
 466         php_persistent_handle_list_t *list;
 467
 468         if (name) {
 469                 zval *zprovider = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash,
 470                                 name);
 471
 472                 if (zprovider && (provider = Z_PTR_P(zprovider))) {
 473                         if (ident) {
 474                                 list = php_persistent_handle_list_find(provider, ident);
 475                                 if (list) {
 476                                         zend_hash_apply_with_argument(&list->free,
 477                                                         php_persistent_handle_apply_cleanup_ex,
 478                                                         &provider->rf);
 479                                 }
 480                         } else {
 481                                 zend_hash_apply_with_argument(&provider->list.free,
 482                                                 php_persistent_handle_apply_cleanup,
 483                                                 &provider->rf);
 484                         }
 485                 }
 486         } else {
 487                 zend_hash_apply_with_arguments(
 488                                 &PHP_RAPHF_G->persistent_handle.hash,
 489                                 php_persistent_handle_apply_cleanup_all, 1, ident);
 490         }
 491 }
 492
 493 HashTable *php_persistent_handle_statall(HashTable *ht)
 494 {
 495         if (zend_hash_num_elements(&PHP_RAPHF_G->persistent_handle.hash)) {
 496                 if (!ht) {
 497                         ALLOC_HASHTABLE(ht);
 498                         zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0);
 499                 }
 500                 zend_hash_apply_with_arguments(
 501                                 &PHP_RAPHF_G->persistent_handle.hash,
 502                                 php_persistent_handle_apply_statall, 1, ht);
 503         } else if (ht) {
 504                 ht = NULL;
 505         }
 506
 507         return ht;
 508 }
 509
 510 static php_resource_factory_ops_t php_persistent_handle_resource_factory_ops = {
 511         (php_resource_factory_handle_ctor_t) php_persistent_handle_acquire,
 512         (php_resource_factory_handle_copy_t) php_persistent_handle_accrete,
 513         (php_resource_factory_handle_dtor_t) php_persistent_handle_release
 514 };
 515
 516 php_resource_factory_ops_t *php_persistent_handle_get_resource_factory_ops(void)
 517 {
 518         return &php_persistent_handle_resource_factory_ops;
 519 }
 520
 521 ZEND_BEGIN_ARG_INFO_EX(ai_raphf_stat_persistent_handles, 0, 0, 0)
 522 ZEND_END_ARG_INFO();
 523 static PHP_FUNCTION(raphf_stat_persistent_handles)
 524 {
 525         if (SUCCESS == zend_parse_parameters_none()) {
 526                 object_init(return_value);
 527                 if (php_persistent_handle_statall(HASH_OF(return_value))) {
 528                         return;
 529                 }
 530                 zval_dtor(return_value);
 531         }
 532         RETURN_FALSE;
 533 }
 534
 535 ZEND_BEGIN_ARG_INFO_EX(ai_raphf_clean_persistent_handles, 0, 0, 0)
 536         ZEND_ARG_INFO(0, name)
 537         ZEND_ARG_INFO(0, ident)
 538 ZEND_END_ARG_INFO();
 539 static PHP_FUNCTION(raphf_clean_persistent_handles)
 540 {
 541         zend_string *name = NULL, *ident = NULL;
 542
 543         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|S!S!", &name, &ident)) {
 544                 php_persistent_handle_cleanup(name, ident);
 545         }
 546 }
 547
 548 #if PHP_RAPHF_TEST
 549 #       include "php_raphf_test.c"
 550 #endif
 551
 552 static const zend_function_entry raphf_functions[] = {
 553         ZEND_NS_FENTRY("raphf", stat_persistent_handles,
 554                         ZEND_FN(raphf_stat_persistent_handles),
 555                         ai_raphf_stat_persistent_handles, 0)
 556         ZEND_NS_FENTRY("raphf", clean_persistent_handles,
 557                         ZEND_FN(raphf_clean_persistent_handles),
 558                         ai_raphf_clean_persistent_handles, 0)
 559 #if PHP_RAPHF_TEST
 560         ZEND_NS_FENTRY("raphf", provide, ZEND_FN(raphf_provide), NULL, 0)
 561         ZEND_NS_FENTRY("raphf", conceal, ZEND_FN(raphf_conceal), NULL, 0)
 562         ZEND_NS_FENTRY("raphf", concede, ZEND_FN(raphf_concede), NULL, 0)
 563         ZEND_NS_FENTRY("raphf", dispute, ZEND_FN(raphf_dispute), NULL, 0)
 564         ZEND_NS_FENTRY("raphf", handle_ctor, ZEND_FN(raphf_handle_ctor), NULL, 0)
 565         ZEND_NS_FENTRY("raphf", handle_copy, ZEND_FN(raphf_handle_copy), NULL, 0)
 566         ZEND_NS_FENTRY("raphf", handle_dtor, ZEND_FN(raphf_handle_dtor), NULL, 0)
 567 #endif
 568         {0}
 569 };
 570
 571 PHP_INI_BEGIN()
 572         STD_PHP_INI_ENTRY("raphf.persistent_handle.limit", "-1", PHP_INI_SYSTEM,
 573                         OnUpdateLong, persistent_handle.limit, zend_raphf_globals,
 574                         raphf_globals)
 575 PHP_INI_END()
 576
 577 static HashTable *php_persistent_handles_global_hash;
 578
 579 static PHP_GINIT_FUNCTION(raphf)
 580 {
 581         raphf_globals->persistent_handle.limit = -1;
 582
 583         zend_hash_init(&raphf_globals->persistent_handle.hash, 0, NULL,
 584                         php_persistent_handle_hash_dtor, 1);
 585         if (php_persistent_handles_global_hash) {
 586                 zend_hash_copy(&raphf_globals->persistent_handle.hash,
 587                                 php_persistent_handles_global_hash, NULL);
 588         }
 589 }
 590
 591 static PHP_GSHUTDOWN_FUNCTION(raphf)
 592 {
 593         zend_hash_destroy(&raphf_globals->persistent_handle.hash);
 594 }
 595
 596 PHP_MINIT_FUNCTION(raphf)
 597 {
 598         php_persistent_handles_global_hash = &PHP_RAPHF_G->persistent_handle.hash;
 599
 600 #if PHP_RAPHF_TEST
 601         PHP_MINIT(raphf_test)(INIT_FUNC_ARGS_PASSTHRU);
 602 #endif
 603
 604         REGISTER_INI_ENTRIES();
 605         return SUCCESS;
 606 }
 607
 608 PHP_MSHUTDOWN_FUNCTION(raphf)
 609 {
 610 #if PHP_RAPHF_TEST
 611         PHP_MSHUTDOWN(raphf_test)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
 612 #endif
 613
 614         UNREGISTER_INI_ENTRIES();
 615         php_persistent_handles_global_hash = NULL;
 616         return SUCCESS;
 617 }
 618
 619 static int php_persistent_handle_apply_info_ex(zval *p, int argc,
 620                 va_list argv, zend_hash_key *key)
 621 {
 622         php_persistent_handle_list_t *list = Z_PTR_P(p);
 623         zend_hash_key *super_key = va_arg(argv, zend_hash_key *);
 624         char used[21], free[21];
 625
 626         slprintf(used, sizeof(used), "%u", list->used);
 627         slprintf(free, sizeof(free), "%d", zend_hash_num_elements(&list->free));
 628
 629         php_info_print_table_row(4, super_key->key->val, key->key->val, used, free);
 630
 631         return ZEND_HASH_APPLY_KEEP;
 632 }
 633
 634 static int php_persistent_handle_apply_info(zval *p, int argc,
 635                 va_list argv, zend_hash_key *key)
 636 {
 637         php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 638
 639         zend_hash_apply_with_arguments(&provider->list.free,
 640                         php_persistent_handle_apply_info_ex, 1, key);
 641
 642         return ZEND_HASH_APPLY_KEEP;
 643 }
 644
 645 PHP_MINFO_FUNCTION(raphf)
 646 {
 647         php_info_print_table_start();
 648         php_info_print_table_header(2,
 649                         "Resource and persistent handle factory support", "enabled");
 650         php_info_print_table_row(2, "Extension version", PHP_RAPHF_VERSION);
 651         php_info_print_table_end();
 652
 653         php_info_print_table_start();
 654         php_info_print_table_colspan_header(4, "Persistent handles in this "
 655 #ifdef ZTS
 656                         "thread"
 657 #else
 658                         "process"
 659 #endif
 660         );
 661         php_info_print_table_header(4, "Provider", "Ident", "Used", "Free");
 662         zend_hash_apply_with_arguments(
 663                         &PHP_RAPHF_G->persistent_handle.hash,
 664                         php_persistent_handle_apply_info, 0);
 665         php_info_print_table_end();
 666
 667         DISPLAY_INI_ENTRIES();
 668 }
 669
 670 zend_module_entry raphf_module_entry = {
 671         STANDARD_MODULE_HEADER,
 672         "raphf",
 673         raphf_functions,
 674         PHP_MINIT(raphf),
 675         PHP_MSHUTDOWN(raphf),
 676         NULL,
 677         NULL,
 678         PHP_MINFO(raphf),
 679         PHP_RAPHF_VERSION,
 680         ZEND_MODULE_GLOBALS(raphf),
 681         PHP_GINIT(raphf),
 682         PHP_GSHUTDOWN(raphf),
 683         NULL,
 684         STANDARD_MODULE_PROPERTIES_EX
 685 };
 686 /* }}} */
 687
 688 #ifdef COMPILE_DL_RAPHF
 689 ZEND_GET_MODULE(raphf)
 690 #endif
 691
 692 /*
 693  * Local variables:
 694  * tab-width: 4
 695  * c-basic-offset: 4
 696  * End:
 697  * vim600: noet sw=4 ts=4 fdm=marker
 698  * vim<600: noet sw=4 ts=4
 699  */