87 files changed, 7311 insertions, 0 deletions

diff --git a/src/regress/lib/libc/Makefile b/src/regress/lib/libc/Makefile
new file mode 100644
index 0000000000..a6d3d766b1
--- /dev/null
+++ b/src/regress/lib/libc/Makefile
@@ -0,0 +1,18 @@
+#       $OpenBSD: Makefile,v 1.23 2006/03/25 20:28:19 otto Exp $
+
+SUBDIR+= _setjmp alloca atexit db getaddrinfo getcap getopt_long hsearch longjmp
+SUBDIR+= locale malloc
+SUBDIR+= netdb popen regex setjmp setjmp-signal sigreturn sigsetjmp
+SUBDIR+= sprintf strerror strtonum telldir time vis
+
+.if (${MACHINE_ARCH} != "vax")
+SUBDIR+= ieeefp
+.endif
+
+.if exists(arch/${MACHINE_ARCH})
+SUBDIR+= arch/${MACHINE_ARCH}
+.endif
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/_setjmp/Makefile b/src/regress/lib/libc/_setjmp/Makefile
new file mode 100644
index 0000000000..5d58242523
--- /dev/null
+++ b/src/regress/lib/libc/_setjmp/Makefile
@@ -0,0 +1,11 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
+#       $NetBSD: Makefile,v 1.2 1995/04/20 22:38:44 cgd Exp $
+
+PROG=   _setjmptest
+SRCS=   jmptest.c
+
+CFLAGS+= -DTEST_U_SETJMP
+
+.PATH:  ${.CURDIR}/../setjmp
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/Makefile b/src/regress/lib/libc/alloca/Makefile
new file mode 100644
index 0000000000..f31417cda7
--- /dev/null
+++ b/src/regress/lib/libc/alloca/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/02/12 06:49:04 mickey Exp $
+
+PROG=   alloca
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/alloca/alloca.c b/src/regress/lib/libc/alloca/alloca.c
new file mode 100644
index 0000000000..54fa90edae
--- /dev/null
+++ b/src/regress/lib/libc/alloca/alloca.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: alloca.c,v 1.7 2004/03/10 01:17:45 deraadt Exp $      */
+
+/*      Written by Michael Shalayeff, 2003, Public Domain.      */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(int argc, char *argv[])
+{
+        char *q, *p;
+
+        p = alloca(41);
+        strlcpy(p, "hellow world", 41);
+
+        q = alloca(53);
+        strlcpy(q, "hellow world", 53);
+
+        exit(strcmp(p, q));
+}
diff --git a/src/regress/lib/libc/arch/alpha/Makefile b/src/regress/lib/libc/arch/alpha/Makefile
new file mode 100644
index 0000000000..8c4dfb735c
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/02/23 01:25:11 art Exp $
+#       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:31 cgd Exp $
+
+# do nothing here; none of the tests here can be run automatically
+SUBDIR=
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/Makefile b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
new file mode 100644
index 0000000000..1da3ac8494
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/Makefile
@@ -0,0 +1,30 @@
+#       $OpenBSD: Makefile,v 1.2 2001/01/29 02:05:39 niklas Exp $
+#       $NetBSD: Makefile,v 1.1 1995/04/24 05:53:34 cgd Exp $
+
+PROG=   divremtest
+NOMAN=
+
+CLEANFILES+=    mkcases cases.c mktestcases testcases
+
+divremtest.c: cases.c
+
+cases.c: mkcases
+        /bin/rm -f cases.c
+        mkcases > cases.c
+
+# a typical strategy to use this:
+# compile a NetBSD divremtest binary, an OSF/1 divremtest binary, and an
+# OSF/1 mktestcases binary.  You then run mktestecases | divremtest -g
+# on an OSF/1 machine, and pipe the output to an rsh to a NetBSD machine
+# which then runs divremtest.  You can test an infinite number of random
+# values that way; I like to put a 'dd' in, so I can see how much I've done.
+
+testcases: mktestcases divremtest
+        /bin/rm -f testcases
+        mktestcases | divremtest -g > testcases
+
+regress:
+        @echo THIS TEST CANNOT BE RUN AUTOMATICALLY.
+        @false
+
+.include <bsd.prog.mk>
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
new file mode 100644
index 0000000000..3d9e8a6de2
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/divremtest.c
@@ -0,0 +1,184 @@
+/*      $OpenBSD: divremtest.c,v 1.2 2001/01/29 02:05:39 niklas Exp $   */
+/*      $NetBSD: divremtest.c,v 1.1 1995/04/24 05:53:35 cgd Exp $       */
+
+/*
+ * Copyright (c) 1995 Christopher G. Demetriou
+ * All rights reserved.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+
+void    testfile();
+void    usage();
+
+int generate;
+
+int
+main(argc, argv)
+        int argc;
+        char **argv;
+{
+        int c;
+
+        signal(SIGFPE, SIG_IGN);
+
+        while ((c = getopt(argc, argv, "g")) != -1)
+                switch (c) {
+                case 'g':
+                        generate = 1;
+                        break;
+
+                default:
+                        usage();
+                        break;
+        }
+
+        argc -= optind;
+        argv += optind;
+
+        if (argc == 0)
+                testfile();
+        else
+                for (; argc != 0; argc--, argv++) {
+                        if (freopen(argv[0], "r", stdin) == NULL) {
+                                fprintf(stderr,
+                                    "divremtest: couldn't open %s\n",
+                                    argv[0]);
+                                exit(1);
+                        }
+
+                        testfile();
+                }
+
+        exit(0);
+}
+
+void
+testfile()
+{
+        union operand {
+                unsigned long   input;
+                int             op_int;
+                unsigned int    op_u_int;
+                long            op_long;
+                unsigned long   op_u_long;
+        } op1, op2, divres, modres, divwant, modwant;
+        char opspec[6];
+        int encoded, i;
+
+        while (scanf("%6c %lx %lx %lx %lx\n", opspec, &op1.input,
+            &op2.input, &divwant.input, &modwant.input) != EOF) {
+
+                encoded = 0;
+
+                for (i = 0; i < 6; i += 2) {
+                        int posval;
+
+                        switch (opspec[i]) {
+                        case '.':
+                                posval = 0;
+                                break;
+                        case '-':
+                                posval = 1;
+                                break;
+                        default:
+                                fprintf(stderr,
+                                    "unknown signedness spec %c\n",
+                                    opspec[i]);
+                                exit(1);
+                        }
+                        encoded |= posval << ((5 - i) * 4);
+                }
+                        
+                for (i = 1; i < 6; i += 2) {
+                        int posval;
+
+                        switch (opspec[i]) {
+                        case 'i':
+                                posval = 0;
+                                break;
+                        case 'l':
+                                posval = 1;
+                                break;
+                        default:
+                                fprintf(stderr, "unknown length spec %c\n",
+                                    opspec[i]);
+                                exit(1);
+                        }
+                        encoded |= posval << ((5 - i) * 4);
+                }
+
+                /* KILL ME!!! */
+                switch (encoded) {
+
+#define TRY_IT(a, b, c)                                                 \
+        divres.a = op1.b / op2.c;                                       \
+        modres.a = op1.b % op2.c;                                       \
+        if (generate) {                                                 \
+                printf("%6s 0x%016lx 0x%016lx 0x%016lx 0x%016lx\n",     \
+                    opspec, op1.input, op2.input,                       \
+                    divres.a, modres.a);                                \
+        } else {                                                        \
+                if ((divres.a != divwant.a) ||                          \
+                    (modres.a != modwant.a)) {                          \
+                        fprintf(stderr, "%6s 0x%016lx 0x%016lx\n",      \
+                            opspec, op1.input, op2.input);              \
+                        fprintf(stderr, "FAILED:\n");                   \
+                        fprintf(stderr,                                 \
+                            "div:\twanted 0x%16lx, got 0x%16lx\n",      \
+                            divwant.a, divres.a);                       \
+                        fprintf(stderr,                                 \
+                            "mod:\twanted 0x%16lx, got 0x%16lx\n",      \
+                            modwant.a, modres.a);                       \
+                                                                        \
+                        exit(1);                                        \
+                }                                                       \
+        }
+
+#include "cases.c"
+
+#undef TRY_IT
+
+                default:
+                        fprintf(stderr,
+                            "INTERNAL ERROR: unknown encoding %x\n", encoded);
+                        exit(1);
+                }
+        }
+}
+
+void
+usage()
+{
+
+        fprintf(stderr, "usage: divremtest [-v] [testfile ...]\n");
+        exit(1);
+}
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
new file mode 100644
index 0000000000..fcb4765b8c
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mkcases.c
@@ -0,0 +1,64 @@
+/*      $OpenBSD: mkcases.c,v 1.2 2001/01/29 02:05:39 niklas Exp $      */
+/*      $NetBSD: mkcases.c,v 1.1 1995/04/24 05:53:36 cgd Exp $  */
+
+/*
+ * Copyright (c) 1995 Christopher G. Demetriou
+ * All rights reserved.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+char *tab[4] = { "u_int", "int", "u_long", "long" };
+
+int
+main()
+{
+        int i;
+
+        for (i = 0; i < 64; i++) {
+                printf(
+"               case 0x%d%d%d%d%d%d:    /* %s <= %s op %s */\n",
+                        (i >> 5) & 1,
+                        (i >> 4) & 1,
+                        (i >> 3) & 1,
+                        (i >> 2) & 1,
+                        (i >> 1) & 1,
+                        (i >> 0) & 1,
+                        tab[(i >> 4) & 0x3],
+                        tab[(i >> 2) & 0x3],
+                        tab[(i >> 0) & 0x3]);
+                printf(
+"                       TRY_IT(op_%s, op_%s, op_%s);\n",
+                        tab[(i >> 4) & 0x3],
+                        tab[(i >> 2) & 0x3],
+                        tab[(i >> 0) & 0x3]);
+                printf(
+"                       break;\n\n");
+        }
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
new file mode 100644
index 0000000000..3b01653f32
--- /dev/null
+++ b/src/regress/lib/libc/arch/alpha/divremtest/mktestcases.c
@@ -0,0 +1,68 @@
+/*      $OpenBSD: mktestcases.c,v 1.2 2001/01/29 02:05:40 niklas Exp $  */
+/*      $NetBSD: mktestcases.c,v 1.1 1995/04/24 05:53:37 cgd Exp $      */
+
+/*
+ * Copyright (c) 1995 Christopher G. Demetriou
+ * All rights reserved.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <stdio.h>
+
+int
+main()
+{
+        int i, j;
+        unsigned long n1, n2;
+
+        srandom(time(NULL));
+
+        for (i = 1; /* i < 10240 */ 1; i++) {
+                n1 = (unsigned)
+                    (random() & ((random() & random()) | 0x80000000));
+                n1 <<= 32;
+                n1 |= (unsigned)(random() & random() & random());
+
+                n2 = (unsigned)
+                    (random() & ((random() & random()) | 0x80000000));
+                n2 <<= 32;
+                n2 |= (unsigned)(random() & random() & random());
+
+                for (j = 0; j < 64; j++) {
+                        char *tab[] = { ".i", ".l", "-i", "-l" };
+
+                        printf("%s%s%s 0x%lx 0x%lx 0 0\n",
+                            tab[(j >> 4) & 0x3],
+                            tab[(j >> 2) & 0x3],
+                            tab[(j >> 0) & 0x3],
+                            n1, n2);
+                }
+        }
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/atexit/Makefile b/src/regress/lib/libc/atexit/Makefile
new file mode 100644
index 0000000000..c14b3c7ac4
--- /dev/null
+++ b/src/regress/lib/libc/atexit/Makefile
@@ -0,0 +1,16 @@
+#       $OpenBSD: Makefile,v 1.5 2003/07/31 22:46:59 david Exp $
+
+NOMAN=
+PROG=atexit_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+CLEANFILES+= invalid.out valid.out
+
+run-regress-atexit_test: ${PROG}
+        ./${PROG} -valid 2>${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+        ./${PROG} -invalid-atexit 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+        ./${PROG} -invalid-cleanup 2>${.OBJDIR}/invalid.out
+        cmp -s ${.OBJDIR}/invalid.out ${.CURDIR}/invalid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/atexit/atexit_test.c b/src/regress/lib/libc/atexit/atexit_test.c
new file mode 100644
index 0000000000..efa2274168
--- /dev/null
+++ b/src/regress/lib/libc/atexit/atexit_test.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: atexit_test.c,v 1.5 2003/09/02 23:52:16 david Exp $ */
+
+/*
+ * Copyright (c) 2002 Daniel Hartmeier
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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.
+ *
+ * Effort sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F30602-01-2-0537.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include "stdlib/atexit.h"
+
+void    handle_first(void);
+void    handle_middle(void);
+void    handle_last(void);
+void    handle_invalid(void);
+void    handle_cleanup(void);
+void    handle_signal(int);
+
+static int counter;
+
+int
+main(int argc, char *argv[])
+{
+        int i;
+
+        if (argc != 2 || (strcmp(argv[1], "-valid") &&
+            strcmp(argv[1], "-invalid-atexit") &&
+            strcmp(argv[1], "-invalid-cleanup"))) {
+                fprintf(stderr, "%s -valid/-invalid-atexit/-invalid-cleanup\n",
+                    argv[0]);
+                return (1);
+        }
+        fprintf(stderr, "main()\n");
+        if (atexit(handle_last)) {
+                perror("atexit(handle_last) failed");
+                return (1);
+        }
+        for (i = 0; i < 65535; ++i) {
+                if (atexit(handle_middle)) {
+                        perror("atexit(handle_middle) failed");
+                        return (1);
+                }
+        }
+        if (atexit(handle_first)) {
+                perror("atexit(handle_first) failed");
+                return (1);
+        }
+        /* this is supposed to segfault */
+        if (!strcmp(argv[1], "-invalid-atexit")) {
+                signal(SIGSEGV, handle_signal);
+                __atexit->fns[0] = handle_invalid;
+        } else if (!strcmp(argv[1], "-invalid-cleanup")) {
+                struct atexit *p = __atexit;
+
+                signal(SIGSEGV, handle_signal);
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                if (p == NULL)
+                        fprintf(stderr, "p == NULL, no page found\n");
+                p->fns[0] = handle_invalid;
+        }
+        __atexit_register_cleanup(handle_cleanup);
+        counter = 0;
+        fprintf(stderr, "main() returns\n");
+        return (0);
+}
+
+void
+handle_first(void)
+{
+        fprintf(stderr, "handle_first() counter == %i\n", counter);
+}
+
+void
+handle_middle(void)
+{
+        counter++;
+}
+
+void
+handle_last(void)
+{
+        fprintf(stderr, "handle_last() counter == %i\n", counter);
+}
+
+void
+handle_cleanup(void)
+{
+        fprintf(stderr, "handle_cleanup()\n");
+}
+
+void
+handle_invalid(void)
+{
+        fprintf(stderr, "handle_invalid() THIS SHOULD HAVE SEGFAULTED INSTEAD!\n");
+}
+
+void
+handle_signal(int sigraised)
+{
+        switch (sigraised) {
+        case SIGSEGV:
+                fprintf(stderr, "SIGSEGV\n");
+                exit(0);
+        default:
+                fprintf(stderr, "unexpected signal caught\n");
+                exit(1);
+        }
+}
diff --git a/src/regress/lib/libc/atexit/invalid.ok b/src/regress/lib/libc/atexit/invalid.ok
new file mode 100644
index 0000000000..98cbf8c1de
--- /dev/null
+++ b/src/regress/lib/libc/atexit/invalid.ok
@@ -0,0 +1,4 @@
+main()
+SIGSEGV
+handle_first() counter == 0
+handle_last() counter == 65535
diff --git a/src/regress/lib/libc/atexit/valid.ok b/src/regress/lib/libc/atexit/valid.ok
new file mode 100644
index 0000000000..6509e827a7
--- /dev/null
+++ b/src/regress/lib/libc/atexit/valid.ok
@@ -0,0 +1,5 @@
+main()
+main() returns
+handle_first() counter == 0
+handle_last() counter == 65535
+handle_cleanup()
diff --git a/src/regress/lib/libc/db/Makefile b/src/regress/lib/libc/db/Makefile
new file mode 100644
index 0000000000..7d2882594d
--- /dev/null
+++ b/src/regress/lib/libc/db/Makefile
@@ -0,0 +1,22 @@
+#       $OpenBSD: Makefile,v 1.10 2002/09/02 20:01:43 avsm Exp $
+#       $NetBSD: Makefile,v 1.11 1995/12/12 01:54:15 cgd Exp $
+
+PROG=   dbtest
+
+# add -DSTATISTICS to CFLAGS to get usage statistics.  Note that
+# for this to work, libc must be compiled with -DSTATISTICS as well
+CFLAGS+= -g -D__DBINTERFACE_PRIVATE -DDEBUG
+CLEANFILES+= t1 t2 t3 log
+
+DBTARGETS=1 2 3 4 5 6 7 8 9 10 11 12 13 20
+
+.for DT in ${DBTARGETS}
+db-${DT}: ${PROG}
+        sh ${.CURDIR}/run.test ${DT}
+REGRESS_TARGETS+=db-${DT}
+.PHONY: db-${DT}
+.endfor
+
+REGRESS_SLOW_TARGETS+=db-3 db-12 db-20
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/db/README b/src/regress/lib/libc/db/README
new file mode 100644
index 0000000000..23a1b77221
--- /dev/null
+++ b/src/regress/lib/libc/db/README
@@ -0,0 +1,69 @@
+#       $OpenBSD: README,v 1.3 2001/01/29 02:05:40 niklas Exp $
+#       $NetBSD: README,v 1.5 1996/05/03 21:54:19 cgd Exp $
+#       @(#)README      8.8 (Berkeley) 7/31/94
+
+To run the tests, enter "make regress".
+
+Fairly large files (the command files) are built in this directory during
+the test runs, and even larger files (the database files) are created in
+"/var/tmp".  If the latter directory doesn't exist, set the environmental
+variable TMPDIR to a directory where the files can be built.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+The script file consists of lines with an initial character which is
+the command for that line, or an initial character indicating a key
+or data entry for a previous command.
+
+Legal command characters are as follows:
+
+c: compare a record
+        + must be followed by [kK][dD]; the data value in the database
+          associated with the specified key is compared to the specified
+          data value.
+e: echo a string
+        + writes out the rest of the line into the output file; if the
+          last character is not a carriage-return, a newline is appended.
+f: set the flags for the next command
+        + no value zero's the flags
+g: do a get command
+        + must be followed by [kK]
+        + writes out the retrieved data DBT.
+o [r]: dump [reverse]
+        + dump the database out, if 'r' is set, in reverse order.
+p: do a put command
+        + must be followed by [kK][dD]
+r: do a del command
+        + must be followed by [kK] unless R_CURSOR flag set.
+S: sync the database
+s: do a seq command
+        + must be followed by [kK] if R_CURSOR flag set.
+        + writes out the retrieved data DBT.
+
+Legal key/data characters are as follows:
+
+D [file]: data file
+        + set the current data value to the contents of the file
+d [data]:
+        + set the current key value to the contents of the line.
+K [file]: key file
+        + set the current key value to the contents of the file
+k [data]:
+        + set the current key value to the contents of the line.
+
+Blank lines, lines with leading white space, and lines with leading
+hash marks (#) are ignored.
+
+Options to dbtest are as follows:
+
+        -d: Set the DB_LOCK flag.
+        -f: Use the file argument as the database file.
+        -i: Use the rest of the argument to set elements in the info
+            structure.  If the type is btree, then "-i cachesize=10240"
+            will set BTREEINFO.cachesize to 10240.
+        -o: The rest of the argument is the output file instead of
+            using stdout.
+        -s: Don't delete the database file before opening it, i.e.
+            use the database file from a previous run.
+
+Dbtest requires two arguments, the type of access "hash", "recno"
+or "btree", and the script name or "-" to indicate stdin.
diff --git a/src/regress/lib/libc/db/dbtest.c b/src/regress/lib/libc/db/dbtest.c
new file mode 100644
index 0000000000..8eda40d6b3
--- /dev/null
+++ b/src/regress/lib/libc/db/dbtest.c
@@ -0,0 +1,747 @@
+/*      $OpenBSD: dbtest.c,v 1.11 2003/07/31 21:48:02 deraadt Exp $     */
+/*      $NetBSD: dbtest.c,v 1.8 1996/05/03 21:57:48 cgd Exp $   */
+
+/*-
+ * Copyright (c) 1992, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * 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.
+ */
+
+#ifndef lint
+static char copyright[] =
+"@(#) Copyright (c) 1992, 1993, 1994\n\
+        The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)dbtest.c    8.17 (Berkeley) 9/1/94";
+#else
+static char rcsid[] = "$OpenBSD: dbtest.c,v 1.11 2003/07/31 21:48:02 deraadt Exp $";
+#endif
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+#include <db.h>
+
+enum S { COMMAND, COMPARE, GET, PUT, REMOVE, SEQ, SEQFLAG, KEY, DATA };
+
+void     compare(DBT *, DBT *);
+DBTYPE   dbtype(char *);
+void     dump(DB *, int);
+void     dberr(const char *, ...);
+void     get(DB *, DBT *);
+void     getdata(DB *, DBT *, DBT *);
+void     put(DB *, DBT *, DBT *);
+void     rem(DB *, DBT *);
+char    *sflags(int);
+void     synk(DB *);
+void    *rfile(char *, size_t *);
+void     seq(DB *, DBT *);
+u_int    setflags(char *);
+void    *setinfo(DBTYPE, char *);
+void     usage(void);
+void    *xmalloc(char *, size_t);
+
+DBTYPE type;                            /* Database type. */
+void *infop;                            /* Iflags. */
+u_long lineno;                          /* Current line in test script. */
+u_int flags;                            /* Current DB flags. */
+int ofd = STDOUT_FILENO;                /* Standard output fd. */
+
+DB *XXdbp;                              /* Global for gdb. */
+int XXlineno;                           /* Fast breakpoint for gdb. */
+
+int
+main(int argc, char *argv[])
+{
+        extern int optind;
+        extern char *optarg;
+        enum S command, state;
+        DB *dbp;
+        DBT data, key, keydata;
+        size_t len;
+        int ch, oflags, sflag;
+        char *fname, *infoarg, *p, *t, buf[8 * 1024];
+
+        infoarg = NULL;
+        fname = NULL;
+        oflags = O_CREAT | O_RDWR;
+        sflag = 0;
+        while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
+                switch (ch) {
+                case 'f':
+                        fname = optarg;
+                        break;
+                case 'i':
+                        infoarg = optarg;
+                        break;
+                case 'l':
+                        oflags |= DB_LOCK;
+                        break;
+                case 'o':
+                        if ((ofd = open(optarg,
+                            O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
+                                dberr("%s: %s", optarg, strerror(errno));
+                        break;
+                case 's':
+                        sflag = 1;
+                        break;
+                case '?':
+                default:
+                        usage();
+                }
+        argc -= optind;
+        argv += optind;
+
+        if (argc != 2)
+                usage();
+
+        /* Set the type. */
+        type = dbtype(*argv++);
+
+        /* Open the descriptor file. */
+        if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
+            dberr("%s: %s", *argv, strerror(errno));
+
+        /* Set up the db structure as necessary. */
+        if (infoarg == NULL)
+                infop = NULL;
+        else
+                for (p = strtok(infoarg, ",\t "); p != NULL;
+                    p = strtok(0, ",\t "))
+                        if (*p != '\0')
+                                infop = setinfo(type, p);
+
+        /*
+         * Open the DB.  Delete any preexisting copy, you almost never
+         * want it around, and it often screws up tests.
+         */
+        if (fname == NULL) {
+                p = getenv("TMPDIR");
+                if (p == NULL)
+                        p = "/var/tmp";
+                (void)snprintf(buf, sizeof buf, "%s/__dbtest", p);
+                fname = buf;
+                (void)unlink(buf);
+        } else  if (!sflag)
+                (void)unlink(fname);
+
+        if ((dbp = dbopen(fname,
+            oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
+                dberr("dbopen: %s", strerror(errno));
+        XXdbp = dbp;
+
+        state = COMMAND;
+        for (lineno = 1;
+            (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
+                /* Delete the newline, displaying the key/data is easier. */
+                if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
+                        *t = '\0';
+                if ((len = strlen(buf)) == 0 || isspace(*p) || *p == '#')
+                        continue;
+
+                /* Convenient gdb break point. */
+                if (XXlineno == lineno)
+                        XXlineno = 1;
+                switch (*p) {
+                case 'c':                       /* compare */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = COMPARE;
+                        break;
+                case 'e':                       /* echo */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        /* Don't display the newline, if CR at EOL. */
+                        if (p[len - 2] == '\r')
+                                --len;
+                        if (write(ofd, p + 1, len - 1) != len - 1 ||
+                            write(ofd, "\n", 1) != 1)
+                                dberr("write: %s", strerror(errno));
+                        break;
+                case 'g':                       /* get */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = GET;
+                        break;
+                case 'p':                       /* put */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        state = KEY;
+                        command = PUT;
+                        break;
+                case 'r':                       /* remove */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        if (flags == R_CURSOR) {
+                                rem(dbp, &key);
+                                state = COMMAND;
+                        } else {
+                                state = KEY;
+                                command = REMOVE;
+                        }
+                        break;
+                case 'S':                       /* sync */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        synk(dbp);
+                        state = COMMAND;
+                        break;
+                case 's':                       /* seq */
+                        if (state != COMMAND)
+                                dberr("line %lu: not expecting command",
+                                    lineno);
+                        if (flags == R_CURSOR) {
+                                state = KEY;
+                                command = SEQ;
+                        } else
+                                seq(dbp, &key);
+                        break;
+                case 'f':
+                        flags = setflags(p + 1);
+                        break;
+                case 'D':                       /* data file */
+                        if (state != DATA)
+                                dberr("line %lu: not expecting data", lineno);
+                        data.data = rfile(p + 1, &data.size);
+                        goto ldata;
+                case 'd':                       /* data */
+                        if (state != DATA)
+                                dberr("line %lu: not expecting data", lineno);
+                        data.data = xmalloc(p + 1, len - 1);
+                        data.size = len - 1;
+ldata:                  switch (command) {
+                        case COMPARE:
+                                compare(&keydata, &data);
+                                break;
+                        case PUT:
+                                put(dbp, &key, &data);
+                                break;
+                        default:
+                                dberr("line %lu: command doesn't take data",
+                                    lineno);
+                        }
+                        if (type != DB_RECNO)
+                                free(key.data);
+                        free(data.data);
+                        state = COMMAND;
+                        break;
+                case 'K':                       /* key file */
+                        if (state != KEY)
+                                dberr("line %lu: not expecting a key", lineno);
+                        if (type == DB_RECNO)
+                                dberr("line %lu: 'K' not available for recno",
+                                    lineno);
+                        key.data = rfile(p + 1, &key.size);
+                        goto lkey;
+                case 'k':                       /* key */
+                        if (state != KEY)
+                                dberr("line %lu: not expecting a key", lineno);
+                        if (type == DB_RECNO) {
+                                static recno_t recno;
+                                recno = atoi(p + 1);
+                                key.data = &recno;
+                                key.size = sizeof(recno);
+                        } else {
+                                key.data = xmalloc(p + 1, len - 1);
+                                key.size = len - 1;
+                        }
+lkey:                   switch (command) {
+                        case COMPARE:
+                                getdata(dbp, &key, &keydata);
+                                state = DATA;
+                                break;
+                        case GET:
+                                get(dbp, &key);
+                                if (type != DB_RECNO)
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        case PUT:
+                                state = DATA;
+                                break;
+                        case REMOVE:
+                                rem(dbp, &key);
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        case SEQ:
+                                seq(dbp, &key);
+                                if ((type != DB_RECNO) && (flags != R_CURSOR))
+                                        free(key.data);
+                                state = COMMAND;
+                                break;
+                        default:
+                                dberr("line %lu: command doesn't take a key",
+                                    lineno);
+                        }
+                        break;
+                case 'o':
+                        dump(dbp, p[1] == 'r');
+                        break;
+                default:
+                        dberr("line %lu: %s: unknown command character",
+                            lineno, p);
+                }
+        }
+#ifdef STATISTICS
+        /*
+         * -l must be used (DB_LOCK must be set) for this to be
+         * used, otherwise a page will be locked and it will fail.
+         */
+        if (type == DB_BTREE && oflags & DB_LOCK)
+                __bt_stat(dbp);
+#endif
+        if (dbp->close(dbp))
+                dberr("db->close: %s", strerror(errno));
+        (void)close(ofd);
+        exit(0);
+}
+
+#define NOOVERWRITE     "put failed, would overwrite key\n"
+
+void
+compare(db1, db2)
+        DBT *db1, *db2;
+{
+        register size_t len;
+        register u_char *p1, *p2;
+
+        if (db1->size != db2->size)
+                printf("compare failed: key->data len %lu != data len %lu\n",
+                    db1->size, db2->size);
+
+        len = MIN(db1->size, db2->size);
+        for (p1 = db1->data, p2 = db2->data; len--;)
+                if (*p1++ != *p2++) {
+                        printf("compare failed at offset %d\n",
+                            p1 - (u_char *)db1->data);
+                        break;
+                }
+}
+
+void
+get(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        DBT data;
+
+        switch (dbp->get(dbp, kp, &data, flags)) {
+        case 0:
+                (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
+                break;
+        case -1:
+                dberr("line %lu: get: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+#define NOSUCHKEY       "get failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else
+                        (void)fprintf(stderr, "%d: %.*s: %s",
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+#undef  NOSUCHKEY
+                break;
+        }
+}
+
+void
+getdata(dbp, kp, dp)
+        DB *dbp;
+        DBT *kp, *dp;
+{
+        switch (dbp->get(dbp, kp, dp, flags)) {
+        case 0:
+                return;
+        case -1:
+                dberr("line %lu: getdata: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+                dberr("line %lu: getdata failed, no such key", lineno);
+                /* NOTREACHED */
+        }
+}
+
+void
+put(dbp, kp, dp)
+        DB *dbp;
+        DBT *kp, *dp;
+{
+        switch (dbp->put(dbp, kp, dp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: put: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+                (void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
+                break;
+        }
+}
+
+void
+rem(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        switch (dbp->del(dbp, kp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: rem: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+#define NOSUCHKEY       "rem failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags != R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: rem of cursor failed\n", lineno);
+#undef  NOSUCHKEY
+                break;
+        }
+}
+
+void
+synk(dbp)
+        DB *dbp;
+{
+        switch (dbp->sync(dbp, flags)) {
+        case 0:
+                break;
+        case -1:
+                dberr("line %lu: synk: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        }
+}
+
+void
+seq(dbp, kp)
+        DB *dbp;
+        DBT *kp;
+{
+        DBT data;
+
+        switch (dbp->seq(dbp, kp, &data, flags)) {
+        case 0:
+                (void)write(ofd, data.data, data.size);
+                if (ofd == STDOUT_FILENO)
+                        (void)write(ofd, "\n", 1);
+                break;
+        case -1:
+                dberr("line %lu: seq: %s", lineno, strerror(errno));
+                /* NOTREACHED */
+        case 1:
+#define NOSUCHKEY       "seq failed, no such key\n"
+                if (ofd != STDOUT_FILENO)
+                        (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
+                else if (flags == R_CURSOR)
+                        (void)fprintf(stderr, "%d: %.*s: %s", 
+                            lineno, MIN(kp->size, 20), kp->data, NOSUCHKEY);
+                else
+                        (void)fprintf(stderr,
+                            "%d: seq (%s) failed\n", lineno, sflags(flags));
+#undef  NOSUCHKEY
+                break;
+        }
+}
+
+void
+dump(dbp, rev)
+        DB *dbp;
+        int rev;
+{
+        DBT key, data;
+        int flags, nflags;
+
+        if (rev) {
+                flags = R_LAST;
+                nflags = R_PREV;
+        } else {
+                flags = R_FIRST;
+                nflags = R_NEXT;
+        }
+        for (;; flags = nflags)
+                switch (dbp->seq(dbp, &key, &data, flags)) {
+                case 0:
+                        (void)write(ofd, data.data, data.size);
+                        if (ofd == STDOUT_FILENO)
+                                (void)write(ofd, "\n", 1);
+                        break;
+                case 1:
+                        goto done;
+                case -1:
+                        dberr("line %lu: (dump) seq: %s",
+                            lineno, strerror(errno));
+                        /* NOTREACHED */
+                }
+done:   return;
+}
+        
+u_int
+setflags(s)
+        char *s;
+{
+        char *p;
+
+        for (; isspace(*s); ++s);
+        if (*s == '\n' || *s == '\0')
+                return (0);
+        if ((p = strchr(s, '\n')) != NULL)
+                *p = '\0';
+        if (!strcmp(s, "R_CURSOR"))             return (R_CURSOR);
+        if (!strcmp(s, "R_FIRST"))              return (R_FIRST);
+        if (!strcmp(s, "R_IAFTER"))             return (R_IAFTER);
+        if (!strcmp(s, "R_IBEFORE"))            return (R_IBEFORE);
+        if (!strcmp(s, "R_LAST"))               return (R_LAST);
+        if (!strcmp(s, "R_NEXT"))               return (R_NEXT);
+        if (!strcmp(s, "R_NOOVERWRITE"))        return (R_NOOVERWRITE);
+        if (!strcmp(s, "R_PREV"))               return (R_PREV);
+        if (!strcmp(s, "R_SETCURSOR"))          return (R_SETCURSOR);
+
+        dberr("line %lu: %s: unknown flag", lineno, s);
+        /* NOTREACHED */
+}
+
+char *
+sflags(flags)
+        int flags;
+{
+        switch (flags) {
+        case R_CURSOR:          return ("R_CURSOR");
+        case R_FIRST:           return ("R_FIRST");
+        case R_IAFTER:          return ("R_IAFTER");
+        case R_IBEFORE:         return ("R_IBEFORE");
+        case R_LAST:            return ("R_LAST");
+        case R_NEXT:            return ("R_NEXT");
+        case R_NOOVERWRITE:     return ("R_NOOVERWRITE");
+        case R_PREV:            return ("R_PREV");
+        case R_SETCURSOR:       return ("R_SETCURSOR");
+        }
+
+        return ("UNKNOWN!");
+}
+        
+DBTYPE
+dbtype(s)
+        char *s;
+{
+        if (!strcmp(s, "btree"))
+                return (DB_BTREE);
+        if (!strcmp(s, "hash"))
+                return (DB_HASH);
+        if (!strcmp(s, "recno"))
+                return (DB_RECNO);
+        dberr("%s: unknown type (use btree, hash or recno)", s);
+        /* NOTREACHED */
+}
+
+void *
+setinfo(type, s)
+        DBTYPE type;
+        char *s;
+{
+        static BTREEINFO ib;
+        static HASHINFO ih;
+        static RECNOINFO rh;
+        char *eq;
+
+        if ((eq = strchr(s, '=')) == NULL)
+                dberr("%s: illegal structure set statement", s);
+        *eq++ = '\0';
+        if (!isdigit(*eq))
+                dberr("%s: structure set statement must be a number", s);
+                
+        switch (type) {
+        case DB_BTREE:
+                if (!strcmp("flags", s)) {
+                        ib.flags = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("cachesize", s)) {
+                        ib.cachesize = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("maxkeypage", s)) {
+                        ib.maxkeypage = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("minkeypage", s)) {
+                        ib.minkeypage = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("lorder", s)) {
+                        ib.lorder = atoi(eq);
+                        return (&ib);
+                }
+                if (!strcmp("psize", s)) {
+                        ib.psize = atoi(eq);
+                        return (&ib);
+                }
+                break;
+        case DB_HASH:
+                if (!strcmp("bsize", s)) {
+                        ih.bsize = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("ffactor", s)) {
+                        ih.ffactor = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("nelem", s)) {
+                        ih.nelem = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("cachesize", s)) {
+                        ih.cachesize = atoi(eq);
+                        return (&ih);
+                }
+                if (!strcmp("lorder", s)) {
+                        ih.lorder = atoi(eq);
+                        return (&ih);
+                }
+                break;
+        case DB_RECNO:
+                if (!strcmp("flags", s)) {
+                        rh.flags = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("cachesize", s)) {
+                        rh.cachesize = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("lorder", s)) {
+                        rh.lorder = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("reclen", s)) {
+                        rh.reclen = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("bval", s)) {
+                        rh.bval = atoi(eq);
+                        return (&rh);
+                }
+                if (!strcmp("psize", s)) {
+                        rh.psize = atoi(eq);
+                        return (&rh);
+                }
+                break;
+        }
+        dberr("%s: unknown structure value", s);
+        /* NOTREACHED */
+}
+
+void *
+rfile(name, lenp)
+        char *name;
+        size_t *lenp;
+{
+        struct stat sb;
+        void *p;
+        int fd;
+        char *np;
+
+        for (; isspace(*name); ++name);
+        if ((np = strchr(name, '\n')) != NULL)
+                *np = '\0';
+        if ((fd = open(name, O_RDONLY, 0)) < 0 ||
+            fstat(fd, &sb))
+                dberr("%s: %s\n", name, strerror(errno));
+#ifdef NOT_PORTABLE
+        if (sb.st_size > (off_t)SIZE_T_MAX)
+                dberr("%s: %s\n", name, strerror(E2BIG));
+#endif
+        if ((p = (void *)malloc((u_int)sb.st_size)) == NULL)
+                dberr("%s", strerror(errno));
+        (void)read(fd, p, (int)sb.st_size);
+        *lenp = sb.st_size;
+        (void)close(fd);
+        return (p);
+}
+
+void *
+xmalloc(text, len)
+        char *text;
+        size_t len;
+{
+        void *p;
+
+        if ((p = (void *)malloc(len)) == NULL)
+                dberr("%s", strerror(errno));
+        memmove(p, text, len);
+        return (p);
+}
+
+void
+usage()
+{
+        (void)fprintf(stderr,
+            "usage: dbtest [-l] [-f file] [-i info] [-o file] type script\n");
+        exit(1);
+}
+
+void
+dberr(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        (void)fprintf(stderr, "dbtest: ");
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        exit(1);
+        /* NOTREACHED */
+}
diff --git a/src/regress/lib/libc/db/run.test b/src/regress/lib/libc/db/run.test
new file mode 100644
index 0000000000..0d6837e360
--- /dev/null
+++ b/src/regress/lib/libc/db/run.test
@@ -0,0 +1,707 @@
+#!/bin/sh -
+#
+#       $OpenBSD: run.test,v 1.3 2001/01/29 02:05:41 niklas Exp $
+#       $NetBSD: run.test,v 1.8 1996/05/03 21:57:51 cgd Exp $
+#       @(#)run.test    8.10 (Berkeley) 7/26/94
+#
+
+# db regression tests
+main()
+{
+
+        PROG=./dbtest
+        TMP1=t1
+        TMP2=t2
+        TMP3=t3
+
+        if [ -f /usr/share/dict/words ]; then
+                DICT=/usr/share/dict/words
+        elif [ -f /usr/dict/words ]; then
+                DICT=/usr/dict/words
+        else
+                echo 'run.test: no dictionary'
+                exit 1
+        fi
+        
+        if [ $# -eq 0 ]; then
+                for t in 1 2 3 4 5 6 7 8 9 10 11 12 13 20; do
+                        test$t
+                done
+        else
+                while [ $# -gt 0 ]
+                        do case "$1" in
+                        test*)
+                                $1;;
+                        [0-9]*)
+                                test$1;;
+                        btree)
+                                for t in 1 2 3 7 8 9 10 12 13; do
+                                        test$t
+                                done;;
+                        hash)
+                                for t in 1 2 3 8 13 20; do
+                                        test$t
+                                done;;
+                        recno)
+                                for t in 1 2 3 4 5 6 7 10 11; do
+                                        test$t
+                                done;;
+                        *)
+                                echo "run.test: unknown test $1"
+                                echo "usage: run.test test# | type"
+                                exit 1
+                        esac
+                        shift
+                done
+        fi
+        rm -f $TMP1 $TMP2 $TMP3
+        exit 0
+}
+
+# Take the first hundred entries in the dictionary, and make them
+# be key/data pairs.
+test1()
+{
+        echo "Test 1: btree, hash: small key, small data pairs"
+        sed 200q $DICT > $TMP1
+        for type in btree hash; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 200q $DICT`; do
+                        echo p
+                        echo k$i
+                        echo d$i
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test1: type $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 1: recno: small key, small data pairs"
+        rm -f $TMP2 $TMP3
+        sed 200q $DICT |
+        awk '{ 
+                ++i;
+                printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test1: type recno: failed"
+                exit 1
+        fi
+}
+
+# Take the first 200 entries in the dictionary, and give them
+# each a medium size data entry.
+test2()
+{
+        echo "Test 2: btree, hash: small key, medium data pairs"
+        mdata=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
+        echo $mdata |
+        awk '{ for (i = 1; i < 201; ++i) print $0 }' > $TMP1
+        for type in hash btree; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 200q $DICT`; do
+                        echo p
+                        echo k$i
+                        echo d$mdata
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test2: type $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 2: recno: small key, medium data pairs"
+        rm -f $TMP2 $TMP3
+        echo $mdata | 
+        awk '{  for (i = 1; i < 201; ++i)
+                printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test2: type recno: failed"
+                exit 1
+        fi
+}
+
+# Insert the programs in /bin with their paths as their keys.
+test3()
+{
+        echo "Test 3: hash: small key, big data pairs"
+        rm -f $TMP1
+        (find /bin -type f -print | xargs cat) > $TMP1
+        for type in hash; do
+                rm -f $TMP2 $TMP3
+                for i in `find /bin -type f -print`; do
+                        echo p
+                        echo k$i
+                        echo D$i
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test3: $type: failed"
+                        exit 1
+                fi
+        done
+        echo "Test 3: btree: small key, big data pairs"
+        for psize in 512 16384 65536; do
+                echo "    page size $psize"
+                for type in btree; do
+                        rm -f $TMP2 $TMP3
+                        for i in `find /bin -type f -print`; do
+                                echo p
+                                echo k$i
+                                echo D$i
+                                echo g
+                                echo k$i
+                        done > $TMP2
+                        $PROG -i psize=$psize -o $TMP3 $type $TMP2
+                        if (cmp -s $TMP1 $TMP3) ; then :
+                        else
+                                echo "test3: $type: page size $psize: failed"
+                                exit 1
+                        fi
+                done
+        done
+        echo "Test 3: recno: big data pairs"
+        rm -f $TMP2 $TMP3
+        find /bin -type f -print | 
+        awk '{
+                ++i;
+                printf("p\nk%d\nD%s\ng\nk%d\n", i, $0, i);
+        }' > $TMP2
+        for psize in 512 16384 65536; do
+                echo "    page size $psize"
+                $PROG -i psize=$psize -o $TMP3 recno $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test3: recno: page size $psize: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Do random recno entries.
+test4()
+{
+        echo "Test 4: recno: random entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 37; i <= 37 + 88 * 17; i += 17) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 1; i <= 15; ++i) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 19234; i <= 19234 + 61 * 27; i += 27) {
+                        if (i % 41)
+                                s = substr($0, 1, i % 41);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 37;
+                        incr = 17;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        if (i == 19234 + 61 * 27)
+                                exit;
+                        if (i == 37 + 88 * 17) {
+                                i = 1;
+                                incr = 1;
+                        } else if (i == 15) {
+                                i = 19234;
+                                incr = 27;
+                        } else
+                                i += incr;
+                }
+                END {
+                        for (i = 37; i <= 37 + 88 * 17; i += 17)
+                                printf("g\nk%d\n", i);
+                        for (i = 1; i <= 15; ++i)
+                                printf("g\nk%d\n", i);
+                        for (i = 19234; i <= 19234 + 61 * 27; i += 27)
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test4: type recno: failed"
+                exit 1
+        fi
+}
+
+# Do reverse order recno entries.
+test5()
+{
+        echo "Test 5: recno: reverse order entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk ' {
+                for (i = 1500; i; --i) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 1500;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        --i;
+                }
+                END {
+                        for (i = 1500; i; --i) 
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test5: type recno: failed"
+                exit 1
+        fi
+}
+                
+# Do alternating order recno entries.
+test6()
+{
+        echo "Test 6: recno: alternating order entries"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk ' {
+                for (i = 1; i < 1200; i += 2) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                for (i = 2; i < 1200; i += 2) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("input key %d: %s\n", i, s);
+                }
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+        cat $TMP1 |
+        awk 'BEGIN {
+                        i = 1;
+                        even = 0;
+                }
+                {
+                        printf("p\nk%d\nd%s\n", i, $0);
+                        i += 2;
+                        if (i >= 1200) {
+                                if (even == 1)
+                                        exit;
+                                even = 1;
+                                i = 2;
+                        }
+                }
+                END {
+                        for (i = 1; i < 1200; ++i) 
+                                printf("g\nk%d\n", i);
+                }' > $TMP2
+        $PROG -o $TMP3 recno $TMP2
+        sort -o $TMP1 $TMP1
+        sort -o $TMP3 $TMP3
+        if (cmp -s $TMP1 $TMP3) ; then :
+        else
+                echo "test6: type recno: failed"
+                exit 1
+        fi
+}
+
+# Delete cursor record
+test7()
+{
+        echo "Test 7: btree, recno: delete cursor record"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 120; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                printf("%05d: input key %d: %s\n", 120, 120, $0);
+                printf("seq failed, no such key\n");
+                printf("%05d: input key %d: %s\n", 1, 1, $0);
+                printf("%05d: input key %d: %s\n", 2, 2, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 120)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_NEXT\n");
+                        for (i = 1; i <= 120; ++i)
+                                printf("s\n");
+                        printf("fR_CURSOR\ns\nk120\n");
+                        printf("r\n");
+                        printf("fR_NEXT\ns\n");
+                        printf("fR_CURSOR\ns\nk1\n");
+                        printf("r\n");
+                        printf("fR_FIRST\ns\n");
+                }' > $TMP2
+                $PROG -o $TMP3 recno $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test7: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Make sure that overflow pages are reused.
+test8()
+{
+        echo "Test 8: btree, hash: repeated small key, big data pairs"
+        rm -f $TMP1
+        echo "" | 
+        awk 'BEGIN {
+                for (i = 1; i <= 10; ++i) {
+                        printf("p\nkkey1\nD/bin/sh\n");
+                        printf("p\nkkey2\nD/bin/csh\n");
+                        if (i % 8 == 0) {
+                                printf("c\nkkey2\nD/bin/csh\n");
+                                printf("c\nkkey1\nD/bin/sh\n");
+                                printf("e\t%d of 10 (comparison)\n", i);
+                        } else
+                                printf("e\t%d of 10             \n", i);
+                        printf("r\nkkey1\nr\nkkey2\n");
+                }
+        }' > $TMP1
+        $PROG btree $TMP1
+#       $PROG hash $TMP1
+        # No explicit test for success.
+}
+
+# Test btree duplicate keys
+test9()
+{
+        echo "Test 9: btree: duplicate keys"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 543; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in btree; do
+                cat $TMP1 | 
+                awk '{
+                        if (i++ % 2)
+                                printf("p\nkduplicatekey\nd%s\n", $0);
+                        else
+                                printf("p\nkunique%dkey\nd%s\n", i, $0);
+                }
+                END {
+                                printf("o\n");
+                }' > $TMP2
+                $PROG -iflags=1 -o $TMP3 $type $TMP2
+                sort -o $TMP3 $TMP3
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test9: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Test use of cursor flags without initialization
+test10()
+{
+        echo "Test 10: btree, recno: test cursor flag use"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 20; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        # Test that R_CURSOR doesn't succeed before cursor initialized
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 10)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_CURSOR\nr\n");
+                        printf("eR_CURSOR SHOULD HAVE FAILED\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
+                if [ -s $TMP3 ] ; then
+                        echo "Test 10: delete: R_CURSOR SHOULD HAVE FAILED"
+                        exit 1
+                fi
+        done
+        for type in btree recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 10)
+                                exit;
+                        printf("p\nk%d\nd%s\n", ++i, $0);
+                }
+                END {
+                        printf("fR_CURSOR\np\nk1\ndsome data\n");
+                        printf("eR_CURSOR SHOULD HAVE FAILED\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
+                if [ -s $TMP3 ] ; then
+                        echo "Test 10: put: R_CURSOR SHOULD HAVE FAILED"
+                        exit 1
+                fi
+        done
+}
+
+# Test insert in reverse order.
+test11()
+{
+        echo "Test 11: recno: reverse order insert"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 779; ++i)
+                        printf("%05d: input key %d: %s\n", i, i, $0);
+                exit;
+        }' > $TMP1
+        rm -f $TMP2 $TMP3
+
+        for type in recno; do
+                cat $TMP1 |
+                awk '{
+                        if (i == 0) {
+                                i = 1;
+                                printf("p\nk1\nd%s\n", $0);
+                                printf("%s\n", "fR_IBEFORE");
+                        } else
+                                printf("p\nk1\nd%s\n", $0);
+                }
+                END {
+                                printf("or\n");
+                }' > $TMP2
+                $PROG -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test11: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Take the first 20000 entries in the dictionary, reverse them, and give
+# them each a small size data entry.  Use a small page size to make sure
+# the btree split code gets hammered.
+test12()
+{
+        echo "Test 12: btree: lots of keys, small page size"
+        mdata=abcdefghijklmnopqrstuvwxy
+        echo $mdata |
+        awk '{ for (i = 1; i < 20001; ++i) print $0 }' > $TMP1
+        for type in btree; do
+                rm -f $TMP2 $TMP3
+                for i in `sed 20000q $DICT | rev`; do
+                        echo p
+                        echo k$i
+                        echo d$mdata
+                        echo g
+                        echo k$i
+                done > $TMP2
+                $PROG -i psize=512 -o $TMP3 $type $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test12: type $type: failed"
+                        exit 1
+                fi
+        done
+}
+
+# Test different byte orders.
+test13()
+{
+        echo "Test 13: btree, hash: differing byte orders"
+        sed 50q $DICT > $TMP1
+        for order in 1234 4321; do
+                for type in btree hash; do
+                        rm -f byte.file $TMP2 $TMP3
+                        for i in `sed 50q $DICT`; do
+                                echo p
+                                echo k$i
+                                echo d$i
+                                echo g
+                                echo k$i
+                        done > $TMP2
+                        $PROG -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
+                        if (cmp -s $TMP1 $TMP3) ; then :
+                        else
+                                echo "test13: $type/$order put failed"
+                                exit 1
+                        fi
+                        for i in `sed 50q $DICT`; do
+                                echo g
+                                echo k$i
+                        done > $TMP2
+                        $PROG -s \
+                            -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
+                        if (cmp -s $TMP1 $TMP3) ; then :
+                        else
+                                echo "test13: $type/$order get failed"
+                                exit 1
+                        fi
+                done
+        done
+        rm -f byte.file
+}
+
+# Try a variety of bucketsizes and fill factors for hashing
+test20()
+{
+        echo\
+    "Test 20: hash: bucketsize, fill factor; nelem 25000 cachesize 65536"
+        echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
+        awk '{
+                for (i = 1; i <= 10000; ++i) {
+                        if (i % 34)
+                                s = substr($0, 1, i % 34);
+                        else
+                                s = substr($0, 1);
+                        printf("%s\n", s);
+                }
+                exit;
+        }' > $TMP1
+        sed 10000q $DICT |
+        awk 'BEGIN {
+                ds="abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg"
+        }
+        {
+                if (++i % 34)
+                        s = substr(ds, 1, i % 34);
+                else
+                        s = substr(ds, 1);
+                printf("p\nk%s\nd%s\n", $0, s);
+        }' > $TMP2
+        sed 10000q $DICT |
+        awk '{
+                ++i;
+                printf("g\nk%s\n", $0);
+        }' >> $TMP2
+        bsize=256
+        for ffactor in 11 14 21; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=512
+        for ffactor in 21 28 43; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=1024
+        for ffactor in 43 57 85; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=2048
+        for ffactor in 85 114 171; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=4096
+        for ffactor in 171 228 341; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+        bsize=8192
+        for ffactor in 341 455 683; do
+                echo "    bucketsize $bsize, fill factor $ffactor"
+                $PROG -o$TMP3 \
+                    -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
+                    hash $TMP2
+                if (cmp -s $TMP1 $TMP3) ; then :
+                else
+                        echo "test20: type hash:\
+bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
+                        exit 1
+                fi
+        done
+}
+
+main $*
diff --git a/src/regress/lib/libc/getaddrinfo/Makefile b/src/regress/lib/libc/getaddrinfo/Makefile
new file mode 100644
index 0000000000..4d4978a6a2
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.3 2002/09/02 20:01:43 avsm Exp $
+
+PROG=           gaitest
+SRCS=           gaitest.c
+NOMAN=          # defined
+CLEANFILES+=    out
+
+REGRESS_TARGETS=do-test
+
+do-test: ${PROG}
+        sh ${.CURDIR}/testsuite.sh >out 2>&1
+        @if diff -u out ${.CURDIR}/answer; then \
+                echo SUCCESS; \
+        else \
+                echo FAIL; \
+                exit 1; \
+        fi
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getaddrinfo/answer b/src/regress/lib/libc/getaddrinfo/answer
new file mode 100644
index 0000000000..fa4985958f
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/answer
@@ -0,0 +1,104 @@
+== basic ones
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv http
+ai1: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv tftp
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv tftp
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv tftp
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv echo
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv echo
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv echo
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai3: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+
+== specific address family
+arg: flags 0x2 family 2 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 24 socktype 0 protocol 0 addrlen 0 host localhost serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+
+== empty hostname
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv echo
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 7
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 7
+ai3: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 7
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 7
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv tftp
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 69
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 69
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv 80
+service not supported for ai_socktype
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv http
+ai1: flags 0x3 family 24 socktype 1 protocol 6 addrlen 28 host :: serv 80
+ai2: flags 0x3 family 2 socktype 1 protocol 6 addrlen 16 host 0.0.0.0 serv 80
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv echo
+ai1: flags 0x3 family 24 socktype 2 protocol 17 addrlen 28 host :: serv 7
+ai2: flags 0x3 family 24 socktype 1 protocol 6 addrlen 28 host :: serv 7
+ai3: flags 0x3 family 2 socktype 2 protocol 17 addrlen 16 host 0.0.0.0 serv 7
+ai4: flags 0x3 family 2 socktype 1 protocol 6 addrlen 16 host 0.0.0.0 serv 7
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv tftp
+ai1: flags 0x3 family 24 socktype 2 protocol 17 addrlen 28 host :: serv 69
+ai2: flags 0x3 family 2 socktype 2 protocol 17 addrlen 16 host 0.0.0.0 serv 69
+arg: flags 0x3 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv 80
+service not supported for ai_socktype
+arg: flags 0x2 family 0 socktype 1 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 80
+arg: flags 0x2 family 0 socktype 2 protocol 0 addrlen 0 host (empty) serv 80
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 80
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 80
+
+== empty servname
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host ::1 serv (empty)
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host 127.0.0.1 serv (empty)
+ai1: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 0
+ai2: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 24 socktype 2 protocol 17 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 2 protocol 17 addrlen 16 host 127.0.0.1 serv 0
+ai3: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host ::1 serv 0
+ai4: flags 0x2 family 2 socktype 1 protocol 6 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host (empty) serv (empty)
+name or service is not known
+
+== sock_raw
+arg: flags 0x2 family 0 socktype 3 protocol 0 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 24 socktype 3 protocol 0 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 3 protocol 0 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv (empty)
+ai1: flags 0x2 family 24 socktype 3 protocol 59 addrlen 28 host ::1 serv 0
+ai2: flags 0x2 family 2 socktype 3 protocol 59 addrlen 16 host 127.0.0.1 serv 0
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv 80
+service not supported for ai_socktype
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host localhost serv www
+service not supported for ai_socktype
+arg: flags 0x2 family 0 socktype 3 protocol 59 addrlen 0 host ::1 serv (empty)
+ai1: flags 0x2 family 24 socktype 3 protocol 59 addrlen 28 host ::1 serv 0
+
+== unsupported family
+arg: flags 0x2 family 99 socktype 0 protocol 0 addrlen 0 host localhost serv (empty)
+ai_family not supported
+
+== the following items are specified in jinmei scopeaddr format doc.
+arg: flags 0x2 family 0 socktype 0 protocol 0 addrlen 0 host fe80::1%lo0 serv http
+ai1: flags 0x2 family 24 socktype 1 protocol 6 addrlen 28 host fe80::1%lo0 serv 80
+
diff --git a/src/regress/lib/libc/getaddrinfo/gaitest.c b/src/regress/lib/libc/getaddrinfo/gaitest.c
new file mode 100644
index 0000000000..059c1aaa1a
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/gaitest.c
@@ -0,0 +1,188 @@
+/*      $OpenBSD: gaitest.c,v 1.5 2004/06/21 21:56:19 itojun Exp $      */
+/*      $NetBSD: gaitest.c,v 1.3 2002/07/05 15:47:43 itojun Exp $       */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, and 2002 WIDE Project.
+ * All rights reserved.
+ *
+ * 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 project 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 PROJECT 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 PROJECT 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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+struct addrinfo ai;
+
+char host[NI_MAXHOST];
+char serv[NI_MAXSERV];
+int vflag = 0;
+
+static void usage(void);
+static void print1(const char *, const struct addrinfo *, char *, char *);
+int main(int, char *[]);
+
+static void
+usage()
+{
+        fprintf(stderr, "usage: test [-f family] [-s socktype] [-p proto] [-DPRSv46] host serv\n");
+}
+
+static void
+print1(title, res, h, s)
+        const char *title;
+        const struct addrinfo *res;
+        char *h;
+        char *s;
+{
+        char *start, *end;
+        int error;
+        const int niflag = NI_NUMERICHOST | NI_NUMERICSERV;
+
+        if (res->ai_addr) {
+                error = getnameinfo(res->ai_addr, res->ai_addr->sa_len,
+                                    host, sizeof(host), serv, sizeof(serv),
+                                    niflag);
+                h = host;
+                s = serv;
+        } else
+                error = 0;
+
+        if (vflag) {
+                start = "\t";
+                end = "\n";
+        } else {
+                start = " ";
+                end = "";
+        }
+        printf("%s%s", title, end);
+        printf("%sflags 0x%x%s", start, res->ai_flags, end);
+        printf("%sfamily %d%s", start, res->ai_family, end);
+        printf("%ssocktype %d%s", start, res->ai_socktype, end);
+        printf("%sprotocol %d%s", start, res->ai_protocol, end);
+        printf("%saddrlen %d%s", start, res->ai_addrlen, end);
+        if (error)
+                printf("%serror %d%s", start, error, end);
+        else {
+                printf("%shost %s%s", start, h, end);
+                printf("%sserv %s%s", start, s, end);
+        }
+#if 0
+        if (res->ai_canonname)
+                printf("%scname \"%s\"%s", start, res->ai_canonname, end);
+#endif
+        if (!vflag)
+                printf("\n");
+
+}
+
+int
+main(argc, argv)
+        int argc;
+        char *argv[];
+{
+        struct addrinfo *res;
+        int error, i;
+        char *p, *q;
+        extern int optind;
+        extern char *optarg;
+        int c;
+        char nbuf[10];
+
+        memset(&ai, 0, sizeof(ai));
+        ai.ai_family = PF_UNSPEC;
+        ai.ai_flags |= AI_CANONNAME;
+        while ((c = getopt(argc, argv, "Df:p:PRs:Sv46")) != -1) {
+                switch (c) {
+                case 'D':
+                        ai.ai_socktype = SOCK_DGRAM;
+                        break;
+                case 'f':
+                        ai.ai_family = atoi(optarg);
+                        break;
+                case 'p':
+                        ai.ai_protocol = atoi(optarg);
+                        break;
+                case 'P':
+                        ai.ai_flags |= AI_PASSIVE;
+                        break;
+                case 'R':
+                        ai.ai_socktype = SOCK_RAW;
+                        break;
+                case 's':
+                        ai.ai_socktype = atoi(optarg);
+                        break;
+                case 'S':
+                        ai.ai_socktype = SOCK_STREAM;
+                        break;
+                case 'v':
+                        vflag++;
+                        break;
+                case '4':
+                        ai.ai_family = PF_INET;
+                        break;
+                case '6':
+                        ai.ai_family = PF_INET6;
+                        break;
+                default:
+                        usage();
+                        exit(1);
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        if (argc != 2){
+                usage();
+                exit(1);
+        }
+
+        p = *argv[0] ? argv[0] : NULL;
+        q = *argv[1] ? argv[1] : NULL;
+
+        print1("arg:", &ai, p ? p : "(empty)", q ? q : "(empty)");
+
+        error = getaddrinfo(p, q, &ai, &res);
+        if (error) {
+                printf("%s\n", gai_strerror(error));
+                exit(1);
+        }
+
+        i = 1;
+        do {
+                snprintf(nbuf, sizeof(nbuf), "ai%d:", i);
+                print1(nbuf, res, NULL, NULL);
+
+                i++;
+        } while ((res = res->ai_next) != NULL);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/getaddrinfo/testsuite.sh b/src/regress/lib/libc/getaddrinfo/testsuite.sh
new file mode 100644
index 0000000000..1e4e524054
--- /dev/null
+++ b/src/regress/lib/libc/getaddrinfo/testsuite.sh
@@ -0,0 +1,89 @@
+#       $OpenBSD: testsuite.sh,v 1.1 2002/07/05 15:54:30 itojun Exp $
+#       $NetBSD: testsuite.sh,v 1.3 2002/07/05 15:49:11 itojun Exp $
+
+#
+# Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, and 2002 WIDE Project.
+# All rights reserved.
+#
+# 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 project 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 PROJECT 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 PROJECT 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.
+#
+
+TEST=./gaitest
+#TEST='./test -v'
+#IF=`ifconfig -a | grep -v '^   ' | sed -e 's/:.*//' | head -1 | awk '{print $1}'`
+
+echo '== basic ones'
+$TEST ::1 http
+$TEST 127.0.0.1 http
+$TEST localhost http
+$TEST ::1 tftp
+$TEST 127.0.0.1 tftp
+$TEST localhost tftp
+$TEST ::1 echo
+$TEST 127.0.0.1 echo
+$TEST localhost echo
+echo
+
+echo '== specific address family'
+$TEST -4 localhost http
+$TEST -6 localhost http
+echo
+
+echo '== empty hostname'
+$TEST '' http
+$TEST '' echo
+$TEST '' tftp
+$TEST '' 80
+$TEST -P '' http
+$TEST -P '' echo
+$TEST -P '' tftp
+$TEST -P '' 80
+$TEST -S '' 80
+$TEST -D '' 80
+echo
+
+echo '== empty servname'
+$TEST ::1 ''
+$TEST 127.0.0.1 ''
+$TEST localhost ''
+$TEST '' ''
+echo
+
+echo '== sock_raw'
+$TEST -R -p 0 localhost ''
+$TEST -R -p 59 localhost ''
+$TEST -R -p 59 localhost 80
+$TEST -R -p 59 localhost www
+$TEST -R -p 59 ::1 ''
+echo
+
+echo '== unsupported family'
+$TEST -f 99 localhost ''
+echo
+
+echo '== the following items are specified in jinmei scopeaddr format doc.'
+$TEST fe80::1%lo0 http
+#$TEST fe80::1%$IF http
+echo
diff --git a/src/regress/lib/libc/getcap/Makefile b/src/regress/lib/libc/getcap/Makefile
new file mode 100644
index 0000000000..d09c9846cc
--- /dev/null
+++ b/src/regress/lib/libc/getcap/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2006/03/10 05:28:57 ray Exp $
+
+PROG=           getcaptest
+
+REGRESS_TARGETS=shortcap
+
+shortcap:
+        ./getcaptest ${.CURDIR}/shortcap.in
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getcap/getcaptest.c b/src/regress/lib/libc/getcap/getcaptest.c
new file mode 100644
index 0000000000..0f4464b6c5
--- /dev/null
+++ b/src/regress/lib/libc/getcap/getcaptest.c
@@ -0,0 +1,26 @@
+/*      $OpenBSD: getcaptest.c,v 1.1 2006/03/10 05:28:57 ray Exp $      */
+
+/*
+ * Written by Raymond Lai <ray@cyth.net>.
+ * Public domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main(int argc, char *argv[])
+{
+        char *buf, *db_array[2];
+
+        if (argc != 2)
+                return (1);
+
+        db_array[0] = argv[1];
+        db_array[1] = NULL;
+
+        while (cgetnext(&buf, db_array) > 0)
+                puts(buf);
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/getcap/shortcap.in b/src/regress/lib/libc/getcap/shortcap.in
new file mode 100644
index 0000000000..573541ac97
--- /dev/null
+++ b/src/regress/lib/libc/getcap/shortcap.in
@@ -0,0 +1 @@
+0
diff --git a/src/regress/lib/libc/getopt_long/Makefile b/src/regress/lib/libc/getopt_long/Makefile
new file mode 100644
index 0000000000..13a187e190
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/Makefile
@@ -0,0 +1,32 @@
+#       $OpenBSD: Makefile,v 1.4 2002/12/08 19:25:08 millert Exp $
+
+NOMAN=
+PROG=getopt_long_test
+CLEANFILES+=test.out
+
+# test getopt_long and getopt_long_only
+run-regress-${PROG}: ${PROG}
+        @( test -n "$$POSIXLY_CORRECT" && unset POSIXLY_CORRECT; \
+          test -n "$$LONG_ONLY" && unset LONG_ONLY; \
+          ./${PROG} myfile --force -f infile -9 ; \
+          ./${PROG} onefile twofile --best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast --drinking=guiness -i foo.in somefile ; \
+          export POSIXLY_CORRECT=1 ; \
+          ./${PROG} myfile --force -f infile -9 ; \
+          ./${PROG} onefile twofile --best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast --drinking=guiness -i foo.in somefile ; \
+          unset POSIXLY_CORRECT ; export LONG_ONLY=1 ; \
+          ./${PROG} myfile -force -f infile -9 ; \
+          ./${PROG} onefile twofile -best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast -drinking=guiness -i foo.in somefile ; \
+          export POSIXLY_CORRECT=1 ; \
+          ./${PROG} myfile -force -f infile -9 ; \
+          ./${PROG} onefile twofile -best -Williterate -i foo.in threefile ; \
+          ./${PROG} -1bfast - ; \
+          ./${PROG} --fast -drinking=guiness -i foo.in somefile ) >test.out 2>&1
+        cmp -s ${.OBJDIR}/test.out ${.CURDIR}/test.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/getopt_long/getopt_long_test.c b/src/regress/lib/libc/getopt_long/getopt_long_test.c
new file mode 100644
index 0000000000..9f6f603702
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/getopt_long_test.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+/*
+ * Simple getopt_long() and getopt_long_only() excerciser.
+ * ENVIRONMENT:
+ *      LONG_ONLY       : use getopt_long_only() (default is getopt_long())
+ *      POSIXLY_CORRECT : don't permute args
+ */
+
+int
+main(int argc, char **argv)
+{
+        int ch, idx, goggles;
+        int (*gl)(int, char * const *, const char *, const struct option *, int *);
+        struct option longopts[] = {
+                { "force", no_argument, 0, 0 },
+                { "fast", no_argument, 0, '1' },
+                { "best", no_argument, 0, '9' },
+                { "input", required_argument, 0, 'i' },
+                { "illiterate", no_argument, 0, 0 },
+                { "drinking", required_argument, &goggles, 42 },
+                { "help", no_argument, 0, 'h' },
+                { 0, 0, 0, 0 },
+        };
+
+        if (getenv("LONG_ONLY")) {
+                gl = getopt_long_only;
+                printf("getopt_long_only");
+        } else {
+                gl = getopt_long;
+                printf("getopt_long");
+        }
+        if (getenv("POSIXLY_CORRECT"))
+                printf(" (POSIXLY_CORRECT)");
+        printf(": ");
+        for (idx = 1; idx < argc; idx++)
+                printf("%s ", argv[idx]);
+        printf("\n");
+
+        goggles = 0;
+        for (;;) {
+                idx = -1;
+                ch = gl(argc, argv, "19bf:i:hW;-", longopts, &idx);
+                if (ch == -1)
+                        break;
+                switch (ch) {
+                case 0:
+                case '1':
+                case '9':
+                case 'h':
+                case 'b':
+                case '-':
+                        if (idx != -1) {
+                                if (goggles == 42)
+                                        printf("option %s, arg %s\n",
+                                            longopts[idx].name, optarg);
+                                else
+                                        printf("option %s\n",
+                                            longopts[idx].name);
+                        } else
+                                printf("option %c\n", ch);
+                        break;
+                case 'f':
+                case 'i':
+                        if (idx != -1)
+                                printf("option %s, arg %s\n",
+                                    longopts[idx].name, optarg);
+                        else
+                                printf("option %c, arg %s\n", ch, optarg);
+                        break;
+
+                case '?':
+                        break;
+
+                default:
+                        printf("unexpected return value: %c\n", ch);
+                        break;
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        if (argc > 0) {
+                printf("remaining ARGV: ");
+                while (argc--)
+                        printf("%s ", *argv++);
+                printf("\n");
+        }
+        printf("\n");
+
+        exit (0);
+}
diff --git a/src/regress/lib/libc/getopt_long/test.ok b/src/regress/lib/libc/getopt_long/test.ok
new file mode 100644
index 0000000000..9782087f40
--- /dev/null
+++ b/src/regress/lib/libc/getopt_long/test.ok
@@ -0,0 +1,84 @@
+getopt_long: myfile --force -f infile -9 
+option force
+option f, arg infile
+option 9
+remaining ARGV: myfile 
+
+getopt_long: onefile twofile --best -Williterate -i foo.in threefile 
+option best
+option illiterate
+option i, arg foo.in
+remaining ARGV: onefile twofile threefile 
+
+getopt_long: -1bfast - 
+option 1
+option b
+option f, arg ast
+option -
+
+getopt_long: --fast --drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long (POSIXLY_CORRECT): myfile --force -f infile -9 
+remaining ARGV: myfile --force -f infile -9 
+
+getopt_long (POSIXLY_CORRECT): onefile twofile --best -Williterate -i foo.in threefile 
+remaining ARGV: onefile twofile --best -Williterate -i foo.in threefile 
+
+getopt_long (POSIXLY_CORRECT): -1bfast - 
+option 1
+option b
+option f, arg ast
+option -
+
+getopt_long (POSIXLY_CORRECT): --fast --drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long_only: myfile -force -f infile -9 
+option force
+option f, arg infile
+option 9
+remaining ARGV: myfile 
+
+getopt_long_only: onefile twofile -best -Williterate -i foo.in threefile 
+option best
+option illiterate
+option i, arg foo.in
+remaining ARGV: onefile twofile threefile 
+
+getopt_long_only: -1bfast - 
+option 1
+option b
+option fast
+option -
+
+getopt_long_only: --fast -drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
+getopt_long_only (POSIXLY_CORRECT): myfile -force -f infile -9 
+remaining ARGV: myfile -force -f infile -9 
+
+getopt_long_only (POSIXLY_CORRECT): onefile twofile -best -Williterate -i foo.in threefile 
+remaining ARGV: onefile twofile -best -Williterate -i foo.in threefile 
+
+getopt_long_only (POSIXLY_CORRECT): -1bfast - 
+option 1
+option b
+option fast
+option -
+
+getopt_long_only (POSIXLY_CORRECT): --fast -drinking=guiness -i foo.in somefile 
+option fast
+option drinking, arg guiness
+option i, arg foo.in
+remaining ARGV: somefile 
+
diff --git a/src/regress/lib/libc/hsearch/Makefile b/src/regress/lib/libc/hsearch/Makefile
new file mode 100644
index 0000000000..cddc8ac0c4
--- /dev/null
+++ b/src/regress/lib/libc/hsearch/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/06/24 04:33:07 millert Exp $
+
+PROG=           hsearchtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/hsearch/hsearchtest.c b/src/regress/lib/libc/hsearch/hsearchtest.c
new file mode 100644
index 0000000000..2972b54794
--- /dev/null
+++ b/src/regress/lib/libc/hsearch/hsearchtest.c
@@ -0,0 +1,131 @@
+/*      $OpenBSD: hsearchtest.c,v 1.1 2004/06/24 04:33:07 millert Exp $ */
+/*      $NetBSD: hsearchtest.c,v 1.5 2003/07/26 19:38:46 salo Exp $     */
+
+/*
+ * Copyright (c) 2001 Christopher G. Demetriou
+ * All rights reserved.
+ * 
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *          This product includes software developed for the
+ *          NetBSD Project.  See http://www.NetBSD.org/ for
+ *          information about NetBSD.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ * 
+ * <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
+ */
+
+/*
+ * Test program for hsearch() et al.
+ */
+
+#ifndef lint
+static const char copyright[] =
+"@(#) Copyright (c) 2001 Christopher G. Demetriou.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static const char rcsid[] = "$OpenBSD: hsearchtest.c,v 1.1 2004/06/24 04:33:07 millert Exp $";
+#endif /* not lint */
+
+#include <search.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TEST(e) ((e) ? (void)0 : testfail(__FILE__, __LINE__, #e))
+
+static void
+testfail(const char *file, unsigned long line, const char *expression)
+{
+
+        fprintf(stderr, "TEST FAILED: %s: file %s, line %ld\n",
+            expression, file, line);
+        exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        ENTRY e, *ep, *ep2;
+        int created_ok;
+        char ch[2];
+        int i;
+
+        created_ok = hcreate(16);
+        TEST(created_ok);
+
+        /* ch[1] should be constant from here on down. */
+        ch[1] = '\0';
+        
+        /* Basic insertions.  Check enough that there'll be collisions. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                e.key = strdup(ch);     /* ptr to provided key is kept! */
+                TEST(e.key != NULL);
+                e.data = (void *)(long)i;
+                ep = hsearch(e, ENTER);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* e.key should be constant from here on down. */
+        e.key = ch;
+
+        /* Basic lookups. */
+        for (i = 0; i < 26; i++) {
+                ch[0] = 'a' + i;
+                ep = hsearch(e, FIND);
+                TEST(ep != NULL);
+                TEST(strcmp(ep->key, ch) == 0);
+                TEST((long)ep->data == i);
+        }
+
+        /* Check duplicate entry.  Should _not_ overwrite existing data.  */
+        ch[0] = 'a';
+        e.data = (void *)(long)12345;
+        ep = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, ch) == 0);
+        TEST((long)ep->data == 0);
+
+        /* Check for something that's not there. */
+        ch[0] = 'A';
+        ep = hsearch(e, FIND);
+        TEST(ep == NULL);
+
+        /* Check two at once. */
+        ch[0] = 'a';
+        ep = hsearch(e, FIND);
+        ch[0] = 'b';
+        ep2 = hsearch(e, FIND);
+        TEST(ep != NULL);
+        TEST(strcmp(ep->key, "a") == 0 && (long)ep->data == 0);
+        TEST(ep2 != NULL);
+        TEST(strcmp(ep2->key, "b") == 0 && (long)ep2->data == 1);
+
+        hdestroy();
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/ieeefp/Makefile b/src/regress/lib/libc/ieeefp/Makefile
new file mode 100644
index 0000000000..89ff51a2e7
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/Makefile
@@ -0,0 +1,8 @@
+#       $OpenBSD: Makefile,v 1.6 2004/01/15 18:53:23 miod Exp $
+#       $NetBSD: Makefile,v 1.5 1996/04/09 16:54:18 phil Exp $
+
+SUBDIR+= except inf infinity round
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/ieeefp/except/Makefile b/src/regress/lib/libc/ieeefp/except/Makefile
new file mode 100644
index 0000000000..205331548f
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/except/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.5 2004/07/22 19:29:42 kettenis Exp $
+
+PROG=except
+
+REGRESS_TARGETS+= fltdiv fltinv fltovf fltund
+
+fltdiv: ${PROG}
+        ./${PROG} fltdiv
+
+fltinv: ${PROG}
+        ./${PROG} fltinv
+
+fltovf: ${PROG}
+        ./${PROG} fltovf
+
+fltund: ${PROG}
+        ./${PROG} fltund
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/except/except.c b/src/regress/lib/libc/ieeefp/except/except.c
new file mode 100644
index 0000000000..1d11877777
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/except/except.c
@@ -0,0 +1,107 @@
+/*      $OpenBSD: except.c,v 1.10 2006/05/15 14:00:22 kettenis Exp $    */
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <assert.h>
+#include <ieeefp.h>
+#include <float.h>
+#include <err.h>
+
+volatile sig_atomic_t signal_status;
+
+volatile const double one  = 1.0;
+volatile const double zero = 0.0;
+volatile const double huge = DBL_MAX;
+volatile const double tiny = DBL_MIN;
+
+void
+sigfpe(int sig, siginfo_t *si, void *v)
+{
+        char buf[132];
+
+        if (si) {
+                snprintf(buf, sizeof(buf), "sigfpe: addr=%p, code=%d\n",
+                    si->si_addr, si->si_code);
+                write(1, buf, strlen(buf));
+        }
+        _exit(signal_status);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction sa;
+        volatile double x;
+
+        if (argc != 2) {
+                fprintf(stderr, "usage: %s condition\n", argv[0]);
+                exit(1);
+        }
+
+        /*
+         * check to make sure that all exceptions are masked and 
+         * that the accumulated exception status is clear.
+         */
+        assert(fpgetmask() == 0);
+        assert(fpgetsticky() == 0);
+
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = sigfpe;
+        sa.sa_flags = SA_SIGINFO;
+        sigaction(SIGFPE, &sa, NULL);
+        signal_status = 1;
+
+        /* trip divide by zero */
+        x = one / zero;
+        assert(fpgetsticky() & FP_X_DZ);
+        fpsetsticky(0);
+
+        /* trip invalid operation */
+        x = zero / zero;
+        assert(fpgetsticky() & FP_X_INV);
+        fpsetsticky(0);
+
+        /* trip overflow */
+        x = huge * huge;
+        assert(fpgetsticky() & FP_X_OFL);
+        fpsetsticky(0);
+
+        /* trip underflow */
+        x = tiny * tiny;
+        assert(fpgetsticky() & FP_X_UFL);
+        fpsetsticky(0);
+
+        signal_status = 0;
+
+        if (strcmp(argv[1], "fltdiv") == 0) {
+                /* unmask and then trip divide by zero */
+                fpsetmask(FP_X_DZ);
+                x = one / zero;
+        } else if (strcmp(argv[1], "fltinv") == 0) {
+                /* unmask and then trip invalid operation */
+                fpsetmask(FP_X_INV);
+                x = zero / zero;
+        } else if (strcmp(argv[1], "fltovf") == 0) {
+                /* unmask and then trip overflow */
+                fpsetmask(FP_X_OFL);
+                x = huge * huge;
+        } else if (strcmp(argv[1], "fltund") == 0) {
+                /* unmask and then trip underflow */
+                fpsetmask(FP_X_UFL);
+                x = tiny * tiny;
+        } else {
+                errx(1, "unrecognized condition %s", argv[1]);
+        }
+
+        /*
+         * attempt to trigger the exception on machines where
+         * floating-point exceptions are deferred.
+         */
+        x = one * one;
+
+        errx(1, "signal wasn't caught");
+}
diff --git a/src/regress/lib/libc/ieeefp/inf/Makefile b/src/regress/lib/libc/ieeefp/inf/Makefile
new file mode 100644
index 0000000000..b9a50e0ce6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 17:22:16 pvalchev Exp $
+
+PROG=   inf
+SRCS=   inf.c
+
+LDADD+= -lm
+DPADD+= ${LIBM}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/inf/inf.c b/src/regress/lib/libc/ieeefp/inf/inf.c
new file mode 100644
index 0000000000..a1956145a6
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/inf/inf.c
@@ -0,0 +1,16 @@
+/*      $OpenBSD: inf.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $ */
+
+/*
+ * Peter Valchev <pvalchev@openbsd.org> Public Domain, 2002.
+ */
+
+#include <math.h>
+
+int
+main(int argc, char *argv[])
+{
+        if (isinf(HUGE_VAL))
+                return 0;
+
+        return 1;
+}
diff --git a/src/regress/lib/libc/ieeefp/infinity/Makefile b/src/regress/lib/libc/ieeefp/infinity/Makefile
new file mode 100644
index 0000000000..ac102d8a63
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/Makefile
@@ -0,0 +1,22 @@
+#       $OpenBSD: Makefile,v 1.2 2004/01/16 19:34:37 miod Exp $
+
+PROG=   infinity
+
+DPADD+= ${LIBM}
+LDADD+= -lm
+
+REGRESS_TARGETS+= add mult neg pumpkin
+
+add: ${PROG}
+        ./${PROG} -a
+
+mult: ${PROG}
+        ./${PROG} -m
+
+neg: ${PROG}
+        ./${PROG} -n
+
+pumpkin: ${PROG}
+        ./${PROG} -p
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/infinity/infinity.c b/src/regress/lib/libc/ieeefp/infinity/infinity.c
new file mode 100644
index 0000000000..3b1b71ec90
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/infinity/infinity.c
@@ -0,0 +1,77 @@
+/*      $OpenBSD: infinity.c,v 1.2 2004/01/16 19:34:37 miod Exp $       */
+/*
+ * Written by Miodrag Vallat, 2004 - Public Domain
+ * Inspired from Perl's t/op/arith test #134
+ */
+
+#include <math.h>
+#include <signal.h>
+#include <unistd.h>
+
+void
+sigfpe(int signum)
+{
+        /* looks like we don't handle fp overflow correctly... */
+        _exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+        int opt;
+        double d, two;
+        int i;
+        char method = 'a';
+
+        while ((opt = getopt(argc, argv, "amnp")) != -1)
+                method = (char)opt;
+
+        signal(SIGFPE, sigfpe);
+
+        switch (method) {
+        case 'a':
+                /* try to produce +Inf through addition */
+                d = 1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'm':
+                /* try to produce +Inf through multiplication */
+                d = 1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _positive_ infinity */
+                if (!isinf(d) || copysign(1.0, d) < 0.0)
+                        return (1);
+                break;
+        case 'n':
+                /* try to produce -Inf through subtraction */
+                d = -1.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d + d;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        case 'p':
+                /* try to produce -Inf through multiplication */
+                d = -1.0;
+                two = 2.0;
+                for (i = 2000; i != 0; i--) {
+                        d = d * two;
+                }
+                /* result should be _negative_ infinity */
+                if (!isinf(d) || copysign(1.0, d) > 0.0)
+                        return (1);
+                break;
+        }
+
+        return (0);
+}
diff --git a/src/regress/lib/libc/ieeefp/round/Makefile b/src/regress/lib/libc/ieeefp/round/Makefile
new file mode 100644
index 0000000000..9ea6dd8c39
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/round/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.4 2002/02/18 11:25:34 art Exp $
+
+PROG=   round
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/ieeefp/round/round.c b/src/regress/lib/libc/ieeefp/round/round.c
new file mode 100644
index 0000000000..807941ea56
--- /dev/null
+++ b/src/regress/lib/libc/ieeefp/round/round.c
@@ -0,0 +1,45 @@
+/*      $OpenBSD: round.c,v 1.3 2003/07/31 21:48:03 deraadt Exp $       */
+/*      $NetBSD: round.c,v 1.1 1995/04/26 00:27:28 jtc Exp $    */
+
+/*
+ * Written by J.T. Conklin, Apr 18, 1995
+ * Public domain.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <ieeefp.h>
+#include <float.h>
+
+int
+main(int argc, char *argv[])
+{
+        /*
+         * This test would be better if it actually performed some
+         * calculations to verify the selected rounding mode.  But
+         * this is probably acceptable since the fp{get,set}round
+         * functions usually just get or set the processors fpu
+         * control word.
+         */
+
+        assert(fpgetround() == FP_RN);
+        assert(FLT_ROUNDS == 1);
+
+        assert(fpsetround(FP_RP) == FP_RN);
+        assert(fpgetround() == FP_RP);
+        assert(FLT_ROUNDS == 2);
+
+        assert(fpsetround(FP_RM) == FP_RP);
+        assert(fpgetround() == FP_RM);
+        assert(FLT_ROUNDS == 3);
+
+        assert(fpsetround(FP_RZ) == FP_RM);
+        assert(fpgetround() == FP_RZ);
+        assert(FLT_ROUNDS == 0);
+
+        assert(fpsetround(FP_RN) == FP_RZ);
+        assert(fpgetround() == FP_RN);
+        assert(FLT_ROUNDS == 1);
+
+        exit(0);
+}
diff --git a/src/regress/lib/libc/locale/Makefile b/src/regress/lib/libc/locale/Makefile
new file mode 100644
index 0000000000..c182172ba2
--- /dev/null
+++ b/src/regress/lib/libc/locale/Makefile
@@ -0,0 +1,7 @@
+# $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+SUBDIR+= check_isw
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/Makefile b/src/regress/lib/libc/locale/check_isw/Makefile
new file mode 100644
index 0000000000..0885968fd1
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.1 2005/08/11 21:57:02 espie Exp $
+
+NOMAN=
+PROG=check_isw
+
+run-regress-check_isw: ${PROG}
+        ./${PROG} >/dev/null
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/locale/check_isw/check_isw.c b/src/regress/lib/libc/locale/check_isw/check_isw.c
new file mode 100644
index 0000000000..9386267f61
--- /dev/null
+++ b/src/regress/lib/libc/locale/check_isw/check_isw.c
@@ -0,0 +1,147 @@
+/* $OpenBSD: check_isw.c,v 1.1 2005/08/11 21:57:02 espie Exp $ */
+/*
+ * Copyright (c) 2005 Marc Espie <espie@openbsd.org>
+ *
+ * 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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.
+ */
+
+/* This checks consistency of the isw* functions with the default <ctype>
+ * functions.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <wchar.h>
+#include <wctype.h>
+
+int bad = 0;
+
+void
+check_bool(int v1, int v2, char msg)
+{
+        if (!v1 != !v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void 
+check_value(int v1, int v2, char msg)
+{
+        if (v1 != v2) {
+                printf("%c", msg);
+                bad++;
+        }
+}
+
+void
+test1()
+{
+        int i;
+
+        for (i = 0; i < 256; i++) {
+                printf(" %02x: ", i);
+                check_bool(isalnum(i), iswalnum(i), '1');
+                check_bool(isalpha(i), iswalpha(i), '2');
+                check_bool(isblank(i), iswblank(i), '3');
+                check_bool(iscntrl(i), iswcntrl(i), '4');
+                check_bool(isdigit(i), iswdigit(i), '5');
+                check_bool(isgraph(i), iswgraph(i), '6');
+                check_bool(islower(i), iswlower(i), '6');
+                check_bool(isprint(i), iswprint(i), '7');
+                check_bool(ispunct(i), iswpunct(i), '8');
+                check_bool(isspace(i), iswspace(i), '9');
+                check_bool(isupper(i), iswupper(i), 'a');
+                check_bool(isxdigit(i), iswxdigit(i), 'b');
+                check_value(tolower(i), towlower(i), 'c');
+                check_value(toupper(i), towupper(i), 'd');
+                if (i % 8 == 7)
+                        printf("\n");
+        }
+        printf("%\n");
+}
+
+void
+test2()
+{
+        unsigned char *s;
+        unsigned char *buf;
+        int i, j;
+        size_t n;
+        wchar_t c, d;
+        mbstate_t state;
+
+        s = malloc(256);
+        if (!s) {
+                bad++;
+                return;
+        }
+        buf = malloc(MB_CUR_MAX);
+        if (!buf) {
+                bad++;
+                free(s);
+                return;
+        }
+        for (i = 0; i < 256; i++)
+                s[i] = i+1;
+
+        j = 0;
+        mbrtowc(NULL, NULL, 1, &state);
+        printf(" %02x: ", 0);
+
+        while ((n = mbrtowc(&c, s+j, 256-j, &state)) == 1) {
+                printf(" %02x: ", s[j]);
+                check_bool(isalnum(s[j]), iswalnum(c), '1');
+                check_bool(isalpha(s[j]), iswalpha(c), '2');
+                check_bool(isblank(s[j]), iswblank(c), '3');
+                check_bool(iscntrl(s[j]), iswcntrl(c), '4');
+                check_bool(isdigit(s[j]), iswdigit(c), '5');
+                check_bool(isgraph(s[j]), iswgraph(c), '6');
+                check_bool(islower(s[j]), iswlower(c), '6');
+                check_bool(isprint(s[j]), iswprint(c), '7');
+                check_bool(ispunct(s[j]), iswpunct(c), '8');
+                check_bool(isspace(s[j]), iswspace(c), '9');
+                check_bool(isupper(s[j]), iswupper(c), 'a');
+                check_bool(isxdigit(s[j]), iswxdigit(c), 'b');
+                d = towlower(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(tolower(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                d = towupper(c);
+                if (wctomb(buf, d) == 1) {      
+                        check_value(toupper(s[j]), buf[0], 'c');
+                } else {
+                        bad++;
+                }
+                if (s[j] % 8 == 7)
+                        printf("\n");
+                j++;
+        }
+        if (n != 0 || j != 255) {
+                bad++;
+        }
+        free(s);
+        free(buf);
+}
+
+
+int
+main()
+{
+        test1();
+        test2();
+        return bad !=0;
+}
diff --git a/src/regress/lib/libc/longjmp/Makefile b/src/regress/lib/libc/longjmp/Makefile
new file mode 100644
index 0000000000..825e0f86d9
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/Makefile
@@ -0,0 +1,13 @@
+#       $OpenBSD: Makefile,v 1.4 2002/09/02 20:01:43 avsm Exp $
+PROG=   longjmp
+
+do-longjmp: ${PROG}
+        ./longjmp
+
+do-_longjmp: ${PROG}
+        ./longjmp -_
+
+REGRESS_TARGETS=do-longjmp do-_longjmp
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/longjmp/longjmp.c b/src/regress/lib/libc/longjmp/longjmp.c
new file mode 100644
index 0000000000..7dea5bd97c
--- /dev/null
+++ b/src/regress/lib/libc/longjmp/longjmp.c
@@ -0,0 +1,71 @@
+/*      $OpenBSD: longjmp.c,v 1.4 2002/02/18 11:27:45 art Exp $ */
+/*
+ *      Artur Grabowski <art@openbsd.org>, 2002 Public Domain.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <setjmp.h>
+#include <err.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+
+jmp_buf buf;
+
+/*
+ * When longjmp is passed the incorrect arg (0), it should translate it into
+ * something better.
+ *
+ * The rlimit is here in case we start spinning.
+ */
+int
+main(int argc, char **argv)
+{
+        struct rlimit rl;
+        volatile int i, expect;
+        int (*sj)(jmp_buf);
+        void (*lj)(jmp_buf, int);
+        int ch;
+        extern char *__progname;
+
+        sj = setjmp;
+        lj = longjmp;
+
+        while ((ch = getopt(argc, argv, "_")) != -1) {
+                switch (ch) {
+                case '_':
+                        sj = _setjmp;
+                        lj = _longjmp;
+                        break;
+                default:
+                        fprintf(stderr, "Usage: %s [-_]\n", __progname);
+                        exit(1);
+                }
+        }
+
+        rl.rlim_cur = 2;
+        rl.rlim_max = 2;
+        if (setrlimit(RLIMIT_CPU, &rl) < 0)
+                err(1, "setrlimit");
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i == 0 && expect != 0)
+                errx(1, "setjmp returns 0 on longjmp(.., 0)");
+        if (expect == 0) {
+                expect = -1;
+                (*lj)(buf, 0);
+        }
+
+        expect = 0;
+        i = (*sj)(buf);
+        if (i != expect)
+                errx(1, "bad return from setjmp %d/%d", expect, i);
+        if (expect < 1000)
+                (*lj)(buf, expect += 2);
+
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/Makefile b/src/regress/lib/libc/malloc/Makefile
new file mode 100644
index 0000000000..7c919d1bc2
--- /dev/null
+++ b/src/regress/lib/libc/malloc/Makefile
@@ -0,0 +1,7 @@
+#       $OpenBSD: Makefile,v 1.5 2006/04/18 19:04:39 otto Exp $
+
+SUBDIR+= malloc0test malloc_errno malloc_ulimit1 malloc_ulimit2
+
+install:
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/Makefile b/src/regress/lib/libc/malloc/malloc0test/Makefile
new file mode 100644
index 0000000000..8ed8163a79
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:09:37 otto Exp $
+
+PROG=   malloc0test
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc0test/malloc0test.c b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
new file mode 100644
index 0000000000..eb00954f92
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc0test/malloc0test.c
@@ -0,0 +1,120 @@
+/*      $OpenBSD: malloc0test.c,v 1.4 2004/08/04 12:02:57 otto Exp $    */
+/*
+ * Public domain.  2001, Theo de Raadt
+ */
+#include <sys/types.h>
+#include <sys/signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <limits.h>
+#include <errno.h>
+
+volatile sig_atomic_t got;
+jmp_buf jmp;
+
+static void
+catch(int signo)
+{
+        got++;
+        longjmp(jmp, 1);
+}
+
+static int
+test(char *p, int size)
+{
+        signal(SIGSEGV, catch);
+        got = 0;
+        if (setjmp(jmp) == 0)
+                *p = 0;
+        if (setjmp(jmp) == 0)
+                *(p+size-1) = 0;
+        return (got);
+}
+
+char *prot_table[] = {
+        "unprotected",
+        "fuckup",
+        "protected"
+};
+
+#define SIZE    10
+
+/*
+ * Do random memory allocations.
+ *
+ * For each one, ensure that it is at least 16 bytes in size (that
+ * being what our current malloc returns for the minsize of an
+ * object, alignment wise);
+ *
+ * For zero-byte allocations, check that they are still aligned.
+ *
+ * For each object, ensure that they are correctly protected or not
+ * protected.
+ *
+ * Does not regress test malloc + free combinations ... it should.
+ */
+int
+main(int argc, char *argv[])
+{
+        caddr_t blob;
+        int size, tsize;
+        int prot;
+        int rval = 0, fuckup = 0;
+        long limit = 200000, count;
+        int ch, silent = 0;
+        char *ep;
+        extern char *__progname;
+
+        while ((ch = getopt(argc, argv, "sn:")) != -1) {
+                switch (ch) {
+                case 's':
+                        silent = 1;
+                        break;
+                case 'n':
+                        errno = 0;
+                        limit = strtol(optarg, &ep, 10);
+                        if (optarg[0] == '\0' || *ep != '\0' ||
+                            (errno == ERANGE &&
+                             (limit == LONG_MAX || limit == LONG_MIN)))
+                                goto usage;
+                        break;
+                default:
+usage:
+                        fprintf(stderr, "Usage: %s [-s][-n <count>]\n",
+                            __progname);
+                        exit(1);
+                }
+        }
+
+        if (limit == 0)
+                limit = LONG_MAX;
+
+        for (count = 0; count < limit; count++) {
+                size = arc4random() % SIZE;
+                blob = malloc(size);
+                if (blob == NULL) {
+                        fprintf(stderr, "success: out of memory\n");
+                        exit(rval);
+                }
+
+                tsize = size == 0 ? 16 : size;
+                fuckup = 0;
+                prot = test(blob, tsize);
+
+                if (size == 0 && prot < 2)
+                        fuckup = 1;
+
+                if (fuckup) {
+                        printf("%8p %6d %20s %10s\n", blob, size,
+                            prot_table[prot], fuckup ? "fuckup" : "");
+                        rval = 1;
+                }
+
+                if (!silent && count % 100000 == 0 && count != 0)
+                        fprintf(stderr, "count = %ld\n", count);
+        }
+
+        return rval;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_errno/Makefile b/src/regress/lib/libc/malloc/malloc_errno/Makefile
new file mode 100644
index 0000000000..73ebe37491
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2003/07/15 10:06:31 otto Exp $
+
+PROG=   malloc_errno
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
new file mode 100644
index 0000000000..896ea3c900
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_errno/malloc_errno.c
@@ -0,0 +1,46 @@
+/*      $OpenBSD: malloc_errno.c,v 1.4 2003/12/25 18:49:57 miod Exp $   */
+/*
+ * Public domain.  2003, Otto Moerbeek
+ */
+#include <err.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void
+testerrno(size_t sz)
+{
+        void *p;
+
+        errno = -1;
+        p = malloc(sz);
+
+        if (p == NULL && errno != ENOMEM)
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        /* if alloc succeeded, test if errno did not change */
+        if (p != NULL && errno != -1) 
+                errx(1, "fail: %lx %p %d", (unsigned long)sz, p, errno);
+
+        free(p);
+}
+
+/*
+ * Provide some (silly) arguments to malloc(), and check if ERRNO is set
+ * correctly.
+ */
+int
+main(int argc, char *argv[])
+{
+        size_t i;
+
+        testerrno(1);
+        testerrno(100000);
+        testerrno(-1);
+        testerrno(-1000);
+        testerrno(-10000);
+        testerrno(-10000000);
+        for (i = 0; i < 0x10; i++)
+                testerrno(i * 0x10000000);
+        return 0;
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
new file mode 100644
index 0000000000..46ced27a98
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:03:30 otto Exp $
+
+PROG=   malloc_ulimit1
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
new file mode 100644
index 0000000000..99e805e8e1
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit1/malloc_ulimit1.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: malloc_ulimit1.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/*
+ * This code tries to trigger the case present in -current as of April
+ * 2006) where the allocation of the region itself succeeds, but the
+ * page dir entry pages fails.
+ * This in turn trips a "hole in directories" error.
+ * Having a large (512M) ulimit -m helps a lot in triggering the 
+ * problem. Note that you may need to run this test multiple times to
+ * see the error.
+*/
+
+#define STARTI  1300
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = STARTI; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
new file mode 100644
index 0000000000..bc83666415
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/04/18 19:04:03 otto Exp $
+
+PROG=   malloc_ulimit2
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
new file mode 100644
index 0000000000..ca8e8f438a
--- /dev/null
+++ b/src/regress/lib/libc/malloc/malloc_ulimit2/malloc_ulimit2.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: malloc_ulimit2.c,v 1.2 2006/05/16 05:47:13 otto Exp $ */
+
+/* Public Domain, 2006, Otto Moerbeek <otto@drijf.net> */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define FACTOR  1024
+
+main()
+{
+        struct rlimit lim;
+        size_t sz;
+        int i;
+        void *p;
+
+        if (getrlimit(RLIMIT_DATA, &lim) == -1)
+                err(1, "getrlimit");
+
+        sz = lim.rlim_cur / FACTOR;
+
+        for (i = 0; ; i++) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                if (p != NULL) {
+                        free(p);
+                        break;
+                }
+        }
+        i += 10;
+        for (; i >= 0; i--) {
+                size_t len = (sz-i) * FACTOR;
+                p = malloc(len);
+                free(p);
+                free(malloc(4096));
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/netdb/Makefile b/src/regress/lib/libc/netdb/Makefile
new file mode 100644
index 0000000000..8254607227
--- /dev/null
+++ b/src/regress/lib/libc/netdb/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/10/25 15:10:36 otto Exp $
+
+PROG=   netdb
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/netdb/netdb.c b/src/regress/lib/libc/netdb/netdb.c
new file mode 100644
index 0000000000..0082c1bd1b
--- /dev/null
+++ b/src/regress/lib/libc/netdb/netdb.c
@@ -0,0 +1,182 @@
+/*      $OpenBSD: netdb.c,v 1.1 2004/10/25 15:10:36 otto Exp $  */
+
+/*
+ * Public domain, 2004, Otto Moerbeek <otto@drijf.net>
+ */
+
+#include <err.h>
+#include <netdb.h>
+#include <stdarg.h>
+
+int ret = 0;
+
+void
+checkp(int n, struct protoent *p, int proto, const char *name, ...)
+{
+        va_list va;
+        char *a;
+        int i;
+
+        if (p == NULL) {
+                warnx("%d proto struct is NULL", n);
+                ret = 1;
+                return;
+        }
+        if (p->p_proto != proto) {
+                warnx("%d proto num mismatch %d %d", n, p->p_proto, proto);
+                ret = 1;
+        }
+        if (strcmp(p->p_name, name) != 0) {
+                warnx("%d proto name mismatch %s %s", n, p->p_name, name);
+                ret = 1;
+        }
+        va_start(va, name);
+        a = va_arg(va, char *);
+        i = 0;
+        while (a != NULL) {
+                if (strcmp(p->p_aliases[i], a) != 0) {
+                        warnx("%d proto alias mismatch %s %s", n,
+                            p->p_aliases[i], a);
+                        ret = 1;
+                }
+                i++;
+                a = va_arg(va, char *);
+        }
+        if (p->p_aliases[i] != NULL) {
+                        warnx("%d proto alias list does not end with NULL", n);
+                        ret = 1;
+        }
+        va_end(va);
+}
+
+
+void
+checks(int n, struct servent *s, int port, const char *proto,
+    const char *name, ...)
+{
+        va_list va;
+        char *a;
+        int i;
+
+        if (s == NULL) {
+                warnx("%d serv struct is NULL", n);
+                ret = 1;
+                return;
+        }
+        if (s->s_port != ntohs(port)) {
+                warnx("%d port num mismatch %d %d", n, s->s_port, port);        
+                ret = 1;
+        }
+        if (strcmp(s->s_name, name) != 0) {
+                warnx("%d serv name mismatch %s %s", n, s->s_name, name);
+                ret = 1;
+        }
+        if (strcmp(s->s_proto, proto) != 0) {
+                warnx("%d serv proto mismatch %s %s", n, s->s_proto, proto);
+                ret = 1;
+        }
+        va_start(va, name);
+        a = va_arg(va, char *);
+        i = 0;
+        while (a != NULL) {
+                if (strcmp(s->s_aliases[i], a) != 0) {
+                        warnx("%d serv alias mismatch %s %s", n,
+                            s->s_aliases[i], a);
+                        ret = 1;
+                }
+                i++;
+                a = va_arg(va, char *);
+        }
+        if (s->s_aliases[i] != NULL) {
+                        warnx("%d serv alias list does not end with NULL", n);
+                        ret = 1;
+        }
+        va_end(va);
+}
+
+int
+main()
+{
+        struct protoent *p;
+        struct protoent protoent;
+        struct protoent_data protoent_data;
+        struct servent *s;
+        struct servent servent;
+        struct servent_data servent_data;
+        int r;
+
+        p = getprotobynumber(35);
+        checkp(1, p, 35, "idpr", "IDPR", (char *)NULL);
+
+        p = getprotobyname("igp");
+        checkp(2, p, 9, "igp", "IGP", (char *) NULL);
+
+        p = getprotobyname("RDP");
+        checkp(3, p, 27, "rdp", "RDP", (char *) NULL);
+
+        p = getprotobyname("vrrp");
+        checkp(4, p, 112, "carp", "CARP", "vrrp", (char *) NULL);
+
+        p = getprotobyname("nonexistent");
+        if (p != NULL)
+                err(1, "nonexistent proto found");
+
+        memset(&protoent_data, 0, sizeof(protoent_data));
+        r = getprotobynumber_r(35, &protoent, &protoent_data);
+        if (r != 0) 
+                err(1, "proto not found");
+
+        checkp(5, &protoent, 35, "idpr", "IDPR", (char *)NULL);
+
+        r = getprotobyname_r("vrrp", &protoent, &protoent_data);
+        if (r != 0) 
+                err(1, "proto not found");
+        checkp(6, &protoent, 112, "carp", "CARP", "vrrp", (char *) NULL);
+
+        r = getprotobyname_r("nonexistent", &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+        r = getprotobyname_r("", &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+
+        r = getprotobynumber_r(256, &protoent, &protoent_data);
+        if (r != -1)
+                err(1, "nonexistent proto found");
+
+        s = getservbyname("zip", NULL);
+        checks(7, s, 6, "ddp", "zip", (char *)NULL);
+
+        s = getservbyname("nicname", "tcp");
+        checks(8, s, 43, "tcp", "whois", "nicname", (char *)NULL);
+
+        s = getservbyport(htons(42), "tcp");
+        checks(9, s, 42, "tcp", "nameserver", "name", (char *)NULL);
+
+        memset(&servent_data, 0, sizeof(servent_data));
+        r = getservbyname_r("zip", "ddp", &servent, &servent_data);
+        if (r != 0) 
+                err(1, "servent not found");
+        checks(10, &servent, 6, "ddp", "zip", (char *)NULL);
+
+        r = getservbyport_r(htons(520), NULL, &servent, &servent_data);
+        if (r != 0) 
+                err(1, "servent not found");
+        checks(11, &servent, 520, "udp", "route", "router", "routed", (char *)NULL);
+
+        r = getservbyname_r("nonexistent", NULL, &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexiststent servent found");
+
+        r = getservbyport_r(htons(50000), NULL, &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexistent servent found");
+
+        r = getservbyport_r(htons(520), "tcp", &servent, &servent_data);
+        if (r != -1) 
+                err(1, "nonexistent servent found");
+
+        return ret;
+}
diff --git a/src/regress/lib/libc/popen/Makefile b/src/regress/lib/libc/popen/Makefile
new file mode 100644
index 0000000000..25b8668a7a
--- /dev/null
+++ b/src/regress/lib/libc/popen/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/02/16 01:55:09 art Exp $
+
+PROG=popen
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/popen/popen.c b/src/regress/lib/libc/popen/popen.c
new file mode 100644
index 0000000000..95ea67f31b
--- /dev/null
+++ b/src/regress/lib/libc/popen/popen.c
@@ -0,0 +1,105 @@
+/*      $NetBSD: popen.c,v 1.1 1999/09/30 09:23:23 tron Exp $   */
+
+/*-
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Matthias Scheler.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the NetBSD
+ *      Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <sys/param.h>
+
+#include <err.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#define _PATH_CAT       "/bin/cat"
+#define BUFSIZE         (640*1024)
+                        /* 640KB ought to be enough for everyone. */
+#define DATAFILE        "popen.data"
+
+int
+main(int argc, char **argv)
+{
+        char *buffer, command[MAXPATHLEN];
+        int index, in;
+        FILE *pipe;
+
+        if ((buffer = malloc(BUFSIZE*sizeof(char))) == NULL)
+            err(1, NULL);
+
+        for (index=0; index<BUFSIZE; index++)
+            buffer[index]=arc4random();
+
+        (void)snprintf(command, sizeof(command), "%s >%s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "w")) == NULL)
+            err(1, "popen write");
+
+        if (fwrite(buffer, sizeof(char), BUFSIZE, pipe) != BUFSIZE)
+            err(1, "write");
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)snprintf(command, sizeof(command), "%s %s",
+                       _PATH_CAT, DATAFILE);
+        if ((pipe = popen(command, "r")) == NULL)
+            err(1, "popen read");
+
+        index = 0;
+        while ((in = fgetc(pipe)) != EOF)
+            if (index == BUFSIZE) {
+                errno = EFBIG;
+                err(1, "read");
+            }
+            else
+                if ((char)in != buffer[index++]) {
+                    errno = EINVAL;
+                    err(1, "read");
+                }
+
+        if (index < BUFSIZE) {
+            errno = EIO;
+            err(1, "read");
+        }
+
+        if (pclose(pipe) == -1)
+            err(1, "pclose");
+
+        (void)unlink(DATAFILE);
+        return 0;
+}
diff --git a/src/regress/lib/libc/regex/Makefile b/src/regress/lib/libc/regex/Makefile
new file mode 100644
index 0000000000..271debb5d3
--- /dev/null
+++ b/src/regress/lib/libc/regex/Makefile
@@ -0,0 +1,21 @@
+#       $OpenBSD: Makefile,v 1.6 2004/08/13 14:54:12 millert Exp $
+#       $NetBSD: Makefile,v 1.2 1995/02/16 19:38:45 cgd Exp $
+
+PROG=   re
+SRCS=   main.c split.c debug.c regcomp.c regerror.c regexec.c regfree.c
+.PATH: ${.CURDIR}/../../../../lib/libc/regex
+
+CFLAGS+= -I${.CURDIR}/../../../../lib/libc/regex -DREDEBUG -DPOSIX_MISTAKE
+
+TESTS=  ${.CURDIR}/tests
+
+REGRESS_TARGETS=do-reg do-reg-long do-reg-backref
+
+do-reg: ${PROG}
+        ./re < ${TESTS}
+do-reg-long: ${PROG}
+        ./re -el < ${TESTS}
+do-reg-backref: ${PROG}
+        ./re -er < ${TESTS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/regex/debug.c b/src/regress/lib/libc/regex/debug.c
new file mode 100644
index 0000000000..11129e7249
--- /dev/null
+++ b/src/regress/lib/libc/regex/debug.c
@@ -0,0 +1,245 @@
+/*      $OpenBSD: debug.c,v 1.4 2003/07/31 21:48:03 deraadt Exp $       */
+/*      $NetBSD: debug.c,v 1.2 1995/04/20 22:39:42 cgd Exp $    */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+#include "debug.ih"
+
+/*
+ - regprint - print a regexp for debugging
+ == void regprint(regex_t *r, FILE *d);
+ */
+void
+regprint(r, d)
+regex_t *r;
+FILE *d;
+{
+        register struct re_guts *g = r->re_g;
+        register int i;
+        register int c;
+        register int last;
+        int nincat[NC];
+
+        fprintf(d, "%ld states, %d categories", (long)g->nstates,
+                                                        g->ncategories);
+        fprintf(d, ", first %ld last %ld", (long)g->firststate,
+                                                (long)g->laststate);
+        if (g->iflags&USEBOL)
+                fprintf(d, ", USEBOL");
+        if (g->iflags&USEEOL)
+                fprintf(d, ", USEEOL");
+        if (g->iflags&BAD)
+                fprintf(d, ", BAD");
+        if (g->nsub > 0)
+                fprintf(d, ", nsub=%ld", (long)g->nsub);
+        if (g->must != NULL)
+                fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
+                                                                g->must);
+        if (g->backrefs)
+                fprintf(d, ", backrefs");
+        if (g->nplus > 0)
+                fprintf(d, ", nplus %ld", (long)g->nplus);
+        fprintf(d, "\n");
+        s_print(g, d);
+        for (i = 0; i < g->ncategories; i++) {
+                nincat[i] = 0;
+                for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+                        if (g->categories[c] == i)
+                                nincat[i]++;
+        }
+        fprintf(d, "cc0#%d", nincat[0]);
+        for (i = 1; i < g->ncategories; i++)
+                if (nincat[i] == 1) {
+                        for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+                                if (g->categories[c] == i)
+                                        break;
+                        fprintf(d, ", %d=%s", i, regchar(c));
+                }
+        fprintf(d, "\n");
+        for (i = 1; i < g->ncategories; i++)
+                if (nincat[i] != 1) {
+                        fprintf(d, "cc%d\t", i);
+                        last = -1;
+                        for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)        /* +1 does flush */
+                                if (c <= CHAR_MAX && g->categories[c] == i) {
+                                        if (last < 0) {
+                                                fprintf(d, "%s", regchar(c));
+                                                last = c;
+                                        }
+                                } else {
+                                        if (last >= 0) {
+                                                if (last != c-1)
+                                                        fprintf(d, "-%s",
+                                                                regchar(c-1));
+                                                last = -1;
+                                        }
+                                }
+                        fprintf(d, "\n");
+                }
+}
+
+/*
+ - s_print - print the strip for debugging
+ == static void s_print(register struct re_guts *g, FILE *d);
+ */
+static void
+s_print(g, d)
+register struct re_guts *g;
+FILE *d;
+{
+        register sop *s;
+        register cset *cs;
+        register int i;
+        register int done = 0;
+        register sop opnd;
+        register int col = 0;
+        register int last;
+        register sopno offset = 2;
+#       define  GAP()   {       if (offset % 5 == 0) { \
+                                        if (col > 40) { \
+                                                fprintf(d, "\n\t"); \
+                                                col = 0; \
+                                        } else { \
+                                                fprintf(d, " "); \
+                                                col++; \
+                                        } \
+                                } else \
+                                        col++; \
+                                offset++; \
+                        }
+
+        if (OP(g->strip[0]) != OEND)
+                fprintf(d, "missing initial OEND!\n");
+        for (s = &g->strip[1]; !done; s++) {
+                opnd = OPND(*s);
+                switch (OP(*s)) {
+                case OEND:
+                        fprintf(d, "\n");
+                        done = 1;
+                        break;
+                case OCHAR:
+                        if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
+                                fprintf(d, "\\%c", (char)opnd);
+                        else
+                                fprintf(d, "%s", regchar((char)opnd));
+                        break;
+                case OBOL:
+                        fprintf(d, "^");
+                        break;
+                case OEOL:
+                        fprintf(d, "$");
+                        break;
+                case OBOW:
+                        fprintf(d, "\\{");
+                        break;
+                case OEOW:
+                        fprintf(d, "\\}");
+                        break;
+                case OANY:
+                        fprintf(d, ".");
+                        break;
+                case OANYOF:
+                        fprintf(d, "[(%ld)", (long)opnd);
+                        cs = &g->sets[opnd];
+                        last = -1;
+                        for (i = 0; i < g->csetsize+1; i++)     /* +1 flushes */
+                                if (CHIN(cs, i) && i < g->csetsize) {
+                                        if (last < 0) {
+                                                fprintf(d, "%s", regchar(i));
+                                                last = i;
+                                        }
+                                } else {
+                                        if (last >= 0) {
+                                                if (last != i-1)
+                                                        fprintf(d, "-%s",
+                                                                regchar(i-1));
+                                                last = -1;
+                                        }
+                                }
+                        fprintf(d, "]");
+                        break;
+                case OBACK_:
+                        fprintf(d, "(\\<%ld>", (long)opnd);
+                        break;
+                case O_BACK:
+                        fprintf(d, "<%ld>\\)", (long)opnd);
+                        break;
+                case OPLUS_:
+                        fprintf(d, "(+");
+                        if (OP(*(s+opnd)) != O_PLUS)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_PLUS:
+                        if (OP(*(s-opnd)) != OPLUS_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "+)");
+                        break;
+                case OQUEST_:
+                        fprintf(d, "(?");
+                        if (OP(*(s+opnd)) != O_QUEST)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_QUEST:
+                        if (OP(*(s-opnd)) != OQUEST_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "?)");
+                        break;
+                case OLPAREN:
+                        fprintf(d, "((<%ld>", (long)opnd);
+                        break;
+                case ORPAREN:
+                        fprintf(d, "<%ld>))", (long)opnd);
+                        break;
+                case OCH_:
+                        fprintf(d, "<");
+                        if (OP(*(s+opnd)) != OOR2)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case OOR1:
+                        if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, "|");
+                        break;
+                case OOR2:
+                        fprintf(d, "|");
+                        if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        break;
+                case O_CH:
+                        if (OP(*(s-opnd)) != OOR1)
+                                fprintf(d, "<%ld>", (long)opnd);
+                        fprintf(d, ">");
+                        break;
+                default:
+                        fprintf(d, "!%ld(%ld)!", (long)OP(*s), (long)opnd);
+                        break;
+                }
+                if (!done)
+                        GAP();
+        }
+}
+
+/*
+ - regchar - make a character printable
+ == static char *regchar(int ch);
+ */
+static char *                   /* -> representation */
+regchar(ch)
+int ch;
+{
+        static char buf[10];
+
+        if (isprint(ch) || ch == ' ')
+                snprintf(buf, sizeof buf, "%c", ch);
+        else
+                snprintf(buf, sizeof buf, "\\%o", ch);
+        return(buf);
+}
diff --git a/src/regress/lib/libc/regex/debug.ih b/src/regress/lib/libc/regex/debug.ih
new file mode 100644
index 0000000000..9eb313af23
--- /dev/null
+++ b/src/regress/lib/libc/regex/debug.ih
@@ -0,0 +1,17 @@
+/*      $OpenBSD: debug.ih,v 1.3 2002/02/16 21:27:32 millert Exp $      */
+/*      $NetBSD: debug.ih,v 1.2 1995/04/20 22:39:47 cgd Exp $   */
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === debug.c === */
+void regprint(regex_t *r, FILE *d);
+static void s_print(register struct re_guts *g, FILE *d);
+static char *regchar(int ch);
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
diff --git a/src/regress/lib/libc/regex/main.c b/src/regress/lib/libc/regex/main.c
new file mode 100644
index 0000000000..fd092905fa
--- /dev/null
+++ b/src/regress/lib/libc/regex/main.c
@@ -0,0 +1,516 @@
+/*      $OpenBSD: main.c,v 1.5 2004/02/28 08:06:46 deraadt Exp $        */
+/*      $NetBSD: main.c,v 1.2 1995/04/20 22:39:51 cgd Exp $     */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <regex.h>
+#include <assert.h>
+#include <unistd.h>
+
+#include "main.ih"
+
+char *progname;
+int debug = 0;
+int line = 0;
+int status = 0;
+
+int copts = REG_EXTENDED;
+int eopts = 0;
+regoff_t startoff = 0;
+regoff_t endoff = 0;
+
+
+extern int split(char *, char *[], int, char *);
+extern void regprint(regex_t *, FILE *);
+
+/*
+ - main - do the simple case, hand off to regress() for regression
+ */
+int
+main(int argc, char *argv[])
+
+{
+        regex_t re;
+#       define  NS      10
+        regmatch_t subs[NS];
+        char erbuf[100];
+        int err;
+        size_t len;
+        int c;
+        int errflg = 0;
+        register int i;
+        extern int optind;
+        extern char *optarg;
+
+        progname = argv[0];
+
+        while ((c = getopt(argc, argv, "c:e:S:E:x")) != -1)
+                switch (c) {
+                case 'c':       /* compile options */
+                        copts = options('c', optarg);
+                        break;
+                case 'e':       /* execute options */
+                        eopts = options('e', optarg);
+                        break;
+                case 'S':       /* start offset */
+                        startoff = (regoff_t)atoi(optarg);
+                        break;
+                case 'E':       /* end offset */
+                        endoff = (regoff_t)atoi(optarg);
+                        break;
+                case 'x':       /* Debugging. */
+                        debug++;
+                        break;
+                case '?':
+                default:
+                        errflg++;
+                        break;
+                }
+        if (errflg) {
+                fprintf(stderr, "usage: %s ", progname);
+                fprintf(stderr, "[-c copt][-C][-d] [re]\n");
+                exit(2);
+        }
+
+        if (optind >= argc) {
+                regress(stdin);
+                exit(status);
+        }
+
+        err = regcomp(&re, argv[optind++], copts);
+        if (err) {
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                        eprint(err), len, sizeof(erbuf), erbuf);
+                exit(status);
+        }
+        regprint(&re, stdout);  
+
+        if (optind >= argc) {
+                regfree(&re);
+                exit(status);
+        }
+
+        if (eopts&REG_STARTEND) {
+                subs[0].rm_so = startoff;
+                subs[0].rm_eo = strlen(argv[optind]) - endoff;
+        }
+        err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
+        if (err) {
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "error %s, %d/%d `%s'\n",
+                        eprint(err), len, sizeof(erbuf), erbuf);
+                exit(status);
+        }
+        if (!(copts&REG_NOSUB)) {
+                len = (size_t)(subs[0].rm_eo - subs[0].rm_so);
+                if (subs[0].rm_so != -1) {
+                        if (len != 0)
+                                printf("match `%.*s'\n", (int)len,
+                                        argv[optind] + subs[0].rm_so);
+                        else
+                                printf("match `'@%.1s\n",
+                                        argv[optind] + subs[0].rm_so);
+                }
+                for (i = 1; i < NS; i++)
+                        if (subs[i].rm_so != -1)
+                                printf("(%d) `%.*s'\n", i,
+                                        (int)(subs[i].rm_eo - subs[i].rm_so),
+                                        argv[optind] + subs[i].rm_so);
+        }
+        exit(status);
+}
+
+/*
+ - regress - main loop of regression test
+ == void regress(FILE *in);
+ */
+void
+regress(in)
+FILE *in;
+{
+        char inbuf[1000];
+#       define  MAXF    10
+        char *f[MAXF];
+        int nf;
+        int i;
+        char erbuf[100];
+        size_t ne;
+        char *badpat = "invalid regular expression";
+#       define  SHORT   10
+        char *bpname = "REG_BADPAT";
+        regex_t re;
+
+        while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
+                line++;
+                if (inbuf[0] == '#' || inbuf[0] == '\n')
+                        continue;                       /* NOTE CONTINUE */
+                inbuf[strlen(inbuf)-1] = '\0';  /* get rid of stupid \n */
+                if (debug)
+                        fprintf(stdout, "%d:\n", line);
+                nf = split(inbuf, f, MAXF, "\t\t");
+                if (nf < 3) {
+                        fprintf(stderr, "bad input, line %d\n", line);
+                        exit(1);
+                }
+                for (i = 0; i < nf; i++)
+                        if (strcmp(f[i], "\"\"") == 0)
+                                f[i] = "";
+                if (nf <= 3)
+                        f[3] = NULL;
+                if (nf <= 4)
+                        f[4] = NULL;
+                try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
+                if (opt('&', f[1]))     /* try with either type of RE */
+                        try(f[0], f[1], f[2], f[3], f[4],
+                                        options('c', f[1]) &~ REG_EXTENDED);
+        }
+
+        ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+        if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
+                fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
+                                                        erbuf, badpat);
+                status = 1;
+        }
+        ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
+        if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
+                                                ne != strlen(badpat)+1) {
+                fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
+                                                erbuf, SHORT-1, badpat);
+                status = 1;
+        }
+        ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+        if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
+                fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
+                                                erbuf, bpname);
+                status = 1;
+        }
+        re.re_endp = bpname;
+        ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
+        if (atoi(erbuf) != (int)REG_BADPAT) {
+                fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
+                                                erbuf, (long)REG_BADPAT);
+                status = 1;
+        } else if (ne != strlen(erbuf)+1) {
+                fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
+                                                erbuf, (long)REG_BADPAT);
+                status = 1;
+        }
+}
+
+/*
+ - try - try it, and report on problems
+ == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+ */
+void
+try(f0, f1, f2, f3, f4, opts)
+char *f0;
+char *f1;
+char *f2;
+char *f3;
+char *f4;
+int opts;                       /* may not match f1 */
+{
+        regex_t re;
+#       define  NSUBS   10
+        regmatch_t subs[NSUBS];
+#       define  NSHOULD 15
+        char *should[NSHOULD];
+        int nshould;
+        char erbuf[100];
+        int err;
+        int len;
+        char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
+        register int i;
+        char *grump;
+        char f0copy[1000];
+        char f2copy[1000];
+
+        strlcpy(f0copy, f0, sizeof f0copy);
+        re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
+        fixstr(f0copy);
+        err = regcomp(&re, f0copy, opts);
+        if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
+                /* unexpected error or wrong error */
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
+                                        line, type, eprint(err), len,
+                                        sizeof(erbuf), erbuf);
+                status = 1;
+        } else if (err == 0 && opt('C', f1)) {
+                /* unexpected success */
+                fprintf(stderr, "%d: %s should have given REG_%s\n",
+                                                line, type, f2);
+                status = 1;
+                err = 1;        /* so we won't try regexec */
+        }
+
+        if (err != 0) {
+                regfree(&re);
+                return;
+        }
+
+        strlcpy(f2copy, f2, sizeof f2copy);
+        fixstr(f2copy);
+
+        if (options('e', f1)&REG_STARTEND) {
+                if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
+                        fprintf(stderr, "%d: bad STARTEND syntax\n", line);
+                subs[0].rm_so = strchr(f2, '(') - f2 + 1;
+                subs[0].rm_eo = strchr(f2, ')') - f2;
+        }
+        err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
+
+        if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
+                /* unexpected error or wrong error */
+                len = regerror(err, &re, erbuf, sizeof(erbuf));
+                fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
+                                        line, type, eprint(err), len,
+                                        sizeof(erbuf), erbuf);
+                status = 1;
+        } else if (err != 0) {
+                /* nothing more to check */
+        } else if (f3 == NULL) {
+                /* unexpected success */
+                fprintf(stderr, "%d: %s exec should have failed\n",
+                                                line, type);
+                status = 1;
+                err = 1;                /* just on principle */
+        } else if (opts&REG_NOSUB) {
+                /* nothing more to check */
+        } else if ((grump = check(f2, subs[0], f3)) != NULL) {
+                fprintf(stderr, "%d: %s %s\n", line, type, grump);
+                status = 1;
+                err = 1;
+        }
+
+        if (err != 0 || f4 == NULL) {
+                regfree(&re);
+                return;
+        }
+
+        for (i = 1; i < NSHOULD; i++)
+                should[i] = NULL;
+        nshould = split(f4, should+1, NSHOULD-1, ",");
+        if (nshould == 0) {
+                nshould = 1;
+                should[1] = "";
+        }
+        for (i = 1; i < NSUBS; i++) {
+                grump = check(f2, subs[i], should[i]);
+                if (grump != NULL) {
+                        fprintf(stderr, "%d: %s $%d %s\n", line,
+                                                        type, i, grump);
+                        status = 1;
+                        err = 1;
+                }
+        }
+
+        regfree(&re);
+}
+
+/*
+ - options - pick options out of a regression-test string
+ == int options(int type, char *s);
+ */
+int
+options(type, s)
+int type;                       /* 'c' compile, 'e' exec */
+char *s;
+{
+        register char *p;
+        register int o = (type == 'c') ? copts : eopts;
+        register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
+
+        for (p = s; *p != '\0'; p++)
+                if (strchr(legal, *p) != NULL)
+                        switch (*p) {
+                        case 'b':
+                                o &= ~REG_EXTENDED;
+                                break;
+                        case 'i':
+                                o |= REG_ICASE;
+                                break;
+                        case 's':
+                                o |= REG_NOSUB;
+                                break;
+                        case 'n':
+                                o |= REG_NEWLINE;
+                                break;
+                        case 'm':
+                                o &= ~REG_EXTENDED;
+                                o |= REG_NOSPEC;
+                                break;
+                        case 'p':
+                                o |= REG_PEND;
+                                break;
+                        case '^':
+                                o |= REG_NOTBOL;
+                                break;
+                        case '$':
+                                o |= REG_NOTEOL;
+                                break;
+                        case '#':
+                                o |= REG_STARTEND;
+                                break;
+                        case 't':       /* trace */
+                                o |= REG_TRACE;
+                                break;
+                        case 'l':       /* force long representation */
+                                o |= REG_LARGE;
+                                break;
+                        case 'r':       /* force backref use */
+                                o |= REG_BACKR;
+                                break;
+                        }
+        return(o);
+}
+
+/*
+ - opt - is a particular option in a regression string?
+ == int opt(int c, char *s);
+ */
+int                             /* predicate */
+opt(c, s)
+int c;
+char *s;
+{
+        return(strchr(s, c) != NULL);
+}
+
+/*
+ - fixstr - transform magic characters in strings
+ == void fixstr(register char *p);
+ */
+void
+fixstr(p)
+register char *p;
+{
+        if (p == NULL)
+                return;
+
+        for (; *p != '\0'; p++)
+                if (*p == 'N')
+                        *p = '\n';
+                else if (*p == 'T')
+                        *p = '\t';
+                else if (*p == 'S')
+                        *p = ' ';
+                else if (*p == 'Z')
+                        *p = '\0';
+}
+
+/*
+ - check - check a substring match
+ == char *check(char *str, regmatch_t sub, char *should);
+ */
+char *                          /* NULL or complaint */
+check(str, sub, should)
+char *str;
+regmatch_t sub;
+char *should;
+{
+        register int len;
+        register int shlen;
+        register char *p;
+        static char grump[500];
+        register char *at = NULL;
+
+        if (should != NULL && strcmp(should, "-") == 0)
+                should = NULL;
+        if (should != NULL && should[0] == '@') {
+                at = should + 1;
+                should = "";
+        }
+
+        /* check rm_so and rm_eo for consistency */
+        if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
+                                (sub.rm_so != -1 && sub.rm_eo == -1) ||
+                                (sub.rm_so != -1 && sub.rm_so < 0) ||
+                                (sub.rm_eo != -1 && sub.rm_eo < 0) ) {
+                snprintf(grump, sizeof grump,
+                    "start %ld end %ld", (long)sub.rm_so,
+                    (long)sub.rm_eo);
+                return(grump);
+        }
+
+        /* check for no match */
+        if (sub.rm_so == -1 && should == NULL)
+                return(NULL);
+        if (sub.rm_so == -1)
+                return("did not match");
+
+        /* check for in range */
+        if (sub.rm_eo > strlen(str)) {
+                snprintf(grump, sizeof grump,
+                        "start %ld end %ld, past end of string",
+                        (long)sub.rm_so, (long)sub.rm_eo);
+                return(grump);
+        }
+
+        len = (int)(sub.rm_eo - sub.rm_so);
+        shlen = (int)strlen(should);
+        p = str + sub.rm_so;
+
+        /* check for not supposed to match */
+        if (should == NULL) {
+                snprintf(grump, sizeof grump, "matched `%.*s'", len, p);
+                return(grump);
+        }
+
+        /* check for wrong match */
+        if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
+                snprintf(grump, sizeof grump, "matched `%.*s' instead", len, p);
+                return(grump);
+        }
+        if (shlen > 0)
+                return(NULL);
+
+        /* check null match in right place */
+        if (at == NULL)
+                return(NULL);
+        shlen = strlen(at);
+        if (shlen == 0)
+                shlen = 1;      /* force check for end-of-string */
+        if (strncmp(p, at, shlen) != 0) {
+                snprintf(grump, sizeof grump, "matched null at `%.20s'", p);
+                return(grump);
+        }
+        return(NULL);
+}
+
+/*
+ - eprint - convert error number to name
+ == static char *eprint(int err);
+ */
+static char *
+eprint(err)
+int err;
+{
+        static char epbuf[100];
+        size_t len;
+
+        len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
+        assert(len <= sizeof(epbuf));
+        return(epbuf);
+}
+
+/*
+ - efind - convert error name to number
+ == static int efind(char *name);
+ */
+static int
+efind(name)
+char *name;
+{
+        static char efbuf[100];
+        regex_t re;
+
+        snprintf(efbuf, sizeof efbuf, "REG_%s", name);
+        assert(strlen(efbuf) < sizeof(efbuf));
+        re.re_endp = efbuf;
+        (void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
+        return(atoi(efbuf));
+}
diff --git a/src/regress/lib/libc/regex/main.ih b/src/regress/lib/libc/regex/main.ih
new file mode 100644
index 0000000000..0860e26333
--- /dev/null
+++ b/src/regress/lib/libc/regex/main.ih
@@ -0,0 +1,22 @@
+/*      $OpenBSD: main.ih,v 1.3 2002/02/16 21:27:32 millert Exp $       */
+/*      $NetBSD: main.ih,v 1.2 1995/04/20 22:39:55 cgd Exp $    */
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === main.c === */
+void regress(FILE *in);
+void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+int options(int type, char *s);
+int opt(int c, char *s);
+void fixstr(register char *p);
+char *check(char *str, regmatch_t sub, char *should);
+static char *eprint(int err);
+static int efind(char *name);
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
diff --git a/src/regress/lib/libc/regex/split.c b/src/regress/lib/libc/regex/split.c
new file mode 100644
index 0000000000..f0f72c8b66
--- /dev/null
+++ b/src/regress/lib/libc/regex/split.c
@@ -0,0 +1,317 @@
+/*      $OpenBSD: split.c,v 1.4 2004/02/28 08:06:47 deraadt Exp $       */
+/*      $NetBSD: split.c,v 1.2 1995/04/20 22:39:57 cgd Exp $    */
+
+#include <stdio.h>
+#include <string.h>
+
+int split(char *string, char *fields[], int nfields, char *sep);
+
+/*
+ - split - divide a string into fields, like awk split()
+ = int split(char *string, char *fields[], int nfields, char *sep);
+ */
+int                             /* number of fields, including overflow */
+split(char *string, char *fields[], int nfields, char *sep)
+{
+        register char *p = string;
+        register char c;                        /* latest character */
+        register char sepc = sep[0];
+        register char sepc2;
+        register int fn;
+        register char **fp = fields;
+        register char *sepp;
+        register int trimtrail;
+
+        /* white space */
+        if (sepc == '\0') {
+                while ((c = *p++) == ' ' || c == '\t')
+                        continue;
+                p--;
+                trimtrail = 1;
+                sep = " \t";    /* note, code below knows this is 2 long */
+                sepc = ' ';
+        } else
+                trimtrail = 0;
+        sepc2 = sep[1];         /* now we can safely pick this up */
+
+        /* catch empties */
+        if (*p == '\0')
+                return(0);
+
+        /* single separator */
+        if (sepc2 == '\0') {
+                fn = nfields;
+                for (;;) {
+                        *fp++ = p;
+                        fn--;
+                        if (fn == 0)
+                                break;
+                        while ((c = *p++) != sepc)
+                                if (c == '\0')
+                                        return(nfields - fn);
+                        *(p-1) = '\0';
+                }
+                /* we have overflowed the fields vector -- just count them */
+                fn = nfields;
+                for (;;) {
+                        while ((c = *p++) != sepc)
+                                if (c == '\0')
+                                        return(fn);
+                        fn++;
+                }
+                /* not reached */
+        }
+
+        /* two separators */
+        if (sep[2] == '\0') {
+                fn = nfields;
+                for (;;) {
+                        *fp++ = p;
+                        fn--;
+                        while ((c = *p++) != sepc && c != sepc2)
+                                if (c == '\0') {
+                                        if (trimtrail && **(fp-1) == '\0')
+                                                fn++;
+                                        return(nfields - fn);
+                                }
+                        if (fn == 0)
+                                break;
+                        *(p-1) = '\0';
+                        while ((c = *p++) == sepc || c == sepc2)
+                                continue;
+                        p--;
+                }
+                /* we have overflowed the fields vector -- just count them */
+                fn = nfields;
+                while (c != '\0') {
+                        while ((c = *p++) == sepc || c == sepc2)
+                                continue;
+                        p--;
+                        fn++;
+                        while ((c = *p++) != '\0' && c != sepc && c != sepc2)
+                                continue;
+                }
+                /* might have to trim trailing white space */
+                if (trimtrail) {
+                        p--;
+                        while ((c = *--p) == sepc || c == sepc2)
+                                continue;
+                        p++;
+                        if (*p != '\0') {
+                                if (fn == nfields+1)
+                                        *p = '\0';
+                                fn--;
+                        }
+                }
+                return(fn);
+        }
+
+        /* n separators */
+        fn = 0;
+        for (;;) {
+                if (fn < nfields)
+                        *fp++ = p;
+                fn++;
+                for (;;) {
+                        c = *p++;
+                        if (c == '\0')
+                                return(fn);
+                        sepp = sep;
+                        while ((sepc = *sepp++) != '\0' && sepc != c)
+                                continue;
+                        if (sepc != '\0')       /* it was a separator */
+                                break;
+                }
+                if (fn < nfields)
+                        *(p-1) = '\0';
+                for (;;) {
+                        c = *p++;
+                        sepp = sep;
+                        while ((sepc = *sepp++) != '\0' && sepc != c)
+                                continue;
+                        if (sepc == '\0')       /* it wasn't a separator */
+                                break;
+                }
+                p--;
+        }
+
+        /* not reached */
+}
+
+#ifdef TEST_SPLIT
+
+
+/*
+ * test program
+ * pgm          runs regression
+ * pgm sep      splits stdin lines by sep
+ * pgm str sep  splits str by sep
+ * pgm str sep n        splits str by sep n times
+ */
+int
+main(argc, argv)
+int argc;
+char *argv[];
+{
+        char buf[512];
+        register int n;
+#       define  MNF     10
+        char *fields[MNF];
+
+        if (argc > 4)
+                for (n = atoi(argv[3]); n > 0; n--) {
+                        (void) strlcpy(buf, argv[1], sizeof buf);
+                }
+        else if (argc > 3)
+                for (n = atoi(argv[3]); n > 0; n--) {
+                        (void) strlcpy(buf, argv[1], sizeof buf);
+                        (void) split(buf, fields, MNF, argv[2]);
+                }
+        else if (argc > 2)
+                dosplit(argv[1], argv[2]);
+        else if (argc > 1)
+                while (fgets(buf, sizeof(buf), stdin) != NULL) {
+                        buf[strlen(buf)-1] = '\0';      /* stomp newline */
+                        dosplit(buf, argv[1]);
+                }
+        else
+                regress();
+
+        exit(0);
+}
+
+dosplit(string, seps)
+char *string;
+char *seps;
+{
+#       define  NF      5
+        char *fields[NF];
+        register int nf;
+
+        nf = split(string, fields, NF, seps);
+        print(nf, NF, fields);
+}
+
+print(nf, nfp, fields)
+int nf;
+int nfp;
+char *fields[];
+{
+        register int fn;
+        register int bound;
+
+        bound = (nf > nfp) ? nfp : nf;
+        printf("%d:\t", nf);
+        for (fn = 0; fn < bound; fn++)
+                printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
+}
+
+#define RNF     5               /* some table entries know this */
+struct {
+        char *str;
+        char *seps;
+        int nf;
+        char *fi[RNF];
+} tests[] = {
+        "",             " ",    0,      { "" },
+        " ",            " ",    2,      { "", "" },
+        "x",            " ",    1,      { "x" },
+        "xy",           " ",    1,      { "xy" },
+        "x y",          " ",    2,      { "x", "y" },
+        "abc def  g ",  " ",    5,      { "abc", "def", "", "g", "" },
+        "  a bcd",      " ",    4,      { "", "", "a", "bcd" },
+        "a b c d e f",  " ",    6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    " ",    6,      { "", "a", "b", "c", "d " },
+
+        "",             " _",   0,      { "" },
+        " ",            " _",   2,      { "", "" },
+        "x",            " _",   1,      { "x" },
+        "x y",          " _",   2,      { "x", "y" },
+        "ab _ cd",      " _",   2,      { "ab", "cd" },
+        " a_b  c ",     " _",   5,      { "", "a", "b", "c", "" },
+        "a b c_d e f",  " _",   6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    " _",   6,      { "", "a", "b", "c", "d " },
+
+        "",             " _~",  0,      { "" },
+        " ",            " _~",  2,      { "", "" },
+        "x",            " _~",  1,      { "x" },
+        "x y",          " _~",  2,      { "x", "y" },
+        "ab _~ cd",     " _~",  2,      { "ab", "cd" },
+        " a_b  c~",     " _~",  5,      { "", "a", "b", "c", "" },
+        "a b_c d~e f",  " _~",  6,      { "a", "b", "c", "d", "e f" },
+        "~a b c d ",    " _~",  6,      { "", "a", "b", "c", "d " },
+
+        "",             " _~-", 0,      { "" },
+        " ",            " _~-", 2,      { "", "" },
+        "x",            " _~-", 1,      { "x" },
+        "x y",          " _~-", 2,      { "x", "y" },
+        "ab _~- cd",    " _~-", 2,      { "ab", "cd" },
+        " a_b  c~",     " _~-", 5,      { "", "a", "b", "c", "" },
+        "a b_c-d~e f",  " _~-", 6,      { "a", "b", "c", "d", "e f" },
+        "~a-b c d ",    " _~-", 6,      { "", "a", "b", "c", "d " },
+
+        "",             "  ",   0,      { "" },
+        " ",            "  ",   2,      { "", "" },
+        "x",            "  ",   1,      { "x" },
+        "xy",           "  ",   1,      { "xy" },
+        "x y",          "  ",   2,      { "x", "y" },
+        "abc def  g ",  "  ",   4,      { "abc", "def", "g", "" },
+        "  a bcd",      "  ",   3,      { "", "a", "bcd" },
+        "a b c d e f",  "  ",   6,      { "a", "b", "c", "d", "e f" },
+        " a b c d ",    "  ",   6,      { "", "a", "b", "c", "d " },
+
+        "",             "",     0,      { "" },
+        " ",            "",     0,      { "" },
+        "x",            "",     1,      { "x" },
+        "xy",           "",     1,      { "xy" },
+        "x y",          "",     2,      { "x", "y" },
+        "abc def  g ",  "",     3,      { "abc", "def", "g" },
+        "\t a bcd",     "",     2,      { "a", "bcd" },
+        "  a \tb\t c ", "",     3,      { "a", "b", "c" },
+        "a b c d e ",   "",     5,      { "a", "b", "c", "d", "e" },
+        "a b\tc d e f", "",     6,      { "a", "b", "c", "d", "e f" },
+        " a b c d e f ",        "",     6,      { "a", "b", "c", "d", "e f " },
+
+        NULL,           NULL,   0,      { NULL },
+};
+
+regress()
+{
+        char buf[512];
+        register int n;
+        char *fields[RNF+1];
+        register int nf;
+        register int i;
+        register int printit;
+        register char *f;
+
+        for (n = 0; tests[n].str != NULL; n++) {
+                (void) strlcpy(buf, tests[n].str, sizeof buf);
+                fields[RNF] = NULL;
+                nf = split(buf, fields, RNF, tests[n].seps);
+                printit = 0;
+                if (nf != tests[n].nf) {
+                        printf("split `%s' by `%s' gave %d fields, not %d\n",
+                                tests[n].str, tests[n].seps, nf, tests[n].nf);
+                        printit = 1;
+                } else if (fields[RNF] != NULL) {
+                        printf("split() went beyond array end\n");
+                        printit = 1;
+                } else {
+                        for (i = 0; i < nf && i < RNF; i++) {
+                                f = fields[i];
+                                if (f == NULL)
+                                        f = "(NULL)";
+                                if (strcmp(f, tests[n].fi[i]) != 0) {
+                                        printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
+                                                tests[n].str, tests[n].seps,
+                                                i, fields[i], tests[n].fi[i]);
+                                        printit = 1;
+                                }
+                        }
+                }
+                if (printit)
+                        print(nf, RNF, fields);
+        }
+}
+#endif
diff --git a/src/regress/lib/libc/regex/tests b/src/regress/lib/libc/regex/tests
new file mode 100644
index 0000000000..c827c868b7
--- /dev/null
+++ b/src/regress/lib/libc/regex/tests
@@ -0,0 +1,503 @@
+#       $OpenBSD: tests,v 1.5 2004/11/29 16:50:31 otto Exp $
+#       $NetBSD: tests,v 1.5 1995/04/20 22:40:00 cgd Exp $
+
+# regular expression test set
+# Lines are at least three fields, separated by one or more tabs.  "" stands
+# for an empty field.  First field is an RE.  Second field is flags.  If
+# C flag given, regcomp() is expected to fail, and the third field is the
+# error name (minus the leading REG_).
+#
+# Otherwise it is expected to succeed, and the third field is the string to
+# try matching it against.  If there is no fourth field, the match is
+# expected to fail.  If there is a fourth field, it is the substring that
+# the RE is expected to match.  If there is a fifth field, it is a comma-
+# separated list of what the subexpressions should match, with - indicating
+# no match for that one.  In both the fourth and fifth fields, a (sub)field
+# starting with @ indicates that the (sub)expression is expected to match
+# a null string followed by the stuff after the @; this provides a way to
+# test where null strings match.  The character `N' in REs and strings
+# is newline, `S' is space, `T' is tab, `Z' is NUL.
+#
+# The full list of flags:
+#       -       placeholder, does nothing
+#       b       RE is a BRE, not an ERE
+#       &       try it as both an ERE and a BRE
+#       C       regcomp() error expected, third field is error name
+#       i       REG_ICASE
+#       m       ("mundane") REG_NOSPEC
+#       s       REG_NOSUB (not really testable)
+#       n       REG_NEWLINE
+#       ^       REG_NOTBOL
+#       $       REG_NOTEOL
+#       #       REG_STARTEND (see below)
+#       p       REG_PEND
+#
+# For REG_STARTEND, the start/end offsets are those of the substring
+# enclosed in ().
+
+# basics
+a               &       a       a
+abc             &       abc     abc
+abc|de          -       abc     abc
+a|b|c           -       abc     a
+
+# parentheses and perversions thereof
+a(b)c           -       abc     abc
+a\(b\)c         b       abc     abc
+a(              C       EPAREN
+a(              b       a(      a(
+a\(             -       a(      a(
+a\(             bC      EPAREN
+a\(b            bC      EPAREN
+a(b             C       EPAREN
+a(b             b       a(b     a(b
+# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
+a)              -       a)      a)
+)               -       )       )
+# end gagging (in a just world, those *should* give EPAREN)
+a)              b       a)      a)
+a\)             bC      EPAREN
+\)              bC      EPAREN
+a()b            -       ab      ab
+a\(\)b          b       ab      ab
+
+# anchoring and REG_NEWLINE
+^abc$           &       abc     abc
+a^b             -       a^b
+a^b             b       a^b     a^b
+a$b             -       a$b
+a$b             b       a$b     a$b
+^               &       abc     @abc
+$               &       abc     @
+^$              &       ""      @
+$^              -       ""      @
+\($\)\(^\)      b       ""      @
+# stop retching, those are legitimate (although disgusting)
+^^              -       ""      @
+$$              -       ""      @
+b$              &       abNc
+b$              &n      abNc    b
+^b$             &       aNbNc
+^b$             &n      aNbNc   b
+^$              &n      aNNb    @Nb
+^$              n       abc
+^$              n       abcN    @
+$^              n       aNNb    @Nb
+\($\)\(^\)      bn      aNNb    @Nb
+^^              n^      aNNb    @Nb
+$$              n       aNNb    @NN
+^a              ^       a
+a$              $       a
+^a              ^n      aNb
+^b              ^n      aNb     b
+a$              $n      bNa
+b$              $n      bNa     b
+a*(^b$)c*       -       b       b
+a*\(^b$\)c*     b       b       b
+
+# certain syntax errors and non-errors
+|               C       EMPTY
+|               b       |       |
+*               C       BADRPT
+*               b       *       *
++               C       BADRPT
+?               C       BADRPT
+""              &C      EMPTY
+()              -       abc     @abc
+\(\)            b       abc     @abc
+a||b            C       EMPTY
+|ab             C       EMPTY
+ab|             C       EMPTY
+(|a)b           C       EMPTY
+(a|)b           C       EMPTY
+(*a)            C       BADRPT
+(+a)            C       BADRPT
+(?a)            C       BADRPT
+({1}a)          C       BADRPT
+\(\{1\}a\)      bC      BADRPT
+(a|*b)          C       BADRPT
+(a|+b)          C       BADRPT
+(a|?b)          C       BADRPT
+(a|{1}b)        C       BADRPT
+^*              C       BADRPT
+^*              b       *       *
+^+              C       BADRPT
+^?              C       BADRPT
+^{1}            C       BADRPT
+^\{1\}          bC      BADRPT
+
+# metacharacters, backslashes
+a.c             &       abc     abc
+a[bc]d          &       abd     abd
+a\*c            &       a*c     a*c
+a\\b            &       a\b     a\b
+a\\\*b          &       a\*b    a\*b
+a\bc            &       abc     abc
+a\              &C      EESCAPE
+a\\bc           &       a\bc    a\bc
+\{              bC      BADRPT
+a\[b            &       a[b     a[b
+a[b             &C      EBRACK
+# trailing $ is a peculiar special case for the BRE code
+a$              &       a       a
+a$              &       a$
+a\$             &       a
+a\$             &       a$      a$
+a\\$            &       a
+a\\$            &       a$
+a\\$            &       a\$
+a\\$            &       a\      a\
+
+# back references, ugh
+a\(b\)\2c       bC      ESUBREG
+a\(b\1\)c       bC      ESUBREG
+a\(b*\)c\1d     b       abbcbbd abbcbbd bb
+a\(b*\)c\1d     b       abbcbd
+a\(b*\)c\1d     b       abbcbbbd
+^\(.\)\1        b       abc
+a\([bc]\)\1d    b       abcdabbd        abbd    b
+a\(\([bc]\)\2\)*d       b       abbccd  abbccd
+a\(\([bc]\)\2\)*d       b       abbcbd
+# actually, this next one probably ought to fail, but the spec is unclear
+a\(\(b\)*\2\)*d         b       abbbd   abbbd
+# here is a case that no NFA implementation does right
+\(ab*\)[ab]*\1  b       ababaaa ababaaa a
+# check out normal matching in the presence of back refs
+\(a\)\1bcd      b       aabcd   aabcd
+\(a\)\1bc*d     b       aabcd   aabcd
+\(a\)\1bc*d     b       aabd    aabd
+\(a\)\1bc*d     b       aabcccd aabcccd
+\(a\)\1bc*[ce]d b       aabcccd aabcccd
+^\(a\)\1b\(c\)*cd$      b       aabcccd aabcccd
+\(b*\)\(a*\1\)* b       ab      a
+\([^_]*\)\(_*\1\)*      b       foo_foo_bar_bar_bar_baz foo_foo foo,_foo
+\([^_]*\)\(_*\1\)*      b       bar_bar_bar_baz bar_bar_bar     bar,_bar
+\([^_]*\)\(_*\1\)*      b       foo_bar_baz     foo     foo
+\(.*\)\1        b       ""      ""
+\(.*\)\1        b       a       ""
+\(.*\)\1        b       aa      aa
+\(.*\)\1        b       aaa     aa
+\(.*\)\1        b       aaaa    aaaa
+\([^_]*\)\1     b       ""      ""
+\([^_]*\)\1     b       a       ""
+\([^_]*\)\1     b       aa      aa
+\([^_]*\)\1     b       aaa     aa
+\([^_]*\)\1     b       aaaa    aaaa
+foo\(.*\)bar\1  b       foolbarl        foolbarl        l
+foo\(.*\)bar\1  b       foobar  foobar  ""
+\(\(.\)b\)*\1   b       aba
+\(\(.\)b\)*\1   b       abba
+\(\(.\)b\)*\1   b       abbba
+\(\(.\)b\)*\1   b       abbbba  bbbb    bb,b
+\(\(.\)b\)*\1   b       abbbbba abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbba        abbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbba        abbbbbbbbbbbbb  bb,b
+\(\(.\)b\)*\1   b       abbbbbbbbbbbbbbba       abbbbbbbbbbbbbbb        bb,b
+
+# ordinary repetitions
+ab*c            &       abc     abc
+ab+c            -       abc     abc
+ab?c            -       abc     abc
+a\(*\)b         b       a*b     a*b
+a\(**\)b        b       ab      ab
+a\(***\)b       bC      BADRPT
+*a              b       *a      *a
+**a             b       a       a
+***a            bC      BADRPT
+
+# the dreaded bounded repetitions
+{               &       {       {
+{abc            &       {abc    {abc
+{1              C       BADRPT
+{1}             C       BADRPT
+a{b             &       a{b     a{b
+a{1}b           -       ab      ab
+a\{1\}b         b       ab      ab
+a{1,}b          -       ab      ab
+a\{1,\}b        b       ab      ab
+a{1,2}b         -       aab     aab
+a\{1,2\}b       b       aab     aab
+a{1             C       EBRACE
+a\{1            bC      EBRACE
+a{1a            C       EBRACE
+a\{1a           bC      EBRACE
+a{1a}           C       BADBR
+a\{1a\}         bC      BADBR
+a{,2}           -       a{,2}   a{,2}
+a\{,2\}         bC      BADBR
+a{,}            -       a{,}    a{,}
+a\{,\}          bC      BADBR
+a{1,x}          C       BADBR
+a\{1,x\}        bC      BADBR
+a{1,x           C       EBRACE
+a\{1,x          bC      EBRACE
+a{300}          C       BADBR
+a\{300\}        bC      BADBR
+a{1,0}          C       BADBR
+a\{1,0\}        bC      BADBR
+ab{0,0}c        -       abcac   ac
+ab\{0,0\}c      b       abcac   ac
+ab{0,1}c        -       abcac   abc
+ab\{0,1\}c      b       abcac   abc
+ab{0,3}c        -       abbcac  abbc
+ab\{0,3\}c      b       abbcac  abbc
+ab{1,1}c        -       acabc   abc
+ab\{1,1\}c      b       acabc   abc
+ab{1,3}c        -       acabc   abc
+ab\{1,3\}c      b       acabc   abc
+ab{2,2}c        -       abcabbc abbc
+ab\{2,2\}c      b       abcabbc abbc
+ab{2,4}c        -       abcabbc abbc
+ab\{2,4\}c      b       abcabbc abbc
+((a{1,10}){1,10}){1,10} -       a       a       a,a
+
+# multiple repetitions
+a**             &C      BADRPT
+a++             C       BADRPT
+a??             C       BADRPT
+a*+             C       BADRPT
+a*?             C       BADRPT
+a+*             C       BADRPT
+a+?             C       BADRPT
+a?*             C       BADRPT
+a?+             C       BADRPT
+a{1}{1}         C       BADRPT
+a*{1}           C       BADRPT
+a+{1}           C       BADRPT
+a?{1}           C       BADRPT
+a{1}*           C       BADRPT
+a{1}+           C       BADRPT
+a{1}?           C       BADRPT
+a*{b}           -       a{b}    a{b}
+a\{1\}\{1\}     bC      BADRPT
+a*\{1\}         bC      BADRPT
+a\{1\}*         bC      BADRPT
+
+# brackets, and numerous perversions thereof
+a[b]c           &       abc     abc
+a[ab]c          &       abc     abc
+a[^ab]c         &       adc     adc
+a[]b]c          &       a]c     a]c
+a[[b]c          &       a[c     a[c
+a[-b]c          &       a-c     a-c
+a[^]b]c         &       adc     adc
+a[^-b]c         &       adc     adc
+a[b-]c          &       a-c     a-c
+a[b             &C      EBRACK
+a[]             &C      EBRACK
+a[1-3]c         &       a2c     a2c
+a[3-1]c         &C      ERANGE
+a[1-3-5]c       &C      ERANGE
+a[[.-.]--]c     &       a-c     a-c
+a[1-            &C      ERANGE
+a[[.            &C      EBRACK
+a[[.x           &C      EBRACK
+a[[.x.          &C      EBRACK
+a[[.x.]         &C      EBRACK
+a[[.x.]]        &       ax      ax
+a[[.x,.]]       &C      ECOLLATE
+a[[.one.]]b     &       a1b     a1b
+a[[.notdef.]]b  &C      ECOLLATE
+a[[.].]]b       &       a]b     a]b
+a[[:alpha:]]c   &       abc     abc
+a[[:notdef:]]c  &C      ECTYPE
+a[[:            &C      EBRACK
+a[[:alpha       &C      EBRACK
+a[[:alpha:]     &C      EBRACK
+a[[:alpha,:]    &C      ECTYPE
+a[[:]:]]b       &C      ECTYPE
+a[[:-:]]b       &C      ECTYPE
+a[[:alph:]]     &C      ECTYPE
+a[[:alphabet:]] &C      ECTYPE
+[[:alnum:]]+    -       -%@a0X- a0X
+[[:alpha:]]+    -       -%@aX0- aX
+[[:blank:]]+    -       aSSTb   SST
+[[:cntrl:]]+    -       aNTb    NT
+[[:digit:]]+    -       a019b   019
+[[:graph:]]+    -       Sa%bS   a%b
+[[:lower:]]+    -       AabC    ab
+[[:print:]]+    -       NaSbN   aSb
+[[:punct:]]+    -       S%-&T   %-&
+[[:space:]]+    -       aSNTb   SNT
+[[:upper:]]+    -       aBCd    BC
+[[:xdigit:]]+   -       p0f3Cq  0f3C
+a[[=b=]]c       &       abc     abc
+a[[=            &C      EBRACK
+a[[=b           &C      EBRACK
+a[[=b=          &C      EBRACK
+a[[=b=]         &C      EBRACK
+a[[=b,=]]       &C      ECOLLATE
+a[[=one=]]b     &       a1b     a1b
+
+# complexities
+a(((b)))c       -       abc     abc
+a(b|(c))d       -       abd     abd
+a(b*|c)d        -       abbd    abbd
+# just gotta have one DFA-buster, of course
+a[ab]{20}       -       aaaaabaaaabaaaabaaaab   aaaaabaaaabaaaabaaaab
+# and an inline expansion in case somebody gets tricky
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]       -       aaaaabaaaabaaaabaaaab   aaaaabaaaabaaaabaaaab
+# and in case somebody just slips in an NFA...
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night)      -       aaaaabaaaabaaaabaaaabweeknights aaaaabaaaabaaaabaaaabweeknights
+# fish for anomalies as the number of states passes 32
+12345678901234567890123456789   -       a12345678901234567890123456789b 12345678901234567890123456789
+123456789012345678901234567890  -       a123456789012345678901234567890b        123456789012345678901234567890
+1234567890123456789012345678901 -       a1234567890123456789012345678901b       1234567890123456789012345678901
+12345678901234567890123456789012        -       a12345678901234567890123456789012b      12345678901234567890123456789012
+123456789012345678901234567890123       -       a123456789012345678901234567890123b     123456789012345678901234567890123
+# and one really big one, beyond any plausible word width
+1234567890123456789012345678901234567890123456789012345678901234567890  -       a1234567890123456789012345678901234567890123456789012345678901234567890b        1234567890123456789012345678901234567890123456789012345678901234567890
+# fish for problems as brackets go past 8
+[ab][cd][ef][gh][ij][kl][mn]    -       xacegikmoq      acegikm
+[ab][cd][ef][gh][ij][kl][mn][op]        -       xacegikmoq      acegikmo
+[ab][cd][ef][gh][ij][kl][mn][op][qr]    -       xacegikmoqy     acegikmoq
+[ab][cd][ef][gh][ij][kl][mn][op][q]     -       xacegikmoqy     acegikmoq
+
+# subtleties of matching
+abc             &       xabcy   abc
+a\(b\)?c\1d     b       acd
+aBc             i       Abc     Abc
+a[Bc]*d         i       abBCcd  abBCcd
+0[[:upper:]]1   &i      0a1     0a1
+0[[:lower:]]1   &i      0A1     0A1
+a[^b]c          &i      abc
+a[^b]c          &i      aBc
+a[^b]c          &i      adc     adc
+[a]b[c]         -       abc     abc
+[a]b[a]         -       aba     aba
+[abc]b[abc]     -       abc     abc
+[abc]b[abd]     -       abd     abd
+a(b?c)+d        -       accd    accd
+(wee|week)(knights|night)       -       weeknights      weeknights
+(we|wee|week|frob)(knights|night|day)   -       weeknights      weeknights
+a[bc]d          -       xyzaaabcaababdacd       abd
+a[ab]c          -       aaabc   abc
+abc             s       abc     abc
+a*              &       b       @b
+
+# Let's have some fun -- try to match a C comment.
+# first the obvious, which looks okay at first glance...
+/\*.*\*/        -       /*x*/   /*x*/
+# but...
+/\*.*\*/        -       /*x*/y/*z*/     /*x*/y/*z*/
+# okay, we must not match */ inside; try to do that...
+/\*([^*]|\*[^/])*\*/    -       /*x*/   /*x*/
+/\*([^*]|\*[^/])*\*/    -       /*x*/y/*z*/     /*x*/
+# but...
+/\*([^*]|\*[^/])*\*/    -       /*x**/y/*z*/    /*x**/y/*z*/
+# and a still fancier version, which does it right (I think)...
+/\*([^*]|\*+[^*/])*\*+/ -       /*x*/   /*x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x*/y/*z*/     /*x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x**/y/*z*/    /*x**/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x****/y/*z*/  /*x****/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x**x*/y/*z*/  /*x**x*/
+/\*([^*]|\*+[^*/])*\*+/ -       /*x***x/y/*z*/  /*x***x/y/*z*/
+
+# subexpressions
+a(b)(c)d        -       abcd    abcd    b,c
+a(((b)))c       -       abc     abc     b,b,b
+a(b|(c))d       -       abd     abd     b,-
+a(b*|c|e)d      -       abbd    abbd    bb
+a(b*|c|e)d      -       acd     acd     c
+a(b*|c|e)d      -       ad      ad      @d
+a(b?)c          -       abc     abc     b
+a(b?)c          -       ac      ac      @c
+a(b+)c          -       abc     abc     b
+a(b+)c          -       abbbc   abbbc   bbb
+a(b*)c          -       ac      ac      @c
+(a|ab)(bc([de]+)f|cde)  -       abcdef  abcdef  a,bcdef,de
+# the regression tester only asks for 9 subexpressions
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)k   -       abcdefghijk     abcdefghijk     b,c,d,e,f,g,h,i,j
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l        -       abcdefghijkl    abcdefghijkl    b,c,d,e,f,g,h,i,j,k
+a([bc]?)c       -       abc     abc     b
+a([bc]?)c       -       ac      ac      @c
+a([bc]+)c       -       abc     abc     b
+a([bc]+)c       -       abcc    abcc    bc
+a([bc]+)bc      -       abcbc   abcbc   bc
+a(bb+|b)b       -       abb     abb     b
+a(bbb+|bb+|b)b  -       abb     abb     b
+a(bbb+|bb+|b)b  -       abbb    abbb    bb
+a(bbb+|bb+|b)bb -       abbb    abbb    b
+(.*).*          -       abcdef  abcdef  abcdef
+(a*)*           -       bc      @b      @b
+
+# do we get the right subexpression when it is used more than once?
+a(b|c)*d        -       ad      ad      -
+a(b|c)*d        -       abcd    abcd    c
+a(b|c)+d        -       abd     abd     b
+a(b|c)+d        -       abcd    abcd    c
+a(b|c?)+d       -       ad      ad      @d
+a(b|c?)+d       -       abcd    abcd    @d
+a(b|c){0,0}d    -       ad      ad      -
+a(b|c){0,1}d    -       ad      ad      -
+a(b|c){0,1}d    -       abd     abd     b
+a(b|c){0,2}d    -       ad      ad      -
+a(b|c){0,2}d    -       abcd    abcd    c
+a(b|c){0,}d     -       ad      ad      -
+a(b|c){0,}d     -       abcd    abcd    c
+a(b|c){1,1}d    -       abd     abd     b
+a(b|c){1,1}d    -       acd     acd     c
+a(b|c){1,2}d    -       abd     abd     b
+a(b|c){1,2}d    -       abcd    abcd    c
+a(b|c){1,}d     -       abd     abd     b
+a(b|c){1,}d     -       abcd    abcd    c
+a(b|c){2,2}d    -       acbd    acbd    b
+a(b|c){2,2}d    -       abcd    abcd    c
+a(b|c){2,4}d    -       abcd    abcd    c
+a(b|c){2,4}d    -       abcbd   abcbd   b
+a(b|c){2,4}d    -       abcbcd  abcbcd  c
+a(b|c){2,}d     -       abcd    abcd    c
+a(b|c){2,}d     -       abcbd   abcbd   b
+a(b+|((c)*))+d  -       abd     abd     @d,@d,-
+a(b+|((c)*))+d  -       abcd    abcd    @d,@d,-
+
+# check out the STARTEND option
+[abc]           &#      a(b)c   b
+[abc]           &#      a(d)c
+[abc]           &#      a(bc)d  b
+[abc]           &#      a(dc)d  c
+.               &#      a()c
+b.*c            &#      b(bc)c  bc
+b.*             &#      b(bc)c  bc
+.*c             &#      b(bc)c  bc
+
+# plain strings, with the NOSPEC flag
+abc             m       abc     abc
+abc             m       xabcy   abc
+abc             m       xyz
+a*b             m       aba*b   a*b
+a*b             m       ab
+""              mC      EMPTY
+
+# cases involving NULs
+aZb             &       a       a
+aZb             &p      a
+aZb             &p#     (aZb)   aZb
+aZ*b            &p#     (ab)    ab
+a.b             &#      (aZb)   aZb
+a.*             &#      (aZb)c  aZb
+
+# word boundaries (ick)
+[[:<:]]a        &       a       a
+[[:<:]]a        &       ba
+[[:<:]]a        &       -a      a
+a[[:>:]]        &       a       a
+a[[:>:]]        &       ab
+a[[:>:]]        &       a-      a
+[[:<:]]a.c[[:>:]]       &       axcd-dayc-dazce-abc     abc
+[[:<:]]a.c[[:>:]]       &       axcd-dayc-dazce-abc-q   abc
+[[:<:]]a.c[[:>:]]       &       axc-dayc-dazce-abc      axc
+[[:<:]]b.c[[:>:]]       &       a_bxc-byc_d-bzc-q       bzc
+[[:<:]].x..[[:>:]]      &       y_xa_-_xb_y-_xc_-axdc   _xc_
+[[:<:]]a_b[[:>:]]       &       x_a_b
+
+# past problems, and suspected problems
+(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A])   -       A1      A1
+abcdefghijklmnop        i       abcdefghijklmnop        abcdefghijklmnop
+abcdefghijklmnopqrstuv  i       abcdefghijklmnopqrstuv  abcdefghijklmnopqrstuv
+(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN])     -       CC11    CC11
+CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a    -       CC11    CC11
+Char \([a-z0-9_]*\)\[.* b       Char xyz[k      Char xyz[k      xyz
+a?b     -       ab      ab
+-\{0,1\}[0-9]*$ b       -5      -5
+
diff --git a/src/regress/lib/libc/setjmp-signal/Makefile b/src/regress/lib/libc/setjmp-signal/Makefile
new file mode 100644
index 0000000000..a9649a8abe
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2002/07/31 05:18:24 art Exp $
+
+PROG=   setjmp-signal
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp-signal/setjmp-signal.c b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
new file mode 100644
index 0000000000..310e4052ef
--- /dev/null
+++ b/src/regress/lib/libc/setjmp-signal/setjmp-signal.c
@@ -0,0 +1,26 @@
+/*      $OpenBSD: setjmp-signal.c,v 1.3 2003/01/03 20:46:05 miod Exp $  */
+/*
+ *      Written by Artur Grabowski <art@openbsd.org> 2002 Public Domain.
+ */
+
+#include <setjmp.h>
+#include <signal.h>
+
+jmp_buf jb;
+
+void
+segv_handler(int signum)
+{
+        longjmp(jb, 1);
+}
+
+int
+main()
+{
+        signal(SIGSEGV, segv_handler);
+        if (setjmp(jb) == 0) {
+                *((int *)0L) = 0;
+                return (1);
+        }
+        return (0);
+}
diff --git a/src/regress/lib/libc/setjmp/Makefile b/src/regress/lib/libc/setjmp/Makefile
new file mode 100644
index 0000000000..fc68e8d44c
--- /dev/null
+++ b/src/regress/lib/libc/setjmp/Makefile
@@ -0,0 +1,9 @@
+#       $OpenBSD: Makefile,v 1.3 2002/01/01 23:00:51 art Exp $
+#       $NetBSD: Makefile,v 1.2 1995/04/20 22:40:13 cgd Exp $
+
+PROG=   setjmptest
+SRCS=   jmptest.c
+
+CFLAGS+= -DTEST_SETJMP
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/setjmp/jmptest.c b/src/regress/lib/libc/setjmp/jmptest.c
new file mode 100644
index 0000000000..9512c9ee34
--- /dev/null
+++ b/src/regress/lib/libc/setjmp/jmptest.c
@@ -0,0 +1,136 @@
+/*      $OpenBSD: jmptest.c,v 1.7 2003/09/02 23:52:16 david Exp $       */
+/*      $NetBSD: jmptest.c,v 1.2 1995/01/01 20:55:35 jtc Exp $  */
+
+/*
+ * Copyright (c) 1994 Christopher G. Demetriou
+ * All rights reserved.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou
+ *      for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <sys/types.h>
+#include <err.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#if (TEST_SETJMP + TEST_U_SETJMP + TEST_SIGSETJMP) != 1
+#error one of TEST_SETJMP, TEST_U_SETJMP, or TEST_SIGSETJMP must be defined
+#endif
+
+#ifdef TEST_SETJMP
+#define BUF             jmp_buf
+#define SET(b, m)       setjmp(b)
+#define JMP(b, v)       longjmp(b, v)
+#endif
+
+#ifdef TEST_U_SETJMP
+#define BUF             jmp_buf
+#define SET(b, m)       _setjmp(b)
+#define JMP(b, v)       _longjmp(b, v)
+#endif
+
+#ifdef TEST_SIGSETJMP
+#define BUF             sigjmp_buf
+#define SET(b, m)       sigsetjmp(b, m)
+#define JMP(b, v)       siglongjmp(b, v)
+#endif
+
+int expectsignal;
+
+static void
+aborthandler(int signo)
+{
+
+        if (expectsignal)
+                _exit(0);
+        else {
+                warnx("kill(SIGABRT) succeeded");
+                _exit(1);
+        }
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct sigaction sa;
+        BUF jb;
+        sigset_t ss;
+        int i, x;
+
+        i = getpid();
+
+#ifdef TEST_SETJMP
+        expectsignal = 0;
+#endif
+#ifdef TEST_U_SETJMP
+        expectsignal = 1;
+#endif
+#ifdef TEST_SIGSETJMP
+        if (argc != 2 ||
+            (strcmp(argv[1], "save") && strcmp(argv[1], "nosave"))) {
+                fprintf(stderr, "usage: %s [save|nosave]\n", argv[0]);
+                exit(1);
+        }
+        expectsignal = (strcmp(argv[1], "save") != 0);
+#endif
+
+        sa.sa_handler = aborthandler;
+        sigemptyset(&sa.sa_mask);
+        sa.sa_flags = 0;
+        if (sigaction(SIGABRT, &sa, NULL) == -1)
+                err(1, "sigaction failed");
+
+        if (sigemptyset(&ss) == -1)
+                err(1, "sigemptyset failed");
+        if (sigaddset(&ss, SIGABRT) == -1)
+                err(1, "sigaddset failed");
+        if (sigprocmask(SIG_BLOCK, &ss, NULL) == -1)
+                err(1, "sigprocmask (1) failed");
+
+        x = SET(jb, !expectsignal);
+        if (x != 0) {
+                if (x != i)
+                        errx(1, "setjmp returned wrong value");
+
+                kill(i, SIGABRT);
+                if (expectsignal)
+                        errx(1, "kill(SIGABRT) failed");
+                else
+                        exit(0);
+        }
+
+        if (sigprocmask(SIG_UNBLOCK, &ss, NULL) == -1)
+                err(1, "sigprocmask (2) failed");
+
+        JMP(jb, i);
+
+        errx(1, "jmp failed");
+}
diff --git a/src/regress/lib/libc/sigreturn/Makefile b/src/regress/lib/libc/sigreturn/Makefile
new file mode 100644
index 0000000000..9891ba9e05
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/Makefile
@@ -0,0 +1,18 @@
+# $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
+
+PROG=   sigret
+
+DEBUG+= -ggdb
+
+REGRESS_TARGETS+= sigret-normal sigret-indirect sigret-altstack
+
+sigret-normal: ${PROG}
+        ./${PROG}
+
+sigret-indirect: ${PROG}
+        ./${PROG} -i
+
+sigret-altstack: ${PROG}
+        ./${PROG} -a
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sigreturn/sigret.c b/src/regress/lib/libc/sigreturn/sigret.c
new file mode 100644
index 0000000000..72945fa503
--- /dev/null
+++ b/src/regress/lib/libc/sigreturn/sigret.c
@@ -0,0 +1,181 @@
+/*
+ * $OpenBSD: sigret.c,v 1.5 2003/07/31 21:48:04 deraadt Exp $
+ *
+ * Public Domain
+ *
+ * Playing games with sigreturn.   Check if calling sigreturn from a
+ * signal handler screws anything up.
+ *
+ * Run with:
+ *      -a:     use an alternate signal stack
+ *
+ *      -b:     call sigreturn from outside of a signal handler
+ *              An error is OK
+ *
+ *      -c:     clobber the sigcontext before calling sigreturn
+ *              the program should die
+ *
+ *      -f:     don't use sigreturn -- fall through the signal handler
+ *              -c, and -i options ignored when used
+ *
+ *      -i:     call sigreturn from a function called by the signal handler
+ *
+ */
+
+#include <sys/time.h>
+
+#include <err.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * sigalarm occurs 50 times/second.  Stop running after 10 seconds
+ * (100 interrupts).
+ */
+#define MAX_INTERRUPTS  500
+
+int failed;
+int altstack;
+int badcall;
+int clobbercall;
+int fallthru;
+int indirect;
+
+volatile int count;
+struct sigcontext gscp;
+int gscp_loaded;
+
+static void
+usage(const char * err, ...)
+{
+        extern const char * __progname;
+
+        if (err) {
+                va_list ap;
+                va_start(ap, err);
+                vwarnx(err, ap);
+                va_end(ap);
+        }
+        fprintf(stderr, "usage: %s [-abcfi]\n", __progname);
+        exit(1);
+}
+
+static void
+indirect_return(struct sigcontext * scp)
+{
+        sigreturn(scp);
+}
+
+static void
+sig_handler(int sig, siginfo_t *blah, void *x)
+{
+        struct sigcontext * scp = x;
+
+        count++;
+
+        if (!fallthru) {
+                if (clobbercall)
+                        memset(scp, 0, sizeof *scp);
+                if (indirect)
+                        indirect_return(scp);
+                else if (badcall) {
+                        gscp = *scp;
+                        gscp_loaded = 1;
+                } else
+                        sigreturn(scp);
+        }
+}
+
+static void
+test2(char *fmt)
+{
+        char *ofmt = fmt;
+
+        if (gscp_loaded) {
+                gscp_loaded = 0;
+                sigreturn(&gscp);
+        }
+
+        for (; *fmt; fmt++)
+          switch (*fmt) {
+          case 'i':
+          case 'c':
+          case 'l':
+          case 'p':
+            break;
+          default:
+            failed = 1;
+            fprintf(stderr,
+                    "unexpected character 0x%02x `%c' in %s: count %d\n",
+                    *fmt, *fmt, ofmt, count);
+          }
+}
+
+int
+main(int argc, char * argv[])
+{
+        extern char *optarg;
+        extern int optind;
+
+        int opt;
+
+        struct sigaction act;
+        struct sigaltstack ss;
+
+        while ((opt = getopt(argc, argv, "abcfi")) != -1) {
+                switch (opt) {
+                case 'a':
+                        /* use sigaltstack */
+                        altstack = 1;
+                        break;
+                case 'b':
+                        /* call outside of sig_handler */
+                        badcall = 1;
+                        break;
+                case 'c':
+                        /* force error by munging sigcontext */
+                        clobbercall = 1;
+                        break;
+                case 'f':
+                        /* don't use sigreturn */
+                        fallthru = 1;
+                        break;
+                case 'i':
+                        /* call sigreturn indirectly */
+                        indirect = 1;
+                        break;
+                }
+        }
+
+        /* make sure there is no other cruft left on the command line */
+        if (optind != argc)
+                usage("unknown argument -- %s", argv[ optind ]);
+
+        if (altstack) {
+                if ((ss.ss_sp = malloc(SIGSTKSZ)) == NULL)
+                        errx(1, "ss_sp malloc");
+
+                ss.ss_size = SIGSTKSZ;
+                ss.ss_flags = 0;
+                if (sigaltstack(&ss,0) == -1)
+                        err(1, "sigaltstack");
+        }
+
+        sigfillset(&act.sa_mask);
+        act.sa_sigaction = sig_handler;
+        act.sa_flags = SA_RESTART;
+        if (altstack)
+                act.sa_flags |= SA_ONSTACK;
+        sigaction(SIGALRM, &act, NULL);
+
+        ualarm(10000, 10000);
+
+        while (count < MAX_INTERRUPTS)
+                test2("iclp");
+
+        return failed;
+}
diff --git a/src/regress/lib/libc/sigsetjmp/Makefile b/src/regress/lib/libc/sigsetjmp/Makefile
new file mode 100644
index 0000000000..f88bea3b47
--- /dev/null
+++ b/src/regress/lib/libc/sigsetjmp/Makefile
@@ -0,0 +1,19 @@
+#       $OpenBSD: Makefile,v 1.5 2002/09/02 20:01:43 avsm Exp $
+
+PROG=   sigsetjmptest
+SRCS=   jmptest.c
+
+CFLAGS+= -DTEST_SIGSETJMP
+
+.PATH:  ${.CURDIR}/../setjmp
+
+REGRESS_TARGETS=sigsetjmp-save sigsetjmp-nosave
+
+sigsetjmp-save: ${PROG}
+        ./${PROG} save
+sigsetjmp-nosave: ${PROG}
+        ./${PROG} nosave
+
+.PHONY: ${REGRESS_TARGETS}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sprintf/Makefile b/src/regress/lib/libc/sprintf/Makefile
new file mode 100644
index 0000000000..47bab9cdd3
--- /dev/null
+++ b/src/regress/lib/libc/sprintf/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2003/05/15 04:23:49 deraadt Exp $
+
+NOMAN=
+PROG=sprintf_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+
+run-regress-atexit_test: ${PROG}
+        ./${PROG}
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/sprintf/sprintf_test.c b/src/regress/lib/libc/sprintf/sprintf_test.c
new file mode 100644
index 0000000000..61c58f2f09
--- /dev/null
+++ b/src/regress/lib/libc/sprintf/sprintf_test.c
@@ -0,0 +1,102 @@
+/*      $OpenBSD: sprintf_test.c,v 1.4 2004/09/18 19:31:32 otto Exp $ */
+
+/*
+ * Copyright (c) 2003 Theo de Raadt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    - Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    - 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT HOLDERS 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 <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+char correct[] =
+        "|xx 01 02 03 04\n"
+        "|xx 05 06 07 08\n"
+        "|xx 09 10 11 12\n"
+        "|xx 13 14 15 16\n"
+        "|xx 17 18 19 20\n"
+        "|xx 21 22 23 24\n"
+        "|xx 25 26 27 28\n"
+        "|xx 29 30 31 32\n"
+        "|xx 33 34 35 36\n"
+        "|xx 37 38 39 40\n"
+        "|xx 41 42 43 44\n"
+        "|xx 45 -1 1 -1 1\n";
+
+char correct2[] =
+        "1 0 -1 1 1 2 1 3 -1 4 1  \n"
+        "1 -1 1 1 -1 1  \n";
+
+int
+main(int argc, char *argv[])
+{
+        char buf[1024];
+        size_t sz1, sz2, sz3, sz4;
+        ptrdiff_t p1, p2, p3, p4;
+
+        /* Test positional arguments */
+        snprintf(buf, sizeof buf,
+            "|xx %1$s %2$s %3$s %4$s\n"
+            "|xx %5$s %6$s %7$s %8$s\n"
+            "|xx %9$s %10$s %11$s %12$s\n"
+            "|xx %13$s %14$s %15$s %16$s\n"
+            "|xx %17$s %18$s %19$s %20$s\n"
+            "|xx %21$s %22$s %23$s %24$s\n"
+            "|xx %25$s %26$s %27$s %28$s\n"
+            "|xx %29$s %30$s %31$s %32$s\n"
+            "|xx %33$s %34$s %35$s %36$s\n"
+            "|xx %37$s %38$s %39$s %40$s\n"
+            "|xx %41$s %42$s %43$s %44$s\n"
+            "|xx %45$d %46$ld %47$lld %48$d %49$lld\n",
+            "01", "02", "03", "04", "05", "06",
+            "07", "08", "09", "10", "11", "12",
+            "13", "14", "15", "16", "17", "18",
+            "19", "20", "21", "22", "23", "24",
+            "25", "26", "27", "28", "29", "30",
+            "31", "32", "33", "34", "35", "36",
+            "37", "38", "39", "40", "41", "42",
+            "43", "44", 45, -1L, 1LL, -1, 1LL
+            );
+
+        if (strcmp(buf, correct) != 0)
+                exit(1);
+
+        sz1 = (size_t)1;
+        sz2 = (size_t)-1;
+        p1 = (ptrdiff_t)1;
+        p2 = (ptrdiff_t)-1;
+        snprintf(buf, sizeof buf,
+                "%zx %d %zd %d %zu %d %tx %d %td %d %tu %zn %tn\n"
+                "%1$zx %3$zd %5$zu %7$tx %9$td %11$tu %14$zn %15$tn\n",
+                sz1, 0, sz2, 1, sz1, 2, p1, 3, p2, 4, p1, &sz3, &p3, &sz4, &p4);
+        if (strcmp(buf, correct2) != 0 || sz3 != 24 || p3 != 25 ||
+            sz4 != 40 || p4 != 41)
+                exit(1);
+        exit(0);
+}
diff --git a/src/regress/lib/libc/strerror/Makefile b/src/regress/lib/libc/strerror/Makefile
new file mode 100644
index 0000000000..448b6da903
--- /dev/null
+++ b/src/regress/lib/libc/strerror/Makefile
@@ -0,0 +1,12 @@
+#       $OpenBSD: Makefile,v 1.1 2004/04/30 17:15:12 espie Exp $
+
+NOMAN=
+PROG=strerror_test
+CPPFLAGS+=-I${.CURDIR}/../../../../lib/libc
+CLEANFILES+= invalid.out valid.out
+
+run-regress-strerror_test: ${PROG}
+        ./${PROG} >${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strerror/strerror_test.c b/src/regress/lib/libc/strerror/strerror_test.c
new file mode 100644
index 0000000000..700080cd3e
--- /dev/null
+++ b/src/regress/lib/libc/strerror/strerror_test.c
@@ -0,0 +1,71 @@
+/* $OpenBSD: strerror_test.c,v 1.4 2005/05/13 07:06:20 otto Exp $ */
+/*
+ * Copyright (c) 2004 Marc Espie <espie@cvs.openbsd.org>
+ *
+ * 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <errno.h>
+
+void
+check_strerror_r(int val)
+{
+        char buffer[NL_TEXTMAX + 1];
+        int i, r;
+
+        memset(buffer, 'X', sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = '\0';
+        (void)strerror_r(val, NULL, 0); /* XXX */
+        for (i = 0; i < 25; i++) {
+                r = strerror_r(val, buffer, i);
+                printf("%d %d %zu: %s\n", i, r, strlen(buffer), buffer);
+        }
+}
+
+void
+check_strsignal(int val)
+{
+        char buffer[NL_TEXTMAX + 1];
+        int i, r;
+
+        memset(buffer, 'X', sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = '\0';
+        (void)__strsignal(val, buffer);
+        printf("%s\n", buffer);
+}
+
+int 
+main()
+{
+        printf("%s\n", strerror(21345));
+        printf("%s\n", strerror(-21345));
+        printf("%s\n", strerror(0));
+        printf("%s\n", strerror(INT_MAX));
+        printf("%s\n", strerror(INT_MIN));
+        printf("%s\n", strerror(EPERM));
+        check_strerror_r(EPERM);
+        check_strerror_r(21345);
+        check_strsignal(-1);
+        check_strsignal(0);
+        check_strsignal(10);
+        check_strsignal(NSIG-1);
+        check_strsignal(NSIG);
+        check_strsignal(100);
+        check_strsignal(INT_MAX);
+        check_strsignal(INT_MIN);
+        check_strsignal(UINT_MAX);
+        return 0;
+}
diff --git a/src/regress/lib/libc/strerror/valid.ok b/src/regress/lib/libc/strerror/valid.ok
new file mode 100644
index 0000000000..ee602a4b13
--- /dev/null
+++ b/src/regress/lib/libc/strerror/valid.ok
@@ -0,0 +1,65 @@
+Unknown error: 21345
+Unknown error: -21345
+Undefined error: 0
+Unknown error: 2147483647
+Unknown error: -2147483648
+Operation not permitted
+0 34 255: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+1 34 0: 
+2 34 1: O
+3 34 2: Op
+4 34 3: Ope
+5 34 4: Oper
+6 34 5: Opera
+7 34 6: Operat
+8 34 7: Operati
+9 34 8: Operatio
+10 34 9: Operation
+11 34 10: Operation 
+12 34 11: Operation n
+13 34 12: Operation no
+14 34 13: Operation not
+15 34 14: Operation not 
+16 34 15: Operation not p
+17 34 16: Operation not pe
+18 34 17: Operation not per
+19 34 18: Operation not perm
+20 34 19: Operation not permi
+21 34 20: Operation not permit
+22 34 21: Operation not permitt
+23 34 22: Operation not permitte
+24 0 23: Operation not permitted
+0 34 255: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+1 34 0: 
+2 34 1: U
+3 34 2: Un
+4 34 3: Unk
+5 34 4: Unkn
+6 34 5: Unkno
+7 34 6: Unknow
+8 34 7: Unknown
+9 34 8: Unknown 
+10 34 9: Unknown e
+11 34 10: Unknown er
+12 34 11: Unknown err
+13 34 12: Unknown erro
+14 34 13: Unknown error
+15 34 14: Unknown error:
+16 34 15: Unknown error: 
+17 34 15: Unknown error: 
+18 34 15: Unknown error: 
+19 34 15: Unknown error: 
+20 34 15: Unknown error: 
+21 22 20: Unknown error: 21345
+22 22 20: Unknown error: 21345
+23 22 20: Unknown error: 21345
+24 22 20: Unknown error: 21345
+Unknown signal: 4294967295
+Signal 0
+Bus error
+User defined signal 2
+Unknown signal: 32
+Unknown signal: 100
+Unknown signal: 2147483647
+Unknown signal: 2147483648
+Unknown signal: 4294967295
diff --git a/src/regress/lib/libc/strtonum/Makefile b/src/regress/lib/libc/strtonum/Makefile
new file mode 100644
index 0000000000..e0e8ecd139
--- /dev/null
+++ b/src/regress/lib/libc/strtonum/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/08/03 20:38:36 otto Exp $
+
+PROG=   strtonumtest
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/strtonum/strtonumtest.c b/src/regress/lib/libc/strtonum/strtonumtest.c
new file mode 100644
index 0000000000..7e82a007fe
--- /dev/null
+++ b/src/regress/lib/libc/strtonum/strtonumtest.c
@@ -0,0 +1,64 @@
+/*      $OpenBSD: strtonumtest.c,v 1.1 2004/08/03 20:38:36 otto Exp $   */
+/*
+ * Copyright (c) 2004 Otto Moerbeek <otto@drijf.net>
+ *
+ * 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int fail;
+
+void
+test(const char *p, long long lb, long long ub, int ok)
+{
+        long long val;
+        const char *q;
+
+        val = strtonum(p, lb, ub, &q);
+        if (ok && q != NULL) {
+                fprintf(stderr, "%s [%lld-%lld] ", p, lb, ub);
+                fprintf(stderr, "NUMBER NOT ACCEPTED %s\n", q);
+                fail = 1;
+        } else if (!ok && q == NULL) {
+                fprintf(stderr, "%s [%lld-%lld] %lld ", p, lb, ub, val);
+                fprintf(stderr, "NUMBER ACCEPTED\n");
+                fail = 1;
+        }
+}
+
+int main(int argc, char *argv[])
+{
+        test("1", 0, 10, 1);
+        test("0", -2, 5, 1);
+        test("0", 2, 5, 0);
+        test("0", 2, LLONG_MAX, 0);
+        test("-2", 0, LLONG_MAX, 0);
+        test("0", -5, LLONG_MAX, 1);
+        test("-3", -3, LLONG_MAX, 1);
+        test("-9223372036854775808", LLONG_MIN, LLONG_MAX, 1);
+        test("9223372036854775807", LLONG_MIN, LLONG_MAX, 1);
+        test("-9223372036854775809", LLONG_MIN, LLONG_MAX, 0);
+        test("9223372036854775808", LLONG_MIN, LLONG_MAX, 0);
+        test("1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0);
+        test("-1000000000000000000000000", LLONG_MIN, LLONG_MAX, 0);
+        test("-2", 10, -1, 0);
+        test("-2", -10, -1, 1);
+        test("-20", -10, -1, 0);
+        test("20", -10, -1, 0);
+
+        return (fail);
+}
+
diff --git a/src/regress/lib/libc/telldir/Makefile b/src/regress/lib/libc/telldir/Makefile
new file mode 100644
index 0000000000..0927779663
--- /dev/null
+++ b/src/regress/lib/libc/telldir/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2006/03/25 20:27:11 otto Exp $
+
+PROG=   telldir
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/telldir/telldir.c b/src/regress/lib/libc/telldir/telldir.c
new file mode 100644
index 0000000000..fc1ca3e891
--- /dev/null
+++ b/src/regress/lib/libc/telldir/telldir.c
@@ -0,0 +1,106 @@
+/*      $OpenBSD: telldir.c,v 1.2 2006/04/01 18:24:53 otto Exp $        */
+
+/*      Written by Otto Moerbeek, 2006,  Public domain. */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <err.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+
+#define NFILES 1000
+
+void
+createfiles(void)
+{
+        int i, fd;
+        char file[PATH_MAX];
+
+        mkdir("d", 0755);
+        for (i = 0; i < NFILES; i++) {
+                snprintf(file, sizeof file, "d/%d", i);
+                if ((fd = open(file, O_CREAT | O_WRONLY, 0600)) == -1)
+                        err(1, "open %s", file);
+                close(fd);
+        }
+}
+
+void
+delfiles(void)
+{
+        DIR *dp;
+        struct dirent *f;
+        char file[PATH_MAX];
+
+        dp = opendir("d");
+        if (dp == NULL)
+                err(1, "opendir");
+        while (f = readdir(dp)) {
+                if (strcmp(f->d_name, ".") == 0 ||
+                    strcmp(f->d_name, "..") == 0)
+                        continue;
+                snprintf(file, sizeof file, "d/%s", f->d_name);
+                if (unlink(file) == -1)
+                        err(1, "unlink %s", f->d_name);
+        }
+        closedir(dp);
+        if (rmdir("d") == -1)
+                err(1, "rmdir");
+}
+
+void
+loop(DIR *dp, int i)
+{
+        struct dirent *f;
+        char file[PATH_MAX];
+        long pos, remember = -1;
+
+        rewinddir(dp);
+        snprintf(file, sizeof file, "%d", i);
+        for (;;) {
+                pos = telldir(dp);
+                f = readdir(dp);
+                if (f == NULL)
+                        break;
+                if (strcmp(file, f->d_name) == 0)
+                        remember = pos;
+        }
+        if (remember == -1)
+                errx(1, "remember");
+        seekdir(dp, remember);
+        if (telldir(dp) != remember)
+                errx(1, "tell after seek");
+        if (telldir(dp) != remember)
+                errx(1, "tell after tell");
+        f = readdir(dp);
+        if (f == NULL)
+                err(1, "seek to %s %ld", file, remember);
+
+        if (strcmp(f->d_name, file) != 0)
+                err(1, "name mismatch: %s != %s\n", f->d_name, file);
+}
+
+int
+main(void)
+{
+        DIR *dp;
+        int i;
+
+        createfiles();
+
+        dp = opendir("d");
+        if (dp == NULL)
+                err(1, "opendir");
+
+        for (i = 0; i < NFILES; i++)
+                loop(dp, (i + NFILES/2) % NFILES);
+
+        closedir(dp);
+        delfiles();
+        return 0;
+}
diff --git a/src/regress/lib/libc/time/Makefile b/src/regress/lib/libc/time/Makefile
new file mode 100644
index 0000000000..28b5556027
--- /dev/null
+++ b/src/regress/lib/libc/time/Makefile
@@ -0,0 +1,5 @@
+#       $OpenBSD: Makefile,v 1.1 2004/01/20 16:47:55 millert Exp $
+
+SUBDIR+=strptime
+
+.include <bsd.subdir.mk>
diff --git a/src/regress/lib/libc/time/strptime/Makefile b/src/regress/lib/libc/time/strptime/Makefile
new file mode 100644
index 0000000000..f2c9ebaf2c
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/Makefile
@@ -0,0 +1,12 @@
+#       $OpenBSD: Makefile,v 1.2 2004/01/21 18:13:48 david Exp $
+
+PROG=           strptime_test
+SRCS=           main.c
+CLEANFILES+=    got
+
+REGRESS_TARGETS=do-reg
+do-reg: ${PROG}
+        ./${PROG} < ${.CURDIR}/tests > got
+        diff ${.CURDIR}/expected got
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/time/strptime/expected b/src/regress/lib/libc/time/strptime/expected
new file mode 100644
index 0000000000..d038d319af
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/expected
@@ -0,0 +1,346 @@
+--- ctime --- 1
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- ctime --- 2
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- ctime --- 3
+succeeded
+46 27 23 20 0 98 2 -1
+
+--- %a --- 1
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %a --- 2
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %a --- 3
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %a --- 4
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %a --- 5
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %a --- 6
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %a --- 7
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %a --- 8
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %a --- 9
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %a --- 10
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %a --- 11
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %a --- 12
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %a --- 13
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %a --- 14
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %a --- 15
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+urn
+
+--- %a --- 16
+failed
+--- %A --- 1
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %A --- 2
+succeeded
+-1 -1 -1 -1 -1 -1 0 -1
+
+--- %A --- 3
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %A --- 4
+succeeded
+-1 -1 -1 -1 -1 -1 1 -1
+
+--- %A --- 5
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %A --- 6
+succeeded
+-1 -1 -1 -1 -1 -1 2 -1
+
+--- %A --- 7
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %A --- 8
+succeeded
+-1 -1 -1 -1 -1 -1 3 -1
+
+--- %A --- 9
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %A --- 10
+succeeded
+-1 -1 -1 -1 -1 -1 4 -1
+
+--- %A --- 11
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %A --- 12
+succeeded
+-1 -1 -1 -1 -1 -1 5 -1
+
+--- %A --- 13
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %A --- 14
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+
+--- %A --- 15
+succeeded
+-1 -1 -1 -1 -1 -1 6 -1
+urn
+
+--- %A --- 16
+failed
+--- %b --- 1
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %b --- 2
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %b --- 3
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %b --- 4
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %b --- 5
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %b --- 6
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %b --- 7
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %b --- 8
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %b --- 9
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+
+--- %b --- 10
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %b --- 11
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %b --- 12
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %b --- 13
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %b --- 14
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %b --- 15
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %b --- 16
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %b --- 17
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %b --- 18
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %b --- 19
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %b --- 20
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %b --- 21
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %b --- 22
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %b --- 23
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %b --- 25
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+or
+
+--- %b --- 24
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+s
+
+--- %b --- 26
+failed
+--- %B --- 1
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %B --- 2
+succeeded
+-1 -1 -1 -1 0 -1 -1 -1
+
+--- %B --- 3
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %B --- 4
+succeeded
+-1 -1 -1 -1 1 -1 -1 -1
+
+--- %B --- 5
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %B --- 6
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+
+--- %B --- 7
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %B --- 8
+succeeded
+-1 -1 -1 -1 3 -1 -1 -1
+
+--- %B --- 9
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+
+--- %B --- 10
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %B --- 11
+succeeded
+-1 -1 -1 -1 5 -1 -1 -1
+
+--- %B --- 12
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %B --- 13
+succeeded
+-1 -1 -1 -1 6 -1 -1 -1
+
+--- %B --- 14
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %B --- 15
+succeeded
+-1 -1 -1 -1 7 -1 -1 -1
+
+--- %B --- 16
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %B --- 17
+succeeded
+-1 -1 -1 -1 8 -1 -1 -1
+
+--- %B --- 18
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %B --- 19
+succeeded
+-1 -1 -1 -1 9 -1 -1 -1
+
+--- %B --- 20
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %B --- 21
+succeeded
+-1 -1 -1 -1 10 -1 -1 -1
+
+--- %B --- 22
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %B --- 23
+succeeded
+-1 -1 -1 -1 11 -1 -1 -1
+
+--- %B --- 25
+succeeded
+-1 -1 -1 -1 4 -1 -1 -1
+or
+
+--- %B --- 24
+succeeded
+-1 -1 -1 -1 2 -1 -1 -1
+s
+
+--- %B --- 26
+failed
diff --git a/src/regress/lib/libc/time/strptime/main.c b/src/regress/lib/libc/time/strptime/main.c
new file mode 100644
index 0000000000..d1d9c394a5
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/main.c
@@ -0,0 +1,117 @@
+/*      $OpenBSD: main.c,v 1.1 2004/01/20 16:47:56 millert Exp $        */
+/*      $NetBSD: main.c,v 1.4 2002/02/21 07:38:18 itojun Exp $  */
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the NetBSD
+ *      Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+int     main(int, char *[]);
+void    die(void);
+
+void
+die(void)
+{
+
+        if (ferror(stdin))
+                err(1, "fgetln");
+        else
+                errx(1, "input is truncated");
+}
+
+int
+main(int argc, char *argv[])
+{
+        char *p, *title, *buf, *format;
+        size_t len;
+        struct tm tm;
+
+        for (;;) {
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                title = malloc(len + 1);
+                memcpy(title, p, len);
+                title[len] = '\0';
+
+                if (!strcmp(title, "EOF\n"))
+                        return(0);
+                if (title[0] == '#' || title[0] == '\n') {
+                        free(title);
+                        continue;
+                }
+
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                buf = malloc(len + 1);
+                memcpy(buf, p, len);
+                buf[len] = '\0';
+
+                p = fgetln(stdin, &len);
+                if (p == 0)
+                        die();
+                format = malloc(len + 1);
+                memcpy(format, p, len);
+                format[len] = '\0';
+
+                tm.tm_sec = -1;
+                tm.tm_min = -1;
+                tm.tm_hour = -1;
+                tm.tm_mday = -1;
+                tm.tm_mon = -1;
+                tm.tm_year = -1;
+                tm.tm_wday = -1;
+                tm.tm_yday = -1;
+
+                p = strptime(buf, format, &tm);
+
+                printf("%s", title);
+                if (p) {
+                        printf("succeeded\n");
+                        printf("%d %d %d %d %d %d %d %d\n",
+                            tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mday,
+                            tm.tm_mon, tm.tm_year, tm.tm_wday, tm.tm_yday);
+                        printf("%s\n", p);
+                } else {
+                        printf("failed\n");
+                }
+
+                free(title);
+                free(buf);
+                free(format);
+        }
+}
diff --git a/src/regress/lib/libc/time/strptime/tests b/src/regress/lib/libc/time/strptime/tests
new file mode 100644
index 0000000000..d96393b2b7
--- /dev/null
+++ b/src/regress/lib/libc/time/strptime/tests
@@ -0,0 +1,267 @@
+# some intial checks to make sure common things work
+--- ctime --- 1
+Tue Jan 20 23:27:46 1998
+%a %b %d %T %Y
+--- ctime --- 2
+Tue Jan 20 23:27:46 1998
+%a %b %d %H:%M:%S %Y
+--- ctime --- 3
+Tue Jan 20 23:27:46 1998
+%c
+
+# test some valid and invalid day names
+--- %a --- 1
+Sun
+%a
+--- %a --- 2
+Sunday
+%a
+--- %a --- 3
+Mon
+%a
+--- %a --- 4
+Monday
+%a
+--- %a --- 5
+Tue
+%a
+--- %a --- 6
+Tuesday
+%a
+--- %a --- 7
+Wed
+%a
+--- %a --- 8
+Wednesday
+%a
+--- %a --- 9
+Thu
+%a
+--- %a --- 10
+Thursday
+%a
+--- %a --- 11
+Fri
+%a
+--- %a --- 12
+Friday
+%a
+--- %a --- 13
+Sat
+%a
+--- %a --- 14
+Saturday
+%a
+--- %a --- 15
+Saturn
+%a
+--- %a --- 16
+Moon
+%a
+--- %A --- 1
+Sun
+%A
+--- %A --- 2
+Sunday
+%A
+--- %A --- 3
+Mon
+%A
+--- %A --- 4
+Monday
+%A
+--- %A --- 5
+Tue
+%A
+--- %A --- 6
+Tuesday
+%A
+--- %A --- 7
+Wed
+%A
+--- %A --- 8
+Wednesday
+%A
+--- %A --- 9
+Thu
+%A
+--- %A --- 10
+Thursday
+%A
+--- %A --- 11
+Fri
+%A
+--- %A --- 12
+Friday
+%A
+--- %A --- 13
+Sat
+%A
+--- %A --- 14
+Saturday
+%A
+--- %A --- 15
+Saturn
+%A
+--- %A --- 16
+Moon
+%A
+
+# test some valid and invalid month names
+--- %b --- 1
+Jan
+%b
+--- %b --- 2
+January
+%b
+--- %b --- 3
+Feb
+%b
+--- %b --- 4
+February
+%b
+--- %b --- 5
+Mar
+%b
+--- %b --- 6
+March
+%b
+--- %b --- 7
+Apr
+%b
+--- %b --- 8
+April
+%b
+--- %b --- 9
+May
+%b
+--- %b --- 10
+Jun
+%b
+--- %b --- 11
+June
+%b
+--- %b --- 12
+Jul
+%b
+--- %b --- 13
+July
+%b
+--- %b --- 14
+Aug
+%b
+--- %b --- 15
+August
+%b
+--- %b --- 16
+Sep
+%b
+--- %b --- 17
+September
+%b
+--- %b --- 18
+Oct
+%b
+--- %b --- 19
+October
+%b
+--- %b --- 20
+Nov
+%b
+--- %b --- 21
+November
+%b
+--- %b --- 22
+Dec
+%b
+--- %b --- 23
+December
+%b
+--- %b --- 25
+Mayor
+%b
+--- %b --- 24
+Mars
+%b
+--- %b --- 26
+Rover
+%b
+--- %B --- 1
+Jan
+%B
+--- %B --- 2
+January
+%B
+--- %B --- 3
+Feb
+%B
+--- %B --- 4
+February
+%B
+--- %B --- 5
+Mar
+%B
+--- %B --- 6
+March
+%B
+--- %B --- 7
+Apr
+%B
+--- %B --- 8
+April
+%B
+--- %B --- 9
+May
+%B
+--- %B --- 10
+Jun
+%B
+--- %B --- 11
+June
+%B
+--- %B --- 12
+Jul
+%B
+--- %B --- 13
+July
+%B
+--- %B --- 14
+Aug
+%B
+--- %B --- 15
+August
+%B
+--- %B --- 16
+Sep
+%B
+--- %B --- 17
+September
+%B
+--- %B --- 18
+Oct
+%B
+--- %B --- 19
+October
+%B
+--- %B --- 20
+Nov
+%B
+--- %B --- 21
+November
+%B
+--- %B --- 22
+Dec
+%B
+--- %B --- 23
+December
+%B
+--- %B --- 25
+Mayor
+%B
+--- %B --- 24
+Mars
+%B
+--- %B --- 26
+Rover
+%B
+EOF
diff --git a/src/regress/lib/libc/vis/Makefile b/src/regress/lib/libc/vis/Makefile
new file mode 100644
index 0000000000..13e560bbf7
--- /dev/null
+++ b/src/regress/lib/libc/vis/Makefile
@@ -0,0 +1,10 @@
+#       $OpenBSD: Makefile,v 1.1 2005/08/29 18:41:56 otto Exp $
+
+PROG=   vis_test
+CLEANFILES+= valid.out
+
+run-regress-vis_test: ${PROG}
+        ./${PROG} >${.OBJDIR}/valid.out
+        cmp -s ${.OBJDIR}/valid.out ${.CURDIR}/valid.ok
+
+.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/vis/valid.ok b/src/regress/lib/libc/vis/valid.ok
new file mode 100644
index 0000000000..f8c0efa503
--- /dev/null
+++ b/src/regress/lib/libc/vis/valid.ok
@@ -0,0 +1,2 @@
+\^@\^A\^B\^C\^D\^E\^F\^G\^H     
+\^K\^L\^M\^N\^O\^P\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\^?\M^@\M^A\M^B\M^C\M^D\M^E\M^F\M^G\M^H\M^I\M^J\M^K\M^L\M^M\M^N\M^O\M^P\M^Q\M^R\M^S\M^T\M^U\M^V\M^W\M^X\M^Y\M^Z\M^[\M^\\M^]\M^^\M^_\240\M-!\M-"\M-#\M-$\M-%\M-&\M-'\M-(\M-)\M-*\M-+\M-,\M--\M-.\M-/\M-0\M-1\M-2\M-3\M-4\M-5\M-6\M-7\M-8\M-9\M-:\M-;\M-<\M-=\M->\M-?\M-@\M-A\M-B\M-C\M-D\M-E\M-F\M-G\M-H\M-I\M-J\M-K\M-L\M-M\M-N\M-O\M-P\M-Q\M-R\M-S\M-T\M-U\M-V\M-W\M-X\M-Y\M-Z\M-[\M-\\M-]\M-^\M-_\M-`\M-a\M-b\M-c\M-d\M-e\M-f\M-g\M-h\M-i\M-j\M-k\M-l\M-m\M-n\M-o\M-p\M-q\M-r\M-s\M-t\M-u\M-v\M-w\M-x\M-y\M-z\M-{\M-|\M-}\M-~\M^?
diff --git a/src/regress/lib/libc/vis/vis_test.c b/src/regress/lib/libc/vis/vis_test.c
new file mode 100644
index 0000000000..40e5d9f503
--- /dev/null
+++ b/src/regress/lib/libc/vis/vis_test.c
@@ -0,0 +1,23 @@
+/*      $OpenBSD */
+
+/* Public domain. 2005, Otto Moerbeek */
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <vis.h>
+
+int
+main()
+{
+        char inp[UCHAR_MAX + 1];
+        char out[4 * UCHAR_MAX + 1];
+        int i;
+
+        for (i = 0; i <= UCHAR_MAX; i++) {
+                inp[i] = i;
+        }
+        strvisx(out, inp, UCHAR_MAX + 1, 0);
+        printf("%s\n", out);
+        exit(0);
+}