BDB 4.1.24

BitKeeper/deleted/.del-ex_access.wpj~3df6ae8c99bf7c5f:
  Delete: bdb/build_vxworks/ex_access/ex_access.wpj
BitKeeper/deleted/.del-ex_btrec.wpj~a7622f1c6f432dc6:
  Delete: bdb/build_vxworks/ex_btrec/ex_btrec.wpj
BitKeeper/deleted/.del-ex_dbclient.wpj~7345440f3b204cdd:
  Delete: bdb/build_vxworks/ex_dbclient/ex_dbclient.wpj
BitKeeper/deleted/.del-ex_env.wpj~fbe1ab10b04e8b74:
  Delete: bdb/build_vxworks/ex_env/ex_env.wpj
BitKeeper/deleted/.del-ex_mpool.wpj~4479cfd5c45f327d:
  Delete: bdb/build_vxworks/ex_mpool/ex_mpool.wpj
BitKeeper/deleted/.del-ex_tpcb.wpj~f78093006e14bf41:
  Delete: bdb/build_vxworks/ex_tpcb/ex_tpcb.wpj
BitKeeper/deleted/.del-db_buildall.dsp~bd749ff6da11682:
  Delete: bdb/build_win32/db_buildall.dsp
BitKeeper/deleted/.del-cxx_app.cpp~ad8df8e0791011ed:
  Delete: bdb/cxx/cxx_app.cpp
BitKeeper/deleted/.del-cxx_log.cpp~a50ff3118fe06952:
  Delete: bdb/cxx/cxx_log.cpp
BitKeeper/deleted/.del-cxx_table.cpp~ecd751e79b055556:
  Delete: bdb/cxx/cxx_table.cpp
BitKeeper/deleted/.del-namemap.txt~796a3acd3885d8fd:
  Delete: bdb/cxx/namemap.txt
BitKeeper/deleted/.del-Design.fileop~3ca4da68f1727373:
  Delete: bdb/db/Design.fileop
BitKeeper/deleted/.del-db185_int.h~61bee3736e7959ef:
  Delete: bdb/db185/db185_int.h
BitKeeper/deleted/.del-acconfig.h~411e8854d67ad8b5:
  Delete: bdb/dist/acconfig.h
BitKeeper/deleted/.del-mutex.m4~a13383cde18a64e1:
  Delete: bdb/dist/aclocal/mutex.m4
BitKeeper/deleted/.del-options.m4~b9d0ca637213750a:
  Delete: bdb/dist/aclocal/options.m4
BitKeeper/deleted/.del-programs.m4~3ce7890b47732b30:
  Delete: bdb/dist/aclocal/programs.m4
BitKeeper/deleted/.del-tcl.m4~f944e2db93c3b6db:
  Delete: bdb/dist/aclocal/tcl.m4
BitKeeper/deleted/.del-types.m4~59cae158c9a32cff:
  Delete: bdb/dist/aclocal/types.m4
BitKeeper/deleted/.del-script~d38f6d3a4f159cb4:
  Delete: bdb/dist/build/script
BitKeeper/deleted/.del-configure.in~ac795a92c8fe049c:
  Delete: bdb/dist/configure.in
BitKeeper/deleted/.del-ltconfig~66bbd007d8024af:
  Delete: bdb/dist/ltconfig
BitKeeper/deleted/.del-rec_ctemp~a28554362534f00a:
  Delete: bdb/dist/rec_ctemp
BitKeeper/deleted/.del-s_tcl~2ffe4326459fcd9f:
  Delete: bdb/dist/s_tcl
BitKeeper/deleted/.del-.IGNORE_ME~d8148b08fa7d5d15:
  Delete: bdb/dist/template/.IGNORE_ME
BitKeeper/deleted/.del-btree.h~179f2aefec1753d:
  Delete: bdb/include/btree.h
BitKeeper/deleted/.del-cxx_int.h~6b649c04766508f8:
  Delete: bdb/include/cxx_int.h
BitKeeper/deleted/.del-db.src~6b433ae615b16a8d:
  Delete: bdb/include/db.src
BitKeeper/deleted/.del-db_185.h~ad8b373d9391d35c:
  Delete: bdb/include/db_185.h
BitKeeper/deleted/.del-db_am.h~a714912b6b75932f:
  Delete: bdb/include/db_am.h
BitKeeper/deleted/.del-db_cxx.h~fcafadf45f5d19e9:
  Delete: bdb/include/db_cxx.h
BitKeeper/deleted/.del-db_dispatch.h~6844f20f7eb46904:
  Delete: bdb/include/db_dispatch.h
BitKeeper/deleted/.del-db_int.src~419a3f48b6a01da7:
  Delete: bdb/include/db_int.src
BitKeeper/deleted/.del-db_join.h~76f9747a42c3399a:
  Delete: bdb/include/db_join.h
BitKeeper/deleted/.del-db_page.h~e302ca3a4db3abdc:
  Delete: bdb/include/db_page.h
BitKeeper/deleted/.del-db_server_int.h~e1d20b6ba3bca1ab:
  Delete: bdb/include/db_server_int.h
BitKeeper/deleted/.del-db_shash.h~5fbf2d696fac90f3:
  Delete: bdb/include/db_shash.h
BitKeeper/deleted/.del-db_swap.h~1e60887550864a59:
  Delete: bdb/include/db_swap.h
BitKeeper/deleted/.del-db_upgrade.h~c644eee73701fc8d:
  Delete: bdb/include/db_upgrade.h
BitKeeper/deleted/.del-db_verify.h~b8d6c297c61f342e:
  Delete: bdb/include/db_verify.h
BitKeeper/deleted/.del-debug.h~dc2b4f2cf27ccebc:
  Delete: bdb/include/debug.h
BitKeeper/deleted/.del-hash.h~2aaa548b28882dfb:
  Delete: bdb/include/hash.h
BitKeeper/deleted/.del-lock.h~a761c1b7de57b77f:
  Delete: bdb/include/lock.h
BitKeeper/deleted/.del-log.h~ff20184238e35e4d:
  Delete: bdb/include/log.h
BitKeeper/deleted/.del-mp.h~7e317597622f3411:
  Delete: bdb/include/mp.h
BitKeeper/deleted/.del-mutex.h~d3ae7a2977a68137:
  Delete: bdb/include/mutex.h
BitKeeper/deleted/.del-os.h~91867cc8757cd0e3:
  Delete: bdb/include/os.h
BitKeeper/deleted/.del-os_jump.h~e1b939fa5151d4be:
  Delete: bdb/include/os_jump.h
BitKeeper/deleted/.del-qam.h~6fad0c1b5723d597:
  Delete: bdb/include/qam.h
BitKeeper/deleted/.del-queue.h~4c72c0826c123d5:
  Delete: bdb/include/queue.h
BitKeeper/deleted/.del-region.h~513fe04d977ca0fc:
  Delete: bdb/include/region.h
BitKeeper/deleted/.del-shqueue.h~525fc3e6c2025c36:
  Delete: bdb/include/shqueue.h
BitKeeper/deleted/.del-tcl_db.h~c536fd61a844f23f:
  Delete: bdb/include/tcl_db.h
BitKeeper/deleted/.del-txn.h~c8d94b221ec147e4:
  Delete: bdb/include/txn.h
BitKeeper/deleted/.del-xa.h~ecc466493aae9d9a:
  Delete: bdb/include/xa.h
BitKeeper/deleted/.del-DbRecoveryInit.java~756b52601a0b9023:
  Delete: bdb/java/src/com/sleepycat/db/DbRecoveryInit.java
BitKeeper/deleted/.del-DbTxnRecover.java~74607cba7ab89d6d:
  Delete: bdb/java/src/com/sleepycat/db/DbTxnRecover.java
BitKeeper/deleted/.del-lock_conflict.c~fc5e0f14cf597a2b:
  Delete: bdb/lock/lock_conflict.c
BitKeeper/deleted/.del-log.src~53ac9e7b5cb023f2:
  Delete: bdb/log/log.src
BitKeeper/deleted/.del-log_findckp.c~24287f008916e81f:
  Delete: bdb/log/log_findckp.c
BitKeeper/deleted/.del-log_rec.c~d51711f2cac09297:
  Delete: bdb/log/log_rec.c
BitKeeper/deleted/.del-log_register.c~b40bb4efac75ca15:
  Delete: bdb/log/log_register.c
BitKeeper/deleted/.del-Design~b3d0f179f2767b:
  Delete: bdb/mp/Design
BitKeeper/deleted/.del-os_finit.c~95dbefc6fe79b26c:
  Delete: bdb/os/os_finit.c
BitKeeper/deleted/.del-os_abs.c~df95d1e7db81924:
  Delete: bdb/os_vxworks/os_abs.c
BitKeeper/deleted/.del-os_finit.c~803b484bdb9d0122:
  Delete: bdb/os_vxworks/os_finit.c
BitKeeper/deleted/.del-os_map.c~3a6d7926398b76d3:
  Delete: bdb/os_vxworks/os_map.c
BitKeeper/deleted/.del-os_finit.c~19a227c6d3c78ad:
  Delete: bdb/os_win32/os_finit.c
BitKeeper/deleted/.del-log-corruption.patch~1cf2ecc7c6408d5d:
  Delete: bdb/patches/log-corruption.patch
BitKeeper/deleted/.del-Btree.pm~af6d0c5eaed4a98e:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB/Btree.pm
BitKeeper/deleted/.del-BerkeleyDB.pm~7244036d4482643:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB.pm
BitKeeper/deleted/.del-BerkeleyDB.pod~e7b18fd6132448e3:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB.pod
BitKeeper/deleted/.del-Hash.pm~10292a26c06a5c95:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB/Hash.pm
BitKeeper/deleted/.del-BerkeleyDB.pod.P~79f76a1495eda203:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB.pod.P
BitKeeper/deleted/.del-BerkeleyDB.xs~80c99afbd98e392c:
  Delete: bdb/perl.BerkeleyDB/BerkeleyDB.xs
BitKeeper/deleted/.del-Changes~729c1891efa60de9:
  Delete: bdb/perl.BerkeleyDB/Changes
BitKeeper/deleted/.del-MANIFEST~63a1e34aecf157a0:
  Delete: bdb/perl.BerkeleyDB/MANIFEST
BitKeeper/deleted/.del-Makefile.PL~c68797707d8df87a:
  Delete: bdb/perl.BerkeleyDB/Makefile.PL
BitKeeper/deleted/.del-README~5f2f579b1a241407:
  Delete: bdb/perl.BerkeleyDB/README
BitKeeper/deleted/.del-Todo~dca3c66c193adda9:
  Delete: bdb/perl.BerkeleyDB/Todo
BitKeeper/deleted/.del-config.in~ae81681e450e0999:
  Delete: bdb/perl.BerkeleyDB/config.in
BitKeeper/deleted/.del-dbinfo~28ad67d83be4f68e:
  Delete: bdb/perl.BerkeleyDB/dbinfo
BitKeeper/deleted/.del-mkconsts~543ab60669c7a04e:
  Delete: bdb/perl.BerkeleyDB/mkconsts
BitKeeper/deleted/.del-mkpod~182c0ca54e439afb:
  Delete: bdb/perl.BerkeleyDB/mkpod
BitKeeper/deleted/.del-5.004~e008cb5a48805543:
  Delete: bdb/perl.BerkeleyDB/patches/5.004
BitKeeper/deleted/.del-irix_6_5.pl~61662bb08afcdec8:
  Delete: bdb/perl.BerkeleyDB/hints/irix_6_5.pl
BitKeeper/deleted/.del-solaris.pl~6771e7182394e152:
  Delete: bdb/perl.BerkeleyDB/hints/solaris.pl
BitKeeper/deleted/.del-typemap~783b8f5295b05f3d:
  Delete: bdb/perl.BerkeleyDB/typemap
BitKeeper/deleted/.del-5.004_01~6081ce2fff7b0bc:
  Delete: bdb/perl.BerkeleyDB/patches/5.004_01
BitKeeper/deleted/.del-5.004_02~87214eac35ad9e6:
  Delete: bdb/perl.BerkeleyDB/patches/5.004_02
BitKeeper/deleted/.del-5.004_03~9a672becec7cb40f:
  Delete: bdb/perl.BerkeleyDB/patches/5.004_03
BitKeeper/deleted/.del-5.004_04~e326cb51af09d154:
  Delete: bdb/perl.BerkeleyDB/patches/5.004_04
BitKeeper/deleted/.del-5.004_05~7ab457a1e41a92fe:
  Delete: bdb/perl.BerkeleyDB/patches/5.004_05
BitKeeper/deleted/.del-5.005~f9e2d59b5964cd4b:
  Delete: bdb/perl.BerkeleyDB/patches/5.005
BitKeeper/deleted/.del-5.005_01~3eb9fb7b5842ea8e:
  Delete: bdb/perl.BerkeleyDB/patches/5.005_01
BitKeeper/deleted/.del-5.005_02~67477ce0bef717cb:
  Delete: bdb/perl.BerkeleyDB/patches/5.005_02
BitKeeper/deleted/.del-5.005_03~c4c29a1fb21e290a:
  Delete: bdb/perl.BerkeleyDB/patches/5.005_03
BitKeeper/deleted/.del-5.6.0~e1fb9897d124ee22:
  Delete: bdb/perl.BerkeleyDB/patches/5.6.0
BitKeeper/deleted/.del-btree.t~e4a1a3c675ddc406:
  Delete: bdb/perl.BerkeleyDB/t/btree.t
BitKeeper/deleted/.del-db-3.0.t~d2c60991d84558f2:
  Delete: bdb/perl.BerkeleyDB/t/db-3.0.t
BitKeeper/deleted/.del-db-3.1.t~6ee88cd13f55e018:
  Delete: bdb/perl.BerkeleyDB/t/db-3.1.t
BitKeeper/deleted/.del-db-3.2.t~f73b6461f98fd1cf:
  Delete: bdb/perl.BerkeleyDB/t/db-3.2.t
BitKeeper/deleted/.del-destroy.t~cc6a2ae1980a2ecd:
  Delete: bdb/perl.BerkeleyDB/t/destroy.t
BitKeeper/deleted/.del-env.t~a8604a4499c4bd07:
  Delete: bdb/perl.BerkeleyDB/t/env.t
BitKeeper/deleted/.del-examples.t~2571b77c3cc75574:
  Delete: bdb/perl.BerkeleyDB/t/examples.t
BitKeeper/deleted/.del-examples.t.T~8228bdd75ac78b88:
  Delete: bdb/perl.BerkeleyDB/t/examples.t.T
BitKeeper/deleted/.del-examples3.t.T~66a186897a87026d:
  Delete: bdb/perl.BerkeleyDB/t/examples3.t.T
BitKeeper/deleted/.del-examples3.t~fe3822ba2f2d7f83:
  Delete: bdb/perl.BerkeleyDB/t/examples3.t
BitKeeper/deleted/.del-filter.t~f87b045c1b708637:
  Delete: bdb/perl.BerkeleyDB/t/filter.t
BitKeeper/deleted/.del-hash.t~616bfb4d644de3a3:
  Delete: bdb/perl.BerkeleyDB/t/hash.t
BitKeeper/deleted/.del-join.t~29fc39f74a83ca22:
  Delete: bdb/perl.BerkeleyDB/t/join.t
BitKeeper/deleted/.del-mldbm.t~31f5015341eea040:
  Delete: bdb/perl.BerkeleyDB/t/mldbm.t
BitKeeper/deleted/.del-queue.t~8f338034ce44a641:
  Delete: bdb/perl.BerkeleyDB/t/queue.t
BitKeeper/deleted/.del-recno.t~d4ddbd3743add63e:
  Delete: bdb/perl.BerkeleyDB/t/recno.t
BitKeeper/deleted/.del-strict.t~6885cdd2ea71ca2d:
  Delete: bdb/perl.BerkeleyDB/t/strict.t
BitKeeper/deleted/.del-subdb.t~aab62a5d5864c603:
  Delete: bdb/perl.BerkeleyDB/t/subdb.t
BitKeeper/deleted/.del-txn.t~65033b8558ae1216:
  Delete: bdb/perl.BerkeleyDB/t/txn.t
BitKeeper/deleted/.del-unknown.t~f3710458682665e1:
  Delete: bdb/perl.BerkeleyDB/t/unknown.t
BitKeeper/deleted/.del-Changes~436f74a5c414c65b:
  Delete: bdb/perl.DB_File/Changes
BitKeeper/deleted/.del-DB_File.pm~ae0951c6c7665a82:
  Delete: bdb/perl.DB_File/DB_File.pm
BitKeeper/deleted/.del-DB_File.xs~89e49a0b5556f1d8:
  Delete: bdb/perl.DB_File/DB_File.xs
BitKeeper/deleted/.del-DB_File_BS~290fad5dbbb87069:
  Delete: bdb/perl.DB_File/DB_File_BS
BitKeeper/deleted/.del-MANIFEST~90ee581572bdd4ac:
  Delete: bdb/perl.DB_File/MANIFEST
BitKeeper/deleted/.del-Makefile.PL~ac0567bb5a377e38:
  Delete: bdb/perl.DB_File/Makefile.PL
BitKeeper/deleted/.del-README~77e924a5a9bae6b3:
  Delete: bdb/perl.DB_File/README
BitKeeper/deleted/.del-config.in~ab4c2792b86a810b:
  Delete: bdb/perl.DB_File/config.in
BitKeeper/deleted/.del-dbinfo~461c43b30fab2cb:
  Delete: bdb/perl.DB_File/dbinfo
BitKeeper/deleted/.del-dynixptx.pl~50dcddfae25d17e9:
  Delete: bdb/perl.DB_File/hints/dynixptx.pl
BitKeeper/deleted/.del-typemap~55cffb3288a9e587:
  Delete: bdb/perl.DB_File/typemap
BitKeeper/deleted/.del-version.c~a4df0e646f8b3975:
  Delete: bdb/perl.DB_File/version.c
BitKeeper/deleted/.del-5.004_01~d6830d0082702af7:
  Delete: bdb/perl.DB_File/patches/5.004_01
BitKeeper/deleted/.del-5.004_02~78b082dc80c91031:
  Delete: bdb/perl.DB_File/patches/5.004_02
BitKeeper/deleted/.del-5.004~4411ec2e3c9e008b:
  Delete: bdb/perl.DB_File/patches/5.004
BitKeeper/deleted/.del-sco.pl~1e795fe14fe4dcfe:
  Delete: bdb/perl.DB_File/hints/sco.pl
BitKeeper/deleted/.del-5.004_03~33f274648b160d95:
  Delete: bdb/perl.DB_File/patches/5.004_03
BitKeeper/deleted/.del-5.004_04~8f3d1b3cf18bb20a:
  Delete: bdb/perl.DB_File/patches/5.004_04
BitKeeper/deleted/.del-5.004_05~9c0f02e7331e142:
  Delete: bdb/perl.DB_File/patches/5.004_05
BitKeeper/deleted/.del-5.005~c2108cb2e3c8d951:
  Delete: bdb/perl.DB_File/patches/5.005
BitKeeper/deleted/.del-5.005_01~3b45e9673afc4cfa:
  Delete: bdb/perl.DB_File/patches/5.005_01
BitKeeper/deleted/.del-5.005_02~9fe5766bb02a4522:
  Delete: bdb/perl.DB_File/patches/5.005_02
BitKeeper/deleted/.del-5.005_03~ffa1c38c19ae72ea:
  Delete: bdb/perl.DB_File/patches/5.005_03
BitKeeper/deleted/.del-5.6.0~373be3a5ce47be85:
  Delete: bdb/perl.DB_File/patches/5.6.0
BitKeeper/deleted/.del-db-btree.t~3231595a1c241eb3:
  Delete: bdb/perl.DB_File/t/db-btree.t
BitKeeper/deleted/.del-db-hash.t~7c4ad0c795c7fad2:
  Delete: bdb/perl.DB_File/t/db-hash.t
BitKeeper/deleted/.del-db-recno.t~6c2d3d80b9ba4a50:
  Delete: bdb/perl.DB_File/t/db-recno.t
BitKeeper/deleted/.del-db_server.sed~cdb00ebcd48a64e2:
  Delete: bdb/rpc_server/db_server.sed
BitKeeper/deleted/.del-db_server_proc.c~d46c8f409c3747f4:
  Delete: bdb/rpc_server/db_server_proc.c
BitKeeper/deleted/.del-db_server_svc.sed~3f5e59f334fa4607:
  Delete: bdb/rpc_server/db_server_svc.sed
BitKeeper/deleted/.del-db_server_util.c~a809f3a4629acda:
  Delete: bdb/rpc_server/db_server_util.c
BitKeeper/deleted/.del-log.tcl~ff1b41f1355b97d7:
  Delete: bdb/test/log.tcl
BitKeeper/deleted/.del-mpool.tcl~b0df4dc1b04db26c:
  Delete: bdb/test/mpool.tcl
BitKeeper/deleted/.del-mutex.tcl~52fd5c73a150565:
  Delete: bdb/test/mutex.tcl
BitKeeper/deleted/.del-txn.tcl~c4ff071550b5446e:
  Delete: bdb/test/txn.tcl
BitKeeper/deleted/.del-README~e800a12a5392010a:
  Delete: bdb/test/upgrade/README
BitKeeper/deleted/.del-pack-2.6.6.pl~89d5076d758d3e98:
  Delete: bdb/test/upgrade/generate-2.X/pack-2.6.6.pl
BitKeeper/deleted/.del-test-2.6.patch~4a52dc83d447547b:
  Delete: bdb/test/upgrade/generate-2.X/test-2.6.patch

1 files changed, 1144 insertions, 0 deletions

diff --git a/bdb/rep/rep_method.c b/bdb/rep/rep_method.c
new file mode 100644
index 00000000000..6773a537f4f
--- /dev/null
+++ b/bdb/rep/rep_method.c
@@ -0,0 +1,1144 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: rep_method.c,v 1.78 2002/09/10 12:58:07 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#ifdef HAVE_RPC
+#include <rpc/rpc.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+#include "dbinc/db_page.h"
+#include "dbinc/db_am.h"
+#include "dbinc/log.h"
+#include "dbinc/rep.h"
+#include "dbinc/txn.h"
+
+#ifdef HAVE_RPC
+#include "dbinc_auto/db_server.h"
+#include "dbinc_auto/rpc_client_ext.h"
+#endif
+
+static int __rep_abort_prepared __P((DB_ENV *));
+static int __rep_bt_cmp __P((DB *, const DBT *, const DBT *));
+static int __rep_client_dbinit __P((DB_ENV *, int));
+static int __rep_elect __P((DB_ENV *, int, int, u_int32_t, int *));
+static int __rep_elect_init __P((DB_ENV *, DB_LSN *, int, int, int, int *));
+static int __rep_flush __P((DB_ENV *));
+static int __rep_restore_prepared __P((DB_ENV *));
+static int __rep_set_limit __P((DB_ENV *, u_int32_t, u_int32_t));
+static int __rep_set_request __P((DB_ENV *, u_int32_t, u_int32_t));
+static int __rep_set_rep_transport __P((DB_ENV *, int,
+    int (*)(DB_ENV *, const DBT *, const DBT *, int, u_int32_t)));
+static int __rep_start __P((DB_ENV *, DBT *, u_int32_t));
+static int __rep_stat __P((DB_ENV *, DB_REP_STAT **, u_int32_t));
+static int __rep_wait __P((DB_ENV *, u_int32_t, int *, u_int32_t));
+
+/*
+ * __rep_dbenv_create --
+ *	Replication-specific initialization of the DB_ENV structure.
+ *
+ * PUBLIC: int __rep_dbenv_create __P((DB_ENV *));
+ */
+int
+__rep_dbenv_create(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_REP *db_rep;
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
+		COMPQUIET(db_rep, NULL);
+		COMPQUIET(ret, 0);
+		dbenv->rep_elect = __dbcl_rep_elect;
+		dbenv->rep_flush = __dbcl_rep_flush;
+		dbenv->rep_process_message = __dbcl_rep_process_message;
+		dbenv->rep_start = __dbcl_rep_start;
+		dbenv->rep_stat = __dbcl_rep_stat;
+		dbenv->set_rep_limit = __dbcl_rep_set_limit;
+		dbenv->set_rep_request = __dbcl_rep_set_request;
+		dbenv->set_rep_transport = __dbcl_rep_set_rep_transport;
+
+	} else
+#endif
+	{
+		dbenv->rep_elect = __rep_elect;
+		dbenv->rep_flush = __rep_flush;
+		dbenv->rep_process_message = __rep_process_message;
+		dbenv->rep_start = __rep_start;
+		dbenv->rep_stat = __rep_stat;
+		dbenv->set_rep_limit = __rep_set_limit;
+		dbenv->set_rep_request = __rep_set_request;
+		dbenv->set_rep_transport = __rep_set_rep_transport;
+		/*
+		 * !!!
+		 * Our caller has not yet had the opportunity to reset the panic
+		 * state or turn off mutex locking, and so we can neither check
+		 * the panic state or acquire a mutex in the DB_ENV create path.
+		 */
+
+		if ((ret = __os_calloc(dbenv, 1, sizeof(DB_REP), &db_rep)) != 0)
+			return (ret);
+		dbenv->rep_handle = db_rep;
+
+		/* Initialize the per-process replication structure. */
+		db_rep->rep_send = NULL;
+	}
+
+	return (0);
+}
+
+/*
+ * __rep_start --
+ *	Become a master or client, and start sending messages to participate
+ * in the replication environment.  Must be called after the environment
+ * is open.
+ */
+static int
+__rep_start(dbenv, dbt, flags)
+	DB_ENV *dbenv;
+	DBT *dbt;
+	u_int32_t flags;
+{
+	DB_LOG *dblp;
+	DB_LSN lsn;
+	DB_REP *db_rep;
+	REP *rep;
+	int announce, init_db, redo_prepared, ret;
+
+	PANIC_CHECK(dbenv);
+	ENV_ILLEGAL_BEFORE_OPEN(dbenv, "rep_start");
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->tx_handle, "rep_stat", DB_INIT_TXN);
+
+	db_rep = dbenv->rep_handle;
+	rep = db_rep->region;
+
+	if ((ret = __db_fchk(dbenv, "DB_ENV->rep_start", flags,
+	    DB_REP_CLIENT | DB_REP_LOGSONLY | DB_REP_MASTER)) != 0)
+		return (ret);
+
+	/* Exactly one of CLIENT and MASTER must be specified. */
+	if ((ret = __db_fcchk(dbenv,
+	    "DB_ENV->rep_start", flags, DB_REP_CLIENT, DB_REP_MASTER)) != 0)
+		return (ret);
+	if (!LF_ISSET(DB_REP_CLIENT | DB_REP_MASTER | DB_REP_LOGSONLY)) {
+		__db_err(dbenv,
+	"DB_ENV->rep_start: replication mode must be specified");
+		return (EINVAL);
+	}
+
+	/* Masters can't be logs-only. */
+	if ((ret = __db_fcchk(dbenv,
+	    "DB_ENV->rep_start", flags, DB_REP_LOGSONLY, DB_REP_MASTER)) != 0)
+		return (ret);
+
+	/* We need a transport function. */
+	if (db_rep->rep_send == NULL) {
+		__db_err(dbenv,
+    "DB_ENV->set_rep_transport must be called before DB_ENV->rep_start");
+		return (EINVAL);
+	}
+	
+	/* We'd better not have any logged files open if we are a client. */
+	if (LF_ISSET(DB_REP_CLIENT) && (ret = __dbreg_nofiles(dbenv)) != 0) {
+		__db_err(dbenv, "DB_ENV->rep_start called with open files");
+		return (ret);
+	}
+
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	if (rep->eid == DB_EID_INVALID)
+		rep->eid = dbenv->rep_eid;
+
+	if (LF_ISSET(DB_REP_MASTER)) {
+		if (F_ISSET(dbenv, DB_ENV_REP_CLIENT)) {
+			/*
+			 * If we're upgrading from having been a client,
+			 * preclose, so that we close our temporary database.
+			 *
+			 * Do not close files that we may have opened while
+			 * doing a rep_apply;  they'll get closed when we
+			 * finally close the environment, but for now, leave
+			 * them open, as we don't want to recycle their
+			 * fileids, and we may need the handles again if
+			 * we become a client and the original master
+			 * that opened them becomes a master again.
+			 */
+			if ((ret = __rep_preclose(dbenv, 0)) != 0)
+				return (ret);
+
+			/*
+			 * Now write a __txn_recycle record so that
+			 * clients don't get confused with our txnids
+			 * and txnids of previous masters.
+			 */
+			F_CLR(dbenv, DB_ENV_REP_CLIENT);
+			if ((ret = __txn_reset(dbenv)) != 0)
+				return (ret);
+		}
+
+		redo_prepared = 0;
+		if (!F_ISSET(rep, REP_F_MASTER)) {
+			/* Master is not yet set. */
+			if (F_ISSET(rep, REP_ISCLIENT)) {
+				F_CLR(rep, REP_ISCLIENT);
+				rep->gen = ++rep->w_gen;
+				redo_prepared = 1;
+			} else if (rep->gen == 0)
+				rep->gen = 1;
+		}
+
+		F_SET(rep, REP_F_MASTER);
+		F_SET(dbenv, DB_ENV_REP_MASTER);
+		MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+		dblp = (DB_LOG *)dbenv->lg_handle;
+		R_LOCK(dbenv, &dblp->reginfo);
+		lsn = ((LOG *)dblp->reginfo.primary)->lsn;
+		R_UNLOCK(dbenv, &dblp->reginfo);
+
+		/*
+		 * Send the NEWMASTER message, then restore prepared txns
+		 * if and only if we just upgraded from being a client.
+		 */
+		if ((ret = __rep_send_message(dbenv,
+		    DB_EID_BROADCAST, REP_NEWMASTER, &lsn, NULL, 0)) == 0 &&
+		    redo_prepared)
+			ret = __rep_restore_prepared(dbenv);
+	} else {
+		F_CLR(dbenv, DB_ENV_REP_MASTER);
+		F_SET(dbenv, DB_ENV_REP_CLIENT);
+		if (LF_ISSET(DB_REP_LOGSONLY))
+			F_SET(dbenv, DB_ENV_REP_LOGSONLY);
+
+		announce = !F_ISSET(rep, REP_ISCLIENT) ||
+		    rep->master_id == DB_EID_INVALID;
+		init_db = 0;
+		if (!F_ISSET(rep, REP_ISCLIENT)) {
+			F_CLR(rep, REP_F_MASTER);
+			if (LF_ISSET(DB_REP_LOGSONLY))
+				F_SET(rep, REP_F_LOGSONLY);
+			else
+				F_SET(rep, REP_F_UPGRADE);
+
+			/*
+			 * We initialize the client's generation number to 0.
+			 * Upon startup, it looks for a master and updates the
+			 * generation number as necessary, exactly as it does
+			 * during normal operation and a master failure.
+			 */
+			rep->gen = 0;
+			rep->master_id = DB_EID_INVALID;
+			init_db = 1;
+		}
+		MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+
+		/*
+		 * Abort any prepared transactions that were restored
+		 * by recovery.  We won't be able to create any txns of
+		 * our own until they're resolved, but we can't resolve
+		 * them ourselves;  the master has to.  If any get
+		 * resolved as commits, we'll redo them when commit
+		 * records come in.  Aborts will simply be ignored.
+		 */
+		if ((ret = __rep_abort_prepared(dbenv)) != 0)
+			return (ret);
+
+		if ((ret = __rep_client_dbinit(dbenv, init_db)) != 0)
+			return (ret);
+
+		/*
+		 * If this client created a newly replicated environment,
+		 * then announce the existence of this client.  The master
+		 * should respond with a message that will tell this client
+		 * the current generation number and the current LSN.  This
+		 * will allow the client to either perform recovery or
+		 * simply join in.
+		 */
+		if (announce)
+			ret = __rep_send_message(dbenv,
+			    DB_EID_BROADCAST, REP_NEWCLIENT, NULL, dbt, 0);
+	}
+	return (ret);
+}
+
+/*
+ * __rep_client_dbinit --
+ *
+ * Initialize the LSN database on the client side.  This is called from the
+ * client initialization code.  The startup flag value indicates if
+ * this is the first thread/process starting up and therefore should create
+ * the LSN database.  This routine must be called once by each process acting
+ * as a client.
+ */
+static int
+__rep_client_dbinit(dbenv, startup)
+	DB_ENV *dbenv;
+	int startup;
+{
+	DB_REP *db_rep;
+	DB *dbp;
+	int ret, t_ret;
+	u_int32_t flags;
+
+	PANIC_CHECK(dbenv);
+	db_rep = dbenv->rep_handle;
+	dbp = NULL;
+
+#define	REPDBNAME	"__db.rep.db"
+
+	/* Check if this has already been called on this environment. */
+	if (db_rep->rep_db != NULL)
+		return (0);
+
+	MUTEX_LOCK(dbenv, db_rep->db_mutexp);
+
+	if (startup) {
+		if ((ret = db_create(&dbp, dbenv, 0)) != 0)
+			goto err;
+		/*
+		 * Ignore errors, because if the file doesn't exist, this
+		 * is perfectly OK.
+		 */
+		(void)dbp->remove(dbp, REPDBNAME, NULL, 0);
+	}
+
+	if ((ret = db_create(&dbp, dbenv, 0)) != 0)
+		goto err;
+	if ((ret = dbp->set_bt_compare(dbp, __rep_bt_cmp)) != 0)
+		goto err;
+
+	/* Allow writes to this database on a client. */
+	F_SET(dbp, DB_AM_CL_WRITER);
+
+	flags = (F_ISSET(dbenv, DB_ENV_THREAD) ? DB_THREAD : 0) |
+	    (startup ? DB_CREATE : 0);
+	if ((ret = dbp->open(dbp, NULL,
+	    "__db.rep.db", NULL, DB_BTREE, flags, 0)) != 0)
+		goto err;
+
+	db_rep->rep_db = dbp;
+
+	if (0) {
+err:		if (dbp != NULL &&
+		    (t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
+			ret = t_ret;
+		db_rep->rep_db = NULL;
+	}
+
+	MUTEX_UNLOCK(dbenv, db_rep->db_mutexp);
+
+	return (ret);
+}
+
+/*
+ * __rep_bt_cmp --
+ *
+ * Comparison function for the LSN table.  We use the entire control
+ * structure as a key (for simplicity, so we don't have to merge the
+ * other fields in the control with the data field), but really only
+ * care about the LSNs.
+ */
+static int
+__rep_bt_cmp(dbp, dbt1, dbt2)
+	DB *dbp;
+	const DBT *dbt1, *dbt2;
+{
+	DB_LSN lsn1, lsn2;
+	REP_CONTROL *rp1, *rp2;
+
+	COMPQUIET(dbp, NULL);
+
+	rp1 = dbt1->data;
+	rp2 = dbt2->data;
+
+	__ua_memcpy(&lsn1, &rp1->lsn, sizeof(DB_LSN));
+	__ua_memcpy(&lsn2, &rp2->lsn, sizeof(DB_LSN));
+
+	if (lsn1.file > lsn2.file)
+		return (1);
+
+	if (lsn1.file < lsn2.file)
+		return (-1);
+
+	if (lsn1.offset > lsn2.offset)
+		return (1);
+
+	if (lsn1.offset < lsn2.offset)
+		return (-1);
+
+	return (0);
+}
+
+/*
+ * __rep_abort_prepared --
+ *	Abort any prepared transactions that recovery restored.
+ *
+ *	This is used by clients that have just run recovery, since
+ * they cannot/should not call txn_recover and handle prepared transactions
+ * themselves.
+ */
+static int
+__rep_abort_prepared(dbenv)
+	DB_ENV *dbenv;
+{
+#define	PREPLISTSIZE	50
+	DB_PREPLIST prep[PREPLISTSIZE], *p;
+	DB_TXNMGR *mgr;
+	DB_TXNREGION *region;
+	int do_aborts, ret;
+	long count, i;
+	u_int32_t op;
+
+	mgr = dbenv->tx_handle;
+	region = mgr->reginfo.primary;
+
+	do_aborts = 0;
+	R_LOCK(dbenv, &mgr->reginfo);
+	if (region->stat.st_nrestores != 0)
+		do_aborts = 1;
+	R_UNLOCK(dbenv, &mgr->reginfo);
+
+	if (do_aborts) {
+		op = DB_FIRST;
+		do {
+			if ((ret = dbenv->txn_recover(dbenv,
+			    prep, PREPLISTSIZE, &count, op)) != 0)
+				return (ret);
+			for (i = 0; i < count; i++) {
+				p = &prep[i];
+				if ((ret = p->txn->abort(p->txn)) != 0)
+					return (ret);
+			}
+			op = DB_NEXT;
+		} while (count == PREPLISTSIZE);
+	}
+
+	return (0);
+}
+
+/*
+ * __rep_restore_prepared --
+ *	Restore to a prepared state any prepared but not yet committed
+ * transactions.
+ *
+ *	This performs, in effect, a "mini-recovery";  it is called from
+ * __rep_start by newly upgraded masters.  There may be transactions that an
+ * old master prepared but did not resolve, which we need to restore to an
+ * active state.
+ */
+static int
+__rep_restore_prepared(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_LOGC *logc;
+	DB_LSN ckp_lsn, lsn;
+	DBT rec;
+	__txn_ckp_args *ckp_args;
+	__txn_regop_args *regop_args;
+	__txn_xa_regop_args *prep_args;
+	int ret, t_ret;
+	u_int32_t hi_txn, low_txn, rectype;
+	void *txninfo;
+
+	txninfo = NULL;
+	ckp_args = NULL;
+	prep_args = NULL;
+	regop_args = NULL;
+	ZERO_LSN(ckp_lsn);
+	ZERO_LSN(lsn);
+
+	if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0)
+		return (ret);
+
+	/*
+	 * We need to consider the set of records between the most recent
+	 * checkpoint LSN and the end of the log;  any txn in that
+	 * range, and only txns in that range, could still have been
+	 * active, and thus prepared but not yet committed (PBNYC),
+	 * when the old master died.
+	 *
+	 * Find the most recent checkpoint LSN, and get the record there.
+	 * If there is no checkpoint in the log, start off by getting
+	 * the very first record in the log instead.
+	 */
+	memset(&rec, 0, sizeof(DBT));
+	if ((ret = __txn_getckp(dbenv, &lsn)) == 0) {
+		if ((ret = logc->get(logc, &lsn, &rec, DB_SET)) != 0)  {
+			__db_err(dbenv,
+			    "Checkpoint record at LSN [%lu][%lu] not found",
+			    (u_long)lsn.file, (u_long)lsn.offset);
+			goto err;
+		}
+
+		if ((ret = __txn_ckp_read(dbenv, rec.data, &ckp_args)) != 0) {
+			__db_err(dbenv,
+			    "Invalid checkpoint record at [%lu][%lu]",
+			    (u_long)lsn.file, (u_long)lsn.offset);
+			goto err;
+		}
+
+		ckp_lsn = ckp_args->ckp_lsn;
+		__os_free(dbenv, ckp_args);
+
+		if ((ret = logc->get(logc, &ckp_lsn, &rec, DB_SET)) != 0) {
+			__db_err(dbenv,
+			    "Checkpoint LSN record [%lu][%lu] not found",
+			    (u_long)ckp_lsn.file, (u_long)ckp_lsn.offset);
+			goto err;
+		}
+	} else if ((ret = logc->get(logc, &lsn, &rec, DB_FIRST)) != 0) {
+		if (ret == DB_NOTFOUND) {
+			/* An empty log means no PBNYC txns. */
+			ret = 0;
+			goto done;
+		}
+		__db_err(dbenv, "Attempt to get first log record failed");
+		goto err;
+	}
+
+	/*
+	 * We use the same txnlist infrastructure that recovery does;
+	 * it demands an estimate of the high and low txnids for
+	 * initialization.
+	 *
+	 * First, the low txnid.
+	 */
+	do {
+		/* txnid is after rectype, which is a u_int32. */
+		memcpy(&low_txn,
+		    (u_int8_t *)rec.data + sizeof(u_int32_t), sizeof(low_txn));
+		if (low_txn != 0)
+			break;
+	} while ((ret = logc->get(logc, &lsn, &rec, DB_NEXT)) == 0);
+
+	/* If there are no txns, there are no PBNYC txns. */
+	if (ret == DB_NOTFOUND) {
+		ret = 0;
+		goto done;
+	} else if (ret != 0)
+		goto err;
+
+	/* Now, the high txnid. */
+	if ((ret = logc->get(logc, &lsn, &rec, DB_LAST)) != 0) {
+		/*
+		 * Note that DB_NOTFOUND is unacceptable here because we
+		 * had to have looked at some log record to get this far.
+		 */
+		__db_err(dbenv, "Final log record not found");
+		goto err;
+	}
+	do {
+		/* txnid is after rectype, which is a u_int32. */
+		memcpy(&hi_txn,
+		    (u_int8_t *)rec.data + sizeof(u_int32_t), sizeof(hi_txn));
+		if (hi_txn != 0)
+			break;
+	} while ((ret = logc->get(logc, &lsn, &rec, DB_PREV)) == 0);
+	if (ret == DB_NOTFOUND) {
+		ret = 0;
+		goto done;
+	} else if (ret != 0)
+		goto err;
+
+	/* We have a high and low txnid.  Initialise the txn list. */
+	if ((ret =
+	    __db_txnlist_init(dbenv, low_txn, hi_txn, NULL, &txninfo)) != 0)
+		goto err;
+
+	/*
+	 * Now, walk backward from the end of the log to ckp_lsn.  Any
+	 * prepares that we hit without first hitting a commit or
+	 * abort belong to PBNYC txns, and we need to apply them and
+	 * restore them to a prepared state.
+	 *
+	 * Note that we wind up applying transactions out of order.
+	 * Since all PBNYC txns still held locks on the old master and
+	 * were isolated, this should be safe.
+	 */
+	for (ret = logc->get(logc, &lsn, &rec, DB_LAST);
+	    ret == 0 && log_compare(&lsn, &ckp_lsn) > 0;
+	    ret = logc->get(logc, &lsn, &rec, DB_PREV)) {
+		memcpy(&rectype, rec.data, sizeof(rectype));
+		switch (rectype) {
+		case DB___txn_regop:
+			/*
+			 * It's a commit or abort--but we don't care
+			 * which!  Just add it to the list of txns
+			 * that are resolved.
+			 */
+			if ((ret = __txn_regop_read(dbenv, rec.data,
+			    &regop_args)) != 0)
+				goto err;
+
+			ret = __db_txnlist_find(dbenv,
+			    txninfo, regop_args->txnid->txnid);
+			if (ret == DB_NOTFOUND)
+				ret = __db_txnlist_add(dbenv, txninfo,
+				    regop_args->txnid->txnid,
+				    regop_args->opcode, &lsn);
+			__os_free(dbenv, regop_args);
+			break;
+		case DB___txn_xa_regop:
+			/*
+			 * It's a prepare.  If we haven't put the
+			 * txn on our list yet, it hasn't been
+			 * resolved, so apply and restore it.
+			 */
+			if ((ret = __txn_xa_regop_read(dbenv, rec.data,
+			    &prep_args)) != 0)
+				goto err;
+			ret = __db_txnlist_find(dbenv, txninfo,
+			    prep_args->txnid->txnid);
+			if (ret == DB_NOTFOUND)
+				if ((ret = __rep_process_txn(dbenv, &rec)) == 0)
+					ret = __txn_restore_txn(dbenv,
+					    &lsn, prep_args);
+			__os_free(dbenv, prep_args);
+			break;
+		default:
+			continue;
+		}
+	}
+
+	/* It's not an error to have hit the beginning of the log. */
+	if (ret == DB_NOTFOUND)
+		ret = 0;
+
+done:
+err:	t_ret = logc->close(logc, 0);
+
+	if (txninfo != NULL)
+		__db_txnlist_end(dbenv, txninfo);
+
+	return (ret == 0 ? t_ret : ret);
+}
+
+/*
+ * __rep_set_limit --
+ *	Set a limit on the amount of data that will be sent during a single
+ * invocation of __rep_process_message.
+ */
+static int
+__rep_set_limit(dbenv, gbytes, bytes)
+	DB_ENV *dbenv;
+	u_int32_t gbytes;
+	u_int32_t bytes;
+{
+	DB_REP *db_rep;
+	REP *rep;
+
+	PANIC_CHECK(dbenv);
+
+	if ((db_rep = dbenv->rep_handle) == NULL) {
+		__db_err(dbenv,
+    "DB_ENV->set_rep_limit: database environment not properly initialized");
+		return (__db_panic(dbenv, EINVAL));
+	}
+	rep = db_rep->region;
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	if (bytes > GIGABYTE) {
+		gbytes += bytes / GIGABYTE;
+		bytes = bytes % GIGABYTE;
+	}
+	rep->gbytes = gbytes;
+	rep->bytes = bytes;
+	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+
+	return (0);
+}
+
+/*
+ * __rep_set_request --
+ *	Set the minimum and maximum number of log records that we wait
+ * before retransmitting.
+ * UNDOCUMENTED.
+ */
+static int
+__rep_set_request(dbenv, min, max)
+	DB_ENV *dbenv;
+	u_int32_t min;
+	u_int32_t max;
+{
+	LOG *lp;
+	DB_LOG *dblp;
+	DB_REP *db_rep;
+	REP *rep;
+
+	PANIC_CHECK(dbenv);
+
+	if ((db_rep = dbenv->rep_handle) == NULL) {
+		__db_err(dbenv,
+    "DB_ENV->set_rep_request: database environment not properly initialized");
+		return (__db_panic(dbenv, EINVAL));
+	}
+	rep = db_rep->region;
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	rep->request_gap = min;
+	rep->max_gap = max;
+	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+	dblp = dbenv->lg_handle;
+	if (dblp != NULL && (lp = dblp->reginfo.primary) != NULL) {
+		R_LOCK(dbenv, &dblp->reginfo);
+		lp->wait_recs = 0;
+		lp->rcvd_recs = 0;
+		R_UNLOCK(dbenv, &dblp->reginfo);
+	}
+
+	return (0);
+}
+
+/*
+ * __rep_set_transport --
+ *	Set the transport function for replication.
+ */
+static int
+__rep_set_rep_transport(dbenv, eid, f_send)
+	DB_ENV *dbenv;
+	int eid;
+	int (*f_send) __P((DB_ENV *, const DBT *, const DBT *, int, u_int32_t));
+{
+	DB_REP *db_rep;
+
+	PANIC_CHECK(dbenv);
+
+	if ((db_rep = dbenv->rep_handle) == NULL) {
+		__db_err(dbenv,
+    "DB_ENV->set_rep_transport: database environment not properly initialized");
+		return (__db_panic(dbenv, EINVAL));
+	}
+
+	if (f_send == NULL) {
+		__db_err(dbenv,
+	"DB_ENV->set_rep_transport: no send function specified");
+		return (EINVAL);
+	}
+
+	if (eid < 0) {
+		__db_err(dbenv,
+	"DB_ENV->set_rep_transport: eid must be greater than or equal to 0");
+		return (EINVAL);
+	}
+
+	db_rep->rep_send = f_send;
+
+	dbenv->rep_eid = eid;
+	return (0);
+}
+
+/*
+ * __rep_elect --
+ *	Called after master failure to hold/participate in an election for
+ *	a new master.
+ */
+static int
+__rep_elect(dbenv, nsites, priority, timeout, eidp)
+	DB_ENV *dbenv;
+	int nsites, priority;
+	u_int32_t timeout;
+	int *eidp;
+{
+	DB_LOG *dblp;
+	DB_LSN lsn;
+	DB_REP *db_rep;
+	REP *rep;
+	int in_progress, ret, send_vote, tiebreaker;
+	u_int32_t pid, sec, usec;
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->tx_handle, "rep_elect", DB_INIT_TXN);
+
+	/* Error checking. */
+	if (nsites <= 0) {
+		__db_err(dbenv,
+		    "DB_ENV->rep_elect: nsites must be greater than 0");
+		return (EINVAL);
+	}
+	if (priority < 0) {
+		__db_err(dbenv,
+		    "DB_ENV->rep_elect: priority may not be negative");
+		return (EINVAL);
+	}
+
+	db_rep = dbenv->rep_handle;
+	rep = db_rep->region;
+	dblp = dbenv->lg_handle;
+
+	R_LOCK(dbenv, &dblp->reginfo);
+	lsn = ((LOG *)dblp->reginfo.primary)->lsn;
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	/* Generate a randomized tiebreaker value. */
+	__os_id(&pid);
+	if ((ret = __os_clock(dbenv, &sec, &usec)) != 0)
+		return (ret);
+	tiebreaker = pid ^ sec ^ usec ^ (u_int)rand() ^ P_TO_UINT32(&pid);
+
+	if ((ret = __rep_elect_init(dbenv,
+	    &lsn, nsites, priority, tiebreaker, &in_progress)) != 0) {
+		if (ret == DB_REP_NEWMASTER) {
+			ret = 0;
+			*eidp = dbenv->rep_eid;
+		}
+		return (ret);
+	}
+
+	if (!in_progress) {
+#ifdef DIAGNOSTIC
+		if (FLD_ISSET(dbenv->verbose, DB_VERB_REPLICATION))
+			__db_err(dbenv, "Beginning an election");
+#endif
+		if ((ret = __rep_send_message(dbenv,
+		    DB_EID_BROADCAST, REP_ELECT, NULL, NULL, 0)) != 0)
+			goto err;
+		DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTSEND, ret, NULL);
+	}
+
+	/* Now send vote */
+	if ((ret =
+	    __rep_send_vote(dbenv, &lsn, nsites, priority, tiebreaker)) != 0)
+		goto err;
+	DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTVOTE1, ret, NULL);
+
+	ret = __rep_wait(dbenv, timeout, eidp, REP_F_EPHASE1);
+	DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTWAIT1, ret, NULL);
+	switch (ret) {
+		case 0:
+			/* Check if election complete or phase complete. */
+			if (*eidp != DB_EID_INVALID)
+				return (0);
+			goto phase2;
+		case DB_TIMEOUT:
+			break;
+		default:
+			goto err;
+	}
+	/*
+	 * If we got here, we haven't heard from everyone, but we've
+	 * run out of time, so it's time to decide if we have enough
+	 * votes to pick a winner and if so, to send out a vote to
+	 * the winner.
+	 */
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	send_vote = DB_EID_INVALID;
+	if (rep->sites > rep->nsites / 2) {
+		/* We think we've seen enough to cast a vote. */
+		send_vote = rep->winner;
+		if (rep->winner == rep->eid)
+			rep->votes++;
+		F_CLR(rep, REP_F_EPHASE1);
+		F_SET(rep, REP_F_EPHASE2);
+	}
+	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+	if (send_vote == DB_EID_INVALID) {
+		/* We do not have enough votes to elect. */
+#ifdef DIAGNOSTIC
+		if (FLD_ISSET(dbenv->verbose, DB_VERB_REPLICATION))
+			__db_err(dbenv,
+			    "Not enough votes to elect: received %d of %d",
+			    rep->sites, rep->nsites);
+#endif
+		ret = DB_REP_UNAVAIL;
+		goto err;
+
+	}
+#ifdef DIAGNOSTIC
+	if (FLD_ISSET(dbenv->verbose, DB_VERB_REPLICATION) &&
+	    send_vote != rep->eid)
+		__db_err(dbenv, "Sending vote");
+#endif
+
+	if (send_vote != rep->eid && (ret = __rep_send_message(dbenv,
+	    send_vote, REP_VOTE2, NULL, NULL, 0)) != 0)
+		goto err;
+	DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTVOTE2, ret, NULL);
+
+phase2:	ret = __rep_wait(dbenv, timeout, eidp, REP_F_EPHASE2);
+	DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTWAIT2, ret, NULL);
+	switch (ret) {
+		case 0:
+			return (0);
+		case DB_TIMEOUT:
+			ret = DB_REP_UNAVAIL;
+			break;
+		default:
+			goto err;
+	}
+
+DB_TEST_RECOVERY_LABEL
+err:	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	ELECTION_DONE(rep);
+	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+
+#ifdef DIAGNOSTIC
+	if (FLD_ISSET(dbenv->verbose, DB_VERB_REPLICATION))
+		__db_err(dbenv, "Ended election with %d", ret);
+#endif
+	return (ret);
+}
+
+/*
+ * __rep_elect_init
+ *	Initialize an election.  Sets beginp non-zero if the election is
+ * already in progress; makes it 0 otherwise.
+ */
+static int
+__rep_elect_init(dbenv, lsnp, nsites, priority, tiebreaker, beginp)
+	DB_ENV *dbenv;
+	DB_LSN *lsnp;
+	int nsites, priority, tiebreaker, *beginp;
+{
+	DB_REP *db_rep;
+	REP *rep;
+	int ret, *tally;
+
+	db_rep = dbenv->rep_handle;
+	rep = db_rep->region;
+
+	ret = 0;
+
+	/* We may miscount, as we don't hold the replication mutex here. */
+	rep->stat.st_elections++;
+
+	/* If we are already a master; simply broadcast that fact and return. */
+	if (F_ISSET(dbenv, DB_ENV_REP_MASTER)) {
+		(void)__rep_send_message(dbenv,
+		    DB_EID_BROADCAST, REP_NEWMASTER, lsnp, NULL, 0);
+		rep->stat.st_elections_won++;
+		return (DB_REP_NEWMASTER);
+	}
+
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	*beginp = IN_ELECTION(rep);
+	if (!*beginp) {
+		/*
+		 * Make sure that we always initialize all the election fields
+		 * before putting ourselves in an election state.  That means
+		 * issuing calls that can fail (allocation) before setting all
+		 * the variables.
+		 */
+		if (nsites > rep->asites &&
+		    (ret = __rep_grow_sites(dbenv, nsites)) != 0)
+			goto err;
+		DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_ELECTINIT, ret, NULL);
+		rep->nsites = nsites;
+		rep->priority = priority;
+		rep->votes = 0;
+		rep->master_id = DB_EID_INVALID;
+		F_SET(rep, REP_F_EPHASE1);
+
+		/* We have always heard from ourselves. */
+		rep->sites = 1;
+		tally = R_ADDR((REGINFO *)dbenv->reginfo, rep->tally_off);
+		tally[0] = rep->eid;
+
+		if (priority != 0) {
+			/* Make ourselves the winner to start. */
+			rep->winner = rep->eid;
+			rep->w_priority = priority;
+			rep->w_gen = rep->gen;
+			rep->w_lsn = *lsnp;
+			rep->w_tiebreaker = tiebreaker;
+		} else {
+			rep->winner = DB_EID_INVALID;
+			rep->w_priority = 0;
+			rep->w_gen = 0;
+			ZERO_LSN(rep->w_lsn);
+			rep->w_tiebreaker = 0;
+		}
+	}
+DB_TEST_RECOVERY_LABEL
+err:	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+	return (ret);
+}
+
+static int
+__rep_wait(dbenv, timeout, eidp, flags)
+	DB_ENV *dbenv;
+	u_int32_t timeout;
+	int *eidp;
+	u_int32_t flags;
+{
+	DB_REP *db_rep;
+	REP *rep;
+	int done, ret;
+	u_int32_t sleeptime;
+
+	done = 0;
+	db_rep = dbenv->rep_handle;
+	rep = db_rep->region;
+
+	/*
+	 * The user specifies an overall timeout function, but checking
+	 * is cheap and the timeout may be a generous upper bound.
+	 * Sleep repeatedly for the smaller of .5s and timeout/10.
+	 */
+	sleeptime = (timeout > 5000000) ? 500000 : timeout / 10;
+	if (sleeptime == 0)
+		sleeptime++;
+	while (timeout > 0) {
+		if ((ret = __os_sleep(dbenv, 0, sleeptime)) != 0)
+			return (ret);
+		MUTEX_LOCK(dbenv, db_rep->mutexp);
+		done = !F_ISSET(rep, flags) && rep->master_id != DB_EID_INVALID;
+
+		*eidp = rep->master_id;
+		MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+
+		if (done)
+			return (0);
+
+		if (timeout > sleeptime)
+			timeout -= sleeptime;
+		else
+			timeout = 0;
+	}
+	return (DB_TIMEOUT);
+}
+
+/*
+ * __rep_flush --
+ *	Re-push the last log record to all clients, in case they've lost
+ * messages and don't know it.
+ */
+static int
+__rep_flush(dbenv)
+	DB_ENV *dbenv;
+{
+	DBT rec;
+	DB_LOGC *logc;
+	DB_LSN lsn;
+	int ret, t_ret;
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->tx_handle, "rep_stat", DB_INIT_TXN);
+
+	if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0)
+		return (ret);
+
+	memset(&rec, 0, sizeof(rec));
+	memset(&lsn, 0, sizeof(lsn));
+
+	if ((ret = logc->get(logc, &lsn, &rec, DB_LAST)) != 0)
+		goto err;
+
+	ret = __rep_send_message(dbenv,
+	    DB_EID_BROADCAST, REP_LOG, &lsn, &rec, 0);
+
+err:	if ((t_ret = logc->close(logc, 0)) != 0 && ret == 0)
+		ret = t_ret;
+	return (ret);
+}
+
+/*
+ * __rep_stat --
+ *	Fetch replication statistics.
+ */
+static int
+__rep_stat(dbenv, statp, flags)
+	DB_ENV *dbenv;
+	DB_REP_STAT **statp;
+	u_int32_t flags;
+{
+	DB_LOG *dblp;
+	DB_REP *db_rep;
+	DB_REP_STAT *stats;
+	LOG *lp;
+	REP *rep;
+	u_int32_t queued;
+	int ret;
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->tx_handle, "rep_stat", DB_INIT_TXN);
+
+	db_rep = dbenv->rep_handle;
+	rep = db_rep->region;
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+
+	*statp = NULL;
+	if ((ret = __db_fchk(dbenv,
+	    "DB_ENV->rep_stat", flags, DB_STAT_CLEAR)) != 0)
+		return (ret);
+
+	/* Allocate a stat struct to return to the user. */
+	if ((ret = __os_umalloc(dbenv, sizeof(DB_REP_STAT), &stats)) != 0)
+		return (ret);
+
+	MUTEX_LOCK(dbenv, db_rep->mutexp);
+	memcpy(stats, &rep->stat, sizeof(*stats));
+
+	/* Copy out election stats. */
+	if (IN_ELECTION(rep)) {
+		if (F_ISSET(rep, REP_F_EPHASE1))
+			stats->st_election_status = 1;
+		else if (F_ISSET(rep, REP_F_EPHASE2))
+			stats->st_election_status = 2;
+
+		stats->st_election_nsites = rep->sites;
+		stats->st_election_cur_winner = rep->winner;
+		stats->st_election_priority = rep->w_priority;
+		stats->st_election_gen = rep->w_gen;
+		stats->st_election_lsn = rep->w_lsn;
+		stats->st_election_votes = rep->votes;
+		stats->st_election_tiebreaker = rep->w_tiebreaker;
+	}
+
+	/* Copy out other info that's protected by the rep mutex. */
+	stats->st_env_id = rep->eid;
+	stats->st_env_priority = rep->priority;
+	stats->st_nsites = rep->nsites;
+	stats->st_master = rep->master_id;
+	stats->st_gen = rep->gen;
+
+	if (F_ISSET(rep, REP_F_MASTER))
+		stats->st_status = DB_REP_MASTER;
+	else if (F_ISSET(rep, REP_F_LOGSONLY))
+		stats->st_status = DB_REP_LOGSONLY;
+	else if (F_ISSET(rep, REP_F_UPGRADE))
+		stats->st_status = DB_REP_CLIENT;
+	else
+		stats->st_status = 0;
+
+	if (LF_ISSET(DB_STAT_CLEAR)) {
+		queued = rep->stat.st_log_queued;
+		memset(&rep->stat, 0, sizeof(rep->stat));
+		rep->stat.st_log_queued = rep->stat.st_log_queued_total =
+		    rep->stat.st_log_queued_max = queued;
+	}
+	MUTEX_UNLOCK(dbenv, db_rep->mutexp);
+
+	/*
+	 * Log-related replication info is stored in the log system and
+	 * protected by the log region lock.
+	 */
+	R_LOCK(dbenv, &dblp->reginfo);
+	if (F_ISSET(rep, REP_ISCLIENT)) {
+		stats->st_next_lsn = lp->ready_lsn;
+		stats->st_waiting_lsn = lp->waiting_lsn;
+	} else {
+		if (F_ISSET(rep, REP_F_MASTER))
+			stats->st_next_lsn = lp->lsn;
+		else
+			ZERO_LSN(stats->st_next_lsn);
+		ZERO_LSN(stats->st_waiting_lsn);
+	}
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	*statp = stats;
+	return (0);
+}