BDB 4.1.24

1 files changed, 262 insertions, 92 deletions

diff --git a/bdb/env/env_method.c b/bdb/env/env_method.c
index 8acb293acca..b51237ec44a 100644
--- a/bdb/env/env_method.c
+++ b/bdb/env/env_method.c
@@ -1,24 +1,24 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1999, 2000
+ * Copyright (c) 1999-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: env_method.c,v 11.31 2000/11/30 00:58:35 ubell Exp $";
+static const char revid[] = "$Id: env_method.c,v 11.87 2002/08/29 14:22:21 margo Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
 #include <sys/types.h>
 
-#include <string.h>
+#ifdef HAVE_RPC
+#include <rpc/rpc.h>
 #endif
 
-#ifdef HAVE_RPC
-#include "db_server.h"
+#include <string.h>
 #endif
 
 /*
@@ -29,41 +29,50 @@ static const char revid[] = "$Id: env_method.c,v 11.31 2000/11/30 00:58:35 ubell
 #define	DB_INITIALIZE_DB_GLOBALS	1
 
 #include "db_int.h"
-#include "db_shash.h"
-#include "db_page.h"
-#include "db_am.h"
-#include "lock.h"
-#include "log.h"
-#include "mp.h"
-#include "txn.h"
+#include "dbinc/crypto.h"
+#include "dbinc/hmac.h"
+#include "dbinc/db_shash.h"
+#include "dbinc/db_page.h"
+#include "dbinc/db_am.h"
+#include "dbinc/lock.h"
+#include "dbinc/log.h"
+#include "dbinc/mp.h"
+#include "dbinc/rep.h"
+#include "dbinc/txn.h"
 
 #ifdef HAVE_RPC
-#include "gen_client_ext.h"
-#include "rpc_client_ext.h"
+#include "dbinc_auto/db_server.h"
+#include "dbinc_auto/rpc_client_ext.h"
 #endif
 
 static void __dbenv_err __P((const DB_ENV *, int, const char *, ...));
 static void __dbenv_errx __P((const DB_ENV *, const char *, ...));
+static int  __dbenv_init __P((DB_ENV *));
+static int  __dbenv_set_alloc __P((DB_ENV *, void *(*)(size_t),
+    void *(*)(void *, size_t), void (*)(void *)));
+static int  __dbenv_set_app_dispatch __P((DB_ENV *,
+    int (*)(DB_ENV *, DBT *, DB_LSN *, db_recops)));
 static int  __dbenv_set_data_dir __P((DB_ENV *, const char *));
+static int  __dbenv_set_encrypt __P((DB_ENV *, const char *, u_int32_t));
 static void __dbenv_set_errcall __P((DB_ENV *, void (*)(const char *, char *)));
 static void __dbenv_set_errfile __P((DB_ENV *, FILE *));
 static void __dbenv_set_errpfx __P((DB_ENV *, const char *));
 static int  __dbenv_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int, int)));
 static int  __dbenv_set_flags __P((DB_ENV *, u_int32_t, int));
-static int  __dbenv_set_mutexlocks __P((DB_ENV *, int));
-static void __dbenv_set_noticecall
-    __P((DB_ENV *, void (*)(DB_ENV *, db_notices)));
+static void __dbenv_set_noticecall __P((DB_ENV *, void (*)(DB_ENV *, db_notices)));
 static int  __dbenv_set_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
-static int  __dbenv_set_recovery_init __P((DB_ENV *, int (*)(DB_ENV *)));
-static int  __dbenv_set_server_noclnt
-    __P((DB_ENV *, char *, long, long, u_int32_t));
+static int  __dbenv_set_rpc_server_noclnt
+    __P((DB_ENV *, void *, const char *, long, long, u_int32_t));
 static int  __dbenv_set_shm_key __P((DB_ENV *, long));
+static int  __dbenv_set_tas_spins __P((DB_ENV *, u_int32_t));
 static int  __dbenv_set_tmp_dir __P((DB_ENV *, const char *));
 static int  __dbenv_set_verbose __P((DB_ENV *, u_int32_t, int));
 
 /*
  * db_env_create --
  *	DB_ENV constructor.
+ *
+ * EXTERN: int db_env_create __P((DB_ENV **, u_int32_t));
  */
 int
 db_env_create(dbenvpp, flags)
@@ -75,6 +84,11 @@ db_env_create(dbenvpp, flags)
 
 	/*
 	 * !!!
+	 * 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.
+	 *
+	 * !!!
 	 * We can't call the flags-checking routines, we don't have an
 	 * environment yet.
 	 */
@@ -91,7 +105,7 @@ db_env_create(dbenvpp, flags)
 	ret = __dbenv_init(dbenv);
 
 	if (ret != 0) {
-		__os_free(dbenv, sizeof(*dbenv));
+		__os_free(NULL, dbenv);
 		return (ret);
 	}
 
@@ -102,14 +116,17 @@ db_env_create(dbenvpp, flags)
 /*
  * __dbenv_init --
  *	Initialize a DB_ENV structure.
- *
- * PUBLIC: int  __dbenv_init __P((DB_ENV *));
  */
-int
+static int
 __dbenv_init(dbenv)
 	DB_ENV *dbenv;
 {
 	/*
+	 * !!!
+	 * 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.
+	 *
 	 * Set up methods that are the same in both normal and RPC
 	 */
 	dbenv->err = __dbenv_err;
@@ -121,44 +138,54 @@ __dbenv_init(dbenv)
 #ifdef	HAVE_RPC
 	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
 		dbenv->close = __dbcl_env_close;
-		dbenv->open = __dbcl_env_open;
+		dbenv->dbremove = __dbcl_env_dbremove;
+		dbenv->dbrename = __dbcl_env_dbrename;
+		dbenv->open = __dbcl_env_open_wrap;
 		dbenv->remove = __dbcl_env_remove;
+		dbenv->set_alloc = __dbcl_env_alloc;
+		dbenv->set_app_dispatch = __dbcl_set_app_dispatch;
 		dbenv->set_data_dir = __dbcl_set_data_dir;
+		dbenv->set_encrypt = __dbcl_env_encrypt;
 		dbenv->set_feedback = __dbcl_env_set_feedback;
 		dbenv->set_flags = __dbcl_env_flags;
-		dbenv->set_mutexlocks = __dbcl_set_mutex_locks;
 		dbenv->set_noticecall = __dbcl_env_noticecall;
 		dbenv->set_paniccall = __dbcl_env_paniccall;
-		dbenv->set_recovery_init = __dbcl_set_recovery_init;
-		dbenv->set_server = __dbcl_envserver;
+		dbenv->set_rpc_server = __dbcl_envrpcserver;
 		dbenv->set_shm_key = __dbcl_set_shm_key;
+		dbenv->set_tas_spins = __dbcl_set_tas_spins;
+		dbenv->set_timeout = __dbcl_set_timeout;
 		dbenv->set_tmp_dir = __dbcl_set_tmp_dir;
 		dbenv->set_verbose = __dbcl_set_verbose;
 	} else {
 #endif
 		dbenv->close = __dbenv_close;
+		dbenv->dbremove = __dbenv_dbremove;
+		dbenv->dbrename = __dbenv_dbrename;
 		dbenv->open = __dbenv_open;
 		dbenv->remove = __dbenv_remove;
+		dbenv->set_alloc = __dbenv_set_alloc;
+		dbenv->set_app_dispatch = __dbenv_set_app_dispatch;
 		dbenv->set_data_dir = __dbenv_set_data_dir;
+		dbenv->set_encrypt = __dbenv_set_encrypt;
 		dbenv->set_feedback = __dbenv_set_feedback;
 		dbenv->set_flags = __dbenv_set_flags;
-		dbenv->set_mutexlocks = __dbenv_set_mutexlocks;
 		dbenv->set_noticecall = __dbenv_set_noticecall;
 		dbenv->set_paniccall = __dbenv_set_paniccall;
-		dbenv->set_recovery_init = __dbenv_set_recovery_init;
-		dbenv->set_server = __dbenv_set_server_noclnt;
+		dbenv->set_rpc_server = __dbenv_set_rpc_server_noclnt;
 		dbenv->set_shm_key = __dbenv_set_shm_key;
+		dbenv->set_tas_spins = __dbenv_set_tas_spins;
 		dbenv->set_tmp_dir = __dbenv_set_tmp_dir;
 		dbenv->set_verbose = __dbenv_set_verbose;
 #ifdef	HAVE_RPC
 	}
 #endif
 	dbenv->shm_key = INVALID_REGION_SEGID;
-	dbenv->db_mutexlocks = 1;
+	dbenv->db_ref = 0;
 
 	__log_dbenv_create(dbenv);		/* Subsystem specific. */
 	__lock_dbenv_create(dbenv);
 	__memp_dbenv_create(dbenv);
+	__rep_dbenv_create(dbenv);
 	__txn_dbenv_create(dbenv);
 
 	return (0);
@@ -179,16 +206,7 @@ __dbenv_err(dbenv, error, fmt, va_alist)
 	va_dcl
 #endif
 {
-	va_list ap;
-
-#ifdef __STDC__
-	va_start(ap, fmt);
-#else
-	va_start(ap);
-#endif
-	__db_real_err(dbenv, error, 1, 1, fmt, ap);
-
-	va_end(ap);
+	DB_REAL_ERR(dbenv, error, 1, 1, fmt);
 }
 
 /*
@@ -205,16 +223,109 @@ __dbenv_errx(dbenv, fmt, va_alist)
 	va_dcl
 #endif
 {
-	va_list ap;
+	DB_REAL_ERR(dbenv, 0, 0, 1, fmt);
+}
 
-#ifdef __STDC__
-	va_start(ap, fmt);
+static int
+__dbenv_set_alloc(dbenv, mal_func, real_func, free_func)
+	DB_ENV *dbenv;
+	void *(*mal_func) __P((size_t));
+	void *(*real_func) __P((void *, size_t));
+	void (*free_func) __P((void *));
+{
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_alloc");
+
+	dbenv->db_malloc = mal_func;
+	dbenv->db_realloc = real_func;
+	dbenv->db_free = free_func;
+	return (0);
+}
+
+/*
+ * __dbenv_set_app_dispatch --
+ *	Set the transaction abort recover function.
+ */
+static int
+__dbenv_set_app_dispatch(dbenv, app_dispatch)
+	DB_ENV *dbenv;
+	int (*app_dispatch) __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
+{
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_app_dispatch");
+
+	dbenv->app_dispatch = app_dispatch;
+	return (0);
+}
+
+static int
+__dbenv_set_encrypt(dbenv, passwd, flags)
+	DB_ENV *dbenv;
+	const char *passwd;
+	u_int32_t flags;
+{
+#ifdef HAVE_CRYPTO
+	DB_CIPHER *db_cipher;
+	int ret;
+
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_encrypt");
+#define	OK_CRYPTO_FLAGS	(DB_ENCRYPT_AES)
+
+	if (flags != 0 && LF_ISSET(~OK_CRYPTO_FLAGS))
+		return (__db_ferr(dbenv, "DB_ENV->set_encrypt", 0));
+
+	if (passwd == NULL || strlen(passwd) == 0) {
+		__db_err(dbenv, "Empty password specified to set_encrypt");
+		return (EINVAL);
+	}
+	if (!CRYPTO_ON(dbenv)) {
+		if ((ret = __os_calloc(dbenv, 1, sizeof(DB_CIPHER), &db_cipher))
+		    != 0)
+			goto err;
+		dbenv->crypto_handle = db_cipher;
+	} else
+		db_cipher = (DB_CIPHER *)dbenv->crypto_handle;
+
+	if (dbenv->passwd != NULL)
+		__os_free(dbenv, dbenv->passwd);
+	if ((ret = __os_strdup(dbenv, passwd, &dbenv->passwd)) != 0) {
+		__os_free(dbenv, db_cipher);
+		goto err;
+	}
+	/*
+	 * We're going to need this often enough to keep around
+	 */
+	dbenv->passwd_len = strlen(dbenv->passwd) + 1;
+	/*
+	 * The MAC key is for checksumming, and is separate from
+	 * the algorithm.  So initialize it here, even if they
+	 * are using CIPHER_ANY.
+	 */
+	__db_derive_mac((u_int8_t *)dbenv->passwd,
+	    dbenv->passwd_len, db_cipher->mac_key);
+	switch (flags) {
+	case 0:
+		F_SET(db_cipher, CIPHER_ANY);
+		break;
+	case DB_ENCRYPT_AES:
+		if ((ret = __crypto_algsetup(dbenv, db_cipher, CIPHER_AES, 0))
+		    != 0)
+			goto err1;
+		break;
+	}
+	return (0);
+
+err1:
+	__os_free(dbenv, dbenv->passwd);
+	__os_free(dbenv, db_cipher);
+	dbenv->crypto_handle = NULL;
+err:
+	return (ret);
 #else
-	va_start(ap);
-#endif
-	__db_real_err(dbenv, 0, 0, 1, fmt, ap);
+	COMPQUIET(dbenv, NULL);
+	COMPQUIET(passwd, NULL);
+	COMPQUIET(flags, 0);
 
-	va_end(ap);
+	return (__db_eopnotsup(dbenv));
+#endif
 }
 
 static int
@@ -223,11 +334,23 @@ __dbenv_set_flags(dbenv, flags, onoff)
 	u_int32_t flags;
 	int onoff;
 {
-#define	OK_FLAGS	(DB_CDB_ALLDB | DB_NOMMAP | DB_TXN_NOSYNC)
+#define	OK_FLAGS							\
+	(DB_AUTO_COMMIT | DB_CDB_ALLDB | DB_DIRECT_DB | DB_DIRECT_LOG |	\
+	    DB_NOLOCKING | DB_NOMMAP | DB_NOPANIC | DB_OVERWRITE |	\
+	    DB_PANIC_ENVIRONMENT | DB_REGION_INIT | DB_TXN_NOSYNC |	\
+	    DB_TXN_WRITE_NOSYNC | DB_YIELDCPU)
 
 	if (LF_ISSET(~OK_FLAGS))
-		return (__db_ferr(dbenv, "DBENV->set_flags", 0));
+		return (__db_ferr(dbenv, "DB_ENV->set_flags", 0));
+	if (onoff && LF_ISSET(DB_TXN_WRITE_NOSYNC) && LF_ISSET(DB_TXN_NOSYNC))
+		return (__db_ferr(dbenv, "DB_ENV->set_flags", 1));
 
+	if (LF_ISSET(DB_AUTO_COMMIT)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_AUTO_COMMIT);
+		else
+			F_CLR(dbenv, DB_ENV_AUTO_COMMIT);
+	}
 	if (LF_ISSET(DB_CDB_ALLDB)) {
 		ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_flags: DB_CDB_ALLDB");
 		if (onoff)
@@ -235,18 +358,72 @@ __dbenv_set_flags(dbenv, flags, onoff)
 		else
 			F_CLR(dbenv, DB_ENV_CDB_ALLDB);
 	}
+	if (LF_ISSET(DB_DIRECT_DB)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_DIRECT_DB);
+		else
+			F_CLR(dbenv, DB_ENV_DIRECT_DB);
+	}
+	if (LF_ISSET(DB_DIRECT_LOG)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_DIRECT_LOG);
+		else
+			F_CLR(dbenv, DB_ENV_DIRECT_LOG);
+	}
+	if (LF_ISSET(DB_NOLOCKING)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_NOLOCKING);
+		else
+			F_CLR(dbenv, DB_ENV_NOLOCKING);
+	}
 	if (LF_ISSET(DB_NOMMAP)) {
 		if (onoff)
 			F_SET(dbenv, DB_ENV_NOMMAP);
 		else
 			F_CLR(dbenv, DB_ENV_NOMMAP);
 	}
+	if (LF_ISSET(DB_NOPANIC)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_NOPANIC);
+		else
+			F_CLR(dbenv, DB_ENV_NOPANIC);
+	}
+	if (LF_ISSET(DB_OVERWRITE)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_OVERWRITE);
+		else
+			F_CLR(dbenv, DB_ENV_OVERWRITE);
+	}
+	if (LF_ISSET(DB_PANIC_ENVIRONMENT)) {
+		ENV_ILLEGAL_BEFORE_OPEN(dbenv,
+		    "set_flags: DB_PANIC_ENVIRONMENT");
+		PANIC_SET(dbenv, onoff);
+	}
+	if (LF_ISSET(DB_REGION_INIT)) {
+		ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_flags: DB_REGION_INIT");
+		if (onoff)
+			F_SET(dbenv, DB_ENV_REGION_INIT);
+		else
+			F_CLR(dbenv, DB_ENV_REGION_INIT);
+	}
 	if (LF_ISSET(DB_TXN_NOSYNC)) {
 		if (onoff)
 			F_SET(dbenv, DB_ENV_TXN_NOSYNC);
 		else
 			F_CLR(dbenv, DB_ENV_TXN_NOSYNC);
 	}
+	if (LF_ISSET(DB_TXN_WRITE_NOSYNC)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_TXN_WRITE_NOSYNC);
+		else
+			F_CLR(dbenv, DB_ENV_TXN_WRITE_NOSYNC);
+	}
+	if (LF_ISSET(DB_YIELDCPU)) {
+		if (onoff)
+			F_SET(dbenv, DB_ENV_YIELDCPU);
+		else
+			F_CLR(dbenv, DB_ENV_YIELDCPU);
+	}
 	return (0);
 }
 
@@ -267,7 +444,7 @@ __dbenv_set_data_dir(dbenv, dir)
 		dbenv->data_cnt *= 2;
 		if ((ret = __os_realloc(dbenv,
 		    dbenv->data_cnt * sizeof(char **),
-		    NULL, &dbenv->db_data_dir)) != 0)
+		    &dbenv->db_data_dir)) != 0)
 			return (ret);
 	}
 	return (__os_strdup(dbenv,
@@ -314,16 +491,7 @@ __dbenv_set_noticecall(dbenv, noticecall)
 {
 	dbenv->db_noticecall = noticecall;
 }
-
-static int
-__dbenv_set_mutexlocks(dbenv, onoff)
-	DB_ENV *dbenv;
-	int onoff;
-{
-	dbenv->db_mutexlocks = onoff;
-	return (0);
-}
-
+			
 static int
 __dbenv_set_paniccall(dbenv, paniccall)
 	DB_ENV *dbenv;
@@ -334,25 +502,22 @@ __dbenv_set_paniccall(dbenv, paniccall)
 }
 
 static int
-__dbenv_set_recovery_init(dbenv, recovery_init)
+__dbenv_set_shm_key(dbenv, shm_key)
 	DB_ENV *dbenv;
-	int (*recovery_init) __P((DB_ENV *));
+	long shm_key;			/* !!!: really a key_t. */
 {
-	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_recovery_init");
-
-	dbenv->db_recovery_init = recovery_init;
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_shm_key");
 
+	dbenv->shm_key = shm_key;
 	return (0);
 }
 
 static int
-__dbenv_set_shm_key(dbenv, shm_key)
+__dbenv_set_tas_spins(dbenv, tas_spins)
 	DB_ENV *dbenv;
-	long shm_key;			/* !!!: really a key_t. */
+	u_int32_t tas_spins;
 {
-	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_shm_key");
-
-	dbenv->shm_key = shm_key;
+	dbenv->tas_spins = tas_spins;
 	return (0);
 }
 
@@ -362,7 +527,7 @@ __dbenv_set_tmp_dir(dbenv, dir)
 	const char *dir;
 {
 	if (dbenv->db_tmp_dir != NULL)
-		__os_freestr(dbenv->db_tmp_dir);
+		__os_free(dbenv, dbenv->db_tmp_dir);
 	return (__os_strdup(dbenv, dir, &dbenv->db_tmp_dir));
 }
 
@@ -376,6 +541,7 @@ __dbenv_set_verbose(dbenv, which, onoff)
 	case DB_VERB_CHKPOINT:
 	case DB_VERB_DEADLOCK:
 	case DB_VERB_RECOVERY:
+	case DB_VERB_REPLICATION:
 	case DB_VERB_WAITSFOR:
 		if (onoff)
 			FLD_SET(dbenv->verbose, which);
@@ -399,7 +565,7 @@ __db_mi_env(dbenv, name)
 	DB_ENV *dbenv;
 	const char *name;
 {
-	__db_err(dbenv, "%s: method meaningless in shared environment", name);
+	__db_err(dbenv, "%s: method not permitted in shared environment", name);
 	return (EINVAL);
 }
 
@@ -415,59 +581,63 @@ __db_mi_open(dbenv, name, after)
 	const char *name;
 	int after;
 {
-	__db_err(dbenv,
-	    "%s: method meaningless %s open", name, after ? "after" : "before");
+	__db_err(dbenv, "%s: method not permitted %s open",
+	    name, after ? "after" : "before");
 	return (EINVAL);
 }
 
 /*
  * __db_env_config --
- *	Method or function called without subsystem being configured.
+ *	Method or function called without required configuration.
  *
- * PUBLIC: int __db_env_config __P((DB_ENV *, int));
+ * PUBLIC: int __db_env_config __P((DB_ENV *, char *, u_int32_t));
  */
 int
-__db_env_config(dbenv, subsystem)
+__db_env_config(dbenv, i, flags)
 	DB_ENV *dbenv;
-	int subsystem;
+	char *i;
+	u_int32_t flags;
 {
-	const char *name;
+	char *sub;
 
-	switch (subsystem) {
+	switch (flags) {
 	case DB_INIT_LOCK:
-		name = "lock";
+		sub = "locking";
 		break;
 	case DB_INIT_LOG:
-		name = "log";
+		sub = "logging";
 		break;
 	case DB_INIT_MPOOL:
-		name = "mpool";
+		sub = "memory pool";
 		break;
 	case DB_INIT_TXN:
-		name = "txn";
+		sub = "transaction";
 		break;
 	default:
-		name = "unknown";
+		sub = "<unspecified>";
 		break;
 	}
 	__db_err(dbenv,
-    "%s interface called with environment not configured for that subsystem",
-	    name);
+    "%s interface requires an environment configured for the %s subsystem",
+	    i, sub);
 	return (EINVAL);
 }
 
 static int
-__dbenv_set_server_noclnt(dbenv, host, tsec, ssec, flags)
+__dbenv_set_rpc_server_noclnt(dbenv, cl, host, tsec, ssec, flags)
 	DB_ENV *dbenv;
-	char *host;
+	void *cl;
+	const char *host;
 	long tsec, ssec;
 	u_int32_t flags;
 {
 	COMPQUIET(host, NULL);
+	COMPQUIET(cl, NULL);
 	COMPQUIET(tsec, 0);
 	COMPQUIET(ssec, 0);
 	COMPQUIET(flags, 0);
 
-	__db_err(dbenv, "set_server method meaningless in non-RPC enviroment");
+	__db_err(dbenv,
+	    "set_rpc_server method not permitted in non-RPC environment");
 	return (__db_eopnotsup(dbenv));
 }