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 16extern "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 38unsigned char second_arg_force_ref[] = { 2, BYREF_NONE, BYREF_FORCE }; 39unsigned 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 */ 43static int le_db; 44static int le_dbc; 45static int le_db_txn; 46static int le_dbenv; 47 48struct php_DB_TXN { 49 DB_TXN *db_txn; 50 struct my_llist *open_cursors; 51 struct my_llist *open_dbs; 52}; 53 54struct php_DBC { 55 DBC *dbc; 56 struct php_DB_TXN *parent_txn; 57 struct php_DB *parent_db; 58}; 59 60struct php_DB { 61 DB *db; 62 struct my_llist *open_cursors; 63}; 64 65struct php_DB_ENV { 66 DB_ENV *dbenv; 67}; 68 69static 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 80static 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 90static 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 100static 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 114static zend_class_entry *db_txn_ce; 115static zend_class_entry *dbc_ce; 116static zend_class_entry *db_ce; 117static zend_class_entry *db_env_ce; 118 119/* helpers */ 120struct my_llist { 121 void *data; 122 struct my_llist *next; 123 struct my_llist *prev; 124}; 125 126static 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 142static 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 */ 166function_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 172PHP_MINIT_FUNCTION(db4); 173PHP_MSHUTDOWN_FUNCTION(db4); 174PHP_RINIT_FUNCTION(db4); 175PHP_RSHUTDOWN_FUNCTION(db4); 176PHP_MINFO_FUNCTION(db4); 177 178/* {{{ db4_module_entry 179 */ 180zend_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 202zend_class_entry *db_txn_ce_get(void) 203{ 204 return db_txn_ce; 205} 206 207ZEND_NAMED_FUNCTION(_wrap_db_txn_abort); 208ZEND_NAMED_FUNCTION(_wrap_db_txn_commit); 209ZEND_NAMED_FUNCTION(_wrap_db_txn_discard); 210ZEND_NAMED_FUNCTION(_wrap_db_txn_id); 211ZEND_NAMED_FUNCTION(_wrap_db_txn_set_timeout); 212ZEND_NAMED_FUNCTION(_wrap_db_txn_set_name); 213ZEND_NAMED_FUNCTION(_wrap_db_txn_get_name); 214ZEND_NAMED_FUNCTION(_wrap_new_DbTxn); 215 216static 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 232zend_class_entry *dbc_ce_get(void) 233{ 234 return dbc_ce; 235} 236 237ZEND_NAMED_FUNCTION(_wrap_dbc_close); 238ZEND_NAMED_FUNCTION(_wrap_dbc_count); 239ZEND_NAMED_FUNCTION(_wrap_dbc_del); 240ZEND_NAMED_FUNCTION(_wrap_dbc_dup); 241ZEND_NAMED_FUNCTION(_wrap_dbc_get); 242ZEND_NAMED_FUNCTION(_wrap_dbc_put); 243ZEND_NAMED_FUNCTION(_wrap_dbc_pget); 244 245#ifdef ZEND_ENGINE_2 246ZEND_BEGIN_ARG_INFO(first_and_second_args_force_ref, 0) 247 ZEND_ARG_PASS_INFO(1) 248 ZEND_ARG_PASS_INFO(1) 249ZEND_END_ARG_INFO(); 250 251ZEND_BEGIN_ARG_INFO(first_and_second_and_third_args_force_ref, 0) 252 ZEND_ARG_PASS_INFO(1) 253 ZEND_ARG_PASS_INFO(1) 254ZEND_END_ARG_INFO(); 255 256#else 257static unsigned char first_and_second_args_force_ref[] = {2, BYREF_FORCE, BYREF_FORCE }; 258static unsigned char first_and_second_and_third_args_force_ref[] = {3, BYREF_FORCE, BYREF_FORCE, BYREF_FORCE }; 259#endif 260 261static 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 276zend_class_entry *db_env_ce_get(void) 277{ 278 return db_env_ce; 279} 280 281ZEND_NAMED_FUNCTION(_wrap_new_DbEnv); 282ZEND_NAMED_FUNCTION(_wrap_db_env_close); 283ZEND_NAMED_FUNCTION(_wrap_db_env_dbremove); 284ZEND_NAMED_FUNCTION(_wrap_db_env_dbrename); 285ZEND_NAMED_FUNCTION(_wrap_db_env_get_encrypt_flags); 286ZEND_NAMED_FUNCTION(_wrap_db_env_open); 287ZEND_NAMED_FUNCTION(_wrap_db_env_remove); 288ZEND_NAMED_FUNCTION(_wrap_db_env_set_data_dir); 289ZEND_NAMED_FUNCTION(_wrap_db_env_set_encrypt); 290ZEND_NAMED_FUNCTION(_wrap_db_env_txn_begin); 291ZEND_NAMED_FUNCTION(_wrap_db_env_txn_checkpoint); 292 293static 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 313zend_class_entry *db_ce_get(void) 314{ 315 return db_ce; 316} 317 318ZEND_NAMED_FUNCTION(_wrap_new_db4); 319ZEND_NAMED_FUNCTION(_wrap_db_open); 320ZEND_NAMED_FUNCTION(_wrap_db_close); 321ZEND_NAMED_FUNCTION(_wrap_db_del); 322ZEND_NAMED_FUNCTION(_wrap_db_get); 323ZEND_NAMED_FUNCTION(_wrap_db_get_encrypt_flags); 324ZEND_NAMED_FUNCTION(_wrap_db_pget); 325ZEND_NAMED_FUNCTION(_wrap_db_get_type); 326ZEND_NAMED_FUNCTION(_wrap_db_join); 327ZEND_NAMED_FUNCTION(_wrap_db_put); 328ZEND_NAMED_FUNCTION(_wrap_db_set_encrypt); 329ZEND_NAMED_FUNCTION(_wrap_db_stat); 330ZEND_NAMED_FUNCTION(_wrap_db_sync); 331ZEND_NAMED_FUNCTION(_wrap_db_truncate); 332ZEND_NAMED_FUNCTION(_wrap_db_cursor); 333 334static 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 359BEGIN_EXTERN_C() 360ZEND_GET_MODULE(db4) 361END_EXTERN_C() 362#endif 363 364/* {{{ PHP_INI 365 */ 366/* Remove comments and fill if you need to have entries in php.ini 367PHP_INI_BEGIN() 368PHP_INI_END() 369*/ 370/* }}} */ 371 372/* {{{ php_db4_init_globals 373 */ 374/* Uncomment this function if you have INI entries 375static void php_db4_init_globals(zend_db4_globals *db4_globals) 376{ 377} 378*/ 379/* }}} */ 380 381/* {{{ PHP_MINIT_FUNCTION 382 */ 383PHP_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 */ 628PHP_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 */ 639PHP_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 */ 654void 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 664DB_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 677struct 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) \ 691do { \ 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 704void 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 714struct 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 725DB *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) \ 737do { \ 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) \ 754do { \ 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 770void 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 781DB_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 794struct 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) \ 808do { \ 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) \ 822do { \ 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 835void 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 858void 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 873DBC *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 886struct 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) \ 900do { \ 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 913int 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 */ 936ZEND_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 */ 959ZEND_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 */ 984ZEND_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 */ 1006ZEND_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 */ 1018ZEND_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 */ 1040ZEND_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 */ 1058ZEND_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 */ 1079ZEND_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 */ 1093ZEND_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 */ 1123ZEND_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 */ 1168ZEND_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 */ 1186ZEND_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 */ 1215ZEND_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 */ 1247ZEND_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 */ 1289ZEND_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 */ 1320ZEND_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 */ 1338ZEND_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 */ 1352ZEND_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 */ 1459ZEND_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 */ 1499ZEND_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 */ 1538ZEND_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 */ 1552ZEND_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 */ 1579ZEND_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 */ 1617ZEND_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 */ 1636ZEND_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 */ 1654ZEND_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 */ 1673ZEND_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 */ 1693ZEND_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 */ 1729ZEND_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 */ 1769ZEND_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 1807void 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 */ 1816ZEND_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 */ 1839ZEND_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 */ 1861ZEND_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 */ 1889ZEND_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 */ 1918ZEND_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 */ 1946ZEND_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 */ 1967ZEND_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 */ 1985ZEND_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 */ 2005ZEND_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 */ 2020ZEND_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 */ 2055ZEND_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 */ 2088