1 files changed, 326 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/db/os_alloc.c b/debian/htdig/htdig-3.2.0b6/db/os_alloc.c
new file mode 100644
index 00000000..4f7190ac
--- /dev/null
+++ b/debian/htdig/htdig-3.2.0b6/db/os_alloc.c
@@ -0,0 +1,326 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997, 1998, 1999
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)os_alloc.c	11.6 (Sleepycat) 11/9/99";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#endif
+
+#include "db_int.h"
+#include "os_jump.h"
+
+#ifdef DIAGNOSTIC
+static void __os_guard __P((void));
+#endif
+
+/*
+ * !!!
+ * Correct for systems that return NULL when you allocate 0 bytes of memory.
+ * There are several places in DB where we allocate the number of bytes held
+ * by the key/data item, and it can be 0.  Correct here so that malloc never
+ * returns a NULL for that reason (which behavior is permitted by ANSI).  We
+ * could make these calls macros on non-Alpha architectures (that's where we
+ * saw the problem), but it's probably not worth the autoconf complexity.
+ *
+ * !!!
+ * Correct for systems that don't set errno when malloc and friends fail.
+ *
+ *	Out of memory.
+ *	We wish to hold the whole sky,
+ *	But we never will.
+ */
+
+/*
+ * CDB___os_strdup --
+ *	The strdup(3) function for DB.
+ *
+ * PUBLIC: int CDB___os_strdup __P((const char *, void *));
+ */
+int
+CDB___os_strdup(str, storep)
+	const char *str;
+	void *storep;
+{
+	size_t size;
+	int ret;
+	void *p;
+
+	*(void **)storep = NULL;
+
+	size = strlen(str) + 1;
+	if ((ret = CDB___os_malloc(size, NULL, &p)) != 0)
+		return (ret);
+
+	memcpy(p, str, size);
+
+	*(void **)storep = p;
+	return (0);
+}
+
+/*
+ * CDB___os_calloc --
+ *	The calloc(3) function for DB.
+ *
+ * PUBLIC: int CDB___os_calloc __P((size_t, size_t, void *));
+ */
+int
+CDB___os_calloc(num, size, storep)
+	size_t num, size;
+	void *storep;
+{
+	void *p;
+	int ret;
+
+	size *= num;
+	if ((ret = CDB___os_malloc(size, NULL, &p)) != 0)
+		return (ret);
+
+	memset(p, 0, size);
+
+	*(void **)storep = p;
+	return (0);
+}
+
+/*
+ * CDB___os_malloc --
+ *	The malloc(3) function for DB.
+ *
+ * PUBLIC: int CDB___os_malloc __P((size_t, void *(*)(size_t), void *));
+ */
+int
+CDB___os_malloc(size, db_malloc, storep)
+	size_t size;
+	void *(*db_malloc) __P((size_t)), *storep;
+{
+	void *p;
+
+	*(void **)storep = NULL;
+
+	/* Never allocate 0 bytes -- some C libraries don't like it. */
+	if (size == 0)
+		++size;
+#ifdef DIAGNOSTIC
+	else
+        	++size;				/* Add room for a guard byte. */
+#endif
+
+	/* Some C libraries don't correctly set errno when malloc(3) fails. */
+	CDB___os_set_errno(0);
+	if (db_malloc != NULL)
+		p = db_malloc(size);
+	else if (CDB___db_jump.j_malloc != NULL)
+		p = CDB___db_jump.j_malloc(size);
+	else
+		p = malloc(size);
+	if (p == NULL) {
+		if (CDB___os_get_errno() == 0)
+			CDB___os_set_errno(ENOMEM);
+		return (CDB___os_get_errno());
+	}
+
+#ifdef DIAGNOSTIC
+	/*
+	 * Guard bytes: if #DIAGNOSTIC is defined, we allocate an additional
+	 * byte after the memory and set it to a special value that we check
+	 * for when the memory is free'd.  This is fine for structures, but
+	 * not quite so fine for strings.  There are places in DB where memory
+	 * is allocated sufficient to hold the largest possible string that
+	 * we'll see, and then only some subset of the memory is used.  To
+	 * support this usage, the CDB___os_freestr() function checks the byte
+	 * after the string's nul, which may or may not be the last byte in
+	 * the originally allocated memory.
+	 */
+	memset(p, CLEAR_BYTE, size);		/* Initialize guard byte. */
+#endif
+	*(void **)storep = p;
+
+	return (0);
+}
+
+/*
+ * CDB___os_realloc --
+ *	The realloc(3) function for DB.
+ *
+ * PUBLIC: int CDB___os_realloc __P((size_t, void *(*)(void *, size_t), void *));
+ */
+int
+CDB___os_realloc(size, db_realloc, storep)
+	size_t size;
+	void *(*db_realloc) __P((void *, size_t)), *storep;
+{
+	void *p, *ptr;
+
+	ptr = *(void **)storep;
+
+	/* If we haven't yet allocated anything yet, simply call malloc. */
+	if (ptr == NULL && db_realloc == NULL)
+		return (CDB___os_malloc(size, NULL, storep));
+
+	/* Never allocate 0 bytes -- some C libraries don't like it. */
+	if (size == 0)
+		++size;
+#ifdef DIAGNOSTIC
+	else
+        	++size;				/* Add room for a guard byte. */
+#endif
+
+	/*
+	 * Some C libraries don't correctly set errno when realloc(3) fails.
+	 *
+	 * Don't overwrite the original pointer, there are places in DB we
+	 * try to continue after realloc fails.
+	 */
+	CDB___os_set_errno(0);
+	if (db_realloc != NULL)
+		p = db_realloc(ptr, size);
+	if (CDB___db_jump.j_realloc != NULL)
+		p = CDB___db_jump.j_realloc(ptr, size);
+	else
+		p = realloc(ptr, size);
+	if (p == NULL) {
+		if (CDB___os_get_errno() == 0)
+			CDB___os_set_errno(ENOMEM);
+		return (CDB___os_get_errno());
+	}
+
+#ifdef DIAGNOSTIC
+        ((u_int8_t *)p)[size - 1] = CLEAR_BYTE;	/* Initialize guard byte. */
+#endif
+
+	*(void **)storep = p;
+
+	return (0);
+}
+
+/*
+ * CDB___os_free --
+ *	The free(3) function for DB.
+ *
+ * PUBLIC: void CDB___os_free __P((void *, size_t));
+ */
+void
+CDB___os_free(ptr, size)
+	void *ptr;
+	size_t size;
+{
+#ifdef DIAGNOSTIC
+	if (size != 0) {
+		/*
+		 * Check that the guard byte (one past the end of the memory) is
+		 * still CLEAR_BYTE.
+		 */
+		if (((u_int8_t *)ptr)[size] != CLEAR_BYTE)
+			 __os_guard();
+
+		/* Clear memory. */
+		if (size != 0)
+			memset(ptr, CLEAR_BYTE, size);
+	}
+#else
+	COMPQUIET(size, 0);
+#endif
+
+	if (CDB___db_jump.j_free != NULL)
+		CDB___db_jump.j_free(ptr);
+	else
+		free(ptr);
+}
+
+/*
+ * CDB___os_freestr --
+ *	The free(3) function for DB, freeing a string.
+ *
+ * PUBLIC: void CDB___os_freestr __P((void *));
+ */
+void
+CDB___os_freestr(ptr)
+	void *ptr;
+{
+#ifdef DIAGNOSTIC
+	size_t size;
+
+	size = strlen(ptr) + 1;
+
+        /*
+         * Check that the guard byte (one past the end of the memory) is
+         * still CLEAR_BYTE.
+         */
+        if (((u_int8_t *)ptr)[size] != CLEAR_BYTE)
+                 __os_guard();
+
+        /* Clear memory. */
+	memset(ptr, CLEAR_BYTE, size);
+#endif
+
+	if (CDB___db_jump.j_free != NULL)
+		CDB___db_jump.j_free(ptr);
+	else
+		free(ptr);
+}
+
+#ifdef DIAGNOSTIC
+/*
+ * __os_guard --
+ *	Complain and abort.
+ */
+static void
+__os_guard()
+{
+	/*
+	 * Eventually, once we push a DB_ENV handle down to these
+	 * routines, we should use the standard output channels.
+	 */
+	fprintf(stderr, "Guard byte incorrect during free.\n");
+	abort();
+	/* NOTREACHED */
+}
+#endif
+
+/*
+ * __ua_copy --
+ *	Copy memory to memory without relying on any kind of alignment.
+ *
+ *	There are places in DB that we have unaligned data, for example,
+ *	when we've stored a structure in a log record as a DBT, and now
+ *	we want to look at it.  Unfortunately, if you have code like:
+ *
+ *		struct a {
+ *			int x;
+ *		} *p;
+ *
+ *		void *func_argument;
+ *		int local;
+ *
+ *		p = (struct a *)func_argument;
+ *		memcpy(&local, p->x, sizeof(local));
+ *
+ *	some compilers optimize to use instructions that require alignment.
+ *	It's a compiler bug, but it's a pretty common one.
+ *
+ *	Casting the memcpy arguments to (u_int8_t *) appears to work most
+ *	of the time, but we've seen examples where it wasn't sufficient
+ *	and there's nothing in ANSI C that requires it.
+ *
+ * PUBLIC: void *CDB___ua_memcpy __P((void *, const void *, size_t));
+ */
+void *
+CDB___ua_memcpy(dst, src, len)
+	void *dst;
+	const void *src;
+	size_t len;
+{
+	return (memcpy(dst, src, len));
+}