ext/dba/dba.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
php_dba_make_key
dba_close
dba_close_rsrc
dba_close_pe_rsrc_deleter
dba_close_pe_rsrc
ZEND_INI_MH
PHP_INI_BEGIN
PHP_MINIT_FUNCTION
PHP_MSHUTDOWN_FUNCTION
PHP_MINFO_FUNCTION
php_dba_update
php_dba_find
php_dba_open
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
PHP_FUNCTION
   1 /*
   2    +----------------------------------------------------------------------+
   3    | PHP Version 5                                                        |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 1997-2016 The PHP Group                                |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15    | Authors: Sascha Schumann <sascha@schumann.cx>                        |
  16    |          Marcus Boerger <helly@php.net>                              |
  17    +----------------------------------------------------------------------+
  18  */
  19 
  20 /* $Id$ */
  21 
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 
  26 #include "php.h"
  27 
  28 #if HAVE_DBA
  29 
  30 #include "php_ini.h"
  31 #include <stdio.h> 
  32 #include <fcntl.h>
  33 #ifdef HAVE_SYS_FILE_H
  34 #include <sys/file.h>
  35 #endif
  36  
  37 #include "php_dba.h"
  38 #include "ext/standard/info.h"
  39 #include "ext/standard/php_string.h"
  40 #include "ext/standard/flock_compat.h"
  41 
  42 #include "php_gdbm.h"
  43 #include "php_ndbm.h"
  44 #include "php_dbm.h"
  45 #include "php_cdb.h"
  46 #include "php_db1.h"
  47 #include "php_db2.h"
  48 #include "php_db3.h"
  49 #include "php_db4.h"
  50 #include "php_flatfile.h"
  51 #include "php_inifile.h"
  52 #include "php_qdbm.h"
  53 #include "php_tcadb.h"
  54 
  55 /* {{{ arginfo */
  56 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_popen, 0, 0, 2)
  57         ZEND_ARG_INFO(0, path)
  58         ZEND_ARG_INFO(0, mode)
  59         ZEND_ARG_INFO(0, handlername)
  60         ZEND_ARG_VARIADIC_INFO(0, handler_parameters)
  61 ZEND_END_ARG_INFO()
  62 
  63 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_open, 0, 0, 2)
  64         ZEND_ARG_INFO(0, path)
  65         ZEND_ARG_INFO(0, mode)
  66         ZEND_ARG_INFO(0, handlername)
  67         ZEND_ARG_VARIADIC_INFO(0, handler_parameters)
  68 ZEND_END_ARG_INFO()
  69 
  70 ZEND_BEGIN_ARG_INFO(arginfo_dba_close, 0)
  71         ZEND_ARG_INFO(0, handle)
  72 ZEND_END_ARG_INFO()
  73 
  74 ZEND_BEGIN_ARG_INFO(arginfo_dba_exists, 0)
  75         ZEND_ARG_INFO(0, key)
  76         ZEND_ARG_INFO(0, handle)
  77 ZEND_END_ARG_INFO()
  78 
  79 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_fetch, 0, 0, 2)
  80         ZEND_ARG_INFO(0, key)
  81         ZEND_ARG_INFO(0, skip)
  82         ZEND_ARG_INFO(0, handle)
  83 ZEND_END_ARG_INFO()
  84 
  85 ZEND_BEGIN_ARG_INFO(arginfo_dba_key_split, 0)
  86         ZEND_ARG_INFO(0, key)
  87 ZEND_END_ARG_INFO()
  88 
  89 ZEND_BEGIN_ARG_INFO(arginfo_dba_firstkey, 0)
  90         ZEND_ARG_INFO(0, handle)
  91 ZEND_END_ARG_INFO()
  92 
  93 ZEND_BEGIN_ARG_INFO(arginfo_dba_nextkey, 0)
  94         ZEND_ARG_INFO(0, handle)
  95 ZEND_END_ARG_INFO()
  96 
  97 ZEND_BEGIN_ARG_INFO(arginfo_dba_delete, 0)
  98         ZEND_ARG_INFO(0, key)
  99         ZEND_ARG_INFO(0, handle)
 100 ZEND_END_ARG_INFO()
 101 
 102 ZEND_BEGIN_ARG_INFO(arginfo_dba_insert, 0)
 103         ZEND_ARG_INFO(0, key)
 104         ZEND_ARG_INFO(0, value)
 105         ZEND_ARG_INFO(0, handle)
 106 ZEND_END_ARG_INFO()
 107 
 108 ZEND_BEGIN_ARG_INFO(arginfo_dba_replace, 0)
 109         ZEND_ARG_INFO(0, key)
 110         ZEND_ARG_INFO(0, value)
 111         ZEND_ARG_INFO(0, handle)
 112 ZEND_END_ARG_INFO()
 113 
 114 ZEND_BEGIN_ARG_INFO(arginfo_dba_optimize, 0)
 115         ZEND_ARG_INFO(0, handle)
 116 ZEND_END_ARG_INFO()
 117 
 118 ZEND_BEGIN_ARG_INFO(arginfo_dba_sync, 0)
 119         ZEND_ARG_INFO(0, handle)
 120 ZEND_END_ARG_INFO()
 121 
 122 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_handlers, 0, 0, 0)
 123         ZEND_ARG_INFO(0, full_info)
 124 ZEND_END_ARG_INFO()
 125 
 126 ZEND_BEGIN_ARG_INFO(arginfo_dba_list, 0)
 127 ZEND_END_ARG_INFO()
 128 
 129 /* }}} */
 130 
 131 /* {{{ dba_functions[]
 132  */
 133 const zend_function_entry dba_functions[] = {
 134         PHP_FE(dba_open, arginfo_dba_open)
 135         PHP_FE(dba_popen, arginfo_dba_popen)
 136         PHP_FE(dba_close, arginfo_dba_close)
 137         PHP_FE(dba_delete, arginfo_dba_delete)
 138         PHP_FE(dba_exists, arginfo_dba_exists)
 139         PHP_FE(dba_fetch, arginfo_dba_fetch)
 140         PHP_FE(dba_insert, arginfo_dba_insert)
 141         PHP_FE(dba_replace, arginfo_dba_replace)
 142         PHP_FE(dba_firstkey, arginfo_dba_firstkey)
 143         PHP_FE(dba_nextkey, arginfo_dba_nextkey)
 144         PHP_FE(dba_optimize, arginfo_dba_optimize)
 145         PHP_FE(dba_sync, arginfo_dba_sync)
 146         PHP_FE(dba_handlers, arginfo_dba_handlers)
 147         PHP_FE(dba_list, arginfo_dba_list)
 148         PHP_FE(dba_key_split, arginfo_dba_key_split)
 149         PHP_FE_END
 150 };
 151 /* }}} */
 152 
 153 PHP_MINIT_FUNCTION(dba);
 154 PHP_MSHUTDOWN_FUNCTION(dba);
 155 PHP_MINFO_FUNCTION(dba);
 156 
 157 ZEND_BEGIN_MODULE_GLOBALS(dba)
 158         char *default_handler;
 159         dba_handler *default_hptr;
 160 ZEND_END_MODULE_GLOBALS(dba) 
 161 
 162 ZEND_DECLARE_MODULE_GLOBALS(dba)
 163 
 164 #ifdef ZTS
 165 #define DBA_G(v) TSRMG(dba_globals_id, zend_dba_globals *, v)
 166 #else
 167 #define DBA_G(v) (dba_globals.v)
 168 #endif 
 169 
 170 static PHP_GINIT_FUNCTION(dba);
 171 
 172 zend_module_entry dba_module_entry = {
 173         STANDARD_MODULE_HEADER,
 174         "dba",
 175         dba_functions, 
 176         PHP_MINIT(dba), 
 177         PHP_MSHUTDOWN(dba),
 178         NULL,
 179         NULL,
 180         PHP_MINFO(dba),
 181         NO_VERSION_YET,
 182         PHP_MODULE_GLOBALS(dba),
 183         PHP_GINIT(dba),
 184         NULL,
 185         NULL,
 186         STANDARD_MODULE_PROPERTIES_EX
 187 };
 188 
 189 #ifdef COMPILE_DL_DBA
 190 ZEND_GET_MODULE(dba)
 191 #endif
 192 
 193 /* {{{ macromania */
 194 
 195 #define DBA_ID_PARS                                                                                     \
 196         zval *id;                                                                                                       \
 197         dba_info *info = NULL;                                                                          \
 198         int ac = ZEND_NUM_ARGS()
 199 
 200 /* these are used to get the standard arguments */
 201 
 202 /* {{{ php_dba_myke_key */
 203 static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS_DC)
 204 {
 205         if (Z_TYPE_P(key) == IS_ARRAY) {
 206                 zval **group, **name;
 207                 HashPosition pos;
 208                 size_t len;
 209         
 210                 if (zend_hash_num_elements(Z_ARRVAL_P(key)) != 2) {
 211                         php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Key does not have exactly two elements: (key, name)");
 212                         return -1;
 213                 }
 214                 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(key), &pos);
 215                 zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &group, &pos);
 216                 zend_hash_move_forward_ex(Z_ARRVAL_P(key), &pos);
 217                 zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &name, &pos);
 218                 convert_to_string_ex(group);
 219                 convert_to_string_ex(name);
 220                 if (Z_STRLEN_PP(group) == 0) {
 221                         *key_str = Z_STRVAL_PP(name);
 222                         *key_free = NULL;
 223                         return Z_STRLEN_PP(name);
 224                 }
 225                 len = spprintf(key_str, 0, "[%s]%s", Z_STRVAL_PP(group), Z_STRVAL_PP(name));
 226                 *key_free = *key_str;
 227                 return len;
 228         } else {
 229                 zval tmp = *key;
 230                 int len;
 231 
 232                 zval_copy_ctor(&tmp);
 233                 convert_to_string(&tmp);
 234 
 235                 *key_free = *key_str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
 236                 len = Z_STRLEN(tmp);
 237 
 238                 zval_dtor(&tmp);
 239                 return len;
 240         }
 241 }
 242 /* }}} */
 243 
 244 #define DBA_GET2                                                                                                \
 245         zval *key;                                                                                                      \
 246         char *key_str, *key_free;                                                                       \
 247         size_t key_len;                                                                                         \
 248         if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) {  \
 249                 return;                                                                                                 \
 250         }                                                                                                                       \
 251         if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
 252                 RETURN_FALSE;                                                                                   \
 253         }
 254 
 255 #define DBA_GET2_3                                                                                              \
 256         zval *key;                                                                                                      \
 257         char *key_str, *key_free;                                                                       \
 258         size_t key_len;                                                                                         \
 259         long skip = 0;                                                                                          \
 260         switch(ac) {                                                                                            \
 261         case 2:                                                                                                         \
 262                 if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { \
 263                         return;                                                                                         \
 264                 }                                                                                                               \
 265                 break;                                                                                                  \
 266         case 3:                                                                                                         \
 267                 if (zend_parse_parameters(ac TSRMLS_CC, "zlr", &key, &skip, &id) == FAILURE) { \
 268                         return;                                                                                         \
 269                 }                                                                                                               \
 270                 break;                                                                                                  \
 271         default:                                                                                                        \
 272                 WRONG_PARAM_COUNT;                                                                              \
 273         }                                                                                                                       \
 274         if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
 275                 RETURN_FALSE;                                                                                   \
 276         }
 277 
 278 
 279 #define DBA_FETCH_RESOURCE(info, id)    \
 280         ZEND_FETCH_RESOURCE2(info, dba_info *, id, -1, "DBA identifier", le_db, le_pdb);
 281 
 282 #define DBA_ID_GET2   DBA_ID_PARS; DBA_GET2;   DBA_FETCH_RESOURCE(info, &id)
 283 #define DBA_ID_GET2_3 DBA_ID_PARS; DBA_GET2_3; DBA_FETCH_RESOURCE(info, &id)
 284 
 285 #define DBA_ID_DONE                                                                                             \
 286         if (key_free) efree(key_free)
 287 /* a DBA handler must have specific routines */
 288 
 289 #define DBA_NAMED_HND(alias, name, flags) \
 290 {\
 291         #alias, flags, dba_open_##name, dba_close_##name, dba_fetch_##name, dba_update_##name, \
 292         dba_exists_##name, dba_delete_##name, dba_firstkey_##name, dba_nextkey_##name, \
 293         dba_optimize_##name, dba_sync_##name, dba_info_##name \
 294 },
 295 
 296 #define DBA_HND(name, flags) DBA_NAMED_HND(name, name, flags)
 297 
 298 /* check whether the user has write access */
 299 #define DBA_WRITE_CHECK \
 300         if(info->mode != DBA_WRITER && info->mode != DBA_TRUNC && info->mode != DBA_CREAT) { \
 301                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "You cannot perform a modification to a database without proper access"); \
 302                 RETURN_FALSE; \
 303         }
 304 
 305 /* the same check, but with a call to DBA_ID_DONE before returning */
 306 #define DBA_WRITE_CHECK_WITH_ID \
 307         if(info->mode != DBA_WRITER && info->mode != DBA_TRUNC && info->mode != DBA_CREAT) { \
 308                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "You cannot perform a modification to a database without proper access"); \
 309                 DBA_ID_DONE; \
 310                 RETURN_FALSE; \
 311         }
 312 
 313 /* }}} */
 314 
 315 /* {{{ globals */
 316 
 317 static dba_handler handler[] = {
 318 #if DBA_GDBM
 319         DBA_HND(gdbm, DBA_LOCK_EXT) /* Locking done in library if set */
 320 #endif
 321 #if DBA_DBM
 322         DBA_HND(dbm, DBA_LOCK_ALL) /* No lock in lib */
 323 #endif
 324 #if DBA_NDBM
 325         DBA_HND(ndbm, DBA_LOCK_ALL) /* Could be done in library: filemode = 0644 + S_ENFMT */
 326 #endif
 327 #if DBA_CDB
 328         DBA_HND(cdb, DBA_STREAM_OPEN|DBA_LOCK_ALL) /* No lock in lib */
 329 #endif
 330 #if DBA_CDB_BUILTIN
 331     DBA_NAMED_HND(cdb_make, cdb, DBA_STREAM_OPEN|DBA_LOCK_ALL) /* No lock in lib */
 332 #endif
 333 #if DBA_DB1
 334         DBA_HND(db1, DBA_LOCK_ALL) /* No lock in lib */
 335 #endif
 336 #if DBA_DB2
 337         DBA_HND(db2, DBA_LOCK_ALL) /* No lock in lib */
 338 #endif
 339 #if DBA_DB3
 340         DBA_HND(db3, DBA_LOCK_ALL) /* No lock in lib */
 341 #endif
 342 #if DBA_DB4
 343         DBA_HND(db4, DBA_LOCK_ALL) /* No lock in lib */
 344 #endif
 345 #if DBA_INIFILE
 346         DBA_HND(inifile, DBA_STREAM_OPEN|DBA_LOCK_ALL|DBA_CAST_AS_FD) /* No lock in lib */
 347 #endif
 348 #if DBA_FLATFILE
 349         DBA_HND(flatfile, DBA_STREAM_OPEN|DBA_LOCK_ALL|DBA_NO_APPEND) /* No lock in lib */
 350 #endif
 351 #if DBA_QDBM
 352         DBA_HND(qdbm, DBA_LOCK_EXT)
 353 #endif
 354 #if DBA_TCADB
 355         DBA_HND(tcadb, DBA_LOCK_ALL)
 356 #endif
 357         { NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
 358 };
 359 
 360 #if DBA_FLATFILE
 361 #define DBA_DEFAULT "flatfile"
 362 #elif DBA_DB4
 363 #define DBA_DEFAULT "db4"
 364 #elif DBA_DB3
 365 #define DBA_DEFAULT "db3"
 366 #elif DBA_DB2
 367 #define DBA_DEFAULT "db2"
 368 #elif DBA_DB1
 369 #define DBA_DEFAULT "db1"
 370 #elif DBA_GDBM
 371 #define DBA_DEFAULT "gdbm"
 372 #elif DBA_NBBM
 373 #define DBA_DEFAULT "ndbm"
 374 #elif DBA_DBM
 375 #define DBA_DEFAULT "dbm"
 376 #elif DBA_QDBM
 377 #define DBA_DEFAULT "qdbm"
 378 #elif DBA_TCADB
 379 #define DBA_DEFAULT "tcadb"
 380 #else
 381 #define DBA_DEFAULT ""
 382 #endif
 383 /* cdb/cdb_make and ini are no option here */
 384 
 385 static int le_db;
 386 static int le_pdb;
 387 /* }}} */
 388 
 389 /* {{{ dba_fetch_resource
 390 PHPAPI void dba_fetch_resource(dba_info **pinfo, zval **id TSRMLS_DC)
 391 {
 392         dba_info *info;
 393         DBA_ID_FETCH
 394         *pinfo = info;
 395 }
 396 */
 397 /* }}} */
 398 
 399 /* {{{ dba_get_handler
 400 PHPAPI dba_handler *dba_get_handler(const char* handler_name)
 401 {
 402         dba_handler *hptr;
 403         for (hptr = handler; hptr->name && strcasecmp(hptr->name, handler_name); hptr++);
 404         return hptr;
 405 }
 406 */
 407 /* }}} */
 408 
 409 /* {{{ dba_close 
 410  */ 
 411 static void dba_close(dba_info *info TSRMLS_DC)
 412 {
 413         if (info->hnd) {
 414                 info->hnd->close(info TSRMLS_CC);
 415         }
 416         if (info->path) {
 417                 pefree(info->path, info->flags&DBA_PERSISTENT);
 418         }
 419         if (info->fp && info->fp!=info->lock.fp) {
 420                 if(info->flags&DBA_PERSISTENT) {
 421                         php_stream_pclose(info->fp);
 422                 } else {
 423                         php_stream_close(info->fp);
 424                 }
 425         }
 426         if (info->lock.fp) {
 427                 if(info->flags&DBA_PERSISTENT) {
 428                         php_stream_pclose(info->lock.fp);
 429                 } else {
 430                         php_stream_close(info->lock.fp);
 431                 }
 432         }
 433         if (info->lock.name) {
 434                 pefree(info->lock.name, info->flags&DBA_PERSISTENT);
 435         }
 436         pefree(info, info->flags&DBA_PERSISTENT);
 437 }
 438 /* }}} */
 439 
 440 /* {{{ dba_close_rsrc
 441  */
 442 static void dba_close_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 443 {
 444         dba_info *info = (dba_info *)rsrc->ptr; 
 445 
 446         dba_close(info TSRMLS_CC);
 447 }
 448 /* }}} */
 449 
 450 /* {{{ dba_close_pe_rsrc_deleter */
 451 int dba_close_pe_rsrc_deleter(zend_rsrc_list_entry *le, void *pDba TSRMLS_DC)
 452 {
 453         return le->ptr == pDba;
 454 }
 455 /* }}} */
 456 
 457 /* {{{ dba_close_pe_rsrc */
 458 static void dba_close_pe_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 459 {
 460         dba_info *info = (dba_info *)rsrc->ptr; 
 461 
 462         /* closes the resource by calling dba_close_rsrc() */
 463         zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) dba_close_pe_rsrc_deleter, info TSRMLS_CC);
 464 }
 465 /* }}} */
 466 
 467 /* {{{ PHP_INI
 468  */
 469 ZEND_INI_MH(OnUpdateDefaultHandler)
 470 {
 471         dba_handler *hptr;
 472 
 473         if (!strlen(new_value)) {
 474                 DBA_G(default_hptr) = NULL;
 475                 return OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
 476         }
 477 
 478         for (hptr = handler; hptr->name && strcasecmp(hptr->name, new_value); hptr++);
 479 
 480         if (!hptr->name) {
 481                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "No such handler: %s", new_value);
 482                 return FAILURE;
 483         }
 484         DBA_G(default_hptr) = hptr;
 485         return OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
 486 }
 487 
 488 PHP_INI_BEGIN()
 489     STD_PHP_INI_ENTRY("dba.default_handler", DBA_DEFAULT, PHP_INI_ALL, OnUpdateDefaultHandler, default_handler,    zend_dba_globals, dba_globals)
 490 PHP_INI_END()
 491 /* }}} */
 492  
 493 /* {{{ PHP_GINIT_FUNCTION
 494  */
 495 static PHP_GINIT_FUNCTION(dba)
 496 {
 497         dba_globals->default_handler = "";
 498         dba_globals->default_hptr    = NULL;
 499 }
 500 /* }}} */
 501 
 502 /* {{{ PHP_MINIT_FUNCTION
 503  */
 504 PHP_MINIT_FUNCTION(dba)
 505 {
 506         REGISTER_INI_ENTRIES();
 507         le_db = zend_register_list_destructors_ex(dba_close_rsrc, NULL, "dba", module_number);
 508         le_pdb = zend_register_list_destructors_ex(dba_close_pe_rsrc, dba_close_rsrc, "dba persistent", module_number);
 509         return SUCCESS;
 510 }
 511 /* }}} */
 512 
 513 /* {{{ PHP_MSHUTDOWN_FUNCTION
 514  */
 515 PHP_MSHUTDOWN_FUNCTION(dba)
 516 {
 517         UNREGISTER_INI_ENTRIES();
 518         return SUCCESS;
 519 }
 520 /* }}} */
 521 
 522 #include "ext/standard/php_smart_str.h"
 523 
 524 /* {{{ PHP_MINFO_FUNCTION
 525  */
 526 PHP_MINFO_FUNCTION(dba)
 527 {
 528         dba_handler *hptr;
 529         smart_str handlers = {0};
 530 
 531         for(hptr = handler; hptr->name; hptr++) {
 532                 smart_str_appends(&handlers, hptr->name);
 533                 smart_str_appendc(&handlers, ' ');
 534         }
 535 
 536         php_info_print_table_start();
 537         php_info_print_table_row(2, "DBA support", "enabled");
 538         if (handlers.c) {
 539                 smart_str_0(&handlers);
 540                 php_info_print_table_row(2, "Supported handlers", handlers.c);
 541                 smart_str_free(&handlers);
 542         } else {
 543                 php_info_print_table_row(2, "Supported handlers", "none");
 544         }
 545         php_info_print_table_end();
 546         DISPLAY_INI_ENTRIES();
 547 }
 548 /* }}} */
 549 
 550 /* {{{ php_dba_update
 551  */
 552 static void php_dba_update(INTERNAL_FUNCTION_PARAMETERS, int mode)
 553 {
 554         int val_len;
 555         zval *id;
 556         dba_info *info = NULL;
 557         int ac = ZEND_NUM_ARGS();
 558         zval *key;
 559         char *val;
 560         char *key_str, *key_free;
 561         size_t key_len;
 562 
 563         if (zend_parse_parameters(ac TSRMLS_CC, "zsr", &key, &val, &val_len, &id) == FAILURE) {
 564                 return;
 565         }
 566 
 567         if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {
 568                 RETURN_FALSE;
 569         }
 570 
 571         DBA_FETCH_RESOURCE(info, &id);
 572 
 573         DBA_WRITE_CHECK_WITH_ID;
 574 
 575         if (info->hnd->update(info, key_str, key_len, val, val_len, mode TSRMLS_CC) == SUCCESS) {
 576                 DBA_ID_DONE;
 577                 RETURN_TRUE;
 578         }
 579 
 580         DBA_ID_DONE;
 581         RETURN_FALSE;
 582 }
 583 /* }}} */
 584 
 585 #define FREENOW if(args) efree(args); if(key) efree(key)
 586 
 587 /* {{{ php_find_dbm
 588  */
 589 dba_info *php_dba_find(const char* path TSRMLS_DC)
 590 {
 591         zend_rsrc_list_entry *le;
 592         dba_info *info;
 593         int numitems, i;
 594 
 595         numitems = zend_hash_next_free_element(&EG(regular_list));
 596         for (i=1; i<numitems; i++) {
 597                 if (zend_hash_index_find(&EG(regular_list), i, (void **) &le)==FAILURE) {
 598                         continue;
 599                 }
 600                 if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
 601                         info = (dba_info *)(le->ptr);
 602                         if (!strcmp(info->path, path)) {
 603                                 return (dba_info *)(le->ptr);
 604                         }
 605                 }
 606         }
 607 
 608         return NULL;
 609 }
 610 /* }}} */
 611 
 612 /* {{{ php_dba_open
 613  */
 614 static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 615 {
 616         zval ***args = (zval ***) NULL;
 617         int ac = ZEND_NUM_ARGS();
 618         dba_mode_t modenr;
 619         dba_info *info, *other;
 620         dba_handler *hptr;
 621         char *key = NULL, *error = NULL;
 622         int keylen = 0;
 623         int i;
 624         int lock_mode, lock_flag, lock_dbf = 0;
 625         char *file_mode;
 626         char mode[4], *pmode, *lock_file_mode = NULL;
 627         int persistent_flag = persistent ? STREAM_OPEN_PERSISTENT : 0;
 628         char *opened_path = NULL;
 629         char *lock_name;
 630         
 631         if(ac < 2) {
 632                 WRONG_PARAM_COUNT;
 633         }
 634         
 635         /* we pass additional args to the respective handler */
 636         args = safe_emalloc(ac, sizeof(zval *), 0);
 637         if (zend_get_parameters_array_ex(ac, args) != SUCCESS) {
 638                 FREENOW;
 639                 WRONG_PARAM_COUNT;
 640         }
 641                 
 642         /* we only take string arguments */
 643         for (i = 0; i < ac; i++) {
 644                 convert_to_string_ex(args[i]);
 645                 keylen += Z_STRLEN_PP(args[i]);
 646         }
 647 
 648         if (persistent) {
 649                 zend_rsrc_list_entry *le;
 650                 
 651                 /* calculate hash */
 652                 key = safe_emalloc(keylen, 1, 1);
 653                 key[keylen] = '\0';
 654                 keylen = 0;
 655                 
 656                 for(i = 0; i < ac; i++) {
 657                         memcpy(key+keylen, Z_STRVAL_PP(args[i]), Z_STRLEN_PP(args[i]));
 658                         keylen += Z_STRLEN_PP(args[i]);
 659                 }
 660 
 661                 /* try to find if we already have this link in our persistent list */
 662                 if (zend_hash_find(&EG(persistent_list), key, keylen+1, (void **) &le) == SUCCESS) {
 663                         FREENOW;
 664                         
 665                         if (Z_TYPE_P(le) != le_pdb) {
 666                                 RETURN_FALSE;
 667                         }
 668                 
 669                         info = (dba_info *)le->ptr;
 670 
 671                         ZEND_REGISTER_RESOURCE(return_value, info, le_pdb);
 672                         return;
 673                 }
 674         }
 675         
 676         if (ac==2) {
 677                 hptr = DBA_G(default_hptr);
 678                 if (!hptr) {
 679                         php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "No default handler selected");
 680                         FREENOW;
 681                         RETURN_FALSE;
 682                 }
 683         } else {
 684                 for (hptr = handler; hptr->name && strcasecmp(hptr->name, Z_STRVAL_PP(args[2])); hptr++);
 685         }
 686 
 687         if (!hptr->name) {
 688                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "No such handler: %s", Z_STRVAL_PP(args[2]));
 689                 FREENOW;
 690                 RETURN_FALSE;
 691         }
 692 
 693         /* Check mode: [rwnc][fl]?t?
 694          * r: Read
 695          * w: Write
 696          * n: Create/Truncate
 697          * c: Create
 698          *
 699          * d: force lock on database file
 700          * l: force lock on lck file
 701          * -: ignore locking
 702          *
 703          * t: test open database, warning if locked
 704          */
 705         strlcpy(mode, Z_STRVAL_PP(args[1]), sizeof(mode));
 706         pmode = &mode[0];
 707         if (pmode[0] && (pmode[1]=='d' || pmode[1]=='l' || pmode[1]=='-')) { /* force lock on db file or lck file or disable locking */
 708                 switch (pmode[1]) {
 709                 case 'd':
 710                         lock_dbf = 1;
 711                         if ((hptr->flags & DBA_LOCK_ALL) == 0) {
 712                                 lock_flag = (hptr->flags & DBA_LOCK_ALL);
 713                                 break;
 714                         }
 715                         /* no break */
 716                 case 'l':
 717                         lock_flag = DBA_LOCK_ALL;
 718                         if ((hptr->flags & DBA_LOCK_ALL) == 0) {
 719                                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_NOTICE, "Handler %s does locking internally", hptr->name);
 720                         }
 721                         break;
 722                 default:
 723                 case '-':
 724                         if ((hptr->flags & DBA_LOCK_ALL) == 0) {
 725                                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Locking cannot be disabled for handler %s", hptr->name);
 726                                 FREENOW;
 727                                 RETURN_FALSE;
 728                         }
 729                         lock_flag = 0;
 730                         break;
 731                 }
 732         } else {
 733                 lock_flag = (hptr->flags&DBA_LOCK_ALL);
 734                 lock_dbf = 1;
 735         }
 736         switch (*pmode++) {
 737                 case 'r': 
 738                         modenr = DBA_READER; 
 739                         lock_mode = (lock_flag & DBA_LOCK_READER) ? LOCK_SH : 0;
 740                         file_mode = "r";
 741                         break;
 742                 case 'w': 
 743                         modenr = DBA_WRITER; 
 744                         lock_mode = (lock_flag & DBA_LOCK_WRITER) ? LOCK_EX : 0;
 745                         file_mode = "r+b";
 746                         break;
 747                 case 'c': 
 748                         modenr = DBA_CREAT; 
 749                         lock_mode = (lock_flag & DBA_LOCK_CREAT) ? LOCK_EX : 0;
 750                         if (lock_mode) {
 751                                 if (lock_dbf) {
 752                                         /* the create/append check will be done on the lock
 753                                          * when the lib opens the file it is already created
 754                                          */
 755                                         file_mode = "r+b";       /* read & write, seek 0 */
 756                                         lock_file_mode = "a+b";  /* append */
 757                                 } else {
 758                                         file_mode = "a+b";       /* append */
 759                                         lock_file_mode = "w+b";  /* create/truncate */
 760                                 }
 761                         } else {
 762                                 file_mode = "a+b";
 763                         }
 764                         /* In case of the 'a+b' append mode, the handler is responsible 
 765                          * to handle any rewind problems (see flatfile handler).
 766                          */
 767                         break;
 768                 case 'n':
 769                         modenr = DBA_TRUNC;
 770                         lock_mode = (lock_flag & DBA_LOCK_TRUNC) ? LOCK_EX : 0;
 771                         file_mode = "w+b";
 772                         break;
 773                 default:
 774                         php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Illegal DBA mode");
 775                         FREENOW;
 776                         RETURN_FALSE;
 777         }
 778         if (!lock_file_mode) {
 779                 lock_file_mode = file_mode;
 780         }
 781         if (*pmode=='d' || *pmode=='l' || *pmode=='-') {
 782                 pmode++; /* done already - skip here */
 783         }
 784         if (*pmode=='t') {
 785                 pmode++;
 786                 if (!lock_flag) {
 787                         php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "You cannot combine modifiers - (no lock) and t (test lock)");
 788                         FREENOW;
 789                         RETURN_FALSE;
 790                 }
 791                 if (!lock_mode) {
 792                         if ((hptr->flags & DBA_LOCK_ALL) == 0) {
 793                                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Handler %s uses its own locking which doesn't support mode modifier t (test lock)", hptr->name);
 794                                 FREENOW;
 795                                 RETURN_FALSE;
 796                         } else {
 797                                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Handler %s doesn't uses locking for this mode which makes modifier t (test lock) obsolete", hptr->name);
 798                                 FREENOW;
 799                                 RETURN_FALSE;
 800                         }
 801                 } else {
 802                         lock_mode |= LOCK_NB; /* test =: non blocking */
 803                 }
 804         }
 805         if (*pmode) {
 806                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Illegal DBA mode");
 807                 FREENOW;
 808                 RETURN_FALSE;
 809         }
 810                         
 811         info = pemalloc(sizeof(dba_info), persistent);
 812         memset(info, 0, sizeof(dba_info));
 813         info->path = pestrdup(Z_STRVAL_PP(args[0]), persistent);
 814         info->mode = modenr;
 815         info->argc = ac - 3;
 816         info->argv = args + 3;
 817         info->flags = (hptr->flags & ~DBA_LOCK_ALL) | (lock_flag & DBA_LOCK_ALL) | (persistent ? DBA_PERSISTENT : 0);
 818         info->lock.mode = lock_mode;
 819 
 820         /* if any open call is a locking call:
 821          * check if we already habe a locking call open that should block this call
 822          * the problem is some systems would allow read during write
 823          */
 824         if (hptr->flags & DBA_LOCK_ALL) {
 825                 if ((other = php_dba_find(info->path TSRMLS_CC)) != NULL) {
 826                         if (   ( (lock_mode&LOCK_EX)        && (other->lock.mode&(LOCK_EX|LOCK_SH)) )
 827                             || ( (other->lock.mode&LOCK_EX) && (lock_mode&(LOCK_EX|LOCK_SH))        )
 828                            ) {
 829                                 error = "Unable to establish lock (database file already open)"; /* force failure exit */
 830                         }
 831                 }
 832         }
 833 
 834         if (!error && lock_mode) {
 835                 if (lock_dbf) {
 836                         lock_name = Z_STRVAL_PP(args[0]);
 837                 } else {
 838                         spprintf(&lock_name, 0, "%s.lck", info->path);
 839                         if (!strcmp(file_mode, "r")) {
 840                                 /* when in read only mode try to use existing .lck file first */
 841                                 /* do not log errors for .lck file while in read ony mode on .lck file */
 842                                 lock_file_mode = "rb";
 843                                 info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|IGNORE_PATH|persistent_flag, &opened_path);
 844                         }
 845                         if (!info->lock.fp) {
 846                                 /* when not in read mode or failed to open .lck file read only. now try again in create(write) mode and log errors */
 847                                 lock_file_mode = "a+b";
 848                         } else {
 849                                 if (!persistent) {
 850                                         info->lock.name = opened_path;
 851                                 } else {
 852                                         if (opened_path) {
 853                                                 info->lock.name = pestrdup(opened_path, persistent);
 854                                                 efree(opened_path);
 855                                         }
 856                                 }
 857                         }
 858                 }
 859                 if (!info->lock.fp) {
 860                         info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, &opened_path);
 861                         if (info->lock.fp) {
 862                                 if (lock_dbf) {
 863                                         /* replace the path info with the real path of the opened file */
 864                                         pefree(info->path, persistent);
 865                                         info->path = pestrdup(opened_path, persistent);
 866                                 }
 867                                 /* now store the name of the lock */
 868                                 if (!persistent) {
 869                                         info->lock.name = opened_path;
 870                                 } else {
 871                                         info->lock.name = pestrdup(opened_path, persistent);
 872                                         efree(opened_path);
 873                                 }
 874                         }
 875                 }
 876                 if (!lock_dbf) {
 877                         efree(lock_name);
 878                 }
 879                 if (!info->lock.fp) {
 880                         dba_close(info TSRMLS_CC);
 881                         /* stream operation already wrote an error message */
 882                         FREENOW;
 883                         RETURN_FALSE;
 884                 }
 885                 if (!php_stream_supports_lock(info->lock.fp)) {
 886                         error = "Stream does not support locking";
 887                 }
 888                 if (php_stream_lock(info->lock.fp, lock_mode)) {
 889                         error = "Unable to establish lock"; /* force failure exit */
 890                 }
 891         }
 892 
 893         /* centralised open stream for builtin */
 894         if (!error && (hptr->flags&DBA_STREAM_OPEN)==DBA_STREAM_OPEN) {
 895                 if (info->lock.fp && lock_dbf) {
 896                         info->fp = info->lock.fp; /* use the same stream for locking and database access */
 897                 } else {
 898                         info->fp = php_stream_open_wrapper(info->path, file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, NULL);
 899                 }
 900                 if (!info->fp) {
 901                         dba_close(info TSRMLS_CC);
 902                         /* stream operation already wrote an error message */
 903                         FREENOW;
 904                         RETURN_FALSE;
 905                 }
 906                 if (hptr->flags & (DBA_NO_APPEND|DBA_CAST_AS_FD)) {
 907                         /* Needed because some systems do not allow to write to the original 
 908                          * file contents with O_APPEND being set.
 909                          */
 910                         if (SUCCESS != php_stream_cast(info->fp, PHP_STREAM_AS_FD, (void*)&info->fd, 1)) {
 911                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not cast stream");
 912                                 dba_close(info TSRMLS_CC);
 913                                 FREENOW;
 914                                 RETURN_FALSE;
 915 #ifdef F_SETFL
 916                         } else if (modenr == DBA_CREAT) {
 917                                 int flags = fcntl(info->fd, F_GETFL);
 918                                 fcntl(info->fd, F_SETFL, flags & ~O_APPEND);
 919 #endif
 920                         }
 921                                 
 922                 }
 923         }
 924 
 925         if (error || hptr->open(info, &error TSRMLS_CC) != SUCCESS) {
 926                 dba_close(info TSRMLS_CC);
 927                 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Driver initialization failed for handler: %s%s%s", hptr->name, error?": ":"", error?error:"");
 928                 FREENOW;
 929                 RETURN_FALSE;
 930         }
 931 
 932         info->hnd = hptr;
 933         info->argc = 0;
 934         info->argv = NULL;
 935 
 936         if (persistent) {
 937                 zend_rsrc_list_entry new_le;
 938 
 939                 Z_TYPE(new_le) = le_pdb;
 940                 new_le.ptr = info;
 941                 if (zend_hash_update(&EG(persistent_list), key, keylen+1, &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
 942                         dba_close(info TSRMLS_CC);
 943                         php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Could not register persistent resource");
 944                         FREENOW;
 945                         RETURN_FALSE;
 946                 }
 947         }
 948 
 949         ZEND_REGISTER_RESOURCE(return_value, info, (persistent ? le_pdb : le_db));
 950         FREENOW;
 951 }
 952 /* }}} */
 953 #undef FREENOW
 954 
 955 /* {{{ proto resource dba_popen(string path, string mode [, string handlername, string ...])
 956    Opens path using the specified handler in mode persistently */
 957 PHP_FUNCTION(dba_popen)
 958 {
 959         php_dba_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
 960 }
 961 /* }}} */
 962 
 963 /* {{{ proto resource dba_open(string path, string mode [, string handlername, string ...])
 964    Opens path using the specified handler in mode*/
 965 PHP_FUNCTION(dba_open)
 966 {
 967         php_dba_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
 968 }
 969 /* }}} */
 970 
 971 /* {{{ proto void dba_close(resource handle)
 972    Closes database */
 973 PHP_FUNCTION(dba_close)
 974 {
 975         zval *id;
 976         dba_info *info = NULL;
 977 
 978         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
 979                 return;
 980         }
 981 
 982         DBA_FETCH_RESOURCE(info, &id);
 983 
 984         zend_list_delete(Z_RESVAL_P(id));
 985 }
 986 /* }}} */
 987 
 988 /* {{{ proto bool dba_exists(string key, resource handle)
 989    Checks, if the specified key exists */
 990 PHP_FUNCTION(dba_exists)
 991 {
 992         DBA_ID_GET2;
 993 
 994         if(info->hnd->exists(info, key_str, key_len TSRMLS_CC) == SUCCESS) {
 995                 DBA_ID_DONE;
 996                 RETURN_TRUE;
 997         }
 998         DBA_ID_DONE;
 999         RETURN_FALSE;
1000 }
1001 /* }}} */
1002 
1003 /* {{{ proto string dba_fetch(string key, [int skip ,] resource handle)
1004    Fetches the data associated with key */
1005 PHP_FUNCTION(dba_fetch)
1006 {
1007         char *val;
1008         int len = 0;
1009         DBA_ID_GET2_3;
1010 
1011         if (ac==3) {
1012                 if (!strcmp(info->hnd->name, "cdb")) {
1013                         if (skip < 0) {
1014                                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s accepts only skip values greater than or equal to zero, using skip=0", info->hnd->name);
1015                                 skip = 0;
1016                         }
1017                 } else if (!strcmp(info->hnd->name, "inifile")) {
1018                         /* "-1" is compareable to 0 but allows a non restrictive 
1019                          * access which is fater. For example 'inifile' uses this
1020                          * to allow faster access when the key was already found
1021                          * using firstkey/nextkey. However explicitly setting the
1022                          * value to 0 ensures the first value. 
1023                          */
1024                         if (skip < -1) {
1025                                 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s accepts only skip value -1 and greater, using skip=0", info->hnd->name);
1026                                 skip = 0;
1027                         }
1028                 } else {
1029                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s does not support optional skip parameter, the value will be ignored", info->hnd->name);
1030                         skip = 0;                       
1031                 }
1032         } else {
1033                 skip = 0; 
1034         }
1035         if((val = info->hnd->fetch(info, key_str, key_len, skip, &len TSRMLS_CC)) != NULL) {
1036                 DBA_ID_DONE;
1037                 RETURN_STRINGL(val, len, 0);
1038         } 
1039         DBA_ID_DONE;
1040         RETURN_FALSE;
1041 }
1042 /* }}} */
1043 
1044 /* {{{ proto array|false dba_key_split(string key)
1045    Splits an inifile key into an array of the form array(0=>group,1=>value_name) but returns false if input is false or null */
1046 PHP_FUNCTION(dba_key_split)
1047 {
1048         zval *zkey;
1049         char *key, *name;
1050         int key_len;
1051 
1052         if (ZEND_NUM_ARGS() != 1) {
1053                 WRONG_PARAM_COUNT;
1054         }
1055         if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &zkey) == SUCCESS) {
1056                 if (Z_TYPE_P(zkey) == IS_NULL || (Z_TYPE_P(zkey) == IS_BOOL && !Z_LVAL_P(zkey))) {
1057                         RETURN_BOOL(0);
1058                 }
1059         }
1060         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
1061                 RETURN_BOOL(0);
1062         }
1063         array_init(return_value);
1064         if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
1065                 add_next_index_stringl(return_value, key+1, name - (key + 1), 1);
1066                 add_next_index_stringl(return_value, name+1, key_len - (name - key + 1), 1);
1067         } else {
1068                 add_next_index_stringl(return_value, "", 0, 1);
1069                 add_next_index_stringl(return_value, key, key_len, 1);
1070         }
1071 }
1072 /* }}} */
1073 
1074 /* {{{ proto string dba_firstkey(resource handle)
1075    Resets the internal key pointer and returns the first key */
1076 PHP_FUNCTION(dba_firstkey)
1077 {
1078         char *fkey;
1079         int len;
1080         zval *id;
1081         dba_info *info = NULL;
1082 
1083         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1084                 return;
1085         }
1086 
1087         DBA_FETCH_RESOURCE(info, &id);
1088 
1089         fkey = info->hnd->firstkey(info, &len TSRMLS_CC);
1090 
1091         if (fkey)
1092                 RETURN_STRINGL(fkey, len, 0);
1093 
1094         RETURN_FALSE;
1095 }
1096 /* }}} */
1097 
1098 /* {{{ proto string dba_nextkey(resource handle)
1099    Returns the next key */
1100 PHP_FUNCTION(dba_nextkey)
1101 {
1102         char *nkey;
1103         int len;
1104         zval *id;
1105         dba_info *info = NULL;
1106 
1107         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1108                 return;
1109         }
1110 
1111         DBA_FETCH_RESOURCE(info, &id);
1112 
1113         nkey = info->hnd->nextkey(info, &len TSRMLS_CC);
1114 
1115         if (nkey)
1116                 RETURN_STRINGL(nkey, len, 0);
1117 
1118         RETURN_FALSE;
1119 }
1120 /* }}} */
1121 
1122 /* {{{ proto bool dba_delete(string key, resource handle)
1123    Deletes the entry associated with key
1124    If inifile: remove all other key lines */
1125 PHP_FUNCTION(dba_delete)
1126 {
1127         DBA_ID_GET2;
1128         
1129         DBA_WRITE_CHECK_WITH_ID;
1130         
1131         if(info->hnd->delete(info, key_str, key_len TSRMLS_CC) == SUCCESS)
1132         {
1133                 DBA_ID_DONE;
1134                 RETURN_TRUE;
1135         }
1136         DBA_ID_DONE;
1137         RETURN_FALSE;
1138 }
1139 /* }}} */
1140 
1141 /* {{{ proto bool dba_insert(string key, string value, resource handle)
1142    If not inifile: Insert value as key, return false, if key exists already 
1143    If inifile: Add vakue as key (next instance of key) */
1144 PHP_FUNCTION(dba_insert)
1145 {
1146         php_dba_update(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1147 }
1148 /* }}} */
1149 
1150 /* {{{ proto bool dba_replace(string key, string value, resource handle)
1151    Inserts value as key, replaces key, if key exists already
1152    If inifile: remove all other key lines */
1153 PHP_FUNCTION(dba_replace)
1154 {
1155         php_dba_update(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1156 }
1157 /* }}} */
1158 
1159 /* {{{ proto bool dba_optimize(resource handle)
1160    Optimizes (e.g. clean up, vacuum) database */
1161 PHP_FUNCTION(dba_optimize)
1162 {
1163         zval *id;
1164         dba_info *info = NULL;
1165 
1166         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1167                 return;
1168         }
1169 
1170         DBA_FETCH_RESOURCE(info, &id);
1171 
1172         DBA_WRITE_CHECK;
1173 
1174         if (info->hnd->optimize(info TSRMLS_CC) == SUCCESS) {
1175                 RETURN_TRUE;
1176         }
1177 
1178         RETURN_FALSE;
1179 }
1180 /* }}} */
1181 
1182 /* {{{ proto bool dba_sync(resource handle)
1183    Synchronizes database */
1184 PHP_FUNCTION(dba_sync)
1185 {
1186         zval *id;
1187         dba_info *info = NULL;
1188 
1189         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1190                 return;
1191         }
1192 
1193         DBA_FETCH_RESOURCE(info, &id);
1194 
1195         if (info->hnd->sync(info TSRMLS_CC) == SUCCESS) {
1196                 RETURN_TRUE;
1197         }
1198 
1199         RETURN_FALSE;
1200 }
1201 /* }}} */
1202 
1203 /* {{{ proto array dba_handlers([bool full_info])
1204    List configured database handlers */
1205 PHP_FUNCTION(dba_handlers)
1206 {
1207         dba_handler *hptr;
1208         zend_bool full_info = 0;
1209 
1210         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &full_info) == FAILURE) {
1211                 RETURN_FALSE;
1212         }
1213 
1214         array_init(return_value);
1215 
1216         for(hptr = handler; hptr->name; hptr++) {
1217                 if (full_info) {
1218                         add_assoc_string(return_value, hptr->name, hptr->info(hptr, NULL TSRMLS_CC), 0);
1219                 } else {
1220                         add_next_index_string(return_value, hptr->name, 1);
1221                 }
1222         }
1223 }
1224 /* }}} */
1225 
1226 /* {{{ proto array dba_list()
1227    List opened databases */
1228 PHP_FUNCTION(dba_list)
1229 {
1230         ulong numitems, i;
1231         zend_rsrc_list_entry *le;
1232         dba_info *info;
1233 
1234         if (zend_parse_parameters_none() == FAILURE) {
1235                 RETURN_FALSE;
1236         }
1237 
1238         array_init(return_value);
1239 
1240         numitems = zend_hash_next_free_element(&EG(regular_list));
1241         for (i=1; i<numitems; i++) {
1242                 if (zend_hash_index_find(&EG(regular_list), i, (void **) &le)==FAILURE) {
1243                         continue;
1244                 }
1245                 if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
1246                         info = (dba_info *)(le->ptr);
1247                         add_index_string(return_value, i, info->path, 1);
1248                 }
1249         }
1250 }
1251 /* }}} */
1252 
1253 #endif /* HAVE_DBA */
1254 
1255 /*
1256  * Local variables:
1257  * tab-width: 4
1258  * c-basic-offset: 4
1259  * End:
1260  * vim600: sw=4 ts=4 fdm=marker
1261  * vim<600: sw=4 ts=4
1262  */
/* [<][>][^][v][top][bottom][index][help] */
root/ext/dba/dba.c

DEFINITIONS
