Initial revision

CVS patchset: 4644
CVS date: 2001/03/21 18:33:35

6 files changed, 980 insertions, 0 deletions

diff --git a/db/common/db_byteorder.c b/db/common/db_byteorder.c
new file mode 100644
index 000000000..d089cfe4c
--- /dev/null
+++ b/db/common/db_byteorder.c
@@ -0,0 +1,62 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: db_byteorder.c,v 11.4 2000/11/30 00:58:31 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#ifdef HAVE_ENDIAN_H
+#include <endian.h>
+#if BYTE_ORDER == BIG_ENDIAN
+#define	WORDS_BIGENDIAN	1
+#endif
+#endif
+
+#endif
+
+#include "db_int.h"
+#include "common_ext.h"
+
+/*
+ * __db_byteorder --
+ *	Return if we need to do byte swapping, checking for illegal
+ *	values.
+ *
+ * PUBLIC: int __db_byteorder __P((DB_ENV *, int));
+ */
+int
+__db_byteorder(dbenv, lorder)
+	DB_ENV *dbenv;
+	int lorder;
+{
+	switch (lorder) {
+	case 0:
+		break;
+	case 1234:
+#if defined(WORDS_BIGENDIAN)
+		return (DB_SWAPBYTES);
+#else
+		break;
+#endif
+	case 4321:
+#if defined(WORDS_BIGENDIAN)
+		break;
+#else
+		return (DB_SWAPBYTES);
+#endif
+	default:
+		__db_err(dbenv,
+	    "unsupported byte order, only big and little-endian supported");
+		return (EINVAL);
+	}
+	return (0);
+}
diff --git a/db/common/db_err.c b/db/common/db_err.c
new file mode 100644
index 000000000..d69bd023d
--- /dev/null
+++ b/db/common/db_err.c
@@ -0,0 +1,544 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: db_err.c,v 11.38 2001/01/22 21:50:25 sue Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "db_shash.h"
+#include "lock.h"
+#include "lock_ext.h"
+#include "log.h"
+#include "log_ext.h"
+#include "mp.h"
+#include "mp_ext.h"
+#include "txn.h"
+#include "txn_ext.h"
+#include "clib_ext.h"
+#include "common_ext.h"
+#include "db_auto.h"
+
+static void __db_errcall __P((const DB_ENV *, int, int, const char *, va_list));
+static void __db_errfile __P((const DB_ENV *, int, int, const char *, va_list));
+
+/*
+ * __db_fchk --
+ *	General flags checking routine.
+ *
+ * PUBLIC: int __db_fchk __P((DB_ENV *, const char *, u_int32_t, u_int32_t));
+ */
+int
+__db_fchk(dbenv, name, flags, ok_flags)
+	DB_ENV *dbenv;
+	const char *name;
+	u_int32_t flags, ok_flags;
+{
+	return (LF_ISSET(~ok_flags) ? __db_ferr(dbenv, name, 0) : 0);
+}
+
+/*
+ * __db_fcchk --
+ *	General combination flags checking routine.
+ *
+ * PUBLIC: int __db_fcchk
+ * PUBLIC:    __P((DB_ENV *, const char *, u_int32_t, u_int32_t, u_int32_t));
+ */
+int
+__db_fcchk(dbenv, name, flags, flag1, flag2)
+	DB_ENV *dbenv;
+	const char *name;
+	u_int32_t flags, flag1, flag2;
+{
+	return (LF_ISSET(flag1) &&
+	    LF_ISSET(flag2) ? __db_ferr(dbenv, name, 1) : 0);
+}
+
+/*
+ * __db_ferr --
+ *	Common flag errors.
+ *
+ * PUBLIC: int __db_ferr __P((const DB_ENV *, const char *, int));
+ */
+int
+__db_ferr(dbenv, name, iscombo)
+	const DB_ENV *dbenv;
+	const char *name;
+	int iscombo;
+{
+	__db_err(dbenv, "illegal flag %sspecified to %s",
+	    iscombo ? "combination " : "", name);
+	return (EINVAL);
+}
+
+/*
+ * __db_pgerr --
+ *	Error when unable to retrieve a specified page.
+ *
+ * PUBLIC: int __db_pgerr __P((DB *, db_pgno_t));
+ */
+int
+__db_pgerr(dbp, pgno)
+	DB *dbp;
+	db_pgno_t pgno;
+{
+	/*
+	 * Three things are certain:
+	 * Death, taxes, and lost data.
+	 * Guess which has occurred.
+	 */
+	__db_err(dbp->dbenv,
+	    "unable to create/retrieve page %lu", (u_long)pgno);
+	return (__db_panic(dbp->dbenv, EIO));
+}
+
+/*
+ * __db_pgfmt --
+ *	Error when a page has the wrong format.
+ *
+ * PUBLIC: int __db_pgfmt __P((DB *, db_pgno_t));
+ */
+int
+__db_pgfmt(dbp, pgno)
+	DB *dbp;
+	db_pgno_t pgno;
+{
+	__db_err(dbp->dbenv,
+	    "page %lu: illegal page type or format", (u_long)pgno);
+	return (__db_panic(dbp->dbenv, EINVAL));
+}
+
+/*
+ * __db_eopnotsup --
+ *	Common operation not supported message.
+ *
+ * PUBLIC: int __db_eopnotsup __P((const DB_ENV *));
+ */
+int
+__db_eopnotsup(dbenv)
+	const DB_ENV *dbenv;
+{
+	__db_err(dbenv, "operation not supported");
+#ifdef EOPNOTSUPP
+	return (EOPNOTSUPP);
+#else
+	return (EINVAL);
+#endif
+}
+
+#ifdef DIAGNOSTIC
+/*
+ * __db_assert --
+ *	Error when an assertion fails.  Only checked if #DIAGNOSTIC defined.
+ *
+ * PUBLIC: #ifdef DIAGNOSTIC
+ * PUBLIC: void __db_assert __P((const char *, const char *, int));
+ * PUBLIC: #endif
+ */
+void
+__db_assert(failedexpr, file, line)
+	const char *failedexpr, *file;
+	int line;
+{
+	(void)fprintf(stderr,
+	    "__db_assert: \"%s\" failed: file \"%s\", line %d\n",
+	    failedexpr, file, line);
+	fflush(stderr);
+
+	/* We want a stack trace of how this could possibly happen. */
+	abort();
+
+	/* NOTREACHED */
+}
+#endif
+
+/*
+ * __db_panic_msg --
+ *	Just report that someone else paniced.
+ *
+ * PUBLIC: int __db_panic_msg __P((DB_ENV *));
+ */
+int
+__db_panic_msg(dbenv)
+	DB_ENV *dbenv;
+{
+	__db_err(dbenv, "region error detected; run recovery.");
+	return (DB_RUNRECOVERY);
+}
+
+/*
+ * __db_panic --
+ *	Lock out the tree due to unrecoverable error.
+ *
+ * PUBLIC: int __db_panic __P((DB_ENV *, int));
+ */
+int
+__db_panic(dbenv, errval)
+	DB_ENV *dbenv;
+	int errval;
+{
+
+	if (dbenv != NULL) {
+		((REGENV *)((REGINFO *)dbenv->reginfo)->primary)->panic = 1;
+
+		dbenv->db_panic = errval;
+
+		__db_err(dbenv, "PANIC: %s", db_strerror(errval));
+
+		if (dbenv->db_paniccall != NULL)
+			dbenv->db_paniccall(dbenv, errval);
+	}
+
+	/*
+	 * Chaos reigns within.
+	 * Reflect, repent, and reboot.
+	 * Order shall return.
+	 */
+	return (DB_RUNRECOVERY);
+}
+
+/*
+ * db_strerror --
+ *	ANSI C strerror(3) for DB.
+ */
+char *
+db_strerror(error)
+	int error;
+{
+	if (error == 0)
+		return ("Successful return: 0");
+	if (error > 0)
+		return (strerror(error));
+
+	/*
+	 * !!!
+	 * The Tcl API requires that some of these return strings be compared
+	 * against strings stored in application scripts.  So, any of these
+	 * errors that do not invariably result in a Tcl exception may not be
+	 * altered.
+	 */
+	switch (error) {
+	case DB_INCOMPLETE:
+		return ("DB_INCOMPLETE: Cache flush was unable to complete");
+	case DB_KEYEMPTY:
+		return ("DB_KEYEMPTY: Non-existent key/data pair");
+	case DB_KEYEXIST:
+		return ("DB_KEYEXIST: Key/data pair already exists");
+	case DB_LOCK_DEADLOCK:
+		return
+		    ("DB_LOCK_DEADLOCK: Locker killed to resolve a deadlock");
+	case DB_LOCK_NOTGRANTED:
+		return ("DB_LOCK_NOTGRANTED: Lock not granted");
+	case DB_NOSERVER:
+		return ("DB_NOSERVER: Fatal error, no server");
+	case DB_NOSERVER_HOME:
+		return ("DB_NOSERVER_HOME: Home unrecognized at server");
+	case DB_NOSERVER_ID:
+		return ("DB_NOSERVER_ID: Identifier unrecognized at server");
+	case DB_NOTFOUND:
+		return ("DB_NOTFOUND: No matching key/data pair found");
+	case DB_OLD_VERSION:
+		return ("DB_OLDVERSION: Database requires a version upgrade");
+	case DB_RUNRECOVERY:
+		return ("DB_RUNRECOVERY: Fatal error, run database recovery");
+	case DB_VERIFY_BAD:
+		return ("DB_VERIFY_BAD: Database verification failed");
+	default: {
+		/*
+		 * !!!
+		 * Room for a 64-bit number + slop.  This buffer is only used
+		 * if we're given an unknown error, which should never happen.
+		 * Note, however, we're no longer thread-safe if it does.
+		 */
+		static char ebuf[40];
+
+		(void)snprintf(ebuf, sizeof(ebuf), "Unknown error: %d", error);
+		return (ebuf);
+	}
+	}
+}
+
+/*
+ * __db_err --
+ *	Standard DB error routine.  The same as db_errx, except that we
+ *	don't write to stderr if no output mechanism was specified.
+ *
+ * PUBLIC: void __db_err __P((const DB_ENV *, const char *, ...));
+ */
+void
+#ifdef __STDC__
+__db_err(const DB_ENV *dbenv, const char *fmt, ...)
+#else
+__db_err(dbenv, fmt, va_alist)
+	const DB_ENV *dbenv;
+	const char *fmt;
+	va_dcl
+#endif
+{
+	va_list ap;
+
+/*
+	XXX
+	Log the message.
+
+	It would be nice to automatically log the error into the log files
+	if the application is configured for logging.  The problem is that
+	if we currently hold the log region mutex, we will self-deadlock.
+	Leave all the structure in place, but turned off.  I'd like to fix
+	this in the future by detecting if we have the log region already
+	locked (e.g., a flag in the environment handle), or perhaps even
+	have a finer granularity so that the only calls to __db_err we
+	can't log are those made while we have the current log buffer
+	locked, or perhaps have a separate buffer into which we log error
+	messages.
+
+#ifdef __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
+	__db_real_log(dbenv, NULL, "db_err", 0, fmt, ap);
+
+	va_end(ap);
+#endif
+*/
+
+	/* Tell the application. */
+#ifdef __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
+	__db_real_err(dbenv, 0, 0, 0, fmt, ap);
+
+	va_end(ap);
+}
+
+/*
+ * __db_real_err --
+ *	All the DB error routines end up here.
+ *
+ * PUBLIC: void __db_real_err
+ * PUBLIC:     __P((const DB_ENV *, int, int, int, const char *, va_list));
+ */
+void
+__db_real_err(dbenv, error, error_set, stderr_default, fmt, ap)
+	const DB_ENV *dbenv;
+	int error, error_set, stderr_default;
+	const char *fmt;
+	va_list ap;
+{
+	/* Call the user's callback function, if specified. */
+	if (dbenv != NULL && dbenv->db_errcall != NULL)
+		__db_errcall(dbenv, error, error_set, fmt, ap);
+
+	/* Write to the user's file descriptor, if specified. */
+	if (dbenv != NULL && dbenv->db_errfile != NULL)
+		__db_errfile(dbenv, error, error_set, fmt, ap);
+
+	/*
+	 * If we have a default and we didn't do either of the above, write
+	 * to the default.
+	 */
+	if (stderr_default && (dbenv == NULL ||
+	    (dbenv->db_errcall == NULL && dbenv->db_errfile == NULL)))
+		__db_errfile(dbenv, error, error_set, fmt, ap);
+}
+
+/*
+ * __db_errcall --
+ *	Do the error message work for callback functions.
+ */
+static void
+__db_errcall(dbenv, error, error_set, fmt, ap)
+	const DB_ENV *dbenv;
+	int error, error_set;
+	const char *fmt;
+	va_list ap;
+{
+	char *p;
+	char __errbuf[2048];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+
+	p = __errbuf;
+	if (fmt != NULL) {
+		p += vsnprintf(__errbuf, sizeof(__errbuf), fmt, ap);
+		if (error_set) {
+			*p++ = ':';
+			*p++ = ' ';
+		}
+	}
+	if (error_set)
+		(void)strcpy(p, db_strerror(error));
+
+	dbenv->db_errcall(dbenv->db_errpfx, __errbuf);
+}
+
+/*
+ * __db_errfile --
+ *	Do the error message work for FILE *s.
+ */
+static void
+__db_errfile(dbenv, error, error_set, fmt, ap)
+	const DB_ENV *dbenv;
+	int error, error_set;
+	const char *fmt;
+	va_list ap;
+{
+	FILE *fp;
+
+	fp = dbenv == NULL ||
+	    dbenv->db_errfile == NULL ? stderr : dbenv->db_errfile;
+
+	if (dbenv != NULL && dbenv->db_errpfx != NULL)
+		(void)fprintf(fp, "%s: ", dbenv->db_errpfx);
+	if (fmt != NULL) {
+		(void)vfprintf(fp, fmt, ap);
+		if (error_set)
+			(void)fprintf(fp, ": ");
+	}
+	if (error_set)
+		(void)fprintf(fp, "%s", db_strerror(error));
+	(void)fprintf(fp, "\n");
+	(void)fflush(fp);
+}
+
+/*
+ * __db_logmsg --
+ *	Write information into the DB log.
+ *
+ * PUBLIC: void __db_logmsg __P((const DB_ENV *,
+ * PUBLIC:     DB_TXN *, const char *, u_int32_t, const char *, ...));
+ */
+void
+#ifdef __STDC__
+__db_logmsg(const DB_ENV *dbenv,
+    DB_TXN *txnid, const char *opname, u_int32_t flags, const char *fmt, ...)
+#else
+__db_logmsg(dbenv, txnid, opname, flags, fmt, va_alist)
+	const DB_ENV *dbenv;
+	DB_TXN *txnid;
+	const char *opname, *fmt;
+	u_int32_t flags;
+	va_dcl
+#endif
+{
+	va_list ap;
+
+#ifdef __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
+	__db_real_log(dbenv, txnid, opname, flags, fmt, ap);
+
+	va_end(ap);
+}
+
+/*
+ * __db_real_log --
+ *	Write information into the DB log.
+ *
+ * PUBLIC: void __db_real_log __P((const DB_ENV *,
+ * PUBLIC:     DB_TXN *, const char *, u_int32_t, const char *, va_list ap));
+ */
+void
+#ifdef __STDC__
+__db_real_log(const DB_ENV *dbenv, DB_TXN *txnid,
+    const char *opname, u_int32_t flags, const char *fmt, va_list ap)
+#else
+__db_real_log(dbenv, txnid, opname, flags, fmt, ap)
+	const DB_ENV *dbenv;
+	DB_TXN *txnid;
+	const char *opname, *fmt;
+	u_int32_t flags;
+	va_list ap;
+#endif
+{
+	DBT opdbt, msgdbt;
+	DB_LSN lsn;
+	char __logbuf[2048];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+
+	if (!LOGGING_ON(dbenv))
+		return;
+
+	memset(&opdbt, 0, sizeof(opdbt));
+	opdbt.data = (void *)opname;
+	opdbt.size = strlen(opname) + 1;
+
+	memset(&msgdbt, 0, sizeof(msgdbt));
+	msgdbt.data = __logbuf;
+	msgdbt.size = vsnprintf(__logbuf, sizeof(__logbuf), fmt, ap);
+
+	/*
+	 * XXX
+	 * Explicitly discard the const.  Otherwise, we have to const DB_ENV
+	 * references throughout the logging subsystem.
+	 */
+	__db_debug_log(
+	    (DB_ENV *)dbenv, txnid, &lsn, flags, &opdbt, -1, &msgdbt, NULL, 0);
+}
+
+/*
+ * __db_unknown_flag -- report internal error
+ *
+ * PUBLIC: int __db_unknown_flag __P((DB_ENV *, char *, u_int32_t));
+ */
+int
+__db_unknown_flag(dbenv, routine, flag)
+	DB_ENV *dbenv;
+	char *routine;
+	u_int32_t flag;
+{
+	__db_err(dbenv, "%s: Unknown flag: 0x%x", routine, flag);
+	DB_ASSERT(0);
+	return (EINVAL);
+}
+
+/*
+ * __db_unknown_type -- report internal error
+ *
+ * PUBLIC: int __db_unknown_type __P((DB_ENV *, char *, u_int32_t));
+ */
+int
+__db_unknown_type(dbenv, routine, type)
+	DB_ENV *dbenv;
+	char *routine;
+	u_int32_t type;
+{
+	__db_err(dbenv, "%s: Unknown db type: 0x%x", routine, type);
+	DB_ASSERT(0);
+	return (EINVAL);
+}
+
+#ifdef DIAGNOSTIC
+/*
+ * __db_missing_txn_err --
+ *	Cannot combine operations with and without transactions.
+ *
+ * PUBLIC: #ifdef DIAGNOSTIC
+ * PUBLIC: int __db_missing_txn_err __P((DB_ENV *));
+ * PUBLIC: #endif
+ */
+int
+__db_missing_txn_err(dbenv)
+	DB_ENV *dbenv;
+{
+	__db_err(dbenv,
+    "DB handle previously used in transaction, missing transaction handle.");
+	return (EINVAL);
+}
+#endif
diff --git a/db/common/db_getlong.c b/db/common/db_getlong.c
new file mode 100644
index 000000000..bead530cd
--- /dev/null
+++ b/db/common/db_getlong.c
@@ -0,0 +1,159 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: db_getlong.c,v 11.11 2000/12/22 19:16:04 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "clib_ext.h"
+
+/*
+ * __db_getlong --
+ *	Return a long value inside of basic parameters.
+ *
+ * PUBLIC: int __db_getlong
+ * PUBLIC:     __P((DB *, const char *, char *, long, long, long *));
+ */
+int
+__db_getlong(dbp, progname, p, min, max, storep)
+	DB *dbp;
+	const char *progname;
+	char *p;
+	long min, max, *storep;
+{
+	long val;
+	char *end;
+
+	__os_set_errno(0);
+	val = strtol(p, &end, 10);
+	if ((val == LONG_MIN || val == LONG_MAX) &&
+	    __os_get_errno() == ERANGE) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: %s\n", progname, p, strerror(ERANGE));
+			exit(1);
+		}
+		dbp->err(dbp, ERANGE, "%s", p);
+		return (1);
+	}
+	if (p[0] == '\0' || (end[0] != '\0' && end[0] != '\n')) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Invalid numeric argument\n", progname, p);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Invalid numeric argument", p);
+		return (1);
+	}
+	if (val < min) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Less than minimum value (%ld)\n",
+			    progname, p, min);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Less than minimum value (%ld)", p, min);
+		return (1);
+	}
+	if (val > max) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Greater than maximum value (%ld)\n",
+			    progname, p, max);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Greater than maximum value (%ld)", p, max);
+		exit(1);
+	}
+	*storep = val;
+	return (0);
+}
+
+/*
+ * __db_getulong --
+ *	Return an unsigned long value inside of basic parameters.
+ *
+ * PUBLIC: int __db_getulong
+ * PUBLIC:     __P((DB *, const char *, char *, u_long, u_long, u_long *));
+ */
+int
+__db_getulong(dbp, progname, p, min, max, storep)
+	DB *dbp;
+	const char *progname;
+	char *p;
+	u_long min, max, *storep;
+{
+#if !defined(HAVE_STRTOUL)
+	COMPQUIET(min, 0);
+
+	return (__db_getlong(dbp, progname, p, 0, max, (long *)storep));
+#else
+	u_long val;
+	char *end;
+
+	__os_set_errno(0);
+	val = strtoul(p, &end, 10);
+	if (val == ULONG_MAX && __os_get_errno() == ERANGE) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: %s\n", progname, p, strerror(ERANGE));
+			exit(1);
+		}
+		dbp->err(dbp, ERANGE, "%s", p);
+		return (1);
+	}
+	if (p[0] == '\0' || (end[0] != '\0' && end[0] != '\n')) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Invalid numeric argument\n", progname, p);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Invalid numeric argument", p);
+		return (1);
+	}
+	if (val < min) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Less than minimum value (%ld)\n",
+			    progname, p, min);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Less than minimum value (%ld)", p, min);
+		return (1);
+	}
+
+	/*
+	 * We allow a 0 to substitute as a max value for ULONG_MAX because
+	 * 1) accepting only a 0 value is unlikely to be necessary, and 2)
+	 * we don't want callers to have to use ULONG_MAX explicitly, as it
+	 * may not exist on all platforms.
+	 */
+	if (max != 0 && val > max) {
+		if (dbp == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Greater than maximum value (%ld)\n",
+			    progname, p, max);
+			exit(1);
+		}
+		dbp->errx(dbp, "%s: Greater than maximum value (%ld)", p, max);
+		exit(1);
+	}
+	*storep = val;
+	return (0);
+#endif	/* !defined(HAVE_STRTOUL) */
+}
diff --git a/db/common/db_log2.c b/db/common/db_log2.c
new file mode 100644
index 000000000..95bc69499
--- /dev/null
+++ b/db/common/db_log2.c
@@ -0,0 +1,65 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+/*
+ * Copyright (c) 1995, 1996
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Margo Seltzer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: db_log2.c,v 11.4 2000/02/14 02:59:41 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+#endif
+
+#include "db_int.h"
+#include "common_ext.h"
+
+/*
+ * PUBLIC: u_int32_t __db_log2 __P((u_int32_t));
+ */
+u_int32_t
+__db_log2(num)
+	u_int32_t num;
+{
+	u_int32_t i, limit;
+
+	limit = 1;
+	for (i = 0; limit < num; limit = limit << 1)
+		++i;
+	return (i);
+}
diff --git a/db/common/util_log.c b/db/common/util_log.c
new file mode 100644
index 000000000..a4743cc2c
--- /dev/null
+++ b/db/common/util_log.c
@@ -0,0 +1,63 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: util_log.c,v 1.7 2000/11/30 00:58:31 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+#if TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+#endif
+
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+#include "common_ext.h"
+
+/*
+ * __db_util_logset --
+ *	Log that we're running.
+ *
+ * PUBLIC: int __db_util_logset __P((const char *, char *));
+ */
+int
+__db_util_logset(progname, fname)
+	const char *progname;
+	char *fname;
+{
+	FILE *fp;
+	time_t now;
+
+	if ((fp = fopen(fname, "w")) == NULL)
+		goto err;
+
+	(void)time(&now);
+	fprintf(fp, "%s: %lu %s", progname, (u_long)getpid(), ctime(&now));
+
+	if (fclose(fp) == EOF)
+		goto err;
+
+	return (0);
+
+err:	fprintf(stderr, "%s: %s: %s\n", progname, fname, strerror(errno));
+	return (1);
+}
diff --git a/db/common/util_sig.c b/db/common/util_sig.c
new file mode 100644
index 000000000..6fe0166fe
--- /dev/null
+++ b/db/common/util_sig.c
@@ -0,0 +1,87 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: util_sig.c,v 1.3 2000/04/28 19:32:00 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <signal.h>
+#endif
+
+#include "db_int.h"
+#include "common_ext.h"
+
+static int	interrupt;
+static void	onint __P((int));
+
+/*
+ * onint --
+ *	Interrupt signal handler.
+ */
+static void
+onint(signo)
+	int signo;
+{
+	if ((interrupt = signo) == 0)
+		interrupt = SIGINT;
+}
+
+/*
+ * __db_util_siginit --
+ *
+ * PUBLIC: void __db_util_siginit __P((void));
+ */
+void
+__db_util_siginit()
+{
+	/*
+	 * Initialize the set of signals for which we want to clean up.
+	 * Generally, we try not to leave the shared regions locked if
+	 * we can.
+	 */
+#ifdef SIGHUP
+	(void)signal(SIGHUP, onint);
+#endif
+	(void)signal(SIGINT, onint);
+#ifdef SIGPIPE
+	(void)signal(SIGPIPE, onint);
+#endif
+	(void)signal(SIGTERM, onint);
+}
+
+/*
+ * __db_util_interrupted --
+ *	Return if interrupted.
+ *
+ * PUBLIC: int __db_util_interrupted __P((void));
+ */
+int
+__db_util_interrupted()
+{
+	return (interrupt != 0);
+}
+
+/*
+ * __db_util_sigresend --
+ *
+ * PUBLIC: void __db_util_sigresend __P((void));
+ */
+void
+__db_util_sigresend()
+{
+	/* Resend any caught signal. */
+	if (__db_util_interrupted != 0) {
+		(void)signal(interrupt, SIG_DFL);
+		(void)raise(interrupt);
+		/* NOTREACHED */
+	}
+}