php_db4/db4.cpp

   1 /*-
   2  * Copyright (c) 2004-2009 Oracle.  All rights reserved.
   3  *
   4  * http://www.apache.org/licenses/LICENSE-2.0.txt
   5  *
   6  * authors: George Schlossnagle <george@omniti.com>
   7  */
   8
   9 #ifdef HAVE_CONFIG_H
  10 #include "config.h"
  11 #endif
  12
  13 // this is here to work around a PHP build issue on Windows
  14 #include <iostream>
  15
  16 extern "C"
  17 {
  18 #include "php.h"
  19 #include "php_ini.h"
  20 #include "ext/standard/info.h"
  21 #include "php_db4.h"
  22 }
  23 #ifdef HAVE_MOD_DB4
  24 #include "mod_db4_export.h"
  25 #else
  26 #include "db_cxx.h"
  27 #endif
  28
  29 #ifdef HAVE_MOD_DB4
  30     #define my_db_create mod_db4_db_create
  31     #define my_db_env_create mod_db4_db_env_create
  32 #else
  33     #define my_db_create db_create
  34     #define my_db_env_create db_env_create
  35 #endif
  36
  37 #if PHP_MAJOR_VERSION <= 4
  38 unsigned char second_arg_force_ref[] = { 2, BYREF_NONE, BYREF_FORCE };
  39 unsigned char third_arg_force_ref[] = { 3, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
  40 #endif
  41
  42 /* True global resources - no need for thread safety here */
  43 static int le_db;
  44 static int le_dbc;
  45 static int le_db_txn;
  46 static int le_dbenv;
  47
  48 struct php_DB_TXN {
  49     DB_TXN *db_txn;
  50     struct my_llist *open_cursors;
  51     struct my_llist *open_dbs;
  52 };
  53
  54 struct php_DBC {
  55     DBC *dbc;
  56     struct php_DB_TXN *parent_txn;
  57     struct php_DB *parent_db;
  58 };
  59
  60 struct php_DB {
  61     DB *db;
  62     struct my_llist *open_cursors;
  63 };
  64
  65 struct php_DB_ENV {
  66     DB_ENV *dbenv;
  67 };
  68
  69 static void _free_php_db_txn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
  70 {
  71     struct php_DB_TXN *pdbtxn = (struct php_DB_TXN *) rsrc->ptr;
  72     /* should probably iterate over open_cursors */
  73 #ifndef HAVE_MOD_DB4
  74     if(pdbtxn->db_txn) pdbtxn->db_txn->abort(pdbtxn->db_txn);
  75     pdbtxn->db_txn = NULL;
  76 #endif
  77     if(pdbtxn) efree(pdbtxn);
  78 }
  79
  80 static void _free_php_dbc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
  81 {
  82     struct php_DBC *pdbc = (struct php_DBC *) rsrc->ptr;
  83 #ifndef HAVE_MOD_DB4
  84     pdbc->dbc = NULL;
  85 #endif
  86     if(pdbc) efree(pdbc);
  87     rsrc->ptr = NULL;
  88 }
  89
  90 static void _free_php_db(zend_rsrc_list_entry *rsrc TSRMLS_DC)
  91 {
  92     struct php_DB *pdb = (struct php_DB *) rsrc->ptr;
  93 #ifndef HAVE_MOD_DB4
  94     if(pdb->db) pdb->db->close(pdb->db, 0);
  95     pdb->db = NULL;
  96 #endif
  97     if(pdb) efree(pdb);
  98 }
  99
 100 static void _free_php_dbenv(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 101 {
 102     struct php_DB_ENV *pdb = (struct php_DB_ENV *)rsrc->ptr;
 103 #ifndef HAVE_MOD_DB4
 104     DbEnv *dbe;
 105         if(pdb->dbenv) {
 106                 dbe = DbEnv::get_DbEnv(pdb->dbenv);
 107             if(dbe) dbe->close(0);
 108                 delete dbe;
 109         }
 110 #endif
 111         if(pdb) efree(pdb);
 112 }
 113
 114 static zend_class_entry *db_txn_ce;
 115 static zend_class_entry *dbc_ce;
 116 static zend_class_entry *db_ce;
 117 static zend_class_entry *db_env_ce;
 118
 119 /* helpers */
 120 struct my_llist {
 121     void *data;
 122     struct my_llist *next;
 123     struct my_llist *prev;
 124 };
 125
 126 static struct my_llist *my_llist_add(struct my_llist *list, void *data) {
 127     if(!list) {
 128         list = (struct my_llist *)emalloc(sizeof(*list));
 129         list->data = data;
 130         list->next = list->prev = NULL;
 131         return list;
 132     } else {
 133         struct my_llist *node;
 134         node = (struct my_llist *)emalloc(sizeof(*node));
 135         node->data = data;
 136         node->next = list;
 137         node->prev = NULL;
 138         return node;
 139     }
 140 }
 141
 142 static struct my_llist *my_llist_del(struct my_llist *list, void *data) {
 143     struct my_llist *ptr = list;
 144     if(!ptr) return NULL;
 145     if(ptr->data == data) { /* special case, first element */
 146         ptr = ptr->next;
 147         efree(list);
 148         return ptr;
 149     }
 150     while(ptr) {
 151         if(data == ptr->data) {
 152             if(ptr->prev) ptr->prev->next = ptr->next;
 153             if(ptr->next) ptr->next->prev = ptr->prev;
 154             efree(ptr);
 155             break;
 156         }
 157         ptr = ptr->next;
 158     }
 159     return list;
 160 }
 161
 162 /* {{{ db4_functions[]
 163  *
 164  * Every user visible function must have an entry in db4_functions[].
 165  */
 166 function_entry db4_functions[] = {
 167     /* PHP_FE(db4_dbenv_create, NULL) */
 168     {NULL, NULL, NULL}  /* Must be the last line in db4_functions[] */
 169 };
 170 /* }}} */
 171
 172 PHP_MINIT_FUNCTION(db4);
 173 PHP_MSHUTDOWN_FUNCTION(db4);
 174 PHP_RINIT_FUNCTION(db4);
 175 PHP_RSHUTDOWN_FUNCTION(db4);
 176 PHP_MINFO_FUNCTION(db4);
 177
 178 /* {{{ db4_module_entry
 179  */
 180 zend_module_entry db4_module_entry = {
 181 #if ZEND_MODULE_API_NO >= 20010901
 182     STANDARD_MODULE_HEADER,
 183 #endif
 184     "db4",
 185     db4_functions,
 186     PHP_MINIT(db4),
 187     PHP_MSHUTDOWN(db4),
 188     NULL,
 189     NULL,
 190     PHP_MINFO(db4),
 191     "0.9", /* Replace with version number for your extension */
 192     STANDARD_MODULE_PROPERTIES
 193 };
 194 /* }}} */
 195
 196 /* {{{ class entries
 197  */
 198
 199 /* {{{ DB4Txn method forward declarations
 200  */
 201
 202 zend_class_entry *db_txn_ce_get(void)
 203 {
 204     return db_txn_ce;
 205 }
 206
 207 ZEND_NAMED_FUNCTION(_wrap_db_txn_abort);
 208 ZEND_NAMED_FUNCTION(_wrap_db_txn_commit);
 209 ZEND_NAMED_FUNCTION(_wrap_db_txn_discard);
 210 ZEND_NAMED_FUNCTION(_wrap_db_txn_id);
 211 ZEND_NAMED_FUNCTION(_wrap_db_txn_set_timeout);
 212 ZEND_NAMED_FUNCTION(_wrap_db_txn_set_name);
 213 ZEND_NAMED_FUNCTION(_wrap_db_txn_get_name);
 214 ZEND_NAMED_FUNCTION(_wrap_new_DbTxn);
 215
 216 static zend_function_entry DbTxn_functions[] = {
 217         ZEND_NAMED_FE(abort, _wrap_db_txn_abort, NULL)
 218         ZEND_NAMED_FE(commit, _wrap_db_txn_commit, NULL)
 219         ZEND_NAMED_FE(discard, _wrap_db_txn_discard, NULL)
 220         ZEND_NAMED_FE(id, _wrap_db_txn_id, NULL)
 221         ZEND_NAMED_FE(set_timeout, _wrap_db_txn_set_timeout, NULL)
 222         ZEND_NAMED_FE(set_name, _wrap_db_txn_set_name, NULL)
 223         ZEND_NAMED_FE(get_name, _wrap_db_txn_get_name, NULL)
 224         ZEND_NAMED_FE(db4txn, _wrap_new_DbTxn, NULL)
 225         { NULL, NULL, NULL}
 226 };
 227 /* }}} */
 228
 229 /* {{{ DB4Cursor method forward declarations
 230  */
 231
 232 zend_class_entry *dbc_ce_get(void)
 233 {
 234     return dbc_ce;
 235 }
 236
 237 ZEND_NAMED_FUNCTION(_wrap_dbc_close);
 238 ZEND_NAMED_FUNCTION(_wrap_dbc_count);
 239 ZEND_NAMED_FUNCTION(_wrap_dbc_del);
 240 ZEND_NAMED_FUNCTION(_wrap_dbc_dup);
 241 ZEND_NAMED_FUNCTION(_wrap_dbc_get);
 242 ZEND_NAMED_FUNCTION(_wrap_dbc_put);
 243 ZEND_NAMED_FUNCTION(_wrap_dbc_pget);
 244
 245 #ifdef ZEND_ENGINE_2
 246 ZEND_BEGIN_ARG_INFO(first_and_second_args_force_ref, 0)
 247     ZEND_ARG_PASS_INFO(1)
 248     ZEND_ARG_PASS_INFO(1)
 249 ZEND_END_ARG_INFO();
 250
 251 ZEND_BEGIN_ARG_INFO(first_and_second_and_third_args_force_ref, 0)
 252     ZEND_ARG_PASS_INFO(1)
 253     ZEND_ARG_PASS_INFO(1)
 254 ZEND_END_ARG_INFO();
 255
 256 #else
 257 static unsigned char first_and_second_args_force_ref[] = {2, BYREF_FORCE, BYREF_FORCE };
 258 static unsigned char first_and_second_and_third_args_force_ref[] = {3, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE };
 259 #endif
 260
 261 static zend_function_entry Dbc_functions[] = {
 262         ZEND_NAMED_FE(close, _wrap_dbc_close, NULL)
 263         ZEND_NAMED_FE(count, _wrap_dbc_count, NULL)
 264         ZEND_NAMED_FE(del, _wrap_dbc_del, NULL)
 265         ZEND_NAMED_FE(dup, _wrap_dbc_dup, NULL)
 266         ZEND_NAMED_FE(get, _wrap_dbc_get, first_and_second_args_force_ref)
 267         ZEND_NAMED_FE(put, _wrap_dbc_put, NULL)
 268         ZEND_NAMED_FE(pget, _wrap_dbc_pget, first_and_second_and_third_args_force_ref)
 269         { NULL, NULL, NULL}
 270 };
 271 /* }}} */
 272
 273 /* {{{ DB4Env method forward declarations
 274  */
 275
 276 zend_class_entry *db_env_ce_get(void)
 277 {
 278     return db_env_ce;
 279 }
 280
 281 ZEND_NAMED_FUNCTION(_wrap_new_DbEnv);
 282 ZEND_NAMED_FUNCTION(_wrap_db_env_close);
 283 ZEND_NAMED_FUNCTION(_wrap_db_env_dbremove);
 284 ZEND_NAMED_FUNCTION(_wrap_db_env_dbrename);
 285 ZEND_NAMED_FUNCTION(_wrap_db_env_get_encrypt_flags);
 286 ZEND_NAMED_FUNCTION(_wrap_db_env_open);
 287 ZEND_NAMED_FUNCTION(_wrap_db_env_remove);
 288 ZEND_NAMED_FUNCTION(_wrap_db_env_set_data_dir);
 289 ZEND_NAMED_FUNCTION(_wrap_db_env_set_encrypt);
 290 ZEND_NAMED_FUNCTION(_wrap_db_env_txn_begin);
 291 ZEND_NAMED_FUNCTION(_wrap_db_env_txn_checkpoint);
 292
 293 static zend_function_entry DbEnv_functions[] = {
 294         ZEND_NAMED_FE(db4env, _wrap_new_DbEnv, NULL)
 295         ZEND_NAMED_FE(close, _wrap_db_env_close, NULL)
 296         ZEND_NAMED_FE(dbremove, _wrap_db_env_dbremove, NULL)
 297         ZEND_NAMED_FE(dbrename, _wrap_db_env_dbrename, NULL)
 298                 ZEND_NAMED_FE(get_encrypt, _wrap_db_env_get_encrypt_flags, NULL)
 299         ZEND_NAMED_FE(open, _wrap_db_env_open, NULL)
 300         ZEND_NAMED_FE(remove, _wrap_db_env_remove, NULL)
 301         ZEND_NAMED_FE(set_data_dir, _wrap_db_env_set_data_dir, NULL)
 302                 ZEND_NAMED_FE(set_encrypt, _wrap_db_env_set_encrypt, NULL)
 303         ZEND_NAMED_FE(txn_begin, _wrap_db_env_txn_begin, NULL)
 304         ZEND_NAMED_FE(txn_checkpoint, _wrap_db_env_txn_checkpoint, NULL)
 305         { NULL, NULL, NULL}
 306 };
 307
 308 /* }}} */
 309
 310 /* {{{ DB4 method forward declarations
 311  */
 312
 313 zend_class_entry *db_ce_get(void)
 314 {
 315     return db_ce;
 316 }
 317
 318 ZEND_NAMED_FUNCTION(_wrap_new_db4);
 319 ZEND_NAMED_FUNCTION(_wrap_db_open);
 320 ZEND_NAMED_FUNCTION(_wrap_db_close);
 321 ZEND_NAMED_FUNCTION(_wrap_db_del);
 322 ZEND_NAMED_FUNCTION(_wrap_db_get);
 323 ZEND_NAMED_FUNCTION(_wrap_db_get_encrypt_flags);
 324 ZEND_NAMED_FUNCTION(_wrap_db_pget);
 325 ZEND_NAMED_FUNCTION(_wrap_db_get_type);
 326 ZEND_NAMED_FUNCTION(_wrap_db_join);
 327 ZEND_NAMED_FUNCTION(_wrap_db_put);
 328 ZEND_NAMED_FUNCTION(_wrap_db_set_encrypt);
 329 ZEND_NAMED_FUNCTION(_wrap_db_stat);
 330 ZEND_NAMED_FUNCTION(_wrap_db_sync);
 331 ZEND_NAMED_FUNCTION(_wrap_db_truncate);
 332 ZEND_NAMED_FUNCTION(_wrap_db_cursor);
 333
 334 static zend_function_entry Db4_functions[] = {
 335         ZEND_NAMED_FE(db4, _wrap_new_db4, NULL)
 336         ZEND_NAMED_FE(open, _wrap_db_open, NULL)
 337         ZEND_NAMED_FE(close, _wrap_db_close, NULL)
 338         ZEND_NAMED_FE(cursor, _wrap_db_cursor, NULL)
 339         ZEND_NAMED_FE(del, _wrap_db_del, NULL)
 340         ZEND_NAMED_FE(get, _wrap_db_get, NULL)
 341                 ZEND_NAMED_FE(get_encrypt_flags, _wrap_db_get_encrypt_flags, NULL)
 342         ZEND_NAMED_FE(pget, _wrap_db_pget, second_arg_force_ref)
 343         ZEND_NAMED_FE(get_type, _wrap_db_get_type, NULL)
 344         ZEND_NAMED_FE(join, _wrap_db_join, NULL)
 345         ZEND_NAMED_FE(put, _wrap_db_put, NULL)
 346                 ZEND_NAMED_FE(set_encrypt, _wrap_db_set_encrypt, NULL)
 347         ZEND_NAMED_FE(stat, _wrap_db_stat, NULL)
 348         ZEND_NAMED_FE(sync, _wrap_db_sync, NULL)
 349         ZEND_NAMED_FE(truncate, _wrap_db_truncate, NULL)
 350         { NULL, NULL, NULL}
 351 };
 352 /* }}} */
 353 /* }}} */
 354
 355 #ifdef COMPILE_DL_DB4
 356 #ifdef PHP_WIN32
 357 #include "zend_arg_defs.c"
 358 #endif
 359 BEGIN_EXTERN_C()
 360 ZEND_GET_MODULE(db4)
 361 END_EXTERN_C()
 362 #endif
 363
 364 /* {{{ PHP_INI
 365  */
 366 /* Remove comments and fill if you need to have entries in php.ini
 367 PHP_INI_BEGIN()
 368 PHP_INI_END()
 369 */
 370 /* }}} */
 371
 372 /* {{{ php_db4_init_globals
 373  */
 374 /* Uncomment this function if you have INI entries
 375 static void php_db4_init_globals(zend_db4_globals *db4_globals)
 376 {
 377 }
 378 */
 379 /* }}} */
 380
 381 /* {{{ PHP_MINIT_FUNCTION
 382  */
 383 PHP_MINIT_FUNCTION(db4)
 384 {
 385     /* If you have INI entries, uncomment these lines
 386     ZEND_INIT_MODULE_GLOBALS(db4, php_db4_init_globals, NULL);
 387     REGISTER_INI_ENTRIES();
 388     */
 389     static zend_class_entry _db_txn_ce;
 390     static zend_class_entry _dbc_ce;
 391     static zend_class_entry _db_ce;
 392     static zend_class_entry _db_env_ce;
 393
 394     INIT_CLASS_ENTRY(_db_txn_ce, "db4txn", DbTxn_functions);
 395     db_txn_ce = zend_register_internal_class(&_db_txn_ce TSRMLS_CC);
 396
 397     INIT_CLASS_ENTRY(_dbc_ce, "db4cursor", Dbc_functions);
 398     dbc_ce = zend_register_internal_class(&_dbc_ce TSRMLS_CC);
 399
 400     INIT_CLASS_ENTRY(_db_ce, "db4", Db4_functions);
 401     db_ce = zend_register_internal_class(&_db_ce TSRMLS_CC);
 402
 403     INIT_CLASS_ENTRY(_db_env_ce, "db4env", DbEnv_functions);
 404     db_env_ce = zend_register_internal_class(&_db_env_ce TSRMLS_CC);
 405
 406     le_db_txn = zend_register_list_destructors_ex(_free_php_db_txn, NULL, "Db4Txn", module_number);
 407     le_dbc = zend_register_list_destructors_ex(_free_php_dbc, NULL, "Db4Cursor", module_number);
 408     le_db = zend_register_list_destructors_ex(_free_php_db, NULL, "Db4", module_number);
 409     le_dbenv = zend_register_list_destructors_ex(_free_php_dbenv, NULL, "Db4Env", module_number);
 410
 411     REGISTER_LONG_CONSTANT("DB_VERSION_MAJOR", DB_VERSION_MAJOR, CONST_CS | CONST_PERSISTENT);
 412     REGISTER_LONG_CONSTANT("DB_VERSION_MINOR", DB_VERSION_MINOR, CONST_CS | CONST_PERSISTENT);
 413     REGISTER_LONG_CONSTANT("DB_VERSION_PATCH", DB_VERSION_PATCH, CONST_CS | CONST_PERSISTENT);
 414     REGISTER_STRING_CONSTANT("DB_VERSION_STRING", DB_VERSION_STRING, CONST_CS | CONST_PERSISTENT);
 415     REGISTER_LONG_CONSTANT("DB_MAX_PAGES", DB_MAX_PAGES, CONST_CS | CONST_PERSISTENT);
 416     REGISTER_LONG_CONSTANT("DB_MAX_RECORDS", DB_MAX_RECORDS, CONST_CS | CONST_PERSISTENT);
 417     REGISTER_LONG_CONSTANT("DB_DBT_APPMALLOC", DB_DBT_APPMALLOC, CONST_CS | CONST_PERSISTENT);
 418     REGISTER_LONG_CONSTANT("DB_DBT_ISSET", DB_DBT_ISSET, CONST_CS | CONST_PERSISTENT);
 419     REGISTER_LONG_CONSTANT("DB_DBT_MALLOC", DB_DBT_MALLOC, CONST_CS | CONST_PERSISTENT);
 420     REGISTER_LONG_CONSTANT("DB_DBT_PARTIAL", DB_DBT_PARTIAL, CONST_CS | CONST_PERSISTENT);
 421     REGISTER_LONG_CONSTANT("DB_DBT_REALLOC", DB_DBT_REALLOC, CONST_CS | CONST_PERSISTENT);
 422     REGISTER_LONG_CONSTANT("DB_DBT_USERMEM", DB_DBT_USERMEM, CONST_CS | CONST_PERSISTENT);
 423     REGISTER_LONG_CONSTANT("DB_DBT_DUPOK", DB_DBT_DUPOK, CONST_CS | CONST_PERSISTENT);
 424     REGISTER_LONG_CONSTANT("DB_CREATE", DB_CREATE, CONST_CS | CONST_PERSISTENT);
 425     REGISTER_LONG_CONSTANT("DB_CXX_NO_EXCEPTIONS", DB_CXX_NO_EXCEPTIONS, CONST_CS | CONST_PERSISTENT);
 426     REGISTER_LONG_CONSTANT("DB_FORCE", DB_FORCE, CONST_CS | CONST_PERSISTENT);
 427     REGISTER_LONG_CONSTANT("DB_NOMMAP", DB_NOMMAP, CONST_CS | CONST_PERSISTENT);
 428     REGISTER_LONG_CONSTANT("DB_RDONLY", DB_RDONLY, CONST_CS | CONST_PERSISTENT);
 429     REGISTER_LONG_CONSTANT("DB_RECOVER", DB_RECOVER, CONST_CS | CONST_PERSISTENT);
 430     REGISTER_LONG_CONSTANT("DB_MULTIVERSION", DB_MULTIVERSION, CONST_CS | CONST_PERSISTENT);
 431     REGISTER_LONG_CONSTANT("DB_TXN_SNAPSHOT", DB_TXN_SNAPSHOT, CONST_CS | CONST_PERSISTENT);
 432     REGISTER_LONG_CONSTANT("DB_THREAD", DB_THREAD, CONST_CS | CONST_PERSISTENT);
 433     REGISTER_LONG_CONSTANT("DB_TRUNCATE", DB_TRUNCATE, CONST_CS | CONST_PERSISTENT);
 434     REGISTER_LONG_CONSTANT("DB_TXN_NOSYNC", DB_TXN_NOSYNC, CONST_CS | CONST_PERSISTENT);
 435     REGISTER_LONG_CONSTANT("DB_TXN_NOT_DURABLE", DB_TXN_NOT_DURABLE, CONST_CS | CONST_PERSISTENT);
 436     REGISTER_LONG_CONSTANT("DB_USE_ENVIRON", DB_USE_ENVIRON, CONST_CS | CONST_PERSISTENT);
 437     REGISTER_LONG_CONSTANT("DB_USE_ENVIRON_ROOT", DB_USE_ENVIRON_ROOT, CONST_CS | CONST_PERSISTENT);
 438     REGISTER_LONG_CONSTANT("DB_AUTO_COMMIT", DB_AUTO_COMMIT, CONST_CS | CONST_PERSISTENT);
 439     REGISTER_LONG_CONSTANT("DB_DIRTY_READ", DB_READ_UNCOMMITTED, CONST_CS | CONST_PERSISTENT);
 440     REGISTER_LONG_CONSTANT("DB_DEGREE_2", DB_READ_COMMITTED, CONST_CS | CONST_PERSISTENT);
 441     REGISTER_LONG_CONSTANT("DB_READ_COMMITTED", DB_READ_COMMITTED, CONST_CS | CONST_PERSISTENT);
 442     REGISTER_LONG_CONSTANT("DB_READ_UNCOMMITTED", DB_READ_UNCOMMITTED, CONST_CS | CONST_PERSISTENT);
 443     REGISTER_LONG_CONSTANT("DB_NO_AUTO_COMMIT", DB_NO_AUTO_COMMIT, CONST_CS | CONST_PERSISTENT);
 444     REGISTER_LONG_CONSTANT("DB_RPCCLIENT", DB_RPCCLIENT, CONST_CS | CONST_PERSISTENT);
 445     REGISTER_LONG_CONSTANT("DB_INIT_CDB", DB_INIT_CDB, CONST_CS | CONST_PERSISTENT);
 446     REGISTER_LONG_CONSTANT("DB_INIT_LOCK", DB_INIT_LOCK, CONST_CS | CONST_PERSISTENT);
 447     REGISTER_LONG_CONSTANT("DB_INIT_LOG", DB_INIT_LOG, CONST_CS | CONST_PERSISTENT);
 448     REGISTER_LONG_CONSTANT("DB_INIT_MPOOL", DB_INIT_MPOOL, CONST_CS | CONST_PERSISTENT);
 449     REGISTER_LONG_CONSTANT("DB_INIT_REP", DB_INIT_REP, CONST_CS | CONST_PERSISTENT);
 450     REGISTER_LONG_CONSTANT("DB_INIT_TXN", DB_INIT_TXN, CONST_CS | CONST_PERSISTENT);
 451     REGISTER_LONG_CONSTANT("DB_JOINENV", DB_JOINENV, CONST_CS | CONST_PERSISTENT);
 452     REGISTER_LONG_CONSTANT("DB_LOCKDOWN", DB_LOCKDOWN, CONST_CS | CONST_PERSISTENT);
 453     REGISTER_LONG_CONSTANT("DB_PRIVATE", DB_PRIVATE, CONST_CS | CONST_PERSISTENT);
 454     REGISTER_LONG_CONSTANT("DB_RECOVER_FATAL", DB_RECOVER_FATAL, CONST_CS | CONST_PERSISTENT);
 455     REGISTER_LONG_CONSTANT("DB_SYSTEM_MEM", DB_SYSTEM_MEM, CONST_CS | CONST_PERSISTENT);
 456     REGISTER_LONG_CONSTANT("DB_EXCL", DB_EXCL, CONST_CS | CONST_PERSISTENT);
 457     REGISTER_LONG_CONSTANT("DB_FCNTL_LOCKING", DB_FCNTL_LOCKING, CONST_CS | CONST_PERSISTENT);
 458     REGISTER_LONG_CONSTANT("DB_RDWRMASTER", DB_RDWRMASTER, CONST_CS | CONST_PERSISTENT);
 459     REGISTER_LONG_CONSTANT("DB_WRITEOPEN", DB_WRITEOPEN, CONST_CS | CONST_PERSISTENT);
 460     REGISTER_LONG_CONSTANT("DB_TXN_NOWAIT", DB_TXN_NOWAIT, CONST_CS | CONST_PERSISTENT);
 461     REGISTER_LONG_CONSTANT("DB_TXN_SYNC", DB_TXN_SYNC, CONST_CS | CONST_PERSISTENT);
 462     REGISTER_LONG_CONSTANT("DB_ENCRYPT_AES", DB_ENCRYPT_AES, CONST_CS | CONST_PERSISTENT);
 463     REGISTER_LONG_CONSTANT("DB_CDB_ALLDB", DB_CDB_ALLDB, CONST_CS | CONST_PERSISTENT);
 464     REGISTER_LONG_CONSTANT("DB_DIRECT_DB", DB_DIRECT_DB, CONST_CS | CONST_PERSISTENT);
 465     REGISTER_LONG_CONSTANT("DB_NOLOCKING", DB_NOLOCKING, CONST_CS | CONST_PERSISTENT);
 466     REGISTER_LONG_CONSTANT("DB_NOPANIC", DB_NOPANIC, CONST_CS | CONST_PERSISTENT);
 467     REGISTER_LONG_CONSTANT("DB_OVERWRITE", DB_OVERWRITE, CONST_CS | CONST_PERSISTENT);
 468     REGISTER_LONG_CONSTANT("DB_PANIC_ENVIRONMENT", DB_PANIC_ENVIRONMENT, CONST_CS | CONST_PERSISTENT);
 469     REGISTER_LONG_CONSTANT("DB_REGION_INIT", DB_REGION_INIT, CONST_CS | CONST_PERSISTENT);
 470     REGISTER_LONG_CONSTANT("DB_TIME_NOTGRANTED", DB_TIME_NOTGRANTED, CONST_CS | CONST_PERSISTENT);
 471     REGISTER_LONG_CONSTANT("DB_TXN_WRITE_NOSYNC", DB_TXN_WRITE_NOSYNC, CONST_CS | CONST_PERSISTENT);
 472     REGISTER_LONG_CONSTANT("DB_YIELDCPU", DB_YIELDCPU, CONST_CS | CONST_PERSISTENT);
 473     REGISTER_LONG_CONSTANT("DB_UPGRADE", DB_UPGRADE, CONST_CS | CONST_PERSISTENT);
 474     REGISTER_LONG_CONSTANT("DB_VERIFY", DB_VERIFY, CONST_CS | CONST_PERSISTENT);
 475     REGISTER_LONG_CONSTANT("DB_DIRECT", DB_DIRECT, CONST_CS | CONST_PERSISTENT);
 476     REGISTER_LONG_CONSTANT("DB_EXTENT", DB_EXTENT, CONST_CS | CONST_PERSISTENT);
 477     REGISTER_LONG_CONSTANT("DB_ODDFILESIZE", DB_ODDFILESIZE, CONST_CS | CONST_PERSISTENT);
 478     REGISTER_LONG_CONSTANT("DB_CHKSUM", DB_CHKSUM, CONST_CS | CONST_PERSISTENT);
 479     REGISTER_LONG_CONSTANT("DB_DUP", DB_DUP, CONST_CS | CONST_PERSISTENT);
 480     REGISTER_LONG_CONSTANT("DB_DUPSORT", DB_DUPSORT, CONST_CS | CONST_PERSISTENT);
 481     REGISTER_LONG_CONSTANT("DB_ENCRYPT", DB_ENCRYPT, CONST_CS | CONST_PERSISTENT);
 482     REGISTER_LONG_CONSTANT("DB_RECNUM", DB_RECNUM, CONST_CS | CONST_PERSISTENT);
 483     REGISTER_LONG_CONSTANT("DB_RENUMBER", DB_RENUMBER, CONST_CS | CONST_PERSISTENT);
 484     REGISTER_LONG_CONSTANT("DB_REVSPLITOFF", DB_REVSPLITOFF, CONST_CS | CONST_PERSISTENT);
 485     REGISTER_LONG_CONSTANT("DB_SNAPSHOT", DB_SNAPSHOT, CONST_CS | CONST_PERSISTENT);
 486     REGISTER_LONG_CONSTANT("DB_STAT_CLEAR", DB_STAT_CLEAR, CONST_CS | CONST_PERSISTENT);
 487     REGISTER_LONG_CONSTANT("DB_JOIN_NOSORT", DB_JOIN_NOSORT, CONST_CS | CONST_PERSISTENT);
 488     REGISTER_LONG_CONSTANT("DB_AGGRESSIVE", DB_AGGRESSIVE, CONST_CS | CONST_PERSISTENT);
 489     REGISTER_LONG_CONSTANT("DB_NOORDERCHK", DB_NOORDERCHK, CONST_CS | CONST_PERSISTENT);
 490     REGISTER_LONG_CONSTANT("DB_ORDERCHKONLY", DB_ORDERCHKONLY, CONST_CS | CONST_PERSISTENT);
 491     REGISTER_LONG_CONSTANT("DB_PR_PAGE", DB_PR_PAGE, CONST_CS | CONST_PERSISTENT);
 492     REGISTER_LONG_CONSTANT("DB_PR_RECOVERYTEST", DB_PR_RECOVERYTEST, CONST_CS | CONST_PERSISTENT);
 493     REGISTER_LONG_CONSTANT("DB_PRINTABLE", DB_PRINTABLE, CONST_CS | CONST_PERSISTENT);
 494     REGISTER_LONG_CONSTANT("DB_SALVAGE", DB_SALVAGE, CONST_CS | CONST_PERSISTENT);
 495     REGISTER_LONG_CONSTANT("DB_REP_NOBUFFER", DB_REP_NOBUFFER, CONST_CS | CONST_PERSISTENT);
 496     REGISTER_LONG_CONSTANT("DB_REP_PERMANENT", DB_REP_PERMANENT, CONST_CS | CONST_PERSISTENT);
 497     REGISTER_LONG_CONSTANT("DB_LOCKVERSION", DB_LOCKVERSION, CONST_CS | CONST_PERSISTENT);
 498     REGISTER_LONG_CONSTANT("DB_FILE_ID_LEN", DB_FILE_ID_LEN, CONST_CS | CONST_PERSISTENT);
 499     REGISTER_LONG_CONSTANT("DB_LOCK_NORUN", DB_LOCK_NORUN, CONST_CS | CONST_PERSISTENT);
 500     REGISTER_LONG_CONSTANT("DB_LOCK_DEFAULT", DB_LOCK_DEFAULT, CONST_CS | CONST_PERSISTENT);
 501     REGISTER_LONG_CONSTANT("DB_LOCK_EXPIRE", DB_LOCK_EXPIRE, CONST_CS | CONST_PERSISTENT);
 502     REGISTER_LONG_CONSTANT("DB_LOCK_MAXLOCKS", DB_LOCK_MAXLOCKS, CONST_CS | CONST_PERSISTENT);
 503     REGISTER_LONG_CONSTANT("DB_LOCK_MINLOCKS", DB_LOCK_MINLOCKS, CONST_CS | CONST_PERSISTENT);
 504     REGISTER_LONG_CONSTANT("DB_LOCK_MINWRITE", DB_LOCK_MINWRITE, CONST_CS | CONST_PERSISTENT);
 505     REGISTER_LONG_CONSTANT("DB_LOCK_OLDEST", DB_LOCK_OLDEST, CONST_CS | CONST_PERSISTENT);
 506     REGISTER_LONG_CONSTANT("DB_LOCK_RANDOM", DB_LOCK_RANDOM, CONST_CS | CONST_PERSISTENT);
 507     REGISTER_LONG_CONSTANT("DB_LOCK_YOUNGEST", DB_LOCK_YOUNGEST, CONST_CS | CONST_PERSISTENT);
 508     REGISTER_LONG_CONSTANT("DB_LOCK_NOWAIT", DB_LOCK_NOWAIT, CONST_CS | CONST_PERSISTENT);
 509     REGISTER_LONG_CONSTANT("DB_LOCK_RECORD", DB_LOCK_RECORD, CONST_CS | CONST_PERSISTENT);
 510     REGISTER_LONG_CONSTANT("DB_LOCK_SET_TIMEOUT", DB_LOCK_SET_TIMEOUT, CONST_CS | CONST_PERSISTENT);
 511     REGISTER_LONG_CONSTANT("DB_LOCK_SWITCH", DB_LOCK_SWITCH, CONST_CS | CONST_PERSISTENT);
 512     REGISTER_LONG_CONSTANT("DB_LOCK_UPGRADE", DB_LOCK_UPGRADE, CONST_CS | CONST_PERSISTENT);
 513     REGISTER_LONG_CONSTANT("DB_HANDLE_LOCK", DB_HANDLE_LOCK, CONST_CS | CONST_PERSISTENT);
 514     REGISTER_LONG_CONSTANT("DB_RECORD_LOCK", DB_RECORD_LOCK, CONST_CS | CONST_PERSISTENT);
 515     REGISTER_LONG_CONSTANT("DB_PAGE_LOCK", DB_PAGE_LOCK, CONST_CS | CONST_PERSISTENT);
 516     REGISTER_LONG_CONSTANT("DB_LOGVERSION", DB_LOGVERSION, CONST_CS | CONST_PERSISTENT);
 517     REGISTER_LONG_CONSTANT("DB_LOGOLDVER", DB_LOGOLDVER, CONST_CS | CONST_PERSISTENT);
 518     REGISTER_LONG_CONSTANT("DB_LOGMAGIC", DB_LOGMAGIC, CONST_CS | CONST_PERSISTENT);
 519     REGISTER_LONG_CONSTANT("DB_ARCH_ABS", DB_ARCH_ABS, CONST_CS | CONST_PERSISTENT);
 520     REGISTER_LONG_CONSTANT("DB_ARCH_DATA", DB_ARCH_DATA, CONST_CS | CONST_PERSISTENT);
 521     REGISTER_LONG_CONSTANT("DB_ARCH_LOG", DB_ARCH_LOG, CONST_CS | CONST_PERSISTENT);
 522     REGISTER_LONG_CONSTANT("DB_ARCH_REMOVE", DB_ARCH_REMOVE, CONST_CS | CONST_PERSISTENT);
 523     REGISTER_LONG_CONSTANT("DB_FLUSH", DB_FLUSH, CONST_CS | CONST_PERSISTENT);
 524     REGISTER_LONG_CONSTANT("DB_LOG_CHKPNT", DB_LOG_CHKPNT, CONST_CS | CONST_PERSISTENT);
 525     REGISTER_LONG_CONSTANT("DB_LOG_COMMIT", DB_LOG_COMMIT, CONST_CS | CONST_PERSISTENT);
 526     REGISTER_LONG_CONSTANT("DB_LOG_NOCOPY", DB_LOG_NOCOPY, CONST_CS | CONST_PERSISTENT);
 527     REGISTER_LONG_CONSTANT("DB_LOG_NOT_DURABLE", DB_LOG_NOT_DURABLE, CONST_CS | CONST_PERSISTENT);
 528     REGISTER_LONG_CONSTANT("DB_LOG_WRNOSYNC", DB_LOG_WRNOSYNC, CONST_CS | CONST_PERSISTENT);
 529     REGISTER_LONG_CONSTANT("DB_user_BEGIN", DB_user_BEGIN, CONST_CS | CONST_PERSISTENT);
 530     REGISTER_LONG_CONSTANT("DB_debug_FLAG", DB_debug_FLAG, CONST_CS | CONST_PERSISTENT);
 531     REGISTER_LONG_CONSTANT("DB_LOG_DISK", DB_LOG_DISK, CONST_CS | CONST_PERSISTENT);
 532     REGISTER_LONG_CONSTANT("DB_LOG_LOCKED", DB_LOG_LOCKED, CONST_CS | CONST_PERSISTENT);
 533     REGISTER_LONG_CONSTANT("DB_LOG_SILENT_ERR", DB_LOG_SILENT_ERR, CONST_CS | CONST_PERSISTENT);
 534     REGISTER_LONG_CONSTANT("DB_MPOOL_CREATE", DB_MPOOL_CREATE, CONST_CS | CONST_PERSISTENT);
 535     REGISTER_LONG_CONSTANT("DB_MPOOL_LAST", DB_MPOOL_LAST, CONST_CS | CONST_PERSISTENT);
 536     REGISTER_LONG_CONSTANT("DB_MPOOL_NEW", DB_MPOOL_NEW, CONST_CS | CONST_PERSISTENT);
 537     REGISTER_LONG_CONSTANT("DB_MPOOL_DIRTY", DB_MPOOL_DIRTY, CONST_CS | CONST_PERSISTENT);
 538     REGISTER_LONG_CONSTANT("DB_MPOOL_DISCARD", DB_MPOOL_DISCARD, CONST_CS | CONST_PERSISTENT);
 539     REGISTER_LONG_CONSTANT("DB_MPOOL_NOFILE", DB_MPOOL_NOFILE, CONST_CS | CONST_PERSISTENT);
 540     REGISTER_LONG_CONSTANT("DB_MPOOL_UNLINK", DB_MPOOL_UNLINK, CONST_CS | CONST_PERSISTENT);
 541     REGISTER_LONG_CONSTANT("DB_TXNVERSION", DB_TXNVERSION, CONST_CS | CONST_PERSISTENT);
 542     REGISTER_LONG_CONSTANT("DB_GID_SIZE", DB_GID_SIZE, CONST_CS | CONST_PERSISTENT);
 543     REGISTER_LONG_CONSTANT("DB_EID_BROADCAST", DB_EID_BROADCAST, CONST_CS | CONST_PERSISTENT);
 544     REGISTER_LONG_CONSTANT("DB_EID_INVALID", DB_EID_INVALID, CONST_CS | CONST_PERSISTENT);
 545     REGISTER_LONG_CONSTANT("DB_REP_CLIENT", DB_REP_CLIENT, CONST_CS | CONST_PERSISTENT);
 546     REGISTER_LONG_CONSTANT("DB_REP_MASTER", DB_REP_MASTER, CONST_CS | CONST_PERSISTENT);
 547     REGISTER_LONG_CONSTANT("DB_RENAMEMAGIC", DB_RENAMEMAGIC, CONST_CS | CONST_PERSISTENT);
 548     REGISTER_LONG_CONSTANT("DB_BTREEVERSION", DB_BTREEVERSION, CONST_CS | CONST_PERSISTENT);
 549     REGISTER_LONG_CONSTANT("DB_BTREEOLDVER", DB_BTREEOLDVER, CONST_CS | CONST_PERSISTENT);
 550     REGISTER_LONG_CONSTANT("DB_BTREEMAGIC", DB_BTREEMAGIC, CONST_CS | CONST_PERSISTENT);
 551     REGISTER_LONG_CONSTANT("DB_HASHVERSION", DB_HASHVERSION, CONST_CS | CONST_PERSISTENT);
 552     REGISTER_LONG_CONSTANT("DB_HASHOLDVER", DB_HASHOLDVER, CONST_CS | CONST_PERSISTENT);
 553     REGISTER_LONG_CONSTANT("DB_HASHMAGIC", DB_HASHMAGIC, CONST_CS | CONST_PERSISTENT);
 554     REGISTER_LONG_CONSTANT("DB_QAMVERSION", DB_QAMVERSION, CONST_CS | CONST_PERSISTENT);
 555     REGISTER_LONG_CONSTANT("DB_QAMOLDVER", DB_QAMOLDVER, CONST_CS | CONST_PERSISTENT);
 556     REGISTER_LONG_CONSTANT("DB_QAMMAGIC", DB_QAMMAGIC, CONST_CS | CONST_PERSISTENT);
 557     REGISTER_LONG_CONSTANT("DB_AFTER", DB_AFTER, CONST_CS | CONST_PERSISTENT);
 558     REGISTER_LONG_CONSTANT("DB_APPEND", DB_APPEND, CONST_CS | CONST_PERSISTENT);
 559     REGISTER_LONG_CONSTANT("DB_BEFORE", DB_BEFORE, CONST_CS | CONST_PERSISTENT);
 560     REGISTER_LONG_CONSTANT("DB_CONSUME", DB_CONSUME, CONST_CS | CONST_PERSISTENT);
 561     REGISTER_LONG_CONSTANT("DB_CONSUME_WAIT", DB_CONSUME_WAIT, CONST_CS | CONST_PERSISTENT);
 562     REGISTER_LONG_CONSTANT("DB_CURRENT", DB_CURRENT, CONST_CS | CONST_PERSISTENT);
 563     REGISTER_LONG_CONSTANT("DB_FAST_STAT", DB_FAST_STAT, CONST_CS | CONST_PERSISTENT);
 564     REGISTER_LONG_CONSTANT("DB_FIRST", DB_FIRST, CONST_CS | CONST_PERSISTENT);
 565     REGISTER_LONG_CONSTANT("DB_GET_BOTH", DB_GET_BOTH, CONST_CS | CONST_PERSISTENT);
 566     REGISTER_LONG_CONSTANT("DB_GET_BOTHC", DB_GET_BOTHC, CONST_CS | CONST_PERSISTENT);
 567     REGISTER_LONG_CONSTANT("DB_GET_BOTH_RANGE", DB_GET_BOTH_RANGE, CONST_CS | CONST_PERSISTENT);
 568     REGISTER_LONG_CONSTANT("DB_GET_RECNO", DB_GET_RECNO, CONST_CS | CONST_PERSISTENT);
 569     REGISTER_LONG_CONSTANT("DB_JOIN_ITEM", DB_JOIN_ITEM, CONST_CS | CONST_PERSISTENT);
 570     REGISTER_LONG_CONSTANT("DB_KEYFIRST", DB_KEYFIRST, CONST_CS | CONST_PERSISTENT);
 571     REGISTER_LONG_CONSTANT("DB_KEYLAST", DB_KEYLAST, CONST_CS | CONST_PERSISTENT);
 572     REGISTER_LONG_CONSTANT("DB_LAST", DB_LAST, CONST_CS | CONST_PERSISTENT);
 573     REGISTER_LONG_CONSTANT("DB_NEXT", DB_NEXT, CONST_CS | CONST_PERSISTENT);
 574     REGISTER_LONG_CONSTANT("DB_NEXT_DUP", DB_NEXT_DUP, CONST_CS | CONST_PERSISTENT);
 575     REGISTER_LONG_CONSTANT("DB_NEXT_NODUP", DB_NEXT_NODUP, CONST_CS | CONST_PERSISTENT);
 576     REGISTER_LONG_CONSTANT("DB_NODUPDATA", DB_NODUPDATA, CONST_CS | CONST_PERSISTENT);
 577     REGISTER_LONG_CONSTANT("DB_NOOVERWRITE", DB_NOOVERWRITE, CONST_CS | CONST_PERSISTENT);
 578     REGISTER_LONG_CONSTANT("DB_NOSYNC", DB_NOSYNC, CONST_CS | CONST_PERSISTENT);
 579     REGISTER_LONG_CONSTANT("DB_POSITION", DB_POSITION, CONST_CS | CONST_PERSISTENT);
 580     REGISTER_LONG_CONSTANT("DB_PREV", DB_PREV, CONST_CS | CONST_PERSISTENT);
 581     REGISTER_LONG_CONSTANT("DB_PREV_NODUP", DB_PREV_NODUP, CONST_CS | CONST_PERSISTENT);
 582     REGISTER_LONG_CONSTANT("DB_SET", DB_SET, CONST_CS | CONST_PERSISTENT);
 583     REGISTER_LONG_CONSTANT("DB_SET_LOCK_TIMEOUT", DB_SET_LOCK_TIMEOUT, CONST_CS | CONST_PERSISTENT);
 584     REGISTER_LONG_CONSTANT("DB_SET_RANGE", DB_SET_RANGE, CONST_CS | CONST_PERSISTENT);
 585     REGISTER_LONG_CONSTANT("DB_SET_RECNO", DB_SET_RECNO, CONST_CS | CONST_PERSISTENT);
 586     REGISTER_LONG_CONSTANT("DB_SET_TXN_NOW", DB_SET_TXN_NOW, CONST_CS | CONST_PERSISTENT);
 587     REGISTER_LONG_CONSTANT("DB_SET_TXN_TIMEOUT", DB_SET_TXN_TIMEOUT, CONST_CS | CONST_PERSISTENT);
 588     REGISTER_LONG_CONSTANT("DB_UPDATE_SECONDARY", DB_UPDATE_SECONDARY, CONST_CS | CONST_PERSISTENT);
 589     REGISTER_LONG_CONSTANT("DB_WRITECURSOR", DB_WRITECURSOR, CONST_CS | CONST_PERSISTENT);
 590     REGISTER_LONG_CONSTANT("DB_WRITELOCK", DB_WRITELOCK, CONST_CS | CONST_PERSISTENT);
 591     REGISTER_LONG_CONSTANT("DB_OPFLAGS_MASK", DB_OPFLAGS_MASK, CONST_CS | CONST_PERSISTENT);
 592     REGISTER_LONG_CONSTANT("DB_MULTIPLE", DB_MULTIPLE, CONST_CS | CONST_PERSISTENT);
 593     REGISTER_LONG_CONSTANT("DB_MULTIPLE_KEY", DB_MULTIPLE_KEY, CONST_CS | CONST_PERSISTENT);
 594     REGISTER_LONG_CONSTANT("DB_RMW", DB_RMW, CONST_CS | CONST_PERSISTENT);
 595     REGISTER_LONG_CONSTANT("DB_DONOTINDEX", DB_DONOTINDEX, CONST_CS | CONST_PERSISTENT);
 596     REGISTER_LONG_CONSTANT("DB_KEYEMPTY", DB_KEYEMPTY, CONST_CS | CONST_PERSISTENT);
 597     REGISTER_LONG_CONSTANT("DB_KEYEXIST", DB_KEYEXIST, CONST_CS | CONST_PERSISTENT);
 598     REGISTER_LONG_CONSTANT("DB_LOCK_DEADLOCK", DB_LOCK_DEADLOCK, CONST_CS | CONST_PERSISTENT);
 599     REGISTER_LONG_CONSTANT("DB_LOCK_NOTGRANTED", DB_LOCK_NOTGRANTED, CONST_CS | CONST_PERSISTENT);
 600     REGISTER_LONG_CONSTANT("DB_NOSERVER", DB_NOSERVER, CONST_CS | CONST_PERSISTENT);
 601     REGISTER_LONG_CONSTANT("DB_NOSERVER_HOME", DB_NOSERVER_HOME, CONST_CS | CONST_PERSISTENT);
 602     REGISTER_LONG_CONSTANT("DB_NOSERVER_ID", DB_NOSERVER_ID, CONST_CS | CONST_PERSISTENT);
 603     REGISTER_LONG_CONSTANT("DB_NOTFOUND", DB_NOTFOUND, CONST_CS | CONST_PERSISTENT);
 604     REGISTER_LONG_CONSTANT("DB_OLD_VERSION", DB_OLD_VERSION, CONST_CS | CONST_PERSISTENT);
 605     REGISTER_LONG_CONSTANT("DB_PAGE_NOTFOUND", DB_PAGE_NOTFOUND, CONST_CS | CONST_PERSISTENT);
 606     REGISTER_LONG_CONSTANT("DB_REP_DUPMASTER", DB_REP_DUPMASTER, CONST_CS | CONST_PERSISTENT);
 607     REGISTER_LONG_CONSTANT("DB_REP_HANDLE_DEAD", DB_REP_HANDLE_DEAD, CONST_CS | CONST_PERSISTENT);
 608     REGISTER_LONG_CONSTANT("DB_REP_HOLDELECTION", DB_REP_HOLDELECTION, CONST_CS | CONST_PERSISTENT);
 609     REGISTER_LONG_CONSTANT("DB_REP_ISPERM", DB_REP_ISPERM, CONST_CS | CONST_PERSISTENT);
 610     REGISTER_LONG_CONSTANT("DB_REP_NEWMASTER", DB_REP_NEWMASTER, CONST_CS | CONST_PERSISTENT);
 611     REGISTER_LONG_CONSTANT("DB_REP_NEWSITE", DB_REP_NEWSITE, CONST_CS | CONST_PERSISTENT);
 612     REGISTER_LONG_CONSTANT("DB_REP_NOTPERM", DB_REP_NOTPERM, CONST_CS | CONST_PERSISTENT);
 613     REGISTER_LONG_CONSTANT("DB_REP_UNAVAIL", DB_REP_UNAVAIL, CONST_CS | CONST_PERSISTENT);
 614     REGISTER_LONG_CONSTANT("DB_RUNRECOVERY", DB_RUNRECOVERY, CONST_CS | CONST_PERSISTENT);
 615     REGISTER_LONG_CONSTANT("DB_SECONDARY_BAD", DB_SECONDARY_BAD, CONST_CS | CONST_PERSISTENT);
 616     REGISTER_LONG_CONSTANT("DB_VERIFY_BAD", DB_VERIFY_BAD, CONST_CS | CONST_PERSISTENT);
 617     REGISTER_LONG_CONSTANT("DB_VERB_DEADLOCK", DB_VERB_DEADLOCK, CONST_CS | CONST_PERSISTENT);
 618     REGISTER_LONG_CONSTANT("DB_VERB_RECOVERY", DB_VERB_RECOVERY, CONST_CS | CONST_PERSISTENT);
 619     REGISTER_LONG_CONSTANT("DB_VERB_REPLICATION", DB_VERB_REPLICATION, CONST_CS | CONST_PERSISTENT);
 620     REGISTER_LONG_CONSTANT("DB_VERB_WAITSFOR", DB_VERB_WAITSFOR, CONST_CS | CONST_PERSISTENT);
 621     REGISTER_LONG_CONSTANT("DB_DBM_HSEARCH", DB_DBM_HSEARCH, CONST_CS | CONST_PERSISTENT);
 622         return SUCCESS;
 623 }
 624 /* }}} */
 625
 626 /* {{{ PHP_MSHUTDOWN_FUNCTION
 627  */
 628 PHP_MSHUTDOWN_FUNCTION(db4)
 629 {
 630     /* uncomment this line if you have INI entries
 631     UNREGISTER_INI_ENTRIES();
 632     */
 633     return SUCCESS;
 634 }
 635 /* }}} */
 636
 637 /* {{{ PHP_MINFO_FUNCTION
 638  */
 639 PHP_MINFO_FUNCTION(db4)
 640 {
 641     php_info_print_table_start();
 642     php_info_print_table_header(2, "db4 support", "enabled");
 643     php_info_print_table_end();
 644
 645     /* Remove comments if you have entries in php.ini
 646     DISPLAY_INI_ENTRIES();
 647     */
 648 }
 649 /* }}} */
 650
 651
 652 /* {{{ resource accessors
 653  */
 654 void setDbEnv(zval *z, DB_ENV *dbenv TSRMLS_DC)
 655 {
 656     long rsrc_id;
 657         struct php_DB_ENV *pdb = (struct php_DB_ENV *) emalloc(sizeof(*pdb));
 658         pdb->dbenv = dbenv;
 659     rsrc_id = zend_register_resource(NULL, pdb, le_dbenv);
 660     zend_list_addref(rsrc_id);
 661     add_property_resource(z, "_dbenv_ptr", rsrc_id);
 662 }
 663
 664 DB_ENV *php_db4_getDbEnvFromObj(zval *z TSRMLS_DC)
 665 {
 666     struct php_DB_ENV *pdb;
 667     zval **rsrc;
 668     if(zend_hash_find(HASH_OF(z), "_dbenv_ptr", sizeof("_dbenv_ptr"),
 669           (void **) &rsrc) == SUCCESS)
 670     {
 671         pdb = (struct php_DB_ENV *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Env", NULL, 1, le_dbenv);
 672         return pdb->dbenv;
 673     }
 674     return NULL;
 675 }
 676
 677 struct php_DB_ENV *php_db4_getPhpDbEnvFromObj(zval *z TSRMLS_DC)
 678 {
 679     struct php_DB_ENV *pdb;
 680     zval **rsrc;
 681     if(zend_hash_find(HASH_OF(z), "_dbenv_ptr", sizeof("_dbenv_ptr"),
 682           (void **) &rsrc) == SUCCESS)
 683     {
 684         pdb = (struct php_DB_ENV *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Env", NULL, 1, le_dbenv);
 685         return pdb;
 686     }
 687     return NULL;
 688 }
 689
 690 #define getDbEnvFromThis(a)        \
 691 do { \
 692   zval *_self = getThis(); \
 693   if(!_self) { \
 694     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 695     RETURN_FALSE; \
 696   } \
 697   (a) = php_db4_getDbEnvFromObj(_self TSRMLS_CC); \
 698   if(!(a)) { \
 699     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4Env object"); \
 700     RETURN_FALSE; \
 701   } \
 702 } while(0)
 703
 704 void setDb(zval *z, DB *db TSRMLS_DC)
 705 {
 706     long rsrc_id;
 707     struct php_DB *pdb = (struct php_DB *) emalloc(sizeof(*pdb));
 708     memset(pdb, 0, sizeof(*pdb));
 709     pdb->db = db;
 710     rsrc_id = ZEND_REGISTER_RESOURCE(NULL, pdb, le_db);
 711     add_property_resource(z, "_db_ptr", rsrc_id);
 712 }
 713
 714 struct php_DB *getPhpDbFromObj(zval *z TSRMLS_DC)
 715 {
 716     struct php_DB *pdb;
 717     zval **rsrc;
 718     if(zend_hash_find(HASH_OF(z), "_db_ptr", sizeof("_db_ptr"), (void **) &rsrc) == SUCCESS) {
 719         pdb = (struct php_DB *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4", NULL, 1, le_db);
 720         return pdb;
 721     }
 722     return NULL;
 723 }
 724
 725 DB *php_db4_getDbFromObj(zval *z TSRMLS_DC)
 726 {
 727     struct php_DB *pdb;
 728     zval **rsrc;
 729     if(zend_hash_find(HASH_OF(z), "_db_ptr", sizeof("_db_ptr"), (void **) &rsrc) == SUCCESS) {
 730         pdb = (struct php_DB *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4", NULL, 1, le_db);
 731         return pdb->db;
 732     }
 733     return NULL;
 734 }
 735
 736 #define getDbFromThis(a)        \
 737 do { \
 738   struct php_DB *pdb; \
 739   zval *_self = getThis(); \
 740   if(!_self) { \
 741     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 742     RETURN_FALSE; \
 743   } \
 744    pdb = getPhpDbFromObj(_self TSRMLS_CC); \
 745   if(!pdb || !pdb->db) { \
 746     assert(0); \
 747     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4 object"); \
 748     RETURN_FALSE; \
 749   } \
 750   (a) = pdb->db; \
 751 } while(0)
 752
 753 #define getPhpDbFromThis(a)        \
 754 do { \
 755   struct php_DB *pdb; \
 756   zval *_self = getThis(); \
 757   if(!_self) { \
 758     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 759     RETURN_FALSE; \
 760   } \
 761    pdb = getPhpDbFromObj(_self TSRMLS_CC); \
 762   if(!pdb) { \
 763     assert(0); \
 764     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4 object"); \
 765     RETURN_FALSE; \
 766   } \
 767   (a) = pdb; \
 768 } while(0)
 769
 770 void setDbTxn(zval *z, DB_TXN *dbtxn TSRMLS_DC)
 771 {
 772     long rsrc_id;
 773     struct php_DB_TXN *txn = (struct php_DB_TXN *) emalloc(sizeof(*txn));
 774     memset(txn, 0, sizeof(*txn));
 775     txn->db_txn = dbtxn;
 776     rsrc_id = ZEND_REGISTER_RESOURCE(NULL, txn, le_db_txn);
 777     zend_list_addref(rsrc_id);
 778     add_property_resource(z, "_dbtxn_ptr", rsrc_id);
 779 }
 780
 781 DB_TXN *php_db4_getDbTxnFromObj(zval *z TSRMLS_DC)
 782 {
 783     struct php_DB_TXN *pdbtxn;
 784     zval **rsrc;
 785     if(zend_hash_find(HASH_OF(z), "_dbtxn_ptr", sizeof("_dbtxn_ptr"),
 786           (void **) &rsrc) == SUCCESS)
 787     {
 788         pdbtxn = (struct php_DB_TXN *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Txn", NULL, 1, le_db_txn);
 789         return pdbtxn->db_txn;
 790     }
 791     return NULL;
 792 }
 793
 794 struct php_DB_TXN *getPhpDbTxnFromObj(zval *z TSRMLS_DC)
 795 {
 796     struct php_DB_TXN *pdbtxn;
 797     zval **rsrc;
 798     if(zend_hash_find(HASH_OF(z), "_dbtxn_ptr", sizeof("_dbtxn_ptr"),
 799           (void **) &rsrc) == SUCCESS)
 800     {
 801         pdbtxn = (struct php_DB_TXN *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Txn", NULL, 1, le_db_txn);
 802         return pdbtxn;
 803     }
 804     return NULL;
 805 }
 806
 807 #define getDbTxnFromThis(a)        \
 808 do { \
 809   zval *_self = getThis(); \
 810   if(!_self) { \
 811     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 812     RETURN_FALSE; \
 813   } \
 814   (a) = php_db4_getDbTxnFromObj(_self TSRMLS_CC); \
 815   if(!(a)) { \
 816     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4txn object"); \
 817     RETURN_FALSE; \
 818   } \
 819 } while(0)
 820
 821 #define getPhpDbTxnFromThis(a)        \
 822 do { \
 823   zval *_self = getThis(); \
 824   if(!_self) { \
 825     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 826     RETURN_FALSE; \
 827   } \
 828   (a) = getPhpDbTxnFromObj(_self TSRMLS_CC); \
 829   if(!(a) || !(a)->db_txn) { \
 830     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4txn object"); \
 831     RETURN_FALSE; \
 832   } \
 833 } while(0)
 834
 835 void closeDbTxnDependencies(zval *obj TSRMLS_DC) {
 836     struct php_DB_TXN *pdbtxn = getPhpDbTxnFromObj(obj TSRMLS_CC);
 837     if(pdbtxn) {
 838         while(pdbtxn->open_cursors) {
 839             struct my_llist *el = pdbtxn->open_cursors;
 840             struct php_DBC *pdbc = (struct php_DBC *) el->data;
 841             if(pdbc) {
 842                 if(pdbc->dbc) {
 843                     pdbc->dbc->c_close(pdbc->dbc);
 844                     pdbc->dbc = NULL;
 845                 }
 846                 pdbc->parent_txn = NULL;
 847             }
 848 //          efree(el->data);
 849             pdbtxn->open_cursors = el->next;
 850             efree(el);
 851             php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attempting to end a transaction without closing it's child cursors.");
 852         }
 853         /* should handle open dbs with pending transactions */
 854     }
 855 }
 856
 857
 858 void setDbc(zval *z, DBC *dbc, struct php_DB_TXN *txn TSRMLS_DC)
 859 {
 860     long rsrc_id;
 861     struct php_DBC *pdbc = (struct php_DBC *) emalloc(sizeof(*pdbc));
 862     memset(pdbc, 0, sizeof(*pdbc));
 863     pdbc->dbc = dbc;
 864     if(txn) {
 865         pdbc->parent_txn = txn;
 866         txn->open_cursors = my_llist_add(txn->open_cursors, pdbc);
 867     }
 868     rsrc_id = zend_register_resource(NULL, pdbc, le_dbc);
 869     zend_list_addref(rsrc_id);
 870     add_property_resource(z, "_dbc_ptr", rsrc_id);
 871 }
 872
 873 DBC *php_db4_getDbcFromObj(zval *z TSRMLS_DC)
 874 {
 875     struct php_DBC *pdbc;
 876     zval **rsrc;
 877     if(zend_hash_find(HASH_OF(z), "_dbc_ptr", sizeof("_dbc_ptr"),
 878           (void **) &rsrc) == SUCCESS)
 879     {
 880         pdbc = (struct php_DBC *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Cursor", NULL, 1, le_dbc);
 881         return pdbc->dbc;
 882     }
 883     return NULL;
 884 }
 885
 886 struct php_DBC *getPhpDbcFromObj(zval *z TSRMLS_DC)
 887 {
 888     struct php_DBC *pdbc;
 889     zval **rsrc;
 890     if(zend_hash_find(HASH_OF(z), "_dbc_ptr", sizeof("_dbc_ptr"),
 891           (void **) &rsrc) == SUCCESS)
 892     {
 893         pdbc = (struct php_DBC *) zend_fetch_resource(rsrc TSRMLS_CC, -1, "Db4Cursor", NULL, 1, le_dbc);
 894         return pdbc;
 895     }
 896     return NULL;
 897 }
 898
 899 #define getDbcFromThis(a)        \
 900 do { \
 901   zval *_self = getThis(); \
 902   if(!_self) { \
 903     php_error_docref(NULL TSRMLS_CC, E_WARNING, "must be called as a method"); \
 904     RETURN_FALSE; \
 905   } \
 906   (a) = php_db4_getDbcFromObj(_self TSRMLS_CC); \
 907   if(!(a)) { \
 908     php_error_docref(NULL TSRMLS_CC, E_WARNING, "not a valid db4Cursor object"); \
 909     RETURN_FALSE; \
 910   } \
 911 } while(0)
 912
 913 int closeDbc(zval *obj TSRMLS_DC)
 914 {
 915     int ret = 0;
 916     struct php_DBC *pdbc = getPhpDbcFromObj(obj TSRMLS_CC);
 917     if(pdbc) {
 918         if(pdbc->parent_txn) {
 919             pdbc->parent_txn->open_cursors =
 920                 my_llist_del(pdbc->parent_txn->open_cursors, pdbc);
 921         }
 922         ret = pdbc->dbc->c_close(pdbc->dbc);
 923         pdbc->dbc = NULL;
 924         pdbc->parent_txn = NULL;
 925     }
 926     return ret;
 927 }
 928
 929 /* }}} */
 930
 931 /* {{{ DB4Txn method definitions
 932  */
 933
 934 /* {{{ proto bool Db4Txn::abort()
 935  */
 936 ZEND_NAMED_FUNCTION(_wrap_db_txn_abort)
 937 {
 938     struct php_DB_TXN *ptxn;
 939     zval *self;
 940     int ret;
 941
 942     if(ZEND_NUM_ARGS()) {
 943         WRONG_PARAM_COUNT;
 944     }
 945     self = getThis();
 946     getPhpDbTxnFromThis(ptxn);
 947     closeDbTxnDependencies(self TSRMLS_CC);
 948     if((ret = ptxn->db_txn->abort(ptxn->db_txn)) != 0) {
 949         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
 950         RETURN_FALSE;
 951     }
 952     ptxn->db_txn = NULL;
 953     RETURN_TRUE;
 954 }
 955 /* }}} */
 956
 957 /* {{{ proto bool Db4Txn::commit()
 958  */
 959 ZEND_NAMED_FUNCTION(_wrap_db_txn_commit)
 960 {
 961     struct php_DB_TXN *ptxn;
 962     u_int32_t flags = 0;
 963     int ret;
 964     zval *self;
 965
 966     self = getThis();
 967     getPhpDbTxnFromThis(ptxn);
 968     closeDbTxnDependencies(self TSRMLS_CC);
 969     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE)
 970     {
 971         return;
 972     }
 973     if((ret = ptxn->db_txn->commit(ptxn->db_txn, flags)) != 0) {
 974         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
 975         RETURN_FALSE;
 976     }
 977     ptxn->db_txn = NULL;
 978     RETURN_TRUE;
 979 }
 980 /* }}} */
 981
 982 /* {{{ proto bool Db4Txn::discard()
 983  */
 984 ZEND_NAMED_FUNCTION(_wrap_db_txn_discard)
 985 {
 986     struct php_DB_TXN *ptxn;
 987     int ret;
 988     zval *self;
 989
 990     self = getThis();
 991     getPhpDbTxnFromThis(ptxn);
 992     closeDbTxnDependencies(self TSRMLS_CC);
 993     if(ZEND_NUM_ARGS()) WRONG_PARAM_COUNT;
 994     if((ret = ptxn->db_txn->discard(ptxn->db_txn, 0)) != 0) {
 995         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
 996         RETURN_FALSE;
 997     }
 998     ptxn->db_txn = NULL;
 999     /* FIXME should destroy $self */
1000     RETURN_TRUE;
1001 }
1002 /* }}} */
1003
1004 /* {{{ proto long Db4Txn::id()
1005  */
1006 ZEND_NAMED_FUNCTION(_wrap_db_txn_id)
1007 {
1008     DB_TXN *txn;
1009
1010     getDbTxnFromThis(txn);
1011     if(ZEND_NUM_ARGS()) WRONG_PARAM_COUNT;
1012     RETURN_LONG(txn->id(txn));
1013 }
1014 /* }}} */
1015
1016 /* {{{ proto bool Db4Txn::set_timeout(long $timeout [, long $flags])
1017  */
1018 ZEND_NAMED_FUNCTION(_wrap_db_txn_set_timeout)
1019 {
1020     DB_TXN *txn;
1021     u_int32_t flags = 0;
1022     long timeout;
1023     int ret;
1024
1025     getDbTxnFromThis(txn);
1026     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &timeout, &flags) == FAILURE)
1027     {
1028         return;
1029     }
1030     if((ret = txn->set_timeout(txn, timeout, flags)) != 0) {
1031         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1032         RETURN_FALSE;
1033     }
1034     RETURN_TRUE;
1035 }
1036 /* }}} */
1037
1038 /* {{{ proto bool Db4Txn::set_name(string $name)
1039  */
1040 ZEND_NAMED_FUNCTION(_wrap_db_txn_set_name)
1041 {
1042     DB_TXN *txn;
1043     char *name;
1044     int name_len;
1045
1046     getDbTxnFromThis(txn);
1047     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE)
1048     {
1049         return;
1050     }
1051     txn->set_name(txn, name);
1052     RETURN_TRUE;
1053 }
1054 /* }}} */
1055
1056 /* {{{ proto bool Db4Txn::get_name()
1057  */
1058 ZEND_NAMED_FUNCTION(_wrap_db_txn_get_name)
1059 {
1060     DB_TXN *txn;
1061     const char *name;
1062     int ret;
1063
1064     getDbTxnFromThis(txn);
1065     if(ZEND_NUM_ARGS())
1066     {
1067                 WRONG_PARAM_COUNT;
1068     }
1069     if((ret = txn->get_name(txn, &name)) != 0) {
1070         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1071         RETURN_FALSE;
1072     }
1073     RETURN_STRING((char *)name, 1);
1074 }
1075 /* }}} */
1076
1077 /* {{{ private Db4Txn::Db4Txn()
1078  */
1079 ZEND_NAMED_FUNCTION(_wrap_new_DbTxn)
1080 {
1081     php_error_docref(NULL TSRMLS_CC, E_ERROR, "DB4Txn objects must be created with Db4Env::begin_txn()");
1082 }
1083 /* }}} */
1084
1085 /* }}} */
1086
1087
1088 /* {{{ DB4 method definitions
1089  */
1090
1091 /* {{{ proto object DB4::DB4([object $dbenv])
1092  */
1093 ZEND_NAMED_FUNCTION(_wrap_new_db4)
1094 {
1095     DB *db;
1096     DB_ENV *dbenv = NULL;
1097     zval *dbenv_obj = NULL;
1098     zval *self;
1099     int ret;
1100
1101     self = getThis();
1102     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O",
1103                              &dbenv_obj, db_env_ce) == FAILURE)
1104     {
1105         return;
1106     }
1107     if(dbenv_obj) {
1108         dbenv = php_db4_getDbEnvFromObj(dbenv_obj TSRMLS_CC);
1109         zval_add_ref(&dbenv_obj);
1110         add_property_zval(self, "dbenv", dbenv_obj);
1111     }
1112     if((ret = my_db_create(&db, dbenv, 0)) != 0) {
1113         php_error_docref(NULL TSRMLS_CC,
1114                          E_WARNING, "error occurred during open");
1115         RETURN_FALSE;
1116     }
1117     setDb(self, db TSRMLS_CC);
1118 }
1119 /* }}} */
1120
1121 /* {{{ proto bool DB4::open([object $txn [, string $file [, string $database [, long $flags [, long $mode]]]]])
1122  */
1123 ZEND_NAMED_FUNCTION(_wrap_db_open)
1124 {
1125     DB *db = NULL;
1126     DB_TXN *dbtxn = NULL;
1127     zval *dbtxn_obj = NULL;
1128     char *file = NULL, *database = NULL;
1129     long filelen = 0, databaselen = 0;
1130     DBTYPE type = DB_BTREE;
1131     u_int32_t flags = DB_CREATE;
1132     int mode = 0;
1133     int ret;
1134
1135     zval *self;
1136     self = getThis();
1137     getDbFromThis(db);
1138
1139     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!sslll",
1140                              &dbtxn_obj, db_txn_ce,
1141                              &file, &filelen,
1142                              &database, &databaselen,
1143                              &type, &flags, &mode) == FAILURE)
1144     {
1145         return;
1146     }
1147     if(dbtxn_obj) {
1148         dbtxn = php_db4_getDbTxnFromObj(dbtxn_obj TSRMLS_CC);
1149     }
1150     add_property_string(self, "file", file, 1);
1151     add_property_string(self, "database", database, 1);
1152     if(strcmp(file, "") == 0) file = NULL;
1153     if(strcmp(database, "") == 0) database = NULL;
1154     /* add type and other introspection data */
1155     if((ret = db->open(db, dbtxn, file, database, type, flags, mode)) == 0) {
1156         RETURN_TRUE;
1157     }
1158     else {
1159         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1160         add_property_string(self, "lastError", db_strerror(ret), 1);
1161         RETURN_FALSE;
1162     }
1163 }
1164 /* }}} */
1165
1166 /* {{{ proto bool DB4::close()
1167  */
1168 ZEND_NAMED_FUNCTION(_wrap_db_close)
1169 {
1170     struct php_DB *pdb = NULL;
1171     getPhpDbFromThis(pdb);
1172
1173     if(ZEND_NUM_ARGS()) {
1174         WRONG_PARAM_COUNT;
1175     }
1176         if(pdb && pdb->db) {
1177       pdb->db->close(pdb->db, 0);
1178           pdb->db = NULL;
1179         }
1180     RETURN_TRUE;
1181 }
1182 /* }}} */
1183
1184 /* {{{ proto bool DB4::del(string $key [, object $txn])
1185  */
1186 ZEND_NAMED_FUNCTION(_wrap_db_del)
1187 {
1188     DB *db = NULL;
1189     DB_TXN *txn = NULL;
1190     zval *txn_obj = NULL;
1191     u_int32_t flags;
1192     DBT key;
1193     char *keyname;
1194     int keylen;
1195
1196     getDbFromThis(db);
1197     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|O", &keyname, &keylen,
1198                              &txn_obj, db_txn_ce) == FAILURE)
1199     {
1200         return;
1201     }
1202     if(txn_obj) {
1203         getDbTxnFromThis(txn);
1204         flags = 0;
1205     }
1206     memset(&key, 0, sizeof(DBT));
1207     key.data = keyname;
1208     key.size = keylen;
1209     RETURN_LONG(db->del(db, txn, &key, flags));
1210 }
1211 /* }}} */
1212
1213 /* {{{ proto string DB4::get(string $key [,object $txn [, long flags]])
1214  */
1215 ZEND_NAMED_FUNCTION(_wrap_db_get)
1216 {
1217     DB *db = NULL;
1218     DB_TXN *txn = NULL;
1219     zval *txn_obj = NULL;
1220     DBT key, value;
1221     char *keyname;
1222     int keylen;
1223     u_int32_t flags = 0;
1224
1225     getDbFromThis(db);
1226     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|Ol", &keyname, &keylen,
1227                              &txn_obj, db_txn_ce, &flags) == FAILURE)
1228     {
1229         return;
1230     }
1231     if(txn_obj) {
1232         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1233     }
1234     memset(&key, 0, sizeof(DBT));
1235     key.data = keyname;
1236     key.size = keylen;
1237     memset(&value, 0, sizeof(DBT));
1238     if(db->get(db, txn, &key, &value, flags) == 0) {
1239         RETURN_STRINGL((char *)value.data, value.size, 1);
1240     }
1241     RETURN_FALSE;
1242 }
1243 /* }}} */
1244
1245 /* {{{ proto string DB4::pget(string $key, string &$pkey [,object $txn [, long flags]])
1246  */
1247 ZEND_NAMED_FUNCTION(_wrap_db_pget)
1248 {
1249     DB *db = NULL;
1250     DB_TXN *txn = NULL;
1251     zval *txn_obj = NULL;
1252     DBT key, value, pkey;
1253     char *keyname;
1254     int keylen;
1255     zval *z_pkey;
1256     u_int32_t flags = 0;
1257
1258     getDbFromThis(db);
1259     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|Ol",
1260                              &keyname, &keylen, &z_pkey,
1261                              &txn_obj, db_txn_ce, &flags) == FAILURE)
1262     {
1263         return;
1264     }
1265     if(txn_obj) {
1266         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1267     }
1268     memset(&key, 0, sizeof(DBT));
1269     key.data = keyname;
1270     key.size = keylen;
1271     memset(&pkey, 0, sizeof(DBT));
1272     memset(&value, 0, sizeof(DBT));
1273     if(db->pget(db, txn, &key, &pkey, &value, flags) == 0) {
1274         if(Z_STRLEN_P(z_pkey) == 0) {
1275             Z_STRVAL_P(z_pkey) = (char *) emalloc(pkey.size);
1276         } else {
1277             Z_STRVAL_P(z_pkey) = (char *) erealloc(Z_STRVAL_P(z_pkey), pkey.size);
1278         }
1279         memcpy(Z_STRVAL_P(z_pkey), pkey.data, pkey.size);
1280         Z_STRLEN_P(z_pkey) = pkey.size;
1281         RETURN_STRINGL((char *)value.data, value.size, 1);
1282     }
1283     RETURN_FALSE;
1284 }
1285 /* }}} */
1286
1287 /* {{{ proto string DB4::get_type()
1288  */
1289 ZEND_NAMED_FUNCTION(_wrap_db_get_type)
1290 {
1291     DB *db = NULL;
1292     DBTYPE type;
1293
1294     getDbFromThis(db);
1295     if(db->get_type(db, &type)) {
1296         RETURN_FALSE;
1297     }
1298     switch(type) {
1299         case DB_BTREE:
1300             RETURN_STRING("DB_BTREE", 1);
1301             break;
1302         case DB_HASH:
1303             RETURN_STRING("DB_HASH", 1);
1304             break;
1305         case DB_RECNO:
1306             RETURN_STRING("DB_RECNO", 1);
1307             break;
1308         case DB_QUEUE:
1309             RETURN_STRING("DB_QUEUE", 1);
1310             break;
1311         default:
1312             RETURN_STRING("UNKNOWN", 1);
1313             break;
1314     }
1315 }
1316 /* }}} */
1317
1318 /* {{{ proto bool DB4::set_encrypt(string $password [, long $flags])
1319  */
1320 ZEND_NAMED_FUNCTION(_wrap_db_set_encrypt)
1321 {
1322     DB *db = NULL;
1323     char *pass;
1324     long passlen;
1325         u_int32_t flags = 0;
1326     getDbFromThis(db);
1327     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &pass, &passlen,
1328                                                          &flags) == FAILURE)
1329     {
1330         return;
1331     }
1332     RETURN_BOOL(db->set_encrypt(db, pass, flags)?0:1);
1333 }
1334 /* }}} */
1335
1336 /* {{{ proto int DB4::get_encrypt_flags()
1337  */
1338 ZEND_NAMED_FUNCTION(_wrap_db_get_encrypt_flags)
1339 {
1340     DB *db = NULL;
1341
1342     getDbFromThis(db);
1343         u_int32_t flags = 0;
1344         if (db->get_encrypt_flags(db, &flags) != 0)
1345                         RETURN_FALSE;
1346         RETURN_LONG(flags);
1347 }
1348 /* }}} */
1349
1350 /* {{{ proto array DB4::stat([object $txn [, long flags]])
1351  */
1352 ZEND_NAMED_FUNCTION(_wrap_db_stat)
1353 {
1354     DB *db = NULL;
1355     DB_TXN *txn = NULL;
1356     zval *txn_obj = NULL;
1357     DBTYPE type;
1358     u_int32_t flags = 0;
1359
1360     getDbFromThis(db);
1361     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zl", &txn_obj, db_txn_ce, &flags) == FAILURE) {
1362         return;
1363     }
1364     if(db->get_type(db, &type)) {
1365         RETURN_FALSE;
1366     }
1367     if(txn_obj) {
1368         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1369         }
1370     switch(type) {
1371 #define ADD_STAT_LONG(a)  add_assoc_long(return_value, #a, sb.a)
1372         case DB_HASH:
1373         {
1374             DB_HASH_STAT sb;
1375             if(db->stat(db, txn, (void *)&sb, flags)) {
1376                 RETURN_FALSE;
1377             }
1378             array_init(return_value);
1379             if(flags & DB_FAST_STAT) {
1380                 ADD_STAT_LONG(hash_magic);
1381                 ADD_STAT_LONG(hash_version);
1382                 ADD_STAT_LONG(hash_nkeys);
1383                 ADD_STAT_LONG(hash_ndata);
1384                 ADD_STAT_LONG(hash_pagesize);
1385                 ADD_STAT_LONG(hash_ffactor);
1386                 ADD_STAT_LONG(hash_buckets);
1387             }
1388             ADD_STAT_LONG(hash_free);
1389             ADD_STAT_LONG(hash_bfree);
1390             ADD_STAT_LONG(hash_bigpages);
1391             ADD_STAT_LONG(hash_bfree);
1392             ADD_STAT_LONG(hash_overflows);
1393             ADD_STAT_LONG(hash_ovfl_free);
1394             ADD_STAT_LONG(hash_dup);
1395             ADD_STAT_LONG(hash_dup_free);
1396         }
1397             break;
1398         case DB_BTREE:
1399         case DB_RECNO:
1400         {
1401             DB_BTREE_STAT sb;
1402             if(db->stat(db, txn, (void *)&sb, flags)) {
1403                 RETURN_FALSE;
1404             }
1405             array_init(return_value);
1406             if(flags & DB_FAST_STAT) {
1407                 ADD_STAT_LONG(bt_magic);
1408                 ADD_STAT_LONG(bt_version);
1409                 ADD_STAT_LONG(bt_nkeys);
1410                 ADD_STAT_LONG(bt_ndata);
1411                 ADD_STAT_LONG(bt_pagesize);
1412                 ADD_STAT_LONG(bt_minkey);
1413                 ADD_STAT_LONG(bt_re_len);
1414                 ADD_STAT_LONG(bt_re_pad);
1415             }
1416             ADD_STAT_LONG(bt_levels);
1417             ADD_STAT_LONG(bt_int_pg);
1418             ADD_STAT_LONG(bt_leaf_pg);
1419             ADD_STAT_LONG(bt_dup_pg);
1420             ADD_STAT_LONG(bt_over_pg);
1421             ADD_STAT_LONG(bt_free);
1422             ADD_STAT_LONG(bt_int_pgfree);
1423             ADD_STAT_LONG(bt_leaf_pgfree);
1424             ADD_STAT_LONG(bt_dup_pgfree);
1425             ADD_STAT_LONG(bt_over_pgfree);
1426         }
1427             break;
1428         case DB_QUEUE:
1429         {
1430             DB_QUEUE_STAT sb;
1431             if(db->stat(db, txn, (void *)&sb, flags)) {
1432                 RETURN_FALSE;
1433             }
1434             array_init(return_value);
1435             if(flags & DB_FAST_STAT) {
1436                 ADD_STAT_LONG(qs_magic);
1437                 ADD_STAT_LONG(qs_version);
1438                 ADD_STAT_LONG(qs_nkeys);
1439                 ADD_STAT_LONG(qs_ndata);
1440                 ADD_STAT_LONG(qs_pagesize);
1441                 ADD_STAT_LONG(qs_extentsize);
1442                 ADD_STAT_LONG(qs_re_len);
1443                 ADD_STAT_LONG(qs_re_pad);
1444                 ADD_STAT_LONG(qs_first_recno);
1445                 ADD_STAT_LONG(qs_cur_recno);
1446             }
1447             ADD_STAT_LONG(qs_pages);
1448             ADD_STAT_LONG(qs_pgfree);
1449             break;
1450         }
1451         default:
1452             RETURN_FALSE;
1453     }
1454 }
1455 /* }}} */
1456
1457 /* {{{ proto DBCursor DB4::join(array $curslist [, long $flags])
1458  */
1459 ZEND_NAMED_FUNCTION(_wrap_db_join)
1460 {
1461     DB *db = NULL;
1462     DBC *dbcp;
1463     DBC **curslist;
1464     zval *z_array;
1465     HashTable *array;
1466     HashPosition pos;
1467     zval **z_cursor;
1468     int num_cursors, rv, i;
1469
1470     u_int32_t flags = 0;
1471
1472     getDbFromThis(db);
1473     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l",
1474                              &z_array, &flags) == FAILURE)
1475     {
1476         return;
1477     }
1478     array = HASH_OF(z_array);
1479     num_cursors = zend_hash_num_elements(array);
1480     curslist = (DBC **) calloc(sizeof(DBC *), num_cursors + 1);
1481     for(zend_hash_internal_pointer_reset_ex(array, &pos), i=0;
1482         zend_hash_get_current_data_ex(array, (void **) &z_cursor, &pos) == SUCCESS;
1483         zend_hash_move_forward_ex(array, &pos), i++) {
1484         curslist[i] = php_db4_getDbcFromObj(*z_cursor TSRMLS_CC);
1485     }
1486     rv = db->join(db, curslist, &dbcp, flags);
1487     free(curslist);
1488     if(rv) {
1489         RETURN_FALSE;
1490     } else {
1491         object_init_ex(return_value, dbc_ce);
1492         setDbc(return_value, dbcp, NULL TSRMLS_CC);
1493     }
1494 }
1495 /* }}} */
1496
1497 /* {{{ proto bool DB4::put(string $key, string $value [, object $txn [, long flags]])
1498  */
1499 ZEND_NAMED_FUNCTION(_wrap_db_put)
1500 {
1501     DB *db = NULL;
1502     DB_TXN *txn = NULL;
1503     zval *txn_obj = NULL;
1504     DBT key, value;
1505     char *keyname, *dataname;
1506     int keylen, datalen;
1507     int ret;
1508     zval *self;
1509     long flags = 0;
1510
1511     self = getThis();
1512     getDbFromThis(db);
1513     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|Ol", &keyname, &keylen,
1514                              &dataname, &datalen, &txn_obj, db_txn_ce, &flags) == FAILURE)
1515     {
1516         return;
1517     }
1518     if(txn_obj) {
1519         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1520     }
1521     memset(&key, 0, sizeof(DBT));
1522     key.data = keyname;
1523     key.size = keylen;
1524     memset(&value, 0, sizeof(DBT));
1525     value.data = dataname;
1526     value.size = datalen;
1527     if((ret = db->put(db, txn, &key, &value, flags)) != 0) {
1528         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1529         add_property_string(self, "lastError", db_strerror(ret), 1);
1530         RETURN_FALSE;
1531     }
1532     RETURN_TRUE;
1533 }
1534 /* }}} */
1535
1536 /* {{{ proto bool DB4::sync()
1537  */
1538 ZEND_NAMED_FUNCTION(_wrap_db_sync)
1539 {
1540     DB *db = NULL;
1541     getDbFromThis(db);
1542     if(ZEND_NUM_ARGS()) {
1543         WRONG_PARAM_COUNT;
1544     }
1545     db->sync(db, 0);
1546     RETURN_TRUE;
1547 }
1548 /* }}} */
1549
1550 /* {{{ proto bool DB4::truncate([object $txn [, long $flags]])
1551  */
1552 ZEND_NAMED_FUNCTION(_wrap_db_truncate)
1553 {
1554     DB *db = NULL;
1555     DB_TXN *txn = NULL;
1556     zval *txn_obj = NULL;
1557     long flags = DB_AUTO_COMMIT;
1558     u_int32_t countp;
1559
1560     getDbFromThis(db);
1561     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Ol",
1562                              &txn_obj, db_txn_ce, &flags) == FAILURE)
1563     {
1564         return;
1565     }
1566     if(txn_obj) {
1567         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1568         flags = 0;
1569     }
1570     if(db->truncate(db, txn, &countp, flags) == 0) {
1571         RETURN_LONG(countp);
1572     }
1573     RETURN_FALSE;
1574 }
1575 /* }}} */
1576
1577 /* {{{ proto DB4Cursor DB4::cursor([object $txn [, long flags]])
1578  */
1579 ZEND_NAMED_FUNCTION(_wrap_db_cursor)
1580 {
1581     DB *db;
1582     DB_TXN *txn = NULL;
1583     zval *txn_obj = NULL, *self;
1584     DBC *cursor = NULL;
1585     u_int32_t flags = 0;
1586     int ret;
1587
1588     self = getThis();
1589     getDbFromThis(db);
1590     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Ol", &txn_obj, db_txn_ce, &flags) == FAILURE)
1591     {
1592         return;
1593     }
1594     if(txn_obj) {
1595         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1596     }
1597     if((ret = db->cursor(db, txn, &cursor, flags)) != 0 ) {
1598         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1599         add_property_string(self, "lastError", db_strerror(ret), 1);
1600         RETURN_FALSE;
1601     }
1602     else {
1603         object_init_ex(return_value, dbc_ce);
1604         setDbc(return_value, cursor, txn_obj?getPhpDbTxnFromObj(txn_obj TSRMLS_CC):NULL TSRMLS_CC);
1605     }
1606
1607 }
1608 /* }}} */
1609
1610 /* }}} end DB4 method definitions */
1611
1612 /* {{{ DB4Cursor method definitions
1613  */
1614
1615 /* {{{ proto bool Db4Cursor::close()
1616  */
1617 ZEND_NAMED_FUNCTION(_wrap_dbc_close)
1618 {
1619     DBC *dbc;
1620     int ret;
1621     zval *self;
1622
1623     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) return;
1624     self = getThis();
1625     getDbcFromThis(dbc);
1626     if((ret = closeDbc(self TSRMLS_CC)) != 0) {
1627         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1628         RETURN_FALSE;
1629     }
1630     RETURN_TRUE;
1631 }
1632 /* }}} */
1633
1634 /* {{{ proto long Db4Cursor::count()
1635  */
1636 ZEND_NAMED_FUNCTION(_wrap_dbc_count)
1637 {
1638     DBC *dbc;
1639     db_recno_t count;
1640     int ret;
1641
1642     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) return;
1643     getDbcFromThis(dbc);
1644     if((ret = dbc->c_count(dbc, &count, 0)) != 0) {
1645         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1646         RETURN_FALSE;
1647     }
1648     RETURN_LONG(count);
1649 }
1650 /* }}} */
1651
1652 /* {{{ proto bool Db4Cursor::del()
1653  */
1654 ZEND_NAMED_FUNCTION(_wrap_dbc_del)
1655 {
1656     DBC *dbc;
1657     int ret;
1658
1659     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) return;
1660     getDbcFromThis(dbc);
1661     if((ret = dbc->c_del(dbc, 0)) != 0) {
1662         if(ret != DB_KEYEMPTY) {
1663             php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1664         }
1665         RETURN_FALSE;
1666     }
1667     RETURN_TRUE;
1668 }
1669 /* }}} */
1670
1671 /* {{{ proto object Db4Cursor::dup([long $flags])
1672  */
1673 ZEND_NAMED_FUNCTION(_wrap_dbc_dup)
1674 {
1675     DBC *dbc, *newdbc;
1676     u_int32_t flags = 0;
1677     int ret;
1678
1679     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE) return;
1680     getDbcFromThis(dbc);
1681     if((ret = dbc->c_dup(dbc, &newdbc, flags)) != 0) {
1682         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1683         RETURN_FALSE;
1684     }
1685     object_init_ex(return_value, dbc_ce);
1686     /* FIXME should pass in dbc's parent txn */
1687     setDbc(return_value, newdbc, NULL TSRMLS_CC);
1688 }
1689 /* }}} */
1690
1691 /* {{{ proto string Db4Cursor::get(string &$key, string &$data [, long $flags])
1692  */
1693 ZEND_NAMED_FUNCTION(_wrap_dbc_get)
1694 {
1695     DBC *dbc;
1696     DBT key, value;
1697     zval *zkey, *zvalue;
1698     u_int32_t flags = DB_NEXT;
1699     zval *self;
1700     int ret;
1701
1702     self = getThis();
1703     getDbcFromThis(dbc);
1704     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/z/|l", &zkey, &zvalue, &flags) == FAILURE)
1705     {
1706         return;
1707     }
1708     memset(&key, 0, sizeof(DBT));
1709         key.data = Z_STRVAL_P(zkey);
1710         key.size = Z_STRLEN_P(zkey);
1711     memset(&value, 0, sizeof(DBT));
1712         value.data = Z_STRVAL_P(zvalue);
1713         value.size = Z_STRLEN_P(zvalue);
1714     if((ret = dbc->c_get(dbc, &key, &value, flags)) == 0) {
1715                 zval_dtor(zkey); ZVAL_STRINGL(zkey, (char *) key.data, key.size, 1);
1716                 zval_dtor(zvalue); ZVAL_STRINGL(zvalue, (char *) value.data, value.size, 1);
1717                 RETURN_LONG(0);
1718     }
1719         if(ret != DB_NOTFOUND) {
1720         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1721         add_property_string(self, "lastError", db_strerror(ret), 1);
1722     }
1723     RETURN_LONG(1);
1724 }
1725 /* }}} */
1726
1727 /* {{{ proto string Db4Cursor::pget(string &$key, string &$pkey, string &$data [, long $flags])
1728  */
1729 ZEND_NAMED_FUNCTION(_wrap_dbc_pget)
1730 {
1731     DBC *dbc;
1732     DBT key, pkey, value;
1733     zval *zkey, *zvalue, *zpkey;
1734     u_int32_t flags = DB_NEXT;
1735     zval *self;
1736     int ret;
1737
1738     self = getThis();
1739     getDbcFromThis(dbc);
1740     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/z/z/|l", &zkey, &zpkey, &zvalue, &flags) == FAILURE)
1741     {
1742         return;
1743     }
1744     memset(&key, 0, sizeof(DBT));
1745         key.data = Z_STRVAL_P(zkey);
1746         key.size = Z_STRLEN_P(zkey);
1747     memset(&pkey, 0, sizeof(DBT));
1748         pkey.data = Z_STRVAL_P(zpkey);
1749         pkey.size = Z_STRLEN_P(zpkey);
1750     memset(&value, 0, sizeof(DBT));
1751         value.data = Z_STRVAL_P(zvalue);
1752         value.size = Z_STRLEN_P(zvalue);
1753     if((ret = dbc->c_pget(dbc, &key, &pkey, &value, flags)) == 0) {
1754                 zval_dtor(zkey); ZVAL_STRINGL(zkey, (char *) key.data, key.size, 1);
1755                 zval_dtor(zpkey); ZVAL_STRINGL(zpkey, (char *) pkey.data, pkey.size, 1);
1756                 zval_dtor(zvalue); ZVAL_STRINGL(zvalue, (char *) value.data, value.size, 1);
1757                 RETURN_LONG(0);
1758     }
1759         if(ret != DB_NOTFOUND) {
1760         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1761         add_property_string(self, "lastError", db_strerror(ret), 1);
1762     }
1763     RETURN_LONG(1);
1764 }
1765 /* }}} */
1766
1767 /* {{{ proto bool Db4Cursor::put(string $key, string $data [, long $flags])
1768  */
1769 ZEND_NAMED_FUNCTION(_wrap_dbc_put)
1770 {
1771     DBC *dbc;
1772     DBT key, value;
1773     char *keyname, *dataname;
1774     int keylen, datalen;
1775     u_int32_t flags = 0;
1776     int ret;
1777
1778     getDbcFromThis(dbc);
1779     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &keyname, &keylen,
1780           &dataname, &datalen, &flags) == FAILURE)
1781     {
1782         return;
1783     }
1784     memset(&key, 0, sizeof(DBT));
1785     key.data = keyname;
1786     key.size = keylen;
1787     memset(&value, 0, sizeof(DBT));
1788     value.data = dataname;
1789     value.size = datalen;
1790     if((ret = dbc->c_put(dbc, &key, &value, flags)) == 0) {
1791         RETURN_TRUE;
1792     }
1793     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
1794     RETURN_FALSE;
1795
1796 }
1797 /* }}} */
1798
1799 /* }}} */
1800
1801 /* {{{ DB4Env method definitions
1802  */
1803
1804 /* {{{ php_db4_error ( zend_error wrapper )
1805  */
1806
1807 void php_db4_error(const DB_ENV *dp, const char *errpfx, const char *msg)
1808 {
1809         TSRMLS_FETCH();
1810     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s %s\n", errpfx, msg);
1811 }
1812 /* }}} */
1813
1814 /* {{{ proto object DB4Env::Db4Env([long $flags])
1815  */
1816 ZEND_NAMED_FUNCTION(_wrap_new_DbEnv)
1817 {
1818     DB_ENV *dbenv;
1819     u_int32_t flags = 0;
1820
1821     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE)
1822     {
1823         return;
1824     }
1825     if(my_db_env_create(&dbenv, flags) != 0) {
1826         php_error_docref(NULL TSRMLS_CC, E_WARNING, "bad things here: %s:%d\n", __FILE__, __LINE__);
1827         RETURN_FALSE;
1828     }
1829 #ifndef HAVE_MOD_DB4
1830         DbEnv::wrap_DB_ENV(dbenv);
1831 #endif
1832     dbenv->set_errcall(dbenv, php_db4_error);
1833     setDbEnv(this_ptr, dbenv TSRMLS_CC);
1834 }
1835 /* }}} */
1836
1837 /* {{{ proto bool DB4Env::close([long $flags])
1838  */
1839 ZEND_NAMED_FUNCTION(_wrap_db_env_close)
1840 {
1841     struct php_DB_ENV *pdb;
1842     DbEnv *dbe;
1843     u_int32_t flags = 0;
1844
1845     pdb = php_db4_getPhpDbEnvFromObj(getThis() TSRMLS_CC);
1846     if(!pdb || !pdb->dbenv) {
1847       RETURN_FALSE;
1848     }
1849     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE) {
1850         RETURN_FALSE;
1851     }
1852     dbe = DbEnv::get_DbEnv(pdb->dbenv);
1853     dbe->close(flags);
1854     pdb->dbenv = NULL;
1855     RETURN_TRUE;
1856 }
1857 /* }}} */
1858
1859 /* {{{ proto bool DB4Env::dbremove(object $txn, string $file [, string $database [, long flags]])
1860  */
1861 ZEND_NAMED_FUNCTION(_wrap_db_env_dbremove)
1862 {
1863     DB_ENV *dbenv;
1864     DB_TXN *txn;
1865     zval *txn_obj;
1866     char *filename=NULL, *database=NULL;
1867     int filenamelen, databaselen;
1868     u_int32_t flags = 0;
1869
1870     getDbEnvFromThis(dbenv);
1871     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O!s|sl", &txn_obj, db_txn_ce,
1872          &filename, &filenamelen, &database, &databaselen, &flags) == FAILURE)
1873     {
1874         return;
1875     }
1876     if(txn_obj) {
1877         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1878         flags = 0;
1879     }
1880     if(dbenv->dbremove(dbenv, txn, filename, database, flags) == 0) {
1881         RETURN_TRUE;
1882     }
1883     RETURN_FALSE;
1884 }
1885 /* }}} */
1886
1887 /* {{{ proto bool DB4Env::dbrename(object $txn, string $file, string $database, string $newdatabase [, long flags])
1888  */
1889 ZEND_NAMED_FUNCTION(_wrap_db_env_dbrename)
1890 {
1891     DB_ENV *dbenv;
1892     DB_TXN *txn;
1893     zval *txn_obj;
1894     char *filename=NULL, *database=NULL, *newname=NULL;
1895     int filenamelen, databaselen, newnamelen;
1896     u_int32_t flags = 0;
1897
1898     getDbEnvFromThis(dbenv);
1899     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O!sss|l", &txn_obj, db_txn_ce,
1900          &filename, &filenamelen, &database, &databaselen,
1901          &newname, &newnamelen, &flags) == FAILURE)
1902     {
1903         return;
1904     }
1905     if(txn_obj) {
1906         txn = php_db4_getDbTxnFromObj(txn_obj TSRMLS_CC);
1907         flags = 0;
1908     }
1909     if(dbenv->dbrename(dbenv, txn, filename, database, newname, flags) == 0) {
1910         RETURN_TRUE;
1911     }
1912     RETURN_FALSE;
1913 }
1914 /* }}} */
1915
1916 /* {{{ proto bool DB4Env::open(string $home [, long flags [, long mode]])
1917  */
1918 ZEND_NAMED_FUNCTION(_wrap_db_env_open)
1919 {
1920     DB_ENV *dbenv;
1921     zval *self;
1922     char *home = NULL;
1923     long  homelen;
1924     u_int32_t flags = DB_CREATE  | DB_INIT_LOCK | DB_INIT_LOG | \
1925             DB_INIT_MPOOL | DB_INIT_TXN ;
1926     int mode = 0666;
1927     int ret;
1928
1929     getDbEnvFromThis(dbenv);
1930     self = getThis();
1931     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!ll", &home, &homelen,
1932         &flags, &mode) == FAILURE)
1933     {
1934         return;
1935     }
1936     if((ret = dbenv->open(dbenv, home, flags, mode) != 0)) {
1937         php_error_docref(NULL TSRMLS_CC, E_WARNING, "open(%s, %d, %o) failed: %s (%d) %s:%d\n", home, flags, mode, strerror(ret), ret, __FILE__, __LINE__);
1938         RETURN_FALSE;
1939     }
1940         if(home) add_property_stringl(self, "home", home, homelen, 1);
1941 }
1942 /* }}} */
1943
1944 /* {{{ proto bool DB4Env::remove(string $home [, long flags])
1945  */
1946 ZEND_NAMED_FUNCTION(_wrap_db_env_remove)
1947 {
1948     DB_ENV *dbenv;
1949         DbEnv *dbe;
1950     zval *self;
1951     char *home;
1952     long homelen;
1953     u_int32_t flags = 0;
1954     self = getThis();
1955     getDbEnvFromThis(dbenv);
1956         dbe = DbEnv::get_DbEnv(dbenv);
1957     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &home, &homelen, &flags) == FAILURE)
1958     {
1959         return;
1960     }
1961     RETURN_BOOL(dbe->remove(home, flags)?0:1);
1962 }
1963 /* }}} */
1964
1965 /* {{{ proto bool DB4Env::set_data_dir(string $dir)
1966  */
1967 ZEND_NAMED_FUNCTION(_wrap_db_env_set_data_dir)
1968 {
1969     DB_ENV *dbenv;
1970     zval *self;
1971     char *dir;
1972     long dirlen;
1973     self = getThis();
1974     getDbEnvFromThis(dbenv);
1975     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &dir, &dirlen) == FAILURE)
1976     {
1977         return;
1978     }
1979     RETURN_BOOL(dbenv->set_data_dir(dbenv, dir)?0:1);
1980 }
1981 /* }}} */
1982
1983 /* {{{ proto bool DB4Env::set_encrypt(string $password [, long $flags])
1984  */
1985 ZEND_NAMED_FUNCTION(_wrap_db_env_set_encrypt)
1986 {
1987     DB_ENV *dbenv;
1988     zval *self;
1989     char *pass;
1990     long passlen;
1991         u_int32_t flags = 0;
1992     self = getThis();
1993     getDbEnvFromThis(dbenv);
1994     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &pass, &passlen,
1995                                                          &flags) == FAILURE)
1996     {
1997         return;
1998     }
1999     RETURN_BOOL(dbenv->set_encrypt(dbenv, pass, flags)?0:1);
2000 }
2001 /* }}} */
2002
2003 /* {{{ proto int DB4Env::get_encrypt_flags()
2004  */
2005 ZEND_NAMED_FUNCTION(_wrap_db_env_get_encrypt_flags)
2006 {
2007     DB_ENV *dbenv;
2008     zval *self;
2009         u_int32_t flags = 0;
2010     self = getThis();
2011     getDbEnvFromThis(dbenv);
2012         if (dbenv->get_encrypt_flags(dbenv, &flags) != 0)
2013                         RETURN_FALSE;
2014         RETURN_LONG(flags);
2015 }
2016 /* }}} */
2017
2018 /* {{{ proto object Db4Env::txn_begin([object $parent_txn [, long $flags]])
2019  */
2020 ZEND_NAMED_FUNCTION(_wrap_db_env_txn_begin)
2021 {
2022     DB_ENV *dbenv;
2023     DB_TXN *txn, *parenttxn = NULL;
2024     zval *self;
2025     zval *cursor_array;
2026     zval *parenttxn_obj = NULL;
2027     u_int32_t flags = 0;
2028     int ret;
2029
2030     self = getThis();
2031     getDbEnvFromThis(dbenv);
2032     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Ol", &parenttxn_obj, db_txn_ce,
2033          &flags) == FAILURE)
2034     {
2035         return;
2036     }
2037     if(parenttxn_obj) {
2038         parenttxn = php_db4_getDbTxnFromObj(parenttxn_obj TSRMLS_CC);
2039     }
2040     if((ret = dbenv->txn_begin(dbenv, parenttxn, &txn, flags)) != 0) {
2041         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", db_strerror(ret));
2042         add_property_string(self, "lastError", db_strerror(ret), 1);
2043         RETURN_FALSE;
2044     }
2045     object_init_ex(return_value, db_txn_ce);
2046     MAKE_STD_ZVAL(cursor_array);
2047     array_init(cursor_array);
2048     add_property_zval(return_value, "openCursors", cursor_array);
2049     setDbTxn(return_value, txn TSRMLS_CC);
2050 }
2051 /* }}} */
2052
2053 /* {{{ Db4Env::txn_checkpoint(long $kbytes, long $minutes [, long $flags])
2054  */
2055 ZEND_NAMED_FUNCTION(_wrap_db_env_txn_checkpoint)
2056 {
2057     DB_ENV *dbenv;
2058     zval *self;
2059     u_int32_t kbytes = 0;
2060     u_int32_t mins = 0;
2061     u_int32_t flags = 0;
2062     int ret;
2063
2064     self = getThis();
2065     getDbEnvFromThis(dbenv);
2066     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll|l", &kbytes, &mins, &flags) == FAILURE)
2067     {
2068         return;
2069     }
2070     if((ret = dbenv->txn_checkpoint(dbenv, kbytes, mins, flags)) != 0) {
2071         add_property_string(self, "lastError", db_strerror(ret), 1);
2072         RETURN_FALSE;
2073     }
2074     RETURN_TRUE;
2075 }
2076 /* }}} */
2077
2078 /* }}} end db4env */
2079
2080 /*
2081  * Local variables:
2082  * tab-width: 4
2083   c-basic-offset: 4
2084  * End:
2085  * vim600: noet sw=4 ts=4 fdm=marker
2086  * vim<600: noet sw=4 ts=4
2087  */