libdb_java/db.i

   1 %{
   2 #include "db_config.h"
   3 #include "db_int.h"
   4 #include "dbinc/txn.h"
   5
   6 #ifdef HAVE_CRYPTO
   7 #define CRYPTO_ONLY(x) (x);
   8 #else
   9 #define CRYPTO_ONLY(x)
  10 #endif
  11 %}
  12
  13 #if defined(SWIGJAVA)
  14 %include "db_java.i"
  15 #elif defined(SWIGCSHARP)
  16 %include "db_csharp.i"
  17 #endif
  18
  19 typedef unsigned char u_int8_t;
  20 typedef long int32_t;
  21 typedef long long db_seq_t;
  22 typedef long long pid_t;
  23 #ifndef SWIGJAVA
  24 typedef long long db_threadid_t;
  25 #endif
  26 typedef unsigned long u_int32_t;
  27 typedef u_int32_t       db_recno_t;     /* Record number type. */
  28 typedef u_int32_t       db_timeout_t;   /* Type of a timeout. */
  29
  30 typedef int db_recops;
  31 typedef int db_lockmode_t;
  32 typedef int DBTYPE;
  33 typedef int DB_CACHE_PRIORITY;
  34
  35 /* Fake typedefs for SWIG */
  36 typedef int db_ret_t;    /* An int that is mapped to a void */
  37 typedef int int_bool;    /* An int that is mapped to a boolean */
  38
  39 %{
  40 typedef int db_ret_t;
  41 typedef int int_bool;
  42
  43 struct __db_lk_conflicts {
  44         u_int8_t *lk_conflicts;
  45         int lk_modes;
  46 };
  47
  48 struct __db_out_stream {
  49         void *handle;
  50         int (*callback) __P((void *, const void *));
  51 };
  52
  53 struct __db_repmgr_sites {
  54         DB_REPMGR_SITE *sites;
  55         u_int32_t nsites;
  56 };
  57
  58 #define Db __db
  59 #define Dbc __dbc
  60 #define Dbt __db_dbt
  61 #define DbEnv __db_env
  62 #define DbLock __db_lock_u
  63 #define DbLogc __db_log_cursor
  64 #define DbLsn __db_lsn
  65 #define DbMpoolFile __db_mpoolfile
  66 #define DbSequence __db_sequence
  67 #define DbTxn __db_txn
  68
  69 /* Suppress a compilation warning for an unused symbol */
  70 void *unused = (void *)SWIG_JavaThrowException;
  71 %}
  72
  73 struct Db;              typedef struct Db DB;
  74 struct Dbc;             typedef struct Dbc DBC;
  75 struct Dbt;     typedef struct Dbt DBT;
  76 struct DbEnv;   typedef struct DbEnv DB_ENV;
  77 struct DbLock;  typedef struct DbLock DB_LOCK;
  78 struct DbLogc;  typedef struct DbLogc DB_LOGC;
  79 struct DbLsn;   typedef struct DbLsn DB_LSN;
  80 struct DbMpoolFile;     typedef struct DbMpoolFile DB_MPOOLFILE;
  81 struct DbSequence;              typedef struct Db DB_SEQUENCE;
  82 struct DbTxn;   typedef struct DbTxn DB_TXN;
  83
  84 /* Methods that allocate new objects */
  85 %newobject Db::join(DBC **curslist, u_int32_t flags);
  86 %newobject Db::dup(u_int32_t flags);
  87 %newobject DbEnv::lock_get(u_int32_t locker,
  88         u_int32_t flags, DBT *object, db_lockmode_t lock_mode);
  89 %newobject DbEnv::log_cursor(u_int32_t flags);
  90
  91 struct Db
  92 {
  93 %extend {
  94         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
  95         Db(DB_ENV *dbenv, u_int32_t flags) {
  96                 DB *self = NULL;
  97                 errno = db_create(&self, dbenv, flags);
  98                 if (errno == 0 && dbenv == NULL)
  99                         self->env->dbt_usercopy = __dbj_dbt_memcopy;
 100                 return self;
 101         }
 102
 103         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 104         db_ret_t associate(DB_TXN *txnid, DB *secondary,
 105             int (*callback)(DB *, const DBT *, const DBT *, DBT *),
 106             u_int32_t flags) {
 107                 return self->associate(self, txnid, secondary, callback, flags);
 108         }
 109
 110         db_ret_t associate_foreign(DB *primary,
 111             int (*callback)(DB *, const DBT *, DBT *, const DBT *, int *), u_int32_t flags) {
 112                 return self->associate_foreign(self, primary, callback, flags);
 113         }
 114
 115         db_ret_t compact(DB_TXN *txnid, DBT *start, DBT *stop,
 116             DB_COMPACT *c_data, u_int32_t flags, DBT *end) {
 117                 return self->compact(self, txnid, start, stop, c_data, flags,
 118                     end);
 119         }
 120
 121         /*
 122          * Should probably be db_ret_t, but maintaining backwards compatibility
 123          * for now.
 124          */
 125         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
 126         int close(u_int32_t flags) {
 127                 errno = self->close(self, flags);
 128                 return errno;
 129         }
 130
 131         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV)
 132         DBC *cursor(DB_TXN *txnid, u_int32_t flags) {
 133                 DBC *cursorp = NULL;
 134                 errno = self->cursor(self, txnid, &cursorp, flags);
 135                 return cursorp;
 136         }
 137
 138         JAVA_EXCEPT(DB_RETOK_DBDEL, DB2JDBENV)
 139         int del(DB_TXN *txnid, DBT *key, u_int32_t flags) {
 140                 return self->del(self, txnid, key, flags);
 141         }
 142
 143         JAVA_EXCEPT_NONE
 144         void err(int error, const char *message) {
 145                 self->err(self, error, message);
 146         }
 147
 148         void errx(const char *message) {
 149                 self->errx(self, message);
 150         }
 151
 152         JAVA_EXCEPT(DB_RETOK_EXISTS, DB2JDBENV)
 153         int exists(DB_TXN *txnid, DBT *key, u_int32_t flags) {
 154                 return self->exists(self, txnid, key, flags);
 155         }
 156
 157 #ifndef SWIGJAVA
 158         int fd() {
 159                 int ret = 0;
 160                 errno = self->fd(self, &ret);
 161                 return ret;
 162         }
 163 #endif
 164
 165         JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV)
 166         int get(DB_TXN *txnid, DBT *key, DBT *data, u_int32_t flags) {
 167                 return self->get(self, txnid, key, data, flags);
 168         }
 169
 170         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV)
 171         int_bool get_byteswapped() {
 172                 int ret = 0;
 173                 errno = self->get_byteswapped(self, &ret);
 174                 return ret;
 175         }
 176
 177         jlong get_cachesize() {
 178                 u_int32_t gbytes = 0, bytes = 0;
 179                 errno = self->get_cachesize(self, &gbytes, &bytes, NULL);
 180                 return (jlong)gbytes * GIGABYTE + bytes;
 181         }
 182
 183         u_int32_t get_cachesize_ncache() {
 184                 int ret = 0;
 185                 errno = self->get_cachesize(self, NULL, NULL, &ret);
 186                 return ret;
 187         }
 188
 189         const char *get_create_dir() {
 190                 const char *ret;
 191                 errno = self->get_create_dir(self, &ret);
 192                 return ret;
 193         }
 194
 195         const char *get_filename() {
 196                 const char *ret = NULL;
 197                 errno = self->get_dbname(self, &ret, NULL);
 198                 return ret;
 199         }
 200
 201         const char *get_dbname() {
 202                 const char *ret = NULL;
 203                 errno = self->get_dbname(self, NULL, &ret);
 204                 return ret;
 205         }
 206
 207         u_int32_t get_encrypt_flags() {
 208                 u_int32_t ret = 0;
 209                 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret))
 210                 return ret;
 211         }
 212
 213         /*
 214          * This method is implemented in Java to avoid wrapping the object on
 215          * every call.
 216          */
 217 #ifndef SWIGJAVA
 218         DB_ENV *get_env() {
 219                 DB_ENV *env = NULL;
 220                 errno = self->get_env(self, &env);
 221                 return env;
 222         }
 223
 224         const char *get_errpfx() {
 225                 const char *ret = NULL;
 226                 errno = 0;
 227                 self->get_errpfx(self, &ret);
 228                 return ret;
 229         }
 230 #endif
 231
 232         u_int32_t get_flags() {
 233                 u_int32_t ret = 0;
 234                 errno = self->get_flags(self, &ret);
 235                 return ret;
 236         }
 237
 238         int get_lorder() {
 239                 int ret = 0;
 240                 errno = self->get_lorder(self, &ret);
 241                 return ret;
 242         }
 243
 244         DB_MPOOLFILE *get_mpf() {
 245                 errno = 0;
 246                 return self->get_mpf(self);
 247         }
 248
 249         u_int32_t get_open_flags() {
 250                 u_int32_t ret = 0;
 251                 errno = self->get_open_flags(self, &ret);
 252                 return ret;
 253         }
 254
 255         u_int32_t get_pagesize() {
 256                 u_int32_t ret = 0;
 257                 errno = self->get_pagesize(self, &ret);
 258                 return ret;
 259         }
 260
 261         u_int32_t get_bt_minkey() {
 262                 u_int32_t ret = 0;
 263                 errno = self->get_bt_minkey(self, &ret);
 264                 return ret;
 265         }
 266
 267         u_int32_t get_h_ffactor() {
 268                 u_int32_t ret = 0;
 269                 errno = self->get_h_ffactor(self, &ret);
 270                 return ret;
 271         }
 272
 273         u_int32_t get_h_nelem() {
 274                 u_int32_t ret = 0;
 275                 errno = self->get_h_nelem(self, &ret);
 276                 return ret;
 277         }
 278
 279         int get_re_delim() {
 280                 int ret = 0;
 281                 errno = self->get_re_delim(self, &ret);
 282                 return ret;
 283         }
 284
 285         DB_CACHE_PRIORITY get_priority() {
 286                 DB_CACHE_PRIORITY ret;
 287                 errno = self->get_priority(self, &ret);
 288                 return ret;
 289         }
 290
 291         const char **get_partition_dirs() {
 292                 const char **ret;
 293                 errno = self->get_partition_dirs(self, &ret);
 294                 return ret;
 295         }
 296
 297         DBT *get_partition_keys() {
 298                 DBT *ret = NULL;
 299                 errno = self->get_partition_keys(self, NULL, &ret);
 300                 return ret;
 301         }
 302
 303         int get_partition_parts() {
 304                 int ret = 0;
 305                 errno = self->get_partition_keys(self, &ret, NULL);
 306                 /* If not partitioned by range, check by callback. */
 307                 if (ret == 0)
 308                         errno = self->get_partition_callback(self, &ret, NULL);
 309                 return ret;
 310         }
 311
 312         u_int32_t get_re_len() {
 313                 u_int32_t ret = 0;
 314                 errno = self->get_re_len(self, &ret);
 315                 return ret;
 316         }
 317
 318         int get_re_pad() {
 319                 int ret = 0;
 320                 errno = self->get_re_pad(self, &ret);
 321                 return ret;
 322         }
 323
 324         const char *get_re_source() {
 325                 const char *ret = NULL;
 326                 errno = self->get_re_source(self, &ret);
 327                 return ret;
 328         }
 329
 330         u_int32_t get_q_extentsize() {
 331                 u_int32_t ret = 0;
 332                 errno = self->get_q_extentsize(self, &ret);
 333                 return ret;
 334         }
 335
 336         JAVA_EXCEPT_NONE
 337         int_bool get_multiple() {
 338                 return self->get_multiple(self);
 339         }
 340
 341         int_bool get_transactional() {
 342                 return self->get_transactional(self);
 343         }
 344
 345         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV)
 346         DBTYPE get_type() {
 347                 DBTYPE type = (DBTYPE)0;
 348                 errno = self->get_type(self, &type);
 349                 return type;
 350         }
 351
 352         DBC *join(DBC **curslist, u_int32_t flags) {
 353                 DBC *dbcp = NULL;
 354                 errno = self->join(self, curslist, &dbcp, flags);
 355                 return dbcp;
 356         }
 357
 358         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 359         db_ret_t key_range(DB_TXN *txnid, DBT *key, DB_KEY_RANGE *key_range,
 360             u_int32_t flags) {
 361                 return self->key_range(self, txnid, key, key_range, flags);
 362         }
 363
 364         db_ret_t open(DB_TXN *txnid, const char *file, const char *database,
 365             DBTYPE type, u_int32_t flags, int mode) {
 366                 return self->open(self, txnid, file, database,
 367                     type, flags, mode);
 368         }
 369
 370         JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV)
 371         int pget(DB_TXN *txnid, DBT *key, DBT *pkey, DBT *data,
 372             u_int32_t flags) {
 373                 return self->pget(self, txnid, key, pkey, data, flags);
 374         }
 375
 376         JAVA_EXCEPT(DB_RETOK_DBPUT, DB2JDBENV)
 377         int put(DB_TXN *txnid, DBT *key, DBT *db_put_data, u_int32_t flags) {
 378                 return self->put(self, txnid, key, db_put_data, flags);
 379         }
 380
 381         JAVA_EXCEPT(DB_RETOK_STD, NULL)
 382         db_ret_t remove(const char *file, const char *database,
 383             u_int32_t flags) {
 384                 return self->remove(self, file, database, flags);
 385         }
 386
 387         db_ret_t rename(const char *file, const char *database,
 388             const char *newname, u_int32_t flags) {
 389                 return self->rename(self, file, database, newname, flags);
 390         }
 391
 392         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 393         db_ret_t set_append_recno(
 394             int (*db_append_recno_fcn)(DB *, DBT *, db_recno_t)) {
 395                 return self->set_append_recno(self, db_append_recno_fcn);
 396         }
 397
 398         db_ret_t set_bt_compare(
 399             int (*bt_compare_fcn)(DB *, const DBT *, const DBT *)) {
 400                 return self->set_bt_compare(self, bt_compare_fcn);
 401         }
 402
 403         db_ret_t set_bt_minkey(u_int32_t bt_minkey) {
 404                 return self->set_bt_minkey(self, bt_minkey);
 405         }
 406
 407         db_ret_t set_bt_compress(
 408             int (*bt_compress_fcn)(DB *, const DBT *, const DBT *,
 409             const DBT *, const DBT *, DBT *),
 410             int (*bt_decompress_fcn)(DB *, const DBT *, const DBT *,
 411             DBT *, DBT *, DBT *)) {
 412                 return self->set_bt_compress(
 413                     self, bt_compress_fcn, bt_decompress_fcn);
 414         }
 415
 416         db_ret_t set_bt_prefix(
 417             size_t (*bt_prefix_fcn)(DB *, const DBT *, const DBT *)) {
 418                 return self->set_bt_prefix(self, bt_prefix_fcn);
 419         }
 420
 421         db_ret_t set_cachesize(jlong bytes, int ncache) {
 422                 return self->set_cachesize(self,
 423                     (u_int32_t)(bytes / GIGABYTE),
 424                     (u_int32_t)(bytes % GIGABYTE), ncache);
 425         }
 426
 427         db_ret_t set_create_dir(const char *dir) {
 428                 return self->set_create_dir(self, dir);
 429         }
 430
 431         db_ret_t set_dup_compare(
 432             int (*dup_compare_fcn)(DB *, const DBT *, const DBT *)) {
 433                 return self->set_dup_compare(self, dup_compare_fcn);
 434         }
 435
 436         db_ret_t set_encrypt(const char *passwd, u_int32_t flags) {
 437                 return self->set_encrypt(self, passwd, flags);
 438         }
 439
 440         JAVA_EXCEPT_NONE
 441 #ifndef SWIGJAVA
 442         void set_errcall(
 443            void (*db_errcall_fcn)(const DB_ENV *, const char *, const char *)) {
 444                 self->set_errcall(self, db_errcall_fcn);
 445         }
 446
 447         void set_errpfx(const char *errpfx) {
 448                 self->set_errpfx(self, errpfx);
 449         }
 450 #endif /* SWIGJAVA */
 451
 452         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 453         db_ret_t set_feedback(void (*db_feedback_fcn)(DB *, int, int)) {
 454                 return self->set_feedback(self, db_feedback_fcn);
 455         }
 456
 457         db_ret_t set_flags(u_int32_t flags) {
 458                 return self->set_flags(self, flags);
 459         }
 460
 461         db_ret_t set_h_compare(
 462             int (*h_compare_fcn)(DB *, const DBT *, const DBT *)) {
 463                 return self->set_h_compare(self, h_compare_fcn);
 464         }
 465
 466         db_ret_t set_h_ffactor(u_int32_t h_ffactor) {
 467                 return self->set_h_ffactor(self, h_ffactor);
 468         }
 469
 470         db_ret_t set_h_hash(
 471             u_int32_t (*h_hash_fcn)(DB *, const void *, u_int32_t)) {
 472                 return self->set_h_hash(self, h_hash_fcn);
 473         }
 474
 475         db_ret_t set_h_nelem(u_int32_t h_nelem) {
 476                 return self->set_h_nelem(self, h_nelem);
 477         }
 478
 479         db_ret_t set_lorder(int lorder) {
 480                 return self->set_lorder(self, lorder);
 481         }
 482
 483 #ifndef SWIGJAVA
 484         void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) {
 485                 self->set_msgcall(self, db_msgcall_fcn);
 486         }
 487 #endif /* SWIGJAVA */
 488
 489         db_ret_t set_pagesize(u_int32_t pagesize) {
 490                 return self->set_pagesize(self, pagesize);
 491         }
 492
 493 #ifndef SWIGJAVA
 494         db_ret_t set_paniccall(void (* db_panic_fcn)(DB_ENV *, int)) {
 495                 return self->set_paniccall(self, db_panic_fcn);
 496         }
 497 #endif /* SWIGJAVA */
 498
 499         db_ret_t set_partition(u_int32_t parts, DBT *keys,
 500             u_int32_t (*db_partition_fcn)(DB *, DBT *)) {
 501                 return self->set_partition(self, parts, keys, db_partition_fcn);
 502         }
 503
 504         db_ret_t set_partition_dirs(const char **dirp) {
 505                 return self->set_partition_dirs(self, dirp);
 506         }
 507
 508         db_ret_t set_priority(DB_CACHE_PRIORITY priority) {
 509                 return self->set_priority(self, priority);
 510         }
 511
 512         db_ret_t set_re_delim(int re_delim) {
 513                 return self->set_re_delim(self, re_delim);
 514         }
 515
 516         db_ret_t set_re_len(u_int32_t re_len) {
 517                 return self->set_re_len(self, re_len);
 518         }
 519
 520         db_ret_t set_re_pad(int re_pad) {
 521                 return self->set_re_pad(self, re_pad);
 522         }
 523
 524         db_ret_t set_re_source(char *source) {
 525                 return self->set_re_source(self, source);
 526         }
 527
 528         db_ret_t set_q_extentsize(u_int32_t extentsize) {
 529                 return self->set_q_extentsize(self, extentsize);
 530         }
 531
 532         db_ret_t sort_multiple(DBT *key, DBT *data) {
 533                 return self->sort_multiple(self, key, data, 0);
 534         }
 535
 536         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV)
 537         void *stat(DB_TXN *txnid, u_int32_t flags) {
 538                 void *statp = NULL;
 539                 errno = self->stat(self, txnid, &statp, flags);
 540                 return statp;
 541         }
 542
 543         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 544         db_ret_t sync(u_int32_t flags) {
 545                 return self->sync(self, flags);
 546         }
 547
 548         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV)
 549         int truncate(DB_TXN *txnid, u_int32_t flags) {
 550                 u_int32_t count = 0;
 551                 errno = self->truncate(self, txnid, &count, flags);
 552                 return count;
 553         }
 554
 555         JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV)
 556         db_ret_t upgrade(const char *file, u_int32_t flags) {
 557                 return self->upgrade(self, file, flags);
 558         }
 559
 560         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
 561         int_bool verify(const char *file, const char *database,
 562             struct __db_out_stream outfile, u_int32_t flags) {
 563                 /*
 564                  * We can't easily #include "dbinc/db_ext.h" because of name
 565                  * clashes, so we declare this explicitly.
 566                  */
 567                 extern int __db_verify_internal __P((DB *, const char *, const
 568                     char *, void *, int (*)(void *, const void *), u_int32_t));
 569                 errno = __db_verify_internal(self, file, database,
 570                     outfile.handle, outfile.callback, flags);
 571                 if (errno == DB_VERIFY_BAD) {
 572                         errno = 0;
 573                         return 0;
 574                 } else
 575                         return 1;
 576         }
 577 }
 578 };
 579
 580 struct Dbc
 581 {
 582 %extend {
 583         JAVA_EXCEPT(DB_RETOK_STD, NULL)
 584         db_ret_t close() {
 585                 return self->close(self);
 586         }
 587
 588         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV)
 589         int cmp(DBC *odbc, u_int32_t flags) {
 590                 int result = 0;
 591                 errno = self->cmp(self, odbc, &result, flags);
 592                 return result;
 593         }
 594
 595         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV)
 596         db_recno_t count(u_int32_t flags) {
 597                 db_recno_t count = 0;
 598                 errno = self->count(self, &count, flags);
 599                 return count;
 600         }
 601
 602         JAVA_EXCEPT(DB_RETOK_DBCDEL, DBC2JDBENV)
 603         int del(u_int32_t flags) {
 604                 return self->del(self, flags);
 605         }
 606
 607         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV)
 608         DBC *dup(u_int32_t flags) {
 609                 DBC *newcurs = NULL;
 610                 errno = self->dup(self, &newcurs, flags);
 611                 return newcurs;
 612         }
 613
 614         JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV)
 615         int get(DBT* key, DBT *data, u_int32_t flags) {
 616                 return self->get(self, key, data, flags);
 617         }
 618
 619         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV)
 620         DB_CACHE_PRIORITY get_priority() {
 621                 DB_CACHE_PRIORITY ret;
 622                 errno = self->get_priority(self, &ret);
 623                 return ret;
 624         }
 625
 626         JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV)
 627         int pget(DBT* key, DBT* pkey, DBT *data, u_int32_t flags) {
 628                 return self->pget(self, key, pkey, data, flags);
 629         }
 630
 631         JAVA_EXCEPT(DB_RETOK_DBCPUT, DBC2JDBENV)
 632         int put(DBT* key, DBT *db_put_data, u_int32_t flags) {
 633                 return self->put(self, key, db_put_data, flags);
 634         }
 635
 636         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV)
 637         db_ret_t set_priority(DB_CACHE_PRIORITY priority) {
 638                 return self->set_priority(self, priority);
 639         }
 640 }
 641 };
 642
 643 struct DbEnv
 644 {
 645 %extend {
 646         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
 647         DbEnv(u_int32_t flags) {
 648                 DB_ENV *self = NULL;
 649                 errno = db_env_create(&self, flags);
 650                 if (errno == 0)
 651                         self->env->dbt_usercopy = __dbj_dbt_memcopy;
 652                 return self;
 653         }
 654
 655         JAVA_EXCEPT(DB_RETOK_STD, NULL)
 656         db_ret_t close(u_int32_t flags) {
 657                 return self->close(self, flags);
 658         }
 659
 660         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 661         db_ret_t dbremove(DB_TXN *txnid, const char *file, const char *database,
 662             u_int32_t flags) {
 663                 return self->dbremove(self, txnid, file, database, flags);
 664         }
 665
 666         db_ret_t dbrename(DB_TXN *txnid, const char *file, const char *database,
 667             const char *newname, u_int32_t flags) {
 668                 return self->dbrename(self,
 669                     txnid, file, database, newname, flags);
 670         }
 671
 672         JAVA_EXCEPT_NONE
 673         void err(int error, const char *message) {
 674                 self->err(self, error, message);
 675         }
 676
 677         void errx(const char *message) {
 678                 self->errx(self, message);
 679         }
 680
 681 #ifndef SWIGJAVA
 682         u_int32_t get_thread_count() {
 683                 u_int32_t ret;
 684                 errno = self->get_thread_count(self, &ret);
 685                 return ret;
 686         }
 687
 688         pid_t getpid() {
 689                 pid_t ret;
 690                 db_threadid_t junk;
 691                 __os_id(self, &ret, &junk);
 692                 return ret;
 693         }
 694
 695         db_threadid_t get_threadid() {
 696                 pid_t junk;
 697                 db_threadid_t ret;
 698                 __os_id(self, &junk, &ret);
 699                 return ret;
 700         }
 701
 702         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 703         db_ret_t failchk(u_int32_t flags) {
 704                 return self->failchk(self, flags);
 705         }
 706
 707         db_ret_t set_isalive(
 708             int (*isalive_fcn)(DB_ENV *, pid_t, db_threadid_t)) {
 709                 return self->set_isalive(self, isalive_fcn);
 710         }
 711
 712         db_ret_t set_thread_count(u_int32_t count) {
 713                 return self->set_thread_count(self, count);
 714         }
 715
 716         db_ret_t set_thread_id(void (*thread_id_fcn)(DB_ENV *, pid_t *,
 717             db_threadid_t *)) {
 718                 return self->set_thread_id(self, thread_id_fcn);
 719         }
 720
 721         db_ret_t set_thread_id_string(char *(*thread_id_string_fcn)(DB_ENV *,
 722             pid_t, db_threadid_t, char *)) {
 723                 return self->set_thread_id_string(self, thread_id_string_fcn);
 724         }
 725 #endif
 726
 727         DB_TXN *cdsgroup_begin() {
 728                 DB_TXN *tid = NULL;
 729                 errno = self->cdsgroup_begin(self, &tid);
 730                 return tid;
 731         }
 732
 733         db_ret_t fileid_reset(const char *file, u_int32_t flags) {
 734                 return self->fileid_reset(self, file, flags);
 735         }
 736
 737         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
 738         const char **get_data_dirs() {
 739                 const char **ret;
 740                 errno = self->get_data_dirs(self, &ret);
 741                 return ret;
 742         }
 743
 744         u_int32_t get_encrypt_flags() {
 745                 u_int32_t ret = 0;
 746                 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret))
 747                 return ret;
 748         }
 749
 750 #ifndef SWIGJAVA
 751         const char *get_errpfx() {
 752                 const char *ret;
 753                 errno = 0;
 754                 self->get_errpfx(self, &ret);
 755                 return ret;
 756         }
 757 #endif /* SWIGJAVA */
 758
 759         u_int32_t get_flags() {
 760                 u_int32_t ret;
 761                 errno = self->get_flags(self, &ret);
 762                 return ret;
 763         }
 764
 765         const char *get_home() {
 766                 const char *ret;
 767                 errno = self->get_home(self, &ret);
 768                 return ret;
 769         }
 770
 771         const char *get_intermediate_dir_mode() {
 772                 const char *ret;
 773                 errno = self->get_intermediate_dir_mode(self, &ret);
 774                 return ret;
 775         }
 776
 777         u_int32_t get_open_flags() {
 778                 u_int32_t ret;
 779                 errno = self->get_open_flags(self, &ret);
 780                 return ret;
 781         }
 782
 783         long get_shm_key() {
 784                 long ret;
 785                 errno = self->get_shm_key(self, &ret);
 786                 return ret;
 787         }
 788
 789         const char *get_tmp_dir() {
 790                 const char *ret;
 791                 errno = self->get_tmp_dir(self, &ret);
 792                 return ret;
 793         }
 794
 795         int_bool get_verbose(u_int32_t which) {
 796                 int ret;
 797                 errno = self->get_verbose(self, which, &ret);
 798                 return ret;
 799         }
 800
 801         JAVA_EXCEPT_NONE
 802         int_bool is_bigendian() {
 803                 return self->is_bigendian();
 804         }
 805
 806         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 807         db_ret_t lsn_reset(const char *file, u_int32_t flags) {
 808                 return self->lsn_reset(self, file, flags);
 809         }
 810
 811         db_ret_t open(const char *db_home, u_int32_t flags, int mode) {
 812                 return self->open(self, db_home, flags, mode);
 813         }
 814
 815         JAVA_EXCEPT(DB_RETOK_STD, NULL)
 816         db_ret_t remove(const char *db_home, u_int32_t flags) {
 817                 return self->remove(self, db_home, flags);
 818         }
 819
 820         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 821         db_ret_t set_cachesize(jlong bytes, int ncache) {
 822                 return self->set_cachesize(self,
 823                     (u_int32_t)(bytes / GIGABYTE),
 824                     (u_int32_t)(bytes % GIGABYTE), ncache);
 825         }
 826
 827         db_ret_t set_cache_max(jlong bytes) {
 828                 return self->set_cache_max(self,
 829                     (u_int32_t)(bytes / GIGABYTE),
 830                     (u_int32_t)(bytes % GIGABYTE));
 831         }
 832
 833         db_ret_t set_create_dir(const char *dir) {
 834                 return self->set_create_dir(self, dir);
 835         }
 836
 837         db_ret_t set_data_dir(const char *dir) {
 838                 return self->set_data_dir(self, dir);
 839         }
 840
 841         db_ret_t set_intermediate_dir_mode(const char *mode) {
 842                 return self->set_intermediate_dir_mode(self, mode);
 843         }
 844
 845         db_ret_t set_encrypt(const char *passwd, u_int32_t flags) {
 846                 return self->set_encrypt(self, passwd, flags);
 847         }
 848
 849         JAVA_EXCEPT_NONE
 850         void set_errcall(void (*db_errcall_fcn)(const DB_ENV *, const char *,
 851             const char *)) {
 852                 self->set_errcall(self, db_errcall_fcn);
 853         }
 854
 855 #ifndef SWIGJAVA
 856         void set_errpfx(const char *errpfx) {
 857                 self->set_errpfx(self, errpfx);
 858         }
 859 #endif
 860
 861         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 862         db_ret_t set_flags(u_int32_t flags, int_bool onoff) {
 863                 return self->set_flags(self, flags, onoff);
 864         }
 865
 866         db_ret_t set_feedback(void (*env_feedback_fcn)(DB_ENV *, int, int)) {
 867                 return self->set_feedback(self, env_feedback_fcn);
 868         }
 869
 870         db_ret_t set_mp_max_openfd(int maxopenfd) {
 871                 return self->set_mp_max_openfd(self, maxopenfd);
 872         }
 873
 874         db_ret_t set_mp_max_write(int maxwrite, db_timeout_t maxwrite_sleep) {
 875                 return self->set_mp_max_write(self, maxwrite, maxwrite_sleep);
 876         }
 877
 878         db_ret_t set_mp_mmapsize(size_t mp_mmapsize) {
 879                 return self->set_mp_mmapsize(self, mp_mmapsize);
 880         }
 881
 882         db_ret_t set_mp_pagesize(size_t mp_pagesize) {
 883                 return self->set_mp_pagesize(self, mp_pagesize);
 884         }
 885
 886         db_ret_t set_mp_tablesize(size_t mp_tablesize) {
 887                 return self->set_mp_tablesize(self, mp_tablesize);
 888         }
 889
 890         JAVA_EXCEPT_NONE
 891         void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) {
 892                 self->set_msgcall(self, db_msgcall_fcn);
 893         }
 894
 895         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
 896         db_ret_t set_paniccall(void (*db_panic_fcn)(DB_ENV *, int)) {
 897                 return self->set_paniccall(self, db_panic_fcn);
 898         }
 899
 900         db_ret_t set_rpc_server(char *host,
 901             long cl_timeout, long sv_timeout, u_int32_t flags) {
 902                 return self->set_rpc_server(self, NULL, host,
 903                     cl_timeout, sv_timeout, flags);
 904         }
 905
 906         db_ret_t set_shm_key(long shm_key) {
 907                 return self->set_shm_key(self, shm_key);
 908         }
 909
 910         db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) {
 911                 return self->set_timeout(self, timeout, flags);
 912         }
 913
 914         db_ret_t set_tmp_dir(const char *dir) {
 915                 return self->set_tmp_dir(self, dir);
 916         }
 917
 918         db_ret_t set_tx_max(u_int32_t max) {
 919                 return self->set_tx_max(self, max);
 920         }
 921
 922         db_ret_t set_app_dispatch(
 923             int (*tx_recover)(DB_ENV *, DBT *, DB_LSN *, db_recops)) {
 924                 return self->set_app_dispatch(self, tx_recover);
 925         }
 926
 927         db_ret_t set_event_notify(
 928             void (*event_notify)(DB_ENV *, u_int32_t, void *)) {
 929                 return self->set_event_notify(self, event_notify);
 930         }
 931
 932         db_ret_t set_tx_timestamp(time_t *timestamp) {
 933                 return self->set_tx_timestamp(self, timestamp);
 934         }
 935
 936         db_ret_t set_verbose(u_int32_t which, int_bool onoff) {
 937                 return self->set_verbose(self, which, onoff);
 938         }
 939
 940         /* Lock functions */
 941         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
 942         struct __db_lk_conflicts get_lk_conflicts() {
 943                 struct __db_lk_conflicts ret;
 944                 errno = self->get_lk_conflicts(self,
 945                     (const u_int8_t **)&ret.lk_conflicts, &ret.lk_modes);
 946                 return ret;
 947         }
 948
 949         u_int32_t get_lk_detect() {
 950                 u_int32_t ret;
 951                 errno = self->get_lk_detect(self, &ret);
 952                 return ret;
 953         }
 954
 955         u_int32_t get_lk_max_locks() {
 956                 u_int32_t ret;
 957                 errno = self->get_lk_max_locks(self, &ret);
 958                 return ret;
 959         }
 960
 961         u_int32_t get_lk_max_lockers() {
 962                 u_int32_t ret;
 963                 errno = self->get_lk_max_lockers(self, &ret);
 964                 return ret;
 965         }
 966
 967         u_int32_t get_lk_max_objects() {
 968                 u_int32_t ret;
 969                 errno = self->get_lk_max_objects(self, &ret);
 970                 return ret;
 971         }
 972
 973         u_int32_t get_lk_partitions() {
 974                 u_int32_t ret;
 975                 errno = self->get_lk_partitions(self, &ret);
 976                 return ret;
 977         }
 978
 979         int lock_detect(u_int32_t flags, u_int32_t atype) {
 980                 int aborted;
 981                 errno = self->lock_detect(self, flags, atype, &aborted);
 982                 return aborted;
 983         }
 984
 985         DB_LOCK *lock_get(u_int32_t locker,
 986             u_int32_t flags, DBT *object, db_lockmode_t lock_mode) {
 987                 DB_LOCK *lock = NULL;
 988                 if ((errno = __os_malloc(self->env, sizeof (DB_LOCK), &lock)) == 0)
 989                         errno = self->lock_get(self, locker, flags, object,
 990                             lock_mode, lock);
 991                 return lock;
 992         }
 993
 994         u_int32_t lock_id() {
 995                 u_int32_t id;
 996                 errno = self->lock_id(self, &id);
 997                 return id;
 998         }
 999
1000         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1001         db_ret_t lock_id_free(u_int32_t id) {
1002                 return self->lock_id_free(self, id);
1003         }
1004
1005         db_ret_t lock_put(DB_LOCK *lock) {
1006                 return self->lock_put(self, lock);
1007         }
1008
1009         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1010         DB_LOCK_STAT *lock_stat(u_int32_t flags) {
1011                 DB_LOCK_STAT *statp = NULL;
1012                 errno = self->lock_stat(self, &statp, flags);
1013                 return statp;
1014         }
1015
1016 #ifndef SWIGJAVA
1017         /* For Java, this is defined in native code */
1018         db_ret_t lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ *list,
1019             int offset, int nlist)
1020         {
1021                 DB_LOCKREQ *elistp;
1022                 return self->lock_vec(self, locker, flags, list + offset,
1023                     nlist, &elistp);
1024         }
1025 #endif
1026
1027         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1028         db_ret_t set_lk_conflicts(struct __db_lk_conflicts conflicts) {
1029                 return self->set_lk_conflicts(self,
1030                     conflicts.lk_conflicts, conflicts.lk_modes);
1031         }
1032
1033         db_ret_t set_lk_detect(u_int32_t detect) {
1034                 return self->set_lk_detect(self, detect);
1035         }
1036
1037         db_ret_t set_lk_max_lockers(u_int32_t max) {
1038                 return self->set_lk_max_lockers(self, max);
1039         }
1040
1041         db_ret_t set_lk_max_locks(u_int32_t max) {
1042                 return self->set_lk_max_locks(self, max);
1043         }
1044
1045         db_ret_t set_lk_max_objects(u_int32_t max) {
1046                 return self->set_lk_max_objects(self, max);
1047         }
1048
1049         db_ret_t set_lk_partitions(u_int32_t partitions) {
1050                 return self->set_lk_partitions(self, partitions);
1051         }
1052
1053         /* Log functions */
1054         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1055         u_int32_t get_lg_bsize() {
1056                 u_int32_t ret;
1057                 errno = self->get_lg_bsize(self, &ret);
1058                 return ret;
1059         }
1060
1061         const char *get_lg_dir() {
1062                 const char *ret;
1063                 errno = self->get_lg_dir(self, &ret);
1064                 return ret;
1065         }
1066
1067         int get_lg_filemode() {
1068                 int ret;
1069                 errno = self->get_lg_filemode(self, &ret);
1070                 return ret;
1071         }
1072
1073         u_int32_t get_lg_max() {
1074                 u_int32_t ret;
1075                 errno = self->get_lg_max(self, &ret);
1076                 return ret;
1077         }
1078
1079         u_int32_t get_lg_regionmax() {
1080                 u_int32_t ret;
1081                 errno = self->get_lg_regionmax(self, &ret);
1082                 return ret;
1083         }
1084
1085         char **log_archive(u_int32_t flags) {
1086                 char **list = NULL;
1087                 errno = self->log_archive(self, &list, flags);
1088                 return list;
1089         }
1090
1091         JAVA_EXCEPT_NONE
1092         static int log_compare(const DB_LSN *lsn0, const DB_LSN *lsn1) {
1093                 return log_compare(lsn0, lsn1);
1094         }
1095
1096         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1097         DB_LOGC *log_cursor(u_int32_t flags) {
1098                 DB_LOGC *cursor = NULL;
1099                 errno = self->log_cursor(self, &cursor, flags);
1100                 return cursor;
1101         }
1102
1103         char *log_file(DB_LSN *lsn) {
1104                 char namebuf[DB_MAXPATHLEN];
1105                 errno = self->log_file(self, lsn, namebuf, sizeof namebuf);
1106                 return (errno == 0) ? strdup(namebuf) : NULL;
1107         }
1108
1109         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1110         db_ret_t log_flush(const DB_LSN *lsn_or_null) {
1111                 return self->log_flush(self, lsn_or_null);
1112         }
1113
1114         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1115         int_bool log_get_config(u_int32_t which) {
1116                 int ret;
1117                 errno = self->log_get_config(self, which, &ret);
1118                 return ret;
1119         }
1120
1121         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1122         db_ret_t log_put(DB_LSN *lsn, const DBT *data, u_int32_t flags) {
1123                 return self->log_put(self, lsn, data, flags);
1124         }
1125
1126         db_ret_t log_print(DB_TXN *txn, const char *msg) {
1127                 return self->log_printf(self, txn, "%s", msg);
1128         }
1129
1130         db_ret_t log_set_config(u_int32_t which, int_bool onoff) {
1131                 return self->log_set_config(self, which, onoff);
1132         }
1133
1134         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1135         DB_LOG_STAT *log_stat(u_int32_t flags) {
1136                 DB_LOG_STAT *sp = NULL;
1137                 errno = self->log_stat(self, &sp, flags);
1138                 return sp;
1139         }
1140
1141         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1142         db_ret_t set_lg_bsize(u_int32_t lg_bsize) {
1143                 return self->set_lg_bsize(self, lg_bsize);
1144         }
1145
1146         db_ret_t set_lg_dir(const char *dir) {
1147                 return self->set_lg_dir(self, dir);
1148         }
1149
1150         db_ret_t set_lg_filemode(int mode) {
1151                 return self->set_lg_filemode(self, mode);
1152         }
1153
1154         db_ret_t set_lg_max(u_int32_t lg_max) {
1155                 return self->set_lg_max(self, lg_max);
1156         }
1157
1158         db_ret_t set_lg_regionmax(u_int32_t lg_regionmax) {
1159                 return self->set_lg_regionmax(self, lg_regionmax);
1160         }
1161
1162         /* Memory pool functions */
1163         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1164         jlong get_cachesize() {
1165                 u_int32_t gbytes, bytes;
1166                 errno = self->get_cachesize(self, &gbytes, &bytes, NULL);
1167                 return (jlong)gbytes * GIGABYTE + bytes;
1168         }
1169
1170         int get_cachesize_ncache() {
1171                 int ret;
1172                 errno = self->get_cachesize(self, NULL, NULL, &ret);
1173                 return ret;
1174         }
1175
1176         jlong get_cache_max() {
1177                 u_int32_t gbytes, bytes;
1178                 errno = self->get_cache_max(self, &gbytes, &bytes);
1179                 return (jlong)gbytes * GIGABYTE + bytes;
1180         }
1181
1182         const char *get_create_dir() {
1183                 const char *ret;
1184                 errno = self->get_create_dir(self, &ret);
1185                 return ret;
1186         }
1187
1188         int get_mp_max_openfd() {
1189                 int ret;
1190                 errno = self->get_mp_max_openfd(self, &ret);
1191                 return ret;
1192         }
1193
1194         int get_mp_max_write() {
1195                 int maxwrite;
1196                 db_timeout_t sleep;
1197                 errno = self->get_mp_max_write(self, &maxwrite, &sleep);
1198                 return maxwrite;
1199         }
1200
1201         db_timeout_t get_mp_max_write_sleep() {
1202                 int maxwrite;
1203                 db_timeout_t sleep;
1204                 errno = self->get_mp_max_write(self, &maxwrite, &sleep);
1205                 return sleep;
1206         }
1207
1208         size_t get_mp_mmapsize() {
1209                 size_t ret;
1210                 errno = self->get_mp_mmapsize(self, &ret);
1211                 return ret;
1212         }
1213
1214         int get_mp_pagesize() {
1215                 int ret;
1216                 errno = self->get_mp_pagesize(self, &ret);
1217                 return ret;
1218         }
1219
1220         int get_mp_tablesize() {
1221                 int ret;
1222                 errno = self->get_mp_tablesize(self, &ret);
1223                 return ret;
1224         }
1225
1226         DB_MPOOL_STAT *memp_stat(u_int32_t flags) {
1227                 DB_MPOOL_STAT *mp_stat = NULL;
1228                 errno = self->memp_stat(self, &mp_stat, NULL, flags);
1229                 return mp_stat;
1230         }
1231
1232         DB_MPOOL_FSTAT **memp_fstat(u_int32_t flags) {
1233                 DB_MPOOL_FSTAT **mp_fstat = NULL;
1234                 errno = self->memp_stat(self, NULL, &mp_fstat, flags);
1235                 return mp_fstat;
1236         }
1237
1238         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1239         db_ret_t memp_sync(DB_LSN *lsn) {
1240                 return self->memp_sync(self, lsn);
1241         }
1242
1243         int memp_trickle(int percent) {
1244                 int ret;
1245                 errno = self->memp_trickle(self, percent, &ret);
1246                 return ret;
1247         }
1248
1249         /* Mutex functions */
1250         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1251         u_int32_t mutex_get_align() {
1252                 u_int32_t ret;
1253                 errno = self->mutex_get_align(self, &ret);
1254                 return ret;
1255         }
1256
1257         u_int32_t mutex_get_increment() {
1258                 u_int32_t ret;
1259                 errno = self->mutex_get_increment(self, &ret);
1260                 return ret;
1261         }
1262
1263         u_int32_t mutex_get_max() {
1264                 u_int32_t ret;
1265                 errno = self->mutex_get_max(self, &ret);
1266                 return ret;
1267         }
1268
1269         u_int32_t mutex_get_tas_spins() {
1270                 u_int32_t ret;
1271                 errno = self->mutex_get_tas_spins(self, &ret);
1272                 return ret;
1273         }
1274
1275         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1276         db_ret_t mutex_set_align(u_int32_t align) {
1277                 return self->mutex_set_align(self, align);
1278         }
1279
1280         db_ret_t mutex_set_increment(u_int32_t increment) {
1281                 return self->mutex_set_increment(self, increment);
1282         }
1283
1284         db_ret_t mutex_set_max(u_int32_t mutex_max) {
1285                 return self->mutex_set_max(self, mutex_max);
1286         }
1287
1288         db_ret_t mutex_set_tas_spins(u_int32_t tas_spins) {
1289                 return self->mutex_set_tas_spins(self, tas_spins);
1290         }
1291
1292         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1293         DB_MUTEX_STAT *mutex_stat(u_int32_t flags) {
1294                 DB_MUTEX_STAT *statp = NULL;
1295                 errno = self->mutex_stat(self, &statp, flags);
1296                 return statp;
1297         }
1298
1299         /* Transaction functions */
1300         u_int32_t get_tx_max() {
1301                 u_int32_t ret;
1302                 errno = self->get_tx_max(self, &ret);
1303                 return ret;
1304         }
1305
1306         time_t get_tx_timestamp() {
1307                 time_t ret;
1308                 errno = self->get_tx_timestamp(self, &ret);
1309                 return ret;
1310         }
1311
1312         db_timeout_t get_timeout(u_int32_t flag) {
1313                 db_timeout_t ret;
1314                 errno = self->get_timeout(self, &ret, flag);
1315                 return ret;
1316         }
1317
1318         DB_TXN *txn_begin(DB_TXN *parent, u_int32_t flags) {
1319                 DB_TXN *tid = NULL;
1320                 errno = self->txn_begin(self, parent, &tid, flags);
1321                 return tid;
1322         }
1323
1324         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1325         db_ret_t txn_checkpoint(u_int32_t kbyte, u_int32_t min,
1326             u_int32_t flags) {
1327                 return self->txn_checkpoint(self, kbyte, min, flags);
1328         }
1329
1330         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1331         DB_PREPLIST *txn_recover(int count, u_int32_t flags) {
1332                 DB_PREPLIST *preplist;
1333                 u_int32_t retcount;
1334
1335                 /* Add a NULL element to terminate the array. */
1336                 if ((errno = __os_malloc(self->env,
1337                     (count + 1) * sizeof(DB_PREPLIST), &preplist)) != 0)
1338                         return NULL;
1339
1340                 if ((errno = self->txn_recover(self, preplist, count,
1341                     &retcount, flags)) != 0) {
1342                         __os_free(self->env, preplist);
1343                         return NULL;
1344                 }
1345
1346                 preplist[retcount].txn = NULL;
1347                 return preplist;
1348         }
1349
1350         DB_TXN_STAT *txn_stat(u_int32_t flags) {
1351                 DB_TXN_STAT *statp = NULL;
1352                 errno = self->txn_stat(self, &statp, flags);
1353                 return statp;
1354         }
1355
1356         /* Replication functions */
1357         jlong rep_get_limit() {
1358                 u_int32_t gbytes, bytes;
1359                 errno = self->rep_get_limit(self, &gbytes, &bytes);
1360                 return (jlong)gbytes * GIGABYTE + bytes;
1361         }
1362
1363         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1364         db_ret_t rep_elect(u_int32_t nsites, int nvotes, u_int32_t flags) {
1365                 return self->rep_elect(self, nsites, nvotes, flags);
1366         }
1367
1368         JAVA_EXCEPT(DB_RETOK_REPPMSG, JDBENV)
1369         int rep_process_message(DBT *control, DBT *rec, int envid,
1370             DB_LSN *ret_lsn) {
1371                 return self->rep_process_message(self, control, rec, envid,
1372                     ret_lsn);
1373         }
1374
1375         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1376         db_ret_t rep_flush() {
1377                 return self->rep_flush(self);
1378         }
1379
1380         db_ret_t rep_set_config(u_int32_t which, int_bool onoff) {
1381                 return self->rep_set_config(self, which, onoff);
1382         }
1383
1384         db_ret_t rep_set_clockskew(u_int32_t fast_clock, u_int32_t slow_clock) {
1385                 return self->rep_set_clockskew(self, fast_clock, slow_clock);
1386         }
1387
1388         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1389         u_int32_t rep_get_clockskew_fast() {
1390                 u_int32_t fast_clock, slow_clock;
1391                 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock);
1392                 return fast_clock;
1393         }
1394
1395         u_int32_t rep_get_clockskew_slow() {
1396                 u_int32_t fast_clock, slow_clock;
1397                 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock);
1398                 return slow_clock;
1399         }
1400
1401         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1402         db_ret_t rep_start(DBT *cdata, u_int32_t flags) {
1403                 return self->rep_start(self, cdata, flags);
1404         }
1405
1406         db_ret_t rep_sync(u_int32_t flags) {
1407                 return self->rep_sync(self, flags);
1408         }
1409
1410         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1411         int_bool rep_get_config(u_int32_t which) {
1412                 int ret;
1413                 errno = self->rep_get_config(self, which, &ret);
1414                 return ret;
1415         }
1416
1417         DB_REP_STAT *rep_stat(u_int32_t flags) {
1418                 DB_REP_STAT *statp = NULL;
1419                 errno = self->rep_stat(self, &statp, flags);
1420                 return statp;
1421         }
1422
1423         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1424         db_ret_t rep_set_limit(jlong bytes) {
1425                 return self->rep_set_limit(self,
1426                     (u_int32_t)(bytes / GIGABYTE),
1427                     (u_int32_t)(bytes % GIGABYTE));
1428         }
1429
1430         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1431         u_int32_t rep_get_request_min(){
1432                 u_int32_t min, max;
1433                 errno = self->rep_get_request(self, &min, &max);
1434                 return min;
1435         }
1436
1437         u_int32_t rep_get_request_max(){
1438                 u_int32_t min, max;
1439                 errno = self->rep_get_request(self, &min, &max);
1440                 return max;
1441         }
1442
1443         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1444         db_ret_t rep_set_request(u_int32_t min, u_int32_t max) {
1445                 return self->rep_set_request(self, min, max);
1446         }
1447
1448         db_ret_t rep_set_transport(int envid,
1449             int (*send)(DB_ENV *, const DBT *, const DBT *,
1450             const DB_LSN *, int, u_int32_t)) {
1451                 return self->rep_set_transport(self, envid, send);
1452         }
1453
1454         /* Advanced replication functions. */
1455         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1456         u_int32_t rep_get_nsites() {
1457                 u_int32_t ret;
1458                 errno = self->rep_get_nsites(self, &ret);
1459                 return ret;
1460         }
1461
1462         u_int32_t rep_get_priority() {
1463                 u_int32_t ret;
1464                 errno = self->rep_get_priority(self, &ret);
1465                 return ret;
1466         }
1467
1468         u_int32_t rep_get_timeout(int which) {
1469                 u_int32_t ret;
1470                 errno = self->rep_get_timeout(self, which, &ret);
1471                 return ret;
1472         }
1473
1474         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1475         db_ret_t rep_set_nsites(u_int32_t number) {
1476                 return self->rep_set_nsites(self, number);
1477         }
1478
1479         db_ret_t rep_set_priority(u_int32_t priority) {
1480                 return self->rep_set_priority(self, priority);
1481         }
1482
1483         db_ret_t rep_set_timeout(int which, db_timeout_t timeout) {
1484                 return self->rep_set_timeout(self, which, timeout);
1485         }
1486
1487         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1488         int repmgr_add_remote_site(const char * host, u_int32_t port,
1489             u_int32_t flags) {
1490                 int eid;
1491                 errno = self->repmgr_add_remote_site(self, host, port, &eid, flags);
1492                 return eid;
1493         }
1494
1495         JAVA_EXCEPT(DB_RETOK_STD, JDBENV)
1496         db_ret_t repmgr_get_ack_policy() {
1497                 int ret;
1498                 errno = self->repmgr_get_ack_policy(self, &ret);
1499                 return ret;
1500         }
1501
1502         db_ret_t repmgr_set_ack_policy(int policy) {
1503                 return self->repmgr_set_ack_policy(self, policy);
1504         }
1505
1506         db_ret_t repmgr_set_local_site(const char * host, u_int32_t port, u_int32_t flags) {
1507                 return self->repmgr_set_local_site(self, host, port, flags);
1508         }
1509
1510         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1511         struct __db_repmgr_sites repmgr_site_list() {
1512                 struct __db_repmgr_sites sites;
1513                 errno = self->repmgr_site_list(self,
1514                     &sites.nsites, &sites.sites);
1515                 return sites;
1516         }
1517
1518         JAVA_EXCEPT(DB_RETOK_REPMGR_START, JDBENV)
1519         db_ret_t repmgr_start(int nthreads, u_int32_t flags) {
1520                 return self->repmgr_start(self, nthreads, flags);
1521         }
1522
1523         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV)
1524         DB_REPMGR_STAT *repmgr_stat(u_int32_t flags) {
1525                 DB_REPMGR_STAT *statp = NULL;
1526                 errno = self->repmgr_stat(self, &statp, flags);
1527                 return statp;
1528         }
1529
1530         /* Convert DB errors to strings */
1531         JAVA_EXCEPT_NONE
1532         static const char *strerror(int error) {
1533                 return db_strerror(error);
1534         }
1535
1536         /* Versioning information */
1537         static int get_version_major() {
1538                 return DB_VERSION_MAJOR;
1539         }
1540
1541         static int get_version_minor() {
1542                 return DB_VERSION_MINOR;
1543         }
1544
1545         static int get_version_patch() {
1546                 return DB_VERSION_PATCH;
1547         }
1548
1549         static const char *get_version_string() {
1550                 return DB_VERSION_STRING;
1551         }
1552 }
1553 };
1554
1555 struct DbLock
1556 {
1557 %extend {
1558         JAVA_EXCEPT_NONE
1559         ~DbLock() {
1560                 __os_free(NULL, self);
1561         }
1562 }
1563 };
1564
1565 struct DbLogc
1566 {
1567 %extend {
1568         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1569         db_ret_t close(u_int32_t flags) {
1570                 return self->close(self, flags);
1571         }
1572
1573         JAVA_EXCEPT(DB_RETOK_LGGET, NULL)
1574         int get(DB_LSN *lsn, DBT *data, u_int32_t flags) {
1575                 return self->get(self, lsn, data, flags);
1576         }
1577
1578         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1579         u_int32_t version(u_int32_t flags) {
1580                 u_int32_t result;
1581                 errno = self->version(self, &result, flags);
1582                 return result;
1583         }
1584 }
1585 };
1586
1587 #ifndef SWIGJAVA
1588 struct DbLsn
1589 {
1590 %extend {
1591         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1592         DbLsn(u_int32_t file, u_int32_t offset) {
1593                 DB_LSN *self = NULL;
1594                 if ((errno = __os_malloc(NULL, sizeof (DB_LSN), &self)) == 0) {
1595                         self->file = file;
1596                         self->offset = offset;
1597                 }
1598                 return self;
1599         }
1600
1601         JAVA_EXCEPT_NONE
1602         ~DbLsn() {
1603                 __os_free(NULL, self);
1604         }
1605
1606         u_int32_t get_file() {
1607                 return self->file;
1608         }
1609
1610         u_int32_t get_offset() {
1611                 return self->offset;
1612         }
1613 }
1614 };
1615 #endif
1616
1617 struct DbMpoolFile
1618 {
1619 %extend {
1620         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1621         DB_CACHE_PRIORITY get_priority() {
1622                 DB_CACHE_PRIORITY ret;
1623                 errno = self->get_priority(self, &ret);
1624                 return ret;
1625         }
1626
1627         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1628         db_ret_t set_priority(DB_CACHE_PRIORITY priority) {
1629                 return self->set_priority(self, priority);
1630         }
1631
1632         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1633         u_int32_t get_flags() {
1634                 u_int32_t ret;
1635                 errno = self->get_flags(self, &ret);
1636                 return ret;
1637         }
1638
1639         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1640         db_ret_t set_flags(u_int32_t flags, int_bool onoff) {
1641                 return self->set_flags(self, flags, onoff);
1642         }
1643
1644         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1645         jlong get_maxsize() {
1646                 u_int32_t gbytes, bytes;
1647                 errno = self->get_maxsize(self, &gbytes, &bytes);
1648                 return (jlong)gbytes * GIGABYTE + bytes;
1649         }
1650
1651         /* New method - no backwards compatibility version */
1652         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1653         db_ret_t set_maxsize(jlong bytes) {
1654                 return self->set_maxsize(self,
1655                     (u_int32_t)(bytes / GIGABYTE),
1656                     (u_int32_t)(bytes % GIGABYTE));
1657         }
1658 }
1659 };
1660
1661 struct DbSequence
1662 {
1663 %extend {
1664         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1665         DbSequence(DB *db, u_int32_t flags) {
1666                 DB_SEQUENCE *self = NULL;
1667                 errno = db_sequence_create(&self, db, flags);
1668                 return self;
1669         }
1670
1671         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1672         db_ret_t close(u_int32_t flags) {
1673                 return self->close(self, flags);
1674         }
1675
1676         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1677         db_seq_t get(DB_TXN *txnid, int32_t delta, u_int32_t flags) {
1678                 db_seq_t ret = 0;
1679                 errno = self->get(self, txnid, delta, &ret, flags);
1680                 return ret;
1681         }
1682
1683         int32_t get_cachesize() {
1684                 int32_t ret = 0;
1685                 errno = self->get_cachesize(self, &ret);
1686                 return ret;
1687         }
1688
1689         DB *get_db() {
1690                 DB *ret = NULL;
1691                 errno = self->get_db(self, &ret);
1692                 return ret;
1693         }
1694
1695         u_int32_t get_flags() {
1696                 u_int32_t ret = 0;
1697                 errno = self->get_flags(self, &ret);
1698                 return ret;
1699         }
1700
1701         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1702         db_ret_t get_key(DBT *key) {
1703                 return self->get_key(self, key);
1704         }
1705
1706         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1707         db_seq_t get_range_min() {
1708                 db_seq_t ret = 0;
1709                 errno = self->get_range(self, &ret, NULL);
1710                 return ret;
1711         }
1712
1713         db_seq_t get_range_max() {
1714                 db_seq_t ret = 0;
1715                 errno = self->get_range(self, NULL, &ret);
1716                 return ret;
1717         }
1718
1719         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1720         db_ret_t initial_value(db_seq_t val) {
1721                 return self->initial_value(self, val);
1722         }
1723
1724         db_ret_t open(DB_TXN *txnid, DBT *key, u_int32_t flags) {
1725                 return self->open(self, txnid, key, flags);
1726         }
1727
1728         db_ret_t remove(DB_TXN *txnid, u_int32_t flags) {
1729                 return self->remove(self, txnid, flags);
1730         }
1731
1732         db_ret_t set_cachesize(int32_t size) {
1733                 return self->set_cachesize(self, size);
1734         }
1735
1736         db_ret_t set_flags(u_int32_t flags) {
1737                 return self->set_flags(self, flags);
1738         }
1739
1740         db_ret_t set_range(db_seq_t min, db_seq_t max) {
1741                 return self->set_range(self, min, max);
1742         }
1743
1744         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL)
1745         DB_SEQUENCE_STAT *stat(u_int32_t flags) {
1746                 DB_SEQUENCE_STAT *ret = NULL;
1747                 errno = self->stat(self, &ret, flags);
1748                 return ret;
1749         }
1750 }
1751 };
1752
1753 struct DbTxn
1754 {
1755 %extend {
1756         JAVA_EXCEPT(DB_RETOK_STD, NULL)
1757         db_ret_t abort() {
1758                 return self->abort(self);
1759         }
1760
1761         db_ret_t commit(u_int32_t flags) {
1762                 return self->commit(self, flags);
1763         }
1764
1765         db_ret_t discard(u_int32_t flags) {
1766                 return self->discard(self, flags);
1767         }
1768
1769         JAVA_EXCEPT_ERRNO(DB_RETOK_STD, TXN2JDBENV)
1770         const char *get_name() {
1771                 const char *name = NULL;
1772                 errno = self->get_name(self, &name);
1773                 return name;
1774         }
1775
1776         JAVA_EXCEPT_NONE
1777         u_int32_t id() {
1778                 return self->id(self);
1779         }
1780
1781         JAVA_EXCEPT(DB_RETOK_STD, TXN2JDBENV)
1782         db_ret_t prepare(u_int8_t *gid) {
1783                 return self->prepare(self, gid);
1784         }
1785
1786         db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) {
1787                 return self->set_timeout(self, timeout, flags);
1788         }
1789
1790         db_ret_t set_name(const char *name) {
1791                 return self->set_name(self, name);
1792         }
1793 }
1794 };
1795