Initial import of a C portability framework and utility functions from

remctl so that the wallet client error handling can rest on a firmer
foundation.

11 files changed, 1252 insertions, 0 deletions

diff --git a/tests/TESTS b/tests/TESTS
index 1c8ab65..298f7a6 100644
--- a/tests/TESTS
+++ b/tests/TESTS
@@ -1,3 +1,8 @@
 client/basic
+portable/asprintf
+portable/snprintf
 server/backend
 server/keytab
+util/concat
+util/messages
+util/xmalloc
diff --git a/tests/libtest.c b/tests/libtest.c
new file mode 100644
index 0000000..727fc81
--- /dev/null
+++ b/tests/libtest.c
@@ -0,0 +1,206 @@
+/*  $Id$
+**
+**  Some utility routines for writing tests.
+**
+**  Herein are a variety of utility routines for writing tests.  All
+**  routines of the form ok*() take a test number and some number of
+**  appropriate arguments, check to be sure the results match the expected
+**  output using the arguments, and print out something appropriate for that
+**  test number.  Other utility routines help in constructing more complex
+**  tests.
+**
+**  Copyright 2006
+**      Board of Trustees, Leland Stanford Jr. University
+**  Copyright (c) 2004, 2005, 2006
+**      by Internet Systems Consortium, Inc. ("ISC")
+**  Copyright (c) 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+**      2002, 2003 by The Internet Software Consortium and Rich Salz
+**
+**  This code is derived from software contributed to the Internet Software
+**  Consortium by Rich Salz.
+**
+**  Permission to use, copy, modify, and distribute this software for any
+**  purpose with or without fee is hereby granted, provided that the above
+**  copyright notice and this permission notice appear in all copies.
+**
+**  THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+**  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+**  MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
+**  SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+**  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+**  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+**  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <config.h>
+#include <system.h>
+
+#include <sys/time.h>
+#include <sys/wait.h>
+
+#include <tests/libtest.h>
+#include <util/util.h>
+
+/* A global buffer into which message_log_buffer stores error messages. */
+char *errors = NULL;
+
+
+/*
+**  Initialize things.  Turns on line buffering on stdout and then prints out
+**  the number of tests in the test suite.
+*/
+void
+test_init(int count)
+{
+    if (setvbuf(stdout, NULL, _IOLBF, BUFSIZ) != 0)
+        syswarn("cannot set stdout to line buffered");
+    printf("%d\n", count);
+}
+
+
+/*
+**  Takes a boolean success value and assumes the test passes if that value
+**  is true and fails if that value is false.
+*/
+void
+ok(int n, int success)
+{
+    printf("%sok %d\n", success ? "" : "not ", n);
+}
+
+
+/*
+**  Takes an expected integer and a seen integer and assumes the test passes
+**  if those two numbers match.
+*/
+void
+ok_int(int n, int wanted, int seen)
+{
+    if (wanted == seen)
+        printf("ok %d\n", n);
+    else
+        printf("not ok %d\n  wanted: %d\n    seen: %d\n", n, wanted, seen);
+}
+
+
+/*
+**  Takes a string and what the string should be, and assumes the test
+**  passes if those strings match (using strcmp).
+*/
+void
+ok_string(int n, const char *wanted, const char *seen)
+{
+    if (wanted == NULL)
+        wanted = "(null)";
+    if (seen == NULL)
+        seen = "(null)";
+    if (strcmp(wanted, seen) != 0)
+        printf("not ok %d\n  wanted: %s\n    seen: %s\n", n, wanted, seen);
+    else
+        printf("ok %d\n", n);
+}
+
+
+/*
+**  Takes an expected integer and a seen integer and assumes the test passes
+**  if those two numbers match.
+*/
+void
+ok_double(int n, double wanted, double seen)
+{
+    if (wanted == seen)
+        printf("ok %d\n", n);
+    else
+        printf("not ok %d\n  wanted: %g\n    seen: %g\n", n, wanted, seen);
+}
+
+
+/*
+**  Skip a test.
+*/
+void
+skip(int n, const char *reason)
+{
+    printf("ok %d # skip", n);
+    if (reason != NULL)
+        printf(" - %s", reason);
+    putchar('\n');
+}
+
+
+/*
+**  Report the same status on the next count tests.
+*/
+void
+ok_block(int n, int count, int status)
+{
+    int i;
+
+    for (i = 0; i < count; i++)
+        ok(n++, status);
+}
+
+
+/*
+**  Skip the next count tests.
+*/
+void
+skip_block(int n, int count, const char *reason)
+{
+    int i;
+
+    for (i = 0; i < count; i++)
+        skip(n++, reason);
+}
+
+
+/*
+**  An error handler that appends all errors to the errors global.  Used by
+**  error_capture.
+*/
+static void
+message_log_buffer(int len, const char *fmt, va_list args, int error UNUSED)
+{
+    char *message;
+
+    message = xmalloc(len + 1);
+    vsnprintf(message, len + 1, fmt, args);
+    if (errors == NULL) {
+        errors = concat(message, "\n", (char *) 0);
+    } else {
+        char *new_errors;
+
+        new_errors = concat(errors, message, "\n", (char *) 0);
+        free(errors);
+        errors = new_errors;
+    }
+    free(message);
+}
+
+
+/*
+**  Turn on the capturing of errors.  Errors will be stored in the global
+**  errors variable where they can be checked by the test suite.  Capturing is
+**  turned off with errors_uncapture.
+*/
+void
+errors_capture(void)
+{
+    if (errors != NULL) {
+        free(errors);
+        errors = NULL;
+    }
+    message_handlers_warn(1, message_log_buffer);
+    message_handlers_notice(1, message_log_buffer);
+}
+
+
+/*
+**  Turn off the capturing of errors again.
+*/
+void
+errors_uncapture(void)
+{
+    message_handlers_warn(1, message_log_stderr);
+    message_handlers_notice(1, message_log_stdout);
+}
diff --git a/tests/libtest.h b/tests/libtest.h
new file mode 100644
index 0000000..aedbaa6
--- /dev/null
+++ b/tests/libtest.h
@@ -0,0 +1,56 @@
+/*  $Id$
+**
+**  Some utility routines for writing tests.
+*/
+
+#ifndef LIBTEST_H
+#define LIBTEST_H 1
+
+#include <config.h>
+
+/* BEGIN_DECLS is used at the beginning of declarations so that C++
+   compilers don't mangle their names.  END_DECLS is used at the end. */
+#undef BEGIN_DECLS
+#undef END_DECLS
+#ifdef __cplusplus
+# define BEGIN_DECLS    extern "C" {
+# define END_DECLS      }
+#else
+# define BEGIN_DECLS    /* empty */
+# define END_DECLS      /* empty */
+#endif
+
+/* Used for iterating through arrays.  ARRAY_SIZE returns the number of
+   elements in the array (useful for a < upper bound in a for loop) and
+   ARRAY_END returns a pointer to the element past the end (ISO C99 makes it
+   legal to refer to such a pointer as long as it's never dereferenced). */
+#define ARRAY_SIZE(array)       (sizeof(array) / sizeof((array)[0]))
+#define ARRAY_END(array)        (&(array)[ARRAY_SIZE(array)])
+
+/* A global buffer into which errors_capture stores errors. */
+extern char *errors;
+
+BEGIN_DECLS
+
+void ok(int n, int success);
+void ok_int(int n, int wanted, int seen);
+void ok_double(int n, double wanted, double seen);
+void ok_string(int n, const char *wanted, const char *seen);
+void skip(int n, const char *reason);
+
+/* Report the same status on, or skip, the next count tests. */
+void ok_block(int n, int count, int success);
+void skip_block(int n, int count, const char *reason);
+
+/* Print out the number of tests and set standard output to line buffered. */
+void test_init(int count);
+
+/* Turn on capturing of errors with errors_capture.  Errors reported by warn
+   will be stored in the global errors variable.  Turn this off again with
+   errors_uncapture.  Caller is responsible for freeing errors when done. */
+void errors_capture(void);
+void errors_uncapture(void);
+
+END_DECLS
+
+#endif /* LIBTEST_H */
diff --git a/tests/portable/asprintf-t.c b/tests/portable/asprintf-t.c
new file mode 100644
index 0000000..a362755
--- /dev/null
+++ b/tests/portable/asprintf-t.c
@@ -0,0 +1,51 @@
+/* $Id$ */
+/* asprintf and vasprintf test suite. */
+
+/* Written by Russ Allbery <rra@stanford.edu>
+   Copyright 2006 Board of Trustees, Leland Stanford Jr. University
+   See README for licensing terms. */
+
+#include <config.h>
+#include <system.h>
+
+#include <tests/libtest.h>
+
+static int
+vatest(char **result, const char *format, ...)
+{
+    va_list args;
+    int status;
+
+    va_start(args, format);
+    status = vasprintf(result, format, args);
+    va_end(args);
+    return status;
+}
+
+int
+main(void)
+{
+    char *result = NULL;
+
+    test_init(12);
+
+    ok_int(1, 7, asprintf(&result, "%s", "testing"));
+    ok_string(2, "testing", result);
+    free(result);
+    ok(3, 1);
+    ok_int(4, 0, asprintf(&result, "%s", ""));
+    ok_string(5, "", result);
+    free(result);
+    ok(6, 1);
+
+    ok_int(7, 6, vatest(&result, "%d %s", 2, "test"));
+    ok_string(8, "2 test", result);
+    free(result);
+    ok(9, 1);
+    ok_int(10, 0, vatest(&result, "%s", ""));
+    ok_string(11, "", result);
+    free(result);
+    ok(12, 1);
+
+    return 0;
+}
diff --git a/tests/portable/asprintf.c b/tests/portable/asprintf.c
new file mode 100644
index 0000000..221c993
--- /dev/null
+++ b/tests/portable/asprintf.c
@@ -0,0 +1,2 @@
+#define TESTING 1
+#include <portable/asprintf.c>
diff --git a/tests/portable/snprintf-t.c b/tests/portable/snprintf-t.c
new file mode 100644
index 0000000..9159fcf
--- /dev/null
+++ b/tests/portable/snprintf-t.c
@@ -0,0 +1,197 @@
+/* $Id$ */
+/* snprintf test suite. */
+
+/* Copyright (c) 2004, 2005, 2006
+       by Internet Systems Consortium, Inc. ("ISC")
+   Copyright (c) 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+       2002, 2003 by The Internet Software Consortium and Rich Salz
+
+   This code is derived from software contributed to the Internet Software
+   Consortium by Rich Salz.
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+   REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
+   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <config.h>
+#include <system.h>
+
+#include <tests/libtest.h>
+
+int test_snprintf(char *str, size_t count, const char *fmt, ...);
+int test_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
+
+static const char string[] = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+static const char *const fp_formats[] = {
+    "%-1.5f",   "%1.5f",    "%31.9f",   "%10.5f",   "% 10.5f",  "%+22.9f",
+    "%+4.9f",   "%01.3f",   "%3.1f",    "%3.2f",    "%.0f",     "%.1f",
+    "%f",
+
+    /* %e and %g formats aren't really implemented yet. */
+#if 0
+    "%-1.5e",   "%1.5e",    "%31.9e",   "%10.5e",   "% 10.5e",  "%+22.9e",
+    "%+4.9e",   "%01.3e",   "%3.1e",    "%3.2e",    "%.0e",     "%.1e",
+    "%e",
+    "%-1.5g",   "%1.5g",    "%31.9g",   "%10.5g",   "% 10.5g",  "%+22.9g",
+    "%+4.9g",   "%01.3g",   "%3.1g",    "%3.2g",    "%.0g",     "%.1g",
+    "%g",
+#endif
+    NULL
+};
+static const char *const int_formats[] = {
+    "%-1.5d",   "%1.5d",    "%31.9d",   "%5.5d",    "%10.5d",   "% 10.5d",
+    "%+22.30d", "%01.3d",   "%4d",      "%d",       "%ld",      NULL
+};
+static const char *const uint_formats[] = {
+    "%-1.5lu",  "%1.5lu",   "%31.9lu",  "%5.5lu",   "%10.5lu",  "% 10.5lu",
+    "%+6.30lu", "%01.3lu",  "%4lu",     "%lu",      "%4lx",     "%4lX",
+    "%01.3lx",  "%1lo",     NULL
+};
+static const char *const llong_formats[] = {
+    "%lld",     "%-1.5lld",  "%1.5lld",    "%123.9lld",  "%5.5lld",
+    "%10.5lld", "% 10.5lld", "%+22.33lld", "%01.3lld",   "%4lld",
+    NULL
+};
+static const char *const ullong_formats[] = {
+    "%llu",     "%-1.5llu",  "%1.5llu",    "%123.9llu",  "%5.5llu",
+    "%10.5llu", "% 10.5llu", "%+22.33llu", "%01.3llu",   "%4llu",
+    "%llx",     "%llo",      NULL
+};
+
+static const double fp_nums[] = {
+    -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 0.9996, 1.996,
+    4.136, 0.1, 0.01, 0.001, 10.1, 0
+};
+static long int_nums[] = {
+    -1, 134, 91340, 341, 0203, 0
+};
+static unsigned long uint_nums[] = {
+    (unsigned long) -1, 134, 91340, 341, 0203, 0
+};
+static long long llong_nums[] = {
+    ~(long long) 0,                     /* All-1 bit pattern. */
+    (~(unsigned long long) 0) >> 1,     /* Largest signed long long. */
+    -150, 134, 91340, 341,
+    0
+};
+static unsigned long long ullong_nums[] = {
+    ~(unsigned long long) 0,            /* All-1 bit pattern. */
+    (~(unsigned long long) 0) >> 1,     /* Largest signed long long. */
+    134, 91340, 341,
+    0
+};
+
+static void
+test_format(int n, int truncate, const char *expected, int count,
+            const char *format, ...)
+{
+    char buf[128];
+    int result;
+    va_list args;
+
+    va_start(args, format);
+    result = test_vsnprintf(buf, truncate ? 32 : sizeof(buf), format, args);
+    va_end(args);
+    if (!strcmp(buf, expected) && result == count) {
+        printf("ok %d\n", n);
+    } else {
+        printf("not ok %d\n", n);
+        printf("  format: %s\n", format);
+        if (strcmp(buf, expected))
+            printf("   saw: %s\n  want: %s\n", buf, expected);
+        if (result != count)
+            printf("  %d != %d\n", result, count);
+    }
+}
+
+int
+main(void)
+{
+    int n, i, count;
+    unsigned int j;
+    long lcount;
+    char lgbuf[128];
+
+    test_init((26 + (ARRAY_SIZE(fp_formats) - 1) * ARRAY_SIZE(fp_nums)
+              + (ARRAY_SIZE(int_formats) - 1) * ARRAY_SIZE(int_nums)
+              + (ARRAY_SIZE(uint_formats) - 1) * ARRAY_SIZE(uint_nums)
+              + (ARRAY_SIZE(llong_formats) - 1) * ARRAY_SIZE(llong_nums)
+              + (ARRAY_SIZE(ullong_formats) - 1) * ARRAY_SIZE(ullong_nums)));
+
+    ok(1, test_snprintf(NULL, 0, "%s", "abcd") == 4);
+    ok(2, test_snprintf(NULL, 0, "%d", 20) == 2);
+    ok(3, test_snprintf(NULL, 0, "Test %.2s", "abcd") == 7);
+    ok(4, test_snprintf(NULL, 0, "%c", 'a') == 1);
+    ok(5, test_snprintf(NULL, 0, "") == 0);
+
+    test_format(6, 1, "abcd", 4, "%s", "abcd");
+    test_format(7, 1, "20", 2, "%d", 20);
+    test_format(8, 1, "Test ab", 7, "Test %.2s", "abcd");
+    test_format(9, 1, "a", 1, "%c", 'a');
+    test_format(10, 1, "", 0, "");
+    test_format(11, 1, "abcdefghijklmnopqrstuvwxyz01234", 36, "%s",
+                string);
+    test_format(12, 1, "abcdefghij", 10, "%.10s", string);
+    test_format(13, 1, "  abcdefghij", 12, "%12.10s", string);
+    test_format(14, 1, "    abcdefghijklmnopqrstuvwxyz0", 40, "%40s",
+                string);
+    test_format(15, 1, "abcdefghij    ", 14, "%-14.10s", string);
+    test_format(16, 1, "              abcdefghijklmnopq", 50, "%50s",
+                string);
+    test_format(17, 1, "%abcd%", 6, "%%%0s%%", "abcd");
+    test_format(18, 1, "", 0, "%.0s", string);
+    test_format(19, 1, "abcdefghijklmnopqrstuvwxyz  444", 32, "%.26s  %d",
+                string, 4444);
+    test_format(20, 1, "abcdefghijklmnopqrstuvwxyz  -2.", 32,
+                "%.26s  %.1f", string, -2.5);
+    test_format(21, 1, "abcdefghij4444", 14, "%.10s%n%d", string, &count,
+                4444);
+    ok(22, count == 10);
+    test_format(23, 1, "abcdefghijklmnopqrstuvwxyz01234", 36, "%n%s%ln",
+                &count, string, &lcount);
+    ok(24, count == 0);
+    ok(25, lcount == 31);
+    test_format(26, 1, "(null)", 6, "%s", NULL);
+
+    n = 26;
+    for (i = 0; fp_formats[i] != NULL; i++)
+        for (j = 0; j < ARRAY_SIZE(fp_nums); j++) {
+            count = sprintf(lgbuf, fp_formats[i], fp_nums[j]);
+            test_format(++n, 0, lgbuf, count, fp_formats[i], fp_nums[j]);
+        }
+    for (i = 0; int_formats[i] != NULL; i++)
+        for (j = 0; j < ARRAY_SIZE(int_nums); j++) {
+            count = sprintf(lgbuf, int_formats[i], int_nums[j]);
+            test_format(++n, 0, lgbuf, count, int_formats[i],
+                        int_nums[j]);
+        }
+    for (i = 0; uint_formats[i] != NULL; i++)
+        for (j = 0; j < ARRAY_SIZE(uint_nums); j++) {
+            count = sprintf(lgbuf, uint_formats[i], uint_nums[j]);
+            test_format(++n, 0, lgbuf, count, uint_formats[i],
+                        uint_nums[j]);
+        }
+    for (i = 0; llong_formats[i] != NULL; i++)
+        for (j = 0; j < ARRAY_SIZE(llong_nums); j++) {
+            count = sprintf(lgbuf, llong_formats[i], llong_nums[j]);
+            test_format(++n, 0, lgbuf, count, llong_formats[i],
+                        llong_nums[j]);
+        }
+    for (i = 0; ullong_formats[i] != NULL; i++)
+        for (j = 0; j < ARRAY_SIZE(ullong_nums); j++) {
+            count = sprintf(lgbuf, ullong_formats[i], ullong_nums[j]);
+            test_format(++n, 0, lgbuf, count, ullong_formats[i],
+                        ullong_nums[j]);
+        }
+
+    return 0;
+}
diff --git a/tests/portable/snprintf.c b/tests/portable/snprintf.c
new file mode 100644
index 0000000..cff95b3
--- /dev/null
+++ b/tests/portable/snprintf.c
@@ -0,0 +1,2 @@
+#define TESTING 1
+#include <portable/snprintf.c>
diff --git a/tests/util/concat-t.c b/tests/util/concat-t.c
new file mode 100644
index 0000000..c18cd19
--- /dev/null
+++ b/tests/util/concat-t.c
@@ -0,0 +1,54 @@
+/* $Id$ */
+/* concat test suite. */
+
+/* Copyright (c) 2004, 2005, 2006
+       by Internet Systems Consortium, Inc. ("ISC")
+   Copyright (c) 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+       2002, 2003 by The Internet Software Consortium and Rich Salz
+
+   This code is derived from software contributed to the Internet Software
+   Consortium by Rich Salz.
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+   REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
+   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <config.h>
+#include <system.h>
+
+#include <tests/libtest.h>
+#include <util/util.h>
+
+#define END     (char *) 0
+
+/* Memory leaks everywhere!  Whoo-hoo! */
+int
+main(void)
+{
+    test_init(13);
+
+    ok_string( 1, "a",     concat("a",                   END));
+    ok_string( 2, "ab",    concat("a", "b",              END));
+    ok_string( 3, "ab",    concat("ab", "",              END));
+    ok_string( 4, "ab",    concat("", "ab",              END));
+    ok_string( 5, "",      concat("",                    END));
+    ok_string( 6, "abcde", concat("ab", "c", "", "de",   END));
+    ok_string( 7, "abcde", concat("abc", "de", END, "f", END));
+
+    ok_string( 8, "/foo",             concatpath("/bar", "/foo"));
+    ok_string( 9, "/foo/bar",         concatpath("/foo", "bar"));
+    ok_string(10, "./bar",            concatpath("/foo", "./bar"));
+    ok_string(11, "/bar/baz/foo/bar", concatpath("/bar/baz", "foo/bar"));
+    ok_string(12, "./foo",            concatpath(NULL, "foo"));
+    ok_string(13, "/foo/bar",         concatpath(NULL, "/foo/bar"));
+
+    return 0;
+}
diff --git a/tests/util/messages-t.c b/tests/util/messages-t.c
new file mode 100644
index 0000000..ef58737
--- /dev/null
+++ b/tests/util/messages-t.c
@@ -0,0 +1,278 @@
+/* $Id$ */
+/* Test suite for error handling routines. */
+
+/* Copyright (c) 2004, 2005, 2006
+       by Internet Systems Consortium, Inc. ("ISC")
+   Copyright (c) 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+       2002, 2003 by The Internet Software Consortium and Rich Salz
+
+   This code is derived from software contributed to the Internet Software
+   Consortium by Rich Salz.
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+   REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
+   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <config.h>
+#include <system.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <tests/libtest.h>
+#include <util/util.h>
+
+#define END     (char *) 0
+
+/* Test function type. */
+typedef void (*test_function_t)(void);
+
+/* Fork and execute the provided function, connecting stdout and stderr to a
+   pipe.  Captures the output into the provided buffer and returns the exit
+   status as a waitpid status value. */
+static int
+run_test(test_function_t function, char *buf, size_t buflen)
+{
+    int fds[2];
+    pid_t child;
+    ssize_t count, status;
+    int rval;
+
+    /* Flush stdout before we start to avoid odd forking issues. */
+    fflush(stdout);
+
+    /* Set up the pipe and call the function, collecting its output. */
+    if (pipe(fds) == -1)
+        sysdie("can't create pipe");
+    child = fork();
+    if (child == (pid_t) -1) {
+        sysdie("can't fork");
+    } else if (child == 0) {
+        /* In child.  Set up our stdout and stderr. */
+        close(fds[0]);
+        if (dup2(fds[1], 1) == -1)
+            _exit(255);
+        if (dup2(fds[1], 2) == -1)
+            _exit(255);
+
+        /* Now, run the function and exit successfully if it returns. */
+        (*function)();
+        fflush(stdout);
+        _exit(0);
+    } else {
+        /* In the parent; close the extra file descriptor, read the output
+           if any, and then collect the exit status. */
+        close(fds[1]);
+        count = 0;
+        do {
+            status = read(fds[0], buf + count, buflen - count - 1);
+            if (status > 0)
+                count += status;
+        } while (status > 0);
+        buf[count < 0 ? 0 : count] = '\0';
+        if (waitpid(child, &rval, 0) == (pid_t) -1)
+            sysdie("waitpid failed");
+    }
+    return rval;
+}
+
+/* Test functions. */
+static void test1(void) { warn("warning"); }
+static void test2(void) { die("fatal"); }
+static void test3(void) { errno = EPERM; syswarn("permissions"); }
+static void test4(void) { errno = EACCES; sysdie("fatal access"); }
+static void test5(void) {
+    message_program_name = "test5";
+    warn("warning");
+}
+static void test6(void) {
+    message_program_name = "test6";
+    die("fatal");
+}
+static void test7(void) {
+    message_program_name = "test7";
+    errno = EPERM;
+    syswarn("perms %d", 7);
+}
+static void test8(void) {
+    message_program_name = "test8";
+    errno = EACCES;
+    sysdie("%st%s", "fa", "al");
+}
+
+static int return10(void) { return 10; }
+
+static void test9(void) {
+    message_fatal_cleanup = return10;
+    die("fatal");
+}
+static void test10(void) {
+    message_program_name = 0;
+    message_fatal_cleanup = return10;
+    errno = EPERM;
+    sysdie("fatal perm");
+}
+static void test11(void) {
+    message_program_name = "test11";
+    message_fatal_cleanup = return10;
+    errno = EPERM;
+    fputs("1st ", stdout);
+    sysdie("fatal");
+}
+
+static void log_msg(int len, const char *format, va_list args, int error) {
+    fprintf(stderr, "%d %d ", len, error);
+    vfprintf(stderr, format, args);
+    fprintf(stderr, "\n");
+}
+
+static void test12(void) {
+    message_handlers_warn(1, log_msg);
+    warn("warning");
+}
+static void test13(void) {
+    message_handlers_die(1, log_msg);
+    die("fatal");
+}
+static void test14(void) {
+    message_handlers_warn(2, log_msg, log_msg);
+    errno = EPERM;
+    syswarn("warning");
+}
+static void test15(void) {
+    message_handlers_die(2, log_msg, log_msg);
+    message_fatal_cleanup = return10;
+    errno = EPERM;
+    sysdie("fatal");
+}
+static void test16(void) {
+    message_handlers_warn(2, message_log_stderr, log_msg);
+    message_program_name = "test16";
+    errno = EPERM;
+    syswarn("warning");
+}
+static void test17(void) { notice("notice"); }
+static void test18(void) {
+    message_program_name = "test18";
+    notice("notice");
+}
+static void test19(void) { debug("debug"); }
+static void test20(void) {
+    message_handlers_notice(1, log_msg);
+    notice("foo");
+}
+static void test21(void) {
+    message_handlers_debug(1, message_log_stdout);
+    message_program_name = "test23";
+    debug("baz");
+}
+static void test22(void) {
+    message_handlers_die(0);
+    die("hi mom!");
+}
+static void test23(void) {
+    message_handlers_warn(0);
+    warn("this is a test");
+}
+static void test24(void) {
+    notice("first");
+    message_handlers_notice(0);
+    notice("second");
+    message_handlers_notice(1, message_log_stdout);
+    notice("third");
+}
+
+/* Given the test number, intended exit status and message, and the function
+   to run, print ok or not ok. */
+static void
+test_error(int n, int status, const char *output, test_function_t function)
+{
+    int real_status;
+    char buf[256];
+    int succeeded = 1;
+
+    real_status = run_test(function, buf, sizeof(buf));
+    if (!WIFEXITED(real_status) || status != WEXITSTATUS(real_status)) {
+        printf("  unexpected exit status %d\n", real_status);
+        succeeded = 0;
+    }
+    if (strcmp(output, buf)) {
+        printf("  unexpected output: %s", buf);
+        printf("    expected output: %s", output);
+        succeeded = 0;
+    }
+    printf("%sok %d\n", succeeded ? "" : "not ", n);
+}
+
+/* Given the test number, intended status, intended message sans the
+   appended strerror output, errno, and the function to run, print ok or not
+   ok. */
+static void
+test_strerror(int n, int status, const char *output, int error,
+              test_function_t function)
+{
+    char *full_output;
+
+    full_output = concat(output, ": ", strerror(error), "\n", END);
+    test_error(n, status, full_output, function);
+    free(full_output);
+}
+
+/* Run the tests. */
+int
+main(void)
+{
+    char buff[32];
+
+    test_init(24);
+
+    test_error(1, 0, "warning\n", test1);
+    test_error(2, 1, "fatal\n", test2);
+    test_strerror(3, 0, "permissions", EPERM, test3);
+    test_strerror(4, 1, "fatal access", EACCES, test4);
+    test_error(5, 0, "test5: warning\n", test5);
+    test_error(6, 1, "test6: fatal\n", test6);
+    test_strerror(7, 0, "test7: perms 7", EPERM, test7);
+    test_strerror(8, 1, "test8: fatal", EACCES, test8);
+    test_error(9, 10, "fatal\n", test9);
+    test_strerror(10, 10, "fatal perm", EPERM, test10);
+    test_strerror(11, 10, "1st test11: fatal", EPERM, test11);
+    test_error(12, 0, "7 0 warning\n", test12);
+    test_error(13, 1, "5 0 fatal\n", test13);
+
+    sprintf(buff, "%d", EPERM);
+
+    test_error(14, 0,
+               concat("7 ", buff, " warning\n7 ", buff, " warning\n", END),
+               test14);
+    test_error(15, 10,
+               concat("5 ", buff, " fatal\n5 ", buff, " fatal\n", END),
+               test15);
+    test_error(16, 0,
+               concat("test16: warning: ", strerror(EPERM), "\n7 ", buff,
+                      " warning\n", END),
+               test16);
+
+    test_error(17, 0, "notice\n", test17);
+    test_error(18, 0, "test18: notice\n", test18);
+    test_error(19, 0, "", test19);
+    test_error(20, 0, "3 0 foo\n", test20);
+    test_error(21, 0, "test23: baz\n", test21);
+
+    /* Make sure that it's possible to turn off a message type entirely. */ 
+    test_error(22, 1, "", test22);
+    test_error(23, 0, "", test23);
+    test_error(24, 0, "first\nthird\n", test24);
+
+    return 0;
+}
diff --git a/tests/util/xmalloc-t.in b/tests/util/xmalloc-t.in
new file mode 100644
index 0000000..e4e971d
--- /dev/null
+++ b/tests/util/xmalloc-t.in
@@ -0,0 +1,107 @@
+#! /bin/sh
+# $Id$
+#
+# Test suite for xmalloc and friends.
+
+# The count starts at 1 and is updated each time ok is printed.  printcount
+# takes "ok" or "not ok".
+count=1
+printcount () {
+    echo "$1 $count $2"
+    count=`expr $count + 1`
+}
+
+# Run a program expected to succeed, and print ok if it does.
+runsuccess () {
+    output=`$xmalloc "$1" "$2" "$3" 2>&1 >/dev/null`
+    status=$?
+    if test $status = 0 && test -z "$output" ; then
+        printcount "ok"
+    else
+        if test $status = 2 ; then
+            printcount "ok" "# skip no data limit support"
+        else
+            printcount "not ok"
+            echo "  $output"
+        fi
+    fi
+}
+
+# Run a program expected to fail and make sure it fails with an exit status
+# of 2 and the right failure message.  Strip the colon and everything after
+# it off the error message since it's system-specific.
+runfailure () {
+    output=`$xmalloc "$1" "$2" "$3" 2>&1 >/dev/null`
+    status=$?
+    output=`echo "$output" | sed 's/:.*//' \
+                | sed 's% [^ ]*/xmalloc.c% xmalloc.c%'`
+    if test $status = 1 && test x"$output" = x"$4" ; then
+        printcount "ok"
+    else
+        if test $status = 2 ; then
+            printcount "ok" "# skip no data limit support"
+        else
+            printcount "not ok"
+            echo "  saw: $output"
+            echo "  not: $4"
+        fi
+    fi
+}
+
+# Find where the helper program is.
+xmalloc="@abs_top_builddir@/tests/util/xmalloc"
+
+# Total tests.
+echo 36
+
+# First run the tests expected to succeed.
+runsuccess "m" "21"     "0"
+runsuccess "m" "128000" "0"
+runsuccess "m" "0"      "0"
+runsuccess "r" "21"     "0"
+runsuccess "r" "128000" "0"
+runsuccess "s" "21"     "0"
+runsuccess "s" "128000" "0"
+runsuccess "n" "21"     "0"
+runsuccess "n" "128000" "0"
+runsuccess "c" "24"     "0"
+runsuccess "c" "128000" "0"
+runsuccess "a" "24"     "0"
+runsuccess "a" "128000" "0"
+runsuccess "v" "24"     "0"
+runsuccess "v" "128000" "0"
+
+# Now limit our memory to 120KB and then try the large ones again, all of
+# which should fail.
+runfailure "m" "128000" "120000" \
+    "failed to malloc 128000 bytes at xmalloc.c line 54"
+runfailure "r" "128000" "120000" \
+    "failed to realloc 128000 bytes at xmalloc.c line 80"
+runfailure "s" "64000"  "120000" \
+    "failed to strdup 64000 bytes at xmalloc.c line 109"
+runfailure "n" "64000"  "120000" \
+    "failed to strndup 64000 bytes at xmalloc.c line 133"
+runfailure "c" "128000" "120000" \
+    "failed to calloc 128000 bytes at xmalloc.c line 155"
+runfailure "a" "64000" "120000" \
+    "failed to asprintf 64000 bytes at xmalloc.c line 177"
+runfailure "v" "64000" "120000" \
+    "failed to vasprintf 64000 bytes at xmalloc.c line 196"
+
+# Check our custom error handler.
+runfailure "M" "128000" "120000" "malloc 128000 xmalloc.c 54"
+runfailure "R" "128000" "120000" "realloc 128000 xmalloc.c 80"
+runfailure "S" "64000"  "120000" "strdup 64000 xmalloc.c 109"
+runfailure "N" "64000"  "120000" "strndup 64000 xmalloc.c 133"
+runfailure "C" "128000" "120000" "calloc 128000 xmalloc.c 155"
+runfailure "A" "64000"  "120000" "asprintf 64000 xmalloc.c 177"
+runfailure "V" "64000"  "120000" "vasprintf 64000 xmalloc.c 196"
+
+# Check the smaller ones again just for grins.
+runsuccess "m" "21" "96000"
+runsuccess "r" "32" "96000"
+runsuccess "s" "64" "96000"
+runsuccess "n" "20" "96000"
+runsuccess "c" "24" "96000"
+runsuccess "a" "30" "96000"
+runsuccess "v" "35" "96000"
diff --git a/tests/util/xmalloc.c b/tests/util/xmalloc.c
new file mode 100644
index 0000000..4327681
--- /dev/null
+++ b/tests/util/xmalloc.c
@@ -0,0 +1,294 @@
+/* $Id$ */
+/* Test suite for xmalloc and family. */
+
+/* Copyright (c) 2004, 2005, 2006
+       by Internet Systems Consortium, Inc. ("ISC")
+   Copyright (c) 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+       2002, 2003 by The Internet Software Consortium and Rich Salz
+
+   This code is derived from software contributed to the Internet Software
+   Consortium by Rich Salz.
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+   REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY
+   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <config.h>
+#include <system.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+/* Linux requires sys/time.h be included before sys/resource.h. */
+#include <sys/resource.h>
+
+#include <util/util.h>
+
+/* A customized error handler for checking xmalloc's support of them.
+   Prints out the error message and exits with status 1. */
+static void
+test_handler(const char *function, size_t size, const char *file, int line)
+{
+    die("%s %lu %s %d", function, (unsigned long) size, file, line);
+}
+
+/* Allocate the amount of memory given and write to all of it to make sure
+   we can, returning true if that succeeded and false on any sort of
+   detectable error. */
+static int
+test_malloc(size_t size)
+{
+    char *buffer;
+    size_t i;
+
+    buffer = xmalloc(size);
+    if (buffer == NULL)
+        return 0;
+    if (size > 0)
+        memset(buffer, 1, size);
+    for (i = 0; i < size; i++)
+        if (buffer[i] != 1)
+            return 0;
+    free(buffer);
+    return 1;
+}
+
+/* Allocate half the memory given, write to it, then reallocate to the
+   desired size, writing to the rest and then checking it all.  Returns true
+   on success, false on any failure. */
+static int
+test_realloc(size_t size)
+{
+    char *buffer;
+    size_t i;
+
+    buffer = xmalloc(size / 2);
+    if (buffer == NULL)
+        return 0;
+    if (size / 2 > 0)
+        memset(buffer, 1, size / 2);
+    buffer = xrealloc(buffer, size);
+    if (buffer == NULL)
+        return 0;
+    if (size > 0)
+        memset(buffer + size / 2, 2, size - size / 2);
+    for (i = 0; i < size / 2; i++)
+        if (buffer[i] != 1)
+            return 0;
+    for (i = size / 2; i < size; i++)
+        if (buffer[i] != 2)
+            return 0;
+    free(buffer);
+    return 1;
+}
+
+/* Generate a string of the size indicated, call xstrdup on it, and then
+   ensure the result matches.  Returns true on success, false on any
+   failure. */
+static int
+test_strdup(size_t size)
+{
+    char *string, *copy;
+    int match;
+
+    string = xmalloc(size);
+    if (string == NULL)
+        return 0;
+    memset(string, 1, size - 1);
+    string[size - 1] = '\0';
+    copy = xstrdup(string);
+    if (copy == NULL)
+        return 0;
+    match = strcmp(string, copy);
+    free(string);
+    free(copy);
+    return (match == 0);
+}
+
+/* Generate a string of the size indicated plus some, call xstrndup on it, and
+   then ensure the result matches.  Returns true on success, false on any
+   failure. */
+static int
+test_strndup(size_t size)
+{
+    char *string, *copy;
+    int match, toomuch;
+
+    string = xmalloc(size + 1);
+    if (string == NULL)
+        return 0;
+    memset(string, 1, size - 1);
+    string[size - 1] = 2;
+    string[size] = '\0';
+    copy = xstrndup(string, size - 1);
+    if (copy == NULL)
+        return 0;
+    match = strncmp(string, copy, size - 1);
+    toomuch = strcmp(string, copy);
+    free(string);
+    free(copy);
+    return (match == 0 && toomuch != 0);
+}
+
+/* Allocate the amount of memory given and check that it's all zeroed,
+   returning true if that succeeded and false on any sort of detectable
+   error. */
+static int
+test_calloc(size_t size)
+{
+    char *buffer;
+    size_t i, nelems;
+
+    nelems = size / 4;
+    if (nelems * 4 != size)
+        return 0;
+    buffer = xcalloc(nelems, 4);
+    if (buffer == NULL)
+        return 0;
+    for (i = 0; i < size; i++)
+        if (buffer[i] != 0)
+            return 0;
+    free(buffer);
+    return 1;
+}
+
+/* Test asprintf with a large string (essentially using it as strdup).
+   Returns true if successful, false otherwise. */
+static int
+test_asprintf(size_t size)
+{
+    char *copy, *string;
+    int status;
+    size_t i;
+
+    string = xmalloc(size);
+    memset(string, 42, size - 1);
+    string[size - 1] = '\0';
+    status = xasprintf(&copy, "%s", string);
+    free(string);
+    for (i = 0; i < size - 1; i++)
+        if (copy[i] != 42)
+            return 0;
+    if (copy[size - 1] != '\0')
+        return 0;
+    free(copy);
+    return 1;
+}
+
+/* Wrapper around vasprintf to do the va_list stuff. */
+static int
+xvasprintf_wrapper(char **strp, const char *format, ...)
+{
+    va_list args;
+    int status;
+
+    va_start(args, format);
+    status = xvasprintf(strp, format, args);
+    va_end(args);
+    return status;
+}
+
+/* Test vasprintf with a large string (essentially using it as strdup).
+   Returns true if successful, false otherwise. */
+static int
+test_vasprintf(size_t size)
+{
+    char *copy, *string;
+    int status;
+    size_t i;
+
+    string = xmalloc(size);
+    memset(string, 42, size - 1);
+    string[size - 1] = '\0';
+    status = xvasprintf_wrapper(&copy, "%s", string);
+    free(string);
+    for (i = 0; i < size - 1; i++)
+        if (copy[i] != 42)
+            return 0;
+    if (copy[size - 1] != '\0')
+        return 0;
+    free(copy);
+    return 1;
+}
+
+/* Take the amount of memory to allocate in bytes as a command-line argument
+   and call test_malloc with that amount of memory. */
+int
+main(int argc, char *argv[])
+{
+    size_t size, max;
+    size_t limit = 0;
+    int willfail = 0;
+    unsigned char code;
+    struct rlimit rl;
+
+    if (argc < 3)
+        die("Usage error.  Type, size, and limit must be given.");
+    errno = 0;
+    size = strtol(argv[2], 0, 10);
+    if (size == 0 && errno != 0)
+        sysdie("Invalid size");
+    errno = 0;
+    limit = strtol(argv[3], 0, 10);
+    if (limit == 0 && errno != 0)
+        sysdie("Invalid limit");
+
+    /* If a memory limit was given and we can set memory limits, set it.
+       Otherwise, exit 2, signalling to the driver that the test should be
+       skipped.  We do this here rather than in the driver due to some
+       pathological problems with Linux (setting ulimit in the shell caused
+       the shell to die). */
+    if (limit > 0) {
+#if HAVE_SETRLIMIT && defined(RLIMIT_DATA)
+        rl.rlim_cur = limit;
+        rl.rlim_max = limit;
+        if (setrlimit(RLIMIT_DATA, &rl) < 0) {
+            syswarn("Can't set data limit to %lu", (unsigned long) limit);
+            exit(2);
+        }
+#else
+        warn("Data limits aren't supported.");
+        exit(2);
+#endif
+    }
+
+    /* If the code is capitalized, install our customized error handler. */
+    code = argv[1][0];
+    if (isupper(code)) {
+        xmalloc_error_handler = test_handler;
+        code = tolower(code);
+    }
+
+    /* Decide if the allocation should fail.  If it should, set willfail to
+       2, so that if it unexpectedly succeeds, we exit with a status
+       indicating that the test should be skipped. */
+    max = size;
+    if (code == 's' || code == 'n' || code == 'a' || code == 'v')
+        max *= 2;
+    if (limit > 0 && max > limit)
+        willfail = 2;
+
+    switch (code) {
+    case 'c': exit(test_calloc(size) ? willfail : 1);
+    case 'm': exit(test_malloc(size) ? willfail : 1);
+    case 'r': exit(test_realloc(size) ? willfail : 1);
+    case 's': exit(test_strdup(size) ? willfail : 1);
+    case 'n': exit(test_strndup(size) ? willfail : 1);
+    case 'a': exit(test_asprintf(size) ? willfail : 1);
+    case 'v': exit(test_vasprintf(size) ? willfail : 1);
+    default:
+        die("Unknown mode %c", argv[1][0]);
+        break;
+    }
+    exit(1);
+}