DEB htdig: Added to repository.

Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

1 files changed, 138 insertions, 0 deletions

diff --git a/debian/htdig/htdig-3.2.0b6/db/lock_util.c b/debian/htdig/htdig-3.2.0b6/db/lock_util.c
new file mode 100644
index 00000000..be529da8
--- /dev/null
+++ b/debian/htdig/htdig-3.2.0b6/db/lock_util.c
@@ -0,0 +1,138 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)lock_util.c	11.1 (Sleepycat) 7/25/99";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "db_shash.h"
+#include "hash.h"
+#include "lock.h"
+
+/*
+ * CDB___lock_cmp --
+ *	This function is used to compare a DBT that is about to be entered
+ *	into a hash table with an object already in the hash table.  Note
+ *	that it just returns true on equal and 0 on not-equal.  Therefore
+ *	this function cannot be used as a sort function; its purpose is to
+ *	be used as a hash comparison function.
+ *
+ * PUBLIC: int CDB___lock_cmp __P((const DBT *, DB_LOCKOBJ *));
+ */
+int
+CDB___lock_cmp(dbt, lock_obj)
+	const DBT *dbt;
+	DB_LOCKOBJ *lock_obj;
+{
+	void *obj_data;
+
+	obj_data = SH_DBT_PTR(&lock_obj->lockobj);
+	return (dbt->size == lock_obj->lockobj.size &&
+		memcmp(dbt->data, obj_data, dbt->size) == 0);
+}
+
+/*
+ * PUBLIC: int CDB___lock_locker_cmp __P((u_int32_t, DB_LOCKER *));
+ */
+int
+CDB___lock_locker_cmp(locker, sh_locker)
+	u_int32_t locker;
+	DB_LOCKER *sh_locker;
+{
+	return (locker == sh_locker->id);
+}
+
+/*
+ * The next two functions are the hash functions used to store objects in the
+ * lock hash tables.  They are hashing the same items, but one (CDB___lock_ohash)
+ * takes a DBT (used for hashing a parameter passed from the user) and the
+ * other (CDB___lock_lhash) takes a DB_LOCKOBJ (used for hashing something that is
+ * already in the lock manager).  In both cases, we have a special check to
+ * fast path the case where we think we are doing a hash on a DB page/fileid
+ * pair.  If the size is right, then we do the fast hash.
+ *
+ * We know that DB uses DB_LOCK_ILOCK types for its lock objects.  The first
+ * four bytes are the 4-byte page number and the next DB_FILE_ID_LEN bytes
+ * are a unique file id, where the first 4 bytes on UNIX systems are the file
+ * inode number, and the first 4 bytes on Windows systems are the FileIndexLow
+ * bytes.  So, we use the XOR of the page number and the first four bytes of
+ * the file id to produce a 32-bit hash value.
+ *
+ * We have no particular reason to believe that this algorithm will produce
+ * a good hash, but we want a fast hash more than we want a good one, when
+ * we're coming through this code path.
+ */
+#define FAST_HASH(P) {			\
+	u_int32_t __h;			\
+	u_int8_t *__cp, *__hp;		\
+	__hp = (u_int8_t *)&__h;	\
+	__cp = (u_int8_t *)(P);		\
+	__hp[0] = __cp[0] ^ __cp[4];	\
+	__hp[1] = __cp[1] ^ __cp[5];	\
+	__hp[2] = __cp[2] ^ __cp[6];	\
+	__hp[3] = __cp[3] ^ __cp[7];	\
+	return (__h);			\
+}
+
+/*
+ * CDB___lock_ohash --
+ *
+ * PUBLIC: u_int32_t CDB___lock_ohash __P((const DBT *));
+ */
+u_int32_t
+CDB___lock_ohash(dbt)
+	const DBT *dbt;
+{
+	if (dbt->size == sizeof(DB_LOCK_ILOCK))
+		FAST_HASH(dbt->data);
+
+	return (CDB___ham_func5(dbt->data, dbt->size));
+}
+
+/*
+ * CDB___lock_lhash --
+ *
+ * PUBLIC: u_int32_t CDB___lock_lhash __P((DB_LOCKOBJ *));
+ */
+u_int32_t
+CDB___lock_lhash(lock_obj)
+	DB_LOCKOBJ *lock_obj;
+{
+	void *obj_data;
+
+	obj_data = SH_DBT_PTR(&lock_obj->lockobj);
+
+	if (lock_obj->lockobj.size == sizeof(DB_LOCK_ILOCK))
+		FAST_HASH(obj_data);
+
+	return (CDB___ham_func5(obj_data, lock_obj->lockobj.size));
+}
+
+/*
+ * CDB___lock_locker_hash --
+ *	Hash function for entering lockers into the locker hash table.
+ * 	Since these are simply 32-bit unsigned integers, just return
+ *	the locker value.
+ *
+ * PUBLIC: u_int32_t CDB___lock_locker_hash __P((u_int32_t));
+ */
+u_int32_t
+CDB___lock_locker_hash(locker)
+	u_int32_t locker;
+{
+	return (locker);
+}