301 files changed, 46005 insertions, 0 deletions

diff --git a/src/lib/libc/crypt/Makefile.inc b/src/lib/libc/crypt/Makefile.inc
new file mode 100644
index 0000000000..131e1d3f39
--- /dev/null
+++ b/src/lib/libc/crypt/Makefile.inc
@@ -0,0 +1,15 @@
+#       $OpenBSD: Makefile.inc,v 1.15 2003/08/12 01:22:17 deraadt Exp $
+
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/crypt ${LIBCSRCDIR}/crypt
+
+SRCS+=  cast.c crypt.c crypt2.c md5crypt.c arc4random.c blowfish.c
+SRCS+=  bcrypt.c skipjack.c
+
+MAN+=   crypt.3 blowfish.3 arc4random.3
+MLINKS+=crypt.3 encrypt.3 crypt.3 setkey.3 crypt.3 des_cipher.3
+MLINKS+=crypt.3 bcrypt_gensalt.3 crypt.3 bcrypt.3 crypt.3 md5crypt.3
+MLINKS+=crypt.3 des_setkey.3 blowfish.3 blf_key.3 blowfish.3 blf_enc.3
+MLINKS+=blowfish.3 blf_dec.3 blowfish.3 blf_ecb_encrypt.3
+MLINKS+=blowfish.3 blf_ecb_decrypt.3 blowfish.3 blf_cbc_encrypt.3
+MLINKS+=blowfish.3 blf_cbc_decrypt.3
+MLINKS+=arc4random.3 arc4random_stir.3 arc4random.3 arc4random_addrandom.3
diff --git a/src/lib/libc/crypt/arc4random.3 b/src/lib/libc/crypt/arc4random.3
new file mode 100644
index 0000000000..fd127439bc
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.3
@@ -0,0 +1,110 @@
+.\" $OpenBSD: arc4random.3,v 1.19 2005/07/17 08:50:55 jaredy Exp $
+.\"
+.\" Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+.\" 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 Niels Provos.
+.\" 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.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd April 15, 1997
+.Dt ARC4RANDOM 3
+.Os
+.Sh NAME
+.Nm arc4random ,
+.Nm arc4random_stir ,
+.Nm arc4random_addrandom
+.Nd arc4 random number generator
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft u_int32_t
+.Fn arc4random "void"
+.Ft void
+.Fn arc4random_stir "void"
+.Ft void
+.Fn arc4random_addrandom "u_char *dat" "int datlen"
+.Sh DESCRIPTION
+The
+.Fn arc4random
+function provides a high quality 32-bit pseudo-random
+number very quickly.
+.Fn arc4random
+seeds itself on a regular basis from the kernel strong random number
+subsystem described in
+.Xr random 4 .
+On each call, an ARC4 generator is used to generate a new result.
+The
+.Fn arc4random
+function uses the ARC4 cipher key stream generator,
+which uses 8*8 8-bit S-Boxes.
+The S-Boxes can be in about (2**1700) states.
+.Pp
+.Fn arc4random
+fits into a middle ground not covered by other subsystems such as
+the strong, slow, and resource expensive random
+devices described in
+.Xr random 4
+versus the fast but poor quality interfaces described in
+.Xr rand 3 ,
+.Xr random 3 ,
+and
+.Xr drand48 3 .
+.Pp
+The
+.Fn arc4random_stir
+function reads data from
+.Pa /dev/arandom
+and uses it to permute the S-Boxes via
+.Fn arc4random_addrandom .
+.Pp
+There is no need to call
+.Fn arc4random_stir
+before using
+.Fn arc4random ,
+since
+.Fn arc4random
+automatically initializes itself.
+.Sh SEE ALSO
+.Xr rand 3 ,
+.Xr rand48 3 ,
+.Xr random 3
+.Sh HISTORY
+An algorithm called
+.Pa RC4
+was designed by RSA Data Security, Inc.
+It was considered a trade secret.
+Because it was a trade secret, it obviously could not be patented.
+A clone of this was posted anonymously to USENET and confirmed to
+be equivalent by several sources who had access to the original cipher.
+Because of the trade secret situation, RSA Data Security, Inc. can do
+nothing about the release of the ARC4 algorithm.
+Since
+.Pa RC4
+used to be a trade secret, the cipher is now referred to as
+.Pa ARC4 .
+.Pp
+These functions first appeared in
+.Ox 2.1 .
diff --git a/src/lib/libc/crypt/arc4random.c b/src/lib/libc/crypt/arc4random.c
new file mode 100644
index 0000000000..1e338f9968
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.c
@@ -0,0 +1,186 @@
+/*      $OpenBSD: arc4random.c,v 1.15 2005/11/30 07:51:02 otto Exp $    */
+
+/*
+ * Copyright (c) 1996, David Mazieres <dm@uun.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.
+ */
+
+/*
+ * Arc4 random number generator for OpenBSD.
+ *
+ * This code is derived from section 17.1 of Applied Cryptography,
+ * second edition, which describes a stream cipher allegedly
+ * compatible with RSA Labs "RC4" cipher (the actual description of
+ * which is a trade secret).  The same algorithm is used as a stream
+ * cipher called "arcfour" in Tatu Ylonen's ssh package.
+ *
+ * Here the stream cipher has been modified always to include the time
+ * when initializing the state.  That makes it impossible to
+ * regenerate the same random sequence twice, so this can't be used
+ * for encryption, but will generate good random numbers.
+ *
+ * RC4 is a registered trademark of RSA Laboratories.
+ */
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/sysctl.h>
+
+#ifdef __GNUC__
+#define inline __inline
+#else                           /* !__GNUC__ */
+#define inline
+#endif                          /* !__GNUC__ */
+
+struct arc4_stream {
+        u_int8_t i;
+        u_int8_t j;
+        u_int8_t s[256];
+};
+
+static int rs_initialized;
+static struct arc4_stream rs;
+static pid_t arc4_stir_pid;
+static int arc4_count;
+
+static inline u_int8_t arc4_getbyte(struct arc4_stream *);
+
+static inline void
+arc4_init(struct arc4_stream *as)
+{
+        int     n;
+
+        for (n = 0; n < 256; n++)
+                as->s[n] = n;
+        as->i = 0;
+        as->j = 0;
+}
+
+static inline void
+arc4_addrandom(struct arc4_stream *as, u_char *dat, int datlen)
+{
+        int     n;
+        u_int8_t si;
+
+        as->i--;
+        for (n = 0; n < 256; n++) {
+                as->i = (as->i + 1);
+                si = as->s[as->i];
+                as->j = (as->j + si + dat[n % datlen]);
+                as->s[as->i] = as->s[as->j];
+                as->s[as->j] = si;
+        }
+        as->j = as->i;
+}
+
+static void
+arc4_stir(struct arc4_stream *as)
+{
+        int     i, mib[2];
+        size_t  len;
+        u_char rnd[128];
+
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_ARND;
+
+        len = sizeof(rnd);
+        sysctl(mib, 2, rnd, &len, NULL, 0);
+
+        arc4_stir_pid = getpid();
+        arc4_addrandom(as, rnd, sizeof(rnd));
+
+        /*
+         * Discard early keystream, as per recommendations in:
+         * http://www.wisdom.weizmann.ac.il/~itsik/RC4/Papers/Rc4_ksa.ps
+         */
+        for (i = 0; i < 256; i++)
+                (void)arc4_getbyte(as);
+        arc4_count = 400000;
+}
+
+static inline u_int8_t
+arc4_getbyte(struct arc4_stream *as)
+{
+        u_int8_t si, sj;
+
+        as->i = (as->i + 1);
+        si = as->s[as->i];
+        as->j = (as->j + si);
+        sj = as->s[as->j];
+        as->s[as->i] = sj;
+        as->s[as->j] = si;
+        return (as->s[(si + sj) & 0xff]);
+}
+
+static inline u_int32_t
+arc4_getword(struct arc4_stream *as)
+{
+        u_int32_t val;
+        val = arc4_getbyte(as) << 24;
+        val |= arc4_getbyte(as) << 16;
+        val |= arc4_getbyte(as) << 8;
+        val |= arc4_getbyte(as);
+        return val;
+}
+
+void
+arc4random_stir(void)
+{
+        if (!rs_initialized) {
+                arc4_init(&rs);
+                rs_initialized = 1;
+        }
+        arc4_stir(&rs);
+}
+
+void
+arc4random_addrandom(u_char *dat, int datlen)
+{
+        if (!rs_initialized)
+                arc4random_stir();
+        arc4_addrandom(&rs, dat, datlen);
+}
+
+u_int32_t
+arc4random(void)
+{
+        if (--arc4_count == 0 || !rs_initialized || arc4_stir_pid != getpid())
+                arc4random_stir();
+        return arc4_getword(&rs);
+}
+
+#if 0
+/*-------- Test code for i386 --------*/
+#include <stdio.h>
+#include <machine/pctr.h>
+int
+main(int argc, char **argv)
+{
+        const int iter = 1000000;
+        int     i;
+        pctrval v;
+
+        v = rdtsc();
+        for (i = 0; i < iter; i++)
+                arc4random();
+        v = rdtsc() - v;
+        v /= iter;
+
+        printf("%qd cycles\n", v);
+}
+#endif
diff --git a/src/lib/libc/crypt/bcrypt.c b/src/lib/libc/crypt/bcrypt.c
new file mode 100644
index 0000000000..cdc2dd05a6
--- /dev/null
+++ b/src/lib/libc/crypt/bcrypt.c
@@ -0,0 +1,338 @@
+/*      $OpenBSD: bcrypt.c,v 1.20 2006/04/03 19:55:49 deraadt Exp $     */
+
+/*
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * 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 Niels Provos.
+ * 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.
+ */
+
+/* This password hashing algorithm was designed by David Mazieres
+ * <dm@lcs.mit.edu> and works as follows:
+ *
+ * 1. state := InitState ()
+ * 2. state := ExpandKey (state, salt, password) 3.
+ * REPEAT rounds:
+ *      state := ExpandKey (state, 0, salt)
+ *      state := ExpandKey(state, 0, password)
+ * 4. ctext := "OrpheanBeholderScryDoubt"
+ * 5. REPEAT 64:
+ *      ctext := Encrypt_ECB (state, ctext);
+ * 6. RETURN Concatenate (salt, ctext);
+ *
+ */
+
+#if 0
+#include <stdio.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <pwd.h>
+#include <blf.h>
+
+/* This implementation is adaptable to current computing power.
+ * You can have up to 2^31 rounds which should be enough for some
+ * time to come.
+ */
+
+#define BCRYPT_VERSION '2'
+#define BCRYPT_MAXSALT 16       /* Precomputation is just so nice */
+#define BCRYPT_BLOCKS 6         /* Ciphertext blocks */
+#define BCRYPT_MINROUNDS 16     /* we have log2(rounds) in salt */
+
+char   *bcrypt_gensalt(u_int8_t);
+
+static void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);
+static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t);
+static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *);
+
+static char    encrypted[_PASSWORD_LEN];
+static char    gsalt[BCRYPT_MAXSALT * 4 / 3 + 1];
+static char    error[] = ":";
+
+const static u_int8_t Base64Code[] =
+"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+const static u_int8_t index_64[128] = {
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 0, 1, 54, 55,
+        56, 57, 58, 59, 60, 61, 62, 63, 255, 255,
+        255, 255, 255, 255, 255, 2, 3, 4, 5, 6,
+        7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+        255, 255, 255, 255, 255, 255, 28, 29, 30,
+        31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+        41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+        51, 52, 53, 255, 255, 255, 255, 255
+};
+#define CHAR64(c)  ( (c) > 127 ? 255 : index_64[(c)])
+
+static void
+decode_base64(u_int8_t *buffer, u_int16_t len, u_int8_t *data)
+{
+        u_int8_t *bp = buffer;
+        u_int8_t *p = data;
+        u_int8_t c1, c2, c3, c4;
+        while (bp < buffer + len) {
+                c1 = CHAR64(*p);
+                c2 = CHAR64(*(p + 1));
+
+                /* Invalid data */
+                if (c1 == 255 || c2 == 255)
+                        break;
+
+                *bp++ = (c1 << 2) | ((c2 & 0x30) >> 4);
+                if (bp >= buffer + len)
+                        break;
+
+                c3 = CHAR64(*(p + 2));
+                if (c3 == 255)
+                        break;
+
+                *bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2);
+                if (bp >= buffer + len)
+                        break;
+
+                c4 = CHAR64(*(p + 3));
+                if (c4 == 255)
+                        break;
+                *bp++ = ((c3 & 0x03) << 6) | c4;
+
+                p += 4;
+        }
+}
+
+static void
+encode_salt(char *salt, u_int8_t *csalt, u_int16_t clen, u_int8_t logr)
+{
+        salt[0] = '$';
+        salt[1] = BCRYPT_VERSION;
+        salt[2] = 'a';
+        salt[3] = '$';
+
+        snprintf(salt + 4, 4, "%2.2u$", logr);
+
+        encode_base64((u_int8_t *) salt + 7, csalt, clen);
+}
+/* Generates a salt for this version of crypt.
+   Since versions may change. Keeping this here
+   seems sensible.
+ */
+
+char *
+bcrypt_gensalt(u_int8_t log_rounds)
+{
+        u_int8_t csalt[BCRYPT_MAXSALT];
+        u_int16_t i;
+        u_int32_t seed = 0;
+
+        for (i = 0; i < BCRYPT_MAXSALT; i++) {
+                if (i % 4 == 0)
+                        seed = arc4random();
+                csalt[i] = seed & 0xff;
+                seed = seed >> 8;
+        }
+
+        if (log_rounds < 4)
+                log_rounds = 4;
+        else if (log_rounds > 31)
+                log_rounds = 31;
+
+        encode_salt(gsalt, csalt, BCRYPT_MAXSALT, log_rounds);
+        return gsalt;
+}
+/* We handle $Vers$log2(NumRounds)$salt+passwd$
+   i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */
+
+char   *
+bcrypt(const char *key, const char *salt)
+{
+        blf_ctx state;
+        u_int32_t rounds, i, k;
+        u_int16_t j;
+        u_int8_t key_len, salt_len, logr, minor;
+        u_int8_t ciphertext[4 * BCRYPT_BLOCKS] = "OrpheanBeholderScryDoubt";
+        u_int8_t csalt[BCRYPT_MAXSALT];
+        u_int32_t cdata[BCRYPT_BLOCKS];
+        int n;
+
+        /* Discard "$" identifier */
+        salt++;
+
+        if (*salt > BCRYPT_VERSION) {
+                /* How do I handle errors ? Return ':' */
+                return error;
+        }
+
+        /* Check for minor versions */
+        if (salt[1] != '$') {
+                 switch (salt[1]) {
+                 case 'a':
+                         /* 'ab' should not yield the same as 'abab' */
+                         minor = salt[1];
+                         salt++;
+                         break;
+                 default:
+                         return error;
+                 }
+        } else
+                 minor = 0;
+
+        /* Discard version + "$" identifier */
+        salt += 2;
+
+        if (salt[2] != '$')
+                /* Out of sync with passwd entry */
+                return error;
+
+        /* Computer power doesn't increase linear, 2^x should be fine */
+        n = atoi(salt);
+        if (n > 31 || n < 0)
+                return error;
+        logr = (u_int8_t)n;
+        if ((rounds = (u_int32_t) 1 << logr) < BCRYPT_MINROUNDS)
+                return error;
+
+        /* Discard num rounds + "$" identifier */
+        salt += 3;
+
+        if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT)
+                return error;
+
+        /* We dont want the base64 salt but the raw data */
+        decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt);
+        salt_len = BCRYPT_MAXSALT;
+        key_len = strlen(key) + (minor >= 'a' ? 1 : 0);
+
+        /* Setting up S-Boxes and Subkeys */
+        Blowfish_initstate(&state);
+        Blowfish_expandstate(&state, csalt, salt_len,
+            (u_int8_t *) key, key_len);
+        for (k = 0; k < rounds; k++) {
+                Blowfish_expand0state(&state, (u_int8_t *) key, key_len);
+                Blowfish_expand0state(&state, csalt, salt_len);
+        }
+
+        /* This can be precomputed later */
+        j = 0;
+        for (i = 0; i < BCRYPT_BLOCKS; i++)
+                cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j);
+
+        /* Now do the encryption */
+        for (k = 0; k < 64; k++)
+                blf_enc(&state, cdata, BCRYPT_BLOCKS / 2);
+
+        for (i = 0; i < BCRYPT_BLOCKS; i++) {
+                ciphertext[4 * i + 3] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 2] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 1] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 0] = cdata[i] & 0xff;
+        }
+
+
+        i = 0;
+        encrypted[i++] = '$';
+        encrypted[i++] = BCRYPT_VERSION;
+        if (minor)
+                encrypted[i++] = minor;
+        encrypted[i++] = '$';
+
+        snprintf(encrypted + i, 4, "%2.2u$", logr);
+
+        encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT);
+        encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext,
+            4 * BCRYPT_BLOCKS - 1);
+        return encrypted;
+}
+
+static void
+encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len)
+{
+        u_int8_t *bp = buffer;
+        u_int8_t *p = data;
+        u_int8_t c1, c2;
+        while (p < data + len) {
+                c1 = *p++;
+                *bp++ = Base64Code[(c1 >> 2)];
+                c1 = (c1 & 0x03) << 4;
+                if (p >= data + len) {
+                        *bp++ = Base64Code[c1];
+                        break;
+                }
+                c2 = *p++;
+                c1 |= (c2 >> 4) & 0x0f;
+                *bp++ = Base64Code[c1];
+                c1 = (c2 & 0x0f) << 2;
+                if (p >= data + len) {
+                        *bp++ = Base64Code[c1];
+                        break;
+                }
+                c2 = *p++;
+                c1 |= (c2 >> 6) & 0x03;
+                *bp++ = Base64Code[c1];
+                *bp++ = Base64Code[c2 & 0x3f];
+        }
+        *bp = '\0';
+}
+#if 0
+void
+main()
+{
+        char    blubber[73];
+        char    salt[100];
+        char   *p;
+        salt[0] = '$';
+        salt[1] = BCRYPT_VERSION;
+        salt[2] = '$';
+
+        snprintf(salt + 3, 4, "%2.2u$", 5);
+
+        printf("24 bytes of salt: ");
+        fgets(salt + 6, 94, stdin);
+        salt[99] = 0;
+        printf("72 bytes of password: ");
+        fpurge(stdin);
+        fgets(blubber, 73, stdin);
+        blubber[72] = 0;
+
+        p = crypt(blubber, salt);
+        printf("Passwd entry: %s\n\n", p);
+
+        p = bcrypt_gensalt(5);
+        printf("Generated salt: %s\n", p);
+        p = crypt(blubber, p);
+        printf("Passwd entry: %s\n", p);
+}
+#endif
diff --git a/src/lib/libc/crypt/blowfish.3 b/src/lib/libc/crypt/blowfish.3
new file mode 100644
index 0000000000..a97e3c94f2
--- /dev/null
+++ b/src/lib/libc/crypt/blowfish.3
@@ -0,0 +1,110 @@
+.\" $OpenBSD: blowfish.3,v 1.14 2005/10/02 08:12:16 jmc Exp $
+.\"
+.\" Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+.\" 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 Niels Provos.
+.\" 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.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd February 13, 1997
+.Dt BLOWFISH 3
+.Os
+.Sh NAME
+.Nm blf_key ,
+.Nm blf_enc ,
+.Nm blf_dec ,
+.Nm blf_ecb_encrypt ,
+.Nm blf_ecb_decrypt ,
+.Nm blf_cbc_encrypt ,
+.Nm blf_cbc_decrypt
+.Nd Blowfish encryption
+.Sh SYNOPSIS
+.Fd #include <blf.h>
+.Ft void
+.Fn blf_key "blf_ctx *state" "const u_int8_t *key" "u_int16_t keylen"
+.Ft void
+.Fn blf_enc "blf_ctx *state" "u_int32_t *data" "u_int16_t datalen"
+.Ft void
+.Fn blf_dec "blf_ctx *state" "u_int32_t *data" "u_int16_t datalen"
+.Ft void
+.Fn blf_ecb_encrypt "blf_ctx *state" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_ecb_decrypt "blf_ctx *state" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_cbc_encrypt "blf_ctx *state" "u_int8_t *iv" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_cbc_decrypt "blf_ctx *state" "u_int8_t *iv" "u_int8_t *data" "u_int32_t datalen"
+.Sh DESCRIPTION
+.Pa Blowfish
+is a fast unpatented block cipher designed by Bruce Schneier.
+It basically consists of a 16-round Feistel network.
+The block size is 64 bits and the maximum key size is 448 bits.
+.Pp
+The
+.Fn blf_key
+function initializes the 4 8-bit S-boxes and the 18 Subkeys with
+the hexadecimal digits of Pi.
+The key is used for further randomization.
+The first argument to
+.Fn blf_enc
+is the initialized state derived from
+.Fn blf_key .
+The stream of 32-bit words is encrypted in Electronic Codebook
+Mode (ECB) and
+.Pa datalen
+must be even.
+.Fn blf_dec
+is used for decrypting Blowfish encrypted blocks.
+.Pp
+The functions
+.Fn blf_ecb_encrypt
+and
+.Fn blf_ecb_decrypt
+are used for encrypting and decrypting octet streams in ECB mode.
+The functions
+.Fn blf_cbc_encrypt
+and
+.Fn blf_cbc_decrypt
+are used for encrypting and decrypting octet streams in
+Cipherblock Chaining Mode (CBC).
+.Pp
+The functions
+.Fn Blowfish_initstate ,
+.Fn Blowfish_expand0state ,
+.Fn Blowfish_expandstate ,
+.Fn Blowfish_encipher
+and
+.Fn Blowfish_decipher
+are used for customization of the
+.Pa Blowfish
+cipher, e.g., for the blowfish password hashing function.
+.Sh SEE ALSO
+.Xr passwd 1 ,
+.Xr crypt 3 ,
+.Xr passwd 5
+.Sh AUTHORS
+.An Niels Provos Aq provos@physnet.uni-hamburg.de
diff --git a/src/lib/libc/crypt/blowfish.c b/src/lib/libc/crypt/blowfish.c
new file mode 100644
index 0000000000..c337df8a0a
--- /dev/null
+++ b/src/lib/libc/crypt/blowfish.c
@@ -0,0 +1,685 @@
+/* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */
+/*
+ * Blowfish block cipher for OpenBSD
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * All rights reserved.
+ *
+ * Implementation advice by David Mazieres <dm@lcs.mit.edu>.
+ *
+ * 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 Niels Provos.
+ * 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.
+ */
+
+/*
+ * This code is derived from section 14.3 and the given source
+ * in section V of Applied Cryptography, second edition.
+ * Blowfish is an unpatented fast block cipher designed by
+ * Bruce Schneier.
+ */
+
+#if 0
+#include <stdio.h>              /* used for debugging */
+#include <string.h>
+#endif
+
+#include <sys/types.h>
+#include <blf.h>
+
+#undef inline
+#ifdef __GNUC__
+#define inline __inline
+#else                           /* !__GNUC__ */
+#define inline
+#endif                          /* !__GNUC__ */
+
+/* Function for Feistel Networks */
+
+#define F(s, x) ((((s)[        (((x)>>24)&0xFF)]  \
+                 + (s)[0x100 + (((x)>>16)&0xFF)]) \
+                 ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
+                 + (s)[0x300 + ( (x)     &0xFF)])
+
+#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
+
+void
+Blowfish_encipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr)
+{
+        u_int32_t Xl;
+        u_int32_t Xr;
+        u_int32_t *s = c->S[0];
+        u_int32_t *p = c->P;
+
+        Xl = *xl;
+        Xr = *xr;
+
+        Xl ^= p[0];
+        BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
+        BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
+        BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
+        BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
+        BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
+        BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
+        BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
+        BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
+
+        *xl = Xr ^ p[17];
+        *xr = Xl;
+}
+
+void
+Blowfish_decipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr)
+{
+        u_int32_t Xl;
+        u_int32_t Xr;
+        u_int32_t *s = c->S[0];
+        u_int32_t *p = c->P;
+
+        Xl = *xl;
+        Xr = *xr;
+
+        Xl ^= p[17];
+        BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
+        BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
+        BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
+        BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
+        BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
+        BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
+        BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
+        BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
+
+        *xl = Xr ^ p[0];
+        *xr = Xl;
+}
+
+void
+Blowfish_initstate(blf_ctx *c)
+{
+        /* P-box and S-box tables initialized with digits of Pi */
+
+        static const blf_ctx initstate =
+        { {
+                {
+                        0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+                        0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+                        0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+                        0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+                        0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+                        0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+                        0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+                        0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+                        0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+                        0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+                        0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+                        0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+                        0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+                        0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+                        0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+                        0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+                        0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+                        0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+                        0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+                        0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+                        0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+                        0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+                        0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+                        0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+                        0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+                        0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+                        0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+                        0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+                        0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+                        0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+                        0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+                        0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+                        0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+                        0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+                        0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+                        0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+                        0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+                        0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+                        0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+                        0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+                        0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+                        0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+                        0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+                        0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+                        0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+                        0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+                        0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+                        0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+                        0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+                        0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+                        0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+                        0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+                        0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+                        0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+                        0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+                        0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+                        0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+                        0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+                        0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+                        0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+                        0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+                        0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+                        0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
+                {
+                        0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+                        0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+                        0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+                        0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+                        0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+                        0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+                        0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+                        0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+                        0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+                        0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+                        0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+                        0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+                        0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+                        0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+                        0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+                        0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+                        0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+                        0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+                        0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+                        0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+                        0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+                        0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+                        0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+                        0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+                        0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+                        0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+                        0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+                        0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+                        0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+                        0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+                        0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+                        0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+                        0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+                        0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+                        0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+                        0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+                        0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+                        0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+                        0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+                        0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+                        0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+                        0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+                        0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+                        0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+                        0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+                        0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+                        0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+                        0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+                        0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+                        0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+                        0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+                        0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+                        0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+                        0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+                        0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+                        0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+                        0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+                        0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+                        0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+                        0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+                        0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+                        0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+                        0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
+                {
+                        0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+                        0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+                        0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+                        0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+                        0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+                        0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+                        0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+                        0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+                        0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+                        0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+                        0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+                        0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+                        0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+                        0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+                        0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+                        0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+                        0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+                        0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+                        0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+                        0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+                        0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+                        0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+                        0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+                        0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+                        0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+                        0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+                        0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+                        0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+                        0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+                        0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+                        0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+                        0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+                        0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+                        0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+                        0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+                        0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+                        0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+                        0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+                        0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+                        0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+                        0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+                        0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+                        0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+                        0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+                        0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+                        0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+                        0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+                        0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+                        0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+                        0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+                        0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+                        0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+                        0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+                        0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+                        0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+                        0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+                        0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+                        0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+                        0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+                        0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+                        0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+                        0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+                        0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
+                {
+                        0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+                        0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+                        0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+                        0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+                        0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+                        0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+                        0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+                        0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+                        0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+                        0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+                        0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+                        0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+                        0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+                        0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+                        0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+                        0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+                        0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+                        0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+                        0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+                        0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+                        0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+                        0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+                        0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+                        0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+                        0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+                        0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+                        0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+                        0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+                        0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+                        0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+                        0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+                        0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+                        0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+                        0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+                        0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+                        0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+                        0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+                        0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+                        0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+                        0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+                        0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+                        0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+                        0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+                        0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+                        0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+                        0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+                        0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+                        0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+                        0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+                        0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+                        0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+                        0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+                        0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+                        0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+                        0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+                        0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+                        0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+                        0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+                        0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+                        0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+                        0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+                        0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+                        0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
+        },
+        {
+                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+                0x9216d5d9, 0x8979fb1b
+        } };
+
+        *c = initstate;
+}
+
+u_int32_t
+Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes,
+    u_int16_t *current)
+{
+        u_int8_t i;
+        u_int16_t j;
+        u_int32_t temp;
+
+        temp = 0x00000000;
+        j = *current;
+
+        for (i = 0; i < 4; i++, j++) {
+                if (j >= databytes)
+                        j = 0;
+                temp = (temp << 8) | data[j];
+        }
+
+        *current = j;
+        return temp;
+}
+
+void
+Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
+{
+        u_int16_t i;
+        u_int16_t j;
+        u_int16_t k;
+        u_int32_t temp;
+        u_int32_t datal;
+        u_int32_t datar;
+
+        j = 0;
+        for (i = 0; i < BLF_N + 2; i++) {
+                /* Extract 4 int8 to 1 int32 from keystream */
+                temp = Blowfish_stream2word(key, keybytes, &j);
+                c->P[i] = c->P[i] ^ temp;
+        }
+
+        j = 0;
+        datal = 0x00000000;
+        datar = 0x00000000;
+        for (i = 0; i < BLF_N + 2; i += 2) {
+                Blowfish_encipher(c, &datal, &datar);
+
+                c->P[i] = datal;
+                c->P[i + 1] = datar;
+        }
+
+        for (i = 0; i < 4; i++) {
+                for (k = 0; k < 256; k += 2) {
+                        Blowfish_encipher(c, &datal, &datar);
+
+                        c->S[i][k] = datal;
+                        c->S[i][k + 1] = datar;
+                }
+        }
+}
+
+
+void
+Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
+    const u_int8_t *key, u_int16_t keybytes)
+{
+        u_int16_t i;
+        u_int16_t j;
+        u_int16_t k;
+        u_int32_t temp;
+        u_int32_t datal;
+        u_int32_t datar;
+
+        j = 0;
+        for (i = 0; i < BLF_N + 2; i++) {
+                /* Extract 4 int8 to 1 int32 from keystream */
+                temp = Blowfish_stream2word(key, keybytes, &j);
+                c->P[i] = c->P[i] ^ temp;
+        }
+
+        j = 0;
+        datal = 0x00000000;
+        datar = 0x00000000;
+        for (i = 0; i < BLF_N + 2; i += 2) {
+                datal ^= Blowfish_stream2word(data, databytes, &j);
+                datar ^= Blowfish_stream2word(data, databytes, &j);
+                Blowfish_encipher(c, &datal, &datar);
+
+                c->P[i] = datal;
+                c->P[i + 1] = datar;
+        }
+
+        for (i = 0; i < 4; i++) {
+                for (k = 0; k < 256; k += 2) {
+                        datal ^= Blowfish_stream2word(data, databytes, &j);
+                        datar ^= Blowfish_stream2word(data, databytes, &j);
+                        Blowfish_encipher(c, &datal, &datar);
+
+                        c->S[i][k] = datal;
+                        c->S[i][k + 1] = datar;
+                }
+        }
+
+}
+
+void
+blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len)
+{
+        /* Initialize S-boxes and subkeys with Pi */
+        Blowfish_initstate(c);
+
+        /* Transform S-boxes and subkeys with key */
+        Blowfish_expand0state(c, k, len);
+}
+
+void
+blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+{
+        u_int32_t *d;
+        u_int16_t i;
+
+        d = data;
+        for (i = 0; i < blocks; i++) {
+                Blowfish_encipher(c, d, d + 1);
+                d += 2;
+        }
+}
+
+void
+blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+{
+        u_int32_t *d;
+        u_int16_t i;
+
+        d = data;
+        for (i = 0; i < blocks; i++) {
+                Blowfish_decipher(c, d, d + 1);
+                d += 2;
+        }
+}
+
+void
+blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i;
+
+        for (i = 0; i < len; i += 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_encipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                data += 8;
+        }
+}
+
+void
+blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i;
+
+        for (i = 0; i < len; i += 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_decipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                data += 8;
+        }
+}
+
+void
+blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i, j;
+
+        for (i = 0; i < len; i += 8) {
+                for (j = 0; j < 8; j++)
+                        data[j] ^= iv[j];
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_encipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                iv = data;
+                data += 8;
+        }
+}
+
+void
+blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int8_t *iv;
+        u_int32_t i, j;
+
+        iv = data + len - 16;
+        data = data + len - 8;
+        for (i = len - 8; i >= 8; i -= 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_decipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                for (j = 0; j < 8; j++)
+                        data[j] ^= iv[j];
+                iv -= 8;
+                data -= 8;
+        }
+        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+        Blowfish_decipher(c, &l, &r);
+        data[0] = l >> 24 & 0xff;
+        data[1] = l >> 16 & 0xff;
+        data[2] = l >> 8 & 0xff;
+        data[3] = l & 0xff;
+        data[4] = r >> 24 & 0xff;
+        data[5] = r >> 16 & 0xff;
+        data[6] = r >> 8 & 0xff;
+        data[7] = r & 0xff;
+        for (j = 0; j < 8; j++)
+                data[j] ^= iva[j];
+}
+
+#if 0
+void
+report(u_int32_t data[], u_int16_t len)
+{
+        u_int16_t i;
+        for (i = 0; i < len; i += 2)
+                printf("Block %0hd: %08lx %08lx.\n",
+                    i / 2, data[i], data[i + 1]);
+}
+void
+main(void)
+{
+
+        blf_ctx c;
+        char    key[] = "AAAAA";
+        char    key2[] = "abcdefghijklmnopqrstuvwxyz";
+
+        u_int32_t data[10];
+        u_int32_t data2[] =
+        {0x424c4f57l, 0x46495348l};
+
+        u_int16_t i;
+
+        /* First test */
+        for (i = 0; i < 10; i++)
+                data[i] = i;
+
+        blf_key(&c, (u_int8_t *) key, 5);
+        blf_enc(&c, data, 5);
+        blf_dec(&c, data, 1);
+        blf_dec(&c, data + 2, 4);
+        printf("Should read as 0 - 9.\n");
+        report(data, 10);
+
+        /* Second test */
+        blf_key(&c, (u_int8_t *) key2, strlen(key2));
+        blf_enc(&c, data2, 1);
+        printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
+        report(data2, 2);
+        blf_dec(&c, data2, 1);
+        report(data2, 2);
+}
+#endif
diff --git a/src/lib/libc/crypt/cast.c b/src/lib/libc/crypt/cast.c
new file mode 100644
index 0000000000..ea026638d6
--- /dev/null
+++ b/src/lib/libc/crypt/cast.c
@@ -0,0 +1,790 @@
+/*      $OpenBSD: cast.c,v 1.3 2004/11/03 10:38:50 hshoexer Exp $       */
+/*
+ *      CAST-128 in C
+ *      Written by Steve Reid <sreid@sea-to-sky.net>
+ *      100% Public Domain - no warranty
+ *      Released 1997.10.11
+ */
+
+#include <sys/types.h>
+
+#include <cast.h>
+
+/* CAST S-Boxes */
+
+static const u_int32_t cast_sbox1[256] = {
+        0x30FB40D4, 0x9FA0FF0B, 0x6BECCD2F, 0x3F258C7A,
+        0x1E213F2F, 0x9C004DD3, 0x6003E540, 0xCF9FC949,
+        0xBFD4AF27, 0x88BBBDB5, 0xE2034090, 0x98D09675,
+        0x6E63A0E0, 0x15C361D2, 0xC2E7661D, 0x22D4FF8E,
+        0x28683B6F, 0xC07FD059, 0xFF2379C8, 0x775F50E2,
+        0x43C340D3, 0xDF2F8656, 0x887CA41A, 0xA2D2BD2D,
+        0xA1C9E0D6, 0x346C4819, 0x61B76D87, 0x22540F2F,
+        0x2ABE32E1, 0xAA54166B, 0x22568E3A, 0xA2D341D0,
+        0x66DB40C8, 0xA784392F, 0x004DFF2F, 0x2DB9D2DE,
+        0x97943FAC, 0x4A97C1D8, 0x527644B7, 0xB5F437A7,
+        0xB82CBAEF, 0xD751D159, 0x6FF7F0ED, 0x5A097A1F,
+        0x827B68D0, 0x90ECF52E, 0x22B0C054, 0xBC8E5935,
+        0x4B6D2F7F, 0x50BB64A2, 0xD2664910, 0xBEE5812D,
+        0xB7332290, 0xE93B159F, 0xB48EE411, 0x4BFF345D,
+        0xFD45C240, 0xAD31973F, 0xC4F6D02E, 0x55FC8165,
+        0xD5B1CAAD, 0xA1AC2DAE, 0xA2D4B76D, 0xC19B0C50,
+        0x882240F2, 0x0C6E4F38, 0xA4E4BFD7, 0x4F5BA272,
+        0x564C1D2F, 0xC59C5319, 0xB949E354, 0xB04669FE,
+        0xB1B6AB8A, 0xC71358DD, 0x6385C545, 0x110F935D,
+        0x57538AD5, 0x6A390493, 0xE63D37E0, 0x2A54F6B3,
+        0x3A787D5F, 0x6276A0B5, 0x19A6FCDF, 0x7A42206A,
+        0x29F9D4D5, 0xF61B1891, 0xBB72275E, 0xAA508167,
+        0x38901091, 0xC6B505EB, 0x84C7CB8C, 0x2AD75A0F,
+        0x874A1427, 0xA2D1936B, 0x2AD286AF, 0xAA56D291,
+        0xD7894360, 0x425C750D, 0x93B39E26, 0x187184C9,
+        0x6C00B32D, 0x73E2BB14, 0xA0BEBC3C, 0x54623779,
+        0x64459EAB, 0x3F328B82, 0x7718CF82, 0x59A2CEA6,
+        0x04EE002E, 0x89FE78E6, 0x3FAB0950, 0x325FF6C2,
+        0x81383F05, 0x6963C5C8, 0x76CB5AD6, 0xD49974C9,
+        0xCA180DCF, 0x380782D5, 0xC7FA5CF6, 0x8AC31511,
+        0x35E79E13, 0x47DA91D0, 0xF40F9086, 0xA7E2419E,
+        0x31366241, 0x051EF495, 0xAA573B04, 0x4A805D8D,
+        0x548300D0, 0x00322A3C, 0xBF64CDDF, 0xBA57A68E,
+        0x75C6372B, 0x50AFD341, 0xA7C13275, 0x915A0BF5,
+        0x6B54BFAB, 0x2B0B1426, 0xAB4CC9D7, 0x449CCD82,
+        0xF7FBF265, 0xAB85C5F3, 0x1B55DB94, 0xAAD4E324,
+        0xCFA4BD3F, 0x2DEAA3E2, 0x9E204D02, 0xC8BD25AC,
+        0xEADF55B3, 0xD5BD9E98, 0xE31231B2, 0x2AD5AD6C,
+        0x954329DE, 0xADBE4528, 0xD8710F69, 0xAA51C90F,
+        0xAA786BF6, 0x22513F1E, 0xAA51A79B, 0x2AD344CC,
+        0x7B5A41F0, 0xD37CFBAD, 0x1B069505, 0x41ECE491,
+        0xB4C332E6, 0x032268D4, 0xC9600ACC, 0xCE387E6D,
+        0xBF6BB16C, 0x6A70FB78, 0x0D03D9C9, 0xD4DF39DE,
+        0xE01063DA, 0x4736F464, 0x5AD328D8, 0xB347CC96,
+        0x75BB0FC3, 0x98511BFB, 0x4FFBCC35, 0xB58BCF6A,
+        0xE11F0ABC, 0xBFC5FE4A, 0xA70AEC10, 0xAC39570A,
+        0x3F04442F, 0x6188B153, 0xE0397A2E, 0x5727CB79,
+        0x9CEB418F, 0x1CACD68D, 0x2AD37C96, 0x0175CB9D,
+        0xC69DFF09, 0xC75B65F0, 0xD9DB40D8, 0xEC0E7779,
+        0x4744EAD4, 0xB11C3274, 0xDD24CB9E, 0x7E1C54BD,
+        0xF01144F9, 0xD2240EB1, 0x9675B3FD, 0xA3AC3755,
+        0xD47C27AF, 0x51C85F4D, 0x56907596, 0xA5BB15E6,
+        0x580304F0, 0xCA042CF1, 0x011A37EA, 0x8DBFAADB,
+        0x35BA3E4A, 0x3526FFA0, 0xC37B4D09, 0xBC306ED9,
+        0x98A52666, 0x5648F725, 0xFF5E569D, 0x0CED63D0,
+        0x7C63B2CF, 0x700B45E1, 0xD5EA50F1, 0x85A92872,
+        0xAF1FBDA7, 0xD4234870, 0xA7870BF3, 0x2D3B4D79,
+        0x42E04198, 0x0CD0EDE7, 0x26470DB8, 0xF881814C,
+        0x474D6AD7, 0x7C0C5E5C, 0xD1231959, 0x381B7298,
+        0xF5D2F4DB, 0xAB838653, 0x6E2F1E23, 0x83719C9E,
+        0xBD91E046, 0x9A56456E, 0xDC39200C, 0x20C8C571,
+        0x962BDA1C, 0xE1E696FF, 0xB141AB08, 0x7CCA89B9,
+        0x1A69E783, 0x02CC4843, 0xA2F7C579, 0x429EF47D,
+        0x427B169C, 0x5AC9F049, 0xDD8F0F00, 0x5C8165BF
+};
+
+static const u_int32_t cast_sbox2[256] = {
+        0x1F201094, 0xEF0BA75B, 0x69E3CF7E, 0x393F4380,
+        0xFE61CF7A, 0xEEC5207A, 0x55889C94, 0x72FC0651,
+        0xADA7EF79, 0x4E1D7235, 0xD55A63CE, 0xDE0436BA,
+        0x99C430EF, 0x5F0C0794, 0x18DCDB7D, 0xA1D6EFF3,
+        0xA0B52F7B, 0x59E83605, 0xEE15B094, 0xE9FFD909,
+        0xDC440086, 0xEF944459, 0xBA83CCB3, 0xE0C3CDFB,
+        0xD1DA4181, 0x3B092AB1, 0xF997F1C1, 0xA5E6CF7B,
+        0x01420DDB, 0xE4E7EF5B, 0x25A1FF41, 0xE180F806,
+        0x1FC41080, 0x179BEE7A, 0xD37AC6A9, 0xFE5830A4,
+        0x98DE8B7F, 0x77E83F4E, 0x79929269, 0x24FA9F7B,
+        0xE113C85B, 0xACC40083, 0xD7503525, 0xF7EA615F,
+        0x62143154, 0x0D554B63, 0x5D681121, 0xC866C359,
+        0x3D63CF73, 0xCEE234C0, 0xD4D87E87, 0x5C672B21,
+        0x071F6181, 0x39F7627F, 0x361E3084, 0xE4EB573B,
+        0x602F64A4, 0xD63ACD9C, 0x1BBC4635, 0x9E81032D,
+        0x2701F50C, 0x99847AB4, 0xA0E3DF79, 0xBA6CF38C,
+        0x10843094, 0x2537A95E, 0xF46F6FFE, 0xA1FF3B1F,
+        0x208CFB6A, 0x8F458C74, 0xD9E0A227, 0x4EC73A34,
+        0xFC884F69, 0x3E4DE8DF, 0xEF0E0088, 0x3559648D,
+        0x8A45388C, 0x1D804366, 0x721D9BFD, 0xA58684BB,
+        0xE8256333, 0x844E8212, 0x128D8098, 0xFED33FB4,
+        0xCE280AE1, 0x27E19BA5, 0xD5A6C252, 0xE49754BD,
+        0xC5D655DD, 0xEB667064, 0x77840B4D, 0xA1B6A801,
+        0x84DB26A9, 0xE0B56714, 0x21F043B7, 0xE5D05860,
+        0x54F03084, 0x066FF472, 0xA31AA153, 0xDADC4755,
+        0xB5625DBF, 0x68561BE6, 0x83CA6B94, 0x2D6ED23B,
+        0xECCF01DB, 0xA6D3D0BA, 0xB6803D5C, 0xAF77A709,
+        0x33B4A34C, 0x397BC8D6, 0x5EE22B95, 0x5F0E5304,
+        0x81ED6F61, 0x20E74364, 0xB45E1378, 0xDE18639B,
+        0x881CA122, 0xB96726D1, 0x8049A7E8, 0x22B7DA7B,
+        0x5E552D25, 0x5272D237, 0x79D2951C, 0xC60D894C,
+        0x488CB402, 0x1BA4FE5B, 0xA4B09F6B, 0x1CA815CF,
+        0xA20C3005, 0x8871DF63, 0xB9DE2FCB, 0x0CC6C9E9,
+        0x0BEEFF53, 0xE3214517, 0xB4542835, 0x9F63293C,
+        0xEE41E729, 0x6E1D2D7C, 0x50045286, 0x1E6685F3,
+        0xF33401C6, 0x30A22C95, 0x31A70850, 0x60930F13,
+        0x73F98417, 0xA1269859, 0xEC645C44, 0x52C877A9,
+        0xCDFF33A6, 0xA02B1741, 0x7CBAD9A2, 0x2180036F,
+        0x50D99C08, 0xCB3F4861, 0xC26BD765, 0x64A3F6AB,
+        0x80342676, 0x25A75E7B, 0xE4E6D1FC, 0x20C710E6,
+        0xCDF0B680, 0x17844D3B, 0x31EEF84D, 0x7E0824E4,
+        0x2CCB49EB, 0x846A3BAE, 0x8FF77888, 0xEE5D60F6,
+        0x7AF75673, 0x2FDD5CDB, 0xA11631C1, 0x30F66F43,
+        0xB3FAEC54, 0x157FD7FA, 0xEF8579CC, 0xD152DE58,
+        0xDB2FFD5E, 0x8F32CE19, 0x306AF97A, 0x02F03EF8,
+        0x99319AD5, 0xC242FA0F, 0xA7E3EBB0, 0xC68E4906,
+        0xB8DA230C, 0x80823028, 0xDCDEF3C8, 0xD35FB171,
+        0x088A1BC8, 0xBEC0C560, 0x61A3C9E8, 0xBCA8F54D,
+        0xC72FEFFA, 0x22822E99, 0x82C570B4, 0xD8D94E89,
+        0x8B1C34BC, 0x301E16E6, 0x273BE979, 0xB0FFEAA6,
+        0x61D9B8C6, 0x00B24869, 0xB7FFCE3F, 0x08DC283B,
+        0x43DAF65A, 0xF7E19798, 0x7619B72F, 0x8F1C9BA4,
+        0xDC8637A0, 0x16A7D3B1, 0x9FC393B7, 0xA7136EEB,
+        0xC6BCC63E, 0x1A513742, 0xEF6828BC, 0x520365D6,
+        0x2D6A77AB, 0x3527ED4B, 0x821FD216, 0x095C6E2E,
+        0xDB92F2FB, 0x5EEA29CB, 0x145892F5, 0x91584F7F,
+        0x5483697B, 0x2667A8CC, 0x85196048, 0x8C4BACEA,
+        0x833860D4, 0x0D23E0F9, 0x6C387E8A, 0x0AE6D249,
+        0xB284600C, 0xD835731D, 0xDCB1C647, 0xAC4C56EA,
+        0x3EBD81B3, 0x230EABB0, 0x6438BC87, 0xF0B5B1FA,
+        0x8F5EA2B3, 0xFC184642, 0x0A036B7A, 0x4FB089BD,
+        0x649DA589, 0xA345415E, 0x5C038323, 0x3E5D3BB9,
+        0x43D79572, 0x7E6DD07C, 0x06DFDF1E, 0x6C6CC4EF,
+        0x7160A539, 0x73BFBE70, 0x83877605, 0x4523ECF1
+};
+
+static const u_int32_t cast_sbox3[256] = {
+        0x8DEFC240, 0x25FA5D9F, 0xEB903DBF, 0xE810C907,
+        0x47607FFF, 0x369FE44B, 0x8C1FC644, 0xAECECA90,
+        0xBEB1F9BF, 0xEEFBCAEA, 0xE8CF1950, 0x51DF07AE,
+        0x920E8806, 0xF0AD0548, 0xE13C8D83, 0x927010D5,
+        0x11107D9F, 0x07647DB9, 0xB2E3E4D4, 0x3D4F285E,
+        0xB9AFA820, 0xFADE82E0, 0xA067268B, 0x8272792E,
+        0x553FB2C0, 0x489AE22B, 0xD4EF9794, 0x125E3FBC,
+        0x21FFFCEE, 0x825B1BFD, 0x9255C5ED, 0x1257A240,
+        0x4E1A8302, 0xBAE07FFF, 0x528246E7, 0x8E57140E,
+        0x3373F7BF, 0x8C9F8188, 0xA6FC4EE8, 0xC982B5A5,
+        0xA8C01DB7, 0x579FC264, 0x67094F31, 0xF2BD3F5F,
+        0x40FFF7C1, 0x1FB78DFC, 0x8E6BD2C1, 0x437BE59B,
+        0x99B03DBF, 0xB5DBC64B, 0x638DC0E6, 0x55819D99,
+        0xA197C81C, 0x4A012D6E, 0xC5884A28, 0xCCC36F71,
+        0xB843C213, 0x6C0743F1, 0x8309893C, 0x0FEDDD5F,
+        0x2F7FE850, 0xD7C07F7E, 0x02507FBF, 0x5AFB9A04,
+        0xA747D2D0, 0x1651192E, 0xAF70BF3E, 0x58C31380,
+        0x5F98302E, 0x727CC3C4, 0x0A0FB402, 0x0F7FEF82,
+        0x8C96FDAD, 0x5D2C2AAE, 0x8EE99A49, 0x50DA88B8,
+        0x8427F4A0, 0x1EAC5790, 0x796FB449, 0x8252DC15,
+        0xEFBD7D9B, 0xA672597D, 0xADA840D8, 0x45F54504,
+        0xFA5D7403, 0xE83EC305, 0x4F91751A, 0x925669C2,
+        0x23EFE941, 0xA903F12E, 0x60270DF2, 0x0276E4B6,
+        0x94FD6574, 0x927985B2, 0x8276DBCB, 0x02778176,
+        0xF8AF918D, 0x4E48F79E, 0x8F616DDF, 0xE29D840E,
+        0x842F7D83, 0x340CE5C8, 0x96BBB682, 0x93B4B148,
+        0xEF303CAB, 0x984FAF28, 0x779FAF9B, 0x92DC560D,
+        0x224D1E20, 0x8437AA88, 0x7D29DC96, 0x2756D3DC,
+        0x8B907CEE, 0xB51FD240, 0xE7C07CE3, 0xE566B4A1,
+        0xC3E9615E, 0x3CF8209D, 0x6094D1E3, 0xCD9CA341,
+        0x5C76460E, 0x00EA983B, 0xD4D67881, 0xFD47572C,
+        0xF76CEDD9, 0xBDA8229C, 0x127DADAA, 0x438A074E,
+        0x1F97C090, 0x081BDB8A, 0x93A07EBE, 0xB938CA15,
+        0x97B03CFF, 0x3DC2C0F8, 0x8D1AB2EC, 0x64380E51,
+        0x68CC7BFB, 0xD90F2788, 0x12490181, 0x5DE5FFD4,
+        0xDD7EF86A, 0x76A2E214, 0xB9A40368, 0x925D958F,
+        0x4B39FFFA, 0xBA39AEE9, 0xA4FFD30B, 0xFAF7933B,
+        0x6D498623, 0x193CBCFA, 0x27627545, 0x825CF47A,
+        0x61BD8BA0, 0xD11E42D1, 0xCEAD04F4, 0x127EA392,
+        0x10428DB7, 0x8272A972, 0x9270C4A8, 0x127DE50B,
+        0x285BA1C8, 0x3C62F44F, 0x35C0EAA5, 0xE805D231,
+        0x428929FB, 0xB4FCDF82, 0x4FB66A53, 0x0E7DC15B,
+        0x1F081FAB, 0x108618AE, 0xFCFD086D, 0xF9FF2889,
+        0x694BCC11, 0x236A5CAE, 0x12DECA4D, 0x2C3F8CC5,
+        0xD2D02DFE, 0xF8EF5896, 0xE4CF52DA, 0x95155B67,
+        0x494A488C, 0xB9B6A80C, 0x5C8F82BC, 0x89D36B45,
+        0x3A609437, 0xEC00C9A9, 0x44715253, 0x0A874B49,
+        0xD773BC40, 0x7C34671C, 0x02717EF6, 0x4FEB5536,
+        0xA2D02FFF, 0xD2BF60C4, 0xD43F03C0, 0x50B4EF6D,
+        0x07478CD1, 0x006E1888, 0xA2E53F55, 0xB9E6D4BC,
+        0xA2048016, 0x97573833, 0xD7207D67, 0xDE0F8F3D,
+        0x72F87B33, 0xABCC4F33, 0x7688C55D, 0x7B00A6B0,
+        0x947B0001, 0x570075D2, 0xF9BB88F8, 0x8942019E,
+        0x4264A5FF, 0x856302E0, 0x72DBD92B, 0xEE971B69,
+        0x6EA22FDE, 0x5F08AE2B, 0xAF7A616D, 0xE5C98767,
+        0xCF1FEBD2, 0x61EFC8C2, 0xF1AC2571, 0xCC8239C2,
+        0x67214CB8, 0xB1E583D1, 0xB7DC3E62, 0x7F10BDCE,
+        0xF90A5C38, 0x0FF0443D, 0x606E6DC6, 0x60543A49,
+        0x5727C148, 0x2BE98A1D, 0x8AB41738, 0x20E1BE24,
+        0xAF96DA0F, 0x68458425, 0x99833BE5, 0x600D457D,
+        0x282F9350, 0x8334B362, 0xD91D1120, 0x2B6D8DA0,
+        0x642B1E31, 0x9C305A00, 0x52BCE688, 0x1B03588A,
+        0xF7BAEFD5, 0x4142ED9C, 0xA4315C11, 0x83323EC5,
+        0xDFEF4636, 0xA133C501, 0xE9D3531C, 0xEE353783
+};
+
+static const u_int32_t cast_sbox4[256] = {
+        0x9DB30420, 0x1FB6E9DE, 0xA7BE7BEF, 0xD273A298,
+        0x4A4F7BDB, 0x64AD8C57, 0x85510443, 0xFA020ED1,
+        0x7E287AFF, 0xE60FB663, 0x095F35A1, 0x79EBF120,
+        0xFD059D43, 0x6497B7B1, 0xF3641F63, 0x241E4ADF,
+        0x28147F5F, 0x4FA2B8CD, 0xC9430040, 0x0CC32220,
+        0xFDD30B30, 0xC0A5374F, 0x1D2D00D9, 0x24147B15,
+        0xEE4D111A, 0x0FCA5167, 0x71FF904C, 0x2D195FFE,
+        0x1A05645F, 0x0C13FEFE, 0x081B08CA, 0x05170121,
+        0x80530100, 0xE83E5EFE, 0xAC9AF4F8, 0x7FE72701,
+        0xD2B8EE5F, 0x06DF4261, 0xBB9E9B8A, 0x7293EA25,
+        0xCE84FFDF, 0xF5718801, 0x3DD64B04, 0xA26F263B,
+        0x7ED48400, 0x547EEBE6, 0x446D4CA0, 0x6CF3D6F5,
+        0x2649ABDF, 0xAEA0C7F5, 0x36338CC1, 0x503F7E93,
+        0xD3772061, 0x11B638E1, 0x72500E03, 0xF80EB2BB,
+        0xABE0502E, 0xEC8D77DE, 0x57971E81, 0xE14F6746,
+        0xC9335400, 0x6920318F, 0x081DBB99, 0xFFC304A5,
+        0x4D351805, 0x7F3D5CE3, 0xA6C866C6, 0x5D5BCCA9,
+        0xDAEC6FEA, 0x9F926F91, 0x9F46222F, 0x3991467D,
+        0xA5BF6D8E, 0x1143C44F, 0x43958302, 0xD0214EEB,
+        0x022083B8, 0x3FB6180C, 0x18F8931E, 0x281658E6,
+        0x26486E3E, 0x8BD78A70, 0x7477E4C1, 0xB506E07C,
+        0xF32D0A25, 0x79098B02, 0xE4EABB81, 0x28123B23,
+        0x69DEAD38, 0x1574CA16, 0xDF871B62, 0x211C40B7,
+        0xA51A9EF9, 0x0014377B, 0x041E8AC8, 0x09114003,
+        0xBD59E4D2, 0xE3D156D5, 0x4FE876D5, 0x2F91A340,
+        0x557BE8DE, 0x00EAE4A7, 0x0CE5C2EC, 0x4DB4BBA6,
+        0xE756BDFF, 0xDD3369AC, 0xEC17B035, 0x06572327,
+        0x99AFC8B0, 0x56C8C391, 0x6B65811C, 0x5E146119,
+        0x6E85CB75, 0xBE07C002, 0xC2325577, 0x893FF4EC,
+        0x5BBFC92D, 0xD0EC3B25, 0xB7801AB7, 0x8D6D3B24,
+        0x20C763EF, 0xC366A5FC, 0x9C382880, 0x0ACE3205,
+        0xAAC9548A, 0xECA1D7C7, 0x041AFA32, 0x1D16625A,
+        0x6701902C, 0x9B757A54, 0x31D477F7, 0x9126B031,
+        0x36CC6FDB, 0xC70B8B46, 0xD9E66A48, 0x56E55A79,
+        0x026A4CEB, 0x52437EFF, 0x2F8F76B4, 0x0DF980A5,
+        0x8674CDE3, 0xEDDA04EB, 0x17A9BE04, 0x2C18F4DF,
+        0xB7747F9D, 0xAB2AF7B4, 0xEFC34D20, 0x2E096B7C,
+        0x1741A254, 0xE5B6A035, 0x213D42F6, 0x2C1C7C26,
+        0x61C2F50F, 0x6552DAF9, 0xD2C231F8, 0x25130F69,
+        0xD8167FA2, 0x0418F2C8, 0x001A96A6, 0x0D1526AB,
+        0x63315C21, 0x5E0A72EC, 0x49BAFEFD, 0x187908D9,
+        0x8D0DBD86, 0x311170A7, 0x3E9B640C, 0xCC3E10D7,
+        0xD5CAD3B6, 0x0CAEC388, 0xF73001E1, 0x6C728AFF,
+        0x71EAE2A1, 0x1F9AF36E, 0xCFCBD12F, 0xC1DE8417,
+        0xAC07BE6B, 0xCB44A1D8, 0x8B9B0F56, 0x013988C3,
+        0xB1C52FCA, 0xB4BE31CD, 0xD8782806, 0x12A3A4E2,
+        0x6F7DE532, 0x58FD7EB6, 0xD01EE900, 0x24ADFFC2,
+        0xF4990FC5, 0x9711AAC5, 0x001D7B95, 0x82E5E7D2,
+        0x109873F6, 0x00613096, 0xC32D9521, 0xADA121FF,
+        0x29908415, 0x7FBB977F, 0xAF9EB3DB, 0x29C9ED2A,
+        0x5CE2A465, 0xA730F32C, 0xD0AA3FE8, 0x8A5CC091,
+        0xD49E2CE7, 0x0CE454A9, 0xD60ACD86, 0x015F1919,
+        0x77079103, 0xDEA03AF6, 0x78A8565E, 0xDEE356DF,
+        0x21F05CBE, 0x8B75E387, 0xB3C50651, 0xB8A5C3EF,
+        0xD8EEB6D2, 0xE523BE77, 0xC2154529, 0x2F69EFDF,
+        0xAFE67AFB, 0xF470C4B2, 0xF3E0EB5B, 0xD6CC9876,
+        0x39E4460C, 0x1FDA8538, 0x1987832F, 0xCA007367,
+        0xA99144F8, 0x296B299E, 0x492FC295, 0x9266BEAB,
+        0xB5676E69, 0x9BD3DDDA, 0xDF7E052F, 0xDB25701C,
+        0x1B5E51EE, 0xF65324E6, 0x6AFCE36C, 0x0316CC04,
+        0x8644213E, 0xB7DC59D0, 0x7965291F, 0xCCD6FD43,
+        0x41823979, 0x932BCDF6, 0xB657C34D, 0x4EDFD282,
+        0x7AE5290C, 0x3CB9536B, 0x851E20FE, 0x9833557E,
+        0x13ECF0B0, 0xD3FFB372, 0x3F85C5C1, 0x0AEF7ED2
+};
+
+static const u_int32_t cast_sbox5[256] = {
+        0x7EC90C04, 0x2C6E74B9, 0x9B0E66DF, 0xA6337911,
+        0xB86A7FFF, 0x1DD358F5, 0x44DD9D44, 0x1731167F,
+        0x08FBF1FA, 0xE7F511CC, 0xD2051B00, 0x735ABA00,
+        0x2AB722D8, 0x386381CB, 0xACF6243A, 0x69BEFD7A,
+        0xE6A2E77F, 0xF0C720CD, 0xC4494816, 0xCCF5C180,
+        0x38851640, 0x15B0A848, 0xE68B18CB, 0x4CAADEFF,
+        0x5F480A01, 0x0412B2AA, 0x259814FC, 0x41D0EFE2,
+        0x4E40B48D, 0x248EB6FB, 0x8DBA1CFE, 0x41A99B02,
+        0x1A550A04, 0xBA8F65CB, 0x7251F4E7, 0x95A51725,
+        0xC106ECD7, 0x97A5980A, 0xC539B9AA, 0x4D79FE6A,
+        0xF2F3F763, 0x68AF8040, 0xED0C9E56, 0x11B4958B,
+        0xE1EB5A88, 0x8709E6B0, 0xD7E07156, 0x4E29FEA7,
+        0x6366E52D, 0x02D1C000, 0xC4AC8E05, 0x9377F571,
+        0x0C05372A, 0x578535F2, 0x2261BE02, 0xD642A0C9,
+        0xDF13A280, 0x74B55BD2, 0x682199C0, 0xD421E5EC,
+        0x53FB3CE8, 0xC8ADEDB3, 0x28A87FC9, 0x3D959981,
+        0x5C1FF900, 0xFE38D399, 0x0C4EFF0B, 0x062407EA,
+        0xAA2F4FB1, 0x4FB96976, 0x90C79505, 0xB0A8A774,
+        0xEF55A1FF, 0xE59CA2C2, 0xA6B62D27, 0xE66A4263,
+        0xDF65001F, 0x0EC50966, 0xDFDD55BC, 0x29DE0655,
+        0x911E739A, 0x17AF8975, 0x32C7911C, 0x89F89468,
+        0x0D01E980, 0x524755F4, 0x03B63CC9, 0x0CC844B2,
+        0xBCF3F0AA, 0x87AC36E9, 0xE53A7426, 0x01B3D82B,
+        0x1A9E7449, 0x64EE2D7E, 0xCDDBB1DA, 0x01C94910,
+        0xB868BF80, 0x0D26F3FD, 0x9342EDE7, 0x04A5C284,
+        0x636737B6, 0x50F5B616, 0xF24766E3, 0x8ECA36C1,
+        0x136E05DB, 0xFEF18391, 0xFB887A37, 0xD6E7F7D4,
+        0xC7FB7DC9, 0x3063FCDF, 0xB6F589DE, 0xEC2941DA,
+        0x26E46695, 0xB7566419, 0xF654EFC5, 0xD08D58B7,
+        0x48925401, 0xC1BACB7F, 0xE5FF550F, 0xB6083049,
+        0x5BB5D0E8, 0x87D72E5A, 0xAB6A6EE1, 0x223A66CE,
+        0xC62BF3CD, 0x9E0885F9, 0x68CB3E47, 0x086C010F,
+        0xA21DE820, 0xD18B69DE, 0xF3F65777, 0xFA02C3F6,
+        0x407EDAC3, 0xCBB3D550, 0x1793084D, 0xB0D70EBA,
+        0x0AB378D5, 0xD951FB0C, 0xDED7DA56, 0x4124BBE4,
+        0x94CA0B56, 0x0F5755D1, 0xE0E1E56E, 0x6184B5BE,
+        0x580A249F, 0x94F74BC0, 0xE327888E, 0x9F7B5561,
+        0xC3DC0280, 0x05687715, 0x646C6BD7, 0x44904DB3,
+        0x66B4F0A3, 0xC0F1648A, 0x697ED5AF, 0x49E92FF6,
+        0x309E374F, 0x2CB6356A, 0x85808573, 0x4991F840,
+        0x76F0AE02, 0x083BE84D, 0x28421C9A, 0x44489406,
+        0x736E4CB8, 0xC1092910, 0x8BC95FC6, 0x7D869CF4,
+        0x134F616F, 0x2E77118D, 0xB31B2BE1, 0xAA90B472,
+        0x3CA5D717, 0x7D161BBA, 0x9CAD9010, 0xAF462BA2,
+        0x9FE459D2, 0x45D34559, 0xD9F2DA13, 0xDBC65487,
+        0xF3E4F94E, 0x176D486F, 0x097C13EA, 0x631DA5C7,
+        0x445F7382, 0x175683F4, 0xCDC66A97, 0x70BE0288,
+        0xB3CDCF72, 0x6E5DD2F3, 0x20936079, 0x459B80A5,
+        0xBE60E2DB, 0xA9C23101, 0xEBA5315C, 0x224E42F2,
+        0x1C5C1572, 0xF6721B2C, 0x1AD2FFF3, 0x8C25404E,
+        0x324ED72F, 0x4067B7FD, 0x0523138E, 0x5CA3BC78,
+        0xDC0FD66E, 0x75922283, 0x784D6B17, 0x58EBB16E,
+        0x44094F85, 0x3F481D87, 0xFCFEAE7B, 0x77B5FF76,
+        0x8C2302BF, 0xAAF47556, 0x5F46B02A, 0x2B092801,
+        0x3D38F5F7, 0x0CA81F36, 0x52AF4A8A, 0x66D5E7C0,
+        0xDF3B0874, 0x95055110, 0x1B5AD7A8, 0xF61ED5AD,
+        0x6CF6E479, 0x20758184, 0xD0CEFA65, 0x88F7BE58,
+        0x4A046826, 0x0FF6F8F3, 0xA09C7F70, 0x5346ABA0,
+        0x5CE96C28, 0xE176EDA3, 0x6BAC307F, 0x376829D2,
+        0x85360FA9, 0x17E3FE2A, 0x24B79767, 0xF5A96B20,
+        0xD6CD2595, 0x68FF1EBF, 0x7555442C, 0xF19F06BE,
+        0xF9E0659A, 0xEEB9491D, 0x34010718, 0xBB30CAB8,
+        0xE822FE15, 0x88570983, 0x750E6249, 0xDA627E55,
+        0x5E76FFA8, 0xB1534546, 0x6D47DE08, 0xEFE9E7D4
+};
+
+static const u_int32_t cast_sbox6[256] = {
+        0xF6FA8F9D, 0x2CAC6CE1, 0x4CA34867, 0xE2337F7C,
+        0x95DB08E7, 0x016843B4, 0xECED5CBC, 0x325553AC,
+        0xBF9F0960, 0xDFA1E2ED, 0x83F0579D, 0x63ED86B9,
+        0x1AB6A6B8, 0xDE5EBE39, 0xF38FF732, 0x8989B138,
+        0x33F14961, 0xC01937BD, 0xF506C6DA, 0xE4625E7E,
+        0xA308EA99, 0x4E23E33C, 0x79CBD7CC, 0x48A14367,
+        0xA3149619, 0xFEC94BD5, 0xA114174A, 0xEAA01866,
+        0xA084DB2D, 0x09A8486F, 0xA888614A, 0x2900AF98,
+        0x01665991, 0xE1992863, 0xC8F30C60, 0x2E78EF3C,
+        0xD0D51932, 0xCF0FEC14, 0xF7CA07D2, 0xD0A82072,
+        0xFD41197E, 0x9305A6B0, 0xE86BE3DA, 0x74BED3CD,
+        0x372DA53C, 0x4C7F4448, 0xDAB5D440, 0x6DBA0EC3,
+        0x083919A7, 0x9FBAEED9, 0x49DBCFB0, 0x4E670C53,
+        0x5C3D9C01, 0x64BDB941, 0x2C0E636A, 0xBA7DD9CD,
+        0xEA6F7388, 0xE70BC762, 0x35F29ADB, 0x5C4CDD8D,
+        0xF0D48D8C, 0xB88153E2, 0x08A19866, 0x1AE2EAC8,
+        0x284CAF89, 0xAA928223, 0x9334BE53, 0x3B3A21BF,
+        0x16434BE3, 0x9AEA3906, 0xEFE8C36E, 0xF890CDD9,
+        0x80226DAE, 0xC340A4A3, 0xDF7E9C09, 0xA694A807,
+        0x5B7C5ECC, 0x221DB3A6, 0x9A69A02F, 0x68818A54,
+        0xCEB2296F, 0x53C0843A, 0xFE893655, 0x25BFE68A,
+        0xB4628ABC, 0xCF222EBF, 0x25AC6F48, 0xA9A99387,
+        0x53BDDB65, 0xE76FFBE7, 0xE967FD78, 0x0BA93563,
+        0x8E342BC1, 0xE8A11BE9, 0x4980740D, 0xC8087DFC,
+        0x8DE4BF99, 0xA11101A0, 0x7FD37975, 0xDA5A26C0,
+        0xE81F994F, 0x9528CD89, 0xFD339FED, 0xB87834BF,
+        0x5F04456D, 0x22258698, 0xC9C4C83B, 0x2DC156BE,
+        0x4F628DAA, 0x57F55EC5, 0xE2220ABE, 0xD2916EBF,
+        0x4EC75B95, 0x24F2C3C0, 0x42D15D99, 0xCD0D7FA0,
+        0x7B6E27FF, 0xA8DC8AF0, 0x7345C106, 0xF41E232F,
+        0x35162386, 0xE6EA8926, 0x3333B094, 0x157EC6F2,
+        0x372B74AF, 0x692573E4, 0xE9A9D848, 0xF3160289,
+        0x3A62EF1D, 0xA787E238, 0xF3A5F676, 0x74364853,
+        0x20951063, 0x4576698D, 0xB6FAD407, 0x592AF950,
+        0x36F73523, 0x4CFB6E87, 0x7DA4CEC0, 0x6C152DAA,
+        0xCB0396A8, 0xC50DFE5D, 0xFCD707AB, 0x0921C42F,
+        0x89DFF0BB, 0x5FE2BE78, 0x448F4F33, 0x754613C9,
+        0x2B05D08D, 0x48B9D585, 0xDC049441, 0xC8098F9B,
+        0x7DEDE786, 0xC39A3373, 0x42410005, 0x6A091751,
+        0x0EF3C8A6, 0x890072D6, 0x28207682, 0xA9A9F7BE,
+        0xBF32679D, 0xD45B5B75, 0xB353FD00, 0xCBB0E358,
+        0x830F220A, 0x1F8FB214, 0xD372CF08, 0xCC3C4A13,
+        0x8CF63166, 0x061C87BE, 0x88C98F88, 0x6062E397,
+        0x47CF8E7A, 0xB6C85283, 0x3CC2ACFB, 0x3FC06976,
+        0x4E8F0252, 0x64D8314D, 0xDA3870E3, 0x1E665459,
+        0xC10908F0, 0x513021A5, 0x6C5B68B7, 0x822F8AA0,
+        0x3007CD3E, 0x74719EEF, 0xDC872681, 0x073340D4,
+        0x7E432FD9, 0x0C5EC241, 0x8809286C, 0xF592D891,
+        0x08A930F6, 0x957EF305, 0xB7FBFFBD, 0xC266E96F,
+        0x6FE4AC98, 0xB173ECC0, 0xBC60B42A, 0x953498DA,
+        0xFBA1AE12, 0x2D4BD736, 0x0F25FAAB, 0xA4F3FCEB,
+        0xE2969123, 0x257F0C3D, 0x9348AF49, 0x361400BC,
+        0xE8816F4A, 0x3814F200, 0xA3F94043, 0x9C7A54C2,
+        0xBC704F57, 0xDA41E7F9, 0xC25AD33A, 0x54F4A084,
+        0xB17F5505, 0x59357CBE, 0xEDBD15C8, 0x7F97C5AB,
+        0xBA5AC7B5, 0xB6F6DEAF, 0x3A479C3A, 0x5302DA25,
+        0x653D7E6A, 0x54268D49, 0x51A477EA, 0x5017D55B,
+        0xD7D25D88, 0x44136C76, 0x0404A8C8, 0xB8E5A121,
+        0xB81A928A, 0x60ED5869, 0x97C55B96, 0xEAEC991B,
+        0x29935913, 0x01FDB7F1, 0x088E8DFA, 0x9AB6F6F5,
+        0x3B4CBF9F, 0x4A5DE3AB, 0xE6051D35, 0xA0E1D855,
+        0xD36B4CF1, 0xF544EDEB, 0xB0E93524, 0xBEBB8FBD,
+        0xA2D762CF, 0x49C92F54, 0x38B5F331, 0x7128A454,
+        0x48392905, 0xA65B1DB8, 0x851C97BD, 0xD675CF2F
+};
+
+static const u_int32_t cast_sbox7[256] = {
+        0x85E04019, 0x332BF567, 0x662DBFFF, 0xCFC65693,
+        0x2A8D7F6F, 0xAB9BC912, 0xDE6008A1, 0x2028DA1F,
+        0x0227BCE7, 0x4D642916, 0x18FAC300, 0x50F18B82,
+        0x2CB2CB11, 0xB232E75C, 0x4B3695F2, 0xB28707DE,
+        0xA05FBCF6, 0xCD4181E9, 0xE150210C, 0xE24EF1BD,
+        0xB168C381, 0xFDE4E789, 0x5C79B0D8, 0x1E8BFD43,
+        0x4D495001, 0x38BE4341, 0x913CEE1D, 0x92A79C3F,
+        0x089766BE, 0xBAEEADF4, 0x1286BECF, 0xB6EACB19,
+        0x2660C200, 0x7565BDE4, 0x64241F7A, 0x8248DCA9,
+        0xC3B3AD66, 0x28136086, 0x0BD8DFA8, 0x356D1CF2,
+        0x107789BE, 0xB3B2E9CE, 0x0502AA8F, 0x0BC0351E,
+        0x166BF52A, 0xEB12FF82, 0xE3486911, 0xD34D7516,
+        0x4E7B3AFF, 0x5F43671B, 0x9CF6E037, 0x4981AC83,
+        0x334266CE, 0x8C9341B7, 0xD0D854C0, 0xCB3A6C88,
+        0x47BC2829, 0x4725BA37, 0xA66AD22B, 0x7AD61F1E,
+        0x0C5CBAFA, 0x4437F107, 0xB6E79962, 0x42D2D816,
+        0x0A961288, 0xE1A5C06E, 0x13749E67, 0x72FC081A,
+        0xB1D139F7, 0xF9583745, 0xCF19DF58, 0xBEC3F756,
+        0xC06EBA30, 0x07211B24, 0x45C28829, 0xC95E317F,
+        0xBC8EC511, 0x38BC46E9, 0xC6E6FA14, 0xBAE8584A,
+        0xAD4EBC46, 0x468F508B, 0x7829435F, 0xF124183B,
+        0x821DBA9F, 0xAFF60FF4, 0xEA2C4E6D, 0x16E39264,
+        0x92544A8B, 0x009B4FC3, 0xABA68CED, 0x9AC96F78,
+        0x06A5B79A, 0xB2856E6E, 0x1AEC3CA9, 0xBE838688,
+        0x0E0804E9, 0x55F1BE56, 0xE7E5363B, 0xB3A1F25D,
+        0xF7DEBB85, 0x61FE033C, 0x16746233, 0x3C034C28,
+        0xDA6D0C74, 0x79AAC56C, 0x3CE4E1AD, 0x51F0C802,
+        0x98F8F35A, 0x1626A49F, 0xEED82B29, 0x1D382FE3,
+        0x0C4FB99A, 0xBB325778, 0x3EC6D97B, 0x6E77A6A9,
+        0xCB658B5C, 0xD45230C7, 0x2BD1408B, 0x60C03EB7,
+        0xB9068D78, 0xA33754F4, 0xF430C87D, 0xC8A71302,
+        0xB96D8C32, 0xEBD4E7BE, 0xBE8B9D2D, 0x7979FB06,
+        0xE7225308, 0x8B75CF77, 0x11EF8DA4, 0xE083C858,
+        0x8D6B786F, 0x5A6317A6, 0xFA5CF7A0, 0x5DDA0033,
+        0xF28EBFB0, 0xF5B9C310, 0xA0EAC280, 0x08B9767A,
+        0xA3D9D2B0, 0x79D34217, 0x021A718D, 0x9AC6336A,
+        0x2711FD60, 0x438050E3, 0x069908A8, 0x3D7FEDC4,
+        0x826D2BEF, 0x4EEB8476, 0x488DCF25, 0x36C9D566,
+        0x28E74E41, 0xC2610ACA, 0x3D49A9CF, 0xBAE3B9DF,
+        0xB65F8DE6, 0x92AEAF64, 0x3AC7D5E6, 0x9EA80509,
+        0xF22B017D, 0xA4173F70, 0xDD1E16C3, 0x15E0D7F9,
+        0x50B1B887, 0x2B9F4FD5, 0x625ABA82, 0x6A017962,
+        0x2EC01B9C, 0x15488AA9, 0xD716E740, 0x40055A2C,
+        0x93D29A22, 0xE32DBF9A, 0x058745B9, 0x3453DC1E,
+        0xD699296E, 0x496CFF6F, 0x1C9F4986, 0xDFE2ED07,
+        0xB87242D1, 0x19DE7EAE, 0x053E561A, 0x15AD6F8C,
+        0x66626C1C, 0x7154C24C, 0xEA082B2A, 0x93EB2939,
+        0x17DCB0F0, 0x58D4F2AE, 0x9EA294FB, 0x52CF564C,
+        0x9883FE66, 0x2EC40581, 0x763953C3, 0x01D6692E,
+        0xD3A0C108, 0xA1E7160E, 0xE4F2DFA6, 0x693ED285,
+        0x74904698, 0x4C2B0EDD, 0x4F757656, 0x5D393378,
+        0xA132234F, 0x3D321C5D, 0xC3F5E194, 0x4B269301,
+        0xC79F022F, 0x3C997E7E, 0x5E4F9504, 0x3FFAFBBD,
+        0x76F7AD0E, 0x296693F4, 0x3D1FCE6F, 0xC61E45BE,
+        0xD3B5AB34, 0xF72BF9B7, 0x1B0434C0, 0x4E72B567,
+        0x5592A33D, 0xB5229301, 0xCFD2A87F, 0x60AEB767,
+        0x1814386B, 0x30BCC33D, 0x38A0C07D, 0xFD1606F2,
+        0xC363519B, 0x589DD390, 0x5479F8E6, 0x1CB8D647,
+        0x97FD61A9, 0xEA7759F4, 0x2D57539D, 0x569A58CF,
+        0xE84E63AD, 0x462E1B78, 0x6580F87E, 0xF3817914,
+        0x91DA55F4, 0x40A230F3, 0xD1988F35, 0xB6E318D2,
+        0x3FFA50BC, 0x3D40F021, 0xC3C0BDAE, 0x4958C24C,
+        0x518F36B2, 0x84B1D370, 0x0FEDCE83, 0x878DDADA,
+        0xF2A279C7, 0x94E01BE8, 0x90716F4B, 0x954B8AA3
+};
+
+static const u_int32_t cast_sbox8[256] = {
+        0xE216300D, 0xBBDDFFFC, 0xA7EBDABD, 0x35648095,
+        0x7789F8B7, 0xE6C1121B, 0x0E241600, 0x052CE8B5,
+        0x11A9CFB0, 0xE5952F11, 0xECE7990A, 0x9386D174,
+        0x2A42931C, 0x76E38111, 0xB12DEF3A, 0x37DDDDFC,
+        0xDE9ADEB1, 0x0A0CC32C, 0xBE197029, 0x84A00940,
+        0xBB243A0F, 0xB4D137CF, 0xB44E79F0, 0x049EEDFD,
+        0x0B15A15D, 0x480D3168, 0x8BBBDE5A, 0x669DED42,
+        0xC7ECE831, 0x3F8F95E7, 0x72DF191B, 0x7580330D,
+        0x94074251, 0x5C7DCDFA, 0xABBE6D63, 0xAA402164,
+        0xB301D40A, 0x02E7D1CA, 0x53571DAE, 0x7A3182A2,
+        0x12A8DDEC, 0xFDAA335D, 0x176F43E8, 0x71FB46D4,
+        0x38129022, 0xCE949AD4, 0xB84769AD, 0x965BD862,
+        0x82F3D055, 0x66FB9767, 0x15B80B4E, 0x1D5B47A0,
+        0x4CFDE06F, 0xC28EC4B8, 0x57E8726E, 0x647A78FC,
+        0x99865D44, 0x608BD593, 0x6C200E03, 0x39DC5FF6,
+        0x5D0B00A3, 0xAE63AFF2, 0x7E8BD632, 0x70108C0C,
+        0xBBD35049, 0x2998DF04, 0x980CF42A, 0x9B6DF491,
+        0x9E7EDD53, 0x06918548, 0x58CB7E07, 0x3B74EF2E,
+        0x522FFFB1, 0xD24708CC, 0x1C7E27CD, 0xA4EB215B,
+        0x3CF1D2E2, 0x19B47A38, 0x424F7618, 0x35856039,
+        0x9D17DEE7, 0x27EB35E6, 0xC9AFF67B, 0x36BAF5B8,
+        0x09C467CD, 0xC18910B1, 0xE11DBF7B, 0x06CD1AF8,
+        0x7170C608, 0x2D5E3354, 0xD4DE495A, 0x64C6D006,
+        0xBCC0C62C, 0x3DD00DB3, 0x708F8F34, 0x77D51B42,
+        0x264F620F, 0x24B8D2BF, 0x15C1B79E, 0x46A52564,
+        0xF8D7E54E, 0x3E378160, 0x7895CDA5, 0x859C15A5,
+        0xE6459788, 0xC37BC75F, 0xDB07BA0C, 0x0676A3AB,
+        0x7F229B1E, 0x31842E7B, 0x24259FD7, 0xF8BEF472,
+        0x835FFCB8, 0x6DF4C1F2, 0x96F5B195, 0xFD0AF0FC,
+        0xB0FE134C, 0xE2506D3D, 0x4F9B12EA, 0xF215F225,
+        0xA223736F, 0x9FB4C428, 0x25D04979, 0x34C713F8,
+        0xC4618187, 0xEA7A6E98, 0x7CD16EFC, 0x1436876C,
+        0xF1544107, 0xBEDEEE14, 0x56E9AF27, 0xA04AA441,
+        0x3CF7C899, 0x92ECBAE6, 0xDD67016D, 0x151682EB,
+        0xA842EEDF, 0xFDBA60B4, 0xF1907B75, 0x20E3030F,
+        0x24D8C29E, 0xE139673B, 0xEFA63FB8, 0x71873054,
+        0xB6F2CF3B, 0x9F326442, 0xCB15A4CC, 0xB01A4504,
+        0xF1E47D8D, 0x844A1BE5, 0xBAE7DFDC, 0x42CBDA70,
+        0xCD7DAE0A, 0x57E85B7A, 0xD53F5AF6, 0x20CF4D8C,
+        0xCEA4D428, 0x79D130A4, 0x3486EBFB, 0x33D3CDDC,
+        0x77853B53, 0x37EFFCB5, 0xC5068778, 0xE580B3E6,
+        0x4E68B8F4, 0xC5C8B37E, 0x0D809EA2, 0x398FEB7C,
+        0x132A4F94, 0x43B7950E, 0x2FEE7D1C, 0x223613BD,
+        0xDD06CAA2, 0x37DF932B, 0xC4248289, 0xACF3EBC3,
+        0x5715F6B7, 0xEF3478DD, 0xF267616F, 0xC148CBE4,
+        0x9052815E, 0x5E410FAB, 0xB48A2465, 0x2EDA7FA4,
+        0xE87B40E4, 0xE98EA084, 0x5889E9E1, 0xEFD390FC,
+        0xDD07D35B, 0xDB485694, 0x38D7E5B2, 0x57720101,
+        0x730EDEBC, 0x5B643113, 0x94917E4F, 0x503C2FBA,
+        0x646F1282, 0x7523D24A, 0xE0779695, 0xF9C17A8F,
+        0x7A5B2121, 0xD187B896, 0x29263A4D, 0xBA510CDF,
+        0x81F47C9F, 0xAD1163ED, 0xEA7B5965, 0x1A00726E,
+        0x11403092, 0x00DA6D77, 0x4A0CDD61, 0xAD1F4603,
+        0x605BDFB0, 0x9EEDC364, 0x22EBE6A8, 0xCEE7D28A,
+        0xA0E736A0, 0x5564A6B9, 0x10853209, 0xC7EB8F37,
+        0x2DE705CA, 0x8951570F, 0xDF09822B, 0xBD691A6C,
+        0xAA12E4F2, 0x87451C0F, 0xE0F6A27A, 0x3ADA4819,
+        0x4CF1764F, 0x0D771C2B, 0x67CDB156, 0x350D8384,
+        0x5938FA0F, 0x42399EF3, 0x36997B07, 0x0E84093D,
+        0x4AA93E61, 0x8360D87B, 0x1FA98B0C, 0x1149382C,
+        0xE97625A5, 0x0614D1B7, 0x0E25244B, 0x0C768347,
+        0x589E8D82, 0x0D2059D1, 0xA466BB1E, 0xF8DA0A82,
+        0x04F19130, 0xBA6E4EC0, 0x99265164, 0x1EE7230D,
+        0x50B2AD80, 0xEAEE6801, 0x8DB2A283, 0xEA8BF59E
+};
+
+/* Macros to access 8-bit bytes out of a 32-bit word */
+#define U8a(x) ( (u_int8_t) (x>>24) )
+#define U8b(x) ( (u_int8_t) ((x>>16)&255) )
+#define U8c(x) ( (u_int8_t) ((x>>8)&255) )
+#define U8d(x) ( (u_int8_t) ((x)&255) )
+
+/* Circular left shift */
+#define ROL(x, n) ( ((x)<<(n)) | ((x)>>(32-(n))) )
+
+/* CAST-128 uses three different round functions */
+#define F1(l, r, i) \
+        t = ROL(key->xkey[i] + r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] ^ cast_sbox2[U8b(t)]) - \
+         cast_sbox3[U8c(t)]) + cast_sbox4[U8d(t)];
+#define F2(l, r, i) \
+        t = ROL(key->xkey[i] ^ r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] - cast_sbox2[U8b(t)]) + \
+         cast_sbox3[U8c(t)]) ^ cast_sbox4[U8d(t)];
+#define F3(l, r, i) \
+        t = ROL(key->xkey[i] - r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] + cast_sbox2[U8b(t)]) ^ \
+         cast_sbox3[U8c(t)]) - cast_sbox4[U8d(t)];
+
+
+/***** Encryption Function *****/
+
+void
+cast_encrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock)
+{
+        u_int32_t t, l, r;
+
+        /* Get inblock into l,r */
+        l = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) |
+            ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3];
+        r = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) |
+            ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7];
+        /* Do the work */
+        F1(l, r,  0);
+        F2(r, l,  1);
+        F3(l, r,  2);
+        F1(r, l,  3);
+        F2(l, r,  4);
+        F3(r, l,  5);
+        F1(l, r,  6);
+        F2(r, l,  7);
+        F3(l, r,  8);
+        F1(r, l,  9);
+        F2(l, r, 10);
+        F3(r, l, 11);
+        /* Only do full 16 rounds if key length > 80 bits */
+        if (key->rounds > 12) {
+                F1(l, r, 12);
+                F2(r, l, 13);
+                F3(l, r, 14);
+                F1(r, l, 15);
+        }
+        /* Put l,r into outblock */
+        outblock[0] = U8a(r);
+        outblock[1] = U8b(r);
+        outblock[2] = U8c(r);
+        outblock[3] = U8d(r);
+        outblock[4] = U8a(l);
+        outblock[5] = U8b(l);
+        outblock[6] = U8c(l);
+        outblock[7] = U8d(l);
+        /* Wipe clean */
+        t = l = r = 0;
+}
+
+
+/***** Decryption Function *****/
+
+void
+cast_decrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock)
+{
+        u_int32_t t, l, r;
+
+        /* Get inblock into l,r */
+        r = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) |
+            ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3];
+        l = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) |
+            ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7];
+        /* Do the work */
+        /* Only do full 16 rounds if key length > 80 bits */
+        if (key->rounds > 12) {
+                F1(r, l, 15);
+                F3(l, r, 14);
+                F2(r, l, 13);
+                F1(l, r, 12);
+        }
+        F3(r, l, 11);
+        F2(l, r, 10);
+        F1(r, l,  9);
+        F3(l, r,  8);
+        F2(r, l,  7);
+        F1(l, r,  6);
+        F3(r, l,  5);
+        F2(l, r,  4);
+        F1(r, l,  3);
+        F3(l, r,  2);
+        F2(r, l,  1);
+        F1(l, r,  0);
+        /* Put l,r into outblock */
+        outblock[0] = U8a(l);
+        outblock[1] = U8b(l);
+        outblock[2] = U8c(l);
+        outblock[3] = U8d(l);
+        outblock[4] = U8a(r);
+        outblock[5] = U8b(r);
+        outblock[6] = U8c(r);
+        outblock[7] = U8d(r);
+        /* Wipe clean */
+        t = l = r = 0;
+}
+
+
+/***** Key Schedual *****/
+
+void
+cast_setkey(cast_key* key, u_int8_t* rawkey, int keybytes)
+{
+        u_int32_t t[4], z[4], x[4];
+        int i;
+
+        /* Set number of rounds to 12 or 16, depending on key length */
+        key->rounds = (keybytes <= 10 ? 12 : 16);
+
+        /* Copy key to workspace x */
+        for (i = 0; i < 4; i++) {
+                x[i] = 0;
+                if ((i*4+0) < keybytes) x[i] = (u_int32_t)rawkey[i*4+0] << 24;
+                if ((i*4+1) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+1] << 16;
+                if ((i*4+2) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+2] << 8;
+                if ((i*4+3) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+3];
+        }
+        /* Generate 32 subkeys, four at a time */
+        for (i = 0; i < 32; i+=4) {
+                switch (i & 4) {
+                case 0:
+                        t[0] = z[0] = x[0] ^ cast_sbox5[U8b(x[3])] ^
+                            cast_sbox6[U8d(x[3])] ^ cast_sbox7[U8a(x[3])] ^
+                            cast_sbox8[U8c(x[3])] ^ cast_sbox7[U8a(x[2])];
+                        t[1] = z[1] = x[2] ^ cast_sbox5[U8a(z[0])] ^
+                            cast_sbox6[U8c(z[0])] ^ cast_sbox7[U8b(z[0])] ^
+                            cast_sbox8[U8d(z[0])] ^ cast_sbox8[U8c(x[2])];
+                        t[2] = z[2] = x[3] ^ cast_sbox5[U8d(z[1])] ^
+                            cast_sbox6[U8c(z[1])] ^ cast_sbox7[U8b(z[1])] ^
+                            cast_sbox8[U8a(z[1])] ^ cast_sbox5[U8b(x[2])];
+                        t[3] = z[3] = x[1] ^ cast_sbox5[U8c(z[2])] ^
+                            cast_sbox6[U8b(z[2])] ^ cast_sbox7[U8d(z[2])] ^
+                            cast_sbox8[U8a(z[2])] ^ cast_sbox6[U8d(x[2])];
+                        break;
+                case 4:
+                        t[0] = x[0] = z[2] ^ cast_sbox5[U8b(z[1])] ^
+                            cast_sbox6[U8d(z[1])] ^ cast_sbox7[U8a(z[1])] ^
+                            cast_sbox8[U8c(z[1])] ^ cast_sbox7[U8a(z[0])];
+                        t[1] = x[1] = z[0] ^ cast_sbox5[U8a(x[0])] ^
+                            cast_sbox6[U8c(x[0])] ^ cast_sbox7[U8b(x[0])] ^
+                            cast_sbox8[U8d(x[0])] ^ cast_sbox8[U8c(z[0])];
+                        t[2] = x[2] = z[1] ^ cast_sbox5[U8d(x[1])] ^
+                            cast_sbox6[U8c(x[1])] ^ cast_sbox7[U8b(x[1])] ^
+                            cast_sbox8[U8a(x[1])] ^ cast_sbox5[U8b(z[0])];
+                        t[3] = x[3] = z[3] ^ cast_sbox5[U8c(x[2])] ^
+                            cast_sbox6[U8b(x[2])] ^ cast_sbox7[U8d(x[2])] ^
+                            cast_sbox8[U8a(x[2])] ^ cast_sbox6[U8d(z[0])];
+                        break;
+                }
+                switch (i & 12) {
+                case 0:
+                case 12:
+                        key->xkey[i+0] = cast_sbox5[U8a(t[2])] ^
+                            cast_sbox6[U8b(t[2])] ^ cast_sbox7[U8d(t[1])] ^
+                            cast_sbox8[U8c(t[1])];
+                        key->xkey[i+1] = cast_sbox5[U8c(t[2])] ^
+                            cast_sbox6[U8d(t[2])] ^ cast_sbox7[U8b(t[1])] ^
+                            cast_sbox8[U8a(t[1])];
+                        key->xkey[i+2] = cast_sbox5[U8a(t[3])] ^
+                            cast_sbox6[U8b(t[3])] ^ cast_sbox7[U8d(t[0])] ^
+                            cast_sbox8[U8c(t[0])];
+                        key->xkey[i+3] = cast_sbox5[U8c(t[3])] ^
+                            cast_sbox6[U8d(t[3])] ^ cast_sbox7[U8b(t[0])] ^
+                            cast_sbox8[U8a(t[0])];
+                        break;
+                case 4:
+                case 8:
+                        key->xkey[i+0] = cast_sbox5[U8d(t[0])] ^
+                            cast_sbox6[U8c(t[0])] ^ cast_sbox7[U8a(t[3])] ^
+                            cast_sbox8[U8b(t[3])];
+                        key->xkey[i+1] = cast_sbox5[U8b(t[0])] ^
+                            cast_sbox6[U8a(t[0])] ^ cast_sbox7[U8c(t[3])] ^
+                            cast_sbox8[U8d(t[3])];
+                        key->xkey[i+2] = cast_sbox5[U8d(t[1])] ^
+                            cast_sbox6[U8c(t[1])] ^ cast_sbox7[U8a(t[2])] ^
+                            cast_sbox8[U8b(t[2])];
+                        key->xkey[i+3] = cast_sbox5[U8b(t[1])] ^
+                            cast_sbox6[U8a(t[1])] ^ cast_sbox7[U8c(t[2])] ^
+                            cast_sbox8[U8d(t[2])];
+                        break;
+                }
+                switch (i & 12) {
+                case 0:
+                        key->xkey[i+0] ^= cast_sbox5[U8c(z[0])];
+                        key->xkey[i+1] ^= cast_sbox6[U8c(z[1])];
+                        key->xkey[i+2] ^= cast_sbox7[U8b(z[2])];
+                        key->xkey[i+3] ^= cast_sbox8[U8a(z[3])];
+                        break;
+                case 4:
+                        key->xkey[i+0] ^= cast_sbox5[U8a(x[2])];
+                        key->xkey[i+1] ^= cast_sbox6[U8b(x[3])];
+                        key->xkey[i+2] ^= cast_sbox7[U8d(x[0])];
+                        key->xkey[i+3] ^= cast_sbox8[U8d(x[1])];
+                        break;
+                case 8:
+                        key->xkey[i+0] ^= cast_sbox5[U8b(z[2])];
+                        key->xkey[i+1] ^= cast_sbox6[U8a(z[3])];
+                        key->xkey[i+2] ^= cast_sbox7[U8c(z[0])];
+                        key->xkey[i+3] ^= cast_sbox8[U8c(z[1])];
+                        break;
+                case 12:
+                        key->xkey[i+0] ^= cast_sbox5[U8d(x[0])];
+                        key->xkey[i+1] ^= cast_sbox6[U8d(x[1])];
+                        key->xkey[i+2] ^= cast_sbox7[U8a(x[2])];
+                        key->xkey[i+3] ^= cast_sbox8[U8b(x[3])];
+                        break;
+                }
+                if (i >= 16) {
+                        key->xkey[i+0] &= 31;
+                        key->xkey[i+1] &= 31;
+                        key->xkey[i+2] &= 31;
+                        key->xkey[i+3] &= 31;
+                }
+        }
+        /* Wipe clean */
+        for (i = 0; i < 4; i++) {
+                t[i] = x[i] = z[i] = 0;
+        }
+}
+
+/* Made in Canada */
+
diff --git a/src/lib/libc/crypt/crypt.3 b/src/lib/libc/crypt/crypt.3
new file mode 100644
index 0000000000..bcfa12f18f
--- /dev/null
+++ b/src/lib/libc/crypt/crypt.3
@@ -0,0 +1,324 @@
+.\" $OpenBSD: crypt.3,v 1.25 2005/10/02 08:06:52 jmc Exp $
+.\"
+.\" FreeSec: libcrypt
+.\"
+.\" Copyright (c) 1994 David Burren
+.\" 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.
+.\" 4. Neither the name of the author nor the names of other contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd March 9, 1994
+.Dt CRYPT 3
+.Os
+.Sh NAME
+.Nm crypt ,
+.Nm setkey ,
+.Nm encrypt ,
+.Nm des_setkey ,
+.Nm des_cipher ,
+.Nm bcrypt_gensalt ,
+.Nm bcrypt ,
+.Nm md5crypt
+.Nd DES encryption
+.Sh SYNOPSIS
+.Fd #include <pwd.h>
+.Fd #include <unistd.h>
+.Ft char *
+.Fn crypt "const char *key" "const char *setting"
+.Ft int
+.Fn setkey "const char *key"
+.Ft int
+.Fn encrypt "char *block" "int flag"
+.Ft int
+.Fn des_setkey "const char *key"
+.Ft int
+.Fn des_cipher "const char *in" "char *out" "int32_t salt" "int count"
+.Ft char *
+.Fn bcrypt_gensalt "u_int8_t log_rounds"
+.Ft char *
+.Fn bcrypt "const char *key" "const char *salt"
+.Ft char *
+.Fn md5crypt "const char *key" "const char *salt"
+.Sh DESCRIPTION
+The
+.Fn crypt
+function performs password encryption based on the
+.Tn NBS
+Data Encryption Standard (DES).
+Additional code has been added to deter key search attempts and to use
+stronger hashing algorithms.
+.Pp
+The first argument to
+.Fn crypt
+is a
+.Dv NUL Ns -terminated
+string, typically a user's typed password.
+The second is in one of three forms:
+if it begins with an underscore
+.Pq Ql _
+then an extended format is used
+in interpreting both the key and the setting, as outlined below.
+If it begins
+with a string character
+.Pq Ql $
+and a number then a different algorithm is used depending on the number.
+At the moment a
+.Ql $1
+chooses MD5 hashing and a
+.Ql $2
+chooses Blowfish hashing; see below for more information.
+.Ss Extended crypt
+The
+.Ar key
+is divided into groups of 8 characters (the last group is null-padded)
+and the low-order 7 bits of each character (56 bits per group) are
+used to form the DES key as follows:
+the first group of 56 bits becomes the initial DES key.
+For each additional group, the XOR of the encryption of the current DES
+key with itself and the group bits becomes the next DES key.
+.Pp
+The setting is a 9-character array consisting of an underscore followed
+by 4 bytes of iteration count and 4 bytes of salt.
+These are encoded as printable characters, 6 bits per character,
+least significant character first.
+The values 0 to 63 are encoded as
+.Dq \&./0-9A-Za-z .
+This allows 24 bits for both
+.Fa count
+and
+.Fa salt .
+.Ss "MD5" crypt
+For
+.Tn MD5
+crypt the version number,
+.Fa salt
+and the hashed password are separated by the
+.Ql $
+character.
+The maximum length of a password is limited by
+the length counter of the MD5 context, which is about
+2**64.
+A valid MD5 password entry looks like this:
+.Pp
+.Dq $1$caeiHQwX$hsKqOjrFRRN6K32OWkCBf1 .
+.Pp
+The whole MD5 password string is passed as
+.Fa setting
+for interpretation.
+.Ss "Blowfish" crypt
+The
+.Tn Blowfish
+version of crypt has 128 bits of
+.Fa salt
+in order to make building dictionaries of common passwords space consuming.
+The initial state of the
+.Tn Blowfish
+cipher is expanded using the
+.Fa salt
+and the
+.Fa password
+repeating the process a variable number of rounds, which is encoded in
+the password string.
+The maximum password length is 72.
+The final Blowfish password entry is created by encrypting the string
+.Pp
+.Dq OrpheanBeholderScryDoubt
+.Pp
+with the
+.Tn Blowfish
+state 64 times.
+.Pp
+The version number, the logarithm of the number of rounds and
+the concatenation of salt and hashed password are separated by the
+.Ql $
+character.
+An encoded
+.Sq 8
+would specify 256 rounds.
+A valid Blowfish password looks like this:
+.Pp
+.Dq $2a$12$eIAq8PR8sIUnJ1HaohxX2O9x9Qlm2vK97LJ5dsXdmB.eXF42qjchC .
+.Pp
+The whole Blowfish password string is passed as
+.Fa setting
+for interpretation.
+.Ss "Traditional" crypt
+The first 8 bytes of the key are null-padded, and the low-order 7 bits of
+each character is used to form the 56-bit
+.Tn DES
+key.
+.Pp
+The setting is a 2-character array of the ASCII-encoded salt.
+Thus only 12 bits of
+.Fa salt
+are used.
+.Fa count
+is set to 25.
+.Ss DES Algorithm
+The
+.Fa salt
+introduces disorder in the
+.Tn DES
+algorithm in one of 16777216 or 4096 possible ways
+(i.e., with 24 or 12 bits: if bit
+.Em i
+of the
+.Ar salt
+is set, then bits
+.Em i
+and
+.Em i+24
+are swapped in the
+.Tn DES
+E-box output).
+.Pp
+The DES key is used to encrypt a 64-bit constant using
+.Ar count
+iterations of
+.Tn DES .
+The value returned is a
+.Dv NUL Ns -terminated
+string, 20 or 13 bytes (plus NUL) in length, consisting of the
+.Ar setting
+followed by the encoded 64-bit encryption.
+.Pp
+The functions
+.Fn encrypt ,
+.Fn setkey ,
+.Fn des_setkey ,
+and
+.Fn des_cipher
+provide access to the
+.Tn DES
+algorithm itself.
+.Fn setkey
+is passed a 64-byte array of binary values (numeric 0 or 1).
+A 56-bit key is extracted from this array by dividing the
+array into groups of 8, and ignoring the last bit in each group.
+That bit is reserved for a byte parity check by DES, but is ignored
+by these functions.
+.Pp
+The
+.Fa block
+argument to
+.Fn encrypt
+is also a 64-byte array of binary values.
+If the value of
+.Fa flag
+is 0,
+.Fa block
+is encrypted otherwise it is decrypted.
+The result is returned in the original array
+.Fa block
+after using the key specified by
+.Fn setkey
+to process it.
+.Pp
+The argument to
+.Fn des_setkey
+is a character array of length 8.
+The least significant bit (the parity bit) in each character is ignored,
+and the remaining bits are concatenated to form a 56-bit key.
+The function
+.Fn des_cipher
+encrypts (or decrypts if
+.Fa count
+is negative) the 64-bits stored in the 8 characters at
+.Fa in
+using
+.Xr abs 3
+of
+.Fa count
+iterations of
+.Tn DES
+and stores the 64-bit result in the 8 characters at
+.Fa out
+(which may be the same as
+.Fa in ) .
+The
+.Fa salt
+specifies perturbations to the
+.Tn DES
+E-box output as described above.
+.Pp
+The function
+.Fn crypt
+returns a pointer to the encrypted value on success, and
+.Dv NULL
+on failure.
+The functions
+.Fn setkey ,
+.Fn encrypt ,
+.Fn des_setkey ,
+and
+.Fn des_cipher
+return 0 on success and 1 on failure.
+.Pp
+The
+.Fn crypt ,
+.Fn setkey ,
+and
+.Fn des_setkey
+functions all manipulate the same key space.
+.Sh SEE ALSO
+.Xr login 1 ,
+.Xr passwd 1 ,
+.Xr blowfish 3 ,
+.Xr getpass 3 ,
+.Xr md5 3 ,
+.Xr passwd 5
+.Sh HISTORY
+A rotor-based
+.Fn crypt
+function appeared in
+.At v3 .
+The current style
+.Fn crypt
+first appeared in
+.At v7 .
+.Pp
+This library (FreeSec 1.0) was developed outside the United States of America
+as an unencumbered replacement for the U.S.-only libcrypt encryption
+library.
+Programs linked against the
+.Fn crypt
+interface may be exported from the U.S.A. only if they use
+.Fn crypt
+solely for authentication purposes and avoid use of
+the other programmer interfaces listed above.
+Special care has been taken
+in the library so that programs which only use the
+.Fn crypt
+interface do not pull in the other components.
+.Sh AUTHORS
+.An David Burren Aq davidb@werj.com.au
+.Sh BUGS
+The
+.Fn crypt
+function returns a pointer to static data, and subsequent calls to
+.Fn crypt
+will modify the same object.
diff --git a/src/lib/libc/crypt/crypt.c b/src/lib/libc/crypt/crypt.c
new file mode 100644
index 0000000000..15a784532d
--- /dev/null
+++ b/src/lib/libc/crypt/crypt.c
@@ -0,0 +1,696 @@
+/*      $OpenBSD: crypt.c,v 1.20 2005/08/08 08:05:33 espie Exp $        */
+
+/*
+ * FreeSec: libcrypt
+ *
+ * Copyright (c) 1994 David Burren
+ * 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.
+ * 4. Neither the name of the author nor the names of other contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *
+ * This is an original implementation of the DES and the crypt(3) interfaces
+ * by David Burren <davidb@werj.com.au>.
+ *
+ * An excellent reference on the underlying algorithm (and related
+ * algorithms) is:
+ *
+ *      B. Schneier, Applied Cryptography: protocols, algorithms,
+ *      and source code in C, John Wiley & Sons, 1994.
+ *
+ * Note that in that book's description of DES the lookups for the initial,
+ * pbox, and final permutations are inverted (this has been brought to the
+ * attention of the author).  A list of errata for this book has been
+ * posted to the sci.crypt newsgroup by the author and is available for FTP.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <string.h>
+
+#ifdef DEBUG
+# include <stdio.h>
+#endif
+
+static const u_char     IP[64] = {
+        58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12,  4,
+        62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16,  8,
+        57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11,  3,
+        61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15,  7
+};
+
+static u_char   inv_key_perm[64];
+static u_char   u_key_perm[56];
+static u_char   const key_perm[56] = {
+        57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
+        10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
+        63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
+        14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
+};
+
+static const u_char     key_shifts[16] = {
+        1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
+};
+
+static u_char   inv_comp_perm[56];
+static const u_char     comp_perm[48] = {
+        14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
+        23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
+        41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
+        44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
+};
+
+/*
+ *      No E box is used, as it's replaced by some ANDs, shifts, and ORs.
+ */
+
+static u_char   u_sbox[8][64];
+static const u_char     sbox[8][64] = {
+        {
+                14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
+                 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
+                 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
+                15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
+        },
+        {
+                15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
+                 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
+                 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
+                13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
+        },
+        {
+                10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
+                13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
+                13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
+                 1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
+        },
+        {
+                 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
+                13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
+                10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
+                 3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
+        },
+        {
+                 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
+                14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
+                 4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
+                11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
+        },
+        {
+                12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
+                10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
+                 9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
+                 4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
+        },
+        {
+                 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
+                13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
+                 1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
+                 6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
+        },
+        {
+                13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
+                 1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
+                 7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
+                 2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
+        }
+};
+
+static u_char   un_pbox[32];
+static const u_char     pbox[32] = {
+        16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
+         2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
+};
+
+const u_int32_t _des_bits32[32] =
+{
+        0x80000000, 0x40000000, 0x20000000, 0x10000000,
+        0x08000000, 0x04000000, 0x02000000, 0x01000000,
+        0x00800000, 0x00400000, 0x00200000, 0x00100000,
+        0x00080000, 0x00040000, 0x00020000, 0x00010000,
+        0x00008000, 0x00004000, 0x00002000, 0x00001000,
+        0x00000800, 0x00000400, 0x00000200, 0x00000100,
+        0x00000080, 0x00000040, 0x00000020, 0x00000010,
+        0x00000008, 0x00000004, 0x00000002, 0x00000001
+};
+
+const u_char    _des_bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+static u_int32_t saltbits;
+static int32_t  old_salt;
+static const u_int32_t *bits28, *bits24;
+static u_char   init_perm[64], final_perm[64];
+static u_int32_t en_keysl[16], en_keysr[16];
+static u_int32_t de_keysl[16], de_keysr[16];
+int     _des_initialised = 0;
+static u_char   m_sbox[4][4096];
+static u_int32_t psbox[4][256];
+static u_int32_t ip_maskl[8][256], ip_maskr[8][256];
+static u_int32_t fp_maskl[8][256], fp_maskr[8][256];
+static u_int32_t key_perm_maskl[8][128], key_perm_maskr[8][128];
+static u_int32_t comp_maskl[8][128], comp_maskr[8][128];
+static u_int32_t old_rawkey0, old_rawkey1;
+
+static u_char   ascii64[] =
+         "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/*        0000000000111111111122222222223333333333444444444455555555556666 */
+/*        0123456789012345678901234567890123456789012345678901234567890123 */
+
+static __inline int
+ascii_to_bin(char ch)
+{
+        if (ch > 'z')
+                return(0);
+        if (ch >= 'a')
+                return(ch - 'a' + 38);
+        if (ch > 'Z')
+                return(0);
+        if (ch >= 'A')
+                return(ch - 'A' + 12);
+        if (ch > '9')
+                return(0);
+        if (ch >= '.')
+                return(ch - '.');
+        return(0);
+}
+
+void
+_des_init(void)
+{
+        int     i, j, b, k, inbit, obit;
+        u_int32_t       *p, *il, *ir, *fl, *fr;
+
+        old_rawkey0 = old_rawkey1 = 0;
+        saltbits = 0;
+        old_salt = 0;
+        bits24 = (bits28 = _des_bits32 + 4) + 4;
+
+        /*
+         * Invert the S-boxes, reordering the input bits.
+         */
+        for (i = 0; i < 8; i++)
+                for (j = 0; j < 64; j++) {
+                        b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
+                        u_sbox[i][j] = sbox[i][b];
+                }
+
+        /*
+         * Convert the inverted S-boxes into 4 arrays of 8 bits.
+         * Each will handle 12 bits of the S-box input.
+         */
+        for (b = 0; b < 4; b++)
+                for (i = 0; i < 64; i++)
+                        for (j = 0; j < 64; j++)
+                                m_sbox[b][(i << 6) | j] =
+                                        (u_sbox[(b << 1)][i] << 4) |
+                                        u_sbox[(b << 1) + 1][j];
+
+        /*
+         * Set up the initial & final permutations into a useful form, and
+         * initialise the inverted key permutation.
+         */
+        for (i = 0; i < 64; i++) {
+                init_perm[final_perm[i] = IP[i] - 1] = i;
+                inv_key_perm[i] = 255;
+        }
+
+        /*
+         * Invert the key permutation and initialise the inverted key
+         * compression permutation.
+         */
+        for (i = 0; i < 56; i++) {
+                u_key_perm[i] = key_perm[i] - 1;
+                inv_key_perm[key_perm[i] - 1] = i;
+                inv_comp_perm[i] = 255;
+        }
+
+        /*
+         * Invert the key compression permutation.
+         */
+        for (i = 0; i < 48; i++) {
+                inv_comp_perm[comp_perm[i] - 1] = i;
+        }
+
+        /*
+         * Set up the OR-mask arrays for the initial and final permutations,
+         * and for the key initial and compression permutations.
+         */
+        for (k = 0; k < 8; k++) {
+                for (i = 0; i < 256; i++) {
+                        *(il = &ip_maskl[k][i]) = 0;
+                        *(ir = &ip_maskr[k][i]) = 0;
+                        *(fl = &fp_maskl[k][i]) = 0;
+                        *(fr = &fp_maskr[k][i]) = 0;
+                        for (j = 0; j < 8; j++) {
+                                inbit = 8 * k + j;
+                                if (i & _des_bits8[j]) {
+                                        if ((obit = init_perm[inbit]) < 32)
+                                                *il |= _des_bits32[obit];
+                                        else
+                                                *ir |= _des_bits32[obit-32];
+                                        if ((obit = final_perm[inbit]) < 32)
+                                                *fl |= _des_bits32[obit];
+                                        else
+                                                *fr |= _des_bits32[obit - 32];
+                                }
+                        }
+                }
+                for (i = 0; i < 128; i++) {
+                        *(il = &key_perm_maskl[k][i]) = 0;
+                        *(ir = &key_perm_maskr[k][i]) = 0;
+                        for (j = 0; j < 7; j++) {
+                                inbit = 8 * k + j;
+                                if (i & _des_bits8[j + 1]) {
+                                        if ((obit = inv_key_perm[inbit]) == 255)
+                                                continue;
+                                        if (obit < 28)
+                                                *il |= bits28[obit];
+                                        else
+                                                *ir |= bits28[obit - 28];
+                                }
+                        }
+                        *(il = &comp_maskl[k][i]) = 0;
+                        *(ir = &comp_maskr[k][i]) = 0;
+                        for (j = 0; j < 7; j++) {
+                                inbit = 7 * k + j;
+                                if (i & _des_bits8[j + 1]) {
+                                        if ((obit=inv_comp_perm[inbit]) == 255)
+                                                continue;
+                                        if (obit < 24)
+                                                *il |= bits24[obit];
+                                        else
+                                                *ir |= bits24[obit - 24];
+                                }
+                        }
+                }
+        }
+
+        /*
+         * Invert the P-box permutation, and convert into OR-masks for
+         * handling the output of the S-box arrays setup above.
+         */
+        for (i = 0; i < 32; i++)
+                un_pbox[pbox[i] - 1] = i;
+
+        for (b = 0; b < 4; b++)
+                for (i = 0; i < 256; i++) {
+                        *(p = &psbox[b][i]) = 0;
+                        for (j = 0; j < 8; j++) {
+                                if (i & _des_bits8[j])
+                                        *p |= _des_bits32[un_pbox[8 * b + j]];
+                        }
+                }
+
+        _des_initialised = 1;
+}
+
+void
+_des_setup_salt(int32_t salt)
+{
+        u_int32_t       obit, saltbit;
+        int     i;
+
+        if (salt == old_salt)
+                return;
+        old_salt = salt;
+
+        saltbits = 0;
+        saltbit = 1;
+        obit = 0x800000;
+        for (i = 0; i < 24; i++) {
+                if (salt & saltbit)
+                        saltbits |= obit;
+                saltbit <<= 1;
+                obit >>= 1;
+        }
+}
+
+int
+des_setkey(const char *key)
+{
+        u_int32_t k0, k1, rawkey0, rawkey1;
+        int     shifts, round;
+
+        if (!_des_initialised)
+                _des_init();
+
+        rawkey0 = ntohl(*(u_int32_t *) key);
+        rawkey1 = ntohl(*(u_int32_t *) (key + 4));
+
+        if ((rawkey0 | rawkey1)
+            && rawkey0 == old_rawkey0
+            && rawkey1 == old_rawkey1) {
+                /*
+                 * Already setup for this key.
+                 * This optimisation fails on a zero key (which is weak and
+                 * has bad parity anyway) in order to simplify the starting
+                 * conditions.
+                 */
+                return(0);
+        }
+        old_rawkey0 = rawkey0;
+        old_rawkey1 = rawkey1;
+
+        /*
+         *      Do key permutation and split into two 28-bit subkeys.
+         */
+        k0 = key_perm_maskl[0][rawkey0 >> 25]
+           | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
+           | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
+           | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
+           | key_perm_maskl[4][rawkey1 >> 25]
+           | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
+           | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
+           | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
+        k1 = key_perm_maskr[0][rawkey0 >> 25]
+           | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
+           | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
+           | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
+           | key_perm_maskr[4][rawkey1 >> 25]
+           | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
+           | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
+           | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
+        /*
+         *      Rotate subkeys and do compression permutation.
+         */
+        shifts = 0;
+        for (round = 0; round < 16; round++) {
+                u_int32_t       t0, t1;
+
+                shifts += key_shifts[round];
+
+                t0 = (k0 << shifts) | (k0 >> (28 - shifts));
+                t1 = (k1 << shifts) | (k1 >> (28 - shifts));
+
+                de_keysl[15 - round] =
+                en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
+                                | comp_maskl[1][(t0 >> 14) & 0x7f]
+                                | comp_maskl[2][(t0 >> 7) & 0x7f]
+                                | comp_maskl[3][t0 & 0x7f]
+                                | comp_maskl[4][(t1 >> 21) & 0x7f]
+                                | comp_maskl[5][(t1 >> 14) & 0x7f]
+                                | comp_maskl[6][(t1 >> 7) & 0x7f]
+                                | comp_maskl[7][t1 & 0x7f];
+
+                de_keysr[15 - round] =
+                en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
+                                | comp_maskr[1][(t0 >> 14) & 0x7f]
+                                | comp_maskr[2][(t0 >> 7) & 0x7f]
+                                | comp_maskr[3][t0 & 0x7f]
+                                | comp_maskr[4][(t1 >> 21) & 0x7f]
+                                | comp_maskr[5][(t1 >> 14) & 0x7f]
+                                | comp_maskr[6][(t1 >> 7) & 0x7f]
+                                | comp_maskr[7][t1 & 0x7f];
+        }
+        return(0);
+}
+
+int
+_des_do_des(u_int32_t l_in, u_int32_t r_in, u_int32_t *l_out, u_int32_t *r_out,
+    int count)
+{
+        /*
+         *      l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
+         */
+        u_int32_t       l, r, *kl, *kr, *kl1, *kr1;
+        u_int32_t       f, r48l, r48r;
+        int             round;
+
+        if (count == 0) {
+                return(1);
+        } else if (count > 0) {
+                /*
+                 * Encrypting
+                 */
+                kl1 = en_keysl;
+                kr1 = en_keysr;
+        } else {
+                /*
+                 * Decrypting
+                 */
+                count = -count;
+                kl1 = de_keysl;
+                kr1 = de_keysr;
+        }
+
+        /*
+         *      Do initial permutation (IP).
+         */
+        l = ip_maskl[0][l_in >> 24]
+          | ip_maskl[1][(l_in >> 16) & 0xff]
+          | ip_maskl[2][(l_in >> 8) & 0xff]
+          | ip_maskl[3][l_in & 0xff]
+          | ip_maskl[4][r_in >> 24]
+          | ip_maskl[5][(r_in >> 16) & 0xff]
+          | ip_maskl[6][(r_in >> 8) & 0xff]
+          | ip_maskl[7][r_in & 0xff];
+        r = ip_maskr[0][l_in >> 24]
+          | ip_maskr[1][(l_in >> 16) & 0xff]
+          | ip_maskr[2][(l_in >> 8) & 0xff]
+          | ip_maskr[3][l_in & 0xff]
+          | ip_maskr[4][r_in >> 24]
+          | ip_maskr[5][(r_in >> 16) & 0xff]
+          | ip_maskr[6][(r_in >> 8) & 0xff]
+          | ip_maskr[7][r_in & 0xff];
+
+        while (count--) {
+                /*
+                 * Do each round.
+                 */
+                kl = kl1;
+                kr = kr1;
+                round = 16;
+                while (round--) {
+                        /*
+                         * Expand R to 48 bits (simulate the E-box).
+                         */
+                        r48l    = ((r & 0x00000001) << 23)
+                                | ((r & 0xf8000000) >> 9)
+                                | ((r & 0x1f800000) >> 11)
+                                | ((r & 0x01f80000) >> 13)
+                                | ((r & 0x001f8000) >> 15);
+
+                        r48r    = ((r & 0x0001f800) << 7)
+                                | ((r & 0x00001f80) << 5)
+                                | ((r & 0x000001f8) << 3)
+                                | ((r & 0x0000001f) << 1)
+                                | ((r & 0x80000000) >> 31);
+                        /*
+                         * Do salting for crypt() and friends, and
+                         * XOR with the permuted key.
+                         */
+                        f = (r48l ^ r48r) & saltbits;
+                        r48l ^= f ^ *kl++;
+                        r48r ^= f ^ *kr++;
+                        /*
+                         * Do sbox lookups (which shrink it back to 32 bits)
+                         * and do the pbox permutation at the same time.
+                         */
+                        f = psbox[0][m_sbox[0][r48l >> 12]]
+                          | psbox[1][m_sbox[1][r48l & 0xfff]]
+                          | psbox[2][m_sbox[2][r48r >> 12]]
+                          | psbox[3][m_sbox[3][r48r & 0xfff]];
+                        /*
+                         * Now that we've permuted things, complete f().
+                         */
+                        f ^= l;
+                        l = r;
+                        r = f;
+                }
+                r = l;
+                l = f;
+        }
+        /*
+         * Do final permutation (inverse of IP).
+         */
+        *l_out  = fp_maskl[0][l >> 24]
+                | fp_maskl[1][(l >> 16) & 0xff]
+                | fp_maskl[2][(l >> 8) & 0xff]
+                | fp_maskl[3][l & 0xff]
+                | fp_maskl[4][r >> 24]
+                | fp_maskl[5][(r >> 16) & 0xff]
+                | fp_maskl[6][(r >> 8) & 0xff]
+                | fp_maskl[7][r & 0xff];
+        *r_out  = fp_maskr[0][l >> 24]
+                | fp_maskr[1][(l >> 16) & 0xff]
+                | fp_maskr[2][(l >> 8) & 0xff]
+                | fp_maskr[3][l & 0xff]
+                | fp_maskr[4][r >> 24]
+                | fp_maskr[5][(r >> 16) & 0xff]
+                | fp_maskr[6][(r >> 8) & 0xff]
+                | fp_maskr[7][r & 0xff];
+        return(0);
+}
+
+int
+des_cipher(const char *in, char *out, int32_t salt, int count)
+{
+        u_int32_t l_out, r_out, rawl, rawr;
+        u_int32_t x[2];
+        int     retval;
+
+        if (!_des_initialised)
+                _des_init();
+
+        _des_setup_salt(salt);
+
+        memcpy(x, in, sizeof x);
+        rawl = ntohl(x[0]);
+        rawr = ntohl(x[1]);
+        retval = _des_do_des(rawl, rawr, &l_out, &r_out, count);
+
+        x[0] = htonl(l_out);
+        x[1] = htonl(r_out);
+        memcpy(out, x, sizeof x);
+        return(retval);
+}
+
+char *
+crypt(const char *key, const char *setting)
+{
+        int             i;
+        u_int32_t       count, salt, l, r0, r1, keybuf[2];
+        u_char          *p, *q;
+        static u_char   output[21];
+        extern char     *md5crypt(const char *, const char *);
+        extern char     *bcrypt(const char *, const char *);
+
+        if (setting[0] == '$') {
+                switch (setting[1]) {
+                case '1':
+                        return (md5crypt(key, setting));
+                default:
+                        return bcrypt(key, setting);
+                }
+        }
+
+        if (!_des_initialised)
+                _des_init();
+
+        /*
+         * Copy the key, shifting each character up by one bit
+         * and padding with zeros.
+         */
+        q = (u_char *) keybuf;
+        while ((q - (u_char *) keybuf) < sizeof(keybuf)) {
+                if ((*q++ = *key << 1))
+                        key++;
+        }
+        if (des_setkey((char *) keybuf))
+                return(NULL);
+
+        if (*setting == _PASSWORD_EFMT1) {
+                /*
+                 * "new"-style:
+                 *      setting - underscore, 4 bytes of count, 4 bytes of salt
+                 *      key - unlimited characters
+                 */
+                for (i = 1, count = 0; i < 5; i++)
+                        count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
+
+                for (i = 5, salt = 0; i < 9; i++)
+                        salt |= ascii_to_bin(setting[i]) << (i - 5) * 6;
+
+                while (*key) {
+                        /*
+                         * Encrypt the key with itself.
+                         */
+                        if (des_cipher((char *)keybuf, (char *)keybuf, 0, 1))
+                                return(NULL);
+                        /*
+                         * And XOR with the next 8 characters of the key.
+                         */
+                        q = (u_char *) keybuf;
+                        while (((q - (u_char *) keybuf) < sizeof(keybuf)) &&
+                                        *key)
+                                *q++ ^= *key++ << 1;
+
+                        if (des_setkey((char *) keybuf))
+                                return(NULL);
+                }
+                strlcpy((char *)output, setting, 10);
+
+                /*
+                 * Double check that we weren't given a short setting.
+                 * If we were, the above code will probably have created
+                 * weird values for count and salt, but we don't really care.
+                 * Just make sure the output string doesn't have an extra
+                 * NUL in it.
+                 */
+                p = output + strlen((const char *)output);
+        } else {
+                /*
+                 * "old"-style:
+                 *      setting - 2 bytes of salt
+                 *      key - up to 8 characters
+                 */
+                count = 25;
+
+                salt = (ascii_to_bin(setting[1]) << 6)
+                     |  ascii_to_bin(setting[0]);
+
+                output[0] = setting[0];
+                /*
+                 * If the encrypted password that the salt was extracted from
+                 * is only 1 character long, the salt will be corrupted.  We
+                 * need to ensure that the output string doesn't have an extra
+                 * NUL in it!
+                 */
+                output[1] = setting[1] ? setting[1] : output[0];
+
+                p = output + 2;
+        }
+        _des_setup_salt(salt);
+
+        /*
+         * Do it.
+         */
+        if (_des_do_des(0, 0, &r0, &r1, count))
+                return(NULL);
+        /*
+         * Now encode the result...
+         */
+        l = (r0 >> 8);
+        *p++ = ascii64[(l >> 18) & 0x3f];
+        *p++ = ascii64[(l >> 12) & 0x3f];
+        *p++ = ascii64[(l >> 6) & 0x3f];
+        *p++ = ascii64[l & 0x3f];
+
+        l = (r0 << 16) | ((r1 >> 16) & 0xffff);
+        *p++ = ascii64[(l >> 18) & 0x3f];
+        *p++ = ascii64[(l >> 12) & 0x3f];
+        *p++ = ascii64[(l >> 6) & 0x3f];
+        *p++ = ascii64[l & 0x3f];
+
+        l = r1 << 2;
+        *p++ = ascii64[(l >> 12) & 0x3f];
+        *p++ = ascii64[(l >> 6) & 0x3f];
+        *p++ = ascii64[l & 0x3f];
+        *p = 0;
+
+        return((char *)output);
+}
diff --git a/src/lib/libc/crypt/crypt2.c b/src/lib/libc/crypt/crypt2.c
new file mode 100644
index 0000000000..63a297e510
--- /dev/null
+++ b/src/lib/libc/crypt/crypt2.c
@@ -0,0 +1,104 @@
+/*      $OpenBSD: crypt2.c,v 1.3 2005/08/08 08:05:33 espie Exp $        */
+
+/*
+ * FreeSec: libcrypt
+ *
+ * Copyright (c) 1994 David Burren
+ * 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.
+ * 4. Neither the name of the author nor the names of other contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *
+ * This is an original implementation of the DES and the crypt(3) interfaces
+ * by David Burren <davidb@werj.com.au>.
+ *
+ * An excellent reference on the underlying algorithm (and related
+ * algorithms) is:
+ *
+ *      B. Schneier, Applied Cryptography: protocols, algorithms,
+ *      and source code in C, John Wiley & Sons, 1994.
+ *
+ * Note that in that book's description of DES the lookups for the initial,
+ * pbox, and final permutations are inverted (this has been brought to the
+ * attention of the author).  A list of errata for this book has been
+ * posted to the sci.crypt newsgroup by the author and is available for FTP.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <string.h>
+
+#ifdef DEBUG
+# include <stdio.h>
+#endif
+
+extern const u_char _des_bits8[8];
+extern const u_int32_t _des_bits32[32];
+extern int      _des_initialised;
+
+int
+setkey(const char *key)
+{
+        int     i, j;
+        u_int32_t packed_keys[2];
+        u_char  *p;
+
+        p = (u_char *) packed_keys;
+
+        for (i = 0; i < 8; i++) {
+                p[i] = 0;
+                for (j = 0; j < 8; j++)
+                        if (*key++ & 1)
+                                p[i] |= _des_bits8[j];
+        }
+        return(des_setkey((char *)p));
+}
+
+int
+encrypt(char *block, int flag)
+{
+        u_int32_t io[2];
+        u_char  *p;
+        int     i, j, retval;
+
+        if (!_des_initialised)
+                _des_init();
+
+        _des_setup_salt(0);
+        p = (u_char *)block;
+        for (i = 0; i < 2; i++) {
+                io[i] = 0L;
+                for (j = 0; j < 32; j++)
+                        if (*p++ & 1)
+                                io[i] |= _des_bits32[j];
+        }
+        retval = _des_do_des(io[0], io[1], io, io + 1, flag ? -1 : 1);
+        for (i = 0; i < 2; i++)
+                for (j = 0; j < 32; j++)
+                        block[(i << 5) | j] = (io[i] & _des_bits32[j]) ? 1 : 0;
+        return(retval);
+}
diff --git a/src/lib/libc/crypt/md5crypt.c b/src/lib/libc/crypt/md5crypt.c
new file mode 100644
index 0000000000..fe1393cf7c
--- /dev/null
+++ b/src/lib/libc/crypt/md5crypt.c
@@ -0,0 +1,149 @@
+/*      $OpenBSD: md5crypt.c,v 1.14 2005/08/08 08:05:33 espie Exp $     */
+
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * $FreeBSD: crypt.c,v 1.5 1996/10/14 08:34:02 phk Exp $
+ *
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <md5.h>
+#include <string.h>
+
+static unsigned char itoa64[] =         /* 0 ... 63 => ascii - 64 */
+        "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void to64(char *, u_int32_t, int);
+
+static void
+to64(char *s, u_int32_t v, int n)
+{
+        while (--n >= 0) {
+                *s++ = itoa64[v&0x3f];
+                v >>= 6;
+        }
+}
+
+/*
+ * UNIX password
+ *
+ * Use MD5 for what it is best at...
+ */
+
+char *md5crypt(const char *pw, const char *salt);
+
+char *
+md5crypt(const char *pw, const char *salt)
+{
+        /*
+         * This string is magic for this algorithm.  Having
+         * it this way, we can get get better later on
+         */
+        static unsigned char    *magic = (unsigned char *)"$1$";
+
+        static char     passwd[120], *p;
+        static const unsigned char *sp,*ep;
+        unsigned char   final[16];
+        int sl,pl,i;
+        MD5_CTX ctx,ctx1;
+        u_int32_t l;
+
+        /* Refine the Salt first */
+        sp = (const unsigned char *)salt;
+
+        /* If it starts with the magic string, then skip that */
+        if(!strncmp((const char *)sp,(const char *)magic,strlen((const char *)magic)))
+                sp += strlen((const char *)magic);
+
+        /* It stops at the first '$', max 8 chars */
+        for(ep=sp;*ep && *ep != '$' && ep < (sp+8);ep++)
+                continue;
+
+        /* get the length of the true salt */
+        sl = ep - sp;
+
+        MD5Init(&ctx);
+
+        /* The password first, since that is what is most unknown */
+        MD5Update(&ctx,(const unsigned char *)pw,strlen(pw));
+
+        /* Then our magic string */
+        MD5Update(&ctx,magic,strlen((const char *)magic));
+
+        /* Then the raw salt */
+        MD5Update(&ctx,sp,sl);
+
+        /* Then just as many characters of the MD5(pw,salt,pw) */
+        MD5Init(&ctx1);
+        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+        MD5Update(&ctx1,sp,sl);
+        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+        MD5Final(final,&ctx1);
+        for(pl = strlen(pw); pl > 0; pl -= 16)
+                MD5Update(&ctx,final,pl>16 ? 16 : pl);
+
+        /* Don't leave anything around in vm they could use. */
+        memset(final,0,sizeof final);
+
+        /* Then something really weird... */
+        for (i = strlen(pw); i ; i >>= 1)
+                if(i&1)
+                    MD5Update(&ctx, final, 1);
+                else
+                    MD5Update(&ctx, (const unsigned char *)pw, 1);
+
+        /* Now make the output string */
+        snprintf(passwd, sizeof(passwd), "%s%.*s$", (char *)magic,
+            sl, (const char *)sp);
+
+        MD5Final(final,&ctx);
+
+        /*
+         * and now, just to make sure things don't run too fast
+         * On a 60 Mhz Pentium this takes 34 msec, so you would
+         * need 30 seconds to build a 1000 entry dictionary...
+         */
+        for(i=0;i<1000;i++) {
+                MD5Init(&ctx1);
+                if(i & 1)
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+                else
+                        MD5Update(&ctx1,final,16);
+
+                if(i % 3)
+                        MD5Update(&ctx1,sp,sl);
+
+                if(i % 7)
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+
+                if(i & 1)
+                        MD5Update(&ctx1,final,16);
+                else
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+                MD5Final(final,&ctx1);
+        }
+
+        p = passwd + strlen(passwd);
+
+        l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p,l,4); p += 4;
+        l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p,l,4); p += 4;
+        l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p,l,4); p += 4;
+        l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p,l,4); p += 4;
+        l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p,l,4); p += 4;
+        l =                    final[11]                ; to64(p,l,2); p += 2;
+        *p = '\0';
+
+        /* Don't leave anything around in vm they could use. */
+        memset(final, 0, sizeof final);
+
+        return passwd;
+}
+
diff --git a/src/lib/libc/crypt/skipjack.c b/src/lib/libc/crypt/skipjack.c
new file mode 100644
index 0000000000..2212b984bb
--- /dev/null
+++ b/src/lib/libc/crypt/skipjack.c
@@ -0,0 +1,260 @@
+/*      $OpenBSD: skipjack.c,v 1.3 2004/10/01 04:08:45 jsg Exp $        */
+
+/* 
+ * Further optimized test implementation of SKIPJACK algorithm 
+ * Mark Tillotson <markt@chaos.org.uk>, 25 June 98
+ * Optimizations suit RISC (lots of registers) machine best.
+ *
+ * based on unoptimized implementation of
+ * Panu Rissanen <bande@lut.fi> 960624
+ *
+ * SKIPJACK and KEA Algorithm Specifications 
+ * Version 2.0 
+ * 29 May 1998
+*/
+
+#include <sys/param.h>
+#include <skipjack.h>
+#include <stdlib.h>
+
+static const u_int8_t ftable[0x100] =
+{ 
+        0xa3, 0xd7, 0x09, 0x83, 0xf8, 0x48, 0xf6, 0xf4, 
+        0xb3, 0x21, 0x15, 0x78, 0x99, 0xb1, 0xaf, 0xf9, 
+        0xe7, 0x2d, 0x4d, 0x8a, 0xce, 0x4c, 0xca, 0x2e, 
+        0x52, 0x95, 0xd9, 0x1e, 0x4e, 0x38, 0x44, 0x28, 
+        0x0a, 0xdf, 0x02, 0xa0, 0x17, 0xf1, 0x60, 0x68, 
+        0x12, 0xb7, 0x7a, 0xc3, 0xe9, 0xfa, 0x3d, 0x53, 
+        0x96, 0x84, 0x6b, 0xba, 0xf2, 0x63, 0x9a, 0x19, 
+        0x7c, 0xae, 0xe5, 0xf5, 0xf7, 0x16, 0x6a, 0xa2, 
+        0x39, 0xb6, 0x7b, 0x0f, 0xc1, 0x93, 0x81, 0x1b, 
+        0xee, 0xb4, 0x1a, 0xea, 0xd0, 0x91, 0x2f, 0xb8, 
+        0x55, 0xb9, 0xda, 0x85, 0x3f, 0x41, 0xbf, 0xe0, 
+        0x5a, 0x58, 0x80, 0x5f, 0x66, 0x0b, 0xd8, 0x90, 
+        0x35, 0xd5, 0xc0, 0xa7, 0x33, 0x06, 0x65, 0x69, 
+        0x45, 0x00, 0x94, 0x56, 0x6d, 0x98, 0x9b, 0x76, 
+        0x97, 0xfc, 0xb2, 0xc2, 0xb0, 0xfe, 0xdb, 0x20, 
+        0xe1, 0xeb, 0xd6, 0xe4, 0xdd, 0x47, 0x4a, 0x1d, 
+        0x42, 0xed, 0x9e, 0x6e, 0x49, 0x3c, 0xcd, 0x43, 
+        0x27, 0xd2, 0x07, 0xd4, 0xde, 0xc7, 0x67, 0x18, 
+        0x89, 0xcb, 0x30, 0x1f, 0x8d, 0xc6, 0x8f, 0xaa, 
+        0xc8, 0x74, 0xdc, 0xc9, 0x5d, 0x5c, 0x31, 0xa4, 
+        0x70, 0x88, 0x61, 0x2c, 0x9f, 0x0d, 0x2b, 0x87, 
+        0x50, 0x82, 0x54, 0x64, 0x26, 0x7d, 0x03, 0x40, 
+        0x34, 0x4b, 0x1c, 0x73, 0xd1, 0xc4, 0xfd, 0x3b, 
+        0xcc, 0xfb, 0x7f, 0xab, 0xe6, 0x3e, 0x5b, 0xa5, 
+        0xad, 0x04, 0x23, 0x9c, 0x14, 0x51, 0x22, 0xf0, 
+        0x29, 0x79, 0x71, 0x7e, 0xff, 0x8c, 0x0e, 0xe2, 
+        0x0c, 0xef, 0xbc, 0x72, 0x75, 0x6f, 0x37, 0xa1, 
+        0xec, 0xd3, 0x8e, 0x62, 0x8b, 0x86, 0x10, 0xe8, 
+        0x08, 0x77, 0x11, 0xbe, 0x92, 0x4f, 0x24, 0xc5, 
+        0x32, 0x36, 0x9d, 0xcf, 0xf3, 0xa6, 0xbb, 0xac, 
+        0x5e, 0x6c, 0xa9, 0x13, 0x57, 0x25, 0xb5, 0xe3, 
+        0xbd, 0xa8, 0x3a, 0x01, 0x05, 0x59, 0x2a, 0x46
+};
+
+/*
+ * For each key byte generate a table to represent the function 
+ *    ftable [in ^ keybyte]
+ *
+ * These tables used to save an XOR in each stage of the G-function
+ * the tables are hopefully pointed to by register allocated variables
+ * k0, k1..k9
+ */
+void
+subkey_table_gen (u_int8_t *key, u_int8_t **key_tables)
+{
+        int i, k;
+
+        for (k = 0; k < 10; k++) {
+                u_int8_t   key_byte = key[k];
+                u_int8_t * table = (u_int8_t *) malloc(0x100);
+                /* XXX */
+
+                key_tables[k] = table;
+                for (i = 0; i < 0x100; i++)
+                        table[i] = ftable[i ^ key_byte];
+        }
+}
+
+
+#define g(k0, k1, k2, k3, ih, il, oh, ol) \
+{ \
+        oh = k##k0 [il] ^ ih; \
+        ol = k##k1 [oh] ^ il; \
+        oh = k##k2 [ol] ^ oh; \
+        ol = k##k3 [oh] ^ ol; \
+}
+
+#define g0(ih, il, oh, ol) g(0, 1, 2, 3, ih, il, oh, ol)
+#define g4(ih, il, oh, ol) g(4, 5, 6, 7, ih, il, oh, ol)
+#define g8(ih, il, oh, ol) g(8, 9, 0, 1, ih, il, oh, ol)
+#define g2(ih, il, oh, ol) g(2, 3, 4, 5, ih, il, oh, ol)
+#define g6(ih, il, oh, ol) g(6, 7, 8, 9, ih, il, oh, ol)
+
+ 
+#define g_inv(k0, k1, k2, k3, ih, il, oh, ol) \
+{ \
+        ol = k##k3 [ih] ^ il; \
+        oh = k##k2 [ol] ^ ih; \
+        ol = k##k1 [oh] ^ ol; \
+        oh = k##k0 [ol] ^ oh; \
+}
+
+
+#define g0_inv(ih, il, oh, ol) g_inv(0, 1, 2, 3, ih, il, oh, ol)
+#define g4_inv(ih, il, oh, ol) g_inv(4, 5, 6, 7, ih, il, oh, ol)
+#define g8_inv(ih, il, oh, ol) g_inv(8, 9, 0, 1, ih, il, oh, ol)
+#define g2_inv(ih, il, oh, ol) g_inv(2, 3, 4, 5, ih, il, oh, ol)
+#define g6_inv(ih, il, oh, ol) g_inv(6, 7, 8, 9, ih, il, oh, ol)
+
+/* optimized version of Skipjack algorithm
+ *
+ * the appropriate g-function is inlined for each round
+ *
+ * the data movement is minimized by rotating the names of the 
+ * variables w1..w4, not their contents (saves 3 moves per round)
+ *
+ * the loops are completely unrolled (needed to staticize choice of g)
+ *
+ * compiles to about 470 instructions on a Sparc (gcc -O)
+ * which is about 58 instructions per byte, 14 per round.
+ * gcc seems to leave in some unnecessary and with 0xFF operations
+ * but only in the latter part of the functions.  Perhaps it
+ * runs out of resources to properly optimize long inlined function?
+ * in theory should get about 11 instructions per round, not 14
+ */
+
+void
+skipjack_forwards(u_int8_t *plain, u_int8_t *cipher, u_int8_t **key_tables)
+{
+        u_int8_t wh1 = plain[0];  u_int8_t wl1 = plain[1];
+        u_int8_t wh2 = plain[2];  u_int8_t wl2 = plain[3];
+        u_int8_t wh3 = plain[4];  u_int8_t wl3 = plain[5];
+        u_int8_t wh4 = plain[6];  u_int8_t wl4 = plain[7];
+
+        u_int8_t * k0 = key_tables [0];
+        u_int8_t * k1 = key_tables [1];
+        u_int8_t * k2 = key_tables [2];
+        u_int8_t * k3 = key_tables [3];
+        u_int8_t * k4 = key_tables [4];
+        u_int8_t * k5 = key_tables [5];
+        u_int8_t * k6 = key_tables [6];
+        u_int8_t * k7 = key_tables [7];
+        u_int8_t * k8 = key_tables [8];
+        u_int8_t * k9 = key_tables [9];
+
+        /* first 8 rounds */
+        g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 1; wh4 ^= wh1;
+        g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 2; wh3 ^= wh4;
+        g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 3; wh2 ^= wh3;
+        g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 4; wh1 ^= wh2;
+        g6 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 5; wh4 ^= wh1;
+        g0 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 6; wh3 ^= wh4;
+        g4 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 7; wh2 ^= wh3;
+        g8 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 8; wh1 ^= wh2;
+
+        /* second 8 rounds */
+        wh2 ^= wh1; wl2 ^= wl1 ^ 9 ; g2 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 10; g6 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 11; g0 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 12; g4 (wh2,wl2, wh2,wl2);
+        wh2 ^= wh1; wl2 ^= wl1 ^ 13; g8 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 14; g2 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 15; g6 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 16; g0 (wh2,wl2, wh2,wl2);
+
+        /* third 8 rounds */
+        g4 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 17; wh4 ^= wh1;
+        g8 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 18; wh3 ^= wh4;
+        g2 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 19; wh2 ^= wh3;
+        g6 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 20; wh1 ^= wh2;
+        g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 21; wh4 ^= wh1;
+        g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 22; wh3 ^= wh4;
+        g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 23; wh2 ^= wh3;
+        g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 24; wh1 ^= wh2;
+
+        /* last 8 rounds */
+        wh2 ^= wh1; wl2 ^= wl1 ^ 25; g6 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 26; g0 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 27; g4 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 28; g8 (wh2,wl2, wh2,wl2);
+        wh2 ^= wh1; wl2 ^= wl1 ^ 29; g2 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 30; g6 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 31; g0 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 32; g4 (wh2,wl2, wh2,wl2);
+
+        /* pack into byte vector */
+        cipher [0] = wh1;  cipher [1] = wl1;
+        cipher [2] = wh2;  cipher [3] = wl2;
+        cipher [4] = wh3;  cipher [5] = wl3;
+        cipher [6] = wh4;  cipher [7] = wl4;
+}
+
+
+void
+skipjack_backwards (u_int8_t *cipher, u_int8_t *plain, u_int8_t **key_tables)
+{
+        /* setup 4 16-bit portions */
+        u_int8_t wh1 = cipher[0];  u_int8_t wl1 = cipher[1];
+        u_int8_t wh2 = cipher[2];  u_int8_t wl2 = cipher[3];
+        u_int8_t wh3 = cipher[4];  u_int8_t wl3 = cipher[5];
+        u_int8_t wh4 = cipher[6];  u_int8_t wl4 = cipher[7];
+
+        u_int8_t * k0 = key_tables [0];
+        u_int8_t * k1 = key_tables [1];
+        u_int8_t * k2 = key_tables [2];
+        u_int8_t * k3 = key_tables [3];
+        u_int8_t * k4 = key_tables [4];
+        u_int8_t * k5 = key_tables [5];
+        u_int8_t * k6 = key_tables [6];
+        u_int8_t * k7 = key_tables [7];
+        u_int8_t * k8 = key_tables [8];
+        u_int8_t * k9 = key_tables [9];
+
+        /* first 8 rounds */
+        g4_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 32; wh3 ^= wh2;
+        g0_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 31; wh4 ^= wh3;
+        g6_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 30; wh1 ^= wh4;
+        g2_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 29; wh2 ^= wh1;
+        g8_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 28; wh3 ^= wh2;
+        g4_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 27; wh4 ^= wh3;
+        g0_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 26; wh1 ^= wh4;
+        g6_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 25; wh2 ^= wh1;
+
+        /* second 8 rounds */
+        wh1 ^= wh2; wl1 ^= wl2 ^ 24; g2_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 23; g8_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 22; g4_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 21; g0_inv (wh1,wl1, wh1,wl1);
+        wh1 ^= wh2; wl1 ^= wl2 ^ 20; g6_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 19; g2_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 18; g8_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 17; g4_inv (wh1,wl1, wh1,wl1);
+
+        /* third 8 rounds */
+        g0_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 16; wh3 ^= wh2;
+        g6_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 15; wh4 ^= wh3;
+        g2_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 14; wh1 ^= wh4;
+        g8_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 13; wh2 ^= wh1;
+        g4_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 12; wh3 ^= wh2;
+        g0_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 11; wh4 ^= wh3;
+        g6_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 10; wh1 ^= wh4;
+        g2_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 9;  wh2 ^= wh1;
+
+        /* last 8 rounds */
+        wh1 ^= wh2; wl1 ^= wl2 ^ 8; g8_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 7; g4_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 6; g0_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 5; g6_inv (wh1,wl1, wh1,wl1);
+        wh1 ^= wh2; wl1 ^= wl2 ^ 4; g2_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 3; g8_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 2; g4_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 1; g0_inv (wh1,wl1, wh1,wl1);
+
+        /* pack into byte vector */
+        plain [0] = wh1;  plain [1] = wl1;
+        plain [2] = wh2;  plain [3] = wl2;
+        plain [4] = wh3;  plain [5] = wl3;
+        plain [6] = wh4;  plain [7] = wl4;
+}
diff --git a/src/lib/libc/include/ctype_private.h b/src/lib/libc/include/ctype_private.h
new file mode 100644
index 0000000000..39cc792ea4
--- /dev/null
+++ b/src/lib/libc/include/ctype_private.h
@@ -0,0 +1,7 @@
+/* $OpenBSD: ctype_private.h,v 1.1 2005/08/08 05:53:00 espie Exp $ */
+/* Written by Marc Espie, public domain */
+#define CTYPE_NUM_CHARS       256
+extern const char _C_ctype_[];
+extern const short _C_toupper_[];
+extern const short _C_tolower_[];
+
diff --git a/src/lib/libc/include/namespace.h b/src/lib/libc/include/namespace.h
new file mode 100644
index 0000000000..4a51f15ddf
--- /dev/null
+++ b/src/lib/libc/include/namespace.h
@@ -0,0 +1,18 @@
+/*      $OpenBSD: namespace.h,v 1.2 1996/08/19 08:28:08 tholo Exp $     */
+
+#define catclose        _catclose
+#define catgets         _catgets
+#define catopen         _catopen
+#define err             _err
+#define errx            _errx
+#define strtoq          _strtoq
+#define strtouq         _strtouq
+#define sys_errlist     _sys_errlist
+#define sys_nerr        _sys_nerr
+#define sys_siglist     _sys_siglist
+#define verr            _verr
+#define verrx           _verrx
+#define vwarn           _vwarn
+#define vwarnx          _vwarnx
+#define warn            _warn
+#define warnx           _warnx
diff --git a/src/lib/libc/include/thread_private.h b/src/lib/libc/include/thread_private.h
new file mode 100644
index 0000000000..5fbbf592a4
--- /dev/null
+++ b/src/lib/libc/include/thread_private.h
@@ -0,0 +1,138 @@
+/* $OpenBSD: thread_private.h,v 1.18 2006/02/22 07:16:31 otto Exp $ */
+
+/* PUBLIC DOMAIN: No Rights Reserved. Marco S Hyman <marc@snafu.org> */
+
+#ifndef _THREAD_PRIVATE_H_
+#define _THREAD_PRIVATE_H_
+
+/*
+ * This file defines the thread library interface to libc.  Thread
+ * libraries must implement the functions described here for proper
+ * inter-operation with libc.   libc contains weak versions of the
+ * described functions for operation in a non-threaded environment.
+ */
+
+/*
+ * This variable is 0 until a second thread is created.
+ */
+extern int __isthreaded;
+
+/*
+ * Weak symbols are used in libc so that the thread library can
+ * efficiently wrap libc functions.
+ * 
+ * Use WEAK_NAME(n) to get a libc-private name for n (_weak_n),
+ *     WEAK_ALIAS(n) to generate the weak symbol n pointing to _weak_n,
+ *     WEAK_PROTOTYPE(n) to generate a prototype for _weak_n (based on n).
+ */
+#define WEAK_NAME(name)         __CONCAT(_weak_,name)
+#define WEAK_ALIAS(name)        __weak_alias(name, WEAK_NAME(name))
+#ifdef __GNUC__
+#define WEAK_PROTOTYPE(name)    __typeof__(name) WEAK_NAME(name)
+#else
+#define WEAK_PROTOTYPE(name)    /* typeof() only in gcc */
+#endif
+
+/*
+ * helper macro to make unique names in the thread namespace
+ */
+#define __THREAD_NAME(name)     __CONCAT(_thread_tagname_,name)
+
+/*
+ * helper functions that exist as (weak) null functions in libc and
+ * (strong) functions in the thread library.   These functions:
+ *
+ * _thread_tag_lock:
+ *      lock the mutex associated with the given tag.   If the given
+ *      tag is NULL a tag is first allocated.
+ *
+ * _thread_tag_unlock:
+ *      unlock the mutex associated with the given tag.   If the given
+ *      tag is NULL a tag is first allocated.
+ *
+ * _thread_tag_storage:
+ *      return a pointer to per thread instance of data associated
+ *      with the given tag.  If the given tag is NULL a tag is first
+ *      allocated.
+ */
+void    _thread_tag_lock(void **);
+void    _thread_tag_unlock(void **);
+void   *_thread_tag_storage(void **, void *, size_t, void *);
+
+/*
+ * Macros used in libc to access thread mutex, keys, and per thread storage.
+ * _THREAD_PRIVATE_KEY and _THREAD_PRIVATE_MUTEX are different macros for
+ * historical reasons.   They do the same thing, define a static variable
+ * keyed by 'name' that identifies a mutex and a key to identify per thread
+ * data.
+ */
+#define _THREAD_PRIVATE_KEY(name)                                       \
+        static void *__THREAD_NAME(name)
+#define _THREAD_PRIVATE_MUTEX(name)                                     \
+        static void *__THREAD_NAME(name)
+#define _THREAD_PRIVATE_MUTEX_LOCK(name)                                \
+        _thread_tag_lock(&(__THREAD_NAME(name)))
+#define _THREAD_PRIVATE_MUTEX_UNLOCK(name)                              \
+        _thread_tag_unlock(&(__THREAD_NAME(name)))
+#define _THREAD_PRIVATE(keyname, storage, error)                        \
+        _thread_tag_storage(&(__THREAD_NAME(keyname)), &(storage),      \
+                            sizeof (storage), error)
+/*
+ * Resolver code is special cased in that it uses global keys.
+ */
+extern void *__THREAD_NAME(_res);
+extern void *__THREAD_NAME(_res_ext);
+extern void *__THREAD_NAME(serv_mutex);
+
+/*
+ * File descriptor locking definitions.
+ */
+#define FD_READ         0x1
+#define FD_WRITE        0x2
+#define FD_RDWR         (FD_READ | FD_WRITE)
+
+struct timespec;
+int     _thread_fd_lock(int, int, struct timespec *);
+void    _thread_fd_unlock(int, int);
+
+/*
+ * Macros are used in libc code for historical (debug) reasons.
+ * Define them here.
+ */
+#define _FD_LOCK(_fd,_type,_ts) _thread_fd_lock(_fd, _type, _ts)
+#define _FD_UNLOCK(_fd,_type)   _thread_fd_unlock(_fd, _type)
+
+
+/*
+ * malloc lock/unlock prototypes and definitions
+ */
+void    _thread_malloc_init(void);
+void    _thread_malloc_lock(void);
+void    _thread_malloc_unlock(void);
+
+#define _MALLOC_LOCK()          do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_lock();  \
+                                } while (0)
+#define _MALLOC_UNLOCK()        do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_unlock();\
+                                } while (0)
+#define _MALLOC_LOCK_INIT()     do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_init();\
+                                } while (0)
+
+void    _thread_atexit_lock(void);
+void    _thread_atexit_unlock(void);
+
+#define _ATEXIT_LOCK()          do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_atexit_lock();  \
+                                } while (0)
+#define _ATEXIT_UNLOCK()        do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_atexit_unlock();\
+                                } while (0)
+
+#endif /* _THREAD_PRIVATE_H_ */
diff --git a/src/lib/libc/net/Makefile.inc b/src/lib/libc/net/Makefile.inc
new file mode 100644
index 0000000000..db2738f868
--- /dev/null
+++ b/src/lib/libc/net/Makefile.inc
@@ -0,0 +1,90 @@
+#       $OpenBSD: Makefile.inc,v 1.42 2005/10/02 14:48:48 jmc Exp $
+
+# net sources
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/net ${LIBCSRCDIR}/net
+
+CFLAGS+=-DRESOLVSORT
+
+SRCS+=  base64.c freeaddrinfo.c gai_strerror.c getaddrinfo.c gethostnamadr.c \
+        getifaddrs.c getnameinfo.c getnetbyaddr.c getnetbyname.c getnetent.c \
+        getnetnamadr.c getproto.c getprotoent.c getprotoname.c \
+        getservbyname.c getservbyport.c getservent.c getrrsetbyname.c \
+        herror.c if_indextoname.c if_nameindex.c if_nametoindex.c inet_addr.c \
+        inet_lnaof.c inet_makeaddr.c inet_neta.c inet_netof.c inet_network.c \
+        inet_net_ntop.c inet_net_pton.c inet_ntoa.c inet_ntop.c inet_pton.c \
+        ipx_addr.c ipx_ntoa.c linkaddr.c net_addrcmp.c nsap_addr.c \
+        rcmd.c rresvport.c recv.c res_comp.c res_data.c res_debug.c \
+        res_debug_syms.c \
+        res_init.c res_mkquery.c res_query.c res_random.c res_send.c send.c \
+        sethostent.c ethers.c rcmdsh.c
+
+# IPv6
+SRCS+=  ip6opt.c rthdr.c vars6.c
+
+# machine-dependent net sources
+# m-d Makefile.inc must include sources for:
+#       htonl() htons() ntohl() ntohs()
+
+.include "${LIBCSRCDIR}/arch/${MACHINE_ARCH}/net/Makefile.inc"
+
+MAN+=   byteorder.3 ethers.3 gai_strerror.3 getaddrinfo.3 gethostbyname.3 \
+        getifaddrs.3 getnameinfo.3 getnetent.3 getprotoent.3 \
+        getrrsetbyname.3 getservent.3 if_indextoname.3 inet.3 \
+        inet_net.3 inet6_option_space.3 inet6_rthdr_space.3 \
+        ipx.3 link_addr.3 net_addrcmp.3 \
+        rcmd.3 rcmdsh.3 resolver.3
+
+MLINKS+=byteorder.3 htonl.3 byteorder.3 htons.3 byteorder.3 ntohl.3 \
+        byteorder.3 ntohs.3 byteorder.3 htobe16.3 byteorder.3 htobe32.3 \
+        byteorder.3 htobe64.3 byteorder.3 betoh16.3 byteorder.3 betoh32.3 \
+        byteorder.3 betoh64.3 byteorder.3 htole16.3 byteorder.3 htole32.3 \
+        byteorder.3 htole64.3 byteorder.3 letoh16.3 byteorder.3 letoh32.3 \
+        byteorder.3 letoh64.3 byteorder.3 swap16.3 byteorder.3 swap32.3 \
+        byteorder.3 swap64.3
+MLINKS+=ethers.3 ether_aton.3 ethers.3 ether_hostton.3 ethers.3 ether_line.3 \
+        ethers.3 ether_ntoa.3 ethers.3 ether_ntohost.3
+MLINKS+=getaddrinfo.3 freeaddrinfo.3
+MLINKS+=gethostbyname.3 endhostent.3 gethostbyname.3 gethostbyaddr.3 \
+        gethostbyname.3 sethostent.3 gethostbyname.3 gethostent.3 \
+        gethostbyname.3 herror.3 gethostbyname.3 gethostbyname2.3 \
+        gethostbyname.3 hstrerror.3
+MLINKS+=getifaddrs.3 freeifaddrs.3
+MLINKS+=getnetent.3 endnetent.3 getnetent.3 getnetbyaddr.3 \
+        getnetent.3 getnetbyname.3 getnetent.3 setnetent.3
+MLINKS+=getprotoent.3 endprotoent.3 getprotoent.3 getprotobyname.3 \
+        getprotoent.3 getprotobynumber.3 getprotoent.3 setprotoent.3 \
+        getprotoent.3 getprotoent_r.3 getprotoent.3 getprotobyname_r.3 \
+        getprotoent.3 getprotobynumber_r.3 getprotoent.3 setprotoent_r.3 \
+        getprotoent.3 endprotoent_r.3
+MLINKS+=getservent.3 endservent.3 getservent.3 getservbyname.3 \
+        getservent.3 getservbyport.3 getservent.3 setservent.3 \
+        getservent.3 getservent_r.3 getservent.3 getservbyname_r.3 \
+        getservent.3 getservbyport_r.3 setservent.3 setservent_r.3 \
+        setservent.3 endservent_r.3
+MLINKS+= if_indextoname.3 if_nametoindex.3 if_indextoname.3 if_nameindex.3 \
+        if_indextoname.3 if_freenameindex.3
+MLINKS+=inet.3 addr.3 inet.3 inet_addr.3 inet.3 inet_aton.3 \
+        inet.3 inet_lnaof.3 inet.3 inet_makeaddr.3 inet.3 inet_netof.3 \
+        inet.3 inet_network.3 inet.3 inet_ntoa.3 inet.3 network.3 \
+        inet.3 ntoa.3 inet.3 inet_ntop.3 inet.3 inet_pton.3
+MLINKS+=inet_net.3 inet_net_ntop.3 inet_net.3 inet_net_pton.3
+MLINKS+=link_addr.3 link_ntoa.3
+MLINKS+=ipx.3 ipx_addr.3 ipx.3 ipx_ntoa.3
+MLINKS+=rcmd.3 iruserok.3 rcmd.3 rresvport.3 rcmd.3 ruserok.3 \
+        rcmd.3 rresvport_af.3 rcmd.3 rcmd_af.3 rcmd.3 iruserok_sa.3
+MLINKS+=resolver.3 dn_comp.3 resolver.3 dn_expand.3 resolver.3 res_init.3 \
+        resolver.3 res_mkquery.3 resolver.3 res_send.3 resolver.3 res_query.3 \
+        resolver.3 res_search.3
+MLINKS+=getrrsetbyname.3 freerrset.3
+MLINKS+=inet6_option_space.3 inet6_option_init.3 \
+        inet6_option_space.3 inet6_option_append.3 \
+        inet6_option_space.3 inet6_option_alloc.3 \
+        inet6_option_space.3 inet6_option_next.3 \
+        inet6_option_space.3 inet6_option_find.3
+MLINKS+=inet6_rthdr_space.3 inet6_rthdr_init.3 \
+        inet6_rthdr_space.3 inet6_rthdr_add.3 \
+        inet6_rthdr_space.3 inet6_rthdr_lasthop.3 \
+        inet6_rthdr_space.3 inet6_rthdr_reverse.3 \
+        inet6_rthdr_space.3 inet6_rthdr_segments.3 \
+        inet6_rthdr_space.3 inet6_rthdr_getaddr.3 \
+        inet6_rthdr_space.3 inet6_rthdr_getflags.3
diff --git a/src/lib/libc/net/base64.c b/src/lib/libc/net/base64.c
new file mode 100644
index 0000000000..33b6ffdc41
--- /dev/null
+++ b/src/lib/libc/net/base64.c
@@ -0,0 +1,318 @@
+/*      $OpenBSD: base64.c,v 1.4 2002/01/02 23:00:10 deraadt Exp $      */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <ctype.h>
+#include <resolv.h>
+#include <stdio.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+/* XXX abort illegal in library */
+#define Assert(Cond) if (!(Cond)) abort()
+
+static const char Base64[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
+
+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
+   The following encoding technique is taken from RFC 1521 by Borenstein
+   and Freed.  It is reproduced here in a slightly edited form for
+   convenience.
+
+   A 65-character subset of US-ASCII is used, enabling 6 bits to be
+   represented per printable character. (The extra 65th character, "=",
+   is used to signify a special processing function.)
+
+   The encoding process represents 24-bit groups of input bits as output
+   strings of 4 encoded characters. Proceeding from left to right, a
+   24-bit input group is formed by concatenating 3 8-bit input groups.
+   These 24 bits are then treated as 4 concatenated 6-bit groups, each
+   of which is translated into a single digit in the base64 alphabet.
+
+   Each 6-bit group is used as an index into an array of 64 printable
+   characters. The character referenced by the index is placed in the
+   output string.
+
+                         Table 1: The Base64 Alphabet
+
+      Value Encoding  Value Encoding  Value Encoding  Value Encoding
+          0 A            17 R            34 i            51 z
+          1 B            18 S            35 j            52 0
+          2 C            19 T            36 k            53 1
+          3 D            20 U            37 l            54 2
+          4 E            21 V            38 m            55 3
+          5 F            22 W            39 n            56 4
+          6 G            23 X            40 o            57 5
+          7 H            24 Y            41 p            58 6
+          8 I            25 Z            42 q            59 7
+          9 J            26 a            43 r            60 8
+         10 K            27 b            44 s            61 9
+         11 L            28 c            45 t            62 +
+         12 M            29 d            46 u            63 /
+         13 N            30 e            47 v
+         14 O            31 f            48 w         (pad) =
+         15 P            32 g            49 x
+         16 Q            33 h            50 y
+
+   Special processing is performed if fewer than 24 bits are available
+   at the end of the data being encoded.  A full encoding quantum is
+   always completed at the end of a quantity.  When fewer than 24 input
+   bits are available in an input group, zero bits are added (on the
+   right) to form an integral number of 6-bit groups.  Padding at the
+   end of the data is performed using the '=' character.
+
+   Since all base64 input is an integral number of octets, only the
+         -------------------------------------------------                       
+   following cases can arise:
+   
+       (1) the final quantum of encoding input is an integral
+           multiple of 24 bits; here, the final unit of encoded
+           output will be an integral multiple of 4 characters
+           with no "=" padding,
+       (2) the final quantum of encoding input is exactly 8 bits;
+           here, the final unit of encoded output will be two
+           characters followed by two "=" padding characters, or
+       (3) the final quantum of encoding input is exactly 16 bits;
+           here, the final unit of encoded output will be three
+           characters followed by one "=" padding character.
+   */
+
+int
+b64_ntop(src, srclength, target, targsize)
+        u_char const *src;
+        size_t srclength;
+        char *target;
+        size_t targsize;
+{
+        size_t datalength = 0;
+        u_char input[3];
+        u_char output[4];
+        int i;
+
+        while (2 < srclength) {
+                input[0] = *src++;
+                input[1] = *src++;
+                input[2] = *src++;
+                srclength -= 3;
+
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                output[3] = input[2] & 0x3f;
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+                Assert(output[3] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                target[datalength++] = Base64[output[2]];
+                target[datalength++] = Base64[output[3]];
+        }
+    
+        /* Now we worry about padding. */
+        if (0 != srclength) {
+                /* Get what's left. */
+                input[0] = input[1] = input[2] = '\0';
+                for (i = 0; i < srclength; i++)
+                        input[i] = *src++;
+        
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                if (srclength == 1)
+                        target[datalength++] = Pad64;
+                else
+                        target[datalength++] = Base64[output[2]];
+                target[datalength++] = Pad64;
+        }
+        if (datalength >= targsize)
+                return (-1);
+        target[datalength] = '\0';      /* Returned value doesn't count \0. */
+        return (datalength);
+}
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+b64_pton(src, target, targsize)
+        char const *src;
+        u_char *target;
+        size_t targsize;
+{
+        int tarindex, state, ch;
+        char *pos;
+
+        state = 0;
+        tarindex = 0;
+
+        while ((ch = *src++) != '\0') {
+                if (isspace(ch))        /* Skip whitespace anywhere. */
+                        continue;
+
+                if (ch == Pad64)
+                        break;
+
+                pos = strchr(Base64, ch);
+                if (pos == 0)           /* A non-base64 character. */
+                        return (-1);
+
+                switch (state) {
+                case 0:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] = (pos - Base64) << 2;
+                        }
+                        state = 1;
+                        break;
+                case 1:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 4;
+                                target[tarindex+1]  = ((pos - Base64) & 0x0f)
+                                                        << 4 ;
+                        }
+                        tarindex++;
+                        state = 2;
+                        break;
+                case 2:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 2;
+                                target[tarindex+1]  = ((pos - Base64) & 0x03)
+                                                        << 6;
+                        }
+                        tarindex++;
+                        state = 3;
+                        break;
+                case 3:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] |= (pos - Base64);
+                        }
+                        tarindex++;
+                        state = 0;
+                        break;
+                }
+        }
+
+        /*
+         * We are done decoding Base-64 chars.  Let's see if we ended
+         * on a byte boundary, and/or with erroneous trailing characters.
+         */
+
+        if (ch == Pad64) {              /* We got a pad char. */
+                ch = *src++;            /* Skip it, get next. */
+                switch (state) {
+                case 0:         /* Invalid = in first position */
+                case 1:         /* Invalid = in second position */
+                        return (-1);
+
+                case 2:         /* Valid, means one byte of info */
+                        /* Skip any number of spaces. */
+                        for (; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        break;
+                        /* Make sure there is another trailing = sign. */
+                        if (ch != Pad64)
+                                return (-1);
+                        ch = *src++;            /* Skip the = */
+                        /* Fall through to "single trailing =" case. */
+                        /* FALLTHROUGH */
+
+                case 3:         /* Valid, means two bytes of info */
+                        /*
+                         * We know this char is an =.  Is there anything but
+                         * whitespace after it?
+                         */
+                        for (; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        return (-1);
+
+                        /*
+                         * Now make sure for cases 2 and 3 that the "extra"
+                         * bits that slopped past the last full byte were
+                         * zeros.  If we don't check them, they become a
+                         * subliminal channel.
+                         */
+                        if (target && target[tarindex] != 0)
+                                return (-1);
+                }
+        } else {
+                /*
+                 * We ended by seeing the end of the string.  Make sure we
+                 * have no partial bytes lying around.
+                 */
+                if (state != 0)
+                        return (-1);
+        }
+
+        return (tarindex);
+}
diff --git a/src/lib/libc/net/byteorder.3 b/src/lib/libc/net/byteorder.3
new file mode 100644
index 0000000000..e548958617
--- /dev/null
+++ b/src/lib/libc/net/byteorder.3
@@ -0,0 +1,206 @@
+.\"     $OpenBSD: byteorder.3,v 1.14 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd June 4, 1993
+.Dt BYTEORDER 3
+.Os
+.Sh NAME
+.Nm htonl ,
+.Nm htons ,
+.Nm ntohl ,
+.Nm ntohs ,
+.Nm htobe64 ,
+.Nm htobe32 ,
+.Nm htobe16 ,
+.Nm betoh64 ,
+.Nm betoh32 ,
+.Nm betoh16 ,
+.Nm htole64 ,
+.Nm htole32 ,
+.Nm htole16 ,
+.Nm letoh64 ,
+.Nm letoh32 ,
+.Nm letoh16 ,
+.Nm swap64 ,
+.Nm swap32 ,
+.Nm swap16
+.Nd convert values between different byte orderings
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Ft u_int32_t
+.Fn htonl "u_int32_t host32"
+.Ft u_int16_t
+.Fn htons "u_int16_t host16"
+.Ft u_int32_t
+.Fn ntohl "u_int32_t net32"
+.Ft u_int16_t
+.Fn ntohs "u_int16_t net16"
+.Ft u_int64_t
+.Fn htobe64 "u_int64_t host64"
+.Ft u_int32_t
+.Fn htobe32 "u_int32_t host32"
+.Ft u_int16_t
+.Fn htobe16 "u_int16_t host16"
+.Ft u_int64_t
+.Fn betoh64 "u_int64_t big64"
+.Ft u_int32_t
+.Fn betoh32 "u_int32_t big32"
+.Ft u_int16_t
+.Fn betoh16 "u_int16_t big16"
+.Ft u_int64_t
+.Fn htole64 "u_int64_t host64"
+.Ft u_int32_t
+.Fn htole32 "u_int32_t host32"
+.Ft u_int16_t
+.Fn htole16 "u_int16_t host16"
+.Ft u_int64_t
+.Fn letoh64 "u_int64_t little64"
+.Ft u_int32_t
+.Fn letoh32 "u_int32_t little32"
+.Ft u_int16_t
+.Fn letoh16 "u_int16_t little16"
+.Ft u_int64_t
+.Fn swap64 "u_int32_t val64"
+.Ft u_int32_t
+.Fn swap32 "u_int32_t val32"
+.Ft u_int16_t
+.Fn swap16 "u_int16_t val16"
+.Sh DESCRIPTION
+These routines convert 16, 32 and 64-bit quantities between different
+byte orderings.
+The
+.Dq swap
+functions reverse the byte ordering of
+the given quantity; the others convert either from/to the native
+byte order used by the host to/from either little- or big-endian (a.k.a
+network) order.
+.Pp
+Apart from the swap functions, the names can be described by this form:
+{src-order}to{dst-order}{size}.
+Both {src-order} and {dst-order} can take the following forms:
+.Pp
+.Bl -tag -width "be " -offset indent -compact
+.It h
+Host order.
+.It n
+Network order (big-endian).
+.It be
+Big-endian (most significant byte first).
+.It le
+Little-endian (least significant byte first).
+.El
+.Pp
+One of the specified orderings must be
+.Sq h .
+{size} will take these forms:
+.Pp
+.Bl -tag -width "32 " -offset indent -compact
+.It l
+Long (32-bit, used in conjunction with forms involving
+.Sq n ) .
+.It s
+Short (16-bit, used in conjunction with forms involving
+.Sq n ) .
+.It 16
+16-bit.
+.It 32
+32-bit.
+.It 64
+64-bit.
+.El
+.Pp
+The swap functions are of the form: swap{size}.
+.Pp
+Names involving
+.Sq n
+convert quantities between network
+byte order and host byte order.
+The last letter
+.Pf ( Sq s
+or
+.Sq l )
+is a mnemonic
+for the traditional names for such quantities,
+.Li short
+and
+.Li long ,
+respectively.
+Today, the C concept of
+.Li short
+and
+.Li long
+integers need not coincide with this traditional misunderstanding.
+On machines which have a byte order which is the same as the network
+order, routines are defined as null macros.
+.Pp
+The functions involving either
+.Dq be ,
+.Dq le ,
+or
+.Dq swap
+use the numbers
+16, 32, or 64 for specifying the bitwidth of the quantities they operate on.
+Currently all supported architectures are either big- or little-endian
+so either the
+.Dq be
+or
+.Dq le
+variants are implemented as null macros.
+.Pp
+The routines mentioned above which have either {src-order} or {dst-order}
+set to
+.Sq n
+are most often used in
+conjunction with Internet addresses and ports as returned by
+.Xr gethostbyname 3
+and
+.Xr getservent 3 .
+.Sh SEE ALSO
+.Xr gethostbyname 3 ,
+.Xr getservent 3
+.Sh STANDARDS
+The
+.Fn htonl ,
+.Fn htons ,
+.Fn ntohl ,
+and
+.Fn ntohs
+functions conform to
+.St -p1003.1 .
+The other functions are extensions that should not be used when portability
+is required.
+.Sh HISTORY
+The
+.Nm byteorder
+functions appeared in
+.Bx 4.2 .
+.Sh BUGS
+On the vax, alpha, i386, and some mips architectures,
+bytes are handled backwards from most everyone else in the world.
+This is not expected to be fixed in the near future.
diff --git a/src/lib/libc/net/ethers.3 b/src/lib/libc/net/ethers.3
new file mode 100644
index 0000000000..fac9c590e3
--- /dev/null
+++ b/src/lib/libc/net/ethers.3
@@ -0,0 +1,122 @@
+.\"     $OpenBSD: ethers.3,v 1.18 2005/12/30 20:45:59 claudio Exp $
+.\"
+.\" Written by roland@frob.com.  Public domain.
+.\"
+.Dd December 16, 1993
+.Dt ETHERS 3
+.Os
+.Sh NAME
+.Nm ether_aton ,
+.Nm ether_ntoa ,
+.Nm ether_ntohost ,
+.Nm ether_hostton ,
+.Nm ether_line
+.Nd get ethers entry
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <net/if.h>
+.Fd #include <netinet/in.h>
+.Fd #include <netinet/if_ether.h>
+.Ft char *
+.Fn ether_ntoa "struct ether_addr *e"
+.Ft struct ether_addr *
+.Fn ether_aton "const char *s"
+.Ft int
+.Fn ether_ntohost "char *hostname" "struct ether_addr *e"
+.Ft int
+.Fn ether_hostton "const char *hostname" "struct ether_addr *e"
+.Ft int
+.Fn ether_line "const char *l" "struct ether_addr *e" "char *hostname"
+.Sh DESCRIPTION
+Ethernet addresses are represented by the
+following structure:
+.Bd -literal -offset indent
+struct ether_addr {
+        u_int8_t  ether_addr_octet[6];
+};
+.Ed
+.Pp
+The
+.Fn ether_ntoa
+function converts this structure into an
+.Tn ASCII
+string of the form
+.Dq xx:xx:xx:xx:xx:xx ,
+consisting of 6 hexadecimal numbers separated
+by colons.
+It returns a pointer to a static buffer that is reused for each call.
+The
+.Fn ether_aton
+converts an
+.Tn ASCII
+string of the same form and to a structure
+containing the 6 octets of the address.
+It returns a pointer to a static structure that is reused for each call.
+.Pp
+The
+.Fn ether_ntohost
+and
+.Fn ether_hostton
+functions interrogate the database mapping host names to Ethernet
+addresses,
+.Pa /etc/ethers .
+The
+.Fn ether_ntohost
+function looks up the given Ethernet address and writes the associated
+host name into the character buffer passed.
+This buffer should be
+.Dv MAXHOSTNAMELEN
+characters in size.
+The
+.Fn ether_hostton
+function looks up the given host name and writes the associated
+Ethernet address into the structure passed.
+Both functions return
+zero if they find the requested host name or address, and \-1 if not.
+.Pp
+Each call reads
+.Pa /etc/ethers
+from the beginning; if a
+.Ql +
+appears alone on a line in the file, then
+.Fn ether_hostton
+will consult the
+.Pa ethers.byname
+YP map, and
+.Fn ether_ntohost
+will consult the
+.Pa ethers.byaddr
+YP map.
+.Pp
+The
+.Fn ether_line
+function parses a line from the
+.Pa /etc/ethers
+file and fills in the passed
+.Li struct ether_addr
+and character buffer with the Ethernet address and host name on the line.
+It returns zero if the line was successfully parsed and \-1 if not.
+The character buffer should be
+.Dv MAXHOSTNAMELEN
+characters in size.
+.Sh FILES
+.Bl -tag -width /etc/ethers -compact
+.It Pa /etc/ethers
+.El
+.Sh SEE ALSO
+.Xr ethers 5
+.Sh HISTORY
+The
+.Fn ether_ntoa ,
+.Fn ether_aton ,
+.Fn ether_ntohost ,
+.Fn ether_hostton ,
+and
+.Fn ether_line
+functions were adopted from SunOS and appeared in
+.Nx 0.9 b.
+.Sh BUGS
+The data space used by these functions is static; if future use
+requires the data, it should be copied before any subsequent calls to
+these functions overwrite it.
diff --git a/src/lib/libc/net/ethers.c b/src/lib/libc/net/ethers.c
new file mode 100644
index 0000000000..d4243ff1da
--- /dev/null
+++ b/src/lib/libc/net/ethers.c
@@ -0,0 +1,232 @@
+/*      $OpenBSD: ethers.c,v 1.20 2005/08/06 20:30:03 espie Exp $       */
+
+/*
+ * Copyright (c) 1998 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.
+ */
+
+/* 
+ * ethers(3) a la Sun.
+ * Originally Written by Roland McGrath <roland@frob.com> 10/14/93.
+ * Substantially modified by Todd C. Miller <Todd.Miller@courtesan.com>
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <netinet/if_ether.h>
+#include <sys/param.h>
+#include <paths.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#ifdef YP
+#include <rpcsvc/ypclnt.h>
+#endif
+
+#ifndef _PATH_ETHERS
+#define _PATH_ETHERS    "/etc/ethers"
+#endif
+
+static char * _ether_aton(const char *, struct ether_addr *);
+
+char *
+ether_ntoa(struct ether_addr *e)
+{
+        static char a[] = "xx:xx:xx:xx:xx:xx";
+
+        (void)snprintf(a, sizeof a, "%02x:%02x:%02x:%02x:%02x:%02x",
+            e->ether_addr_octet[0], e->ether_addr_octet[1],
+            e->ether_addr_octet[2], e->ether_addr_octet[3],
+            e->ether_addr_octet[4], e->ether_addr_octet[5]);
+
+        return (a);
+}
+
+static char *
+_ether_aton(const char *s, struct ether_addr *e)
+{
+        int i;
+        long l;
+        char *pp;
+
+        while (isspace(*s))
+                s++;
+
+        /* expect 6 hex octets separated by ':' or space/NUL if last octet */
+        for (i = 0; i < 6; i++) {
+                l = strtol(s, &pp, 16);
+                if (pp == s || l > 0xFF || l < 0)
+                        return (NULL);
+                if (!(*pp == ':' || (i == 5 && (isspace(*pp) || *pp == '\0'))))
+                        return (NULL);
+                e->ether_addr_octet[i] = (u_char)l;
+                s = pp + 1;
+        }
+
+        /* return character after the octets ala strtol(3) */
+        return (pp);
+}
+
+struct ether_addr *
+ether_aton(const char *s)
+{
+        static struct ether_addr n;
+
+        return (_ether_aton(s, &n) ? &n : NULL);
+}
+
+int
+ether_ntohost(char *hostname, struct ether_addr *e)
+{
+        FILE *f; 
+        char buf[BUFSIZ+1], *p;
+        size_t len;
+        struct ether_addr try;
+#ifdef YP
+        char trybuf[sizeof("xx:xx:xx:xx:xx:xx")];
+        int trylen;
+#endif
+
+#ifdef YP
+        snprintf(trybuf, sizeof trybuf, "%x:%x:%x:%x:%x:%x", 
+            e->ether_addr_octet[0], e->ether_addr_octet[1],
+            e->ether_addr_octet[2], e->ether_addr_octet[3],
+            e->ether_addr_octet[4], e->ether_addr_octet[5]);
+        trylen = strlen(trybuf);
+#endif
+
+        f = fopen(_PATH_ETHERS, "r");
+        if (f == NULL)
+                return (-1);
+        while ((p = fgetln(f, &len)) != NULL) {
+                if (p[len-1] == '\n')
+                        len--;
+                if (len > sizeof(buf) - 2)
+                        continue;
+                (void)memcpy(buf, p, len);
+                buf[len] = '\n';        /* code assumes newlines later on */
+                buf[len+1] = '\0';
+#ifdef YP
+                /* A + in the file means try YP now.  */
+                if (!strncmp(buf, "+\n", sizeof(buf))) {
+                        char *ypbuf, *ypdom;
+                        int ypbuflen;
+
+                        if (yp_get_default_domain(&ypdom))
+                                continue;
+                        if (yp_match(ypdom, "ethers.byaddr", trybuf,
+                            trylen, &ypbuf, &ypbuflen))
+                                continue;
+                        if (ether_line(ypbuf, &try, hostname) == 0) {
+                                free(ypbuf);
+                                (void)fclose(f);
+                                return (0);
+                        }
+                        free(ypbuf);
+                        continue;
+                }
+#endif
+                if (ether_line(buf, &try, hostname) == 0 &&
+                    memcmp((void *)&try, (void *)e, sizeof(try)) == 0) {
+                        (void)fclose(f);
+                        return (0);
+                }     
+        }
+        (void)fclose(f);
+        errno = ENOENT;
+        return (-1);
+}
+
+int
+ether_hostton(const char *hostname, struct ether_addr *e)
+{
+        FILE *f;
+        char buf[BUFSIZ+1], *p;
+        char try[MAXHOSTNAMELEN];
+        size_t len;
+#ifdef YP
+        int hostlen = strlen(hostname);
+#endif
+
+        f = fopen(_PATH_ETHERS, "r");
+        if (f==NULL)
+                return (-1);
+
+        while ((p = fgetln(f, &len)) != NULL) {
+                if (p[len-1] == '\n')
+                        len--;
+                if (len > sizeof(buf) - 2)
+                        continue;
+                memcpy(buf, p, len);
+                buf[len] = '\n';        /* code assumes newlines later on */
+                buf[len+1] = '\0';
+#ifdef YP
+                /* A + in the file means try YP now.  */
+                if (!strncmp(buf, "+\n", sizeof(buf))) {
+                        char *ypbuf, *ypdom;
+                        int ypbuflen;
+
+                        if (yp_get_default_domain(&ypdom))
+                                continue;
+                        if (yp_match(ypdom, "ethers.byname", hostname, hostlen,
+                            &ypbuf, &ypbuflen))
+                                continue;
+                        if (ether_line(ypbuf, e, try) == 0) {
+                                free(ypbuf);
+                                (void)fclose(f);
+                                return (0);
+                        }
+                        free(ypbuf);
+                        continue;
+                }
+#endif
+                if (ether_line(buf, e, try) == 0 && strcmp(hostname, try) == 0) {
+                        (void)fclose(f);
+                        return (0);
+                }
+        }
+        (void)fclose(f);
+        errno = ENOENT;
+        return (-1);
+}
+
+int
+ether_line(const char *line, struct ether_addr *e, char *hostname)
+{
+        char *p;
+        size_t n;
+
+        /* Parse "xx:xx:xx:xx:xx:xx" */
+        if ((p = _ether_aton(line, e)) == NULL || (*p != ' ' && *p != '\t'))
+                goto bad;
+
+        /* Now get the hostname */
+        while (isspace(*p))
+                p++;
+        if (*p == '\0')
+                goto bad;
+        n = strcspn(p, " \t\n");
+        if (n >= MAXHOSTNAMELEN)
+                goto bad;
+        strlcpy(hostname, p, n + 1);
+        return (0);
+
+bad:
+        errno = EINVAL;
+        return (-1);
+}
diff --git a/src/lib/libc/net/freeaddrinfo.c b/src/lib/libc/net/freeaddrinfo.c
new file mode 100644
index 0000000000..58702d0b18
--- /dev/null
+++ b/src/lib/libc/net/freeaddrinfo.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: freeaddrinfo.c,v 1.6 2005/03/25 13:24:11 otto Exp $   */
+
+/*
+ * Copyright (c) 1996, 1997, 1998, 1999, Craig Metz, 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 Craig Metz and
+ *      by other contributors.
+ * 4. Neither the name of the author nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <netdb.h>
+
+void
+freeaddrinfo(struct addrinfo *ai)
+{
+        struct addrinfo *p;
+
+        do {
+                p = ai;
+                ai = ai->ai_next;
+                if (p->ai_canonname)
+                        free(p->ai_canonname);
+                free((void *)p);
+        } while (ai);
+}
diff --git a/src/lib/libc/net/gai_strerror.3 b/src/lib/libc/net/gai_strerror.3
new file mode 100644
index 0000000000..d0a636ee03
--- /dev/null
+++ b/src/lib/libc/net/gai_strerror.3
@@ -0,0 +1,93 @@
+.\"     $OpenBSD: gai_strerror.3,v 1.5 2005/01/06 03:50:46 itojun Exp $
+.\"     $KAME: gai_strerror.3,v 1.1 2005/01/05 03:04:47 itojun Exp $
+.\"
+.\" Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
+.\" Copyright (C) 2000, 2001  Internet Software Consortium.
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+.\" REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+.\" INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+.\" LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+.\" OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+.\" PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd December 20, 2004
+.Dt GAI_STRERROR 3
+.Os
+.Sh NAME
+.Nm gai_strerror
+.Nd get error message string from EAI_xxx error code
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netdb.h>
+.Ft "const char *"
+.Fn gai_strerror "int ecode"
+.Sh DESCRIPTION
+The
+.Fn gai_strerror
+function returns an error message string corresponding to the error code
+returned by
+.Xr getaddrinfo 3
+or
+.Xr getnameinfo 3 .
+.Pp
+The following error codes and their meaning are defined in
+.Aq Pa netdb.h :
+.Pp
+.Bl -tag -width "EAI_ADDRFAMILYXX" -offset indent -compact
+.It Dv EAI_ADDRFAMILY
+address family for
+.Fa hostname
+not supported
+.It Dv EAI_AGAIN
+temporary failure in name resolution
+.It Dv EAI_BADFLAGS
+invalid value for
+.Fa ai_flags
+.It Dv EAI_BADHINTS
+invalid value for
+.Fa hints
+.It Dv EAI_FAIL
+non-recoverable failure in name resolution
+.It Dv EAI_FAMILY
+.Fa ai_family
+not supported.
+.It Dv EAI_MEMORY
+memory allocation failure
+.It Dv EAI_NODATA
+no address associated with
+.Fa hostname
+.It Dv EAI_NONAME
+.Fa hostname
+or
+.Fa servname
+not provided, or not known
+.It Dv EAI_PROTOCOL
+resolved protocol is unknown
+.It Dv EAI_SERVICE
+.Fa servname
+not supported for
+.Fa ai_socktype
+.It Dv EAI_SOCKTYPE
+.Fa ai_socktype
+not supported
+.It Dv EAI_SYSTEM
+system error returned in
+.Va errno
+.El
+.Sh RETURN VALUES
+.Fn gai_strerror
+returns a pointer to the error message string corresponding to
+.Fa ecode .
+If
+.Fa ecode
+is out of range, an implementation-specific error message string is returned.
+.Sh SEE ALSO
+.Xr getaddrinfo 3 ,
+.Xr getnameinfo 3
diff --git a/src/lib/libc/net/gai_strerror.c b/src/lib/libc/net/gai_strerror.c
new file mode 100644
index 0000000000..767bc2f7e8
--- /dev/null
+++ b/src/lib/libc/net/gai_strerror.c
@@ -0,0 +1,76 @@
+/*      $OpenBSD: gai_strerror.c,v 1.6 2004/12/20 22:35:32 millert Exp $        */
+
+/*
+ * Copyright (c) 1997-1999, Craig Metz, 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 Craig Metz and
+ *      by other contributors.
+ * 4. Neither the name of the author nor the names of 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.
+ */
+
+/* gai_strerror() v1.38 */
+
+#include <sys/types.h>
+#include <netdb.h>
+#include <errno.h>
+
+const char *
+gai_strerror(int errnum)
+{
+        switch (errnum) {
+        case 0:
+                return "no error";
+        case EAI_BADFLAGS:
+                return "invalid value for ai_flags";
+        case EAI_NONAME:
+                return "name or service is not known";
+        case EAI_AGAIN:
+                return "temporary failure in name resolution";
+        case EAI_FAIL:
+                return "non-recoverable failure in name resolution";
+        case EAI_NODATA:
+                return "no address associated with name";
+        case EAI_FAMILY:
+                return "ai_family not supported";
+        case EAI_SOCKTYPE:
+                return "ai_socktype not supported";
+        case EAI_SERVICE:
+                return "service not supported for ai_socktype";
+        case EAI_ADDRFAMILY:
+                return "address family for name not supported";
+        case EAI_MEMORY:
+                return "memory allocation failure";
+        case EAI_SYSTEM:
+                return "system error";
+        case EAI_BADHINTS:
+                return "invalid value for hints";
+        case EAI_PROTOCOL:
+                return "resolved protocol is unknown";
+        default:
+                return "unknown/invalid error";
+        }
+}
diff --git a/src/lib/libc/net/getaddrinfo.3 b/src/lib/libc/net/getaddrinfo.3
new file mode 100644
index 0000000000..12a0d8ce12
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.3
@@ -0,0 +1,445 @@
+.\"     $OpenBSD: getaddrinfo.3,v 1.43 2005/11/15 19:35:31 otto Exp $
+.\"     $KAME: getaddrinfo.3,v 1.36 2005/01/05 03:23:05 itojun Exp $
+.\"
+.\" Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
+.\" Copyright (C) 2000, 2001  Internet Software Consortium.
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+.\" REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+.\" INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+.\" LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+.\" OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+.\" PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd December 20, 2004
+.Dt GETADDRINFO 3
+.Os
+.Sh NAME
+.Nm getaddrinfo ,
+.Nm freeaddrinfo
+.Nd host and service name to socket address structure
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netdb.h>
+.Ft int
+.Fn getaddrinfo "const char *hostname" "const char *servname" \
+    "const struct addrinfo *hints" "struct addrinfo **res"
+.Ft void
+.Fn freeaddrinfo "struct addrinfo *ai"
+.Sh DESCRIPTION
+The
+.Fn getaddrinfo
+function is used to get a list of
+.Tn IP
+addresses and port numbers for host
+.Fa hostname
+and service
+.Fa servname .
+It is a replacement for and provides more flexibility than the
+.Xr gethostbyname 3
+and
+.Xr getservbyname 3
+functions.
+.Pp
+The
+.Fa hostname
+and
+.Fa servname
+arguments are either pointers to NUL-terminated strings or the null pointer.
+An acceptable value for
+.Fa hostname
+is either a valid host name or a numeric host address string consisting
+of a dotted decimal IPv4 address or an IPv6 address.
+The
+.Fa servname
+is either a decimal port number or a service name listed in
+.Xr services 5 .
+At least one of
+.Fa hostname
+and
+.Fa servname
+must be non-null.
+.Pp
+.Fa hints
+is an optional pointer to a
+.Li struct addrinfo ,
+as defined by
+.Aq Pa netdb.h :
+.Bd -literal
+struct addrinfo {
+        int ai_flags;           /* input flags */
+        int ai_family;          /* protocol family for socket */
+        int ai_socktype;        /* socket type */
+        int ai_protocol;        /* protocol for socket */
+        socklen_t ai_addrlen;   /* length of socket-address */
+        struct sockaddr *ai_addr; /* socket-address for socket */
+        char *ai_canonname;     /* canonical name for service location */
+        struct addrinfo *ai_next; /* pointer to next in list */
+};
+.Ed
+.Pp
+This structure can be used to provide hints concerning the type of socket
+that the caller supports or wishes to use.
+The caller can supply the following structure elements in
+.Fa hints :
+.Bl -tag -width "ai_socktypeXX"
+.It Fa ai_family
+The protocol family that should be used.
+When
+.Fa ai_family
+is set to
+.Dv PF_UNSPEC ,
+it means the caller will accept any protocol family supported by the
+operating system.
+.It Fa ai_socktype
+Denotes the type of socket that is wanted:
+.Dv SOCK_STREAM ,
+.Dv SOCK_DGRAM ,
+or
+.Dv SOCK_RAW .
+When
+.Fa ai_socktype
+is zero the caller will accept any socket type.
+.It Fa ai_protocol
+Indicates which transport protocol is desired,
+.Dv IPPROTO_UDP
+or
+.Dv IPPROTO_TCP .
+If
+.Fa ai_protocol
+is zero the caller will accept any protocol.
+.It Fa ai_flags
+.Fa ai_flags
+is formed by
+.Tn OR Ns 'ing
+the following values:
+.Bl -tag -width "AI_CANONNAMEXX"
+.It Dv AI_CANONNAME
+If the
+.Dv AI_CANONNAME
+bit is set, a successful call to
+.Fn getaddrinfo
+will return a NUL-terminated string containing the canonical name
+of the specified hostname in the
+.Fa ai_canonname
+element of the first
+.Li addrinfo
+structure returned.
+.It Dv AI_NUMERICHOST
+If the
+.Dv AI_NUMERICHOST
+bit is set, it indicates that
+.Fa hostname
+should be treated as a numeric string defining an IPv4 or IPv6 address
+and no name resolution should be attempted.
+.It Dv AI_PASSIVE
+If the
+.Dv AI_PASSIVE
+bit is set it indicates that the returned socket address structure
+is intended for use in a call to
+.Xr bind 2 .
+In this case, if the
+.Fa hostname
+argument is the null pointer, then the IP address portion of the
+socket address structure will be set to
+.Dv INADDR_ANY
+for an IPv4 address or
+.Dv IN6ADDR_ANY_INIT
+for an IPv6 address.
+.Pp
+If the
+.Dv AI_PASSIVE
+bit is not set, the returned socket address structure will be ready
+for use in a call to
+.Xr connect 2
+for a connection-oriented protocol or
+.Xr connect 2 ,
+.Xr sendto 2 ,
+or
+.Xr sendmsg 2
+if a connectionless protocol was chosen.
+The
+.Tn IP
+address portion of the socket address structure will be set to the
+loopback address if
+.Fa hostname
+is the null pointer and
+.Dv AI_PASSIVE
+is not set.
+.El
+.El
+.Pp
+All other elements of the
+.Li addrinfo
+structure passed via
+.Fa hints
+must be zero or the null pointer.
+.Pp
+If
+.Fa hints
+is the null pointer,
+.Fn getaddrinfo
+behaves as if the caller provided a
+.Li struct addrinfo
+with
+.Fa ai_family
+set to
+.Dv PF_UNSPEC
+and all other elements set to zero or
+.Dv NULL .
+.Pp
+After a successful call to
+.Fn getaddrinfo ,
+.Fa *res
+is a pointer to a linked list of one or more
+.Li addrinfo
+structures.
+The list can be traversed by following the
+.Fa ai_next
+pointer in each
+.Li addrinfo
+structure until a null pointer is encountered.
+The three members
+.Fa ai_family ,
+.Fa ai_socktype ,
+and
+.Fa ai_protocol
+in each returned
+.Li addrinfo
+structure are suitable for a call to
+.Xr socket 2 .
+For each
+.Li addrinfo
+structure in the list, the
+.Fa ai_addr
+member points to a filled-in socket address structure of length
+.Fa ai_addrlen .
+.Pp
+This implementation of
+.Fn getaddrinfo
+allows numeric IPv6 address notation with scope identifier,
+as documented in chapter 11 of draft-ietf-ipv6-scoping-arch-02.txt.
+By appending the percent character and scope identifier to addresses,
+one can fill the
+.Li sin6_scope_id
+field for addresses.
+This would make management of scoped addresses easier
+and allows cut-and-paste input of scoped addresses.
+.Pp
+At this moment the code supports only link-local addresses with the format.
+The scope identifier is hardcoded to the name of the hardware interface
+associated
+with the link
+.Po
+such as
+.Li ne0
+.Pc .
+An example is
+.Dq Li fe80::1%ne0 ,
+which means
+.Do
+.Li fe80::1
+on the link associated with the
+.Li ne0
+interface
+.Dc .
+.Pp
+The current implementation assumes a one-to-one relationship between
+the interface and link, which is not necessarily true from the specification.
+.Pp
+All of the information returned by
+.Fn getaddrinfo
+is dynamically allocated: the
+.Li addrinfo
+structures themselves as well as the socket address structures and
+the canonical host name strings included in the
+.Li addrinfo
+structures.
+.Pp
+Memory allocated for the dynamically allocated structures created by
+a successful call to
+.Fn getaddrinfo
+is released by the
+.Fn freeaddrinfo
+function.
+The
+.Fa ai
+pointer should be a
+.Li addrinfo
+structure created by a call to
+.Fn getaddrinfo .
+.Sh RETURN VALUES
+.Fn getaddrinfo
+returns zero on success or one of the error codes listed in
+.Xr gai_strerror 3
+if an error occurs.
+If an error occurs, no memory is allocated by
+.Fn getaddrinfo ,
+therefore it is not necessary to release the
+.Li addrinfo
+structure(s).
+.Sh EXAMPLES
+The following code tries to connect to
+.Dq Li www.kame.net
+service
+.Dq Li www
+via a stream socket.
+It loops through all the addresses available, regardless of address family.
+If the destination resolves to an IPv4 address, it will use an
+.Dv AF_INET
+socket.
+Similarly, if it resolves to IPv6, an
+.Dv AF_INET6
+socket is used.
+Observe that there is no hardcoded reference to a particular address family.
+The code works even if
+.Fn getaddrinfo
+returns addresses that are not IPv4/v6.
+.Bd -literal -offset indent
+struct addrinfo hints, *res, *res0;
+int error;
+int save_errno;
+int s;
+const char *cause = NULL;
+
+memset(&hints, 0, sizeof(hints));
+hints.ai_family = PF_UNSPEC;
+hints.ai_socktype = SOCK_STREAM;
+error = getaddrinfo("www.kame.net", "www", &hints, &res0);
+if (error) {
+        errx(1, "%s", gai_strerror(error));
+        /*NOTREACHED*/
+}
+s = -1;
+for (res = res0; res; res = res->ai_next) {
+        s = socket(res->ai_family, res->ai_socktype,
+            res->ai_protocol);
+        if (s < 0) {
+                cause = "socket";
+                continue;
+        }
+
+        if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
+                cause = "connect";
+                save_errno = errno;
+                close(s);
+                errno = save_errno;
+                s = -1;
+                continue;
+        }
+
+        break;  /* okay we got one */
+}
+if (s < 0) {
+        err(1, "%s", cause);
+        /*NOTREACHED*/
+}
+freeaddrinfo(res0);
+.Ed
+.Pp
+The following example tries to open a wildcard listening socket onto service
+.Dq Li www ,
+for all the address families available.
+.Bd -literal -offset indent
+struct addrinfo hints, *res, *res0;
+int error;
+int save_errno;
+int s[MAXSOCK];
+int nsock;
+const char *cause = NULL;
+
+memset(&hints, 0, sizeof(hints));
+hints.ai_family = PF_UNSPEC;
+hints.ai_socktype = SOCK_STREAM;
+hints.ai_flags = AI_PASSIVE;
+error = getaddrinfo(NULL, "www", &hints, &res0);
+if (error) {
+        errx(1, "%s", gai_strerror(error));
+        /*NOTREACHED*/
+}
+nsock = 0;
+for (res = res0; res && nsock < MAXSOCK; res = res->ai_next) {
+        s[nsock] = socket(res->ai_family, res->ai_socktype,
+            res->ai_protocol);
+        if (s[nsock] < 0) {
+                cause = "socket";
+                continue;
+        }
+
+        if (bind(s[nsock], res->ai_addr, res->ai_addrlen) < 0) {
+                cause = "bind";
+                save_errno = errno;
+                close(s[nsock]);
+                errno = save_errno;
+                continue;
+        }
+        (void) listen(s[nsock], 5);
+
+        nsock++;
+}
+if (nsock == 0) {
+        err(1, "%s", cause);
+        /*NOTREACHED*/
+}
+freeaddrinfo(res0);
+.Ed
+.Sh SEE ALSO
+.Xr bind 2 ,
+.Xr connect 2 ,
+.Xr send 2 ,
+.Xr socket 2 ,
+.Xr gai_strerror 3 ,
+.Xr gethostbyname 3 ,
+.Xr getnameinfo 3 ,
+.Xr getservbyname 3 ,
+.Xr resolver 3 ,
+.Xr hosts 5 ,
+.Xr resolv.conf 5 ,
+.Xr services 5 ,
+.Xr hostname 7 ,
+.Xr named 8
+.Rs
+.%A R. Gilligan
+.%A S. Thomson
+.%A J. Bound
+.%A J. McCann
+.%A W. Stevens
+.%T Basic Socket Interface Extensions for IPv6
+.%R RFC 3493
+.%D February 2003
+.Re
+.Rs
+.%A S. Deering
+.%A B. Haberman
+.%A T. Jinmei
+.%A E. Nordmark
+.%A B. Zill
+.%T "IPv6 Scoped Address Architecture"
+.%R internet draft
+.%N draft-ietf-ipv6-scoping-arch-02.txt
+.%O work in progress material
+.Re
+.Rs
+.%A Craig Metz
+.%T Protocol Independence Using the Sockets API
+.%B "Proceedings of the Freenix Track: 2000 USENIX Annual Technical Conference"
+.%D June 2000
+.Re
+.Sh STANDARDS
+The
+.Fn getaddrinfo
+function is defined by the
+.St -p1003.1g-2000
+draft specification and documented in
+.Dv "RFC 3493" ,
+.Dq Basic Socket Interface Extensions for IPv6 .
+.Sh BUGS
+The implementation of
+.Fn getaddrinfo
+is not thread-safe.
diff --git a/src/lib/libc/net/getaddrinfo.c b/src/lib/libc/net/getaddrinfo.c
new file mode 100644
index 0000000000..06ab8f2095
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.c
@@ -0,0 +1,1781 @@
+/*      $OpenBSD: getaddrinfo.c,v 1.56 2006/04/18 02:57:10 ray Exp $    */
+/*      $KAME: getaddrinfo.c,v 1.31 2000/08/31 17:36:43 itojun Exp $    */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 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.
+ */
+
+/*
+ * Issues to be discussed:
+ * - Thread safe-ness must be checked.
+ * - Return values.  There are nonstandard return values defined and used
+ *   in the source code.  This is because RFC2553 is silent about which error
+ *   code must be returned for which situation.
+ * - IPv4 classful (shortened) form.  RFC2553 is silent about it.  XNET 5.2
+ *   says to use inet_aton() to convert IPv4 numeric to binary (alows
+ *   classful form as a result).
+ *   current code - disallow classful form for IPv4 (due to use of inet_pton).
+ * - freeaddrinfo(NULL).  RFC2553 is silent about it.  XNET 5.2 says it is
+ *   invalid.
+ *   current code - SEGV on freeaddrinfo(NULL)
+ * Note:
+ * - We use getipnodebyname() just for thread-safeness.  There's no intent
+ *   to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to
+ *   getipnodebyname().
+ * - The code filters out AFs that are not supported by the kernel,
+ *   when globbing NULL hostname (to loopback, or wildcard).  Is it the right
+ *   thing to do?  What is the relationship with post-RFC2553 AI_ADDRCONFIG
+ *   in ai_flags?
+ * - (post-2553) semantics of AI_ADDRCONFIG itself is too vague.
+ *   (1) what should we do against numeric hostname (2) what should we do
+ *   against NULL hostname (3) what is AI_ADDRCONFIG itself.  AF not ready?
+ *   non-loopback address configured?  global address configured?
+ * - To avoid search order issue, we have a big amount of code duplicate
+ *   from gethnamaddr.c and some other places.  The issues that there's no
+ *   lower layer function to lookup "IPv4 or IPv6" record.  Calling
+ *   gethostbyname2 from getaddrinfo will end up in wrong search order, as
+ *   follows:
+ *      - The code makes use of following calls when asked to resolver with
+ *        ai_family  = PF_UNSPEC:
+ *              getipnodebyname(host, AF_INET6);
+ *              getipnodebyname(host, AF_INET);
+ *        This will result in the following queries if the node is configure to
+ *        prefer /etc/hosts than DNS:
+ *              lookup /etc/hosts for IPv6 address
+ *              lookup DNS for IPv6 address
+ *              lookup /etc/hosts for IPv4 address
+ *              lookup DNS for IPv4 address
+ *        which may not meet people's requirement.
+ *        The right thing to happen is to have underlying layer which does
+ *        PF_UNSPEC lookup (lookup both) and return chain of addrinfos.
+ *        This would result in a bit of code duplicate with _dns_ghbyname() and
+ *        friends.
+ */
+
+#ifndef INET6
+#define INET6
+#endif
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <syslog.h>
+#include <stdarg.h>
+
+#ifdef YP
+#include <rpc/rpc.h>
+#include <rpcsvc/yp.h>
+#include <rpcsvc/ypclnt.h>
+#include "ypinternal.h"
+#endif
+
+#include "thread_private.h"
+
+#define SUCCESS 0
+#define ANY 0
+#define YES 1
+#define NO  0
+
+static const char in_addrany[] = { 0, 0, 0, 0 };
+static const char in6_addrany[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+static const char in_loopback[] = { 127, 0, 0, 1 };
+static const char in6_loopback[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+};
+
+static const struct afd {
+        int a_af;
+        int a_addrlen;
+        int a_socklen;
+        int a_off;
+        const char *a_addrany;
+        const char *a_loopback; 
+        int a_scoped;
+} afdl [] = {
+#ifdef INET6
+        {PF_INET6, sizeof(struct in6_addr),
+         sizeof(struct sockaddr_in6),
+         offsetof(struct sockaddr_in6, sin6_addr),
+         in6_addrany, in6_loopback, 1},
+#endif
+        {PF_INET, sizeof(struct in_addr),
+         sizeof(struct sockaddr_in),
+         offsetof(struct sockaddr_in, sin_addr),
+         in_addrany, in_loopback, 0},
+        {0, 0, 0, 0, NULL, NULL, 0},
+};
+
+struct explore {
+        int e_af;
+        int e_socktype;
+        int e_protocol;
+        const char *e_protostr;
+        int e_wild;
+#define WILD_AF(ex)             ((ex)->e_wild & 0x01)
+#define WILD_SOCKTYPE(ex)       ((ex)->e_wild & 0x02)
+#define WILD_PROTOCOL(ex)       ((ex)->e_wild & 0x04)
+};
+
+static const struct explore explore[] = {
+#if 0
+        { PF_LOCAL, 0, ANY, ANY, NULL, 0x01 },
+#endif
+#ifdef INET6
+        { PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
+        { PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
+        { PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },
+#endif
+        { PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
+        { PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
+        { PF_INET, SOCK_RAW, ANY, NULL, 0x05 },
+        { PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
+        { PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
+        { PF_UNSPEC, SOCK_RAW, ANY, NULL, 0x05 },
+        { -1, 0, 0, NULL, 0 },
+};
+
+#ifdef INET6
+#define PTON_MAX        16
+#else
+#define PTON_MAX        4
+#endif
+
+#define MAXPACKET       (64*1024)
+
+typedef union {
+        HEADER hdr;
+        u_char buf[MAXPACKET];
+} querybuf;
+
+struct res_target {
+        struct res_target *next;
+        const char *name;       /* domain name */
+        int qclass, qtype;      /* class and type of query */
+        u_char *answer;         /* buffer to put answer */
+        int anslen;             /* size of answer buffer */
+        int n;                  /* result length */
+};
+
+static int explore_fqdn(const struct addrinfo *, const char *,
+        const char *, struct addrinfo **);
+static int explore_null(const struct addrinfo *,
+        const char *, struct addrinfo **);
+static int explore_numeric(const struct addrinfo *, const char *,
+        const char *, struct addrinfo **, const char *);
+static int explore_numeric_scope(const struct addrinfo *, const char *,
+        const char *, struct addrinfo **);
+static int get_canonname(const struct addrinfo *,
+        struct addrinfo *, const char *);
+static struct addrinfo *get_ai(const struct addrinfo *,
+        const struct afd *, const char *);
+static int get_portmatch(const struct addrinfo *, const char *);
+static int get_port(struct addrinfo *, const char *, int);
+static const struct afd *find_afd(int);
+#ifdef INET6
+static int ip6_str2scopeid(char *, struct sockaddr_in6 *, u_int32_t *);
+#endif
+
+static void _sethtent(void);
+static void _endhtent(void);
+static struct addrinfo * _gethtent(const char *, const struct addrinfo *);
+static struct addrinfo *_files_getaddrinfo(const char *,
+        const struct addrinfo *);
+
+#ifdef YP
+static struct addrinfo *_yphostent(char *, const struct addrinfo *);
+static struct addrinfo *_yp_getaddrinfo(const char *,
+        const struct addrinfo *);
+#endif
+
+static struct addrinfo *getanswer(const querybuf *, int, const char *, int,
+        const struct addrinfo *);
+static int res_queryN(const char *, struct res_target *);
+static int res_searchN(const char *, struct res_target *);
+static int res_querydomainN(const char *, const char *, struct res_target *);
+static struct addrinfo *_dns_getaddrinfo(const char *, const struct addrinfo *);
+
+
+/* XXX macros that make external reference is BAD. */
+
+#define GET_AI(ai, afd, addr) \
+do { \
+        /* external reference: pai, error, and label free */ \
+        (ai) = get_ai(pai, (afd), (addr)); \
+        if ((ai) == NULL) { \
+                error = EAI_MEMORY; \
+                goto free; \
+        } \
+} while (/*CONSTCOND*/0)
+
+#define GET_PORT(ai, serv) \
+do { \
+        /* external reference: error and label free */ \
+        error = get_port((ai), (serv), 0); \
+        if (error != 0) \
+                goto free; \
+} while (/*CONSTCOND*/0)
+
+#define GET_CANONNAME(ai, str) \
+do { \
+        /* external reference: pai, error and label free */ \
+        error = get_canonname(pai, (ai), (str)); \
+        if (error != 0) \
+                goto free; \
+} while (/*CONSTCOND*/0)
+
+#define ERR(err) \
+do { \
+        /* external reference: error, and label bad */ \
+        error = (err); \
+        goto bad; \
+        /*NOTREACHED*/ \
+} while (/*CONSTCOND*/0)
+
+#define MATCH_FAMILY(x, y, w) \
+        ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC)))
+#define MATCH(x, y, w) \
+        ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))
+
+int
+getaddrinfo(const char *hostname, const char *servname,
+    const struct addrinfo *hints, struct addrinfo **res)
+{
+        struct addrinfo sentinel;
+        struct addrinfo *cur;
+        int error = 0;
+        struct addrinfo ai;
+        struct addrinfo ai0;
+        struct addrinfo *pai;
+        const struct explore *ex;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+        pai = &ai;
+        pai->ai_flags = 0;
+        pai->ai_family = PF_UNSPEC;
+        pai->ai_socktype = ANY;
+        pai->ai_protocol = ANY;
+        pai->ai_addrlen = 0;
+        pai->ai_canonname = NULL;
+        pai->ai_addr = NULL;
+        pai->ai_next = NULL;
+        
+        if (hostname == NULL && servname == NULL)
+                return EAI_NONAME;
+        if (hints) {
+                /* error check for hints */
+                if (hints->ai_addrlen || hints->ai_canonname ||
+                    hints->ai_addr || hints->ai_next)
+                        ERR(EAI_BADHINTS); /* xxx */
+                if (hints->ai_flags & ~AI_MASK)
+                        ERR(EAI_BADFLAGS);
+                switch (hints->ai_family) {
+                case PF_UNSPEC:
+                case PF_INET:
+#ifdef INET6
+                case PF_INET6:
+#endif
+                        break;
+                default:
+                        ERR(EAI_FAMILY);
+                }
+                memcpy(pai, hints, sizeof(*pai));
+
+                /*
+                 * if both socktype/protocol are specified, check if they
+                 * are meaningful combination.
+                 */
+                if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
+                        for (ex = explore; ex->e_af >= 0; ex++) {
+                                if (pai->ai_family != ex->e_af)
+                                        continue;
+                                if (ex->e_socktype == ANY)
+                                        continue;
+                                if (ex->e_protocol == ANY)
+                                        continue;
+                                if (pai->ai_socktype == ex->e_socktype
+                                 && pai->ai_protocol != ex->e_protocol) {
+                                        ERR(EAI_BADHINTS);
+                                }
+                        }
+                }
+        }
+
+        /*
+         * check for special cases.  (1) numeric servname is disallowed if
+         * socktype/protocol are left unspecified. (2) servname is disallowed
+         * for raw and other inet{,6} sockets.
+         */
+        if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
+#ifdef PF_INET6
+         || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
+#endif
+            ) {
+                ai0 = *pai;     /* backup *pai */
+
+                if (pai->ai_family == PF_UNSPEC) {
+#ifdef PF_INET6
+                        pai->ai_family = PF_INET6;
+#else
+                        pai->ai_family = PF_INET;
+#endif
+                }
+                error = get_portmatch(pai, servname);
+                if (error)
+                        ERR(error);
+
+                *pai = ai0;
+        }
+
+        ai0 = *pai;
+
+        /* NULL hostname, or numeric hostname */
+        for (ex = explore; ex->e_af >= 0; ex++) {
+                *pai = ai0;
+
+                /* PF_UNSPEC entries are prepared for DNS queries only */
+                if (ex->e_af == PF_UNSPEC)
+                        continue;
+
+                if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
+                        continue;
+                if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
+                        continue;
+                if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
+                        continue;
+
+                if (pai->ai_family == PF_UNSPEC)
+                        pai->ai_family = ex->e_af;
+                if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+                        pai->ai_socktype = ex->e_socktype;
+                if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+                        pai->ai_protocol = ex->e_protocol;
+
+                if (hostname == NULL)
+                        error = explore_null(pai, servname, &cur->ai_next);
+                else
+                        error = explore_numeric_scope(pai, hostname, servname,
+                            &cur->ai_next);
+
+                if (error)
+                        goto free;
+
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        /*
+         * XXX
+         * If numeric representation of AF1 can be interpreted as FQDN
+         * representation of AF2, we need to think again about the code below.
+         */
+        if (sentinel.ai_next)
+                goto good;
+
+        if (hostname == NULL)
+                ERR(EAI_NODATA);
+        if (pai->ai_flags & AI_NUMERICHOST)
+                ERR(EAI_NONAME);
+
+        /*
+         * hostname as alphabetical name.
+         * we would like to prefer AF_INET6 than AF_INET, so we'll make a
+         * outer loop by AFs.
+         */
+        for (ex = explore; ex->e_af >= 0; ex++) {
+                *pai = ai0;
+
+                /* require exact match for family field */
+                if (pai->ai_family != ex->e_af)
+                        continue;
+
+                if (!MATCH(pai->ai_socktype, ex->e_socktype,
+                                WILD_SOCKTYPE(ex))) {
+                        continue;
+                }
+                if (!MATCH(pai->ai_protocol, ex->e_protocol,
+                                WILD_PROTOCOL(ex))) {
+                        continue;
+                }
+
+                if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+                        pai->ai_socktype = ex->e_socktype;
+                if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+                        pai->ai_protocol = ex->e_protocol;
+
+                error = explore_fqdn(pai, hostname, servname,
+                        &cur->ai_next);
+
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        /* XXX */
+        if (sentinel.ai_next)
+                error = 0;
+
+        if (error)
+                goto free;
+        if (error == 0) {
+                if (sentinel.ai_next) {
+ good:
+                        *res = sentinel.ai_next;
+                        return SUCCESS;
+                } else
+                        error = EAI_FAIL;
+        }
+ free:
+ bad:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        *res = NULL;
+        return error;
+}
+
+/*
+ * FQDN hostname, DNS lookup
+ */
+
+static int
+explore_fqdn(const struct addrinfo *pai, const char *hostname,
+    const char *servname, struct addrinfo **res)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        struct addrinfo *result;
+        struct addrinfo *cur;
+        int error = 0;
+        char lookups[MAXDNSLUS];
+        int i;
+        _THREAD_PRIVATE_MUTEX(_explore_mutex);
+
+        result = NULL;
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0) {
+                return 0;
+        }
+
+        if (_res_init(0) == -1)
+                strlcpy(lookups, "f", sizeof lookups);
+        else {
+                bcopy(_resp->lookups, lookups, sizeof lookups);
+                if (lookups[0] == '\0')
+                        strlcpy(lookups, "bf", sizeof lookups);
+        }
+
+        /*
+         * The yp/dns/files getaddrinfo functions are not thread safe.
+         * Protect them with a mutex.
+         */
+        _THREAD_PRIVATE_MUTEX_LOCK(_explore_mutex);
+        for (i = 0; i < MAXDNSLUS && result == NULL && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        result = _yp_getaddrinfo(hostname, pai);
+                        break;
+#endif
+                case 'b':
+                        result = _dns_getaddrinfo(hostname, pai);
+                        break;
+                case 'f':
+                        result = _files_getaddrinfo(hostname, pai);
+                        break;
+                }
+        }
+        _THREAD_PRIVATE_MUTEX_UNLOCK(_explore_mutex);
+        if (result) {
+                for (cur = result; cur; cur = cur->ai_next) {
+                        GET_PORT(cur, servname);
+                        /* canonname should be filled already */
+                }
+                *res = result;
+                return 0;
+        } else {
+                /* translate error code */
+                switch (h_errno) {
+                case NETDB_SUCCESS:
+                        error = EAI_FAIL;       /*XXX strange */
+                        break;
+                case HOST_NOT_FOUND:
+                        error = EAI_NODATA;
+                        break;
+                case TRY_AGAIN:
+                        error = EAI_AGAIN;
+                        break;
+                case NO_RECOVERY:
+                        error = EAI_FAIL;
+                        break;
+                case NO_DATA:
+#if NO_ADDRESS != NO_DATA
+                case NO_ADDRESS:
+#endif
+                        error = EAI_NODATA;
+                        break;
+                default:                        /* unknown ones */
+                        error = EAI_FAIL;
+                        break;
+                }
+        }
+
+free:
+        if (result)
+                freeaddrinfo(result);
+        return error;
+}
+
+/*
+ * hostname == NULL.
+ * passive socket -> anyaddr (0.0.0.0 or ::)
+ * non-passive socket -> localhost (127.0.0.1 or ::1)
+ */
+static int
+explore_null(const struct addrinfo *pai, const char *servname,
+    struct addrinfo **res)
+{
+        int s;
+        const struct afd *afd;
+        struct addrinfo *cur;
+        struct addrinfo sentinel;
+        int error;
+
+        *res = NULL;
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
+
+        /*
+         * filter out AFs that are not supported by the kernel
+         * XXX errno?
+         */
+        s = socket(pai->ai_family, SOCK_DGRAM, 0);
+        if (s < 0) {
+                if (errno != EMFILE)
+                        return 0;
+        } else
+                close(s);
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0)
+                return 0;
+
+        afd = find_afd(pai->ai_family);
+        if (afd == NULL)
+                return 0;
+
+        if (pai->ai_flags & AI_PASSIVE) {
+                GET_AI(cur->ai_next, afd, afd->a_addrany);
+                /* xxx meaningless?
+                 * GET_CANONNAME(cur->ai_next, "anyaddr");
+                 */
+                GET_PORT(cur->ai_next, servname);
+        } else {
+                GET_AI(cur->ai_next, afd, afd->a_loopback);
+                /* xxx meaningless?
+                 * GET_CANONNAME(cur->ai_next, "localhost");
+                 */
+                GET_PORT(cur->ai_next, servname);
+        }
+        cur = cur->ai_next;
+
+        *res = sentinel.ai_next;
+        return 0;
+
+free:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        return error;
+}
+
+/*
+ * numeric hostname
+ */
+static int
+explore_numeric(const struct addrinfo *pai, const char *hostname,
+    const char *servname, struct addrinfo **res, const char *canonname)
+{
+        const struct afd *afd;
+        struct addrinfo *cur;
+        struct addrinfo sentinel;
+        int error;
+        char pton[PTON_MAX];
+
+        *res = NULL;
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0)
+                return 0;
+
+        afd = find_afd(pai->ai_family);
+        if (afd == NULL)
+                return 0;
+
+        switch (afd->a_af) {
+#if 0 /*X/Open spec*/
+        case AF_INET:
+                if (inet_aton(hostname, (struct in_addr *)pton) == 1) {
+                        if (pai->ai_family == afd->a_af ||
+                            pai->ai_family == PF_UNSPEC /*?*/) {
+                                GET_AI(cur->ai_next, afd, pton);
+                                GET_PORT(cur->ai_next, servname);
+                                if ((pai->ai_flags & AI_CANONNAME)) {
+                                        /*
+                                         * Set the numeric address itself as
+                                         * the canonical name, based on a
+                                         * clarification in rfc2553bis-03.
+                                         */
+                                        GET_CANONNAME(cur->ai_next, canonname);
+                                }
+                                while (cur && cur->ai_next)
+                                        cur = cur->ai_next;
+                        } else
+                                ERR(EAI_FAMILY);        /*xxx*/
+                }
+                break;
+#endif
+        default:
+                if (inet_pton(afd->a_af, hostname, pton) == 1) {
+                        if (pai->ai_family == afd->a_af ||
+                            pai->ai_family == PF_UNSPEC /*?*/) {
+                                GET_AI(cur->ai_next, afd, pton);
+                                GET_PORT(cur->ai_next, servname);
+                                if ((pai->ai_flags & AI_CANONNAME)) {
+                                        /*
+                                         * Set the numeric address itself as
+                                         * the canonical name, based on a
+                                         * clarification in rfc2553bis-03.
+                                         */
+                                        GET_CANONNAME(cur->ai_next, canonname);
+                                }
+                                while (cur && cur->ai_next)
+                                        cur = cur->ai_next;
+                        } else
+                                ERR(EAI_FAMILY);        /*xxx*/
+                }
+                break;
+        }
+
+        *res = sentinel.ai_next;
+        return 0;
+
+free:
+bad:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        return error;
+}
+
+/*
+ * numeric hostname with scope
+ */
+static int
+explore_numeric_scope(const struct addrinfo *pai, const char *hostname,
+    const char *servname, struct addrinfo **res)
+{
+#if !defined(SCOPE_DELIMITER) || !defined(INET6)
+        return explore_numeric(pai, hostname, servname, res, hostname);
+#else
+        const struct afd *afd;
+        struct addrinfo *cur;
+        int error;
+        char *cp, *hostname2 = NULL, *scope, *addr;
+        struct sockaddr_in6 *sin6;
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0)
+                return 0;
+
+        afd = find_afd(pai->ai_family);
+        if (afd == NULL)
+                return 0;
+
+        if (!afd->a_scoped)
+                return explore_numeric(pai, hostname, servname, res, hostname);
+
+        cp = strchr(hostname, SCOPE_DELIMITER);
+        if (cp == NULL)
+                return explore_numeric(pai, hostname, servname, res, hostname);
+
+        /*
+         * Handle special case of <scoped_address><delimiter><scope id>
+         */
+        hostname2 = strdup(hostname);
+        if (hostname2 == NULL)
+                return EAI_MEMORY;
+        /* terminate at the delimiter */
+        hostname2[cp - hostname] = '\0';
+        addr = hostname2;
+        scope = cp + 1;
+
+        error = explore_numeric(pai, addr, servname, res, hostname);
+        if (error == 0) {
+                u_int32_t scopeid;
+
+                for (cur = *res; cur; cur = cur->ai_next) {
+                        if (cur->ai_family != AF_INET6)
+                                continue;
+                        sin6 = (struct sockaddr_in6 *)(void *)cur->ai_addr;
+                        if (ip6_str2scopeid(scope, sin6, &scopeid) == -1) {
+                                free(hostname2);
+                                return(EAI_NODATA); /* XXX: is return OK? */
+                        }
+                        sin6->sin6_scope_id = scopeid;
+                }
+        }
+
+        free(hostname2);
+
+        return error;
+#endif
+}
+
+static int
+get_canonname(const struct addrinfo *pai, struct addrinfo *ai, const char *str)
+{
+        if ((pai->ai_flags & AI_CANONNAME) != 0) {
+                ai->ai_canonname = strdup(str);
+                if (ai->ai_canonname == NULL)
+                        return EAI_MEMORY;
+        }
+        return 0;
+}
+
+static struct addrinfo *
+get_ai(const struct addrinfo *pai, const struct afd *afd, const char *addr)
+{
+        char *p;
+        struct addrinfo *ai;
+
+        ai = (struct addrinfo *)malloc(sizeof(struct addrinfo)
+                + (afd->a_socklen));
+        if (ai == NULL)
+                return NULL;
+
+        memcpy(ai, pai, sizeof(struct addrinfo));
+        ai->ai_addr = (struct sockaddr *)(void *)(ai + 1);
+        memset(ai->ai_addr, 0, (size_t)afd->a_socklen);
+        ai->ai_addr->sa_len = afd->a_socklen;
+        ai->ai_addrlen = afd->a_socklen;
+        ai->ai_addr->sa_family = ai->ai_family = afd->a_af;
+        p = (char *)(void *)(ai->ai_addr);
+        memcpy(p + afd->a_off, addr, (size_t)afd->a_addrlen);
+        return ai;
+}
+
+static int
+get_portmatch(const struct addrinfo *ai, const char *servname)
+{
+
+        /* get_port does not touch first argument. when matchonly == 1. */
+        /* LINTED const cast */
+        return get_port((struct addrinfo *)ai, servname, 1);
+}
+
+static int
+get_port(struct addrinfo *ai, const char *servname, int matchonly)
+{
+        const char *errstr, *proto;
+        struct servent *sp;
+        int port;
+        int allownumeric;
+        /* mutex is defined in getnameinfo.c */
+        extern void *__THREAD_NAME(serv_mutex);
+
+        if (servname == NULL)
+                return 0;
+        switch (ai->ai_family) {
+        case AF_INET:
+#ifdef AF_INET6
+        case AF_INET6:
+#endif
+                break;
+        default:
+                return 0;
+        }
+
+        switch (ai->ai_socktype) {
+        case SOCK_RAW:
+                return EAI_SERVICE;
+        case SOCK_DGRAM:
+        case SOCK_STREAM:
+                allownumeric = 1;
+                break;
+        case ANY:
+                allownumeric = 0;
+                break;
+        default:
+                return EAI_SOCKTYPE;
+        }
+
+        port = (int)strtonum(servname, 0, USHRT_MAX, &errstr);
+        if (!errstr) {
+                if (!allownumeric)
+                        return EAI_SERVICE;
+                port = htons(port);
+        } else {
+                if (errno == ERANGE)
+                        return EAI_SERVICE;
+                if (ai->ai_flags & AI_NUMERICSERV)
+                        return EAI_NONAME;
+
+                switch (ai->ai_socktype) {
+                case SOCK_DGRAM:
+                        proto = "udp";
+                        break;
+                case SOCK_STREAM:
+                        proto = "tcp";
+                        break;
+                default:
+                        proto = NULL;
+                        break;
+                }
+
+                _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                sp = getservbyname(servname, proto);
+                _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+                if (sp == NULL)
+                        return EAI_SERVICE;
+                port = sp->s_port;
+        }
+
+        if (!matchonly) {
+                switch (ai->ai_family) {
+                case AF_INET:
+                        ((struct sockaddr_in *)(void *)
+                            ai->ai_addr)->sin_port = port;
+                        break;
+#ifdef INET6
+                case AF_INET6:
+                        ((struct sockaddr_in6 *)(void *)
+                            ai->ai_addr)->sin6_port = port;
+                        break;
+#endif
+                }
+        }
+
+        return 0;
+}
+
+static const struct afd *
+find_afd(int af)
+{
+        const struct afd *afd;
+
+        if (af == PF_UNSPEC)
+                return NULL;
+        for (afd = afdl; afd->a_af; afd++) {
+                if (afd->a_af == af)
+                        return afd;
+        }
+        return NULL;
+}
+
+#ifdef INET6
+/* convert a string to a scope identifier. XXX: IPv6 specific */
+static int
+ip6_str2scopeid(char *scope, struct sockaddr_in6 *sin6, u_int32_t *scopeid)
+{
+        struct in6_addr *a6 = &sin6->sin6_addr;
+        const char *errstr;
+
+        /* empty scopeid portion is invalid */
+        if (*scope == '\0')
+                return -1;
+
+        if (IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) {
+                /*
+                 * We currently assume a one-to-one mapping between links
+                 * and interfaces, so we simply use interface indices for
+                 * like-local scopes.
+                 */
+                *scopeid = if_nametoindex(scope);
+                if (*scopeid == 0)
+                        goto trynumeric;
+                return 0;
+        }
+
+        /* still unclear about literal, allow numeric only - placeholder */
+        if (IN6_IS_ADDR_SITELOCAL(a6) || IN6_IS_ADDR_MC_SITELOCAL(a6))
+                goto trynumeric;
+        if (IN6_IS_ADDR_MC_ORGLOCAL(a6))
+                goto trynumeric;
+        else
+                goto trynumeric;        /* global */
+
+        /* try to convert to a numeric id as a last resort */
+  trynumeric:
+        *scopeid = (u_int32_t)strtonum(scope, 0, UINT32_MAX, &errstr);
+        if (errstr)
+                return (-1);
+        return (0);
+}
+#endif
+
+/* code duplicate with gethnamaddr.c */
+
+static const char AskedForGot[] =
+        "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
+static FILE *hostf = NULL;
+
+static struct addrinfo *
+getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
+    const struct addrinfo *pai)
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo ai;
+        const struct afd *afd;
+        char *canonname;
+        const HEADER *hp;
+        const u_char *cp;
+        int n;
+        const u_char *eom;
+        char *bp, *ep;
+        int type, class, ancount, qdcount;
+        int haveanswer, had_error;
+        char tbuf[MAXDNAME];
+        int (*name_ok)(const char *);
+        char hostbuf[8*1024];
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        canonname = NULL;
+        eom = answer->buf + anslen;
+        switch (qtype) {
+        case T_A:
+        case T_AAAA:
+        case T_ANY:     /*use T_ANY only for T_A/T_AAAA lookup*/
+                name_ok = res_hnok;
+                break;
+        default:
+                return (NULL);  /* XXX should be abort() -- but that is illegal */
+        }
+        /*
+         * find first satisfactory answer
+         */
+        hp = &answer->hdr;
+        ancount = ntohs(hp->ancount);
+        qdcount = ntohs(hp->qdcount);
+        bp = hostbuf;
+        ep = hostbuf + sizeof hostbuf;
+        cp = answer->buf + HFIXEDSZ;
+        if (qdcount != 1) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+        if ((n < 0) || !(*name_ok)(bp)) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        cp += n + QFIXEDSZ;
+        if (qtype == T_A || qtype == T_AAAA || qtype == T_ANY) {
+                /* res_send() has already verified that the query name is the
+                 * same as the one we sent; this just gets the expanded name
+                 * (i.e., with the succeeding search-domain tacked on).
+                 */
+                n = strlen(bp) + 1;             /* for the \0 */
+                if (n >= MAXHOSTNAMELEN) {
+                        h_errno = NO_RECOVERY;
+                        return (NULL);
+                }
+                canonname = bp;
+                bp += n;
+                /* The qname can be abbreviated, but h_name is now absolute. */
+                qname = canonname;
+        }
+        haveanswer = 0;
+        had_error = 0;
+        while (ancount-- > 0 && cp < eom && !had_error) {
+                n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+                if ((n < 0) || !(*name_ok)(bp)) {
+                        had_error++;
+                        continue;
+                }
+                cp += n;                        /* name */
+                type = _getshort(cp);
+                cp += INT16SZ;                  /* type */
+                class = _getshort(cp);
+                cp += INT16SZ + INT32SZ;        /* class, TTL */
+                n = _getshort(cp);
+                cp += INT16SZ;                  /* len */
+                if (class != C_IN) {
+                        /* XXX - debug? syslog? */
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                if ((qtype == T_A || qtype == T_AAAA || qtype == T_ANY) &&
+                    type == T_CNAME) {
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+                        if ((n < 0) || !(*name_ok)(tbuf)) {
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Get canonical name. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp || n >= MAXHOSTNAMELEN) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        canonname = bp;
+                        bp += n;
+                        continue;
+                }
+                if (qtype == T_ANY) {
+                        if (!(type == T_A || type == T_AAAA)) {
+                                cp += n;
+                                continue;
+                        }
+                } else if (type != qtype) {
+                        if (type != T_KEY && type != T_SIG)
+                                syslog(LOG_NOTICE|LOG_AUTH,
+               "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
+                                       qname, p_class(C_IN), p_type(qtype),
+                                       p_type(type));
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                switch (type) {
+                case T_A:
+                case T_AAAA:
+                        if (strcasecmp(canonname, bp) != 0) {
+                                syslog(LOG_NOTICE|LOG_AUTH,
+                                       AskedForGot, canonname, bp);
+                                cp += n;
+                                continue;       /* XXX - had_error++ ? */
+                        }
+                        if (type == T_A && n != INADDRSZ) {
+                                cp += n;
+                                continue;
+                        }
+                        if (type == T_AAAA && n != IN6ADDRSZ) {
+                                cp += n;
+                                continue;
+                        }
+                        if (type == T_AAAA) {
+                                struct in6_addr in6;
+                                memcpy(&in6, cp, IN6ADDRSZ);
+                                if (IN6_IS_ADDR_V4MAPPED(&in6)) {
+                                        cp += n;
+                                        continue;
+                                }
+                        }
+                        if (!haveanswer) {
+                                int nn;
+
+                                canonname = bp;
+                                nn = strlen(bp) + 1;    /* for the \0 */
+                                bp += nn;
+                        }
+
+                        /* don't overwrite pai */
+                        ai = *pai;
+                        ai.ai_family = (type == T_A) ? AF_INET : AF_INET6;
+                        afd = find_afd(ai.ai_family);
+                        if (afd == NULL) {
+                                cp += n;
+                                continue;
+                        }
+                        cur->ai_next = get_ai(&ai, afd, (const char *)cp);
+                        if (cur->ai_next == NULL)
+                                had_error++;
+                        while (cur && cur->ai_next)
+                                cur = cur->ai_next;
+                        cp += n;
+                        break;
+                default:
+                        abort();        /* XXX abort illegal in library */
+                }
+                if (!had_error)
+                        haveanswer++;
+        }
+        if (haveanswer) {
+                if (!canonname)
+                        (void)get_canonname(pai, sentinel.ai_next, qname);
+                else
+                        (void)get_canonname(pai, sentinel.ai_next, canonname);
+                h_errno = NETDB_SUCCESS;
+                return sentinel.ai_next;
+        }
+
+        h_errno = NO_RECOVERY;
+        return NULL;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_dns_getaddrinfo(const char *name, const struct addrinfo *pai)
+{
+        struct addrinfo *ai;
+        querybuf *buf, *buf2;
+        struct addrinfo sentinel, *cur;
+        struct res_target q, q2;
+
+        memset(&q, 0, sizeof(q));
+        memset(&q2, 0, sizeof(q2));
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        buf = malloc(sizeof(*buf));
+        if (buf == NULL) {
+                h_errno = NETDB_INTERNAL;
+                return NULL;
+        }
+        buf2 = malloc(sizeof(*buf2));
+        if (buf2 == NULL) {
+                free(buf);
+                h_errno = NETDB_INTERNAL;
+                return NULL;
+        }
+
+        switch (pai->ai_family) {
+        case AF_UNSPEC:
+                /* prefer IPv6 */
+                q.qclass = C_IN;
+                q.qtype = T_AAAA;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                q.next = &q2;
+                q2.qclass = C_IN;
+                q2.qtype = T_A;
+                q2.answer = buf2->buf;
+                q2.anslen = sizeof(buf2->buf);
+                break;
+        case AF_INET:
+                q.qclass = C_IN;
+                q.qtype = T_A;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                break;
+        case AF_INET6:
+                q.qclass = C_IN;
+                q.qtype = T_AAAA;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                break;
+        default:
+                free(buf);
+                free(buf2);
+                return NULL;
+        }
+        if (res_searchN(name, &q) < 0) {
+                free(buf);
+                free(buf2);
+                return NULL;
+        }
+        ai = getanswer(buf, q.n, q.name, q.qtype, pai);
+        if (ai) {
+                cur->ai_next = ai;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+        if (q.next) {
+                ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai);
+                if (ai)
+                        cur->ai_next = ai;
+        }
+        free(buf);
+        free(buf2);
+        return sentinel.ai_next;
+}
+
+static FILE *hostf;
+
+static void
+_sethtent(void)
+{
+        if (!hostf)
+                hostf = fopen(_PATH_HOSTS, "r" );
+        else
+                rewind(hostf);
+}
+
+static void
+_endhtent(void)
+{
+        if (hostf) {
+                (void) fclose(hostf);
+                hostf = NULL;
+        }
+}
+
+static struct addrinfo *
+_gethtent(const char *name, const struct addrinfo *pai)
+{
+        char *p;
+        char *cp, *tname, *cname;
+        struct addrinfo hints, *res0, *res;
+        int error;
+        const char *addr;
+        char hostbuf[8*1024];
+
+        if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" )))
+                return (NULL);
+ again:
+        if (!(p = fgets(hostbuf, sizeof hostbuf, hostf)))
+                return (NULL);
+        if (*p == '#')
+                goto again;
+        if (!(cp = strpbrk(p, "#\n")))
+                goto again;
+        *cp = '\0';
+        if (!(cp = strpbrk(p, " \t")))
+                goto again;
+        *cp++ = '\0';
+        addr = p;
+        /* if this is not something we're looking for, skip it. */
+        cname = NULL;
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (!cname)
+                        cname = cp;
+                tname = cp;
+                if ((cp = strpbrk(cp, " \t")) != NULL)
+                        *cp++ = '\0';
+                if (strcasecmp(name, tname) == 0)
+                        goto found;
+        }
+        goto again;
+
+found:
+        hints = *pai;
+        hints.ai_flags = AI_NUMERICHOST;
+        error = getaddrinfo(addr, NULL, &hints, &res0);
+        if (error)
+                goto again;
+        for (res = res0; res; res = res->ai_next) {
+                /* cover it up */
+                res->ai_flags = pai->ai_flags;
+
+                if (pai->ai_flags & AI_CANONNAME) {
+                        if (get_canonname(pai, res, cname) != 0) {
+                                freeaddrinfo(res0);
+                                goto again;
+                        }
+                }
+        }
+        return res0;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_files_getaddrinfo(const char *name, const struct addrinfo *pai)
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo *p;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        _sethtent();
+        while ((p = _gethtent(name, pai)) != NULL) {
+                cur->ai_next = p;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+        _endhtent();
+
+        return sentinel.ai_next;
+}
+
+#ifdef YP
+static char *__ypdomain;
+
+/*ARGSUSED*/
+static struct addrinfo *
+_yphostent(char *line, const struct addrinfo *pai)
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo hints, *res, *res0;
+        int error;
+        char *p = line;
+        const char *addr, *canonname;
+        char *nextline;
+        char *cp;
+
+        addr = canonname = NULL;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+nextline:
+        /* terminate line */
+        cp = strchr(p, '\n');
+        if (cp) {
+                *cp++ = '\0';
+                nextline = cp;
+        } else
+                nextline = NULL;
+
+        cp = strpbrk(p, " \t");
+        if (cp == NULL) {
+                if (canonname == NULL)
+                        return (NULL);
+                else
+                        goto done;
+        }
+        *cp++ = '\0';
+
+        addr = p;
+
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (!canonname)
+                        canonname = cp;
+                if ((cp = strpbrk(cp, " \t")) != NULL)
+                        *cp++ = '\0';
+        }
+
+        hints = *pai;
+        hints.ai_flags = AI_NUMERICHOST;
+        error = getaddrinfo(addr, NULL, &hints, &res0);
+        if (error == 0) {
+                for (res = res0; res; res = res->ai_next) {
+                        /* cover it up */
+                        res->ai_flags = pai->ai_flags;
+
+                        if (pai->ai_flags & AI_CANONNAME)
+                                (void)get_canonname(pai, res, canonname);
+                }
+        } else
+                res0 = NULL;
+        if (res0) {
+                cur->ai_next = res0;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        if (nextline) {
+                p = nextline;
+                goto nextline;
+        }
+
+done:
+        return sentinel.ai_next;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_yp_getaddrinfo(const char *name, const struct addrinfo *pai)
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo *ai = NULL;
+        static char *__ypcurrent;
+        int __ypcurrentlen, r;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        if (!__ypdomain) {
+                if (_yp_check(&__ypdomain) == 0)
+                        return NULL;
+        }
+        if (__ypcurrent)
+                free(__ypcurrent);
+        __ypcurrent = NULL;
+
+        /* hosts.byname is only for IPv4 (Solaris8) */
+        if (pai->ai_family == PF_UNSPEC || pai->ai_family == PF_INET) {
+                r = yp_match(__ypdomain, "hosts.byname", name,
+                        (int)strlen(name), &__ypcurrent, &__ypcurrentlen);
+                if (r == 0) {
+                        struct addrinfo ai4;
+
+                        ai4 = *pai;
+                        ai4.ai_family = AF_INET;
+                        ai = _yphostent(__ypcurrent, &ai4);
+                        if (ai) {
+                                cur->ai_next = ai;
+                                while (cur && cur->ai_next)
+                                        cur = cur->ai_next;
+                        }
+                }
+        }
+
+        /* ipnodes.byname can hold both IPv4/v6 */
+        r = yp_match(__ypdomain, "ipnodes.byname", name,
+                (int)strlen(name), &__ypcurrent, &__ypcurrentlen);
+        if (r == 0) {
+                ai = _yphostent(__ypcurrent, pai);
+                if (ai) {
+                        cur->ai_next = ai;
+                        while (cur && cur->ai_next)
+                                cur = cur->ai_next;
+                }
+        }
+
+        return sentinel.ai_next;
+}
+#endif
+
+
+/* resolver logic */
+
+extern const char *__hostalias(const char *);
+extern int h_errno;
+extern int res_opt(int, u_char *, int, int);
+
+/*
+ * Formulate a normal query, send, and await answer.
+ * Returned answer is placed in supplied buffer "answer".
+ * Perform preliminary check of answer, returning success only
+ * if no error is indicated and the answer count is nonzero.
+ * Return the size of the response on success, -1 on error.
+ * Error number is left in h_errno.
+ *
+ * Caller must parse answer and determine whether it answers the question.
+ */
+static int
+res_queryN(const char *name, struct res_target *target)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        u_char *buf;
+        HEADER *hp;
+        int n;
+        struct res_target *t;
+        int rcode;
+        int ancount;
+
+        buf = malloc(MAXPACKET);
+        if (buf == NULL) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+
+        rcode = NOERROR;
+        ancount = 0;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                free(buf);
+                return (-1);
+        }
+
+        for (t = target; t; t = t->next) {
+                int class, type;
+                u_char *answer;
+                int anslen;
+
+                hp = (HEADER *)(void *)t->answer;
+                hp->rcode = NOERROR;    /* default */
+
+                /* make it easier... */
+                class = t->qclass;
+                type = t->qtype;
+                answer = t->answer;
+                anslen = t->anslen;
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG)
+                        printf(";; res_query(%s, %d, %d)\n", name, class, type);
+#endif
+
+                n = res_mkquery(QUERY, name, class, type, NULL, 0, NULL,
+                    buf, MAXPACKET);
+                if (n > 0 && (_resp->options & RES_USE_EDNS0) != 0)
+                        n = res_opt(n, buf, MAXPACKET, anslen);
+                if (n <= 0) {
+#ifdef DEBUG
+                        if (_resp->options & RES_DEBUG)
+                                printf(";; res_query: mkquery failed\n");
+#endif
+                        h_errno = NO_RECOVERY;
+                        free(buf);
+                        return (n);
+                }
+                n = res_send(buf, n, answer, anslen);
+#if 0
+                if (n < 0) {
+#ifdef DEBUG
+                        if (_resp->options & RES_DEBUG)
+                                printf(";; res_query: send error\n");
+#endif
+                        h_errno = TRY_AGAIN;
+                        free(buf);
+                        return (n);
+                }
+#endif
+
+                if (n < 0 || hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
+                        rcode = hp->rcode;      /* record most recent error */
+#ifdef DEBUG
+                        if (_resp->options & RES_DEBUG)
+                                printf(";; rcode = %u, ancount=%u\n", hp->rcode,
+                                    ntohs(hp->ancount));
+#endif
+                        continue;
+                }
+
+                ancount += ntohs(hp->ancount);
+
+                t->n = n;
+        }
+
+        if (ancount == 0) {
+                switch (rcode) {
+                case NXDOMAIN:
+                        h_errno = HOST_NOT_FOUND;
+                        break;
+                case SERVFAIL:
+                        h_errno = TRY_AGAIN;
+                        break;
+                case NOERROR:
+                        h_errno = NO_DATA;
+                        break;
+                case FORMERR:
+                case NOTIMP:
+                case REFUSED:
+                default:
+                        h_errno = NO_RECOVERY;
+                        break;
+                }
+                free(buf);
+                return (-1);
+        }
+        free(buf);
+        return (ancount);
+}
+
+/*
+ * Formulate a normal query, send, and retrieve answer in supplied buffer.
+ * Return the size of the response on success, -1 on error.
+ * If enabled, implement search rules until answer or unrecoverable failure
+ * is detected.  Error code, if any, is left in h_errno.
+ */
+static int
+res_searchN(const char *name, struct res_target *target)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        const char *cp, * const *domain;
+        HEADER *hp = (HEADER *)(void *)target->answer;  /*XXX*/
+        u_int dots;
+        int trailing_dot, ret, saved_herrno;
+        int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+
+        errno = 0;
+        h_errno = HOST_NOT_FOUND;       /* default, if we never query */
+        dots = 0;
+        for (cp = name; *cp; cp++)
+                dots += (*cp == '.');
+        trailing_dot = 0;
+        if (cp > name && *--cp == '.')
+                trailing_dot++;
+
+        /*
+         * if there aren't any dots, it could be a user-level alias
+         */
+        if (!dots && (cp = __hostalias(name)) != NULL)
+                return (res_queryN(cp, target));
+
+        /*
+         * If there are dots in the name already, let's just give it a try
+         * 'as is'.  The threshold can be set with the "ndots" option.
+         */
+        saved_herrno = -1;
+        if (dots >= _resp->ndots) {
+                ret = res_querydomainN(name, NULL, target);
+                if (ret > 0)
+                        return (ret);
+                saved_herrno = h_errno;
+                tried_as_is++;
+        }
+
+        /*
+         * We do at least one level of search if
+         *      - there is no dot and RES_DEFNAME is set, or
+         *      - there is at least one dot, there is no trailing dot,
+         *        and RES_DNSRCH is set.
+         */
+        if ((!dots && (_resp->options & RES_DEFNAMES)) ||
+            (dots && !trailing_dot && (_resp->options & RES_DNSRCH))) {
+                int done = 0;
+
+                for (domain = (const char * const *)_resp->dnsrch;
+                   *domain && !done;
+                   domain++) {
+
+                        ret = res_querydomainN(name, *domain, target);
+                        if (ret > 0)
+                                return (ret);
+
+                        /*
+                         * If no server present, give up.
+                         * If name isn't found in this domain,
+                         * keep trying higher domains in the search list
+                         * (if that's enabled).
+                         * On a NO_DATA error, keep trying, otherwise
+                         * a wildcard entry of another type could keep us
+                         * from finding this entry higher in the domain.
+                         * If we get some other error (negative answer or
+                         * server failure), then stop searching up,
+                         * but try the input name below in case it's
+                         * fully-qualified.
+                         */
+                        if (errno == ECONNREFUSED) {
+                                h_errno = TRY_AGAIN;
+                                return (-1);
+                        }
+
+                        switch (h_errno) {
+                        case NO_DATA:
+                                got_nodata++;
+                                /* FALLTHROUGH */
+                        case HOST_NOT_FOUND:
+                                /* keep trying */
+                                break;
+                        case TRY_AGAIN:
+                                if (hp->rcode == SERVFAIL) {
+                                        /* try next search element, if any */
+                                        got_servfail++;
+                                        break;
+                                }
+                                /* FALLTHROUGH */
+                        default:
+                                /* anything else implies that we're done */
+                                done++;
+                        }
+                        /*
+                         * if we got here for some reason other than DNSRCH,
+                         * we only wanted one iteration of the loop, so stop.
+                         */
+                        if (!(_resp->options & RES_DNSRCH))
+                                done++;
+                }
+        }
+
+        /*
+         * if we have not already tried the name "as is", do that now.
+         * note that we do this regardless of how many dots were in the
+         * name or whether it ends with a dot.
+         */
+        if (!tried_as_is) {
+                ret = res_querydomainN(name, NULL, target);
+                if (ret > 0)
+                        return (ret);
+        }
+
+        /*
+         * if we got here, we didn't satisfy the search.
+         * if we did an initial full query, return that query's h_errno
+         * (note that we wouldn't be here if that query had succeeded).
+         * else if we ever got a nodata, send that back as the reason.
+         * else send back meaningless h_errno, that being the one from
+         * the last DNSRCH we did.
+         */
+        if (saved_herrno != -1)
+                h_errno = saved_herrno;
+        else if (got_nodata)
+                h_errno = NO_DATA;
+        else if (got_servfail)
+                h_errno = TRY_AGAIN;
+        return (-1);
+}
+
+/*
+ * Perform a call on res_query on the concatenation of name and domain,
+ * removing a trailing dot from name if domain is NULL.
+ */
+static int
+res_querydomainN(const char *name, const char *domain,
+    struct res_target *target)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char nbuf[MAXDNAME];
+        const char *longname = nbuf;
+        size_t len;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+#ifdef DEBUG
+        if (_resp->options & RES_DEBUG)
+                printf(";; res_querydomain(%s, %s)\n",
+                        name, domain?domain:"<Nil>");
+#endif
+        if (domain == NULL) {
+                /*
+                 * Check for trailing '.';
+                 * copy without '.' if present.
+                 */
+                len = strlcpy(nbuf, name, sizeof(nbuf));
+                if (len >= sizeof(nbuf)) {
+                        h_errno = NO_RECOVERY;
+                        return (-1);
+                }
+                if (len > 0 && nbuf[len - 1] == '.')
+                        nbuf[len - 1] = '\0';
+        } else {
+                int i;
+
+                i = snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain);
+                if (i < 0 || i >= sizeof(nbuf)) {
+                        h_errno = NO_RECOVERY;
+                        return (-1);
+                }
+        }
+        return (res_queryN(longname, target));
+}
diff --git a/src/lib/libc/net/gethostbyname.3 b/src/lib/libc/net/gethostbyname.3
new file mode 100644
index 0000000000..f3f3ea580f
--- /dev/null
+++ b/src/lib/libc/net/gethostbyname.3
@@ -0,0 +1,297 @@
+.\"     $OpenBSD: gethostbyname.3,v 1.24 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1983, 1987, 1991, 1993
+.\"     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.
+.\"
+.Dd March 13, 1997
+.Dt GETHOSTBYNAME 3
+.Os
+.Sh NAME
+.Nm gethostbyname ,
+.Nm gethostbyname2 ,
+.Nm gethostbyaddr ,
+.Nm gethostent ,
+.Nm sethostent ,
+.Nm endhostent ,
+.Nm hstrerror ,
+.Nm herror
+.Nd get network host entry
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Vt extern int h_errno ;
+.Ft struct hostent *
+.Fn gethostbyname "const char *name"
+.Ft struct hostent *
+.Fn gethostbyname2 "const char *name" "int af"
+.Ft struct hostent *
+.Fn gethostbyaddr "const void *addr" "socklen_t len" "int af"
+.Ft struct hostent *
+.Fn gethostent void
+.Ft void
+.Fn sethostent "int stayopen"
+.Ft void
+.Fn endhostent void
+.Ft void
+.Fn herror "const char *string"
+.Ft const char *
+.Fn hstrerror "int err"
+.Sh DESCRIPTION
+The
+.Fn gethostbyname ,
+.Fn gethostbyname2 ,
+and
+.Fn gethostbyaddr
+functions each return a pointer to an object with the following structure
+describing an Internet host referenced by name or by address, respectively.
+This structure contains either information obtained from the name server (i.e.,
+.Xr resolver 3
+and
+.Xr named 8 ) ,
+broken-out fields from a line in
+.Pa /etc/hosts ,
+or database entries supplied by the
+.Xr yp 8
+system.
+.Xr resolv.conf 5
+describes how the particular database is chosen.
+.Bd -literal -offset indent
+struct  hostent {
+        char    *h_name;        /* official name of host */
+        char    **h_aliases;    /* alias list */
+        int     h_addrtype;     /* host address type */
+        int     h_length;       /* length of address */
+        char    **h_addr_list;  /* list of returned addresses */
+};
+#define h_addr  h_addr_list[0]  /* address, for backward compat */
+.Ed
+.Pp
+The members of this structure are:
+.Bl -tag -width h_addr_list
+.It Fa h_name
+Official name of the host.
+.It Fa h_aliases
+A null-terminated array of alternate names for the host.
+.It Fa h_addrtype
+The type of address being returned.
+.It Fa h_length
+The length, in bytes, of the address.
+.It Fa h_addr_list
+A null-terminated array of network addresses for the host.
+Host addresses are returned in network byte order.
+.It Fa h_addr
+The first address in
+.Fa h_addr_list ;
+this is for backward compatibility.
+.El
+.Pp
+The function
+.Fn gethostbyname
+will search for the named host in the current domain and its parents
+using the search lookup semantics detailed in
+.Xr resolv.conf 5
+and
+.Xr hostname 7 .
+.Pp
+.Fn gethostbyname2
+is an advanced form of
+.Fn gethostbyname
+which allows lookups in address families other than
+.Dv AF_INET .
+Currently, the only supported address family besides
+.Dv AF_INET
+is
+.Dv AF_INET6 .
+.Pp
+The
+.Fn gethostbyaddr
+function will search for the specified address of length
+.Fa len
+in the address family
+.Fa af .
+The only address family currently supported is
+.Dv AF_INET .
+.Pp
+The
+.Fn sethostent
+function may be used to request the use of a connected
+.Tn TCP
+socket for queries.
+If the
+.Fa stayopen
+flag is non-zero,
+this sets the option to send all queries to the name server using
+.Tn TCP
+and to retain the connection after each call to
+.Fn gethostbyname
+or
+.Fn gethostbyaddr .
+Otherwise, queries are performed using
+.Tn UDP
+datagrams.
+.Pp
+The
+.Fn endhostent
+function closes the
+.Tn TCP
+connection.
+.Pp
+The
+.Fn herror
+function prints an error message describing the failure.
+If its argument
+.Fa string
+is non-null,
+it is prepended to the message string and separated from it by a colon
+.Pq Ql \&:
+and a space.
+The error message is printed with a trailing newline.
+The contents of the error message is the same as that returned by
+.Fn hstrerror
+with argument
+.Fa h_errno .
+.Sh ENVIRONMENT
+.Bl -tag -width HOSTALIASES
+.It HOSTALIASES
+A file containing local host aliases.
+See
+.Xr hostname 7
+for more information.
+.It RES_OPTIONS
+A list of options to override the resolver's internal defaults.
+See
+.Xr resolver 3
+for more information.
+.El
+.Sh FILES
+.Bl -tag -width /etc/resolv.conf -compact
+.It Pa /etc/hosts
+.It Pa /etc/resolv.conf
+.El
+.Sh DIAGNOSTICS
+Error return status from
+.Fn gethostbyname ,
+.Fn gethostbyname2 ,
+and
+.Fn gethostbyaddr
+is indicated by return of a null pointer.
+The external integer
+.Va h_errno
+may then be checked to see whether this is a temporary failure
+or an invalid or unknown host.
+.Pp
+The variable
+.Va h_errno
+can have the following values:
+.Bl -tag -width HOST_NOT_FOUND
+.It Dv HOST_NOT_FOUND
+No such host is known.
+.It Dv TRY_AGAIN
+This is usually a temporary error
+and means that the local server did not receive
+a response from an authoritative server.
+A retry at some later time may succeed.
+.It Dv NO_RECOVERY
+Some unexpected server failure was encountered.
+This is a non-recoverable error.
+.It Dv NO_DATA
+The requested name is valid but does not have an IP address;
+this is not a temporary error.
+This means that the name is known to the name server but there is no address
+associated with this name.
+Another type of request to the name server using this domain name
+will result in an answer;
+for example, a mail-forwarder may be registered for this domain.
+.It Dv NETDB_INTERNAL
+An internal error occurred.
+This may occur when an address family other than
+.Dv AF_INET
+or
+.Dv AF_INET6
+is specified or when a resource is unable to be allocated.
+.It Dv NETDB_SUCCESS
+The function completed successfully.
+.El
+.Sh SEE ALSO
+.Xr getaddrinfo 3 ,
+.Xr getnameinfo 3 ,
+.Xr resolver 3 ,
+.Xr hosts 5 ,
+.Xr resolv.conf 5 ,
+.Xr hostname 7 ,
+.Xr named 8
+.Sh HISTORY
+The
+.Fn herror
+function appeared in
+.Bx 4.3 .
+The
+.Fn endhostent ,
+.Fn gethostbyaddr ,
+.Fn gethostbyname ,
+.Fn gethostent ,
+and
+.Fn sethostent
+functions appeared in
+.Bx 4.2 .
+.Sh CAVEATS
+If the search routines in
+.Xr resolv.conf 5
+decide to read the
+.Pa /etc/hosts
+file,
+.Fn gethostent
+and other functions will
+read the next line of the file,
+re-opening the file if necessary.
+.Pp
+The
+.Fn sethostent
+function opens and/or rewinds the file
+.Pa /etc/hosts .
+If the
+.Fa stayopen
+argument is non-zero, the file will not be closed after each call to
+.Fn gethostbyname ,
+.Fn gethostbyname2 ,
+or
+.Fn gethostbyaddr .
+.Pp
+The
+.Fn endhostent
+function closes the file.
+.Sh BUGS
+These functions use static data storage;
+if the data is needed for future use, it should be
+copied before any subsequent calls overwrite it.
+.Pp
+Only the Internet
+address formats are currently understood.
+.Pp
+YP does not support any address families other than
+.Dv AF_INET
+and uses
+the traditional database format.
diff --git a/src/lib/libc/net/gethostnamadr.c b/src/lib/libc/net/gethostnamadr.c
new file mode 100644
index 0000000000..d1c7d80df6
--- /dev/null
+++ b/src/lib/libc/net/gethostnamadr.c
@@ -0,0 +1,1126 @@
+/*      $OpenBSD: gethostnamadr.c,v 1.68 2005/08/06 20:30:03 espie Exp $ */
+/*-
+ * Copyright (c) 1985, 1988, 1993
+ *      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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>
+#include <syslog.h>
+#include <stdlib.h>
+#ifdef YP
+#include <rpc/rpc.h>
+#include <rpcsvc/yp.h>
+#include <rpcsvc/ypclnt.h>
+#include "ypinternal.h"
+#endif
+#include "thread_private.h"
+
+#define MULTI_PTRS_ARE_ALIASES 1        /* XXX - experimental */
+
+#define MAXALIASES      35
+#define MAXADDRS        35
+
+static char *h_addr_ptrs[MAXADDRS + 1];
+
+#ifdef YP
+static char *__ypdomain;
+#endif
+
+static struct hostent host;
+static char *host_aliases[MAXALIASES];
+static char hostbuf[BUFSIZ+1];
+static union {
+        struct in_addr _host_in_addr;
+        u_char _host_addr[16];          /* IPv4 or IPv6 */
+} _host_addr_u;
+#define host_addr _host_addr_u._host_addr
+static FILE *hostf = NULL;
+static int stayopen = 0;
+
+static void map_v4v6_address(const char *src, char *dst);
+static void map_v4v6_hostent(struct hostent *hp, char **bp, char *);
+
+#ifdef RESOLVSORT
+static void addrsort(char **, int);
+#endif
+
+int _hokchar(const char *);
+
+static const char AskedForGot[] =
+                          "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
+
+#define MAXPACKET       (64*1024)
+
+typedef union {
+        HEADER hdr;
+        u_char buf[MAXPACKET];
+} querybuf;
+
+typedef union {
+        int32_t al;
+        char ac;
+} align;
+
+static struct hostent *getanswer(const querybuf *, int, const char *, int);
+
+extern int h_errno;
+
+int
+_hokchar(const char *p)
+{
+        char c;
+
+        /*
+         * Many people do not obey RFC 822 and 1035.  The valid
+         * characters are a-z, A-Z, 0-9, '-' and . But the others
+         * tested for below can happen, and we must be more permissive
+         * than the resolver until those idiots clean up their act.
+         * We let '/' through, but not '..'
+         */
+        while ((c = *p++)) {
+                if (('a' <= c && c <= 'z') ||
+                    ('A' <= c && c <= 'Z') ||
+                    ('0' <= c && c <= '9'))
+                        continue;
+                if (strchr("-_/", c))
+                        continue;
+                if (c == '.' && *p != '.')
+                        continue;
+                return 0;
+        }
+        return 1;
+}
+
+static struct hostent *
+getanswer(const querybuf *answer, int anslen, const char *qname, int qtype)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        const HEADER *hp;
+        const u_char *cp, *eom;
+        char tbuf[MAXDNAME];
+        char *bp, **ap, **hap, *ep;
+        int type, class, ancount, qdcount, n;
+        int haveanswer, had_error, toobig = 0;
+        const char *tname;
+        int (*name_ok)(const char *);
+
+        tname = qname;
+        host.h_name = NULL;
+        eom = answer->buf + anslen;
+        switch (qtype) {
+        case T_A:
+        case T_AAAA:
+#ifdef USE_RESOLV_NAME_OK
+                name_ok = res_hnok;
+                break;
+#endif
+        case T_PTR:
+#ifdef USE_RESOLV_NAME_OK
+                name_ok = res_dnok;
+#else
+                name_ok = _hokchar;
+#endif
+                break;
+        default:
+                return (NULL);
+        }
+        /*
+         * find first satisfactory answer
+         */
+        hp = &answer->hdr;
+        ancount = ntohs(hp->ancount);
+        qdcount = ntohs(hp->qdcount);
+        bp = hostbuf;
+        ep = hostbuf + sizeof hostbuf;
+        cp = answer->buf + HFIXEDSZ;
+        if (qdcount != 1) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+        if ((n < 0) || !(*name_ok)(bp)) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        cp += n + QFIXEDSZ;
+        if (qtype == T_A || qtype == T_AAAA) {
+                /* res_send() has already verified that the query name is the
+                 * same as the one we sent; this just gets the expanded name
+                 * (i.e., with the succeeding search-domain tacked on).
+                 */
+                n = strlen(bp) + 1;             /* for the \0 */
+                host.h_name = bp;
+                bp += n;
+                /* The qname can be abbreviated, but h_name is now absolute. */
+                qname = host.h_name;
+        }
+        ap = host_aliases;
+        *ap = NULL;
+        host.h_aliases = host_aliases;
+        hap = h_addr_ptrs;
+        *hap = NULL;
+        host.h_addr_list = h_addr_ptrs;
+        haveanswer = 0;
+        had_error = 0;
+        while (ancount-- > 0 && cp < eom && !had_error) {
+                n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+                if ((n < 0) || !(*name_ok)(bp)) {
+                        had_error++;
+                        continue;
+                }
+                cp += n;                        /* name */
+                if (cp >= eom)
+                        break;
+                type = _getshort(cp);
+                cp += INT16SZ;                  /* type */
+                if (cp >= eom)
+                        break;
+                class = _getshort(cp);
+                cp += INT16SZ + INT32SZ;        /* class, TTL */
+                if (cp >= eom)
+                        break;
+                n = _getshort(cp);
+                cp += INT16SZ;                  /* len */
+                if (cp >= eom)
+                        break;
+                if (type == T_SIG) {
+                        /* XXX - ignore signatures as we don't use them yet */
+                        cp += n;
+                        continue;
+                }
+                if (class != C_IN) {
+                        /* XXX - debug? syslog? */
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
+                        if (ap >= &host_aliases[MAXALIASES-1])
+                                continue;
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+                        if ((n < 0) || !(*name_ok)(tbuf)) {
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Store alias. */
+                        *ap++ = bp;
+                        n = strlen(bp) + 1;     /* for the \0 */
+                        bp += n;
+                        /* Get canonical name. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        host.h_name = bp;
+                        bp += n;
+                        continue;
+                }
+                if (qtype == T_PTR && type == T_CNAME) {
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+#ifdef USE_RESOLV_NAME_OK
+                        if ((n < 0) || !res_hnok(tbuf)) {
+#else
+                        if ((n < 0) || !_hokchar(tbuf)) {
+#endif
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Get canonical name. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        tname = bp;
+                        bp += n;
+                        continue;
+                }
+                if (type != qtype) {
+                        syslog(LOG_NOTICE|LOG_AUTH,
+               "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
+                               qname, p_class(C_IN), p_type(qtype),
+                               p_type(type));
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                switch (type) {
+                case T_PTR:
+                        if (strcasecmp(tname, bp) != 0) {
+                                syslog(LOG_NOTICE|LOG_AUTH,
+                                       AskedForGot, qname, bp);
+                                cp += n;
+                                continue;       /* XXX - had_error++ ? */
+                        }
+                        n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+#ifdef USE_RESOLV_NAME_OK
+                        if ((n < 0) || !res_hnok(bp)) {
+#else
+                        if ((n < 0) || !_hokchar(bp)) {
+#endif
+                                had_error++;
+                                break;
+                        }
+#if MULTI_PTRS_ARE_ALIASES
+                        cp += n;
+                        if (!haveanswer)
+                                host.h_name = bp;
+                        else if (ap < &host_aliases[MAXALIASES-1])
+                                *ap++ = bp;
+                        else
+                                n = -1;
+                        if (n != -1) {
+                                n = strlen(bp) + 1;     /* for the \0 */
+                                bp += n;
+                        }
+                        break;
+#else
+                        host.h_name = bp;
+                        if (_resp->options & RES_USE_INET6) {
+                                n = strlen(bp) + 1;     /* for the \0 */
+                                bp += n;
+                                map_v4v6_hostent(&host, &bp, ep);
+                        }
+                        h_errno = NETDB_SUCCESS;
+                        return (&host);
+#endif
+                case T_A:
+                case T_AAAA:
+                        if (strcasecmp(host.h_name, bp) != 0) {
+                                syslog(LOG_NOTICE|LOG_AUTH,
+                                       AskedForGot, host.h_name, bp);
+                                cp += n;
+                                continue;       /* XXX - had_error++ ? */
+                        }
+                        if (n != host.h_length) {
+                                cp += n;
+                                continue;
+                        }
+                        if (type == T_AAAA) {
+                                struct in6_addr in6;
+                                memcpy(&in6, cp, IN6ADDRSZ);
+                                if (IN6_IS_ADDR_V4MAPPED(&in6)) {
+                                        cp += n;
+                                        continue;
+                                }
+                        }
+                        if (!haveanswer) {
+                                int nn;
+
+                                host.h_name = bp;
+                                nn = strlen(bp) + 1;    /* for the \0 */
+                                bp += nn;
+                        }
+
+                        bp += sizeof(align) - ((u_long)bp % sizeof(align));
+
+                        if (bp + n >= &hostbuf[sizeof hostbuf]) {
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("size (%d) too big\n", n);
+#endif
+                                had_error++;
+                                continue;
+                        }
+                        if (hap >= &h_addr_ptrs[MAXADDRS-1]) {
+                                if (!toobig++)
+#ifdef DEBUG
+                                        if (_resp->options & RES_DEBUG)
+                                                printf("Too many addresses (%d)\n", MAXADDRS);
+#endif
+                                cp += n;
+                                continue;
+                        }
+                        bcopy(cp, *hap++ = bp, n);
+                        bp += n;
+                        cp += n;
+                        break;
+                }
+                if (!had_error)
+                        haveanswer++;
+        }
+        if (haveanswer) {
+                *ap = NULL;
+                *hap = NULL;
+# if defined(RESOLVSORT)
+                /*
+                 * Note: we sort even if host can take only one address
+                 * in its return structures - should give it the "best"
+                 * address in that case, not some random one
+                 */
+                if (_resp->nsort && haveanswer > 1 && qtype == T_A)
+                        addrsort(h_addr_ptrs, haveanswer);
+# endif /*RESOLVSORT*/
+                if (!host.h_name) {
+                        n = strlen(qname) + 1;  /* for the \0 */
+                        if (n > ep - bp)
+                                goto try_again;
+                        strlcpy(bp, qname, ep - bp);
+                        host.h_name = bp;
+                        bp += n;
+                }
+                if (_resp->options & RES_USE_INET6)
+                        map_v4v6_hostent(&host, &bp, ep);
+                h_errno = NETDB_SUCCESS;
+                return (&host);
+        }
+ try_again:
+        h_errno = TRY_AGAIN;
+        return (NULL);
+}
+
+#ifdef notyet
+/*
+ * XXX This is an extremely bogus implementation.
+ *
+ * FreeBSD has this interface:
+ *    int gethostbyaddr_r(const char *addr, int len, int type,
+ *             struct hostent *result, struct hostent_data *buffer)
+ */
+
+struct hostent *
+gethostbyname_r(const char *name, struct hostent *hp, char *buf, int buflen,
+    int *errorp)
+{
+        struct hostent *res;
+
+        res = gethostbyname(name);
+        *errorp = h_errno;
+        if (res == NULL)
+                return NULL;
+        memcpy(hp, res, sizeof *hp); /* XXX not sufficient */
+        return hp;
+}
+
+/*
+ * XXX This is an extremely bogus implementation.
+ */
+struct hostent *
+gethostbyaddr_r(const char *addr, int len, int af, struct hostent *he,
+    char *buf, int buflen, int *errorp)
+{
+        struct hostent * res;
+
+        res = gethostbyaddr(addr, len, af);
+        *errorp = h_errno;
+        if (res == NULL)
+                return NULL;
+        memcpy(he, res, sizeof *he); /* XXX not sufficient */
+        return he;
+}
+
+/* XXX RFC2133 expects a gethostbyname2_r() -- unimplemented */
+#endif
+
+struct hostent *
+gethostbyname(const char *name)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        struct hostent *hp;
+        extern struct hostent *_gethtbyname2(const char *, int);
+
+        if (_res_init(0) == -1)
+                hp = _gethtbyname2(name, AF_INET);
+
+        else if (_resp->options & RES_USE_INET6) {
+                hp = gethostbyname2(name, AF_INET6);
+                if (hp == NULL)
+                        hp = gethostbyname2(name, AF_INET);
+        }
+        else
+                hp = gethostbyname2(name, AF_INET);
+        return hp;
+}
+
+struct hostent *
+gethostbyname2(const char *name, int af)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        querybuf *buf;
+        const char *cp;
+        char *bp, *ep;
+        int n, size, type, i;
+        struct hostent *hp;
+        char lookups[MAXDNSLUS];
+        extern struct hostent *_gethtbyname2(const char *, int);
+        extern struct hostent *_yp_gethtbyname(const char *);
+
+        if (_res_init(0) == -1)
+                return (_gethtbyname2(name, af));
+
+        switch (af) {
+        case AF_INET:
+                size = INADDRSZ;
+                type = T_A;
+                break;
+        case AF_INET6:
+                size = IN6ADDRSZ;
+                type = T_AAAA;
+                break;
+        default:
+                h_errno = NETDB_INTERNAL;
+                errno = EAFNOSUPPORT;
+                return (NULL);
+        }
+
+        host.h_addrtype = af;
+        host.h_length = size;
+
+        /*
+         * if there aren't any dots, it could be a user-level alias.
+         * this is also done in res_query() since we are not the only
+         * function that looks up host names.
+         */
+        if (!strchr(name, '.') && (cp = __hostalias(name)))
+                name = cp;
+
+        /*
+         * disallow names consisting only of digits/dots, unless
+         * they end in a dot.
+         */
+        if (isdigit(name[0]))
+                for (cp = name;; ++cp) {
+                        if (!*cp) {
+                                if (*--cp == '.')
+                                        break;
+                                /*
+                                 * All-numeric, no dot at the end.
+                                 * Fake up a hostent as if we'd actually
+                                 * done a lookup.
+                                 */
+                                if (inet_pton(af, name, host_addr) <= 0) {
+                                        h_errno = HOST_NOT_FOUND;
+                                        return (NULL);
+                                }
+                                strlcpy(hostbuf, name, MAXHOSTNAMELEN);
+                                bp = hostbuf + MAXHOSTNAMELEN;
+                                ep = hostbuf + sizeof(hostbuf);
+                                host.h_name = hostbuf;
+                                host.h_aliases = host_aliases;
+                                host_aliases[0] = NULL;
+                                h_addr_ptrs[0] = (char *)host_addr;
+                                h_addr_ptrs[1] = NULL;
+                                host.h_addr_list = h_addr_ptrs;
+                                if (_resp->options & RES_USE_INET6)
+                                        map_v4v6_hostent(&host, &bp, ep);
+                                h_errno = NETDB_SUCCESS;
+                                return (&host);
+                        }
+                        if (!isdigit(*cp) && *cp != '.') 
+                                break;
+                }
+        if ((isxdigit(name[0]) && strchr(name, ':') != NULL) ||
+            name[0] == ':')
+                for (cp = name;; ++cp) {
+                        if (!*cp) {
+                                if (*--cp == '.')
+                                        break;
+                                /*
+                                 * All-IPv6-legal, no dot at the end.
+                                 * Fake up a hostent as if we'd actually
+                                 * done a lookup.
+                                 */
+                                if (inet_pton(af, name, host_addr) <= 0) {
+                                        h_errno = HOST_NOT_FOUND;
+                                        return (NULL);
+                                }
+                                strlcpy(hostbuf, name, MAXHOSTNAMELEN);
+                                bp = hostbuf + MAXHOSTNAMELEN;
+                                ep = hostbuf + sizeof(hostbuf);
+                                host.h_name = hostbuf;
+                                host.h_aliases = host_aliases;
+                                host_aliases[0] = NULL;
+                                h_addr_ptrs[0] = (char *)host_addr;
+                                h_addr_ptrs[1] = NULL;
+                                host.h_addr_list = h_addr_ptrs;
+                                h_errno = NETDB_SUCCESS;
+                                return (&host);
+                        }
+                        if (!isxdigit(*cp) && *cp != ':' && *cp != '.') 
+                                break;
+                }
+
+        bcopy(_resp->lookups, lookups, sizeof lookups);
+        if (lookups[0] == '\0')
+                strlcpy(lookups, "bf", sizeof lookups);
+
+        hp = (struct hostent *)NULL;
+        for (i = 0; i < MAXDNSLUS && hp == NULL && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        /* YP only supports AF_INET. */
+                        if (af == AF_INET)
+                                hp = _yp_gethtbyname(name);
+                        break;
+#endif
+                case 'b':
+                        buf = malloc(sizeof(*buf));
+                        if (buf == NULL)
+                                break;
+                        if ((n = res_search(name, C_IN, type, buf->buf,
+                            sizeof(buf->buf))) < 0) {
+                                free(buf);
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("res_search failed\n");
+#endif
+                                break;
+                        }
+                        hp = getanswer(buf, n, name, type);
+                        free(buf);
+                        break;
+                case 'f':
+                        hp = _gethtbyname2(name, af);
+                        break;
+                }
+        }
+        /* XXX h_errno not correct in all cases... */
+        return (hp);
+}
+
+struct hostent *
+gethostbyaddr(const void *addr, socklen_t len, int af)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        const u_char *uaddr = (const u_char *)addr;
+        int n, size, i;
+        querybuf *buf;
+        struct hostent *hp;
+        char qbuf[MAXDNAME+1], *qp, *ep;
+        char lookups[MAXDNSLUS];
+        struct hostent *res;
+        extern struct hostent *_gethtbyaddr(const void *, socklen_t, int);
+        extern struct hostent *_yp_gethtbyaddr(const void *);
+        
+        if (_res_init(0) == -1) {
+                res = _gethtbyaddr(addr, len, af);
+                return (res);
+        }
+
+        if (af == AF_INET6 && len == IN6ADDRSZ &&
+            (IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)uaddr) ||
+             IN6_IS_ADDR_SITELOCAL((struct in6_addr *)uaddr))) {
+                h_errno = HOST_NOT_FOUND;
+                return (NULL);
+        }
+        if (af == AF_INET6 && len == IN6ADDRSZ &&
+            (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)uaddr) ||
+             IN6_IS_ADDR_V4COMPAT((struct in6_addr *)uaddr))) {
+                /* Unmap. */
+                uaddr += IN6ADDRSZ - INADDRSZ;
+                af = AF_INET;
+                len = INADDRSZ;
+        }
+        switch (af) {
+        case AF_INET:
+                size = INADDRSZ;
+                break;
+        case AF_INET6:
+                size = IN6ADDRSZ;
+                break;
+        default:
+                errno = EAFNOSUPPORT;
+                h_errno = NETDB_INTERNAL;
+                return (NULL);
+        }
+        if (size != len) {
+                errno = EINVAL;
+                h_errno = NETDB_INTERNAL;
+                return (NULL);
+        }
+        ep = qbuf + sizeof(qbuf);
+        switch (af) {
+        case AF_INET:
+                (void) snprintf(qbuf, sizeof qbuf, "%u.%u.%u.%u.in-addr.arpa",
+                    (uaddr[3] & 0xff), (uaddr[2] & 0xff),
+                    (uaddr[1] & 0xff), (uaddr[0] & 0xff));
+                break;
+        case AF_INET6:
+                qp = qbuf;
+                for (n = IN6ADDRSZ - 1; n >= 0; n--) {
+                        i = snprintf(qp, ep - qp, "%x.%x.",
+                            uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
+                        if (i <= 0 || i >= ep - qp) {
+                                errno = EINVAL;
+                                h_errno = NETDB_INTERNAL;
+                                return (NULL);
+                        }
+                        qp += i;
+                }
+                strlcpy(qp, "ip6.arpa", ep - qp);
+                break;
+        }
+
+        bcopy(_resp->lookups, lookups, sizeof lookups);
+        if (lookups[0] == '\0')
+                strlcpy(lookups, "bf", sizeof lookups);
+
+        hp = (struct hostent *)NULL;
+        for (i = 0; i < MAXDNSLUS && hp == NULL && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        /* YP only supports AF_INET. */
+                        if (af == AF_INET)
+                                hp = _yp_gethtbyaddr(uaddr);
+                        break;
+#endif
+                case 'b':
+                        buf = malloc(sizeof(*buf));
+                        if (!buf)
+                                break;
+                        n = res_query(qbuf, C_IN, T_PTR, buf->buf,
+                            sizeof(buf->buf));
+                        if (n < 0) {
+                                free(buf);
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("res_query failed\n");
+#endif
+                                break;
+                        }
+                        if (!(hp = getanswer(buf, n, qbuf, T_PTR))) {
+                                free(buf);
+                                break;
+                        }
+                        free(buf);
+                        hp->h_addrtype = af;
+                        hp->h_length = len;
+                        bcopy(uaddr, host_addr, len);
+                        h_addr_ptrs[0] = (char *)host_addr;
+                        h_addr_ptrs[1] = NULL;
+                        if (af == AF_INET && (_resp->options & RES_USE_INET6)) {
+                                map_v4v6_address((char*)host_addr,
+                                    (char*)host_addr);
+                                hp->h_addrtype = AF_INET6;
+                                hp->h_length = IN6ADDRSZ;
+                        }
+                        h_errno = NETDB_SUCCESS;
+                        break;
+                case 'f':
+                        hp = _gethtbyaddr(uaddr, len, af);
+                        break;
+                }
+        }
+        /* XXX h_errno not correct in all cases... */
+        return (hp);
+}
+
+void
+_sethtent(int f)
+{
+        if (hostf == NULL)
+                hostf = fopen(_PATH_HOSTS, "r" );
+        else
+                rewind(hostf);
+        stayopen = f;
+}
+
+void
+_endhtent(void)
+{
+        if (hostf && !stayopen) {
+                (void) fclose(hostf);
+                hostf = NULL;
+        }
+}
+
+static struct hostent *
+_gethtent(void)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char *p, *cp, **q;
+        int af;
+        size_t len;
+
+        if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
+                h_errno = NETDB_INTERNAL;
+                return (NULL);
+        }
+ again:
+        if ((p = fgetln(hostf, &len)) == NULL) {
+                h_errno = HOST_NOT_FOUND;
+                return (NULL);
+        }
+        if (p[len-1] == '\n')
+                len--;
+        if (len >= sizeof(hostbuf) || len == 0)
+                goto again;
+        p = memcpy(hostbuf, p, len);
+        hostbuf[len] = '\0';
+        if (*p == '#')
+                goto again;
+        if ((cp = strchr(p, '#')))
+                *cp = '\0';
+        if (!(cp = strpbrk(p, " \t")))
+                goto again;
+        *cp++ = '\0';
+        if (inet_pton(AF_INET6, p, host_addr) > 0) {
+                af = AF_INET6;
+                len = IN6ADDRSZ;
+        } else if (inet_pton(AF_INET, p, host_addr) > 0) {
+                if (_resp->options & RES_USE_INET6) {
+                        map_v4v6_address((char*)host_addr, (char*)host_addr);
+                        af = AF_INET6;
+                        len = IN6ADDRSZ;
+                } else {
+                        af = AF_INET;
+                        len = INADDRSZ;
+                }
+        } else {
+                goto again;
+        }
+        /* if this is not something we're looking for, skip it. */
+        if (host.h_addrtype != AF_UNSPEC && host.h_addrtype != af)
+                goto again;
+        if (host.h_length != 0 && host.h_length != len)
+                goto again;
+        h_addr_ptrs[0] = (char *)host_addr;
+        h_addr_ptrs[1] = NULL;
+        host.h_addr_list = h_addr_ptrs;
+        host.h_length = len;
+        host.h_addrtype = af;
+        while (*cp == ' ' || *cp == '\t')
+                cp++;
+        host.h_name = cp;
+        q = host.h_aliases = host_aliases;
+        if ((cp = strpbrk(cp, " \t")))
+                *cp++ = '\0';
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (q < &host_aliases[MAXALIASES - 1])
+                        *q++ = cp;
+                if ((cp = strpbrk(cp, " \t")))
+                        *cp++ = '\0';
+        }
+        *q = NULL;
+        if (_resp->options & RES_USE_INET6) {
+                char *bp = hostbuf;
+                char *ep = hostbuf + sizeof hostbuf;
+
+                map_v4v6_hostent(&host, &bp, ep);
+        }
+        h_errno = NETDB_SUCCESS;
+        return (&host);
+}
+
+struct hostent *
+_gethtbyname2(const char *name, int af)
+{
+        struct hostent *p;
+        char **cp;
+        
+        _sethtent(0);
+        while ((p = _gethtent())) {
+                if (p->h_addrtype != af)
+                        continue;
+                if (strcasecmp(p->h_name, name) == 0)
+                        break;
+                for (cp = p->h_aliases; *cp != 0; cp++)
+                        if (strcasecmp(*cp, name) == 0)
+                                goto found;
+        }
+ found:
+        _endhtent();
+        return (p);
+}
+
+struct hostent *
+_gethtbyaddr(const void *addr, socklen_t len, int af)
+{
+        struct hostent *p;
+
+        host.h_length = len;
+        host.h_addrtype = af;
+
+        _sethtent(0);
+        while ((p = _gethtent()))
+                if (p->h_addrtype == af && p->h_length == len &&
+                    !bcmp(p->h_addr, addr, len))
+                        break;
+        _endhtent();
+        return (p);
+}
+
+#ifdef YP
+struct hostent *
+_yphostent(char *line)
+{
+        static struct in_addr host_addrs[MAXADDRS];
+        char *p = line;
+        char *cp, **q;
+        char **hap;
+        struct in_addr *buf;
+        int more;
+
+        host.h_name = NULL;
+        host.h_addr_list = h_addr_ptrs;
+        host.h_length = INADDRSZ;
+        host.h_addrtype = AF_INET;
+        hap = h_addr_ptrs;
+        buf = host_addrs;
+        q = host.h_aliases = host_aliases;
+
+nextline:
+        /* check for host_addrs overflow */
+        if (buf >= &host_addrs[sizeof(host_addrs) / sizeof(host_addrs[0])])
+                goto done;
+
+        more = 0;
+        cp = strpbrk(p, " \t");
+        if (cp == NULL)
+                goto done;
+        *cp++ = '\0';
+
+        *hap++ = (char *)buf;
+        (void) inet_aton(p, buf++);
+
+        while (*cp == ' ' || *cp == '\t')
+                cp++;
+        p = cp;
+        cp = strpbrk(p, " \t\n");
+        if (cp != NULL) {
+                if (*cp == '\n')
+                        more = 1;
+                *cp++ = '\0';
+        }
+        if (!host.h_name)
+                host.h_name = p;
+        else if (strcmp(host.h_name, p)==0)
+                ;
+        else if (q < &host_aliases[MAXALIASES - 1])
+                *q++ = p;
+        p = cp;
+        if (more)
+                goto nextline;
+
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (*cp == '\n') {
+                        cp++;
+                        goto nextline;
+                }
+                if (q < &host_aliases[MAXALIASES - 1])
+                        *q++ = cp;
+                cp = strpbrk(cp, " \t");
+                if (cp != NULL)
+                        *cp++ = '\0';
+        }
+done:
+        if (host.h_name == NULL)
+                return (NULL);
+        *q = NULL;
+        *hap = NULL;
+        return (&host);
+}
+
+struct hostent *
+_yp_gethtbyaddr(const void *addr)
+{
+        struct hostent *hp = NULL;
+        const u_char *uaddr = (const u_char *)addr;
+        static char *__ypcurrent;
+        int __ypcurrentlen, r;
+        char name[sizeof("xxx.xxx.xxx.xxx")];
+        
+        if (!__ypdomain) {
+                if (_yp_check(&__ypdomain) == 0)
+                        return (hp);
+        }
+        snprintf(name, sizeof name, "%u.%u.%u.%u", (uaddr[0] & 0xff),
+            (uaddr[1] & 0xff), (uaddr[2] & 0xff), (uaddr[3] & 0xff));
+        if (__ypcurrent)
+                free(__ypcurrent);
+        __ypcurrent = NULL;
+        r = yp_match(__ypdomain, "hosts.byaddr", name,
+                strlen(name), &__ypcurrent, &__ypcurrentlen);
+        if (r==0)
+                hp = _yphostent(__ypcurrent);
+        if (hp==NULL)
+                h_errno = HOST_NOT_FOUND;
+        return (hp);
+}
+
+struct hostent *
+_yp_gethtbyname(const char *name)
+{
+        struct hostent *hp = (struct hostent *)NULL;
+        static char *__ypcurrent;
+        int __ypcurrentlen, r;
+
+        if (strlen(name) >= MAXHOSTNAMELEN)
+                return (NULL);
+        if (!__ypdomain) {
+                if (_yp_check(&__ypdomain) == 0)
+                        return (hp);
+        }
+        if (__ypcurrent)
+                free(__ypcurrent);
+        __ypcurrent = NULL;
+        r = yp_match(__ypdomain, "hosts.byname", name,
+                strlen(name), &__ypcurrent, &__ypcurrentlen);
+        if (r == 0)
+                hp = _yphostent(__ypcurrent);
+        if (hp == NULL)
+                h_errno = HOST_NOT_FOUND;
+        return (hp);
+}
+#endif
+
+static void
+map_v4v6_address(const char *src, char *dst)
+{
+        u_char *p = (u_char *)dst;
+        char tmp[INADDRSZ];
+        int i;
+
+        /* Stash a temporary copy so our caller can update in place. */
+        bcopy(src, tmp, INADDRSZ);
+        /* Mark this ipv6 addr as a mapped ipv4. */
+        for (i = 0; i < 10; i++)
+                *p++ = 0x00;
+        *p++ = 0xff;
+        *p++ = 0xff;
+        /* Retrieve the saved copy and we're done. */
+        bcopy(tmp, (void*)p, INADDRSZ);
+}
+
+static void
+map_v4v6_hostent(struct hostent *hp, char **bpp, char *ep)
+{
+        char **ap;
+
+        if (hp->h_addrtype != AF_INET || hp->h_length != INADDRSZ)
+                return;
+        hp->h_addrtype = AF_INET6;
+        hp->h_length = IN6ADDRSZ;
+        for (ap = hp->h_addr_list; *ap; ap++) {
+                int i = sizeof(align) - ((u_long)*bpp % sizeof(align));
+
+                if (ep - *bpp < (i + IN6ADDRSZ)) {
+                        /* Out of memory.  Truncate address list here.  XXX */
+                        *ap = NULL;
+                        return;
+                }
+                *bpp += i;
+                map_v4v6_address(*ap, *bpp);
+                *ap = *bpp;
+                *bpp += IN6ADDRSZ;
+        }
+}
+
+struct hostent *
+gethostent(void)
+{
+        host.h_addrtype = AF_UNSPEC;
+        host.h_length = 0;
+        return (_gethtent());
+}
+
+#ifdef RESOLVSORT
+static void
+addrsort(char **ap, int num)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int i, j;
+        char **p;
+        short aval[MAXADDRS];
+        int needsort = 0;
+
+        p = ap;
+        for (i = 0; i < num; i++, p++) {
+                for (j = 0 ; (unsigned)j < _resp->nsort; j++)
+                        if (_resp->sort_list[j].addr.s_addr == 
+                            (((struct in_addr *)(*p))->s_addr & 
+                            _resp->sort_list[j].mask))
+                                break;
+                aval[i] = j;
+                if (needsort == 0 && i > 0 && j < aval[i-1])
+                        needsort = i;
+        }
+        if (!needsort)
+                return;
+
+        while (needsort < num) {
+                for (j = needsort - 1; j >= 0; j--) {
+                        if (aval[j] > aval[j+1]) {
+                                char *hp;
+
+                                i = aval[j];
+                                aval[j] = aval[j+1];
+                                aval[j+1] = i;
+
+                                hp = ap[j];
+                                ap[j] = ap[j+1];
+                                ap[j+1] = hp;
+                        } else
+                                break;
+                }
+                needsort++;
+        }
+}
+#endif
diff --git a/src/lib/libc/net/getifaddrs.3 b/src/lib/libc/net/getifaddrs.3
new file mode 100644
index 0000000000..e6380be4b7
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.3
@@ -0,0 +1,158 @@
+.\"     $OpenBSD: getifaddrs.3,v 1.12 2005/07/22 04:50:51 jaredy Exp $
+.\"     BSDI    getifaddrs.3,v 2.5 2000/02/23 14:51:59 dab Exp
+.\"
+.\" Copyright (c) 1995, 1999
+.\"     Berkeley Software Design, 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.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+.Dd October 12, 1995
+.Dt GETIFADDRS 3
+.Os
+.Sh NAME
+.Nm getifaddrs
+.Nd get interface addresses
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <ifaddrs.h>
+.Ft int
+.Fn getifaddrs "struct ifaddrs **ifap"
+.Ft void
+.Fn freeifaddrs "struct ifaddrs *ifap"
+.Sh DESCRIPTION
+The
+.Fn getifaddrs
+function stores a reference to a linked list of the network interfaces
+on the local machine in the memory referenced by
+.Fa ifap .
+The list consists of
+.Nm ifaddrs
+structures, as defined in the include file
+.Aq Pa ifaddrs.h .
+The
+.Nm ifaddrs
+structure contains at least the following entries:
+.Bd -literal
+    struct ifaddrs   *ifa_next;         /* Pointer to next struct */
+    char             *ifa_name;         /* Interface name */
+    u_int             ifa_flags;        /* Interface flags */
+    struct sockaddr  *ifa_addr;         /* Interface address */
+    struct sockaddr  *ifa_netmask;      /* Interface netmask */
+    struct sockaddr  *ifa_broadaddr;    /* Interface broadcast address */
+    struct sockaddr  *ifa_dstaddr;      /* P2P interface destination */
+    void             *ifa_data;         /* Address specific data */
+.Ed
+.Bl -tag -width ifa_broadaddr
+.It Fa ifa_next
+Contains a pointer to the next structure on the list.
+This field is set to
+.Dv NULL
+in the last structure on the list.
+.It Fa ifa_name
+Contains the interface name.
+.It Fa ifa_flags
+Contains the interface flags, as set by
+.Xr ifconfig 8 .
+.It Fa ifa_addr
+References either the address of the interface or the link level
+address of the interface, if one exists, otherwise it is
+.Dv NULL .
+(The
+.Fa sa_family
+field of the
+.Fa ifa_addr
+field should be consulted to determine the format of the
+.Fa ifa_addr
+address.)
+.It Fa ifa_netmask
+References the netmask associated with
+.Fa ifa_addr ,
+if one is set, otherwise it is
+.Dv NULL .
+.It Fa ifa_broadaddr
+This field, which should only be referenced for non-P2P interfaces,
+references the broadcast address associated with
+.Fa ifa_addr ,
+if one exists, otherwise it is
+.Dv NULL .
+.It Fa ifa_dstaddr
+References the destination address on a P2P interface,
+if one exists, otherwise it is
+.Dv NULL .
+.It Fa ifa_data
+References address family specific data.
+For
+.Dv AF_LINK
+addresses it contains a pointer to the
+.Li struct if_data
+(as defined in include file
+.Aq Pa net/if.h )
+which contains various interface attributes and statistics.
+For all other address families, it contains a pointer to the
+.Li struct ifa_data
+(as defined in include file
+.Aq Pa net/if.h )
+which contains per-address interface statistics.
+.El
+.Pp
+The data returned by
+.Fn getifaddrs
+is dynamically allocated and should be freed using
+.Fn freeifaddrs
+when no longer needed.
+.Sh RETURN VALUES
+Upon successful completion, a value of 0 is returned.
+Otherwise, a value of \-1 is returned and
+.Va errno
+is set to indicate the error.
+.Sh ERRORS
+The
+.Fn getifaddrs
+may fail and set
+.Va errno
+for any of the errors specified for the library routines
+.Xr ioctl 2 ,
+.Xr socket 2 ,
+.Xr malloc 3 ,
+or
+.Xr sysctl 3 .
+.Sh SEE ALSO
+.Xr ioctl 2 ,
+.Xr socket 2 ,
+.Xr sysctl 3 ,
+.Xr networking 4 ,
+.Xr ifconfig 8
+.Sh HISTORY
+The
+.Fn getifaddrs
+function first appeared in BSDI BSD/OS.
+The function has been available on
+.Ox
+since
+.Ox 2.7 .
+.Sh BUGS
+If both
+.Aq Pa net/if.h
+and
+.Aq Pa ifaddrs.h
+are being included,
+.Aq Pa net/if.h
+.Em must
+be included before
+.Aq Pa ifaddrs.h .
diff --git a/src/lib/libc/net/getifaddrs.c b/src/lib/libc/net/getifaddrs.c
new file mode 100644
index 0000000000..0db89f6c19
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.c
@@ -0,0 +1,277 @@
+/*      $OpenBSD: getifaddrs.c,v 1.9 2002/08/09 06:12:25 itojun Exp $   */
+
+/*
+ * Copyright (c) 1995, 1999
+ *      Berkeley Software Design, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+ *
+ *      BSDI getifaddrs.c,v 2.12 2000/02/23 14:51:59 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <sys/param.h>
+#include <net/route.h>
+#include <sys/sysctl.h>
+#include <net/if_dl.h>
+
+#include <errno.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define SALIGN  (sizeof(long) - 1)
+#define SA_RLEN(sa)     ((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : (SALIGN + 1))
+
+int
+getifaddrs(struct ifaddrs **pif)
+{
+        int icnt = 1;
+        int dcnt = 0;
+        int ncnt = 0;
+        int mib[6];
+        size_t needed;
+        char *buf;
+        char *next;
+        struct ifaddrs *cif = 0;
+        char *p, *p0;
+        struct rt_msghdr *rtm;
+        struct if_msghdr *ifm;
+        struct ifa_msghdr *ifam;
+        struct sockaddr_dl *dl;
+        struct sockaddr *sa;
+        u_short index = 0;
+        size_t len, alen;
+        struct ifaddrs *ifa, *ift;
+        int i;
+        char *data;
+        char *names;
+
+        mib[0] = CTL_NET;
+        mib[1] = PF_ROUTE;
+        mib[2] = 0;             /* protocol */
+        mib[3] = 0;             /* wildcard address family */
+        mib[4] = NET_RT_IFLIST;
+        mib[5] = 0;             /* no flags */
+        if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+                return (-1);
+        if ((buf = malloc(needed)) == NULL)
+                return (-1);
+        if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
+                free(buf);
+                return (-1);
+        }
+
+        for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
+                rtm = (struct rt_msghdr *)next;
+                if (rtm->rtm_version != RTM_VERSION)
+                        continue;
+                switch (rtm->rtm_type) {
+                case RTM_IFINFO:
+                        ifm = (struct if_msghdr *)rtm;
+                        if (ifm->ifm_addrs & RTA_IFP) {
+                                index = ifm->ifm_index;
+                                ++icnt;
+                                dl = (struct sockaddr_dl *)(ifm + 1);
+                                dcnt += SA_RLEN((struct sockaddr *)dl) +
+                                        ALIGNBYTES;
+                                dcnt += sizeof(ifm->ifm_data);
+                                ncnt += dl->sdl_nlen + 1;
+                        } else
+                                index = 0;
+                        break;
+
+                case RTM_NEWADDR:
+                        ifam = (struct ifa_msghdr *)rtm;
+                        if (index && ifam->ifam_index != index)
+                                abort();        /* XXX abort illegal in library */
+
+#define RTA_MASKS       (RTA_NETMASK | RTA_IFA | RTA_BRD)
+                        if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
+                                break;
+                        p = (char *)(ifam + 1);
+                        ++icnt;
+                        /* Scan to look for length of address */
+                        alen = 0;
+                        for (p0 = p, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_IFA) {
+                                        alen = len;
+                                        break;
+                                }
+                                p += len;
+                        }
+                        for (p = p0, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_NETMASK && sa->sa_len == 0)
+                                        dcnt += alen;
+                                else
+                                        dcnt += len;
+                                p += len;
+                        }
+                        break;
+                }
+        }
+
+        if (icnt + dcnt + ncnt == 1) {
+                *pif = NULL;
+                free(buf);
+                return (0);
+        }
+        data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
+        if (data == NULL) {
+                free(buf);
+                return(-1);
+        }
+
+        ifa = (struct ifaddrs *)data;
+        data += sizeof(struct ifaddrs) * icnt;
+        names = data + dcnt;
+
+        memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
+        ift = ifa;
+
+        index = 0;
+        for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
+                rtm = (struct rt_msghdr *)next;
+                if (rtm->rtm_version != RTM_VERSION)
+                        continue;
+                switch (rtm->rtm_type) {
+                case RTM_IFINFO:
+                        ifm = (struct if_msghdr *)rtm;
+                        if (ifm->ifm_addrs & RTA_IFP) {
+                                index = ifm->ifm_index;
+                                dl = (struct sockaddr_dl *)(ifm + 1);
+
+                                cif = ift;
+                                ift->ifa_name = names;
+                                ift->ifa_flags = (int)ifm->ifm_flags;
+                                memcpy(names, dl->sdl_data, dl->sdl_nlen);
+                                names[dl->sdl_nlen] = 0;
+                                names += dl->sdl_nlen + 1;
+
+                                ift->ifa_addr = (struct sockaddr *)data;
+                                memcpy(data, dl,
+                                    ((struct sockaddr *)dl)->sa_len);
+                                data += SA_RLEN((struct sockaddr *)dl);
+
+                                /* ifm_data needs to be aligned */
+                                ift->ifa_data = data = (void *)ALIGN(data);
+                                memcpy(data, &ifm->ifm_data, sizeof(ifm->ifm_data));
+                                data += sizeof(ifm->ifm_data);
+
+                                ift = (ift->ifa_next = ift + 1);
+                        } else
+                                index = 0;
+                        break;
+
+                case RTM_NEWADDR:
+                        ifam = (struct ifa_msghdr *)rtm;
+                        if (index && ifam->ifam_index != index)
+                                abort();        /* XXX abort illegal in library */
+
+                        if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
+                                break;
+                        ift->ifa_name = cif->ifa_name;
+                        ift->ifa_flags = cif->ifa_flags;
+                        ift->ifa_data = NULL;
+                        p = (char *)(ifam + 1);
+                        /* Scan to look for length of address */
+                        alen = 0;
+                        for (p0 = p, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_IFA) {
+                                        alen = len;
+                                        break;
+                                }
+                                p += len;
+                        }
+                        for (p = p0, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                switch (i) {
+                                case RTAX_IFA:
+                                        ift->ifa_addr = (struct sockaddr *)data;
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+
+                                case RTAX_NETMASK:
+                                        ift->ifa_netmask =
+                                            (struct sockaddr *)data;
+                                        if (sa->sa_len == 0) {
+                                                memset(data, 0, alen);
+                                                data += alen;
+                                                break;
+                                        }
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+
+                                case RTAX_BRD:
+                                        ift->ifa_broadaddr =
+                                            (struct sockaddr *)data;
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+                                }
+                                p += len;
+                        }
+
+
+                        ift = (ift->ifa_next = ift + 1);
+                        break;
+                }
+        }
+
+        free(buf);
+        if (--ift >= ifa) {
+                ift->ifa_next = NULL;
+                *pif = ifa;
+        } else {
+                *pif = NULL;
+                free(ifa);
+        }
+        return (0);
+}
+
+void
+freeifaddrs(struct ifaddrs *ifp)
+{
+        free(ifp);
+}
diff --git a/src/lib/libc/net/getnameinfo.3 b/src/lib/libc/net/getnameinfo.3
new file mode 100644
index 0000000000..b17f2e4aeb
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.3
@@ -0,0 +1,270 @@
+.\"     $OpenBSD: getnameinfo.3,v 1.38 2005/01/29 00:49:47 jmc Exp $
+.\"     $KAME: getnameinfo.3,v 1.37 2005/01/05 03:23:05 itojun Exp $
+.\"
+.\" Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
+.\" Copyright (C) 2000, 2001  Internet Software Consortium.
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+.\" REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+.\" INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+.\" LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+.\" OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+.\" PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd December 20, 2004
+.Dt GETNAMEINFO 3
+.Os
+.Sh NAME
+.Nm getnameinfo
+.Nd socket address structure to hostname and service name
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netdb.h>
+.Ft int
+.Fn getnameinfo "const struct sockaddr *sa" "socklen_t salen" "char *host" \
+    "size_t hostlen" "char *serv" "size_t servlen" "int flags"
+.Sh DESCRIPTION
+The
+.Fn getnameinfo
+function is used to convert a
+.Li sockaddr
+structure to a pair of host name and service strings.
+It is a replacement for and provides more flexibility than the
+.Xr gethostbyaddr 3
+and
+.Xr getservbyport 3
+functions and is the converse of the
+.Xr getaddrinfo 3
+function.
+.Pp
+The
+.Li sockaddr
+structure
+.Fa sa
+should point to either a
+.Li sockaddr_in
+or
+.Li sockaddr_in6
+structure (for IPv4 or IPv6 respectively) that is
+.Fa salen
+bytes long.
+.Pp
+The host and service names associated with
+.Fa sa
+are stored in
+.Fa host
+and
+.Fa serv
+which have length parameters
+.Fa hostlen
+and
+.Fa servlen .
+The maximum value for
+.Fa hostlen
+is
+.Dv NI_MAXHOST
+and
+the maximum value for
+.Fa servlen
+is
+.Dv NI_MAXSERV ,
+as defined by
+.Aq Pa netdb.h .
+If a length parameter is zero, no string will be stored.
+Otherwise, enough space must be provided to store the
+host name or service string plus a byte for the NUL terminator.
+.Pp
+The
+.Fa flags
+argument is formed by
+.Tn OR Ns 'ing
+the following values:
+.Bl -tag -width "NI_NUMERICHOSTXX"
+.It Dv NI_NOFQDN
+A fully qualified domain name is not required for local hosts.
+The local part of the fully qualified domain name is returned instead.
+.It Dv NI_NUMERICHOST
+Return the address in numeric form, as if calling
+.Xr inet_ntop 3 ,
+instead of a host name.
+.It Dv NI_NAMEREQD
+A name is required.
+If the host name cannot be found in DNS and this flag is set,
+a non-zero error code is returned.
+If the host name is not found and the flag is not set, the
+address is returned in numeric form.
+.It NI_NUMERICSERV
+The service name is returned as a digit string representing the port number.
+.It NI_DGRAM
+Specifies that the service being looked up is a datagram
+service, and causes
+.Xr getservbyport 3
+to be called with a second argument of
+.Dq udp
+instead of its default of
+.Dq tcp .
+This is required for the few ports (512\-514) that have different services
+for
+.Tn UDP
+and
+.Tn TCP .
+.El
+.Pp
+This implementation allows numeric IPv6 address notation with scope identifier,
+as documented in chapter 11 of draft-ietf-ipv6-scoping-arch-02.txt.
+IPv6 link-local address will appear as a string like
+.Dq Li fe80::1%ne0 .
+Refer to
+.Xr getaddrinfo 3
+for more information.
+.Sh RETURN VALUES
+.Fn getnameinfo
+returns zero on success or one of the error codes listed in
+.Xr gai_strerror 3
+if an error occurs.
+.Sh EXAMPLES
+The following code tries to get a numeric host name, and service name,
+for a given socket address.
+Observe that there is no hardcoded reference to a particular address family.
+.Bd -literal -offset indent
+struct sockaddr *sa;    /* input */
+char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+
+if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), sbuf,
+    sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
+        errx(1, "could not get numeric hostname");
+        /*NOTREACHED*/
+}
+printf("host=%s, serv=%s\en", hbuf, sbuf);
+.Ed
+.Pp
+The following version checks if the socket address has a reverse address mapping:
+.Bd -literal -offset indent
+struct sockaddr *sa;    /* input */
+char hbuf[NI_MAXHOST];
+
+if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), NULL, 0,
+    NI_NAMEREQD)) {
+        errx(1, "could not resolve hostname");
+        /*NOTREACHED*/
+}
+printf("host=%s\en", hbuf);
+.Ed
+.Sh SEE ALSO
+.Xr gai_strerror 3 ,
+.Xr getaddrinfo 3 ,
+.Xr gethostbyaddr 3 ,
+.Xr getservbyport 3 ,
+.Xr inet_ntop 3 ,
+.Xr resolver 3 ,
+.Xr hosts 5 ,
+.Xr resolv.conf 5 ,
+.Xr services 5 ,
+.Xr hostname 7 ,
+.Xr named 8
+.Rs
+.%A R. Gilligan
+.%A S. Thomson
+.%A J. Bound
+.%A W. Stevens
+.%T Basic Socket Interface Extensions for IPv6
+.%R RFC 2553
+.%D March 1999
+.Re
+.Rs
+.%A S. Deering
+.%A B. Haberman
+.%A T. Jinmei
+.%A E. Nordmark
+.%A B. Zill
+.%T "IPv6 Scoped Address Architecture"
+.%R internet draft
+.%N draft-ietf-ipv6-scoping-arch-02.txt
+.%O work in progress material
+.Re
+.Rs
+.%A Craig Metz
+.%T Protocol Independence Using the Sockets API
+.%B "Proceedings of the Freenix Track: 2000 USENIX Annual Technical Conference"
+.%D June 2000
+.Re
+.Sh STANDARDS
+The
+.Fn getnameinfo
+function is defined by the
+.St -p1003.1g-2000
+draft specification and documented in
+.Tn "RFC 2553" ,
+.Dq Basic Socket Interface Extensions for IPv6 .
+.Sh CAVEATS
+.Fn getnameinfo
+can return both numeric and FQDN forms of the address specified in
+.Fa sa .
+There is no return value that indicates whether the string returned in
+.Fa host
+is a result of binary to numeric-text translation (like
+.Xr inet_ntop 3 ) ,
+or is the result of a DNS reverse lookup.
+Because of this, malicious parties could set up a PTR record as follows:
+.Bd -literal -offset indent
+1.0.0.127.in-addr.arpa. IN PTR  10.1.1.1
+.Ed
+.Pp
+and trick the caller of
+.Fn getnameinfo
+into believing that
+.Fa sa
+is
+.Li 10.1.1.1
+when it is actually
+.Li 127.0.0.1 .
+.Pp
+To prevent such attacks, the use of
+.Dv NI_NAMEREQD
+is recommended when the result of
+.Fn getnameinfo
+is used
+for access control purposes:
+.Bd -literal -offset indent
+struct sockaddr *sa;
+socklen_t salen;
+char addr[NI_MAXHOST];
+struct addrinfo hints, *res;
+int error;
+
+error = getnameinfo(sa, salen, addr, sizeof(addr),
+    NULL, 0, NI_NAMEREQD);
+if (error == 0) {
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
+        hints.ai_flags = AI_NUMERICHOST;
+        if (getaddrinfo(addr, "0", &hints, &res) == 0) {
+                /* malicious PTR record */
+                freeaddrinfo(res);
+                printf("bogus PTR record\en");
+                return -1;
+        }
+        /* addr is FQDN as a result of PTR lookup */
+} else {
+        /* addr is numeric string */
+        error = getnameinfo(sa, salen, addr, sizeof(addr),
+            NULL, 0, NI_NUMERICHOST);
+}
+.Ed
+.Sh BUGS
+The implementation of
+.Fn getnameinfo
+is not thread-safe.
+.Pp
+.Ox
+intentionally uses a different
+.Dv NI_MAXHOST
+value from what
+.Tn "RFC 2553"
+suggests, to avoid buffer length handling mistakes.
diff --git a/src/lib/libc/net/getnameinfo.c b/src/lib/libc/net/getnameinfo.c
new file mode 100644
index 0000000000..4c8ee80fec
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.c
@@ -0,0 +1,353 @@
+/*      $OpenBSD: getnameinfo.c,v 1.31 2005/06/19 04:44:34 marcm Exp $  */
+/*      $KAME: getnameinfo.c,v 1.45 2000/09/25 22:43:56 itojun Exp $    */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 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.
+ */
+
+/*
+ * Issues to be discussed:
+ * - Thread safe-ness must be checked
+ * - RFC2553 says that we should raise error on short buffer.  X/Open says
+ *   we need to truncate the result.  We obey RFC2553 (and X/Open should be
+ *   modified).  ipngwg rough consensus seems to follow RFC2553.
+ * - What is "local" in NI_FQDN?
+ * - NI_NAMEREQD and NI_NUMERICHOST conflict with each other.
+ * - (KAME extension) always attach textual scopeid (fe80::1%lo0), if
+ *   sin6_scope_id is filled - standardization status?
+ *   XXX breaks backward compat for code that expects no scopeid.
+ *   beware on merge.
+ */
+
+#ifndef INET6
+#define INET6
+#endif
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <string.h>
+#include <stddef.h>
+
+#include "thread_private.h"
+
+static const struct afd {
+        int a_af;
+        int a_addrlen;
+        int a_socklen;
+        int a_off;
+} afdl [] = {
+#ifdef INET6
+        {PF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6),
+                offsetof(struct sockaddr_in6, sin6_addr)},
+#endif
+        {PF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in),
+                offsetof(struct sockaddr_in, sin_addr)},
+        {0, 0, 0},
+};
+
+struct sockinet {
+        u_char  si_len;
+        u_char  si_family;
+        u_short si_port;
+};
+
+#ifdef INET6
+static int ip6_parsenumeric(const struct sockaddr *, const char *, char *,
+    size_t, int);
+static int ip6_sa2str(const struct sockaddr_in6 *, char *, size_t, int);
+#endif
+
+/*
+ * this mutex is also used by get_port in getaddrinfo.c
+ */
+void *__THREAD_NAME(serv_mutex);
+
+int
+getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host,
+    size_t hostlen, char *serv, size_t servlen, int flags)
+{
+        const struct afd *afd;
+        struct servent *sp;
+        struct hostent *hp;
+        u_short port;
+        int family, i;
+        const char *addr;
+        u_int32_t v4a;
+        char numserv[512];
+        char numaddr[512];
+
+        if (sa == NULL)
+                return EAI_FAIL;
+
+        family = sa->sa_family;
+        for (i = 0; afdl[i].a_af; i++)
+                if (afdl[i].a_af == family) {
+                        afd = &afdl[i];
+                        goto found;
+                }
+        return EAI_FAMILY;
+
+ found:
+        if (salen != afd->a_socklen)
+                return EAI_FAIL;
+
+        /* network byte order */
+        port = ((const struct sockinet *)sa)->si_port;
+        addr = (const char *)sa + afd->a_off;
+
+        if (serv == NULL || servlen == 0) {
+                /*
+                 * do nothing in this case.
+                 * in case you are wondering if "&&" is more correct than
+                 * "||" here: rfc2553bis-03 says that serv == NULL OR
+                 * servlen == 0 means that the caller does not want the result.
+                 */
+        } else {
+                if (flags & NI_NUMERICSERV)
+                        sp = NULL;
+                else {
+                        _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                        sp = getservbyport(port,
+                            (flags & NI_DGRAM) ? "udp" : "tcp");
+                        _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+                }
+                if (sp) {
+                        if (strlen(sp->s_name) + 1 > servlen)
+                                return EAI_MEMORY;
+                        strlcpy(serv, sp->s_name, servlen);
+                } else {
+                        snprintf(numserv, sizeof(numserv), "%u", ntohs(port));
+                        if (strlen(numserv) + 1 > servlen)
+                                return EAI_MEMORY;
+                        strlcpy(serv, numserv, servlen);
+                }
+        }
+
+        switch (sa->sa_family) {
+        case AF_INET:
+                v4a = (u_int32_t)
+                    ntohl(((const struct sockaddr_in *)sa)->sin_addr.s_addr);
+                if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+                        flags |= NI_NUMERICHOST;
+                v4a >>= IN_CLASSA_NSHIFT;
+                if (v4a == 0)
+                        flags |= NI_NUMERICHOST;                        
+                break;
+#ifdef INET6
+        case AF_INET6:
+            {
+                const struct sockaddr_in6 *sin6;
+                sin6 = (const struct sockaddr_in6 *)sa;
+                switch (sin6->sin6_addr.s6_addr[0]) {
+                case 0x00:
+                        if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
+                                ;
+                        else if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
+                                ;
+                        else
+                                flags |= NI_NUMERICHOST;
+                        break;
+                default:
+                        if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
+                                flags |= NI_NUMERICHOST;
+                        }
+                        else if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
+                                flags |= NI_NUMERICHOST;
+                        break;
+                }
+            }
+                break;
+#endif
+        }
+        if (host == NULL || hostlen == 0) {
+                /*
+                 * do nothing in this case.
+                 * in case you are wondering if "&&" is more correct than
+                 * "||" here: rfc2553bis-03 says that host == NULL or
+                 * hostlen == 0 means that the caller does not want the result.
+                 */
+        } else if (flags & NI_NUMERICHOST) {
+                int numaddrlen;
+
+                /* NUMERICHOST and NAMEREQD conflicts with each other */
+                if (flags & NI_NAMEREQD)
+                        return EAI_NONAME;
+
+                switch(afd->a_af) {
+#ifdef INET6
+                case AF_INET6:
+                {
+                        int error;
+
+                        if ((error = ip6_parsenumeric(sa, addr, host,
+                                                      hostlen, flags)) != 0)
+                                return(error);
+                        break;
+                }
+#endif
+                default:
+                        if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+                            == NULL)
+                                return EAI_SYSTEM;
+                        numaddrlen = strlen(numaddr);
+                        if (numaddrlen + 1 > hostlen) /* don't forget terminator */
+                                return EAI_MEMORY;
+                        strlcpy(host, numaddr, hostlen);
+                        break;
+                }
+        } else {
+                _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
+                _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+
+                if (hp) {
+#if 0
+                        /*
+                         * commented out, since "for local host" is not
+                         * implemented here - see RFC2553 p30
+                         */
+                        if (flags & NI_NOFQDN) {
+                                char *p;
+                                p = strchr(hp->h_name, '.');
+                                if (p)
+                                        *p = '\0';
+                        }
+#endif
+                        if (strlen(hp->h_name) + 1 > hostlen) {
+                                return EAI_MEMORY;
+                        }
+                        strlcpy(host, hp->h_name, hostlen);
+                } else {
+                        if (flags & NI_NAMEREQD)
+                                return EAI_NONAME;
+                        switch(afd->a_af) {
+#ifdef INET6
+                        case AF_INET6:
+                        {
+                                int error;
+
+                                if ((error = ip6_parsenumeric(sa, addr, host,
+                                                              hostlen,
+                                                              flags)) != 0)
+                                        return(error);
+                                break;
+                        }
+#endif
+                        default:
+                                if (inet_ntop(afd->a_af, addr, host,
+                                    hostlen) == NULL)
+                                        return EAI_SYSTEM;
+                                break;
+                        }
+                }
+        }
+        return(0);
+}
+
+#ifdef INET6
+static int
+ip6_parsenumeric(const struct sockaddr *sa, const char *addr, char *host,
+    size_t hostlen, int flags)
+{
+        int numaddrlen;
+        char numaddr[512];
+
+        if (inet_ntop(AF_INET6, addr, numaddr, sizeof(numaddr)) == NULL)
+                return EAI_SYSTEM;
+
+        numaddrlen = strlen(numaddr);
+        if (numaddrlen + 1 > hostlen) /* don't forget terminator */
+                return EAI_MEMORY;
+        strlcpy(host, numaddr, hostlen);
+
+        if (((const struct sockaddr_in6 *)sa)->sin6_scope_id) {
+                char zonebuf[MAXHOSTNAMELEN];
+                int zonelen;
+
+                zonelen = ip6_sa2str(
+                    (const struct sockaddr_in6 *)(const void *)sa,
+                    zonebuf, sizeof(zonebuf), flags);
+                if (zonelen < 0)
+                        return EAI_MEMORY;
+                if (zonelen + 1 + numaddrlen + 1 > hostlen)
+                        return EAI_MEMORY;
+
+                /* construct <numeric-addr><delim><zoneid> */
+                memcpy(host + numaddrlen + 1, zonebuf,
+                    (size_t)zonelen);
+                host[numaddrlen] = SCOPE_DELIMITER;
+                host[numaddrlen + 1 + zonelen] = '\0';
+        }
+
+        return 0;
+}
+
+/* ARGSUSED */
+static int
+ip6_sa2str(const struct sockaddr_in6 *sa6, char *buf, size_t bufsiz, int flags)
+{
+        unsigned int ifindex;
+        const struct in6_addr *a6;
+        int n;
+
+        ifindex = (unsigned int)sa6->sin6_scope_id;
+        a6 = &sa6->sin6_addr;
+
+#ifdef notdef
+        if ((flags & NI_NUMERICSCOPE) != 0) {
+                n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
+                if (n < 0 || n >= bufsiz)
+                        return -1;
+                else
+                        return n;
+        }
+#endif
+
+        /* if_indextoname() does not take buffer size.  not a good api... */
+        if ((IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) &&
+            bufsiz >= IF_NAMESIZE) {
+                char *p = if_indextoname(ifindex, buf);
+                if (p) {
+                        return(strlen(p));
+                }
+        }
+
+        /* last resort */
+        n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
+        if (n < 0 || n >= bufsiz)
+                return -1;
+        else
+                return n;
+}
+#endif /* INET6 */
diff --git a/src/lib/libc/net/getnetbyaddr.c b/src/lib/libc/net/getnetbyaddr.c
new file mode 100644
index 0000000000..a85106630c
--- /dev/null
+++ b/src/lib/libc/net/getnetbyaddr.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: getnetbyaddr.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+
+extern int _net_stayopen;
+
+struct netent *
+_getnetbyaddr(in_addr_t net, int type)
+{
+        struct netent *p;
+
+        setnetent(_net_stayopen);
+        while ((p = getnetent()))
+                if (p->n_addrtype == type && p->n_net == net)
+                        break;
+        if (!_net_stayopen)
+                endnetent();
+        return (p);
+}
diff --git a/src/lib/libc/net/getnetbyname.c b/src/lib/libc/net/getnetbyname.c
new file mode 100644
index 0000000000..e6540cf12c
--- /dev/null
+++ b/src/lib/libc/net/getnetbyname.c
@@ -0,0 +1,54 @@
+/*      $OpenBSD: getnetbyname.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+#include <string.h>
+
+extern int _net_stayopen;
+
+struct netent *
+_getnetbyname(const char *name)
+{
+        struct netent *p;
+        char **cp;
+
+        setnetent(_net_stayopen);
+        while ((p = getnetent())) {
+                if (strcasecmp(p->n_name, name) == 0)
+                        break;
+                for (cp = p->n_aliases; *cp != 0; cp++)
+                        if (strcasecmp(*cp, name) == 0)
+                                goto found;
+        }
+found:
+        if (!_net_stayopen)
+                endnetent();
+        return (p);
+}
diff --git a/src/lib/libc/net/getnetent.3 b/src/lib/libc/net/getnetent.3
new file mode 100644
index 0000000000..b337c8c02d
--- /dev/null
+++ b/src/lib/libc/net/getnetent.3
@@ -0,0 +1,140 @@
+.\"     $OpenBSD: getnetent.3,v 1.14 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd March 13, 1997
+.Dt GETNETENT 3
+.Os
+.Sh NAME
+.Nm getnetent ,
+.Nm getnetbyaddr ,
+.Nm getnetbyname ,
+.Nm setnetent ,
+.Nm endnetent
+.Nd get network entry
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft struct netent *
+.Fn getnetent "void"
+.Ft struct netent *
+.Fn getnetbyname "const char *name"
+.Ft struct netent *
+.Fn getnetbyaddr "in_addr_t net" "int type"
+.Ft void
+.Fn setnetent "int stayopen"
+.Ft void
+.Fn endnetent "void"
+.Sh DESCRIPTION
+The
+.Fn getnetent ,
+.Fn getnetbyname ,
+and
+.Fn getnetbyaddr
+functions each return a pointer to an object with the following structure
+containing the broken-out fields of a line in the network database,
+.Pa /etc/networks .
+.Bd -literal -offset indent
+struct  netent {
+        char            *n_name;        /* official name of net */
+        char            **n_aliases;    /* alias list */
+        int             n_addrtype;     /* net number type */
+        in_addr_t       n_net;          /* net number */
+};
+.Ed
+.Pp
+The members of this structure are:
+.Bl -tag -width n_addrtype
+.It Fa n_name
+The official name of the network.
+.It Fa n_aliases
+A null-terminated list of alternate names for the network.
+.It Fa n_addrtype
+The type of the network number returned; currently only
+.Dv AF_INET .
+.It Fa n_net
+The network number.
+Network numbers are returned in machine byte order.
+.El
+.Pp
+The
+.Fn getnetent
+function reads the next line of the file, opening the file if necessary.
+.Pp
+The
+.Fn setnetent
+function opens and rewinds the file.
+If the
+.Fa stayopen
+flag is non-zero,
+the net database will not be closed after each call to
+.Fn getnetbyname
+or
+.Fn getnetbyaddr .
+.Pp
+The
+.Fn endnetent
+function closes the file.
+.Pp
+The
+.Fn getnetbyname
+and
+.Fn getnetbyaddr
+functions search the domain name server if the system is configured to use one.
+If the search fails, or no name server is configured, they sequentially
+search from the beginning of the file until a matching net name or
+net address and type is found, or until
+.Dv EOF
+is encountered.
+Network numbers are supplied in host order.
+.Sh FILES
+.Bl -tag -width /etc/networks -compact
+.It Pa /etc/networks
+.El
+.Sh DIAGNOSTICS
+Null pointer (0) returned on
+.Dv EOF
+or error.
+.Sh SEE ALSO
+.Xr resolver 3 ,
+.Xr networks 5
+.Sh HISTORY
+The
+.Fn getnetent ,
+.Fn getnetbyaddr ,
+.Fn getnetbyname ,
+.Fn setnetent ,
+and
+.Fn endnetent
+functions appeared in
+.Bx 4.2 .
+.Sh BUGS
+The data space used by these functions is static; if future use
+requires the data, it should be copied before any subsequent calls
+to these functions overwrite it.
+Only Internet network numbers are currently understood.
+Expecting network numbers to fit in no more than 32 bits is naive.
diff --git a/src/lib/libc/net/getnetent.c b/src/lib/libc/net/getnetent.c
new file mode 100644
index 0000000000..1bec6fb98c
--- /dev/null
+++ b/src/lib/libc/net/getnetent.c
@@ -0,0 +1,121 @@
+/*      $OpenBSD: getnetent.c,v 1.12 2006/01/17 15:37:58 millert Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+
+#define MAXALIASES      35
+
+static FILE *netf;
+static char line[BUFSIZ+1];
+static struct netent net;
+static char *net_aliases[MAXALIASES];
+int _net_stayopen;
+
+void
+setnetent(int f)
+{
+        if (netf == NULL)
+                netf = fopen(_PATH_NETWORKS, "r" );
+        else
+                rewind(netf);
+        _net_stayopen |= f;
+}
+
+void
+endnetent(void)
+{
+        if (netf) {
+                fclose(netf);
+                netf = NULL;
+        }
+        _net_stayopen = 0;
+}
+
+struct netent *
+getnetent(void)
+{
+        char *p, *cp, **q;
+        size_t len;
+
+        if (netf == NULL && (netf = fopen(_PATH_NETWORKS, "r" )) == NULL)
+                return (NULL);
+again:
+        if ((p = fgetln(netf, &len)) == NULL)
+                return (NULL);
+        if (p[len-1] == '\n')
+                len--;
+        if (len >= sizeof(line) || len == 0)
+                goto again;
+        p = memcpy(line, p, len);
+        line[len] = '\0';
+        if (*p == '#')
+                goto again;
+        if ((cp = strchr(p, '#')) != NULL)
+                *cp = '\0';
+        net.n_name = p;
+        if (strlen(net.n_name) >= MAXHOSTNAMELEN-1)
+                net.n_name[MAXHOSTNAMELEN-1] = '\0';
+        cp = strpbrk(p, " \t");
+        if (cp == NULL)
+                goto again;
+        *cp++ = '\0';
+        while (*cp == ' ' || *cp == '\t')
+                cp++;
+        p = strpbrk(cp, " \t");
+        if (p != NULL)
+                *p++ = '\0';
+        net.n_net = inet_network(cp);
+        net.n_addrtype = AF_INET;
+        q = net.n_aliases = net_aliases;
+        if (p != NULL) 
+                cp = p;
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (q < &net_aliases[MAXALIASES - 1]) {
+                        *q++ = cp;
+                        if (strlen(cp) >= MAXHOSTNAMELEN-1)
+                                cp[MAXHOSTNAMELEN-1] = '\0';
+                }
+                cp = strpbrk(cp, " \t");
+                if (cp != NULL)
+                        *cp++ = '\0';
+        }
+        *q = NULL;
+        return (&net);
+}
diff --git a/src/lib/libc/net/getnetnamadr.c b/src/lib/libc/net/getnetnamadr.c
new file mode 100644
index 0000000000..7b770f1ce7
--- /dev/null
+++ b/src/lib/libc/net/getnetnamadr.c
@@ -0,0 +1,384 @@
+/*      $OpenBSD: getnetnamadr.c,v 1.26 2005/08/06 20:30:03 espie Exp $ */
+
+/*
+ * Copyright (c) 1997, Jason Downs.  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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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(S) 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.
+ */
+/* Copyright (c) 1993 Carlos Leandro and Rui Salgueiro
+ *      Dep. Matematica Universidade de Coimbra, Portugal, Europe
+ *
+ * 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.
+ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "thread_private.h"
+
+extern int h_errno;
+
+struct netent *_getnetbyaddr(in_addr_t net, int type);
+struct netent *_getnetbyname(const char *name);
+
+int _hokchar(const char *);
+
+#define BYADDR 0
+#define BYNAME 1
+#define MAXALIASES      35
+
+#define MAXPACKET       (64*1024)
+
+typedef union {
+        HEADER  hdr;
+        u_char  buf[MAXPACKET];
+} querybuf;
+
+typedef union {
+        long    al;
+        char    ac;
+} align;
+
+static struct netent *
+getnetanswer(querybuf *answer, int anslen, int net_i)
+{
+
+        HEADER *hp;
+        u_char *cp;
+        int n;
+        u_char *eom;
+        int type, class, ancount, qdcount, haveanswer, i, nchar;
+        char aux1[MAXHOSTNAMELEN], aux2[MAXHOSTNAMELEN], ans[MAXHOSTNAMELEN];
+        char *in, *st, *pauxt, *bp, **ap, *ep;
+        char *paux1 = &aux1[0], *paux2 = &aux2[0];
+        static  struct netent net_entry;
+        static  char *net_aliases[MAXALIASES], netbuf[BUFSIZ+1];
+
+        /*
+         * find first satisfactory answer
+         *
+         *      answer --> +------------+  ( MESSAGE )
+         *                 |   Header   |
+         *                 +------------+
+         *                 |  Question  | the question for the name server
+         *                 +------------+
+         *                 |   Answer   | RRs answering the question
+         *                 +------------+
+         *                 | Authority  | RRs pointing toward an authority
+         *                 | Additional | RRs holding additional information
+         *                 +------------+
+         */
+        eom = answer->buf + anslen;
+        hp = &answer->hdr;
+        ancount = ntohs(hp->ancount); /* #/records in the answer section */
+        qdcount = ntohs(hp->qdcount); /* #/entries in the question section */
+        bp = netbuf;
+        ep = netbuf + sizeof(netbuf);
+        cp = answer->buf + HFIXEDSZ;
+        if (!qdcount) {
+                if (hp->aa)
+                        h_errno = HOST_NOT_FOUND;
+                else
+                        h_errno = TRY_AGAIN;
+                return (NULL);
+        }
+        while (qdcount-- > 0) {
+                n = __dn_skipname(cp, eom);
+                if (n < 0 || (cp + n + QFIXEDSZ) > eom) {
+                        h_errno = NO_RECOVERY;
+                        return(NULL);
+                }
+                cp += n + QFIXEDSZ;
+        }
+        ap = net_aliases;
+        *ap = NULL;
+        net_entry.n_aliases = net_aliases;
+        haveanswer = 0;
+        while (--ancount >= 0 && cp < eom) {
+                n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+#ifdef USE_RESOLV_NAME_OK
+                if ((n < 0) || !res_dnok(bp))
+#else
+                if ((n < 0) || !_hokchar(bp))
+#endif
+                        break;
+                cp += n;
+                ans[0] = '\0';
+                strlcpy(&ans[0], bp, sizeof ans);
+                GETSHORT(type, cp);
+                GETSHORT(class, cp);
+                cp += INT32SZ;          /* TTL */
+                GETSHORT(n, cp);
+                if (class == C_IN && type == T_PTR) {
+                        n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+#ifdef USE_RESOLV_NAME_OK
+                        if ((n < 0) || !res_hnok(bp))
+#else
+                        if ((n < 0) || !_hokchar(bp))
+#endif
+                        {
+                                cp += n;
+                                return (NULL);
+                        }
+                        cp += n; 
+                        if ((ap + 2) < &net_aliases[MAXALIASES]) {
+                                *ap++ = bp;
+                                bp += strlen(bp) + 1;
+                                net_entry.n_addrtype =
+                                        (class == C_IN) ? AF_INET : AF_UNSPEC;
+                                haveanswer++;
+                        }
+                }
+        }
+        if (haveanswer) {
+                *ap = NULL;
+                switch (net_i) {
+                case BYADDR:
+                        net_entry.n_name = *net_entry.n_aliases;
+                        net_entry.n_net = 0L;
+                        break;
+                case BYNAME:
+                        ap = net_entry.n_aliases;
+                next_alias:
+                        in = *ap++;
+                        if (in == NULL) {
+                                h_errno = HOST_NOT_FOUND;
+                                return (NULL);
+                        }
+                        net_entry.n_name = ans;
+                        aux2[0] = '\0';
+                        for (i = 0; i < 4; i++) {
+                                for (st = in, nchar = 0;
+                                     isdigit((unsigned char)*st);
+                                     st++, nchar++)
+                                        ;
+                                if (*st != '.' || nchar == 0 || nchar > 3)
+                                        goto next_alias;
+                                if (i != 0)
+                                        nchar++;
+                                strlcpy(paux1, in, nchar+1);
+                                strlcat(paux1, paux2, MAXHOSTNAMELEN);
+                                pauxt = paux2;
+                                paux2 = paux1;
+                                paux1 = pauxt;
+                                in = ++st;
+                        }                 
+                        if (strcasecmp(in, "IN-ADDR.ARPA") != 0)
+                                goto next_alias;
+                        net_entry.n_net = inet_network(paux2);
+                        break;
+                }
+                net_entry.n_aliases++;
+                return (&net_entry);
+        }
+        h_errno = TRY_AGAIN;
+        return (NULL);
+}
+
+struct netent *
+getnetbyaddr(in_addr_t net, int net_type)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        unsigned int netbr[4];
+        int nn, anslen;
+        querybuf *buf;
+        char qbuf[MAXDNAME];
+        in_addr_t net2;
+        struct netent *net_entry = NULL;
+        char lookups[MAXDNSLUS];
+        int i;
+
+        if (_res_init(0) == -1)
+                return(_getnetbyaddr(net, net_type));
+
+        bcopy(_resp->lookups, lookups, sizeof lookups);
+        if (lookups[0] == '\0')
+                strlcpy(lookups, "bf", sizeof lookups);
+
+        for (i = 0; i < MAXDNSLUS && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        /* There is no YP support. */
+                        break;
+#endif  /* YP */
+                case 'b':
+                        if (net_type != AF_INET)
+                                break;  /* DNS only supports AF_INET? */
+
+                        for (nn = 4, net2 = net; net2; net2 >>= 8)
+                                netbr[--nn] = net2 & 0xff;
+                        switch (nn) {
+                        case 3:         /* Class A */
+                                snprintf(qbuf, sizeof(qbuf),
+                                    "0.0.0.%u.in-addr.arpa", netbr[3]);
+                                break;
+                        case 2:         /* Class B */
+                                snprintf(qbuf, sizeof(qbuf),
+                                    "0.0.%u.%u.in-addr.arpa",
+                                    netbr[3], netbr[2]);
+                                break;
+                        case 1:         /* Class C */
+                                snprintf(qbuf, sizeof(qbuf),
+                                    "0.%u.%u.%u.in-addr.arpa",
+                                    netbr[3], netbr[2], netbr[1]);
+                                break;
+                        case 0:         /* Class D - E */
+                                snprintf(qbuf, sizeof(qbuf),
+                                    "%u.%u.%u.%u.in-addr.arpa",
+                                    netbr[3], netbr[2], netbr[1], netbr[0]);
+                                break;
+                        }
+                        buf = malloc(sizeof(*buf));
+                        if (buf == NULL)
+                                break;
+                        anslen = res_query(qbuf, C_IN, T_PTR, buf->buf,
+                            sizeof(buf->buf));
+                        if (anslen < 0) {
+                                free(buf);
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("res_query failed\n");
+#endif
+                                break;
+                        }
+                        net_entry = getnetanswer(buf, anslen, BYADDR);
+                        free(buf);
+                        if (net_entry != NULL) {
+                                unsigned u_net = net;   /* maybe net should be unsigned ? */
+
+                                /* Strip trailing zeros */
+                                while ((u_net & 0xff) == 0 && u_net != 0)
+                                        u_net >>= 8;
+                                net_entry->n_net = u_net;
+                                return (net_entry);
+                        }
+                        break;
+                case 'f':
+                        net_entry = _getnetbyaddr(net, net_type);
+                        if (net_entry != NULL)
+                                return (net_entry);
+                }
+        }
+
+        /* Nothing matched. */
+        return (NULL);
+}
+
+struct netent *
+getnetbyname(const char *net)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int anslen;
+        querybuf *buf;
+        char qbuf[MAXDNAME];
+        struct netent *net_entry = NULL;
+        char lookups[MAXDNSLUS];
+        int i;
+
+        if (_res_init(0) == -1)
+                return (_getnetbyname(net));
+
+        bcopy(_resp->lookups, lookups, sizeof lookups);
+        if (lookups[0] == '\0')
+                strlcpy(lookups, "bf", sizeof lookups);
+
+        for (i = 0; i < MAXDNSLUS && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        /* There is no YP support. */
+                        break;
+#endif  /* YP */
+                case 'b':
+                        strlcpy(qbuf, net, sizeof qbuf);
+                        buf = malloc(sizeof(*buf));
+                        if (buf == NULL)
+                                break;
+                        anslen = res_search(qbuf, C_IN, T_PTR, buf->buf,
+                            sizeof(buf->buf));
+                        if (anslen < 0) {
+                                free(buf);
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("res_query failed\n");
+#endif
+                                break;
+                        }
+                        net_entry = getnetanswer(buf, anslen, BYNAME);
+                        free(buf);
+                        if (net_entry != NULL)
+                                return (net_entry);
+                        break;
+                case 'f':
+                        net_entry = _getnetbyname(net);
+                        if (net_entry != NULL)
+                                return (net_entry);
+                        break;
+                }
+        }
+
+        /* Nothing matched. */
+        return (NULL);
+}
diff --git a/src/lib/libc/net/getproto.c b/src/lib/libc/net/getproto.c
new file mode 100644
index 0000000000..07fa33288d
--- /dev/null
+++ b/src/lib/libc/net/getproto.c
@@ -0,0 +1,59 @@
+/*      $OpenBSD: getproto.c,v 1.7 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+#include <stdio.h>
+
+int
+getprotobynumber_r(int num, struct protoent *pe, struct protoent_data *pd)
+{
+        int error;
+
+        setprotoent_r(pd->stayopen, pd);
+        while ((error = getprotoent_r(pe, pd)) == 0)
+                if (pe->p_proto == num)
+                        break;
+        if (!pd->stayopen && pd->fp != NULL) {
+                (void)fclose(pd->fp);
+                pd->fp = NULL;
+        }
+        return (error);
+}
+
+struct protoent *
+getprotobynumber(int num)
+{
+        extern struct protoent_data _protoent_data;
+        static struct protoent proto;
+
+        if (getprotobynumber_r(num, &proto, &_protoent_data) != 0)
+                return (NULL);
+        return (&proto);
+}
diff --git a/src/lib/libc/net/getprotoent.3 b/src/lib/libc/net/getprotoent.3
new file mode 100644
index 0000000000..ea3644f6c9
--- /dev/null
+++ b/src/lib/libc/net/getprotoent.3
@@ -0,0 +1,213 @@
+.\"     $OpenBSD: getprotoent.3,v 1.16 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd October 13, 2004
+.Dt GETPROTOENT 3
+.Os
+.Sh NAME
+.Nm getprotoent ,
+.Nm getprotoent_r ,
+.Nm getprotobynumber ,
+.Nm getprotobynumber_r ,
+.Nm getprotobyname ,
+.Nm getprotobyname_r ,
+.Nm setprotoent ,
+.Nm setprotoent_r ,
+.Nm endprotoent ,
+.Nm endprotoent_r
+.Nd get protocol entry
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft struct protoent *
+.Fn getprotoent "void"
+.Ft int
+.Fn getprotoent_r "struct protoent *protoent" "struct protoent_data *protoent_data"
+.Ft struct protoent *
+.Fn getprotobyname "const char *name"
+.Ft int
+.Fn getprotobyname_r "const char *name" "struct protoent *protoent" "struct protoent_data *protoent_data"
+.Ft struct protoent *
+.Fn getprotobynumber "int proto"
+.Ft int
+.Fn getprotobynumber_r "int proto" "struct protoent *protoent" "struct protoent_data *protoent_data"
+.Ft void
+.Fn setprotoent "int stayopen"
+.Ft void
+.Fn setprotoent_r "int stayopen" "struct protoent_data *protoent_data"
+.Ft void
+.Fn endprotoent "void"
+.Ft void
+.Fn endprotoent_r "struct protoent_data *protoent_data"
+.Sh DESCRIPTION
+The
+.Fn getprotoent ,
+.Fn getprotobyname ,
+and
+.Fn getprotobynumber
+functions each return a pointer to an object with the following structure
+containing the broken-out fields of a line in the network protocol database,
+.Pa /etc/protocols .
+.Bd -literal -offset indent
+.Pp
+struct  protoent {
+        char    *p_name;        /* official name of protocol */
+        char    **p_aliases;    /* alias list */
+        int     p_proto;        /* protocol number */
+};
+.Ed
+.Pp
+The members of this structure are:
+.Bl -tag -width p_aliases
+.It Fa p_name
+The official name of the protocol.
+.It Fa p_aliases
+A null-terminated list of alternate names for the protocol.
+.It Fa p_proto
+The protocol number.
+.El
+.Pp
+The
+.Fn getprotoent
+function reads the next line of the file, opening the file if necessary.
+.Pp
+The
+.Fn setprotoent
+function opens and rewinds the file.
+If the
+.Fa stayopen
+flag is non-zero,
+the protocol database will not be closed after each call to
+.Fn getprotobyname
+or
+.Fn getprotobynumber .
+.Pp
+The
+.Fn endprotoent
+function closes the file.
+.Pp
+The
+.Fn getprotobyname
+and
+.Fn getprotobynumber
+functions sequentially search from the beginning of the file until a
+matching protocol name or protocol number is found, or until
+.Dv EOF
+is encountered.
+.Pp
+The
+.Fn getprotoent_r ,
+.Fn getprotobyport_r ,
+.Fn getprotobyname_r ,
+.Fn setprotoent_r ,
+and
+.Fn endprotoent_r
+functions are reentrant versions of the above functions that take a
+pointer to a
+.Vt protoent_data
+structure which is used to store state information.
+The structure must be zero-filled before it is used
+and should be considered opaque for the sake of portability.
+.Pp
+The
+.Fn getprotoent_r ,
+.Fn getprotobyport_r ,
+and
+.Fn getprotobyname_r
+functions
+also take a pointer to a
+.Vt protoent
+structure which is used to store the results of the database lookup.
+.Sh RETURN VALUES
+The
+.Fn getprotoent ,
+.Fn getprotobyport ,
+and
+.Fn getprotobyname
+functions return a pointer to a
+.Vt protoent
+structure on success or a null pointer if end-of-file
+is reached or an error occurs.
+.Pp
+The
+.Fn getprotoent_r ,
+.Fn getprotobyport_r ,
+and
+.Fn getprotobyname_r
+functions return 0 on success or \-1 if end-of-file
+is reached or an error occurs.
+.Sh FILES
+.Bl -tag -width /etc/protocols -compact
+.It Pa /etc/protocols
+.El
+.Sh SEE ALSO
+.Xr protocols 5
+.Sh STANDARDS
+The
+.Fn getprotoent ,
+.Fn getprotobynumber ,
+.Fn getprotobyname ,
+.Fn setprotoent ,
+and
+.Fn endprotoent
+functions conform to
+.St -p1003.1-2004 .
+.Pp
+The
+.Fn getprotoent_r ,
+.Fn getprotobyport_r ,
+.Fn getprotobyname_r ,
+.Fn setprotoent_r ,
+and
+.Fn endprotoent_r
+functions are not currently standardized.
+This implementation follows the API used by HP, IBM, and Digital.
+.Sh HISTORY
+The
+.Fn getprotoent ,
+.Fn getprotobynumber ,
+.Fn getprotobyname ,
+.Fn setprotoent ,
+and
+.Fn endprotoent
+functions appeared in
+.Bx 4.2 .
+.Pp
+The
+.Fn getprotoent_r ,
+.Fn getprotobyport_r ,
+.Fn getprotobyname_r ,
+.Fn setprotoent_r ,
+and
+.Fn endprotoent_r
+functions appeared in
+.Ox 3.7 .
+.Sh BUGS
+The non-reentrant functions use a static data space; if the data is needed
+for future use, it should be copied before any subsequent calls overwrite it.
+Only the Internet protocols are currently understood.
diff --git a/src/lib/libc/net/getprotoent.c b/src/lib/libc/net/getprotoent.c
new file mode 100644
index 0000000000..7c6ab68166
--- /dev/null
+++ b/src/lib/libc/net/getprotoent.c
@@ -0,0 +1,166 @@
+/*      $OpenBSD: getprotoent.c,v 1.9 2006/01/17 15:41:52 millert Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void
+setprotoent_r(int f, struct protoent_data *pd)
+{
+        if (pd->fp == NULL)
+                pd->fp = fopen(_PATH_PROTOCOLS, "r" );
+        else
+                rewind(pd->fp);
+        pd->stayopen |= f;
+}
+
+void
+endprotoent_r(struct protoent_data *pd)
+{
+        if (pd->fp) {
+                fclose(pd->fp);
+                pd->fp = NULL;
+        }
+        free(pd->aliases);
+        pd->aliases = NULL;
+        pd->maxaliases = 0;
+        free(pd->line);
+        pd->line = NULL;
+        pd->stayopen = 0;
+}
+
+int
+getprotoent_r(struct protoent *pe, struct protoent_data *pd)
+{
+        char *p, *cp, **q, *endp;
+        size_t len;
+        long l;
+        int serrno;
+
+        if (pd->fp == NULL && (pd->fp = fopen(_PATH_PROTOCOLS, "r" )) == NULL)
+                return (-1);
+again:
+        if ((p = fgetln(pd->fp, &len)) == NULL)
+                return (-1);
+        if (len == 0 || *p == '#' || *p == '\n')
+                goto again;
+        if (p[len-1] == '\n')
+                len--;
+        if ((cp = memchr(p, '#', len)) != NULL)
+                len = cp - p;
+        cp = realloc(pd->line, len + 1);
+        if (cp == NULL)
+                return (-1);
+        pd->line = pe->p_name = memcpy(cp, p, len);
+        cp[len] = '\0';
+        cp = strpbrk(cp, " \t");
+        if (cp == NULL)
+                goto again;
+        *cp++ = '\0';
+        while (*cp == ' ' || *cp == '\t')
+                cp++;
+        p = strpbrk(cp, " \t");
+        if (p != NULL)
+                *p++ = '\0';
+        l = strtol(cp, &endp, 10);
+        if (endp == cp || *endp != '\0' || l < 0 || l >= INT_MAX)
+                goto again;
+        pe->p_proto = l;
+        if (pd->aliases == NULL) {
+                pd->maxaliases = 5;
+                pd->aliases = malloc(pd->maxaliases * sizeof(char *));
+                if (pd->aliases == NULL) {
+                        serrno = errno;
+                        endprotoent_r(pd);
+                        errno = serrno;
+                        return (-1);
+                }
+        }
+        q = pe->p_aliases = pd->aliases;
+        if (p != NULL) {
+                cp = p;
+                while (cp && *cp) {
+                        if (*cp == ' ' || *cp == '\t') {
+                                cp++;
+                                continue;
+                        }
+                        if (q == &pe->p_aliases[pd->maxaliases - 1]) {
+                                p = realloc(pe->p_aliases,
+                                    2 * pd->maxaliases * sizeof(char *));
+                                if (p == NULL) {
+                                        serrno = errno;
+                                        endprotoent_r(pd);
+                                        errno = serrno;
+                                        return (-1);
+                                }
+                                pd->maxaliases *= 2;
+                                q = (char **)p + (q - pe->p_aliases);
+                                pe->p_aliases = pd->aliases = (char **)p;
+                        }
+                        *q++ = cp;
+                        cp = strpbrk(cp, " \t");
+                        if (cp != NULL)
+                                *cp++ = '\0';
+                }
+        }
+        *q = NULL;
+        return (0);
+}
+
+struct protoent_data _protoent_data;    /* shared with getproto{,name}.c */
+
+void
+setprotoent(int f)
+{
+        setprotoent_r(f, &_protoent_data);
+}
+
+void
+endprotoent(void)
+{
+        endprotoent_r(&_protoent_data);
+}
+
+struct protoent *
+getprotoent(void)
+{
+        static struct protoent proto;
+
+        if (getprotoent_r(&proto, &_protoent_data) != 0)
+                return (NULL);
+        return (&proto);
+}
diff --git a/src/lib/libc/net/getprotoname.c b/src/lib/libc/net/getprotoname.c
new file mode 100644
index 0000000000..749b6b3f13
--- /dev/null
+++ b/src/lib/libc/net/getprotoname.c
@@ -0,0 +1,67 @@
+/*      $OpenBSD: getprotoname.c,v 1.7 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+
+int
+getprotobyname_r(const char *name, struct protoent *pe,
+    struct protoent_data *pd)
+{
+        char **cp;
+        int error;
+
+        setprotoent_r(pd->stayopen, pd);
+        while ((error = getprotoent_r(pe, pd)) == 0) {
+                if (strcmp(pe->p_name, name) == 0)
+                        break;
+                for (cp = pe->p_aliases; *cp != 0; cp++)
+                        if (strcmp(*cp, name) == 0)
+                                goto found;
+        }
+found:
+        if (!pd->stayopen && pd->fp != NULL) {
+                fclose(pd->fp);
+                pd->fp = NULL;
+        }
+        return (error);
+}
+
+struct protoent *
+getprotobyname(const char *name)
+{
+        extern struct protoent_data _protoent_data;
+        static struct protoent proto;
+
+        if (getprotobyname_r(name, &proto, &_protoent_data) != 0)
+                return (NULL);
+        return (&proto);
+}
diff --git a/src/lib/libc/net/getrrsetbyname.3 b/src/lib/libc/net/getrrsetbyname.3
new file mode 100644
index 0000000000..c951f905ab
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.3
@@ -0,0 +1,166 @@
+.\" $OpenBSD: getrrsetbyname.3,v 1.14 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (C) 2000, 2001  Internet Software Consortium.
+.\"
+.\" 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 INTERNET SOFTWARE CONSORTIUM
+.\" DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+.\" INTERNET SOFTWARE CONSORTIUM 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.
+.\"
+.Dd October 18, 2000
+.Dt GETRRSETBYNAME 3
+.Os
+.Sh NAME
+.Nm freerrset ,
+.Nm getrrsetbyname
+.Nd retrieve DNS records
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft int
+.Fn getrrsetbyname "const char *hostname" "unsigned int rdclass" \
+"unsigned int rdtype" "unsigned int flags" "struct rrsetinfo **res"
+.Ft void
+.Fn freerrset "struct rrsetinfo *rrset"
+.Sh DESCRIPTION
+.Fn getrrsetbyname
+gets a set of resource records associated with a
+.Fa hostname ,
+.Fa rdclass ,
+and
+.Fa rdtype .
+.Fa hostname
+is a pointer to a NUL-terminated string.
+The
+.Fa flags
+field is currently unused and must be zero.
+.Pp
+After a successful call to
+.Fn getrrsetbyname ,
+.Fa *res
+is a pointer to an
+.Li rrsetinfo
+structure, containing a list of one or more
+.Li rdatainfo
+structures containing resource records and potentially another list of
+.Li rdatainfo
+structures containing SIG resource records associated with those records.
+The members
+.Li rri_rdclass
+and
+.Li rri_rdtype
+are copied from the parameters.
+.Li rri_ttl
+and
+.Li rri_name
+are properties of the obtained rrset.
+The resource records contained in
+.Li rri_rdatas
+and
+.Li rri_sigs
+are in uncompressed DNS wire format.
+Properties of the rdataset are represented in the
+.Li rri_flags
+bitfield.
+If the
+.Dv RRSET_VALIDATED
+bit is set, the data has been DNSSEC
+validated and the signatures verified.
+.Pp
+The following structures are used:
+.Bd -literal -offset indent
+struct  rdatainfo {
+        unsigned int    rdi_length;     /* length of data */
+        unsigned char   *rdi_data;      /* record data */
+};
+
+struct  rrsetinfo {
+        unsigned int     rri_flags;     /* RRSET_VALIDATED ... */
+        unsigned int     rri_rdclass;   /* class number */
+        unsigned int     rri_rdtype;    /* RR type number */
+        unsigned int     rri_ttl;       /* time to live */
+        unsigned int     rri_nrdatas;   /* size of rdatas array */
+        unsigned int     rri_nsigs;     /* size of sigs array */
+        char             *rri_name;     /* canonical name */
+        struct rdatainfo *rri_rdatas;   /* individual records */
+        struct rdatainfo *rri_sigs;     /* individual signatures */
+};
+.Ed
+.Pp
+All of the information returned by
+.Fn getrrsetbyname
+is dynamically allocated: the
+.Li rrsetinfo
+and
+.Li rdatainfo
+structures,
+and the canonical host name strings pointed to by the
+.Li rrsetinfo
+structure.
+Memory allocated for the dynamically allocated structures created by
+a successful call to
+.Fn getrrsetbyname
+is released by
+.Fn freerrset .
+.Li rrset
+is a pointer to a
+.Li struct rrsetinfo
+created by a call to
+.Fn getrrsetbyname .
+.Pp
+If the EDNS0 option is activated in
+.Xr resolv.conf 5 ,
+.Fn getrrsetbyname
+will request DNSSEC authentication using the EDNS0 DNSSEC OK (DO) bit.
+.Sh RETURN VALUES
+.Fn getrrsetbyname
+returns zero on success, and one of the following error
+codes if an error occurred:
+.Pp
+.Bl -tag -width ERRSET_NOMEMORY
+.It Bq Er ERRSET_NONAME
+The name does not exist.
+.It Bq Er ERRSET_NODATA
+The name exists, but does not have data of the desired type.
+.It Bq Er ERRSET_NOMEMORY
+Memory could not be allocated.
+.It Bq Er ERRSET_INVAL
+A parameter is invalid.
+.It Bq Er ERRSET_FAIL
+Other failure.
+.El
+.Sh SEE ALSO
+.Xr resolver 3 ,
+.Xr resolv.conf 5 ,
+.Xr named 8
+.Sh HISTORY
+.Fn getrrsetbyname
+first appeared in
+.Ox 3.0 .
+The API first appeared in ISC BIND version 9.
+.Sh AUTHORS
+.An Jakob Schlyter Aq jakob@openbsd.org
+.Sh CAVEATS
+The
+.Dv RRSET_VALIDATED
+flag in
+.Li rri_flags
+is set if the AD (authenticated data) bit in the DNS answer is
+set.
+This flag
+.Em should not
+be trusted unless the transport between the nameserver and the resolver
+is secure (e.g. IPsec, trusted network, loopback communication).
+.Sh BUGS
+The data in
+.Li *rdi_data
+should be returned in uncompressed wire format.
+Currently, the data is in compressed format and the caller can't
+uncompress since it doesn't have the full message.
diff --git a/src/lib/libc/net/getrrsetbyname.c b/src/lib/libc/net/getrrsetbyname.c
new file mode 100644
index 0000000000..e679eb5d96
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.c
@@ -0,0 +1,514 @@
+/* $OpenBSD: getrrsetbyname.c,v 1.10 2005/03/30 02:58:28 tedu Exp $ */
+
+/*
+ * Copyright (c) 2001 Jakob Schlyter. 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.
+ *
+ * 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.
+ */
+
+/*
+ * Portions Copyright (c) 1999-2001 Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM 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 <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "thread_private.h"
+
+#define ANSWER_BUFFER_SIZE 1024*64
+
+struct dns_query {
+        char                    *name;
+        u_int16_t               type;
+        u_int16_t               class;
+        struct dns_query        *next;
+};
+
+struct dns_rr {
+        char                    *name;
+        u_int16_t               type;
+        u_int16_t               class;
+        u_int16_t               ttl;
+        u_int16_t               size;
+        void                    *rdata;
+        struct dns_rr           *next;
+};
+
+struct dns_response {
+        HEADER                  header;
+        struct dns_query        *query;
+        struct dns_rr           *answer;
+        struct dns_rr           *authority;
+        struct dns_rr           *additional;
+};
+
+static struct dns_response *parse_dns_response(const u_char *, int);
+static struct dns_query *parse_dns_qsection(const u_char *, int,
+    const u_char **, int);
+static struct dns_rr *parse_dns_rrsection(const u_char *, int, const u_char **,
+    int);
+
+static void free_dns_query(struct dns_query *);
+static void free_dns_rr(struct dns_rr *);
+static void free_dns_response(struct dns_response *);
+
+static int count_dns_rr(struct dns_rr *, u_int16_t, u_int16_t);
+
+int
+getrrsetbyname(const char *hostname, unsigned int rdclass,
+    unsigned int rdtype, unsigned int flags,
+    struct rrsetinfo **res)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int result;
+        struct rrsetinfo *rrset = NULL;
+        struct dns_response *response = NULL;
+        struct dns_rr *rr;
+        struct rdatainfo *rdata;
+        int length;
+        unsigned int index_ans, index_sig;
+        u_char answer[ANSWER_BUFFER_SIZE];
+
+        /* check for invalid class and type */
+        if (rdclass > 0xffff || rdtype > 0xffff) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* don't allow queries of class or type ANY */
+        if (rdclass == 0xff || rdtype == 0xff) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* don't allow flags yet, unimplemented */
+        if (flags) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* initialize resolver */
+        if (_res_init(0) == -1) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+#ifdef DEBUG
+        _resp->options |= RES_DEBUG;
+#endif /* DEBUG */
+
+#ifdef RES_USE_DNSSEC
+        /* turn on DNSSEC if EDNS0 is configured */
+        if (_resp->options & RES_USE_EDNS0)
+                _resp->options |= RES_USE_DNSSEC;
+#endif /* RES_USE_DNSEC */
+
+        /* make query */
+        length = res_query(hostname, (signed int) rdclass, (signed int) rdtype,
+            answer, sizeof(answer));
+        if (length < 0) {
+                switch(h_errno) {
+                case HOST_NOT_FOUND:
+                        result = ERRSET_NONAME;
+                        goto fail;
+                case NO_DATA:
+                        result = ERRSET_NODATA;
+                        goto fail;
+                default:
+                        result = ERRSET_FAIL;
+                        goto fail;
+                }
+        }
+
+        /* parse result */
+        response = parse_dns_response(answer, length);
+        if (response == NULL) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+        if (response->header.qdcount != 1) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+        /* initialize rrset */
+        rrset = calloc(1, sizeof(struct rrsetinfo));
+        if (rrset == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+        rrset->rri_rdclass = response->query->class;
+        rrset->rri_rdtype = response->query->type;
+        rrset->rri_ttl = response->answer->ttl;
+        rrset->rri_nrdatas = response->header.ancount;
+
+        /* check for authenticated data */
+        if (response->header.ad == 1)
+                rrset->rri_flags |= RRSET_VALIDATED;
+
+        /* copy name from answer section */
+        rrset->rri_name = strdup(response->answer->name);
+        if (rrset->rri_name == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+
+        /* count answers */
+        rrset->rri_nrdatas = count_dns_rr(response->answer, rrset->rri_rdclass,
+            rrset->rri_rdtype);
+        rrset->rri_nsigs = count_dns_rr(response->answer, rrset->rri_rdclass,
+            T_SIG);
+
+        /* allocate memory for answers */
+        rrset->rri_rdatas = calloc(rrset->rri_nrdatas,
+            sizeof(struct rdatainfo));
+        if (rrset->rri_rdatas == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+
+        /* allocate memory for signatures */
+        rrset->rri_sigs = calloc(rrset->rri_nsigs, sizeof(struct rdatainfo));
+        if (rrset->rri_sigs == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+
+        /* copy answers & signatures */
+        for (rr = response->answer, index_ans = 0, index_sig = 0;
+            rr; rr = rr->next) {
+
+                rdata = NULL;
+
+                if (rr->class == rrset->rri_rdclass &&
+                    rr->type  == rrset->rri_rdtype)
+                        rdata = &rrset->rri_rdatas[index_ans++];
+
+                if (rr->class == rrset->rri_rdclass &&
+                    rr->type  == T_SIG)
+                        rdata = &rrset->rri_sigs[index_sig++];
+
+                if (rdata) {
+                        rdata->rdi_length = rr->size;
+                        rdata->rdi_data   = malloc(rr->size);
+
+                        if (rdata->rdi_data == NULL) {
+                                result = ERRSET_NOMEMORY;
+                                goto fail;
+                        }
+                        memcpy(rdata->rdi_data, rr->rdata, rr->size);
+                }
+        }
+        free_dns_response(response);
+
+        *res = rrset;
+        return (ERRSET_SUCCESS);
+
+fail:
+        if (rrset != NULL)
+                freerrset(rrset);
+        if (response != NULL)
+                free_dns_response(response);
+        return (result);
+}
+
+void
+freerrset(struct rrsetinfo *rrset)
+{
+        u_int16_t i;
+
+        if (rrset == NULL)
+                return;
+
+        if (rrset->rri_rdatas) {
+                for (i = 0; i < rrset->rri_nrdatas; i++) {
+                        if (rrset->rri_rdatas[i].rdi_data == NULL)
+                                break;
+                        free(rrset->rri_rdatas[i].rdi_data);
+                }
+                free(rrset->rri_rdatas);
+        }
+
+        if (rrset->rri_sigs) {
+                for (i = 0; i < rrset->rri_nsigs; i++) {
+                        if (rrset->rri_sigs[i].rdi_data == NULL)
+                                break;
+                        free(rrset->rri_sigs[i].rdi_data);
+                }
+                free(rrset->rri_sigs);
+        }
+
+        if (rrset->rri_name)
+                free(rrset->rri_name);
+        free(rrset);
+}
+
+/*
+ * DNS response parsing routines
+ */
+static struct dns_response *
+parse_dns_response(const u_char *answer, int size)
+{
+        struct dns_response *resp;
+        const u_char *cp;
+
+        /* allocate memory for the response */
+        resp = calloc(1, sizeof(*resp));
+        if (resp == NULL)
+                return (NULL);
+
+        /* initialize current pointer */
+        cp = answer;
+
+        /* copy header */
+        memcpy(&resp->header, cp, HFIXEDSZ);
+        cp += HFIXEDSZ;
+
+        /* fix header byte order */
+        resp->header.qdcount = ntohs(resp->header.qdcount);
+        resp->header.ancount = ntohs(resp->header.ancount);
+        resp->header.nscount = ntohs(resp->header.nscount);
+        resp->header.arcount = ntohs(resp->header.arcount);
+
+        /* there must be at least one query */
+        if (resp->header.qdcount < 1) {
+                free_dns_response(resp);
+                return (NULL);
+        }
+
+        /* parse query section */
+        resp->query = parse_dns_qsection(answer, size, &cp,
+            resp->header.qdcount);
+        if (resp->header.qdcount && resp->query == NULL) {
+                free_dns_response(resp);
+                return (NULL);
+        }
+
+        /* parse answer section */
+        resp->answer = parse_dns_rrsection(answer, size, &cp,
+            resp->header.ancount);
+        if (resp->header.ancount && resp->answer == NULL) {
+                free_dns_response(resp);
+                return (NULL);
+        }
+
+        /* parse authority section */
+        resp->authority = parse_dns_rrsection(answer, size, &cp,
+            resp->header.nscount);
+        if (resp->header.nscount && resp->authority == NULL) {
+                free_dns_response(resp);
+                return (NULL);
+        }
+
+        /* parse additional section */
+        resp->additional = parse_dns_rrsection(answer, size, &cp,
+            resp->header.arcount);
+        if (resp->header.arcount && resp->additional == NULL) {
+                free_dns_response(resp);
+                return (NULL);
+        }
+
+        return (resp);
+}
+
+static struct dns_query *
+parse_dns_qsection(const u_char *answer, int size, const u_char **cp, int count)
+{
+        struct dns_query *head, *curr, *prev;
+        int i, length;
+        char name[MAXDNAME];
+
+        for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
+
+                /* allocate and initialize struct */
+                curr = calloc(1, sizeof(struct dns_query));
+                if (curr == NULL) {
+                        free_dns_query(head);
+                        return (NULL);
+                }
+                if (head == NULL)
+                        head = curr;
+                if (prev != NULL)
+                        prev->next = curr;
+
+                /* name */
+                length = dn_expand(answer, answer + size, *cp, name,
+                    sizeof(name));
+                if (length < 0) {
+                        free_dns_query(head);
+                        return (NULL);
+                }
+                curr->name = strdup(name);
+                if (curr->name == NULL) {
+                        free_dns_query(head);
+                        return (NULL);
+                }
+                *cp += length;
+
+                /* type */
+                curr->type = _getshort(*cp);
+                *cp += INT16SZ;
+
+                /* class */
+                curr->class = _getshort(*cp);
+                *cp += INT16SZ;
+        }
+
+        return (head);
+}
+
+static struct dns_rr *
+parse_dns_rrsection(const u_char *answer, int size, const u_char **cp,
+    int count)
+{
+        struct dns_rr *head, *curr, *prev;
+        int i, length;
+        char name[MAXDNAME];
+
+        for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
+
+                /* allocate and initialize struct */
+                curr = calloc(1, sizeof(struct dns_rr));
+                if (curr == NULL) {
+                        free_dns_rr(head);
+                        return (NULL);
+                }
+                if (head == NULL)
+                        head = curr;
+                if (prev != NULL)
+                        prev->next = curr;
+
+                /* name */
+                length = dn_expand(answer, answer + size, *cp, name,
+                    sizeof(name));
+                if (length < 0) {
+                        free_dns_rr(head);
+                        return (NULL);
+                }
+                curr->name = strdup(name);
+                if (curr->name == NULL) {
+                        free_dns_rr(head);
+                        return (NULL);
+                }
+                *cp += length;
+
+                /* type */
+                curr->type = _getshort(*cp);
+                *cp += INT16SZ;
+
+                /* class */
+                curr->class = _getshort(*cp);
+                *cp += INT16SZ;
+
+                /* ttl */
+                curr->ttl = _getlong(*cp);
+                *cp += INT32SZ;
+
+                /* rdata size */
+                curr->size = _getshort(*cp);
+                *cp += INT16SZ;
+
+                /* rdata itself */
+                curr->rdata = malloc(curr->size);
+                if (curr->rdata == NULL) {
+                        free_dns_rr(head);
+                        return (NULL);
+                }
+                memcpy(curr->rdata, *cp, curr->size);
+                *cp += curr->size;
+        }
+
+        return (head);
+}
+
+static void
+free_dns_query(struct dns_query *p)
+{
+        if (p == NULL)
+                return;
+
+        if (p->name)
+                free(p->name);
+        free_dns_query(p->next);
+        free(p);
+}
+
+static void
+free_dns_rr(struct dns_rr *p)
+{
+        if (p == NULL)
+                return;
+
+        if (p->name)
+                free(p->name);
+        if (p->rdata)
+                free(p->rdata);
+        free_dns_rr(p->next);
+        free(p);
+}
+
+static void
+free_dns_response(struct dns_response *p)
+{
+        if (p == NULL)
+                return;
+
+        free_dns_query(p->query);
+        free_dns_rr(p->answer);
+        free_dns_rr(p->authority);
+        free_dns_rr(p->additional);
+        free(p);
+}
+
+static int
+count_dns_rr(struct dns_rr *p, u_int16_t class, u_int16_t type)
+{
+        int n = 0;
+
+        while(p) {
+                if (p->class == class && p->type == type)
+                        n++;
+                p = p->next;
+        }
+
+        return (n);
+}
diff --git a/src/lib/libc/net/getservbyname.c b/src/lib/libc/net/getservbyname.c
new file mode 100644
index 0000000000..beb8943af6
--- /dev/null
+++ b/src/lib/libc/net/getservbyname.c
@@ -0,0 +1,70 @@
+/*      $OpenBSD: getservbyname.c,v 1.10 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+
+int
+getservbyname_r(const char *name, const char *proto, struct servent *se,
+    struct servent_data *sd)
+{
+        char **cp;
+        int error;
+
+        setservent_r(sd->stayopen, sd);
+        while ((error = getservent_r(se, sd)) == 0) {
+                if (strcmp(name, se->s_name) == 0)
+                        goto gotname;
+                for (cp = se->s_aliases; *cp; cp++)
+                        if (strcmp(name, *cp) == 0)
+                                goto gotname;
+                continue;
+gotname:
+                if (proto == 0 || strcmp(se->s_proto, proto) == 0)
+                        break;
+        }
+        if (!sd->stayopen && sd->fp != NULL) {
+                fclose(sd->fp);
+                sd->fp = NULL;
+        }
+        return (error);
+}
+
+struct servent *
+getservbyname(const char *name, const char *proto)
+{
+        extern struct servent_data _servent_data;
+        static struct servent serv;
+
+        if (getservbyname_r(name, proto, &serv, &_servent_data) != 0)
+                return (NULL);
+        return (&serv);
+}
diff --git a/src/lib/libc/net/getservbyport.c b/src/lib/libc/net/getservbyport.c
new file mode 100644
index 0000000000..46679ba366
--- /dev/null
+++ b/src/lib/libc/net/getservbyport.c
@@ -0,0 +1,64 @@
+/*      $OpenBSD: getservbyport.c,v 1.7 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+
+int
+getservbyport_r(int port, const char *proto, struct servent *se,
+    struct servent_data *sd)
+{
+        int error;
+
+        setservent_r(sd->stayopen, sd);
+        while ((error = getservent_r(se, sd)) == 0) {
+                if (se->s_port != port)
+                        continue;
+                if (proto == 0 || strcmp(se->s_proto, proto) == 0)
+                        break;
+        }
+        if (!sd->stayopen && sd->fp != NULL) {
+                fclose(sd->fp);
+                sd->fp = NULL;
+        }
+        return (error);
+}
+
+struct servent *
+getservbyport(int port, const char *proto)
+{
+        extern struct servent_data _servent_data;
+        static struct servent serv;
+
+        if (getservbyport_r(port, proto, &serv, &_servent_data) != 0)
+                return (NULL);
+        return (&serv);
+}
diff --git a/src/lib/libc/net/getservent.3 b/src/lib/libc/net/getservent.3
new file mode 100644
index 0000000000..839d89de6c
--- /dev/null
+++ b/src/lib/libc/net/getservent.3
@@ -0,0 +1,220 @@
+.\"     $OpenBSD: getservent.3,v 1.19 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd October 13, 2004
+.Dt GETSERVENT 3
+.Os
+.Sh NAME
+.Nm getservent ,
+.Nm getservent_r ,
+.Nm getservbyport ,
+.Nm getservbyport_r ,
+.Nm getservbyname ,
+.Nm getservbyname_r ,
+.Nm setservent ,
+.Nm setservent_r ,
+.Nm endservent ,
+.Nm endservent_r
+.Nd get service entry
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft struct servent *
+.Fn getservent "void"
+.Ft int
+.Fn getservent_r "struct servent *servent" "struct servent_data *servent_data"
+.Ft struct servent *
+.Fn getservbyname "const char *name" "const char *proto"
+.Ft int
+.Fn getservbyname_r "const char *name" "const char *proto" "struct servent *servent" "struct servent_data *servent_data"
+.Ft struct servent *
+.Fn getservbyport "int port" "const char *proto"
+.Ft int
+.Fn getservbyport_r "int port" "const char *proto" "struct servent *servent" "struct servent_data *servent_data"
+.Ft void
+.Fn setservent "int stayopen"
+.Ft void
+.Fn setservent_r "int stayopen" "struct servent_data *servent_data"
+.Ft void
+.Fn endservent "void"
+.Ft void
+.Fn endservent_r "struct servent_data *servent_data"
+.Sh DESCRIPTION
+The
+.Fn getservent ,
+.Fn getservbyname ,
+and
+.Fn getservbyport
+functions each return a pointer to an object with the following structure
+containing the broken-out fields of a line in the network services database,
+.Pa /etc/services .
+.Bd -literal -offset indent
+struct  servent {
+        char    *s_name;        /* official name of service */
+        char    **s_aliases;    /* alias list */
+        int     s_port;         /* port service resides at */
+        char    *s_proto;       /* protocol to use */
+};
+.Ed
+.Pp
+The members of this structure are:
+.Bl -tag -width s_aliases
+.It Fa s_name
+The official name of the service.
+.It Fa s_aliases
+A null-terminated list of alternate names for the service.
+.It Fa s_port
+The port number at which the service resides.
+Port numbers are returned in network byte order.
+.It Fa s_proto
+The name of the protocol to use when contacting the service.
+.El
+.Pp
+The
+.Fn getservent
+function reads the next line of the file, opening the file if necessary.
+.Pp
+The
+.Fn setservent
+function opens and rewinds the file.
+If the
+.Fa stayopen
+flag is non-zero,
+the services database will not be closed after each call to
+.Fn getservbyname
+or
+.Fn getservbyport .
+.Pp
+The
+.Fn endservent
+function closes the file.
+.Pp
+The
+.Fn getservbyname
+and
+.Fn getservbyport
+functions sequentially search from the beginning of the file until a
+matching protocol name or port number (specified in network byte order)
+is found, or until
+.Dv EOF
+is encountered.
+If a protocol name is also supplied (non-null),
+searches must also match the protocol.
+.Pp
+The
+.Fn getservent_r ,
+.Fn getservbyport_r ,
+.Fn getservbyname_r ,
+.Fn setservent_r ,
+and
+.Fn endservent_r
+functions are reentrant versions of the above functions that take a
+pointer to a
+.Fa servent_data
+structure which is used to store state information.
+The structure must be zero-filled before it is used
+and should be considered opaque for the sake of portability.
+.Pp
+The
+.Fn getservent_r ,
+.Fn getservbyport_r ,
+and
+.Fn getservbyname_r
+functions
+also take a pointer to a
+.Fa servent
+structure which is used to store the results of the database lookup.
+.Sh RETURN VALUES
+The
+.Fn getservent ,
+.Fn getservbyport ,
+and
+.Fn getservbyname
+functions return a pointer to a
+.Fa servent
+structure on success or a null pointer if end-of-file
+is reached or an error occurs.
+.Pp
+The
+.Fn getservent_r ,
+.Fn getservbyport_r ,
+and
+.Fn getservbyname_r
+functions return 0 on success or \-1 if end-of-file
+is reached or an error occurs.
+.Sh FILES
+.Bl -tag -width /etc/services -compact
+.It Pa /etc/services
+.El
+.Sh SEE ALSO
+.Xr getprotoent 3 ,
+.Xr services 5
+.Sh STANDARDS
+The
+.Fn getservent ,
+.Fn getservbynumber ,
+.Fn getservbyname ,
+.Fn setservent ,
+and
+.Fn endservent
+functions conform to
+.St -p1003.1-2004 .
+.Pp
+The
+.Fn getservent_r ,
+.Fn getservbyport_r ,
+.Fn getservbyname_r ,
+.Fn setservent_r ,
+and
+.Fn endservent_r
+functions are not currently standardized.
+This implementation follows the API used by HP, IBM, and Digital.
+.Sh HISTORY
+The
+.Fn getservent ,
+.Fn getservbyport ,
+.Fn getservbyname ,
+.Fn setservent ,
+and
+.Fn endservent
+functions appeared in
+.Bx 4.2 .
+.Pp
+The
+.Fn getservent_r ,
+.Fn getservbyport_r ,
+.Fn getservbyname_r ,
+.Fn setservent_r ,
+and
+.Fn endservent_r
+functions appeared in
+.Ox 3.7 .
+.Sh BUGS
+The non-reentrant functions use static data storage; if the data is needed
+for future use, it should be copied before any subsequent calls overwrite it.
+Expecting port numbers to fit in a 32-bit quantity is probably naive.
diff --git a/src/lib/libc/net/getservent.c b/src/lib/libc/net/getservent.c
new file mode 100644
index 0000000000..ab916b8e80
--- /dev/null
+++ b/src/lib/libc/net/getservent.c
@@ -0,0 +1,168 @@
+/*      $OpenBSD: getservent.c,v 1.11 2006/01/17 15:41:52 millert Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+void
+setservent_r(int f, struct servent_data *sd)
+{
+        if (sd->fp == NULL)
+                sd->fp = fopen(_PATH_SERVICES, "r" );
+        else
+                rewind(sd->fp);
+        sd->stayopen |= f;
+}
+
+void
+endservent_r(struct servent_data *sd)
+{
+        if (sd->fp) {
+                fclose(sd->fp);
+                sd->fp = NULL;
+        }
+        free(sd->aliases);
+        sd->aliases = NULL;
+        sd->maxaliases = 0;
+        free(sd->line);
+        sd->line = NULL;
+        sd->stayopen = 0;
+}
+
+int
+getservent_r(struct servent *se, struct servent_data *sd)
+{
+        char *p, *cp, **q, *endp;
+        size_t len;
+        long l;
+        int serrno;
+
+        if (sd->fp == NULL && (sd->fp = fopen(_PATH_SERVICES, "r" )) == NULL)
+                return (-1);
+again:
+        if ((p = fgetln(sd->fp, &len)) == NULL)
+                return (-1);
+        if (len == 0 || *p == '#' || *p == '\n')
+                goto again;
+        if (p[len-1] == '\n')
+                len--;
+        if ((cp = memchr(p, '#', len)) != NULL)
+                len = cp - p;
+        cp = realloc(sd->line, len + 1);
+        if (cp == NULL)
+                return (-1);
+        sd->line = se->s_name = memcpy(cp, p, len);
+        cp[len] = '\0';
+        p = strpbrk(cp, " \t");
+        if (p == NULL)
+                goto again;
+        *p++ = '\0';
+        while (*p == ' ' || *p == '\t')
+                p++;
+        cp = strpbrk(p, ",/");
+        if (cp == NULL)
+                goto again;
+        *cp++ = '\0';
+        l = strtol(p, &endp, 10);
+        if (endp == p || *endp != '\0' || l < 0 || l > USHRT_MAX)
+                goto again;
+        se->s_port = htons((in_port_t)l);
+        se->s_proto = cp;
+        if (sd->aliases == NULL) {
+                sd->maxaliases = 10;
+                sd->aliases = malloc(sd->maxaliases * sizeof(char *));
+                if (sd->aliases == NULL) {
+                        serrno = errno;
+                        endservent_r(sd);
+                        errno = serrno;
+                        return (-1);
+                }
+        }
+        q = se->s_aliases = sd->aliases;
+        cp = strpbrk(cp, " \t");
+        if (cp != NULL)
+                *cp++ = '\0';
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (q == &se->s_aliases[sd->maxaliases - 1]) {
+                        p = realloc(se->s_aliases,
+                            2 * sd->maxaliases * sizeof(char *));
+                        if (p == NULL) {
+                                serrno = errno;
+                                endservent_r(sd);
+                                errno = serrno;
+                                return (-1);
+                        }
+                        sd->maxaliases *= 2;
+                        q = (char **)p + (q - se->s_aliases);
+                        se->s_aliases = sd->aliases = (char **)p;
+                }
+                *q++ = cp;
+                cp = strpbrk(cp, " \t");
+                if (cp != NULL)
+                        *cp++ = '\0';
+        }
+        *q = NULL;
+        return (0);
+}
+
+struct servent_data _servent_data;      /* shared with getservby{name,port}.c */
+
+void
+setservent(int f)
+{
+        setservent_r(f, &_servent_data);
+}
+
+void
+endservent(void)
+{
+        endservent_r(&_servent_data);
+}
+
+struct servent *
+getservent(void)
+{
+        static struct servent serv;
+
+        if (getservent_r(&serv, &_servent_data) != 0)
+                return (NULL);
+        return (&serv);
+}
diff --git a/src/lib/libc/net/herror.c b/src/lib/libc/net/herror.c
new file mode 100644
index 0000000000..7787115a9d
--- /dev/null
+++ b/src/lib/libc/net/herror.c
@@ -0,0 +1,106 @@
+/*      $OpenBSD: herror.c,v 1.8 2005/08/06 20:30:03 espie Exp $        */
+
+/*
+ * ++Copyright++ 1987, 1993
+ * -
+ * Copyright (c) 1987, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/uio.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <string.h>
+
+const char * const h_errlist[] = {
+        "Resolver Error 0 (no error)",
+        "Unknown host",                         /* 1 HOST_NOT_FOUND */
+        "Host name lookup failure",             /* 2 TRY_AGAIN */
+        "Unknown server error",                 /* 3 NO_RECOVERY */
+        "No address associated with name",      /* 4 NO_ADDRESS */
+};
+const int       h_nerr = { sizeof h_errlist / sizeof h_errlist[0] };
+
+extern int      h_errno;
+
+/*
+ * herror --
+ *      print the error indicated by the h_errno value.
+ */
+void
+herror(const char *s)
+{
+        struct iovec iov[4];
+        struct iovec *v = iov;
+
+        if (s && *s) {
+                v->iov_base = (char *)s;
+                v->iov_len = strlen(s);
+                v++;
+                v->iov_base = ": ";
+                v->iov_len = 2;
+                v++;
+        }
+        v->iov_base = (char *)hstrerror(h_errno);
+        v->iov_len = strlen(v->iov_base);
+        v++;
+        v->iov_base = "\n";
+        v->iov_len = 1;
+        writev(STDERR_FILENO, iov, (v - iov) + 1);
+}
+
+const char *
+hstrerror(int err)
+{
+        if (err < 0)
+                return ("Resolver internal error");
+        else if (err < h_nerr)
+                return (h_errlist[err]);
+        return ("Unknown resolver error");
+}
diff --git a/src/lib/libc/net/htonl.c b/src/lib/libc/net/htonl.c
new file mode 100644
index 0000000000..5ab4189597
--- /dev/null
+++ b/src/lib/libc/net/htonl.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: htonl.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <sys/types.h>
+#include <machine/endian.h>
+
+#undef htonl
+
+u_int32_t
+htonl(u_int32_t x)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+        u_char *s = (u_char *)&x;
+        return (u_int32_t)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
+#else
+        return x;
+#endif
+}
diff --git a/src/lib/libc/net/htons.c b/src/lib/libc/net/htons.c
new file mode 100644
index 0000000000..c8b73fdbb7
--- /dev/null
+++ b/src/lib/libc/net/htons.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: htons.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <sys/types.h>
+#include <machine/endian.h>
+
+#undef htons
+
+u_int16_t
+htons(u_int16_t x)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+        u_char *s = (u_char *) &x;
+        return (u_int16_t)(s[0] << 8 | s[1]);
+#else
+        return x;
+#endif
+}
diff --git a/src/lib/libc/net/if_indextoname.3 b/src/lib/libc/net/if_indextoname.3
new file mode 100644
index 0000000000..da2330b861
--- /dev/null
+++ b/src/lib/libc/net/if_indextoname.3
@@ -0,0 +1,144 @@
+.\"     $OpenBSD: if_indextoname.3,v 1.10 2005/12/30 20:45:59 claudio Exp $
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.\"     From: @(#)rcmd.3        8.1 (Berkeley) 6/4/93
+.\"
+.Dd May 21, 1998
+.Dt IF_NAMETOINDEX 3
+.Os
+.Sh NAME
+.Nm if_nametoindex ,
+.Nm if_indextoname ,
+.Nm if_nameindex ,
+.Nm if_freenameindex
+.Nd convert interface index to name, and vice versa
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <net/if.h>
+.Ft "unsigned int"
+.Fn if_nametoindex "const char *ifname"
+.Ft "char *"
+.Fn if_indextoname "unsigned int ifindex" "char *ifname"
+.Ft "struct if_nameindex *"
+.Fn if_nameindex "void"
+.Ft "void"
+.Fn if_freenameindex "struct if_nameindex *ptr"
+.Sh DESCRIPTION
+These functions map interface indexes to interface names (such as
+.Dq lo0 ) ,
+and vice versa.
+.Pp
+The
+.Fn if_nametoindex
+function converts an interface name specified by the
+.Fa ifname
+argument to an interface index (positive integer value).
+If the specified interface does not exist, 0 will be returned.
+.Pp
+.Fn if_indextoname
+converts an interface index specified by the
+.Fa ifindex
+argument to an interface name.
+The
+.Fa ifname
+argument must point to a buffer of at least
+.Dv IF_NAMESIZE
+bytes into which the interface name corresponding to the specified index is
+returned.
+.Pf ( Dv IF_NAMESIZE
+is also defined in
+.Aq Pa net/if.h
+and its value includes a terminating NUL byte at the end of the
+interface name.)
+This pointer is also the return value of the function.
+If there is no interface corresponding to the specified index,
+.Dv NULL
+is returned.
+.Pp
+.Fn if_nameindex
+returns an array of
+.Vt if_nameindex
+structures.
+.Vt if_nameindex
+is also defined in
+.Aq Pa net/if.h ,
+and is as follows:
+.Bd -literal -offset indent
+struct if_nameindex {
+        unsigned int      if_index;     /* 1, 2, ... */
+        char             *if_name;      /* NUL-terminated name */
+};
+.Ed
+.Pp
+The end of the array of structures is indicated by a structure with
+an
+.Fa if_index
+of 0 and an
+.Fa if_name
+of
+.Dv NULL .
+The function returns a null pointer on error.
+The memory used for this array of structures along with the interface
+names pointed to by the
+.Fa if_name
+members is obtained dynamically.
+This memory is freed by the
+.Fn if_freenameindex
+function.
+.Pp
+.Fn if_freenameindex
+takes a pointer that was returned by
+.Fn if_nameindex
+as argument
+.Pq Fa ptr ,
+and it reclaims the region allocated.
+.Sh DIAGNOSTICS
+.Fn if_nametoindex
+returns 0 on error, positive integer on success.
+.Fn if_indextoname
+and
+.Fn if_nameindex
+return
+.Dv NULL
+on errors.
+.Sh SEE ALSO
+.Xr getifaddrs 3 ,
+.Xr networking 4
+.Rs
+.%A R. Gilligan
+.%A S. Thomson
+.%A J. Bound
+.%A W. Stevens
+.%T Basic Socket Interface Extensions for IPv6
+.%R RFC 2553
+.%D March 1999
+.Re
+.Sh STANDARDS
+These functions are defined in ``Basic Socket Interface Extensions for IPv6''
+.Pq RFC 2533 .
diff --git a/src/lib/libc/net/if_indextoname.c b/src/lib/libc/net/if_indextoname.c
new file mode 100644
index 0000000000..f99e52e387
--- /dev/null
+++ b/src/lib/libc/net/if_indextoname.c
@@ -0,0 +1,86 @@
+/*      $OpenBSD: if_indextoname.c,v 1.9 2002/03/07 22:40:23 millert Exp $      */
+/*      $KAME: if_indextoname.c,v 1.6 2000/11/07 22:33:25 jinmei Exp $  */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+ *
+ *      BSDI Id: if_indextoname.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * From RFC 2533:
+ *
+ * The second function maps an interface index into its corresponding
+ * name.
+ *
+ *    #include <net/if.h>
+ *
+ *    char  *if_indextoname(unsigned int ifindex, char *ifname);
+ *
+ * The ifname argument must point to a buffer of at least IF_NAMESIZE
+ * bytes into which the interface name corresponding to the specified
+ * index is returned.  (IF_NAMESIZE is also defined in <net/if.h> and
+ * its value includes a terminating null byte at the end of the
+ * interface name.) This pointer is also the return value of the
+ * function.  If there is no interface corresponding to the specified
+ * index, NULL is returned, and errno is set to ENXIO, if there was a
+ * system error (such as running out of memory), if_indextoname returns
+ * NULL and errno would be set to the proper value (e.g., ENOMEM).
+ */
+
+char *
+if_indextoname(unsigned int ifindex, char *ifname)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        int error = 0;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(NULL);   /* getifaddrs properly set errno */
+
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK &&
+                    ifindex == ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index)
+                        break;
+        }
+
+        if (ifa == NULL) {
+                error = ENXIO;
+                ifname = NULL;
+        }
+        else
+                strlcpy(ifname, ifa->ifa_name, IFNAMSIZ);
+
+        freeifaddrs(ifaddrs);
+
+        errno = error;
+        return(ifname);
+}
diff --git a/src/lib/libc/net/if_nameindex.c b/src/lib/libc/net/if_nameindex.c
new file mode 100644
index 0000000000..3675a2a450
--- /dev/null
+++ b/src/lib/libc/net/if_nameindex.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: if_nameindex.c,v 1.9 2002/03/07 22:40:23 millert Exp $        */
+/*      $KAME: if_nameindex.c,v 1.7 2000/11/24 08:17:20 itojun Exp $    */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+ *
+ *      BSDI Id: if_nameindex.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * From RFC 2553:
+ *
+ * 4.3 Return All Interface Names and Indexes
+ *
+ *    The if_nameindex structure holds the information about a single
+ *    interface and is defined as a result of including the <net/if.h>
+ *    header.
+ *
+ *       struct if_nameindex {
+ *         unsigned int   if_index;
+ *         char          *if_name;
+ *       };
+ *
+ *    The final function returns an array of if_nameindex structures, one
+ *    structure per interface.
+ *
+ *       struct if_nameindex  *if_nameindex(void);
+ *
+ *    The end of the array of structures is indicated by a structure with
+ *    an if_index of 0 and an if_name of NULL.  The function returns a NULL
+ *    pointer upon an error, and would set errno to the appropriate value.
+ *
+ *    The memory used for this array of structures along with the interface
+ *    names pointed to by the if_name members is obtained dynamically.
+ *    This memory is freed by the next function.
+ *
+ * 4.4.  Free Memory
+ *
+ *    The following function frees the dynamic memory that was allocated by
+ *    if_nameindex().
+ *
+ *        #include <net/if.h>
+ *
+ *        void  if_freenameindex(struct if_nameindex *ptr);
+ *
+ *    The argument to this function must be a pointer that was returned by
+ *    if_nameindex().
+ */
+
+struct if_nameindex *
+if_nameindex(void)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        unsigned int ni;
+        size_t nbytes;
+        struct if_nameindex *ifni, *ifni2;
+        char *cp;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(NULL);
+
+        /*
+         * First, find out how many interfaces there are, and how
+         * much space we need for the string names.
+         */
+        ni = 0;
+        nbytes = 0;
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK) {
+                        nbytes += strlen(ifa->ifa_name) + 1;
+                        ni++;
+                }
+        }
+
+        /*
+         * Next, allocate a chunk of memory, use the first part
+         * for the array of structures, and the last part for
+         * the strings.
+         */
+        cp = malloc((ni + 1) * sizeof(struct if_nameindex) + nbytes);
+        ifni = (struct if_nameindex *)cp;
+        if (ifni == NULL)
+                goto out;
+        cp += (ni + 1) * sizeof(struct if_nameindex);
+
+        /*
+         * Now just loop through the list of interfaces again,
+         * filling in the if_nameindex array and making copies
+         * of all the strings.
+         */
+        ifni2 = ifni;
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK) {
+                        ifni2->if_index =
+                            ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index;
+                        ifni2->if_name = cp;
+                        nbytes = strlen(ifa->ifa_name) + 1;
+                        memcpy(cp, ifa->ifa_name, nbytes);
+                        ifni2++;
+                        cp += nbytes;
+                }
+        }
+        /*
+         * Finally, don't forget to terminate the array.
+         */
+        ifni2->if_index = 0;
+        ifni2->if_name = NULL;
+out:
+        freeifaddrs(ifaddrs);
+        return(ifni);
+}
diff --git a/src/lib/libc/net/if_nametoindex.c b/src/lib/libc/net/if_nametoindex.c
new file mode 100644
index 0000000000..8bd792b949
--- /dev/null
+++ b/src/lib/libc/net/if_nametoindex.c
@@ -0,0 +1,81 @@
+/*      $OpenBSD: if_nametoindex.c,v 1.8 2002/03/07 22:40:23 millert Exp $      */
+/*      $KAME: if_nametoindex.c,v 1.5 2000/11/24 08:04:40 itojun Exp $  */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+ *
+ *      BSDI Id: if_nametoindex.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * From RFC 2553:
+ *
+ * 4.1 Name-to-Index
+ *
+ *
+ *    The first function maps an interface name into its corresponding
+ *    index.
+ *
+ *       #include <net/if.h>
+ *
+ *       unsigned int  if_nametoindex(const char *ifname);
+ *
+ *    If the specified interface name does not exist, the return value is
+ *    0, and errno is set to ENXIO.  If there was a system error (such as
+ *    running out of memory), the return value is 0 and errno is set to the
+ *    proper value (e.g., ENOMEM).
+ */
+
+unsigned int
+if_nametoindex(const char *ifname)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        unsigned int ni;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(0);
+
+        ni = 0;
+
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK &&
+                    strcmp(ifa->ifa_name, ifname) == 0) {
+                        ni = ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index;
+                        break;
+                }
+        }
+
+        freeifaddrs(ifaddrs);
+        if (!ni)
+                errno = ENXIO;
+        return(ni);
+}
diff --git a/src/lib/libc/net/inet.3 b/src/lib/libc/net/inet.3
new file mode 100644
index 0000000000..f22e4b7d6f
--- /dev/null
+++ b/src/lib/libc/net/inet.3
@@ -0,0 +1,355 @@
+.\"     $OpenBSD: inet.3,v 1.19 2005/07/22 04:50:51 jaredy Exp $
+.\"     $NetBSD: inet.3,v 1.7 1997/06/18 02:25:24 lukem Exp $
+.\"
+.\" Copyright (c) 1983, 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)inet.3      8.1 (Berkeley) 6/4/93
+.\"
+.Dd June 18, 1997
+.Dt INET 3
+.Os
+.Sh NAME
+.Nm inet_addr ,
+.Nm inet_aton ,
+.Nm inet_lnaof ,
+.Nm inet_makeaddr ,
+.Nm inet_netof ,
+.Nm inet_network ,
+.Nm inet_ntoa ,
+.Nm inet_ntop ,
+.Nm inet_pton
+.Nd Internet address manipulation routines
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netinet/in.h>
+.Fd #include <arpa/inet.h>
+.Ft in_addr_t
+.Fn inet_addr "const char *cp"
+.Ft int
+.Fn inet_aton "const char *cp" "struct in_addr *addr"
+.Ft in_addr_t
+.Fn inet_lnaof "struct in_addr in"
+.Ft struct in_addr
+.Fn inet_makeaddr "in_addr_t net" "in_addr_t lna"
+.Ft in_addr_t
+.Fn inet_netof "struct in_addr in"
+.Ft in_addr_t
+.Fn inet_network "const char *cp"
+.Ft char *
+.Fn inet_ntoa "struct in_addr in"
+.Ft const char *
+.Fn inet_ntop "int af" "const void *src" "char *dst" "size_t size"
+.Ft int
+.Fn inet_pton "int af" "const char *src" "void *dst"
+.Sh DESCRIPTION
+The routines
+.Fn inet_aton ,
+.Fn inet_addr ,
+and
+.Fn inet_network
+interpret character strings representing
+numbers expressed in the Internet standard
+.Ql \&.
+notation.
+The
+.Fn inet_pton
+function converts a presentation format address (that is, printable form
+as held in a character string) to network format (usually a
+.Li struct in_addr
+or some other internal binary representation, in network byte order).
+It returns 1 if the address was valid for the specified address family;
+0 if the address wasn't parseable in the specified address family; or \-1
+if some system error occurred (in which case
+.Va errno
+will have been set).
+This function is presently valid for
+.Dv AF_INET
+and
+.Dv AF_INET6 .
+The
+.Fn inet_aton
+routine interprets the specified character string as an Internet address,
+placing the address into the structure provided.
+It returns 1 if the string was successfully interpreted,
+or 0 if the string was invalid.
+The
+.Fn inet_addr
+and
+.Fn inet_network
+functions return numbers suitable for use
+as Internet addresses and Internet network
+numbers, respectively.
+.Pp
+The function
+.Fn inet_ntop
+converts an address from network format (usually a
+.Li struct in_addr
+or some other binary form, in network byte order) to presentation format
+(suitable for external display purposes).
+It returns
+.Dv NULL
+if a system
+error occurs (in which case,
+.Va errno
+will have been set), or it returns a pointer to the destination string.
+The routine
+.Fn inet_ntoa
+takes an Internet address and returns an
+.Tn ASCII
+string representing the address in
+.Ql \&.
+notation.
+The routine
+.Fn inet_makeaddr
+takes an Internet network number and a local
+network address and constructs an Internet address
+from it.
+The routines
+.Fn inet_netof
+and
+.Fn inet_lnaof
+break apart Internet host addresses, returning
+the network number and local network address part,
+respectively.
+.Pp
+All Internet addresses are returned in network
+order (bytes ordered from left to right).
+All network numbers and local address parts are
+returned as machine format integer values.
+.Sh INTERNET ADDRESSES (IP VERSION 4)
+Values specified using the
+.Ql \&.
+notation take one
+of the following forms:
+.Bd -literal -offset indent
+a.b.c.d
+a.b.c
+a.b
+a
+.Ed
+.Pp
+When four parts are specified, each is interpreted
+as a byte of data and assigned, from left to right,
+to the four bytes of an Internet address.
+Note that when an Internet address is viewed as a 32-bit
+integer quantity on a system that uses little-endian
+byte order (such as the
+.Tn Intel 386, 486
+and
+.Tn Pentium
+processors) the bytes referred to above appear as
+.Dq Li d.c.b.a .
+That is, little-endian bytes are ordered from right to left.
+.Pp
+When a three part address is specified, the last
+part is interpreted as a 16-bit quantity and placed
+in the rightmost two bytes of the network address.
+This makes the three part address format convenient
+for specifying Class B network addresses as
+.Dq Li 128.net.host .
+.Pp
+When a two part address is supplied, the last part
+is interpreted as a 24-bit quantity and placed in
+the rightmost three bytes of the network address.
+This makes the two part address format convenient
+for specifying Class A network addresses as
+.Dq Li net.host .
+.Pp
+When only one part is given, the value is stored
+directly in the network address without any byte
+rearrangement.
+.Pp
+All numbers supplied as
+.Dq parts
+in a
+.Ql \&.
+notation
+may be decimal, octal, or hexadecimal, as specified
+in the C language (i.e., a leading 0x or 0X implies
+hexadecimal; a leading 0 implies octal;
+otherwise, the number is interpreted as decimal).
+.Sh INTERNET ADDRESSES (IP VERSION 6)
+In order to support scoped IPv6 addresses,
+.Xr getaddrinfo 3
+and
+.Xr getnameinfo 3
+are recommended rather than the functions presented here.
+.Pp
+The presentation format of an IPv6 address is given in RFC 2373:
+.Pp
+There are three conventional forms for representing IPv6 addresses as
+text strings:
+.Bl -enum
+.It
+The preferred form is x:x:x:x:x:x:x:x, where the 'x's are the
+hexadecimal values of the eight 16-bit pieces of the address.
+Examples:
+.Bd -literal -offset indent
+FEDC:BA98:7654:3210:FEDC:BA98:7654:3210
+1080:0:0:0:8:800:200C:417A
+.Ed
+.Pp
+Note that it is not necessary to write the leading zeros in an
+individual field, but there must be at least one numeral in
+every field (except for the case described in 2.).
+.It
+Due to the method of allocating certain styles of IPv6
+addresses, it will be common for addresses to contain long
+strings of zero bits.
+In order to make writing addresses
+containing zero bits easier, a special syntax is available to
+compress the zeros.
+The use of
+.Dq \&:\&:
+indicates multiple groups
+of 16 bits of zeros.
+The
+.Dq \&:\&:
+can only appear once in an
+address.
+The
+.Dq \&:\&:
+can also be used to compress the leading and/or trailing zeros in an address.
+.Pp
+For example the following addresses:
+.Bd -literal -offset indent
+1080:0:0:0:8:800:200C:417A  a unicast address
+FF01:0:0:0:0:0:0:43         a multicast address
+0:0:0:0:0:0:0:1             the loopback address
+0:0:0:0:0:0:0:0             the unspecified addresses
+.Ed
+.Pp
+may be represented as:
+.Bd -literal -offset indent
+1080::8:800:200C:417A       a unicast address
+FF01::43                    a multicast address
+::1                         the loopback address
+::                          the unspecified addresses
+.Ed
+.It
+An alternative form that is sometimes more convenient when
+dealing with a mixed environment of IPv4 and IPv6 nodes is
+x:x:x:x:x:x:d.d.d.d, where the 'x's are the hexadecimal values
+of the six high-order 16-bit pieces of the address, and the 'd's
+are the decimal values of the four low-order 8-bit pieces of the
+address (standard IPv4 representation).
+Examples:
+.Bd -literal -offset indent
+0:0:0:0:0:0:13.1.68.3
+0:0:0:0:0:FFFF:129.144.52.38
+.Ed
+.Pp
+or in compressed form:
+.Bd -literal -offset indent
+::13.1.68.3
+::FFFF:129.144.52.38
+.Ed
+.El
+.Sh DIAGNOSTICS
+The constant
+.Dv INADDR_NONE
+is returned by
+.Fn inet_addr
+and
+.Fn inet_network
+for malformed requests.
+.Sh SEE ALSO
+.Xr byteorder 3 ,
+.Xr gethostbyname 3 ,
+.Xr getnetent 3 ,
+.Xr inet_net 3 ,
+.Xr hosts 5 ,
+.Xr networks 5
+.Rs
+.%R RFC 2373
+.%D July 1998
+.%T "IP Version 6 Addressing Architecture"
+.Re
+.Rs
+.%R RFC 3493
+.%D February 2003
+.%T "Basic Socket Interface Extensions for IPv6"
+.Re
+.Sh STANDARDS
+The
+.Nm inet_ntop
+and
+.Nm inet_pton
+functions conform to the IETF IPv6 BSD API and address formatting
+specifications.
+Note that
+.Nm inet_pton
+does not accept 1-, 2-, or 3-part dotted addresses; all four parts
+must be specified.
+This is a narrower input set than that accepted by
+.Nm inet_aton .
+.Sh HISTORY
+The
+.Nm inet_addr ,
+.Nm inet_network ,
+.Nm inet_makeaddr ,
+.Nm inet_lnaof ,
+and
+.Nm inet_netof
+functions appeared in
+.Bx 4.2 .
+The
+.Nm inet_aton
+and
+.Nm inet_ntoa
+functions appeared in
+.Bx 4.3 .
+The
+.Nm inet_pton
+and
+.Nm inet_ntop
+functions appeared in BIND 4.9.4.
+.Sh BUGS
+The value
+.Dv INADDR_NONE
+(0xffffffff) is a valid broadcast address, but
+.Fn inet_addr
+cannot return that value without indicating failure.
+Also,
+.Fn inet_addr
+should have been designed to return a
+.Li struct in_addr .
+The newer
+.Fn inet_aton
+function does not share these problems, and almost all existing code
+should be modified to use
+.Fn inet_aton
+instead.
+.Pp
+The problem of host byte ordering versus network byte ordering is
+confusing.
+.Pp
+The string returned by
+.Fn inet_ntoa
+resides in a static memory area.
diff --git a/src/lib/libc/net/inet6_option_space.3 b/src/lib/libc/net/inet6_option_space.3
new file mode 100644
index 0000000000..5beec487ac
--- /dev/null
+++ b/src/lib/libc/net/inet6_option_space.3
@@ -0,0 +1,438 @@
+.\"     $OpenBSD: inet6_option_space.3,v 1.18 2005/01/11 17:45:41 jaredy Exp $
+.\"     $KAME: inet6_option_space.3,v 1.11 2005/01/05 03:00:44 itojun Exp $
+.\"
+.\" Copyright (C) 2004 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.
+.\"
+.Dd December 23, 2004
+.Dt INET6_OPTION_SPACE 3
+.Os
+.\"
+.Sh NAME
+.Nm inet6_option_space ,
+.Nm inet6_option_init ,
+.Nm inet6_option_append ,
+.Nm inet6_option_alloc ,
+.Nm inet6_option_next ,
+.Nm inet6_option_find
+.Nd IPv6 Hop-by-Hop and Destination Option Manipulation
+.\"
+.Sh SYNOPSIS
+.In sys/types.h
+.In netinet/in.h
+.Ft "int"
+.Fn inet6_option_space "int nbytes"
+.Ft "int"
+.Fn inet6_option_init "void *bp" "struct cmsghdr **cmsgp" "int type"
+.Ft "int"
+.Fn inet6_option_append "struct cmsghdr *cmsg" "const u_int8_t *typep" "int multx" "int plusy"
+.Ft "u_int8_t *"
+.Fn inet6_option_alloc "struct cmsghdr *cmsg" "int datalen" "int multx" "int plusy"
+.Ft "int"
+.Fn inet6_option_next "const struct cmsghdr *cmsg" "u_int8_t **tptrp"
+.Ft "int"
+.Fn inet6_option_find "const struct cmsghdr *cmsg" "u_int8_t **tptrp" "int type"
+.\"
+.Sh DESCRIPTION
+.\"
+Manipulating and parsing IPv6's Hop-by-Hop and Destination options is
+complicated by the need to properly align and pad data as well as the
+need to manipulate ancillary information that is not part of the data
+stream.
+RFC 2292 defines a set of functions, which are implemented as
+part of the Kame libraries, to help developers create, change,
+and parse Hop-by-Hop and Destination options.
+All of the prototypes
+for the option functions are defined in the
+.Aq Pa netinet/in.h
+header file.
+.\"
+.Ss inet6_option_space
+In order to determine the amount of space necessary to hold any option
+the
+.Fn inet6_option_space
+function is called.
+It returns the number of bytes required to hold
+an option when it is stored as ancillary data, including the
+.Li cmsghdr
+structure at the beginning, and any necessary padding at the end.
+The
+.Fa nbytes
+argument indicates the size of the structure defining the option,
+and must include any pad bytes at the beginning (the value
+.Li y
+in the alignment term
+.Dq Li "xn + y" ) ,
+the type byte, the length byte, and the option data.
+.Pp
+Note: If multiple options are stored in a single ancillary data
+object, which is the recommended technique, the
+.Fn inet6_option_space
+function overestimates the amount of space required by the size of
+.Li N-1
+.Li cmsghdr
+structures, where
+.Li N
+is the number of options to be stored in the object.
+Usually this has
+no impact because it is assumed that most Hop-by-Hop and Destination
+option headers carry only one option as indicated in appendix B of RFC 2460.
+.\"
+.Ss inet6_option_init
+The
+.Fn inet6_option_init
+function is called to initialize any ancillary data object that will contain
+a Hop-by-Hop or Destination option.
+It returns
+.Li 0
+on success and
+.Li \-1
+when an error occurs.
+.Pp
+The
+.Fa bp
+argument points to a previously allocated area of memory which must be
+large enough to contain all the arguments that the application intends
+to add later via the
+.Fn inet6_option_append
+and
+.Fn inet6_option_alloc
+routines.
+.Pp
+The
+.Fa cmsgp
+argument is a pointer to a pointer to a
+.Li cmsghdr
+structure.
+The
+.Fa *cmsgp
+argument
+points to a
+.Li cmsghdr
+structure which is constructed by this function and stored in the
+area of memory pointed to by
+.Fa bp .
+.Pp
+The
+.Fa type
+is either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS
+and is stored in the
+.Li cmsg_type
+member of the
+.Li cmsghdr
+structure mentioned above.
+.\"
+.Ss inet6_option_append
+This function appends a Hop-by-Hop option or a Destination option into
+an ancillary data object previously initialized by a call to
+.Fn inet6_option_init .
+The
+.Fn inet6_option_append
+function returns
+.Li 0
+if it succeeds or
+.Li \-1
+when an error occurs.
+.Pp
+The
+.Fa cmsg
+argument is a pointer to the
+.Li cmsghdr
+structure that was initialized by a call to
+.Fn inet6_option_init .
+.Pp
+The
+.Fa typep
+argument is a pointer to the 8-bit option type.
+All options are
+encoded as type-length-value tuples and it is assumed that
+the
+.Fa typep
+field is immediately followed by the 8-bit option data length field,
+which is then followed by the option data.
+.Pp
+The option types of
+.Li 0
+and
+.Li 1
+are reserved for the
+.Li Pad1
+and
+.Li PadN
+options respectively.
+All other values from
+.Li 2
+through
+.Li 255
+are available for applications to use.
+.Pp
+The option data length, since it is stored in 8 bites, must have a
+value between
+.Li 0
+and
+.Li 255 ,
+inclusive.
+.Pp
+The
+.Fa multx
+argument
+is the value
+.Li x
+in the alignment term
+.Dq Li xn + y
+and indicates the byte alignment necessary for the data.
+Alignments may be specified as
+.Li 1 ,
+.Li 2 ,
+.Li 4 ,
+or
+.Li 8
+bytes, which is no alignment, 16-bit, 32-bit and 64-bit alignments
+respectively.
+.Pp
+The
+.Fa plusy
+argument
+is the value
+.Li y
+in the alignment term
+.Dq Li xn + y
+and must have a value between
+.Li 0
+and
+.Li 7 ,
+inclusive, indicating the amount of padding that is necessary for an
+option.
+.\"
+.Ss inet6_option_alloc
+The
+.Fn inet6_option_alloc
+function appends a Hop-by-Hop option or a Destination option into an
+ancillary data object that has previously been initialized by a call to
+.Fn inet6_option_init .
+A successful call to the
+.Fn inet6_option_alloc
+function returns a pointer to the 8-bit option type field,
+which is at the beginning of the allocated region.
+.Fn inet6_option_alloc
+returns
+.Dv NULL
+when an error has occurred.
+.Pp
+The difference between the
+.Fn inet6_option_alloc
+and
+.Fn inet6_option_append
+functions is that the latter copies the contents of a previously built
+option into the ancillary data object while the former returns a
+pointer to the place in the data object where the option's TLV must
+then be built by the application.
+.Pp
+The
+.Fa cmsg
+argument is a pointer to a
+.Li cmsghdr
+structure that was initialized by
+.Fn inet6_option_init .
+.Pp
+The
+.Fa datalen
+argument is the value of the option data length byte for this option.
+This value is required as an argument to allow the function to
+determine if padding must be appended at the end of the option.
+(The
+.Fn inet6_option_append
+function does not need a data length argument
+since the option data length must already be stored by the caller.)
+.Pp
+The
+.Fa multx
+and
+.Fa plusy
+arguments
+are identical to the arguments of the same name described in the
+.Fn inet6_option_init
+function above.
+.\"
+.Ss inet6_option_next
+The
+.Fn inet6_option_next
+function is used to process Hop-by-Hop and Destination options that
+are present in an ancillary data object.
+When an option remains to
+be processed, the return value of the
+.Fn inet6_option_next
+function is
+.Li 0
+and the
+.Fa *tptrp
+argument points to the 8-bit option type field, which is followed by
+the 8-bit option data length, and then the option data.
+When no more
+options remain to be processed, the return value is
+.Li \-1
+and
+.Fa *tptrp
+is
+.Dv NULL .
+When an error occurs, the return value is
+.Li \-1 ,
+but the
+.Fa *tptrp
+argument is not
+.Dv NULL .
+This set of return values allows a program to easily loop through all
+the options in an ancillary data object, checking for the error and
+end of stream conditions along the way.
+.Pp
+When a valid option is returned, the
+.Fa cmsg
+argument points to a
+.Li cmsghdr
+where the
+.Li cmsg_level
+element equals
+.Dv IPPROTO_IPV6
+and the
+.Li cmsg_type
+element is either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS .
+.Pp
+The
+.Fa tptrp
+argument is a pointer to a pointer to an 8-bit byte and
+.Fa *tptrp
+is used by the function to remember its place in the ancillary data
+object each time the function is called.
+When the
+.Fn inet6_option_next
+function is called for the first time on a given ancillary data object,
+.Fa *tptrp
+must be set to
+.Dv NULL .
+.Pp
+Each time the function returns success,
+the
+.Fa *tptrp
+argument points to the 8-bit option type field for the next option to
+be processed.
+.\"
+.Ss inet6_option_find
+The
+.Fn inet6_option_find
+function allows an application to search for a particular option type
+in an ancillary data object.
+The
+.Fa cmsg
+argument is a pointer to a
+.Li cmsghdr
+structure in which the
+.Li cmsg_level
+element equals
+.Dv IPPROTO_IPV6
+and the
+.Li cmsg_type
+element is either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS .
+.Pp
+The
+.Fa tptrp
+argument is handled exactly as in the
+.Fn inet6_option_next
+function described above.
+.Pp
+The
+.Fn inet6_option_find
+function starts searching for an option of the specified type
+beginning after the value of
+.Fa *tptrp .
+.\"
+.Sh EXAMPLES
+RFC 2292 gives comprehensive examples in chapter 6.
+.\"
+.Sh DIAGNOSTICS
+The
+.Fn inet6_option_init
+and
+.Fn inet6_option_append
+functions return
+.Li 0
+on success or
+.Li \-1
+on an error.
+.Pp
+The
+.Fn inet6_option_alloc
+function returns
+.Dv NULL
+on an error.
+.Pp
+When
+.Fn inet6_option_next
+or
+.Fn inet6_option_find
+detect an error they return
+.Li \-1 ,
+setting
+.Fa *tptrp
+to a non
+.Dv NULL
+value.
+.\"
+.Sh SEE ALSO
+.Xr inet6 4 ,
+.Xr ip6 4
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%T "Advanced Sockets API for IPv6"
+.%N RFC 2292
+.%D February 1998
+.Re
+.Rs
+.%A S. Deering
+.%A R. Hinden
+.%T "Internet Protocol, Version 6 (IPv6) Specification"
+.%N RFC 2460
+.%D December 1998
+.Re
+.\"
+.Sh STANDARDS
+The functions are documented in
+.Dq Advanced Sockets API for IPv6
+(RFC 2292).
+.\"
+.Sh HISTORY
+This implementation first appeared in the KAME advanced networking kit.
+.\"
diff --git a/src/lib/libc/net/inet6_rthdr_space.3 b/src/lib/libc/net/inet6_rthdr_space.3
new file mode 100644
index 0000000000..7c00c42e42
--- /dev/null
+++ b/src/lib/libc/net/inet6_rthdr_space.3
@@ -0,0 +1,308 @@
+.\"     $OpenBSD: inet6_rthdr_space.3,v 1.17 2005/01/11 17:45:41 jaredy Exp $
+.\"     $KAME: inet6_rthdr_space.3,v 1.11 2005/01/05 03:00:44 itojun Exp $
+.\"
+.\" Copyright (C) 2004 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.
+.\"
+.Dd December 27, 2004
+.Dt INET6_RTHDR_SPACE 3
+.Os
+.\"
+.Sh NAME
+.Nm inet6_rthdr_space ,
+.Nm inet6_rthdr_init ,
+.Nm inet6_rthdr_add ,
+.Nm inet6_rthdr_lasthop ,
+.Nm inet6_rthdr_reverse ,
+.Nm inet6_rthdr_segments ,
+.Nm inet6_rthdr_getaddr ,
+.Nm inet6_rthdr_getflags
+.Nd IPv6 Routing Header Options Manipulation
+.\"
+.Sh SYNOPSIS
+.In sys/types.h
+.In netinet/in.h
+.Ft size_t
+.Fn inet6_rthdr_space "int type" "int segments"
+.Ft "struct cmsghdr *"
+.Fn inet6_rthdr_init "void *bp" "int type"
+.Ft int
+.Fn inet6_rthdr_add "struct cmsghdr *cmsg" "const struct in6_addr *addr" "unsigned int flags"
+.Ft int
+.Fn inet6_rthdr_lasthop "struct cmsghdr *cmsg" "unsigned int flags"
+.Ft int
+.Fn inet6_rthdr_reverse "const struct cmsghdr *in" "struct cmsghdr *out"
+.Ft int
+.Fn inet6_rthdr_segments "const struct cmsghdr *cmsg"
+.Ft "struct in6_addr *"
+.Fn inet6_rthdr_getaddr "struct cmsghdr *cmsg" "int index"
+.Ft int
+.Fn inet6_rthdr_getflags "const struct cmsghdr *cmsg" "int index"
+.\"
+.Sh DESCRIPTION
+.\"The RFC 2292 IPv6 Advanced API has been deprecated in favor of the
+.\"newer, RFC 3542 APIs.
+.\"On platforms that support it, currently only
+.\"FreeBSD, please use the newer API to manipulate routing header
+.\"options.
+.\".Pp
+The RFC 2292 IPv6 Advanced API defined eight functions for
+applications to use for building and parsing routing headers.
+The
+eight functions are split into two groups, the first of which builds
+the header and the second of which can parse it.
+The function prototypes for these functions are all in the
+.Aq Pa netinet/in.h
+header.
+Although direct manipulation of a routing header is possible,
+this set of APIs make it unnecessary and such direct manipulation
+should be avoided so that changes to the underlying structures do not
+break applications.
+.Pp
+Please note that RFC 2292 uses the term
+.Dq segments
+instead of the term
+.Dq addresses
+but they are considered equivalent for this manual page.
+.\"
+.Ss inet6_rthdr_space
+The
+.Fn inet6_rthdr_space
+function returns the number of bytes required to hold a routing header
+of the specified
+.Fa type
+and containing the specified number of
+.Fa segments .
+Only one
+.Fa type
+is supported,
+.Dv IPV6_RTHDR_TYPE_0 ,
+and it can hold from 1 to 23 segments.
+The return value includes the
+size of the
+.Vt cmsghdr
+structure that precedes the routing header and
+any required padding.
+.Pp
+A return value of 0 indicates an error.
+Either the type was specified
+incorrectly, or the number of segments was less than one or greater
+than 23.
+.Pp
+Note: The
+.Fn inet6_rthdr_space
+function only returns the size required by the routing header and does
+not allocate memory for the caller.
+.\"
+.Ss inet6_rthdr_init
+The
+.Fn inet6_rthdr_init
+function initializes a buffer, pointed to by
+.Fa bp
+with an appropriate
+.Li cmsghdr
+structure followed by a routing header of the specified
+.Fa type .
+.Pp
+The caller must use the
+.Fn inet6_rthdr_space
+function to determine the size of the buffer, and then allocate that
+buffer before calling
+.Fn inet6_rthdr_init .
+.Pp
+The return value is a pointer to a
+.Li cmsghdr
+structure, which is used as the first argument to the
+.Fn inet6_rthdr_add
+and
+.Fn inet6_rthdr_lasthop
+functions in order to construct the routing header.
+When an error occurs the return value is
+.Dv NULL .
+.\"
+.Ss inet6_rthdr_add
+The
+.Fn inet6_rthdr_add
+function adds the IPv6 address pointed to by
+.Fa addr
+to the end of the
+routing header being constructed and sets the type of this address to the
+value of
+.Fa flags .
+The
+.Fa flags
+must be either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT
+indicating whether loose or strict source routing is required.
+.Pp
+When the function succeeds it returns 0, otherwise \-1 is returned.
+.\"
+.Ss inet6_rthdr_lasthop
+The
+.Fn inet6_rthdr_lasthop
+function specifies the strict or loose flag for the final hop of a
+routing header.
+The
+.Fa flags
+argument must be either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT .
+.Pp
+The return value of the function is 0 upon success, and \-1 when an
+error has occurred.
+.Pp
+Please note that a routing header specifying
+.Li N
+intermediate nodes requires
+.Li N+1
+strict or loose flags meaning that
+.Fn inet6_rthdr_add
+must be called
+.Li N
+times and then
+.Fn inet6_rthdr_lasthop
+must be called once.
+.\"
+.Ss inet6_rthdr_reverse
+This function was never implemented.
+.Pp
+The following three functions provide an API for parsing a received
+routing header:
+.\"
+.Ss inet6_rthdr_segments
+The
+.Fn inet6_rthdr_segments
+function returns the number of segments contained in the routing
+header pointed to by the
+.Fa cmsg
+argument.
+On success the return value is from 1 to 23.
+When an error occurs, \-1 is returned.
+.\"
+.Ss inet6_rthdr_getaddr
+The
+.Fn inet6_rthdr_getaddr
+function returns a pointer to the IPv6 address specified by the
+.Fa index
+argument from the routing header pointed to by
+.Fa cmsg .
+The index must be between 1 and the number returned by
+.Fn inet6_rthdr_segments ,
+described above.
+An application must call
+.Fn inet6_rthdr_segments
+to obtain the number of segments in the routing header.
+.Pp
+If an error occurs,
+.Dv NULL
+is returned.
+.\"
+.Ss inet6_rthdr_getflags
+The
+.Fn inet6_rthdr_getflags
+function returns the flags value of the segment specified by
+.Fa index
+of the routing header pointed to by
+.Fa cmsg .
+The
+.Fa index
+argument must be between 0 and the value returned by
+.Fn inet6_rthdr_segments .
+The return value will be either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT
+indicating whether loose or strict source routing was requested for
+that segment.
+.Pp
+When an error occurs, \-1 is returned.
+.Pp
+Note: Flags begin at index 0 while segments begin at index 1, to
+maintain consistency with the terminology and figures in RFC 2460.
+.\"
+.Sh EXAMPLES
+RFC 2292 gives comprehensive examples in chapter 8.
+.\"
+.Sh DIAGNOSTICS
+The
+.Fn inet6_rthdr_space
+function returns 0 when an error occurs.
+.Pp
+The
+.Fn inet6_rthdr_add
+and
+.Fn inet6_rthdr_lasthop
+functions return 0 on success, and \-1 on error.
+.Pp
+The
+.Fn inet6_rthdr_init
+and
+.Fn inet6_rthdr_getaddr
+functions
+return
+.Dv NULL
+on error.
+.Pp
+The
+.Fn inet6_rthdr_segments
+and
+.Fn inet6_rthdr_getflags
+functions return \-1 on error.
+.\"
+.Sh SEE ALSO
+.Xr inet6 4 ,
+.Xr ip6 4
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%T "Advanced Sockets API for IPv6"
+.%N RFC 2292
+.%D February 1998
+.Re
+.Rs
+.%A S. Deering
+.%A R. Hinden
+.%T "Internet Protocol, Version 6 (IPv6) Specification"
+.%N RFC 2460
+.%D December 1998
+.Re
+.\"
+.Sh HISTORY
+This implementation first appeared in the KAME advanced networking kit.
+.\"
+.Sh BUGS
+The
+.Fn inet6_rthdr_reverse
+function was never implemented.
+.\".Pp
+.\"This API is deprecated in favor of
+.\".Xr inet6_rth_space 3
+.\".Sh SEE ALSO
+.\".Xr inet6_rth_space 3
diff --git a/src/lib/libc/net/inet_addr.c b/src/lib/libc/net/inet_addr.c
new file mode 100644
index 0000000000..c962a03382
--- /dev/null
+++ b/src/lib/libc/net/inet_addr.c
@@ -0,0 +1,171 @@
+/*      $OpenBSD: inet_addr.c,v 1.9 2005/08/06 20:30:03 espie Exp $     */
+
+/*
+ * ++Copyright++ 1983, 1990, 1993
+ * -
+ * Copyright (c) 1983, 1990, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <ctype.h>
+
+/*
+ * Ascii internet address interpretation routine.
+ * The value returned is in network order.
+ */
+in_addr_t
+inet_addr(const char *cp)
+{
+        struct in_addr val;
+
+        if (inet_aton(cp, &val))
+                return (val.s_addr);
+        return (INADDR_NONE);
+}
+
+/* 
+ * Check whether "cp" is a valid ascii representation
+ * of an Internet address and convert to a binary address.
+ * Returns 1 if the address is valid, 0 if not.
+ * This replaces inet_addr, the return value from which
+ * cannot distinguish between failure and a local broadcast address.
+ */
+int
+inet_aton(const char *cp, struct in_addr *addr)
+{
+        in_addr_t val;
+        int base, n;
+        char c;
+        u_int parts[4];
+        u_int *pp = parts;
+
+        c = *cp;
+        for (;;) {
+                /*
+                 * Collect number up to ``.''.
+                 * Values are specified as for C:
+                 * 0x=hex, 0=octal, isdigit=decimal.
+                 */
+                if (!isdigit(c))
+                        return (0);
+                val = 0; base = 10;
+                if (c == '0') {
+                        c = *++cp;
+                        if (c == 'x' || c == 'X')
+                                base = 16, c = *++cp;
+                        else
+                                base = 8;
+                }
+                for (;;) {
+                        if (isascii(c) && isdigit(c)) {
+                                val = (val * base) + (c - '0');
+                                c = *++cp;
+                        } else if (base == 16 && isascii(c) && isxdigit(c)) {
+                                val = (val << 4) |
+                                        (c + 10 - (islower(c) ? 'a' : 'A'));
+                                c = *++cp;
+                        } else
+                                break;
+                }
+                if (c == '.') {
+                        /*
+                         * Internet format:
+                         *      a.b.c.d
+                         *      a.b.c   (with c treated as 16 bits)
+                         *      a.b     (with b treated as 24 bits)
+                         */
+                        if (pp >= parts + 3)
+                                return (0);
+                        *pp++ = val;
+                        c = *++cp;
+                } else
+                        break;
+        }
+        /*
+         * Check for trailing characters.
+         */
+        if (c != '\0' && (!isascii(c) || !isspace(c)))
+                return (0);
+        /*
+         * Concoct the address according to
+         * the number of parts specified.
+         */
+        n = pp - parts + 1;
+        switch (n) {
+
+        case 0:
+                return (0);             /* initial nondigit */
+
+        case 1:                         /* a -- 32 bits */
+                break;
+
+        case 2:                         /* a.b -- 8.24 bits */
+                if ((val > 0xffffff) || (parts[0] > 0xff))
+                        return (0);
+                val |= parts[0] << 24;
+                break;
+
+        case 3:                         /* a.b.c -- 8.8.16 bits */
+                if ((val > 0xffff) || (parts[0] > 0xff) || (parts[1] > 0xff))
+                        return (0);
+                val |= (parts[0] << 24) | (parts[1] << 16);
+                break;
+
+        case 4:                         /* a.b.c.d -- 8.8.8.8 bits */
+                if ((val > 0xff) || (parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff))
+                        return (0);
+                val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+                break;
+        }
+        if (addr)
+                addr->s_addr = htonl(val);
+        return (1);
+}
diff --git a/src/lib/libc/net/inet_lnaof.c b/src/lib/libc/net/inet_lnaof.c
new file mode 100644
index 0000000000..b1a58cd2c1
--- /dev/null
+++ b/src/lib/libc/net/inet_lnaof.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: inet_lnaof.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/*
+ * Return the local network address portion of an
+ * internet address; handles class a/b/c network
+ * number formats.
+ */
+in_addr_t
+inet_lnaof(struct in_addr in)
+{
+        in_addr_t i = ntohl(in.s_addr);
+
+        if (IN_CLASSA(i))
+                return ((i)&IN_CLASSA_HOST);
+        else if (IN_CLASSB(i))
+                return ((i)&IN_CLASSB_HOST);
+        else
+                return ((i)&IN_CLASSC_HOST);
+}
diff --git a/src/lib/libc/net/inet_makeaddr.c b/src/lib/libc/net/inet_makeaddr.c
new file mode 100644
index 0000000000..87d9325231
--- /dev/null
+++ b/src/lib/libc/net/inet_makeaddr.c
@@ -0,0 +1,54 @@
+/*      $OpenBSD: inet_makeaddr.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/*
+ * Formulate an Internet address from network + host.  Used in
+ * building addresses stored in the ifnet structure.
+ */
+struct in_addr
+inet_makeaddr(in_addr_t net, in_addr_t host)
+{
+        in_addr_t addr;
+
+        if (net < 128)
+                addr = (net << IN_CLASSA_NSHIFT) | (host & IN_CLASSA_HOST);
+        else if (net < 65536)
+                addr = (net << IN_CLASSB_NSHIFT) | (host & IN_CLASSB_HOST);
+        else if (net < 16777216L)
+                addr = (net << IN_CLASSC_NSHIFT) | (host & IN_CLASSC_HOST);
+        else
+                addr = net | host;
+        addr = htonl(addr);
+        return (*(struct in_addr *)&addr);
+}
diff --git a/src/lib/libc/net/inet_net.3 b/src/lib/libc/net/inet_net.3
new file mode 100644
index 0000000000..a763bb12a5
--- /dev/null
+++ b/src/lib/libc/net/inet_net.3
@@ -0,0 +1,183 @@
+.\"     $OpenBSD: inet_net.3,v 1.12 2005/12/30 20:45:59 claudio Exp $
+.\"     $NetBSD: inet_net.3,v 1.1 1997/06/18 02:25:27 lukem Exp $
+.\"
+.\" Copyright (c) 1997 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to The NetBSD Foundation
+.\" by Luke Mewburn.
+.\"
+.\" 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 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.
+.\"
+.Dd June 18, 1997
+.Dt INET_NET 3
+.Os
+.Sh NAME
+.Nm inet_net_ntop ,
+.Nm inet_net_pton
+.Nd Internet network number manipulation routines
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netinet/in.h>
+.Fd #include <arpa/inet.h>
+.Ft char *
+.Fn inet_net_ntop "int af" "const void *src" "int bits" "char *dst" "size_t size"
+.Ft int
+.Fn inet_net_pton "int af" "const char *src" "void *dst" "size_t size"
+.Sh DESCRIPTION
+The
+.Fn inet_net_ntop
+function converts an Internet network number from network format (usually a
+.Li struct in_addr
+or some other binary form, in network byte order) to CIDR presentation format
+(suitable for external display purposes).
+.Fa bits
+is the number of bits in
+.Fa src
+that are the network number.
+It returns
+.Dv NULL
+if a system error occurs (in which case,
+.Va errno
+will have been set), or it returns a pointer to the destination string.
+.Pp
+The
+.Fn inet_net_pton
+function converts a presentation format Internet network number (that is,
+printable form as held in a character string) to network format (usually a
+.Li struct in_addr
+or some other internal binary representation, in network byte order).
+It returns the number of bits (either computed based on the class, or
+specified with /CIDR), or \-1 if a failure occurred
+(in which case
+.Va errno
+will have been set.
+It will be set to
+.Er ENOENT
+if the Internet network number was not valid).
+.Pp
+Caution:
+The
+.Fa dst
+field should be zeroed before calling
+.Fn inet_net_pton
+as the function will only fill the number of bytes necessary to
+encode the network number in network byte order.
+.Pp
+The only value for
+.Fa af
+currently supported is
+.Dv AF_INET .
+.Fa size
+is the size of the result buffer
+.Fa dst .
+.Sh NETWORK NUMBERS (IP VERSION 4)
+The external representation of Internet network numbers may be specified in
+one of the following forms:
+.Bd -literal -offset indent
+a
+a.b
+a.b.c
+a.b.c.d
+.Ed
+.Pp
+Any of the above four forms may have
+.Dq Li /bits
+appended where
+.Dq Li bits
+is in the range
+.Li 0-32
+and is used to explicitly specify the number of bits in the network address.
+When
+.Dq Li /bits
+is not specified the number of bits in the network address is calculated
+as the larger of the number of bits in the class to which the address
+belongs and the number of bits provided rounded up modulo 8.
+Examples:
+.Pp
+.Bl -tag -width 10.1.2.3/24 -offset indent -compact
+.It Li 10
+an 8-bit network number (class A), value
+.Li 10.0.0.0 .
+.It Li 192
+a 24-bit network number (class C), value
+.Li 192.0.0.0 .
+.It Li 10.10
+a 16-bit network number, value
+.Li 10.10.0.0 .
+.It Li 10.1.2
+a 24-bit network number, value
+.Li 10.1.2.0 .
+.It Li 10.1.2.3
+a 32-bit network number, value
+.Li 10.1.2.3 .
+.It Li 10.1.2.3/24
+a 24-bit network number (explicit), value
+.Li 10.1.2.3 .
+.El
+.Pp
+Note that when the number of bits is specified using
+.Dq Li /bits
+notation, the value of the address still includes all bits supplied
+in the external representation, even those bits which are the host
+part of an Internet address.
+Also, unlike
+.Xr inet_pton 3
+where the external representation is assumed to be a host address, the
+external representation for
+.Fn inet_net_pton
+is assumed to be a network address.
+Thus
+.Dq Li 10.1
+is assumed to be
+.Dq Li 10.1.0.0
+not
+.Dq Li 10.0.0.1
+.Pp
+All numbers supplied as
+.Dq parts
+in a
+.Ql \&.
+notation
+may be decimal, octal, or hexadecimal, as specified
+in the C language (i.e., a leading 0x or 0X implies
+hexadecimal; otherwise, a leading 0 implies octal;
+otherwise, the number is interpreted as decimal).
+.Sh SEE ALSO
+.Xr byteorder 3 ,
+.Xr inet 3 ,
+.Xr inet_pton 3 ,
+.Xr networks 5
+.Sh HISTORY
+The
+.Nm inet_net_ntop
+and
+.Nm inet_net_pton
+functions first appeared in BIND 4.9.4.
diff --git a/src/lib/libc/net/inet_net_ntop.c b/src/lib/libc/net/inet_net_ntop.c
new file mode 100644
index 0000000000..fc9071798a
--- /dev/null
+++ b/src/lib/libc/net/inet_net_ntop.c
@@ -0,0 +1,135 @@
+/*      $OpenBSD: inet_net_ntop.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static char *inet_net_ntop_ipv4(const u_char *, int, char *, size_t);
+
+/*
+ * char *
+ * inet_net_ntop(af, src, bits, dst, size)
+ *      convert network number from network to presentation format.
+ *      generates CIDR style result always.
+ * return:
+ *      pointer to dst, or NULL if an error occurred (check errno).
+ * author:
+ *      Paul Vixie (ISC), July 1996
+ */
+char *
+inet_net_ntop(int af, const void *src, int bits, char *dst, size_t size)
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_net_ntop_ipv4(src, bits, dst, size));
+        default:
+                errno = EAFNOSUPPORT;
+                return (NULL);
+        }
+}
+
+/*
+ * static char *
+ * inet_net_ntop_ipv4(src, bits, dst, size)
+ *      convert IPv4 network number from network to presentation format.
+ *      generates CIDR style result always.
+ * return:
+ *      pointer to dst, or NULL if an error occurred (check errno).
+ * note:
+ *      network byte order assumed.  this means 192.5.5.240/28 has
+ *      0x11110000 in its fourth octet.
+ * author:
+ *      Paul Vixie (ISC), July 1996
+ */
+static char *
+inet_net_ntop_ipv4(const u_char *src, int bits, char *dst, size_t size)
+{
+        char *odst = dst;
+        u_int m;
+        int b;
+        char *ep;
+        int advance;
+
+        ep = dst + size;
+        if (ep <= dst)
+                goto emsgsize;
+
+        if (bits < 0 || bits > 32) {
+                errno = EINVAL;
+                return (NULL);
+        }
+        if (bits == 0) {
+                if (ep - dst < sizeof "0")
+                        goto emsgsize;
+                *dst++ = '0';
+                *dst = '\0';
+        }
+
+        /* Format whole octets. */
+        for (b = bits / 8; b > 0; b--) {
+                if (ep - dst < sizeof "255.")
+                        goto emsgsize;
+                advance = snprintf(dst, ep - dst, "%u", *src++);
+                if (advance <= 0 || advance >= ep - dst)
+                        goto emsgsize;
+                dst += advance;
+                if (b > 1) {
+                        if (dst + 1 >= ep)
+                                goto emsgsize;
+                        *dst++ = '.';
+                        *dst = '\0';
+                }
+        }
+
+        /* Format partial octet. */
+        b = bits % 8;
+        if (b > 0) {
+                if (ep - dst < sizeof ".255")
+                        goto emsgsize;
+                if (dst != odst)
+                        if (dst + 1 >= ep)
+                                goto emsgsize;
+                        *dst++ = '.';
+                m = ((1 << b) - 1) << (8 - b);
+                advance = snprintf(dst, ep - dst, "%u", *src & m);
+                if (advance <= 0 || advance >= ep - dst)
+                        goto emsgsize;
+                dst += advance;
+        }
+
+        /* Format CIDR /width. */
+        if (ep - dst < sizeof "/32")
+                goto emsgsize;
+        advance = snprintf(dst, ep - dst, "/%u", bits);
+        if (advance <= 0 || advance >= ep - dst)
+                goto emsgsize;
+        dst += advance;
+        return (odst);
+
+ emsgsize:
+        errno = EMSGSIZE;
+        return (NULL);
+}
diff --git a/src/lib/libc/net/inet_net_pton.c b/src/lib/libc/net/inet_net_pton.c
new file mode 100644
index 0000000000..9bb35478ca
--- /dev/null
+++ b/src/lib/libc/net/inet_net_pton.c
@@ -0,0 +1,191 @@
+/*      $OpenBSD: inet_net_pton.c,v 1.5 2005/08/06 20:30:03 espie Exp $ */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static int      inet_net_pton_ipv4(const char *, u_char *, size_t);
+
+/*
+ * static int
+ * inet_net_pton(af, src, dst, size)
+ *      convert network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not a valid network specification.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+int
+inet_net_pton(int af, const char *src, void *dst, size_t size)
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_net_pton_ipv4(src, dst, size));
+        default:
+                errno = EAFNOSUPPORT;
+                return (-1);
+        }
+}
+
+/*
+ * static int
+ * inet_net_pton_ipv4(src, dst, size)
+ *      convert IPv4 network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not an IPv4 network specification.
+ * note:
+ *      network byte order assumed.  this means 192.5.5.240/28 has
+ *      0x11110000 in its fourth octet.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+static int
+inet_net_pton_ipv4(const char *src, u_char *dst, size_t size)
+{
+        static const char
+                xdigits[] = "0123456789abcdef",
+                digits[] = "0123456789";
+        int n, ch, tmp, dirty, bits;
+        const u_char *odst = dst;
+
+        ch = *src++;
+        if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
+            && isascii(src[1]) && isxdigit(src[1])) {
+                /* Hexadecimal: Eat nybble string. */
+                if (size <= 0)
+                        goto emsgsize;
+                *dst = 0, dirty = 0;
+                src++;  /* skip x or X. */
+                while ((ch = *src++) != '\0' &&
+                       isascii(ch) && isxdigit(ch)) {
+                        if (isupper(ch))
+                                ch = tolower(ch);
+                        n = strchr(xdigits, ch) - xdigits;
+                        assert(n >= 0 && n <= 15);
+                        *dst |= n;
+                        if (!dirty++)
+                                *dst <<= 4;
+                        else if (size-- > 0)
+                                *++dst = 0, dirty = 0;
+                        else
+                                goto emsgsize;
+                }
+                if (dirty)
+                        size--;
+        } else if (isascii(ch) && isdigit(ch)) {
+                /* Decimal: eat dotted digit string. */
+                for (;;) {
+                        tmp = 0;
+                        do {
+                                n = strchr(digits, ch) - digits;
+                                assert(n >= 0 && n <= 9);
+                                tmp *= 10;
+                                tmp += n;
+                                if (tmp > 255)
+                                        goto enoent;
+                        } while ((ch = *src++) != '\0' &&
+                                 isascii(ch) && isdigit(ch));
+                        if (size-- <= 0)
+                                goto emsgsize;
+                        *dst++ = (u_char) tmp;
+                        if (ch == '\0' || ch == '/')
+                                break;
+                        if (ch != '.')
+                                goto enoent;
+                        ch = *src++;
+                        if (!isascii(ch) || !isdigit(ch))
+                                goto enoent;
+                }
+        } else
+                goto enoent;
+
+        bits = -1;
+        if (ch == '/' && isascii(src[0]) && isdigit(src[0]) && dst > odst) {
+                /* CIDR width specifier.  Nothing can follow it. */
+                ch = *src++;    /* Skip over the /. */
+                bits = 0;
+                do {
+                        n = strchr(digits, ch) - digits;
+                        assert(n >= 0 && n <= 9);
+                        bits *= 10;
+                        bits += n;
+                } while ((ch = *src++) != '\0' &&
+                         isascii(ch) && isdigit(ch));
+                if (ch != '\0')
+                        goto enoent;
+                if (bits > 32)
+                        goto emsgsize;
+        }
+
+        /* Firey death and destruction unless we prefetched EOS. */
+        if (ch != '\0')
+                goto enoent;
+
+        /* If nothing was written to the destination, we found no address. */
+        if (dst == odst)
+                goto enoent;
+        /* If no CIDR spec was given, infer width from net class. */
+        if (bits == -1) {
+                if (*odst >= 240)       /* Class E */
+                        bits = 32;
+                else if (*odst >= 224)  /* Class D */
+                        bits = 4;
+                else if (*odst >= 192)  /* Class C */
+                        bits = 24;
+                else if (*odst >= 128)  /* Class B */
+                        bits = 16;
+                else                    /* Class A */
+                        bits = 8;
+                /* If imputed mask is narrower than specified octets, widen. */
+                if (bits < ((dst - odst) * 8))
+                        bits = (dst - odst) * 8;
+        }
+        /* Extend network to cover the actual mask. */
+        while (bits > ((dst - odst) * 8)) {
+                if (size-- <= 0)
+                        goto emsgsize;
+                *dst++ = '\0';
+        }
+        return (bits);
+
+ enoent:
+        errno = ENOENT;
+        return (-1);
+
+ emsgsize:
+        errno = EMSGSIZE;
+        return (-1);
+}
diff --git a/src/lib/libc/net/inet_neta.c b/src/lib/libc/net/inet_neta.c
new file mode 100644
index 0000000000..e3e7d0eb71
--- /dev/null
+++ b/src/lib/libc/net/inet_neta.c
@@ -0,0 +1,80 @@
+/*      $OpenBSD: inet_neta.c,v 1.7 2005/08/06 20:30:03 espie Exp $     */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+/*
+ * char *
+ * inet_neta(src, dst, size)
+ *      format an in_addr_t network number into presentation format.
+ * return:
+ *      pointer to dst, or NULL if an error occurred (check errno).
+ * note:
+ *      format of ``src'' is as for inet_network().
+ * author:
+ *      Paul Vixie (ISC), July 1996
+ */
+char *
+inet_neta(in_addr_t src, char *dst, size_t size)
+{
+        char *odst = dst;
+        char *ep;
+        int advance;
+
+        if (src == 0x00000000) {
+                if (size < sizeof "0.0.0.0")
+                        goto emsgsize;
+                strlcpy(dst, "0.0.0.0", size);
+                return dst;
+        }
+        ep = dst + size;
+        if (ep <= dst)
+                goto emsgsize;
+        while (src & 0xffffffff) {
+                u_char b = (src & 0xff000000) >> 24;
+
+                src <<= 8;
+                if (b || src) {
+                        if (ep - dst < sizeof "255.")
+                                goto emsgsize;
+                        advance = snprintf(dst, ep - dst, "%u", b);
+                        if (advance <= 0 || advance >= ep - dst)
+                                goto emsgsize;
+                        dst += advance;
+                        if (src != 0L) {
+                                if (dst + 1 >= ep)
+                                        goto emsgsize;
+                                *dst++ = '.';
+                                *dst = '\0';
+                        }
+                }
+        }
+        return (odst);
+
+ emsgsize:
+        errno = EMSGSIZE;
+        return (NULL);
+}
diff --git a/src/lib/libc/net/inet_netof.c b/src/lib/libc/net/inet_netof.c
new file mode 100644
index 0000000000..2f468c3aca
--- /dev/null
+++ b/src/lib/libc/net/inet_netof.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: inet_netof.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/*
+ * Return the network number from an internet
+ * address; handles class a/b/c network #'s.
+ */
+in_addr_t
+inet_netof(struct in_addr in)
+{
+        in_addr_t i = ntohl(in.s_addr);
+
+        if (IN_CLASSA(i))
+                return (((i)&IN_CLASSA_NET) >> IN_CLASSA_NSHIFT);
+        else if (IN_CLASSB(i))
+                return (((i)&IN_CLASSB_NET) >> IN_CLASSB_NSHIFT);
+        else
+                return (((i)&IN_CLASSC_NET) >> IN_CLASSC_NSHIFT);
+}
diff --git a/src/lib/libc/net/inet_network.c b/src/lib/libc/net/inet_network.c
new file mode 100644
index 0000000000..8b26ba8ff9
--- /dev/null
+++ b/src/lib/libc/net/inet_network.c
@@ -0,0 +1,84 @@
+/*      $OpenBSD: inet_network.c,v 1.10 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <ctype.h>
+
+/*
+ * Internet network address interpretation routine.
+ * The library routines call this routine to interpret
+ * network numbers.
+ */
+in_addr_t
+inet_network(const char *cp)
+{
+        in_addr_t val, base, n;
+        char c;
+        in_addr_t parts[4], *pp = parts;
+        int i;
+
+again:
+        val = 0; base = 10;
+        if (*cp == '0')
+                base = 8, cp++;
+        if (*cp == 'x' || *cp == 'X')
+                base = 16, cp++;
+        while ((c = *cp)) {
+                if (isdigit(c)) {
+                        val = (val * base) + (c - '0');
+                        cp++;
+                        continue;
+                }
+                if (base == 16 && isxdigit(c)) {
+                        val = (val << 4) + (c + 10 - (islower(c) ? 'a' : 'A'));
+                        cp++;
+                        continue;
+                }
+                break;
+        }
+        if (*cp == '.') {
+                if (pp >= parts + 3)
+                        return (INADDR_NONE);
+                *pp++ = val, cp++;
+                goto again;
+        }
+        if (*cp && !isspace(*cp))
+                return (INADDR_NONE);
+        *pp++ = val;
+        n = pp - parts;
+        for (val = 0, i = 0; i < 4; i++) {
+                val <<= 8;
+                if (i < n)
+                        val |= parts[i] & 0xff;
+        }
+        return (val);
+}
diff --git a/src/lib/libc/net/inet_ntoa.c b/src/lib/libc/net/inet_ntoa.c
new file mode 100644
index 0000000000..ff5d93ded2
--- /dev/null
+++ b/src/lib/libc/net/inet_ntoa.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: inet_ntoa.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1983, 1993
+ *      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.
+ */
+
+/*
+ * Convert network-format internet address
+ * to base 256 d.d.d.d representation.
+ */
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+
+char *
+inet_ntoa(struct in_addr in)
+{
+        static char b[18];
+        char *p;
+
+        p = (char *)&in;
+#define UC(b)   (((int)b)&0xff)
+        (void)snprintf(b, sizeof(b),
+            "%u.%u.%u.%u", UC(p[0]), UC(p[1]), UC(p[2]), UC(p[3]));
+        return (b);
+}
diff --git a/src/lib/libc/net/inet_ntop.c b/src/lib/libc/net/inet_ntop.c
new file mode 100644
index 0000000000..d36a0d7889
--- /dev/null
+++ b/src/lib/libc/net/inet_ntop.c
@@ -0,0 +1,195 @@
+/*      $OpenBSD: inet_ntop.c,v 1.7 2005/08/06 20:30:03 espie Exp $     */
+
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static const char *inet_ntop4(const u_char *src, char *dst, size_t size);
+static const char *inet_ntop6(const u_char *src, char *dst, size_t size);
+
+/* char *
+ * inet_ntop(af, src, dst, size)
+ *      convert a network format address to presentation format.
+ * return:
+ *      pointer to presentation format address (`dst'), or NULL (see errno).
+ * author:
+ *      Paul Vixie, 1996.
+ */
+const char *
+inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_ntop4(src, dst, size));
+        case AF_INET6:
+                return (inet_ntop6(src, dst, size));
+        default:
+                errno = EAFNOSUPPORT;
+                return (NULL);
+        }
+        /* NOTREACHED */
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *      format an IPv4 address, more or less like inet_ntoa()
+ * return:
+ *      `dst' (as a const)
+ * notes:
+ *      (1) uses no statics
+ *      (2) takes a u_char* not an in_addr as input
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(const u_char *src, char *dst, size_t size)
+{
+        static const char fmt[] = "%u.%u.%u.%u";
+        char tmp[sizeof "255.255.255.255"];
+        int l;
+
+        l = snprintf(tmp, size, fmt, src[0], src[1], src[2], src[3]);
+        if (l <= 0 || l >= size) {
+                errno = ENOSPC;
+                return (NULL);
+        }
+        strlcpy(dst, tmp, size);
+        return (dst);
+}
+
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *      convert IPv6 binary address into presentation (printable) format
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop6(const u_char *src, char *dst, size_t size)
+{
+        /*
+         * Note that int32_t and int16_t need only be "at least" large enough
+         * to contain a value of the specified size.  On some systems, like
+         * Crays, there is no such thing as an integer variable with 16 bits.
+         * Keep this in mind if you think this function should have been coded
+         * to use pointer overlays.  All the world's not a VAX.
+         */
+        char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
+        char *tp, *ep;
+        struct { int base, len; } best, cur;
+        u_int words[IN6ADDRSZ / INT16SZ];
+        int i;
+        int advance;
+
+        /*
+         * Preprocess:
+         *      Copy the input (bytewise) array into a wordwise array.
+         *      Find the longest run of 0x00's in src[] for :: shorthanding.
+         */
+        memset(words, '\0', sizeof words);
+        for (i = 0; i < IN6ADDRSZ; i++)
+                words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+        best.base = -1;
+        cur.base = -1;
+        for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
+                if (words[i] == 0) {
+                        if (cur.base == -1)
+                                cur.base = i, cur.len = 1;
+                        else
+                                cur.len++;
+                } else {
+                        if (cur.base != -1) {
+                                if (best.base == -1 || cur.len > best.len)
+                                        best = cur;
+                                cur.base = -1;
+                        }
+                }
+        }
+        if (cur.base != -1) {
+                if (best.base == -1 || cur.len > best.len)
+                        best = cur;
+        }
+        if (best.base != -1 && best.len < 2)
+                best.base = -1;
+
+        /*
+         * Format the result.
+         */
+        tp = tmp;
+        ep = tmp + sizeof(tmp);
+        for (i = 0; i < (IN6ADDRSZ / INT16SZ) && tp < ep; i++) {
+                /* Are we inside the best run of 0x00's? */
+                if (best.base != -1 && i >= best.base &&
+                    i < (best.base + best.len)) {
+                        if (i == best.base) {
+                                if (tp + 1 >= ep)
+                                        return (NULL);
+                                *tp++ = ':';
+                        }
+                        continue;
+                }
+                /* Are we following an initial run of 0x00s or any real hex? */
+                if (i != 0) {
+                        if (tp + 1 >= ep)
+                                return (NULL);
+                        *tp++ = ':';
+                }
+                /* Is this address an encapsulated IPv4? */
+                if (i == 6 && best.base == 0 &&
+                    (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
+                        if (!inet_ntop4(src+12, tp, (size_t)(ep - tp)))
+                                return (NULL);
+                        tp += strlen(tp);
+                        break;
+                }
+                advance = snprintf(tp, ep - tp, "%x", words[i]);
+                if (advance <= 0 || advance >= ep - tp)
+                        return (NULL);
+                tp += advance;
+        }
+        /* Was it a trailing run of 0x00's? */
+        if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
+                if (tp + 1 >= ep)
+                        return (NULL);
+                *tp++ = ':';
+        }
+        if (tp + 1 >= ep)
+                return (NULL);
+        *tp++ = '\0';
+
+        /*
+         * Check for overflow, copy, and we're done.
+         */
+        if ((size_t)(tp - tmp) > size) {
+                errno = ENOSPC;
+                return (NULL);
+        }
+        strlcpy(dst, tmp, size);
+        return (dst);
+}
diff --git a/src/lib/libc/net/inet_pton.c b/src/lib/libc/net/inet_pton.c
new file mode 100644
index 0000000000..87206ee8b8
--- /dev/null
+++ b/src/lib/libc/net/inet_pton.c
@@ -0,0 +1,207 @@
+/*      $OpenBSD: inet_pton.c,v 1.6 2005/08/06 20:30:03 espie Exp $     */
+
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static int      inet_pton4(const char *src, u_char *dst);
+static int      inet_pton6(const char *src, u_char *dst);
+
+/* int
+ * inet_pton(af, src, dst)
+ *      convert from presentation format (which usually means ASCII printable)
+ *      to network format (which is usually some kind of binary format).
+ * return:
+ *      1 if the address was valid for the specified address family
+ *      0 if the address wasn't valid (`dst' is untouched in this case)
+ *      -1 if some other error occurred (`dst' is untouched in this case, too)
+ * author:
+ *      Paul Vixie, 1996.
+ */
+int
+inet_pton(int af, const char *src, void *dst)
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_pton4(src, dst));
+        case AF_INET6:
+                return (inet_pton6(src, dst));
+        default:
+                errno = EAFNOSUPPORT;
+                return (-1);
+        }
+        /* NOTREACHED */
+}
+
+/* int
+ * inet_pton4(src, dst)
+ *      like inet_aton() but without all the hexadecimal and shorthand.
+ * return:
+ *      1 if `src' is a valid dotted quad, else 0.
+ * notice:
+ *      does not touch `dst' unless it's returning 1.
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static int
+inet_pton4(const char *src, u_char *dst)
+{
+        static const char digits[] = "0123456789";
+        int saw_digit, octets, ch;
+        u_char tmp[INADDRSZ], *tp;
+
+        saw_digit = 0;
+        octets = 0;
+        *(tp = tmp) = 0;
+        while ((ch = *src++) != '\0') {
+                const char *pch;
+
+                if ((pch = strchr(digits, ch)) != NULL) {
+                        u_int new = *tp * 10 + (pch - digits);
+
+                        if (new > 255)
+                                return (0);
+                        if (! saw_digit) {
+                                if (++octets > 4)
+                                        return (0);
+                                saw_digit = 1;
+                        }
+                        *tp = new;
+                } else if (ch == '.' && saw_digit) {
+                        if (octets == 4)
+                                return (0);
+                        *++tp = 0;
+                        saw_digit = 0;
+                } else
+                        return (0);
+        }
+        if (octets < 4)
+                return (0);
+
+        memcpy(dst, tmp, INADDRSZ);
+        return (1);
+}
+
+/* int
+ * inet_pton6(src, dst)
+ *      convert presentation level address to network order binary form.
+ * return:
+ *      1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *      (1) does not touch `dst' unless it's returning 1.
+ *      (2) :: in a full address is silently ignored.
+ * credit:
+ *      inspired by Mark Andrews.
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static int
+inet_pton6(const char *src, u_char *dst)
+{
+        static const char xdigits_l[] = "0123456789abcdef",
+                          xdigits_u[] = "0123456789ABCDEF";
+        u_char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
+        const char *xdigits, *curtok;
+        int ch, saw_xdigit;
+        u_int val;
+
+        memset((tp = tmp), '\0', IN6ADDRSZ);
+        endp = tp + IN6ADDRSZ;
+        colonp = NULL;
+        /* Leading :: requires some special handling. */
+        if (*src == ':')
+                if (*++src != ':')
+                        return (0);
+        curtok = src;
+        saw_xdigit = 0;
+        val = 0;
+        while ((ch = *src++) != '\0') {
+                const char *pch;
+
+                if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+                        pch = strchr((xdigits = xdigits_u), ch);
+                if (pch != NULL) {
+                        val <<= 4;
+                        val |= (pch - xdigits);
+                        if (val > 0xffff)
+                                return (0);
+                        saw_xdigit = 1;
+                        continue;
+                }
+                if (ch == ':') {
+                        curtok = src;
+                        if (!saw_xdigit) {
+                                if (colonp)
+                                        return (0);
+                                colonp = tp;
+                                continue;
+                        } else if (*src == '\0') {
+                                return (0);
+                        }
+                        if (tp + INT16SZ > endp)
+                                return (0);
+                        *tp++ = (u_char) (val >> 8) & 0xff;
+                        *tp++ = (u_char) val & 0xff;
+                        saw_xdigit = 0;
+                        val = 0;
+                        continue;
+                }
+                if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
+                    inet_pton4(curtok, tp) > 0) {
+                        tp += INADDRSZ;
+                        saw_xdigit = 0;
+                        break;  /* '\0' was seen by inet_pton4(). */
+                }
+                return (0);
+        }
+        if (saw_xdigit) {
+                if (tp + INT16SZ > endp)
+                        return (0);
+                *tp++ = (u_char) (val >> 8) & 0xff;
+                *tp++ = (u_char) val & 0xff;
+        }
+        if (colonp != NULL) {
+                /*
+                 * Since some memmove()'s erroneously fail to handle
+                 * overlapping regions, we'll do the shift by hand.
+                 */
+                const int n = tp - colonp;
+                int i;
+
+                for (i = 1; i <= n; i++) {
+                        endp[- i] = colonp[n - i];
+                        colonp[n - i] = 0;
+                }
+                tp = endp;
+        }
+        if (tp != endp)
+                return (0);
+        memcpy(dst, tmp, IN6ADDRSZ);
+        return (1);
+}
diff --git a/src/lib/libc/net/ip6opt.c b/src/lib/libc/net/ip6opt.c
new file mode 100644
index 0000000000..565c0ed369
--- /dev/null
+++ b/src/lib/libc/net/ip6opt.c
@@ -0,0 +1,371 @@
+/*      $OpenBSD: ip6opt.c,v 1.2 2005/03/25 13:24:12 otto Exp $ */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 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/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+
+#include <string.h>
+#include <stdio.h>
+
+static int ip6optlen(u_int8_t *opt, u_int8_t *lim);
+static void inet6_insert_padopt(u_char *p, int len);
+
+/*
+ * This function returns the number of bytes required to hold an option
+ * when it is stored as ancillary data, including the cmsghdr structure
+ * at the beginning, and any padding at the end (to make its size a
+ * multiple of 8 bytes).  The argument is the size of the structure
+ * defining the option, which must include any pad bytes at the
+ * beginning (the value y in the alignment term "xn + y"), the type
+ * byte, the length byte, and the option data.
+ */
+int
+inet6_option_space(int nbytes)
+{
+        nbytes += 2;    /* we need space for nxt-hdr and length fields */
+        return(CMSG_SPACE((nbytes + 7) & ~7));
+}
+
+/*
+ * This function is called once per ancillary data object that will
+ * contain either Hop-by-Hop or Destination options.  It returns 0 on
+ * success or -1 on an error.
+ */
+int
+inet6_option_init(void *bp, struct cmsghdr **cmsgp, int type)
+{
+        struct cmsghdr *ch = (struct cmsghdr *)bp;
+
+        /* argument validation */
+        if (type != IPV6_HOPOPTS && type != IPV6_DSTOPTS)
+                return(-1);
+        
+        ch->cmsg_level = IPPROTO_IPV6;
+        ch->cmsg_type = type;
+        ch->cmsg_len = CMSG_LEN(0);
+
+        *cmsgp = ch;
+        return(0);
+}
+
+/*
+ * This function appends a Hop-by-Hop option or a Destination option
+ * into an ancillary data object that has been initialized by
+ * inet6_option_init().  This function returns 0 if it succeeds or -1 on
+ * an error.
+ * multx is the value x in the alignment term "xn + y" described
+ * earlier.  It must have a value of 1, 2, 4, or 8.
+ * plusy is the value y in the alignment term "xn + y" described
+ * earlier.  It must have a value between 0 and 7, inclusive.
+ */
+int
+inet6_option_append(struct cmsghdr *cmsg, const u_int8_t *typep, int multx,
+    int plusy)
+{
+        int padlen, optlen, off;
+        u_char *bp = (u_char *)cmsg + cmsg->cmsg_len;
+        struct ip6_ext *eh = (struct ip6_ext *)CMSG_DATA(cmsg);
+
+        /* argument validation */
+        if (multx != 1 && multx != 2 && multx != 4 && multx != 8)
+                return(-1);
+        if (plusy < 0 || plusy > 7)
+                return(-1);
+        if (typep[0] > 255)
+                return(-1);
+
+        /*
+         * If this is the first option, allocate space for the
+         * first 2 bytes(for next header and length fields) of
+         * the option header.
+         */
+        if (bp == (u_char *)eh) {
+                bp += 2;
+                cmsg->cmsg_len += 2;
+        }
+
+        /* calculate pad length before the option. */
+        off = bp - (u_char *)eh;
+        padlen = (((off % multx) + (multx - 1)) & ~(multx - 1)) -
+                (off % multx);
+        padlen += plusy;
+        padlen %= multx;        /* keep the pad as short as possible */
+        /* insert padding */
+        inet6_insert_padopt(bp, padlen);
+        cmsg->cmsg_len += padlen;
+        bp += padlen;
+
+        /* copy the option */
+        if (typep[0] == IP6OPT_PAD1)
+                optlen = 1;
+        else
+                optlen = typep[1] + 2;
+        memcpy(bp, typep, optlen);
+        bp += optlen;
+        cmsg->cmsg_len += optlen;
+
+        /* calculate pad length after the option and insert the padding */
+        off = bp - (u_char *)eh;
+        padlen = ((off + 7) & ~7) - off;
+        inet6_insert_padopt(bp, padlen);
+        bp += padlen;
+        cmsg->cmsg_len += padlen;
+
+        /* update the length field of the ip6 option header */
+        eh->ip6e_len = ((bp - (u_char *)eh) >> 3) - 1;
+
+        return(0);
+}
+
+/*
+ * This function appends a Hop-by-Hop option or a Destination option
+ * into an ancillary data object that has been initialized by
+ * inet6_option_init().  This function returns a pointer to the 8-bit
+ * option type field that starts the option on success, or NULL on an
+ * error.
+ * The difference between this function and inet6_option_append() is
+ * that the latter copies the contents of a previously built option into
+ * the ancillary data object while the current function returns a
+ * pointer to the space in the data object where the option's TLV must
+ * then be built by the caller.
+ * 
+ */
+u_int8_t *
+inet6_option_alloc(struct cmsghdr *cmsg, int datalen, int multx, int plusy)
+{
+        int padlen, off;
+        u_int8_t *bp = (u_char *)cmsg + cmsg->cmsg_len;
+        u_int8_t *retval;
+        struct ip6_ext *eh = (struct ip6_ext *)CMSG_DATA(cmsg);
+
+        /* argument validation */
+        if (multx != 1 && multx != 2 && multx != 4 && multx != 8)
+                return(NULL);
+        if (plusy < 0 || plusy > 7)
+                return(NULL);
+
+        /*
+         * If this is the first option, allocate space for the
+         * first 2 bytes(for next header and length fields) of
+         * the option header.
+         */
+        if (bp == (u_char *)eh) {
+                bp += 2;
+                cmsg->cmsg_len += 2;
+        }
+
+        /* calculate pad length before the option. */
+        off = bp - (u_char *)eh;
+        padlen = (((off % multx) + (multx - 1)) & ~(multx - 1)) -
+                (off % multx);
+        padlen += plusy;
+        padlen %= multx;        /* keep the pad as short as possible */
+        /* insert padding */
+        inet6_insert_padopt(bp, padlen);
+        cmsg->cmsg_len += padlen;
+        bp += padlen;
+
+        /* keep space to store specified length of data */
+        retval = bp;
+        bp += datalen;
+        cmsg->cmsg_len += datalen;
+
+        /* calculate pad length after the option and insert the padding */
+        off = bp - (u_char *)eh;
+        padlen = ((off + 7) & ~7) - off;
+        inet6_insert_padopt(bp, padlen);
+        bp += padlen;
+        cmsg->cmsg_len += padlen;
+
+        /* update the length field of the ip6 option header */
+        eh->ip6e_len = ((bp - (u_char *)eh) >> 3) - 1;
+
+        return(retval);
+}
+
+/*
+ * This function processes the next Hop-by-Hop option or Destination
+ * option in an ancillary data object.  If another option remains to be
+ * processed, the return value of the function is 0 and *tptrp points to
+ * the 8-bit option type field (which is followed by the 8-bit option
+ * data length, followed by the option data).  If no more options remain
+ * to be processed, the return value is -1 and *tptrp is NULL.  If an
+ * error occurs, the return value is -1 and *tptrp is not NULL.
+ * (RFC 2292, 6.3.5)
+ */
+int
+inet6_option_next(const struct cmsghdr *cmsg, u_int8_t **tptrp)
+{
+        struct ip6_ext *ip6e;
+        int hdrlen, optlen;
+        u_int8_t *lim;
+
+        if (cmsg->cmsg_level != IPPROTO_IPV6 ||
+            (cmsg->cmsg_type != IPV6_HOPOPTS &&
+             cmsg->cmsg_type != IPV6_DSTOPTS))
+                return(-1);
+
+        /* message length validation */
+        if (cmsg->cmsg_len < CMSG_SPACE(sizeof(struct ip6_ext)))
+                return(-1);
+        ip6e = (struct ip6_ext *)CMSG_DATA(cmsg);
+        hdrlen = (ip6e->ip6e_len + 1) << 3;
+        if (cmsg->cmsg_len < CMSG_SPACE(hdrlen))
+                return(-1);
+
+        /*
+         * If the caller does not specify the starting point,
+         * simply return the 1st option.
+         * Otherwise, search the option list for the next option.
+         */
+        lim = (u_int8_t *)ip6e + hdrlen;
+        if (*tptrp == NULL)
+                *tptrp = (u_int8_t *)(ip6e + 1);
+        else {
+                if ((optlen = ip6optlen(*tptrp, lim)) == 0)
+                        return(-1);
+
+                *tptrp = *tptrp + optlen;
+        }
+        if (*tptrp >= lim) {    /* there is no option */
+                *tptrp = NULL;
+                return(-1);
+        }
+        /*
+         * Finally, checks if the next option is safely stored in the
+         * cmsg data.
+         */
+        if (ip6optlen(*tptrp, lim) == 0)
+                return(-1);
+        else
+                return(0);
+}
+
+/*
+ * This function is similar to the inet6_option_next() function,
+ * except this function lets the caller specify the option type to be
+ * searched for, instead of always returning the next option in the
+ * ancillary data object.
+ * Note: RFC 2292 says the type of tptrp is u_int8_t *, but we think
+ *       it's a typo. The variable should be type of u_int8_t **.
+ */
+int
+inet6_option_find(const struct cmsghdr *cmsg, u_int8_t **tptrp, int type)
+{
+        struct ip6_ext *ip6e;
+        int hdrlen, optlen;
+        u_int8_t *optp, *lim;
+
+        if (cmsg->cmsg_level != IPPROTO_IPV6 ||
+            (cmsg->cmsg_type != IPV6_HOPOPTS &&
+             cmsg->cmsg_type != IPV6_DSTOPTS))
+                return(-1);
+
+        /* message length validation */
+        if (cmsg->cmsg_len < CMSG_SPACE(sizeof(struct ip6_ext)))
+                return(-1);
+        ip6e = (struct ip6_ext *)CMSG_DATA(cmsg);
+        hdrlen = (ip6e->ip6e_len + 1) << 3;
+        if (cmsg->cmsg_len < CMSG_SPACE(hdrlen))
+                return(-1);     
+
+        /*
+         * If the caller does not specify the starting point,
+         * search from the beginning of the option list.
+         * Otherwise, search from *the next option* of the specified point.
+         */
+        lim = (u_int8_t *)ip6e + hdrlen;
+        if (*tptrp == NULL)
+                *tptrp = (u_int8_t *)(ip6e + 1);
+        else {
+                if ((optlen = ip6optlen(*tptrp, lim)) == 0)
+                        return(-1);
+
+                *tptrp = *tptrp + optlen;
+        }
+        for (optp = *tptrp; optp < lim; optp += optlen) {
+                if (*optp == type) {
+                        *tptrp = optp;
+                        return(0);
+                }
+                if ((optlen = ip6optlen(optp, lim)) == 0)
+                        return(-1);
+        }
+
+        /* search failed */
+        *tptrp = NULL;
+        return(-1);
+}
+
+/*
+ * Calculate the length of a given IPv6 option. Also checks
+ * if the option is safely stored in user's buffer according to the
+ * calculated length and the limitation of the buffer.
+ */
+static int
+ip6optlen(u_int8_t *opt, u_int8_t *lim)
+{
+        int optlen;
+
+        if (*opt == IP6OPT_PAD1)
+                optlen = 1;
+        else {
+                /* is there enough space to store type and len? */
+                if (opt + 2 > lim)
+                        return(0);
+                optlen = *(opt + 1) + 2;
+        }
+        if (opt + optlen <= lim)
+                return(optlen);
+
+        return(0);
+}
+
+static void
+inet6_insert_padopt(u_char *p, int len)
+{
+        switch(len) {
+         case 0:
+                 return;
+         case 1:
+                 p[0] = IP6OPT_PAD1;
+                 return;
+         default:
+                 p[0] = IP6OPT_PADN;
+                 p[1] = len - 2; 
+                 memset(&p[2], 0, len - 2);
+                 return;
+        }
+}
diff --git a/src/lib/libc/net/ipx.3 b/src/lib/libc/net/ipx.3
new file mode 100644
index 0000000000..503483bfab
--- /dev/null
+++ b/src/lib/libc/net/ipx.3
@@ -0,0 +1,122 @@
+.\"     $OpenBSD: ipx.3,v 1.11 2005/06/09 08:40:49 jmc Exp $
+.\"
+.\" Copyright (c) 1986, 1991, 1993
+.\"     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.
+.\"
+.Dd June 4, 1993
+.Dt IPX 3
+.Os
+.Sh NAME
+.Nm ipx_addr ,
+.Nm ipx_ntoa
+.Nd IPX address conversion routines
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <netipx/ipx.h>
+.Ft struct ipx_addr
+.Fn ipx_addr "const char *cp"
+.Ft char *
+.Fn ipx_ntoa "struct ipx_addr ipx"
+.Sh DESCRIPTION
+The routine
+.Fn ipx_addr
+interprets character strings representing
+.Tn IPX
+addresses, returning binary information suitable
+for use in system calls.
+The routine
+.Fn ipx_ntoa
+takes
+.Tn IPX
+addresses and returns
+.Tn ASCII
+strings representing the address in a
+notation in common use:
+.Bd -filled -offset indent
+<network number>.<host number>.<port number>
+.Ed
+.Pp
+Trailing zero fields are suppressed, and each number is printed in hexadecimal,
+in a format suitable for input to
+.Fn ipx_addr .
+Any fields lacking super-decimal digits will have a
+trailing
+.Sq H
+appended.
+.Pp
+An effort has been made to ensure that
+.Fn ipx_addr
+be compatible with most formats in common use.
+It will first separate an address into 1 to 3 fields using a single delimiter
+chosen from
+period
+.Pq Ql \&. ,
+colon
+.Pq Ql \&: ,
+or pound-sign
+.Pq Ql # .
+Each field is then examined for byte separators (colon or period).
+If there are byte separators, each subfield separated is taken to be
+a small hexadecimal number, and the entirety is taken as a network-byte-ordered
+quantity to be zero extended in the high-network-order bytes.
+Next, the field is inspected for hyphens, in which case
+the field is assumed to be a number in decimal notation
+with hyphens separating the millenia.
+Next, the field is assumed to be a number:
+It is interpreted
+as hexadecimal if there is a leading
+.Ql 0x
+(as in C),
+a trailing
+.Sq H
+(as in Mesa), or there are any super-decimal digits present.
+It is interpreted as octal if there is a leading
+.Ql 0
+and there are no super-octal digits.
+Otherwise, it is converted as a decimal number.
+.Sh RETURN VALUES
+None.
+(See
+.Sx BUGS . )
+.Sh SEE ALSO
+.Xr hosts 5 ,
+.Xr networks 5
+.Sh HISTORY
+The precursor
+.Fn ns_addr
+and
+.Fn ns_ntoa
+functions appeared in
+.Bx 4.3 .
+.Sh BUGS
+The string returned by
+.Fn ipx_ntoa
+resides in a static memory area.
+The function
+.Fn ipx_addr
+should diagnose improperly formed input, and there should be an unambiguous
+way to recognize this.
diff --git a/src/lib/libc/net/ipx_addr.c b/src/lib/libc/net/ipx_addr.c
new file mode 100644
index 0000000000..b65d5f6cfd
--- /dev/null
+++ b/src/lib/libc/net/ipx_addr.c
@@ -0,0 +1,213 @@
+/*      $OpenBSD: ipx_addr.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1986, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * J.Q. Johnson.
+ *
+ * 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.
+ *
+ * from @(#)ipx_addr.c
+ */
+
+#include <sys/param.h>
+#include <netipx/ipx.h>
+#include <stdio.h>
+#include <string.h>
+
+static struct ipx_addr addr, zero_addr;
+
+static void Field(char *, u_char *, int);
+static void cvtbase(long, int, int *, int, unsigned char *, int);
+
+struct ipx_addr 
+ipx_addr(const char *name)
+{
+        char separator;
+        char *hostname, *socketname, *cp;
+        char buf[50];
+
+        strlcpy(buf, name, sizeof(buf));
+
+        /*
+         * First, figure out what he intends as a field separtor.
+         * Despite the way this routine is written, the prefered
+         * form  2-272.AA001234H.01777, i.e. XDE standard.
+         * Great efforts are made to insure backward compatibility.
+         */
+        if ((hostname = strchr(buf, '#')))
+                separator = '#';
+        else {
+                hostname = strchr(buf, '.');
+                if ((cp = strchr(buf, ':')) &&
+                    ((hostname && cp < hostname) || (hostname == 0))) {
+                        hostname = cp;
+                        separator = ':';
+                } else
+                        separator = '.';
+        }
+        if (hostname)
+                *hostname++ = 0;
+
+        addr = zero_addr;
+        Field(buf, addr.ipx_net.c_net, 4);
+        if (hostname == 0)
+                return (addr);  /* No separator means net only */
+
+        socketname = strchr(hostname, separator);
+        if (socketname) {
+                *socketname++ = 0;
+                Field(socketname, (u_char *)&addr.ipx_port, 2);
+        }
+
+        Field(hostname, addr.ipx_host.c_host, 6);
+
+        return (addr);
+}
+
+static void
+Field(char *buf, u_char *out, int len)
+{
+        char *bp = buf;
+        int i, ibase, base16 = 0, base10 = 0, clen = 0;
+        int hb[6], *hp;
+        char *fmt;
+
+        /*
+         * first try 2-273#2-852-151-014#socket
+         */
+        if ((*buf != '-') &&
+            (1 < (i = sscanf(buf, "%d-%d-%d-%d-%d",
+                        &hb[0], &hb[1], &hb[2], &hb[3], &hb[4])))) {
+                cvtbase(1000L, 256, hb, i, out, len);
+                return;
+        }
+        /*
+         * try form 8E1#0.0.AA.0.5E.E6#socket
+         */
+        if (1 < (i = sscanf(buf,"%x.%x.%x.%x.%x.%x",
+                        &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
+                cvtbase(256L, 256, hb, i, out, len);
+                return;
+        }
+        /*
+         * try form 8E1#0:0:AA:0:5E:E6#socket
+         */
+        if (1 < (i = sscanf(buf,"%x:%x:%x:%x:%x:%x",
+                        &hb[0], &hb[1], &hb[2], &hb[3], &hb[4], &hb[5]))) {
+                cvtbase(256L, 256, hb, i, out, len);
+                return;
+        }
+        /*
+         * This is REALLY stretching it but there was a
+         * comma notation separting shorts -- definitely non standard
+         */
+        if (1 < (i = sscanf(buf,"%x,%x,%x",
+                        &hb[0], &hb[1], &hb[2]))) {
+                hb[0] = htons(hb[0]); hb[1] = htons(hb[1]);
+                hb[2] = htons(hb[2]);
+                cvtbase(65536L, 256, hb, i, out, len);
+                return;
+        }
+
+        /* Need to decide if base 10, 16 or 8 */
+        while (*bp) switch (*bp++) {
+
+        case '0': case '1': case '2': case '3': case '4': case '5':
+        case '6': case '7': case '-':
+                break;
+
+        case '8': case '9':
+                base10 = 1;
+                break;
+
+        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                base16 = 1;
+                break;
+        
+        case 'x': case 'X':
+                *--bp = '0';
+                base16 = 1;
+                break;
+
+        case 'h': case 'H':
+                base16 = 1;
+                /* fall into */
+
+        default:
+                *--bp = 0; /* Ends Loop */
+        }
+        if (base16) {
+                fmt = "%3x";
+                ibase = 4096;
+        } else if (base10 == 0 && *buf == '0') {
+                fmt = "%3o";
+                ibase = 512;
+        } else {
+                fmt = "%3d";
+                ibase = 1000;
+        }
+
+        for (bp = buf; *bp++; ) clen++;
+        if (clen == 0) clen++;
+        if (clen > 18) clen = 18;
+        i = ((clen - 1) / 3) + 1;
+        bp = clen + buf - 3;
+        hp = hb + i - 1;
+
+        while (hp > hb) {
+                (void)sscanf(bp, fmt, hp);
+                bp[0] = 0;
+                hp--;
+                bp -= 3;
+        }
+        (void)sscanf(buf, fmt, hp);
+        cvtbase((long)ibase, 256, hb, i, out, len);
+}
+
+static void
+cvtbase(long oldbase, int newbase, int *input, int inlen,
+    unsigned char *result, int reslen)
+{
+        int d, e;
+        long sum;
+
+        e = 1;
+        while (e > 0 && reslen > 0) {
+                d = 0; e = 0; sum = 0;
+                /* long division: input=input/newbase */
+                while (d < inlen) {
+                        sum = sum*oldbase + (long) input[d];
+                        e += (sum > 0);
+                        input[d++] = sum / newbase;
+                        sum %= newbase;
+                }
+                result[--reslen] = sum; /* accumulate remainder */
+        }
+        for (d=0; d < reslen; d++)
+                result[d] = 0;
+}
diff --git a/src/lib/libc/net/ipx_ntoa.c b/src/lib/libc/net/ipx_ntoa.c
new file mode 100644
index 0000000000..9b1b6a1c49
--- /dev/null
+++ b/src/lib/libc/net/ipx_ntoa.c
@@ -0,0 +1,46 @@
+/*      $OpenBSD: ipx_ntoa.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1986, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <netipx/ipx.h>
+#include <stdio.h>
+
+char *
+ipx_ntoa(struct ipx_addr addr)
+{
+        static char obuf[] = "xxxxxxxxH.xx:xx:xx:xx:xx:xx.uuuuu";
+
+        snprintf(obuf, sizeof obuf, "%8xH.%02x:%02x:%02x:%02x:%02x:%02x.%u",
+            ntohl(addr.ipx_net.l_net), addr.ipx_host.c_host[0],
+            addr.ipx_host.c_host[1], addr.ipx_host.c_host[2],
+            addr.ipx_host.c_host[3], addr.ipx_host.c_host[4],
+            addr.ipx_host.c_host[5], ntohs(addr.ipx_port));
+        return (obuf);
+}
diff --git a/src/lib/libc/net/link_addr.3 b/src/lib/libc/net/link_addr.3
new file mode 100644
index 0000000000..fc1fd85257
--- /dev/null
+++ b/src/lib/libc/net/link_addr.3
@@ -0,0 +1,127 @@
+.\"     $OpenBSD: link_addr.3,v 1.11 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Donn Seeley at BSDI.
+.\"
+.\" 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.
+.\"
+.Dd July 28, 1993
+.Dt LINK_ADDR 3
+.Os
+.Sh NAME
+.Nm link_addr ,
+.Nm link_ntoa
+.Nd elementary address specification routines for link level access
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <net/if_dl.h>
+.Ft void
+.Fn link_addr "const char *addr" "struct sockaddr_dl *sdl"
+.Ft char *
+.Fn link_ntoa "const struct sockaddr_dl *sdl"
+.Sh DESCRIPTION
+The
+.Fn link_addr
+function interprets character strings representing
+link-level addresses, returning binary information suitable
+for use in system calls.
+.Fn link_ntoa
+takes
+a link-level
+address and returns an
+.Tn ASCII
+string representing some of the information present,
+including the link level address itself, and the interface name
+or number, if present.
+This facility is experimental and is
+still subject to change.
+.Pp
+For
+.Fn link_addr ,
+the string
+.Fa addr
+may contain
+an optional network interface identifier of the form
+.Dq name unit-number ,
+suitable for the first argument to
+.Xr ifconfig 8 ,
+followed in all cases by a colon and
+an interface address in the form of
+groups of hexadecimal digits
+separated by periods.
+Each group represents a byte of address;
+address bytes are filled left to right from
+low order bytes through high order bytes.
+.Pp
+.\" A regular expression may make this format clearer:
+.\" .Bd -literal -offset indent
+.\" ([a-z]+[0-9]+:)?[0-9a-f]+(\e.[0-9a-f]+)*
+.\" .Ed
+.\" .Pp
+Thus
+.Li le0:8.0.9.13.d.30
+represents an Ethernet address
+to be transmitted on the first Lance Ethernet interface.
+.Sh RETURN VALUES
+.Fn link_ntoa
+always returns a NUL-terminated string.
+.Fn link_addr
+has no return value.
+(See
+.Sx BUGS . )
+.Sh SEE ALSO
+.Xr ifconfig 8
+.Sh HISTORY
+The
+.Fn link_addr
+and
+.Fn link_ntoa
+functions appeared in
+.Bx 4.3 Reno .
+.Sh BUGS
+The returned values for
+.Fn link_ntoa
+reside in a static memory area.
+.Pp
+The function
+.Fn link_addr
+should diagnose improperly formed input, and there should be an unambiguous
+way to recognize this.
+.Pp
+If the
+.Fa sdl_len
+field of the link socket address
+.Fa sdl
+is 0,
+.Fn link_ntoa
+will not insert a colon before the interface address bytes.
+If this translated address is given to
+.Fn link_addr
+without inserting an initial colon,
+the latter will not interpret it correctly.
diff --git a/src/lib/libc/net/linkaddr.c b/src/lib/libc/net/linkaddr.c
new file mode 100644
index 0000000000..ac96f3acdf
--- /dev/null
+++ b/src/lib/libc/net/linkaddr.c
@@ -0,0 +1,148 @@
+/*      $OpenBSD: linkaddr.c,v 1.5 2005/08/06 20:30:03 espie Exp $ */
+/*-
+ * Copyright (c) 1990, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>
+#include <string.h>
+
+/* States*/
+#define NAMING  0
+#define GOTONE  1
+#define GOTTWO  2
+#define RESET   3
+/* Inputs */
+#define DIGIT   (4*0)
+#define END     (4*1)
+#define DELIM   (4*2)
+#define LETTER  (4*3)
+
+void
+link_addr(const char *addr, struct sockaddr_dl *sdl)
+{
+        char *cp = sdl->sdl_data;
+        char *cplim = sdl->sdl_len + (char *)sdl;
+        int byte = 0, state = NAMING, new;
+
+        bzero((char *)&sdl->sdl_family, sdl->sdl_len - 1);
+        sdl->sdl_family = AF_LINK;
+        do {
+                state &= ~LETTER;
+                if ((*addr >= '0') && (*addr <= '9')) {
+                        new = *addr - '0';
+                } else if ((*addr >= 'a') && (*addr <= 'f')) {
+                        new = *addr - 'a' + 10;
+                } else if ((*addr >= 'A') && (*addr <= 'F')) {
+                        new = *addr - 'A' + 10;
+                } else if (*addr == 0) {
+                        state |= END;
+                } else if (state == NAMING &&
+                           (((*addr >= 'A') && (*addr <= 'Z')) ||
+                           ((*addr >= 'a') && (*addr <= 'z'))))
+                        state |= LETTER;
+                else
+                        state |= DELIM;
+                addr++;
+                switch (state /* | INPUT */) {
+                case NAMING | DIGIT:
+                case NAMING | LETTER:
+                        *cp++ = addr[-1];
+                        continue;
+                case NAMING | DELIM:
+                        state = RESET;
+                        sdl->sdl_nlen = cp - sdl->sdl_data;
+                        continue;
+                case GOTTWO | DIGIT:
+                        *cp++ = byte;
+                        /* FALLTHROUGH */
+                case RESET | DIGIT:
+                        state = GOTONE;
+                        byte = new;
+                        continue;
+                case GOTONE | DIGIT:
+                        state = GOTTWO;
+                        byte = new + (byte << 4);
+                        continue;
+                default: /* | DELIM */
+                        state = RESET;
+                        *cp++ = byte;
+                        byte = 0;
+                        continue;
+                case GOTONE | END:
+                case GOTTWO | END:
+                        *cp++ = byte;
+                        /* FALLTHROUGH */
+                case RESET | END:
+                        break;
+                }
+                break;
+        } while (cp < cplim); 
+        sdl->sdl_alen = cp - LLADDR(sdl);
+        new = cp - (char *)sdl;
+        if (new > sizeof(*sdl))
+                sdl->sdl_len = new;
+        return;
+}
+
+static char hexlist[] = "0123456789abcdef";
+
+char *
+link_ntoa(const struct sockaddr_dl *sdl)
+{
+        static char obuf[64];
+        char *out = obuf; 
+        int i;
+        u_char *in = (u_char *)LLADDR(sdl);
+        u_char *inlim = in + sdl->sdl_alen;
+        int firsttime = 1;
+
+        if (sdl->sdl_nlen) {
+                bcopy(sdl->sdl_data, obuf, sdl->sdl_nlen);
+                out += sdl->sdl_nlen;
+                if (sdl->sdl_alen)
+                        *out++ = ':';
+        }
+        while (in < inlim) {
+                if (firsttime)
+                        firsttime = 0;
+                else
+                        *out++ = '.';
+                i = *in++;
+                if (i > 0xf) {
+                        out[1] = hexlist[i & 0xf];
+                        i >>= 4;
+                        out[0] = hexlist[i];
+                        out += 2;
+                } else
+                        *out++ = hexlist[i];
+        }
+        *out = 0;
+        return (obuf);
+}
diff --git a/src/lib/libc/net/net_addrcmp.3 b/src/lib/libc/net/net_addrcmp.3
new file mode 100644
index 0000000000..f1ce4c8cd1
--- /dev/null
+++ b/src/lib/libc/net/net_addrcmp.3
@@ -0,0 +1,91 @@
+.\"     $OpenBSD: net_addrcmp.3,v 1.3 2001/08/07 06:53:27 deraadt Exp $
+.\"
+.\" Copyright (c) 1999 Theo de Raadt
+.\"
+.\" 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.
+.\"
+.\" 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.
+.\"
+.Dd July 3, 1999
+.Dt NET_ADDRCMP 3
+.Os
+.Sh NAME
+.Nm net_addrcmp
+.Nd compare socket address structures
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft int
+.Fn net_addrcmp "struct sockaddr *sa1" "struct sockaddr *sa2"
+.Sh DESCRIPTION
+The
+.Fn net_addrcmp
+function compares two socket address structures,
+.Fa sa1
+and
+.Fa sa2 .
+.Sh RETURN VALUES
+If
+.Fa sa1
+and
+.Fa sa2
+are for the same address,
+.Fn net_addrcmp
+returns 0.
+.Pp
+The
+.Fa sa_len
+fields are compared first.
+If they do not match,
+.Fn net_addrcmp
+returns \-1 or 1 if
+.Li sa1->sa_len
+is less than or greater than
+.Li sa2->sa_len ,
+respectively.
+.Pp
+Next, the
+.Fa sa_family
+members are compared.
+If they do not match,
+.Fn net_addrcmp
+returns \-1 or 1 if
+.Li sa1->sa_family
+is less than or greater than
+.Li sa2->sa_family ,
+respectively.
+.Pp
+Lastly, if each socket address structure's
+.Fa sa_len
+and
+.Fa sa_family
+fields match,
+the protocol-specific data (the
+.Fa sa_data
+field) is compared.
+If there's a match, both
+.Fa sa1
+and
+.Fa sa2
+must refer to the same address, and 0 is returned; otherwise, a value >0
+or <0 is returned.
+.Sh HISTORY
+A
+.Fn net_addrcmp
+function was added in
+.Ox 2.5 .
diff --git a/src/lib/libc/net/net_addrcmp.c b/src/lib/libc/net/net_addrcmp.c
new file mode 100644
index 0000000000..c2630a5265
--- /dev/null
+++ b/src/lib/libc/net/net_addrcmp.c
@@ -0,0 +1,63 @@
+/*      $OpenBSD: net_addrcmp.c,v 1.10 2005/06/17 20:36:16 henning Exp $        */
+
+/*
+ * Copyright (c) 1999 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:
+ * 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.
+ *
+ * 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 <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <string.h>
+
+int
+net_addrcmp(struct sockaddr *sa1, struct sockaddr *sa2)
+{
+
+        if (sa1->sa_len != sa2->sa_len)
+                return (sa1->sa_len < sa2->sa_len) ? -1 : 1;
+        if (sa1->sa_family != sa2->sa_family)
+                return (sa1->sa_family < sa2->sa_family) ? -1 : 1;
+
+        switch(sa1->sa_family) {
+        case AF_INET:
+                return (memcmp(&((struct sockaddr_in *)sa1)->sin_addr,
+                    &((struct sockaddr_in *)sa2)->sin_addr,
+                    sizeof(struct in_addr)));
+        case AF_INET6:
+                if (((struct sockaddr_in6 *)sa1)->sin6_scope_id !=
+                    ((struct sockaddr_in6 *)sa2)->sin6_scope_id)
+                        return (((struct sockaddr_in6 *)sa1)->sin6_scope_id < 
+                            ((struct sockaddr_in6 *)sa2)->sin6_scope_id)
+                            ? -1 : 1;
+                return memcmp(&((struct sockaddr_in6 *)sa1)->sin6_addr,
+                    &((struct sockaddr_in6 *)sa2)->sin6_addr,
+                    sizeof(struct in6_addr));
+        case AF_LOCAL:
+                return (strcmp(((struct sockaddr_un *)sa1)->sun_path,
+                    ((struct sockaddr_un *)sa1)->sun_path));
+        default:
+                return -1;
+        }
+}
diff --git a/src/lib/libc/net/nsap_addr.c b/src/lib/libc/net/nsap_addr.c
new file mode 100644
index 0000000000..8cfe86f475
--- /dev/null
+++ b/src/lib/libc/net/nsap_addr.c
@@ -0,0 +1,94 @@
+/*      $OpenBSD: nsap_addr.c,v 1.7 2006/03/31 05:35:44 deraadt Exp $   */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM 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 <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <ctype.h>
+#include <resolv.h>
+
+static u_char
+xtob(int c)
+{
+        return (c - (((c >= '0') && (c <= '9')) ? '0' : '7'));
+}
+
+u_int
+inet_nsap_addr(const char *ascii, u_char *binary, int maxlen)
+{
+        u_char c, nib;
+        u_int len = 0;
+
+        while ((c = *ascii++) != '\0' && len < maxlen) {
+                if (c == '.' || c == '+' || c == '/')
+                        continue;
+                if (!isascii(c))
+                        return (0);
+                if (islower(c))
+                        c = (u_char)toupper(c);
+                if (isxdigit(c)) {
+                        nib = xtob(c);
+                        if ((c = *ascii++)) {
+                                c = (u_char)toupper(c);
+                                if (isxdigit(c)) {
+                                        *binary++ = (nib << 4) | xtob(c);
+                                        len++;
+                                } else
+                                        return (0);
+                        }
+                        else
+                                return (0);
+                }
+                else
+                        return (0);
+        }
+        return (len);
+}
+
+char *
+inet_nsap_ntoa(int binlen, const u_char *binary, char *ascii)
+{
+        int nib;
+        int i;
+        static char tmpbuf[255*3];
+        char *start;
+
+        if (ascii)
+                start = ascii;
+        else {
+                ascii = tmpbuf;
+                start = tmpbuf;
+        }
+
+        if (binlen > 255)
+                binlen = 255;
+
+        for (i = 0; i < binlen; i++) {
+                nib = *binary >> 4;
+                *ascii++ = nib + (nib < 10 ? '0' : '7');
+                nib = *binary++ & 0x0f;
+                *ascii++ = nib + (nib < 10 ? '0' : '7');
+                if (((i % 2) == 0 && (i + 1) < binlen))
+                        *ascii++ = '.';
+        }
+        *ascii = '\0';
+        return (start);
+}
diff --git a/src/lib/libc/net/ntohl.c b/src/lib/libc/net/ntohl.c
new file mode 100644
index 0000000000..36414b7a13
--- /dev/null
+++ b/src/lib/libc/net/ntohl.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: ntohl.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <sys/types.h>
+#include <machine/endian.h>
+
+#undef ntohl
+
+u_int32_t
+ntohl(u_int32_t x)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+        u_char *s = (u_char *)&x;
+        return (u_int32_t)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
+#else
+        return x;
+#endif
+}
diff --git a/src/lib/libc/net/ntohs.c b/src/lib/libc/net/ntohs.c
new file mode 100644
index 0000000000..8f345e84ad
--- /dev/null
+++ b/src/lib/libc/net/ntohs.c
@@ -0,0 +1,21 @@
+/*      $OpenBSD: ntohs.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <sys/types.h>
+#include <machine/endian.h>
+
+#undef ntohs
+
+u_int16_t
+ntohs(u_int16_t x)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+        u_char *s = (u_char *) &x;
+        return (u_int16_t)(s[0] << 8 | s[1]);
+#else
+        return x;
+#endif
+}
diff --git a/src/lib/libc/net/rcmd.3 b/src/lib/libc/net/rcmd.3
new file mode 100644
index 0000000000..df31a60b63
--- /dev/null
+++ b/src/lib/libc/net/rcmd.3
@@ -0,0 +1,266 @@
+.\"     $OpenBSD: rcmd.3,v 1.26 2003/06/02 20:18:35 millert Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd June 4, 1993
+.Dt RCMD 3
+.Os
+.Sh NAME
+.Nm rcmd ,
+.Nm rcmd_af ,
+.Nm rresvport ,
+.Nm rresvport_af ,
+.Nm iruserok ,
+.Nm ruserok ,
+.Nm iruserok_sa
+.Nd routines for returning a stream to a remote command
+.Sh SYNOPSIS
+.Fd #include <unistd.h>
+.Ft int
+.Fn rcmd "char **ahost" "int inport" "const char *locuser" "const char *remuser" "const char *cmd" "int *fd2p"
+.Ft int
+.Fn rcmd_af "char **ahost" "int inport" "const char *locuser" "const char *remuser" "const char *cmd" "int *fd2p" "int af"
+.Ft int
+.Fn rresvport "int *port"
+.Ft int
+.Fn rresvport_af "int *port" "int af"
+.Ft int
+.Fn iruserok "u_int32_t raddr" "int superuser" "const char *ruser" "const char *luser"
+.Ft int
+.Fn ruserok "const char *rhost" "int superuser" "const char *ruser" "const char *luser"
+.Ft int
+.Fn iruserok_sa "const void *sa" "int salen" "int superuser" "const char *ruser" "const char *luser"
+.Sh DESCRIPTION
+The
+.Fn rcmd
+function is used by the superuser to execute a command on a remote
+machine using an authentication scheme based on reserved
+port numbers.
+If the calling process is not setuid, the
+.Ev RSH
+environment variable is set, and
+.Fa inport
+is
+.Dq shell/tcp ,
+.Xr rcmdsh 3
+is called instead with the value of
+.Ev RSH .
+Alternately, if the user is not the superuser,
+.Fn rcmd
+will invoke
+.Xr rcmdsh 3
+to run the command via
+.Xr rsh 1 .
+While
+.Fn rcmd
+can handle IPv4 cases only,
+the
+.Fn rcmd_af
+function can handle other cases as well.
+.Pp
+The
+.Fn rresvport
+and
+.Fn rresvport_af
+functions return a descriptor to a socket
+with an address in the privileged port space.
+The
+.Fn iruserok
+and
+.Fn ruserok
+functions are used by servers
+to authenticate clients requesting service with
+.Fn rcmd .
+All four functions are present in the same file and are used
+by the
+.Xr rshd 8
+server (among others).
+.Fn iruserok_sa
+is an address family independent variant of
+.Fn iruserok .
+.Pp
+The
+.Fn rcmd
+function looks up the host
+.Fa *ahost
+using
+.Xr gethostbyname 3 ,
+returning \-1 if the host does not exist.
+Otherwise
+.Fa *ahost
+is set to the standard name of the host
+and a connection is established to a server
+residing at the well-known Internet port
+.Fa inport .
+If the user is not the superuser, the only valid port is
+.Dq shell/tcp
+(usually port 514).
+.Pp
+If the connection succeeds,
+a socket in the Internet domain of type
+.Dv SOCK_STREAM
+is returned to the caller, and given to the remote
+command as stdin and stdout.
+If
+.Fa fd2p
+is non-zero, then an auxiliary channel to a control
+process will be set up, and a descriptor for it will be placed
+in
+.Fa *fd2p .
+The control process will return diagnostic
+output from the command (unit 2) on this channel, and will also
+accept bytes on this channel as being
+.Tn UNIX
+signal numbers, to be
+forwarded to the process group of the command.
+If
+.Fa fd2p
+is
+.Va NULL ,
+then the standard error (unit 2 of the remote command) will be made
+the same as the standard output and no provision is made for sending
+arbitrary signals to the remote process, although you may be able to
+get its attention by using out-of-band data.
+Note that if the user is not the superuser,
+.Fa fd2p
+must be
+.Va NULL .
+.Pp
+.Fn rcmd_af
+takes address family in the last argument.
+If the last argument is
+.Dv PF_UNSPEC ,
+interpretation of
+.Fa *ahost
+will obey the underlying address resolution like DNS.
+.Pp
+The protocol is described in detail in
+.Xr rshd 8 .
+.Pp
+The
+.Fn rresvport
+and
+.Fn rresvport_af
+functions are used to obtain a socket with a privileged
+address bound to it.
+This socket is suitable for use by
+.Fn rcmd
+and several other functions.
+Privileged Internet ports are those in the range 0 to
+.Va IPPORT_RESERVED - 1 ,
+which happens to be 1023.
+Only the superuser is allowed to bind an address of this sort to a socket.
+.Fn rresvport
+and
+.Fn rresvport_af
+need to be seeded with a port number; if that port
+is not available these functions will find another.
+.Pp
+The
+.Fn iruserok
+and
+.Fn ruserok
+functions take a remote host's IP address or name, respectively,
+two user names and a flag indicating whether the local user's
+name is that of the superuser.
+Then, if the user is
+.Em not
+the superuser, it checks the
+.Pa /etc/hosts.equiv
+file.
+If that lookup is not done, or is unsuccessful, the
+.Pa .rhosts
+in the local user's home directory is checked to see if the request for
+service is allowed.
+.Pp
+If this file does not exist, is not a regular file, is owned by anyone
+other than the user or the superuser, or is writeable by anyone other
+than the owner, the check automatically fails.
+Zero is returned if the machine name is listed in the
+.Pa hosts.equiv
+file, or the host and remote user name are found in the
+.Pa .rhosts
+file; otherwise
+.Fn iruserok
+and
+.Fn ruserok
+return \-1.
+If the local domain (as obtained from
+.Xr gethostname 3 )
+is the same as the remote domain, only the machine name need be specified.
+.Pp
+If the IP address of the remote host is known,
+.Fn iruserok
+should be used in preference to
+.Fn ruserok ,
+as it does not require trusting the DNS server for the remote host's domain.
+.Pp
+While
+.Fn iruserok
+can handle IPv4 addresses only,
+.Fn iruserok_sa
+and
+.Fn ruserok
+can handle other address families as well, like IPv6.
+The first argument of
+.Fn iruserok_sa
+is typed as
+.Li "void *"
+to avoid dependency between
+.Aq Pa unistd.h
+and
+.Aq Pa sys/socket.h .
+.Sh DIAGNOSTICS
+The
+.Fn rcmd
+function returns a valid socket descriptor on success.
+It returns \-1 on error and prints a diagnostic message on the standard error.
+.Pp
+The
+.Fn rresvport
+and
+.Fn rresvport_af
+functions return a valid, bound socket descriptor on success.
+It returns \-1 on error with the global value
+.Va errno
+set according to the reason for failure.
+The error code
+.Er EAGAIN
+is overloaded to mean
+.Dq all network ports in use .
+.Sh SEE ALSO
+.Xr rsh 1 ,
+.Xr intro 2 ,
+.Xr bindresvport 3 ,
+.Xr bindresvport_sa 3 ,
+.Xr rcmdsh 3 ,
+.Xr rshd 8
+.Sh HISTORY
+These
+functions appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/net/rcmd.c b/src/lib/libc/net/rcmd.c
new file mode 100644
index 0000000000..e2b9199492
--- /dev/null
+++ b/src/lib/libc/net/rcmd.c
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 1995, 1996, 1998 Theo de Raadt.  All rights reserved.
+ * Copyright (c) 1983, 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.
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <signal.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <syslog.h>
+#include <stdlib.h>
+#include <netgroup.h>
+
+int     __ivaliduser(FILE *, in_addr_t, const char *, const char *);
+int     __ivaliduser_sa(FILE *, struct sockaddr *, socklen_t,
+            const char *, const char *);
+static int __icheckhost(struct sockaddr *, socklen_t, const char *);
+static char *__gethostloop(struct sockaddr *, socklen_t);
+
+int
+rcmd(char **ahost, int rport, const char *locuser, const char *remuser,
+    const char *cmd, int *fd2p)
+{
+        return rcmd_af(ahost, rport, locuser, remuser, cmd, fd2p, AF_INET);
+}
+
+int
+rcmd_af(char **ahost, int porta, const char *locuser, const char *remuser,
+    const char *cmd, int *fd2p, int af)
+{
+        static char hbuf[MAXHOSTNAMELEN];
+        char pbuf[NI_MAXSERV];
+        struct addrinfo hints, *res, *r;
+        int error;
+        struct sockaddr_storage from;
+        fd_set *readsp = NULL;
+        sigset_t oldmask, mask;
+        pid_t pid;
+        int s, lport, timo;
+        char c, *p;
+        int refused;
+        in_port_t rport = porta;
+
+        /* call rcmdsh() with specified remote shell if appropriate. */
+        if (!issetugid() && (p = getenv("RSH")) && *p) {
+                struct servent *sp = getservbyname("shell", "tcp");
+
+                if (sp && sp->s_port == rport)
+                        return (rcmdsh(ahost, rport, locuser, remuser,
+                            cmd, p));
+        }
+
+        /* use rsh(1) if non-root and remote port is shell. */
+        if (geteuid()) {
+                struct servent *sp = getservbyname("shell", "tcp");
+
+                if (sp && sp->s_port == rport)
+                        return (rcmdsh(ahost, rport, locuser, remuser,
+                            cmd, NULL));
+        }
+
+        pid = getpid();
+        snprintf(pbuf, sizeof(pbuf), "%u", ntohs(rport));
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = af;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = AI_CANONNAME;
+        error = getaddrinfo(*ahost, pbuf, &hints, &res);
+        if (error) {
+#if 0
+                warnx("%s: %s", *ahost, gai_strerror(error));
+#endif
+                return (-1);
+        }
+        if (res->ai_canonname) {
+                strlcpy(hbuf, res->ai_canonname, sizeof(hbuf));
+                *ahost = hbuf;
+        } else
+                ; /*XXX*/
+
+        r = res;
+        refused = 0;
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGURG);
+        sigprocmask(SIG_BLOCK, &mask, &oldmask);
+        for (timo = 1, lport = IPPORT_RESERVED - 1;;) {
+                s = rresvport_af(&lport, r->ai_family);
+                if (s < 0) {
+                        if (errno == EAGAIN)
+                                (void)fprintf(stderr,
+                                    "rcmd: socket: All ports in use\n");
+                        else
+                                (void)fprintf(stderr, "rcmd: socket: %s\n",
+                                    strerror(errno));
+                        if (r->ai_next) {
+                                r = r->ai_next;
+                                continue;
+                        } else {
+                                sigprocmask(SIG_SETMASK, &oldmask, NULL);
+                                freeaddrinfo(res);
+                                return (-1);
+                        }
+                }
+                fcntl(s, F_SETOWN, pid);
+                if (connect(s, r->ai_addr, r->ai_addrlen) >= 0)
+                        break;
+                (void)close(s);
+                if (errno == EADDRINUSE) {
+                        lport--;
+                        continue;
+                }
+                if (errno == ECONNREFUSED)
+                        refused++;
+                if (r->ai_next) {
+                        int oerrno = errno;
+                        char hbuf[NI_MAXHOST];
+                        const int niflags = NI_NUMERICHOST;
+
+                        hbuf[0] = '\0';
+                        if (getnameinfo(r->ai_addr, r->ai_addrlen,
+                            hbuf, sizeof(hbuf), NULL, 0, niflags) != 0)
+                                strlcpy(hbuf, "(invalid)", sizeof hbuf);
+                        (void)fprintf(stderr, "connect to address %s: ", hbuf);
+                        errno = oerrno;
+                        perror(0);
+                        r = r->ai_next;
+                        hbuf[0] = '\0';
+                        if (getnameinfo(r->ai_addr, r->ai_addrlen,
+                            hbuf, sizeof(hbuf), NULL, 0, niflags) != 0)
+                                strlcpy(hbuf, "(invalid)", sizeof hbuf);
+                        (void)fprintf(stderr, "Trying %s...\n", hbuf);
+                        continue;
+                }
+                if (refused && timo <= 16) {
+                        (void)sleep(timo);
+                        timo *= 2;
+                        r = res;
+                        refused = 0;
+                        continue;
+                }
+                (void)fprintf(stderr, "%s: %s\n", res->ai_canonname,
+                    strerror(errno));
+                sigprocmask(SIG_SETMASK, &oldmask, NULL);
+                freeaddrinfo(res);
+                return (-1);
+        }
+        /* given "af" can be PF_UNSPEC, we need the real af for "s" */
+        af = r->ai_family;
+        freeaddrinfo(res);
+#if 0
+        /*
+         * try to rresvport() to the same port. This will make rresvport()
+         * fail it's first bind, resulting in it choosing a random port.
+         */
+        lport--;
+#endif
+        if (fd2p == 0) {
+                write(s, "", 1);
+                lport = 0;
+        } else {
+                char num[8];
+                int s2 = rresvport_af(&lport, af), s3;
+                socklen_t len = sizeof(from);
+                int fdssize = howmany(MAX(s, s2)+1, NFDBITS) * sizeof(fd_mask);
+
+                if (s2 < 0)
+                        goto bad;
+                readsp = (fd_set *)malloc(fdssize);
+                if (readsp == NULL) {
+                        close(s2);
+                        goto bad;
+                }
+                listen(s2, 1);
+                (void)snprintf(num, sizeof(num), "%d", lport);
+                if (write(s, num, strlen(num)+1) != strlen(num)+1) {
+                        (void)fprintf(stderr,
+                            "rcmd: write (setting up stderr): %s\n",
+                            strerror(errno));
+                        (void)close(s2);
+                        goto bad;
+                }
+again:
+                bzero(readsp, fdssize);
+                FD_SET(s, readsp);
+                FD_SET(s2, readsp);
+                errno = 0;
+                if (select(MAX(s, s2) + 1, readsp, 0, 0, 0) < 1 ||
+                    !FD_ISSET(s2, readsp)) {
+                        if (errno != 0)
+                                (void)fprintf(stderr,
+                                    "rcmd: select (setting up stderr): %s\n",
+                                    strerror(errno));
+                        else
+                                (void)fprintf(stderr,
+                                "select: protocol failure in circuit setup\n");
+                        (void)close(s2);
+                        goto bad;
+                }
+                s3 = accept(s2, (struct sockaddr *)&from, &len);
+                if (s3 < 0) {
+                        (void)fprintf(stderr,
+                            "rcmd: accept: %s\n", strerror(errno));
+                        lport = 0;
+                        close(s2);
+                        goto bad;
+                }
+
+                /*
+                 * XXX careful for ftp bounce attacks. If discovered, shut them
+                 * down and check for the real auxiliary channel to connect.
+                 */
+                switch (from.ss_family) {
+                case AF_INET:
+                case AF_INET6:
+                        if (getnameinfo((struct sockaddr *)&from, len,
+                            NULL, 0, num, sizeof(num), NI_NUMERICSERV) == 0 &&
+                            atoi(num) != 20) {
+                                break;
+                        }
+                        close(s3);
+                        goto again;
+                default:
+                        break;
+                }
+                (void)close(s2);
+
+                *fd2p = s3;
+                switch (from.ss_family) {
+                case AF_INET:
+                case AF_INET6:
+                        if (getnameinfo((struct sockaddr *)&from, len,
+                            NULL, 0, num, sizeof(num), NI_NUMERICSERV) != 0 ||
+                            (atoi(num) >= IPPORT_RESERVED ||
+                             atoi(num) < IPPORT_RESERVED / 2)) {
+                                (void)fprintf(stderr,
+                                    "socket: protocol failure in circuit setup.\n");
+                                goto bad2;
+                        }
+                        break;
+                default:
+                        break;
+                }
+        }
+        (void)write(s, locuser, strlen(locuser)+1);
+        (void)write(s, remuser, strlen(remuser)+1);
+        (void)write(s, cmd, strlen(cmd)+1);
+        if (read(s, &c, 1) != 1) {
+                (void)fprintf(stderr,
+                    "rcmd: %s: %s\n", *ahost, strerror(errno));
+                goto bad2;
+        }
+        if (c != 0) {
+                while (read(s, &c, 1) == 1) {
+                        (void)write(STDERR_FILENO, &c, 1);
+                        if (c == '\n')
+                                break;
+                }
+                goto bad2;
+        }
+        sigprocmask(SIG_SETMASK, &oldmask, NULL);
+        free(readsp);
+        return (s);
+bad2:
+        if (lport)
+                (void)close(*fd2p);
+bad:
+        if (readsp)
+                free(readsp);
+        (void)close(s);
+        sigprocmask(SIG_SETMASK, &oldmask, NULL);
+        return (-1);
+}
+
+int     __check_rhosts_file = 1;
+char    *__rcmd_errstr;
+
+int
+ruserok(const char *rhost, int superuser, const char *ruser, const char *luser)
+{
+        struct addrinfo hints, *res, *r;
+        int error;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = PF_UNSPEC;
+        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
+        error = getaddrinfo(rhost, "0", &hints, &res);
+        if (error)
+                return (-1);
+
+        for (r = res; r; r = r->ai_next) {
+                if (iruserok_sa(r->ai_addr, r->ai_addrlen, superuser, ruser,
+                    luser) == 0) {
+                        freeaddrinfo(res);
+                        return (0);
+                }
+        }
+        freeaddrinfo(res);
+        return (-1);
+}
+
+/*
+ * New .rhosts strategy: We are passed an ip address. We spin through
+ * hosts.equiv and .rhosts looking for a match. When the .rhosts only
+ * has ip addresses, we don't have to trust a nameserver.  When it
+ * contains hostnames, we spin through the list of addresses the nameserver
+ * gives us and look for a match.
+ *
+ * Returns 0 if ok, -1 if not ok.
+ */
+int
+iruserok(u_int32_t raddr, int superuser, const char *ruser, const char *luser)
+{
+        struct sockaddr_in sin;
+
+        memset(&sin, 0, sizeof(sin));
+        sin.sin_family = AF_INET;
+        sin.sin_len = sizeof(struct sockaddr_in);
+        memcpy(&sin.sin_addr, &raddr, sizeof(sin.sin_addr));
+        return iruserok_sa(&sin, sizeof(struct sockaddr_in), superuser, ruser,
+                    luser);
+}
+
+int
+iruserok_sa(const void *raddr, int rlen, int superuser, const char *ruser,
+    const char *luser)
+{
+        struct sockaddr *sa;
+        char *cp;
+        struct stat sbuf;
+        struct passwd *pwd;
+        FILE *hostf;
+        uid_t uid;
+        int first;
+        char pbuf[MAXPATHLEN];
+
+        sa = (struct sockaddr *)raddr;
+        first = 1;
+        hostf = superuser ? NULL : fopen(_PATH_HEQUIV, "r");
+again:
+        if (hostf) {
+                if (__ivaliduser_sa(hostf, sa, rlen, luser, ruser) == 0) {
+                        (void)fclose(hostf);
+                        return (0);
+                }
+                (void)fclose(hostf);
+        }
+        if (first == 1 && (__check_rhosts_file || superuser)) {
+                first = 0;
+                if ((pwd = getpwnam(luser)) == NULL)
+                        return (-1);
+                snprintf(pbuf, sizeof pbuf, "%s/.rhosts", pwd->pw_dir);
+
+                /*
+                 * Change effective uid while opening .rhosts.  If root and
+                 * reading an NFS mounted file system, can't read files that
+                 * are protected read/write owner only.
+                 */
+                uid = geteuid();
+                (void)seteuid(pwd->pw_uid);
+                hostf = fopen(pbuf, "r");
+                (void)seteuid(uid);
+
+                if (hostf == NULL)
+                        return (-1);
+                /*
+                 * If not a regular file, or is owned by someone other than
+                 * user or root or if writeable by anyone but the owner, quit.
+                 */
+                cp = NULL;
+                if (lstat(pbuf, &sbuf) < 0)
+                        cp = ".rhosts lstat failed";
+                else if (!S_ISREG(sbuf.st_mode))
+                        cp = ".rhosts not regular file";
+                else if (fstat(fileno(hostf), &sbuf) < 0)
+                        cp = ".rhosts fstat failed";
+                else if (sbuf.st_uid && sbuf.st_uid != pwd->pw_uid)
+                        cp = "bad .rhosts owner";
+                else if (sbuf.st_mode & (S_IWGRP|S_IWOTH))
+                        cp = ".rhosts writable by other than owner";
+                /* If there were any problems, quit. */
+                if (cp) {
+                        __rcmd_errstr = cp;
+                        (void)fclose(hostf);
+                        return (-1);
+                }
+                goto again;
+        }
+        return (-1);
+}
+
+/*
+ * XXX
+ * Don't make static, used by lpd(8).
+ *
+ * Returns 0 if ok, -1 if not ok.
+ */
+int
+__ivaliduser(FILE *hostf, in_addr_t raddrl, const char *luser,
+    const char *ruser)
+{
+        struct sockaddr_in sin;
+
+        memset(&sin, 0, sizeof(sin));
+        sin.sin_family = AF_INET;
+        sin.sin_len = sizeof(struct sockaddr_in);
+        memcpy(&sin.sin_addr, &raddrl, sizeof(sin.sin_addr));
+        return __ivaliduser_sa(hostf, (struct sockaddr *)&sin, sin.sin_len,
+                    luser, ruser);
+}
+
+int
+__ivaliduser_sa(FILE *hostf, struct sockaddr *raddr, socklen_t salen,
+    const char *luser, const char *ruser)
+{
+        char *user, *p;
+        char *buf;
+        const char *auser, *ahost;
+        int hostok, userok;
+        char *rhost = (char *)-1;
+        char domain[MAXHOSTNAMELEN];
+        size_t buflen;
+
+        getdomainname(domain, sizeof(domain));
+
+        while ((buf = fgetln(hostf, &buflen))) {
+                p = buf;
+                if (*p == '#')
+                        continue;
+                while (p < buf + buflen && *p != '\n' && *p != ' ' && *p != '\t') {
+                        if (!isprint(*p))
+                                goto bail;
+                        *p = isupper(*p) ? tolower(*p) : *p;
+                        p++;
+                }
+                if (p >= buf + buflen)
+                        continue;
+                if (*p == ' ' || *p == '\t') {
+                        *p++ = '\0';
+                        while (p < buf + buflen && (*p == ' ' || *p == '\t'))
+                                p++;
+                        if (p >= buf + buflen)
+                                continue;
+                        user = p;
+                        while (p < buf + buflen && *p != '\n' && *p != ' ' &&
+                            *p != '\t') {
+                                if (!isprint(*p))
+                                        goto bail;
+                                p++;
+                        }
+                } else
+                        user = p;
+                *p = '\0';
+
+                if (p == buf)
+                        continue;
+
+                auser = *user ? user : luser;
+                ahost = buf;
+
+                if (strlen(ahost) >= MAXHOSTNAMELEN)
+                        continue;
+
+                /*
+                 * innetgr() must lookup a hostname (we do not attempt
+                 * to change the semantics so that netgroups may have
+                 * #.#.#.# addresses in the list.)
+                 */
+                if (ahost[0] == '+')
+                        switch (ahost[1]) {
+                        case '\0':
+                                hostok = 1;
+                                break;
+                        case '@':
+                                if (rhost == (char *)-1)
+                                        rhost = __gethostloop(raddr, salen);
+                                hostok = 0;
+                                if (rhost)
+                                        hostok = innetgr(&ahost[2], rhost,
+                                            NULL, domain);
+                                break;
+                        default:
+                                hostok = __icheckhost(raddr, salen, &ahost[1]);
+                                break;
+                        }
+                else if (ahost[0] == '-')
+                        switch (ahost[1]) {
+                        case '\0':
+                                hostok = -1;
+                                break;
+                        case '@':
+                                if (rhost == (char *)-1)
+                                        rhost = __gethostloop(raddr, salen);
+                                hostok = 0;
+                                if (rhost)
+                                        hostok = -innetgr(&ahost[2], rhost,
+                                            NULL, domain);
+                                break;
+                        default:
+                                hostok = -__icheckhost(raddr, salen, &ahost[1]);
+                                break;
+                        }
+                else
+                        hostok = __icheckhost(raddr, salen, ahost);
+
+
+                if (auser[0] == '+')
+                        switch (auser[1]) {
+                        case '\0':
+                                userok = 1;
+                                break;
+                        case '@':
+                                userok = innetgr(&auser[2], NULL, ruser,
+                                    domain);
+                                break;
+                        default:
+                                userok = strcmp(ruser, &auser[1]) ? 0 : 1;
+                                break;
+                        }
+                else if (auser[0] == '-')
+                        switch (auser[1]) {
+                        case '\0':
+                                userok = -1;
+                                break;
+                        case '@':
+                                userok = -innetgr(&auser[2], NULL, ruser,
+                                    domain);
+                                break;
+                        default:
+                                userok = strcmp(ruser, &auser[1]) ? 0 : -1;
+                                break;
+                        }
+                else
+                        userok = strcmp(ruser, auser) ? 0 : 1;
+
+                /* Check if one component did not match */
+                if (hostok == 0 || userok == 0)
+                        continue;
+
+                /* Check if we got a forbidden pair */
+                if (userok <= -1 || hostok <= -1)
+                        return (-1);
+
+                /* Check if we got a valid pair */
+                if (hostok >= 1 && userok >= 1)
+                        return (0);
+        }
+bail:
+        return (-1);
+}
+
+/*
+ * Returns "true" if match, 0 if no match.  If we do not find any
+ * semblance of an A->PTR->A loop, allow a simple #.#.#.# match to work.
+ */
+static int
+__icheckhost(struct sockaddr *raddr, socklen_t salen, const char *lhost)
+{
+        struct addrinfo hints, *res, *r;
+        char h1[NI_MAXHOST], h2[NI_MAXHOST];
+        int error;
+        const int niflags = NI_NUMERICHOST;
+
+        h1[0] = '\0';
+        if (getnameinfo(raddr, salen, h1, sizeof(h1), NULL, 0,
+            niflags) != 0)
+                return (0);
+
+        /* Resolve laddr into sockaddr */
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = raddr->sa_family;
+        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
+        res = NULL;
+        error = getaddrinfo(lhost, "0", &hints, &res);
+        if (error)
+                return (0);
+
+        /*
+         * Try string comparisons between raddr and laddr.
+         */
+        for (r = res; r; r = r->ai_next) {
+                h2[0] = '\0';
+                if (getnameinfo(r->ai_addr, r->ai_addrlen, h2, sizeof(h2),
+                    NULL, 0, niflags) != 0)
+                        continue;
+                if (strcmp(h1, h2) == 0) {
+                        freeaddrinfo(res);
+                        return (1);
+                }
+        }
+
+        /* No match. */
+        freeaddrinfo(res);
+        return (0);
+}
+
+/*
+ * Return the hostname associated with the supplied address.
+ * Do a reverse lookup as well for security. If a loop cannot
+ * be found, pack the result of inet_ntoa() into the string.
+ */
+static char *
+__gethostloop(struct sockaddr *raddr, socklen_t salen)
+{
+        static char remotehost[NI_MAXHOST];
+        char h1[NI_MAXHOST], h2[NI_MAXHOST];
+        struct addrinfo hints, *res, *r;
+        int error;
+        const int niflags = NI_NUMERICHOST;
+
+        h1[0] = remotehost[0] = '\0';
+        if (getnameinfo(raddr, salen, remotehost, sizeof(remotehost),
+            NULL, 0, NI_NAMEREQD) != 0)
+                return (NULL);
+        if (getnameinfo(raddr, salen, h1, sizeof(h1), NULL, 0,
+            niflags) != 0)
+                return (NULL);
+
+        /*
+         * Look up the name and check that the supplied
+         * address is in the list
+         */
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = raddr->sa_family;
+        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
+        hints.ai_flags = AI_CANONNAME;
+        res = NULL;
+        error = getaddrinfo(remotehost, "0", &hints, &res);
+        if (error)
+                return (NULL);
+
+        for (r = res; r; r = r->ai_next) {
+                h2[0] = '\0';
+                if (getnameinfo(r->ai_addr, r->ai_addrlen, h2, sizeof(h2),
+                    NULL, 0, niflags) != 0)
+                        continue;
+                if (strcmp(h1, h2) == 0) {
+                        freeaddrinfo(res);
+                        return (remotehost);
+                }
+        }
+
+        /*
+         * either the DNS adminstrator has made a configuration
+         * mistake, or someone has attempted to spoof us
+         */
+        syslog(LOG_NOTICE, "rcmd: address %s not listed for host %s",
+            h1, res->ai_canonname ? res->ai_canonname : remotehost);
+        freeaddrinfo(res);
+        return (NULL);
+}
diff --git a/src/lib/libc/net/rcmdsh.3 b/src/lib/libc/net/rcmdsh.3
new file mode 100644
index 0000000000..be566f09ca
--- /dev/null
+++ b/src/lib/libc/net/rcmdsh.3
@@ -0,0 +1,96 @@
+.\"     $OpenBSD: rcmdsh.3,v 1.11 2003/06/02 20:18:35 millert Exp $
+.\"
+.\" Copyright (c) 1983, 1991, 1993
+.\"     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.
+.\"
+.Dd May 5, 2003
+.Dt RCMDSH 3
+.Os
+.Sh NAME
+.Nm rcmdsh
+.Nd return a stream to a remote command without superuser
+.Sh SYNOPSIS
+.Fd #include <unistd.h>
+.Ft int
+.Fn rcmdsh "char **ahost" "int inport" "const char *locuser" "const char *remuser" "const char *cmd" "char *rshprog"
+.Sh DESCRIPTION
+The
+.Fn rcmdsh
+function is used by normal users to execute a command on a remote machine
+using an authentication scheme based on reserved port numbers using
+.Xr rsh 1
+or the value of
+.Fa rshprog
+(if non-null).
+.Fa rshprog
+may be a fully-qualified path, a non-qualified command, or a command containing
+space-separated command line arguments.
+.Pp
+The
+.Fn rcmdsh
+function looks up the host
+.Fa *ahost
+using
+.Xr gethostbyname 3 ,
+returning \-1 if the host does not exist.
+Otherwise
+.Fa *ahost
+is set to the standard name of the host and a connection is established to
+a server residing at the well-known Internet port
+.Li shell/tcp
+(or whatever port is used by
+.Fa rshprog ) .
+The parameter
+.Fa inport
+is ignored; it is only included to provide an interface similar to
+.Xr rcmd 3 .
+.Pp
+If the connection succeeds, a socket in the
+.Tn UNIX
+domain of type
+.Dv SOCK_STREAM
+is returned to the caller, and given to the remote
+command as stdin and stdout, and stderr.
+.Sh DIAGNOSTICS
+The
+.Fn rcmdsh
+function returns a valid socket descriptor on success.
+It returns \-1 on error and prints a diagnostic message on the standard error.
+.Sh SEE ALSO
+.Xr rsh 1 ,
+.Xr socketpair 2 ,
+.Xr rcmd 3 ,
+.Xr rshd 8
+.Sh HISTORY
+The
+.Fn rcmdsh
+function first appeared in
+.Ox 2.0 .
+.Sh BUGS
+If
+.Xr rsh 1
+encounters an error, a file descriptor is still returned instead of \-1.
diff --git a/src/lib/libc/net/rcmdsh.c b/src/lib/libc/net/rcmdsh.c
new file mode 100644
index 0000000000..34a228d1e9
--- /dev/null
+++ b/src/lib/libc/net/rcmdsh.c
@@ -0,0 +1,186 @@
+/*      $OpenBSD: rcmdsh.c,v 1.11 2005/08/06 20:30:03 espie Exp $       */ 
+
+/*
+ * Copyright (c) 2001, MagniComp
+ * 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 MagniComp 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 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 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.
+ */
+
+/*
+ * This is an rcmd() replacement originally by 
+ * Chris Siebenmann <cks@utcc.utoronto.ca>.
+ */
+
+#include      <sys/types.h>
+#include      <sys/socket.h>
+#include      <sys/wait.h>
+#include      <signal.h>
+#include      <errno.h>
+#include      <netdb.h>
+#include      <stdio.h>
+#include      <stdlib.h>
+#include      <string.h>
+#include      <pwd.h>
+#include      <paths.h>
+#include      <unistd.h>
+
+/*
+ * This is a replacement rcmd() function that uses the rsh(1)
+ * program in place of a direct rcmd(3) function call so as to
+ * avoid having to be root.  Note that rport is ignored.
+ */
+/* ARGSUSED */
+int
+rcmdsh(char **ahost, int rport, const char *locuser, const char *remuser,
+    const char *cmd, char *rshprog)
+{
+        struct hostent *hp;
+        int sp[2];
+        pid_t cpid;
+        char *p;
+        struct passwd *pw;
+
+        /* What rsh/shell to use. */
+        if (rshprog == NULL)
+                rshprog = _PATH_RSH;
+
+        /* locuser must exist on this host. */
+        if ((pw = getpwnam(locuser)) == NULL) {
+                (void) fprintf(stderr, "rcmdsh: unknown user: %s\n", locuser);
+                return(-1);
+        }
+
+        /* Validate remote hostname. */
+        if (strcmp(*ahost, "localhost") != 0) {
+                if (((hp = gethostbyname2(*ahost, AF_INET)) == NULL) &&
+                    ((hp = gethostbyname2(*ahost, AF_INET6)) == NULL)) {
+                        herror(*ahost);
+                        return(-1);
+                }
+                *ahost = hp->h_name;
+        }
+
+        /* Get a socketpair we'll use for stdin and stdout. */
+        if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sp) < 0) {
+                perror("rcmdsh: socketpair");
+                return(-1);
+        }
+
+        cpid = fork();
+        if (cpid < 0) {
+                perror("rcmdsh: fork failed");
+                return(-1);
+        } else if (cpid == 0) {
+                /*
+                 * Child.  We use sp[1] to be stdin/stdout, and close sp[0].
+                 */
+                (void) close(sp[0]);
+                if (dup2(sp[1], 0) < 0 || dup2(0, 1) < 0) {
+                        perror("rcmdsh: dup2 failed");
+                        _exit(255);
+                }
+                /* Fork again to lose parent. */
+                cpid = fork();
+                if (cpid < 0) {
+                        perror("rcmdsh: fork to lose parent failed");
+                        _exit(255);
+                }
+                if (cpid > 0)
+                        _exit(0);
+
+                /* In grandchild here.  Become local user for rshprog. */
+                if (setuid(pw->pw_uid)) {
+                        (void) fprintf(stderr, "rcmdsh: setuid(%u): %s\n",
+                                       pw->pw_uid, strerror(errno));
+                        _exit(255);
+                }
+
+                /*
+                 * If remote host is "localhost" and local and remote user
+                 * are the same, avoid running remote shell for efficiency.
+                 */
+                if (!strcmp(*ahost, "localhost") && !strcmp(locuser, remuser)) {
+                        char *argv[4];
+                        if (pw->pw_shell[0] == '\0')
+                                rshprog = _PATH_BSHELL;
+                        else
+                                rshprog = pw->pw_shell;
+                        p = strrchr(rshprog, '/');
+                        argv[0] = p ? p + 1 : rshprog;
+                        argv[1] = "-c";
+                        argv[2] = (char *)cmd;
+                        argv[3] = NULL;
+                        execvp(rshprog, argv);
+                } else if ((p = strchr(rshprog, ' ')) == NULL) {
+                        /* simple case */
+                        char *argv[6];
+                        p = strrchr(rshprog, '/');
+                        argv[0] = p ? p + 1 : rshprog;
+                        argv[1] = "-l";
+                        argv[2] = (char *)remuser;
+                        argv[3] = *ahost;
+                        argv[4] = (char *)cmd;
+                        argv[5] = NULL;
+                        execvp(rshprog, argv);
+                } else {
+                        /* must pull args out of rshprog and dyn alloc argv */
+                        char **argv, **ap;
+                        int n;
+                        for (n = 7; (p = strchr(++p, ' ')) != NULL; n++)
+                                continue;
+                        rshprog = strdup(rshprog);
+                        ap = argv = malloc(sizeof(char *) * n);
+                        if (rshprog == NULL || argv == NULL) {
+                                perror("rcmdsh");
+                                _exit(255);
+                        }
+                        while ((p = strsep(&rshprog, " ")) != NULL) {
+                                if (*p == '\0')
+                                        continue;
+                                *ap++ = p;
+                        }
+                        if (ap != argv)         /* all spaces?!? */
+                                rshprog = argv[0];
+                        if ((p = strrchr(argv[0], '/')) != NULL)
+                                argv[0] = p + 1;
+                        *ap++ = "-l";
+                        *ap++ = (char *)remuser;
+                        *ap++ = *ahost;
+                        *ap++ = (char *)cmd;
+                        *ap++ = NULL;
+                        execvp(rshprog, argv);
+                }
+                (void) fprintf(stderr, "rcmdsh: execvp %s failed: %s\n",
+                               rshprog, strerror(errno));
+                _exit(255);
+        } else {
+                /* Parent. close sp[1], return sp[0]. */
+                (void) close(sp[1]);
+                /* Reap child. */
+                (void) wait(NULL);
+                return(sp[0]);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/net/recv.c b/src/lib/libc/net/recv.c
new file mode 100644
index 0000000000..6241cc6b12
--- /dev/null
+++ b/src/lib/libc/net/recv.c
@@ -0,0 +1,40 @@
+/*      $OpenBSD: recv.c,v 1.5 2005/08/06 20:30:03 espie Exp $ */
+/*
+ * Copyright (c) 1988, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stddef.h>
+
+ssize_t
+recv(int s, void *buf, size_t len, int flags)
+{
+        return (recvfrom(s, buf, len, flags, NULL, 0));
+}
diff --git a/src/lib/libc/net/res_comp.c b/src/lib/libc/net/res_comp.c
new file mode 100644
index 0000000000..9bdc26dd24
--- /dev/null
+++ b/src/lib/libc/net/res_comp.c
@@ -0,0 +1,474 @@
+/*      $OpenBSD: res_comp.c,v 1.13 2005/08/06 20:30:03 espie Exp $     */
+
+/*
+ * ++Copyright++ 1985, 1993
+ * -
+ * Copyright (c) 1985, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <resolv.h>
+#include <ctype.h>
+
+#include <unistd.h>
+#include <string.h>
+
+static int dn_find(u_char *, u_char *, u_char **, u_char **);
+
+/*
+ * Expand compressed domain name 'comp_dn' to full domain name.
+ * 'msg' is a pointer to the begining of the message,
+ * 'eomorig' points to the first location after the message,
+ * 'exp_dn' is a pointer to a buffer of size 'length' for the result.
+ * Return size of compressed name or -1 if there was an error.
+ */
+int
+dn_expand(const u_char *msg, const u_char *eomorig, const u_char *comp_dn,
+    char *exp_dn, int length)
+{
+        const u_char *cp;
+        char *dn;
+        int n, c;
+        char *eom;
+        int len = -1, checked = 0;
+
+        dn = exp_dn;
+        cp = comp_dn;
+        if (length > MAXHOSTNAMELEN-1)
+                length = MAXHOSTNAMELEN-1;
+        eom = exp_dn + length;
+        /*
+         * fetch next label in domain name
+         */
+        while ((n = *cp++)) {
+                /*
+                 * Check for indirection
+                 */
+                switch (n & INDIR_MASK) {
+                case 0:
+                        if (dn != exp_dn) {
+                                if (dn >= eom)
+                                        return (-1);
+                                *dn++ = '.';
+                        }
+                        if (dn+n >= eom)
+                                return (-1);
+                        checked += n + 1;
+                        while (--n >= 0) {
+                                if (((c = *cp++) == '.') || (c == '\\')) {
+                                        if (dn + n + 2 >= eom)
+                                                return (-1);
+                                        *dn++ = '\\';
+                                }
+                                *dn++ = c;
+                                if (cp >= eomorig)      /* out of range */
+                                        return (-1);
+                        }
+                        break;
+
+                case INDIR_MASK:
+                        if (len < 0)
+                                len = cp - comp_dn + 1;
+                        cp = msg + (((n & 0x3f) << 8) | (*cp & 0xff));
+                        if (cp < msg || cp >= eomorig)  /* out of range */
+                                return (-1);
+                        checked += 2;
+                        /*
+                         * Check for loops in the compressed name;
+                         * if we've looked at the whole message,
+                         * there must be a loop.
+                         */
+                        if (checked >= eomorig - msg)
+                                return (-1);
+                        break;
+
+                default:
+                        return (-1);                    /* flag error */
+                }
+        }
+        *dn = '\0';
+        if (len < 0)
+                len = cp - comp_dn;
+        return (len);
+}
+
+/*
+ * Compress domain name 'exp_dn' into 'comp_dn'.
+ * Return the size of the compressed name or -1.
+ * 'length' is the size of the array pointed to by 'comp_dn'.
+ * 'dnptrs' is a list of pointers to previous compressed names. dnptrs[0]
+ * is a pointer to the beginning of the message. The list ends with NULL.
+ * 'lastdnptr' is a pointer to the end of the arrary pointed to
+ * by 'dnptrs'. Side effect is to update the list of pointers for
+ * labels inserted into the message as we compress the name.
+ * If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
+ * is NULL, we don't update the list.
+ */
+int
+dn_comp(const char *exp_dn, u_char *comp_dn, int length, u_char **dnptrs,
+    u_char **lastdnptr)
+{
+        u_char *cp, *dn;
+        int c, l;
+        u_char **cpp, **lpp, *sp, *eob;
+        u_char *msg;
+
+        dn = (u_char *)exp_dn;
+        cp = comp_dn;
+        eob = cp + length;
+        lpp = cpp = NULL;
+        if (dnptrs != NULL) {
+                if ((msg = *dnptrs++) != NULL) {
+                        for (cpp = dnptrs; *cpp != NULL; cpp++)
+                                ;
+                        lpp = cpp;      /* end of list to search */
+                }
+        } else
+                msg = NULL;
+        for (c = *dn++; c != '\0'; ) {
+                /* look to see if we can use pointers */
+                if (msg != NULL) {
+                        if ((l = dn_find(dn-1, msg, dnptrs, lpp)) >= 0) {
+                                if (cp+1 >= eob)
+                                        return (-1);
+                                *cp++ = (l >> 8) | INDIR_MASK;
+                                *cp++ = l % 256;
+                                return (cp - comp_dn);
+                        }
+                        /* not found, save it */
+                        if (lastdnptr != NULL && cpp < lastdnptr-1) {
+                                *cpp++ = cp;
+                                *cpp = NULL;
+                        }
+                }
+                sp = cp++;      /* save ptr to length byte */
+                do {
+                        if (c == '.') {
+                                c = *dn++;
+                                break;
+                        }
+                        if (c == '\\') {
+                                if ((c = *dn++) == '\0')
+                                        break;
+                        }
+                        if (cp >= eob) {
+                                if (msg != NULL)
+                                        *lpp = NULL;
+                                return (-1);
+                        }
+                        *cp++ = c;
+                } while ((c = *dn++) != '\0');
+                /* catch trailing '.'s but not '..' */
+                if ((l = cp - sp - 1) == 0 && c == '\0') {
+                        cp--;
+                        break;
+                }
+                if (l <= 0 || l > MAXLABEL) {
+                        if (msg != NULL)
+                                *lpp = NULL;
+                        return (-1);
+                }
+                *sp = l;
+        }
+        if (cp >= eob) {
+                if (msg != NULL)
+                        *lpp = NULL;
+                return (-1);
+        }
+        *cp++ = '\0';
+        return (cp - comp_dn);
+}
+
+/*
+ * Skip over a compressed domain name. Return the size or -1.
+ */
+int
+__dn_skipname(const u_char *comp_dn, const u_char *eom)
+{
+        const u_char *cp;
+        int n;
+
+        cp = comp_dn;
+        while (cp < eom && (n = *cp++)) {
+                /*
+                 * check for indirection
+                 */
+                switch (n & INDIR_MASK) {
+                case 0:                 /* normal case, n == len */
+                        cp += n;
+                        continue;
+                case INDIR_MASK:        /* indirection */
+                        cp++;
+                        break;
+                default:                /* illegal type */
+                        return (-1);
+                }
+                break;
+        }
+        if (cp > eom)
+                return (-1);
+        return (cp - comp_dn);
+}
+
+static int
+mklower(int ch)
+{
+        if (isascii(ch) && isupper(ch))
+                return (tolower(ch));
+        return (ch);
+}
+
+/*
+ * Search for expanded name from a list of previously compressed names.
+ * Return the offset from msg if found or -1.
+ * dnptrs is the pointer to the first name on the list,
+ * not the pointer to the start of the message.
+ */
+static int
+dn_find(u_char *exp_dn, u_char *msg, u_char **dnptrs, u_char **lastdnptr)
+{
+        u_char *dn, *cp, **cpp;
+        int n;
+        u_char *sp;
+
+        for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
+                dn = exp_dn;
+                sp = cp = *cpp;
+                while ((n = *cp++)) {
+                        /*
+                         * check for indirection
+                         */
+                        switch (n & INDIR_MASK) {
+                        case 0:         /* normal case, n == len */
+                                while (--n >= 0) {
+                                        if (*dn == '.')
+                                                goto next;
+                                        if (*dn == '\\')
+                                                dn++;
+                                        if (mklower(*dn++) != mklower(*cp++))
+                                                goto next;
+                                }
+                                if ((n = *dn++) == '\0' && *cp == '\0')
+                                        return (sp - msg);
+                                if (n == '.')
+                                        continue;
+                                goto next;
+
+                        case INDIR_MASK:        /* indirection */
+                                cp = msg + (((n & 0x3f) << 8) | *cp);
+                                break;
+
+                        default:        /* illegal type */
+                                return (-1);
+                        }
+                }
+                if (*dn == '\0')
+                        return (sp - msg);
+        next:   ;
+        }
+        return (-1);
+}
+
+/*
+ * Verify that a domain name uses an acceptable character set.
+ */
+
+/*
+ * Note the conspicuous absence of ctype macros in these definitions.  On
+ * non-ASCII hosts, we can't depend on string literals or ctype macros to
+ * tell us anything about network-format data.  The rest of the BIND system
+ * is not careful about this, but for some reason, we're doing it right here.
+ */
+#define PERIOD 0x2e
+#define hyphenchar(c) ((c) == 0x2d)
+#define bslashchar(c) ((c) == 0x5c)
+#define periodchar(c) ((c) == PERIOD)
+#define asterchar(c) ((c) == 0x2a)
+#define alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) \
+                   || ((c) >= 0x61 && (c) <= 0x7a))
+#define digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
+
+#define borderchar(c) (alphachar(c) || digitchar(c))
+#define middlechar(c) (borderchar(c) || hyphenchar(c))
+#define domainchar(c) ((c) > 0x20 && (c) < 0x7f)
+
+int
+res_hnok(const char *dn)
+{
+        int pch = PERIOD, ch = *dn++;
+
+        while (ch != '\0') {
+                int nch = *dn++;
+
+                if (periodchar(ch)) {
+                        ;
+                } else if (periodchar(pch)) {
+                        if (!borderchar(ch))
+                                return (0);
+                } else if (periodchar(nch) || nch == '\0') {
+                        if (!borderchar(ch))
+                                return (0);
+                } else {
+                        if (!middlechar(ch))
+                                return (0);
+                }
+                pch = ch, ch = nch;
+        }
+        return (1);
+}
+
+/*
+ * hostname-like (A, MX, WKS) owners can have "*" as their first label
+ * but must otherwise be as a host name.
+ */
+int
+res_ownok(const char *dn)
+{
+        if (asterchar(dn[0])) {
+                if (periodchar(dn[1]))
+                        return (res_hnok(dn+2));
+                if (dn[1] == '\0')
+                        return (1);
+        }
+        return (res_hnok(dn));
+}
+
+/*
+ * SOA RNAMEs and RP RNAMEs can have any printable character in their first
+ * label, but the rest of the name has to look like a host name.
+ */
+int
+res_mailok(const char *dn)
+{
+        int ch, escaped = 0;
+
+        /* "." is a valid missing representation */
+        if (*dn == '\0')
+                return(1);
+
+        /* otherwise <label>.<hostname> */
+        while ((ch = *dn++) != '\0') {
+                if (!domainchar(ch))
+                        return (0);
+                if (!escaped && periodchar(ch))
+                        break;
+                if (escaped)
+                        escaped = 0;
+                else if (bslashchar(ch))
+                        escaped = 1;
+        }
+        if (periodchar(ch))
+                return (res_hnok(dn));
+        return(0);
+}
+
+/*
+ * This function is quite liberal, since RFC 1034's character sets are only
+ * recommendations.
+ */
+int
+res_dnok(const char *dn)
+{
+        int ch;
+
+        while ((ch = *dn++) != '\0')
+                if (!domainchar(ch))
+                        return (0);
+        return (1);
+}
+
+/*
+ * Routines to insert/extract short/long's.
+ */
+
+u_int16_t
+_getshort(const u_char *msgp)
+{
+        u_int16_t u;
+
+        GETSHORT(u, msgp);
+        return (u);
+}
+
+#ifdef NeXT
+/*
+ * nExt machines have some funky library conventions, which we must maintain.
+ */
+u_int16_t
+res_getshort(msgp)
+        const u_char *msgp;
+{
+        return (_getshort(msgp));
+}
+#endif
+
+u_int32_t
+_getlong(const u_char *msgp)
+{
+        u_int32_t u;
+
+        GETLONG(u, msgp);
+        return (u);
+}
+
+void
+__putshort(u_int16_t s, u_char *msgp)
+{
+        PUTSHORT(s, msgp);
+}
+
+void
+__putlong(u_int32_t l, u_char *msgp)
+{
+        PUTLONG(l, msgp);
+}
diff --git a/src/lib/libc/net/res_data.c b/src/lib/libc/net/res_data.c
new file mode 100644
index 0000000000..a5f6b03a7f
--- /dev/null
+++ b/src/lib/libc/net/res_data.c
@@ -0,0 +1,105 @@
+/*      $OpenBSD: res_data.c,v 1.3 2005/08/06 20:30:03 espie Exp $      */
+
+/*
+ * ++Copyright++ 1995
+ * -
+ * Copyright (c) 1995
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <resolv.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+const char *_res_opcodes[] = {
+        "QUERY",
+        "IQUERY",
+        "CQUERYM",
+        "CQUERYU",      /* experimental */
+        "NOTIFY",       /* experimental */
+        "5",
+        "6",
+        "7",
+        "8",
+        "UPDATEA",
+        "UPDATED",
+        "UPDATEDA",
+        "UPDATEM",
+        "UPDATEMA",
+        "ZONEINIT",
+        "ZONEREF",
+};
+
+const char *_res_resultcodes[] = {
+        "NOERROR",
+        "FORMERR",
+        "SERVFAIL",
+        "NXDOMAIN",
+        "NOTIMP",
+        "REFUSED",
+        "6",
+        "7",
+        "8",
+        "9",
+        "10",
+        "11",
+        "12",
+        "13",
+        "14",
+        "NOCHANGE",
+};
diff --git a/src/lib/libc/net/res_debug.c b/src/lib/libc/net/res_debug.c
new file mode 100644
index 0000000000..8e72c2a5e5
--- /dev/null
+++ b/src/lib/libc/net/res_debug.c
@@ -0,0 +1,1394 @@
+/*      $OpenBSD: res_debug.c,v 1.21 2005/08/06 20:30:04 espie Exp $    */
+
+/*
+ * ++Copyright++ 1985, 1990, 1993
+ * -
+ * Copyright (c) 1985, 1990, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * --Copyright--
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <ctype.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "thread_private.h"
+
+extern const char *_res_opcodes[];
+extern const char *_res_resultcodes[];
+
+static const char *loc_ntoal(const u_char *binary, char *ascii, int ascii_len);
+
+/* XXX: we should use getservbyport() instead. */
+static const char *
+dewks(int wks)
+{
+        static char nbuf[20];
+
+        switch (wks) {
+        case 5: return "rje";
+        case 7: return "echo";
+        case 9: return "discard";
+        case 11: return "systat";
+        case 13: return "daytime";
+        case 15: return "netstat";
+        case 17: return "qotd";
+        case 19: return "chargen";
+        case 20: return "ftp-data";
+        case 21: return "ftp";
+        case 23: return "telnet";
+        case 25: return "smtp";
+        case 37: return "time";
+        case 39: return "rlp";
+        case 42: return "name";
+        case 43: return "whois";
+        case 53: return "domain";
+        case 57: return "apts";
+        case 59: return "apfs";
+        case 67: return "bootps";
+        case 68: return "bootpc";
+        case 69: return "tftp";
+        case 77: return "rje";
+        case 79: return "finger";
+        case 87: return "link";
+        case 95: return "supdup";
+        case 100: return "newacct";
+        case 101: return "hostnames";
+        case 102: return "iso-tsap";
+        case 103: return "x400";
+        case 104: return "x400-snd";
+        case 105: return "csnet-ns";
+        case 109: return "pop-2";
+        case 111: return "sunrpc";
+        case 113: return "auth";
+        case 115: return "sftp";
+        case 117: return "uucp-path";
+        case 119: return "nntp";
+        case 121: return "erpc";
+        case 123: return "ntp";
+        case 133: return "statsrv";
+        case 136: return "profile";
+        case 144: return "NeWS";
+        case 161: return "snmp";
+        case 162: return "snmp-trap";
+        case 170: return "print-srv";
+        default:
+                (void) snprintf(nbuf, sizeof nbuf, "%d", wks);
+                return (nbuf);
+        }
+}
+
+/* XXX: we should use getprotobynumber() instead. */
+static const char *
+deproto(int protonum)
+{
+        static char nbuf[20];
+
+        switch (protonum) {
+        case 1: return "icmp";
+        case 2: return "igmp";
+        case 3: return "ggp";
+        case 5: return "st";
+        case 6: return "tcp";
+        case 7: return "ucl";
+        case 8: return "egp";
+        case 9: return "igp";
+        case 11: return "nvp-II";
+        case 12: return "pup";
+        case 16: return "chaos";
+        case 17: return "udp";
+        default:
+                (void) snprintf(nbuf, sizeof nbuf, "%d", protonum);
+                return (nbuf);
+        }
+}
+
+static const u_char *
+do_rrset(const u_char *msg, int len, const u_char *cp, int cnt, int pflag,
+    FILE *file, const char *hs)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int n;
+        int sflag;
+
+        /*
+         * Print answer records.
+         */
+        sflag = (_resp->pfcode & pflag);
+        if ((n = ntohs(cnt))) {
+                if ((!_resp->pfcode) ||
+                    ((sflag) && (_resp->pfcode & RES_PRF_HEAD1)))
+                        fprintf(file, "%s", hs);
+                while (--n >= 0) {
+                        if ((!_resp->pfcode) || sflag) {
+                                cp = p_rr(cp, msg, file);
+                        } else {
+                                unsigned int dlen;
+                                cp += __dn_skipname(cp, cp + MAXCDNAME);
+                                cp += INT16SZ;
+                                cp += INT16SZ;
+                                cp += INT32SZ;
+                                dlen = _getshort((u_char*)cp);
+                                cp += INT16SZ;
+                                cp += dlen;
+                        }
+                        if ((cp - msg) > len)
+                                return (NULL);
+                }
+                if ((!_resp->pfcode) ||
+                    ((sflag) && (_resp->pfcode & RES_PRF_HEAD1)))
+                        putc('\n', file);
+        }
+        return (cp);
+}
+
+void
+__p_query(const u_char *msg)
+{
+        __fp_query(msg, stdout);
+}
+
+/*
+ * Print the current options.
+ * This is intended to be primarily a debugging routine.
+ */
+void
+__fp_resstat(struct __res_state *statp, FILE *file)
+{
+        u_long mask;
+
+        fprintf(file, ";; res options:");
+        if (!statp)
+                statp = &_res;
+        for (mask = 1;  mask != 0;  mask <<= 1)
+                if (statp->options & mask)
+                        fprintf(file, " %s", p_option(mask));
+        putc('\n', file);
+}
+
+/*
+ * Print the contents of a query.
+ * This is intended to be primarily a debugging routine.
+ */
+void
+__fp_nquery(const u_char *msg, int len, FILE *file)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        const u_char *cp, *endMark;
+        const HEADER *hp;
+        int n;
+
+        if (_res_init(0) == -1)
+                return;
+
+#define TruncTest(x) if (x > endMark) goto trunc
+#define ErrorTest(x) if (x == NULL) goto error
+
+        /*
+         * Print header fields.
+         */
+        hp = (HEADER *)msg;
+        cp = msg + HFIXEDSZ;
+        endMark = msg + len;
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_HEADX) || hp->rcode) {
+                fprintf(file, ";; ->>HEADER<<- opcode: %s, status: %s, id: %u",
+                        _res_opcodes[hp->opcode],
+                        _res_resultcodes[hp->rcode],
+                        ntohs(hp->id));
+                putc('\n', file);
+        }
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_HEADX))
+                putc(';', file);
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_HEAD2)) {
+                fprintf(file, "; flags:");
+                if (hp->qr)
+                        fprintf(file, " qr");
+                if (hp->aa)
+                        fprintf(file, " aa");
+                if (hp->tc)
+                        fprintf(file, " tc");
+                if (hp->rd)
+                        fprintf(file, " rd");
+                if (hp->ra)
+                        fprintf(file, " ra");
+                if (hp->unused)
+                        fprintf(file, " UNUSED-BIT-ON");
+                if (hp->ad)
+                        fprintf(file, " ad");
+                if (hp->cd)
+                        fprintf(file, " cd");
+        }
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_HEAD1)) {
+                fprintf(file, "; Ques: %u", ntohs(hp->qdcount));
+                fprintf(file, ", Ans: %u", ntohs(hp->ancount));
+                fprintf(file, ", Auth: %u", ntohs(hp->nscount));
+                fprintf(file, ", Addit: %u", ntohs(hp->arcount));
+        }
+        if ((!_resp->pfcode) || (_resp->pfcode & 
+                (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
+                putc('\n',file);
+        }
+        /*
+         * Print question records.
+         */
+        if ((n = ntohs(hp->qdcount))) {
+                if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                        fprintf(file, ";; QUESTIONS:\n");
+                while (--n >= 0) {
+                        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                                fprintf(file, ";;\t");
+                        TruncTest(cp);
+                        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                                cp = p_cdnname(cp, msg, len, file);
+                        else {
+                                int n;
+                                char name[MAXDNAME];
+
+                                if ((n = dn_expand(msg, msg+len, cp, name,
+                                                sizeof name)) < 0)
+                                        cp = NULL;
+                                else
+                                        cp += n;
+                        }
+                        ErrorTest(cp);
+                        TruncTest(cp);
+                        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                                fprintf(file, ", type = %s",
+                                        __p_type(_getshort((u_char*)cp)));
+                        cp += INT16SZ;
+                        TruncTest(cp);
+                        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                                fprintf(file, ", class = %s\n",
+                                        __p_class(_getshort((u_char*)cp)));
+                        cp += INT16SZ;
+                        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                                putc('\n', file);
+                }
+        }
+        /*
+         * Print authoritative answer records
+         */
+        TruncTest(cp);
+        cp = do_rrset(msg, len, cp, hp->ancount, RES_PRF_ANS, file,
+                      ";; ANSWERS:\n");
+        ErrorTest(cp);
+
+        /*
+         * print name server records
+         */
+        TruncTest(cp);
+        cp = do_rrset(msg, len, cp, hp->nscount, RES_PRF_AUTH, file,
+                      ";; AUTHORITY RECORDS:\n");
+        ErrorTest(cp);
+
+        TruncTest(cp);
+        /*
+         * print additional records
+         */
+        cp = do_rrset(msg, len, cp, hp->arcount, RES_PRF_ADD, file,
+                      ";; ADDITIONAL RECORDS:\n");
+        ErrorTest(cp);
+        return;
+ trunc:
+        fprintf(file, "\n;; ...truncated\n");
+        return;
+ error:
+        fprintf(file, "\n;; ...malformed\n");
+}
+
+void
+__fp_query(const u_char *msg, FILE *file)
+{
+        fp_nquery(msg, PACKETSZ, file);
+}
+
+const u_char *
+__p_cdnname(const u_char *cp, const u_char *msg, int len, FILE *file)
+{
+        char name[MAXDNAME];
+        int n;
+
+        if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0)
+                return (NULL);
+        if (name[0] == '\0')
+                putc('.', file);
+        else
+                fputs(name, file);
+        return (cp + n);
+}
+
+const u_char *
+__p_cdname(const u_char *cp, const u_char *msg, FILE *file)
+{
+        return (p_cdnname(cp, msg, PACKETSZ, file));
+}
+
+
+/* Return a fully-qualified domain name from a compressed name (with
+   length supplied).  */
+
+const u_char *
+__p_fqnname(const u_char *cp, const u_char *msg, int msglen, char *name, int namelen)
+{
+        int n, newlen;
+
+        if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0)
+                return (NULL);
+        newlen = strlen(name);
+        if (newlen == 0 || name[newlen - 1] != '.') {
+                if (newlen + 1 >= namelen)      /* Lack space for final dot */
+                        return (NULL);
+                else
+                        strlcpy(name + newlen, ".", namelen - newlen);
+        }
+        return (cp + n);
+}
+
+/* XXX: the rest of these functions need to become length-limited, too. (vix)
+ */
+
+const u_char *
+__p_fqname(const u_char *cp, const u_char *msg, FILE *file)
+{
+        char name[MAXDNAME];
+        const u_char *n;
+
+        n = __p_fqnname(cp, msg, MAXCDNAME, name, sizeof name);
+        if (n == NULL)
+                return (NULL);
+        fputs(name, file);
+        return (n);
+}
+
+/*
+ * Print resource record fields in human readable form.
+ */
+const u_char *
+__p_rr(const u_char *cp, const u_char *msg, FILE *file)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int type, class, dlen, n, c;
+        struct in_addr inaddr;
+        const u_char *cp1, *cp2;
+        u_int32_t tmpttl, t;
+        int lcnt;
+        u_int16_t keyflags;
+        char rrname[MAXDNAME];          /* The fqdn of this RR */
+        char base64_key[MAX_KEY_BASE64];
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (NULL);
+        }
+        cp = __p_fqnname(cp, msg, MAXCDNAME, rrname, sizeof rrname);
+        if (!cp)
+                return (NULL);                  /* compression error */
+        fputs(rrname, file);
+        
+        type = _getshort((u_char*)cp);
+        cp += INT16SZ;
+        class = _getshort((u_char*)cp);
+        cp += INT16SZ;
+        tmpttl = _getlong((u_char*)cp);
+        cp += INT32SZ;
+        dlen = _getshort((u_char*)cp);
+        cp += INT16SZ;
+        cp1 = cp;
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_TTLID))
+                fprintf(file, "\t%lu", (u_long)tmpttl);
+        if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_CLASS))
+                fprintf(file, "\t%s", __p_class(class));
+        fprintf(file, "\t%s", __p_type(type));
+        /*
+         * Print type specific data, if appropriate
+         */
+        switch (type) {
+        case T_A:
+                switch (class) {
+                case C_IN:
+                case C_HS:
+                        bcopy(cp, (char *)&inaddr, INADDRSZ);
+                        if (dlen == 4) {
+                                fprintf(file, "\t%s", inet_ntoa(inaddr));
+                                cp += dlen;
+                        } else if (dlen == 7) {
+                                char *address;
+                                u_char protocol;
+                                in_port_t port;
+
+                                address = inet_ntoa(inaddr);
+                                cp += INADDRSZ;
+                                protocol = *(u_char*)cp;
+                                cp += sizeof (u_char);
+                                port = _getshort((u_char*)cp);
+                                cp += INT16SZ;
+                                fprintf(file, "\t%s\t; proto %u, port %u",
+                                        address, protocol, port);
+                        }
+                        break;
+                default:
+                        cp += dlen;
+                }
+                break;
+        case T_CNAME:
+        case T_MB:
+        case T_MG:
+        case T_MR:
+        case T_NS:
+        case T_PTR:
+                putc('\t', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+
+        case T_HINFO:
+        case T_ISDN:
+                cp2 = cp + dlen;
+                (void) fputs("\t\"", file);
+                if ((n = (unsigned char) *cp++) != 0) {
+                        for (c = n; c > 0 && cp < cp2; c--) {
+                                if (strchr("\n\"\\", *cp))
+                                        (void) putc('\\', file);
+                                (void) putc(*cp++, file);
+                        }
+                }
+                putc('"', file);
+                if (cp < cp2 && (n = (unsigned char) *cp++) != 0) {
+                        (void) fputs ("\t\"", file);
+                        for (c = n; c > 0 && cp < cp2; c--) {
+                                if (strchr("\n\"\\", *cp))
+                                        (void) putc('\\', file);
+                                (void) putc(*cp++, file);
+                        }
+                        putc('"', file);
+                } else if (type == T_HINFO) {
+                        (void) fputs("\"?\"", file);
+                        fprintf(file, "\n;; *** Warning *** OS-type missing");
+                }
+                break;
+
+        case T_SOA:
+                putc('\t', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                putc(' ', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                fputs(" (\n", file);
+                t = _getlong((u_char*)cp);  cp += INT32SZ;
+                fprintf(file, "\t\t\t%lu\t; serial\n", (u_long)t);
+                t = _getlong((u_char*)cp);  cp += INT32SZ;
+                fprintf(file, "\t\t\t%lu\t; refresh (%s)\n",
+                        (u_long)t, __p_time(t));
+                t = _getlong((u_char*)cp);  cp += INT32SZ;
+                fprintf(file, "\t\t\t%lu\t; retry (%s)\n",
+                        (u_long)t, __p_time(t));
+                t = _getlong((u_char*)cp);  cp += INT32SZ;
+                fprintf(file, "\t\t\t%lu\t; expire (%s)\n",
+                        (u_long)t, __p_time(t));
+                t = _getlong((u_char*)cp);  cp += INT32SZ;
+                fprintf(file, "\t\t\t%lu )\t; minimum (%s)",
+                        (u_long)t, __p_time(t));
+                break;
+
+        case T_MX:
+        case T_AFSDB:
+        case T_RT:
+                fprintf(file, "\t%u ", _getshort((u_char*)cp));
+                cp += INT16SZ;
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+
+        case T_PX:
+                fprintf(file, "\t%u ", _getshort((u_char*)cp));
+                cp += INT16SZ;
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                putc(' ', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+
+        case T_X25:
+                cp2 = cp + dlen;
+                (void) fputs("\t\"", file);
+                if ((n = (unsigned char) *cp++) != 0) {
+                        for (c = n; c > 0 && cp < cp2; c--) {
+                                if (strchr("\n\"\\", *cp))
+                                        (void) putc('\\', file);
+                                (void) putc(*cp++, file);
+                        }
+                }
+                putc('"', file);
+                break;
+
+        case T_TXT:
+                (void) putc('\t', file);
+                cp2 = cp1 + dlen;
+                while (cp < cp2) {
+                        putc('"', file);
+                        if ((n = (unsigned char) *cp++)) {
+                                for (c = n; c > 0 && cp < cp2; c--) {
+                                        if (strchr("\n\"\\", *cp))
+                                                (void) putc('\\', file);
+                                        (void) putc(*cp++, file);
+                                }
+                        }
+                        putc('"', file);
+                        if (cp < cp2)
+                                putc(' ', file);
+                }
+                break;
+
+        case T_NSAP:
+                (void) fprintf(file, "\t%s", inet_nsap_ntoa(dlen, cp, NULL));
+                cp += dlen;
+                break;
+
+        case T_AAAA: {
+                char t[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
+
+                fprintf(file, "\t%s", inet_ntop(AF_INET6, cp, t, sizeof t));
+                cp += dlen;
+                break;
+            }
+
+        case T_LOC: {
+                char t[255];
+
+                fprintf(file, "\t%s", loc_ntoal(cp, t, sizeof t));
+                cp += dlen;
+                break;
+            }
+
+        case T_NAPTR: {
+                u_int order, preference;
+
+                order = _getshort(cp);  cp += INT16SZ;
+                preference   = _getshort(cp);  cp += INT16SZ;
+                fprintf(file, "\t%u %u ",order, preference);
+                /* Flags */
+                n = *cp++;
+                fprintf(file,"\"%.*s\" ", (int)n, cp);
+                cp += n;
+                /* Service */
+                n = *cp++;
+                fprintf(file,"\"%.*s\" ", (int)n, cp);
+                cp += n;
+                /* Regexp */
+                n = *cp++;
+                fprintf(file,"\"%.*s\" ", (int)n, cp);
+                cp += n;
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+            }
+
+        case T_SRV: {
+                u_int priority, weight, port;
+
+                priority = _getshort(cp);  cp += INT16SZ;
+                weight   = _getshort(cp);  cp += INT16SZ;
+                port     = _getshort(cp);  cp += INT16SZ;
+                fprintf(file, "\t%u %u %u ", priority, weight, port);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+            }
+
+        case T_MINFO:
+        case T_RP:
+                putc('\t', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                putc(' ', file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
+                break;
+
+        case T_UINFO:
+                putc('\t', file);
+                fputs((char *)cp, file);
+                cp += dlen;
+                break;
+
+        case T_UID:
+        case T_GID:
+                if (dlen == 4) {
+                        fprintf(file, "\t%u", _getlong((u_char*)cp));
+                        cp += INT32SZ;
+                }
+                break;
+
+        case T_WKS:
+                if (dlen < INT32SZ + 1)
+                        break;
+                bcopy(cp, (char *)&inaddr, INADDRSZ);
+                cp += INT32SZ;
+                fprintf(file, "\t%s %s ( ",
+                        inet_ntoa(inaddr),
+                        deproto((int) *cp));
+                cp += sizeof (u_char);
+                n = 0;
+                lcnt = 0;
+                while (cp < cp1 + dlen) {
+                        c = *cp++;
+                        do {
+                                if (c & 0200) {
+                                        if (lcnt == 0) {
+                                                fputs("\n\t\t\t", file);
+                                                lcnt = 5;
+                                        }
+                                        fputs(dewks(n), file);
+                                        putc(' ', file);
+                                        lcnt--;
+                                }
+                                c <<= 1;
+                        } while (++n & 07);
+                }
+                putc(')', file);
+                break;
+
+        case T_KEY:
+                putc('\t', file);
+                keyflags = _getshort(cp);
+                cp += 2;
+                fprintf(file,"0x%04x", keyflags );      /* flags */
+                fprintf(file," %u", *cp++);     /* protocol */
+                fprintf(file," %u (", *cp++);   /* algorithm */
+
+                n = b64_ntop(cp, (cp1 + dlen) - cp,
+                             base64_key, sizeof base64_key);
+                for (c = 0; c < n; ++c) {
+                        if (0 == (c & 0x3F))
+                                fprintf(file, "\n\t");
+                        putc(base64_key[c], file);  /* public key data */
+                }
+
+                fprintf(file, " )");
+                if (n < 0)
+                        fprintf(file, "\t; BAD BASE64");
+                fflush(file);
+                cp = cp1 + dlen;
+                break;
+
+        case T_SIG:
+                type = _getshort((u_char*)cp);
+                cp += INT16SZ;
+                fprintf(file, " %s", p_type(type));
+                fprintf(file, "\t%u", *cp++);   /* algorithm */
+                /* Check label value and print error if wrong. */
+                n = *cp++;
+                c = dn_count_labels (rrname);
+                if (n != c)
+                        fprintf(file, "\t; LABELS WRONG (%d should be %d)\n\t",
+                                n, c);
+                /* orig ttl */
+                n = _getlong((u_char*)cp);
+                if (n != tmpttl)
+                        fprintf(file, " %u", n);
+                cp += INT32SZ;
+                /* sig expire */
+                fprintf(file, " (\n\t%s",
+                                     __p_secstodate(_getlong((u_char*)cp)));
+                cp += INT32SZ;
+                /* time signed */
+                fprintf(file, " %s", __p_secstodate(_getlong((u_char*)cp)));
+                cp += INT32SZ;
+                /* sig footprint */
+                fprintf(file," %u ", _getshort((u_char*)cp));
+                cp += INT16SZ;
+                /* signer's name */
+                cp = p_fqname(cp, msg, file);
+                n = b64_ntop(cp, (cp1 + dlen) - cp,
+                             base64_key, sizeof base64_key);
+                for (c = 0; c < n; c++) {
+                        if (0 == (c & 0x3F))
+                                fprintf (file, "\n\t");
+                        putc(base64_key[c], file);              /* signature */
+                }
+                /* Clean up... */
+                fprintf(file, " )");
+                if (n < 0)
+                        fprintf(file, "\t; BAD BASE64");
+                fflush(file);
+                cp = cp1+dlen;
+                break;
+
+#ifdef ALLOW_T_UNSPEC
+        case T_UNSPEC:
+                {
+                        int NumBytes = 8;
+                        u_char *DataPtr;
+                        int i;
+
+                        if (dlen < NumBytes) NumBytes = dlen;
+                        fprintf(file, "\tFirst %d bytes of hex data:",
+                                NumBytes);
+                        for (i = 0, DataPtr = cp; i < NumBytes; i++, DataPtr++)
+                                fprintf(file, " %x", *DataPtr);
+                        cp += dlen;
+                }
+                break;
+#endif /* ALLOW_T_UNSPEC */
+
+        default:
+                fprintf(file, "\t?%d?", type);
+                cp += dlen;
+        }
+#if 0
+        fprintf(file, "\t; dlen=%d, ttl %s\n", dlen, __p_time(tmpttl));
+#else
+        putc('\n', file);
+#endif
+        if (cp - cp1 != dlen) {
+                fprintf(file, ";; packet size error (found %ld, dlen was %d)\n",
+                        (long)(cp - cp1), dlen);
+                cp = NULL;
+        }
+        return (cp);
+}
+
+int
+__sym_ston(const struct res_sym *syms, char *name, int *success)
+{
+        for (; syms->name != 0; syms++) {
+                if (strcasecmp (name, syms->name) == 0) {
+                        if (success)
+                                *success = 1;
+                        return (syms->number);
+                }
+        }
+        if (success)
+                *success = 0;
+        return (syms->number);          /* The default value. */
+}
+
+
+const char *
+__sym_ntop(const struct res_sym *syms, int number, int *success)
+{
+        static char unname[20];
+
+        for (; syms->name != 0; syms++) {
+                if (number == syms->number) {
+                        if (success)
+                                *success = 1;
+                        return (syms->humanname);
+                }
+        }
+        snprintf(unname, sizeof unname, "%d", number);
+        if (success)
+                *success = 0;
+        return (unname);
+}
+
+/*
+ * Return a mnemonic for an option
+ */
+const char *
+__p_option(u_long option)
+{
+        static char nbuf[40];
+
+        switch (option) {
+        case RES_INIT:          return "init";
+        case RES_DEBUG:         return "debug";
+        case RES_AAONLY:        return "aaonly(unimpl)";
+        case RES_USEVC:         return "usevc";
+        case RES_PRIMARY:       return "primry(unimpl)";
+        case RES_IGNTC:         return "igntc";
+        case RES_RECURSE:       return "recurs";
+        case RES_DEFNAMES:      return "defnam";
+        case RES_STAYOPEN:      return "styopn";
+        case RES_DNSRCH:        return "dnsrch";
+        case RES_INSECURE1:     return "insecure1";
+        case RES_INSECURE2:     return "insecure2";
+        case RES_USE_INET6:     return "inet6";
+        case RES_USE_EDNS0:     return "edns0";
+        default:
+                snprintf(nbuf, sizeof nbuf, "?0x%lx?", (u_long)option);
+                return (nbuf);
+        }
+}
+
+/*
+ * Return a mnemonic for a time to live
+ */
+const char *
+p_time(u_int32_t value)
+{
+        static char nbuf[40];
+        char *ebuf;
+        int secs, mins, hours, days;
+        char *p;
+        int tmp;
+
+        if (value == 0) {
+                strlcpy(nbuf, "0 secs", sizeof nbuf);
+                return (nbuf);
+        }
+
+        secs = value % 60;
+        value /= 60;
+        mins = value % 60;
+        value /= 60;
+        hours = value % 24;
+        value /= 24;
+        days = value;
+        value = 0;
+
+#define PLURALIZE(x)    x, (x == 1) ? "" : "s"
+        p = nbuf;
+        ebuf = nbuf + sizeof(nbuf);
+        if (days) {
+                if ((tmp = snprintf(p, ebuf - p, "%d day%s",
+                    PLURALIZE(days))) >= ebuf - p || tmp < 0)
+                        goto full;
+                p += tmp;
+        }
+        if (hours) {
+                if (days)
+                        *p++ = ' ';
+                if (p >= ebuf)
+                        goto full;
+                if ((tmp = snprintf(p, ebuf - p, "%d hour%s",
+                    PLURALIZE(hours))) >= ebuf - p || tmp < 0)
+                        goto full;
+                p += tmp;
+        }
+        if (mins) {
+                if (days || hours)
+                        *p++ = ' ';
+                if (p >= ebuf)
+                        goto full;
+                if ((tmp = snprintf(p, ebuf - p, "%d min%s",
+                    PLURALIZE(mins))) >= ebuf - p || tmp < 0)
+                        goto full;
+                p += tmp;
+        }
+        if (secs || ! (days || hours || mins)) {
+                if (days || hours || mins)
+                        *p++ = ' ';
+                if (p >= ebuf)
+                        goto full;
+                if ((tmp = snprintf(p, ebuf - p, "%d sec%s",
+                    PLURALIZE(secs))) >= ebuf - p || tmp < 0)
+                        goto full;
+        }
+        return (nbuf);
+full:
+        p = nbuf + sizeof(nbuf) - 4;
+        *p++ = '.';
+        *p++ = '.';
+        *p++ = '.';
+        *p++ = '\0';
+        return (nbuf);
+}
+
+/*
+ * routines to convert between on-the-wire RR format and zone file format.
+ * Does not contain conversion to/from decimal degrees; divide or multiply
+ * by 60*60*1000 for that.
+ */
+
+static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000,
+                                      1000000,10000000,100000000,1000000000};
+
+/* takes an XeY precision/size value, returns a string representation. */
+static const char *
+precsize_ntoa(u_int8_t prec)
+{
+        static char retbuf[sizeof "90000000.00"];
+        unsigned long val;
+        int mantissa, exponent;
+
+        mantissa = (int)((prec >> 4) & 0x0f) % 10;
+        exponent = (int)((prec >> 0) & 0x0f) % 10;
+
+        val = mantissa * poweroften[exponent];
+
+        (void) snprintf(retbuf, sizeof retbuf, "%ld.%.2ld", val/100, val%100);
+        return (retbuf);
+}
+
+/* converts ascii size/precision X * 10**Y(cm) to 0xXY.  moves pointer. */
+static u_int8_t
+precsize_aton(char **strptr)
+{
+        unsigned int mval = 0, cmval = 0;
+        u_int8_t retval = 0;
+        char *cp;
+        int exponent;
+        int mantissa;
+
+        cp = *strptr;
+
+        while (isdigit(*cp))
+                mval = mval * 10 + (*cp++ - '0');
+
+        if (*cp == '.') {               /* centimeters */
+                cp++;
+                if (isdigit(*cp)) {
+                        cmval = (*cp++ - '0') * 10;
+                        if (isdigit(*cp)) {
+                                cmval += (*cp++ - '0');
+                        }
+                }
+        }
+        cmval = (mval * 100) + cmval;
+
+        for (exponent = 0; exponent < 9; exponent++)
+                if (cmval < poweroften[exponent+1])
+                        break;
+
+        mantissa = cmval / poweroften[exponent];
+        if (mantissa > 9)
+                mantissa = 9;
+
+        retval = (mantissa << 4) | exponent;
+
+        *strptr = cp;
+
+        return (retval);
+}
+
+/* converts ascii lat/lon to unsigned encoded 32-bit number.  moves pointer. */
+static u_int32_t
+latlon2ul(char **latlonstrptr, int *which)
+{
+        char *cp;
+        u_int32_t retval;
+        int deg = 0, min = 0, secs = 0, secsfrac = 0;
+
+        cp = *latlonstrptr;
+
+        while (isdigit(*cp))
+                deg = deg * 10 + (*cp++ - '0');
+
+        while (isspace(*cp))
+                cp++;
+
+        if (!(isdigit(*cp)))
+                goto fndhemi;
+
+        while (isdigit(*cp))
+                min = min * 10 + (*cp++ - '0');
+
+        while (isspace(*cp))
+                cp++;
+
+        if (!(isdigit(*cp)))
+                goto fndhemi;
+
+        while (isdigit(*cp))
+                secs = secs * 10 + (*cp++ - '0');
+
+        if (*cp == '.') {               /* decimal seconds */
+                cp++;
+                if (isdigit(*cp)) {
+                        secsfrac = (*cp++ - '0') * 100;
+                        if (isdigit(*cp)) {
+                                secsfrac += (*cp++ - '0') * 10;
+                                if (isdigit(*cp)) {
+                                        secsfrac += (*cp++ - '0');
+                                }
+                        }
+                }
+        }
+
+        while (!isspace(*cp))   /* if any trailing garbage */
+                cp++;
+
+        while (isspace(*cp))
+                cp++;
+
+ fndhemi:
+        switch (*cp) {
+        case 'N': case 'n':
+        case 'E': case 'e':
+                retval = ((unsigned)1<<31)
+                        + (((((deg * 60) + min) * 60) + secs) * 1000)
+                        + secsfrac;
+                break;
+        case 'S': case 's':
+        case 'W': case 'w':
+                retval = ((unsigned)1<<31)
+                        - (((((deg * 60) + min) * 60) + secs) * 1000)
+                        - secsfrac;
+                break;
+        default:
+                retval = 0;     /* invalid value -- indicates error */
+                break;
+        }
+
+        switch (*cp) {
+        case 'N': case 'n':
+        case 'S': case 's':
+                *which = 1;     /* latitude */
+                break;
+        case 'E': case 'e':
+        case 'W': case 'w':
+                *which = 2;     /* longitude */
+                break;
+        default:
+                *which = 0;     /* error */
+                break;
+        }
+
+        cp++;                   /* skip the hemisphere */
+
+        while (!isspace(*cp))   /* if any trailing garbage */
+                cp++;
+
+        while (isspace(*cp))    /* move to next field */
+                cp++;
+
+        *latlonstrptr = cp;
+
+        return (retval);
+}
+
+/* converts a zone file representation in a string to an RDATA on-the-wire
+ * representation. */
+int
+loc_aton(const char *ascii, u_char *binary)
+{
+        const char *maxcp;
+        u_char *bcp;
+        char *cp;
+
+        u_int32_t latit = 0, longit = 0, alt = 0;
+        u_int32_t lltemp1 = 0, lltemp2 = 0;
+        int altmeters = 0, altfrac = 0, altsign = 1;
+        u_int8_t hp = 0x16;     /* default = 1e6 cm = 10000.00m = 10km */
+        u_int8_t vp = 0x13;     /* default = 1e3 cm = 10.00m */
+        u_int8_t siz = 0x12;    /* default = 1e2 cm = 1.00m */
+        int which1 = 0, which2 = 0;
+
+        cp = (char *)ascii;
+        maxcp = cp + strlen(ascii);
+
+        lltemp1 = latlon2ul(&cp, &which1);
+
+        lltemp2 = latlon2ul(&cp, &which2);
+
+        switch (which1 + which2) {
+        case 3:                 /* 1 + 2, the only valid combination */
+                if ((which1 == 1) && (which2 == 2)) { /* normal case */
+                        latit = lltemp1;
+                        longit = lltemp2;
+                } else if ((which1 == 2) && (which2 == 1)) { /* reversed */
+                        longit = lltemp1;
+                        latit = lltemp2;
+                } else {        /* some kind of brokenness */
+                        return (0);
+                }
+                break;
+        default:                /* we didn't get one of each */
+                return (0);
+        }
+
+        /* altitude */
+        if (*cp == '-') {
+                altsign = -1;
+                cp++;
+        }
+    
+        if (*cp == '+')
+                cp++;
+
+        while (isdigit(*cp))
+                altmeters = altmeters * 10 + (*cp++ - '0');
+
+        if (*cp == '.') {               /* decimal meters */
+                cp++;
+                if (isdigit(*cp)) {
+                        altfrac = (*cp++ - '0') * 10;
+                        if (isdigit(*cp)) {
+                                altfrac += (*cp++ - '0');
+                        }
+                }
+        }
+
+        alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));
+
+        while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */
+                cp++;
+
+        while (isspace(*cp) && (cp < maxcp))
+                cp++;
+
+        if (cp >= maxcp)
+                goto defaults;
+
+        siz = precsize_aton(&cp);
+        
+        while (!isspace(*cp) && (cp < maxcp))   /* if trailing garbage or m */
+                cp++;
+
+        while (isspace(*cp) && (cp < maxcp))
+                cp++;
+
+        if (cp >= maxcp)
+                goto defaults;
+
+        hp = precsize_aton(&cp);
+
+        while (!isspace(*cp) && (cp < maxcp))   /* if trailing garbage or m */
+                cp++;
+
+        while (isspace(*cp) && (cp < maxcp))
+                cp++;
+
+        if (cp >= maxcp)
+                goto defaults;
+
+        vp = precsize_aton(&cp);
+
+ defaults:
+
+        bcp = binary;
+        *bcp++ = (u_int8_t) 0;  /* version byte */
+        *bcp++ = siz;
+        *bcp++ = hp;
+        *bcp++ = vp;
+        PUTLONG(latit,bcp);
+        PUTLONG(longit,bcp);
+        PUTLONG(alt,bcp);
+    
+        return (16);            /* size of RR in octets */
+}
+
+const char *
+loc_ntoa(const u_char *binary, char *ascii)
+{
+        return loc_ntoal(binary, ascii, 255);
+}
+
+/* takes an on-the-wire LOC RR and formats it in a human readable format. */
+static const char *
+loc_ntoal(const u_char *binary, char *ascii, int ascii_len)
+{
+        static char *error = "?";
+        const u_char *cp = binary;
+
+        int latdeg, latmin, latsec, latsecfrac;
+        int longdeg, longmin, longsec, longsecfrac;
+        char northsouth, eastwest;
+        int altmeters, altfrac, altsign;
+
+        const int referencealt = 100000 * 100;
+
+        int32_t latval, longval, altval;
+        u_int32_t templ;
+        u_int8_t sizeval, hpval, vpval, versionval;
+    
+        char *sizestr, *hpstr, *vpstr;
+
+        versionval = *cp++;
+
+        if (versionval) {
+                snprintf(ascii, ascii_len, "; error: unknown LOC RR version");
+                return (ascii);
+        }
+
+        sizeval = *cp++;
+
+        hpval = *cp++;
+        vpval = *cp++;
+
+        GETLONG(templ, cp);
+        latval = (templ - ((unsigned)1<<31));
+
+        GETLONG(templ, cp);
+        longval = (templ - ((unsigned)1<<31));
+
+        GETLONG(templ, cp);
+        if (templ < referencealt) { /* below WGS 84 spheroid */
+                altval = referencealt - templ;
+                altsign = -1;
+        } else {
+                altval = templ - referencealt;
+                altsign = 1;
+        }
+
+        if (latval < 0) {
+                northsouth = 'S';
+                latval = -latval;
+        } else
+                northsouth = 'N';
+
+        latsecfrac = latval % 1000;
+        latval = latval / 1000;
+        latsec = latval % 60;
+        latval = latval / 60;
+        latmin = latval % 60;
+        latval = latval / 60;
+        latdeg = latval;
+
+        if (longval < 0) {
+                eastwest = 'W';
+                longval = -longval;
+        } else
+                eastwest = 'E';
+
+        longsecfrac = longval % 1000;
+        longval = longval / 1000;
+        longsec = longval % 60;
+        longval = longval / 60;
+        longmin = longval % 60;
+        longval = longval / 60;
+        longdeg = longval;
+
+        altfrac = altval % 100;
+        altmeters = (altval / 100) * altsign;
+
+        if ((sizestr = strdup(precsize_ntoa(sizeval))) == NULL)
+                sizestr = error;
+        if ((hpstr = strdup(precsize_ntoa(hpval))) == NULL)
+                hpstr = error;
+        if ((vpstr = strdup(precsize_ntoa(vpval))) == NULL)
+                vpstr = error;
+
+        snprintf(ascii, ascii_len,
+              "%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %d.%.2dm %sm %sm %sm",
+                latdeg, latmin, latsec, latsecfrac, northsouth,
+                longdeg, longmin, longsec, longsecfrac, eastwest,
+                altmeters, altfrac, sizestr, hpstr, vpstr);
+
+        if (sizestr != error)
+                free(sizestr);
+        if (hpstr != error)
+                free(hpstr);
+        if (vpstr != error)
+                free(vpstr);
+
+        return (ascii);
+}
+
+
+/* Return the number of DNS hierarchy levels in the name. */
+int
+__dn_count_labels(char *name)
+{
+        int i, len, count;
+
+        len = strlen(name);
+
+        for(i = 0, count = 0; i < len; i++) {
+                if (name[i] == '.')
+                        count++;
+        }
+
+        /* don't count initial wildcard */
+        if (name[0] == '*')
+                if (count)
+                        count--;
+
+        /* don't count the null label for root. */
+        /* if terminating '.' not found, must adjust */
+        /* count to include last label */
+        if (len > 0 && name[len-1] != '.')
+                count++;
+        return (count);
+}
+
+
+/* 
+ * Make dates expressed in seconds-since-Jan-1-1970 easy to read.  
+ * SIG records are required to be printed like this, by the Secure DNS RFC.
+ */
+char *
+__p_secstodate (long unsigned int secs)
+{
+        static char output[15];         /* YYYYMMDDHHMMSS and null */
+        time_t clock = secs;
+        struct tm *time;
+        
+        time = gmtime(&clock);
+        time->tm_year += 1900;
+        time->tm_mon += 1;
+        snprintf(output, sizeof output, "%04d%02d%02d%02d%02d%02d",
+                time->tm_year, time->tm_mon, time->tm_mday,
+                time->tm_hour, time->tm_min, time->tm_sec);
+        return (output);
+}
diff --git a/src/lib/libc/net/res_debug_syms.c b/src/lib/libc/net/res_debug_syms.c
new file mode 100644
index 0000000000..7e7d22c914
--- /dev/null
+++ b/src/lib/libc/net/res_debug_syms.c
@@ -0,0 +1,189 @@
+/*      $OpenBSD: res_debug_syms.c,v 1.1 2005/08/06 20:30:04 espie Exp $        */
+
+/*
+ * ++Copyright++ 1985, 1990, 1993
+ * -
+ * Copyright (c) 1985, 1990, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * --Copyright--
+ */
+
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+
+#include <resolv.h>
+#include <stdio.h>
+
+/*
+ * Names of RR classes and qclasses.  Classes and qclasses are the same, except
+ * that C_ANY is a qclass but not a class.  (You can ask for records of class
+ * C_ANY, but you can't have any records of that class in the database.)
+ */
+const struct res_sym __p_class_syms[] = {
+        {C_IN,          "IN"},
+        {C_CHAOS,       "CHAOS"},
+        {C_HS,          "HS"},
+        {C_HS,          "HESIOD"},
+        {C_ANY,         "ANY"},
+        {C_IN,          (char *)0}
+};
+
+/*
+ * Names of RR types and qtypes.  Types and qtypes are the same, except
+ * that T_ANY is a qtype but not a type.  (You can ask for records of type
+ * T_ANY, but you can't have any records of that type in the database.)
+ */
+const struct res_sym __p_type_syms[] = {
+        {T_A,           "A",            "address"},
+        {T_NS,          "NS",           "name server"},
+        {T_MD,          "MD",           "mail destination (deprecated)"},
+        {T_MF,          "MF",           "mail forwarder (deprecated)"},
+        {T_CNAME,       "CNAME",        "canonical name"},
+        {T_SOA,         "SOA",          "start of authority"},
+        {T_MB,          "MB",           "mailbox"},
+        {T_MG,          "MG",           "mail group member"},
+        {T_MR,          "MR",           "mail rename"},
+        {T_NULL,        "NULL",         "null"},
+        {T_WKS,         "WKS",          "well-known service (deprecated)"},
+        {T_PTR,         "PTR",          "domain name pointer"},
+        {T_HINFO,       "HINFO",        "host information"},
+        {T_MINFO,       "MINFO",        "mailbox information"},
+        {T_MX,          "MX",           "mail exchanger"},
+        {T_TXT,         "TXT",          "text"},
+        {T_RP,          "RP",           "responsible person"},
+        {T_AFSDB,       "AFSDB",        "DCE or AFS server"},
+        {T_X25,         "X25",          "X25 address"},
+        {T_ISDN,        "ISDN",         "ISDN address"},
+        {T_RT,          "RT",           "router"},
+        {T_NSAP,        "NSAP",         "nsap address"},
+        {T_NSAP_PTR,    "NSAP_PTR",     "domain name pointer"},
+        {T_SIG,         "SIG",          "signature"},
+        {T_KEY,         "KEY",          "key"},
+        {T_PX,          "PX",           "mapping information"},
+        {T_GPOS,        "GPOS",         "geographical position (withdrawn)"},
+        {T_AAAA,        "AAAA",         "IPv6 address"},
+        {T_LOC,         "LOC",          "location"},
+        {T_NXT,         "NXT",          "next valid name (unimplemented)"},
+        {T_EID,         "EID",          "endpoint identifier (unimplemented)"},
+        {T_NIMLOC,      "NIMLOC",       "NIMROD locator (unimplemented)"},
+        {T_SRV,         "SRV",          "server selection"},
+        {T_ATMA,        "ATMA",         "ATM address (unimplemented)"},
+        {T_IXFR,        "IXFR",         "incremental zone transfer"},
+        {T_AXFR,        "AXFR",         "zone transfer"},
+        {T_MAILB,       "MAILB",        "mailbox-related data (deprecated)"},
+        {T_MAILA,       "MAILA",        "mail agent (deprecated)"},
+        {T_UINFO,       "UINFO",        "user information (nonstandard)"},
+        {T_UID,         "UID",          "user ID (nonstandard)"},
+        {T_GID,         "GID",          "group ID (nonstandard)"},
+        {T_NAPTR,       "NAPTR",        "URN Naming Authority"},
+#ifdef ALLOW_T_UNSPEC
+        {T_UNSPEC,      "UNSPEC",       "unspecified data (nonstandard)"},
+#endif /* ALLOW_T_UNSPEC */
+        {T_ANY,         "ANY",          "\"any\""},
+        {0,             NULL,           NULL}
+};
+
+const char *
+__sym_ntos(const struct res_sym *syms, int number, int *success)
+{
+        static char unname[20];
+
+        for (; syms->name != 0; syms++) {
+                if (number == syms->number) {
+                        if (success)
+                                *success = 1;
+                        return (syms->name);
+                }
+        }
+
+        snprintf(unname, sizeof unname, "%d", number);
+        if (success)
+                *success = 0;
+        return (unname);
+}
+
+/*
+ * Return a string for the type
+ */
+const char *
+__p_type(int type)
+{
+        return (__sym_ntos (__p_type_syms, type, (int *)0));
+}
+
+/*
+ * Return a mnemonic for class
+ */
+const char *
+__p_class(int class)
+{
+        return (__sym_ntos (__p_class_syms, class, (int *)0));
+}
+
diff --git a/src/lib/libc/net/res_init.c b/src/lib/libc/net/res_init.c
new file mode 100644
index 0000000000..43ee5ac6bb
--- /dev/null
+++ b/src/lib/libc/net/res_init.c
@@ -0,0 +1,666 @@
+/*      $OpenBSD: res_init.c,v 1.34 2005/12/22 06:52:11 tedu Exp $      */
+
+/*
+ * ++Copyright++ 1985, 1989, 1993
+ * -
+ * Copyright (c) 1985, 1989, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#ifndef INET6
+#define INET6
+#endif
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <resolv.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef INET6
+#include <netdb.h>
+#endif /* INET6 */
+
+#include "thread_private.h"
+
+/*-------------------------------------- info about "sortlist" --------------
+ * Marc Majka           1994/04/16
+ * Allan Nathanson      1994/10/29 (BIND 4.9.3.x)
+ *
+ * NetInfo resolver configuration directory support.
+ *
+ * Allow a NetInfo directory to be created in the hierarchy which
+ * contains the same information as the resolver configuration file.
+ *
+ * - The local domain name is stored as the value of the "domain" property.
+ * - The Internet address(es) of the name server(s) are stored as values
+ *   of the "nameserver" property.
+ * - The name server addresses are stored as values of the "nameserver"
+ *   property.
+ * - The search list for host-name lookup is stored as values of the
+ *   "search" property.
+ * - The sortlist comprised of IP address netmask pairs are stored as
+ *   values of the "sortlist" property. The IP address and optional netmask
+ *   should be separated by a slash (/) or ampersand (&) character.
+ * - Internal resolver variables can be set from the value of the "options"
+ *   property.
+ */
+
+static void res_setoptions(char *, char *);
+
+#ifdef RESOLVSORT
+static const char sort_mask[] = "/&";
+#define ISSORTMASK(ch) (strchr(sort_mask, ch) != NULL)
+static u_int32_t net_mask(struct in_addr);
+#endif
+
+/*
+ * Resolver state default settings.
+ */
+void *__THREAD_NAME(_res);
+
+struct __res_state _res
+# if defined(__BIND_RES_TEXT)
+        = { RES_TIMEOUT, }      /* Motorola, et al. */
+# endif
+        ;
+#ifdef INET6
+void *__THREAD_NAME(_res_ext);
+
+struct __res_state_ext _res_ext;
+#endif /* INET6 */
+
+int __res_chktime = 30;
+
+/*
+ * Set up default settings.  If the configuration file exist, the values
+ * there will have precedence.  Otherwise, the server address is set to
+ * INADDR_ANY and the default domain name comes from the gethostname().
+ *
+ * An interrim version of this code (BIND 4.9, pre-4.4BSD) used 127.0.0.1
+ * rather than INADDR_ANY ("0.0.0.0") as the default name server address
+ * since it was noted that INADDR_ANY actually meant ``the first interface
+ * you "ifconfig"'d at boot time'' and if this was a SLIP or PPP interface,
+ * it had to be "up" in order for you to reach your own name server.  It
+ * was later decided that since the recommended practice is to always 
+ * install local static routes through 127.0.0.1 for all your network
+ * interfaces, that we could solve this problem without a code change.
+ *
+ * The configuration file should always be used, since it is the only way
+ * to specify a default domain.  If you are running a server on your local
+ * machine, you should say "nameserver 0.0.0.0" or "nameserver 127.0.0.1"
+ * in the configuration file.
+ *
+ * Return 0 if completes successfully, -1 on error
+ */
+int
+res_init(void)
+{
+
+        return (_res_init(1));
+}
+
+int
+_res_init(int usercall)
+{
+        struct stat sb;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+#ifdef INET6
+        struct __res_state_ext *_res_extp = _THREAD_PRIVATE(_res_ext, _res_ext,
+                                                            &_res_ext);
+#endif
+        FILE *fp;
+        char *cp, **pp;
+        int n;
+        char buf[BUFSIZ];
+        int nserv = 0;    /* number of nameserver records read from file */
+        int haveenv = 0;
+        int havesearch = 0;
+        size_t len;
+#ifdef RESOLVSORT
+        int nsort = 0;
+        char *net;
+#endif
+#ifndef RFC1535
+        int dots;
+#endif
+
+        if (!usercall && _resp->options & RES_INIT &&
+            _resp->reschktime >= time(NULL))
+                return (0);
+        _resp->reschktime = time(NULL) + __res_chktime;
+        if (stat(_PATH_RESCONF, &sb) != -1) {
+                if (!usercall && timespeccmp(&sb.st_mtimespec,
+                    &_resp->restimespec, ==))
+                        return (0);
+                else
+                        _resp->restimespec = sb.st_mtimespec;
+        } else {
+                /*
+                 * Lost the file, in chroot?
+                 * Don't trash settings
+                 */
+                if (!usercall && timespecisset(&_resp->restimespec))
+                        return (0);
+        }
+
+
+        /*
+         * These three fields used to be statically initialized.  This made
+         * it hard to use this code in a shared library.  It is necessary,
+         * now that we're doing dynamic initialization here, that we preserve
+         * the old semantics: if an application modifies one of these three
+         * fields of _res before res_init() is called, res_init() will not
+         * alter them.  Of course, if an application is setting them to
+         * _zero_ before calling res_init(), hoping to override what used
+         * to be the static default, we can't detect it and unexpected results
+         * will follow.  Zero for any of these fields would make no sense,
+         * so one can safely assume that the applications were already getting
+         * unexpected results.
+         *
+         * _res.options is tricky since some apps were known to diddle the bits
+         * before res_init() was first called. We can't replicate that semantic
+         * with dynamic initialization (they may have turned bits off that are
+         * set in RES_DEFAULT).  Our solution is to declare such applications
+         * "broken".  They could fool us by setting RES_INIT but none do (yet).
+         */
+        if (!_resp->retrans)
+                _resp->retrans = RES_TIMEOUT;
+        if (!_resp->retry)
+                _resp->retry = 4;
+        if (!(_resp->options & RES_INIT))
+                _resp->options = RES_DEFAULT;
+
+#ifdef USELOOPBACK
+        _resp->nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
+#else
+        _resp->nsaddr.sin_addr.s_addr = INADDR_ANY;
+#endif
+        _resp->nsaddr.sin_family = AF_INET;
+        _resp->nsaddr.sin_port = htons(NAMESERVER_PORT);
+        _resp->nsaddr.sin_len = sizeof(struct sockaddr_in);
+#ifdef INET6
+        if (sizeof(_res_extp->nsaddr) >= _resp->nsaddr.sin_len)
+                memcpy(&_res_extp->nsaddr, &_resp->nsaddr, _resp->nsaddr.sin_len);
+#endif
+        _resp->nscount = 1;
+        _resp->ndots = 1;
+        _resp->pfcode = 0;
+        strlcpy(_resp->lookups, "f", sizeof _resp->lookups);
+
+        /* Allow user to override the local domain definition */
+        if (issetugid() == 0 && (cp = getenv("LOCALDOMAIN")) != NULL) {
+                strlcpy(_resp->defdname, cp, sizeof(_resp->defdname));
+                haveenv++;
+
+                /*
+                 * Set search list to be blank-separated strings
+                 * from rest of env value.  Permits users of LOCALDOMAIN
+                 * to still have a search list, and anyone to set the
+                 * one that they want to use as an individual (even more
+                 * important now that the rfc1535 stuff restricts searches)
+                 */
+                cp = _resp->defdname;
+                pp = _resp->dnsrch;
+                *pp++ = cp;
+                for (n = 0; *cp && pp < _resp->dnsrch + MAXDNSRCH; cp++) {
+                        if (*cp == '\n')        /* silly backwards compat */
+                                break;
+                        else if (*cp == ' ' || *cp == '\t') {
+                                *cp = 0;
+                                n = 1;
+                        } else if (n) {
+                                *pp++ = cp;
+                                n = 0;
+                                havesearch = 1;
+                        }
+                }
+                /* null terminate last domain if there are excess */
+                while (*cp != '\0' && *cp != ' ' && *cp != '\t' && *cp != '\n')
+                        cp++;
+                *cp = '\0';
+                *pp++ = 0;
+        }
+
+#define MATCH(line, name) \
+        (!strncmp(line, name, sizeof(name) - 1) && \
+        (line[sizeof(name) - 1] == ' ' || \
+         line[sizeof(name) - 1] == '\t'))
+
+        if ((fp = fopen(_PATH_RESCONF, "r")) != NULL) {
+            strlcpy(_resp->lookups, "bf", sizeof _resp->lookups);
+
+            /* read the config file */
+            buf[0] = '\0';
+            while ((cp = fgetln(fp, &len)) != NULL) {
+                /* skip lines that are too long or zero length */
+                if (len >= sizeof(buf) || len == 0)
+                    continue;
+                (void)memcpy(buf, cp, len);
+                buf[len] = '\0';
+                /* skip comments */
+                if ((cp = strpbrk(buf, ";#")) != NULL)
+                        *cp = '\0';
+                if (buf[0] == '\0')
+                        continue;
+                /* read default domain name */
+                if (MATCH(buf, "domain")) {
+                    if (haveenv)        /* skip if have from environ */
+                            continue;
+                    cp = buf + sizeof("domain") - 1;
+                    while (*cp == ' ' || *cp == '\t')
+                            cp++;
+                    if ((*cp == '\0') || (*cp == '\n'))
+                            continue;
+                    strlcpy(_resp->defdname, cp, sizeof(_resp->defdname));
+                    if ((cp = strpbrk(_resp->defdname, " \t\n")) != NULL)
+                            *cp = '\0';
+                    havesearch = 0;
+                    continue;
+                }
+                /* lookup types */
+                if (MATCH(buf, "lookup")) {
+                    char *sp = NULL;
+
+                    bzero(_resp->lookups, sizeof _resp->lookups);
+                    cp = buf + sizeof("lookup") - 1;
+                    for (n = 0;; cp++) {
+                            if (n == MAXDNSLUS)
+                                    break;
+                            if ((*cp == '\0') || (*cp == '\n')) {
+                                    if (sp) {
+                                            if (*sp=='y' || *sp=='b' || *sp=='f')
+                                                    _resp->lookups[n++] = *sp;
+                                            sp = NULL;
+                                    }
+                                    break;
+                            } else if ((*cp == ' ') || (*cp == '\t') || (*cp == ',')) {
+                                    if (sp) {
+                                            if (*sp=='y' || *sp=='b' || *sp=='f')
+                                                    _resp->lookups[n++] = *sp;
+                                            sp = NULL;
+                                    }
+                            } else if (sp == NULL)
+                                    sp = cp;
+                    }
+                    continue;
+                }
+                /* set search list */
+                if (MATCH(buf, "search")) {
+                    if (haveenv)        /* skip if have from environ */
+                            continue;
+                    cp = buf + sizeof("search") - 1;
+                    while (*cp == ' ' || *cp == '\t')
+                            cp++;
+                    if ((*cp == '\0') || (*cp == '\n'))
+                            continue;
+                    strlcpy(_resp->defdname, cp, sizeof(_resp->defdname));
+                    if ((cp = strchr(_resp->defdname, '\n')) != NULL)
+                            *cp = '\0';
+                    /*
+                     * Set search list to be blank-separated strings
+                     * on rest of line.
+                     */
+                    cp = _resp->defdname;
+                    pp = _resp->dnsrch;
+                    *pp++ = cp;
+                    for (n = 0; *cp && pp < _resp->dnsrch + MAXDNSRCH; cp++) {
+                            if (*cp == ' ' || *cp == '\t') {
+                                    *cp = 0;
+                                    n = 1;
+                            } else if (n) {
+                                    *pp++ = cp;
+                                    n = 0;
+                            }
+                    }
+                    /* null terminate last domain if there are excess */
+                    while (*cp != '\0' && *cp != ' ' && *cp != '\t')
+                            cp++;
+                    *cp = '\0';
+                    *pp++ = 0;
+                    havesearch = 1;
+                    continue;
+                }
+                /* read nameservers to query */
+                if (MATCH(buf, "nameserver") && nserv < MAXNS) {
+#ifdef INET6
+                    char *q;
+                    struct addrinfo hints, *res;
+                    char pbuf[NI_MAXSERV];
+#else
+                    struct in_addr a;
+#endif /* INET6 */
+
+                    cp = buf + sizeof("nameserver") - 1;
+                    while (*cp == ' ' || *cp == '\t')
+                        cp++;
+#ifdef INET6
+                    if ((*cp == '\0') || (*cp == '\n'))
+                        continue;
+                    for (q = cp; *q; q++) {
+                        if (isspace(*q)) {
+                            *q = '\0';
+                            break;
+                        }
+                    }
+                    memset(&hints, 0, sizeof(hints));
+                    hints.ai_flags = AI_NUMERICHOST;
+                    hints.ai_socktype = SOCK_DGRAM;
+                    snprintf(pbuf, sizeof(pbuf), "%u", NAMESERVER_PORT);
+                    res = NULL;
+                    if (getaddrinfo(cp, pbuf, &hints, &res) == 0 &&
+                            res->ai_next == NULL) {
+                        if (res->ai_addrlen <= sizeof(_res_extp->nsaddr_list[nserv])) {
+                            memcpy(&_res_extp->nsaddr_list[nserv], res->ai_addr,
+                                res->ai_addrlen);
+                        } else {
+                            memset(&_res_extp->nsaddr_list[nserv], 0,
+                                sizeof(_res_extp->nsaddr_list[nserv]));
+                        }
+                        if (res->ai_addrlen <= sizeof(_resp->nsaddr_list[nserv])) {
+                            memcpy(&_resp->nsaddr_list[nserv], res->ai_addr,
+                                res->ai_addrlen);
+                        } else {
+                            memset(&_resp->nsaddr_list[nserv], 0,
+                                sizeof(_resp->nsaddr_list[nserv]));
+                        }
+                        nserv++;
+                    }
+                    if (res)
+                        freeaddrinfo(res);
+#else /* INET6 */
+                    if ((*cp != '\0') && (*cp != '\n') && inet_aton(cp, &a)) {
+                        _resp->nsaddr_list[nserv].sin_addr = a;
+                        _resp->nsaddr_list[nserv].sin_family = AF_INET;
+                        _resp->nsaddr_list[nserv].sin_port =
+                                htons(NAMESERVER_PORT);
+                        _resp->nsaddr_list[nserv].sin_len =
+                                sizeof(struct sockaddr_in);
+                        nserv++;
+                    }
+#endif /* INET6 */
+                    continue;
+                }
+#ifdef RESOLVSORT
+                if (MATCH(buf, "sortlist")) {
+                    struct in_addr a;
+#ifdef INET6
+                    struct in6_addr a6;
+                    int m, i;
+                    u_char *u;
+#endif /* INET6 */
+
+                    cp = buf + sizeof("sortlist") - 1;
+                    while (nsort < MAXRESOLVSORT) {
+                        while (*cp == ' ' || *cp == '\t')
+                            cp++;
+                        if (*cp == '\0' || *cp == '\n' || *cp == ';')
+                            break;
+                        net = cp;
+                        while (*cp && !ISSORTMASK(*cp) && *cp != ';' &&
+                               isascii(*cp) && !isspace(*cp))
+                                cp++;
+                        n = *cp;
+                        *cp = 0;
+                        if (inet_aton(net, &a)) {
+                            _resp->sort_list[nsort].addr = a;
+                            if (ISSORTMASK(n)) {
+                                *cp++ = n;
+                                net = cp;
+                                while (*cp && *cp != ';' &&
+                                        isascii(*cp) && !isspace(*cp))
+                                    cp++;
+                                n = *cp;
+                                *cp = 0;
+                                if (inet_aton(net, &a)) {
+                                    _resp->sort_list[nsort].mask = a.s_addr;
+                                } else {
+                                    _resp->sort_list[nsort].mask = 
+                                        net_mask(_resp->sort_list[nsort].addr);
+                                }
+                            } else {
+                                _resp->sort_list[nsort].mask = 
+                                    net_mask(_resp->sort_list[nsort].addr);
+                            }
+#ifdef INET6
+                            _res_extp->sort_list[nsort].af = AF_INET;
+                            _res_extp->sort_list[nsort].addr.ina =
+                                _resp->sort_list[nsort].addr;
+                            _res_extp->sort_list[nsort].mask.ina.s_addr =
+                                _resp->sort_list[nsort].mask;
+#endif /* INET6 */
+                            nsort++;
+                        }
+#ifdef INET6
+                        else if (inet_pton(AF_INET6, net, &a6) == 1) {
+                            _res_extp->sort_list[nsort].af = AF_INET6;
+                            _res_extp->sort_list[nsort].addr.in6a = a6;
+                            u = (u_char *)&_res_extp->sort_list[nsort].mask.in6a;
+                            *cp++ = n;
+                            net = cp;
+                            while (*cp && *cp != ';' &&
+                                    isascii(*cp) && !isspace(*cp))
+                                cp++;
+                            m = n;
+                            n = *cp;
+                            *cp = 0;
+                            switch (m) {
+                            case '/':
+                                m = atoi(net);
+                                break;
+                            case '&':
+                                if (inet_pton(AF_INET6, net, u) == 1) {
+                                    m = -1;
+                                    break;
+                                }
+                                /*FALLTHRU*/
+                            default:
+                                m = sizeof(struct in6_addr) * NBBY;
+                                break;
+                            }
+                            if (m >= 0) {
+                                for (i = 0; i < sizeof(struct in6_addr); i++) {
+                                    if (m <= 0) {
+                                        *u = 0;
+                                    } else {
+                                        m -= NBBY;
+                                        *u = (u_char)~0;
+                                        if (m < 0)
+                                            *u <<= -m;
+                                    }
+                                    u++;
+                                }
+                            }
+                            nsort++;
+                        }
+#endif /* INET6 */
+                        *cp = n;
+                    }
+                    continue;
+                }
+#endif
+                if (MATCH(buf, "options")) {
+                    res_setoptions(buf + sizeof("options") - 1, "conf");
+                    continue;
+                }
+            }
+            if (nserv > 1) 
+                _resp->nscount = nserv;
+#ifdef RESOLVSORT
+            _resp->nsort = nsort;
+#endif
+            (void) fclose(fp);
+        }
+        if (_resp->defdname[0] == 0 &&
+            gethostname(buf, sizeof(_resp->defdname) - 1) == 0 &&
+            (cp = strchr(buf, '.')) != NULL)
+        {
+                strlcpy(_resp->defdname, cp + 1,
+                        sizeof(_resp->defdname));
+        }
+
+        /* find components of local domain that might be searched */
+        if (havesearch == 0) {
+                pp = _resp->dnsrch;
+                *pp++ = _resp->defdname;
+                *pp = NULL;
+
+#ifndef RFC1535
+                dots = 0;
+                for (cp = _resp->defdname; *cp; cp++)
+                        dots += (*cp == '.');
+
+                cp = _resp->defdname;
+                while (pp < _resp->dnsrch + MAXDFLSRCH) {
+                        if (dots < LOCALDOMAINPARTS)
+                                break;
+                        cp = strchr(cp, '.') + 1;    /* we know there is one */
+                        *pp++ = cp;
+                        dots--;
+                }
+                *pp = NULL;
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG) {
+                        printf(";; res_init()... default dnsrch list:\n");
+                        for (pp = _resp->dnsrch; *pp; pp++)
+                                printf(";;\t%s\n", *pp);
+                        printf(";;\t..END..\n");
+                }
+#endif /* DEBUG */
+#endif /* !RFC1535 */
+        }
+
+        if (issetugid())
+                _resp->options |= RES_NOALIASES;
+        else if ((cp = getenv("RES_OPTIONS")) != NULL)
+                res_setoptions(cp, "env");
+        _resp->options |= RES_INIT;
+        return (0);
+}
+
+/* ARGSUSED */
+static void
+res_setoptions(char *options, char *source)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char *cp = options;
+        char *endp;
+        long l;
+
+#ifdef DEBUG
+        if (_resp->options & RES_DEBUG)
+                printf(";; res_setoptions(\"%s\", \"%s\")...\n",
+                       options, source);
+#endif
+        while (*cp) {
+                /* skip leading and inner runs of spaces */
+                while (*cp == ' ' || *cp == '\t')
+                        cp++;
+                /* search for and process individual options */
+                if (!strncmp(cp, "ndots:", sizeof("ndots:") - 1)) {
+                        char *p = cp + sizeof("ndots:") - 1;
+                        l = strtol(p, &endp, 10);
+                        if (l >= 0 && endp != p &&
+                            (*endp = '\0' || isspace(*endp))) {
+                                if (l <= RES_MAXNDOTS)
+                                        _resp->ndots = l;
+                                else
+                                        _resp->ndots = RES_MAXNDOTS;
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf(";;\tndots=%u\n", _resp->ndots);
+#endif
+                        }
+                } else if (!strncmp(cp, "debug", sizeof("debug") - 1)) {
+#ifdef DEBUG
+                        if (!(_resp->options & RES_DEBUG)) {
+                                printf(";; res_setoptions(\"%s\", \"%s\")..\n",
+                                       options, source);
+                                _resp->options |= RES_DEBUG;
+                        }
+                        printf(";;\tdebug\n");
+#endif
+                } else if (!strncmp(cp, "inet6", sizeof("inet6") - 1)) {
+                        _resp->options |= RES_USE_INET6;
+                } else if (!strncmp(cp, "insecure1", sizeof("insecure1") - 1)) {
+                        _resp->options |= RES_INSECURE1;
+                } else if (!strncmp(cp, "insecure2", sizeof("insecure2") - 1)) {
+                        _resp->options |= RES_INSECURE2;
+                } else if (!strncmp(cp, "edns0", sizeof("edns0") - 1)) {
+                        _resp->options |= RES_USE_EDNS0;
+                } else {
+                        /* XXX - print a warning here? */
+                }
+                /* skip to next run of spaces */
+                while (*cp && *cp != ' ' && *cp != '\t')
+                        cp++;
+        }
+}
+
+#ifdef RESOLVSORT
+/* XXX - should really support CIDR which means explicit masks always. */
+static u_int32_t
+net_mask(struct in_addr in)     /* XXX - should really use system's version of this */
+{
+        u_int32_t i = ntohl(in.s_addr);
+
+        if (IN_CLASSA(i))
+                return (htonl(IN_CLASSA_NET));
+        else if (IN_CLASSB(i))
+                return (htonl(IN_CLASSB_NET));
+        return (htonl(IN_CLASSC_NET));
+}
+#endif
diff --git a/src/lib/libc/net/res_mkquery.c b/src/lib/libc/net/res_mkquery.c
new file mode 100644
index 0000000000..5c6b273abe
--- /dev/null
+++ b/src/lib/libc/net/res_mkquery.c
@@ -0,0 +1,232 @@
+/*      $OpenBSD: res_mkquery.c,v 1.17 2005/08/06 20:30:04 espie Exp $  */
+
+/*
+ * ++Copyright++ 1985, 1993
+ * -
+ * Copyright (c) 1985, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <string.h>
+
+#include "thread_private.h"
+
+/*
+ * Form all types of queries.
+ * Returns the size of the result or -1.
+ */
+/* ARGSUSED */
+int
+res_mkquery(int op,
+    const char *dname,          /* opcode of query */
+    int class,                  /* domain name */
+    int type,                   /* class and type of query */
+    const u_char *data,         /* resource record data */
+    int datalen,                /* length of data */
+    const u_char *newrr_in,     /* new rr for modify or append */
+    u_char *buf,                /* buffer to put query */
+    int buflen)                 /* size of buffer */
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        HEADER *hp;
+        u_char *cp, *ep;
+        int n;
+        u_char *dnptrs[20], **dpp, **lastdnptr;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+#ifdef DEBUG
+        if (_resp->options & RES_DEBUG)
+                printf(";; res_mkquery(%d, %s, %d, %d)\n",
+                       op, dname, class, type);
+#endif
+        /*
+         * Initialize header fields.
+         *
+         * A special random number generator is used to create non predictable
+         * and non repeating ids over a long period. It also avoids reuse
+         * by switching between two distinct number cycles.
+         */
+
+        if ((buf == NULL) || (buflen < HFIXEDSZ))
+                return (-1);
+        bzero(buf, HFIXEDSZ);
+        hp = (HEADER *) buf;
+        _resp->id = res_randomid();
+        hp->id = htons(_resp->id);
+        hp->opcode = op;
+        hp->rd = (_resp->options & RES_RECURSE) != 0;
+        hp->rcode = NOERROR;
+        cp = buf + HFIXEDSZ;
+        ep = buf + buflen;
+        dpp = dnptrs;
+        *dpp++ = buf;
+        *dpp++ = NULL;
+        lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
+        /*
+         * perform opcode specific processing
+         */
+        switch (op) {
+        case QUERY:     /*FALLTHROUGH*/
+        case NS_NOTIFY_OP:
+                if (ep - cp < QFIXEDSZ)
+                        return (-1);
+                if ((n = dn_comp(dname, cp, ep - cp - QFIXEDSZ, dnptrs,
+                    lastdnptr)) < 0)
+                        return (-1);
+                cp += n;
+                __putshort(type, cp);
+                cp += INT16SZ;
+                __putshort(class, cp);
+                cp += INT16SZ;
+                hp->qdcount = htons(1);
+                if (op == QUERY || data == NULL)
+                        break;
+                /*
+                 * Make an additional record for completion domain.
+                 */
+                if (ep - cp < RRFIXEDSZ)
+                        return (-1);
+                n = dn_comp((char *)data, cp, ep - cp - RRFIXEDSZ, dnptrs,
+                    lastdnptr);
+                if (n < 0)
+                        return (-1);
+                cp += n;
+                __putshort(T_NULL, cp);
+                cp += INT16SZ;
+                __putshort(class, cp);
+                cp += INT16SZ;
+                __putlong(0, cp);
+                cp += INT32SZ;
+                __putshort(0, cp);
+                cp += INT16SZ;
+                hp->arcount = htons(1);
+                break;
+
+        case IQUERY:
+                /*
+                 * Initialize answer section
+                 */
+                if (ep - cp < 1 + RRFIXEDSZ + datalen)
+                        return (-1);
+                *cp++ = '\0';   /* no domain name */
+                __putshort(type, cp);
+                cp += INT16SZ;
+                __putshort(class, cp);
+                cp += INT16SZ;
+                __putlong(0, cp);
+                cp += INT32SZ;
+                __putshort(datalen, cp);
+                cp += INT16SZ;
+                if (datalen) {
+                        bcopy(data, cp, datalen);
+                        cp += datalen;
+                }
+                hp->ancount = htons(1);
+                break;
+
+        default:
+                return (-1);
+        }
+        return (cp - buf);
+}
+
+/* attach OPT pseudo-RR, as documented in RFC2671 (EDNS0). */
+int
+res_opt(int n0,
+        u_char *buf,            /* buffer to put query */
+        int buflen,             /* size of buffer */
+        int anslen)             /* answer buffer length */
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        HEADER *hp;
+        u_char *cp, *ep;
+
+        hp = (HEADER *) buf;
+        cp = buf + n0;
+        ep = buf + buflen;
+
+        if (ep - cp < 1 + RRFIXEDSZ)
+                return -1;
+
+        *cp++ = 0;      /* "." */
+
+        __putshort(T_OPT, cp);  /* TYPE */
+        cp += INT16SZ;
+        if (anslen > 0xffff)
+                anslen = 0xffff;                /* limit to 16bit value */
+        __putshort(anslen & 0xffff, cp);        /* CLASS = UDP payload size */
+        cp += INT16SZ;
+        *cp++ = NOERROR;        /* extended RCODE */
+        *cp++ = 0;              /* EDNS version */
+        if (_resp->options & RES_USE_DNSSEC) {
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG)
+                        printf(";; res_opt()... ENDS0 DNSSEC OK\n");
+#endif /* DEBUG */
+                __putshort(DNS_MESSAGEEXTFLAG_DO, cp);  /* EDNS Z field */
+                cp += INT16SZ;
+        } else {
+                __putshort(0, cp);      /* EDNS Z field */
+                cp += INT16SZ;
+        }
+        __putshort(0, cp);      /* RDLEN */
+        cp += INT16SZ;
+        hp->arcount = htons(ntohs(hp->arcount) + 1);
+
+        return cp - buf;
+}
diff --git a/src/lib/libc/net/res_query.c b/src/lib/libc/net/res_query.c
new file mode 100644
index 0000000000..32cd04306c
--- /dev/null
+++ b/src/lib/libc/net/res_query.c
@@ -0,0 +1,398 @@
+/*      $OpenBSD: res_query.c,v 1.24 2005/08/06 20:30:04 espie Exp $    */
+
+/*
+ * ++Copyright++ 1988, 1993
+ * -
+ * Copyright (c) 1988, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <stdio.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "thread_private.h"
+
+#if PACKETSZ > 1024
+#define MAXPACKET       PACKETSZ
+#else
+#define MAXPACKET       1024
+#endif
+
+const char *hostalias(const char *);
+int h_errno;
+extern int res_opt(int, u_char *, int, int);
+
+/*
+ * Formulate a normal query, send, and await answer.
+ * Returned answer is placed in supplied buffer "answer".
+ * Perform preliminary check of answer, returning success only
+ * if no error is indicated and the answer count is nonzero.
+ * Return the size of the response on success, -1 on error.
+ * Error number is left in h_errno.
+ *
+ * Caller must parse answer and determine whether it answers the question.
+ */
+int
+res_query(const char *name,
+    int class,          /* domain name */
+    int type,           /* class and type of query */
+    u_char *answer,     /* buffer to put answer */
+    int anslen)         /* size of answer buffer */
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        u_char buf[MAXPACKET];
+        HEADER *hp = (HEADER *) answer;
+        int n;
+
+        hp->rcode = NOERROR;    /* default */
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+#ifdef DEBUG
+        if (_resp->options & RES_DEBUG)
+                printf(";; res_query(%s, %d, %d)\n", name, class, type);
+#endif
+
+        n = res_mkquery(QUERY, name, class, type, NULL, 0, NULL,
+                        buf, sizeof(buf));
+        if (n > 0 && ((_resp->options & RES_USE_EDNS0) ||
+            (_resp->options & RES_USE_DNSSEC))) {
+                n = res_opt(n, buf, sizeof(buf), anslen);
+        }
+
+        if (n <= 0) {
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG)
+                        printf(";; res_query: mkquery failed\n");
+#endif
+                h_errno = NO_RECOVERY;
+                return (n);
+        }
+        n = res_send(buf, n, answer, anslen);
+        if (n < 0) {
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG)
+                        printf(";; res_query: send error\n");
+#endif
+                h_errno = TRY_AGAIN;
+                return (n);
+        }
+
+        if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
+#ifdef DEBUG
+                if (_resp->options & RES_DEBUG)
+                        printf(";; rcode = %u, ancount=%u\n", hp->rcode,
+                            ntohs(hp->ancount));
+#endif
+                switch (hp->rcode) {
+                case NXDOMAIN:
+                        h_errno = HOST_NOT_FOUND;
+                        break;
+                case SERVFAIL:
+                        h_errno = TRY_AGAIN;
+                        break;
+                case NOERROR:
+                        h_errno = NO_DATA;
+                        break;
+                case FORMERR:
+                case NOTIMP:
+                case REFUSED:
+                default:
+                        h_errno = NO_RECOVERY;
+                        break;
+                }
+                return (-1);
+        }
+        return (n);
+}
+
+/*
+ * Formulate a normal query, send, and retrieve answer in supplied buffer.
+ * Return the size of the response on success, -1 on error.
+ * If enabled, implement search rules until answer or unrecoverable failure
+ * is detected.  Error code, if any, is left in h_errno.
+ */
+int
+res_search(const char *name,
+    int class,          /* domain name */
+    int type,           /* class and type of query */
+    u_char *answer,     /* buffer to put answer */
+    int anslen)         /* size of answer */
+{
+        const char *cp, * const *domain;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        HEADER *hp = (HEADER *) answer;
+        u_int dots;
+        int trailing_dot, ret, saved_herrno;
+        int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+        errno = 0;
+        h_errno = HOST_NOT_FOUND;       /* default, if we never query */
+        dots = 0;
+        for (cp = name; *cp; cp++)
+                dots += (*cp == '.');
+        trailing_dot = 0;
+        if (cp > name && *--cp == '.')
+                trailing_dot++;
+
+        /*
+         * if there aren't any dots, it could be a user-level alias
+         */
+        if (!dots && (cp = __hostalias(name)) != NULL)
+                return (res_query(cp, class, type, answer, anslen));
+
+        /*
+         * If there are dots in the name already, let's just give it a try
+         * 'as is'.  The threshold can be set with the "ndots" option.
+         */
+        saved_herrno = -1;
+        if (dots >= _resp->ndots) {
+                ret = res_querydomain(name, NULL, class, type, answer, anslen);
+                if (ret > 0)
+                        return (ret);
+                saved_herrno = h_errno;
+                tried_as_is++;
+        }
+
+        /*
+         * We do at least one level of search if
+         *      - there is no dot and RES_DEFNAME is set, or
+         *      - there is at least one dot, there is no trailing dot,
+         *        and RES_DNSRCH is set.
+         */
+        if ((!dots && (_resp->options & RES_DEFNAMES)) ||
+            (dots && !trailing_dot && (_resp->options & RES_DNSRCH))) {
+                int done = 0;
+
+                for (domain = (const char * const *)_resp->dnsrch;
+                     *domain && !done;
+                     domain++) {
+
+                        ret = res_querydomain(name, *domain, class, type,
+                                              answer, anslen);
+                        if (ret > 0)
+                                return (ret);
+
+                        /*
+                         * If no server present, give up.
+                         * If name isn't found in this domain,
+                         * keep trying higher domains in the search list
+                         * (if that's enabled).
+                         * On a NO_DATA error, keep trying, otherwise
+                         * a wildcard entry of another type could keep us
+                         * from finding this entry higher in the domain.
+                         * If we get some other error (negative answer or
+                         * server failure), then stop searching up,
+                         * but try the input name below in case it's
+                         * fully-qualified.
+                         */
+                        if (errno == ECONNREFUSED) {
+                                h_errno = TRY_AGAIN;
+                                return (-1);
+                        }
+
+                        switch (h_errno) {
+                        case NO_DATA:
+                                got_nodata++;
+                                /* FALLTHROUGH */
+                        case HOST_NOT_FOUND:
+                                /* keep trying */
+                                break;
+                        case TRY_AGAIN:
+                                if (hp->rcode == SERVFAIL) {
+                                        /* try next search element, if any */
+                                        got_servfail++;
+                                        break;
+                                }
+                                /* FALLTHROUGH */
+                        default:
+                                /* anything else implies that we're done */
+                                done++;
+                        }
+
+                        /* if we got here for some reason other than DNSRCH,
+                         * we only wanted one iteration of the loop, so stop.
+                         */
+                        if (!(_resp->options & RES_DNSRCH))
+                                done++;
+                }
+        }
+
+        /* if we have not already tried the name "as is", do that now.
+         * note that we do this regardless of how many dots were in the
+         * name or whether it ends with a dot.
+         */
+        if (!tried_as_is) {
+                ret = res_querydomain(name, NULL, class, type, answer, anslen);
+                if (ret > 0)
+                        return (ret);
+        }
+
+        /* if we got here, we didn't satisfy the search.
+         * if we did an initial full query, return that query's h_errno
+         * (note that we wouldn't be here if that query had succeeded).
+         * else if we ever got a nodata, send that back as the reason.
+         * else send back meaningless h_errno, that being the one from
+         * the last DNSRCH we did.
+         */
+        if (saved_herrno != -1)
+                h_errno = saved_herrno;
+        else if (got_nodata)
+                h_errno = NO_DATA;
+        else if (got_servfail)
+                h_errno = TRY_AGAIN;
+        return (-1);
+}
+
+/*
+ * Perform a call on res_query on the concatenation of name and domain,
+ * removing a trailing dot from name if domain is NULL.
+ */
+int
+res_querydomain(const char *name,
+    const char *domain,
+    int class,          /* class and type of query */
+    int type,
+    u_char *answer,     /* buffer to put answer */
+    int anslen)         /* size of answer */
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char nbuf[MAXDNAME*2+1+1];
+        const char *longname = nbuf;
+        int n;
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
+                return (-1);
+        }
+#ifdef DEBUG
+        if (_resp->options & RES_DEBUG)
+                printf(";; res_querydomain(%s, %s, %d, %d)\n",
+                       name, domain?domain:"<Nil>", class, type);
+#endif
+        if (domain == NULL) {
+                /*
+                 * Check for trailing '.';
+                 * copy without '.' if present.
+                 */
+                n = strlen(name) - 1;
+                if (n != (0 - 1) && name[n] == '.' && n < sizeof(nbuf) - 1) {
+                        bcopy(name, nbuf, n);
+                        nbuf[n] = '\0';
+                } else
+                        longname = name;
+        } else
+                snprintf(nbuf, sizeof nbuf, "%.*s.%.*s",
+                    MAXDNAME, name, MAXDNAME, domain);
+
+        return (res_query(longname, class, type, answer, anslen));
+}
+
+const char *
+hostalias(const char *name)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char *cp1, *cp2;
+        FILE *fp;
+        char *file;
+        char buf[BUFSIZ];
+        static char abuf[MAXDNAME];
+        size_t len;
+
+        if (_resp->options & RES_NOALIASES)
+                return (NULL);
+        file = getenv("HOSTALIASES");
+        if (issetugid() != 0 || file == NULL || (fp = fopen(file, "r")) == NULL)
+                return (NULL);
+        setbuf(fp, NULL);
+        while ((cp1 = fgetln(fp, &len)) != NULL) {
+                if (cp1[len-1] == '\n')
+                        len--;
+                if (len >= sizeof(buf) || len == 0)
+                        continue;
+                (void)memcpy(buf, cp1, len);
+                buf[len] = '\0';
+                
+                for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1)
+                        ;
+                if (!*cp1)
+                        break;
+                *cp1 = '\0';
+                if (!strcasecmp(buf, name)) {
+                        while (isspace(*++cp1))
+                                ;
+                        if (!*cp1)
+                                break;
+                        for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2)
+                                ;
+                        *cp2 = '\0';
+                        strlcpy(abuf, cp1, sizeof(abuf));
+                        fclose(fp);
+                        return (abuf);
+                }
+        }
+        fclose(fp);
+        return (NULL);
+}
diff --git a/src/lib/libc/net/res_random.c b/src/lib/libc/net/res_random.c
new file mode 100644
index 0000000000..4dc1d33462
--- /dev/null
+++ b/src/lib/libc/net/res_random.c
@@ -0,0 +1,228 @@
+/* $OpenBSD: res_random.c,v 1.16 2005/03/25 13:24:12 otto Exp $ */
+
+/*
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * All rights reserved.
+ *
+ * Theo de Raadt <deraadt@openbsd.org> came up with the idea of using
+ * such a mathematical system to generate more random (yet non-repeating)
+ * ids to solve the resolver/named problem.  But Niels designed the
+ * actual system based on the constraints.
+ *
+ * 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.
+ *
+ * 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.
+ */
+
+/* 
+ * seed = random 15bit
+ * n = prime, g0 = generator to n,
+ * j = random so that gcd(j,n-1) == 1
+ * g = g0^j mod n will be a generator again.
+ *
+ * X[0] = random seed.
+ * X[n] = a*X[n-1]+b mod m is a Linear Congruential Generator
+ * with a = 7^(even random) mod m, 
+ *      b = random with gcd(b,m) == 1
+ *      m = 31104 and a maximal period of m-1.
+ *
+ * The transaction id is determined by:
+ * id[n] = seed xor (g^X[n] mod n)
+ *
+ * Effectivly the id is restricted to the lower 15 bits, thus
+ * yielding two different cycles by toggling the msb on and off.
+ * This avoids reuse issues caused by reseeding.
+ *
+ * The 16 bit space is very small and brute force attempts are
+ * entirly feasible, we skip a random number of transaction ids
+ * so that an attacker will not get sequential ids.
+ */
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <resolv.h>
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define RU_OUT  180             /* Time after wich will be reseeded */
+#define RU_MAX  30000           /* Uniq cycle, avoid blackjack prediction */
+#define RU_GEN  2               /* Starting generator */
+#define RU_N    32749           /* RU_N-1 = 2*2*3*2729 */
+#define RU_AGEN 7               /* determine ru_a as RU_AGEN^(2*rand) */
+#define RU_M    31104           /* RU_M = 2^7*3^5 - don't change */
+
+#define PFAC_N 3
+const static u_int16_t pfacts[PFAC_N] = {
+        2, 
+        3,
+        2729
+};
+
+static u_int16_t ru_x;
+static u_int16_t ru_seed, ru_seed2;
+static u_int16_t ru_a, ru_b;
+static u_int16_t ru_g;
+static u_int16_t ru_counter = 0;
+static u_int16_t ru_msb = 0;
+static long ru_reseed;
+static u_int32_t tmp;                /* Storage for unused random */
+static struct timeval tv;
+
+static u_int16_t pmod(u_int16_t, u_int16_t, u_int16_t);
+static void res_initid(void);
+
+/*
+ * Do a fast modular exponation, returned value will be in the range
+ * of 0 - (mod-1)
+ */
+
+static u_int16_t
+pmod(u_int16_t gen, u_int16_t exp, u_int16_t mod)
+{
+        u_int16_t s, t, u;
+
+        s = 1;
+        t = gen;
+        u = exp;
+
+        while (u) {
+                if (u & 1)
+                        s = (s * t) % mod;
+                u >>= 1;
+                t = (t * t) % mod;
+        }
+        return (s);
+}
+
+/* 
+ * Initializes the seed and chooses a suitable generator. Also toggles 
+ * the msb flag. The msb flag is used to generate two distinct
+ * cycles of random numbers and thus avoiding reuse of ids.
+ *
+ * This function is called from res_randomid() when needed, an 
+ * application does not have to worry about it.
+ */
+static void 
+res_initid(void)
+{
+        u_int16_t j, i;
+        int noprime = 1;
+
+        tmp = arc4random();
+        ru_x = (tmp & 0xFFFF) % RU_M;
+
+        /* 15 bits of random seed */
+        ru_seed = (tmp >> 16) & 0x7FFF;
+        tmp = arc4random();
+        ru_seed2 = tmp & 0x7FFF;
+
+        tmp = arc4random();
+
+        /* Determine the LCG we use */
+        ru_b = (tmp & 0xfffe) | 1;
+        ru_a = pmod(RU_AGEN, (tmp >> 16) & 0xfffe, RU_M);
+        while (ru_b % 3 == 0)
+                ru_b += 2;
+        
+        tmp = arc4random();
+        j = tmp % RU_N;
+        tmp = tmp >> 16;
+
+        /* 
+         * Do a fast gcd(j,RU_N-1), so we can find a j with
+         * gcd(j, RU_N-1) == 1, giving a new generator for
+         * RU_GEN^j mod RU_N
+         */
+
+        while (noprime) {
+                for (i = 0; i < PFAC_N; i++)
+                        if (j % pfacts[i] == 0)
+                                break;
+
+                if (i >= PFAC_N)
+                        noprime = 0;
+                else 
+                        j = (j + 1) % RU_N;
+        }
+
+        ru_g = pmod(RU_GEN, j, RU_N);
+        ru_counter = 0;
+
+        gettimeofday(&tv, NULL);
+        ru_reseed = tv.tv_sec + RU_OUT;
+        ru_msb = ru_msb == 0x8000 ? 0 : 0x8000; 
+}
+
+u_int
+res_randomid(void)
+{
+        int i, n;
+
+        gettimeofday(&tv, NULL);
+        if (ru_counter >= RU_MAX || tv.tv_sec > ru_reseed)
+                res_initid();
+
+#if 0
+        if (!tmp)
+                tmp = arc4random();
+
+        /* Skip a random number of ids */
+        n = tmp & 0x7; tmp = tmp >> 3;
+        if (ru_counter + n >= RU_MAX)
+                res_initid();
+#else
+        n = 0;
+#endif
+
+        for (i = 0; i <= n; i++)
+                /* Linear Congruential Generator */
+                ru_x = (ru_a * ru_x + ru_b) % RU_M;
+
+        ru_counter += i;
+
+        return (ru_seed ^ pmod(ru_g, ru_seed2 + ru_x, RU_N)) | ru_msb;
+}
+
+#if 0
+void
+main(int argc, char **argv)
+{
+        int i, n;
+        u_int16_t wert;
+
+        res_initid();
+
+        printf("Generator: %u\n", ru_g);
+        printf("Seed: %u\n", ru_seed);
+        printf("Reseed at %ld\n", ru_reseed);
+        printf("Ru_X: %u\n", ru_x);
+        printf("Ru_A: %u\n", ru_a);
+        printf("Ru_B: %u\n", ru_b);
+
+        n = atoi(argv[1]);
+        for (i=0;i<n;i++) {
+                wert = res_randomid();
+                printf("%06d\n", wert);
+        }
+}
+#endif
+
diff --git a/src/lib/libc/net/res_send.c b/src/lib/libc/net/res_send.c
new file mode 100644
index 0000000000..f7631350bc
--- /dev/null
+++ b/src/lib/libc/net/res_send.c
@@ -0,0 +1,870 @@
+/*      $OpenBSD: res_send.c,v 1.19 2005/08/06 20:30:04 espie Exp $     */
+
+/*
+ * ++Copyright++ 1985, 1989, 1993
+ * -
+ * Copyright (c) 1985, 1989, 1993
+ *    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.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * 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, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION 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.
+ * -
+ * --Copyright--
+ */
+
+#ifndef INET6
+#define INET6
+#endif
+
+        /* change this to "0"
+         * if you talk to a lot
+         * of multi-homed SunOS
+         * ("broken") name servers.
+         */
+#define CHECK_SRVR_ADDR 1       /* XXX - should be in options.h */
+
+/*
+ * Send query to name server and wait for reply.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <arpa/inet.h>
+
+#include <stdio.h>
+#include <netdb.h>
+#include <errno.h>
+#include <resolv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "thread_private.h"
+
+static int s = -1;      /* socket used for communications */
+static int connected = 0;       /* is the socket connected */
+static int vc = 0;      /* is the socket a virtual ciruit? */
+static int af = 0;              /* address family of socket */
+
+#ifndef FD_SET
+/* XXX - should be in portability.h */
+#define NFDBITS         32
+#define FD_SETSIZE      32
+#define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+#define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+#define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+#define FD_ZERO(p)      bzero((char *)(p), sizeof(*(p)))
+#endif
+
+#define CAN_RECONNECT 1
+
+#ifndef DEBUG
+#   define Dprint(cond, args) /*empty*/
+#   define DprintQ(cond, args, query, size) /*empty*/
+#   define Aerror(file, string, error, address) /*empty*/
+#   define Perror(file, string, error) /*empty*/
+#else
+#   define Dprint(cond, args) if (cond) {fprintf args;} else {}
+#   define DprintQ(cond, args, query, size) if (cond) {\
+                        fprintf args;\
+                        __fp_nquery(query, size, stdout);\
+                } else {}
+static char abuf[NI_MAXHOST];
+static char pbuf[NI_MAXSERV];
+static void Aerror(FILE *, char *, int, struct sockaddr *);
+static void Perror(FILE *, char *, int);
+
+    static void
+    Aerror(FILE *file, char *string, int error, struct sockaddr *address)
+    {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int save = errno;
+
+        if (_resp->options & RES_DEBUG) {
+                if (getnameinfo(address, address->sa_len, abuf, sizeof(abuf),
+                    pbuf, sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
+                        strlcpy(abuf, "?", sizeof(abuf));
+                        strlcpy(pbuf, "?", sizeof(pbuf));
+                }
+                fprintf(file, "res_send: %s ([%s].%s): %s\n",
+                        string, abuf, pbuf, strerror(error));
+        }
+        errno = save;
+    }
+    static void
+    Perror(FILE *file, char *string, int error)
+    {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int save = errno;
+
+        if (_resp->options & RES_DEBUG) {
+                fprintf(file, "res_send: %s: %s\n",
+                        string, strerror(error));
+        }
+        errno = save;
+    }
+#endif
+
+static res_send_qhook Qhook = NULL;
+static res_send_rhook Rhook = NULL;
+
+void
+res_send_setqhook(res_send_qhook hook)
+{
+
+        Qhook = hook;
+}
+
+void
+res_send_setrhook(res_send_rhook hook)
+{
+
+        Rhook = hook;
+}
+
+#ifdef INET6
+static struct sockaddr * get_nsaddr(size_t);
+
+/*
+ * pick appropriate nsaddr_list for use.  see res_init() for initialization.
+ */
+static struct sockaddr *
+get_nsaddr(size_t n)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        struct __res_state_ext *_res_extp = _THREAD_PRIVATE(_res_ext, _res_ext,
+                                                            &_res_ext);
+
+        if (!_resp->nsaddr_list[n].sin_family) {
+                /*
+                 * - _res_extp->nsaddr_list[n] holds an address that is larger
+                 *   than struct sockaddr, and
+                 * - user code did not update _resp->nsaddr_list[n].
+                 */
+                return (struct sockaddr *)&_res_extp->nsaddr_list[n];
+        } else {
+                /*
+                 * - user code updated _res.nsaddr_list[n], or
+                 * - _resp->nsaddr_list[n] has the same content as
+                 *   _res_extp->nsaddr_list[n].
+                 */
+                return (struct sockaddr *)&_resp->nsaddr_list[n];
+        }
+}
+#else
+#define get_nsaddr(n)   ((struct sockaddr *)&_resp->nsaddr_list[(n)])
+#endif
+
+/* int
+ * res_isourserver(ina)
+ *      looks up "ina" in _resp->ns_addr_list[]
+ * returns:
+ *      0  : not found
+ *      >0 : found
+ * author:
+ *      paul vixie, 29may94
+ */
+int
+res_isourserver(const struct sockaddr_in *inp)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+#ifdef INET6
+        const struct sockaddr_in6 *in6p = (const struct sockaddr_in6 *)inp;
+        const struct sockaddr_in6 *srv6;
+#endif
+        const struct sockaddr_in *srv;
+        int ns, ret;
+
+        ret = 0;
+        switch (inp->sin_family) {
+#ifdef INET6
+        case AF_INET6:
+                for (ns = 0; ns < _resp->nscount; ns++) {
+                        srv6 = (struct sockaddr_in6 *)get_nsaddr(ns);
+                        if (srv6->sin6_family == in6p->sin6_family &&
+                            srv6->sin6_port == in6p->sin6_port &&
+                            srv6->sin6_scope_id == in6p->sin6_scope_id &&
+                            (IN6_IS_ADDR_UNSPECIFIED(&srv6->sin6_addr) ||
+                             IN6_ARE_ADDR_EQUAL(&srv6->sin6_addr,
+                                 &in6p->sin6_addr))) {
+                                ret++;
+                                break;
+                        }
+                }
+                break;
+#endif
+        case AF_INET:
+                for (ns = 0; ns < _resp->nscount; ns++) {
+                        srv = (struct sockaddr_in *)get_nsaddr(ns);
+                        if (srv->sin_family == inp->sin_family &&
+                            srv->sin_port == inp->sin_port &&
+                            (srv->sin_addr.s_addr == INADDR_ANY ||
+                             srv->sin_addr.s_addr == inp->sin_addr.s_addr)) {
+                                ret++;
+                                break;
+                        }
+                }
+                break;
+        }
+        return (ret);
+}
+
+/* int
+ * res_nameinquery(name, type, class, buf, eom)
+ *      look for (name,type,class) in the query section of packet (buf,eom)
+ * returns:
+ *      -1 : format error
+ *      0  : not found
+ *      >0 : found
+ * author:
+ *      paul vixie, 29may94
+ */
+int
+res_nameinquery(const char *name, int type, int class, const u_char *buf,
+    const u_char *eom)
+{
+        const u_char *cp = buf + HFIXEDSZ;
+        int qdcount = ntohs(((HEADER*)buf)->qdcount);
+
+        while (qdcount-- > 0) {
+                char tname[MAXDNAME+1];
+                int n, ttype, tclass;
+
+                n = dn_expand(buf, eom, cp, tname, sizeof tname);
+                if (n < 0)
+                        return (-1);
+                cp += n;
+                ttype = _getshort(cp); cp += INT16SZ;
+                tclass = _getshort(cp); cp += INT16SZ;
+                if (ttype == type &&
+                    tclass == class &&
+                    strcasecmp(tname, name) == 0)
+                        return (1);
+        }
+        return (0);
+}
+
+/* int
+ * res_queriesmatch(buf1, eom1, buf2, eom2)
+ *      is there a 1:1 mapping of (name,type,class)
+ *      in (buf1,eom1) and (buf2,eom2)?
+ * returns:
+ *      -1 : format error
+ *      0  : not a 1:1 mapping
+ *      >0 : is a 1:1 mapping
+ * author:
+ *      paul vixie, 29may94
+ */
+int
+res_queriesmatch(const u_char *buf1, const u_char *eom1, const u_char *buf2,
+    const u_char *eom2)
+{
+        const u_char *cp = buf1 + HFIXEDSZ;
+        int qdcount = ntohs(((HEADER*)buf1)->qdcount);
+
+        if (qdcount != ntohs(((HEADER*)buf2)->qdcount))
+                return (0);
+        while (qdcount-- > 0) {
+                char tname[MAXDNAME+1];
+                int n, ttype, tclass;
+
+                n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
+                if (n < 0)
+                        return (-1);
+                cp += n;
+                ttype = _getshort(cp);  cp += INT16SZ;
+                tclass = _getshort(cp); cp += INT16SZ;
+                if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
+                        return (0);
+        }
+        return (1);
+}
+
+int
+res_send(const u_char *buf, int buflen, u_char *ans, int anssiz)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        HEADER *hp = (HEADER *) buf;
+        HEADER *anhp = (HEADER *) ans;
+        int gotsomewhere, connreset, terrno, try, v_circuit, resplen, ns;
+        int n;
+        u_int badns;    /* XXX NSMAX can't exceed #/bits in this var */
+
+        if (_res_init(0) == -1) {
+                /* errno should have been set by res_init() in this case. */
+                return (-1);
+        }
+        DprintQ((_resp->options & RES_DEBUG) || (_resp->pfcode & RES_PRF_QUERY),
+                (stdout, ";; res_send()\n"), buf, buflen);
+        v_circuit = (_resp->options & RES_USEVC) || buflen > PACKETSZ;
+        gotsomewhere = 0;
+        connreset = 0;
+        terrno = ETIMEDOUT;
+        badns = 0;
+
+        /*
+         * Send request, RETRY times, or until successful
+         */
+        for (try = 0; try < _resp->retry; try++) {
+            for (ns = 0; ns < _resp->nscount; ns++) {
+                struct sockaddr *nsap = get_nsaddr(ns);
+                socklen_t salen;
+
+                if (nsap->sa_len)
+                        salen = nsap->sa_len;
+#ifdef INET6
+                else if (nsap->sa_family == AF_INET6)
+                        salen = sizeof(struct sockaddr_in6);
+#endif
+                else if (nsap->sa_family == AF_INET)
+                        salen = sizeof(struct sockaddr_in);
+                else
+                        salen = 0;      /*unknown, die on connect*/
+
+    same_ns:
+                if (badns & (1 << ns)) {
+                        res_close();
+                        goto next_ns;
+                }
+
+                if (Qhook) {
+                        int done = 0, loops = 0;
+
+                        do {
+                                res_sendhookact act;
+
+                                act = (*Qhook)((struct sockaddr_in **)&nsap,
+                                               &buf, &buflen,
+                                               ans, anssiz, &resplen);
+                                switch (act) {
+                                case res_goahead:
+                                        done = 1;
+                                        break;
+                                case res_nextns:
+                                        res_close();
+                                        goto next_ns;
+                                case res_done:
+                                        return (resplen);
+                                case res_modified:
+                                        /* give the hook another try */
+                                        if (++loops < 42) /*doug adams*/
+                                                break;
+                                        /*FALLTHROUGH*/
+                                case res_error:
+                                        /*FALLTHROUGH*/
+                                default:
+                                        return (-1);
+                                }
+                        } while (!done);
+                }
+
+                Dprint((_resp->options & RES_DEBUG) &&
+                       getnameinfo(nsap, salen, abuf, sizeof(abuf),
+                           NULL, 0, NI_NUMERICHOST) == 0,
+                       (stdout, ";; Querying server (# %d) address = %s\n",
+                        ns + 1, abuf));
+
+                if (v_circuit) {
+                        int truncated;
+                        struct iovec iov[2];
+                        u_short len;
+                        u_char *cp;
+
+                        /*
+                         * Use virtual circuit;
+                         * at most one attempt per server.
+                         */
+                        try = _resp->retry;
+                        truncated = 0;
+                        if ((s < 0) || (!vc) || (af != nsap->sa_family)) {
+                                if (s >= 0)
+                                        res_close();
+
+                                af = nsap->sa_family;
+                                s = socket(af, SOCK_STREAM, 0);
+                                if (s < 0) {
+                                        terrno = errno;
+                                        Perror(stderr, "socket(vc)", errno);
+#if 0
+                                        return (-1);
+#else
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
+#endif
+                                }
+                                errno = 0;
+                                if (connect(s, nsap, salen) < 0) {
+                                        terrno = errno;
+                                        Aerror(stderr, "connect/vc",
+                                               errno, nsap);
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
+                                }
+                                vc = 1;
+                        }
+                        /*
+                         * Send length & message
+                         */
+                        putshort((u_short)buflen, (u_char*)&len);
+                        iov[0].iov_base = (caddr_t)&len;
+                        iov[0].iov_len = INT16SZ;
+                        iov[1].iov_base = (caddr_t)buf;
+                        iov[1].iov_len = buflen;
+                        if (writev(s, iov, 2) != (INT16SZ + buflen)) {
+                                terrno = errno;
+                                Perror(stderr, "write failed", errno);
+                                badns |= (1 << ns);
+                                res_close();
+                                goto next_ns;
+                        }
+                        /*
+                         * Receive length & response
+                         */
+read_len:
+                        cp = ans;
+                        len = INT16SZ;
+                        while ((n = read(s, (char *)cp, (int)len)) > 0) {
+                                cp += n;
+                                if ((len -= n) <= 0)
+                                        break;
+                        }
+                        if (n <= 0) {
+                                terrno = errno;
+                                Perror(stderr, "read failed", errno);
+                                res_close();
+                                /*
+                                 * A long running process might get its TCP
+                                 * connection reset if the remote server was
+                                 * restarted.  Requery the server instead of
+                                 * trying a new one.  When there is only one
+                                 * server, this means that a query might work
+                                 * instead of failing.  We only allow one reset
+                                 * per query to prevent looping.
+                                 */
+                                if (terrno == ECONNRESET && !connreset) {
+                                        connreset = 1;
+                                        res_close();
+                                        goto same_ns;
+                                }
+                                res_close();
+                                goto next_ns;
+                        }
+                        resplen = _getshort(ans);
+                        if (resplen > anssiz) {
+                                Dprint(_resp->options & RES_DEBUG,
+                                       (stdout, ";; response truncated\n")
+                                       );
+                                truncated = 1;
+                                len = anssiz;
+                        } else
+                                len = resplen;
+                        cp = ans;
+                        while (len != 0 &&
+                               (n = read(s, (char *)cp, (int)len)) > 0) {
+                                cp += n;
+                                len -= n;
+                        }
+                        if (n <= 0) {
+                                terrno = errno;
+                                Perror(stderr, "read(vc)", errno);
+                                res_close();
+                                goto next_ns;
+                        }
+                        if (truncated) {
+                                /*
+                                 * Flush rest of answer
+                                 * so connection stays in synch.
+                                 */
+                                anhp->tc = 1;
+                                len = resplen - anssiz;
+                                while (len != 0) {
+                                        char junk[PACKETSZ];
+
+                                        n = (len > sizeof(junk)
+                                             ? sizeof(junk)
+                                             : len);
+                                        if ((n = read(s, junk, n)) > 0)
+                                                len -= n;
+                                        else
+                                                break;
+                                }
+                        }
+                        /*
+                         * The calling applicating has bailed out of
+                         * a previous call and failed to arrange to have
+                         * the circuit closed or the server has got
+                         * itself confused. Anyway drop the packet and
+                         * wait for the correct one.
+                         */
+                        if (hp->id != anhp->id) {
+                                DprintQ((_resp->options & RES_DEBUG) ||
+                                        (_resp->pfcode & RES_PRF_REPLY),
+                                        (stdout, ";; old answer (unexpected):\n"),
+                                        ans, (resplen>anssiz)?anssiz:resplen);
+                                goto read_len;
+                        }
+                } else {
+                        /*
+                         * Use datagrams.
+                         */
+                        struct timeval timeout;
+                        fd_set *dsmaskp;
+                        struct sockaddr_storage from;
+                        socklen_t fromlen;
+
+                        if ((s < 0) || vc || (af != nsap->sa_family)) {
+                                if (vc)
+                                        res_close();
+                                af = nsap->sa_family;
+                                s = socket(af, SOCK_DGRAM, 0);
+                                if (s < 0) {
+#if !CAN_RECONNECT
+ bad_dg_sock:
+#endif
+                                        terrno = errno;
+                                        Perror(stderr, "socket(dg)", errno);
+#if 0
+                                        return (-1);
+#else
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
+#endif
+                                }
+#ifdef IPV6_MINMTU
+                                if (af == AF_INET6) {
+                                        const int yes = 1;
+                                        (void)setsockopt(s, IPPROTO_IPV6,
+                                            IPV6_USE_MIN_MTU, &yes,
+                                            sizeof(yes));
+                                }
+#endif
+                                connected = 0;
+                        }
+                        /*
+                         * On a 4.3BSD+ machine (client and server,
+                         * actually), sending to a nameserver datagram
+                         * port with no nameserver will cause an
+                         * ICMP port unreachable message to be returned.
+                         * If our datagram socket is "connected" to the
+                         * server, we get an ECONNREFUSED error on the next
+                         * socket operation, and select returns if the
+                         * error message is received.  We can thus detect
+                         * the absence of a nameserver without timing out.
+                         * If we have sent queries to at least two servers,
+                         * however, we don't want to remain connected,
+                         * as we wish to receive answers from the first
+                         * server to respond.
+                         */
+                        if (!(_resp->options & RES_INSECURE1) &&
+                            (_resp->nscount == 1 || (try == 0 && ns == 0))) {
+                                /*
+                                 * Connect only if we are sure we won't
+                                 * receive a response from another server.
+                                 */
+                                if (!connected) {
+                                        if (connect(s, nsap, salen) < 0) {
+                                                Aerror(stderr,
+                                                       "connect(dg)",
+                                                       errno, nsap);
+                                                badns |= (1 << ns);
+                                                res_close();
+                                                goto next_ns;
+                                        }
+                                        connected = 1;
+                                }
+                                if (send(s, (char*)buf, buflen, 0) != buflen) {
+                                        Perror(stderr, "send", errno);
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
+                                }
+                        } else {
+                                /*
+                                 * Disconnect if we want to listen
+                                 * for responses from more than one server.
+                                 */
+                                if (connected) {
+#if CAN_RECONNECT
+#ifdef INET6
+                                        /* XXX: any errornous address */
+#endif /* INET6 */
+                                        struct sockaddr_in no_addr;
+
+                                        no_addr.sin_family = AF_INET;
+                                        no_addr.sin_addr.s_addr = INADDR_ANY;
+                                        no_addr.sin_port = 0;
+                                        (void) connect(s,
+                                                       (struct sockaddr *)
+                                                        &no_addr,
+                                                       sizeof(no_addr));
+#else
+                                        int s1 = socket(af, SOCK_DGRAM,0);
+                                        if (s1 < 0)
+                                                goto bad_dg_sock;
+                                        (void) dup2(s1, s);
+                                        (void) close(s1);
+                                        Dprint(_resp->options & RES_DEBUG,
+                                               (stdout, ";; new DG socket\n"))
+#endif
+#ifdef IPV6_MINMTU
+                                        if (af == AF_INET6) {
+                                                const int yes = 1;
+                                                (void)setsockopt(s, IPPROTO_IPV6,
+                                                    IPV6_USE_MIN_MTU, &yes,
+                                                    sizeof(yes));
+                                        }
+#endif
+                                        connected = 0;
+                                        errno = 0;
+                                }
+                                if (sendto(s, (char*)buf, buflen, 0,
+                                           nsap, salen) != buflen) {
+                                        Aerror(stderr, "sendto", errno, nsap);
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
+                                }
+                        }
+
+                        /*
+                         * Wait for reply
+                         */
+                        timeout.tv_sec = (_resp->retrans << try);
+                        if (try > 0)
+                                timeout.tv_sec /= _resp->nscount;
+                        if ((long) timeout.tv_sec <= 0)
+                                timeout.tv_sec = 1;
+                        timeout.tv_usec = 0;
+    wait:
+                        dsmaskp = (fd_set *)calloc(howmany(s+1, NFDBITS),
+                                                   sizeof(fd_mask));
+                        if (dsmaskp == NULL) {
+                                res_close();
+                                goto next_ns;
+                        }
+                        FD_SET(s, dsmaskp);
+                        n = select(s+1, dsmaskp, (fd_set *)NULL,
+                                   (fd_set *)NULL, &timeout);
+                        free(dsmaskp);
+                        if (n < 0) {
+                                if (errno == EINTR)
+                                        goto wait;
+                                Perror(stderr, "select", errno);
+                                res_close();
+                                goto next_ns;
+                        }
+                        if (n == 0) {
+                                /*
+                                 * timeout
+                                 */
+                                Dprint(_resp->options & RES_DEBUG,
+                                       (stdout, ";; timeout\n"));
+                                gotsomewhere = 1;
+                                res_close();
+                                goto next_ns;
+                        }
+                        errno = 0;
+                        fromlen = sizeof(from);
+                        resplen = recvfrom(s, (char*)ans, anssiz, 0,
+                                           (struct sockaddr *)&from, &fromlen);
+                        if (resplen <= 0) {
+                                Perror(stderr, "recvfrom", errno);
+                                res_close();
+                                goto next_ns;
+                        }
+                        gotsomewhere = 1;
+                        if (hp->id != anhp->id) {
+                                /*
+                                 * response from old query, ignore it.
+                                 * XXX - potential security hazard could
+                                 *       be detected here.
+                                 */
+                                DprintQ((_resp->options & RES_DEBUG) ||
+                                        (_resp->pfcode & RES_PRF_REPLY),
+                                        (stdout, ";; old answer:\n"),
+                                        ans, (resplen>anssiz)?anssiz:resplen);
+                                goto wait;
+                        }
+#if CHECK_SRVR_ADDR
+                        if (!(_resp->options & RES_INSECURE1) &&
+                            !res_isourserver((struct sockaddr_in *)&from)) {
+                                /*
+                                 * response from wrong server? ignore it.
+                                 * XXX - potential security hazard could
+                                 *       be detected here.
+                                 */
+                                DprintQ((_resp->options & RES_DEBUG) ||
+                                        (_resp->pfcode & RES_PRF_REPLY),
+                                        (stdout, ";; not our server:\n"),
+                                        ans, (resplen>anssiz)?anssiz:resplen);
+                                goto wait;
+                        }
+#endif
+                        if (!(_resp->options & RES_INSECURE2) &&
+                            !res_queriesmatch(buf, buf + buflen,
+                                              ans, ans + anssiz)) {
+                                /*
+                                 * response contains wrong query? ignore it.
+                                 * XXX - potential security hazard could
+                                 *       be detected here.
+                                 */
+                                DprintQ((_resp->options & RES_DEBUG) ||
+                                        (_resp->pfcode & RES_PRF_REPLY),
+                                        (stdout, ";; wrong query name:\n"),
+                                        ans, (resplen>anssiz)?anssiz:resplen);
+                                goto wait;
+                        }
+                        if (anhp->rcode == SERVFAIL ||
+                            anhp->rcode == NOTIMP ||
+                            anhp->rcode == REFUSED) {
+                                DprintQ(_resp->options & RES_DEBUG,
+                                        (stdout, "server rejected query:\n"),
+                                        ans, (resplen>anssiz)?anssiz:resplen);
+                                badns |= (1 << ns);
+                                res_close();
+                                /* don't retry if called from dig */
+                                if (!_resp->pfcode)
+                                        goto next_ns;
+                        }
+                        if (!(_resp->options & RES_IGNTC) && anhp->tc) {
+                                /*
+                                 * get rest of answer;
+                                 * use TCP with same server.
+                                 */
+                                Dprint(_resp->options & RES_DEBUG,
+                                       (stdout, ";; truncated answer\n"));
+                                v_circuit = 1;
+                                res_close();
+                                goto same_ns;
+                        }
+                } /*if vc/dg*/
+                Dprint((_resp->options & RES_DEBUG) ||
+                       ((_resp->pfcode & RES_PRF_REPLY) &&
+                        (_resp->pfcode & RES_PRF_HEAD1)),
+                       (stdout, ";; got answer:\n"));
+                DprintQ((_resp->options & RES_DEBUG) ||
+                        (_resp->pfcode & RES_PRF_REPLY),
+                        (stdout, "%s", ""),
+                        ans, (resplen>anssiz)?anssiz:resplen);
+                /*
+                 * If using virtual circuits, we assume that the first server
+                 * is preferred over the rest (i.e. it is on the local
+                 * machine) and only keep that one open.
+                 * If we have temporarily opened a virtual circuit,
+                 * or if we haven't been asked to keep a socket open,
+                 * close the socket.
+                 */
+                if ((v_circuit && (!(_resp->options & RES_USEVC) || ns != 0)) ||
+                    !(_resp->options & RES_STAYOPEN)) {
+                        res_close();
+                }
+                if (Rhook) {
+                        int done = 0, loops = 0;
+
+                        do {
+                                res_sendhookact act;
+
+                                act = (*Rhook)((struct sockaddr_in *)nsap,
+                                               buf, buflen,
+                                               ans, anssiz, &resplen);
+                                switch (act) {
+                                case res_goahead:
+                                case res_done:
+                                        done = 1;
+                                        break;
+                                case res_nextns:
+                                        res_close();
+                                        goto next_ns;
+                                case res_modified:
+                                        /* give the hook another try */
+                                        if (++loops < 42) /*doug adams*/
+                                                break;
+                                        /*FALLTHROUGH*/
+                                case res_error:
+                                        /*FALLTHROUGH*/
+                                default:
+                                        return (-1);
+                                }
+                        } while (!done);
+
+                }
+                return (resplen);
+    next_ns: ;
+           } /*foreach ns*/
+        } /*foreach retry*/
+        res_close();
+        if (!v_circuit) {
+                if (!gotsomewhere)
+                        errno = ECONNREFUSED;   /* no nameservers found */
+                else
+                        errno = ETIMEDOUT;      /* no answer obtained */
+        } else
+                errno = terrno;
+        return (-1);
+}
+
+/*
+ * This routine is for closing the socket if a virtual circuit is used and
+ * the program wants to close it.  This provides support for endhostent()
+ * which expects to close the socket.
+ *
+ * This routine is not expected to be user visible.
+ */
+void
+res_close(void)
+{
+        if (s >= 0) {
+                (void) close(s);
+                s = -1;
+                connected = 0;
+                vc = 0;
+                af = 0;
+        }
+}
diff --git a/src/lib/libc/net/resolver.3 b/src/lib/libc/net/resolver.3
new file mode 100644
index 0000000000..c9532e9c94
--- /dev/null
+++ b/src/lib/libc/net/resolver.3
@@ -0,0 +1,354 @@
+.\"     $OpenBSD: resolver.3,v 1.20 2005/07/22 04:50:51 jaredy Exp $
+.\"
+.\" Copyright (c) 1985, 1991, 1993
+.\"     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.
+.\"
+.Dd June 4, 1993
+.Dt RESOLVER 3
+.Os
+.Sh NAME
+.Nm res_query ,
+.Nm res_search ,
+.Nm res_mkquery ,
+.Nm res_send ,
+.Nm res_init ,
+.Nm dn_comp ,
+.Nm dn_expand
+.Nd resolver routines
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <netinet/in.h>
+.Fd #include <arpa/nameser.h>
+.Fd #include <resolv.h>
+.Ft int
+.Fo res_query
+.Fa "const char *dname"
+.Fa "int class"
+.Fa "int type"
+.Fa "unsigned char *answer"
+.Fa "int anslen"
+.Fc
+.Ft int
+.Fo res_search
+.Fa "const char *dname"
+.Fa "int class"
+.Fa "int type"
+.Fa "unsigned char *answer"
+.Fa "int anslen"
+.Fc
+.Ft int
+.Fo res_mkquery
+.Fa "int op"
+.Fa "const char *dname"
+.Fa "int class"
+.Fa "int type"
+.Fa "const unsigned char *data"
+.Fa "int datalen"
+.Fa "const unsigned char *newrr"
+.Fa "unsigned char *buf"
+.Fa "int buflen"
+.Fc
+.Ft int
+.Fo res_send
+.Fa "const unsigned char *msg"
+.Fa "int msglen"
+.Fa "unsigned char *answer"
+.Fa "int anslen"
+.Fc
+.Ft int
+.Fn res_init "void"
+.Ft int
+.Fo dn_comp
+.Fa "const char *exp_dn"
+.Fa "unsigned char *comp_dn"
+.Fa "int length"
+.Fa "unsigned char **dnptrs"
+.Fa "unsigned char **lastdnptr"
+.Fc
+.Ft int
+.Fo dn_expand
+.Fa "const unsigned char *msg"
+.Fa "const unsigned char *eomorig"
+.Fa "const unsigned char *comp_dn"
+.Fa "char *exp_dn"
+.Fa "int length"
+.Fc
+.Sh DESCRIPTION
+These routines are used for making, sending, and interpreting
+query and reply messages with Internet domain name servers.
+.Pp
+Global configuration and state information that is used by the
+resolver routines is kept in the structure
+.Li _res .
+Most of the values have reasonable defaults and can be ignored.
+Options stored in
+.Li _res.options
+are defined in
+.Aq Pa resolv.h
+and are as follows.
+Options are stored as a simple bit mask containing the bitwise
+.Tn OR
+of the options enabled.
+.Bl -tag -width RES_USE_INET6
+.It Dv RES_INIT
+True if the initial name server address and default domain name are
+initialized (i.e.,
+.Fn res_init
+has been called).
+.It Dv RES_DEBUG
+Print debugging messages.
+.It Dv RES_AAONLY
+Accept authoritative answers only.
+With this option,
+.Fn res_send
+should continue until it finds an authoritative answer or finds an error.
+Currently this is not implemented.
+.It Dv RES_USEVC
+Use
+.Tn TCP
+connections for queries instead of
+.Tn UDP
+datagrams.
+.It Dv RES_STAYOPEN
+Used with
+.Dv RES_USEVC
+to keep the
+.Tn TCP
+connection open between queries.
+This is useful only in programs that regularly do many queries.
+.Tn UDP
+should be the normal mode used.
+.It Dv RES_IGNTC
+Unused currently (ignore truncation errors, i.e., don't retry with
+.Tn TCP ) .
+.It Dv RES_RECURSE
+Set the recursion-desired bit in queries.
+This is the default.
+.Pf ( Fn res_send
+does not do iterative queries and expects the name server
+to handle recursion.)
+.It Dv RES_DEFNAMES
+If set,
+.Fn res_search
+will append the default domain name to single-component names
+(those that do not contain a dot).
+This option is enabled by default.
+.It Dv RES_DNSRCH
+If this option is set,
+.Fn res_search
+will search for host names in the current domain and in parent domains; see
+.Xr hostname 7 .
+This is used by the standard host lookup routine
+.Xr gethostbyname 3 .
+This option is enabled by default.
+.It Dv RES_USE_INET6
+Enables support for IPv6-only applications.
+This causes IPv4 addresses to be returned as an IPv4 mapped address.
+For example, 10.1.1.1 will be returned as ::ffff:10.1.1.1.
+The option is not meaningful on
+.Ox .
+.It Dv RES_USE_EDNS0
+Enables support for OPT pseudo-RR for EDNS0 extension.
+With this option, resolver code will attach OPT pseudo-RR into DNS queries,
+to inform of our receive buffer size.
+The option will allow DNS servers to take advantage of non-default receive
+buffer size, and to send larger replies.
+DNS query packets with EDNS0 extension is not compatible with
+non-EDNS0 DNS servers.
+.El
+.Pp
+The
+.Fn res_init
+routine reads the configuration file (if any; see
+.Xr resolv.conf 5 )
+to get the default domain name, search list, and the Internet address
+of the local name server(s).
+If no server is configured, the host running
+the resolver is tried.
+The current domain name is defined by the hostname
+if not specified in the configuration file;
+it can be overridden by the environment variable
+.Ev LOCALDOMAIN .
+This environment variable may contain several blank-separated
+tokens if you wish to override the
+.Fa search list
+on a per-process basis.
+This is similar to the
+.Fa search
+command in the configuration file.
+Another environment variable
+.Ev RES_OPTIONS
+can be set to override certain internal resolver options which
+are otherwise set by changing fields in the
+.Fa _res
+structure or are inherited from the configuration file's
+.Fa options
+command.
+The syntax of the
+.Ev RES_OPTIONS
+environment variable is explained in
+.Xr resolv.conf 5 .
+Initialization normally occurs on the first call
+to one of the following routines.
+.Pp
+The
+.Fn res_query
+function provides an interface to the server query mechanism.
+It constructs a query, sends it to the local server,
+awaits a response, and makes preliminary checks on the reply.
+The query requests information of the specified
+.Fa type
+and
+.Fa class
+for the specified fully qualified domain name
+.Fa dname .
+The reply message is left in the
+.Fa answer
+buffer with length
+.Fa anslen
+supplied by the caller.
+Values for the
+.Fa class
+and
+.Fa type
+fields
+are defined in
+.Aq Pa arpa/nameser.h .
+.Pp
+The
+.Fn res_search
+routine makes a query and awaits a response like
+.Fn res_query ,
+but in addition, it implements the default and search rules controlled by the
+.Dv RES_DEFNAMES
+and
+.Dv RES_DNSRCH
+options.
+It returns the first successful reply.
+.Pp
+The remaining routines are lower-level routines used by
+.Fn res_query .
+The
+.Fn res_mkquery
+function constructs a standard query message and places it in
+.Fa buf .
+It returns the size of the query, or \-1 if the query is larger than
+.Fa buflen .
+The query type
+.Fa op
+is usually
+.Dv QUERY ,
+but can be any of the query types defined in
+.Aq Pa arpa/nameser.h .
+The domain name for the query is given by
+.Fa dname .
+.Fa newrr
+is currently unused but is intended for making update messages.
+.Pp
+The
+.Fn res_send
+routine sends a pre-formatted query and returns an answer.
+It will call
+.Fn res_init
+if
+.Dv RES_INIT
+is not set, send the query to the local name server, and
+handle timeouts and retries.
+The length of the reply message is returned, or \-1 if there were errors.
+.Pp
+The
+.Fn dn_comp
+function compresses the domain name
+.Fa exp_dn
+and stores it in
+.Fa comp_dn .
+The size of the compressed name is returned or \-1 if there were errors.
+The size of the array pointed to by
+.Fa comp_dn
+is given by
+.Fa length .
+The compression uses an array of pointers
+.Fa dnptrs
+to previously compressed names in the current message.
+The first pointer points
+to the beginning of the message and the list ends with
+.Dv NULL .
+The limit to the array is specified by
+.Fa lastdnptr .
+A side effect of
+.Fn dn_comp
+is to update the list of pointers for labels inserted into the message
+as the name is compressed.
+If
+.Fa dnptrs
+is
+.Dv NULL ,
+names are not compressed.
+If
+.Fa lastdnptr
+is
+.Dv NULL ,
+the list of labels is not updated.
+.Pp
+The
+.Fn dn_expand
+entry expands the compressed domain name
+.Fa comp_dn
+to a full domain name.
+The compressed name is contained in a query or reply message;
+.Fa msg
+is a pointer to the beginning of the message.
+The uncompressed name is placed in the buffer indicated by
+.Fa exp_dn
+which is of size
+.Fa length .
+The size of compressed name is returned or \-1 if there was an error.
+.Sh FILES
+.Bl -tag -width "/etc/resolv.confXX"
+.It Pa /etc/resolv.conf
+The configuration file.
+.El
+.Sh SEE ALSO
+.Xr gethostbyname 3 ,
+.Xr resolv.conf 5 ,
+.Xr hostname 7 ,
+.Xr named 8
+.Pp
+.%T RFC 974 ,
+.%T RFC 1032 ,
+.%T RFC 1033 ,
+.%T RFC 1034 ,
+.%T RFC 1035 ,
+.%T RFC 1535
+.Rs
+.%T "Name Server Operations Guide for BIND"
+.Re
+.Sh HISTORY
+The
+.Nm
+function appeared in
+.Bx 4.3 .
diff --git a/src/lib/libc/net/rresvport.c b/src/lib/libc/net/rresvport.c
new file mode 100644
index 0000000000..ccc411500b
--- /dev/null
+++ b/src/lib/libc/net/rresvport.c
@@ -0,0 +1,107 @@
+/* $OpenBSD: rresvport.c,v 1.9 2005/11/10 10:00:17 espie Exp $ */
+/*
+ * Copyright (c) 1995, 1996, 1998 Theo de Raadt.  All rights reserved.
+ * Copyright (c) 1983, 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.
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <signal.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <syslog.h>
+#include <stdlib.h>
+#include <netgroup.h>
+
+int
+rresvport(int *alport)
+{
+        return rresvport_af(alport, AF_INET);
+}
+
+
+int
+rresvport_af(int *alport, int af)
+{
+        struct sockaddr_storage ss;
+        struct sockaddr *sa;
+        u_int16_t *portp;
+        int s;
+
+        bzero(&ss, sizeof ss);
+        sa = (struct sockaddr *)&ss;
+
+        switch (af) {
+        case AF_INET:
+                sa->sa_len = sizeof(struct sockaddr_in);
+                portp = &((struct sockaddr_in *)sa)->sin_port;
+                break;
+        case AF_INET6:
+                sa->sa_len = sizeof(struct sockaddr_in6);
+                portp = &((struct sockaddr_in6 *)sa)->sin6_port;
+                break;
+        default:
+                errno = EPFNOSUPPORT;
+                return (-1);
+        }
+        sa->sa_family = af;
+        
+        s = socket(af, SOCK_STREAM, 0);
+        if (s < 0)
+                return (-1);
+
+        *portp = htons(*alport);
+        if (*alport < IPPORT_RESERVED - 1) {
+                if (bind(s, sa, sa->sa_len) >= 0)
+                        return (s);
+                if (errno != EADDRINUSE) {
+                        (void)close(s);
+                        return (-1);
+                }
+        }
+
+        *portp = 0;
+        sa->sa_family = af;
+        if (bindresvport_sa(s, sa) == -1) {
+                (void)close(s);
+                return (-1);
+        }
+        *alport = ntohs(*portp);
+        return (s);
+}
diff --git a/src/lib/libc/net/rthdr.c b/src/lib/libc/net/rthdr.c
new file mode 100644
index 0000000000..36ac5a3554
--- /dev/null
+++ b/src/lib/libc/net/rthdr.c
@@ -0,0 +1,215 @@
+/*      $OpenBSD: rthdr.c,v 1.7 2005/03/25 13:24:12 otto Exp $  */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 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/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+
+#include <string.h>
+#include <stdio.h>
+
+size_t
+inet6_rthdr_space(int type, int seg)
+{
+        switch (type) {
+        case IPV6_RTHDR_TYPE_0:
+                if (seg < 1 || seg > 23)
+                        return (0);
+                return (CMSG_SPACE(sizeof(struct in6_addr) * seg +
+                    sizeof(struct ip6_rthdr0)));
+        default:
+                return (0);
+        }
+}
+
+struct cmsghdr *
+inet6_rthdr_init(void *bp, int type)
+{
+        struct cmsghdr *ch = (struct cmsghdr *)bp;
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(ch);
+
+        ch->cmsg_level = IPPROTO_IPV6;
+        ch->cmsg_type = IPV6_RTHDR;
+
+        switch (type) {
+        case IPV6_RTHDR_TYPE_0:
+                ch->cmsg_len = CMSG_LEN(sizeof(struct ip6_rthdr0));
+                bzero(rthdr, sizeof(struct ip6_rthdr0));
+                rthdr->ip6r_type = IPV6_RTHDR_TYPE_0;
+                return (ch);
+        default:
+                return (NULL);
+        }
+}
+
+int
+inet6_rthdr_add(struct cmsghdr *cmsg, const struct in6_addr *addr, u_int flags)
+{
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(cmsg);
+
+        switch (rthdr->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+        {
+                struct ip6_rthdr0 *rt0 = (struct ip6_rthdr0 *)rthdr;
+                if (flags != IPV6_RTHDR_LOOSE)
+                        return (-1);
+                if (rt0->ip6r0_segleft == 23)
+                        return (-1);
+                rt0->ip6r0_segleft++;
+                bcopy(addr, (caddr_t)rt0 + ((rt0->ip6r0_len + 1) << 3),
+                    sizeof(struct in6_addr));
+                rt0->ip6r0_len += sizeof(struct in6_addr) >> 3;
+                cmsg->cmsg_len = CMSG_LEN((rt0->ip6r0_len + 1) << 3);
+                break;
+        }
+        default:
+                return (-1);
+        }
+
+        return (0);
+}
+
+int
+inet6_rthdr_lasthop(struct cmsghdr *cmsg, unsigned int flags)
+{
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(cmsg);
+
+        switch (rthdr->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+        {
+                struct ip6_rthdr0 *rt0 = (struct ip6_rthdr0 *)rthdr;
+                if (flags != IPV6_RTHDR_LOOSE)
+                        return (-1);
+                if (rt0->ip6r0_segleft > 23)
+                        return (-1);
+                break;
+        }
+        default:
+                return (-1);
+        }
+
+        return (0);
+}
+
+#if 0
+int
+inet6_rthdr_reverse(in, out)
+        const struct cmsghdr *in;
+        struct cmsghdr *out;
+{
+
+        return (-1);
+}
+#endif
+
+int
+inet6_rthdr_segments(const struct cmsghdr *cmsg)
+{
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(cmsg);
+
+        switch (rthdr->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+        {
+                struct ip6_rthdr0 *rt0 = (struct ip6_rthdr0 *)rthdr;
+
+                if (rt0->ip6r0_len % 2 || 46 < rt0->ip6r0_len)
+                        return (-1);
+
+                return (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+        }
+
+        default:
+                return (-1);
+        }
+}
+
+struct in6_addr *
+inet6_rthdr_getaddr(struct cmsghdr *cmsg, int index)
+{
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(cmsg);
+
+        switch (rthdr->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+        {
+                struct ip6_rthdr0 *rt0 = (struct ip6_rthdr0 *)rthdr;
+                int naddr;
+
+                if (rt0->ip6r0_len % 2 || 46 < rt0->ip6r0_len)
+                        return NULL;
+                naddr = (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+                if (index <= 0 || naddr < index)
+                        return NULL;
+                return ((struct in6_addr *)(rt0 + 1)) + index;
+        }
+
+        default:
+                return NULL;
+        }
+}
+
+int
+inet6_rthdr_getflags(const struct cmsghdr *cmsg, int index)
+{
+        struct ip6_rthdr *rthdr;
+
+        rthdr = (struct ip6_rthdr *)CMSG_DATA(cmsg);
+
+        switch (rthdr->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+        {
+                struct ip6_rthdr0 *rt0 = (struct ip6_rthdr0 *)rthdr;
+                int naddr;
+
+                if (rt0->ip6r0_len % 2 || 46 < rt0->ip6r0_len)
+                        return (-1);
+                naddr = (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+                if (index < 0 || naddr < index)
+                        return (-1);
+                return IPV6_RTHDR_LOOSE;
+        }
+
+        default:
+                return (-1);
+        }
+}
diff --git a/src/lib/libc/net/send.c b/src/lib/libc/net/send.c
new file mode 100644
index 0000000000..1bfc80b87a
--- /dev/null
+++ b/src/lib/libc/net/send.c
@@ -0,0 +1,40 @@
+/*      $OpenBSD: send.c,v 1.5 2005/08/06 20:30:04 espie Exp $ */
+/*
+ * Copyright (c) 1988, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stddef.h>
+
+ssize_t
+send(int s, const void *msg, size_t len, int flags)
+{
+        return (sendto(s, msg, len, flags, NULL, 0));
+}
diff --git a/src/lib/libc/net/sethostent.c b/src/lib/libc/net/sethostent.c
new file mode 100644
index 0000000000..6f6d0e405a
--- /dev/null
+++ b/src/lib/libc/net/sethostent.c
@@ -0,0 +1,57 @@
+/*      $OpenBSD: sethostent.c,v 1.9 2005/08/06 20:30:04 espie Exp $ */
+/*
+ * Copyright (c) 1985, 1993
+ *      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.
+ */
+
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+
+#include "thread_private.h"
+
+void
+sethostent(int stayopen)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+
+        if (_res_init(0) == -1)
+                return;
+        if (stayopen)
+                _resp->options |= RES_STAYOPEN | RES_USEVC;
+}
+
+void
+endhostent(void)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+
+        _resp->options &= ~(RES_STAYOPEN | RES_USEVC);
+        res_close();
+}
diff --git a/src/lib/libc/net/vars6.c b/src/lib/libc/net/vars6.c
new file mode 100644
index 0000000000..a22d49d047
--- /dev/null
+++ b/src/lib/libc/net/vars6.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: vars6.c,v 1.2 2003/05/10 10:56:47 jmc Exp $   */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 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 <netinet/in.h>
+
+/*
+ * Definitions of some constant IPv6 addresses.
+ */
+const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
+const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
+const struct in6_addr in6addr_nodelocal_allnodes = IN6ADDR_NODELOCAL_ALLNODES_INIT;
+const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
+
diff --git a/src/lib/libc/stdlib/Makefile.inc b/src/lib/libc/stdlib/Makefile.inc
new file mode 100644
index 0000000000..c7ee0a80ec
--- /dev/null
+++ b/src/lib/libc/stdlib/Makefile.inc
@@ -0,0 +1,72 @@
+#       $OpenBSD: Makefile.inc,v 1.35 2006/01/13 17:58:09 millert Exp $
+
+# stdlib sources
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/stdlib ${LIBCSRCDIR}/stdlib
+
+SRCS+=  a64l.c abort.c atexit.c atoi.c atof.c atol.c atoll.c bsearch.c \
+        calloc.c cfree.c exit.c ecvt.c gcvt.c getenv.c getopt_long.c \
+        getsubopt.c hcreate.c heapsort.c imaxabs.c imaxdiv.c l64a.c llabs.c \
+        lldiv.c lsearch.c malloc.c merge.c putenv.c qsort.c radixsort.c rand.c \
+        random.c realpath.c setenv.c strtoimax.c strtod.c strtol.c strtoll.c \
+        strtonum.c strtoul.c strtoull.c strtoumax.c system.c \
+        tfind.c tsearch.c _rand48.c drand48.c erand48.c jrand48.c lcong48.c \
+        lrand48.c mrand48.c nrand48.c seed48.c srand48.c qabs.c qdiv.c _Exit.c
+
+.if   (${MACHINE_ARCH} == "m68k")
+SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
+.elif (${MACHINE_ARCH} == "i386")
+SRCS+=  abs.S div.S labs.S ldiv.S
+LSRCS+= abs.c div.c labs.c ldiv.c
+.elif (${MACHINE_ARCH} == "ns32k")
+SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
+.elif (${MACHINE_ARCH} == "tahoe")
+SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
+.elif (${MACHINE_ARCH} == "vax")
+SRCS+=  abs.c div.c labs.c ldiv.c
+.elif (${MACHINE_ARCH} == "alpha")
+# XXX should be .S's
+SRCS+=  abs.c div.c labs.c ldiv.c
+.else
+SRCS+=  abs.c div.c labs.c ldiv.c
+.endif
+
+.if (${MACHINE_ARCH} == "vax") || (${MACHINE_ARCH} == "m68k")
+SRCS+=  insque.S remque.S
+.else
+SRCS+=  insque.c remque.c
+.endif
+
+MAN+=   a64l.3 abort.3 abs.3 alloca.3 atexit.3 atof.3 atoi.3 atol.3 atoll.3 \
+        bsearch.3 div.3 ecvt.3 exit.3 getenv.3 getopt.3 getopt_long.3 \
+        getsubopt.3 hcreate.3 imaxabs.3 imaxdiv.3 insque.3 labs.3 ldiv.3 \
+        lldiv.3 lsearch.3 malloc.3 qabs.3 qdiv.3 qsort.3 radixsort.3 rand48.3 \
+        rand.3 random.3 realpath.3 strtod.3 strtonum.3 strtol.3 strtoul.3 \
+        system.3 tsearch.3
+
+MLINKS+=exit.3 _Exit.3
+MLINKS+=ecvt.3 fcvt.3 ecvt.3 gcvt.3
+MLINKS+=getenv.3 setenv.3 getenv.3 unsetenv.3 getenv.3 putenv.3
+MLINKS+=getopt_long.3 getopt_long_only.3
+MLINKS+=hcreate.3 hdestroy.3 hcreate.3 hsearch.3
+MLINKS+=insque.3 remque.3
+MLINKS+=labs.3 llabs.3
+MLINKS+=lsearch.3 lfind.3
+MLINKS+=malloc.3 free.3 malloc.3 realloc.3 malloc.3 calloc.3
+MLINKS+=malloc.3 cfree.3 malloc.3 malloc.conf.5
+MLINKS+=qsort.3 heapsort.3 qsort.3 mergesort.3
+MLINKS+=radixsort.3 sradixsort.3
+MLINKS+=rand.3 srand.3 rand.3 rand_r.3
+MLINKS+=random.3 initstate.3 random.3 setstate.3
+MLINKS+=random.3 srandom.3 random.3 srandomdev.3
+MLINKS+=rand48.3 drand48.3 rand48.3 erand48.3 rand48.3 lrand48.3
+MLINKS+=rand48.3 mrand48.3 rand48.3 nrand48.3 rand48.3 jrand48.3
+MLINKS+=rand48.3 srand48.3 rand48.3 seed48.3 rand48.3 lcong48.3
+MLINKS+=strtol.3 strtoll.3 strtol.3 strtoq.3 strtol.3 strtoimax.3
+MLINKS+=strtoul.3 strtoull.3 strtoul.3 strtouq.3 strtoul.3 strtoumax.3
+MLINKS+=tsearch.3 tfind.3
+MLINKS+=tsearch.3 tdelete.3
+MLINKS+=tsearch.3 twalk.3
+MLINKS+=a64l.3 l64a.3
diff --git a/src/lib/libc/stdlib/_Exit.c b/src/lib/libc/stdlib/_Exit.c
new file mode 100644
index 0000000000..5a2291a931
--- /dev/null
+++ b/src/lib/libc/stdlib/_Exit.c
@@ -0,0 +1,22 @@
+/*      $OpenBSD: _Exit.c,v 1.2 2005/08/08 08:05:36 espie Exp $ */
+
+/*
+ * Placed in the public domain by Todd C. Miller on January 21, 2004.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+
+/*
+ * _Exit() is the ISO/ANSI C99 equivalent of the POSIX _exit() function.
+ * No atexit() handlers are called and no signal handlers are run.
+ * Whether or not stdio buffers are flushed or temporary files are removed
+ * is implementation-dependent.  As such it is safest to *not* flush
+ * stdio buffers or remove temporary files.  This is also consistent
+ * with most other implementations.
+ */
+void
+_Exit(int status)
+{
+        _exit(status);
+}
diff --git a/src/lib/libc/stdlib/_rand48.c b/src/lib/libc/stdlib/_rand48.c
new file mode 100644
index 0000000000..7c950f7cee
--- /dev/null
+++ b/src/lib/libc/stdlib/_rand48.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: _rand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+unsigned short __rand48_seed[3] = {
+        RAND48_SEED_0,
+        RAND48_SEED_1,
+        RAND48_SEED_2
+};
+unsigned short __rand48_mult[3] = {
+        RAND48_MULT_0,
+        RAND48_MULT_1,
+        RAND48_MULT_2
+};
+unsigned short __rand48_add = RAND48_ADD;
+
+void
+__dorand48(unsigned short xseed[3])
+{
+        unsigned long accu;
+        unsigned short temp[2];
+
+        accu = (unsigned long) __rand48_mult[0] * (unsigned long) xseed[0] +
+         (unsigned long) __rand48_add;
+        temp[0] = (unsigned short) accu;        /* lower 16 bits */
+        accu >>= sizeof(unsigned short) * 8;
+        accu += (unsigned long) __rand48_mult[0] * (unsigned long) xseed[1] +
+         (unsigned long) __rand48_mult[1] * (unsigned long) xseed[0];
+        temp[1] = (unsigned short) accu;        /* middle 16 bits */
+        accu >>= sizeof(unsigned short) * 8;
+        accu += __rand48_mult[0] * xseed[2] + __rand48_mult[1] * xseed[1] + __rand48_mult[2] * xseed[0];
+        xseed[0] = temp[0];
+        xseed[1] = temp[1];
+        xseed[2] = (unsigned short) accu;
+}
diff --git a/src/lib/libc/stdlib/a64l.3 b/src/lib/libc/stdlib/a64l.3
new file mode 100644
index 0000000000..f2957a7ad4
--- /dev/null
+++ b/src/lib/libc/stdlib/a64l.3
@@ -0,0 +1,133 @@
+.\" $OpenBSD: a64l.3,v 1.9 2005/02/25 03:12:44 cloder Exp $
+.\"
+.\" Copyright (c) 1997 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.
+.\"
+.Dd August 17, 1997
+.Dt A64L 3
+.Os
+.Sh NAME
+.Nm a64l ,
+.Nm l64a
+.Nd convert between 32-bit integer and radix-64 ASCII string
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long
+.Fn a64l "const char *s"
+.Ft char *
+.Fn l64a "long l"
+.Sh DESCRIPTION
+The
+.Fn a64l
+and
+.Fn l64a
+functions are used to maintain numbers stored in radix-64
+.Tn ASCII
+characters.
+This is a notation by which 32-bit integers
+can be represented by up to six characters; each character represents a
+.Dq digit
+in a radix-64 notation.
+.Pp
+The characters used to represent digits are
+.Ql \&.
+for 0,
+.Ql /
+for 1,
+.Ql 0
+through
+.Ql 9
+for 2-11,
+.Ql A
+through
+.Ql Z
+for 12-37, and
+.Ql a
+through
+.Ql z
+for 38-63.
+.Pp
+The
+.Fn a64l
+function takes a pointer to a NUL-terminated radix-64 representation
+and returns a corresponding 32-bit value.
+If the string pointed to by
+.Fa s
+contains more than six characters,
+.Fn a64l
+will use the first six.
+.Fn a64l
+scans the character string from left to right, decoding
+each character as a 6-bit radix-64 number.
+If a long integer is
+larger than 32 bits, the return value will be sign-extended.
+.Pp
+.Fn l64a
+takes a long integer argument
+.Fa l
+and returns a pointer to the corresponding radix-64 representation.
+.Sh RETURN VALUES
+On success,
+.Fn a64l
+returns a 32-bit representation of
+.Fa s .
+If
+.Fa s
+is a null pointer or if it contains digits other than those described above,
+.Fn a64l
+returns \-1 and sets the global variable
+.Va errno
+to
+.Er EINVAL .
+.Pp
+On success,
+.Fn l64a
+returns a pointer to a string containing the radix-64 representation of
+.Fa l .
+If
+.Fa l
+is 0,
+.Fn l64a
+returns a pointer to the empty string.
+If
+.Fa l
+is negative,
+.Fn l64a
+returns a null pointer and sets the global variable
+.Va errno
+to
+.Er EINVAL .
+.Sh WARNINGS
+The value returned by
+.Fn l64a
+is a pointer into a static buffer, the contents of which
+will be overwritten by subsequent calls.
+.Pp
+The value returned by
+.Fn a64l
+may be incorrect if the value is too large; for that reason, only strings
+that resulted from a call to
+.Fn l64a
+should be used to call
+.Fn a64l .
+.Pp
+If a long integer is larger than 32 bits, only the low-order
+32 bits are used.
+.Sh STANDARDS
+The
+.Fn a64l
+and
+.Fn l64a
+functions conform to
+.St -xpg4.2 .
diff --git a/src/lib/libc/stdlib/a64l.c b/src/lib/libc/stdlib/a64l.c
new file mode 100644
index 0000000000..5312929c6f
--- /dev/null
+++ b/src/lib/libc/stdlib/a64l.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: a64l.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+
+long
+a64l(const char *s)
+{
+        long value, digit, shift;
+        int i;
+
+        if (s == NULL) {
+                errno = EINVAL;
+                return(-1L);
+        }
+
+        value = 0;
+        shift = 0;
+        for (i = 0; *s && i < 6; i++, s++) {
+                if (*s >= '.' && *s <= '/')
+                        digit = *s - '.';
+                else if (*s >= '0' && *s <= '9')
+                        digit = *s - '0' + 2;
+                else if (*s >= 'A' && *s <= 'Z')
+                        digit = *s - 'A' + 12;
+                else if (*s >= 'a' && *s <= 'z')
+                        digit = *s - 'a' + 38;
+                else {
+                        errno = EINVAL;
+                        return(-1L);
+                }
+
+                value |= digit << shift;
+                shift += 6;
+        }
+
+        return(value);
+}
diff --git a/src/lib/libc/stdlib/abort.3 b/src/lib/libc/stdlib/abort.3
new file mode 100644
index 0000000000..d411b859eb
--- /dev/null
+++ b/src/lib/libc/stdlib/abort.3
@@ -0,0 +1,63 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: abort.3,v 1.7 2003/06/02 20:18:37 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt ABORT 3
+.Os
+.Sh NAME
+.Nm abort
+.Nd cause abnormal program termination
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void
+.Fn abort void
+.Sh DESCRIPTION
+The
+.Fn abort
+function causes abnormal program termination to occur, unless the signal
+.Dv SIGABRT
+is being caught and the signal handler does not return.
+.Pp
+Any open streams are flushed and closed.
+.Sh RETURN VALUES
+The
+.Fn abort
+function never returns.
+.Sh SEE ALSO
+.Xr sigaction 2 ,
+.Xr exit 3
+.Sh STANDARDS
+The
+.Fn abort
+function conforms to
+.St -p1003.1-90 .
diff --git a/src/lib/libc/stdlib/abort.c b/src/lib/libc/stdlib/abort.c
new file mode 100644
index 0000000000..072a9fa8c1
--- /dev/null
+++ b/src/lib/libc/stdlib/abort.c
@@ -0,0 +1,75 @@
+/*      $OpenBSD: abort.c,v 1.14 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1985 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.
+ */
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "thread_private.h"
+#include "atexit.h"
+
+void
+abort(void)
+{
+        struct atexit *p = __atexit;
+        static int cleanup_called = 0;
+        sigset_t mask;
+
+
+        sigfillset(&mask);
+        /*
+         * don't block SIGABRT to give any handler a chance; we ignore
+         * any errors -- X311J doesn't allow abort to return anyway.
+         */
+        sigdelset(&mask, SIGABRT);
+        (void)_thread_sys_sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
+
+        /*
+         * POSIX requires we flush stdio buffers on abort
+         */
+        if (cleanup_called == 0) {
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                if (p != NULL && p->fns[0] != NULL) {
+                        cleanup_called = 1;
+                        (*p->fns[0])();
+                }
+        }
+
+        (void)kill(getpid(), SIGABRT);
+
+        /*
+         * if SIGABRT ignored, or caught and the handler returns, do
+         * it again, only harder.
+         */
+        (void)signal(SIGABRT, SIG_DFL);
+        (void)_thread_sys_sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
+        (void)kill(getpid(), SIGABRT);
+        _exit(1);
+}
diff --git a/src/lib/libc/stdlib/abs.3 b/src/lib/libc/stdlib/abs.3
new file mode 100644
index 0000000000..fc0b20b7d5
--- /dev/null
+++ b/src/lib/libc/stdlib/abs.3
@@ -0,0 +1,66 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: abs.3,v 1.7 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt ABS 3
+.Os
+.Sh NAME
+.Nm abs
+.Nd integer absolute value function
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft int
+.Fn abs "int j"
+.Sh DESCRIPTION
+The
+.Fn abs
+function computes the absolute value of the integer
+.Fa j .
+.Sh RETURN VALUES
+The
+.Fn abs
+function returns the absolute value.
+.Sh SEE ALSO
+.Xr cabs 3 ,
+.Xr floor 3 ,
+.Xr hypot 3 ,
+.Xr imaxabs 3 ,
+.Xr labs 3 ,
+.Xr math 3
+.Sh STANDARDS
+The
+.Fn abs
+function conforms to
+.St -ansiC .
+.Sh BUGS
+The absolute value of the most negative integer remains negative.
diff --git a/src/lib/libc/stdlib/abs.c b/src/lib/libc/stdlib/abs.c
new file mode 100644
index 0000000000..5d2fbae69f
--- /dev/null
+++ b/src/lib/libc/stdlib/abs.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: abs.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <stdlib.h>
+
+int
+abs(int j)
+{
+        return(j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/alloca.3 b/src/lib/libc/stdlib/alloca.3
new file mode 100644
index 0000000000..4136dc405c
--- /dev/null
+++ b/src/lib/libc/stdlib/alloca.3
@@ -0,0 +1,80 @@
+.\" Copyright (c) 1980, 1991 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.
+.\"
+.\"     $OpenBSD: alloca.3,v 1.10 2003/06/02 20:18:37 millert Exp $
+.\"
+.Dd May 2, 1991
+.Dt ALLOCA 3
+.Os
+.Sh NAME
+.Nm alloca
+.Nd memory allocator
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void *
+.Fn alloca "size_t size"
+.Sh DESCRIPTION
+The
+.Fn alloca
+function allocates
+.Fa size
+bytes of space in the stack frame of the caller.
+This temporary space is automatically freed on return.
+.Sh RETURN VALUES
+The
+.Fn alloca
+function returns a pointer to the beginning of the allocated space.
+.Sh SEE ALSO
+.Xr pagesize 1 ,
+.Xr brk 2 ,
+.Xr calloc 3 ,
+.Xr malloc 3 ,
+.Xr realloc 3
+.Sh BUGS
+The
+.Fn alloca
+function is machine dependent; its use is discouraged.
+.\" .Sh HISTORY
+.\" The
+.\" .Fn alloca
+.\" function appeared in
+.\" .Bx ?? .
+.\" The function appeared in 32v, pwb and pwb.2 and in 3bsd 4bsd
+.\" The first man page (or link to a man page that I can find at the
+.\" moment is 4.3...
+.Pp
+The
+.Fn alloca
+function is slightly unsafe because it cannot ensure that the pointer
+returned points to a valid and usable block of memory.
+The allocation made may exceed the bounds of the stack, or even go
+further into other objects in memory, and
+.Fn alloca
+cannot determine such an error.
+Avoid
+.Fn alloca
+with large unbounded allocations.
diff --git a/src/lib/libc/stdlib/atexit.3 b/src/lib/libc/stdlib/atexit.3
new file mode 100644
index 0000000000..4272c8b66d
--- /dev/null
+++ b/src/lib/libc/stdlib/atexit.3
@@ -0,0 +1,77 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: atexit.3,v 1.7 2005/08/22 14:17:31 jmc Exp $
+.\"
+.Dd June 29, 1991
+.Dt ATEXIT 3
+.Os
+.Sh NAME
+.Nm atexit
+.Nd register a function to be called on exit
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft int
+.Fn atexit "void (*function)(void)"
+.Sh DESCRIPTION
+The
+.Fn atexit
+function registers the given
+.Fa function
+to be called at program exit, whether via
+.Xr exit 3
+or via return from the program's
+.Fn main .
+Functions so registered are called in reverse order;
+no arguments are passed.
+At least 32 functions can always be registered,
+and more are allowed as long as sufficient memory can be allocated.
+.Pp
+.Fn atexit
+is very difficult to use correctly without creating
+.Xr exit 3 Ns -time
+races.
+Unless absolutely necessary, please avoid using it.
+.Sh RETURN VALUES
+.Rv -std atexit
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+No memory was available to add the function to the list.
+The existing list of functions is unmodified.
+.El
+.Sh SEE ALSO
+.Xr exit 3
+.Sh STANDARDS
+The
+.Fn atexit
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/atexit.c b/src/lib/libc/stdlib/atexit.c
new file mode 100644
index 0000000000..50f8ec9372
--- /dev/null
+++ b/src/lib/libc/stdlib/atexit.c
@@ -0,0 +1,133 @@
+/*      $OpenBSD: atexit.c,v 1.12 2006/02/22 07:16:32 otto 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.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "atexit.h"
+#include "thread_private.h"
+
+int __atexit_invalid = 1;
+struct atexit *__atexit;
+
+/*
+ * Function pointers are stored in a linked list of pages. The list
+ * is initially empty, and pages are allocated on demand. The first
+ * function pointer in the first allocated page (the last one in
+ * the linked list) is reserved for the cleanup function.
+ *
+ * Outside the following two functions, all pages are mprotect()'ed
+ * to prevent unintentional/malicious corruption.
+ */
+
+/*
+ * Register a function to be performed at exit.
+ */
+int
+atexit(void (*fn)(void))
+{
+        struct atexit *p;
+        int pgsize = getpagesize();
+        int ret = -1;
+
+        if (pgsize < sizeof(*p))
+                return (-1);
+        _ATEXIT_LOCK();
+        p = __atexit;
+        if (p != NULL) {
+                if (p->ind + 1 >= p->max)
+                        p = NULL;
+                else if (mprotect(p, pgsize, PROT_READ | PROT_WRITE))
+                        goto unlock;
+        }
+        if (p == NULL) {
+                p = mmap(NULL, pgsize, PROT_READ | PROT_WRITE,
+                    MAP_ANON | MAP_PRIVATE, -1, 0);
+                if (p == MAP_FAILED)
+                        goto unlock;
+                if (__atexit == NULL) {
+                        p->fns[0] = NULL;
+                        p->ind = 1;
+                } else
+                        p->ind = 0;
+                p->max = (pgsize - ((char *)&p->fns[0] - (char *)p)) /
+                    sizeof(p->fns[0]);
+                p->next = __atexit;
+                __atexit = p;
+                if (__atexit_invalid)
+                        __atexit_invalid = 0;
+        }
+        p->fns[p->ind++] = fn;
+        if (mprotect(p, pgsize, PROT_READ))
+                goto unlock;
+        ret = 0;
+unlock:
+        _ATEXIT_UNLOCK();
+        return (ret);
+}
+
+/*
+ * Register the cleanup function
+ */
+void
+__atexit_register_cleanup(void (*fn)(void))
+{
+        struct atexit *p;
+        int pgsize = getpagesize();
+
+        if (pgsize < sizeof(*p))
+                return;
+        _ATEXIT_LOCK();
+        p = __atexit;
+        while (p != NULL && p->next != NULL)
+                p = p->next;
+        if (p == NULL) {
+                p = mmap(NULL, pgsize, PROT_READ | PROT_WRITE,
+                    MAP_ANON | MAP_PRIVATE, -1, 0);
+                if (p == MAP_FAILED)
+                        goto unlock;
+                p->ind = 1;
+                p->max = (pgsize - ((char *)&p->fns[0] - (char *)p)) /
+                    sizeof(p->fns[0]);
+                p->next = NULL;
+                __atexit = p;
+                if (__atexit_invalid)
+                        __atexit_invalid = 0;
+        } else {
+                if (mprotect(p, pgsize, PROT_READ | PROT_WRITE))
+                        goto unlock;
+        }
+        p->fns[0] = fn;
+        mprotect(p, pgsize, PROT_READ);
+unlock:
+        _ATEXIT_UNLOCK();
+}
diff --git a/src/lib/libc/stdlib/atexit.h b/src/lib/libc/stdlib/atexit.h
new file mode 100644
index 0000000000..21b0c2e532
--- /dev/null
+++ b/src/lib/libc/stdlib/atexit.h
@@ -0,0 +1,41 @@
+/*      $OpenBSD: atexit.h,v 1.6 2003/07/31 07:08:42 deraadt 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.
+ *
+ */
+
+struct atexit {
+        struct atexit *next;            /* next in list */
+        int ind;                        /* next index in this table */
+        int max;                        /* max entries >= ATEXIT_SIZE */
+        void (*fns[1])(void);           /* the table itself */
+};
+
+extern int __atexit_invalid;
+extern struct atexit *__atexit;         /* points to head of LIFO stack */
diff --git a/src/lib/libc/stdlib/atof.3 b/src/lib/libc/stdlib/atof.3
new file mode 100644
index 0000000000..c60b9e9fd7
--- /dev/null
+++ b/src/lib/libc/stdlib/atof.3
@@ -0,0 +1,69 @@
+.\" Copyright (c) 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: atof.3,v 1.4 2003/06/02 20:18:37 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt ATOF 3
+.Os
+.Sh NAME
+.Nm atof
+.Nd convert
+.Tn ASCII
+string to double
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft double
+.Fn atof "const char *nptr"
+.Sh DESCRIPTION
+The
+.Fn atof
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li double
+representation.
+.Pp
+It is equivalent to:
+.Bd -literal -offset indent
+strtod(nptr, (char **)NULL);
+.Ed
+.Sh SEE ALSO
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn atof
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/atof.c b/src/lib/libc/stdlib/atof.c
new file mode 100644
index 0000000000..d14b58b070
--- /dev/null
+++ b/src/lib/libc/stdlib/atof.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: atof.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <stdlib.h>
+
+double
+atof(const char *ascii)
+{
+        return(strtod(ascii, (char **)NULL));
+}
diff --git a/src/lib/libc/stdlib/atoi.3 b/src/lib/libc/stdlib/atoi.3
new file mode 100644
index 0000000000..dee8b637a3
--- /dev/null
+++ b/src/lib/libc/stdlib/atoi.3
@@ -0,0 +1,86 @@
+.\" Copyright (c) 1990, 1991, 1993
+.\"    The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: atoi.3,v 1.8 2004/08/22 21:47:41 jaredy Exp $
+.\"
+.Dd June 4, 1993
+.Dt ATOI 3
+.Os
+.Sh NAME
+.Nm atoi
+.Nd convert
+.Tn ASCII
+string to integer
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft int
+.Fn atoi "const char *nptr"
+.Sh DESCRIPTION
+The
+.Fn atoi
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li integer
+representation.
+.Pp
+It is equivalent to:
+.Bd -literal -offset indent
+(int)strtol(nptr, (char **)NULL, 10);
+.Ed
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atol 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtonum 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn atoi
+function conforms to
+.St -ansiC .
+.Sh CAVEATS
+.Nm
+does no overflow checking, handles unsigned numbers poorly,
+and handles strings containing trailing extra characters
+(like
+.Dq "123abc" )
+poorly.
+Careful use of
+.Xr strtol 3
+and
+.Xr strtoul 3
+can alleviate these problems,
+but
+.Xr strtonum 3
+can be used to convert numbers from strings much more safely
+and easily.
diff --git a/src/lib/libc/stdlib/atoi.c b/src/lib/libc/stdlib/atoi.c
new file mode 100644
index 0000000000..b0842678e2
--- /dev/null
+++ b/src/lib/libc/stdlib/atoi.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: atoi.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <stdlib.h>
+
+int
+atoi(const char *str)
+{
+        return((int)strtol(str, (char **)NULL, 10));
+}
diff --git a/src/lib/libc/stdlib/atol.3 b/src/lib/libc/stdlib/atol.3
new file mode 100644
index 0000000000..80e54c892d
--- /dev/null
+++ b/src/lib/libc/stdlib/atol.3
@@ -0,0 +1,70 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: atol.3,v 1.6 2003/06/02 20:18:37 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt ATOL 3
+.Os
+.Sh NAME
+.Nm atol
+.Nd convert
+.Tn ASCII
+string to long integer
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long
+.Fn atol "const char *nptr"
+.Sh DESCRIPTION
+The
+.Fn atol
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li long integer
+representation.
+.Pp
+It is equivalent to:
+.Bd -literal -offset indent
+strtol(nptr, (char **)NULL, 10);
+.Ed
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atoll 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn atol
+function conforms to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/atol.c b/src/lib/libc/stdlib/atol.c
new file mode 100644
index 0000000000..1970804401
--- /dev/null
+++ b/src/lib/libc/stdlib/atol.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: atol.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <stdlib.h>
+
+long
+atol(const char *str)
+{
+        return(strtol(str, (char **)NULL, 10));
+}
diff --git a/src/lib/libc/stdlib/atoll.3 b/src/lib/libc/stdlib/atoll.3
new file mode 100644
index 0000000000..2b53e9b694
--- /dev/null
+++ b/src/lib/libc/stdlib/atoll.3
@@ -0,0 +1,70 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: atoll.3,v 1.4 2005/07/26 04:20:23 jaredy Exp $
+.\"
+.Dd June 29, 1991
+.Dt ATOLL 3
+.Os
+.Sh NAME
+.Nm atoll
+.Nd convert
+.Tn ASCII
+string to long long integer
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long long
+.Fn atoll "const char *nptr"
+.Sh DESCRIPTION
+The
+.Fn atoll
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li long long integer
+representation.
+.Pp
+It is equivalent to:
+.Bd -literal -offset indent
+strtoll(nptr, (char **)NULL, 10);
+.Ed
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn atoll
+function conforms to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/atoll.c b/src/lib/libc/stdlib/atoll.c
new file mode 100644
index 0000000000..a65e682cfb
--- /dev/null
+++ b/src/lib/libc/stdlib/atoll.c
@@ -0,0 +1,38 @@
+/*      $OpenBSD: atoll.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <stdlib.h>
+
+long long
+atoll(str)
+        const char *str;
+{
+        return(strtoll(str, (char **)NULL, 10));
+}
diff --git a/src/lib/libc/stdlib/bsearch.3 b/src/lib/libc/stdlib/bsearch.3
new file mode 100644
index 0000000000..d1dd9173db
--- /dev/null
+++ b/src/lib/libc/stdlib/bsearch.3
@@ -0,0 +1,84 @@
+.\" Copyright (c) 1990, 1991, 1993, 1994
+.\"    The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: bsearch.3,v 1.6 2003/06/02 20:18:37 millert Exp $
+.\"
+.Dd April 19, 1994
+.Dt BSEARCH 3
+.Os
+.Sh NAME
+.Nm bsearch
+.Nd binary search of a sorted table
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void *
+.Fn bsearch "const void *key" "const void *base" "size_t nmemb" "size_t size" "int (*compar) (const void *, const void *)"
+.Sh DESCRIPTION
+The
+.Fn bsearch
+function searches an array of
+.Fa nmemb
+objects, the initial member of which is
+pointed to by
+.Fa base ,
+for a member that matches the object pointed to by
+.Fa key .
+The size of each member of the array is specified by
+.Fa size .
+.Pp
+The contents of the array should be in ascending sorted order according
+to the comparison function referenced by
+.Fa compar .
+The
+.Fa compar
+routine is expected to have two arguments which point to the
+.Fa key
+object and to an array member, in that order, and should return an integer
+less than, equal to, or greater than zero if the
+.Fa key
+object is found, respectively, to be less than, to match, or be
+greater than the array member.
+.Sh RETURN VALUES
+The
+.Fn bsearch
+function returns a pointer to a matching member of the array, or a null
+pointer if no match is found.
+If two members compare as equal, which member is matched is unspecified.
+.Sh SEE ALSO
+.Xr db 3 ,
+.Xr lsearch 3 ,
+.Xr qsort 3 ,
+.Xr tsearch 3
+.Sh STANDARDS
+The
+.Fn bsearch
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/bsearch.c b/src/lib/libc/stdlib/bsearch.c
new file mode 100644
index 0000000000..8193d27c60
--- /dev/null
+++ b/src/lib/libc/stdlib/bsearch.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1990 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.
+ */
+
+#include <stdlib.h>
+
+/*
+ * Perform a binary search.
+ *
+ * The code below is a bit sneaky.  After a comparison fails, we
+ * divide the work in half by moving either left or right. If lim
+ * is odd, moving left simply involves halving lim: e.g., when lim
+ * is 5 we look at item 2, so we change lim to 2 so that we will
+ * look at items 0 & 1.  If lim is even, the same applies.  If lim
+ * is odd, moving right again involes halving lim, this time moving
+ * the base up one item past p: e.g., when lim is 5 we change base
+ * to item 3 and make lim 2 so that we will look at items 3 and 4.
+ * If lim is even, however, we have to shrink it by one before
+ * halving: e.g., when lim is 4, we still looked at item 2, so we
+ * have to make lim 3, then halve, obtaining 1, so that we will only
+ * look at item 3.
+ */
+void *
+bsearch(const void *key, const void *base0, size_t nmemb, size_t size,
+    int (*compar)(const void *, const void *))
+{
+        const char *base = base0;
+        int lim, cmp;
+        const void *p;
+
+        for (lim = nmemb; lim != 0; lim >>= 1) {
+                p = base + (lim >> 1) * size;
+                cmp = (*compar)(key, p);
+                if (cmp == 0)
+                        return ((void *)p);
+                if (cmp > 0) {  /* key > p: move right */
+                        base = (char *)p + size;
+                        lim--;
+                } /* else move left */
+        }
+        return (NULL);
+}
diff --git a/src/lib/libc/stdlib/calloc.c b/src/lib/libc/stdlib/calloc.c
new file mode 100644
index 0000000000..43a0d1632c
--- /dev/null
+++ b/src/lib/libc/stdlib/calloc.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: calloc.c,v 1.11 2006/04/02 18:22:14 otto Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+void *
+calloc(size_t num, size_t size)
+{
+        void *p;
+
+        if (num && SIZE_MAX / num < size) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        size *= num;
+        p = malloc(size);
+        if (p)
+                memset(p, 0, size);
+        return(p);
+}
diff --git a/src/lib/libc/stdlib/cfree.c b/src/lib/libc/stdlib/cfree.c
new file mode 100644
index 0000000000..373c7ff75d
--- /dev/null
+++ b/src/lib/libc/stdlib/cfree.c
@@ -0,0 +1,40 @@
+/*      $OpenBSD: cfree.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+
+/*
+ * Copyright (c) 1996 SigmaSoft, Th. Lockert <tholo@sigmasoft.com>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED ``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/cdefs.h>
+#include <stdlib.h>
+
+#ifdef __indr_reference
+__indr_reference(free, cfree);
+#else
+
+void
+cfree(void *p)
+{
+    free(p);
+}
+#endif
diff --git a/src/lib/libc/stdlib/div.3 b/src/lib/libc/stdlib/div.3
new file mode 100644
index 0000000000..d6a9a0029d
--- /dev/null
+++ b/src/lib/libc/stdlib/div.3
@@ -0,0 +1,65 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: div.3,v 1.8 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd April 19, 1991
+.Dt DIV 3
+.Os
+.Sh NAME
+.Nm div
+.Nd return quotient and remainder from division
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft div_t
+.Fn div "int num" "int denom"
+.Sh DESCRIPTION
+The
+.Fn div
+function computes the value
+.Fa num Ns / Ns Fa denom
+and returns the quotient and remainder in a structure named
+.Fa div_t
+that contains two
+.Li int
+members named
+.Fa quot
+and
+.Fa rem .
+.Sh SEE ALSO
+.Xr imaxdiv 3 ,
+.Xr ldiv 3 ,
+.Xr lldiv 3 ,
+.Xr math 3 ,
+.Xr qdiv 3
+.Sh STANDARDS
+The
+.Fn div
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/div.c b/src/lib/libc/stdlib/div.c
new file mode 100644
index 0000000000..f7ac2db4b0
--- /dev/null
+++ b/src/lib/libc/stdlib/div.c
@@ -0,0 +1,71 @@
+/*      $OpenBSD: div.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>             /* div_t */
+
+div_t
+div(int num, int denom)
+{
+        div_t r;
+
+        r.quot = num / denom;
+        r.rem = num % denom;
+        /*
+         * The ANSI standard says that |r.quot| <= |n/d|, where
+         * n/d is to be computed in infinite precision.  In other
+         * words, we should always truncate the quotient towards
+         * 0, never -infinity.
+         *
+         * Machine division and remainer may work either way when
+         * one or both of n or d is negative.  If only one is
+         * negative and r.quot has been truncated towards -inf,
+         * r.rem will have the same sign as denom and the opposite
+         * sign of num; if both are negative and r.quot has been
+         * truncated towards -inf, r.rem will be positive (will
+         * have the opposite sign of num).  These are considered
+         * `wrong'.
+         *
+         * If both are num and denom are positive, r will always
+         * be positive.
+         *
+         * This all boils down to:
+         *      if num >= 0, but r.rem < 0, we got the wrong answer.
+         * In that case, to get the right answer, add 1 to r.quot and
+         * subtract denom from r.rem.
+         */
+        if (num >= 0 && r.rem < 0) {
+                r.quot++;
+                r.rem -= denom;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/drand48.c b/src/lib/libc/stdlib/drand48.c
new file mode 100644
index 0000000000..b6c046c831
--- /dev/null
+++ b/src/lib/libc/stdlib/drand48.c
@@ -0,0 +1,23 @@
+/*      $OpenBSD: drand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+
+double
+drand48(void)
+{
+        return erand48(__rand48_seed);
+}
diff --git a/src/lib/libc/stdlib/ecvt.3 b/src/lib/libc/stdlib/ecvt.3
new file mode 100644
index 0000000000..689cb1c6f9
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.3
@@ -0,0 +1,165 @@
+.\" $OpenBSD: ecvt.3,v 1.7 2004/01/25 14:48:32 jmc Exp $
+.\"
+.\" 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.
+.\"
+.Dd December 1, 2002
+.Dt ECVT 3
+.Os
+.Sh NAME
+.Nm ecvt ,
+.Nm fcvt ,
+.Nm gcvt
+.Nd convert double to
+.Tn ASCII
+string
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft char *
+.Fn ecvt "double value" "int ndigit" "int *decpt" "int *sign"
+.Ft char *
+.Fn fcvt "double value" "int ndigit" "int *decpt" "int *sign"
+.Ft char *
+.Fn gcvt "double value" "int ndigit" "char *buf"
+.Sh DESCRIPTION
+.Bf -symbolic
+These functions are provided for compatibility with legacy code.
+New code should use the
+.Xr snprintf 3
+function for improved safety and portability.
+.Ef
+.Pp
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions convert the double precision floating-point number
+.Fa value
+to a NUL-terminated
+.Tn ASCII
+string.
+.Pp
+The
+.Fn ecvt
+function converts
+.Fa value
+to a NUL-terminated string of exactly
+.Fa ndigit
+digits and returns a pointer to that string.
+The result is padded with zeroes from left to right as needed.
+There are no leading zeroes unless
+.Fa value
+itself is 0.
+The least significant digit is rounded in an implementation-dependent manner.
+The position of the decimal point relative to the beginning of the string
+is stored in
+.Fa decpt .
+A negative value indicates that the decimal point is located
+to the left of the returned digits (this occurs when there is no
+whole number component to
+.Fa value ) .
+If
+.Fa value
+is zero, it is unspecified whether the integer pointed to by
+.Fa decpt
+will be 0 or 1.
+The decimal point itself is not included in the returned string.
+If the sign of the result is negative, the integer pointed to by
+.Fa sign
+is non-zero; otherwise, it is 0.
+.Pp
+If the converted value is out of range or is not representable,
+the contents of the returned string are unspecified.
+.Pp
+The
+.Fn fcvt
+function is identical to
+.Fn ecvt
+with the exception that
+.Fa ndigit
+specifies the number of digits after the decimal point (zero-padded as
+needed).
+.Pp
+The
+.Fn gcvt
+function converts
+.Fa value
+to a NUL-terminated string similar to the %g
+.Xr printf 3
+format specifier and stores the result in
+.Fa buf .
+It produces
+.Fa ndigit
+significant digits similar to the %f
+.Xr printf 3
+format specifier where possible.
+If
+.Fa ndigit
+does allow sufficient precision, the result is stored in
+exponential notation similar to the %e
+.Xr printf 3
+format specifier.
+If
+.Fa value
+is less than zero,
+.Fa buf
+will be prefixed with a minus sign.
+A decimal point is included in the returned string if
+.Fa value
+is not a whole number.
+Unlike the
+.Fn ecvt
+and
+.Fn fcvt
+functions,
+.Fa buf
+is not zero-padded.
+.Sh RETURN VALUES
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions return a NUL-terminated string representation of
+.Fa value .
+.Sh WARNINGS
+The
+.Fn ecvt
+and
+.Fn fcvt
+functions return a pointer to internal storage space that will be
+overwritten by subsequent calls to either function.
+.Pp
+The maximum possible precision of the return value is limited by the
+precision of a double and may not be the same on all architectures.
+.Pp
+The
+.Xr snprintf 3
+function is preferred over these functions for new code.
+.Sh SEE ALSO
+.Xr printf 3 ,
+.Xr strtod 3
+.Sh STANDARDS
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions conform to
+.St -p1003.1-2001 .
diff --git a/src/lib/libc/stdlib/ecvt.c b/src/lib/libc/stdlib/ecvt.c
new file mode 100644
index 0000000000..eb0e428996
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.c
@@ -0,0 +1,99 @@
+/*      $OpenBSD: ecvt.c,v 1.5 2006/01/10 16:18:37 millert Exp $        */
+
+/*
+ * Copyright (c) 2002, 2006 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 <string.h>
+
+extern char *__dtoa(double, int, int, int *, int *, char **);
+static char *__cvt(double, int, int *, int *, int, int);
+
+static char *
+__cvt(double value, int ndigit, int *decpt, int *sign, int fmode, int pad)
+{
+        static char *s;
+        char *p, *rve;
+        size_t siz;
+
+        if (ndigit == 0) {
+                *sign = value < 0.0;
+                *decpt = 0;
+                return ("");
+        }
+
+        if (s) {
+                free(s);
+                s = NULL;
+        }
+
+        if (ndigit < 0)
+                siz = -ndigit + 1;
+        else
+                siz = ndigit + 1;
+
+
+        /* __dtoa() doesn't allocate space for 0 so we do it by hand */
+        if (value == 0.0) {
+                *decpt = 1 - fmode;     /* 1 for 'e', 0 for 'f' */
+                *sign = 0;
+                if ((rve = s = (char *)malloc(siz)) == NULL)
+                        return(NULL);
+                *rve++ = '0';
+                *rve = '\0';
+        } else {
+                p = __dtoa(value, fmode + 2, ndigit, decpt, sign, &rve);
+                if (*decpt == 9999) {
+                        /* Infinity or Nan, convert to inf or nan like printf */
+                        *decpt = 0;
+                        return(*p == 'I' ? "inf" : "nan");
+                }
+                /* Make a local copy and adjust rve to be in terms of s */
+                if (pad && fmode)
+                        siz += *decpt;
+                if ((s = (char *)malloc(siz)) == NULL)
+                        return(NULL);
+                (void) strlcpy(s, p, siz);
+                rve = s + (rve - p);
+        }
+
+        /* Add trailing zeros */
+        if (pad) {
+                siz -= rve - s;
+                while (--siz)
+                        *rve++ = '0';
+                *rve = '\0';
+        }
+
+        return(s);
+}
+
+char *
+ecvt(double value, int ndigit, int *decpt, int *sign)
+{
+        return(__cvt(value, ndigit, decpt, sign, 0, 1));
+}
+
+char *
+fcvt(double value, int ndigit, int *decpt, int *sign)
+{
+        return(__cvt(value, ndigit, decpt, sign, 1, 1));
+}
diff --git a/src/lib/libc/stdlib/erand48.c b/src/lib/libc/stdlib/erand48.c
new file mode 100644
index 0000000000..2ffeaa6e71
--- /dev/null
+++ b/src/lib/libc/stdlib/erand48.c
@@ -0,0 +1,24 @@
+/*      $OpenBSD: erand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+double
+erand48(unsigned short xseed[3])
+{
+        __dorand48(xseed);
+        return ldexp((double) xseed[0], -48) +
+               ldexp((double) xseed[1], -32) +
+               ldexp((double) xseed[2], -16);
+}
diff --git a/src/lib/libc/stdlib/exit.3 b/src/lib/libc/stdlib/exit.3
new file mode 100644
index 0000000000..fa233ac75f
--- /dev/null
+++ b/src/lib/libc/stdlib/exit.3
@@ -0,0 +1,114 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: exit.3,v 1.10 2004/05/03 17:21:13 millert Exp $
+.\"
+.Dd January 21, 2004
+.Dt EXIT 3
+.Os
+.Sh NAME
+.Nm exit, _Exit
+.Nd perform normal program termination
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void
+.Fn exit "int status"
+.Ft void
+.Fn _Exit "int status"
+.Sh DESCRIPTION
+The
+.Fn exit
+and
+.Fn _Exit
+functions terminate a process.
+.Pp
+Before termination,
+.Fn exit
+performs the following operations in the order listed:
+.Bl -enum -offset indent
+.It
+Call the functions registered with the
+.Xr atexit 3
+function, in the reverse order of their registration.
+.It
+Flush all open output streams.
+.It
+Close all open streams.
+.It
+Unlink all files created with the
+.Xr tmpfile 3
+function.
+.El
+.Pp
+The
+.Fn _Exit
+function terminates without calling the functions registered with the
+.Xr atexit 3
+function.
+The
+.Ox
+implementation of
+.Fn _Exit
+does not flush open output streams or unlink files created with the
+.Xr tmpfile 3
+function.
+However, this behavior is implementation-specific.
+.Pp
+Lastly,
+.Fn exit
+and
+.Fn _Exit
+call
+.Xr _exit 2 .
+Note that typically
+.Xr _exit 2
+only passes the lower 8 bits of
+.Fa status
+on to the parent, thus negative values have less meaning.
+.Sh RETURN VALUES
+The
+.Fn exit
+and
+.Fn _Exit
+functions never return.
+.Sh SEE ALSO
+.Xr _exit 2 ,
+.Xr atexit 3 ,
+.Xr intro 3 ,
+.Xr sysexits 3 ,
+.Xr tmpfile 3
+.Sh STANDARDS
+The
+.Fn exit
+and
+.Fn _Exit
+functions conform to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/exit.c b/src/lib/libc/stdlib/exit.c
new file mode 100644
index 0000000000..90b7d5adc2
--- /dev/null
+++ b/src/lib/libc/stdlib/exit.c
@@ -0,0 +1,69 @@
+/*      $OpenBSD: exit.c,v 1.11 2005/08/08 08:05:36 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "atexit.h"
+#include "thread_private.h"
+
+/*
+ * This variable is zero until a process has created a thread.
+ * It is used to avoid calling locking functions in libc when they
+ * are not required. By default, libc is intended to be(come)
+ * thread-safe, but without a (significant) penalty to non-threaded
+ * processes.
+ */
+int     __isthreaded    = 0;
+
+/*
+ * Exit, flushing stdio buffers if necessary.
+ */
+void
+exit(int status)
+{
+        struct atexit *p, *q;
+        int n, pgsize = getpagesize();
+
+        if (!__atexit_invalid) {
+                p = __atexit;
+                while (p != NULL) {
+                        for (n = p->ind; --n >= 0;)
+                                if (p->fns[n] != NULL)
+                                        (*p->fns[n])();
+                        q = p;
+                        p = p->next;
+                        munmap(q, pgsize);
+                }
+        }
+        /* cleanup, if registered, was called through fns[0] in the last page */
+        _exit(status);
+}
diff --git a/src/lib/libc/stdlib/gcvt.c b/src/lib/libc/stdlib/gcvt.c
new file mode 100644
index 0000000000..bc6295c03d
--- /dev/null
+++ b/src/lib/libc/stdlib/gcvt.c
@@ -0,0 +1,108 @@
+/*      $OpenBSD: gcvt.c,v 1.9 2006/01/10 16:18:37 millert Exp $        */
+
+/*
+ * Copyright (c) 2002, 2003, 2006 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 <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char *__dtoa(double, int, int, int *, int *, char **);
+
+char *
+gcvt(double value, int ndigit, char *buf)
+{
+        char *digits, *dst, *src;
+        int i, decpt, sign;
+        struct lconv *lconv;
+
+        lconv = localeconv();
+        if (ndigit == 0) {
+                buf[0] = '\0';
+                return (buf);
+        }
+
+        digits = __dtoa(value, 2, ndigit, &decpt, &sign, NULL);
+        if (decpt == 9999) {
+                /*
+                 * Infinity or NaN, convert to inf or nan with sign.
+                 * We assume the buffer is at least ndigit long.
+                 */
+                snprintf(buf, ndigit + 1, "%s%s", sign ? "-" : "",
+                    *digits == 'I' ? "inf" : "nan");
+                return (buf);
+        }
+
+        dst = buf;
+        if (sign)
+                *dst++ = '-';
+
+        if (decpt < 0 || decpt > ndigit) {
+                /* exponential format (e.g. 1.2345e+13) */
+                if (--decpt < 0) {
+                        sign = 1;
+                        decpt = -decpt;
+                } else
+                        sign = 0;
+                src = digits;
+                *dst++ = *src++;
+                *dst++ = *lconv->decimal_point;
+                while (*src != '\0')
+                        *dst++ = *src++;
+                *dst++ = 'e';
+                if (sign)
+                        *dst++ = '-';
+                else
+                        *dst++ = '+';
+                if (decpt < 10) {
+                        *dst++ = '0';
+                        *dst++ = '0' + decpt;
+                        *dst = '\0';
+                } else {
+                        /* XXX - optimize */
+                        for (sign = decpt, i = 0; (sign /= 10) != 0; i++)
+                                continue;
+                        dst[i + 1] = '\0';
+                        while (decpt != 0) {
+                                dst[i--] = '0' + decpt % 10;
+                                decpt /= 10;
+                        }
+                }
+        } else {
+                /* standard format */
+                for (i = 0, src = digits; i < decpt; i++) {
+                        if (*src != '\0')
+                                *dst++ = *src++;
+                        else
+                                *dst++ = '0';
+                }
+                if (*src != '\0') {
+                        if (src == digits)
+                                *dst++ = '0';   /* zero before decimal point */
+                        *dst++ = *lconv->decimal_point;
+                        for (i = decpt; digits[i] != '\0'; i++) {
+                                *dst++ = digits[i];
+                        }
+                }
+                *dst = '\0';
+        }
+        return (buf);
+}
diff --git a/src/lib/libc/stdlib/getenv.3 b/src/lib/libc/stdlib/getenv.3
new file mode 100644
index 0000000000..f131bbf513
--- /dev/null
+++ b/src/lib/libc/stdlib/getenv.3
@@ -0,0 +1,148 @@
+.\" Copyright (c) 1988, 1991, 1993
+.\"    The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: getenv.3,v 1.11 2005/07/26 04:20:23 jaredy Exp $
+.\"
+.Dd December 11, 1993
+.Dt GETENV 3
+.Os
+.Sh NAME
+.Nm getenv ,
+.Nm putenv ,
+.Nm setenv ,
+.Nm unsetenv
+.Nd environment variable functions
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft char *
+.Fn getenv "const char *name"
+.Ft int
+.Fn setenv "const char *name" "const char *value" "int overwrite"
+.Ft int
+.Fn putenv "const char *string"
+.Ft void
+.Fn unsetenv "const char *name"
+.Sh DESCRIPTION
+These functions set, unset, and fetch environment variables from the host
+.Em environment list .
+For compatibility with differing environment conventions, the given arguments
+.Fa name
+and
+.Fa value
+may be appended and prepended, respectively, with an equal sign
+.Dq Li \&= .
+.Pp
+The
+.Fn getenv
+function obtains the current value of the environment variable
+.Fa name .
+If the variable
+.Fa name
+is not in the current environment, a null pointer is returned.
+.Pp
+The
+.Fn setenv
+function inserts or resets the environment variable
+.Fa name
+in the current environment list.
+If the variable
+.Fa name
+does not exist in the list, it is inserted with the given
+.Fa value .
+If the variable does exist, the argument
+.Fa overwrite
+is tested; if
+.Fa overwrite
+is zero, the variable is not reset, otherwise it is reset to the given
+.Fa value .
+.Pp
+The
+.Fn putenv
+function takes an argument of the form
+.Ar name Ns = Ns Ar value
+and is equivalent to:
+.Bd -literal -offset indent
+setenv(name, value, 1);
+.Ed
+.Pp
+The
+.Fn unsetenv
+function deletes all instances of the variable name pointed to by
+.Fa name
+from the list.
+.Sh RETURN VALUES
+The functions
+.Fn setenv
+and
+.Fn putenv
+return zero if successful; otherwise the global variable
+.Va errno
+is set to indicate the error and \-1 is returned.
+.Pp
+If
+.Fn getenv
+is successful, the string returned should be considered read-only.
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+The function
+.Fn setenv
+or
+.Fn putenv
+failed because they were unable to allocate memory for the environment.
+.El
+.Sh SEE ALSO
+.Xr csh 1 ,
+.Xr sh 1 ,
+.Xr execve 2 ,
+.Xr environ 7
+.Sh STANDARDS
+The
+.Fn getenv
+function conforms to
+.St -ansiC .
+.Sh HISTORY
+The function
+.Fn getenv
+appeared in
+.At v7
+and
+.Bx 3 .
+The functions
+.Fn setenv
+and
+.Fn unsetenv
+appeared in
+.Bx 4.3 Tahoe .
+The
+.Fn putenv
+function appeared in
+.Bx 4.3 Reno .
diff --git a/src/lib/libc/stdlib/getenv.c b/src/lib/libc/stdlib/getenv.c
new file mode 100644
index 0000000000..72367b34e2
--- /dev/null
+++ b/src/lib/libc/stdlib/getenv.c
@@ -0,0 +1,80 @@
+/*      $OpenBSD: getenv.c,v 1.8 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1987, 1993
+ *      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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+char *__findenv(const char *name, int *offset);
+
+/*
+ * __findenv --
+ *      Returns pointer to value associated with name, if any, else NULL.
+ *      Sets offset to be the offset of the name/value combination in the
+ *      environmental array, for use by setenv(3) and unsetenv(3).
+ *      Explicitly removes '=' in argument name.
+ *
+ *      This routine *should* be a static; don't use it.
+ */
+char *
+__findenv(const char *name, int *offset)
+{
+        extern char **environ;
+        int len, i;
+        const char *np;
+        char **p, *cp;
+
+        if (name == NULL || environ == NULL)
+                return (NULL);
+        for (np = name; *np && *np != '='; ++np)
+                ;
+        len = np - name;
+        for (p = environ; (cp = *p) != NULL; ++p) {
+                for (np = name, i = len; i && *cp; i--)
+                        if (*cp++ != *np++)
+                                break;
+                if (i == 0 && *cp++ == '=') {
+                        *offset = p - environ;
+                        return (cp);
+                }
+        }
+        return (NULL);
+}
+
+/*
+ * getenv --
+ *      Returns ptr to value associated with name, if any, else NULL.
+ */
+char *
+getenv(const char *name)
+{
+        int offset;
+
+        return (__findenv(name, &offset));
+}
diff --git a/src/lib/libc/stdlib/getopt.3 b/src/lib/libc/stdlib/getopt.3
new file mode 100644
index 0000000000..796541184f
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt.3
@@ -0,0 +1,387 @@
+.\" Copyright (c) 1988, 1991, 1993
+.\"     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.
+.\"
+.\"     $OpenBSD: getopt.3,v 1.38 2006/03/15 02:50:25 ray Exp $
+.\"
+.Dd December 17, 2002
+.Dt GETOPT 3
+.Os
+.Sh NAME
+.Nm getopt
+.Nd get option character from command line argument list
+.Sh SYNOPSIS
+.Fd #include <unistd.h>
+.Vt extern char *optarg;
+.Vt extern int   opterr;
+.Vt extern int   optind;
+.Vt extern int   optopt;
+.Vt extern int   optreset;
+.Ft int
+.Fn getopt "int argc" "char * const *argv" "const char *optstring"
+.Sh DESCRIPTION
+The
+.Fn getopt
+function incrementally parses a command line argument list
+.Fa argv
+and returns the next
+.Em known
+option character.
+An option character is
+.Em known
+if it has been specified in the string of accepted option characters,
+.Fa optstring .
+.Pp
+The option string
+.Fa optstring
+may contain the following elements: individual characters,
+characters followed by a colon, and characters followed by two colons.
+A character followed by a single colon indicates that an argument
+is to follow the option on the command line.
+Two colons indicates that the argument is optional \- this is an
+extension not covered by POSIX.
+For example, an option string
+.Qq x
+recognizes an option
+.Fl x ,
+and an option string
+.Qq Li x:
+recognizes an option and argument
+.Fl x Ar argument .
+It does not matter to
+.Fn getopt
+if a following argument has leading whitespace.
+.Pp
+On return from
+.Fn getopt ,
+.Va optarg
+points to an option argument, if it is anticipated,
+and the variable
+.Va optind
+contains the index to the next
+.Fa argv
+argument for a subsequent call
+to
+.Fn getopt .
+.Pp
+The variables
+.Va opterr
+and
+.Va optind
+are both initialized to 1.
+The
+.Va optind
+variable may be set to another value larger than 0 before a set of calls to
+.Fn getopt
+in order to skip over more or less
+.Fa argv
+entries.
+An
+.Va optind
+value of 0 is reserved for compatibility with GNU
+.Fn getopt .
+.Pp
+In order to use
+.Fn getopt
+to evaluate multiple sets of arguments, or to evaluate a single set of
+arguments multiple times,
+the variable
+.Va optreset
+must be set to 1 before the second and each additional set of calls to
+.Fn getopt ,
+and the variable
+.Va optind
+must be reinitialized.
+.Pp
+The
+.Fn getopt
+function returns \-1 when the argument list is exhausted.
+The interpretation of options in the argument list may be cancelled
+by the option
+.Ql --
+(double dash) which causes
+.Fn getopt
+to signal the end of argument processing and return \-1.
+When all options have been processed (i.e., up to the first non-option
+argument),
+.Fn getopt
+returns \-1.
+.Sh RETURN VALUES
+The
+.Fn getopt
+function returns the next known option character in
+.Fa optstring .
+If
+.Fn getopt
+encounters a character not found in
+.Fa optstring
+or if it detects a missing option argument,
+it returns
+.Sq \&?
+(question mark).
+If
+.Fa optstring
+has a leading
+.Sq \&:
+then a missing option argument causes
+.Sq \&:
+to be returned instead of
+.Sq \&? .
+In either case, the variable
+.Va optopt
+is set to the character that caused the error.
+The
+.Fn getopt
+function returns \-1 when the argument list is exhausted.
+.Sh ENVIRONMENT
+.Bl -tag -width POSIXLY_CORRECTXX
+.It Ev POSIXLY_CORRECT
+If set, a leading
+.Sq -
+in
+.Ar optstring
+is ignored.
+.El
+.Sh EXAMPLES
+The following code accepts the options
+.Fl b
+and
+.Fl f Ar argument
+and adjusts
+.Va argc
+and
+.Va argv
+after option argument processing has completed.
+.Bd -literal -offset indent
+int bflag, ch, fd;
+
+bflag = 0;
+while ((ch = getopt(argc, argv, "bf:")) != -1) {
+        switch (ch) {
+        case 'b':
+                bflag = 1;
+                break;
+        case 'f':
+                if ((fd = open(optarg, O_RDONLY, 0)) == -1)
+                        err(1, "%s", optarg);
+                break;
+        default:
+                usage();
+                /* NOTREACHED */
+        }
+}
+argc -= optind;
+argv += optind;
+.Ed
+.Sh DIAGNOSTICS
+If the
+.Fn getopt
+function encounters a character not found in the string
+.Fa optstring
+or detects
+a missing option argument, it writes an error message to
+.Em stderr
+and returns
+.Ql \&? .
+Setting
+.Va opterr
+to a zero will disable these error messages.
+If
+.Fa optstring
+has a leading
+.Ql \&:
+then a missing option argument causes a
+.Ql \&:
+to be returned in addition to suppressing any error messages.
+.Pp
+Option arguments are allowed to begin with
+.Ql - ;
+this is reasonable but reduces the amount of error checking possible.
+.Sh SEE ALSO
+.Xr getopt 1 ,
+.Xr getopt_long 3 ,
+.Xr getsubopt 3
+.Sh STANDARDS
+The
+.Fn getopt
+function implements a superset of the functionality specified by
+.St -p1003.1 .
+.Pp
+The following extensions are supported:
+.Bl -tag -width "xxx"
+.It Li o
+The
+.Va optreset
+variable was added to make it possible to call the
+.Fn getopt
+function multiple times.
+.It Li o
+If the
+.Va optind
+variable is set to 0,
+.Fn getopt
+will behave as if the
+.Va optreset
+variable has been set.
+This is for compatibility with
+.Tn GNU
+.Fn getopt .
+New code should use
+.Va optreset
+instead.
+.It Li o
+If the first character of
+.Fa optstring
+is a plus sign
+.Pq Ql + ,
+it will be ignored.
+This is for compatibility with
+.Tn GNU
+.Fn getopt .
+.It Li o
+If the first character of
+.Fa optstring
+is a dash
+.Pq Ql - ,
+non-options will be returned as arguments to the option character
+.Ql \e1 .
+This is for compatibility with
+.Tn GNU
+.Fn getopt .
+.It Li o
+A single dash
+.Pq Ql -
+may be specified as a character in
+.Fa optstring ,
+however it should
+.Em never
+have an argument associated with it.
+This allows
+.Fn getopt
+to be used with programs that expect
+.Ql -
+as an option flag.
+This practice is wrong, and should not be used in any current development.
+It is provided for backward compatibility
+.Em only .
+Care should be taken not to use
+.Ql -
+as the first character in
+.Fa optstring
+to avoid a semantic conflict with
+.Tn GNU
+.Fn getopt
+semantics (see above).
+By default, a single dash causes
+.Fn getopt
+to return \-1.
+.El
+.Pp
+Unlike
+.Tn GNU
+.Fn getopt ,
+.Ox
+does not permute the argument vector to allow non-options to be
+interspersed with options on the command line.
+Programs requiring this behavior should use
+.Xr getopt_long 3
+instead.
+Because of this (and unlike
+.Tn GNU ) ,
+the
+.Ox
+.Fn getopt
+supports optional arguments separated by whitespace.
+.Pp
+Historic
+.Bx
+versions of
+.Fn getopt
+set
+.Fa optopt
+to the last option character processed.
+However, this conflicts with
+.St -p1003.1
+which stipulates that
+.Fa optopt
+be set to the last character that caused an error.
+.Sh HISTORY
+The
+.Fn getopt
+function appeared in
+.Bx 4.3 .
+.Sh BUGS
+The
+.Fn getopt
+function was once specified to return
+.Dv EOF
+instead of \-1.
+This was changed by
+.St -p1003.2-92
+to decouple
+.Fn getopt
+from
+.Aq Pa stdio.h .
+.Pp
+It is possible to handle digits as option letters.
+This allows
+.Fn getopt
+to be used with programs that expect a number
+.Pq Dq Li \-3
+as an option.
+This practice is wrong, and should not be used in any current development.
+It is provided for backward compatibility
+.Em only .
+The following code fragment works in most cases and can handle mixed
+number and letter arguments.
+.Bd -literal -offset indent
+int aflag = 0, bflag = 0, ch, lastch = '\e0';
+int length = -1, newarg = 1, prevoptind = 1;
+
+while ((ch = getopt(argc, argv, "0123456789ab")) != -1) {
+        switch (ch) {
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+                if (newarg || !isdigit(lastch))
+                        length = 0;
+                else if (length > INT_MAX / 10)
+                        usage();
+                length = (length * 10) + (ch - '0');
+                break;
+        case 'a':
+                aflag = 1;
+                break;
+        case 'b':
+                bflag = 1;
+                break;
+        default:
+                usage();
+        }
+        lastch = ch;
+        newarg = optind != prevoptind;
+        prevoptind = optind;
+}
+.Ed
diff --git a/src/lib/libc/stdlib/getopt_long.3 b/src/lib/libc/stdlib/getopt_long.3
new file mode 100644
index 0000000000..bf5ba22ece
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.3
@@ -0,0 +1,459 @@
+.\"     $OpenBSD: getopt_long.3,v 1.12 2005/10/11 01:23:41 jaredy Exp $
+.\"     $NetBSD: getopt_long.3,v 1.11 2002/10/02 10:54:19 wiz Exp $
+.\"
+.\" Copyright (c) 1988, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)getopt.3    8.5 (Berkeley) 4/27/95
+.\"
+.Dd April 1, 2000
+.Dt GETOPT_LONG 3
+.Os
+.Sh NAME
+.Nm getopt_long ,
+.Nm getopt_long_only
+.Nd get long options from command line argument list
+.Sh SYNOPSIS
+.Fd #include <getopt.h>
+.Vt extern char *optarg;
+.Vt extern int optind;
+.Vt extern int optopt;
+.Vt extern int opterr;
+.Vt extern int optreset;
+.Ft int
+.Fn getopt_long "int argc" "char * const *argv" "const char *optstring" "const struct option *longopts" "int *longindex"
+.Ft int
+.Fn getopt_long_only "int argc" "char * const *argv" "const char *optstring" "const struct option *longopts" "int *longindex"
+.Sh DESCRIPTION
+The
+.Fn getopt_long
+function is similar to
+.Xr getopt 3
+but it accepts options in two forms: words and characters.
+The
+.Fn getopt_long
+function provides a superset of the functionality of
+.Xr getopt 3 .
+.Fn getopt_long
+can be used in two ways.
+In the first way, every long option understood by the program has a
+corresponding short option, and the option structure is only used to
+translate from long options to short options.
+When used in this fashion,
+.Fn getopt_long
+behaves identically to
+.Xr getopt 3 .
+This is a good way to add long option processing to an existing program
+with the minimum of rewriting.
+.Pp
+In the second mechanism, a long option sets a flag in the
+.Fa option
+structure passed, or will store a pointer to the command line argument
+in the
+.Fa option
+structure passed to it for options that take arguments.
+Additionally, the long option's argument may be specified as a single
+argument with an equal sign, e.g.
+.Bd -literal -offset indent
+$ myprogram --myoption=somevalue
+.Ed
+.Pp
+When a long option is processed, the call to
+.Fn getopt_long
+will return 0.
+For this reason, long option processing without
+shortcuts is not backwards compatible with
+.Xr getopt 3 .
+.Pp
+It is possible to combine these methods, providing for long options
+processing with short option equivalents for some options.
+Less frequently used options would be processed as long options only.
+.Pp
+The
+.Fn getopt_long
+call requires a structure to be initialized describing the long
+options.
+The structure is:
+.Bd -literal -offset indent
+struct option {
+        char *name;
+        int has_arg;
+        int *flag;
+        int val;
+};
+.Ed
+.Pp
+The
+.Fa name
+field should contain the option name without the leading double dash.
+.Pp
+The
+.Fa has_arg
+field should be one of:
+.Pp
+.Bl -tag -width "optional_argument" -compact -offset indent
+.It Dv no_argument
+no argument to the option is expected.
+.It Dv required_argument
+an argument to the option is required.
+.It Dv optional_argument
+an argument to the option may be presented.
+.El
+.Pp
+If
+.Fa flag
+is not
+.Dv NULL ,
+then the integer pointed to by it will be set to the value in the
+.Fa val
+field.
+If the
+.Fa flag
+field is
+.Dv NULL ,
+then the
+.Fa val
+field will be returned.
+Setting
+.Fa flag
+to
+.Dv NULL
+and setting
+.Fa val
+to the corresponding short option will make this function act just
+like
+.Xr getopt 3 .
+.Pp
+If the
+.Fa longindex
+field is not
+.Dv NULL ,
+then the integer pointed to by it will be set to the index of the long
+option relative to
+.Fa longopts .
+.Pp
+The last element of the
+.Fa longopts
+array has to be filled with zeroes.
+.Pp
+The
+.Fn getopt_long_only
+function behaves identically to
+.Fn getopt_long
+with the exception that long options may start with
+.Sq -
+in addition to
+.Sq -- .
+If an option starting with
+.Sq -
+does not match a long option but does match a single-character option,
+the single-character option is returned.
+.Sh RETURN VALUES
+If the
+.Fa flag
+field in
+.Li struct option
+is
+.Dv NULL ,
+.Fn getopt_long
+and
+.Fn getopt_long_only
+return the value specified in the
+.Fa val
+field, which is usually just the corresponding short option.
+If
+.Fa flag
+is not
+.Dv NULL ,
+these functions return 0 and store
+.Fa val
+in the location pointed to by
+.Fa flag .
+These functions return
+.Sq \:
+if there was a missing option argument,
+.Sq \&?
+if the user specified an unknown or ambiguous option, and
+\-1 when the argument list has been exhausted.
+.Sh EXAMPLES
+.Bd -literal -compact
+int bflag, ch, fd;
+int daggerset;
+
+/* options descriptor */
+static struct option longopts[] = {
+        { "buffy",      no_argument,            NULL,           'b' },
+        { "fluoride",   required_argument,      NULL,           'f' },
+        { "daggerset",  no_argument,            &daggerset,     1 },
+        { NULL,         0,                      NULL,           0 }
+};
+
+bflag = 0;
+while ((ch = getopt_long(argc, argv, "bf:", longopts, NULL)) != -1)
+        switch (ch) {
+        case 'b':
+                bflag = 1;
+                break;
+        case 'f':
+                if ((fd = open(optarg, O_RDONLY, 0)) == -1)
+                        err(1, "unable to open %s", optarg);
+                break;
+        case 0:
+                if (daggerset)
+                        fprintf(stderr, "Buffy will use her dagger to "
+                            "apply fluoride to dracula's teeth\en");
+                break;
+        default:
+                usage();
+                /* NOTREACHED */
+        }
+argc -= optind;
+argv += optind;
+.Ed
+.Sh IMPLEMENTATION DIFFERENCES
+This section describes differences to the GNU implementation
+found in glibc-2.1.3:
+.Bl -bullet
+.It
+handling of
+.Ql -
+as the first character of the option string in the presence of the
+environment variable
+.Ev POSIXLY_CORRECT :
+.Bl -tag -width "OpenBSD"
+.It GNU
+ignores
+.Ev POSIXLY_CORRECT
+and returns non-options as arguments to option
+.Ql \e1 .
+.It OpenBSD
+honors
+.Ev POSIXLY_CORRECT
+and stops at the first non-option.
+.El
+.It
+handling of
+.Ql -
+within the option string (not the first character):
+.Bl -tag -width "OpenBSD"
+.It GNU
+treats a
+.Ql -
+on the command line as a non-argument.
+.It OpenBSD
+a
+.Ql -
+within the option string matches a
+.Ql -
+(single dash) on the command line.
+This functionality is provided for backward compatibility with
+programs, such as
+.Xr su 1 ,
+that use
+.Ql -
+as an option flag.
+This practice is wrong, and should not be used in any current development.
+.El
+.It
+handling of
+.Ql ::
+in the option string in the presence of
+.Ev POSIXLY_CORRECT :
+.Bl -tag -width "OpenBSD"
+.It Both
+GNU and
+.Ox
+ignore
+.Ev POSIXLY_CORRECT
+here and take
+.Ql ::
+to mean the preceding option takes an optional argument.
+.El
+.It
+return value in case of missing argument if first character
+(after
+.Ql +
+or
+.Ql - )
+in the option string is not
+.Ql \&: :
+.Bl -tag -width "OpenBSD"
+.It GNU
+returns
+.Ql \&?
+.It OpenBSD
+returns
+.Ql \&:
+(since
+.Ox Ns 's
+.Xr getopt 3
+does).
+.El
+.It
+handling of
+.Ql --a
+in
+.Xr getopt 3 :
+.Bl -tag -width "OpenBSD"
+.It GNU
+parses this as option
+.Ql - ,
+option
+.Ql a .
+.It OpenBSD
+parses this as
+.Ql -- ,
+and returns \-1 (ignoring the
+.Ql a )
+(because the original
+.Fn getopt
+did.)
+.El
+.It
+setting of
+.Va optopt
+for long options with
+.Va flag
+.No non- Ns Dv NULL :
+.Bl -tag -width "OpenBSD"
+.It GNU
+sets
+.Va optopt
+to
+.Va val .
+.It OpenBSD
+sets
+.Va optopt
+to 0 (since
+.Va val
+would never be returned).
+.El
+.It
+handling of
+.Ql -W
+with
+.Ql W;
+in the option string in
+.Xr getopt 3
+(not
+.Fn getopt_long ) :
+.Bl -tag -width "OpenBSD"
+.It GNU
+causes a segmentation fault.
+.It OpenBSD
+no special handling is done;
+.Ql W;
+is interpreted as two separate options, neither of which take an argument.
+.El
+.It
+setting of
+.Va optarg
+for long options without an argument that are invoked via
+.Ql -W
+(with
+.Ql W;
+in the option string):
+.Bl -tag -width "OpenBSD"
+.It GNU
+sets
+.Va optarg
+to the option name (the argument of
+.Ql -W ) .
+.It OpenBSD
+sets
+.Va optarg
+to
+.Dv NULL
+(the argument of the long option).
+.El
+.It
+handling of
+.Ql -W
+with an argument that is not (a prefix to) a known long option
+(with
+.Ql W;
+in the option string):
+.Bl -tag -width "OpenBSD"
+.It GNU
+returns
+.Ql -W
+with
+.Va optarg
+set to the unknown option.
+.It OpenBSD
+treats this as an error (unknown option) and returns
+.Ql \&?
+with
+.Va optopt
+set to 0 and
+.Va optarg
+set to
+.Dv NULL
+(as GNU's man page documents).
+.El
+.It
+The error messages are different.
+.It
+.Ox
+does not permute the argument vector at the same points in
+the calling sequence as GNU does.
+The aspects normally used by the caller
+(ordering after \-1 is returned, value of
+.Va optind
+relative to current positions) are the same, though.
+(We do fewer variable swaps.)
+.El
+.Sh ENVIRONMENT
+.Bl -tag -width Ev
+.It Ev POSIXLY_CORRECT
+If set, option processing stops when the first non-option is found and
+a leading
+.Sq -
+or
+.Sq +
+in the
+.Ar optstring
+is ignored.
+.El
+.Sh SEE ALSO
+.Xr getopt 3
+.Sh HISTORY
+The
+.Fn getopt_long
+and
+.Fn getopt_long_only
+functions first appeared in GNU libiberty.
+This implementation first appeared in
+.Ox 3.3 .
+.Sh BUGS
+The
+.Ar argv
+argument is not really
+.Dv const
+as its elements may be permuted (unless
+.Ev POSIXLY_CORRECT
+is set).
diff --git a/src/lib/libc/stdlib/getopt_long.c b/src/lib/libc/stdlib/getopt_long.c
new file mode 100644
index 0000000000..41b6cd9f8d
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.c
@@ -0,0 +1,533 @@
+/*      $OpenBSD: getopt_long.c,v 1.20 2005/10/25 15:49:37 jmc Exp $    */
+/*      $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $      */
+
+/*
+ * 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.
+ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * 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 <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define REPLACE_GETOPT          /* use this getopt as the system getopt(3) */
+
+#ifdef REPLACE_GETOPT
+int     opterr = 1;             /* if error message should be printed */
+int     optind = 1;             /* index into parent argv vector */
+int     optopt = '?';           /* character checked for validity */
+int     optreset;               /* reset getopt */
+char    *optarg;                /* argument associated with option */
+#endif
+
+#define PRINT_ERROR     ((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE    0x01    /* permute non-options to the end of argv */
+#define FLAG_ALLARGS    0x02    /* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY   0x04    /* operate as getopt_long_only */
+
+/* return values */
+#define BADCH           (int)'?'
+#define BADARG          ((*options == ':') ? (int)':' : (int)'?')
+#define INORDER         (int)1
+
+#define EMSG            ""
+
+static int getopt_internal(int, char * const *, const char *,
+                           const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+                              const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+        int c;
+
+        c = a % b;
+        while (c != 0) {
+                a = b;
+                b = c;
+                c = a % b;
+        }
+
+        return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+        char * const *nargv)
+{
+        int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+        char *swap;
+
+        /*
+         * compute lengths of blocks and number and size of cycles
+         */
+        nnonopts = panonopt_end - panonopt_start;
+        nopts = opt_end - panonopt_end;
+        ncycle = gcd(nnonopts, nopts);
+        cyclelen = (opt_end - panonopt_start) / ncycle;
+
+        for (i = 0; i < ncycle; i++) {
+                cstart = panonopt_end+i;
+                pos = cstart;
+                for (j = 0; j < cyclelen; j++) {
+                        if (pos >= panonopt_end)
+                                pos -= nnonopts;
+                        else
+                                pos += nopts;
+                        swap = nargv[pos];
+                        /* LINTED const cast */
+                        ((char **) nargv)[pos] = nargv[cstart];
+                        /* LINTED const cast */
+                        ((char **)nargv)[cstart] = swap;
+                }
+        }
+}
+
+/*
+ * parse_long_options --
+ *      Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+        const struct option *long_options, int *idx, int short_too)
+{
+        char *current_argv, *has_equal;
+        size_t current_argv_len;
+        int i, match;
+
+        current_argv = place;
+        match = -1;
+
+        optind++;
+
+        if ((has_equal = strchr(current_argv, '=')) != NULL) {
+                /* argument found (--option=arg) */
+                current_argv_len = has_equal - current_argv;
+                has_equal++;
+        } else
+                current_argv_len = strlen(current_argv);
+
+        for (i = 0; long_options[i].name; i++) {
+                /* find matching long option */
+                if (strncmp(current_argv, long_options[i].name,
+                    current_argv_len))
+                        continue;
+
+                if (strlen(long_options[i].name) == current_argv_len) {
+                        /* exact match */
+                        match = i;
+                        break;
+                }
+                /*
+                 * If this is a known short option, don't allow
+                 * a partial match of a single character.
+                 */
+                if (short_too && current_argv_len == 1)
+                        continue;
+
+                if (match == -1)        /* partial match */
+                        match = i;
+                else {
+                        /* ambiguous abbreviation */
+                        if (PRINT_ERROR)
+                                warnx(ambig, (int)current_argv_len,
+                                     current_argv);
+                        optopt = 0;
+                        return (BADCH);
+                }
+        }
+        if (match != -1) {              /* option found */
+                if (long_options[match].has_arg == no_argument
+                    && has_equal) {
+                        if (PRINT_ERROR)
+                                warnx(noarg, (int)current_argv_len,
+                                     current_argv);
+                        /*
+                         * XXX: GNU sets optopt to val regardless of flag
+                         */
+                        if (long_options[match].flag == NULL)
+                                optopt = long_options[match].val;
+                        else
+                                optopt = 0;
+                        return (BADARG);
+                }
+                if (long_options[match].has_arg == required_argument ||
+                    long_options[match].has_arg == optional_argument) {
+                        if (has_equal)
+                                optarg = has_equal;
+                        else if (long_options[match].has_arg ==
+                            required_argument) {
+                                /*
+                                 * optional argument doesn't use next nargv
+                                 */
+                                optarg = nargv[optind++];
+                        }
+                }
+                if ((long_options[match].has_arg == required_argument)
+                    && (optarg == NULL)) {
+                        /*
+                         * Missing argument; leading ':' indicates no error
+                         * should be generated.
+                         */
+                        if (PRINT_ERROR)
+                                warnx(recargstring,
+                                    current_argv);
+                        /*
+                         * XXX: GNU sets optopt to val regardless of flag
+                         */
+                        if (long_options[match].flag == NULL)
+                                optopt = long_options[match].val;
+                        else
+                                optopt = 0;
+                        --optind;
+                        return (BADARG);
+                }
+        } else {                        /* unknown option */
+                if (short_too) {
+                        --optind;
+                        return (-1);
+                }
+                if (PRINT_ERROR)
+                        warnx(illoptstring, current_argv);
+                optopt = 0;
+                return (BADCH);
+        }
+        if (idx)
+                *idx = match;
+        if (long_options[match].flag) {
+                *long_options[match].flag = long_options[match].val;
+                return (0);
+        } else
+                return (long_options[match].val);
+}
+
+/*
+ * getopt_internal --
+ *      Parse argc/argv argument vector.  Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+        const struct option *long_options, int *idx, int flags)
+{
+        char *oli;                              /* option letter list index */
+        int optchar, short_too;
+        static int posixly_correct = -1;
+
+        if (options == NULL)
+                return (-1);
+
+        /*
+         * Disable GNU extensions if POSIXLY_CORRECT is set or options
+         * string begins with a '+'.
+         */
+        if (posixly_correct == -1)
+                posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+        if (posixly_correct || *options == '+')
+                flags &= ~FLAG_PERMUTE;
+        else if (*options == '-')
+                flags |= FLAG_ALLARGS;
+        if (*options == '+' || *options == '-')
+                options++;
+
+        /*
+         * XXX Some GNU programs (like cvs) set optind to 0 instead of
+         * XXX using optreset.  Work around this braindamage.
+         */
+        if (optind == 0)
+                optind = optreset = 1;
+
+        optarg = NULL;
+        if (optreset)
+                nonopt_start = nonopt_end = -1;
+start:
+        if (optreset || !*place) {              /* update scanning pointer */
+                optreset = 0;
+                if (optind >= nargc) {          /* end of argument vector */
+                        place = EMSG;
+                        if (nonopt_end != -1) {
+                                /* do permutation, if we have to */
+                                permute_args(nonopt_start, nonopt_end,
+                                    optind, nargv);
+                                optind -= nonopt_end - nonopt_start;
+                        }
+                        else if (nonopt_start != -1) {
+                                /*
+                                 * If we skipped non-options, set optind
+                                 * to the first of them.
+                                 */
+                                optind = nonopt_start;
+                        }
+                        nonopt_start = nonopt_end = -1;
+                        return (-1);
+                }
+                if (*(place = nargv[optind]) != '-' ||
+                    (place[1] == '\0' && strchr(options, '-') == NULL)) {
+                        place = EMSG;           /* found non-option */
+                        if (flags & FLAG_ALLARGS) {
+                                /*
+                                 * GNU extension:
+                                 * return non-option as argument to option 1
+                                 */
+                                optarg = nargv[optind++];
+                                return (INORDER);
+                        }
+                        if (!(flags & FLAG_PERMUTE)) {
+                                /*
+                                 * If no permutation wanted, stop parsing
+                                 * at first non-option.
+                                 */
+                                return (-1);
+                        }
+                        /* do permutation */
+                        if (nonopt_start == -1)
+                                nonopt_start = optind;
+                        else if (nonopt_end != -1) {
+                                permute_args(nonopt_start, nonopt_end,
+                                    optind, nargv);
+                                nonopt_start = optind -
+                                    (nonopt_end - nonopt_start);
+                                nonopt_end = -1;
+                        }
+                        optind++;
+                        /* process next argument */
+                        goto start;
+                }
+                if (nonopt_start != -1 && nonopt_end == -1)
+                        nonopt_end = optind;
+
+                /*
+                 * If we have "-" do nothing, if "--" we are done.
+                 */
+                if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+                        optind++;
+                        place = EMSG;
+                        /*
+                         * We found an option (--), so if we skipped
+                         * non-options, we have to permute.
+                         */
+                        if (nonopt_end != -1) {
+                                permute_args(nonopt_start, nonopt_end,
+                                    optind, nargv);
+                                optind -= nonopt_end - nonopt_start;
+                        }
+                        nonopt_start = nonopt_end = -1;
+                        return (-1);
+                }
+        }
+
+        /*
+         * Check long options if:
+         *  1) we were passed some
+         *  2) the arg is not just "-"
+         *  3) either the arg starts with -- we are getopt_long_only()
+         */
+        if (long_options != NULL && place != nargv[optind] &&
+            (*place == '-' || (flags & FLAG_LONGONLY))) {
+                short_too = 0;
+                if (*place == '-')
+                        place++;                /* --foo long option */
+                else if (*place != ':' && strchr(options, *place) != NULL)
+                        short_too = 1;          /* could be short option too */
+
+                optchar = parse_long_options(nargv, options, long_options,
+                    idx, short_too);
+                if (optchar != -1) {
+                        place = EMSG;
+                        return (optchar);
+                }
+        }
+
+        if ((optchar = (int)*place++) == (int)':' ||
+            optchar == (int)'-' && *place != '\0' ||
+            (oli = strchr(options, optchar)) == NULL) {
+                /*
+                 * If the user specified "-" and  '-' isn't listed in
+                 * options, return -1 (non-option) as per POSIX.
+                 * Otherwise, it is an unknown option character (or ':').
+                 */
+                if (optchar == (int)'-' && *place == '\0')
+                        return (-1);
+                if (!*place)
+                        ++optind;
+                if (PRINT_ERROR)
+                        warnx(illoptchar, optchar);
+                optopt = optchar;
+                return (BADCH);
+        }
+        if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+                /* -W long-option */
+                if (*place)                     /* no space */
+                        /* NOTHING */;
+                else if (++optind >= nargc) {   /* no arg */
+                        place = EMSG;
+                        if (PRINT_ERROR)
+                                warnx(recargchar, optchar);
+                        optopt = optchar;
+                        return (BADARG);
+                } else                          /* white space */
+                        place = nargv[optind];
+                optchar = parse_long_options(nargv, options, long_options,
+                    idx, 0);
+                place = EMSG;
+                return (optchar);
+        }
+        if (*++oli != ':') {                    /* doesn't take argument */
+                if (!*place)
+                        ++optind;
+        } else {                                /* takes (optional) argument */
+                optarg = NULL;
+                if (*place)                     /* no white space */
+                        optarg = place;
+                /* XXX: disable test for :: if PC? (GNU doesn't) */
+                else if (oli[1] != ':') {       /* arg not optional */
+                        if (++optind >= nargc) {        /* no arg */
+                                place = EMSG;
+                                if (PRINT_ERROR)
+                                        warnx(recargchar, optchar);
+                                optopt = optchar;
+                                return (BADARG);
+                        } else
+                                optarg = nargv[optind];
+                } else if (!(flags & FLAG_PERMUTE)) {
+                        /*
+                         * If permutation is disabled, we can accept an
+                         * optional arg separated by whitespace so long
+                         * as it does not start with a dash (-).
+                         */
+                        if (optind + 1 < nargc && *nargv[optind + 1] != '-')
+                                optarg = nargv[++optind];
+                }
+                place = EMSG;
+                ++optind;
+        }
+        /* dump back option letter */
+        return (optchar);
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ *      Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+        /*
+         * We don't pass FLAG_PERMUTE to getopt_internal() since
+         * the BSD getopt(3) (unlike GNU) has never done this.
+         *
+         * Furthermore, since many privileged programs call getopt()
+         * before dropping privileges it makes sense to keep things
+         * as simple (and bug-free) as possible.
+         */
+        return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+#endif /* REPLACE_GETOPT */
+
+/*
+ * getopt_long --
+ *      Parse argc/argv argument vector.
+ */
+int
+getopt_long(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+        return (getopt_internal(nargc, nargv, options, long_options, idx,
+            FLAG_PERMUTE));
+}
+
+/*
+ * getopt_long_only --
+ *      Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+        return (getopt_internal(nargc, nargv, options, long_options, idx,
+            FLAG_PERMUTE|FLAG_LONGONLY));
+}
diff --git a/src/lib/libc/stdlib/getsubopt.3 b/src/lib/libc/stdlib/getsubopt.3
new file mode 100644
index 0000000000..6a7c28ff4d
--- /dev/null
+++ b/src/lib/libc/stdlib/getsubopt.3
@@ -0,0 +1,145 @@
+.\" $OpenBSD: getsubopt.3,v 1.11 2005/10/11 01:23:41 jaredy Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)getsubopt.3 8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt GETSUBOPT 3
+.Os
+.Sh NAME
+.Nm getsubopt
+.Nd get sub options from an argument
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Vt extern char *suboptarg;
+.Ft int
+.Fn getsubopt "char **optionp" "char * const *tokens" "char **valuep"
+.Sh DESCRIPTION
+The
+.Fn getsubopt
+function parses a string containing tokens delimited by one or more
+tab, space, or comma
+.Pq Ql \&,
+characters.
+It is intended for use in parsing groups of option arguments provided
+as part of a utility command line.
+.Pp
+The argument
+.Fa optionp
+is a pointer to a pointer to the string.
+The argument
+.Fa tokens
+is a pointer to a null-terminated array of pointers to strings.
+.Pp
+The
+.Fn getsubopt
+function returns the zero-based offset of the pointer in the
+.Fa tokens
+array referencing a string which matches the first token
+in the string, or \-1 if the string contains no tokens or
+.Fa tokens
+does not contain a matching string.
+.Pp
+If the token is of the form
+.Ar name Ns = Ns Ar value ,
+the location referenced by
+.Fa valuep
+will be set to point to the start of the
+.Dq value
+portion of the token.
+.Pp
+On return from
+.Fn getsubopt ,
+.Fa optionp
+will be set to point to the start of the next token in the string,
+or the NUL at the end of the string if no more tokens are present.
+The external variable
+.Fa suboptarg
+will be set to point to the start of the current token, or
+.Dv NULL
+if no tokens were present.
+The argument
+.Fa valuep
+will be set to point to the value portion of the token, or
+.Dv NULL
+if no value portion was present.
+.Sh EXAMPLES
+.Bd -literal
+char *tokens[] = {
+        #define ONE     0
+                "one",
+        #define TWO     1
+                "two",
+        NULL
+};
+
+\&...
+
+extern char *optarg, *suboptarg;
+char *options, *value;
+
+while ((ch = getopt(argc, argv, "ab:")) != -1) {
+        switch (ch) {
+        case 'a':
+                /* process ``a'' option */
+                break;
+        case 'b':
+                options = optarg;
+                while (*options) {
+                        switch (getsubopt(&options, tokens, &value)) {
+                        case ONE:
+                                /* process ``one'' sub option */
+                                break;
+                        case TWO:
+                                /* process ``two'' sub option */
+                                if (!value)
+                                        error("no value for two");
+                                i = atoi(value);
+                                break;
+                        case -1:
+                                if (suboptarg)
+                                        error("illegal sub option %s",
+                                          suboptarg);
+                                else
+                                        error("missing sub option");
+                                break;
+                        }
+                }
+                break;
+        }
+}
+.Ed
+.Sh SEE ALSO
+.Xr getopt 3 ,
+.Xr strsep 3
+.Sh HISTORY
+The
+.Fn getsubopt
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/stdlib/getsubopt.c b/src/lib/libc/stdlib/getsubopt.c
new file mode 100644
index 0000000000..735c85ba8a
--- /dev/null
+++ b/src/lib/libc/stdlib/getsubopt.c
@@ -0,0 +1,92 @@
+/*      $OpenBSD: getsubopt.c,v 1.4 2005/08/08 08:05:36 espie Exp $     */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      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.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * The SVID interface to getsubopt provides no way of figuring out which
+ * part of the suboptions list wasn't matched.  This makes error messages
+ * tricky...  The extern variable suboptarg is a pointer to the token
+ * which didn't match.
+ */
+char *suboptarg;
+
+int
+getsubopt(char **optionp, char * const *tokens, char **valuep)
+{
+        int cnt;
+        char *p;
+
+        suboptarg = *valuep = NULL;
+
+        if (!optionp || !*optionp)
+                return(-1);
+
+        /* skip leading white-space, commas */
+        for (p = *optionp; *p && (*p == ',' || *p == ' ' || *p == '\t'); ++p);
+
+        if (!*p) {
+                *optionp = p;
+                return(-1);
+        }
+
+        /* save the start of the token, and skip the rest of the token. */
+        for (suboptarg = p;
+            *++p && *p != ',' && *p != '=' && *p != ' ' && *p != '\t';);
+
+        if (*p) {
+                /*
+                 * If there's an equals sign, set the value pointer, and
+                 * skip over the value part of the token.  Terminate the
+                 * token.
+                 */
+                if (*p == '=') {
+                        *p = '\0';
+                        for (*valuep = ++p;
+                            *p && *p != ',' && *p != ' ' && *p != '\t'; ++p);
+                        if (*p) 
+                                *p++ = '\0';
+                } else
+                        *p++ = '\0';
+                /* Skip any whitespace or commas after this token. */
+                for (; *p && (*p == ',' || *p == ' ' || *p == '\t'); ++p);
+        }
+
+        /* set optionp for next round. */
+        *optionp = p;
+
+        for (cnt = 0; *tokens; ++tokens, ++cnt)
+                if (!strcmp(suboptarg, *tokens))
+                        return(cnt);
+        return(-1);
+}
diff --git a/src/lib/libc/stdlib/hcreate.3 b/src/lib/libc/stdlib/hcreate.3
new file mode 100644
index 0000000000..66b1dd126d
--- /dev/null
+++ b/src/lib/libc/stdlib/hcreate.3
@@ -0,0 +1,191 @@
+.\"     $OpenBSD: hcreate.3,v 1.3 2006/01/30 19:50:41 jmc Exp $
+.\"     $NetBSD: hcreate.3,v 1.6 2003/04/16 13:34:46 wiz Exp $
+.\"
+.\" Copyright (c) 1999 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to The NetBSD Foundation
+.\" by Klaus Klein.
+.\"
+.\" 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.
+.\"
+.Dd February 13, 2001
+.Dt HCREATE 3
+.Os
+.Sh NAME
+.Nm hcreate ,
+.Nm hdestroy ,
+.Nm hsearch
+.Nd manage hash search table
+.Sh SYNOPSIS
+.In search.h
+.Ft int
+.Fn hcreate "size_t nel"
+.Ft void
+.Fn hdestroy "void"
+.Ft ENTRY *
+.Fn hsearch "ENTRY item" "ACTION action"
+.Sh DESCRIPTION
+The
+.Fn hcreate ,
+.Fn hdestroy ,
+and
+.Fn hsearch
+functions manage hash search tables.
+.Pp
+The
+.Fn hcreate
+function allocates and initializes the table.
+The
+.Fa nel
+argument specifies an estimate of the maximum number of entries to be held
+by the table.
+Unless further memory allocation fails, supplying an insufficient
+.Fa nel
+value will not result in functional harm, although a performance degradation
+may occur.
+Initialization using the
+.Fn hcreate
+function is mandatory prior to any access operations using
+.Fn hsearch .
+.Pp
+The
+.Fn hdestroy
+function destroys a table previously created using
+.Fn hcreate .
+After a call to
+.Fn hdestroy ,
+the data can no longer be accessed.
+.Pp
+The
+.Fn hsearch
+function is used to search to the hash table.
+It returns a pointer into the
+hash table indicating the address of an item.
+The
+.Fa item
+argument is of type
+.Dv ENTRY ,
+a structural type which contains the following members:
+.Pp
+.Bl -tag -compact -offset indent -width voidX*dataXX
+.It Fa char *key
+comparison key.
+.It Fa void *data
+pointer to data associated with
+.Fa key .
+.El
+.Pp
+The key comparison function used by
+.Fn hsearch
+is
+.Xr strcmp 3 .
+.Pp
+The
+.Fa action
+argument is of type
+.Dv ACTION ,
+an enumeration type which defines the following values:
+.Bl -tag -offset indent -width ENTERXX
+.It Dv ENTER
+Insert
+.Fa item
+into the hash table.
+If an existing item with the same key is found, it is not replaced.
+Note that the
+.Fa key
+and
+.Fa data
+elements of
+.Fa item
+are used directly by the new table entry.
+The storage for the
+key must not be modified during the lifetime of the hash table.
+.It Dv FIND
+Search the hash table without inserting
+.Fa item .
+.El
+.Sh RETURN VALUES
+If successful, the
+.Fn hcreate
+function returns a non-zero value.
+Otherwise, a value of 0 is returned and
+.Va errno
+is set to indicate the error.
+.Pp
+The
+.Fn hdestroy
+functions
+returns no value.
+.Pp
+If successful, the
+.Fn hsearch
+function returns a pointer to a hash table entry matching
+the provided key.
+If the action is
+.Dv FIND
+and the item was not found, or if the action is
+.Dv ENTER
+and the insertion failed,
+.Dv NULL
+is returned and
+.Va errno
+is set to indicate the error.
+If the action is
+.Dv ENTER
+and an entry already existed in the table matching the given
+key, the existing entry is returned and is not replaced.
+.Sh ERRORS
+The
+.Fn hcreate
+and
+.Fn hsearch
+functions will fail if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient memory is available.
+.El
+.Sh SEE ALSO
+.Xr bsearch 3 ,
+.Xr lsearch 3 ,
+.Xr malloc 3 ,
+.Xr strcmp 3
+.Sh STANDARDS
+These functions conform to
+.St -p1003.1-2004 .
+.Sh HISTORY
+The
+.Fn hcreate ,
+.Fn hdestroy
+and
+.Fn hsearch
+functions first appeared in
+.At V .
+.Sh BUGS
+The interface permits the use of only one hash table at a time.
diff --git a/src/lib/libc/stdlib/hcreate.c b/src/lib/libc/stdlib/hcreate.c
new file mode 100644
index 0000000000..f8df1bcd7c
--- /dev/null
+++ b/src/lib/libc/stdlib/hcreate.c
@@ -0,0 +1,191 @@
+/*      $OpenBSD: hcreate.c,v 1.3 2005/10/10 17:37:44 espie Exp $       */
+/*      $NetBSD: hcreate.c,v 1.5 2004/04/23 02:48:12 simonb 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>>
+ */
+
+/*
+ * hcreate() / hsearch() / hdestroy()
+ *
+ * SysV/XPG4 hash table functions.
+ *
+ * Implementation done based on NetBSD manual page and Solaris manual page,
+ * plus my own personal experience about how they're supposed to work.
+ *
+ * I tried to look at Knuth (as cited by the Solaris manual page), but
+ * nobody had a copy in the office, so...
+ */
+
+#include "namespace.h"
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <search.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/queue.h>
+
+#ifndef _DIAGASSERT
+#define _DIAGASSERT(x)
+#endif
+
+/*
+ * DO NOT MAKE THIS STRUCTURE LARGER THAN 32 BYTES (4 ptrs on 64-bit
+ * ptr machine) without adjusting MAX_BUCKETS_LG2 below.
+ */
+struct internal_entry {
+        SLIST_ENTRY(internal_entry) link;
+        ENTRY ent;
+};
+SLIST_HEAD(internal_head, internal_entry);
+
+#define MIN_BUCKETS_LG2 4
+#define MIN_BUCKETS     (1 << MIN_BUCKETS_LG2)
+
+/*
+ * max * sizeof internal_entry must fit into size_t.
+ * assumes internal_entry is <= 32 (2^5) bytes.
+ */
+#define MAX_BUCKETS_LG2 (sizeof (size_t) * 8 - 1 - 5)
+#define MAX_BUCKETS     ((size_t)1 << MAX_BUCKETS_LG2)
+
+/* Default hash function, from db/hash/hash_func.c */
+extern u_int32_t (*__default_hash)(const void *, size_t);
+
+static struct internal_head *htable;
+static size_t htablesize;
+
+int
+hcreate(size_t nel)
+{
+        size_t idx;
+        unsigned int p2;
+
+        /* Make sure this isn't called when a table already exists. */
+        _DIAGASSERT(htable == NULL);
+        if (htable != NULL) {
+                errno = EINVAL;
+                return 0;
+        }
+
+        /* If nel is too small, make it min sized. */
+        if (nel < MIN_BUCKETS)
+                nel = MIN_BUCKETS;
+
+        /* If it's too large, cap it. */
+        if (nel > MAX_BUCKETS)
+                nel = MAX_BUCKETS;
+
+        /* If it's is not a power of two in size, round up. */
+        if ((nel & (nel - 1)) != 0) {
+                for (p2 = 0; nel != 0; p2++)
+                        nel >>= 1;
+                _DIAGASSERT(p2 <= MAX_BUCKETS_LG2);
+                nel = 1 << p2;
+        }
+        
+        /* Allocate the table. */
+        htablesize = nel;
+        htable = malloc(htablesize * sizeof htable[0]);
+        if (htable == NULL) {
+                errno = ENOMEM;
+                return 0;
+        }
+
+        /* Initialize it. */
+        for (idx = 0; idx < htablesize; idx++)
+                SLIST_INIT(&htable[idx]);
+
+        return 1;
+}
+
+void
+hdestroy(void)
+{
+        struct internal_entry *ie;
+        size_t idx;
+
+        _DIAGASSERT(htable != NULL);
+        if (htable == NULL)
+                return;
+
+        for (idx = 0; idx < htablesize; idx++) {
+                while (!SLIST_EMPTY(&htable[idx])) {
+                        ie = SLIST_FIRST(&htable[idx]);
+                        SLIST_REMOVE_HEAD(&htable[idx], link);
+                        free(ie->ent.key);
+                        free(ie);
+                }
+        }
+        free(htable);
+        htable = NULL;
+}
+
+ENTRY *
+hsearch(ENTRY item, ACTION action)
+{
+        struct internal_head *head;
+        struct internal_entry *ie;
+        uint32_t hashval;
+        size_t len;
+
+        _DIAGASSERT(htable != NULL);
+        _DIAGASSERT(item.key != NULL);
+        _DIAGASSERT(action == ENTER || action == FIND);
+
+        len = strlen(item.key);
+        hashval = (*__default_hash)(item.key, len);
+
+        head = &htable[hashval & (htablesize - 1)];
+        ie = SLIST_FIRST(head);
+        while (ie != NULL) {
+                if (strcmp(ie->ent.key, item.key) == 0)
+                        break;
+                ie = SLIST_NEXT(ie, link);
+        }
+
+        if (ie != NULL)
+                return &ie->ent;
+        else if (action == FIND)
+                return NULL;
+
+        ie = malloc(sizeof *ie);
+        if (ie == NULL)
+                return NULL;
+        ie->ent.key = item.key;
+        ie->ent.data = item.data;
+
+        SLIST_INSERT_HEAD(head, ie, link);
+        return &ie->ent;
+}
diff --git a/src/lib/libc/stdlib/heapsort.c b/src/lib/libc/stdlib/heapsort.c
new file mode 100644
index 0000000000..e6fb61ba2f
--- /dev/null
+++ b/src/lib/libc/stdlib/heapsort.c
@@ -0,0 +1,173 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Ronnie Kon at Mindcraft Inc., Kevin Lew and Elmer Yglesias.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/*
+ * Swap two areas of size number of bytes.  Although qsort(3) permits random
+ * blocks of memory to be sorted, sorting pointers is almost certainly the
+ * common case (and, were it not, could easily be made so).  Regardless, it
+ * isn't worth optimizing; the SWAP's get sped up by the cache, and pointer
+ * arithmetic gets lost in the time required for comparison function calls.
+ */
+#define SWAP(a, b, count, size, tmp) { \
+        count = size; \
+        do { \
+                tmp = *a; \
+                *a++ = *b; \
+                *b++ = tmp; \
+        } while (--count); \
+}
+
+/* Copy one block of size size to another. */
+#define COPY(a, b, count, size, tmp1, tmp2) { \
+        count = size; \
+        tmp1 = a; \
+        tmp2 = b; \
+        do { \
+                *tmp1++ = *tmp2++; \
+        } while (--count); \
+}
+
+/*
+ * Build the list into a heap, where a heap is defined such that for
+ * the records K1 ... KN, Kj/2 >= Kj for 1 <= j/2 <= j <= N.
+ *
+ * There are two cases.  If j == nmemb, select largest of Ki and Kj.  If
+ * j < nmemb, select largest of Ki, Kj and Kj+1.
+ */
+#define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp) { \
+        for (par_i = initval; (child_i = par_i * 2) <= nmemb; \
+            par_i = child_i) { \
+                child = base + child_i * size; \
+                if (child_i < nmemb && compar(child, child + size) < 0) { \
+                        child += size; \
+                        ++child_i; \
+                } \
+                par = base + par_i * size; \
+                if (compar(child, par) <= 0) \
+                        break; \
+                SWAP(par, child, count, size, tmp); \
+        } \
+}
+
+/*
+ * Select the top of the heap and 'heapify'.  Since by far the most expensive
+ * action is the call to the compar function, a considerable optimization
+ * in the average case can be achieved due to the fact that k, the displaced
+ * element, is usually quite small, so it would be preferable to first
+ * heapify, always maintaining the invariant that the larger child is copied
+ * over its parent's record.
+ *
+ * Then, starting from the *bottom* of the heap, finding k's correct place,
+ * again maintaining the invariant.  As a result of the invariant no element
+ * is 'lost' when k is assigned its correct place in the heap.
+ *
+ * The time savings from this optimization are on the order of 15-20% for the
+ * average case. See Knuth, Vol. 3, page 158, problem 18.
+ *
+ * XXX Don't break the #define SELECT line, below.  Reiser cpp gets upset.
+ */
+#define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2) { \
+        for (par_i = 1; (child_i = par_i * 2) <= nmemb; par_i = child_i) { \
+                child = base + child_i * size; \
+                if (child_i < nmemb && compar(child, child + size) < 0) { \
+                        child += size; \
+                        ++child_i; \
+                } \
+                par = base + par_i * size; \
+                COPY(par, child, count, size, tmp1, tmp2); \
+        } \
+        for (;;) { \
+                child_i = par_i; \
+                par_i = child_i / 2; \
+                child = base + child_i * size; \
+                par = base + par_i * size; \
+                if (child_i == 1 || compar(k, par) < 0) { \
+                        COPY(child, k, count, size, tmp1, tmp2); \
+                        break; \
+                } \
+                COPY(child, par, count, size, tmp1, tmp2); \
+        } \
+}
+
+/*
+ * Heapsort -- Knuth, Vol. 3, page 145.  Runs in O (N lg N), both average
+ * and worst.  While heapsort is faster than the worst case of quicksort,
+ * the BSD quicksort does median selection so that the chance of finding
+ * a data set that will trigger the worst case is nonexistent.  Heapsort's
+ * only advantage over quicksort is that it requires little additional memory.
+ */
+int
+heapsort(void *vbase, size_t nmemb, size_t size,
+    int (*compar)(const void *, const void *))
+{
+        int cnt, i, j, l;
+        char tmp, *tmp1, *tmp2;
+        char *base, *k, *p, *t;
+
+        if (nmemb <= 1)
+                return (0);
+
+        if (!size) {
+                errno = EINVAL;
+                return (-1);
+        }
+
+        if ((k = malloc(size)) == NULL)
+                return (-1);
+
+        /*
+         * Items are numbered from 1 to nmemb, so offset from size bytes
+         * below the starting address.
+         */
+        base = (char *)vbase - size;
+
+        for (l = nmemb / 2 + 1; --l;)
+                CREATE(l, nmemb, i, j, t, p, size, cnt, tmp);
+
+        /*
+         * For each element of the heap, save the largest element into its
+         * final slot, save the displaced element (k), then recreate the
+         * heap.
+         */
+        while (nmemb > 1) {
+                COPY(k, base + nmemb * size, cnt, size, tmp1, tmp2);
+                COPY(base + nmemb * size, base + size, cnt, size, tmp1, tmp2);
+                --nmemb;
+                SELECT(i, j, nmemb, t, p, size, k, cnt, tmp1, tmp2);
+        }
+        free(k);
+        return (0);
+}
diff --git a/src/lib/libc/stdlib/imaxabs.3 b/src/lib/libc/stdlib/imaxabs.3
new file mode 100644
index 0000000000..5384d0c9a6
--- /dev/null
+++ b/src/lib/libc/stdlib/imaxabs.3
@@ -0,0 +1,66 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: imaxabs.3,v 1.1 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd January 6, 2005
+.Dt IMAXABS 3
+.Os
+.Sh NAME
+.Nm imaxabs
+.Nd integer absolute value function
+.Sh SYNOPSIS
+.Fd #include <inttypes.h>
+.Ft int
+.Fn imaxabs "int j"
+.Sh DESCRIPTION
+The
+.Fn imaxabs
+function computes the absolute value of the intmax_t variable
+.Fa j .
+.Sh RETURN VALUES
+The
+.Fn imaxabs
+function returns the absolute value.
+.Sh SEE ALSO
+.Xr abs 3 ,
+.Xr cabs 3 ,
+.Xr floor 3 ,
+.Xr hypot 3 ,
+.Xr labs 3 ,
+.Xr math 3
+.Sh STANDARDS
+The
+.Fn abs
+function conforms to
+.St -ansiC-99 .
+.Sh BUGS
+The absolute value of the most negative integer remains negative.
diff --git a/src/lib/libc/stdlib/imaxabs.c b/src/lib/libc/stdlib/imaxabs.c
new file mode 100644
index 0000000000..b7e910eefd
--- /dev/null
+++ b/src/lib/libc/stdlib/imaxabs.c
@@ -0,0 +1,38 @@
+/*      $OpenBSD: imaxabs.c,v 1.1 2006/01/13 17:58:09 millert Exp $     */
+
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <inttypes.h>
+
+intmax_t
+imaxabs(intmax_t j)
+{
+        return (j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/imaxdiv.3 b/src/lib/libc/stdlib/imaxdiv.3
new file mode 100644
index 0000000000..63f25d52de
--- /dev/null
+++ b/src/lib/libc/stdlib/imaxdiv.3
@@ -0,0 +1,67 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: imaxdiv.3,v 1.2 2006/01/14 13:04:53 jmc Exp $
+.\"
+.Dd January 3, 2006
+.Dt IMAXDIV 3
+.Os
+.Sh NAME
+.Nm imaxdiv
+.Nd return quotient and remainder from division
+.Sh SYNOPSIS
+.Fd #include <inttypes.h>
+.Ft imaxdiv_t
+.Fn imaxdiv "intmax_t num" "intmax_t denom"
+.Sh DESCRIPTION
+The
+.Fn imaxdiv
+function computes the value
+.Fa num Ns / Ns Fa denom
+and returns the quotient and remainder in a structure named
+.Li imaxdiv_t
+that contains two
+.Li intmax_t
+members named
+.Fa quot
+and
+.Fa rem .
+.Sh SEE ALSO
+.Xr div 3 ,
+.Xr ldiv 3 ,
+.Xr lldiv 3 ,
+.Xr math 3 ,
+.Xr qdiv 3
+.Sh STANDARDS
+The
+.Fn imaxdiv
+function conforms to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/imaxdiv.c b/src/lib/libc/stdlib/imaxdiv.c
new file mode 100644
index 0000000000..0515a94b96
--- /dev/null
+++ b/src/lib/libc/stdlib/imaxdiv.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: imaxdiv.c,v 1.1 2006/01/13 17:58:09 millert Exp $     */
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <inttypes.h>           /* imaxdiv_t */
+
+imaxdiv_t
+imaxdiv(intmax_t num, intmax_t denom)
+{
+        imaxdiv_t r;
+
+        /* see div.c for comments */
+
+        r.quot = num / denom;
+        r.rem = num % denom;
+        if (num >= 0 && r.rem < 0) {
+                r.quot++;
+                r.rem -= denom;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/insque.3 b/src/lib/libc/stdlib/insque.3
new file mode 100644
index 0000000000..fb4f55112d
--- /dev/null
+++ b/src/lib/libc/stdlib/insque.3
@@ -0,0 +1,106 @@
+.\"     $OpenBSD: insque.3,v 1.6 2005/07/26 04:20:23 jaredy Exp $
+.\" Copyright (c) 1993 John Brezak
+.\" 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. The name of the author may 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.
+.\"
+.\"
+.Dd August 12, 1993
+.Dt INSQUE 3
+.Os
+.Sh NAME
+.Nm insque ,
+.Nm remque
+.Nd insert/remove element from a queue
+.Sh SYNOPSIS
+.Fd #include <search.h>
+.Ft void
+.Fn insque "void *elem" "void *pred"
+.Ft void
+.Fn remque "void *elem"
+.Sh DESCRIPTION
+.Bf -symbolic
+These interfaces have been superceded by the
+.Xr queue 3
+macros and are provided for compatibility with legacy code.
+.Ef
+.Pp
+.Fn insque
+and
+.Fn remque
+manipulate queues built from doubly linked lists.
+The queue can be either circular or linear.
+Each element in the queue must be of the following form:
+.Bd -literal -offset indent
+struct qelem {
+        struct qelem   *q_forw;
+        struct qelem   *q_back;
+        char            q_data[];
+};
+.Ed
+.Pp
+The first two elements in the struct must be pointers of the
+same type that point to the previous and next elements in
+the queue respectively.
+Any subsequent data in the struct is application-dependent.
+.Pp
+The
+.Fn insque
+function inserts
+.Fa elem
+into a queue immediately after
+.Fa pred .
+.Pp
+The
+.Fn remque
+function removes
+.Fa elem
+from the queue.
+.Pp
+These functions are not atomic unless that machine architecture allows it.
+.Sh SEE ALSO
+.Xr queue 3
+.Sh STANDARDS
+The
+.Fn insque
+and
+.Fn remque
+functions conform to the
+.St -p1003.1-2001
+and
+.St -xpg4.3
+specifications.
+.Sh HISTORY
+The
+.Fn insque
+and
+.Fn remque
+functions are derived from the
+.Li insque
+and
+.Li remque
+instructions on the
+.Tn VAX .
+They first appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/stdlib/insque.c b/src/lib/libc/stdlib/insque.c
new file mode 100644
index 0000000000..8724efec74
--- /dev/null
+++ b/src/lib/libc/stdlib/insque.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: insque.c,v 1.2 2005/08/08 08:05:36 espie Exp $        */
+
+/*
+ *  Copyright (c) 1993 John Brezak
+ *  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. The name of the author may 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 <search.h>
+
+struct qelem {
+        struct qelem *q_forw;
+        struct qelem *q_back;
+};
+
+void
+insque(void *entry, void *pred)
+{
+        struct qelem *e = (struct qelem *) entry;
+        struct qelem *p = (struct qelem *) pred;
+
+        e->q_forw = p->q_forw;
+        e->q_back = p;
+        p->q_forw->q_back = e;
+        p->q_forw = e;
+}
diff --git a/src/lib/libc/stdlib/jrand48.c b/src/lib/libc/stdlib/jrand48.c
new file mode 100644
index 0000000000..cb8c592750
--- /dev/null
+++ b/src/lib/libc/stdlib/jrand48.c
@@ -0,0 +1,22 @@
+/*      $OpenBSD: jrand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+long
+jrand48(unsigned short xseed[3])
+{
+        __dorand48(xseed);
+        return ((long) xseed[2] << 16) + (long) xseed[1];
+}
diff --git a/src/lib/libc/stdlib/l64a.c b/src/lib/libc/stdlib/l64a.c
new file mode 100644
index 0000000000..4f33df37b2
--- /dev/null
+++ b/src/lib/libc/stdlib/l64a.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: l64a.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+
+char *
+l64a(long value)
+{
+        static char buf[8];
+        char *s = buf;
+        int digit;
+        int i;
+
+        if (value < 0) {
+                errno = EINVAL;
+                return(NULL);
+        }
+
+        for (i = 0; value != 0 && i < 6; i++) {
+                digit = value & 0x3f;
+
+                if (digit < 2) 
+                        *s = digit + '.';
+                else if (digit < 12)
+                        *s = digit + '0' - 2;
+                else if (digit < 38)
+                        *s = digit + 'A' - 12;
+                else
+                        *s = digit + 'a' - 38;
+
+                value >>= 6;
+                s++;
+        }
+
+        *s = '\0';
+
+        return(buf);
+}
diff --git a/src/lib/libc/stdlib/labs.3 b/src/lib/libc/stdlib/labs.3
new file mode 100644
index 0000000000..ab1ccaaf53
--- /dev/null
+++ b/src/lib/libc/stdlib/labs.3
@@ -0,0 +1,69 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: labs.3,v 1.8 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd May 14, 2003
+.Dt LABS 3
+.Os
+.Sh NAME
+.Nm labs, llabs
+.Nd return the absolute value of a long integer
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long
+.Fn labs "long i"
+.Ft long long
+.Fn llabs "long long j"
+.Sh DESCRIPTION
+The
+.Fn labs
+function returns the absolute value of the long integer
+.Fa i .
+The
+.Fn llabs
+function returns the absolute value of the long long integer
+.Fa j .
+.Sh SEE ALSO
+.Xr abs 3 ,
+.Xr cabs 3 ,
+.Xr floor 3 ,
+.Xr imaxabs 3 ,
+.Xr math 3
+.Sh STANDARDS
+The
+.Fn labs
+and
+.Fn llabs
+functions conform to
+.St -ansiC-99 .
+.Sh BUGS
+The absolute value of the most negative integer remains negative.
diff --git a/src/lib/libc/stdlib/labs.c b/src/lib/libc/stdlib/labs.c
new file mode 100644
index 0000000000..ca60b9aba2
--- /dev/null
+++ b/src/lib/libc/stdlib/labs.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: labs.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <stdlib.h>
+
+long
+labs(long j)
+{
+        return(j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/lcong48.c b/src/lib/libc/stdlib/lcong48.c
new file mode 100644
index 0000000000..2cf5c271ba
--- /dev/null
+++ b/src/lib/libc/stdlib/lcong48.c
@@ -0,0 +1,31 @@
+/*      $OpenBSD: lcong48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+extern unsigned short __rand48_mult[3];
+extern unsigned short __rand48_add;
+
+void
+lcong48(unsigned short p[7])
+{
+        __rand48_seed[0] = p[0];
+        __rand48_seed[1] = p[1];
+        __rand48_seed[2] = p[2];
+        __rand48_mult[0] = p[3];
+        __rand48_mult[1] = p[4];
+        __rand48_mult[2] = p[5];
+        __rand48_add = p[6];
+}
diff --git a/src/lib/libc/stdlib/ldiv.3 b/src/lib/libc/stdlib/ldiv.3
new file mode 100644
index 0000000000..951a5807e0
--- /dev/null
+++ b/src/lib/libc/stdlib/ldiv.3
@@ -0,0 +1,67 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: ldiv.3,v 1.8 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt LDIV 3
+.Os
+.Sh NAME
+.Nm ldiv
+.Nd return quotient and remainder from division
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft ldiv_t
+.Fn ldiv "long num" "long denom"
+.Sh DESCRIPTION
+The
+.Fn ldiv
+function computes the value
+.Fa num Ns / Ns Fa denom
+and returns the quotient and remainder in a structure named
+.Li ldiv_t
+that contains two
+.Li long integer
+members named
+.Fa quot
+and
+.Fa rem .
+.Sh SEE ALSO
+.Xr div 3 ,
+.Xr imaxdiv 3 ,
+.Xr lldiv 3 ,
+.Xr math 3 ,
+.Xr qdiv 3
+.Sh STANDARDS
+The
+.Fn ldiv
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/ldiv.c b/src/lib/libc/stdlib/ldiv.c
new file mode 100644
index 0000000000..775065f525
--- /dev/null
+++ b/src/lib/libc/stdlib/ldiv.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: ldiv.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>             /* ldiv_t */
+
+ldiv_t
+ldiv(long num, long denom)
+{
+        ldiv_t r;
+
+        /* see div.c for comments */
+
+        r.quot = num / denom;
+        r.rem = num % denom;
+        if (num >= 0 && r.rem < 0) {
+                r.quot++;
+                r.rem -= denom;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/llabs.c b/src/lib/libc/stdlib/llabs.c
new file mode 100644
index 0000000000..0a0ff784af
--- /dev/null
+++ b/src/lib/libc/stdlib/llabs.c
@@ -0,0 +1,42 @@
+/*      $OpenBSD: llabs.c,v 1.2 2005/08/08 08:05:36 espie Exp $ */
+
+/*-
+ * Copyright (c) 1990 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+
+long long
+llabs(long long j)
+{
+        return (j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/lldiv.3 b/src/lib/libc/stdlib/lldiv.3
new file mode 100644
index 0000000000..53bb3d35ae
--- /dev/null
+++ b/src/lib/libc/stdlib/lldiv.3
@@ -0,0 +1,67 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: lldiv.3,v 1.1 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd January 3, 2006
+.Dt LLDIV 3
+.Os
+.Sh NAME
+.Nm lldiv
+.Nd return quotient and remainder from division
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft lldiv_t
+.Fn lldiv "long long num" "long long denom"
+.Sh DESCRIPTION
+The
+.Fn lldiv
+function computes the value
+.Fa num Ns / Ns Fa denom
+and returns the quotient and remainder in a structure named
+.Li lldiv_t
+that contains two
+.Li long long integer
+members named
+.Fa quot
+and
+.Fa rem .
+.Sh SEE ALSO
+.Xr div 3 ,
+.Xr imaxdiv 3 ,
+.Xr ldiv 3 ,
+.Xr math 3 ,
+.Xr qdiv 3
+.Sh STANDARDS
+The
+.Fn lldiv
+function conforms to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/lldiv.c b/src/lib/libc/stdlib/lldiv.c
new file mode 100644
index 0000000000..e8d6c978b3
--- /dev/null
+++ b/src/lib/libc/stdlib/lldiv.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: lldiv.c,v 1.1 2006/01/13 17:58:09 millert Exp $       */
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>             /* lldiv_t */
+
+lldiv_t
+lldiv(long long num, long long denom)
+{
+        lldiv_t r;
+
+        /* see div.c for comments */
+
+        r.quot = num / denom;
+        r.rem = num % denom;
+        if (num >= 0 && r.rem < 0) {
+                r.quot++;
+                r.rem -= denom;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/lrand48.c b/src/lib/libc/stdlib/lrand48.c
new file mode 100644
index 0000000000..21beb858ca
--- /dev/null
+++ b/src/lib/libc/stdlib/lrand48.c
@@ -0,0 +1,24 @@
+/*      $OpenBSD: lrand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+
+long
+lrand48(void)
+{
+        __dorand48(__rand48_seed);
+        return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1);
+}
diff --git a/src/lib/libc/stdlib/lsearch.3 b/src/lib/libc/stdlib/lsearch.3
new file mode 100644
index 0000000000..eda67ada01
--- /dev/null
+++ b/src/lib/libc/stdlib/lsearch.3
@@ -0,0 +1,108 @@
+.\"     $OpenBSD: lsearch.3,v 1.7 2005/12/23 21:34:16 millert Exp $
+.\"
+.\" Copyright (c) 1989, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)lsearch.3   8.1 (Berkeley) 6/4/93
+.\"
+.Dd June 4, 1993
+.Dt LSEARCH 3
+.Os
+.Sh NAME
+.Nm lsearch ,
+.Nm lfind
+.Nd linear searching routines
+.Sh SYNOPSIS
+.Fd #include <search.h>
+.Ft char *
+.Fn lsearch "const void *key" "const void *base" "size_t *nelp" \
+    "size_t width" "int (*compar)(void *, void *)"
+.Ft char *
+.Fn lfind "const void *key" "const void *base" "size_t *nelp" \
+    "size_t width" "int (*compar)(void *, void *)"
+.Sh DESCRIPTION
+The functions
+.Fn lsearch
+and
+.Fn lfind
+provide basic linear searching functionality.
+.Pp
+.Fa base
+is the pointer to the beginning of an array.
+The argument
+.Fa nelp
+is the current number of elements in the array, where each element
+is
+.Fa width
+bytes long.
+The
+.Fa compar
+function
+is a comparison routine which is used to compare two elements.
+It takes two arguments which point to the
+.Fa key
+object and to an array member, in that order, and must return an integer
+less than, equivalent to, or greater than zero if the
+.Fa key
+object is considered, respectively, to be less than, equal to, or greater
+than the array member.
+.Pp
+The
+.Fn lsearch
+and
+.Fn lfind
+functions
+return a pointer into the array referenced by
+.Fa base
+where
+.Fa key
+is located.
+If
+.Fa key
+does not exist,
+.Fn lfind
+will return a null pointer and
+.Fn lsearch
+will add it to the array.
+When an element is added to the array by
+.Fn lsearch ,
+the location referenced by the argument
+.Fa nelp
+is incremented by one.
+.Sh SEE ALSO
+.Xr bsearch 3 ,
+.Xr db 3
+.Sh STANDARDS
+The
+.Fn lsearch
+and
+.Fn lfind
+functions conform to the
+.St -p1003.1-2001
+and
+.St -xpg4.3
+specifications.
diff --git a/src/lib/libc/stdlib/lsearch.c b/src/lib/libc/stdlib/lsearch.c
new file mode 100644
index 0000000000..0815430199
--- /dev/null
+++ b/src/lib/libc/stdlib/lsearch.c
@@ -0,0 +1,88 @@
+/*      $OpenBSD: lsearch.c,v 1.3 2004/10/01 04:08:45 jsg Exp $ */
+
+/*
+ * Copyright (c) 1989, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Roger L. Snyder.
+ *
+ * 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)lsearch.c   8.1 (Berkeley) 6/4/93";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+#include <search.h>
+
+typedef int (*cmp_fn_t)(const void *, const void *);
+static void *linear_base(const void *, const void *, size_t *, size_t,
+    cmp_fn_t, int);
+
+void *
+lsearch(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar)
+{
+
+        return(linear_base(key, base, nelp, width, compar, 1));
+}
+
+void *
+lfind(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar)
+{
+        return(linear_base(key, base, nelp, width, compar, 0));
+}
+
+static void *
+linear_base(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar, int add_flag)
+{
+        const char *element, *end;
+
+        end = (const char *)base + *nelp * width;
+        for (element = base; element < end; element += width)
+                if (!compar(key, element))              /* key found */
+                        return((void *)element);
+
+        if (!add_flag)                                  /* key not found */
+                return(NULL);
+
+        /*
+         * The UNIX System User's Manual, 1986 edition claims that
+         * a NULL pointer is returned by lsearch with errno set
+         * appropriately, if there is not enough room in the table
+         * to add a new item.  This can't be done as none of these
+         * routines have any method of determining the size of the
+         * table.  This comment isn't in the 1986-87 System V
+         * manual.
+         */
+        ++*nelp;
+        memcpy((void *)end, key, width);
+        return((void *)end);
+}
diff --git a/src/lib/libc/stdlib/malloc.3 b/src/lib/libc/stdlib/malloc.3
new file mode 100644
index 0000000000..e5bb1315df
--- /dev/null
+++ b/src/lib/libc/stdlib/malloc.3
@@ -0,0 +1,466 @@
+.\"
+.\" Copyright (c) 1980, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: malloc.3,v 1.45 2006/06/06 14:49:26 pedro Exp $
+.\"
+.Dd August 27, 1996
+.Dt MALLOC 3
+.Os
+.Sh NAME
+.Nm malloc ,
+.Nm calloc ,
+.Nm realloc ,
+.Nm free ,
+.Nm cfree
+.Nd memory allocation and deallocation
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void *
+.Fn malloc "size_t size"
+.Ft void *
+.Fn calloc "size_t nmemb" "size_t size"
+.Ft void *
+.Fn realloc "void *ptr" "size_t size"
+.Ft void
+.Fn free "void *ptr"
+.Ft void
+.Fn cfree "void *ptr"
+.Ft char *
+.Va malloc_options ;
+.Sh DESCRIPTION
+The
+.Fn malloc
+function allocates uninitialized space for an object whose
+size is specified by
+.Fa size .
+The
+.Fn malloc
+function maintains multiple lists of free blocks according to size, allocating
+space from the appropriate list.
+.Pp
+The allocated space is
+suitably aligned (after possible pointer
+coercion) for storage of any type of object.
+If the space is of
+.Em pagesize
+or larger, the memory returned will be page-aligned.
+.Pp
+Allocation of a zero size object returns a pointer to a zero size object.
+This zero size object is access protected, so any access to it will
+generate an exception (SIGSEGV).
+Many zero-sized objects can be placed consecutively in shared
+protected pages.
+The minimum size of the protection on each object is suitably aligned and
+sized as previously stated, but the protection may extend further depending
+on where in a protected zone the object lands.
+.Pp
+When using
+.Fn malloc
+be careful to avoid the following idiom:
+.Bd -literal -offset indent
+if ((p = malloc(num * size)) == NULL)
+        err(1, "malloc");
+.Ed
+.Pp
+The multiplication may lead to an integer overflow.
+To avoid this,
+.Fn calloc
+is recommended.
+.Pp
+If
+.Fn malloc
+must be used, be sure to test for overflow:
+.Bd -literal -offset indent
+if (num && SIZE_MAX / num < size) {
+        errno = ENOMEM;
+        err(1, "overflow");
+}
+.Ed
+.Pp
+The
+.Fn calloc
+function allocates space for an array of
+.Fa nmemb
+objects, each of whose size is
+.Fa size .
+The space is initialized to all bits zero.
+The use of
+.Fn calloc
+is strongly encouraged when allocating multiple sized objects
+in order to avoid possible integer overflows.
+.Pp
+The
+.Fn free
+function causes the space pointed to by
+.Fa ptr
+to be deallocated, that is, at least made available for further allocation,
+but if possible, it will be passed back to the kernel with
+.Xr sbrk 2 .
+If
+.Fa ptr
+is a null pointer, no action occurs.
+.Pp
+A
+.Fn cfree
+function is also provided for compatibility with old systems and other
+.Nm malloc
+libraries; it is simply an alias for
+.Fn free .
+.Pp
+The
+.Fn realloc
+function changes the size of the object pointed to by
+.Fa ptr
+to
+.Fa size
+bytes and returns a pointer to the (possibly moved) object.
+The contents of the object are unchanged up to the lesser
+of the new and old sizes.
+If the new size is larger, the value of the newly allocated portion
+of the object is indeterminate and uninitialized.
+If
+.Fa ptr
+is a null pointer, the
+.Fn realloc
+function behaves like the
+.Fn malloc
+function for the specified size.
+If the space cannot be allocated, the object
+pointed to by
+.Fa ptr
+is unchanged.
+If
+.Fa size
+is zero and
+.Fa ptr
+is not a null pointer, the object it points to is freed and a new zero size
+object is returned.
+.Pp
+When using
+.Fn realloc
+be careful to avoid the following idiom:
+.Bd -literal -offset indent
+size += 50;
+if ((p = realloc(p, size)) == NULL)
+        return (NULL);
+.Ed
+.Pp
+Do not adjust the variable describing how much memory has been allocated
+until the allocation has been successful.
+This can cause aberrant program behavior if the incorrect size value is used.
+In most cases, the above sample will also result in a leak of memory.
+As stated earlier, a return value of
+.Dv NULL
+indicates that the old object still remains allocated.
+Better code looks like this:
+.Bd -literal -offset indent
+newsize = size + 50;
+if ((newp = realloc(p, newsize)) == NULL) {
+        free(p);
+        p = NULL;
+        size = 0;
+        return (NULL);
+}
+p = newp;
+size = newsize;
+.Ed
+.Pp
+As with
+.Fn malloc
+it is important to ensure the new size value will not overflow;
+i.e. avoid allocations like the following:
+.Bd -literal -offset indent
+if ((newp = realloc(p, num * size)) == NULL) {
+        ...
+.Ed
+.Pp
+Malloc will first look for a symbolic link called
+.Pa /etc/malloc.conf
+and next check the environment for a variable called
+.Ev MALLOC_OPTIONS
+and finally for the global variable
+.Va malloc_options
+and scan them for flags in that order.
+Flags are single letters, uppercase means on, lowercase means off.
+.Bl -tag -width indent
+.It Cm A
+.Dq Abort .
+.Fn malloc
+will coredump the process, rather than tolerate failure.
+This is a very handy debugging aid, since the core file will represent the
+time of failure, rather than when the null pointer was accessed.
+.It Cm D
+.Dq Dump .
+.Fn malloc
+will dump statistics in a file called
+.Pa malloc.out
+at exit.
+This option requires the library to have been compiled with -DMALLOC_STATS in
+order to have any effect.
+.It Cm F
+.Dq Freeguard .
+Enable use after free protection.
+Unused pages on the freelist are read and write protected to
+cause a segmentation fault upon access.
+.It Cm G
+.Dq Guard .
+Enable guard pages and chunk randomization.
+Each page size or larger allocation is followed by a guard page that will
+cause a segmentation fault upon any access.
+Smaller than page size chunks are returned in a random order.
+.It Cm H
+.Dq Hint .
+Pass a hint to the kernel about pages we don't use.
+If the machine is paging a lot this may help a bit.
+.It Cm J
+.Dq Junk .
+Fill some junk into the area allocated.
+Currently junk is bytes of 0xd0; this is pronounced
+.Dq Duh .
+\&:-)
+.It Cm N
+Do not output warning messages when encountering possible corruption
+or bad pointers.
+.It Cm P
+.Dq Pointer Protection .
+Pointer sized allocations are aligned to the end of a page to catch
+sizeof(ptr) errors where sizeof(*ptr) is meant.
+.It Cm R
+.Dq realloc .
+Always reallocate when
+.Fn realloc
+is called, even if the initial allocation was big enough.
+This can substantially aid in compacting memory.
+.\".Pp
+.\".It Cm U
+.\".Dq utrace .
+.\"Generate entries for
+.\".Xr ktrace 1
+.\"for all operations.
+.\"Consult the source for this one.
+.It Cm X
+.Dq xmalloc .
+Rather than return failure,
+.Xr abort 3
+the program with a diagnostic message on stderr.
+It is the intention that this option be set at compile time by
+including in the source:
+.Bd -literal -offset indent
+extern char *malloc_options;
+malloc_options = "X";
+.Ed
+.It Cm Z
+.Dq Zero .
+Fill some junk into the area allocated (see
+.Cm J ) ,
+except for the exact length the user asked for, which is zeroed.
+.It Cm <
+.Dq Half the cache size .
+Decrease the size of the free page cache by a factor of two.
+.It Cm >
+.Dq Double the cache size .
+Increase the size of the free page cache by a factor of two.
+.El
+.Pp
+So to set a systemwide reduction of cache size and coredumps on problems:
+.Li ln -s 'A<' /etc/malloc.conf
+.Pp
+The
+.Cm J
+and
+.Cm Z
+flags are mostly for testing and debugging.
+If a program changes behavior if either of these options are used,
+it is buggy.
+.Pp
+The default number of free pages cached is 16.
+.Sh RETURN VALUES
+The
+.Fn malloc
+and
+.Fn calloc
+functions return a pointer to the allocated space if successful; otherwise,
+a null pointer is returned and
+.Va errno
+is set to
+.Er ENOMEM .
+.Pp
+The
+.Fn free
+and
+.Fn cfree
+functions return no value.
+.Pp
+The
+.Fn realloc
+function returns a pointer to the (possibly moved) allocated space
+if successful; otherwise, a null pointer is returned and
+.Va errno
+is set to
+.Er ENOMEM .
+.Sh ENVIRONMENT
+.Bl -tag -width Ev
+.It Ev MALLOC_OPTIONS
+See above.
+.El
+.Sh FILES
+.Bl -tag -width "/etc/malloc.conf"
+.It Pa /etc/malloc.conf
+symbolic link to filename containing option flags
+.El
+.Sh DIAGNOSTICS
+If
+.Fn malloc ,
+.Fn calloc ,
+.Fn realloc ,
+or
+.Fn free
+detect an error or warning condition,
+a message will be printed to file descriptor
+2 (not using stdio).
+Errors will always result in the process being
+.Xr abort 3 'ed.
+If the
+.Cm A
+option has been specified, warnings will also
+.Xr abort 3
+the process.
+.Pp
+Here is a brief description of the error messages and what they mean:
+.Bl -tag -width Ds
+.It Dq (ES): mumble mumble mumble
+.Fn malloc
+has been compiled with
+.Dv \&-DEXTRA_SANITY
+and something looks fishy in there.
+Consult sources and/or wizards.
+.It Dq allocation failed
+If the
+.Cm A
+option is specified it is an error for
+.Fn malloc ,
+.Fn calloc ,
+or
+.Fn realloc
+to return
+.Dv NULL .
+.It Dq mmap(2) failed, check limits.
+This is a rather weird condition that is most likely to indicate a
+seriously overloaded system or a
+.Xr ulimit 1
+restriction.
+.It Dq freelist is destroyed.
+.Fn malloc Ns 's
+internal freelist has been stomped on.
+.El
+.Pp
+Here is a brief description of the warning messages and what they mean:
+.Bl -tag -width Ds
+.It Dq chunk/page is already free.
+There was an attempt to free a chunk that had already been freed.
+.It Dq junk pointer, too high to make sense.
+The pointer doesn't make sense.
+It's above the area of memory that
+.Fn malloc
+knows something about.
+This could be a pointer from some
+.Xr mmap 2 'ed
+memory.
+.It Dq junk pointer, too low to make sense.
+The pointer doesn't make sense.
+It's below the area of memory that
+.Fn malloc
+knows something about.
+This pointer probably came from your data or bss segments.
+.It Dq malloc() has never been called.
+Nothing has ever been allocated, yet something is being freed or
+realloc'ed.
+.It Dq modified (chunk-/page-) pointer.
+The pointer passed to
+.Fn free
+or
+.Fn realloc
+has been modified.
+.It Dq pointer to wrong page.
+The pointer that
+.Fn malloc
+is trying to free is not pointing to
+a sensible page.
+.It Dq recursive call.
+An attempt was made to call recursively into these functions, i.e., from a
+signal handler.
+This behavior is not supported.
+In particular, signal handlers should
+.Em not
+use any of the
+.Fn malloc
+functions nor utilize any other functions which may call
+.Fn malloc
+(e.g.,
+.Xr stdio 3
+routines).
+.It Dq unknown char in MALLOC_OPTIONS
+We found something we didn't understand.
+.El
+.Sh SEE ALSO
+.Xr brk 2 ,
+.Xr alloca 3 ,
+.Xr getpagesize 3
+.Sh STANDARDS
+The
+.Fn malloc
+function conforms to
+.St -ansiC .
+.Sh HISTORY
+The present implementation of
+.Fn malloc
+started out as a filesystem on a drum
+attached to a 20-bit binary challenged computer built with discrete germanium
+transistors, and it has since graduated to handle primary storage rather than
+secondary.
+.Pp
+The main difference from other
+.Fn malloc
+implementations are believed to be that
+the free pages are not accessed until allocated.
+Most
+.Fn malloc
+implementations will store a data structure containing a,
+possibly double-, linked list in the free chunks of memory, used to tie
+all the free memory together.
+That is a quite suboptimal thing to do.
+Every time the free-list is traversed, all the otherwise unused, and very
+likely paged out, pages get faulted into primary memory, just to see what
+lies after them in the list.
+.Pp
+On systems which are paging, this can increase the page-faults
+of a process by a factor of five.
diff --git a/src/lib/libc/stdlib/malloc.c b/src/lib/libc/stdlib/malloc.c
new file mode 100644
index 0000000000..028eff2b2d
--- /dev/null
+++ b/src/lib/libc/stdlib/malloc.c
@@ -0,0 +1,1870 @@
+/*      $OpenBSD: malloc.c,v 1.83 2006/05/14 19:53:40 otto Exp $        */
+
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ */
+
+/*
+ * Defining MALLOC_EXTRA_SANITY will enable extra checks which are
+ * related to internal conditions and consistency in malloc.c. This has
+ * a noticeable runtime performance hit, and generally will not do you
+ * any good unless you fiddle with the internals of malloc or want
+ * to catch random pointer corruption as early as possible.
+ */
+#ifndef MALLOC_EXTRA_SANITY
+#undef  MALLOC_EXTRA_SANITY
+#endif
+
+/*
+ * Defining MALLOC_STATS will enable you to call malloc_dump() and set
+ * the [dD] options in the MALLOC_OPTIONS environment variable.
+ * It has no run-time performance hit, but does pull in stdio...
+ */
+#ifndef MALLOC_STATS
+#undef  MALLOC_STATS
+#endif
+
+/*
+ * What to use for Junk.  This is the byte value we use to fill with
+ * when the 'J' option is enabled.
+ */
+#define SOME_JUNK       0xd0    /* as in "Duh" :-) */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <errno.h>
+#include <err.h>
+
+#include "thread_private.h"
+
+/*
+ * The basic parameters you can tweak.
+ *
+ * malloc_pageshift     pagesize = 1 << malloc_pageshift
+ *                      It's probably best if this is the native
+ *                      page size, but it shouldn't have to be.
+ *
+ * malloc_minsize       minimum size of an allocation in bytes.
+ *                      If this is too small it's too much work
+ *                      to manage them.  This is also the smallest
+ *                      unit of alignment used for the storage
+ *                      returned by malloc/realloc.
+ *
+ */
+
+#if defined(__sparc__)
+#define malloc_pageshift        13U
+#endif /* __sparc__ */
+
+#ifndef malloc_pageshift
+#define malloc_pageshift        (PGSHIFT)
+#endif
+
+/*
+ * No user serviceable parts behind this point.
+ *
+ * This structure describes a page worth of chunks.
+ */
+struct pginfo {
+        struct pginfo   *next;  /* next on the free list */
+        void            *page;  /* Pointer to the page */
+        u_short         size;   /* size of this page's chunks */
+        u_short         shift;  /* How far to shift for this size chunks */
+        u_short         free;   /* How many free chunks */
+        u_short         total;  /* How many chunk */
+        u_long          bits[1];/* Which chunks are free */
+};
+
+/* How many bits per u_long in the bitmap */
+#define MALLOC_BITS     (NBBY * sizeof(u_long))
+
+/*
+ * This structure describes a number of free pages.
+ */
+struct pgfree {
+        struct pgfree   *next;  /* next run of free pages */
+        struct pgfree   *prev;  /* prev run of free pages */
+        void            *page;  /* pointer to free pages */
+        void            *pdir;  /* pointer to the base page's dir */
+        size_t          size;   /* number of bytes free */
+};
+
+/*
+ * Magic values to put in the page_directory
+ */
+#define MALLOC_NOT_MINE ((struct pginfo*) 0)
+#define MALLOC_FREE     ((struct pginfo*) 1)
+#define MALLOC_FIRST    ((struct pginfo*) 2)
+#define MALLOC_FOLLOW   ((struct pginfo*) 3)
+#define MALLOC_MAGIC    ((struct pginfo*) 4)
+
+#ifndef malloc_minsize
+#define malloc_minsize                  16UL
+#endif
+
+#if !defined(malloc_pagesize)
+#define malloc_pagesize                 (1UL<<malloc_pageshift)
+#endif
+
+#if ((1UL<<malloc_pageshift) != malloc_pagesize)
+#error  "(1UL<<malloc_pageshift) != malloc_pagesize"
+#endif
+
+#ifndef malloc_maxsize
+#define malloc_maxsize                  ((malloc_pagesize)>>1)
+#endif
+
+/* A mask for the offset inside a page. */
+#define malloc_pagemask ((malloc_pagesize)-1)
+
+#define pageround(foo)  (((foo) + (malloc_pagemask)) & ~malloc_pagemask)
+#define ptr2index(foo)  (((u_long)(foo) >> malloc_pageshift)+malloc_pageshift)
+#define index2ptr(idx)  ((void*)(((idx)-malloc_pageshift)<<malloc_pageshift))
+
+/* Set when initialization has been done */
+static unsigned int     malloc_started;
+
+/* Number of free pages we cache */
+static unsigned int     malloc_cache = 16;
+
+/* Structure used for linking discrete directory pages. */
+struct pdinfo {
+        struct pginfo   **base;
+        struct pdinfo   *prev;
+        struct pdinfo   *next;
+        u_long          dirnum;
+};
+static struct pdinfo *last_dir; /* Caches to the last and previous */
+static struct pdinfo *prev_dir; /* referenced directory pages. */
+
+static size_t   pdi_off;
+static u_long   pdi_mod;
+#define PD_IDX(num)     ((num) / (malloc_pagesize/sizeof(struct pginfo *)))
+#define PD_OFF(num)     ((num) & ((malloc_pagesize/sizeof(struct pginfo *))-1))
+#define PI_IDX(index)   ((index) / pdi_mod)
+#define PI_OFF(index)   ((index) % pdi_mod)
+
+/* The last index in the page directory we care about */
+static u_long   last_index;
+
+/* Pointer to page directory. Allocated "as if with" malloc */
+static struct pginfo **page_dir;
+
+/* Free pages line up here */
+static struct pgfree free_list;
+
+/* Abort(), user doesn't handle problems. */
+static int      malloc_abort = 2;
+
+/* Are we trying to die ? */
+static int      suicide;
+
+#ifdef MALLOC_STATS
+/* dump statistics */
+static int      malloc_stats;
+#endif
+
+/* avoid outputting warnings? */
+static int      malloc_silent;
+
+/* always realloc ? */
+static int      malloc_realloc;
+
+/* mprotect free pages PROT_NONE? */
+static int      malloc_freeprot;
+
+/* use guard pages after allocations? */
+static size_t   malloc_guard = 0;
+static size_t   malloc_guarded;
+/* align pointers to end of page? */
+static int      malloc_ptrguard;
+
+static int      malloc_hint;
+
+/* xmalloc behaviour ? */
+static int      malloc_xmalloc;
+
+/* zero fill ? */
+static int      malloc_zero;
+
+/* junk fill ? */
+static int      malloc_junk;
+
+#ifdef __FreeBSD__
+/* utrace ? */
+static int      malloc_utrace;
+
+struct ut {
+        void            *p;
+        size_t          s;
+        void            *r;
+};
+
+void            utrace(struct ut *, int);
+
+#define UTRACE(a, b, c) \
+        if (malloc_utrace) \
+                {struct ut u; u.p=a; u.s = b; u.r=c; utrace(&u, sizeof u);}
+#else                           /* !__FreeBSD__ */
+#define UTRACE(a,b,c)
+#endif
+
+/* Status of malloc. */
+static int      malloc_active;
+
+/* Allocated memory. */
+static size_t   malloc_used;
+
+/* My last break. */
+static caddr_t  malloc_brk;
+
+/* One location cache for free-list holders. */
+static struct pgfree *px;
+
+/* Compile-time options. */
+char            *malloc_options;
+
+/* Name of the current public function. */
+static char     *malloc_func;
+
+#define MMAP(size) \
+        mmap((void *)0, (size), PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, \
+            -1, (off_t)0)
+
+/*
+ * Necessary function declarations.
+ */
+static void     *imalloc(size_t size);
+static void     ifree(void *ptr);
+static void     *irealloc(void *ptr, size_t size);
+static void     *malloc_bytes(size_t size);
+
+/*
+ * Function for page directory lookup.
+ */
+static int
+pdir_lookup(u_long index, struct pdinfo ** pdi)
+{
+        struct pdinfo   *spi;
+        u_long          pidx = PI_IDX(index);
+
+        if (last_dir != NULL && PD_IDX(last_dir->dirnum) == pidx)
+                *pdi = last_dir;
+        else if (prev_dir != NULL && PD_IDX(prev_dir->dirnum) == pidx)
+                *pdi = prev_dir;
+        else if (last_dir != NULL && prev_dir != NULL) {
+                if ((PD_IDX(last_dir->dirnum) > pidx) ?
+                    (PD_IDX(last_dir->dirnum) - pidx) :
+                    (pidx - PD_IDX(last_dir->dirnum))
+                    < (PD_IDX(prev_dir->dirnum) > pidx) ?
+                    (PD_IDX(prev_dir->dirnum) - pidx) :
+                    (pidx - PD_IDX(prev_dir->dirnum)))
+                        *pdi = last_dir;
+                else
+                        *pdi = prev_dir;
+
+                if (PD_IDX((*pdi)->dirnum) > pidx) {
+                        for (spi = (*pdi)->prev;
+                            spi != NULL && PD_IDX(spi->dirnum) > pidx;
+                            spi = spi->prev)
+                                *pdi = spi;
+                        if (spi != NULL)
+                                *pdi = spi;
+                } else
+                        for (spi = (*pdi)->next;
+                            spi != NULL && PD_IDX(spi->dirnum) <= pidx;
+                            spi = spi->next)
+                                *pdi = spi;
+        } else {
+                *pdi = (struct pdinfo *) ((caddr_t) page_dir + pdi_off);
+                for (spi = *pdi;
+                    spi != NULL && PD_IDX(spi->dirnum) <= pidx;
+                    spi = spi->next)
+                        *pdi = spi;
+        }
+
+        return ((PD_IDX((*pdi)->dirnum) == pidx) ? 0 :
+            (PD_IDX((*pdi)->dirnum) > pidx) ? 1 : -1);
+}
+
+#ifdef MALLOC_STATS
+void
+malloc_dump(int fd)
+{
+        char            buf[1024];
+        struct pginfo   **pd;
+        struct pgfree   *pf;
+        struct pdinfo   *pi;
+        u_long          j;
+
+        pd = page_dir;
+        pi = (struct pdinfo *) ((caddr_t) pd + pdi_off);
+
+        /* print out all the pages */
+        for (j = 0; j <= last_index;) {
+                snprintf(buf, sizeof buf, "%08lx %5lu ", j << malloc_pageshift, j);
+                write(fd, buf, strlen(buf));
+                if (pd[PI_OFF(j)] == MALLOC_NOT_MINE) {
+                        for (j++; j <= last_index && pd[PI_OFF(j)] == MALLOC_NOT_MINE;) {
+                                if (!PI_OFF(++j)) {
+                                        if ((pi = pi->next) == NULL ||
+                                            PD_IDX(pi->dirnum) != PI_IDX(j))
+                                                break;
+                                        pd = pi->base;
+                                        j += pdi_mod;
+                                }
+                        }
+                        j--;
+                        snprintf(buf, sizeof buf, ".. %5lu not mine\n", j);
+                        write(fd, buf, strlen(buf));
+                } else if (pd[PI_OFF(j)] == MALLOC_FREE) {
+                        for (j++; j <= last_index && pd[PI_OFF(j)] == MALLOC_FREE;) {
+                                if (!PI_OFF(++j)) {
+                                        if ((pi = pi->next) == NULL ||
+                                            PD_IDX(pi->dirnum) != PI_IDX(j))
+                                                break;
+                                        pd = pi->base;
+                                        j += pdi_mod;
+                                }
+                        }
+                        j--;
+                        snprintf(buf, sizeof buf, ".. %5lu free\n", j);
+                        write(fd, buf, strlen(buf));
+                } else if (pd[PI_OFF(j)] == MALLOC_FIRST) {
+                        for (j++; j <= last_index && pd[PI_OFF(j)] == MALLOC_FOLLOW;) {
+                                if (!PI_OFF(++j)) {
+                                        if ((pi = pi->next) == NULL ||
+                                            PD_IDX(pi->dirnum) != PI_IDX(j))
+                                                break;
+                                        pd = pi->base;
+                                        j += pdi_mod;
+                                }
+                        }
+                        j--;
+                        snprintf(buf, sizeof buf, ".. %5lu in use\n", j);
+                        write(fd, buf, strlen(buf));
+                } else if (pd[PI_OFF(j)] < MALLOC_MAGIC) {
+                        snprintf(buf, sizeof buf, "(%p)\n", pd[PI_OFF(j)]);
+                        write(fd, buf, strlen(buf));
+                } else {
+                        snprintf(buf, sizeof buf, "%p %d (of %d) x %d @ %p --> %p\n",
+                            pd[PI_OFF(j)], pd[PI_OFF(j)]->free,
+                            pd[PI_OFF(j)]->total, pd[PI_OFF(j)]->size,
+                            pd[PI_OFF(j)]->page, pd[PI_OFF(j)]->next);
+                        write(fd, buf, strlen(buf));
+                }
+                if (!PI_OFF(++j)) {
+                        if ((pi = pi->next) == NULL)
+                                break;
+                        pd = pi->base;
+                        j += (1 + PD_IDX(pi->dirnum) - PI_IDX(j)) * pdi_mod;
+                }
+        }
+
+        for (pf = free_list.next; pf; pf = pf->next) {
+                snprintf(buf, sizeof buf, "Free: @%p [%p...%p[ %ld ->%p <-%p\n",
+                    pf, pf->page, (char *)pf->page + pf->size,
+                    pf->size, pf->prev, pf->next);
+                write(fd, buf, strlen(buf));
+                if (pf == pf->next) {
+                        snprintf(buf, sizeof buf, "Free_list loops\n");
+                        write(fd, buf, strlen(buf));
+                        break;
+                }
+        }
+
+        /* print out various info */
+        snprintf(buf, sizeof buf, "Minsize\t%lu\n", malloc_minsize);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof buf, "Maxsize\t%lu\n", malloc_maxsize);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof buf, "Pagesize\t%lu\n", malloc_pagesize);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof buf, "Pageshift\t%u\n", malloc_pageshift);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof buf, "In use\t%lu\n", (u_long) malloc_used);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof buf, "Guarded\t%lu\n", (u_long) malloc_guarded);
+        write(fd, buf, strlen(buf));
+}
+#endif /* MALLOC_STATS */
+
+extern char     *__progname;
+
+static void
+wrterror(char *p)
+{
+        char            *q = " error: ";
+        struct iovec    iov[5];
+
+        iov[0].iov_base = __progname;
+        iov[0].iov_len = strlen(__progname);
+        iov[1].iov_base = malloc_func;
+        iov[1].iov_len = strlen(malloc_func);
+        iov[2].iov_base = q;
+        iov[2].iov_len = strlen(q);
+        iov[3].iov_base = p;
+        iov[3].iov_len = strlen(p);
+        iov[4].iov_base = "\n";
+        iov[4].iov_len = 1;
+        writev(STDERR_FILENO, iov, 5);
+
+        suicide = 1;
+#ifdef MALLOC_STATS
+        if (malloc_stats)
+                malloc_dump(STDERR_FILENO);
+#endif /* MALLOC_STATS */
+        malloc_active--;
+        if (malloc_abort)
+                abort();
+}
+
+static void
+wrtwarning(char *p)
+{
+        char            *q = " warning: ";
+        struct iovec    iov[5];
+
+        if (malloc_abort)
+                wrterror(p);
+        else if (malloc_silent)
+                return;
+
+        iov[0].iov_base = __progname;
+        iov[0].iov_len = strlen(__progname);
+        iov[1].iov_base = malloc_func;
+        iov[1].iov_len = strlen(malloc_func);
+        iov[2].iov_base = q;
+        iov[2].iov_len = strlen(q);
+        iov[3].iov_base = p;
+        iov[3].iov_len = strlen(p);
+        iov[4].iov_base = "\n";
+        iov[4].iov_len = 1;
+        
+        writev(STDERR_FILENO, iov, 5);
+}
+
+#ifdef MALLOC_STATS
+static void
+malloc_exit(void)
+{
+        char    *q = "malloc() warning: Couldn't dump stats\n";
+        int     save_errno = errno, fd;
+
+        fd = open("malloc.out", O_RDWR|O_APPEND);
+        if (fd != -1) {
+                malloc_dump(fd);
+                close(fd);
+        } else
+                write(STDERR_FILENO, q, strlen(q));
+        errno = save_errno;
+}
+#endif /* MALLOC_STATS */
+
+/*
+ * Allocate a number of pages from the OS
+ */
+static void *
+map_pages(size_t pages)
+{
+        struct pdinfo   *pi, *spi;
+        struct pginfo   **pd;
+        u_long          idx, pidx, lidx;
+        caddr_t         result, tail;
+        u_long          index, lindex;
+        void            *pdregion = NULL;
+        size_t          dirs, cnt;
+
+        pages <<= malloc_pageshift;
+        result = MMAP(pages + malloc_guard);
+        if (result == MAP_FAILED) {
+#ifdef MALLOC_EXTRA_SANITY
+                wrtwarning("(ES): map_pages fails");
+#endif /* MALLOC_EXTRA_SANITY */
+                errno = ENOMEM;
+                return (NULL);
+        }
+        index = ptr2index(result);
+        tail = result + pages + malloc_guard;
+        lindex = ptr2index(tail) - 1;
+        if (malloc_guard)
+                mprotect(result + pages, malloc_guard, PROT_NONE);
+
+        pidx = PI_IDX(index);
+        lidx = PI_IDX(lindex);
+
+        if (tail > malloc_brk) {
+                malloc_brk = tail;
+                last_index = lindex;
+        }
+
+        dirs = lidx - pidx;
+
+        /* Insert directory pages, if needed. */
+        if (pdir_lookup(index, &pi) != 0)
+                dirs++;
+
+        if (dirs > 0) {
+                pdregion = MMAP(malloc_pagesize * dirs);
+                if (pdregion == MAP_FAILED) {
+                        munmap(result, tail - result);
+#ifdef MALLOC_EXTRA_SANITY
+                wrtwarning("(ES): map_pages fails");
+#endif
+                        errno = ENOMEM;
+                        return (NULL);
+                }
+        }
+
+        cnt = 0;
+        for (idx = pidx, spi = pi; idx <= lidx; idx++) {
+                if (pi == NULL || PD_IDX(pi->dirnum) != idx) {
+                        pd = (struct pginfo **)((char *)pdregion +
+                            cnt * malloc_pagesize);
+                        cnt++;
+                        memset(pd, 0, malloc_pagesize);
+                        pi = (struct pdinfo *) ((caddr_t) pd + pdi_off);
+                        pi->base = pd;
+                        pi->prev = spi;
+                        pi->next = spi->next;
+                        pi->dirnum = idx * (malloc_pagesize /
+                            sizeof(struct pginfo *));
+
+                        if (spi->next != NULL)
+                                spi->next->prev = pi;
+                        spi->next = pi;
+                }
+                if (idx > pidx && idx < lidx) {
+                        pi->dirnum += pdi_mod;
+                } else if (idx == pidx) {
+                        if (pidx == lidx) {
+                                pi->dirnum += (u_long)(tail - result) >>
+                                    malloc_pageshift;
+                        } else {
+                                pi->dirnum += pdi_mod - PI_OFF(index);
+                        }
+                } else {
+                        pi->dirnum += PI_OFF(ptr2index(tail - 1)) + 1;
+                }
+#ifdef MALLOC_EXTRA_SANITY
+                if (PD_OFF(pi->dirnum) > pdi_mod || PD_IDX(pi->dirnum) > idx) {
+                        wrterror("(ES): pages directory overflow");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+#endif /* MALLOC_EXTRA_SANITY */
+                if (idx == pidx && pi != last_dir) {
+                        prev_dir = last_dir;
+                        last_dir = pi;
+                }
+                spi = pi;
+                pi = spi->next;
+        }
+#ifdef MALLOC_EXTRA_SANITY
+        if (cnt > dirs)
+                wrtwarning("(ES): cnt > dirs");
+#endif /* MALLOC_EXTRA_SANITY */
+        if (cnt < dirs)
+                munmap((char *)pdregion + cnt * malloc_pagesize,
+                    (dirs - cnt) * malloc_pagesize);
+
+        return (result);
+}
+
+/*
+ * Initialize the world
+ */
+static void
+malloc_init(void)
+{
+        char            *p, b[64];
+        int             i, j, save_errno = errno;
+
+        _MALLOC_LOCK_INIT();
+
+#ifdef MALLOC_EXTRA_SANITY
+        malloc_junk = 1;
+#endif /* MALLOC_EXTRA_SANITY */
+
+        for (i = 0; i < 3; i++) {
+                switch (i) {
+                case 0:
+                        j = readlink("/etc/malloc.conf", b, sizeof b - 1);
+                        if (j <= 0)
+                                continue;
+                        b[j] = '\0';
+                        p = b;
+                        break;
+                case 1:
+                        if (issetugid() == 0)
+                                p = getenv("MALLOC_OPTIONS");
+                        else
+                                continue;
+                        break;
+                case 2:
+                        p = malloc_options;
+                        break;
+                default:
+                        p = NULL;
+                }
+
+                for (; p != NULL && *p != '\0'; p++) {
+                        switch (*p) {
+                        case '>':
+                                malloc_cache <<= 1;
+                                break;
+                        case '<':
+                                malloc_cache >>= 1;
+                                break;
+                        case 'a':
+                                malloc_abort = 0;
+                                break;
+                        case 'A':
+                                malloc_abort = 1;
+                                break;
+#ifdef MALLOC_STATS
+                        case 'd':
+                                malloc_stats = 0;
+                                break;
+                        case 'D':
+                                malloc_stats = 1;
+                                break;
+#endif /* MALLOC_STATS */
+                        case 'f':
+                                malloc_freeprot = 0;
+                                break;
+                        case 'F':
+                                malloc_freeprot = 1;
+                                break;
+                        case 'g':
+                                malloc_guard = 0;
+                                break;
+                        case 'G':
+                                malloc_guard = malloc_pagesize;
+                                break;
+                        case 'h':
+                                malloc_hint = 0;
+                                break;
+                        case 'H':
+                                malloc_hint = 1;
+                                break;
+                        case 'j':
+                                malloc_junk = 0;
+                                break;
+                        case 'J':
+                                malloc_junk = 1;
+                                break;
+                        case 'n':
+                                malloc_silent = 0;
+                                break;
+                        case 'N':
+                                malloc_silent = 1;
+                                break;
+                        case 'p':
+                                malloc_ptrguard = 0;
+                                break;
+                        case 'P':
+                                malloc_ptrguard = 1;
+                                break;
+                        case 'r':
+                                malloc_realloc = 0;
+                                break;
+                        case 'R':
+                                malloc_realloc = 1;
+                                break;
+#ifdef __FreeBSD__
+                        case 'u':
+                                malloc_utrace = 0;
+                                break;
+                        case 'U':
+                                malloc_utrace = 1;
+                                break;
+#endif /* __FreeBSD__ */
+                        case 'x':
+                                malloc_xmalloc = 0;
+                                break;
+                        case 'X':
+                                malloc_xmalloc = 1;
+                                break;
+                        case 'z':
+                                malloc_zero = 0;
+                                break;
+                        case 'Z':
+                                malloc_zero = 1;
+                                break;
+                        default:
+                                j = malloc_abort;
+                                malloc_abort = 0;
+                                wrtwarning("unknown char in MALLOC_OPTIONS");
+                                malloc_abort = j;
+                                break;
+                        }
+                }
+        }
+
+        UTRACE(0, 0, 0);
+
+        /*
+         * We want junk in the entire allocation, and zero only in the part
+         * the user asked for.
+         */
+        if (malloc_zero)
+                malloc_junk = 1;
+
+#ifdef MALLOC_STATS
+        if (malloc_stats && (atexit(malloc_exit) == -1))
+                wrtwarning("atexit(2) failed."
+                    "  Will not be able to dump malloc stats on exit");
+#endif /* MALLOC_STATS */
+
+        /* Allocate one page for the page directory. */
+        page_dir = (struct pginfo **)MMAP(malloc_pagesize);
+
+        if (page_dir == MAP_FAILED) {
+                wrterror("mmap(2) failed, check limits");
+                errno = ENOMEM;
+                return;
+        }
+        pdi_off = (malloc_pagesize - sizeof(struct pdinfo)) & ~(malloc_minsize - 1);
+        pdi_mod = pdi_off / sizeof(struct pginfo *);
+
+        last_dir = (struct pdinfo *) ((caddr_t) page_dir + pdi_off);
+        last_dir->base = page_dir;
+        last_dir->prev = last_dir->next = NULL;
+        last_dir->dirnum = malloc_pageshift;
+
+        /* Been here, done that. */
+        malloc_started++;
+
+        /* Recalculate the cache size in bytes, and make sure it's nonzero. */
+        if (!malloc_cache)
+                malloc_cache++;
+        malloc_cache <<= malloc_pageshift;
+        errno = save_errno;
+}
+
+/*
+ * Allocate a number of complete pages
+ */
+static void *
+malloc_pages(size_t size)
+{
+        void            *p, *delay_free = NULL, *tp;
+        int             i;
+        struct pginfo   **pd;
+        struct pdinfo   *pi;
+        u_long          pidx, index;
+        struct pgfree   *pf;
+
+        size = pageround(size) + malloc_guard;
+
+        p = NULL;
+        /* Look for free pages before asking for more */
+        for (pf = free_list.next; pf; pf = pf->next) {
+
+#ifdef MALLOC_EXTRA_SANITY
+                if (pf->size & malloc_pagemask) {
+                        wrterror("(ES): junk length entry on free_list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                if (!pf->size) {
+                        wrterror("(ES): zero length entry on free_list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                if (pf->page > (pf->page + pf->size)) {
+                        wrterror("(ES): sick entry on free_list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                if ((pi = pf->pdir) == NULL) {
+                        wrterror("(ES): invalid page directory on free-list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                if ((pidx = PI_IDX(ptr2index(pf->page))) != PD_IDX(pi->dirnum)) {
+                        wrterror("(ES): directory index mismatch on free-list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                pd = pi->base;
+                if (pd[PI_OFF(ptr2index(pf->page))] != MALLOC_FREE) {
+                        wrterror("(ES): non-free first page on free-list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                pidx = PI_IDX(ptr2index((pf->page) + (pf->size)) - 1);
+                for (pi = pf->pdir; pi != NULL && PD_IDX(pi->dirnum) < pidx;
+                    pi = pi->next)
+                        ;
+                if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                        wrterror("(ES): last page not referenced in page directory");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                pd = pi->base;
+                if (pd[PI_OFF(ptr2index((pf->page) + (pf->size)) - 1)] != MALLOC_FREE) {
+                        wrterror("(ES): non-free last page on free-list");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+#endif /* MALLOC_EXTRA_SANITY */
+
+                if (pf->size < size)
+                        continue;
+
+                if (pf->size == size) {
+                        p = pf->page;
+                        pi = pf->pdir;
+                        if (pf->next != NULL)
+                                pf->next->prev = pf->prev;
+                        pf->prev->next = pf->next;
+                        delay_free = pf;
+                        break;
+                }
+                p = pf->page;
+                pf->page = (char *) pf->page + size;
+                pf->size -= size;
+                pidx = PI_IDX(ptr2index(pf->page));
+                for (pi = pf->pdir; pi != NULL && PD_IDX(pi->dirnum) < pidx;
+                    pi = pi->next)
+                        ;
+                if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                        wrterror("(ES): hole in directories");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+                tp = pf->pdir;
+                pf->pdir = pi;
+                pi = tp;
+                break;
+        }
+
+        size -= malloc_guard;
+
+#ifdef MALLOC_EXTRA_SANITY
+        if (p != NULL && pi != NULL) {
+                pidx = PD_IDX(pi->dirnum);
+                pd = pi->base;
+        }
+        if (p != NULL && pd[PI_OFF(ptr2index(p))] != MALLOC_FREE) {
+                wrterror("(ES): allocated non-free page on free-list");
+                errno = EFAULT;
+                return (NULL);
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+
+        if (p != NULL && (malloc_guard || malloc_freeprot))
+                mprotect(p, size, PROT_READ | PROT_WRITE);
+
+        size >>= malloc_pageshift;
+
+        /* Map new pages */
+        if (p == NULL)
+                p = map_pages(size);
+
+        if (p != NULL) {
+                index = ptr2index(p);
+                pidx = PI_IDX(index);
+                pdir_lookup(index, &pi);
+#ifdef MALLOC_EXTRA_SANITY
+                if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                        wrterror("(ES): mapped pages not found in directory");
+                        errno = EFAULT;
+                        return (NULL);
+                }
+#endif /* MALLOC_EXTRA_SANITY */
+                if (pi != last_dir) {
+                        prev_dir = last_dir;
+                        last_dir = pi;
+                }
+                pd = pi->base;
+                pd[PI_OFF(index)] = MALLOC_FIRST;
+                for (i = 1; i < size; i++) {
+                        if (!PI_OFF(index + i)) {
+                                pidx++;
+                                pi = pi->next;
+#ifdef MALLOC_EXTRA_SANITY
+                                if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                                        wrterror("(ES): hole in mapped pages directory");
+                                        errno = EFAULT;
+                                        return (NULL);
+                                }
+#endif /* MALLOC_EXTRA_SANITY */
+                                pd = pi->base;
+                        }
+                        pd[PI_OFF(index + i)] = MALLOC_FOLLOW;
+                }
+                if (malloc_guard) {
+                        if (!PI_OFF(index + i)) {
+                                pidx++;
+                                pi = pi->next;
+#ifdef MALLOC_EXTRA_SANITY
+                                if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                                        wrterror("(ES): hole in mapped pages directory");
+                                        errno = EFAULT;
+                                        return (NULL);
+                                }
+#endif /* MALLOC_EXTRA_SANITY */
+                                pd = pi->base;
+                        }
+                        pd[PI_OFF(index + i)] = MALLOC_FIRST;
+                }
+                malloc_used += size << malloc_pageshift;
+                malloc_guarded += malloc_guard;
+
+                if (malloc_junk)
+                        memset(p, SOME_JUNK, size << malloc_pageshift);
+        }
+        if (delay_free) {
+                if (px == NULL)
+                        px = delay_free;
+                else
+                        ifree(delay_free);
+        }
+        return (p);
+}
+
+/*
+ * Allocate a page of fragments
+ */
+
+static __inline__ int
+malloc_make_chunks(int bits)
+{
+        struct pginfo   *bp, **pd;
+        struct pdinfo   *pi;
+#ifdef  MALLOC_EXTRA_SANITY
+        u_long          pidx;
+#endif  /* MALLOC_EXTRA_SANITY */
+        void            *pp;
+        long            i, k;
+        size_t          l;
+
+        /* Allocate a new bucket */
+        pp = malloc_pages((size_t) malloc_pagesize);
+        if (pp == NULL)
+                return (0);
+
+        /* Find length of admin structure */
+        l = sizeof *bp - sizeof(u_long);
+        l += sizeof(u_long) *
+            (((malloc_pagesize >> bits) + MALLOC_BITS - 1) / MALLOC_BITS);
+
+        /* Don't waste more than two chunks on this */
+
+        /*
+         * If we are to allocate a memory protected page for the malloc(0)
+         * case (when bits=0), it must be from a different page than the
+         * pginfo page.
+         * --> Treat it like the big chunk alloc, get a second data page.
+         */
+        if (bits != 0 && (1UL << (bits)) <= l + l) {
+                bp = (struct pginfo *) pp;
+        } else {
+                bp = (struct pginfo *) imalloc(l);
+                if (bp == NULL) {
+                        ifree(pp);
+                        return (0);
+                }
+        }
+
+        /* memory protect the page allocated in the malloc(0) case */
+        if (bits == 0) {
+                bp->size = 0;
+                bp->shift = 1;
+                i = malloc_minsize - 1;
+                while (i >>= 1)
+                        bp->shift++;
+                bp->total = bp->free = malloc_pagesize >> bp->shift;
+                bp->page = pp;
+
+                k = mprotect(pp, malloc_pagesize, PROT_NONE);
+                if (k < 0) {
+                        ifree(pp);
+                        ifree(bp);
+                        return (0);
+                }
+        } else {
+                bp->size = (1UL << bits);
+                bp->shift = bits;
+                bp->total = bp->free = malloc_pagesize >> bits;
+                bp->page = pp;
+        }
+
+        /* set all valid bits in the bitmap */
+        k = bp->total;
+        i = 0;
+
+        /* Do a bunch at a time */
+        for (; (k - i) >= MALLOC_BITS; i += MALLOC_BITS)
+                bp->bits[i / MALLOC_BITS] = ~0UL;
+
+        for (; i < k; i++)
+                bp->bits[i / MALLOC_BITS] |= 1UL << (i % MALLOC_BITS);
+
+        k = (long)l;
+        if (bp == bp->page) {
+                /* Mark the ones we stole for ourselves */
+                for (i = 0; k > 0; i++) {
+                        bp->bits[i / MALLOC_BITS] &= ~(1UL << (i % MALLOC_BITS));
+                        bp->free--;
+                        bp->total--;
+                        k -= (1 << bits);
+                }
+        }
+        /* MALLOC_LOCK */
+
+        pdir_lookup(ptr2index(pp), &pi);
+#ifdef MALLOC_EXTRA_SANITY
+        pidx = PI_IDX(ptr2index(pp));
+        if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                wrterror("(ES): mapped pages not found in directory");
+                errno = EFAULT;
+                return (0);
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+        if (pi != last_dir) {
+                prev_dir = last_dir;
+                last_dir = pi;
+        }
+        pd = pi->base;
+        pd[PI_OFF(ptr2index(pp))] = bp;
+
+        bp->next = page_dir[bits];
+        page_dir[bits] = bp;
+
+        /* MALLOC_UNLOCK */
+        return (1);
+}
+
+/*
+ * Allocate a fragment
+ */
+static void *
+malloc_bytes(size_t size)
+{
+        int             i, j;
+        size_t          k;
+        u_long          u, *lp;
+        struct pginfo   *bp;
+
+        /* Don't bother with anything less than this */
+        /* unless we have a malloc(0) requests */
+        if (size != 0 && size < malloc_minsize)
+                size = malloc_minsize;
+
+        /* Find the right bucket */
+        if (size == 0)
+                j = 0;
+        else {
+                j = 1;
+                i = size - 1;
+                while (i >>= 1)
+                        j++;
+        }
+
+        /* If it's empty, make a page more of that size chunks */
+        if (page_dir[j] == NULL && !malloc_make_chunks(j))
+                return (NULL);
+
+        bp = page_dir[j];
+
+        /* Find first word of bitmap which isn't empty */
+        for (lp = bp->bits; !*lp; lp++);
+
+        /* Find that bit, and tweak it */
+        u = 1;
+        k = 0;
+        while (!(*lp & u)) {
+                u += u;
+                k++;
+        }
+
+        if (malloc_guard) {
+                /* Walk to a random position. */
+                i = arc4random() % bp->free;
+                while (i > 0) {
+                        u += u;
+                        k++;
+                        if (k >= MALLOC_BITS) {
+                                lp++;
+                                u = 1;
+                                k = 0;
+                        }
+#ifdef MALLOC_EXTRA_SANITY
+                        if (lp - bp->bits > (bp->total - 1) / MALLOC_BITS) {
+                                wrterror("chunk overflow");
+                                errno = EFAULT;
+                                return (NULL);
+                        }
+#endif /* MALLOC_EXTRA_SANITY */
+                        if (*lp & u)
+                                i--;
+                }
+        }
+        *lp ^= u;
+
+        /* If there are no more free, remove from free-list */
+        if (!--bp->free) {
+                page_dir[j] = bp->next;
+                bp->next = NULL;
+        }
+        /* Adjust to the real offset of that chunk */
+        k += (lp - bp->bits) * MALLOC_BITS;
+        k <<= bp->shift;
+
+        if (malloc_junk && bp->size != 0)
+                memset((char *)bp->page + k, SOME_JUNK, (size_t)bp->size);
+
+        return ((u_char *) bp->page + k);
+}
+
+/*
+ * Magic so that malloc(sizeof(ptr)) is near the end of the page.
+ */
+#define PTR_GAP         (malloc_pagesize - sizeof(void *))
+#define PTR_SIZE        (sizeof(void *))
+#define PTR_ALIGNED(p)  (((unsigned long)p & malloc_pagemask) == PTR_GAP)
+
+/*
+ * Allocate a piece of memory
+ */
+static void *
+imalloc(size_t size)
+{
+        void            *result;
+        int             ptralloc = 0;
+
+        if (!malloc_started)
+                malloc_init();
+
+        if (suicide)
+                abort();
+
+        /* does not matter if malloc_bytes fails */
+        if (px == NULL)
+                px = malloc_bytes(sizeof *px);
+
+        if (malloc_ptrguard && size == PTR_SIZE) {
+                ptralloc = 1;
+                size = malloc_pagesize;
+        }
+        if ((size + malloc_pagesize) < size) {  /* Check for overflow */
+                result = NULL;
+                errno = ENOMEM;
+        } else if (size <= malloc_maxsize)
+                result = malloc_bytes(size);
+        else
+                result = malloc_pages(size);
+
+        if (malloc_abort == 1 && result == NULL)
+                wrterror("allocation failed");
+
+        if (malloc_zero && result != NULL)
+                memset(result, 0, size);
+
+        if (result && ptralloc)
+                return ((char *) result + PTR_GAP);
+        return (result);
+}
+
+/*
+ * Change the size of an allocation.
+ */
+static void *
+irealloc(void *ptr, size_t size)
+{
+        void            *p;
+        size_t          osize;
+        u_long          index, i;
+        struct pginfo   **mp;
+        struct pginfo   **pd;
+        struct pdinfo   *pi;
+#ifdef  MALLOC_EXTRA_SANITY
+        u_long          pidx;
+#endif  /* MALLOC_EXTRA_SANITY */
+
+        if (suicide)
+                abort();
+
+        if (!malloc_started) {
+                wrtwarning("malloc() has never been called");
+                return (NULL);
+        }
+        if (malloc_ptrguard && PTR_ALIGNED(ptr)) {
+                if (size <= PTR_SIZE)
+                        return (ptr);
+
+                p = imalloc(size);
+                if (p)
+                        memcpy(p, ptr, PTR_SIZE);
+                ifree(ptr);
+                return (p);
+        }
+        index = ptr2index(ptr);
+
+        if (index < malloc_pageshift) {
+                wrtwarning("junk pointer, too low to make sense");
+                return (NULL);
+        }
+        if (index > last_index) {
+                wrtwarning("junk pointer, too high to make sense");
+                return (NULL);
+        }
+        pdir_lookup(index, &pi);
+#ifdef MALLOC_EXTRA_SANITY
+        pidx = PI_IDX(index);
+        if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                wrterror("(ES): mapped pages not found in directory");
+                errno = EFAULT;
+                return (NULL);
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+        if (pi != last_dir) {
+                prev_dir = last_dir;
+                last_dir = pi;
+        }
+        pd = pi->base;
+        mp = &pd[PI_OFF(index)];
+
+        if (*mp == MALLOC_FIRST) {      /* Page allocation */
+
+                /* Check the pointer */
+                if ((u_long) ptr & malloc_pagemask) {
+                        wrtwarning("modified (page-) pointer");
+                        return (NULL);
+                }
+                /* Find the size in bytes */
+                i = index;
+                if (!PI_OFF(++i)) {
+                        pi = pi->next;
+                        if (pi != NULL && PD_IDX(pi->dirnum) != PI_IDX(i))
+                                pi = NULL;
+                        if (pi != NULL)
+                                pd = pi->base;
+                }
+                for (osize = malloc_pagesize;
+                    pi != NULL && pd[PI_OFF(i)] == MALLOC_FOLLOW;) {
+                        osize += malloc_pagesize;
+                        if (!PI_OFF(++i)) {
+                                pi = pi->next;
+                                if (pi != NULL && PD_IDX(pi->dirnum) != PI_IDX(i))
+                                        pi = NULL;
+                                if (pi != NULL)
+                                        pd = pi->base;
+                        }
+                }
+
+                if (!malloc_realloc && size <= osize &&
+                    size > osize - malloc_pagesize) {
+                        if (malloc_junk)
+                                memset((char *)ptr + size, SOME_JUNK, osize - size);
+                        return (ptr);   /* ..don't do anything else. */
+                }
+        } else if (*mp >= MALLOC_MAGIC) {       /* Chunk allocation */
+
+                /* Check the pointer for sane values */
+                if ((u_long) ptr & ((1UL << ((*mp)->shift)) - 1)) {
+                        wrtwarning("modified (chunk-) pointer");
+                        return (NULL);
+                }
+                /* Find the chunk index in the page */
+                i = ((u_long) ptr & malloc_pagemask) >> (*mp)->shift;
+
+                /* Verify that it isn't a free chunk already */
+                if ((*mp)->bits[i / MALLOC_BITS] & (1UL << (i % MALLOC_BITS))) {
+                        wrtwarning("chunk is already free");
+                        return (NULL);
+                }
+                osize = (*mp)->size;
+
+                if (!malloc_realloc && size <= osize &&
+                    (size > osize / 2 || osize == malloc_minsize)) {
+                        if (malloc_junk)
+                                memset((char *) ptr + size, SOME_JUNK, osize - size);
+                        return (ptr);   /* ..don't do anything else. */
+                }
+        } else {
+                wrtwarning("irealloc: pointer to wrong page");
+                return (NULL);
+        }
+
+        p = imalloc(size);
+
+        if (p != NULL) {
+                /* copy the lesser of the two sizes, and free the old one */
+                /* Don't move from/to 0 sized region !!! */
+                if (osize != 0 && size != 0) {
+                        if (osize < size)
+                                memcpy(p, ptr, osize);
+                        else
+                                memcpy(p, ptr, size);
+                }
+                ifree(ptr);
+        }
+        return (p);
+}
+
+/*
+ * Free a sequence of pages
+ */
+static __inline__ void
+free_pages(void *ptr, u_long index, struct pginfo * info)
+{
+        u_long          i, pidx, lidx;
+        size_t          l, cachesize = 0;
+        struct pginfo   **pd;
+        struct pdinfo   *pi, *spi;
+        struct pgfree   *pf, *pt = NULL;
+        caddr_t         tail;
+
+        if (info == MALLOC_FREE) {
+                wrtwarning("page is already free");
+                return;
+        }
+        if (info != MALLOC_FIRST) {
+                wrtwarning("free_pages: pointer to wrong page");
+                return;
+        }
+        if ((u_long) ptr & malloc_pagemask) {
+                wrtwarning("modified (page-) pointer");
+                return;
+        }
+        /* Count how many pages and mark them free at the same time */
+        pidx = PI_IDX(index);
+        pdir_lookup(index, &pi);
+#ifdef MALLOC_EXTRA_SANITY
+        if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                wrterror("(ES): mapped pages not found in directory");
+                errno = EFAULT;
+                return;
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+
+        spi = pi;               /* Save page index for start of region. */
+
+        pd = pi->base;
+        pd[PI_OFF(index)] = MALLOC_FREE;
+        i = 1;
+        if (!PI_OFF(index + i)) {
+                pi = pi->next;
+                if (pi == NULL || PD_IDX(pi->dirnum) != PI_IDX(index + i))
+                        pi = NULL;
+                else
+                        pd = pi->base;
+        }
+        while (pi != NULL && pd[PI_OFF(index + i)] == MALLOC_FOLLOW) {
+                pd[PI_OFF(index + i)] = MALLOC_FREE;
+                i++;
+                if (!PI_OFF(index + i)) {
+                        if ((pi = pi->next) == NULL ||
+                            PD_IDX(pi->dirnum) != PI_IDX(index + i))
+                                pi = NULL;
+                        else
+                                pd = pi->base;
+                }
+        }
+
+        l = i << malloc_pageshift;
+
+        if (malloc_junk)
+                memset(ptr, SOME_JUNK, l);
+
+        malloc_used -= l;
+        malloc_guarded -= malloc_guard;
+        if (malloc_guard) {
+#ifdef MALLOC_EXTRA_SANITY
+                if (pi == NULL || PD_IDX(pi->dirnum) != PI_IDX(index + i)) {
+                        wrterror("(ES): hole in mapped pages directory");
+                        errno = EFAULT;
+                        return;
+                }
+#endif /* MALLOC_EXTRA_SANITY */
+                pd[PI_OFF(index + i)] = MALLOC_FREE;
+                l += malloc_guard;
+        }
+        tail = (caddr_t)ptr + l;
+
+        if (malloc_hint)
+                madvise(ptr, l, MADV_FREE);
+
+        if (malloc_freeprot)
+                mprotect(ptr, l, PROT_NONE);
+
+        /* Add to free-list. */
+        if (px == NULL && (px = malloc_bytes(sizeof *px)) == NULL)
+                        goto not_return;
+        px->page = ptr;
+        px->pdir = spi;
+        px->size = l;
+
+        if (free_list.next == NULL) {
+                /* Nothing on free list, put this at head. */
+                px->next = NULL;
+                px->prev = &free_list;
+                free_list.next = px;
+                pf = px;
+                px = NULL;
+        } else {
+                /*
+                 * Find the right spot, leave pf pointing to the modified
+                 * entry.
+                 */
+
+                /* Race ahead here, while calculating cache size. */
+                for (pf = free_list.next;
+                    (caddr_t)ptr > ((caddr_t)pf->page + pf->size)
+                    && pf->next != NULL;
+                    pf = pf->next)
+                        cachesize += pf->size;
+
+                /* Finish cache size calculation. */
+                pt = pf;
+                while (pt) {
+                        cachesize += pt->size;
+                        pt = pt->next;
+                }
+
+                if ((caddr_t)pf->page > tail) {
+                        /* Insert before entry */
+                        px->next = pf;
+                        px->prev = pf->prev;
+                        pf->prev = px;
+                        px->prev->next = px;
+                        pf = px;
+                        px = NULL;
+                } else if (((caddr_t)pf->page + pf->size) == ptr) {
+                        /* Append to the previous entry. */
+                        cachesize -= pf->size;
+                        pf->size += l;
+                        if (pf->next != NULL &&
+                            pf->next->page == ((caddr_t)pf->page + pf->size)) {
+                                /* And collapse the next too. */
+                                pt = pf->next;
+                                pf->size += pt->size;
+                                pf->next = pt->next;
+                                if (pf->next != NULL)
+                                        pf->next->prev = pf;
+                        }
+                } else if (pf->page == tail) {
+                        /* Prepend to entry. */
+                        cachesize -= pf->size;
+                        pf->size += l;
+                        pf->page = ptr;
+                        pf->pdir = spi;
+                } else if (pf->next == NULL) {
+                        /* Append at tail of chain. */
+                        px->next = NULL;
+                        px->prev = pf;
+                        pf->next = px;
+                        pf = px;
+                        px = NULL;
+                } else {
+                        wrterror("freelist is destroyed");
+                        errno = EFAULT;
+                        return;
+                }
+        }
+
+        if (pf->pdir != last_dir) {
+                prev_dir = last_dir;
+                last_dir = pf->pdir;
+        }
+
+        /* Return something to OS ? */
+        if (pf->size > (malloc_cache - cachesize)) {
+
+                /*
+                 * Keep the cache intact.  Notice that the '>' above guarantees that
+                 * the pf will always have at least one page afterwards.
+                 */
+                if (munmap((char *) pf->page + (malloc_cache - cachesize),
+                    pf->size - (malloc_cache - cachesize)) != 0)
+                        goto not_return;
+                tail = (caddr_t)pf->page + pf->size;
+                lidx = ptr2index(tail) - 1;
+                pf->size = malloc_cache - cachesize;
+
+                index = ptr2index((caddr_t)pf->page + pf->size);
+
+                pidx = PI_IDX(index);
+                if (prev_dir != NULL && PD_IDX(prev_dir->dirnum) >= pidx)
+                        prev_dir = NULL;        /* Will be wiped out below ! */
+
+                for (pi = pf->pdir; pi != NULL && PD_IDX(pi->dirnum) < pidx;
+                    pi = pi->next)
+                        ;
+
+                spi = pi;
+                if (pi != NULL && PD_IDX(pi->dirnum) == pidx) {
+                        pd = pi->base;
+
+                        for (i = index; i <= lidx;) {
+                                if (pd[PI_OFF(i)] != MALLOC_NOT_MINE) {
+                                        pd[PI_OFF(i)] = MALLOC_NOT_MINE;
+#ifdef MALLOC_EXTRA_SANITY
+                                        if (!PD_OFF(pi->dirnum)) {
+                                                wrterror("(ES): pages directory underflow");
+                                                errno = EFAULT;
+                                                return;
+                                        }
+#endif /* MALLOC_EXTRA_SANITY */
+                                        pi->dirnum--;
+                                }
+#ifdef MALLOC_EXTRA_SANITY
+                                else
+                                        wrtwarning("(ES): page already unmapped");
+#endif /* MALLOC_EXTRA_SANITY */
+                                i++;
+                                if (!PI_OFF(i)) {
+                                        /*
+                                         * If no page in that dir, free
+                                         * directory page.
+                                         */
+                                        if (!PD_OFF(pi->dirnum)) {
+                                                /* Remove from list. */
+                                                if (spi == pi)
+                                                        spi = pi->prev;
+                                                if (pi->prev != NULL)
+                                                        pi->prev->next = pi->next;
+                                                if (pi->next != NULL)
+                                                        pi->next->prev = pi->prev;
+                                                pi = pi->next;
+                                                munmap(pd, malloc_pagesize);
+                                        } else
+                                                pi = pi->next;
+                                        if (pi == NULL ||
+                                            PD_IDX(pi->dirnum) != PI_IDX(i))
+                                                break;
+                                        pd = pi->base;
+                                }
+                        }
+                        if (pi && !PD_OFF(pi->dirnum)) {
+                                /* Resulting page dir is now empty. */
+                                /* Remove from list. */
+                                if (spi == pi)  /* Update spi only if first. */
+                                        spi = pi->prev;
+                                if (pi->prev != NULL)
+                                        pi->prev->next = pi->next;
+                                if (pi->next != NULL)
+                                        pi->next->prev = pi->prev;
+                                pi = pi->next;
+                                munmap(pd, malloc_pagesize);
+                        }
+                }
+                if (pi == NULL && malloc_brk == tail) {
+                        /* Resize down the malloc upper boundary. */
+                        last_index = index - 1;
+                        malloc_brk = index2ptr(index);
+                }
+
+                /* XXX: We could realloc/shrink the pagedir here I guess. */
+                if (pf->size == 0) {    /* Remove from free-list as well. */
+                        if (px)
+                                ifree(px);
+                        if ((px = pf->prev) != &free_list) {
+                                if (pi == NULL && last_index == (index - 1)) {
+                                        if (spi == NULL) {
+                                                malloc_brk = NULL;
+                                                i = 11;
+                                        } else {
+                                                pd = spi->base;
+                                                if (PD_IDX(spi->dirnum) < pidx)
+                                                        index =
+                                                            ((PD_IDX(spi->dirnum) + 1) *
+                                                            pdi_mod) - 1;
+                                                for (pi = spi, i = index;
+                                                    pd[PI_OFF(i)] == MALLOC_NOT_MINE;
+                                                    i--)
+#ifdef MALLOC_EXTRA_SANITY
+                                                        if (!PI_OFF(i)) {
+                                                                pi = pi->prev;
+                                                                if (pi == NULL || i == 0)
+                                                                        break;
+                                                                pd = pi->base;
+                                                                i = (PD_IDX(pi->dirnum) + 1) * pdi_mod;
+                                                        }
+#else /* !MALLOC_EXTRA_SANITY */
+                                                {
+                                                }
+#endif /* MALLOC_EXTRA_SANITY */
+                                                malloc_brk = index2ptr(i + 1);
+                                        }
+                                        last_index = i;
+                                }
+                                if ((px->next = pf->next) != NULL)
+                                        px->next->prev = px;
+                        } else {
+                                if ((free_list.next = pf->next) != NULL)
+                                        free_list.next->prev = &free_list;
+                        }
+                        px = pf;
+                        last_dir = prev_dir;
+                        prev_dir = NULL;
+                }
+        }
+not_return:
+        if (pt != NULL)
+                ifree(pt);
+}
+
+/*
+ * Free a chunk, and possibly the page it's on, if the page becomes empty.
+ */
+
+/* ARGSUSED */
+static __inline__ void
+free_bytes(void *ptr, u_long index, struct pginfo * info)
+{
+        struct pginfo   **mp, **pd;
+        struct pdinfo   *pi;
+#ifdef  MALLOC_EXTRA_SANITY
+        u_long          pidx;
+#endif  /* MALLOC_EXTRA_SANITY */
+        void            *vp;
+        long            i;
+
+        /* Find the chunk number on the page */
+        i = ((u_long) ptr & malloc_pagemask) >> info->shift;
+
+        if ((u_long) ptr & ((1UL << (info->shift)) - 1)) {
+                wrtwarning("modified (chunk-) pointer");
+                return;
+        }
+        if (info->bits[i / MALLOC_BITS] & (1UL << (i % MALLOC_BITS))) {
+                wrtwarning("chunk is already free");
+                return;
+        }
+        if (malloc_junk && info->size != 0)
+                memset(ptr, SOME_JUNK, (size_t)info->size);
+
+        info->bits[i / MALLOC_BITS] |= 1UL << (i % MALLOC_BITS);
+        info->free++;
+
+        if (info->size != 0)
+                mp = page_dir + info->shift;
+        else
+                mp = page_dir;
+
+        if (info->free == 1) {
+                /* Page became non-full */
+
+                /* Insert in address order */
+                while (*mp != NULL && (*mp)->next != NULL &&
+                    (*mp)->next->page < info->page)
+                        mp = &(*mp)->next;
+                info->next = *mp;
+                *mp = info;
+                return;
+        }
+        if (info->free != info->total)
+                return;
+
+        /* Find & remove this page in the queue */
+        while (*mp != info) {
+                mp = &((*mp)->next);
+#ifdef MALLOC_EXTRA_SANITY
+                if (!*mp) {
+                        wrterror("(ES): Not on queue");
+                        errno = EFAULT;
+                        return;
+                }
+#endif /* MALLOC_EXTRA_SANITY */
+        }
+        *mp = info->next;
+
+        /* Free the page & the info structure if need be */
+        pdir_lookup(ptr2index(info->page), &pi);
+#ifdef MALLOC_EXTRA_SANITY
+        pidx = PI_IDX(ptr2index(info->page));
+        if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                wrterror("(ES): mapped pages not found in directory");
+                errno = EFAULT;
+                return;
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+        if (pi != last_dir) {
+                prev_dir = last_dir;
+                last_dir = pi;
+        }
+        pd = pi->base;
+        pd[PI_OFF(ptr2index(info->page))] = MALLOC_FIRST;
+
+        /* If the page was mprotected, unprotect it before releasing it */
+        if (info->size == 0)
+                mprotect(info->page, malloc_pagesize, PROT_READ | PROT_WRITE);
+
+        vp = info->page;        /* Order is important ! */
+        if (vp != (void *) info)
+                ifree(info);
+        ifree(vp);
+}
+
+static void
+ifree(void *ptr)
+{
+        struct pginfo   *info, **pd;
+        u_long          index;
+#ifdef  MALLOC_EXTRA_SANITY
+        u_long          pidx;
+#endif  /* MALLOC_EXTRA_SANITY */
+        struct pdinfo   *pi;
+
+        if (!malloc_started) {
+                wrtwarning("malloc() has never been called");
+                return;
+        }
+        /* If we're already sinking, don't make matters any worse. */
+        if (suicide)
+                return;
+
+        if (malloc_ptrguard && PTR_ALIGNED(ptr))
+                ptr = (char *) ptr - PTR_GAP;
+
+        index = ptr2index(ptr);
+
+        if (index < malloc_pageshift) {
+                warnx("(%p)", ptr);
+                wrtwarning("ifree: junk pointer, too low to make sense");
+                return;
+        }
+        if (index > last_index) {
+                warnx("(%p)", ptr);
+                wrtwarning("ifree: junk pointer, too high to make sense");
+                return;
+        }
+        pdir_lookup(index, &pi);
+#ifdef MALLOC_EXTRA_SANITY
+        pidx = PI_IDX(index);
+        if (pi == NULL || PD_IDX(pi->dirnum) != pidx) {
+                wrterror("(ES): mapped pages not found in directory");
+                errno = EFAULT;
+                return;
+        }
+#endif /* MALLOC_EXTRA_SANITY */
+        if (pi != last_dir) {
+                prev_dir = last_dir;
+                last_dir = pi;
+        }
+        pd = pi->base;
+        info = pd[PI_OFF(index)];
+
+        if (info < MALLOC_MAGIC)
+                free_pages(ptr, index, info);
+        else
+                free_bytes(ptr, index, info);
+
+        /* does not matter if malloc_bytes fails */
+        if (px == NULL)
+                px = malloc_bytes(sizeof *px);
+
+        return;
+}
+
+/*
+ * Common function for handling recursion.  Only
+ * print the error message once, to avoid making the problem
+ * potentially worse.
+ */
+static void
+malloc_recurse(void)
+{
+        static int      noprint;
+
+        if (noprint == 0) {
+                noprint = 1;
+                wrtwarning("recursive call");
+        }
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        errno = EDEADLK;
+}
+
+/*
+ * These are the public exported interface routines.
+ */
+void *
+malloc(size_t size)
+{
+        void            *r;
+
+        _MALLOC_LOCK();
+        malloc_func = " in malloc():";
+        if (malloc_active++) {
+                malloc_recurse();
+                return (NULL);
+        }
+        r = imalloc(size);
+        UTRACE(0, size, r);
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        if (malloc_xmalloc && r == NULL) {
+                wrterror("out of memory");
+                errno = ENOMEM;
+        }
+        return (r);
+}
+
+void
+free(void *ptr)
+{
+        /* This is legal. XXX quick path */
+        if (ptr == NULL)
+                return;
+
+        _MALLOC_LOCK();
+        malloc_func = " in free():";
+        if (malloc_active++) {
+                malloc_recurse();
+                return;
+        }
+        ifree(ptr);
+        UTRACE(ptr, 0, 0);
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        return;
+}
+
+void *
+realloc(void *ptr, size_t size)
+{
+        void            *r;
+
+        _MALLOC_LOCK();
+        malloc_func = " in realloc():";
+        if (malloc_active++) {
+                malloc_recurse();
+                return (NULL);
+        }
+
+        if (ptr == NULL)
+                r = imalloc(size);
+        else
+                r = irealloc(ptr, size);
+
+        UTRACE(ptr, size, r);
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        if (malloc_xmalloc && r == NULL) {
+                wrterror("out of memory");
+                errno = ENOMEM;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/merge.c b/src/lib/libc/stdlib/merge.c
new file mode 100644
index 0000000000..623f652134
--- /dev/null
+++ b/src/lib/libc/stdlib/merge.c
@@ -0,0 +1,333 @@
+/*      $OpenBSD: merge.c,v 1.8 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Peter McIlroy.
+ *
+ * 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.
+ */
+
+/*
+ * Hybrid exponential search/linear search merge sort with hybrid
+ * natural/pairwise first pass.  Requires about .3% more comparisons
+ * for random data than LSMS with pairwise first pass alone.
+ * It works for objects as small as two bytes.
+ */
+
+#define NATURAL
+#define THRESHOLD 16    /* Best choice for natural merge cut-off. */
+
+/* #define NATURAL to get hybrid natural merge.
+ * (The default is pairwise merging.)
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void setup(u_char *, u_char *, size_t, size_t, int (*)());
+static void insertionsort(u_char *, size_t, size_t, int (*)());
+
+#define ISIZE sizeof(int)
+#define PSIZE sizeof(u_char *)
+#define ICOPY_LIST(src, dst, last)                              \
+        do                                                      \
+        *(int*)dst = *(int*)src, src += ISIZE, dst += ISIZE;    \
+        while(src < last)
+#define ICOPY_ELT(src, dst, i)                                  \
+        do                                                      \
+        *(int*) dst = *(int*) src, src += ISIZE, dst += ISIZE;  \
+        while (i -= ISIZE)
+
+#define CCOPY_LIST(src, dst, last)              \
+        do                                      \
+                *dst++ = *src++;                \
+        while (src < last)
+#define CCOPY_ELT(src, dst, i)                  \
+        do                                      \
+                *dst++ = *src++;                \
+        while (i -= 1)
+                
+/*
+ * Find the next possible pointer head.  (Trickery for forcing an array
+ * to do double duty as a linked list when objects do not align with word
+ * boundaries.
+ */
+/* Assumption: PSIZE is a power of 2. */
+#define EVAL(p) (u_char **)                                             \
+        ((u_char *)0 +                                                  \
+            (((u_char *)p + PSIZE - 1 - (u_char *) 0) & ~(PSIZE - 1)))
+
+/*
+ * Arguments are as for qsort.
+ */
+int
+mergesort(void *base, size_t nmemb, size_t size,
+    int (*cmp)(const void *, const void *))
+{
+        int i, sense;
+        int big, iflag;
+        u_char *f1, *f2, *t, *b, *tp2, *q, *l1, *l2;
+        u_char *list2, *list1, *p2, *p, *last, **p1;
+
+        if (size < PSIZE / 2) {         /* Pointers must fit into 2 * size. */
+                errno = EINVAL;
+                return (-1);
+        }
+
+        /*
+         * XXX
+         * Stupid subtraction for the Cray.
+         */
+        iflag = 0;
+        if (!(size % ISIZE) && !(((char *)base - (char *)0) % ISIZE))
+                iflag = 1;
+
+        if ((list2 = malloc(nmemb * size + PSIZE)) == NULL)
+                return (-1);
+
+        list1 = base;
+        setup(list1, list2, nmemb, size, cmp);
+        last = list2 + nmemb * size;
+        i = big = 0;
+        while (*EVAL(list2) != last) {
+            l2 = list1;
+            p1 = EVAL(list1);
+            for (tp2 = p2 = list2; p2 != last; p1 = EVAL(l2)) {
+                p2 = *EVAL(p2);
+                f1 = l2;
+                f2 = l1 = list1 + (p2 - list2);
+                if (p2 != last)
+                        p2 = *EVAL(p2);
+                l2 = list1 + (p2 - list2);
+                while (f1 < l1 && f2 < l2) {
+                        if ((*cmp)(f1, f2) <= 0) {
+                                q = f2;
+                                b = f1, t = l1;
+                                sense = -1;
+                        } else {
+                                q = f1;
+                                b = f2, t = l2;
+                                sense = 0;
+                        }
+                        if (!big) {     /* here i = 0 */
+                                while ((b += size) < t && cmp(q, b) >sense)
+                                        if (++i == 6) {
+                                                big = 1;
+                                                goto EXPONENTIAL;
+                                        }
+                        } else {
+EXPONENTIAL:                    for (i = size; ; i <<= 1)
+                                        if ((p = (b + i)) >= t) {
+                                                if ((p = t - size) > b &&
+                                                    (*cmp)(q, p) <= sense)
+                                                        t = p;
+                                                else
+                                                        b = p;
+                                                break;
+                                        } else if ((*cmp)(q, p) <= sense) {
+                                                t = p;
+                                                if (i == size)
+                                                        big = 0; 
+                                                goto FASTCASE;
+                                        } else
+                                                b = p;
+                                while (t > b+size) {
+                                        i = (((t - b) / size) >> 1) * size;
+                                        if ((*cmp)(q, p = b + i) <= sense)
+                                                t = p;
+                                        else
+                                                b = p;
+                                }
+                                goto COPY;
+FASTCASE:                       while (i > size)
+                                        if ((*cmp)(q,
+                                                p = b + (i >>= 1)) <= sense)
+                                                t = p;
+                                        else
+                                                b = p;
+COPY:                           b = t;
+                        }
+                        i = size;
+                        if (q == f1) {
+                                if (iflag) {
+                                        ICOPY_LIST(f2, tp2, b);
+                                        ICOPY_ELT(f1, tp2, i);
+                                } else {
+                                        CCOPY_LIST(f2, tp2, b);
+                                        CCOPY_ELT(f1, tp2, i);
+                                }
+                        } else {
+                                if (iflag) {
+                                        ICOPY_LIST(f1, tp2, b);
+                                        ICOPY_ELT(f2, tp2, i);
+                                } else {
+                                        CCOPY_LIST(f1, tp2, b);
+                                        CCOPY_ELT(f2, tp2, i);
+                                }
+                        }
+                }
+                if (f2 < l2) {
+                        if (iflag)
+                                ICOPY_LIST(f2, tp2, l2);
+                        else
+                                CCOPY_LIST(f2, tp2, l2);
+                } else if (f1 < l1) {
+                        if (iflag)
+                                ICOPY_LIST(f1, tp2, l1);
+                        else
+                                CCOPY_LIST(f1, tp2, l1);
+                }
+                *p1 = l2;
+            }
+            tp2 = list1;        /* swap list1, list2 */
+            list1 = list2;
+            list2 = tp2;
+            last = list2 + nmemb*size;
+        }
+        if (base == list2) {
+                memmove(list2, list1, nmemb*size);
+                list2 = list1;
+        }
+        free(list2);
+        return (0);
+}
+
+#define swap(a, b) {                                    \
+                s = b;                                  \
+                i = size;                               \
+                do {                                    \
+                        tmp = *a; *a++ = *s; *s++ = tmp; \
+                } while (--i);                          \
+                a -= size;                              \
+        }
+#define reverse(bot, top) {                             \
+        s = top;                                        \
+        do {                                            \
+                i = size;                               \
+                do {                                    \
+                        tmp = *bot; *bot++ = *s; *s++ = tmp; \
+                } while (--i);                          \
+                s -= size2;                             \
+        } while(bot < s);                               \
+}
+
+/*
+ * Optional hybrid natural/pairwise first pass.  Eats up list1 in runs of
+ * increasing order, list2 in a corresponding linked list.  Checks for runs
+ * when THRESHOLD/2 pairs compare with same sense.  (Only used when NATURAL
+ * is defined.  Otherwise simple pairwise merging is used.)
+ */
+void
+setup(u_char *list1, u_char *list2, size_t n, size_t size,
+    int (*cmp)(const void *, const void *))
+{
+        int i, length, size2, tmp, sense;
+        u_char *f1, *f2, *s, *l2, *last, *p2;
+
+        size2 = size*2;
+        if (n <= 5) {
+                insertionsort(list1, n, size, cmp);
+                *EVAL(list2) = (u_char*) list2 + n*size;
+                return;
+        }
+        /*
+         * Avoid running pointers out of bounds; limit n to evens
+         * for simplicity.
+         */
+        i = 4 + (n & 1);
+        insertionsort(list1 + (n - i) * size, i, size, cmp);
+        last = list1 + size * (n - i);
+        *EVAL(list2 + (last - list1)) = list2 + n * size;
+
+#ifdef NATURAL
+        p2 = list2;
+        f1 = list1;
+        sense = (cmp(f1, f1 + size) > 0);
+        for (; f1 < last; sense = !sense) {
+                length = 2;
+                                        /* Find pairs with same sense. */
+                for (f2 = f1 + size2; f2 < last; f2 += size2) {
+                        if ((cmp(f2, f2+ size) > 0) != sense)
+                                break;
+                        length += 2;
+                }
+                if (length < THRESHOLD) {               /* Pairwise merge */
+                        do {
+                                p2 = *EVAL(p2) = f1 + size2 - list1 + list2;
+                                if (sense > 0)
+                                        swap (f1, f1 + size);
+                        } while ((f1 += size2) < f2);
+                } else {                                /* Natural merge */
+                        l2 = f2;
+                        for (f2 = f1 + size2; f2 < l2; f2 += size2) {
+                                if ((cmp(f2-size, f2) > 0) != sense) {
+                                        p2 = *EVAL(p2) = f2 - list1 + list2;
+                                        if (sense > 0)
+                                                reverse(f1, f2-size);
+                                        f1 = f2;
+                                }
+                        }
+                        if (sense > 0)
+                                reverse (f1, f2-size);
+                        f1 = f2;
+                        if (f2 < last || cmp(f2 - size, f2) > 0)
+                                p2 = *EVAL(p2) = f2 - list1 + list2;
+                        else
+                                p2 = *EVAL(p2) = list2 + n*size;
+                }
+        }
+#else           /* pairwise merge only. */
+        for (f1 = list1, p2 = list2; f1 < last; f1 += size2) {
+                p2 = *EVAL(p2) = p2 + size2;
+                if (cmp (f1, f1 + size) > 0)
+                        swap(f1, f1 + size);
+        }
+#endif /* NATURAL */
+}
+
+/*
+ * This is to avoid out-of-bounds addresses in sorting the
+ * last 4 elements.
+ */
+static void
+insertionsort(u_char *a, size_t n, size_t size,
+    int (*cmp)(const void *, const void *))
+{
+        u_char *ai, *s, *t, *u, tmp;
+        int i;
+
+        for (ai = a+size; --n >= 1; ai += size)
+                for (t = ai; t > a; t -= size) {
+                        u = t - size;
+                        if (cmp(u, t) <= 0)
+                                break;
+                        swap(u, t);
+                }
+}
diff --git a/src/lib/libc/stdlib/mrand48.c b/src/lib/libc/stdlib/mrand48.c
new file mode 100644
index 0000000000..977264aba5
--- /dev/null
+++ b/src/lib/libc/stdlib/mrand48.c
@@ -0,0 +1,24 @@
+/*      $OpenBSD: mrand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+
+long
+mrand48(void)
+{
+        __dorand48(__rand48_seed);
+        return ((long) __rand48_seed[2] << 16) + (long) __rand48_seed[1];
+}
diff --git a/src/lib/libc/stdlib/nrand48.c b/src/lib/libc/stdlib/nrand48.c
new file mode 100644
index 0000000000..f1f548c3af
--- /dev/null
+++ b/src/lib/libc/stdlib/nrand48.c
@@ -0,0 +1,22 @@
+/*      $OpenBSD: nrand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+long
+nrand48(unsigned short xseed[3])
+{
+        __dorand48(xseed);
+        return ((long) xseed[2] << 15) + ((long) xseed[1] >> 1);
+}
diff --git a/src/lib/libc/stdlib/putenv.c b/src/lib/libc/stdlib/putenv.c
new file mode 100644
index 0000000000..54482f6a14
--- /dev/null
+++ b/src/lib/libc/stdlib/putenv.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: putenv.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1988, 1993
+ *     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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+int
+putenv(const char *str)
+{
+        char *p, *equal;
+        int rval;
+
+        if ((p = strdup(str)) == NULL)
+                return (-1);
+        if ((equal = strchr(p, '=')) == NULL) {
+                (void)free(p);
+                return (-1);
+        }
+        *equal = '\0';
+        rval = setenv(p, equal + 1, 1);
+        (void)free(p);
+        return (rval);
+}
diff --git a/src/lib/libc/stdlib/qabs.3 b/src/lib/libc/stdlib/qabs.3
new file mode 100644
index 0000000000..863758e1c7
--- /dev/null
+++ b/src/lib/libc/stdlib/qabs.3
@@ -0,0 +1,57 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: qabs.3,v 1.10 2006/01/15 17:31:06 jmc Exp $
+.\"
+.Dd June 29, 1991
+.Dt QABS 3
+.Os
+.Sh NAME
+.Nm qabs
+.Nd return the absolute value of a quad integer
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft quad_t
+.Fn qabs "quad_t j"
+.Sh DESCRIPTION
+The
+.Fn qabs
+function returns the absolute value of the quad integer
+.Fa j .
+.Sh SEE ALSO
+.Xr abs 3 ,
+.Xr cabs 3 ,
+.Xr floor 3 ,
+.Xr imaxabs 3 ,
+.Xr labs 3 ,
+.Xr math 3
+.Sh BUGS
+The absolute value of the most negative integer remains negative.
diff --git a/src/lib/libc/stdlib/qabs.c b/src/lib/libc/stdlib/qabs.c
new file mode 100644
index 0000000000..656b93c822
--- /dev/null
+++ b/src/lib/libc/stdlib/qabs.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: qabs.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <stdlib.h>
+
+quad_t
+qabs(quad_t j)
+{
+        return(j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/qdiv.3 b/src/lib/libc/stdlib/qdiv.3
new file mode 100644
index 0000000000..643672ea5b
--- /dev/null
+++ b/src/lib/libc/stdlib/qdiv.3
@@ -0,0 +1,62 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: qdiv.3,v 1.7 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt QDIV 3
+.Os
+.Sh NAME
+.Nm qdiv
+.Nd return quotient and remainder from division
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft qdiv_t
+.Fn qdiv "quad_t num" "quad_t denom"
+.Sh DESCRIPTION
+The
+.Fn qdiv
+function computes the value
+.Fa num Ns / Ns Fa denom
+and returns the quotient and remainder in a structure named
+.Li qdiv_t
+that contains two
+.Li quad integer
+members named
+.Fa quot
+and
+.Fa rem .
+.Sh SEE ALSO
+.Xr div 3 ,
+.Xr imaxdiv 3 ,
+.Xr ldiv 3 ,
+.Xr lldiv 3 ,
+.Xr math 3
diff --git a/src/lib/libc/stdlib/qdiv.c b/src/lib/libc/stdlib/qdiv.c
new file mode 100644
index 0000000000..f3db0915ed
--- /dev/null
+++ b/src/lib/libc/stdlib/qdiv.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: qdiv.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>             /* qdiv_t */
+
+qdiv_t
+qdiv(quad_t num, quad_t denom)
+{
+        qdiv_t r;
+
+        /* see div.c for comments */
+
+        r.quot = num / denom;
+        r.rem = num % denom;
+        if (num >= 0 && r.rem < 0) {
+                r.quot++;
+                r.rem -= denom;
+        }
+        return (r);
+}
diff --git a/src/lib/libc/stdlib/qsort.3 b/src/lib/libc/stdlib/qsort.3
new file mode 100644
index 0000000000..668ea90243
--- /dev/null
+++ b/src/lib/libc/stdlib/qsort.3
@@ -0,0 +1,233 @@
+.\" Copyright (c) 1990, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: qsort.3,v 1.14 2003/10/01 08:11:58 jmc Exp $
+.\"
+.Dd June 4, 1993
+.Dt QSORT 3
+.Os
+.Sh NAME
+.Nm qsort ,
+.Nm heapsort ,
+.Nm mergesort
+.Nd sort functions
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void
+.Fn qsort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)"
+.Ft int
+.Fn heapsort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)"
+.Ft int
+.Fn mergesort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)"
+.Sh DESCRIPTION
+The
+.Fn qsort
+function is a modified partition-exchange sort, or quicksort.
+The
+.Fn heapsort
+function is a modified selection sort.
+The
+.Fn mergesort
+function is a modified merge sort with exponential search
+intended for sorting data with pre-existing order.
+.Pp
+The
+.Fn qsort
+and
+.Fn heapsort
+functions sort an array of
+.Fa nmemb
+objects, the initial member of which is pointed to by
+.Fa base .
+The size of each object is specified by
+.Fa size .
+.Fn mergesort
+behaves similarly, but
+.Em requires
+that
+.Fa size
+be greater than
+.Dq "sizeof(void *) / 2" .
+.Pp
+The contents of the array
+.Fa base
+are sorted in ascending order according to
+a comparison function pointed to by
+.Fa compar ,
+which requires two arguments pointing to the objects being
+compared.
+.Pp
+The comparison function must return an integer less than, equal to, or
+greater than zero if the first argument is considered to be respectively
+less than, equal to, or greater than the second.
+.Pp
+The functions
+.Fn qsort
+and
+.Fn heapsort
+are
+.Em not
+stable, that is, if two members compare as equal, their order in
+the sorted array is undefined.
+The function
+.Fn mergesort
+is stable.
+.Pp
+The
+.Fn qsort
+function is an implementation of C.A.R. Hoare's
+.Dq quicksort
+algorithm,
+a variant of partition-exchange sorting; in particular, see D.E. Knuth's
+Algorithm Q.
+.Fn qsort
+takes O N lg N average time.
+This implementation uses median selection to avoid its
+O N**2 worst-case behavior.
+.Pp
+The
+.Fn heapsort
+function is an implementation of J.W.J. William's
+.Dq heapsort
+algorithm,
+a variant of selection sorting; in particular, see D.E. Knuth's Algorithm H.
+.Fn heapsort
+takes O N lg N worst-case time.
+This implementation of
+.Fn heapsort
+is implemented without recursive function calls.
+.Pp
+The function
+.Fn mergesort
+requires additional memory of size
+.Fa nmemb *
+.Fa size
+bytes; it should be used only when space is not at a premium.
+.Fn mergesort
+is optimized for data with pre-existing order; its worst case
+time is O N lg N; its best case is O N.
+.Pp
+Normally,
+.Fn qsort
+is faster than
+.Fn mergesort ,
+which is faster than
+.Fn heapsort .
+Memory availability and pre-existing order in the data can make this untrue.
+.Sh RETURN VALUES
+The
+.Fn qsort
+function returns no value.
+.Pp
+Upon successful completion,
+.Fn heapsort
+and
+.Fn mergesort
+return 0.
+Otherwise, they return \-1 and the global variable
+.Va errno
+is set to indicate the error.
+.Sh ERRORS
+The
+.Fn heapsort
+and
+.Fn mergesort
+functions succeed unless:
+.Bl -tag -width Er
+.It Bq Er EINVAL
+The
+.Fa size
+argument is zero, or the
+.Fa size
+argument to
+.Fn mergesort
+is less than
+.Dq "sizeof(void *) / 2" .
+.It Bq Er ENOMEM
+.Fn heapsort
+or
+.Fn mergesort
+were unable to allocate memory.
+.El
+.Sh SEE ALSO
+.Xr sort 1 ,
+.Xr radixsort 3
+.Rs
+.%A Hoare, C.A.R.
+.%D 1962
+.%T "Quicksort"
+.%J "The Computer Journal"
+.%V 5:1
+.%P pp. 10-15
+.Re
+.Rs
+.%A Williams, J.W.J
+.%D 1964
+.%T "Heapsort"
+.%J "Communications of the ACM"
+.%V 7:1
+.%P pp. 347\-348
+.Re
+.Rs
+.%A Knuth, D.E.
+.%D 1968
+.%B "The Art of Computer Programming"
+.%V Vol. 3
+.%T "Sorting and Searching"
+.%P pp. 114\-123, 145\-149
+.Re
+.Rs
+.%A McIlroy, P.M.
+.%T "Optimistic Sorting and Information Theoretic Complexity"
+.%J "Fourth Annual ACM-SIAM Symposium on Discrete Algorithms"
+.%P pp. 467\-464
+.%D January 1993
+.Re
+.Rs
+.%A Bentley, J.L.
+.%A McIlroy, M.D.
+.%T "Engineering a Sort Function"
+.%J "Software \- Practice and Experience"
+.%V Vol. 23(11)
+.%P pp. 1249\-1265
+.%D November 1993
+.Re
+.Sh STANDARDS
+Previous versions of
+.Fn qsort
+did not permit the comparison routine itself to call
+.Fn qsort .
+This is no longer true.
+.Pp
+The
+.Fn qsort
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/qsort.c b/src/lib/libc/stdlib/qsort.c
new file mode 100644
index 0000000000..bb4a9a11f2
--- /dev/null
+++ b/src/lib/libc/stdlib/qsort.c
@@ -0,0 +1,161 @@
+/*      $OpenBSD: qsort.c,v 1.10 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1992, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+
+static __inline char    *med3(char *, char *, char *, int (*)(const void *, const void *));
+static __inline void     swapfunc(char *, char *, int, int);
+
+#define min(a, b)       (a) < (b) ? a : b
+
+/*
+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
+ */
+#define swapcode(TYPE, parmi, parmj, n) {               \
+        long i = (n) / sizeof (TYPE);                   \
+        TYPE *pi = (TYPE *) (parmi);                    \
+        TYPE *pj = (TYPE *) (parmj);                    \
+        do {                                            \
+                TYPE    t = *pi;                        \
+                *pi++ = *pj;                            \
+                *pj++ = t;                              \
+        } while (--i > 0);                              \
+}
+
+#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
+        es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+
+static __inline void
+swapfunc(char *a, char *b, int n, int swaptype)
+{
+        if (swaptype <= 1) 
+                swapcode(long, a, b, n)
+        else
+                swapcode(char, a, b, n)
+}
+
+#define swap(a, b)                                      \
+        if (swaptype == 0) {                            \
+                long t = *(long *)(a);                  \
+                *(long *)(a) = *(long *)(b);            \
+                *(long *)(b) = t;                       \
+        } else                                          \
+                swapfunc(a, b, es, swaptype)
+
+#define vecswap(a, b, n)        if ((n) > 0) swapfunc(a, b, n, swaptype)
+
+static __inline char *
+med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
+{
+        return cmp(a, b) < 0 ?
+               (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
+              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
+}
+
+void
+qsort(void *aa, size_t n, size_t es, int (*cmp)(const void *, const void *))
+{
+        char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+        int d, r, swaptype, swap_cnt;
+        char *a = aa;
+
+loop:   SWAPINIT(a, es);
+        swap_cnt = 0;
+        if (n < 7) {
+                for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
+                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
+                             pl -= es)
+                                swap(pl, pl - es);
+                return;
+        }
+        pm = (char *)a + (n / 2) * es;
+        if (n > 7) {
+                pl = (char *)a;
+                pn = (char *)a + (n - 1) * es;
+                if (n > 40) {
+                        d = (n / 8) * es;
+                        pl = med3(pl, pl + d, pl + 2 * d, cmp);
+                        pm = med3(pm - d, pm, pm + d, cmp);
+                        pn = med3(pn - 2 * d, pn - d, pn, cmp);
+                }
+                pm = med3(pl, pm, pn, cmp);
+        }
+        swap(a, pm);
+        pa = pb = (char *)a + es;
+
+        pc = pd = (char *)a + (n - 1) * es;
+        for (;;) {
+                while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+                        if (r == 0) {
+                                swap_cnt = 1;
+                                swap(pa, pb);
+                                pa += es;
+                        }
+                        pb += es;
+                }
+                while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+                        if (r == 0) {
+                                swap_cnt = 1;
+                                swap(pc, pd);
+                                pd -= es;
+                        }
+                        pc -= es;
+                }
+                if (pb > pc)
+                        break;
+                swap(pb, pc);
+                swap_cnt = 1;
+                pb += es;
+                pc -= es;
+        }
+        if (swap_cnt == 0) {  /* Switch to insertion sort */
+                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                             pl -= es)
+                                swap(pl, pl - es);
+                return;
+        }
+
+        pn = (char *)a + n * es;
+        r = min(pa - (char *)a, pb - pa);
+        vecswap(a, pb - r, r);
+        r = min(pd - pc, pn - pd - es);
+        vecswap(pb, pn - r, r);
+        if ((r = pb - pa) > es)
+                qsort(a, r / es, es, cmp);
+        if ((r = pd - pc) > es) { 
+                /* Iterate rather than recurse to save stack space */
+                a = pn - r;
+                n = r / es;
+                goto loop;
+        }
+/*              qsort(pn - r, r / es, es, cmp);*/
+}
diff --git a/src/lib/libc/stdlib/radixsort.3 b/src/lib/libc/stdlib/radixsort.3
new file mode 100644
index 0000000000..8a4f71641f
--- /dev/null
+++ b/src/lib/libc/stdlib/radixsort.3
@@ -0,0 +1,155 @@
+.\" Copyright (c) 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     $OpenBSD: radixsort.3,v 1.10 2005/07/26 04:20:23 jaredy Exp $
+.\"
+.Dd January 27, 1994
+.Dt RADIXSORT 3
+.Os
+.Sh NAME
+.Nm radixsort ,
+.Nm sradixsort
+.Nd radix sort
+.Sh SYNOPSIS
+.Fd #include <limits.h>
+.Fd #include <stdlib.h>
+.Ft int
+.Fn radixsort "const u_char **base" "int nmemb" "const u_char *table" "u_int endbyte"
+.Ft int
+.Fn sradixsort "const u_char **base" "int nmemb" "const u_char *table" "u_int endbyte"
+.Sh DESCRIPTION
+The
+.Fn radixsort
+and
+.Fn sradixsort
+functions are implementations of radix sort.
+.Pp
+These functions sort an array of
+.Fa nmemb
+pointers to byte strings.
+The initial member is referenced by
+.Fa base .
+The byte strings may contain any values; the end of each string
+is denoted by the user-specified value
+.Fa endbyte .
+.Pp
+Applications may specify a sort order by providing the
+.Fa table
+argument.
+If non-null,
+.Fa table
+must reference an array of
+.Dv UCHAR_MAX
++ 1 bytes which contains the sort weight of each possible byte value.
+The end-of-string byte must have a sort weight of 0 or 255
+(for sorting in reverse order).
+More than one byte may have the same sort weight.
+The
+.Fa table
+argument is useful for applications which wish to sort different characters
+equally; for example, providing a table with the same weights
+for A\-Z as for a\-z will result in a case-insensitive sort.
+If
+.Fa table
+is
+.Dv NULL ,
+the contents of the array are sorted in ascending order according to the
+.Tn ASCII
+order of the byte strings they reference and
+.Fa endbyte
+has a sorting weight of 0.
+.Pp
+The
+.Fn sradixsort
+function is stable; that is, if two elements compare as equal, their
+order in the sorted array is unchanged.
+The
+.Fn sradixsort
+function uses additional memory sufficient to hold
+.Fa nmemb
+pointers.
+.Pp
+The
+.Fn radixsort
+function is not stable, but uses no additional memory.
+.Pp
+These functions are variants of most-significant-byte radix sorting; in
+particular, see D.E. Knuth's Algorithm R and section 5.2.5, exercise 10.
+They take linear time relative to the number of bytes in the strings.
+.Sh RETURN VALUES
+Upon successful completion 0 is returned.
+Otherwise, \-1 is returned and the global variable
+.Va errno
+is set to indicate the error.
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er EINVAL
+The value of the
+.Fa endbyte
+element of
+.Fa table
+is not 0 or 255.
+.El
+.Pp
+Additionally, the
+.Fn sradixsort
+function may fail and set
+.Va errno
+for any of the errors specified for the library routine
+.Xr malloc 3 .
+.Sh SEE ALSO
+.Xr sort 1 ,
+.Xr qsort 3
+.Rs
+.%A Knuth, D.E.
+.%D 1968
+.%B "The Art of Computer Programming"
+.%T "Sorting and Searching"
+.%V Vol. 3
+.%P pp. 170-178
+.Re
+.Rs
+.%A Paige, R.
+.%D 1987
+.%T "Three Partition Refinement Algorithms"
+.%J "SIAM J. Comput."
+.%V Vol. 16
+.%N No. 6
+.Re
+.Rs
+.%A McIlroy, P.
+.%D 1993
+.%B "Engineering Radix Sort"
+.%T "Computing Systems"
+.%V Vol. 6:1
+.%P pp. 5-27
+.Re
+.Sh HISTORY
+The
+.Fn radixsort
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/stdlib/radixsort.c b/src/lib/libc/stdlib/radixsort.c
new file mode 100644
index 0000000000..0b2ff27044
--- /dev/null
+++ b/src/lib/libc/stdlib/radixsort.c
@@ -0,0 +1,294 @@
+/*      $OpenBSD: radixsort.c,v 1.8 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Peter McIlroy and by Dan Bernstein at New York University, 
+ *
+ * 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.
+ */
+
+/*
+ * Radixsort routines.
+ * 
+ * Program r_sort_a() is unstable but uses O(logN) extra memory for a stack.
+ * Use radixsort(a, n, trace, endchar) for this case.
+ * 
+ * For stable sorting (using N extra pointers) use sradixsort(), which calls
+ * r_sort_b().
+ * 
+ * For a description of this code, see D. McIlroy, P. McIlroy, K. Bostic,
+ * "Engineering Radix Sort".
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <errno.h>
+
+typedef struct {
+        const u_char **sa;
+        int sn, si;
+} stack;
+
+static __inline void simplesort
+(const u_char **, int, int, const u_char *, u_int);
+static void r_sort_a(const u_char **, int, int, const u_char *, u_int);
+static void r_sort_b(const u_char **,
+            const u_char **, int, int, const u_char *, u_int);
+
+#define THRESHOLD       20              /* Divert to simplesort(). */
+#define SIZE            512             /* Default stack size. */
+
+#define SETUP {                                                         \
+        if (tab == NULL) {                                              \
+                tr = tr0;                                               \
+                for (c = 0; c < endch; c++)                             \
+                        tr0[c] = c + 1;                                 \
+                tr0[c] = 0;                                             \
+                for (c++; c < 256; c++)                                 \
+                        tr0[c] = c;                                     \
+                endch = 0;                                              \
+        } else {                                                        \
+                endch = tab[endch];                                     \
+                tr = tab;                                               \
+                if (endch != 0 && endch != 255) {                       \
+                        errno = EINVAL;                                 \
+                        return (-1);                                    \
+                }                                                       \
+        }                                                               \
+}
+
+int
+radixsort(const u_char **a, int n, const u_char *tab, u_int endch)
+{
+        const u_char *tr;
+        int c;
+        u_char tr0[256];
+
+        SETUP;
+        r_sort_a(a, n, 0, tr, endch);
+        return (0);
+}
+
+int
+sradixsort(const u_char **a, int n, const u_char *tab, u_int endch)
+{
+        const u_char *tr, **ta;
+        int c;
+        u_char tr0[256];
+
+        SETUP;
+        if (n < THRESHOLD)
+                simplesort(a, n, 0, tr, endch);
+        else {
+                if ((ta = malloc(n * sizeof(a))) == NULL)
+                        return (-1);
+                r_sort_b(a, ta, n, 0, tr, endch);
+                free(ta);
+        }
+        return (0);
+}
+
+#define empty(s)        (s >= sp)
+#define pop(a, n, i)    a = (--sp)->sa, n = sp->sn, i = sp->si
+#define push(a, n, i)   sp->sa = a, sp->sn = n, (sp++)->si = i
+#define swap(a, b, t)   t = a, a = b, b = t
+
+/* Unstable, in-place sort. */
+void
+r_sort_a(const u_char **a, int n, int i, const u_char *tr, u_int endch)
+{
+        static int count[256], nc, bmin;
+        int c;
+        const u_char **ak, *r;
+        stack s[SIZE], *sp, *sp0, *sp1, temp;
+        int *cp, bigc;
+        const u_char **an, *t, **aj, **top[256];
+
+        /* Set up stack. */
+        sp = s;
+        push(a, n, i);
+        while (!empty(s)) {
+                pop(a, n, i);
+                if (n < THRESHOLD) {
+                        simplesort(a, n, i, tr, endch);
+                        continue;
+                }
+                an = a + n;
+
+                /* Make character histogram. */
+                if (nc == 0) {
+                        bmin = 255;     /* First occupied bin, excluding eos. */
+                        for (ak = a; ak < an;) {
+                                c = tr[(*ak++)[i]];
+                                if (++count[c] == 1 && c != endch) {
+                                        if (c < bmin)
+                                                bmin = c;
+                                        nc++;
+                                }
+                        }
+                        if (sp + nc > s + SIZE) {       /* Get more stack. */
+                                r_sort_a(a, n, i, tr, endch);
+                                continue;
+                        }
+                }
+
+                /*
+                 * Set top[]; push incompletely sorted bins onto stack.
+                 * top[] = pointers to last out-of-place element in bins.
+                 * count[] = counts of elements in bins.
+                 * Before permuting: top[c-1] + count[c] = top[c];
+                 * during deal: top[c] counts down to top[c-1].
+                 */
+                sp0 = sp1 = sp;         /* Stack position of biggest bin. */
+                bigc = 2;               /* Size of biggest bin. */
+                if (endch == 0)         /* Special case: set top[eos]. */
+                        top[0] = ak = a + count[0];
+                else {
+                        ak = a;
+                        top[255] = an;
+                }
+                for (cp = count + bmin; nc > 0; cp++) {
+                        while (*cp == 0)        /* Find next non-empty pile. */
+                                cp++;
+                        if (*cp > 1) {
+                                if (*cp > bigc) {
+                                        bigc = *cp;
+                                        sp1 = sp;
+                                }
+                                push(ak, *cp, i+1);
+                        }
+                        top[cp-count] = ak += *cp;
+                        nc--;
+                }
+                swap(*sp0, *sp1, temp); /* Play it safe -- biggest bin last. */
+
+                /*
+                 * Permute misplacements home.  Already home: everything
+                 * before aj, and in bin[c], items from top[c] on.
+                 * Inner loop:
+                 *      r = next element to put in place;
+                 *      ak = top[r[i]] = location to put the next element.
+                 *      aj = bottom of 1st disordered bin.
+                 * Outer loop:
+                 *      Once the 1st disordered bin is done, ie. aj >= ak,
+                 *      aj<-aj + count[c] connects the bins in a linked list;
+                 *      reset count[c].
+                 */
+                for (aj = a; aj < an;  *aj = r, aj += count[c], count[c] = 0)
+                        for (r = *aj;  aj < (ak = --top[c = tr[r[i]]]);)
+                                swap(*ak, r, t);
+        }
+}
+
+/* Stable sort, requiring additional memory. */
+void
+r_sort_b(const u_char **a, const u_char **ta, int n, int i, const u_char *tr,
+    u_int endch)
+{
+        static int count[256], nc, bmin;
+        int c;
+        const u_char **ak, **ai;
+        stack s[512], *sp, *sp0, *sp1, temp;
+        const u_char **top[256];
+        int *cp, bigc;
+
+        sp = s;
+        push(a, n, i);
+        while (!empty(s)) {
+                pop(a, n, i);
+                if (n < THRESHOLD) {
+                        simplesort(a, n, i, tr, endch);
+                        continue;
+                }
+
+                if (nc == 0) {
+                        bmin = 255;
+                        for (ak = a + n; --ak >= a;) {
+                                c = tr[(*ak)[i]];
+                                if (++count[c] == 1 && c != endch) {
+                                        if (c < bmin)
+                                                bmin = c;
+                                        nc++;
+                                }
+                        }
+                        if (sp + nc > s + SIZE) {
+                                r_sort_b(a, ta, n, i, tr, endch);
+                                continue;
+                        }
+                }
+
+                sp0 = sp1 = sp;
+                bigc = 2;
+                if (endch == 0) {
+                        top[0] = ak = a + count[0];
+                        count[0] = 0;
+                } else {
+                        ak = a;
+                        top[255] = a + n;
+                        count[255] = 0;
+                }
+                for (cp = count + bmin; nc > 0; cp++) {
+                        while (*cp == 0)
+                                cp++;
+                        if ((c = *cp) > 1) {
+                                if (c > bigc) {
+                                        bigc = c;
+                                        sp1 = sp;
+                                }
+                                push(ak, c, i+1);
+                        }
+                        top[cp-count] = ak += c;
+                        *cp = 0;                        /* Reset count[]. */
+                        nc--;
+                }
+                swap(*sp0, *sp1, temp);
+
+                for (ak = ta + n, ai = a+n; ak > ta;)   /* Copy to temp. */
+                        *--ak = *--ai;
+                for (ak = ta+n; --ak >= ta;)            /* Deal to piles. */
+                        *--top[tr[(*ak)[i]]] = *ak;
+        }
+}
+                
+static __inline void
+simplesort(const u_char **a, int n, int b, const u_char *tr, u_int endch)
+    /* insertion sort */
+{
+        u_char ch;
+        const u_char  **ak, **ai, *s, *t;
+
+        for (ak = a+1; --n >= 1; ak++)
+                for (ai = ak; ai > a; ai--) {
+                        for (s = ai[0] + b, t = ai[-1] + b;
+                            (ch = tr[*s]) != endch; s++, t++)
+                                if (ch != tr[*t])
+                                        break;
+                        if (ch >= tr[*t])
+                                break;
+                        swap(ai[0], ai[-1], s);
+                }
+}
diff --git a/src/lib/libc/stdlib/rand.3 b/src/lib/libc/stdlib/rand.3
new file mode 100644
index 0000000000..0d9c52a3b9
--- /dev/null
+++ b/src/lib/libc/stdlib/rand.3
@@ -0,0 +1,98 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: rand.3,v 1.9 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt RAND 3
+.Os
+.Sh NAME
+.Nm rand ,
+.Nm srand
+.Nd bad random number generator
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft void
+.Fn srand "unsigned int seed"
+.Ft int
+.Fn rand void
+.Ft int
+.Fn rand_r "unsigned int *seed"
+.Sh DESCRIPTION
+.Bf -symbolic
+These interfaces are obsoleted by
+.Xr random 3 .
+.Ef
+.Pp
+The
+.Fn rand
+function computes a sequence of pseudo-random integers in the range
+of 0 to
+.Dv RAND_MAX
+(as defined by the header file
+.Aq Pa stdlib.h ) .
+.Pp
+The
+.Fn srand
+function sets its argument as the seed for a new sequence of
+pseudo-random numbers to be returned by
+.Fn rand .
+These sequences are repeatable by calling
+.Fn srand
+with the same seed value.
+.Pp
+If no seed value is provided, the functions are automatically
+seeded with a value of 1.
+.Pp
+The
+.Fn rand_r
+is a thread-safe version of
+.Fn rand .
+Storage for the seed must be provided through the
+.Fa seed
+argument, and needs to have been initialized by the caller.
+.Sh SEE ALSO
+.Xr arc4random 3 ,
+.Xr rand48 3 ,
+.Xr random 3
+.Sh STANDARDS
+The
+.Fn rand
+and
+.Fn srand
+functions conform to
+.St -ansiC .
+.Pp
+The
+.Fn rand_r
+function conforms to ISO/IEC 9945-1 ANSI/IEEE
+.Pq Dq Tn POSIX
+Std 1003.1c Draft 10.
diff --git a/src/lib/libc/stdlib/rand.c b/src/lib/libc/stdlib/rand.c
new file mode 100644
index 0000000000..0f9c100807
--- /dev/null
+++ b/src/lib/libc/stdlib/rand.c
@@ -0,0 +1,52 @@
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+
+static u_int next = 1;
+
+int
+rand_r(u_int *seed)
+{
+        *seed = *seed * 1103515245 + 12345;
+        return (*seed % ((u_int)RAND_MAX + 1));
+}
+
+int
+rand(void)
+{
+        return (rand_r(&next));
+}
+
+void
+srand(u_int seed)
+{
+        next = seed;
+}
diff --git a/src/lib/libc/stdlib/rand48.3 b/src/lib/libc/stdlib/rand48.3
new file mode 100644
index 0000000000..78cd0a7cd5
--- /dev/null
+++ b/src/lib/libc/stdlib/rand48.3
@@ -0,0 +1,165 @@
+.\" Copyright (c) 1993 Martin Birgmeier
+.\" All rights reserved.
+.\"
+.\" You may redistribute unmodified or modified versions of this source
+.\" code provided that the above copyright notice and this and the
+.\" following conditions are retained.
+.\"
+.\" This software is provided ``as is'', and comes with no warranties
+.\" of any kind. I shall in no event be liable for anything that happens
+.\" to anyone/anything when using this software.
+.\"
+.\"     $OpenBSD: rand48.3,v 1.10 2003/06/01 19:27:27 jmc Exp $
+.\"
+.Dd October 8, 1993
+.Dt RAND48 3
+.Os
+.Sh NAME
+.Nm drand48 ,
+.Nm erand48 ,
+.Nm lrand48 ,
+.Nm nrand48 ,
+.Nm mrand48 ,
+.Nm jrand48 ,
+.Nm srand48 ,
+.Nm seed48 ,
+.Nm lcong48
+.Nd pseudo-random number generators and initialization routines
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft double
+.Fn drand48 void
+.Ft double
+.Fn erand48 "unsigned short xseed[3]"
+.Ft long
+.Fn lrand48 void
+.Ft long
+.Fn nrand48 "unsigned short xseed[3]"
+.Ft long
+.Fn mrand48 void
+.Ft long
+.Fn jrand48 "unsigned short xseed[3]"
+.Ft void
+.Fn srand48 "long seed"
+.Ft "unsigned short *"
+.Fn seed48 "unsigned short xseed[3]"
+.Ft void
+.Fn lcong48 "unsigned short p[7]"
+.Sh DESCRIPTION
+The
+.Fn rand48
+family of functions generates pseudo-random numbers using a linear
+congruential algorithm working on integers 48 bits in size.
+The particular formula employed is
+r(n+1) = (a * r(n) + c) mod m
+where the default values are
+for the multiplicand a = 0xfdeece66d = 25214903917 and
+the addend c = 0xb = 11.
+The modulus is always fixed at m = 2 ** 48.
+r(n) is called the seed of the random number generator.
+.Pp
+For all the six generator routines described next, the first
+computational step is to perform a single iteration of the algorithm.
+.Pp
+.Fn drand48
+and
+.Fn erand48
+return values of type double.
+The full 48 bits of r(n+1) are
+loaded into the mantissa of the returned value, with the exponent set
+such that the values produced lie in the interval [0.0, 1.0].
+.Pp
+.Fn lrand48
+and
+.Fn nrand48
+return values of type long in the range
+[0, 2**31-1].
+The high-order (31) bits of
+r(n+1) are loaded into the lower bits of the returned value, with
+the topmost (sign) bit set to zero.
+.Pp
+.Fn mrand48
+and
+.Fn jrand48
+return values of type long in the range
+[-2**31, 2**31-1].
+The high-order (32) bits of r(n+1) are loaded into the returned value.
+.Pp
+.Fn drand48 ,
+.Fn lrand48 ,
+and
+.Fn mrand48
+use an internal buffer to store r(n).
+For these functions
+the initial value of r(0) = 0x1234abcd330e = 20017429951246.
+.Pp
+On the other hand,
+.Fn erand48 ,
+.Fn nrand48 ,
+and
+.Fn jrand48
+use a user-supplied buffer to store the seed r(n),
+which consists of an array of 3 shorts, where the zeroth member
+holds the least significant bits.
+.Pp
+All functions share the same multiplicand and addend.
+.Pp
+.Fn srand48
+is used to initialize the internal buffer r(n) of
+.Fn drand48 ,
+.Fn lrand48 ,
+and
+.Fn mrand48
+such that the 32 bits of the seed value are copied into the upper 32 bits
+of r(n), with the lower 16 bits of r(n) arbitrarily being set to 0x330e.
+Additionally, the constant multiplicand and addend of the algorithm are
+reset to the default values given above.
+.Pp
+.Fn seed48
+also initializes the internal buffer r(n) of
+.Fn drand48 ,
+.Fn lrand48 ,
+and
+.Fn mrand48 ,
+but here all 48 bits of the seed can be specified in an array of 3 shorts,
+where the zeroth member specifies the lowest bits.
+Again, the constant multiplicand and addend of the algorithm are
+reset to the default values given above.
+.Fn seed48
+returns a pointer to an array of 3 shorts which contains the old seed.
+This array is statically allocated, so its contents are lost after
+each new call to
+.Fn seed48 .
+.Pp
+Finally,
+.Fn lcong48
+allows full control over the multiplicand and addend used in
+.Fn drand48 ,
+.Fn erand48 ,
+.Fn lrand48 ,
+.Fn nrand48 ,
+.Fn mrand48 ,
+and
+.Fn jrand48 ,
+and the seed used in
+.Fn drand48 ,
+.Fn lrand48 ,
+and
+.Fn mrand48 .
+An array of 7 shorts is passed as parameter; the first three shorts are
+used to initialize the seed; the second three are used to initialize the
+multiplicand; and the last short is used to initialize the addend.
+It is thus not possible to use values greater than 0xffff as the addend.
+.Pp
+Note that all three methods of seeding the random number generator
+always also set the multiplicand and addend for any of the six
+generator calls.
+.Pp
+For a more powerful random number generator, see
+.Xr random 3 .
+.Sh SEE ALSO
+.Xr arc4random 3 ,
+.Xr rand 3 ,
+.Xr random 3
+.Sh AUTHORS
+Martin Birgmeier
diff --git a/src/lib/libc/stdlib/rand48.h b/src/lib/libc/stdlib/rand48.h
new file mode 100644
index 0000000000..afa49f65f3
--- /dev/null
+++ b/src/lib/libc/stdlib/rand48.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ *
+ *      $OpenBSD: rand48.h,v 1.3 2002/02/16 21:27:24 millert Exp $
+ */
+
+#ifndef _RAND48_H_
+#define _RAND48_H_
+
+#include <math.h>
+#include <stdlib.h>
+
+void            __dorand48(unsigned short[3]);
+
+#define RAND48_SEED_0   (0x330e)
+#define RAND48_SEED_1   (0xabcd)
+#define RAND48_SEED_2   (0x1234)
+#define RAND48_MULT_0   (0xe66d)
+#define RAND48_MULT_1   (0xdeec)
+#define RAND48_MULT_2   (0x0005)
+#define RAND48_ADD      (0x000b)
+
+#endif /* _RAND48_H_ */
diff --git a/src/lib/libc/stdlib/random.3 b/src/lib/libc/stdlib/random.3
new file mode 100644
index 0000000000..626b040b50
--- /dev/null
+++ b/src/lib/libc/stdlib/random.3
@@ -0,0 +1,185 @@
+.\" Copyright (c) 1983, 1991 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.
+.\"
+.\"     $OpenBSD: random.3,v 1.18 2005/11/30 07:51:02 otto Exp $
+.\"
+.Dd April 19, 1991
+.Dt RANDOM 3
+.Os
+.Sh NAME
+.Nm random ,
+.Nm srandom ,
+.Nm srandomdev ,
+.Nm initstate ,
+.Nm setstate
+.Nd better random number generator; routines for changing generators
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long
+.Fn random void
+.Ft void
+.Fn srandom "unsigned int seed"
+.Ft void
+.Fn srandomdev void
+.Ft char *
+.Fn initstate "unsigned int seed" "char *state" "size_t n"
+.Ft char *
+.Fn setstate "const char *state"
+.Sh DESCRIPTION
+The
+.Fn random
+function uses a non-linear additive feedback random number generator employing
+a default table of size 31 long integers to return successive pseudo-random
+numbers in the range from 0 to (2**31)\-1.
+The period of this random number generator is very large, approximately
+16*((2**31)\-1).
+.Pp
+The
+.Fn random
+and
+.Fn srandom
+functions have (almost) the same calling sequence and initialization
+properties as
+.Xr rand 3 Ns / Ns Xr srand 3 .
+The difference is that
+.Xr rand
+produces a much less random sequence \(em in fact, the low dozen bits
+generated by rand go through a cyclic pattern.
+All the bits generated by
+.Fn random
+are usable.
+For example,
+.Sq Li random()&01
+will produce a random binary
+value.
+.Pp
+Like
+.Xr rand 3 ,
+.Fn random
+will by default produce a sequence of numbers that can be duplicated
+by calling
+.Fn srandom
+with
+.Ql 1
+as the seed.
+.Pp
+The
+.Fn srandomdev
+routine initializes a state array using
+random numbers obtained from the kernel,
+suitable for cryptographic use.
+Note that this particular seeding procedure can generate
+states which are impossible to reproduce by calling
+.Fn srandom
+with any value, since the succeeding terms in the
+state buffer are no longer derived from the LC algorithm applied to
+a fixed seed.
+.Pp
+The
+.Fn initstate
+routine allows a state array, passed in as an argument, to be initialized
+for future use.
+The size of the state array (in bytes) is used by
+.Fn initstate
+to decide how sophisticated a random number generator it should use \(em the
+more state, the better the random numbers will be.
+(Current "optimal" values for the amount of state information are
+8, 32, 64, 128, and 256 bytes; other amounts will be rounded down to
+the nearest known amount.
+Using less than 8 bytes will cause an error.)
+The seed for the initialization (which specifies a starting point for
+the random number sequence, and provides for restarting at the same
+point) is also an argument.
+The
+.Fn initstate
+function returns a pointer to the previous state information array.
+.Pp
+Once a state has been initialized, the
+.Fn setstate
+routine provides for rapid switching between states.
+The
+.Fn setstate
+function returns a pointer to the previous state array; its
+argument state array is used for further random number generation
+until the next call to
+.Fn initstate
+or
+.Fn setstate .
+.Pp
+Once a state array has been initialized, it may be restarted at a
+different point either by calling
+.Fn initstate
+(with the desired seed, the state array, and its size) or by calling
+both
+.Fn setstate
+(with the state array) and
+.Fn srandom
+(with the desired seed).
+The advantage of calling both
+.Fn setstate
+and
+.Fn srandom
+is that the size of the state array does not have to be remembered after
+it is initialized.
+.Pp
+With 256 bytes of state information, the period of the random number
+generator is greater than 2**69
+which should be sufficient for most purposes.
+.Sh DIAGNOSTICS
+If
+.Fn initstate
+is called with less than 8 bytes of state information, or if
+.Fn setstate
+detects that the state information has been garbled, error
+messages are printed on the standard error output.
+.Sh SEE ALSO
+.Xr arc4random 3 ,
+.Xr drand48 3 ,
+.Xr rand 3 ,
+.Xr random 4
+.Sh STANDARDS
+The
+.Fn random ,
+.Fn srandom ,
+.Fn initstate ,
+and
+.Fn setstate
+functions conform to
+.St -xpg4.2 .
+.Pp
+The
+.Fn srandomdev
+function is an extension.
+.Sh HISTORY
+These
+functions appeared in
+.Bx 4.2 .
+.Sh AUTHORS
+.An Earl T. Cohen
+.Sh BUGS
+About 2/3 the speed of
+.Xr rand 3 .
diff --git a/src/lib/libc/stdlib/random.c b/src/lib/libc/stdlib/random.c
new file mode 100644
index 0000000000..48e892042b
--- /dev/null
+++ b/src/lib/libc/stdlib/random.c
@@ -0,0 +1,395 @@
+/*      $OpenBSD: random.c,v 1.15 2005/11/30 07:51:02 otto Exp $ */
+/*
+ * Copyright (c) 1983 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.
+ */
+
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/*
+ * random.c:
+ *
+ * An improved random number generation package.  In addition to the standard
+ * rand()/srand() like interface, this package also has a special state info
+ * interface.  The initstate() routine is called with a seed, an array of
+ * bytes, and a count of how many bytes are being passed in; this array is
+ * then initialized to contain information for random number generation with
+ * that much state information.  Good sizes for the amount of state
+ * information are 32, 64, 128, and 256 bytes.  The state can be switched by
+ * calling the setstate() routine with the same array as was initiallized
+ * with initstate().  By default, the package runs with 128 bytes of state
+ * information and generates far better random numbers than a linear
+ * congruential generator.  If the amount of state information is less than
+ * 32 bytes, a simple linear congruential R.N.G. is used.
+ *
+ * Internally, the state information is treated as an array of int32_t; the
+ * zeroeth element of the array is the type of R.N.G. being used (small
+ * integer); the remainder of the array is the state information for the
+ * R.N.G.  Thus, 32 bytes of state information will give 7 int32_ts worth of
+ * state information, which will allow a degree seven polynomial.  (Note:
+ * the zeroeth word of state information also has some other information
+ * stored in it -- see setstate() for details).
+ * 
+ * The random number generation technique is a linear feedback shift register
+ * approach, employing trinomials (since there are fewer terms to sum up that
+ * way).  In this approach, the least significant bit of all the numbers in
+ * the state table will act as a linear feedback shift register, and will
+ * have period 2^deg - 1 (where deg is the degree of the polynomial being
+ * used, assuming that the polynomial is irreducible and primitive).  The
+ * higher order bits will have longer periods, since their values are also
+ * influenced by pseudo-random carries out of the lower bits.  The total
+ * period of the generator is approximately deg*(2**deg - 1); thus doubling
+ * the amount of state information has a vast influence on the period of the
+ * generator.  Note: the deg*(2**deg - 1) is an approximation only good for
+ * large deg, when the period of the shift register is the dominant factor.
+ * With deg equal to seven, the period is actually much longer than the
+ * 7*(2**7 - 1) predicted by this formula.
+ */
+
+/*
+ * For each of the currently supported random number generators, we have a
+ * break value on the amount of state information (you need at least this
+ * many bytes of state info to support this random number generator), a degree
+ * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
+ * the separation between the two lower order coefficients of the trinomial.
+ */
+#define TYPE_0          0               /* linear congruential */
+#define BREAK_0         8
+#define DEG_0           0
+#define SEP_0           0
+
+#define TYPE_1          1               /* x**7 + x**3 + 1 */
+#define BREAK_1         32
+#define DEG_1           7
+#define SEP_1           3
+
+#define TYPE_2          2               /* x**15 + x + 1 */
+#define BREAK_2         64
+#define DEG_2           15
+#define SEP_2           1
+
+#define TYPE_3          3               /* x**31 + x**3 + 1 */
+#define BREAK_3         128
+#define DEG_3           31
+#define SEP_3           3
+
+#define TYPE_4          4               /* x**63 + x + 1 */
+#define BREAK_4         256
+#define DEG_4           63
+#define SEP_4           1
+
+/*
+ * Array versions of the above information to make code run faster --
+ * relies on fact that TYPE_i == i.
+ */
+#define MAX_TYPES       5               /* max number of types above */
+
+static int degrees[MAX_TYPES] = { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 };
+static int seps [MAX_TYPES] =   { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
+
+/*
+ * Initially, everything is set up as if from:
+ *
+ *      initstate(1, &randtbl, 128);
+ *
+ * Note that this initialization takes advantage of the fact that srandom()
+ * advances the front and rear pointers 10*rand_deg times, and hence the
+ * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
+ * element of the state information, which contains info about the current
+ * position of the rear pointer is just
+ *
+ *      MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3.
+ */
+
+static int32_t randtbl[DEG_3 + 1] = {
+        TYPE_3,
+        0x991539b1, 0x16a5bce3, 0x6774a4cd, 0x3e01511e, 0x4e508aaa, 0x61048c05, 
+        0xf5500617, 0x846b7115, 0x6a19892c, 0x896a97af, 0xdb48f936, 0x14898454, 
+        0x37ffd106, 0xb58bff9c, 0x59e17104, 0xcf918a49, 0x09378c83, 0x52c7a471, 
+        0x8d293ea9, 0x1f4fc301, 0xc3db71be, 0x39b44e1c, 0xf8a44ef9, 0x4c8b80b1, 
+        0x19edc328, 0x87bf4bdd, 0xc9b240e5, 0xe9ee4b1b, 0x4382aee7, 0x535b6b41, 
+        0xf3bec5da,
+};
+
+/*
+ * fptr and rptr are two pointers into the state info, a front and a rear
+ * pointer.  These two pointers are always rand_sep places aparts, as they
+ * cycle cyclically through the state information.  (Yes, this does mean we
+ * could get away with just one pointer, but the code for random() is more
+ * efficient this way).  The pointers are left positioned as they would be
+ * from the call
+ *
+ *      initstate(1, randtbl, 128);
+ *
+ * (The position of the rear pointer, rptr, is really 0 (as explained above
+ * in the initialization of randtbl) because the state table pointer is set
+ * to point to randtbl[1] (as explained below).
+ */
+static int32_t *fptr = &randtbl[SEP_3 + 1];
+static int32_t *rptr = &randtbl[1];
+
+/*
+ * The following things are the pointer to the state information table, the
+ * type of the current generator, the degree of the current polynomial being
+ * used, and the separation between the two pointers.  Note that for efficiency
+ * of random(), we remember the first location of the state information, not
+ * the zeroeth.  Hence it is valid to access state[-1], which is used to
+ * store the type of the R.N.G.  Also, we remember the last location, since
+ * this is more efficient than indexing every time to find the address of
+ * the last element to see if the front and rear pointers have wrapped.
+ */
+static int32_t *state = &randtbl[1];
+static int32_t *end_ptr = &randtbl[DEG_3 + 1];
+static int rand_type = TYPE_3;
+static int rand_deg = DEG_3;
+static int rand_sep = SEP_3;
+
+/*
+ * srandom:
+ *
+ * Initialize the random number generator based on the given seed.  If the
+ * type is the trivial no-state-information type, just remember the seed.
+ * Otherwise, initializes state[] based on the given "seed" via a linear
+ * congruential generator.  Then, the pointers are set to known locations
+ * that are exactly rand_sep places apart.  Lastly, it cycles the state
+ * information a given number of times to get rid of any initial dependencies
+ * introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
+ * for default usage relies on values produced by this routine.
+ */
+void
+srandom(unsigned int x)
+{
+        int i;
+        int32_t test;
+        div_t val;
+
+        if (rand_type == TYPE_0)
+                state[0] = x;
+        else {
+                state[0] = x;
+                for (i = 1; i < rand_deg; i++) {
+                        /*
+                         * Implement the following, without overflowing 31 bits:
+                         *
+                         *      state[i] = (16807 * state[i - 1]) % 2147483647;
+                         *
+                         *      2^31-1 (prime) = 2147483647 = 127773*16807+2836
+                         */
+                        val = div(state[i-1], 127773);
+                        test = 16807 * val.rem - 2836 * val.quot;
+                        state[i] = test + (test < 0 ? 2147483647 : 0);
+                }
+                fptr = &state[rand_sep];
+                rptr = &state[0];
+                for (i = 0; i < 10 * rand_deg; i++)
+                        (void)random();
+        }
+}
+
+/*
+ * srandomdev:
+ *
+ * Many programs choose the seed value in a totally predictable manner.
+ * This often causes problems.  We seed the generator using random
+ * data from the kernel.
+ * Note that this particular seeding procedure can generate states
+ * which are impossible to reproduce by calling srandom() with any
+ * value, since the succeeding terms in the state buffer are no longer
+ * derived from the LC algorithm applied to a fixed seed.
+ */
+void
+srandomdev(void)
+{
+        int mib[2];
+        size_t len;
+
+        if (rand_type == TYPE_0)
+                len = sizeof(state[0]);
+        else
+                len = rand_deg * sizeof(state[0]);
+
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_ARND;
+        sysctl(mib, 2, state, &len, NULL, 0);
+
+        if (rand_type != TYPE_0) {
+                fptr = &state[rand_sep];
+                rptr = &state[0];
+        }
+}
+
+/*
+ * initstate:
+ *
+ * Initialize the state information in the given array of n bytes for future
+ * random number generation.  Based on the number of bytes we are given, and
+ * the break values for the different R.N.G.'s, we choose the best (largest)
+ * one we can and set things up for it.  srandom() is then called to
+ * initialize the state information.
+ * 
+ * Note that on return from srandom(), we set state[-1] to be the type
+ * multiplexed with the current value of the rear pointer; this is so
+ * successive calls to initstate() won't lose this information and will be
+ * able to restart with setstate().
+ * 
+ * Note: the first thing we do is save the current state, if any, just like
+ * setstate() so that it doesn't matter when initstate is called.
+ *
+ * Returns a pointer to the old state.
+ */
+char *
+initstate(u_int seed, char *arg_state, size_t n)
+{
+        char *ostate = (char *)(&state[-1]);
+
+        if (rand_type == TYPE_0)
+                state[-1] = rand_type;
+        else
+                state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+        if (n < BREAK_0)
+                return(NULL);
+        if (n < BREAK_1) {
+                rand_type = TYPE_0;
+                rand_deg = DEG_0;
+                rand_sep = SEP_0;
+        } else if (n < BREAK_2) {
+                rand_type = TYPE_1;
+                rand_deg = DEG_1;
+                rand_sep = SEP_1;
+        } else if (n < BREAK_3) {
+                rand_type = TYPE_2;
+                rand_deg = DEG_2;
+                rand_sep = SEP_2;
+        } else if (n < BREAK_4) {
+                rand_type = TYPE_3;
+                rand_deg = DEG_3;
+                rand_sep = SEP_3;
+        } else {
+                rand_type = TYPE_4;
+                rand_deg = DEG_4;
+                rand_sep = SEP_4;
+        }
+        state = &(((int32_t *)arg_state)[1]);   /* first location */
+        end_ptr = &state[rand_deg];     /* must set end_ptr before srandom */
+        srandom(seed);
+        if (rand_type == TYPE_0)
+                state[-1] = rand_type;
+        else
+                state[-1] = MAX_TYPES*(rptr - state) + rand_type;
+        return(ostate);
+}
+
+/*
+ * setstate:
+ *
+ * Restore the state from the given state array.
+ *
+ * Note: it is important that we also remember the locations of the pointers
+ * in the current state information, and restore the locations of the pointers
+ * from the old state information.  This is done by multiplexing the pointer
+ * location into the zeroeth word of the state information.
+ *
+ * Note that due to the order in which things are done, it is OK to call
+ * setstate() with the same state as the current state.
+ *
+ * Returns a pointer to the old state information.
+ */
+char *
+setstate(const char *arg_state)
+{
+        int32_t *new_state = (int32_t *)arg_state;
+        int32_t type = new_state[0] % MAX_TYPES;
+        int32_t rear = new_state[0] / MAX_TYPES;
+        char *ostate = (char *)(&state[-1]);
+
+        if (rand_type == TYPE_0)
+                state[-1] = rand_type;
+        else
+                state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+        switch(type) {
+        case TYPE_0:
+        case TYPE_1:
+        case TYPE_2:
+        case TYPE_3:
+        case TYPE_4:
+                rand_type = type;
+                rand_deg = degrees[type];
+                rand_sep = seps[type];
+                break;
+        default:
+                return(NULL);
+        }
+        state = &new_state[1];
+        if (rand_type != TYPE_0) {
+                rptr = &state[rear];
+                fptr = &state[(rear + rand_sep) % rand_deg];
+        }
+        end_ptr = &state[rand_deg];             /* set end_ptr too */
+        return(ostate);
+}
+
+/*
+ * random:
+ *
+ * If we are using the trivial TYPE_0 R.N.G., just do the old linear
+ * congruential bit.  Otherwise, we do our fancy trinomial stuff, which is
+ * the same in all the other cases due to all the global variables that have
+ * been set up.  The basic operation is to add the number at the rear pointer
+ * into the one at the front pointer.  Then both pointers are advanced to
+ * the next location cyclically in the table.  The value returned is the sum
+ * generated, reduced to 31 bits by throwing away the "least random" low bit.
+ *
+ * Note: the code takes advantage of the fact that both the front and
+ * rear pointers can't wrap on the same call by not testing the rear
+ * pointer if the front one has wrapped.
+ *
+ * Returns a 31-bit random number.
+ */
+long
+random(void)
+{
+        int32_t i;
+
+        if (rand_type == TYPE_0)
+                i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
+        else {
+                *fptr += *rptr;
+                i = (*fptr >> 1) & 0x7fffffff;  /* chucking least random bit */
+                if (++fptr >= end_ptr) {
+                        fptr = state;
+                        ++rptr;
+                } else if (++rptr >= end_ptr)
+                        rptr = state;
+        }
+        return((long)i);
+}
diff --git a/src/lib/libc/stdlib/realpath.3 b/src/lib/libc/stdlib/realpath.3
new file mode 100644
index 0000000000..e1e0b10605
--- /dev/null
+++ b/src/lib/libc/stdlib/realpath.3
@@ -0,0 +1,117 @@
+.\" Copyright (c) 1994
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Jan-Simon Pendry.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: realpath.3,v 1.13 2005/04/03 18:59:15 otto Exp $
+.\"
+.Dd February 16, 1994
+.Dt REALPATH 3
+.Os
+.Sh NAME
+.Nm realpath
+.Nd returns the canonicalized absolute pathname
+.Sh SYNOPSIS
+.Fd #include <sys/param.h>
+.Fd #include <stdlib.h>
+.Ft "char *"
+.Fn realpath "const char *pathname" "char resolved[PATH_MAX]"
+.Sh DESCRIPTION
+The
+.Fn realpath
+function resolves all symbolic links, extra
+.Dq /
+characters and references to
+.Pa /./
+and
+.Pa /../
+in
+.Fa pathname ,
+and copies the resulting absolute pathname into the memory referenced by
+.Fa resolved .
+The
+.Fa resolved
+argument
+.Em must
+refer to a buffer capable of storing at least
+.Dv PATH_MAX
+characters.
+.Pp
+The
+.Fn realpath
+function will resolve both absolute and relative paths
+and return the absolute pathname corresponding to
+.Fa pathname .
+All but the last component of
+.Fa pathname
+must exist when
+.Fn realpath
+is called.
+.Sh RETURN VALUES
+The
+.Fn realpath
+function returns
+.Fa resolved
+on success.
+If an error occurs,
+.Fn realpath
+returns
+.Dv NULL
+and the contents of
+.Fa resolved
+are undefined.
+.Sh ERRORS
+The function
+.Fn realpath
+may fail and set the external variable
+.Va errno
+for any of the errors specified for the library functions
+.Xr lstat 2 ,
+.Xr readlink 2 ,
+and
+.Xr getcwd 3 .
+.Sh SEE ALSO
+.Xr readlink 1 ,
+.Xr getcwd 3
+.Sh HISTORY
+The
+.Fn realpath
+function call first appeared in
+.Bx 4.4 .
+.Sh CAVEATS
+This implementation of
+.Fn realpath
+differs slightly from the Solaris implementation.
+The
+.Bx 4.4
+version always returns absolute pathnames,
+whereas the Solaris implementation will,
+under certain circumstances, return a relative
+.Fa resolved
+when given a relative
+.Fa pathname .
diff --git a/src/lib/libc/stdlib/realpath.c b/src/lib/libc/stdlib/realpath.c
new file mode 100644
index 0000000000..4cb847b313
--- /dev/null
+++ b/src/lib/libc/stdlib/realpath.c
@@ -0,0 +1,190 @@
+/*      $OpenBSD: realpath.c,v 1.13 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 2003 Constantin S. Svintsoff <kostik@iclub.nsu.ru>
+ *
+ * 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. The names of the authors 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 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 AUTHOR 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 <sys/stat.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * char *realpath(const char *path, char resolved[PATH_MAX]);
+ *
+ * Find the real name of path, by removing all ".", ".." and symlink
+ * components.  Returns (resolved) on success, or (NULL) on failure,
+ * in which case the path which caused trouble is left in (resolved).
+ */
+char *
+realpath(const char *path, char resolved[PATH_MAX])
+{
+        struct stat sb;
+        char *p, *q, *s;
+        size_t left_len, resolved_len;
+        unsigned symlinks;
+        int serrno, slen;
+        char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
+
+        serrno = errno;
+        symlinks = 0;
+        if (path[0] == '/') {
+                resolved[0] = '/';
+                resolved[1] = '\0';
+                if (path[1] == '\0')
+                        return (resolved);
+                resolved_len = 1;
+                left_len = strlcpy(left, path + 1, sizeof(left));
+        } else {
+                if (getcwd(resolved, PATH_MAX) == NULL) {
+                        strlcpy(resolved, ".", PATH_MAX);
+                        return (NULL);
+                }
+                resolved_len = strlen(resolved);
+                left_len = strlcpy(left, path, sizeof(left));
+        }
+        if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
+                errno = ENAMETOOLONG;
+                return (NULL);
+        }
+
+        /*
+         * Iterate over path components in `left'.
+         */
+        while (left_len != 0) {
+                /*
+                 * Extract the next path component and adjust `left'
+                 * and its length.
+                 */
+                p = strchr(left, '/');
+                s = p ? p : left + left_len;
+                if (s - left >= sizeof(next_token)) {
+                        errno = ENAMETOOLONG;
+                        return (NULL);
+                }
+                memcpy(next_token, left, s - left);
+                next_token[s - left] = '\0';
+                left_len -= s - left;
+                if (p != NULL)
+                        memmove(left, s + 1, left_len + 1);
+                if (resolved[resolved_len - 1] != '/') {
+                        if (resolved_len + 1 >= PATH_MAX) {
+                                errno = ENAMETOOLONG;
+                                return (NULL);
+                        }
+                        resolved[resolved_len++] = '/';
+                        resolved[resolved_len] = '\0';
+                }
+                if (next_token[0] == '\0')
+                        continue;
+                else if (strcmp(next_token, ".") == 0)
+                        continue;
+                else if (strcmp(next_token, "..") == 0) {
+                        /*
+                         * Strip the last path component except when we have
+                         * single "/"
+                         */
+                        if (resolved_len > 1) {
+                                resolved[resolved_len - 1] = '\0';
+                                q = strrchr(resolved, '/') + 1;
+                                *q = '\0';
+                                resolved_len = q - resolved;
+                        }
+                        continue;
+                }
+
+                /*
+                 * Append the next path component and lstat() it. If
+                 * lstat() fails we still can return successfully if
+                 * there are no more path components left.
+                 */
+                resolved_len = strlcat(resolved, next_token, PATH_MAX);
+                if (resolved_len >= PATH_MAX) {
+                        errno = ENAMETOOLONG;
+                        return (NULL);
+                }
+                if (lstat(resolved, &sb) != 0) {
+                        if (errno == ENOENT && p == NULL) {
+                                errno = serrno;
+                                return (resolved);
+                        }
+                        return (NULL);
+                }
+                if (S_ISLNK(sb.st_mode)) {
+                        if (symlinks++ > MAXSYMLINKS) {
+                                errno = ELOOP;
+                                return (NULL);
+                        }
+                        slen = readlink(resolved, symlink, sizeof(symlink) - 1);
+                        if (slen < 0)
+                                return (NULL);
+                        symlink[slen] = '\0';
+                        if (symlink[0] == '/') {
+                                resolved[1] = 0;
+                                resolved_len = 1;
+                        } else if (resolved_len > 1) {
+                                /* Strip the last path component. */
+                                resolved[resolved_len - 1] = '\0';
+                                q = strrchr(resolved, '/') + 1;
+                                *q = '\0';
+                                resolved_len = q - resolved;
+                        }
+
+                        /*
+                         * If there are any path components left, then
+                         * append them to symlink. The result is placed
+                         * in `left'.
+                         */
+                        if (p != NULL) {
+                                if (symlink[slen - 1] != '/') {
+                                        if (slen + 1 >= sizeof(symlink)) {
+                                                errno = ENAMETOOLONG;
+                                                return (NULL);
+                                        }
+                                        symlink[slen] = '/';
+                                        symlink[slen + 1] = 0;
+                                }
+                                left_len = strlcat(symlink, left, sizeof(left));
+                                if (left_len >= sizeof(left)) {
+                                        errno = ENAMETOOLONG;
+                                        return (NULL);
+                                }
+                        }
+                        left_len = strlcpy(left, symlink, sizeof(left));
+                }
+        }
+
+        /*
+         * Remove trailing slash except when the resolved pathname
+         * is a single "/".
+         */
+        if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
+                resolved[resolved_len - 1] = '\0';
+        return (resolved);
+}
diff --git a/src/lib/libc/stdlib/remque.c b/src/lib/libc/stdlib/remque.c
new file mode 100644
index 0000000000..ae249ae053
--- /dev/null
+++ b/src/lib/libc/stdlib/remque.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: remque.c,v 1.2 2005/08/08 08:05:37 espie Exp $        */
+
+/*
+ *  Copyright (c) 1993 John Brezak
+ *  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. The name of the author may 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 <search.h>
+
+struct qelem {
+        struct qelem *q_forw;
+        struct qelem *q_back;
+};
+
+void
+remque(void *element)
+{
+        struct qelem *e = (struct qelem *) element;
+        e->q_forw->q_back = e->q_back;
+        e->q_back->q_forw = e->q_forw;
+}
diff --git a/src/lib/libc/stdlib/seed48.c b/src/lib/libc/stdlib/seed48.c
new file mode 100644
index 0000000000..583262f2d5
--- /dev/null
+++ b/src/lib/libc/stdlib/seed48.c
@@ -0,0 +1,37 @@
+/*      $OpenBSD: seed48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+extern unsigned short __rand48_mult[3];
+extern unsigned short __rand48_add;
+
+unsigned short *
+seed48(unsigned short xseed[3])
+{
+        static unsigned short sseed[3];
+
+        sseed[0] = __rand48_seed[0];
+        sseed[1] = __rand48_seed[1];
+        sseed[2] = __rand48_seed[2];
+        __rand48_seed[0] = xseed[0];
+        __rand48_seed[1] = xseed[1];
+        __rand48_seed[2] = xseed[2];
+        __rand48_mult[0] = RAND48_MULT_0;
+        __rand48_mult[1] = RAND48_MULT_1;
+        __rand48_mult[2] = RAND48_MULT_2;
+        __rand48_add = RAND48_ADD;
+        return sseed;
+}
diff --git a/src/lib/libc/stdlib/setenv.c b/src/lib/libc/stdlib/setenv.c
new file mode 100644
index 0000000000..36540ebb0c
--- /dev/null
+++ b/src/lib/libc/stdlib/setenv.c
@@ -0,0 +1,103 @@
+/*      $OpenBSD: setenv.c,v 1.9 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1987 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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+char *__findenv(const char *name, int *offset);
+
+extern char **environ;
+
+/*
+ * setenv --
+ *      Set the value of the environmental variable "name" to be
+ *      "value".  If rewrite is set, replace any current value.
+ */
+int
+setenv(const char *name, const char *value, int rewrite)
+{
+        static char **lastenv;                  /* last value of environ */
+        char *C;
+        int l_value, offset;
+
+        if (*value == '=')                      /* no `=' in value */
+                ++value;
+        l_value = strlen(value);
+        if ((C = __findenv(name, &offset))) {   /* find if already exists */
+                if (!rewrite)
+                        return (0);
+                if (strlen(C) >= l_value) {     /* old larger; copy over */
+                        while ((*C++ = *value++))
+                                ;
+                        return (0);
+                }
+        } else {                                        /* create new slot */
+                size_t cnt;
+                char **P;
+
+                for (P = environ; *P != NULL; P++)
+                        ;
+                cnt = P - environ;
+                P = (char **)realloc(lastenv, sizeof(char *) * (cnt + 2));
+                if (!P)
+                        return (-1);
+                if (lastenv != environ)
+                        memcpy(P, environ, cnt * sizeof(char *));
+                lastenv = environ = P;
+                offset = cnt;
+                environ[cnt + 1] = NULL;
+        }
+        for (C = (char *)name; *C && *C != '='; ++C)
+                ;                               /* no `=' in name */
+        if (!(environ[offset] =                 /* name + `=' + value */
+            malloc((size_t)((int)(C - name) + l_value + 2))))
+                return (-1);
+        for (C = environ[offset]; (*C = *name++) && *C != '='; ++C)
+                ;
+        for (*C++ = '='; (*C++ = *value++); )
+                ;
+        return (0);
+}
+
+/*
+ * unsetenv(name) --
+ *      Delete environmental variable "name".
+ */
+void
+unsetenv(const char *name)
+{
+        char **P;
+        int offset;
+
+        while (__findenv(name, &offset))        /* if set multiple times */
+                for (P = &environ[offset];; ++P)
+                        if (!(*P = *(P + 1)))
+                                break;
+}
diff --git a/src/lib/libc/stdlib/srand48.c b/src/lib/libc/stdlib/srand48.c
new file mode 100644
index 0000000000..f76b6cca86
--- /dev/null
+++ b/src/lib/libc/stdlib/srand48.c
@@ -0,0 +1,31 @@
+/*      $OpenBSD: srand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1993 Martin Birgmeier
+ * All rights reserved.
+ *
+ * You may redistribute unmodified or modified versions of this source
+ * code provided that the above copyright notice and this and the
+ * following conditions are retained.
+ *
+ * This software is provided ``as is'', and comes with no warranties
+ * of any kind. I shall in no event be liable for anything that happens
+ * to anyone/anything when using this software.
+ */
+
+#include "rand48.h"
+
+extern unsigned short __rand48_seed[3];
+extern unsigned short __rand48_mult[3];
+extern unsigned short __rand48_add;
+
+void
+srand48(long seed)
+{
+        __rand48_seed[0] = RAND48_SEED_0;
+        __rand48_seed[1] = (unsigned short) seed;
+        __rand48_seed[2] = (unsigned short) (seed >> 16);
+        __rand48_mult[0] = RAND48_MULT_0;
+        __rand48_mult[1] = RAND48_MULT_1;
+        __rand48_mult[2] = RAND48_MULT_2;
+        __rand48_add = RAND48_ADD;
+}
diff --git a/src/lib/libc/stdlib/strtod.3 b/src/lib/libc/stdlib/strtod.3
new file mode 100644
index 0000000000..e25b0a5511
--- /dev/null
+++ b/src/lib/libc/stdlib/strtod.3
@@ -0,0 +1,113 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strtod.3,v 1.8 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRTOD 3
+.Os
+.Sh NAME
+.Nm strtod
+.Nd convert
+.Tn ASCII
+string to double
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft double
+.Fn strtod "const char *nptr" "char **endptr"
+.Sh DESCRIPTION
+The
+.Fn strtod
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li double
+representation.
+.Pp
+The expected form of the string is an optional plus
+.Pq Ql +
+or minus sign
+.Pq Ql -
+followed by a sequence of digits optionally containing
+a decimal-point character, optionally followed by an exponent.
+An exponent consists of an
+.Sq E
+or
+.Sq e ,
+followed by an optional plus or minus sign, followed by a sequence of digits.
+.Pp
+Leading whitespace characters in the string (as defined by the
+.Xr isspace 3
+function) are skipped.
+.Sh RETURN VALUES
+The
+.Fn strtod
+function returns the converted value, if any.
+.Pp
+If
+.Fa endptr
+is not
+.Dv NULL ,
+a pointer to the character after the last character used
+in the conversion is stored in the location referenced by
+.Fa endptr .
+.Pp
+If no conversion is performed, zero is returned and the value of
+.Fa nptr
+is stored in the location referenced by
+.Fa endptr .
+.Pp
+If the correct value would cause overflow, plus or minus
+.Dv HUGE_VAL
+is returned (according to the sign of the value), and
+.Er ERANGE
+is stored in
+.Va errno .
+If the correct value would cause underflow, zero is returned and
+.Er ERANGE
+is stored in
+.Va errno .
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ERANGE
+Overflow or underflow occurred.
+.El
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn strtod
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/stdlib/strtod.c b/src/lib/libc/stdlib/strtod.c
new file mode 100644
index 0000000000..d01158e10c
--- /dev/null
+++ b/src/lib/libc/stdlib/strtod.c
@@ -0,0 +1,2408 @@
+/*      $OpenBSD: strtod.c,v 1.22 2006/05/19 14:15:27 thib Exp $ */
+/****************************************************************
+ *
+ * The author of this software is David M. Gay.
+ *
+ * Copyright (c) 1991 by AT&T.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ ***************************************************************/
+
+/* Please send bug reports to
+        David M. Gay
+        AT&T Bell Laboratories, Room 2C-463
+        600 Mountain Avenue
+        Murray Hill, NJ 07974-2070
+        U.S.A.
+        dmg@research.att.com or research!dmg
+ */
+
+/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
+ *
+ * This strtod returns a nearest machine number to the input decimal
+ * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
+ * broken by the IEEE round-even rule.  Otherwise ties are broken by
+ * biased rounding (add half and chop).
+ *
+ * Inspired loosely by William D. Clinger's paper "How to Read Floating
+ * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *
+ *      1. We only require IEEE, IBM, or VAX double-precision
+ *              arithmetic (not IEEE double-extended).
+ *      2. We get by with floating-point arithmetic in a case that
+ *              Clinger missed -- when we're computing d * 10^n
+ *              for a small integer d and the integer n is not too
+ *              much larger than 22 (the maximum integer k for which
+ *              we can represent 10^k exactly), we may be able to
+ *              compute (d*10^k) * 10^(e-k) with just one roundoff.
+ *      3. Rather than a bit-at-a-time adjustment of the binary
+ *              result in the hard case, we use floating-point
+ *              arithmetic to determine the adjustment to within
+ *              one bit; only in really hard cases do we need to
+ *              compute a second residual.
+ *      4. Because of 3., we don't need a large table of powers of 10
+ *              for ten-to-e (just some small tables, e.g. of 10^k
+ *              for 0 <= k <= 22).
+ */
+
+/*
+ * #define IEEE_LITTLE_ENDIAN for IEEE-arithmetic machines where the least
+ *      significant byte has the lowest address.
+ * #define IEEE_BIG_ENDIAN for IEEE-arithmetic machines where the most
+ *      significant byte has the lowest address.
+ * #define Long int on machines with 32-bit ints and 64-bit longs.
+ * #define Sudden_Underflow for IEEE-format machines without gradual
+ *      underflow (i.e., that flush to zero on underflow).
+ * #define IBM for IBM mainframe-style floating-point arithmetic.
+ * #define VAX for VAX-style floating-point arithmetic.
+ * #define Unsigned_Shifts if >> does treats its left operand as unsigned.
+ * #define No_leftright to omit left-right logic in fast floating-point
+ *      computation of dtoa.
+ * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
+ * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
+ *      that use extended-precision instructions to compute rounded
+ *      products and quotients) with IBM.
+ * #define ROUND_BIASED for IEEE-format with biased rounding.
+ * #define Inaccurate_Divide for IEEE-format with correctly rounded
+ *      products but inaccurate quotients, e.g., for Intel i860.
+ * #define Just_16 to store 16 bits per 32-bit Long when doing high-precision
+ *      integer arithmetic.  Whether this speeds things up or slows things
+ *      down depends on the machine and the number being converted.
+ * #define Bad_float_h if your system lacks a float.h or if it does not
+ *      define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
+ *      FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
+ * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
+ *      if memory is available and otherwise does something you deem
+ *      appropriate.  If MALLOC is undefined, malloc will be invoked
+ *      directly -- and assumed always to succeed.
+ */
+
+#if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \
+    defined(__mips__) || defined(__ns32k__) || defined(__alpha__) || \
+    defined(__powerpc__) || defined(__m88k__) || defined(__hppa__) || \
+    defined(__x86_64__) || (defined(__arm__) && defined(__VFP_FP__))
+#include <sys/types.h>
+#if BYTE_ORDER == BIG_ENDIAN
+#define IEEE_BIG_ENDIAN
+#else
+#define IEEE_LITTLE_ENDIAN
+#endif
+#endif
+
+#if defined(__arm__) && !defined(__VFP_FP__)
+/*
+ * Although the CPU is little endian the FP has different
+ * byte and word endianness. The byte order is still little endian
+ * but the word order is big endian.
+ */
+#define IEEE_BIG_ENDIAN
+#endif
+
+#ifdef __vax__
+#define VAX
+#endif
+
+#define Long    int32_t
+#define ULong   u_int32_t
+
+#ifdef DEBUG
+#include "stdio.h"
+#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
+#endif
+
+#ifdef __cplusplus
+#include "malloc.h"
+#include "memory.h"
+#else
+#include "stdlib.h"
+#include "string.h"
+#include "locale.h"
+#endif
+
+#ifdef MALLOC
+extern void *MALLOC(size_t);
+#else
+#define MALLOC malloc
+#endif
+
+#include "ctype.h"
+#include "errno.h"
+
+#ifdef Bad_float_h
+#ifdef IEEE_BIG_ENDIAN
+#define IEEE_ARITHMETIC
+#endif
+#ifdef IEEE_LITTLE_ENDIAN
+#define IEEE_ARITHMETIC
+#endif
+
+#ifdef IEEE_ARITHMETIC
+#define DBL_DIG 15
+#define DBL_MAX_10_EXP 308
+#define DBL_MAX_EXP 1024
+#define FLT_RADIX 2
+#define FLT_ROUNDS 1
+#define DBL_MAX 1.7976931348623157e+308
+#endif
+
+#ifdef IBM
+#define DBL_DIG 16
+#define DBL_MAX_10_EXP 75
+#define DBL_MAX_EXP 63
+#define FLT_RADIX 16
+#define FLT_ROUNDS 0
+#define DBL_MAX 7.2370055773322621e+75
+#endif
+
+#ifdef VAX
+#define DBL_DIG 16
+#define DBL_MAX_10_EXP 38
+#define DBL_MAX_EXP 127
+#define FLT_RADIX 2
+#define FLT_ROUNDS 1
+#define DBL_MAX 1.7014118346046923e+38
+#endif
+
+#ifndef LONG_MAX
+#define LONG_MAX 2147483647
+#endif
+#else
+#include "float.h"
+#endif
+#ifndef __MATH_H__
+#include "math.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CONST
+#define CONST const
+#endif
+
+#ifdef Unsigned_Shifts
+#define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000;
+#else
+#define Sign_Extend(a,b) /*no-op*/
+#endif
+
+#if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) + defined(VAX) + \
+    defined(IBM) != 1
+Exactly one of IEEE_LITTLE_ENDIAN IEEE_BIG_ENDIAN, VAX, or
+IBM should be defined.
+#endif
+
+typedef union {
+        double d;
+        ULong ul[2];
+} _double;
+#define value(x) ((x).d)
+#ifdef IEEE_LITTLE_ENDIAN
+#define word0(x) ((x).ul[1])
+#define word1(x) ((x).ul[0])
+#else
+#define word0(x) ((x).ul[0])
+#define word1(x) ((x).ul[1])
+#endif
+
+/* The following definition of Storeinc is appropriate for MIPS processors.
+ * An alternative that might be better on some machines is
+ * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
+ */
+#if defined(IEEE_LITTLE_ENDIAN) + defined(VAX) + defined(__arm__)
+#define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
+((unsigned short *)a)[0] = (unsigned short)c, a++)
+#else
+#define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
+((unsigned short *)a)[1] = (unsigned short)c, a++)
+#endif
+
+/* #define P DBL_MANT_DIG */
+/* Ten_pmax = floor(P*log(2)/log(5)) */
+/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
+/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
+/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
+
+#if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN)
+#define Exp_shift  20
+#define Exp_shift1 20
+#define Exp_msk1    0x100000
+#define Exp_msk11   0x100000
+#define Exp_mask  0x7ff00000
+#define P 53
+#define Bias 1023
+#define IEEE_Arith
+#define Emin (-1022)
+#define Exp_1  0x3ff00000
+#define Exp_11 0x3ff00000
+#define Ebits 11
+#define Frac_mask  0xfffff
+#define Frac_mask1 0xfffff
+#define Ten_pmax 22
+#define Bletch 0x10
+#define Bndry_mask  0xfffff
+#define Bndry_mask1 0xfffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 1
+#define Tiny0 0
+#define Tiny1 1
+#define Quick_max 14
+#define Int_max 14
+#define Infinite(x) (word0(x) == 0x7ff00000) /* sufficient test for here */
+#else
+#undef  Sudden_Underflow
+#define Sudden_Underflow
+#ifdef IBM
+#define Exp_shift  24
+#define Exp_shift1 24
+#define Exp_msk1   0x1000000
+#define Exp_msk11  0x1000000
+#define Exp_mask  0x7f000000
+#define P 14
+#define Bias 65
+#define Exp_1  0x41000000
+#define Exp_11 0x41000000
+#define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */
+#define Frac_mask  0xffffff
+#define Frac_mask1 0xffffff
+#define Bletch 4
+#define Ten_pmax 22
+#define Bndry_mask  0xefffff
+#define Bndry_mask1 0xffffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 4
+#define Tiny0 0x100000
+#define Tiny1 0
+#define Quick_max 14
+#define Int_max 15
+#else /* VAX */
+#define Exp_shift  23
+#define Exp_shift1 7
+#define Exp_msk1    0x80
+#define Exp_msk11   0x800000
+#define Exp_mask  0x7f80
+#define P 56
+#define Bias 129
+#define Exp_1  0x40800000
+#define Exp_11 0x4080
+#define Ebits 8
+#define Frac_mask  0x7fffff
+#define Frac_mask1 0xffff007f
+#define Ten_pmax 24
+#define Bletch 2
+#define Bndry_mask  0xffff007f
+#define Bndry_mask1 0xffff007f
+#define LSB 0x10000
+#define Sign_bit 0x8000
+#define Log2P 1
+#define Tiny0 0x80
+#define Tiny1 0
+#define Quick_max 15
+#define Int_max 15
+#endif
+#endif
+
+#ifndef IEEE_Arith
+#define ROUND_BIASED
+#endif
+
+#ifdef RND_PRODQUOT
+#define rounded_product(a,b) a = rnd_prod(a, b)
+#define rounded_quotient(a,b) a = rnd_quot(a, b)
+extern double rnd_prod(double, double), rnd_quot(double, double);
+#else
+#define rounded_product(a,b) a *= b
+#define rounded_quotient(a,b) a /= b
+#endif
+
+#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
+#define Big1 0xffffffff
+
+#ifndef Just_16
+/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
+ * This makes some inner loops simpler and sometimes saves work
+ * during multiplications, but it often seems to make things slightly
+ * slower.  Hence the default is now to store 32 bits per Long.
+ */
+#ifndef Pack_32
+#define Pack_32
+#endif
+#endif
+
+#define Kmax 15
+
+#ifdef __cplusplus
+extern "C" double strtod(const char *s00, char **se);
+extern "C" char *__dtoa(double d, int mode, int ndigits,
+                        int *decpt, int *sign, char **rve);
+#endif
+
+ struct
+Bigint {
+        struct Bigint *next;
+        int k, maxwds, sign, wds;
+        ULong x[1];
+        };
+
+ typedef struct Bigint Bigint;
+
+ static Bigint *freelist[Kmax+1];
+
+ static Bigint *
+Balloc(int k)
+{
+        int x;
+        Bigint *rv;
+
+        if ((rv = freelist[k])) {
+                freelist[k] = rv->next;
+                }
+        else {
+                x = 1 << k;
+                rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(Long));
+                rv->k = k;
+                rv->maxwds = x;
+                }
+        rv->sign = rv->wds = 0;
+        return rv;
+        }
+
+ static void
+Bfree(Bigint *v)
+{
+        if (v) {
+                v->next = freelist[v->k];
+                freelist[v->k] = v;
+                }
+        }
+
+#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+y->wds*sizeof(Long) + 2*sizeof(int))
+
+ static Bigint *
+multadd(Bigint *b, int m, int a)        /* multiply by m and add a */
+{
+        int i, wds;
+        ULong *x, y;
+#ifdef Pack_32
+        ULong xi, z;
+#endif
+        Bigint *b1;
+
+        wds = b->wds;
+        x = b->x;
+        i = 0;
+        do {
+#ifdef Pack_32
+                xi = *x;
+                y = (xi & 0xffff) * m + a;
+                z = (xi >> 16) * m + (y >> 16);
+                a = (int)(z >> 16);
+                *x++ = (z << 16) + (y & 0xffff);
+#else
+                y = *x * m + a;
+                a = (int)(y >> 16);
+                *x++ = y & 0xffff;
+#endif
+                }
+                while(++i < wds);
+        if (a) {
+                if (wds >= b->maxwds) {
+                        b1 = Balloc(b->k+1);
+                        Bcopy(b1, b);
+                        Bfree(b);
+                        b = b1;
+                        }
+                b->x[wds++] = a;
+                b->wds = wds;
+                }
+        return b;
+        }
+
+ static Bigint *
+s2b(CONST char *s, int nd0, int nd, ULong y9)
+{
+        Bigint *b;
+        int i, k;
+        Long x, y;
+
+        x = (nd + 8) / 9;
+        for(k = 0, y = 1; x > y; y <<= 1, k++) ;
+#ifdef Pack_32
+        b = Balloc(k);
+        b->x[0] = y9;
+        b->wds = 1;
+#else
+        b = Balloc(k+1);
+        b->x[0] = y9 & 0xffff;
+        b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
+#endif
+
+        i = 9;
+        if (9 < nd0) {
+                s += 9;
+                do b = multadd(b, 10, *s++ - '0');
+                        while(++i < nd0);
+                s++;
+                }
+        else
+                s += 10;
+        for(; i < nd; i++)
+                b = multadd(b, 10, *s++ - '0');
+        return b;
+        }
+
+ static int
+hi0bits(ULong x)
+{
+        int k = 0;
+
+        if (!(x & 0xffff0000)) {
+                k = 16;
+                x <<= 16;
+                }
+        if (!(x & 0xff000000)) {
+                k += 8;
+                x <<= 8;
+                }
+        if (!(x & 0xf0000000)) {
+                k += 4;
+                x <<= 4;
+                }
+        if (!(x & 0xc0000000)) {
+                k += 2;
+                x <<= 2;
+                }
+        if (!(x & 0x80000000)) {
+                k++;
+                if (!(x & 0x40000000))
+                        return 32;
+                }
+        return k;
+        }
+
+ static int
+lo0bits(ULong *y)
+{
+        int k;
+        ULong x = *y;
+
+        if (x & 7) {
+                if (x & 1)
+                        return 0;
+                if (x & 2) {
+                        *y = x >> 1;
+                        return 1;
+                        }
+                *y = x >> 2;
+                return 2;
+                }
+        k = 0;
+        if (!(x & 0xffff)) {
+                k = 16;
+                x >>= 16;
+                }
+        if (!(x & 0xff)) {
+                k += 8;
+                x >>= 8;
+                }
+        if (!(x & 0xf)) {
+                k += 4;
+                x >>= 4;
+                }
+        if (!(x & 0x3)) {
+                k += 2;
+                x >>= 2;
+                }
+        if (!(x & 1)) {
+                k++;
+                x >>= 1;
+                if (!(x & 1))
+                        return 32;
+                }
+        *y = x;
+        return k;
+        }
+
+ static Bigint *
+i2b(int i)
+{
+        Bigint *b;
+
+        b = Balloc(1);
+        b->x[0] = i;
+        b->wds = 1;
+        return b;
+        }
+
+ static Bigint *
+mult(Bigint *a, Bigint *b)
+{
+        Bigint *c;
+        int k, wa, wb, wc;
+        ULong carry, y, z;
+        ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
+#ifdef Pack_32
+        ULong z2;
+#endif
+
+        if (a->wds < b->wds) {
+                c = a;
+                a = b;
+                b = c;
+                }
+        k = a->k;
+        wa = a->wds;
+        wb = b->wds;
+        wc = wa + wb;
+        if (wc > a->maxwds)
+                k++;
+        c = Balloc(k);
+        for(x = c->x, xa = x + wc; x < xa; x++)
+                *x = 0;
+        xa = a->x;
+        xae = xa + wa;
+        xb = b->x;
+        xbe = xb + wb;
+        xc0 = c->x;
+#ifdef Pack_32
+        for(; xb < xbe; xb++, xc0++) {
+                if ((y = *xb & 0xffff)) {
+                        x = xa;
+                        xc = xc0;
+                        carry = 0;
+                        do {
+                                z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
+                                carry = z >> 16;
+                                z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
+                                carry = z2 >> 16;
+                                Storeinc(xc, z2, z);
+                                }
+                                while(x < xae);
+                        *xc = carry;
+                        }
+                if ((y = *xb >> 16)) {
+                        x = xa;
+                        xc = xc0;
+                        carry = 0;
+                        z2 = *xc;
+                        do {
+                                z = (*x & 0xffff) * y + (*xc >> 16) + carry;
+                                carry = z >> 16;
+                                Storeinc(xc, z, z2);
+                                z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
+                                carry = z2 >> 16;
+                                }
+                                while(x < xae);
+                        *xc = z2;
+                        }
+                }
+#else
+        for(; xb < xbe; xc0++) {
+                if (y = *xb++) {
+                        x = xa;
+                        xc = xc0;
+                        carry = 0;
+                        do {
+                                z = *x++ * y + *xc + carry;
+                                carry = z >> 16;
+                                *xc++ = z & 0xffff;
+                                }
+                                while(x < xae);
+                        *xc = carry;
+                        }
+                }
+#endif
+        for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
+        c->wds = wc;
+        return c;
+        }
+
+ static Bigint *p5s;
+
+ static Bigint *
+pow5mult(Bigint *b, int k)
+{
+        Bigint *b1, *p5, *p51;
+        int i;
+        static int p05[3] = { 5, 25, 125 };
+
+        if ((i = k & 3))
+                b = multadd(b, p05[i-1], 0);
+
+        if (!(k >>= 2))
+                return b;
+        if (!(p5 = p5s)) {
+                /* first time */
+                p5 = p5s = i2b(625);
+                p5->next = 0;
+                }
+        for(;;) {
+                if (k & 1) {
+                        b1 = mult(b, p5);
+                        Bfree(b);
+                        b = b1;
+                        }
+                if (!(k >>= 1))
+                        break;
+                if (!(p51 = p5->next)) {
+                        p51 = p5->next = mult(p5,p5);
+                        p51->next = 0;
+                        }
+                p5 = p51;
+                }
+        return b;
+        }
+
+ static Bigint *
+lshift(Bigint *b, int k)
+{
+        int i, k1, n, n1;
+        Bigint *b1;
+        ULong *x, *x1, *xe, z;
+
+#ifdef Pack_32
+        n = k >> 5;
+#else
+        n = k >> 4;
+#endif
+        k1 = b->k;
+        n1 = n + b->wds + 1;
+        for(i = b->maxwds; n1 > i; i <<= 1)
+                k1++;
+        b1 = Balloc(k1);
+        x1 = b1->x;
+        for(i = 0; i < n; i++)
+                *x1++ = 0;
+        x = b->x;
+        xe = x + b->wds;
+#ifdef Pack_32
+        if (k &= 0x1f) {
+                k1 = 32 - k;
+                z = 0;
+                do {
+                        *x1++ = *x << k | z;
+                        z = *x++ >> k1;
+                        }
+                        while(x < xe);
+                if ((*x1 = z))
+                        ++n1;
+                }
+#else
+        if (k &= 0xf) {
+                k1 = 16 - k;
+                z = 0;
+                do {
+                        *x1++ = *x << k  & 0xffff | z;
+                        z = *x++ >> k1;
+                        }
+                        while(x < xe);
+                if (*x1 = z)
+                        ++n1;
+                }
+#endif
+        else do
+                *x1++ = *x++;
+                while(x < xe);
+        b1->wds = n1 - 1;
+        Bfree(b);
+        return b1;
+        }
+
+ static int
+cmp(Bigint *a, Bigint *b)
+{
+        ULong *xa, *xa0, *xb, *xb0;
+        int i, j;
+
+        i = a->wds;
+        j = b->wds;
+#ifdef DEBUG
+        if (i > 1 && !a->x[i-1])
+                Bug("cmp called with a->x[a->wds-1] == 0");
+        if (j > 1 && !b->x[j-1])
+                Bug("cmp called with b->x[b->wds-1] == 0");
+#endif
+        if (i -= j)
+                return i;
+        xa0 = a->x;
+        xa = xa0 + j;
+        xb0 = b->x;
+        xb = xb0 + j;
+        for(;;) {
+                if (*--xa != *--xb)
+                        return *xa < *xb ? -1 : 1;
+                if (xa <= xa0)
+                        break;
+                }
+        return 0;
+        }
+
+ static Bigint *
+diff(Bigint *a, Bigint *b)
+{
+        Bigint *c;
+        int i, wa, wb;
+        Long borrow, y; /* We need signed shifts here. */
+        ULong *xa, *xae, *xb, *xbe, *xc;
+#ifdef Pack_32
+        Long z;
+#endif
+
+        i = cmp(a,b);
+        if (!i) {
+                c = Balloc(0);
+                c->wds = 1;
+                c->x[0] = 0;
+                return c;
+                }
+        if (i < 0) {
+                c = a;
+                a = b;
+                b = c;
+                i = 1;
+                }
+        else
+                i = 0;
+        c = Balloc(a->k);
+        c->sign = i;
+        wa = a->wds;
+        xa = a->x;
+        xae = xa + wa;
+        wb = b->wds;
+        xb = b->x;
+        xbe = xb + wb;
+        xc = c->x;
+        borrow = 0;
+#ifdef Pack_32
+        do {
+                y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
+                borrow = y >> 16;
+                Sign_Extend(borrow, y);
+                z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
+                borrow = z >> 16;
+                Sign_Extend(borrow, z);
+                Storeinc(xc, z, y);
+                }
+                while(xb < xbe);
+        while(xa < xae) {
+                y = (*xa & 0xffff) + borrow;
+                borrow = y >> 16;
+                Sign_Extend(borrow, y);
+                z = (*xa++ >> 16) + borrow;
+                borrow = z >> 16;
+                Sign_Extend(borrow, z);
+                Storeinc(xc, z, y);
+                }
+#else
+        do {
+                y = *xa++ - *xb++ + borrow;
+                borrow = y >> 16;
+                Sign_Extend(borrow, y);
+                *xc++ = y & 0xffff;
+                }
+                while(xb < xbe);
+        while(xa < xae) {
+                y = *xa++ + borrow;
+                borrow = y >> 16;
+                Sign_Extend(borrow, y);
+                *xc++ = y & 0xffff;
+                }
+#endif
+        while(!*--xc)
+                wa--;
+        c->wds = wa;
+        return c;
+        }
+
+ static double
+ulp(double _x)
+{
+        _double x;
+        Long L;
+        _double a;
+
+        value(x) = _x;
+        L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
+#ifndef Sudden_Underflow
+        if (L > 0) {
+#endif
+#ifdef IBM
+                L |= Exp_msk1 >> 4;
+#endif
+                word0(a) = L;
+                word1(a) = 0;
+#ifndef Sudden_Underflow
+                }
+        else {
+                L = -L >> Exp_shift;
+                if (L < Exp_shift) {
+                        word0(a) = 0x80000 >> L;
+                        word1(a) = 0;
+                        }
+                else {
+                        word0(a) = 0;
+                        L -= Exp_shift;
+                        word1(a) = L >= 31 ? 1 : 1 << 31 - L;
+                        }
+                }
+#endif
+        return value(a);
+        }
+
+ static double
+b2d(Bigint *a, int *e)
+{
+        ULong *xa, *xa0, w, y, z;
+        int k;
+        _double d;
+#ifdef VAX
+        ULong d0, d1;
+#else
+#define d0 word0(d)
+#define d1 word1(d)
+#endif
+
+        xa0 = a->x;
+        xa = xa0 + a->wds;
+        y = *--xa;
+#ifdef DEBUG
+        if (!y) Bug("zero y in b2d");
+#endif
+        k = hi0bits(y);
+        *e = 32 - k;
+#ifdef Pack_32
+        if (k < Ebits) {
+                d0 = Exp_1 | y >> Ebits - k;
+                w = xa > xa0 ? *--xa : 0;
+                d1 = y << (32-Ebits) + k | w >> Ebits - k;
+                goto ret_d;
+                }
+        z = xa > xa0 ? *--xa : 0;
+        if (k -= Ebits) {
+                d0 = Exp_1 | y << k | z >> 32 - k;
+                y = xa > xa0 ? *--xa : 0;
+                d1 = z << k | y >> 32 - k;
+                }
+        else {
+                d0 = Exp_1 | y;
+                d1 = z;
+                }
+#else
+        if (k < Ebits + 16) {
+                z = xa > xa0 ? *--xa : 0;
+                d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
+                w = xa > xa0 ? *--xa : 0;
+                y = xa > xa0 ? *--xa : 0;
+                d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
+                goto ret_d;
+                }
+        z = xa > xa0 ? *--xa : 0;
+        w = xa > xa0 ? *--xa : 0;
+        k -= Ebits + 16;
+        d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
+        y = xa > xa0 ? *--xa : 0;
+        d1 = w << k + 16 | y << k;
+#endif
+ ret_d:
+#ifdef VAX
+        word0(d) = d0 >> 16 | d0 << 16;
+        word1(d) = d1 >> 16 | d1 << 16;
+#else
+#undef d0
+#undef d1
+#endif
+        return value(d);
+        }
+
+ static Bigint *
+d2b(double _d, int *e, int *bits)
+{
+        Bigint *b;
+        int de, i, k;
+        ULong *x, y, z;
+        _double d;
+#ifdef VAX
+        ULong d0, d1;
+#endif
+
+        value(d) = _d;
+#ifdef VAX
+        d0 = word0(d) >> 16 | word0(d) << 16;
+        d1 = word1(d) >> 16 | word1(d) << 16;
+#else
+#define d0 word0(d)
+#define d1 word1(d)
+#endif
+
+#ifdef Pack_32
+        b = Balloc(1);
+#else
+        b = Balloc(2);
+#endif
+        x = b->x;
+
+        z = d0 & Frac_mask;
+        d0 &= 0x7fffffff;       /* clear sign bit, which we ignore */
+#ifdef Sudden_Underflow
+        de = (int)(d0 >> Exp_shift);
+#ifndef IBM
+        z |= Exp_msk11;
+#endif
+#else
+        if (de = (int)(d0 >> Exp_shift))
+                z |= Exp_msk1;
+#endif
+#ifdef Pack_32
+        if (y = d1) {
+                if (k = lo0bits(&y)) {
+                        x[0] = y | z << 32 - k;
+                        z >>= k;
+                        }
+                else
+                        x[0] = y;
+                i = b->wds = (x[1] = z) ? 2 : 1;
+                }
+        else {
+#ifdef DEBUG
+                if (!z)
+                        Bug("Zero passed to d2b");
+#endif
+                k = lo0bits(&z);
+                x[0] = z;
+                i = b->wds = 1;
+                k += 32;
+                }
+#else
+        if (y = d1) {
+                if (k = lo0bits(&y))
+                        if (k >= 16) {
+                                x[0] = y | z << 32 - k & 0xffff;
+                                x[1] = z >> k - 16 & 0xffff;
+                                x[2] = z >> k;
+                                i = 2;
+                                }
+                        else {
+                                x[0] = y & 0xffff;
+                                x[1] = y >> 16 | z << 16 - k & 0xffff;
+                                x[2] = z >> k & 0xffff;
+                                x[3] = z >> k+16;
+                                i = 3;
+                                }
+                else {
+                        x[0] = y & 0xffff;
+                        x[1] = y >> 16;
+                        x[2] = z & 0xffff;
+                        x[3] = z >> 16;
+                        i = 3;
+                        }
+                }
+        else {
+#ifdef DEBUG
+                if (!z)
+                        Bug("Zero passed to d2b");
+#endif
+                k = lo0bits(&z);
+                if (k >= 16) {
+                        x[0] = z;
+                        i = 0;
+                        }
+                else {
+                        x[0] = z & 0xffff;
+                        x[1] = z >> 16;
+                        i = 1;
+                        }
+                k += 32;
+                }
+        while(!x[i])
+                --i;
+        b->wds = i + 1;
+#endif
+#ifndef Sudden_Underflow
+        if (de) {
+#endif
+#ifdef IBM
+                *e = (de - Bias - (P-1) << 2) + k;
+                *bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
+#else
+                *e = de - Bias - (P-1) + k;
+                *bits = P - k;
+#endif
+#ifndef Sudden_Underflow
+                }
+        else {
+                *e = de - Bias - (P-1) + 1 + k;
+#ifdef Pack_32
+                *bits = 32*i - hi0bits(x[i-1]);
+#else
+                *bits = (i+2)*16 - hi0bits(x[i]);
+#endif
+                }
+#endif
+        return b;
+        }
+#undef d0
+#undef d1
+
+ static double
+ratio(Bigint *a, Bigint *b)
+{
+        _double da, db;
+        int k, ka, kb;
+
+        value(da) = b2d(a, &ka);
+        value(db) = b2d(b, &kb);
+#ifdef Pack_32
+        k = ka - kb + 32*(a->wds - b->wds);
+#else
+        k = ka - kb + 16*(a->wds - b->wds);
+#endif
+#ifdef IBM
+        if (k > 0) {
+                word0(da) += (k >> 2)*Exp_msk1;
+                if (k &= 3)
+                        da *= 1 << k;
+                }
+        else {
+                k = -k;
+                word0(db) += (k >> 2)*Exp_msk1;
+                if (k &= 3)
+                        db *= 1 << k;
+                }
+#else
+        if (k > 0)
+                word0(da) += k*Exp_msk1;
+        else {
+                k = -k;
+                word0(db) += k*Exp_msk1;
+                }
+#endif
+        return value(da) / value(db);
+        }
+
+static CONST double
+tens[] = {
+                1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+                1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+                1e20, 1e21, 1e22
+#ifdef VAX
+                , 1e23, 1e24
+#endif
+                };
+
+#ifdef IEEE_Arith
+static CONST double bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
+#define n_bigtens 5
+#else
+#ifdef IBM
+static CONST double bigtens[] = { 1e16, 1e32, 1e64 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 };
+#define n_bigtens 3
+#else
+static CONST double bigtens[] = { 1e16, 1e32 };
+static CONST double tinytens[] = { 1e-16, 1e-32 };
+#define n_bigtens 2
+#endif
+#endif
+
+ double
+strtod(CONST char *s00, char **se)
+{
+        int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
+                 e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
+        CONST char *s, *s0, *s1;
+        double aadj, aadj1, adj;
+        _double rv, rv0;
+        Long L;
+        ULong y, z;
+        Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
+
+        CONST char decimal_point = localeconv()->decimal_point[0];
+
+        sign = nz0 = nz = 0;
+        value(rv) = 0.;
+
+
+        for(s = s00; isspace((unsigned char) *s); s++)
+                ;
+
+        if (*s == '-') {
+                sign = 1;
+                s++;
+        } else if (*s == '+') {
+                s++;
+        }
+
+        if (*s == '\0') {
+                s = s00;
+                goto ret;
+        }
+
+        if (*s == '0') {
+                nz0 = 1;
+                while(*++s == '0') ;
+                if (!*s)
+                        goto ret;
+                }
+        s0 = s;
+        y = z = 0;
+        for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
+                if (nd < 9)
+                        y = 10*y + c - '0';
+                else if (nd < 16)
+                        z = 10*z + c - '0';
+        nd0 = nd;
+        if (c == decimal_point) {
+                c = *++s;
+                if (!nd) {
+                        for(; c == '0'; c = *++s)
+                                nz++;
+                        if (c > '0' && c <= '9') {
+                                s0 = s;
+                                nf += nz;
+                                nz = 0;
+                                goto have_dig;
+                                }
+                        goto dig_done;
+                        }
+                for(; c >= '0' && c <= '9'; c = *++s) {
+ have_dig:
+                        nz++;
+                        if (c -= '0') {
+                                nf += nz;
+                                for(i = 1; i < nz; i++)
+                                        if (nd++ < 9)
+                                                y *= 10;
+                                        else if (nd <= DBL_DIG + 1)
+                                                z *= 10;
+                                if (nd++ < 9)
+                                        y = 10*y + c;
+                                else if (nd <= DBL_DIG + 1)
+                                        z = 10*z + c;
+                                nz = 0;
+                                }
+                        }
+                }
+ dig_done:
+        e = 0;
+        if (c == 'e' || c == 'E') {
+                if (!nd && !nz && !nz0) {
+                        s = s00;
+                        goto ret;
+                        }
+                s00 = s;
+                esign = 0;
+                switch(c = *++s) {
+                        case '-':
+                                esign = 1;
+                        case '+':
+                                c = *++s;
+                        }
+                if (c >= '0' && c <= '9') {
+                        while(c == '0')
+                                c = *++s;
+                        if (c > '0' && c <= '9') {
+                                L = c - '0';
+                                s1 = s;
+                                while((c = *++s) >= '0' && c <= '9')
+                                        L = 10*L + c - '0';
+                                if (s - s1 > 8 || L > 19999)
+                                        /* Avoid confusion from exponents
+                                         * so large that e might overflow.
+                                         */
+                                        e = 19999; /* safe for 16 bit ints */
+                                else
+                                        e = (int)L;
+                                if (esign)
+                                        e = -e;
+                                }
+                        else
+                                e = 0;
+                        }
+                else
+                        s = s00;
+                }
+        if (!nd) {
+                if (!nz && !nz0)
+                        s = s00;
+                goto ret;
+                }
+        e1 = e -= nf;
+
+        /* Now we have nd0 digits, starting at s0, followed by a
+         * decimal point, followed by nd-nd0 digits.  The number we're
+         * after is the integer represented by those digits times
+         * 10**e */
+
+        if (!nd0)
+                nd0 = nd;
+        k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+        value(rv) = y;
+        if (k > 9)
+                value(rv) = tens[k - 9] * value(rv) + z;
+        bd0 = 0;
+        if (nd <= DBL_DIG
+#ifndef RND_PRODQUOT
+                && FLT_ROUNDS == 1
+#endif
+                        ) {
+                if (!e)
+                        goto ret;
+                if (e > 0) {
+                        if (e <= Ten_pmax) {
+#ifdef VAX
+                                goto vax_ovfl_check;
+#else
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
+                                goto ret;
+#endif
+                                }
+                        i = DBL_DIG - nd;
+                        if (e <= Ten_pmax + i) {
+                                /* A fancier test would sometimes let us do
+                                 * this for larger i values.
+                                 */
+                                e -= i;
+                                value(rv) *= tens[i];
+#ifdef VAX
+                                /* VAX exponent range is so narrow we must
+                                 * worry about overflow here...
+                                 */
+ vax_ovfl_check:
+                                word0(rv) -= P*Exp_msk1;
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
+                                if ((word0(rv) & Exp_mask)
+                                 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
+                                        goto ovfl;
+                                word0(rv) += P*Exp_msk1;
+#else
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
+#endif
+                                goto ret;
+                                }
+                        }
+#ifndef Inaccurate_Divide
+                else if (e >= -Ten_pmax) {
+                        /* value(rv) = */ rounded_quotient(value(rv),
+                            tens[-e]);
+                        goto ret;
+                        }
+#endif
+                }
+        e1 += nd - k;
+
+        /* Get starting approximation = rv * 10**e1 */
+
+        if (e1 > 0) {
+                if (i = e1 & 15)
+                        value(rv) *= tens[i];
+                if (e1 &= ~15) {
+                        if (e1 > DBL_MAX_10_EXP) {
+ ovfl:
+                                errno = ERANGE;
+#ifndef Bad_float_h
+                                value(rv) = HUGE_VAL;
+#else
+                                /* Can't trust HUGE_VAL */
+#ifdef IEEE_Arith
+                                word0(rv) = Exp_mask;
+                                word1(rv) = 0;
+#else
+                                word0(rv) = Big0;
+                                word1(rv) = Big1;
+#endif
+#endif
+                                if (bd0)
+                                        goto retfree;
+                                goto ret;
+                                }
+                        if (e1 >>= 4) {
+                                for(j = 0; e1 > 1; j++, e1 >>= 1)
+                                        if (e1 & 1)
+                                                value(rv) *= bigtens[j];
+                        /* The last multiplication could overflow. */
+                                word0(rv) -= P*Exp_msk1;
+                                value(rv) *= bigtens[j];
+                                if ((z = word0(rv) & Exp_mask)
+                                 > Exp_msk1*(DBL_MAX_EXP+Bias-P))
+                                        goto ovfl;
+                                if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
+                                        /* set to largest number */
+                                        /* (Can't trust DBL_MAX) */
+                                        word0(rv) = Big0;
+                                        word1(rv) = Big1;
+                                        }
+                                else
+                                        word0(rv) += P*Exp_msk1;
+                                }
+
+                        }
+                }
+        else if (e1 < 0) {
+                e1 = -e1;
+                if (i = e1 & 15)
+                        value(rv) /= tens[i];
+                if (e1 &= ~15) {
+                        e1 >>= 4;
+                        if (e1 >= 1 << n_bigtens)
+                                goto undfl;
+                        for(j = 0; e1 > 1; j++, e1 >>= 1)
+                                if (e1 & 1)
+                                        value(rv) *= tinytens[j];
+                        /* The last multiplication could underflow. */
+                        value(rv0) = value(rv);
+                        value(rv) *= tinytens[j];
+                        if (!value(rv)) {
+                                value(rv) = 2.*value(rv0);
+                                value(rv) *= tinytens[j];
+                                if (!value(rv)) {
+ undfl:
+                                        value(rv) = 0.;
+                                        errno = ERANGE;
+                                        if (bd0)
+                                                goto retfree;
+                                        goto ret;
+                                        }
+                                word0(rv) = Tiny0;
+                                word1(rv) = Tiny1;
+                                /* The refinement below will clean
+                                 * this approximation up.
+                                 */
+                                }
+                        }
+                }
+
+        /* Now the hard part -- adjusting rv to the correct value.*/
+
+        /* Put digits into bd: true value = bd * 10^e */
+
+        bd0 = s2b(s0, nd0, nd, y);
+
+        for(;;) {
+                bd = Balloc(bd0->k);
+                Bcopy(bd, bd0);
+                bb = d2b(value(rv), &bbe, &bbbits);     /* rv = bb * 2^bbe */
+                bs = i2b(1);
+
+                if (e >= 0) {
+                        bb2 = bb5 = 0;
+                        bd2 = bd5 = e;
+                        }
+                else {
+                        bb2 = bb5 = -e;
+                        bd2 = bd5 = 0;
+                        }
+                if (bbe >= 0)
+                        bb2 += bbe;
+                else
+                        bd2 -= bbe;
+                bs2 = bb2;
+#ifdef Sudden_Underflow
+#ifdef IBM
+                j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
+#else
+                j = P + 1 - bbbits;
+#endif
+#else
+                i = bbe + bbbits - 1;   /* logb(rv) */
+                if (i < Emin)   /* denormal */
+                        j = bbe + (P-Emin);
+                else
+                        j = P + 1 - bbbits;
+#endif
+                bb2 += j;
+                bd2 += j;
+                i = bb2 < bd2 ? bb2 : bd2;
+                if (i > bs2)
+                        i = bs2;
+                if (i > 0) {
+                        bb2 -= i;
+                        bd2 -= i;
+                        bs2 -= i;
+                        }
+                if (bb5 > 0) {
+                        bs = pow5mult(bs, bb5);
+                        bb1 = mult(bs, bb);
+                        Bfree(bb);
+                        bb = bb1;
+                        }
+                if (bb2 > 0)
+                        bb = lshift(bb, bb2);
+                if (bd5 > 0)
+                        bd = pow5mult(bd, bd5);
+                if (bd2 > 0)
+                        bd = lshift(bd, bd2);
+                if (bs2 > 0)
+                        bs = lshift(bs, bs2);
+                delta = diff(bb, bd);
+                dsign = delta->sign;
+                delta->sign = 0;
+                i = cmp(delta, bs);
+                if (i < 0) {
+                        /* Error is less than half an ulp -- check for
+                         * special case of mantissa a power of two.
+                         */
+                        if (dsign || word1(rv) || word0(rv) & Bndry_mask)
+                                break;
+                        delta = lshift(delta,Log2P);
+                        if (cmp(delta, bs) > 0)
+                                goto drop_down;
+                        break;
+                        }
+                if (i == 0) {
+                        /* exactly half-way between */
+                        if (dsign) {
+                                if ((word0(rv) & Bndry_mask1) == Bndry_mask1
+                                 &&  word1(rv) == 0xffffffff) {
+                                        /*boundary case -- increment exponent*/
+                                        word0(rv) = (word0(rv) & Exp_mask)
+                                                + Exp_msk1
+#ifdef IBM
+                                                | Exp_msk1 >> 4
+#endif
+                                                ;
+                                        word1(rv) = 0;
+                                        break;
+                                        }
+                                }
+                        else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
+ drop_down:
+                                /* boundary case -- decrement exponent */
+#ifdef Sudden_Underflow
+                                L = word0(rv) & Exp_mask;
+#ifdef IBM
+                                if (L <  Exp_msk1)
+#else
+                                if (L <= Exp_msk1)
+#endif
+                                        goto undfl;
+                                L -= Exp_msk1;
+#else
+                                L = (word0(rv) & Exp_mask) - Exp_msk1;
+#endif
+                                word0(rv) = L | Bndry_mask1;
+                                word1(rv) = 0xffffffff;
+#ifdef IBM
+                                goto cont;
+#else
+                                break;
+#endif
+                                }
+#ifndef ROUND_BIASED
+                        if (!(word1(rv) & LSB))
+                                break;
+#endif
+                        if (dsign)
+                                value(rv) += ulp(value(rv));
+#ifndef ROUND_BIASED
+                        else {
+                                value(rv) -= ulp(value(rv));
+#ifndef Sudden_Underflow
+                                if (!value(rv))
+                                        goto undfl;
+#endif
+                                }
+#endif
+                        break;
+                        }
+                if ((aadj = ratio(delta, bs)) <= 2.) {
+                        if (dsign)
+                                aadj = aadj1 = 1.;
+                        else if (word1(rv) || word0(rv) & Bndry_mask) {
+#ifndef Sudden_Underflow
+                                if (word1(rv) == Tiny1 && !word0(rv))
+                                        goto undfl;
+#endif
+                                aadj = 1.;
+                                aadj1 = -1.;
+                                }
+                        else {
+                                /* special case -- power of FLT_RADIX to be */
+                                /* rounded down... */
+
+                                if (aadj < 2./FLT_RADIX)
+                                        aadj = 1./FLT_RADIX;
+                                else
+                                        aadj *= 0.5;
+                                aadj1 = -aadj;
+                                }
+                        }
+                else {
+                        aadj *= 0.5;
+                        aadj1 = dsign ? aadj : -aadj;
+#ifdef Check_FLT_ROUNDS
+                        switch(FLT_ROUNDS) {
+                                case 2: /* towards +infinity */
+                                        aadj1 -= 0.5;
+                                        break;
+                                case 0: /* towards 0 */
+                                case 3: /* towards -infinity */
+                                        aadj1 += 0.5;
+                                }
+#else
+                        if (FLT_ROUNDS == 0)
+                                aadj1 += 0.5;
+#endif
+                        }
+                y = word0(rv) & Exp_mask;
+
+                /* Check for overflow */
+
+                if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
+                        value(rv0) = value(rv);
+                        word0(rv) -= P*Exp_msk1;
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
+                        if ((word0(rv) & Exp_mask) >=
+                                        Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
+                                if (word0(rv0) == Big0 && word1(rv0) == Big1)
+                                        goto ovfl;
+                                word0(rv) = Big0;
+                                word1(rv) = Big1;
+                                goto cont;
+                                }
+                        else
+                                word0(rv) += P*Exp_msk1;
+                        }
+                else {
+#ifdef Sudden_Underflow
+                        if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
+                                value(rv0) = value(rv);
+                                word0(rv) += P*Exp_msk1;
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
+#ifdef IBM
+                                if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
+#else
+                                if ((word0(rv) & Exp_mask) <= P*Exp_msk1)
+#endif
+                                        {
+                                        if (word0(rv0) == Tiny0
+                                         && word1(rv0) == Tiny1)
+                                                goto undfl;
+                                        word0(rv) = Tiny0;
+                                        word1(rv) = Tiny1;
+                                        goto cont;
+                                        }
+                                else
+                                        word0(rv) -= P*Exp_msk1;
+                                }
+                        else {
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
+                                }
+#else
+                        /* Compute adj so that the IEEE rounding rules will
+                         * correctly round rv + adj in some half-way cases.
+                         * If rv * ulp(rv) is denormalized (i.e.,
+                         * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
+                         * trouble from bits lost to denormalization;
+                         * example: 1.2e-307 .
+                         */
+                        if (y <= (P-1)*Exp_msk1 && aadj >= 1.) {
+                                aadj1 = (double)(int)(aadj + 0.5);
+                                if (!dsign)
+                                        aadj1 = -aadj1;
+                                }
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
+#endif
+                        }
+                z = word0(rv) & Exp_mask;
+                if (y == z) {
+                        /* Can we stop now? */
+                        L = aadj;
+                        aadj -= L;
+                        /* The tolerances below are conservative. */
+                        if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
+                                if (aadj < .4999999 || aadj > .5000001)
+                                        break;
+                                }
+                        else if (aadj < .4999999/FLT_RADIX)
+                                break;
+                        }
+ cont:
+                Bfree(bb);
+                Bfree(bd);
+                Bfree(bs);
+                Bfree(delta);
+                }
+ retfree:
+        Bfree(bb);
+        Bfree(bd);
+        Bfree(bs);
+        Bfree(bd0);
+        Bfree(delta);
+ ret:
+        if (se)
+                *se = (char *)s;
+        return sign ? -value(rv) : value(rv);
+        }
+
+ static int
+quorem(Bigint *b, Bigint *S)
+{
+        int n;
+        Long borrow, y;
+        ULong carry, q, ys;
+        ULong *bx, *bxe, *sx, *sxe;
+#ifdef Pack_32
+        Long z;
+        ULong si, zs;
+#endif
+
+        n = S->wds;
+#ifdef DEBUG
+        /*debug*/ if (b->wds > n)
+        /*debug*/       Bug("oversize b in quorem");
+#endif
+        if (b->wds < n)
+                return 0;
+        sx = S->x;
+        sxe = sx + --n;
+        bx = b->x;
+        bxe = bx + n;
+        q = *bxe / (*sxe + 1);  /* ensure q <= true quotient */
+#ifdef DEBUG
+        /*debug*/ if (q > 9)
+        /*debug*/       Bug("oversized quotient in quorem");
+#endif
+        if (q) {
+                borrow = 0;
+                carry = 0;
+                do {
+#ifdef Pack_32
+                        si = *sx++;
+                        ys = (si & 0xffff) * q + carry;
+                        zs = (si >> 16) * q + (ys >> 16);
+                        carry = zs >> 16;
+                        y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+                        borrow = y >> 16;
+                        Sign_Extend(borrow, y);
+                        z = (*bx >> 16) - (zs & 0xffff) + borrow;
+                        borrow = z >> 16;
+                        Sign_Extend(borrow, z);
+                        Storeinc(bx, z, y);
+#else
+                        ys = *sx++ * q + carry;
+                        carry = ys >> 16;
+                        y = *bx - (ys & 0xffff) + borrow;
+                        borrow = y >> 16;
+                        Sign_Extend(borrow, y);
+                        *bx++ = y & 0xffff;
+#endif
+                        }
+                        while(sx <= sxe);
+                if (!*bxe) {
+                        bx = b->x;
+                        while(--bxe > bx && !*bxe)
+                                --n;
+                        b->wds = n;
+                        }
+                }
+        if (cmp(b, S) >= 0) {
+                q++;
+                borrow = 0;
+                carry = 0;
+                bx = b->x;
+                sx = S->x;
+                do {
+#ifdef Pack_32
+                        si = *sx++;
+                        ys = (si & 0xffff) + carry;
+                        zs = (si >> 16) + (ys >> 16);
+                        carry = zs >> 16;
+                        y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+                        borrow = y >> 16;
+                        Sign_Extend(borrow, y);
+                        z = (*bx >> 16) - (zs & 0xffff) + borrow;
+                        borrow = z >> 16;
+                        Sign_Extend(borrow, z);
+                        Storeinc(bx, z, y);
+#else
+                        ys = *sx++ + carry;
+                        carry = ys >> 16;
+                        y = *bx - (ys & 0xffff) + borrow;
+                        borrow = y >> 16;
+                        Sign_Extend(borrow, y);
+                        *bx++ = y & 0xffff;
+#endif
+                        }
+                        while(sx <= sxe);
+                bx = b->x;
+                bxe = bx + n;
+                if (!*bxe) {
+                        while(--bxe > bx && !*bxe)
+                                --n;
+                        b->wds = n;
+                        }
+                }
+        return q;
+        }
+
+/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
+ *
+ * Inspired by "How to Print Floating-Point Numbers Accurately" by
+ * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *      1. Rather than iterating, we use a simple numeric overestimate
+ *         to determine k = floor(log10(d)).  We scale relevant
+ *         quantities using O(log2(k)) rather than O(k) multiplications.
+ *      2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
+ *         try to generate digits strictly left to right.  Instead, we
+ *         compute with fewer bits and propagate the carry if necessary
+ *         when rounding the final digit up.  This is often faster.
+ *      3. Under the assumption that input will be rounded nearest,
+ *         mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
+ *         That is, we allow equality in stopping tests when the
+ *         round-nearest rule will give the same floating-point value
+ *         as would satisfaction of the stopping test with strict
+ *         inequality.
+ *      4. We remove common factors of powers of 2 from relevant
+ *         quantities.
+ *      5. When converting floating-point integers less than 1e16,
+ *         we use floating-point arithmetic rather than resorting
+ *         to multiple-precision integers.
+ *      6. When asked to produce fewer than 15 digits, we first try
+ *         to get by with floating-point arithmetic; we resort to
+ *         multiple-precision integer arithmetic only if we cannot
+ *         guarantee that the floating-point calculation has given
+ *         the correctly rounded result.  For k requested digits and
+ *         "uniformly" distributed input, the probability is
+ *         something like 10^(k-15) that we must resort to the Long
+ *         calculation.
+ */
+
+ char *
+__dtoa(double _d, int mode, int ndigits, int *decpt, int *sign, char **rve)
+{
+ /*     Arguments ndigits, decpt, sign are similar to those
+        of ecvt and fcvt; trailing zeros are suppressed from
+        the returned string.  If not null, *rve is set to point
+        to the end of the return value.  If d is +-Infinity or NaN,
+        then *decpt is set to 9999.
+
+        mode:
+                0 ==> shortest string that yields d when read in
+                        and rounded to nearest.
+                1 ==> like 0, but with Steele & White stopping rule;
+                        e.g. with IEEE P754 arithmetic , mode 0 gives
+                        1e23 whereas mode 1 gives 9.999999999999999e22.
+                2 ==> max(1,ndigits) significant digits.  This gives a
+                        return value similar to that of ecvt, except
+                        that trailing zeros are suppressed.
+                3 ==> through ndigits past the decimal point.  This
+                        gives a return value similar to that from fcvt,
+                        except that trailing zeros are suppressed, and
+                        ndigits can be negative.
+                4-9 should give the same return values as 2-3, i.e.,
+                        4 <= mode <= 9 ==> same return as mode
+                        2 + (mode & 1).  These modes are mainly for
+                        debugging; often they run slower but sometimes
+                        faster than modes 2-3.
+                4,5,8,9 ==> left-to-right digit generation.
+                6-9 ==> don't try fast floating-point estimate
+                        (if applicable).
+
+                Values of mode other than 0-9 are treated as mode 0.
+
+                Sufficient space is allocated to the return value
+                to hold the suppressed trailing zeros.
+        */
+
+        int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
+                j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
+                spec_case, try_quick;
+        Long L;
+#ifndef Sudden_Underflow
+        int denorm;
+        ULong x;
+#endif
+        Bigint *b, *b1, *delta, *mlo, *mhi, *S;
+        double ds;
+        char *s, *s0;
+        static Bigint *result;
+        static int result_k;
+        _double d, d2, eps;
+
+        value(d) = _d;
+        if (result) {
+                result->k = result_k;
+                result->maxwds = 1 << result_k;
+                Bfree(result);
+                result = 0;
+                }
+
+        if (word0(d) & Sign_bit) {
+                /* set sign for everything, including 0's and NaNs */
+                *sign = 1;
+                word0(d) &= ~Sign_bit;  /* clear sign bit */
+                }
+        else
+                *sign = 0;
+
+#if defined(IEEE_Arith) + defined(VAX)
+#ifdef IEEE_Arith
+        if ((word0(d) & Exp_mask) == Exp_mask)
+#else
+        if (word0(d)  == 0x8000)
+#endif
+                {
+                /* Infinity or NaN */
+                *decpt = 9999;
+                s =
+#ifdef IEEE_Arith
+                        !word1(d) && !(word0(d) & 0xfffff) ? ndigits < 8 ? "Inf" : "Infinity" :
+#endif
+                                "NaN";
+                if (rve)
+                        *rve =
+#ifdef IEEE_Arith
+                                s[3] ? s + 8 :
+#endif
+                                                s + 3;
+                return s;
+                }
+#endif
+#ifdef IBM
+        value(d) += 0; /* normalize */
+#endif
+        if (!value(d)) {
+                *decpt = 1;
+                s = "0";
+                if (rve)
+                        *rve = s + 1;
+                return s;
+                }
+
+        b = d2b(value(d), &be, &bbits);
+#ifdef Sudden_Underflow
+        i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
+#else
+        if (i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) {
+#endif
+                value(d2) = value(d);
+                word0(d2) &= Frac_mask1;
+                word0(d2) |= Exp_11;
+#ifdef IBM
+                if (j = 11 - hi0bits(word0(d2) & Frac_mask))
+                        value(d2) /= 1 << j;
+#endif
+
+                /* log(x)       ~=~ log(1.5) + (x-1.5)/1.5
+                 * log10(x)      =  log(x) / log(10)
+                 *              ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
+                 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+                 *
+                 * This suggests computing an approximation k to log10(d) by
+                 *
+                 * k = (i - Bias)*0.301029995663981
+                 *      + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
+                 *
+                 * We want k to be too large rather than too small.
+                 * The error in the first-order Taylor series approximation
+                 * is in our favor, so we just round up the constant enough
+                 * to compensate for any error in the multiplication of
+                 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
+                 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
+                 * adding 1e-13 to the constant term more than suffices.
+                 * Hence we adjust the constant term to 0.1760912590558.
+                 * (We could get a more accurate k by invoking log10,
+                 *  but this is probably not worthwhile.)
+                 */
+
+                i -= Bias;
+#ifdef IBM
+                i <<= 2;
+                i += j;
+#endif
+#ifndef Sudden_Underflow
+                denorm = 0;
+                }
+        else {
+                /* d is denormalized */
+
+                i = bbits + be + (Bias + (P-1) - 1);
+                x = i > 32  ? word0(d) << 64 - i | word1(d) >> i - 32
+                            : word1(d) << 32 - i;
+                value(d2) = x;
+                word0(d2) -= 31*Exp_msk1; /* adjust exponent */
+                i -= (Bias + (P-1) - 1) + 1;
+                denorm = 1;
+                }
+#endif
+        ds = (value(d2)-1.5)*0.289529654602168 + 0.1760912590558 +
+            i*0.301029995663981;
+        k = (int)ds;
+        if (ds < 0. && ds != k)
+                k--;    /* want k = floor(ds) */
+        k_check = 1;
+        if (k >= 0 && k <= Ten_pmax) {
+                if (value(d) < tens[k])
+                        k--;
+                k_check = 0;
+                }
+        j = bbits - i - 1;
+        if (j >= 0) {
+                b2 = 0;
+                s2 = j;
+                }
+        else {
+                b2 = -j;
+                s2 = 0;
+                }
+        if (k >= 0) {
+                b5 = 0;
+                s5 = k;
+                s2 += k;
+                }
+        else {
+                b2 -= k;
+                b5 = -k;
+                s5 = 0;
+                }
+        if (mode < 0 || mode > 9)
+                mode = 0;
+        try_quick = 1;
+        if (mode > 5) {
+                mode -= 4;
+                try_quick = 0;
+                }
+        leftright = 1;
+        switch(mode) {
+                case 0:
+                case 1:
+                        ilim = ilim1 = -1;
+                        i = 18;
+                        ndigits = 0;
+                        break;
+                case 2:
+                        leftright = 0;
+                        /* no break */
+                case 4:
+                        if (ndigits <= 0)
+                                ndigits = 1;
+                        ilim = ilim1 = i = ndigits;
+                        break;
+                case 3:
+                        leftright = 0;
+                        /* no break */
+                case 5:
+                        i = ndigits + k + 1;
+                        ilim = i;
+                        ilim1 = i - 1;
+                        if (i <= 0)
+                                i = 1;
+                }
+        j = sizeof(ULong);
+        for(result_k = 0; sizeof(Bigint) - sizeof(ULong) + j <= i;
+                j <<= 1) result_k++;
+        result = Balloc(result_k);
+        s = s0 = (char *)result;
+
+        if (ilim >= 0 && ilim <= Quick_max && try_quick) {
+
+                /* Try to get by with floating-point arithmetic. */
+
+                i = 0;
+                value(d2) = value(d);
+                k0 = k;
+                ilim0 = ilim;
+                ieps = 2; /* conservative */
+                if (k > 0) {
+                        ds = tens[k&0xf];
+                        j = k >> 4;
+                        if (j & Bletch) {
+                                /* prevent overflows */
+                                j &= Bletch - 1;
+                                value(d) /= bigtens[n_bigtens-1];
+                                ieps++;
+                                }
+                        for(; j; j >>= 1, i++)
+                                if (j & 1) {
+                                        ieps++;
+                                        ds *= bigtens[i];
+                                        }
+                        value(d) /= ds;
+                        }
+                else if (j1 = -k) {
+                        value(d) *= tens[j1 & 0xf];
+                        for(j = j1 >> 4; j; j >>= 1, i++)
+                                if (j & 1) {
+                                        ieps++;
+                                        value(d) *= bigtens[i];
+                                        }
+                        }
+                if (k_check && value(d) < 1. && ilim > 0) {
+                        if (ilim1 <= 0)
+                                goto fast_failed;
+                        ilim = ilim1;
+                        k--;
+                        value(d) *= 10.;
+                        ieps++;
+                        }
+                value(eps) = ieps*value(d) + 7.;
+                word0(eps) -= (P-1)*Exp_msk1;
+                if (ilim == 0) {
+                        S = mhi = 0;
+                        value(d) -= 5.;
+                        if (value(d) > value(eps))
+                                goto one_digit;
+                        if (value(d) < -value(eps))
+                                goto no_digits;
+                        goto fast_failed;
+                        }
+#ifndef No_leftright
+                if (leftright) {
+                        /* Use Steele & White method of only
+                         * generating digits needed.
+                         */
+                        value(eps) = 0.5/tens[ilim-1] - value(eps);
+                        for(i = 0;;) {
+                                L = value(d);
+                                value(d) -= L;
+                                *s++ = '0' + (int)L;
+                                if (value(d) < value(eps))
+                                        goto ret1;
+                                if (1. - value(d) < value(eps))
+                                        goto bump_up;
+                                if (++i >= ilim)
+                                        break;
+                                value(eps) *= 10.;
+                                value(d) *= 10.;
+                                }
+                        }
+                else {
+#endif
+                        /* Generate ilim digits, then fix them up. */
+                        value(eps) *= tens[ilim-1];
+                        for(i = 1;; i++, value(d) *= 10.) {
+                                L = value(d);
+                                value(d) -= L;
+                                *s++ = '0' + (int)L;
+                                if (i == ilim) {
+                                        if (value(d) > 0.5 + value(eps))
+                                                goto bump_up;
+                                        else if (value(d) < 0.5 - value(eps)) {
+                                                while(*--s == '0');
+                                                s++;
+                                                goto ret1;
+                                                }
+                                        break;
+                                        }
+                                }
+#ifndef No_leftright
+                        }
+#endif
+ fast_failed:
+                s = s0;
+                value(d) = value(d2);
+                k = k0;
+                ilim = ilim0;
+                }
+
+        /* Do we have a "small" integer? */
+
+        if (be >= 0 && k <= Int_max) {
+                /* Yes. */
+                ds = tens[k];
+                if (ndigits < 0 && ilim <= 0) {
+                        S = mhi = 0;
+                        if (ilim < 0 || value(d) <= 5*ds)
+                                goto no_digits;
+                        goto one_digit;
+                        }
+                for(i = 1;; i++) {
+                        L = value(d) / ds;
+                        value(d) -= L*ds;
+#ifdef Check_FLT_ROUNDS
+                        /* If FLT_ROUNDS == 2, L will usually be high by 1 */
+                        if (value(d) < 0) {
+                                L--;
+                                value(d) += ds;
+                                }
+#endif
+                        *s++ = '0' + (int)L;
+                        if (i == ilim) {
+                                value(d) += value(d);
+                                if (value(d) > ds || value(d) == ds && L & 1) {
+ bump_up:
+                                        while(*--s == '9')
+                                                if (s == s0) {
+                                                        k++;
+                                                        *s = '0';
+                                                        break;
+                                                        }
+                                        ++*s++;
+                                        }
+                                break;
+                                }
+                        if (!(value(d) *= 10.))
+                                break;
+                        }
+                goto ret1;
+                }
+
+        m2 = b2;
+        m5 = b5;
+        mhi = mlo = 0;
+        if (leftright) {
+                if (mode < 2) {
+                        i =
+#ifndef Sudden_Underflow
+                                denorm ? be + (Bias + (P-1) - 1 + 1) :
+#endif
+#ifdef IBM
+                                1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3);
+#else
+                                1 + P - bbits;
+#endif
+                        }
+                else {
+                        j = ilim - 1;
+                        if (m5 >= j)
+                                m5 -= j;
+                        else {
+                                s5 += j -= m5;
+                                b5 += j;
+                                m5 = 0;
+                                }
+                        if ((i = ilim) < 0) {
+                                m2 -= i;
+                                i = 0;
+                                }
+                        }
+                b2 += i;
+                s2 += i;
+                mhi = i2b(1);
+                }
+        if (m2 > 0 && s2 > 0) {
+                i = m2 < s2 ? m2 : s2;
+                b2 -= i;
+                m2 -= i;
+                s2 -= i;
+                }
+        if (b5 > 0) {
+                if (leftright) {
+                        if (m5 > 0) {
+                                mhi = pow5mult(mhi, m5);
+                                b1 = mult(mhi, b);
+                                Bfree(b);
+                                b = b1;
+                                }
+                        if (j = b5 - m5)
+                                b = pow5mult(b, j);
+                        }
+                else
+                        b = pow5mult(b, b5);
+                }
+        S = i2b(1);
+        if (s5 > 0)
+                S = pow5mult(S, s5);
+
+        /* Check for special case that d is a normalized power of 2. */
+
+        if (mode < 2) {
+                if (!word1(d) && !(word0(d) & Bndry_mask)
+#ifndef Sudden_Underflow
+                 && word0(d) & Exp_mask
+#endif
+                                ) {
+                        /* The special case */
+                        b2 += Log2P;
+                        s2 += Log2P;
+                        spec_case = 1;
+                        }
+                else
+                        spec_case = 0;
+                }
+
+        /* Arrange for convenient computation of quotients:
+         * shift left if necessary so divisor has 4 leading 0 bits.
+         *
+         * Perhaps we should just compute leading 28 bits of S once
+         * and for all and pass them and a shift to quorem, so it
+         * can do shifts and ors to compute the numerator for q.
+         */
+#ifdef Pack_32
+        if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f)
+                i = 32 - i;
+#else
+        if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf)
+                i = 16 - i;
+#endif
+        if (i > 4) {
+                i -= 4;
+                b2 += i;
+                m2 += i;
+                s2 += i;
+                }
+        else if (i < 4) {
+                i += 28;
+                b2 += i;
+                m2 += i;
+                s2 += i;
+                }
+        if (b2 > 0)
+                b = lshift(b, b2);
+        if (s2 > 0)
+                S = lshift(S, s2);
+        if (k_check) {
+                if (cmp(b,S) < 0) {
+                        k--;
+                        b = multadd(b, 10, 0);  /* we botched the k estimate */
+                        if (leftright)
+                                mhi = multadd(mhi, 10, 0);
+                        ilim = ilim1;
+                        }
+                }
+        if (ilim <= 0 && mode > 2) {
+                if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
+                        /* no digits, fcvt style */
+ no_digits:
+                        k = -1 - ndigits;
+                        goto ret;
+                        }
+ one_digit:
+                *s++ = '1';
+                k++;
+                goto ret;
+                }
+        if (leftright) {
+                if (m2 > 0)
+                        mhi = lshift(mhi, m2);
+
+                /* Compute mlo -- check for special case
+                 * that d is a normalized power of 2.
+                 */
+
+                mlo = mhi;
+                if (spec_case) {
+                        mhi = Balloc(mhi->k);
+                        Bcopy(mhi, mlo);
+                        mhi = lshift(mhi, Log2P);
+                        }
+
+                for(i = 1;;i++) {
+                        dig = quorem(b,S) + '0';
+                        /* Do we yet have the shortest decimal string
+                         * that will round to d?
+                         */
+                        j = cmp(b, mlo);
+                        delta = diff(S, mhi);
+                        j1 = delta->sign ? 1 : cmp(b, delta);
+                        Bfree(delta);
+#ifndef ROUND_BIASED
+                        if (j1 == 0 && !mode && !(word1(d) & 1)) {
+                                if (dig == '9')
+                                        goto round_9_up;
+                                if (j > 0)
+                                        dig++;
+                                *s++ = dig;
+                                goto ret;
+                                }
+#endif
+                        if (j < 0 || j == 0 && !mode
+#ifndef ROUND_BIASED
+                                                        && !(word1(d) & 1)
+#endif
+                                        ) {
+                                if (j1 > 0) {
+                                        b = lshift(b, 1);
+                                        j1 = cmp(b, S);
+                                        if ((j1 > 0 || j1 == 0 && dig & 1)
+                                        && dig++ == '9')
+                                                goto round_9_up;
+                                        }
+                                *s++ = dig;
+                                goto ret;
+                                }
+                        if (j1 > 0) {
+                                if (dig == '9') { /* possible if i == 1 */
+ round_9_up:
+                                        *s++ = '9';
+                                        goto roundoff;
+                                        }
+                                *s++ = dig + 1;
+                                goto ret;
+                                }
+                        *s++ = dig;
+                        if (i == ilim)
+                                break;
+                        b = multadd(b, 10, 0);
+                        if (mlo == mhi)
+                                mlo = mhi = multadd(mhi, 10, 0);
+                        else {
+                                mlo = multadd(mlo, 10, 0);
+                                mhi = multadd(mhi, 10, 0);
+                                }
+                        }
+                }
+        else
+                for(i = 1;; i++) {
+                        *s++ = dig = quorem(b,S) + '0';
+                        if (i >= ilim)
+                                break;
+                        b = multadd(b, 10, 0);
+                        }
+
+        /* Round off last digit */
+
+        b = lshift(b, 1);
+        j = cmp(b, S);
+        if (j > 0 || j == 0 && dig & 1) {
+ roundoff:
+                while(*--s == '9')
+                        if (s == s0) {
+                                k++;
+                                *s++ = '1';
+                                goto ret;
+                                }
+                ++*s++;
+                }
+        else {
+                while(*--s == '0');
+                s++;
+                }
+ ret:
+        Bfree(S);
+        if (mhi) {
+                if (mlo && mlo != mhi)
+                        Bfree(mlo);
+                Bfree(mhi);
+                }
+ ret1:
+        Bfree(b);
+        if (s == s0) {                          /* don't return empty string */
+                *s++ = '0';
+                k = 0;
+        }
+        *s = 0;
+        *decpt = k + 1;
+        if (rve)
+                *rve = s;
+        return s0;
+        }
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/lib/libc/stdlib/strtoimax.c b/src/lib/libc/stdlib/strtoimax.c
new file mode 100644
index 0000000000..2c77f41650
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoimax.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: strtoimax.c,v 1.1 2006/01/13 17:58:09 millert Exp $   */
+
+/*-
+ * Copyright (c) 1992 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.
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h>
+
+/*
+ * Convert a string to an intmax_t
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+intmax_t
+strtoimax(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        intmax_t acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * Skip white space and pick up leading +/- sign if any.
+         * If base is 0, allow 0x for hex and 0 for octal, else
+         * assume decimal; if base is already 16, allow 0x.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        /*
+         * Compute the cutoff value between legal numbers and illegal
+         * numbers.  That is the largest legal value, divided by the
+         * base.  An input number that is greater than this value, if
+         * followed by a legal input character, is too big.  One that
+         * is equal to this value may be valid or not; the limit
+         * between valid and invalid numbers is then based on the last
+         * digit.  For instance, if the range for intmax_t is
+         * [-9223372036854775808..9223372036854775807] and the input base
+         * is 10, cutoff will be set to 922337203685477580 and cutlim to
+         * either 7 (neg==0) or 8 (neg==1), meaning that if we have
+         * accumulated a value > 922337203685477580, or equal but the
+         * next digit is > 7 (or 8), the number is too big, and we will
+         * return a range error.
+         *
+         * Set any if any `digits' consumed; make it negative to indicate
+         * overflow.
+         */
+        cutoff = neg ? INTMAX_MIN : INTMAX_MAX;
+        cutlim = cutoff % base;
+        cutoff /= base;
+        if (neg) {
+                if (cutlim > 0) {
+                        cutlim -= base;
+                        cutoff += 1;
+                }
+                cutlim = -cutlim;
+        }
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (neg) {
+                        if (acc < cutoff || (acc == cutoff && c > cutlim)) {
+                                any = -1;
+                                acc = INTMAX_MIN;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc -= c;
+                        }
+                } else {
+                        if (acc > cutoff || (acc == cutoff && c > cutlim)) {
+                                any = -1;
+                                acc = INTMAX_MAX;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc += c;
+                        }
+                }
+        }
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
diff --git a/src/lib/libc/stdlib/strtol.3 b/src/lib/libc/stdlib/strtol.3
new file mode 100644
index 0000000000..e45941e07b
--- /dev/null
+++ b/src/lib/libc/stdlib/strtol.3
@@ -0,0 +1,258 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strtol.3,v 1.15 2006/03/29 20:10:52 grunk Exp $
+.\"
+.Dd January 3, 2006
+.Dt STRTOL 3
+.Os
+.Sh NAME
+.Nm strtol ,
+.Nm strtoll ,
+.Nm strtoimax ,
+.Nm strtoq ,
+.Nd "convert string value to a long, long long or intmax_t integer"
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft long
+.Fn strtol "const char *nptr" "char **endptr" "int base"
+.Pp
+.Ft long long
+.Fn strtoll "const char *nptr" "char **endptr" "int base"
+.Pp
+.Fd #include <inttypes.h>
+.Ft intmax_t
+.Fn strtoimax "const char *nptr" "char **endptr" "int base"
+.Pp
+.Fd #include <sys/types.h>
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft quad_t
+.Fn strtoq "const char *nptr" "char **endptr" "int base"
+.Sh DESCRIPTION
+The
+.Fn strtol
+function converts the string in
+.Fa nptr
+to a
+.Li long
+value.
+The
+.Fn strtoll
+function converts the string in
+.Fa nptr
+to a
+.Li long long
+value.
+The
+.Fn strtoimax
+function converts the string in
+.Fa nptr
+to an
+.Li intmax_t
+value.
+The
+.Fn strtoq
+function is a deprecated equivalent of
+.Fn strtoll
+and is provided for backwards compatibility with legacy programs.
+The conversion is done according to the given
+.Fa base ,
+which must be a number between 2 and 36 inclusive or the special value 0.
+.Pp
+The string may begin with an arbitrary amount of whitespace
+(as determined by
+.Xr isspace 3 )
+followed by a single optional
+.Ql +
+or
+.Ql -
+sign.
+If
+.Fa base
+is zero or 16, the string may then include a
+.Ql 0x
+prefix, and the number will be read in base 16; otherwise, a zero
+.Fa base
+is taken as 10 (decimal) unless the next character is
+.Ql 0 ,
+in which case it is taken as 8 (octal).
+.Pp
+The remainder of the string is converted to a
+.Li long ,
+.Li long long ,
+or
+.Li intmax_t ,
+value in the obvious manner,
+stopping at the first character which is not a valid digit
+in the given base.
+(In bases above 10, the letter
+.Ql A
+in either upper or lower case represents 10,
+.Ql B
+represents 11, and so forth, with
+.Ql Z
+representing 35.)
+.Pp
+If
+.Fa endptr
+is non-null,
+.Fn strtol
+stores the address of the first invalid character in
+.Fa *endptr .
+If there were no digits at all, however,
+.Fn strtol
+stores the original value of
+.Fa nptr
+in
+.Fa *endptr .
+(Thus, if
+.Fa *nptr
+is not
+.Ql \e0
+but
+.Fa **endptr
+is
+.Ql \e0
+on return, the entire string was valid.)
+.Sh RETURN VALUES
+The
+.Fn strtol ,
+.Fn strtoll ,
+.Fn strtoimax ,
+and
+.Fn strtoq
+functions returns the result of the conversion,
+unless the value would underflow or overflow.
+If overflow or underflow occurs,
+.Va errno
+is set to
+.Er ERANGE
+and the function return value is as follows:
+.Bl -column -offset indent "strtoimax" "overflow" "underflow"
+.It Sy Function Ta Sy overflow Ta Sy underflow
+.It Fn strtol Ta Dv LONG_MIN Ta Dv LONG_MAX
+.It Fn strtoll Ta Dv LLONG_MIN Ta Dv LLONG_MAX
+.It Fn strtoimax Ta Dv INTMAX_MIN Ta Dv INTMAX_MAX
+.It Fn strtoq Ta Dv LLONG_MIN Ta Dv LLONG_MAX
+.El
+.Sh EXAMPLES
+Ensuring that a string is a valid number (i.e., in range and containing no
+trailing characters) requires clearing
+.Va errno
+beforehand explicitly since
+.Va errno
+is not changed on a successful call to
+.Fn strtol ,
+and the return value of
+.Fn strtol
+cannot be used unambiguously to signal an error:
+.Bd -literal -offset indent
+char *ep;
+long lval;
+
+\&...
+
+errno = 0;
+lval = strtol(buf, &ep, 10);
+if (buf[0] == '\e0' || *ep != '\e0')
+        goto not_a_number;
+if (errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN))
+        goto out_of_range;
+.Ed
+.Pp
+This example will accept
+.Dq 12
+but not
+.Dq 12foo
+or
+.Dq 12\en .
+If trailing whitespace is acceptable, further checks must be done on
+.Va *ep ;
+alternately, use
+.Xr sscanf 3 .
+.Pp
+If
+.Fn strtol
+is being used instead of
+.Xr atoi 3 ,
+error checking is further complicated because the desired return value is an
+.Li int
+rather than a
+.Li long ;
+however, on some architectures integers and long integers are the same size.
+Thus the following is necessary:
+.Bd -literal -offset indent
+char *ep;
+int ival;
+long lval;
+
+\&...
+
+errno = 0;
+lval = strtol(buf, &ep, 10);
+if (buf[0] == '\e0' || *ep != '\e0')
+     goto not_a_number;
+if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||
+    (lval > INT_MAX || lval < INT_MIN))
+     goto out_of_range;
+ival = lval;
+.Ed
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ERANGE
+The given string was out of range; the value converted has been clamped.
+.El
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr atoll 3 ,
+.Xr sscanf 3 ,
+.Xr strtod 3 ,
+.Xr strtonum 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+The
+.Fn strtol ,
+.Fn strtoll ,
+and
+.Fn strtoimax
+functions conform to
+.St -ansiC-99 .
+The
+.Fn strtoq
+function is a
+.Bx
+extension and is provided for backwards compatibility with legacy programs.
+.Sh BUGS
+Ignores the current locale.
diff --git a/src/lib/libc/stdlib/strtol.c b/src/lib/libc/stdlib/strtol.c
new file mode 100644
index 0000000000..5a244766db
--- /dev/null
+++ b/src/lib/libc/stdlib/strtol.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: strtol.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+
+/*
+ * Convert a string to a long integer.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+long
+strtol(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        long acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * Skip white space and pick up leading +/- sign if any.
+         * If base is 0, allow 0x for hex and 0 for octal, else
+         * assume decimal; if base is already 16, allow 0x.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        /*
+         * Compute the cutoff value between legal numbers and illegal
+         * numbers.  That is the largest legal value, divided by the
+         * base.  An input number that is greater than this value, if
+         * followed by a legal input character, is too big.  One that
+         * is equal to this value may be valid or not; the limit
+         * between valid and invalid numbers is then based on the last
+         * digit.  For instance, if the range for longs is
+         * [-2147483648..2147483647] and the input base is 10,
+         * cutoff will be set to 214748364 and cutlim to either
+         * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
+         * a value > 214748364, or equal but the next digit is > 7 (or 8),
+         * the number is too big, and we will return a range error.
+         *
+         * Set any if any `digits' consumed; make it negative to indicate
+         * overflow.
+         */
+        cutoff = neg ? LONG_MIN : LONG_MAX;
+        cutlim = cutoff % base;
+        cutoff /= base;
+        if (neg) {
+                if (cutlim > 0) {
+                        cutlim -= base;
+                        cutoff += 1;
+                }
+                cutlim = -cutlim;
+        }
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (neg) {
+                        if (acc < cutoff || acc == cutoff && c > cutlim) {
+                                any = -1;
+                                acc = LONG_MIN;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc -= c;
+                        }
+                } else {
+                        if (acc > cutoff || acc == cutoff && c > cutlim) {
+                                any = -1;
+                                acc = LONG_MAX;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc += c;
+                        }
+                }
+        }
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
diff --git a/src/lib/libc/stdlib/strtoll.c b/src/lib/libc/stdlib/strtoll.c
new file mode 100644
index 0000000000..37379252e3
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoll.c
@@ -0,0 +1,153 @@
+/* $OpenBSD: strtoll.c,v 1.6 2005/11/10 10:00:17 espie Exp $ */
+/*-
+ * Copyright (c) 1992 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.
+ */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+/*
+ * Convert a string to a long long.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+long long
+strtoll(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        long long acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * Skip white space and pick up leading +/- sign if any.
+         * If base is 0, allow 0x for hex and 0 for octal, else
+         * assume decimal; if base is already 16, allow 0x.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        /*
+         * Compute the cutoff value between legal numbers and illegal
+         * numbers.  That is the largest legal value, divided by the
+         * base.  An input number that is greater than this value, if
+         * followed by a legal input character, is too big.  One that
+         * is equal to this value may be valid or not; the limit
+         * between valid and invalid numbers is then based on the last
+         * digit.  For instance, if the range for long longs is
+         * [-9223372036854775808..9223372036854775807] and the input base
+         * is 10, cutoff will be set to 922337203685477580 and cutlim to
+         * either 7 (neg==0) or 8 (neg==1), meaning that if we have
+         * accumulated a value > 922337203685477580, or equal but the
+         * next digit is > 7 (or 8), the number is too big, and we will
+         * return a range error.
+         *
+         * Set any if any `digits' consumed; make it negative to indicate
+         * overflow.
+         */
+        cutoff = neg ? LLONG_MIN : LLONG_MAX;
+        cutlim = cutoff % base;
+        cutoff /= base;
+        if (neg) {
+                if (cutlim > 0) {
+                        cutlim -= base;
+                        cutoff += 1;
+                }
+                cutlim = -cutlim;
+        }
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (neg) {
+                        if (acc < cutoff || (acc == cutoff && c > cutlim)) {
+                                any = -1;
+                                acc = LLONG_MIN;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc -= c;
+                        }
+                } else {
+                        if (acc > cutoff || (acc == cutoff && c > cutlim)) {
+                                any = -1;
+                                acc = LLONG_MAX;
+                                errno = ERANGE;
+                        } else {
+                                any = 1;
+                                acc *= base;
+                                acc += c;
+                        }
+                }
+        }
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
+
+#ifdef __weak_alias
+__weak_alias(strtoq, strtoll);
+#else
+quad_t
+strtoq(const char *nptr, char **endptr, int base)
+{
+
+        return ((quad_t)strtoll(nptr, endptr, base));
+}
+#endif
diff --git a/src/lib/libc/stdlib/strtonum.3 b/src/lib/libc/stdlib/strtonum.3
new file mode 100644
index 0000000000..6b3c9031d6
--- /dev/null
+++ b/src/lib/libc/stdlib/strtonum.3
@@ -0,0 +1,152 @@
+.\" $OpenBSD: strtonum.3,v 1.13 2006/04/25 05:15:42 tedu Exp $
+.\"
+.\" Copyright (c) 2004 Ted Unangst
+.\"
+.\" 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.
+.\"
+.Dd April 29, 2004
+.Dt STRTONUM 3
+.Os
+.Sh NAME
+.Nm strtonum
+.Nd "reliably convert string value to an integer"
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long long
+.Fo strtonum
+.Fa "const char *nptr"
+.Fa "long long minval"
+.Fa "long long maxval"
+.Fa "const char **errstr"
+.Fc
+.Sh DESCRIPTION
+The
+.Fn strtonum
+function converts the string in
+.Fa nptr
+to a
+.Li long long
+value.
+The
+.Fn strtonum
+function was designed to facilitate safe, robust programming
+and overcome the shortcomings of the
+.Xr atoi 3
+and
+.Xr strtol 3
+family of interfaces.
+.Pp
+The string may begin with an arbitrary amount of whitespace
+(as determined by
+.Xr isspace 3 )
+followed by a single optional
+.Ql +
+or
+.Ql -
+sign.
+.Pp
+The remainder of the string is converted to a
+.Li long long
+value according to base 10.
+.Pp
+The value obtained is then checked against the provided
+.Fa minval
+and
+.Fa maxval
+bounds.
+If
+.Fa errstr
+is non-null,
+.Fn strtonum
+stores an error string in
+.Fa *errstr
+indicating the failure.
+.Sh RETURN VALUES
+The
+.Fn strtonum
+function returns the result of the conversion,
+unless the value would exceed the provided bounds or is invalid.
+On error, 0 is returned,
+.Va errno
+is set, and
+.Fa errstr
+will point to an error message.
+.Fa *errstr
+will be set to
+.Dv NULL
+on success;
+this fact can be used to differentiate
+a successful return of 0 from an error.
+.Sh EXAMPLES
+Using
+.Fn strtonum
+correctly is meant to be simpler than the alternative functions.
+.Bd -literal -offset indent
+int iterations;
+const char *errstr;
+
+iterations = strtonum(optarg, 1, 64, &errstr);
+if (errstr)
+        errx(1, "number of iterations is %s: %s", errstr, optarg);
+.Ed
+.Pp
+The above example will guarantee that the value of iterations is between
+1 and 64 (inclusive).
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ERANGE
+The given string was out of range.
+.It Bq Er EINVAL
+The given string did not consist solely of digit characters.
+.It Bq Er EINVAL
+.Ar minval
+was larger than
+.Ar maxval .
+.El
+.Pp
+If an error occurs,
+.Fa errstr
+will be set to one of the following strings:
+.Pp
+.Bl -tag -width "too largeXX" -compact
+.It too large
+The result was larger than the provided maximum value.
+.It too small
+The result was smaller than the provided minimum value.
+.It invalid
+The string did not consist solely of digit characters.
+.El
+.Sh SEE ALSO
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr atoll 3 ,
+.Xr sscanf 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
+.Sh STANDARDS
+.Fn strtonum
+is an
+.Ox
+extension.
+The existing alternatives, such as
+.Xr atoi 3
+and
+.Xr strtol 3 ,
+are either impossible or difficult to use safely.
+.Sh HISTORY
+The
+.Fn strtonum
+function first appeared in
+.Ox 3.6 .
diff --git a/src/lib/libc/stdlib/strtonum.c b/src/lib/libc/stdlib/strtonum.c
new file mode 100644
index 0000000000..e426388ed0
--- /dev/null
+++ b/src/lib/libc/stdlib/strtonum.c
@@ -0,0 +1,65 @@
+/*      $OpenBSD: strtonum.c,v 1.6 2004/08/03 19:38:01 millert Exp $    */
+
+/*
+ * Copyright (c) 2004 Ted Unangst and Todd Miller
+ * All rights reserved.
+ *
+ * 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 <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+#define INVALID         1
+#define TOOSMALL        2
+#define TOOLARGE        3
+
+long long
+strtonum(const char *numstr, long long minval, long long maxval,
+    const char **errstrp)
+{
+        long long ll = 0;
+        char *ep;
+        int error = 0;
+        struct errval {
+                const char *errstr;
+                int err;
+        } ev[4] = {
+                { NULL,         0 },
+                { "invalid",    EINVAL },
+                { "too small",  ERANGE },
+                { "too large",  ERANGE },
+        };
+
+        ev[0].err = errno;
+        errno = 0;
+        if (minval > maxval)
+                error = INVALID;
+        else {
+                ll = strtoll(numstr, &ep, 10);
+                if (numstr == ep || *ep != '\0')
+                        error = INVALID;
+                else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
+                        error = TOOSMALL;
+                else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
+                        error = TOOLARGE;
+        }
+        if (errstrp != NULL)
+                *errstrp = ev[error].errstr;
+        errno = ev[error].err;
+        if (error)
+                ll = 0;
+
+        return (ll);
+}
diff --git a/src/lib/libc/stdlib/strtoul.3 b/src/lib/libc/stdlib/strtoul.3
new file mode 100644
index 0000000000..2ea5e83297
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoul.3
@@ -0,0 +1,242 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strtoul.3,v 1.16 2006/01/13 17:58:09 millert Exp $
+.\"
+.Dd January 3, 2006
+.Dt STRTOUL 3
+.Os
+.Sh NAME
+.Nm strtoul ,
+.Nm strtoull ,
+.Nm strtoumax ,
+.Nm strtouq
+.Nd "convert a string to an unsigned long, unsigned long long or uintmax_t integer"
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft unsigned long
+.Fn strtoul "const char *nptr" "char **endptr" "int base"
+.Pp
+.Ft unsigned long long
+.Fn strtoull "const char *nptr" "char **endptr" "int base"
+.Pp
+.Fd #include <inttypes.h>
+.Ft uintmax_t
+.Fn strtoumax "const char *nptr" "char **endptr" "int base"
+.Pp
+.Fd #include <sys/types.h>
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft u_quad_t
+.Fn strtouq "const char *nptr" "char **endptr" "int base"
+.Sh DESCRIPTION
+The
+.Fn strtoul
+function converts the string in
+.Fa nptr
+to an
+.Li unsigned long
+value.
+The
+.Fn strtoull
+function converts the string in
+.Fa nptr
+to an
+.Li unsigned long long
+value.
+The
+.Fn strtoumax
+function converts the string in
+.Fa nptr
+to a
+.Li umaxint_t
+value.
+The
+.Fn strtouq
+function is a deprecated equivalent of
+.Fn strtoull
+and is provided for backwards compatibility with legacy programs.
+The conversion is done according to the given
+.Fa base ,
+which must be a number between 2 and 36 inclusive
+or the special value 0.
+If the string in
+.Fa nptr
+represents a negative number, it will be converted to its unsigned equivalent.
+This behavior is consistent with what happens when a signed integer type is
+cast to its unsigned counterpart.
+.Pp
+The string may begin with an arbitrary amount of whitespace
+(as determined by
+.Xr isspace 3 )
+followed by a single optional
+.Ql +
+or
+.Ql -
+sign.
+If
+.Fa base
+is zero or 16, the string may then include a
+.Ql 0x
+prefix, and the number will be read in base 16; otherwise, a zero
+.Fa base
+is taken as 10 (decimal) unless the next character is
+.Ql 0 ,
+in which case it is taken as 8 (octal).
+.Pp
+The remainder of the string is converted to an
+.Li unsigned long
+value in the obvious manner, stopping at the end of the string
+or at the first character that does not produce a valid digit
+in the given base.
+(In bases above 10, the letter
+.Ql A
+in either upper or lower case represents 10,
+.Ql B
+represents 11, and so forth, with
+.Ql Z
+representing 35.)
+.Pp
+If
+.Fa endptr
+is non-null,
+.Fn strtoul
+stores the address of the first invalid character in
+.Fa *endptr .
+If there were no digits at all, however,
+.Fn strtoul
+stores the original value of
+.Fa nptr
+in
+.Fa *endptr .
+(Thus, if
+.Fa *nptr
+is not
+.Ql \e0
+but
+.Fa **endptr
+is
+.Ql \e0
+on return, the entire string was valid.)
+.Sh RETURN VALUES
+The
+.Fn strtoul ,
+.Fn strtoull ,
+.Fn strtoumax
+and
+.Fn strtouq
+functions return either the result of the conversion or,
+if there was a leading minus sign,
+the negation of the result of the conversion,
+unless the original (non-negated) value would overflow.
+If overflow occurs,
+.Fn strtoul
+returns
+.Dv ULONG_MAX ,
+.Fn strtoull
+returns
+.Dv ULLONG_MAX ,
+.Fn strtoumax
+returns
+.Dv UINTMAX_MAX ,
+.Fn strtouq
+returns
+.Dv ULLONG_MAX
+and the global variable
+.Va errno
+is set to
+.Er ERANGE .
+.Pp
+There is no way to determine if
+.Fn strtoul
+has processed a negative number (and returned an unsigned value) short of
+examining the string in
+.Fa nptr
+directly.
+.Sh EXAMPLES
+Ensuring that a string is a valid number (i.e., in range and containing no
+trailing characters) requires clearing
+.Va errno
+beforehand explicitly since
+.Va errno
+is not changed on a successful call to
+.Fn strtoul ,
+and the return value of
+.Fn strtoul
+cannot be used unambiguously to signal an error:
+.Bd -literal -offset indent
+char *ep;
+unsigned long ulval;
+
+\&...
+
+errno = 0;
+ulval = strtoul(buf, &ep, 10);
+if (buf[0] == '\e0' || *ep != '\e0')
+        goto not_a_number;
+if (errno == ERANGE && ulval == ULONG_MAX)
+        goto out_of_range;
+.Ed
+.Pp
+This example will accept
+.Dq 12
+but not
+.Dq 12foo
+or
+.Dq 12\en .
+If trailing whitespace is acceptable, further checks must be done on
+.Va *ep ;
+alternately, use
+.Xr sscanf 3 .
+.Sh ERRORS
+.Bl -tag -width Er
+.It Bq Er ERANGE
+The given string was out of range; the value converted has been clamped.
+.El
+.Sh SEE ALSO
+.Xr sscanf 3 ,
+.Xr strtol 3
+.Sh STANDARDS
+The
+.Fn strtoul ,
+.Fn strtoull ,
+and
+.Fn strtoumax
+functions conform to
+.St -ansiC-99 .
+The
+.Fn strtouq
+function is a
+.Bx
+extension and is provided for backwards compatibility with legacy programs.
+.Sh BUGS
+Ignores the current locale.
diff --git a/src/lib/libc/stdlib/strtoul.c b/src/lib/libc/stdlib/strtoul.c
new file mode 100644
index 0000000000..d7dddab778
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoul.c
@@ -0,0 +1,102 @@
+/*      $OpenBSD: strtoul.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1990 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.
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+/*
+ * Convert a string to an unsigned long integer.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+unsigned long
+strtoul(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        unsigned long acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * See strtol for comments as to the logic used.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        cutoff = ULONG_MAX / (unsigned long)base;
+        cutlim = ULONG_MAX % (unsigned long)base;
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (acc > cutoff || acc == cutoff && c > cutlim) {
+                        any = -1;
+                        acc = ULONG_MAX;
+                        errno = ERANGE;
+                } else {
+                        any = 1;
+                        acc *= (unsigned long)base;
+                        acc += c;
+                }
+        }
+        if (neg && any > 0)
+                acc = -acc;
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
diff --git a/src/lib/libc/stdlib/strtoull.c b/src/lib/libc/stdlib/strtoull.c
new file mode 100644
index 0000000000..37859776f9
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoull.c
@@ -0,0 +1,115 @@
+/*      $OpenBSD: strtoull.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1992 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.
+ */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+/*
+ * Convert a string to an unsigned long long.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+unsigned long long
+strtoull(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        unsigned long long acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * See strtoq for comments as to the logic used.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else { 
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        cutoff = ULLONG_MAX / (unsigned long long)base;
+        cutlim = ULLONG_MAX % (unsigned long long)base;
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (acc > cutoff || (acc == cutoff && c > cutlim)) {
+                        any = -1;
+                        acc = ULLONG_MAX;
+                        errno = ERANGE;
+                } else {
+                        any = 1;
+                        acc *= (unsigned long long)base;
+                        acc += c;
+                }
+        }
+        if (neg && any > 0)
+                acc = -acc;
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
+
+#ifdef __weak_alias
+__weak_alias(strtouq, strtoull);
+#else
+u_quad_t
+strtouq(const char *nptr, char **endptr, int base)
+{
+
+        return ((u_quad_t)strtoull(nptr, endptr, base));
+}
+#endif
diff --git a/src/lib/libc/stdlib/strtoumax.c b/src/lib/libc/stdlib/strtoumax.c
new file mode 100644
index 0000000000..ce6e2c00f1
--- /dev/null
+++ b/src/lib/libc/stdlib/strtoumax.c
@@ -0,0 +1,102 @@
+/*      $OpenBSD: strtoumax.c,v 1.1 2006/01/13 17:58:09 millert Exp $   */
+
+/*-
+ * Copyright (c) 1992 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.
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h>
+
+/*
+ * Convert a string to a uintmax_t.
+ *
+ * Ignores `locale' stuff.  Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+uintmax_t
+strtoumax(const char *nptr, char **endptr, int base)
+{
+        const char *s;
+        uintmax_t acc, cutoff;
+        int c;
+        int neg, any, cutlim;
+
+        /*
+         * See strtoq for comments as to the logic used.
+         */
+        s = nptr;
+        do {
+                c = (unsigned char) *s++;
+        } while (isspace(c));
+        if (c == '-') {
+                neg = 1;
+                c = *s++;
+        } else { 
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
+        if ((base == 0 || base == 16) &&
+            c == '0' && (*s == 'x' || *s == 'X')) {
+                c = s[1];
+                s += 2;
+                base = 16;
+        }
+        if (base == 0)
+                base = c == '0' ? 8 : 10;
+
+        cutoff = UINTMAX_MAX / (uintmax_t)base;
+        cutlim = UINTMAX_MAX % (uintmax_t)base;
+        for (acc = 0, any = 0;; c = (unsigned char) *s++) {
+                if (isdigit(c))
+                        c -= '0';
+                else if (isalpha(c))
+                        c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+                else
+                        break;
+                if (c >= base)
+                        break;
+                if (any < 0)
+                        continue;
+                if (acc > cutoff || (acc == cutoff && c > cutlim)) {
+                        any = -1;
+                        acc = UINTMAX_MAX;
+                        errno = ERANGE;
+                } else {
+                        any = 1;
+                        acc *= (uintmax_t)base;
+                        acc += c;
+                }
+        }
+        if (neg && any > 0)
+                acc = -acc;
+        if (endptr != 0)
+                *endptr = (char *) (any ? s - 1 : nptr);
+        return (acc);
+}
diff --git a/src/lib/libc/stdlib/system.3 b/src/lib/libc/stdlib/system.3
new file mode 100644
index 0000000000..1034b01066
--- /dev/null
+++ b/src/lib/libc/stdlib/system.3
@@ -0,0 +1,99 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: system.3,v 1.9 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt SYSTEM 3
+.Os
+.Sh NAME
+.Nm system
+.Nd pass a command to the shell
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft int
+.Fn system "const char *string"
+.Sh DESCRIPTION
+The
+.Fn system
+function hands the argument
+.Fa string
+to the command interpreter
+.Xr sh 1 .
+The calling process waits for the shell to finish executing the command,
+ignoring
+.Dv SIGINT
+and
+.Dv SIGQUIT ,
+and blocking
+.Dv SIGCHLD .
+.Pp
+If
+.Fa string
+is
+.Dv NULL ,
+.Fn system
+will return non-zero.
+Otherwise,
+.Fn system
+returns the termination status of the shell in the format specified by
+.Xr waitpid 2 .
+.Sh RETURN VALUES
+If a child process cannot be created, or the termination status of
+the shell cannot be obtained,
+.Fn system
+returns \-1 and sets
+.Va errno
+to indicate the error.
+If execution of the shell fails,
+.Fn system
+returns the termination status for a program that terminates with a call of
+.Fn exit 127 .
+.Sh SEE ALSO
+.Xr sh 1 ,
+.Xr execve 2 ,
+.Xr waitpid 2 ,
+.Xr popen 3
+.Sh STANDARDS
+The
+.Fn system
+function conforms to
+.St -ansiC
+and
+.St -p1003.2-92 .
+.Sh CAVEATS
+Never supply the
+.Fn system
+function with a command containing any part of an unsanitized user-supplied
+string.
+Shell meta-characters present will be honored by the
+.Xr sh 1
+command interpreter.
diff --git a/src/lib/libc/stdlib/system.c b/src/lib/libc/stdlib/system.c
new file mode 100644
index 0000000000..14ddcae8d3
--- /dev/null
+++ b/src/lib/libc/stdlib/system.c
@@ -0,0 +1,74 @@
+/*      $OpenBSD: system.c,v 1.8 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <paths.h>
+
+extern char **environ;
+
+int
+system(const char *command)
+{
+        pid_t pid;
+        sig_t intsave, quitsave;
+        sigset_t mask, omask;
+        int pstat;
+        char *argp[] = {"sh", "-c", NULL, NULL};
+
+        if (!command)           /* just checking... */
+                return(1);
+
+        argp[2] = (char *)command;
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &mask, &omask);
+        switch (pid = vfork()) {
+        case -1:                        /* error */
+                sigprocmask(SIG_SETMASK, &omask, NULL);
+                return(-1);
+        case 0:                         /* child */
+                sigprocmask(SIG_SETMASK, &omask, NULL);
+                execve(_PATH_BSHELL, argp, environ);
+                _exit(127);
+        }
+
+        intsave = signal(SIGINT, SIG_IGN);
+        quitsave = signal(SIGQUIT, SIG_IGN);
+        pid = waitpid(pid, (int *)&pstat, 0);
+        sigprocmask(SIG_SETMASK, &omask, NULL);
+        (void)signal(SIGINT, intsave);
+        (void)signal(SIGQUIT, quitsave);
+        return (pid == -1 ? -1 : pstat);
+}
diff --git a/src/lib/libc/stdlib/tfind.c b/src/lib/libc/stdlib/tfind.c
new file mode 100644
index 0000000000..ff6bcd742d
--- /dev/null
+++ b/src/lib/libc/stdlib/tfind.c
@@ -0,0 +1,41 @@
+/*      $OpenBSD: tfind.c,v 1.5 2005/03/30 18:51:49 pat Exp $   */
+
+/*
+ * Tree search generalized from Knuth (6.2.2) Algorithm T just like
+ * the AT&T man page says.
+ *
+ * The node_t structure is for internal use only, lint doesn't grok it.
+ *
+ * Written by reading the System V Interface Definition, not the code.
+ *
+ * Totally public domain.
+ */
+/*LINTLIBRARY*/
+#include <search.h>
+
+typedef struct node_t
+{
+    char          *key;
+    struct node_t *llink, *rlink;
+} node;
+
+/* find a node, or return 0 */
+void *
+tfind(const void *vkey, void * const *vrootp,
+    int (*compar)(const void *, const void *))
+{
+    char *key = (char *)vkey;
+    node **rootp = (node **)vrootp;
+
+    if (rootp == (struct node_t **)0)
+        return ((struct node_t *)0);
+    while (*rootp != (struct node_t *)0) {      /* T1: */
+        int r;
+        if ((r = (*compar)(key, (*rootp)->key)) == 0)   /* T2: */
+            return (*rootp);            /* key found */
+        rootp = (r < 0) ?
+            &(*rootp)->llink :          /* T3: follow left branch */
+            &(*rootp)->rlink;           /* T4: follow right branch */
+    }
+    return (node *)0;
+}
diff --git a/src/lib/libc/stdlib/tsearch.3 b/src/lib/libc/stdlib/tsearch.3
new file mode 100644
index 0000000000..0dc5c0c374
--- /dev/null
+++ b/src/lib/libc/stdlib/tsearch.3
@@ -0,0 +1,127 @@
+.\" $OpenBSD: tsearch.3,v 1.15 2006/04/04 19:07:23 otto Exp $
+.\"
+.\" Copyright (c) 1997 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.
+.\"
+.Dd June 15, 1997
+.Dt TSEARCH 3
+.Os
+.Sh NAME
+.Nm tsearch ,
+.Nm tfind ,
+.Nm tdelete ,
+.Nm twalk
+.Nd manipulate binary search trees
+.Sh SYNOPSIS
+.Fd #include <search.h>
+.Ft void *
+.Fn tdelete "const void *key" "void **rootp" "int (*compar) (const void *, const void *)"
+.Ft void *
+.Fn tfind "const void *key" "void * const *rootp" "int (*compar) (const void *, const void *)"
+.Ft void *
+.Fn tsearch "const void *key" "void **rootp" "int (*compar) (const void *, const void *)"
+.Ft void
+.Fn twalk "const void *root" "void (*action) (const void *, VISIT, int)"
+.Sh DESCRIPTION
+The
+.Fn tdelete ,
+.Fn tfind ,
+.Fn tsearch ,
+and
+.Fn twalk
+functions manage binary search trees based on algorithms T and D
+from Knuth (6.2.2).
+The comparison function passed in by
+the user has the same style of return values as
+.Xr strcmp 3 .
+.Pp
+.Fn tfind
+searches for the datum matched by the argument
+.Fa key
+in the binary tree rooted at
+.Fa rootp ,
+returning a pointer to the datum if it is found and
+.Dv NULL
+if it is not.
+.Pp
+.Fn tsearch
+is identical to
+.Fn tfind
+except that if no match is found,
+.Fa key
+is inserted into the tree and a pointer to it is returned.
+If
+.Fa rootp
+points to a null value a new binary search tree is created.
+.Pp
+.Fn tdelete
+deletes a node from the specified binary search tree and returns
+a pointer to the parent of the node to be deleted.
+It takes the same arguments as
+.Fn tfind
+and
+.Fn tsearch .
+If the node to be deleted is the root of the binary search tree,
+.Fa rootp
+will be adjusted and a pointer to the new root will be returned.
+.Pp
+.Fn twalk
+walks the binary search tree rooted in
+.Fa root
+and calls the function
+.Fa action
+on each node.
+.Fa action
+is called with three arguments: a pointer to the current node,
+a value from the enum
+.Sy "typedef enum { preorder, postorder, endorder, leaf } VISIT;"
+specifying the traversal type, and a node level (where level
+zero is the root of the tree).
+.Sh RETURN VALUES
+The
+.Fn tsearch
+function returns
+.Dv NULL
+if allocation of a new node fails (usually
+due to a lack of free memory).
+.Pp
+.Fn tfind ,
+.Fn tsearch ,
+and
+.Fn tdelete
+return
+.Dv NULL
+if
+.Fa rootp
+is
+.Dv NULL
+or the datum cannot be found.
+.Pp
+The
+.Fn twalk
+function returns no value.
+.Sh SEE ALSO
+.Xr bsearch 3 ,
+.Xr lsearch 3
+.Sh STANDARDS
+These functions conform to
+.St -p1003.1-2004 .
+.Sh CAVEATS
+The
+.St -p1003.1-2004
+standard does not specify what value should be returned when deleting the
+root node.
+Since implementations vary, the user of the
+.Fn tdelete
+function should not rely on a specific behaviour.
diff --git a/src/lib/libc/stdlib/tsearch.c b/src/lib/libc/stdlib/tsearch.c
new file mode 100644
index 0000000000..667c57731b
--- /dev/null
+++ b/src/lib/libc/stdlib/tsearch.c
@@ -0,0 +1,121 @@
+/*      $OpenBSD: tsearch.c,v 1.6 2006/04/04 11:21:50 moritz Exp $      */
+
+/*
+ * Tree search generalized from Knuth (6.2.2) Algorithm T just like
+ * the AT&T man page says.
+ *
+ * The node_t structure is for internal use only, lint doesn't grok it.
+ *
+ * Written by reading the System V Interface Definition, not the code.
+ *
+ * Totally public domain.
+ */
+/*LINTLIBRARY*/
+
+#include <search.h>
+#include <stdlib.h>
+
+typedef struct node_t {
+    char          *key;
+    struct node_t *left, *right;
+} node;
+
+/* find or insert datum into search tree */
+void *
+tsearch(const void *vkey, void **vrootp,
+    int (*compar)(const void *, const void *))
+{
+    node *q;
+    char *key = (char *)vkey;
+    node **rootp = (node **)vrootp;
+
+    if (rootp == (struct node_t **)0)
+        return ((void *)0);
+    while (*rootp != (struct node_t *)0) {      /* Knuth's T1: */
+        int r;
+
+        if ((r = (*compar)(key, (*rootp)->key)) == 0)   /* T2: */
+            return ((void *)*rootp);            /* we found it! */
+        rootp = (r < 0) ?
+            &(*rootp)->left :           /* T3: follow left branch */
+            &(*rootp)->right;           /* T4: follow right branch */
+    }
+    q = (node *) malloc(sizeof(node));  /* T5: key not found */
+    if (q != (struct node_t *)0) {      /* make new node */
+        *rootp = q;                     /* link new node to old */
+        q->key = key;                   /* initialize new node */
+        q->left = q->right = (struct node_t *)0;
+    }
+    return ((void *)q);
+}
+
+/* delete node with given key */
+void *
+tdelete(const void *vkey, void **vrootp,
+    int (*compar)(const void *, const void *))
+{
+    node **rootp = (node **)vrootp;
+    char *key = (char *)vkey;
+    node *p;
+    node *q;
+    node *r;
+    int cmp;
+
+    if (rootp == (struct node_t **)0 || (p = *rootp) == (struct node_t *)0)
+        return ((struct node_t *)0);
+    while ((cmp = (*compar)(key, (*rootp)->key)) != 0) {
+        p = *rootp;
+        rootp = (cmp < 0) ?
+            &(*rootp)->left :           /* follow left branch */
+            &(*rootp)->right;           /* follow right branch */
+        if (*rootp == (struct node_t *)0)
+            return ((void *)0);         /* key not found */
+    }
+    r = (*rootp)->right;                        /* D1: */
+    if ((q = (*rootp)->left) == (struct node_t *)0)     /* Left (struct node_t *)0? */
+        q = r;
+    else if (r != (struct node_t *)0) {         /* Right link is null? */
+        if (r->left == (struct node_t *)0) {    /* D2: Find successor */
+            r->left = q;
+            q = r;
+        } else {                        /* D3: Find (struct node_t *)0 link */
+            for (q = r->left; q->left != (struct node_t *)0; q = r->left)
+                r = q;
+            r->left = q->right;
+            q->left = (*rootp)->left;
+            q->right = (*rootp)->right;
+        }
+    }
+    if (p == *rootp)
+        p = q;
+    free((struct node_t *) *rootp);     /* D4: Free node */
+    *rootp = q;                         /* link parent to new node */
+    return(p);
+}
+
+/* Walk the nodes of a tree */
+static void
+trecurse(node *root, void (*action)(const void *, VISIT, int), int level)
+{
+    if (root->left == (struct node_t *)0 && root->right == (struct node_t *)0)
+        (*action)(root, leaf, level);
+    else {
+        (*action)(root, preorder, level);
+        if (root->left != (struct node_t *)0)
+            trecurse(root->left, action, level + 1);
+        (*action)(root, postorder, level);
+        if (root->right != (struct node_t *)0)
+            trecurse(root->right, action, level + 1);
+        (*action)(root, endorder, level);
+    }
+}
+
+/* Walk the nodes of a tree */
+void
+twalk(const void *vroot, void (*action)(const void *, VISIT, int))
+{
+    node *root = (node *)vroot;
+
+    if (root != (node *)0 && action != (void (*)(const void *, VISIT, int))0)
+        trecurse(root, action, 0);
+}
diff --git a/src/lib/libc/string/Makefile.inc b/src/lib/libc/string/Makefile.inc
new file mode 100644
index 0000000000..72ec34e694
--- /dev/null
+++ b/src/lib/libc/string/Makefile.inc
@@ -0,0 +1,177 @@
+#       $OpenBSD: Makefile.inc,v 1.18 2005/10/29 10:05:11 espie Exp $
+
+# string sources
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/string ${LIBCSRCDIR}/string
+
+SRCS+=  bm.c memccpy.c strcasecmp.c strcasestr.c strcoll.c strdup.c \
+        strerror.c strerror_r.c strlcat.c strmode.c strsignal.c strtok.c \
+        strxfrm.c \
+        wcscat.c wcschr.c wcscmp.c wcscpy.c wcscspn.c wcslcat.c wcslcpy.c \
+        wcslen.c wcsncat.c wcsncmp.c wcsncpy.c wcspbrk.c wcsrchr.c wcsspn.c \
+        wcsstr.c wcstok.c wcswcs.c wcswidth.c wmemchr.c wmemcmp.c wmemcpy.c \
+        wmemmove.c wmemset.c
+
+# machine-dependent net sources
+# m-d Makefile.inc must include sources for:
+#       bcmp() bcopy() bzero() ffs() index() memchr() memcmp() memset()
+#       rindex() strcat() strcmp() strcpy() strcspn() strlen() strlcpy()
+#       strncat() strncmp() strncpy() strpbrk() strsep()
+#       strspn() strstr() swav()
+# m-d Makefile.inc may include sources for:
+#       memcpy() memmove() strchr() strrchr()
+
+.include "${LIBCSRCDIR}/arch/${MACHINE_ARCH}/string/Makefile.inc"
+
+# if no machine specific memmove(3), build one out of bcopy(3).
+.if empty(SRCS:Mmemmove.S)
+OBJS+=  memmove.o
+memmove.o: bcopy.c
+        ${CC} -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memmove.go: bcopy.c
+        ${CC} -g -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memmove.po: bcopy.c
+        ${CC} -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
+        @${LD} -X -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memmove.so: bcopy.c
+        ${CC} ${PICFLAG} -DPIC -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
+                -o ${.TARGET}
+.endif
+
+# if no machine specific memcpy(3), build one out of bcopy(3).
+# if there is a machine specific memmove(3), we'll assume it aliases
+# memcpy(3).
+.if empty(SRCS:Mmemcpy.S)
+.if empty(SRCS:Mmemmove.S)
+OBJS+=  memcpy.o
+memcpy.o: bcopy.c
+        ${CC} -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memcpy.go: bcopy.c
+        ${CC} -g -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memcpy.po: bcopy.c
+        ${CC} -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
+        @${LD} -X -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+memcpy.so: bcopy.c
+        ${CC} ${PICFLAG} -DPIC -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
+                -o ${.TARGET}
+.endif
+.endif
+
+# if no machine specific strchr(3), build one out of index(3).
+.if empty(SRCS:Mstrchr.S)
+OBJS+=  strchr.o
+strchr.o: index.c
+        ${CC} -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strchr.go: index.c
+        ${CC} -g -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strchr.po: index.c
+        ${CC} -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
+        @${LD} -X -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strchr.so: index.c
+        ${CC} ${PICFLAG} -DPIC -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
+            -o ${.TARGET}
+.endif
+
+# if no machine specific strrchr(3), build one out of rindex(3).
+.if empty(SRCS:Mstrrchr.S)
+OBJS+=  strrchr.o
+strrchr.o: rindex.c
+        ${CC} -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strrchr.go: rindex.c
+        ${CC} -g -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strrchr.po: rindex.c
+        ${CC} -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
+        @${LD} -X -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
+strrchr.so: rindex.c
+        ${CC} ${PICFLAG} -DPIC -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
+            -o ${.TARGET}
+.endif
+
+# build .ln files for memmove, memcpy, strchr and strrchr always from
+# bcopy, index, and rindex
+LOBJS+= memmove.ln memcpy.ln strchr.ln strrchr.ln
+
+memmove.ln: bcopy.c
+        lint ${LINTFLAGS} -DMEMMOVE ${CFLAGS:M-[IDU]*} -i -o ${.TARGET} \
+                ${LIBCSRCDIR}/string/bcopy.c
+
+memcpy.ln: bcopy.c
+        lint ${LINTFLAGS} -DMEMCOPY ${CFLAGS:M-[IDU]*} -i -o ${.TARGET} \
+                ${LIBCSRCDIR}/string/bcopy.c
+
+strchr.ln: index.c
+        lint ${LINTFLAGS} -DSTRCHR ${CFLAGS:M-[IDU]*} -i -o ${.TARGET} \
+                ${LIBCSRCDIR}/string/index.c
+
+strrchr.ln: rindex.c
+        lint ${LINTFLAGS} -DSTRRCHR ${CFLAGS:M-[IDU]*} -i -o ${.TARGET} \
+                ${LIBCSRCDIR}/string/rindex.c
+
+MAN+=   bm.3 bcmp.3 bcopy.3 bstring.3 bzero.3 ffs.3 memccpy.3 memchr.3 \
+        memcmp.3 memcpy.3 memmove.3 memset.3 strcasecmp.3 strcat.3 \
+        strchr.3 strcmp.3 strcoll.3 strcpy.3 strcspn.3 strerror.3 \
+        string.3 strlen.3 strmode.3 strdup.3 strpbrk.3 strrchr.3 strsep.3 \
+        strsignal.3 strspn.3 strstr.3 strtok.3 strxfrm.3 swab.3 strlcpy.3 \
+        wcstok.3 wmemchr.3
+
+MLINKS+=bm.3 bm_comp.3 bm.3 bm_exec.3 bm.3 bm_free.3
+MLINKS+=strchr.3 index.3
+MLINKS+=strrchr.3 rindex.3
+MLINKS+=strcasecmp.3 strncasecmp.3
+MLINKS+=strcat.3 strncat.3
+MLINKS+=strcmp.3 strncmp.3
+MLINKS+=strcpy.3 strncpy.3
+MLINKS+=strlcpy.3 strlcat.3
+MLINKS+=strstr.3 strcasestr.3
+MLINKS+=strtok.3 strtok_r.3
+MLINKS+=strerror.3 strerror_r.3
+MLINKS+=wmemchr.3 wmemcmp.3
+MLINKS+=wmemchr.3 wmemcpy.3
+MLINKS+=wmemchr.3 wmemmove.3
+MLINKS+=wmemchr.3 wmemset.3
+MLINKS+=wmemchr.3 wcscat.3
+MLINKS+=wmemchr.3 wcschr.3
+MLINKS+=wmemchr.3 wcscmp.3
+MLINKS+=wmemchr.3 wcscpy.3
+MLINKS+=wmemchr.3 wcscspn.3
+MLINKS+=wmemchr.3 wcslcat.3
+MLINKS+=wmemchr.3 wcslcpy.3
+MLINKS+=wmemchr.3 wcslen.3
+MLINKS+=wmemchr.3 wcsncat.3
+MLINKS+=wmemchr.3 wcsncmp.3
+MLINKS+=wmemchr.3 wcsncpy.3
+MLINKS+=wmemchr.3 wcspbrk.3
+MLINKS+=wmemchr.3 wcsrchr.3
+MLINKS+=wmemchr.3 wcsspn.3
+MLINKS+=wmemchr.3 wcsstr.3
diff --git a/src/lib/libc/string/bcmp.3 b/src/lib/libc/string/bcmp.3
new file mode 100644
index 0000000000..953476caa7
--- /dev/null
+++ b/src/lib/libc/string/bcmp.3
@@ -0,0 +1,66 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: bcmp.3,v 1.6 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd April 19, 1991
+.Dt BCMP 3
+.Os
+.Sh NAME
+.Nm bcmp
+.Nd compare byte string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn bcmp "const void *b1" "const void *b2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn bcmp
+function compares byte string
+.Fa b1
+against byte string
+.Fa b2 ,
+returning zero if they are identical, non-zero otherwise.
+Both strings are assumed to be
+.Fa len
+bytes long.
+Zero-length strings are always identical.
+.Pp
+The strings may overlap.
+.Sh SEE ALSO
+.Xr memcmp 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcmp 3 ,
+.Xr strcoll 3 ,
+.Xr strxfrm 3
+.Sh HISTORY
+A
+.Fn bcmp
+function first appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/string/bcmp.c b/src/lib/libc/string/bcmp.c
new file mode 100644
index 0000000000..a35689a209
--- /dev/null
+++ b/src/lib/libc/string/bcmp.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: bcmp.c,v 1.8 2005/08/08 08:05:37 espie Exp $  */
+
+/*
+ * Copyright (c) 1987 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+/*
+ * bcmp -- vax cmpc3 instruction
+ */
+int
+bcmp(const void *b1, const void *b2, size_t length)
+{
+        char *p1, *p2;
+
+        if (length == 0)
+                return(0);
+        p1 = (char *)b1;
+        p2 = (char *)b2;
+        do
+                if (*p1++ != *p2++)
+                        break;
+        while (--length);
+        return(length);
+}
diff --git a/src/lib/libc/string/bcopy.3 b/src/lib/libc/string/bcopy.3
new file mode 100644
index 0000000000..7b55bcbf43
--- /dev/null
+++ b/src/lib/libc/string/bcopy.3
@@ -0,0 +1,67 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: bcopy.3,v 1.8 2003/06/21 12:04:01 avsm Exp $
+.\"
+.Dd April 19, 1991
+.Dt BCOPY 3
+.Os
+.Sh NAME
+.Nm bcopy
+.Nd copy bytes
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void
+.Fn bcopy "const void *src" "void *dst" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn bcopy
+function copies
+.Fa len
+bytes from buffer
+.Fa src
+to buffer
+.Fa dst .
+The two buffers may overlap.
+If
+.Fa len
+is zero, no bytes are copied.
+.Sh SEE ALSO
+.Xr memccpy 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr strncpy 3
+.Sh HISTORY
+A
+.Fn bcopy
+function appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/string/bcopy.c b/src/lib/libc/string/bcopy.c
new file mode 100644
index 0000000000..4308c6484a
--- /dev/null
+++ b/src/lib/libc/string/bcopy.c
@@ -0,0 +1,128 @@
+/*      $OpenBSD: bcopy.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * sizeof(word) MUST BE A POWER OF TWO
+ * SO THAT wmask BELOW IS ALL ONES
+ */
+typedef long word;              /* "word" used for optimal copy speed */
+
+#define wsize   sizeof(word)
+#define wmask   (wsize - 1)
+
+/*
+ * Copy a block of memory, handling overlap.
+ * This is the routine that actually implements
+ * (the portable versions of) bcopy, memcpy, and memmove.
+ */
+#ifdef MEMCOPY
+void *
+memcpy(void *dst0, const void *src0, size_t length)
+#else
+#ifdef MEMMOVE
+void *
+memmove(void *dst0, const void *src0, size_t length)
+#else
+void
+bcopy(const void *src0, void *dst0, size_t length)
+#endif
+#endif
+{
+        char *dst = dst0;
+        const char *src = src0;
+        size_t t;
+
+        if (length == 0 || dst == src)          /* nothing to do */
+                goto done;
+
+        /*
+         * Macros: loop-t-times; and loop-t-times, t>0
+         */
+#define TLOOP(s) if (t) TLOOP1(s)
+#define TLOOP1(s) do { s; } while (--t)
+
+        if ((unsigned long)dst < (unsigned long)src) {
+                /*
+                 * Copy forward.
+                 */
+                t = (long)src;  /* only need low bits */
+                if ((t | (long)dst) & wmask) {
+                        /*
+                         * Try to align operands.  This cannot be done
+                         * unless the low bits match.
+                         */
+                        if ((t ^ (long)dst) & wmask || length < wsize)
+                                t = length;
+                        else
+                                t = wsize - (t & wmask);
+                        length -= t;
+                        TLOOP1(*dst++ = *src++);
+                }
+                /*
+                 * Copy whole words, then mop up any trailing bytes.
+                 */
+                t = length / wsize;
+                TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
+                t = length & wmask;
+                TLOOP(*dst++ = *src++);
+        } else {
+                /*
+                 * Copy backwards.  Otherwise essentially the same.
+                 * Alignment works as before, except that it takes
+                 * (t&wmask) bytes to align, not wsize-(t&wmask).
+                 */
+                src += length;
+                dst += length;
+                t = (long)src;
+                if ((t | (long)dst) & wmask) {
+                        if ((t ^ (long)dst) & wmask || length <= wsize)
+                                t = length;
+                        else
+                                t &= wmask;
+                        length -= t;
+                        TLOOP1(*--dst = *--src);
+                }
+                t = length / wsize;
+                TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
+                t = length & wmask;
+                TLOOP(*--dst = *--src);
+        }
+done:
+#if defined(MEMCOPY) || defined(MEMMOVE)
+        return (dst0);
+#else
+        return;
+#endif
+}
diff --git a/src/lib/libc/string/bm.3 b/src/lib/libc/string/bm.3
new file mode 100644
index 0000000000..b586a63398
--- /dev/null
+++ b/src/lib/libc/string/bm.3
@@ -0,0 +1,112 @@
+.\" Copyright (c) 1994
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Andrew Hume of AT&T Bell Laboratories.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: bm.3,v 1.8 2005/08/06 03:19:23 jaredy Exp $
+.\"
+.Dd June 29, 1999
+.Dt BM 3
+.Os
+.Sh NAME
+.Nm bm_comp ,
+.Nm bm_exec ,
+.Nm bm_free
+.Nd Boyer-Moore string search
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <bm.h>
+.Ft bm_pat *
+.Fn bm_comp "const unsigned char *pattern" "size_t patlen" \
+    "const unsigned char freq[256]"
+.Ft unsigned char *
+.Fn bm_exec "bm_pat *pdesc" "unsigned char *text" "size_t len"
+.Ft void
+.Fn bm_free "bm_pat *pdesc"
+.Sh DESCRIPTION
+These routines implement an efficient mechanism to find an
+occurrence of a byte string within another byte string.
+.Pp
+.Fn bm_comp
+evaluates
+.Fa patlen
+bytes starting at
+.Fa pattern
+and returns a pointer to a structure describing them.
+The bytes referenced by
+.Fa pattern
+may be of any value.
+.Pp
+The search takes advantage of the frequency distribution of the
+bytes in the text to be searched.
+If specified,
+.Ar freq
+should be an array of 256 values,
+with higher values indicating that the corresponding character occurs
+more frequently.
+(A less than optimal frequency distribution can only result in less
+than optimal performance, not incorrect results.)
+If
+.Ar freq
+is
+.Dv NULL ,
+a system default table is used.
+.Pp
+.Fn bm_exec
+returns a pointer to the leftmost occurrence of the string given to
+.Fn bm_comp
+within
+.Ar text ,
+or
+.Dv NULL
+if none occurs.
+The number of bytes in
+.Ar text
+must be specified by
+.Ar len .
+.Pp
+Space allocated for the returned description is discarded
+by calling
+.Fn bm_free
+with the returned description as an argument.
+.Pp
+The asymptotic speed of
+.Fn bm_exec
+is
+.Pf O Ns Pq len / patlen .
+.Sh SEE ALSO
+.Xr regexp 3 ,
+.Xr strstr 3
+.Rs
+.%R "Fast String Searching"
+.%A Andrew Hume
+.%A Daniel Sunday
+.%J "Software Practice and Experience"
+.%V Volume 21, 11 (November 1991)
+.%P 1221-48
+.Re
diff --git a/src/lib/libc/string/bm.c b/src/lib/libc/string/bm.c
new file mode 100644
index 0000000000..829c24082e
--- /dev/null
+++ b/src/lib/libc/string/bm.c
@@ -0,0 +1,205 @@
+/*      $OpenBSD: bm.c,v 1.6 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Andrew Hume of AT&T Bell Laboratories.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+#include <bm.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* 
+ * XXX
+ * The default frequency table starts at 99 and counts down.  The default
+ * table should probably be oriented toward text, and will necessarily be
+ * locale specific.  This one is for English.  It was derived from the
+ * OSF/1 and 4.4BSD formatted and unformatted manual pages, and about 100Mb
+ * of email and random text.  Change it if you can find something better.
+ */
+static u_char const freq_def[256] = {
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0, 77, 90,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+        99, 28, 42, 27, 16, 14, 20, 51,
+        66, 65, 59, 24, 75, 76, 84, 56,
+        72, 74, 64, 55, 54, 47, 41, 37,
+        44, 61, 70, 43, 23, 53, 49, 22,
+        33, 58, 40, 46, 45, 57, 60, 26,
+        30, 63, 21, 12, 32, 50, 38, 39,
+        34, 11, 48, 67, 62, 35, 15, 29,
+        71, 18,  9, 17, 25, 13, 10, 52,
+        36, 95, 78, 86, 87, 98, 82, 80,
+        88, 94, 19, 68, 89, 83, 93, 96,
+        81,  7, 91, 92, 97, 85, 69, 73,
+        31, 79,  8,  5,  4,  6,  3,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+         0,  0,  0,  0,  0,  0,  0,  0,
+};
+
+bm_pat *
+bm_comp(u_char const *pb, size_t len, u_char const *freq)
+{
+        u_char const *pe, *p;
+        size_t *d, r;
+        int j;
+        int sv_errno;
+        bm_pat *pat;
+
+        if (len == 0) {
+                errno = EINVAL;
+                return (NULL);
+        }
+        if ((pat = malloc(sizeof(*pat))) == NULL)
+                return (NULL);
+        pat->pat = NULL;
+        pat->delta = NULL;
+
+        pat->patlen = len;                      /* copy pattern */
+        if ((pat->pat = malloc(pat->patlen)) == NULL)
+                goto mem;
+        memcpy(pat->pat, pb, pat->patlen);
+                                                /* get skip delta */
+        if ((pat->delta = malloc(256 * sizeof(*d))) == NULL)
+                goto mem;
+        for (j = 0, d = pat->delta; j < 256; j++)
+                d[j] = pat->patlen;
+        for (pe = pb + pat->patlen - 1; pb <= pe; pb++)
+                d[*pb] = pe - pb;
+
+        if (freq == NULL)                       /* default freq table */
+                freq = freq_def;
+        r = 0;                                  /* get guard */
+        for (pb = pat->pat, pe = pb + pat->patlen - 1; pb < pe; pb++)
+                if (freq[*pb] < freq[pat->pat[r]])
+                        r = pb - pat->pat;
+        pat->rarec = pat->pat[r];
+        pat->rareoff = r - (pat->patlen - 1);
+
+                                                /* get md2 shift */
+        for (pe = pat->pat + pat->patlen - 1, p = pe - 1; p >= pat->pat; p--)
+                if (*p == *pe)
+                        break;
+
+        /* *p is first leftward reoccurrence of *pe */
+        pat->md2 = pe - p;
+        return (pat);
+
+mem:    sv_errno = errno;
+        bm_free(pat);
+        errno = sv_errno;
+        return (NULL);
+}
+
+void
+bm_free(bm_pat *pat)
+{
+        if (pat->pat != NULL)
+                free(pat->pat);
+        if (pat->delta != NULL)
+                free(pat->delta);
+        free(pat);
+}
+
+u_char *
+bm_exec(bm_pat *pat, u_char *base, size_t n)
+{
+        u_char *e, *ep, *p, *q, *s;
+        size_t *d0, k, md2, n1, ro;
+        int rc;
+
+        if (n == 0)
+                return (NULL);
+
+        d0 = pat->delta;
+        n1 = pat->patlen - 1;
+        md2 = pat->md2;
+        ro = pat->rareoff;
+        rc = pat->rarec;
+        ep = pat->pat + pat->patlen - 1;
+        s = base + (pat->patlen - 1);
+
+        /* fast loop up to n - 3 * patlen */
+        e = base + n - 3 * pat->patlen;
+        while (s < e) {
+                k = d0[*s];             /* ufast skip loop */
+                while (k) {
+                        k = d0[*(s += k)];
+                        k = d0[*(s += k)];
+                }
+                if (s >= e)
+                        break;
+                if (s[ro] != rc)        /* guard test */
+                        goto mismatch1;
+                                        /* fwd match */
+                for (p = pat->pat, q = s - n1; p < ep;)
+                        if (*q++ != *p++)
+                                goto mismatch1;
+                return (s - n1);
+
+mismatch1:      s += md2;               /* md2 shift */
+        }
+
+        /* slow loop up to end */
+        e = base + n;
+        while (s < e) {
+                s += d0[*s];            /* step */
+                if (s >= e)
+                        break;
+                if (s[ro] != rc)        /* guard test */
+                        goto mismatch2;
+                                        /* fwd match */
+                for (p = pat->pat, q = s - n1; p <= ep;)
+                        if (*q++ != *p++)
+                                goto mismatch2;
+                return (s - n1);
+
+mismatch2:      s += md2;               /* md2 shift */
+        }
+
+        return (NULL);
+}
diff --git a/src/lib/libc/string/bstring.3 b/src/lib/libc/string/bstring.3
new file mode 100644
index 0000000000..bcb5ac98fc
--- /dev/null
+++ b/src/lib/libc/string/bstring.3
@@ -0,0 +1,98 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: bstring.3,v 1.7 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd April 19, 1991
+.Dt BSTRING 3
+.Os
+.Sh NAME
+.Nm bstring
+.Nd byte string operations
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn bcmp "const void *b1" "const void *b2" "size_t len"
+.Ft void
+.Fn bcopy "const void *src" "void *dst" "size_t len"
+.Ft void
+.Fn bzero "void *b" "size_t len"
+.Ft void *
+.Fn memchr "const void *b" "int c" "size_t len"
+.Ft int
+.Fn memcmp "const void *b1" "const void *b2" "size_t len"
+.Ft void *
+.Fn memccpy "void *dst" "const void *src" "int c" "size_t len"
+.Ft void *
+.Fn memcpy "void *dst" "const void *src" "size_t len"
+.Ft void *
+.Fn memmove "void *dst" "const void *src" "size_t len"
+.Ft void *
+.Fn memset "void *b" "int c" "size_t len"
+.Sh DESCRIPTION
+These functions operate on variable length strings of bytes.
+They do not check for terminating NUL bytes as the routines
+listed in
+.Xr string 3
+do.
+.Pp
+See the specific manual pages for more information.
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr bcopy 3 ,
+.Xr bzero 3 ,
+.Xr memccpy 3 ,
+.Xr memchr 3 ,
+.Xr memcmp 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr memset 3
+.Sh STANDARDS
+The functions
+.Fn memchr ,
+.Fn memcmp ,
+.Fn memcpy ,
+.Fn memmove ,
+and
+.Fn memset
+conform to
+.St -ansiC .
+.Sh HISTORY
+The
+.Fn bzero
+and
+.Fn memccpy
+functions appeared in
+.Bx 4.3 .
+The
+.Fn bcmp
+and
+.Fn bcopy
+functions appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/string/bzero.3 b/src/lib/libc/string/bzero.3
new file mode 100644
index 0000000000..592d9f2f08
--- /dev/null
+++ b/src/lib/libc/string/bzero.3
@@ -0,0 +1,61 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: bzero.3,v 1.6 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd April 19, 1991
+.Dt BZERO 3
+.Os
+.Sh NAME
+.Nm bzero
+.Nd write zeroes to a byte string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void
+.Fn bzero "void *b" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn bzero
+function writes
+.Fa len
+zero bytes to the string
+.Fa b .
+If
+.Fa len
+is zero,
+.Fn bzero
+does nothing.
+.Sh SEE ALSO
+.Xr memset 3 ,
+.Xr swab 3
+.Sh HISTORY
+A
+.Fn bzero
+function appeared in
+.Bx 4.3 .
diff --git a/src/lib/libc/string/bzero.c b/src/lib/libc/string/bzero.c
new file mode 100644
index 0000000000..4d267d4f40
--- /dev/null
+++ b/src/lib/libc/string/bzero.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: bzero.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+
+/*
+ * Copyright (c) 1987 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+/*
+ * bzero -- vax movc5 instruction
+ */
+void
+bzero(void *b, size_t length)
+{
+        char *p;
+
+        for (p = b; length--;)
+                *p++ = '\0';
+}
diff --git a/src/lib/libc/string/ffs.3 b/src/lib/libc/string/ffs.3
new file mode 100644
index 0000000000..a2f0cd336d
--- /dev/null
+++ b/src/lib/libc/string/ffs.3
@@ -0,0 +1,56 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: ffs.3,v 1.4 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd April 19, 1991
+.Dt FFS 3
+.Os
+.Sh NAME
+.Nm ffs
+.Nd find first bit set in a bit string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn ffs "int value"
+.Sh DESCRIPTION
+The
+.Fn ffs
+function finds the first bit set in
+.Fa value
+and returns the index of that bit.
+Bits are numbered starting from 1, starting at the rightmost bit.
+A return value of 0 means that the argument was zero.
+.Sh SEE ALSO
+.Xr bitstring 3
+.Sh HISTORY
+The
+.Fn ffs
+function appeared in
+.Bx 4.3 .
diff --git a/src/lib/libc/string/ffs.c b/src/lib/libc/string/ffs.c
new file mode 100644
index 0000000000..7dec1613a8
--- /dev/null
+++ b/src/lib/libc/string/ffs.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: ffs.c,v 1.7 2005/08/08 08:05:37 espie Exp $   */
+
+/*
+ * Public domain.
+ * Written by Dale Rahn.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+/*
+ * ffs -- vax ffs instruction
+ */
+int
+ffs(int mask)
+{
+        int bit;
+        unsigned int r = mask;
+        static const signed char t[16] = {
+                -28, 1, 2, 1,
+                  3, 1, 2, 1,
+                  4, 1, 2, 1,
+                  3, 1, 2, 1
+        };
+
+        bit = 0;
+        if (!(r & 0xffff)) {
+                bit += 16;
+                r >>= 16;
+        }
+        if (!(r & 0xff)) {
+                bit += 8;
+                r >>= 8;
+        }
+        if (!(r & 0xf)) {
+                bit += 4;
+                r >>= 4;
+        }
+
+        return (bit + t[ r & 0xf ]);
+}
diff --git a/src/lib/libc/string/index.c b/src/lib/libc/string/index.c
new file mode 100644
index 0000000000..50e9ca35ab
--- /dev/null
+++ b/src/lib/libc/string/index.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: index.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <string.h>
+
+char *
+#ifdef STRCHR
+strchr(const char *p, int ch)
+#else
+index(const char *p, int ch)
+#endif
+{
+        for (;; ++p) {
+                if (*p == ch)
+                        return((char *)p);
+                if (!*p)
+                        return((char *)NULL);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/memccpy.3 b/src/lib/libc/string/memccpy.3
new file mode 100644
index 0000000000..8c159cb8de
--- /dev/null
+++ b/src/lib/libc/string/memccpy.3
@@ -0,0 +1,73 @@
+.\" $OpenBSD: memccpy.3,v 1.8 2003/06/02 20:18:38 millert Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)memccpy.3   8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt MEMCCPY 3
+.Os
+.Sh NAME
+.Nm memccpy
+.Nd copy string until character found
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void *
+.Fn memccpy "void *dst" "const void *src" "int c" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memccpy
+function copies bytes from string
+.Fa src
+to string
+.Fa dst .
+If the character
+.Fa c
+(as converted to an
+.Li unsigned char )
+occurs in the string
+.Fa src ,
+the copy stops and a pointer to the byte after the copy of
+.Fa c
+in the string
+.Fa dst
+is returned.
+Otherwise,
+.Fa len
+bytes are copied, and a null pointer is returned.
+.Sh SEE ALSO
+.Xr bcopy 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr strcpy 3 ,
+.Xr strlcpy 3
+.Sh HISTORY
+The
+.Fn memccpy
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/memccpy.c b/src/lib/libc/string/memccpy.c
new file mode 100644
index 0000000000..485c55fcab
--- /dev/null
+++ b/src/lib/libc/string/memccpy.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: memccpy.c,v 1.6 2005/08/08 08:05:37 espie Exp $       */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      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.
+ */
+
+#include <string.h>
+
+void *
+memccpy(void *t, const void *f, int c, size_t n)
+{
+
+        if (n) {
+                unsigned char *tp = t;
+                const unsigned char *fp = f;
+                unsigned char uc = c;
+                do {
+                        if ((*tp++ = *fp++) == uc)
+                                return (tp);
+                } while (--n != 0);
+        }
+        return (0);
+}
diff --git a/src/lib/libc/string/memchr.3 b/src/lib/libc/string/memchr.3
new file mode 100644
index 0000000000..ddca58bc5e
--- /dev/null
+++ b/src/lib/libc/string/memchr.3
@@ -0,0 +1,74 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: memchr.3,v 1.6 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt MEMCHR 3
+.Os
+.Sh NAME
+.Nm memchr
+.Nd locate byte in byte string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void *
+.Fn memchr "const void *b" "int c" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memchr
+function locates the first occurrence of
+.Fa c
+(converted to an
+.Li unsigned char )
+in string
+.Fa b .
+.Sh RETURN VALUES
+The
+.Fn memchr
+function returns a pointer to the byte located, or
+.Dv NULL
+if no such byte exists within
+.Fa len
+bytes.
+.Sh SEE ALSO
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn memchr
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/memchr.c b/src/lib/libc/string/memchr.c
new file mode 100644
index 0000000000..4573e3ceb1
--- /dev/null
+++ b/src/lib/libc/string/memchr.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: memchr.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+void *
+memchr(const void *s, int c, size_t n)
+{
+        if (n != 0) {
+                const unsigned char *p = s;
+
+                do {
+                        if (*p++ == (unsigned char)c)
+                                return ((void *)(p - 1));
+                } while (--n != 0);
+        }
+        return (NULL);
+}
diff --git a/src/lib/libc/string/memcmp.3 b/src/lib/libc/string/memcmp.3
new file mode 100644
index 0000000000..bd46e6898e
--- /dev/null
+++ b/src/lib/libc/string/memcmp.3
@@ -0,0 +1,77 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: memcmp.3,v 1.5 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt MEMCMP 3
+.Os
+.Sh NAME
+.Nm memcmp
+.Nd compare byte string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn memcmp "const void *b1" "const void *b2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memcmp
+function compares byte string
+.Fa b1
+against byte string
+.Fa b2 .
+Both strings are assumed to be
+.Fa len
+bytes long.
+.Sh RETURN VALUES
+The
+.Fn memcmp
+function returns zero if the two strings are identical,
+otherwise returns the difference between the first two differing bytes
+(treated as
+.Li unsigned char
+values, so that
+.Sq Li \e200
+is greater than
+.Sq Li \&\e0 ,
+for example).
+Zero-length strings are always identical.
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcmp 3 ,
+.Xr strcoll 3 ,
+.Xr strxfrm 3
+.Sh STANDARDS
+The
+.Fn memcmp
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/memcmp.c b/src/lib/libc/string/memcmp.c
new file mode 100644
index 0000000000..49384a6fb9
--- /dev/null
+++ b/src/lib/libc/string/memcmp.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: memcmp.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Compare memory regions.
+ */
+int
+memcmp(const void *s1, const void *s2, size_t n)
+{
+        if (n != 0) {
+                const unsigned char *p1 = s1, *p2 = s2;
+
+                do {
+                        if (*p1++ != *p2++)
+                                return (*--p1 - *--p2);
+                } while (--n != 0);
+        }
+        return (0);
+}
diff --git a/src/lib/libc/string/memcpy.3 b/src/lib/libc/string/memcpy.3
new file mode 100644
index 0000000000..c8265d94a6
--- /dev/null
+++ b/src/lib/libc/string/memcpy.3
@@ -0,0 +1,77 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: memcpy.3,v 1.6 2003/06/21 12:04:01 avsm Exp $
+.\"
+.Dd June 29, 1991
+.Dt MEMCPY 3
+.Os
+.Sh NAME
+.Nm memcpy
+.Nd copy bytes
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void *
+.Fn memcpy "void *dst" "const void *src" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memcpy
+function copies
+.Fa len
+bytes from buffer
+.Fa src
+to buffer
+.Fa dst .
+.Sh RETURN VALUES
+The
+.Fn memcpy
+function returns the original value of
+.Fa dst .
+.Sh SEE ALSO
+.Xr bcopy 3 ,
+.Xr memccpy 3 ,
+.Xr memmove 3 ,
+.Xr strcpy 3 ,
+.Xr strlcpy 3
+.Sh STANDARDS
+The
+.Fn memcpy
+function conforms to
+.St -ansiC .
+.Sh BUGS
+In this implementation
+.Fn memcpy
+is implemented using
+.Xr bcopy 3 ,
+and therefore the buffers may overlap.
+On other systems, copying overlapping buffers may produce surprises.
+A simpler solution is to not use
+.Fn memcpy .
diff --git a/src/lib/libc/string/memmove.3 b/src/lib/libc/string/memmove.3
new file mode 100644
index 0000000000..d4a364eb36
--- /dev/null
+++ b/src/lib/libc/string/memmove.3
@@ -0,0 +1,70 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: memmove.3,v 1.6 2003/06/21 12:04:01 avsm Exp $
+.\"
+.Dd June 29, 1991
+.Dt MEMMOVE 3
+.Os
+.Sh NAME
+.Nm memmove
+.Nd copy bytes
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void *
+.Fn memmove "void *dst" "const void *src" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memmove
+function copies
+.Fa len
+bytes from buffer
+.Fa src
+to buffer
+.Fa dst .
+The two buffers may overlap;
+the copy is always done in a non-destructive manner.
+.Sh RETURN VALUES
+The
+.Fn memmove
+function returns the original value of
+.Fa dst .
+.Sh SEE ALSO
+.Xr bcopy 3 ,
+.Xr memccpy 3 ,
+.Xr memcpy 3 ,
+.Xr strcpy 3 ,
+.Xr strlcpy 3
+.Sh STANDARDS
+The
+.Fn memmove
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/memset.3 b/src/lib/libc/string/memset.3
new file mode 100644
index 0000000000..291b1427dc
--- /dev/null
+++ b/src/lib/libc/string/memset.3
@@ -0,0 +1,67 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: memset.3,v 1.5 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt MEMSET 3
+.Os
+.Sh NAME
+.Nm memset
+.Nd write a byte to byte string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void *
+.Fn memset "void *b" "int c" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn memset
+function writes
+.Fa len
+bytes of value
+.Fa c
+(converted to an
+.Li unsigned char )
+to the string
+.Fa b .
+.Sh RETURN VALUES
+The
+.Fn memset
+function returns the original value of
+.Fa b .
+.Sh SEE ALSO
+.Xr bzero 3 ,
+.Xr swab 3
+.Sh STANDARDS
+The
+.Fn memset
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/memset.c b/src/lib/libc/string/memset.c
new file mode 100644
index 0000000000..db32866a0e
--- /dev/null
+++ b/src/lib/libc/string/memset.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: memset.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+void *
+memset(void *dst, int c, size_t n)
+{
+
+        if (n != 0) {
+                char *d = dst;
+
+                do
+                        *d++ = c;
+                while (--n != 0);
+        }
+        return (dst);
+}
diff --git a/src/lib/libc/string/rindex.c b/src/lib/libc/string/rindex.c
new file mode 100644
index 0000000000..bf9d6f7cf1
--- /dev/null
+++ b/src/lib/libc/string/rindex.c
@@ -0,0 +1,49 @@
+/*      $OpenBSD: rindex.c,v 1.6 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <string.h>
+
+char *
+#ifdef STRRCHR
+strrchr(const char *p, int ch)
+#else
+rindex(const char *p, int ch)
+#endif
+{
+        char *save;
+
+        for (save = NULL;; ++p) {
+                if (*p == ch)
+                        save = (char *)p;
+                if (!*p)
+                        return(save);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/strcasecmp.3 b/src/lib/libc/string/strcasecmp.3
new file mode 100644
index 0000000000..c4253e5afd
--- /dev/null
+++ b/src/lib/libc/string/strcasecmp.3
@@ -0,0 +1,84 @@
+.\" $OpenBSD: strcasecmp.3,v 1.9 2005/02/25 03:12:44 cloder Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     @(#)strcasecmp.3        8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt STRCASECMP 3
+.Os
+.Sh NAME
+.Nm strcasecmp ,
+.Nm strncasecmp
+.Nd compare strings, ignoring case
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn strcasecmp "const char *s1" "const char *s2"
+.Ft int
+.Fn strncasecmp "const char *s1" "const char *s2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn strcasecmp
+and
+.Fn strncasecmp
+functions compare the NUL-terminated strings
+.Fa s1
+and
+.Fa s2
+and return an integer greater than, equal to, or less than 0,
+according to whether
+.Fa s1
+is lexicographically greater than, equal to, or less than
+.Fa s2
+after translation of each corresponding character to lower-case.
+The strings themselves are not modified.
+The comparison is done using unsigned characters, so that
+.Sq Li \e200
+is greater than
+.Ql \e0 .
+.Pp
+.Fn strncasecmp
+compares at most
+.Fa len
+characters.
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr memcmp 3 ,
+.Xr strcmp 3 ,
+.Xr strcoll 3 ,
+.Xr strxfrm 3
+.Sh HISTORY
+The
+.Fn strcasecmp
+and
+.Fn strncasecmp
+functions first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strcasecmp.c b/src/lib/libc/string/strcasecmp.c
new file mode 100644
index 0000000000..2be09136c0
--- /dev/null
+++ b/src/lib/libc/string/strcasecmp.c
@@ -0,0 +1,105 @@
+/*      $OpenBSD: strcasecmp.c,v 1.6 2005/08/08 08:05:37 espie Exp $    */
+
+/*
+ * Copyright (c) 1987, 1993
+ *      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.
+ */
+
+#include <string.h>
+
+typedef unsigned char u_char;
+
+/*
+ * This array is designed for mapping upper and lower case letter
+ * together for a case independent comparison.  The mappings are
+ * based upon ascii character sequences.
+ */
+static const u_char charmap[] = {
+        '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
+        '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
+        '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
+        '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
+        '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
+        '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
+        '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
+        '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
+        '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+        '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+        '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+        '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
+        '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+        '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+        '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+        '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
+        '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
+        '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
+        '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
+        '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
+        '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
+        '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
+        '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
+        '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
+        '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
+        '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
+        '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
+        '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
+        '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+        '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+        '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
+        '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
+};
+
+int
+strcasecmp(const char *s1, const char *s2)
+{
+        const u_char *cm = charmap;
+        const u_char *us1 = (const u_char *)s1;
+        const u_char *us2 = (const u_char *)s2;
+
+        while (cm[*us1] == cm[*us2++])
+                if (*us1++ == '\0')
+                        return (0);
+        return (cm[*us1] - cm[*--us2]);
+}
+
+int
+strncasecmp(const char *s1, const char *s2, size_t n)
+{
+        if (n != 0) {
+                const u_char *cm = charmap;
+                const u_char *us1 = (const u_char *)s1;
+                const u_char *us2 = (const u_char *)s2;
+
+                do {
+                        if (cm[*us1] != cm[*us2++])
+                                return (cm[*us1] - cm[*--us2]);
+                        if (*us1++ == '\0')
+                                break;
+                } while (--n != 0);
+        }
+        return (0);
+}
diff --git a/src/lib/libc/string/strcasestr.c b/src/lib/libc/string/strcasestr.c
new file mode 100644
index 0000000000..aa74c0176d
--- /dev/null
+++ b/src/lib/libc/string/strcasestr.c
@@ -0,0 +1,60 @@
+/*      $OpenBSD: strcasestr.c,v 1.3 2006/03/31 05:34:55 deraadt Exp $  */
+/*      $NetBSD: strcasestr.c,v 1.2 2005/02/09 21:35:47 kleink Exp $    */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <ctype.h>
+#include <string.h>
+
+/*
+ * Find the first occurrence of find in s, ignore case.
+ */
+char *
+strcasestr(const char *s, const char *find)
+{
+        char c, sc;
+        size_t len;
+
+        if ((c = *find++) != 0) {
+                c = (char)tolower((unsigned char)c);
+                len = strlen(find);
+                do {
+                        do {
+                                if ((sc = *s++) == 0)
+                                        return (NULL);
+                        } while ((char)tolower((unsigned char)sc) != c);
+                } while (strncasecmp(s, find, len) != 0);
+                s--;
+        }
+        return ((char *)s);
+}
diff --git a/src/lib/libc/string/strcat.3 b/src/lib/libc/string/strcat.3
new file mode 100644
index 0000000000..b81e724917
--- /dev/null
+++ b/src/lib/libc/string/strcat.3
@@ -0,0 +1,133 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strcat.3,v 1.11 2005/08/06 03:21:36 jaredy Exp $
+.\"
+.Dd July 8, 1997
+.Dt STRCAT 3
+.Os
+.Sh NAME
+.Nm strcat ,
+.Nm strncat
+.Nd concatenate strings
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strcat "char *s" "const char *append"
+.Ft char *
+.Fn strncat "char *s" "const char *append" "size_t count"
+.Sh DESCRIPTION
+The
+.Fn strcat
+and
+.Fn strncat
+functions append a copy of the NUL-terminated string
+.Fa append
+to the end of the NUL-terminated string
+.Fa s ,
+then add a terminating
+.Ql \e0 .
+The string
+.Fa s
+must have sufficient space to hold the result.
+.Pp
+The
+.Fn strncat
+function appends not more than
+.Fa count
+characters where space for the terminating
+.Ql \e0
+should not be included in
+.Fa count .
+.Sh RETURN VALUES
+The
+.Fn strcat
+and
+.Fn strncat
+functions return the pointer
+.Fa s .
+.Sh EXAMPLES
+The following appends
+.Dq Li abc
+to
+.Va chararray :
+.Bd -literal -offset indent
+char *letters = "abcdefghi";
+
+(void)strncat(chararray, letters, 3);
+.Ed
+.Pp
+The following example shows how to use
+.Fn strncat
+safely in conjunction with
+.Xr strncpy 3 .
+.Bd -literal -offset indent
+char buf[BUFSIZ];
+char *input, *suffix;
+
+(void)strncpy(buf, input, sizeof(buf) - 1);
+buf[sizeof(buf) - 1] = '\e0';
+(void)strncat(buf, suffix, sizeof(buf) - 1 - strlen(buf));
+.Ed
+.Pp
+The above will copy as many characters from
+.Va input
+to
+.Va buf
+as will fit.
+It then appends as many characters from
+.Va suffix
+as will fit (or none
+if there is no space).
+For operations like this, the
+.Xr strlcpy 3
+and
+.Xr strlcat 3
+functions are a better choice, as shown below.
+.Bd -literal -offset indent
+(void)strlcpy(buf, input, sizeof(buf));
+(void)strlcat(buf, suffix, sizeof(buf));
+.Ed
+.Sh SEE ALSO
+.Xr bcopy 3 ,
+.Xr memccpy 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr strcpy 3 ,
+.Xr strlcat 3 ,
+.Xr strlcpy 3
+.Sh STANDARDS
+The
+.Fn strcat
+and
+.Fn strncat
+functions conform to
+.St -ansiC .
diff --git a/src/lib/libc/string/strcat.c b/src/lib/libc/string/strcat.c
new file mode 100644
index 0000000000..7cea5229fb
--- /dev/null
+++ b/src/lib/libc/string/strcat.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strcat.c,v 1.8 2005/08/08 08:05:37 espie Exp $        */
+
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+#if defined(APIWARN)
+__warn_references(strcat,
+    "warning: strcat() is almost always misused, please use strlcat()");
+#endif
+
+char *
+strcat(char *s, const char *append)
+{
+        char *save = s;
+
+        for (; *s; ++s);
+        while ((*s++ = *append++) != '\0');
+        return(save);
+}
diff --git a/src/lib/libc/string/strchr.3 b/src/lib/libc/string/strchr.3
new file mode 100644
index 0000000000..86841bac25
--- /dev/null
+++ b/src/lib/libc/string/strchr.3
@@ -0,0 +1,102 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strchr.3,v 1.8 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRCHR 3
+.Os
+.Sh NAME
+.Nm strchr ,
+.Nm index
+.Nd locate first occurrence of a character in a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strchr "const char *s" "int c"
+.Ft char *
+.Fn index "const char *s" "int c"
+.Sh DESCRIPTION
+The
+.Fn strchr
+function locates the first occurrence of the character
+.Fa c
+in the string
+.Fa s .
+The terminating NUL character is considered part of the string.
+If
+.Fa c
+is
+.Ql \e0 ,
+.Fn strchr
+locates the terminating
+.Ql \e0 .
+.Pp
+The
+.Fn index
+function is an old synonym for
+.Fn strchr .
+.Sh RETURN VALUES
+The
+.Fn strchr
+function returns a pointer to the located character or
+.Dv NULL
+if the character does not appear in the string.
+.Sh EXAMPLES
+After the following call to
+.Fn strchr ,
+.Va p
+will point to the string
+.Qq oobar :
+.Bd -literal -offset indent
+char *p;
+char *s = "foobar";
+
+p = strchr(s, 'o');
+.Ed
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strchr
+function conforms to
+.St -ansiC .
+.Pp
+The
+.Fn index
+function is deprecated and shouldn't be used in new code.
diff --git a/src/lib/libc/string/strcmp.3 b/src/lib/libc/string/strcmp.3
new file mode 100644
index 0000000000..953181e8de
--- /dev/null
+++ b/src/lib/libc/string/strcmp.3
@@ -0,0 +1,87 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strcmp.3,v 1.8 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRCMP 3
+.Os
+.Sh NAME
+.Nm strcmp ,
+.Nm strncmp
+.Nd compare strings
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn strcmp "const char *s1" "const char *s2"
+.Ft int
+.Fn strncmp "const char *s1" "const char *s2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn strcmp
+and
+.Fn strncmp
+functions lexicographically compare the NUL-terminated strings
+.Fa s1
+and
+.Fa s2 .
+.Sh RETURN VALUES
+The
+.Fn strcmp
+and
+.Fn strncmp
+return an integer greater than, equal to, or less than 0, according
+to whether the string
+.Fa s1
+is greater than, equal to, or less than the string
+.Fa s2 .
+The comparison is done using unsigned characters, so that
+.Ql \e200
+is greater than
+.Ql \e0 .
+.Pp
+.Fn strncmp
+compares at most
+.Fa len
+characters.
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr memcmp 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcoll 3 ,
+.Xr strxfrm 3
+.Sh STANDARDS
+The
+.Fn strcmp
+and
+.Fn strncmp
+functions conform to
+.St -ansiC .
diff --git a/src/lib/libc/string/strcmp.c b/src/lib/libc/string/strcmp.c
new file mode 100644
index 0000000000..816fd111ac
--- /dev/null
+++ b/src/lib/libc/string/strcmp.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strcmp.c,v 1.7 2005/08/08 08:05:37 espie Exp $        */
+
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+/*
+ * Compare strings.
+ */
+int
+strcmp(const char *s1, const char *s2)
+{
+        while (*s1 == *s2++)
+                if (*s1++ == 0)
+                        return (0);
+        return (*(unsigned char *)s1 - *(unsigned char *)--s2);
+}
diff --git a/src/lib/libc/string/strcoll.3 b/src/lib/libc/string/strcoll.3
new file mode 100644
index 0000000000..d1a4e60dc6
--- /dev/null
+++ b/src/lib/libc/string/strcoll.3
@@ -0,0 +1,68 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strcoll.3,v 1.6 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRCOLL 3
+.Os
+.Sh NAME
+.Nm strcoll
+.Nd compare strings according to current collation
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft int
+.Fn strcoll "const char *s1" "const char *s2"
+.Sh DESCRIPTION
+The
+.Fn strcoll
+function lexicographically compares the NUL-terminated strings
+.Fa s1
+and
+.Fa s2
+according to the current locale collation
+and returns an integer greater than, equal to, or less than 0,
+according to whether
+.Fa s1
+is greater than, equal to, or less than
+.Fa s2 .
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr memcmp 3 ,
+.Xr setlocale 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcmp 3 ,
+.Xr strxfrm 3
+.Sh STANDARDS
+The
+.Fn strcoll
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strcoll.c b/src/lib/libc/string/strcoll.c
new file mode 100644
index 0000000000..2df983bd65
--- /dev/null
+++ b/src/lib/libc/string/strcoll.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: strcoll.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Compare strings according to LC_COLLATE category of current locale.
+ */
+int
+strcoll(const char *s1, const char *s2)
+{
+        /* LC_COLLATE is unimplemented, hence always "C" */
+        return (strcmp(s1, s2));
+}
diff --git a/src/lib/libc/string/strcpy.3 b/src/lib/libc/string/strcpy.3
new file mode 100644
index 0000000000..2bc413c6ca
--- /dev/null
+++ b/src/lib/libc/string/strcpy.3
@@ -0,0 +1,151 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strcpy.3,v 1.14 2005/08/06 03:21:36 jaredy Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRCPY 3
+.Os
+.Sh NAME
+.Nm strcpy ,
+.Nm strncpy
+.Nd copy strings
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strcpy "char *dst" "const char *src"
+.Ft char *
+.Fn strncpy "char *dst" "const char *src" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn strcpy
+and
+.Fn strncpy
+functions copy the string
+.Fa src
+to
+.Fa dst
+(including the terminating
+.Ql \e0
+character).
+.Pp
+.Fn strncpy
+copies not more than
+.Fa len
+characters into
+.Fa dst ,
+appending
+.Ql \e0
+characters if
+.Fa src
+is less than
+.Fa len
+characters long, and
+.Em not
+terminating
+.Fa dst
+if the length of
+.Fa src
+is greater than or equal to
+.Fa len .
+.Sh RETURN VALUES
+The
+.Fn strcpy
+and
+.Fn strncpy
+functions return
+.Fa dst .
+.Sh EXAMPLES
+The following sets
+.Va chararray
+to
+.Dq abc\e0\e0\e0 :
+.Bd -literal -offset indent
+(void)strncpy(chararray, "abc", 6);
+.Ed
+.Pp
+The following sets
+.Va chararray
+to
+.Dq abcdef
+and does
+.Em not
+NUL terminate
+.Va chararray
+because the length of the source string is greater than or equal to the
+length parameter.
+.Fn strncpy
+.Em only
+NUL terminates the destination string when the length of the source
+string is less than the length parameter.
+.Bd -literal -offset indent
+(void)strncpy(chararray, "abcdefgh", 6);
+.Ed
+.Pp
+The following copies as many characters from
+.Va input
+to
+.Va buf
+as will fit and NUL terminates the result.
+Because
+.Fn strncpy
+does
+.Em not
+guarantee to NUL terminate the string itself, it must be done by hand.
+.Bd -literal -offset indent
+char buf[BUFSIZ];
+
+(void)strncpy(buf, input, sizeof(buf) - 1);
+buf[sizeof(buf) - 1] = '\e0';
+.Ed
+.Pp
+Note that
+.Xr strlcpy 3
+is a better choice for this kind of operation.
+The equivalent using
+.Xr strlcpy 3
+is simply:
+.Bd -literal -offset indent
+(void)strlcpy(buf, input, sizeof(buf));
+.Ed
+.Sh SEE ALSO
+.Xr bcopy 3 ,
+.Xr memccpy 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr strlcpy 3
+.Sh STANDARDS
+The
+.Fn strcpy
+and
+.Fn strncpy
+functions conform to
+.St -ansiC .
diff --git a/src/lib/libc/string/strcpy.c b/src/lib/libc/string/strcpy.c
new file mode 100644
index 0000000000..71d90d4100
--- /dev/null
+++ b/src/lib/libc/string/strcpy.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: strcpy.c,v 1.8 2005/08/08 08:05:37 espie Exp $        */
+
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+#if defined(APIWARN)
+__warn_references(strcpy,
+    "warning: strcpy() is almost always misused, please use strlcpy()");
+#endif
+
+char *
+strcpy(char *to, const char *from)
+{
+        char *save = to;
+
+        for (; (*to = *from) != '\0'; ++from, ++to);
+        return(save);
+}
diff --git a/src/lib/libc/string/strcspn.3 b/src/lib/libc/string/strcspn.3
new file mode 100644
index 0000000000..c28d99a901
--- /dev/null
+++ b/src/lib/libc/string/strcspn.3
@@ -0,0 +1,88 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strcspn.3,v 1.7 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRCSPN 3
+.Os
+.Sh NAME
+.Nm strcspn
+.Nd span the complement of a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strcspn "const char *s" "const char *charset"
+.Sh DESCRIPTION
+The
+.Fn strcspn
+function spans the initial part of the NUL-terminated string
+.Fa s
+as long as the characters from
+.Fa s
+do not occur in string
+.Fa charset
+(it spans the
+.Em complement
+of
+.Fa charset ) .
+.Sh RETURN VALUES
+The
+.Fn strcspn
+function returns the number of characters spanned.
+.Sh EXAMPLES
+The following call to
+.Fn strcspn
+will return 3, since the first three characters of string
+.Fa s
+do not occur in string
+.Fa charset :
+.Bd -literal -offset indent
+char *s = "foobar";
+char *charset = "bar";
+size_t span;
+
+span = strcspn(s, charset);
+.Ed
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strcspn
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strcspn.c b/src/lib/libc/string/strcspn.c
new file mode 100644
index 0000000000..1eb233614d
--- /dev/null
+++ b/src/lib/libc/string/strcspn.c
@@ -0,0 +1,58 @@
+/*      $OpenBSD: strcspn.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Span the complement of string s2.
+ */
+size_t
+strcspn(const char *s1, const char *s2)
+{
+        const char *p, *spanp;
+        char c, sc;
+
+        /*
+         * Stop as soon as we find any character from s2.  Note that there
+         * must be a NUL in s2; it suffices to stop when we find that, too.
+         */
+        for (p = s1;;) {
+                c = *p++;
+                spanp = s2;
+                do {
+                        if ((sc = *spanp++) == c)
+                                return (p - 1 - s1);
+                } while (sc != 0);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/strdup.3 b/src/lib/libc/string/strdup.3
new file mode 100644
index 0000000000..a434312c42
--- /dev/null
+++ b/src/lib/libc/string/strdup.3
@@ -0,0 +1,84 @@
+.\" $OpenBSD: strdup.3,v 1.13 2005/02/25 03:12:44 cloder Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)strdup.3    8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt STRDUP 3
+.Os
+.Sh NAME
+.Nm strdup
+.Nd save a copy of a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strdup "const char *s"
+.Sh DESCRIPTION
+The
+.Fn strdup
+function allocates sufficient memory for a copy of the string
+.Fa s ,
+does the copy, and returns a pointer to it.
+The pointer may subsequently be used as an argument to the function
+.Xr free 3 .
+.Pp
+If insufficient memory is available,
+.Dv NULL
+is returned.
+.Sh EXAMPLES
+The following will point
+.Va p
+to an allocated area of memory containing the NUL-terminated string
+.Qq foobar :
+.Bd -literal -offset indent
+char *p;
+
+if ((p = strdup("foobar")) == NULL) {
+        fprintf(stderr, "Out of memory.\en");
+        exit(1);
+}
+.Ed
+.Sh ERRORS
+The
+.Fn strdup
+function may fail and set the external variable
+.Va errno
+for any of the errors specified for the library function
+.Xr malloc 3 .
+.Sh SEE ALSO
+.Xr free 3 ,
+.Xr malloc 3 ,
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr strlen 3
+.Sh HISTORY
+The
+.Fn strdup
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strdup.c b/src/lib/libc/string/strdup.c
new file mode 100644
index 0000000000..a6aa1e03b0
--- /dev/null
+++ b/src/lib/libc/string/strdup.c
@@ -0,0 +1,49 @@
+/*      $OpenBSD: strdup.c,v 1.6 2005/08/08 08:05:37 espie Exp $        */
+
+/*
+ * Copyright (c) 1988, 1993
+ *      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.
+ */
+
+#include <sys/types.h>
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *
+strdup(const char *str)
+{
+        size_t siz;
+        char *copy;
+
+        siz = strlen(str) + 1;
+        if ((copy = malloc(siz)) == NULL)
+                return(NULL);
+        (void)memcpy(copy, str, siz);
+        return(copy);
+}
diff --git a/src/lib/libc/string/strerror.3 b/src/lib/libc/string/strerror.3
new file mode 100644
index 0000000000..066cc0e28b
--- /dev/null
+++ b/src/lib/libc/string/strerror.3
@@ -0,0 +1,113 @@
+.\" Copyright (c) 1980, 1991 Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strerror.3,v 1.8 2004/12/10 03:54:18 jaredy Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRERROR 3
+.Os
+.Sh NAME
+.Nm strerror
+.Nd get error message string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strerror "int errnum"
+.Ft int
+.Fn strerror_r "int errnum" "char *strerrbuf" "size_t buflen"
+.Sh DESCRIPTION
+The
+.Fn strerror
+and
+.Fn strerror_r
+functions map the error number
+.Fa errnum
+to a language-dependent error message string.
+.Pp
+.Fn strerror
+returns a string containing a maximum of
+.Dv NL_TEXTMAX
+characters, including the trailing NUL.
+This string is not to be modified by the calling program,
+but may be overwritten by subsequent calls to
+.Fn strerror .
+.Pp
+.Fn strerror_r
+is a thread safe version of
+.Fn strerror
+that places the error message in the specified buffer
+.Fa strerrbuf .
+.Sh RETURN VALUES
+.Fn strerror
+returns a pointer to the error message string.
+If an error occurs, the error code is stored in
+.Va errno .
+.Pp
+.Fn strerror_r
+returns zero upon successful completion.
+If an error occurs, the error code is stored in
+.Va errno
+and the error code is returned.
+.Sh ERRORS
+.Fn strerror
+and
+.Fn strerror_r
+may fail if:
+.Bl -tag -width Er
+.It Bq Er EINVAL
+.Fa errnum
+is not a valid error number.
+The returned error string will consist of an error message that includes
+.Fa errnum .
+.El
+.Pp
+.Fn strerror_r
+may fail if:
+.Bl -tag -width Er
+.It Bq Er ERANGE
+The error message is larger than
+.Fa buflen
+characters.
+The message will be truncated to fit.
+.El
+.Sh SEE ALSO
+.Xr intro 2 ,
+.Xr perror 3 ,
+.Xr setlocale 3
+.Sh STANDARDS
+The
+.Fn strerror
+function conforms to
+.St -ansiC .
+The
+.Fn strerror_r
+function conforms to
+.St -p1003.1 .
diff --git a/src/lib/libc/string/strerror.c b/src/lib/libc/string/strerror.c
new file mode 100644
index 0000000000..13996f08e9
--- /dev/null
+++ b/src/lib/libc/string/strerror.c
@@ -0,0 +1,41 @@
+/*      $OpenBSD: strerror.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <string.h>
+#include <limits.h>
+
+char *
+strerror(int num)
+{
+        static char buf[NL_TEXTMAX];
+
+        (void)strerror_r(num, buf, sizeof(buf));
+        return (buf);
+}
diff --git a/src/lib/libc/string/strerror_r.c b/src/lib/libc/string/strerror_r.c
new file mode 100644
index 0000000000..85988a2561
--- /dev/null
+++ b/src/lib/libc/string/strerror_r.c
@@ -0,0 +1,137 @@
+/* $OpenBSD: strerror_r.c,v 1.6 2005/08/08 08:05:37 espie Exp $ */
+/* Public Domain <marc@snafu.org> */
+
+#ifdef NLS
+#define catclose        _catclose
+#define catgets         _catgets
+#define catopen         _catopen
+#include <nl_types.h>
+#endif
+
+#define sys_errlist     _sys_errlist
+#define sys_nerr        _sys_nerr
+#define sys_siglist     _sys_siglist
+
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <string.h>
+
+static size_t
+__digits10(unsigned int num)
+{
+        size_t i = 0;
+
+        do {
+                num /= 10;
+                i++;
+        } while (num != 0);
+
+        return i;
+}
+
+static int
+__itoa(int num, int sign, char *buffer, size_t start, size_t end)
+{
+        size_t pos;
+        unsigned int a;
+        int neg;
+
+        if (sign && num < 0) {
+                a = -num;
+                neg = 1;
+        }
+        else {
+                a = num;
+                neg = 0;
+        }
+
+        pos = start + __digits10(a);
+        if (neg)
+            pos++;
+
+        if (pos < end)
+                buffer[pos] = '\0';
+        else
+                return ERANGE;
+        pos--;
+        do {
+                buffer[pos] = (a % 10) + '0';
+                pos--;
+                a /= 10;
+        } while (a != 0);
+        if (neg)
+                buffer[pos] = '-';
+        return 0;
+}
+
+
+static int
+__num2string(int num, int sign, int setid, char *buf, size_t buflen,
+    char * list[], size_t max, const char *def)
+{
+        int ret = 0;
+        size_t len;
+
+#ifdef NLS
+        nl_catd catd;
+        catd = catopen("libc", 0);
+#endif
+
+        if (0 <= num && num < max) {
+#ifdef NLS
+                len = strlcpy(buf, catgets(catd, setid, num, list[num]),
+                    buflen);
+#else
+                len = strlcpy(buf, def, buflen);
+#endif
+                if (len >= buflen)
+                        ret = ERANGE;
+        } else {
+#ifdef NLS
+                len = strlcpy(buf, catgets(catd, setid, 0xffff, def), buflen);
+#else
+                len = strlcpy(buf, def, buflen);
+#endif
+                if (len >= buflen)
+                        ret = ERANGE;
+                else {
+                        ret = __itoa(num, sign, buf, len, buflen);
+                        if (ret == 0)
+                                ret = EINVAL;
+                }
+        }
+
+#ifdef NLS
+        catclose(catd);
+#endif
+
+        return ret;
+}
+
+#define UPREFIX "Unknown error: "
+
+int
+strerror_r(int errnum, char *strerrbuf, size_t buflen)
+{
+        int save_errno;
+        int ret_errno;
+
+        save_errno = errno;
+
+        ret_errno = __num2string(errnum, 1, 1, strerrbuf, buflen,
+            sys_errlist, sys_nerr, UPREFIX);
+
+        errno = ret_errno ? ret_errno : save_errno;
+        return (ret_errno);
+}
+
+#define USIGPREFIX "Unknown signal: "
+
+char *
+__strsignal(int num, char *buf)
+{
+        __num2string(num, 0, 2, buf, NL_TEXTMAX, (char **)sys_siglist, NSIG,
+            USIGPREFIX);
+        return buf;
+}
diff --git a/src/lib/libc/string/string.3 b/src/lib/libc/string/string.3
new file mode 100644
index 0000000000..690cf4dbda
--- /dev/null
+++ b/src/lib/libc/string/string.3
@@ -0,0 +1,136 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\" 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.
+.\"
+.\"     $OpenBSD: string.3,v 1.11 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd April 19, 1991
+.Dt STRING 3
+.Os
+.Sh NAME
+.Nm string
+.Nd string specific functions
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strcat "char *s" "const char *append"
+.Ft char *
+.Fn strlcat "char *s" "const char *append" "size_t size"
+.Ft char *
+.Fn strncat "char *s" "const char *append" "size_t count"
+.Ft char *
+.Fn strchr "const char *s" "int c"
+.Ft char *
+.Fn strrchr "const char *s" "int c"
+.Ft int
+.Fn strcmp "const char *s1" "const char *s2"
+.Ft int
+.Fn strncmp "const char *s1" "const char *s2" "size_t count"
+.Ft int
+.Fn strcasecmp "const char *s1" "const char *s2"
+.Ft int
+.Fn strncasecmp "const char *s1" "const char *s2" "size_t count"
+.Ft char *
+.Fn strcpy "char *dst" "const char *src"
+.Ft char *
+.Fn strlcpy "char *dst" "const char *src" "size_t size"
+.Ft char *
+.Fn strncpy "char *dst" "const char *src" "size_t count"
+.Ft char *
+.Fn strerror "int errno"
+.Ft size_t
+.Fn strlen "const char *s"
+.Ft char *
+.Fn strpbrk "const char *s" "const char *charset"
+.Ft char *
+.Fn strsep "char **stringp" "const char *delim"
+.Ft size_t
+.Fn strspn "const char *s" "const char *charset"
+.Ft size_t
+.Fn strcspn "const char *s" "const char *charset"
+.Ft char *
+.Fn strstr "const char *big" "const char *little"
+.Ft char *
+.Fn strtok "char *s" "const char *delim"
+.Ft char *
+.Fn index "const char *s" "int c"
+.Ft char *
+.Fn rindex "const char *s" "int c"
+.Sh DESCRIPTION
+The string functions
+manipulate strings terminated by a
+NUL byte.
+.Pp
+See the specific manual pages for more information.
+For manipulating variable length generic objects as byte
+strings (without the NUL-byte check), see
+.Xr bstring 3 .
+.Pp
+Except as noted in their specific manual pages,
+the string functions do not test the destination
+for size limitations.
+.Sh SEE ALSO
+.Xr bstring 3 ,
+.Xr index 3 ,
+.Xr rindex 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcat 3 ,
+.Xr strchr 3 ,
+.Xr strcmp 3 ,
+.Xr strcpy 3 ,
+.Xr strcspn 3 ,
+.Xr strerror 3 ,
+.Xr strlcat 3 ,
+.Xr strlcpy 3 ,
+.Xr strlen 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strcat ,
+.Fn strncat ,
+.Fn strchr ,
+.Fn strrchr ,
+.Fn strcmp ,
+.Fn strncmp ,
+.Fn strcpy ,
+.Fn strncpy ,
+.Fn strerror ,
+.Fn strlen ,
+.Fn strpbrk ,
+.Fn strspn ,
+.Fn strcspn ,
+.Fn strstr ,
+and
+.Fn strtok
+functions conform to
+.St -ansiC .
diff --git a/src/lib/libc/string/strlcat.c b/src/lib/libc/string/strlcat.c
new file mode 100644
index 0000000000..ceab094411
--- /dev/null
+++ b/src/lib/libc/string/strlcat.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $      */
+
+/*
+ * Copyright (c) 1998 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.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(char *dst, const char *src, size_t siz)
+{
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
+        size_t dlen;
+
+        /* Find the end of dst and adjust bytes left but don't go past end */
+        while (n-- != 0 && *d != '\0')
+                d++;
+        dlen = d - dst;
+        n = siz - dlen;
+
+        if (n == 0)
+                return(dlen + strlen(s));
+        while (*s != '\0') {
+                if (n != 1) {
+                        *d++ = *s;
+                        n--;
+                }
+                s++;
+        }
+        *d = '\0';
+
+        return(dlen + (s - src));       /* count does not include NUL */
+}
diff --git a/src/lib/libc/string/strlcpy.3 b/src/lib/libc/string/strlcpy.3
new file mode 100644
index 0000000000..631298884e
--- /dev/null
+++ b/src/lib/libc/string/strlcpy.3
@@ -0,0 +1,186 @@
+.\" $OpenBSD: strlcpy.3,v 1.18 2005/08/06 03:24:19 jaredy Exp $
+.\"
+.\" Copyright (c) 1998, 2000 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.
+.\"
+.Dd June 22, 1998
+.Dt STRLCPY 3
+.Os
+.Sh NAME
+.Nm strlcpy ,
+.Nm strlcat
+.Nd size-bounded string copying and concatenation
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strlcpy "char *dst" "const char *src" "size_t size"
+.Ft size_t
+.Fn strlcat "char *dst" "const char *src" "size_t size"
+.Sh DESCRIPTION
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions copy and concatenate strings respectively.
+They are designed
+to be safer, more consistent, and less error prone replacements for
+.Xr strncpy 3
+and
+.Xr strncat 3 .
+Unlike those functions,
+.Fn strlcpy
+and
+.Fn strlcat
+take the full size of the buffer (not just the length) and guarantee to
+NUL-terminate the result (as long as
+.Fa size
+is larger than 0 or, in the case of
+.Fn strlcat ,
+as long as there is at least one byte free in
+.Fa dst ) .
+Note that a byte for the NUL should be included in
+.Fa size .
+Also note that
+.Fn strlcpy
+and
+.Fn strlcat
+only operate on true
+.Dq C
+strings.
+This means that for
+.Fn strlcpy
+.Fa src
+must be NUL-terminated and for
+.Fn strlcat
+both
+.Fa src
+and
+.Fa dst
+must be NUL-terminated.
+.Pp
+The
+.Fn strlcpy
+function copies up to
+.Fa size
+- 1 characters from the NUL-terminated string
+.Fa src
+to
+.Fa dst ,
+NUL-terminating the result.
+.Pp
+The
+.Fn strlcat
+function appends the NUL-terminated string
+.Fa src
+to the end of
+.Fa dst .
+It will append at most
+.Fa size
+- strlen(dst) - 1 bytes, NUL-terminating the result.
+.Sh RETURN VALUES
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions return the total length of the string they tried to create.
+For
+.Fn strlcpy
+that means the length of
+.Fa src .
+For
+.Fn strlcat
+that means the initial length of
+.Fa dst
+plus
+the length of
+.Fa src .
+While this may seem somewhat confusing, it was done to make
+truncation detection simple.
+.Pp
+Note, however, that if
+.Fn strlcat
+traverses
+.Fa size
+characters without finding a NUL, the length of the string is considered
+to be
+.Fa size
+and the destination string will not be NUL-terminated (since there was
+no space for the NUL).
+This keeps
+.Fn strlcat
+from running off the end of a string.
+In practice this should not happen (as it means that either
+.Fa size
+is incorrect or that
+.Fa dst
+is not a proper
+.Dq C
+string).
+The check exists to prevent potential security problems in incorrect code.
+.Sh EXAMPLES
+The following code fragment illustrates the simple case:
+.Bd -literal -offset indent
+char *s, *p, buf[BUFSIZ];
+
+\&...
+
+(void)strlcpy(buf, s, sizeof(buf));
+(void)strlcat(buf, p, sizeof(buf));
+.Ed
+.Pp
+To detect truncation, perhaps while building a pathname, something
+like the following might be used:
+.Bd -literal -offset indent
+char *dir, *file, pname[MAXPATHLEN];
+
+\&...
+
+if (strlcpy(pname, dir, sizeof(pname)) >= sizeof(pname))
+        goto toolong;
+if (strlcat(pname, file, sizeof(pname)) >= sizeof(pname))
+        goto toolong;
+.Ed
+.Pp
+Since it is known how many characters were copied the first time, things
+can be sped up a bit by using a copy instead of an append:
+.Bd -literal -offset indent
+char *dir, *file, pname[MAXPATHLEN];
+size_t n;
+
+\&...
+
+n = strlcpy(pname, dir, sizeof(pname));
+if (n >= sizeof(pname))
+        goto toolong;
+if (strlcpy(pname + n, file, sizeof(pname) - n) >= sizeof(pname) - n)
+        goto toolong;
+.Ed
+.Pp
+However, one may question the validity of such optimizations, as they
+defeat the whole purpose of
+.Fn strlcpy
+and
+.Fn strlcat .
+As a matter of fact, the first version of this manual page got it wrong.
+.Sh SEE ALSO
+.Xr snprintf 3 ,
+.Xr strncat 3 ,
+.Xr strncpy 3
+.Sh HISTORY
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions first appeared in
+.Ox 2.4 .
diff --git a/src/lib/libc/string/strlcpy.c b/src/lib/libc/string/strlcpy.c
new file mode 100644
index 0000000000..d32b6590f1
--- /dev/null
+++ b/src/lib/libc/string/strlcpy.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $    */
+
+/*
+ * Copyright (c) 1998 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.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+strlcpy(char *dst, const char *src, size_t siz)
+{
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
+
+        /* Copy as many bytes as will fit */
+        if (n != 0) {
+                while (--n != 0) {
+                        if ((*d++ = *s++) == '\0')
+                                break;
+                }
+        }
+
+        /* Not enough room in dst, add NUL and traverse rest of src */
+        if (n == 0) {
+                if (siz != 0)
+                        *d = '\0';              /* NUL-terminate dst */
+                while (*s++)
+                        ;
+        }
+
+        return(s - src - 1);    /* count does not include NUL */
+}
diff --git a/src/lib/libc/string/strlen.3 b/src/lib/libc/string/strlen.3
new file mode 100644
index 0000000000..32bbc88542
--- /dev/null
+++ b/src/lib/libc/string/strlen.3
@@ -0,0 +1,61 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strlen.3,v 1.5 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRLEN 3
+.Os
+.Sh NAME
+.Nm strlen
+.Nd find length of a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strlen "const char *s"
+.Sh DESCRIPTION
+The
+.Fn strlen
+function computes the length of the string
+.Fa s .
+.Sh RETURN VALUES
+The
+.Fn strlen
+function returns the number of characters that precede the terminating
+.Tn NUL
+character.
+.Sh SEE ALSO
+.Xr string 3
+.Sh STANDARDS
+The
+.Fn strlen
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strlen.c b/src/lib/libc/string/strlen.c
new file mode 100644
index 0000000000..12d9ec4dad
--- /dev/null
+++ b/src/lib/libc/string/strlen.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: strlen.c,v 1.7 2005/08/08 08:05:37 espie Exp $        */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+size_t
+strlen(const char *str)
+{
+        const char *s;
+
+        for (s = str; *s; ++s)
+                ;
+        return (s - str);
+}
+
diff --git a/src/lib/libc/string/strmode.3 b/src/lib/libc/string/strmode.3
new file mode 100644
index 0000000000..99e6d44fd2
--- /dev/null
+++ b/src/lib/libc/string/strmode.3
@@ -0,0 +1,157 @@
+.\" $OpenBSD: strmode.3,v 1.13 2005/06/15 17:48:52 millert Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     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.
+.\"
+.\"     @(#)strmode.3   8.3 (Berkeley) 7/28/94
+.\"
+.Dd July 28, 1994
+.Dt STRMODE 3
+.Os
+.Sh NAME
+.Nm strmode
+.Nd convert inode status information into a symbolic string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft void
+.Fn strmode "mode_t mode" "char *bp"
+.Sh DESCRIPTION
+The
+.Fn strmode
+function converts a file
+.Fa mode
+(the type and permission information associated with an inode, see
+.Xr stat 2 )
+into a symbolic string which is stored in the location referenced by
+.Fa bp .
+This stored string is eleven characters in length plus a trailing NUL byte.
+.Pp
+The first character is the inode type, and will be one of the following:
+.Pp
+.Bl -tag -width flag -offset indent -compact
+.It \-
+regular file
+.It b
+block special
+.It c
+character special
+.It d
+directory
+.It l
+symbolic link
+.It p
+FIFO
+.It s
+socket
+.It \&?
+unknown inode type
+.El
+.Pp
+The next nine characters encode three sets of permissions, in three
+characters each.
+The first three characters are the permissions for the owner of the
+file, the second three for the group the file belongs to, and the
+third for the
+.Dq other ,
+or default, set of users.
+.Pp
+Permission checking is done as specifically as possible.
+If read permission is denied to the owner of a file in the first set
+of permissions, the owner of the file will not be able to read the file.
+This is true even if the owner is in the file's group and the group
+permissions allow reading or the
+.Dq other
+permissions allow reading.
+.Pp
+If the first character of the three character set is an
+.Sq r ,
+the file is readable for that set of users; if a dash
+.Pq Ql - ,
+it is not readable.
+.Pp
+If the second character of the three character set is a
+.Sq w ,
+the file is writable for that set of users; if a dash
+.Pq Ql - ,
+it is not writable.
+.Pp
+The third character is the first of the following characters that apply:
+.Bl -tag -width xxxx
+.It S
+If the character is part of the owner permissions and the file is not
+executable or the directory is not searchable by the owner, and the
+set-user-ID bit is set.
+.It S
+If the character is part of the group permissions and the file is not
+executable or the directory is not searchable by the group, and the
+set-group-ID bit is set.
+.It T
+If the character is part of the other permissions and the file is not
+executable or the directory is not searchable by others, and the
+.Dq sticky
+.Pq Dv S_ISVTX
+bit is set.
+.It s
+If the character is part of the owner permissions and the file is
+executable or the directory searchable by the owner, and the set-user-ID
+bit is set.
+.It s
+If the character is part of the group permissions and the file is
+executable or the directory searchable by the group, and the set-group-ID
+bit is set.
+.It t
+If the character is part of the other permissions and the file is
+executable or the directory searchable by others, and the
+.Dq sticky
+.Pq Dv S_ISVTX
+bit is set.
+.It x
+The file is executable or the directory is searchable.
+.It \-
+None of the above apply.
+.El
+.Pp
+The last character is a plus sign
+.Pq Ql +
+if there are any alternate
+or additional access control methods associated with the inode, otherwise
+it will be a space.
+.Sh RETURN VALUES
+The
+.Fn strmode
+function always returns 0.
+.Sh SEE ALSO
+.Xr chmod 1 ,
+.Xr find 1 ,
+.Xr stat 2 ,
+.Xr getmode 3 ,
+.Xr setmode 3
+.Sh HISTORY
+The
+.Fn strmode
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strmode.c b/src/lib/libc/string/strmode.c
new file mode 100644
index 0000000000..6f0fa34ed8
--- /dev/null
+++ b/src/lib/libc/string/strmode.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: strmode.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 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.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+
+/* XXX mode should be mode_t */
+
+void
+strmode(int mode, char *p)
+{
+         /* print type */
+        switch (mode & S_IFMT) {
+        case S_IFDIR:                   /* directory */
+                *p++ = 'd';
+                break;
+        case S_IFCHR:                   /* character special */
+                *p++ = 'c';
+                break;
+        case S_IFBLK:                   /* block special */
+                *p++ = 'b';
+                break;
+        case S_IFREG:                   /* regular */
+                *p++ = '-';
+                break;
+        case S_IFLNK:                   /* symbolic link */
+                *p++ = 'l';
+                break;
+        case S_IFSOCK:                  /* socket */
+                *p++ = 's';
+                break;
+#ifdef S_IFIFO
+        case S_IFIFO:                   /* fifo */
+                *p++ = 'p';
+                break;
+#endif
+        default:                        /* unknown */
+                *p++ = '?';
+                break;
+        }
+        /* usr */
+        if (mode & S_IRUSR)
+                *p++ = 'r';
+        else
+                *p++ = '-';
+        if (mode & S_IWUSR)
+                *p++ = 'w';
+        else
+                *p++ = '-';
+        switch (mode & (S_IXUSR | S_ISUID)) {
+        case 0:
+                *p++ = '-';
+                break;
+        case S_IXUSR:
+                *p++ = 'x';
+                break;
+        case S_ISUID:
+                *p++ = 'S';
+                break;
+        case S_IXUSR | S_ISUID:
+                *p++ = 's';
+                break;
+        }
+        /* group */
+        if (mode & S_IRGRP)
+                *p++ = 'r';
+        else
+                *p++ = '-';
+        if (mode & S_IWGRP)
+                *p++ = 'w';
+        else
+                *p++ = '-';
+        switch (mode & (S_IXGRP | S_ISGID)) {
+        case 0:
+                *p++ = '-';
+                break;
+        case S_IXGRP:
+                *p++ = 'x';
+                break;
+        case S_ISGID:
+                *p++ = 'S';
+                break;
+        case S_IXGRP | S_ISGID:
+                *p++ = 's';
+                break;
+        }
+        /* other */
+        if (mode & S_IROTH)
+                *p++ = 'r';
+        else
+                *p++ = '-';
+        if (mode & S_IWOTH)
+                *p++ = 'w';
+        else
+                *p++ = '-';
+        switch (mode & (S_IXOTH | S_ISVTX)) {
+        case 0:
+                *p++ = '-';
+                break;
+        case S_IXOTH:
+                *p++ = 'x';
+                break;
+        case S_ISVTX:
+                *p++ = 'T';
+                break;
+        case S_IXOTH | S_ISVTX:
+                *p++ = 't';
+                break;
+        }
+        *p++ = ' ';             /* will be a '+' if ACL's implemented */
+        *p = '\0';
+}
diff --git a/src/lib/libc/string/strncat.c b/src/lib/libc/string/strncat.c
new file mode 100644
index 0000000000..c4df4f2fad
--- /dev/null
+++ b/src/lib/libc/string/strncat.c
@@ -0,0 +1,57 @@
+/*      $OpenBSD: strncat.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Concatenate src on the end of dst.  At most strlen(dst)+n+1 bytes
+ * are written at dst (at most n+1 bytes being appended).  Return dst.
+ */
+char *
+strncat(char *dst, const char *src, size_t n)
+{
+        if (n != 0) {
+                char *d = dst;
+                const char *s = src;
+
+                while (*d != 0)
+                        d++;
+                do {
+                        if ((*d = *s++) == 0)
+                                break;
+                        d++;
+                } while (--n != 0);
+                *d = 0;
+        }
+        return (dst);
+}
diff --git a/src/lib/libc/string/strncmp.c b/src/lib/libc/string/strncmp.c
new file mode 100644
index 0000000000..0aea80d7d9
--- /dev/null
+++ b/src/lib/libc/string/strncmp.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strncmp.c,v 1.7 2005/08/08 08:05:37 espie Exp $       */
+
+/*
+ * Copyright (c) 1989 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+int
+strncmp(const char *s1, const char *s2, size_t n)
+{
+
+        if (n == 0)
+                return (0);
+        do {
+                if (*s1 != *s2++)
+                        return (*(unsigned char *)s1 - *(unsigned char *)--s2);
+                if (*s1++ == 0)
+                        break;
+        } while (--n != 0);
+        return (0);
+}
diff --git a/src/lib/libc/string/strncpy.c b/src/lib/libc/string/strncpy.c
new file mode 100644
index 0000000000..4426cbe2e3
--- /dev/null
+++ b/src/lib/libc/string/strncpy.c
@@ -0,0 +1,62 @@
+/*      $OpenBSD: strncpy.c,v 1.6 2005/08/08 08:05:37 espie Exp $       */
+
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+/*
+ * Copy src to dst, truncating or null-padding to always copy n bytes.
+ * Return dst.
+ */
+char *
+strncpy(char *dst, const char *src, size_t n)
+{
+        if (n != 0) {
+                char *d = dst;
+                const char *s = src;
+
+                do {
+                        if ((*d++ = *s++) == 0) {
+                                /* NUL pad the remaining n-1 bytes */
+                                while (--n != 0)
+                                        *d++ = 0;
+                                break;
+                        }
+                } while (--n != 0);
+        }
+        return (dst);
+}
diff --git a/src/lib/libc/string/strpbrk.3 b/src/lib/libc/string/strpbrk.3
new file mode 100644
index 0000000000..e91776a0ca
--- /dev/null
+++ b/src/lib/libc/string/strpbrk.3
@@ -0,0 +1,72 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strpbrk.3,v 1.7 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRPBRK 3
+.Os
+.Sh NAME
+.Nm strpbrk
+.Nd locate multiple characters in string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strpbrk "const char *s" "const char *charset"
+.Sh DESCRIPTION
+The
+.Fn strpbrk
+function locates in the NUL-terminated string
+.Fa s
+the first occurrence of any character in the string
+.Fa charset
+and returns a pointer to this character.
+If no characters from
+.Fa charset
+occur anywhere in
+.Fa s ,
+.Fn strpbrk
+returns
+.Dv NULL .
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strpbrk
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strpbrk.c b/src/lib/libc/string/strpbrk.c
new file mode 100644
index 0000000000..cd3b71c0d3
--- /dev/null
+++ b/src/lib/libc/string/strpbrk.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: strpbrk.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1985 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.
+ */
+
+#include <string.h>
+
+/*
+ * Find the first occurrence in s1 of a character in s2 (excluding NUL).
+ */
+char *
+strpbrk(const char *s1, const char *s2)
+{
+        const char *scanp;
+        int c, sc;
+
+        while ((c = *s1++) != 0) {
+                for (scanp = s2; (sc = *scanp++) != 0;)
+                        if (sc == c)
+                                return ((char *)(s1 - 1));
+        }
+        return (NULL);
+}
diff --git a/src/lib/libc/string/strrchr.3 b/src/lib/libc/string/strrchr.3
new file mode 100644
index 0000000000..d7e0eeff85
--- /dev/null
+++ b/src/lib/libc/string/strrchr.3
@@ -0,0 +1,104 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strrchr.3,v 1.7 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRRCHR 3
+.Os
+.Sh NAME
+.Nm strrchr ,
+.Nm rindex
+.Nd locate last occurrence of a character in a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strrchr "const char *s" "int c"
+.Ft char *
+.Fn rindex "const char *s" "int c"
+.Sh DESCRIPTION
+The
+.Fn strrchr
+function locates the last occurrence of the character
+.Fa c
+in the string
+.Fa s .
+The terminating
+.Tn NUL
+character is considered part of the string.
+If
+.Fa c
+is
+.Ql \e0 ,
+.Fn strrchr
+locates the terminating
+.Ql \e0 .
+.Pp
+The
+.Fn rindex
+function is an old synonym for
+.Fn strrchr .
+.Sh RETURN VALUES
+The
+.Fn strrchr
+function returns a pointer to the located character or
+.Dv NULL
+if the character does not appear in the string.
+.Sh EXAMPLES
+After the following call to
+.Fn strrchr ,
+.Va p
+will point to the string
+.Qq obar :
+.Bd -literal -offset indent
+char *p;
+char *s = "foobar";
+
+p = strrchr(s, 'o');
+.Ed
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strrchr
+function conforms to
+.St -ansiC .
+.Pp
+The
+.Fn rindex
+function is deprecated and shouldn't be used in new code.
diff --git a/src/lib/libc/string/strsep.3 b/src/lib/libc/string/strsep.3
new file mode 100644
index 0000000000..ddcc22916a
--- /dev/null
+++ b/src/lib/libc/string/strsep.3
@@ -0,0 +1,112 @@
+.\" $OpenBSD: strsep.3,v 1.11 2003/06/02 20:18:38 millert Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek.
+.\"
+.\" 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.
+.\"
+.\"     @(#)strsep.3    8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt STRSEP 3
+.Os
+.Sh NAME
+.Nm strsep
+.Nd separate strings
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strsep "char **stringp" "const char *delim"
+.Sh DESCRIPTION
+The
+.Fn strsep
+function locates, in the string referenced by
+.Fa *stringp ,
+the first occurrence of any character in the string
+.Fa delim
+(or the terminating
+.Ql \e0
+character) and replaces it with a
+.Ql \e0 .
+The location of the next character after the delimiter character
+(or
+.Dv NULL ,
+if the end of the string was reached) is stored in
+.Fa *stringp .
+The original value of
+.Fa *stringp
+is returned.
+.Pp
+An
+.Dq empty
+field, i.e., one caused by two adjacent delimiter characters,
+can be detected by comparing the location referenced by the pointer returned
+by
+.Fn strsep
+to
+.Ql \e0 .
+.Pp
+If
+.Fa *stringp
+is initially
+.Dv NULL ,
+.Fn strsep
+returns
+.Dv NULL .
+.Sh EXAMPLES
+The following uses
+.Fn strsep
+to parse a string, containing tokens delimited by whitespace, into an
+argument vector:
+.Bd -literal -offset indent
+char **ap, *argv[10], *inputstring;
+
+for (ap = argv; ap < &argv[9] &&
+    (*ap = strsep(&inputstring, " \et")) != NULL;) {
+        if (**ap != '\e0')
+                ap++;
+}
+*ap = NULL;
+.Ed
+.Sh HISTORY
+The
+.Fn strsep
+function is intended as a replacement for the
+.Fn strtok
+function.
+While the
+.Fn strtok
+function should be preferred for portability reasons (it conforms to
+.St -ansiC )
+it is unable to handle empty fields, i.e., detect fields delimited by
+two adjacent delimiter characters, or to be used for more than a single
+string at a time.
+The
+.Fn strsep
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strsep.c b/src/lib/libc/string/strsep.c
new file mode 100644
index 0000000000..bcca681e03
--- /dev/null
+++ b/src/lib/libc/string/strsep.c
@@ -0,0 +1,71 @@
+/*      $OpenBSD: strsep.c,v 1.6 2005/08/08 08:05:37 espie Exp $        */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      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.
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+/*
+ * Get next token from string *stringp, where tokens are possibly-empty
+ * strings separated by characters from delim.  
+ *
+ * Writes NULs into the string at *stringp to end tokens.
+ * delim need not remain constant from call to call.
+ * On return, *stringp points past the last NUL written (if there might
+ * be further tokens), or is NULL (if there are definitely no more tokens).
+ *
+ * If *stringp is NULL, strsep returns NULL.
+ */
+char *
+strsep(char **stringp, const char *delim)
+{
+        char *s;
+        const char *spanp;
+        int c, sc;
+        char *tok;
+
+        if ((s = *stringp) == NULL)
+                return (NULL);
+        for (tok = s;;) {
+                c = *s++;
+                spanp = delim;
+                do {
+                        if ((sc = *spanp++) == c) {
+                                if (c == 0)
+                                        s = NULL;
+                                else
+                                        s[-1] = 0;
+                                *stringp = s;
+                                return (tok);
+                        }
+                } while (sc != 0);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/strsignal.3 b/src/lib/libc/string/strsignal.3
new file mode 100644
index 0000000000..b1082c2dd0
--- /dev/null
+++ b/src/lib/libc/string/strsignal.3
@@ -0,0 +1,56 @@
+.\" Copyright (c) 1980, 1991 Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strsignal.3,v 1.4 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRSIGNAL 3
+.Os
+.Sh NAME
+.Nm strsignal
+.Nd get signal description string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strsignal "int sig"
+.Sh DESCRIPTION
+The
+.Fn strsignal
+function returns a pointer to the language-dependent string describing
+a signal.
+.Pp
+The array pointed to is not to be modified by the program, but may be
+overwritten by subsequent calls to
+.Fn strsignal .
+.Sh SEE ALSO
+.Xr intro 2 ,
+.Xr psignal 3 ,
+.Xr setlocale 3
diff --git a/src/lib/libc/string/strsignal.c b/src/lib/libc/string/strsignal.c
new file mode 100644
index 0000000000..aa541cefed
--- /dev/null
+++ b/src/lib/libc/string/strsignal.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <string.h>
+#include <limits.h>
+
+extern char *__strsignal(int, char *);
+
+char *
+strsignal(int sig)
+{
+        static char buf[NL_TEXTMAX];
+
+        return __strsignal(sig, buf);
+}
diff --git a/src/lib/libc/string/strspn.3 b/src/lib/libc/string/strspn.3
new file mode 100644
index 0000000000..5dc7e9746a
--- /dev/null
+++ b/src/lib/libc/string/strspn.3
@@ -0,0 +1,84 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strspn.3,v 1.8 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRSPN 3
+.Os
+.Sh NAME
+.Nm strspn
+.Nd span a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strspn "const char *s" "const char *charset"
+.Sh DESCRIPTION
+The
+.Fn strspn
+function spans the initial part of the NUL-terminated string
+.Fa s
+as long as the characters from
+.Fa s
+occur in string
+.Fa charset .
+.Sh RETURN VALUES
+The
+.Fn strspn
+function returns the number of characters spanned.
+.Sh EXAMPLES
+The following call to
+.Fn strspn
+will return 3, since the first three characters of string
+.Fa s
+are part of string
+.Fa charset :
+.Bd -literal -offset indent
+char *s = "foobar";
+char *charset = "of";
+size_t span;
+
+span = strspn(s, charset);
+.Ed
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strstr 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strspn
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strspn.c b/src/lib/libc/string/strspn.c
new file mode 100644
index 0000000000..385649c041
--- /dev/null
+++ b/src/lib/libc/string/strspn.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strspn.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1989 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.
+ */
+
+#include <string.h>
+
+/*
+ * Span the string s2 (skip characters that are in s2).
+ */
+size_t
+strspn(const char *s1, const char *s2)
+{
+        const char *p = s1, *spanp;
+        char c, sc;
+
+        /*
+         * Skip any characters in s2, excluding the terminating \0.
+         */
+cont:
+        c = *p++;
+        for (spanp = s2; (sc = *spanp++) != 0;)
+                if (sc == c)
+                        goto cont;
+        return (p - 1 - s1);
+}
diff --git a/src/lib/libc/string/strstr.3 b/src/lib/libc/string/strstr.3
new file mode 100644
index 0000000000..2c8fa1888f
--- /dev/null
+++ b/src/lib/libc/string/strstr.3
@@ -0,0 +1,87 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strstr.3,v 1.8 2005/03/30 03:04:19 deraadt Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRSTR 3
+.Os
+.Sh NAME
+.Nm strstr , strcasestr
+.Nd locate a substring in a string
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strstr "const char *big" "const char *little"
+.Ft char *
+.Fn strcasestr "const char *big" "const char *little"
+.Sh DESCRIPTION
+The
+.Fn strstr
+function locates the first occurrence of the NUL-terminated string
+.Fa little
+in the NUL-terminated string
+.Fa big .
+.Pp
+The
+.Fn strcasestr
+function is similar to
+.Fn strstr
+but ignores the case of both strings.
+.Pp
+If
+.Fa little
+is an empty string,
+.Fa big
+is returned;
+if
+.Fa little
+occurs nowhere in
+.Fa big ,
+.Dv NULL
+is returned;
+otherwise a pointer to the first character of the first occurrence of
+.Fa little
+is returned.
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strtok 3
+.Sh STANDARDS
+The
+.Fn strstr
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strstr.c b/src/lib/libc/string/strstr.c
new file mode 100644
index 0000000000..95a865bf79
--- /dev/null
+++ b/src/lib/libc/string/strstr.c
@@ -0,0 +1,56 @@
+/*      $OpenBSD: strstr.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Find the first occurrence of find in s.
+ */
+char *
+strstr(const char *s, const char *find)
+{
+        char c, sc;
+        size_t len;
+
+        if ((c = *find++) != 0) {
+                len = strlen(find);
+                do {
+                        do {
+                                if ((sc = *s++) == 0)
+                                        return (NULL);
+                        } while (sc != c);
+                } while (strncmp(s, find, len) != 0);
+                s--;
+        }
+        return ((char *)s);
+}
diff --git a/src/lib/libc/string/strtok.3 b/src/lib/libc/string/strtok.3
new file mode 100644
index 0000000000..03a93980ab
--- /dev/null
+++ b/src/lib/libc/string/strtok.3
@@ -0,0 +1,152 @@
+.\" Copyright (c) 1988, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strtok.3,v 1.18 2005/02/25 03:12:44 cloder Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRTOK 3
+.Os
+.Sh NAME
+.Nm strtok ,
+.Nm strtok_r
+.Nd string token operations
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft char *
+.Fn strtok "char *str" "const char *sep"
+.Ft char *
+.Fn strtok_r "char *str" "const char *sep" "char **last"
+.Sh DESCRIPTION
+.Bf -symbolic
+This interface is obsoleted by
+.Xr strsep 3 .
+.Ef
+.Pp
+The
+.Fn strtok
+function is used to isolate sequential tokens in a NUL-terminated string,
+.Fa str .
+These tokens are separated in the string by at least one of the
+characters in
+.Fa sep .
+The first time that
+.Fn strtok
+is called,
+.Fa str
+should be specified; subsequent calls, wishing to obtain further tokens
+from the same string, should pass a null pointer instead.
+The separator string,
+.Fa sep ,
+must be supplied each time, and may change between calls.
+.Pp
+The
+.Fn strtok_r
+function is a version of
+.Fn strtok
+that takes an explicit context argument and is reentrant.
+.Pp
+The
+.Fn strtok
+and
+.Fn strtok_r
+functions return a pointer to the beginning of each subsequent token
+in the string, after replacing the separator character itself with an
+.Tn ASCII NUL
+character.
+When no more tokens remain, a null pointer is returned.
+.Pp
+Since
+.Fn strtok
+and
+.Fn strtok_r
+modify the string,
+.Fa str
+should not point to an area in the initialized data segment.
+.Sh EXAMPLES
+The following will construct an array of pointers to each individual word in
+the string
+.Va s :
+.Bd -literal -offset indent
+#define MAXTOKENS       128
+
+char s[512], *p, *tokens[MAXTOKENS];
+char *last;
+int i = 0;
+
+snprintf(s, sizeof(s), "cat dog horse cow");
+
+for ((p = strtok_r(s, " ", &last)); p;
+    (p = strtok_r(NULL, " ", &last))) {
+        if (i < MAXTOKENS - 1)
+                tokens[i++] = p;
+}
+tokens[i] = NULL;
+.Ed
+.Pp
+That is,
+.Li tokens[0]
+will point to
+.Qq cat ,
+.Li tokens[1]
+will point to
+.Qq dog ,
+.Li tokens[2]
+will point to
+.Qq horse ,
+and
+.Li tokens[3]
+will point to
+.Qq cow .
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr strchr 3 ,
+.Xr strcspn 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strsep 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3
+.Sh STANDARDS
+The
+.Fn strtok
+function conforms to
+.St -ansiC .
+.Sh BUGS
+The System V
+.Fn strtok ,
+if handed a string containing only delimiter characters,
+will not alter the next starting point, so that a call to
+.Fn strtok
+with a different (or empty) delimiter string
+may return a non-null value.
+Since this implementation always alters the next starting point,
+such a sequence of calls would always return
+.Dv NULL .
diff --git a/src/lib/libc/string/strtok.c b/src/lib/libc/string/strtok.c
new file mode 100644
index 0000000000..4e963a019e
--- /dev/null
+++ b/src/lib/libc/string/strtok.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 1988 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.
+ */
+
+#include <string.h>
+
+char *
+strtok(char *s, const char *delim)
+{
+        static char *last;
+
+        return strtok_r(s, delim, &last);
+}
+
+char *
+strtok_r(char *s, const char *delim, char **last)
+{
+        char *spanp;
+        int c, sc;
+        char *tok;
+
+
+        if (s == NULL && (s = *last) == NULL)
+                return (NULL);
+
+        /*
+         * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
+         */
+cont:
+        c = *s++;
+        for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
+                if (c == sc)
+                        goto cont;
+        }
+
+        if (c == 0) {           /* no non-delimiter characters */
+                *last = NULL;
+                return (NULL);
+        }
+        tok = s - 1;
+
+        /*
+         * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
+         * Note that delim must have one NUL; we stop if we see that, too.
+         */
+        for (;;) {
+                c = *s++;
+                spanp = (char *)delim;
+                do {
+                        if ((sc = *spanp++) == c) {
+                                if (c == 0)
+                                        s = NULL;
+                                else
+                                        s[-1] = 0;
+                                *last = s;
+                                return (tok);
+                        }
+                } while (sc != 0);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/strxfrm.3 b/src/lib/libc/string/strxfrm.3
new file mode 100644
index 0000000000..008bd611e4
--- /dev/null
+++ b/src/lib/libc/string/strxfrm.3
@@ -0,0 +1,62 @@
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     $OpenBSD: strxfrm.3,v 1.5 2005/08/12 18:34:32 jmc Exp $
+.\"
+.Dd June 29, 1991
+.Dt STRXFRM 3
+.Os
+.Sh NAME
+.Nm strxfrm
+.Nd transform a string under locale
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strxfrm "char *dst" "const char *src" "size_t n"
+.Sh DESCRIPTION
+The
+.Fn strxfrm
+function does something horrible (see
+.Tn ANSI
+standard).
+In this implementation it just copies.
+.Sh SEE ALSO
+.Xr bcmp 3 ,
+.Xr memcmp 3 ,
+.Xr setlocale 3 ,
+.Xr strcasecmp 3 ,
+.Xr strcmp 3 ,
+.Xr strcoll 3
+.Sh STANDARDS
+The
+.Fn strxfrm
+function conforms to
+.St -ansiC .
diff --git a/src/lib/libc/string/strxfrm.c b/src/lib/libc/string/strxfrm.c
new file mode 100644
index 0000000000..6f289c901e
--- /dev/null
+++ b/src/lib/libc/string/strxfrm.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: strxfrm.c,v 1.6 2005/08/08 08:05:37 espie Exp $ */
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+/*
+ * Transform src, storing the result in dst, such that
+ * strcmp() on transformed strings returns what strcoll()
+ * on the original untransformed strings would return.
+ */
+size_t
+strxfrm(char *dst, const char *src, size_t n)
+{
+
+        /*
+         * Since locales are unimplemented, this is just a copy.
+         */
+        if (n == 0)
+                return (strlen(src));
+        return (strlcpy(dst, src, n));
+}
diff --git a/src/lib/libc/string/swab.3 b/src/lib/libc/string/swab.3
new file mode 100644
index 0000000000..abeff903de
--- /dev/null
+++ b/src/lib/libc/string/swab.3
@@ -0,0 +1,61 @@
+.\" Copyright (c) 1990, 1991 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.
+.\"
+.\"     $OpenBSD: swab.3,v 1.5 2003/06/02 20:18:38 millert Exp $
+.\"
+.Dd May 1, 1991
+.Dt SWAB 3
+.Os
+.Sh NAME
+.Nm swab
+.Nd swap adjacent bytes
+.Sh SYNOPSIS
+.Fd #include <unistd.h>
+.Ft void
+.Fn swab "const void *src" "void *dst" "size_t len"
+.Sh DESCRIPTION
+The function
+.Fn swab
+copies
+.Fa len
+bytes from the location referenced by
+.Fa src
+to the location referenced by
+.Fa dst ,
+swapping adjacent bytes.
+.Pp
+The argument
+.Fa len
+must be an even number.
+.Sh SEE ALSO
+.Xr bzero 3 ,
+.Xr memset 3
+.Sh HISTORY
+A
+.Fn swab
+function appeared in
+.At v7 .
diff --git a/src/lib/libc/string/swab.c b/src/lib/libc/string/swab.c
new file mode 100644
index 0000000000..b53717dcde
--- /dev/null
+++ b/src/lib/libc/string/swab.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: swab.c,v 1.7 2005/08/08 08:05:37 espie Exp $ */
+/*
+ * Copyright (c) 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Jeffrey Mogul.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <unistd.h>
+
+void
+swab(const void *from, void *to, size_t len)
+{
+        unsigned long temp;
+        int n;
+        char *fp, *tp;
+
+        n = (len >> 1) + 1;
+        fp = (char *)from;
+        tp = (char *)to;
+#define STEP    temp = *fp++,*tp++ = *fp++,*tp++ = temp
+        /* round to multiple of 8 */
+        while ((--n) & 07)
+                STEP;
+        n >>= 3;
+        while (--n >= 0) {
+                STEP; STEP; STEP; STEP;
+                STEP; STEP; STEP; STEP;
+        }
+}
diff --git a/src/lib/libc/string/wcscat.c b/src/lib/libc/string/wcscat.c
new file mode 100644
index 0000000000..a4841a975a
--- /dev/null
+++ b/src/lib/libc/string/wcscat.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: wcscat.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcscat.c,v 1.2 2001/01/03 14:29:36 lukem Exp $ */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcscat.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+#if defined(APIWARN)
+__warn_references(wcscat,
+    "warning: wcscat() is almost always misused, please use wcslcat()");
+#endif
+
+wchar_t *
+wcscat(wchar_t *s1, const wchar_t *s2)
+{
+        wchar_t *p;
+        wchar_t *q;
+        const wchar_t *r;
+
+        p = s1;
+        while (*p)
+                p++;
+        q = p;
+        r = s2;
+        while (*r)
+                *q++ = *r++;
+        *q = '\0';
+        return s1;
+}
diff --git a/src/lib/libc/string/wcschr.c b/src/lib/libc/string/wcschr.c
new file mode 100644
index 0000000000..c06127e087
--- /dev/null
+++ b/src/lib/libc/string/wcschr.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: wcschr.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcschr.c,v 1.2 2001/01/03 14:29:36 lukem Exp $ */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcschr.c,v 1.2 2000/12/21 05:07:25 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcschr(const wchar_t *s, wchar_t c)
+{
+        const wchar_t *p;
+
+        p = s;
+        while (*p) {
+                if (*p == c) {
+                        /* LINTED interface specification */
+                        return (wchar_t *)p;
+                }
+                p++;
+        }
+        return NULL;
+}
diff --git a/src/lib/libc/string/wcscmp.c b/src/lib/libc/string/wcscmp.c
new file mode 100644
index 0000000000..4a8f6ba3fb
--- /dev/null
+++ b/src/lib/libc/string/wcscmp.c
@@ -0,0 +1,51 @@
+/*      $OpenBSD: wcscmp.c,v 1.4 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcscmp.c,v 1.5 2003/08/07 16:43:54 agc Exp $   */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <wchar.h>
+#include "locale/runetype.h"
+
+/*
+ * Compare strings.
+ */
+int
+wcscmp(const wchar_t *s1, const wchar_t *s2)
+{
+
+        while (*s1 == *s2++)
+                if (*s1++ == 0)
+                        return (0);
+        /* XXX assumes wchar_t = int */
+        return (*(const rune_t *)s1 - *(const rune_t *)--s2);
+}
diff --git a/src/lib/libc/string/wcscpy.c b/src/lib/libc/string/wcscpy.c
new file mode 100644
index 0000000000..75fdb75fe4
--- /dev/null
+++ b/src/lib/libc/string/wcscpy.c
@@ -0,0 +1,52 @@
+/*      $OpenBSD: wcscpy.c,v 1.4 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcscpy.c,v 1.2 2001/01/03 14:29:36 lukem Exp $ */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcscpy.c,v 1.2 2000/12/21 04:51:09 itojun Exp
+ */
+
+#include <wchar.h>
+
+#if defined(APIWARN)
+__warn_references(wcscpy,
+    "warning: wcscpy() is almost always misused, please use wcslcpy()");
+#endif
+
+wchar_t *
+wcscpy(wchar_t *s1, const wchar_t *s2)
+{
+        wchar_t *p;
+        const wchar_t *q;
+
+        p = s1;
+        q = s2;
+        while (*q)
+                *p++ = *q++;
+        *p = '\0';
+
+        return s1;
+}
diff --git a/src/lib/libc/string/wcscspn.c b/src/lib/libc/string/wcscspn.c
new file mode 100644
index 0000000000..cf40092465
--- /dev/null
+++ b/src/lib/libc/string/wcscspn.c
@@ -0,0 +1,53 @@
+/*      $OpenBSD: wcscspn.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcscspn.c,v 1.2 2001/01/03 14:29:36 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcscspn.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+size_t
+wcscspn(const wchar_t *s, const wchar_t *set)
+{
+        const wchar_t *p;
+        const wchar_t *q;
+
+        p = s;
+        while (*p) {
+                q = set;
+                while (*q) {
+                        if (*p == *q)
+                                goto done;
+                        q++;
+                }
+                p++;
+        }
+
+done:
+        return (p - s);
+}
diff --git a/src/lib/libc/string/wcslcat.c b/src/lib/libc/string/wcslcat.c
new file mode 100644
index 0000000000..bcd52d1f3c
--- /dev/null
+++ b/src/lib/libc/string/wcslcat.c
@@ -0,0 +1,68 @@
+/*      $OpenBSD: wcslcat.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcslcat.c,v 1.2 2001/01/03 14:33:02 lukem Exp $        */
+/*      from OpenBSD: strlcat.c,v 1.3 2000/11/24 11:10:02 itojun Exp    */
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * 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. 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 ``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 <wchar.h>
+
+/*
+ * Appends src to string dst of size siz (unlike wcsncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns wcslen(initial dst) + wcslen(src); if retval >= siz,
+ * truncation occurred.
+ */
+size_t
+wcslcat(wchar_t *dst, const wchar_t *src, size_t siz)
+{
+        wchar_t *d = dst;
+        const wchar_t *s = src;
+        size_t n = siz;
+        size_t dlen;
+
+        /* Find the end of dst and adjust bytes left but don't go past end */
+        while (*d != '\0' && n-- != 0)
+                d++;
+        dlen = d - dst;
+        n = siz - dlen;
+
+        if (n == 0)
+                return(dlen + wcslen(s));
+        while (*s != '\0') {
+                if (n != 1) {
+                        *d++ = *s;
+                        n--;
+                }
+                s++;
+        }
+        *d = '\0';
+
+        return(dlen + (s - src));       /* count does not include NUL */
+}
diff --git a/src/lib/libc/string/wcslcpy.c b/src/lib/libc/string/wcslcpy.c
new file mode 100644
index 0000000000..85f51df35f
--- /dev/null
+++ b/src/lib/libc/string/wcslcpy.c
@@ -0,0 +1,64 @@
+/*      $OpenBSD: wcslcpy.c,v 1.4 2006/05/05 15:27:38 millert Exp $     */
+/*      $NetBSD: wcslcpy.c,v 1.2 2001/01/03 14:33:02 lukem Exp $        */
+/*      from OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp   */
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * 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. 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 ``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 <wchar.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns wcslen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+wcslcpy(wchar_t *dst, const wchar_t *src, size_t siz)
+{
+        wchar_t *d = dst;
+        const wchar_t *s = src;
+        size_t n = siz;
+
+        /* Copy as many bytes as will fit */
+        if (n != 0) {
+                while (--n != 0) {
+                        if ((*d++ = *s++) == '\0')
+                                break;
+                }
+        }
+
+        /* Not enough room in dst, add NUL and traverse rest of src */
+        if (n == 0) {
+                if (siz != 0)
+                        *d = '\0';              /* NUL-terminate dst */
+                while (*s++)
+                        ;
+        }
+
+        return(s - src - 1);    /* count does not include NUL */
+}
diff --git a/src/lib/libc/string/wcslen.c b/src/lib/libc/string/wcslen.c
new file mode 100644
index 0000000000..c1de4a271e
--- /dev/null
+++ b/src/lib/libc/string/wcslen.c
@@ -0,0 +1,44 @@
+/*      $OpenBSD: wcslen.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcslen.c,v 1.2 2001/01/03 14:29:36 lukem Exp $ */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcslen.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+size_t
+wcslen(const wchar_t *s)
+{
+        const wchar_t *p;
+
+        p = s;
+        while (*p)
+                p++;
+
+        return p - s;
+}
diff --git a/src/lib/libc/string/wcsncat.c b/src/lib/libc/string/wcsncat.c
new file mode 100644
index 0000000000..eb9a701514
--- /dev/null
+++ b/src/lib/libc/string/wcsncat.c
@@ -0,0 +1,52 @@
+/*      $OpenBSD: wcsncat.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcsncat.c,v 1.2 2001/01/03 14:29:36 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcsncat.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcsncat(wchar_t *s1, const wchar_t *s2, size_t n)
+{
+        wchar_t *p;
+        wchar_t *q;
+        const wchar_t *r;
+
+        p = s1;
+        while (*p)
+                p++;
+        q = p;
+        r = s2;
+        while (*r && n) {
+                *q++ = *r++;
+                n--;
+        }
+        *q = '\0';
+        return s1;
+}
diff --git a/src/lib/libc/string/wcsncmp.c b/src/lib/libc/string/wcsncmp.c
new file mode 100644
index 0000000000..fb3c7057cf
--- /dev/null
+++ b/src/lib/libc/string/wcsncmp.c
@@ -0,0 +1,52 @@
+/*      $OpenBSD: wcsncmp.c,v 1.4 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcsncmp.c,v 1.5 2003/08/07 16:43:54 agc Exp $  */
+
+/*
+ * Copyright (c) 1989, 1993
+ *      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.
+ */
+
+#include <wchar.h>
+#include "locale/runetype.h"
+
+int
+wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n)
+{
+
+        if (n == 0)
+                return (0);
+        do {
+                if (*s1 != *s2++) {
+                        /* XXX assumes wchar_t = int */
+                        return (*(const rune_t *)s1 -
+                            *(const rune_t *)--s2);
+                }
+                if (*s1++ == 0)
+                        break;
+        } while (--n != 0);
+        return (0);
+}
diff --git a/src/lib/libc/string/wcsncpy.c b/src/lib/libc/string/wcsncpy.c
new file mode 100644
index 0000000000..107696f1de
--- /dev/null
+++ b/src/lib/libc/string/wcsncpy.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: wcsncpy.c,v 1.4 2006/04/17 18:05:35 espie Exp $       */
+/*      $NetBSD: wcsncpy.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcsncpy.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcsncpy(wchar_t *s1, const wchar_t *s2, size_t n)
+{
+        wchar_t *p;
+
+        p = s1;
+        while (n && *s2) {
+                *p++ = *s2++;
+                n--;
+        }
+        while (n) {
+                *p++ = L'\0';
+                n--;
+        }
+
+        return s1;
+}
diff --git a/src/lib/libc/string/wcspbrk.c b/src/lib/libc/string/wcspbrk.c
new file mode 100644
index 0000000000..1923abfc89
--- /dev/null
+++ b/src/lib/libc/string/wcspbrk.c
@@ -0,0 +1,53 @@
+/*      $OpenBSD: wcspbrk.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcspbrk.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcspbrk.c,v 1.2 2000/12/21 05:07:25 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcspbrk(const wchar_t *s, const wchar_t *set)
+{
+        const wchar_t *p;
+        const wchar_t *q;
+
+        p = s;
+        while (*p) {
+                q = set;
+                while (*q) {
+                        if (*p == *q) {
+                                /* LINTED interface specification */
+                                return (wchar_t *)p;
+                        }
+                        q++;
+                }
+                p++;
+        }
+        return NULL;
+}
diff --git a/src/lib/libc/string/wcsrchr.c b/src/lib/libc/string/wcsrchr.c
new file mode 100644
index 0000000000..3433310c56
--- /dev/null
+++ b/src/lib/libc/string/wcsrchr.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: wcsrchr.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wcsrchr.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcsrchr.c,v 1.2 2000/12/21 05:07:25 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcsrchr(const wchar_t *s, wchar_t c)
+{
+        const wchar_t *p;
+
+        p = s;
+        while (*p)
+                p++;
+        while (s <= p) {
+                if (*p == c) {
+                        /* LINTED interface specification */
+                        return (wchar_t *)p;
+                }
+                p--;
+        }
+        return NULL;
+}
diff --git a/src/lib/libc/string/wcsspn.c b/src/lib/libc/string/wcsspn.c
new file mode 100644
index 0000000000..5162fa0763
--- /dev/null
+++ b/src/lib/libc/string/wcsspn.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: wcsspn.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcsspn.c,v 1.3 2001/09/21 16:09:15 yamt Exp $  */
+
+/*-
+ * Copyright (c)1999,2001 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      $Citrus: xpg4dl/FreeBSD/lib/libc/string/wcsspn.c,v 1.3 2001/09/21 16:06:43 yamt Exp $
+ */
+
+#include <wchar.h>
+
+size_t
+wcsspn(const wchar_t *s, const wchar_t *set)
+{
+        const wchar_t *p;
+        const wchar_t *q;
+
+        p = s;
+        while (*p) {
+                q = set;
+                while (*q) {
+                        if (*p == *q)
+                                break;
+                        q++;
+                }
+                if (!*q)
+                        goto done;
+                p++;
+        }
+
+done:
+        return (p - s);
+}
diff --git a/src/lib/libc/string/wcsstr.c b/src/lib/libc/string/wcsstr.c
new file mode 100644
index 0000000000..669e340280
--- /dev/null
+++ b/src/lib/libc/string/wcsstr.c
@@ -0,0 +1,70 @@
+/*      $OpenBSD: wcsstr.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/*      $NetBSD: wcsstr.c,v 1.3 2003/03/05 20:18:17 tshiozak Exp $      */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcsstr.c,v 1.2 2000/12/21 05:07:25 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+#ifdef WCSWCS
+wcswcs(const wchar_t *big, const wchar_t *little)
+#else
+wcsstr(const wchar_t *big, const wchar_t *little)
+#endif
+{
+        const wchar_t *p;
+        const wchar_t *q;
+        const wchar_t *r;
+
+        if (!*little) {
+                /* LINTED interface specification */
+                return (wchar_t *)big;
+        }
+        if (wcslen(big) < wcslen(little))
+                return NULL;
+
+        p = big;
+        q = little;
+        while (*p) {
+                q = little;
+                r = p;
+                while (*q) {
+                        if (*r != *q)
+                                break;
+                        q++;
+                        r++;
+                }
+                if (!*q) {
+                        /* LINTED interface specification */
+                        return (wchar_t *)p;
+                }
+                p++;
+        }
+        return NULL;
+}
diff --git a/src/lib/libc/string/wcstok.3 b/src/lib/libc/string/wcstok.3
new file mode 100644
index 0000000000..fef2754474
--- /dev/null
+++ b/src/lib/libc/string/wcstok.3
@@ -0,0 +1,136 @@
+.\"     $OpenBSD: wcstok.3,v 1.4 2005/08/07 10:22:21 jmc Exp $
+.\"
+.\" $NetBSD: wcstok.3,v 1.3 2003/09/08 17:54:33 wiz Exp $
+.\"
+.\" Copyright (c) 1998 Softweyr LLC.  All rights reserved.
+.\"
+.\" strtok_r, from Berkeley strtok
+.\" Oct 13, 1998 by Wes Peters <wes@softweyr.com>
+.\"
+.\" Copyright (c) 1988, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" the American National Standards Committee X3, on Information
+.\" Processing Systems.
+.\"
+.\" 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
+.\"    notices, this list of conditions and the following disclaimer.
+.\"
+.\" 2. Redistributions in binary form must reproduce the above
+.\"    copyright notices, 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 Softweyr LLC, the
+.\"      University of California, Berkeley, and its contributors.
+.\"
+.\" 4. Neither the name of Softweyr LLC, 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 SOFTWEYR LLC, 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 SOFTWEYR LLC, 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.
+.\"
+.\" Original version ID:
+.\" FreeBSD: src/lib/libc/string/wcstok.3,v 1.4 2002/10/15 09:49:54 tjr Exp
+.\"
+.Dd October 3, 2002
+.Dt WCSTOK 3
+.Os
+.Sh NAME
+.Nm wcstok
+.Nd split wide-character string into tokens
+.Sh SYNOPSIS
+.In wchar.h
+.Ft wchar_t *
+.Fn wcstok "wchar_t * restrict str" "const wchar_t * restrict sep" "wchar_t ** restrict last"
+.Sh DESCRIPTION
+The
+.Fn wcstok
+function
+is used to isolate sequential tokens in a NUL-terminated wide character
+string,
+.Fa str .
+These tokens are separated in the string by at least one of the
+characters in
+.Fa sep .
+The first time that
+.Fn wcstok
+is called,
+.Fa str
+should be specified; subsequent calls, wishing to obtain further tokens
+from the same string, should pass a null pointer instead.
+The separator string,
+.Fa sep ,
+must be supplied each time, and may change between calls.
+The context pointer
+.Fa last
+must be provided on each call.
+.Pp
+The
+.Fn wcstok
+function is the wide character counterpart of the
+.Fn strtok_r
+function.
+.Sh RETURN VALUES
+The
+.Fn wcstok
+function
+returns a pointer to the beginning of each subsequent token in the string,
+after replacing the token itself with a NUL wide character (L'\e0').
+When no more tokens remain, a null pointer is returned.
+.Sh EXAMPLES
+The following code fragment splits a wide character string on
+.Tn ASCII
+space, tab, and newline characters and writes the tokens to
+standard output:
+.Bd -literal -offset indent
+const wchar_t *seps = L" \et\en";
+wchar_t *last, *tok, text[] = L" \enone\ettwo\et\etthree  \en";
+
+for (tok = wcstok(text, seps, &last); tok != NULL;
+    tok = wcstok(NULL, seps, &last))
+        wprintf(L"%ls\en", tok);
+.Ed
+.Sh SEE ALSO
+.Xr strtok 3 ,
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3
+.Sh STANDARDS
+The
+.Fn wcstok
+function
+conforms to
+.St -isoC-99 .
+.Sh HISTORY
+Some early implementations of
+.Fn wcstok
+omit the
+context pointer argument,
+.Fa last ,
+and maintain state across calls in a static variable like
+.Fn strtok
+does.
diff --git a/src/lib/libc/string/wcstok.c b/src/lib/libc/string/wcstok.c
new file mode 100644
index 0000000000..bc1ac3e8cb
--- /dev/null
+++ b/src/lib/libc/string/wcstok.c
@@ -0,0 +1,93 @@
+/*      $OpenBSD: wcstok.c,v 1.3 2005/08/08 08:05:37 espie Exp $        */
+/* $NetBSD: wcstok.c,v 1.3 2003/07/10 08:50:48 tshiozak Exp $ */
+
+/*-
+ * Copyright (c) 1998 Softweyr LLC.  All rights reserved.
+ *
+ * strtok_r, from Berkeley strtok
+ * Oct 13, 1998 by Wes Peters <wes@softweyr.com>
+ *
+ * Copyright (c) 1988, 1993
+ *      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
+ *    notices, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notices, 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 Softweyr LLC, the
+ *      University of California, Berkeley, and its contributors.
+ * 4. 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 SOFTWEYR LLC, 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 SOFTWEYR LLC, 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.
+ *
+ * Original version ID:
+ * FreeBSD: src/lib/libc/string/wcstok.c,v 1.1 2002/09/07 08:16:57 tjr Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wcstok(wchar_t * __restrict s, const wchar_t * __restrict delim, 
+    wchar_t ** __restrict last)
+{
+        const wchar_t *spanp;
+        wchar_t c, sc;
+        wchar_t *tok;
+
+        if (s == NULL && (s = *last) == NULL)
+                return (NULL);
+
+        /*
+         * Skip (span) leading delimiters (s += wcsspn(s, delim), sort of).
+         */
+cont:
+        c = *s++;
+        for (spanp = delim; (sc = *spanp++) != L'\0';) {
+                if (c == sc)
+                        goto cont;
+        }
+
+        if (c == L'\0') {       /* no non-delimiter characters */
+                *last = NULL;
+                return (NULL);
+        }
+        tok = s - 1;
+
+        /*
+         * Scan token (scan for delimiters: s += wcscspn(s, delim), sort of).
+         * Note that delim must have one NUL; we stop if we see that, too.
+         */
+        for (;;) {
+                c = *s++;
+                spanp = delim;
+                do {
+                        if ((sc = *spanp++) == c) {
+                                if (c == L'\0')
+                                        s = NULL;
+                                else
+                                        s[-1] = L'\0';
+                                *last = s;
+                                return (tok);
+                        }
+                } while (sc != L'\0');
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/wcswcs.c b/src/lib/libc/string/wcswcs.c
new file mode 100644
index 0000000000..bd35605547
--- /dev/null
+++ b/src/lib/libc/string/wcswcs.c
@@ -0,0 +1,5 @@
+/*      $OpenBSD: wcswcs.c,v 1.1 2005/04/13 16:35:58 espie Exp $        */
+/* $NetBSD: wcswcs.c,v 1.1 2003/03/05 20:18:17 tshiozak Exp $ */
+
+#define WCSWCS
+#include "wcsstr.c"
diff --git a/src/lib/libc/string/wcswidth.c b/src/lib/libc/string/wcswidth.c
new file mode 100644
index 0000000000..cd240897b5
--- /dev/null
+++ b/src/lib/libc/string/wcswidth.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: wcswidth.c,v 1.3 2005/08/08 08:05:37 espie Exp $      */
+/*      $NetBSD: wcswidth.c,v 1.2 2001/01/03 14:29:37 lukem Exp $       */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wcswidth.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp
+ */
+
+#include <wchar.h>
+
+int
+wcswidth(const wchar_t *s, size_t n)
+{
+        int w;
+
+        w = 0;
+        while (n && *s) {
+                w += wcwidth(*s);
+                s++;
+                n--;
+        }
+
+        return w;
+}
diff --git a/src/lib/libc/string/wmemchr.3 b/src/lib/libc/string/wmemchr.3
new file mode 100644
index 0000000000..0b6935837c
--- /dev/null
+++ b/src/lib/libc/string/wmemchr.3
@@ -0,0 +1,141 @@
+.\"     $OpenBSD: wmemchr.3,v 1.2 2005/04/13 20:42:48 jmc Exp $
+.\"
+.\"     $NetBSD: wmemchr.3,v 1.9 2003/09/08 17:54:33 wiz Exp $
+.\"
+.\" Copyright (c) 1990, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Chris Torek and the American National Standards Committee X3,
+.\" on Information Processing Systems.
+.\"
+.\" 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.
+.\"
+.\"     from: @(#)strcpy.3      8.1 (Berkeley) 6/4/93
+.\"
+.Dd December 22, 2000
+.Dt WMEMCHR 3
+.Os
+.Sh NAME
+.Nm wmemchr ,
+.Nm wmemcmp ,
+.Nm wmemcpy ,
+.Nm wmemmove ,
+.Nm wmemset ,
+.Nm wcscat ,
+.Nm wcschr ,
+.Nm wcscmp ,
+.Nm wcscpy ,
+.Nm wcscspn ,
+.Nm wcslcat ,
+.Nm wcslcpy ,
+.Nm wcslen ,
+.Nm wcsncat ,
+.Nm wcsncmp ,
+.Nm wcsncpy ,
+.Nm wcspbrk ,
+.Nm wcsrchr ,
+.Nm wcsspn ,
+.Nm wcsstr
+.Nd wide character string manipulation operations
+.Sh SYNOPSIS
+.In wchar.h
+.Ft wchar_t *
+.Fn wmemchr "const wchar_t *s" "wchar_t c" "size_t n"
+.Ft int
+.Fn wmemcmp "const wchar_t *s1" "const wchar_t *s2" "size_t n"
+.Ft wchar_t *
+.Fn wmemcpy "wchar_t * restrict s1" "const wchar_t * restrict s2" "size_t n"
+.Ft wchar_t *
+.Fn wmemmove "wchar_t *s1" "const wchar_t *s2" "size_t n"
+.Ft wchar_t *
+.Fn wmemset "wchar_t *s" "wchar_t c" "size_t n"
+.Ft wchar_t *
+.Fn wcscat "wchar_t * restrict s1" "const wchar_t * restrict s2"
+.Ft wchar_t *
+.Fn wcschr "const wchar_t *s" "wchar_t c"
+.Ft int
+.Fn wcscmp "const wchar_t *s1" "const wchar_t *s2"
+.Ft wchar_t *
+.Fn wcscpy "wchar_t * restrict s1" "const wchar_t * restrict s2"
+.Ft size_t
+.Fn wcscspn "const wchar_t *s1" "const wchar_t *s2"
+.Ft size_t
+.Fn wcslcat "wchar_t *s1" "const wchar_t *s2" "size_t n"
+.Ft size_t
+.Fn wcslcpy "wchar_t *s1" "const wchar_t *s2" "size_t n"
+.Ft size_t
+.Fn wcslen "const wchar_t *s"
+.Ft wchar_t *
+.Fn wcsncat "wchar_t * restrict s1" "const wchar_t * restrict s2" "size_t n"
+.Ft int
+.Fn wcsncmp "const wchar_t *s1" "const wchar_t * s2" "size_t n"
+.Ft wchar_t *
+.Fn wcsncpy "wchar_t * restrict s1" "const wchar_t * restrict s2" "size_t n"
+.Ft wchar_t *
+.Fn wcspbrk "const wchar_t *s1" "const wchar_t *s2"
+.Ft wchar_t *
+.Fn wcsrchr "const wchar_t *s" "wchar_t c"
+.Ft size_t
+.Fn wcsspn "const wchar_t *s1" "const wchar_t *s2"
+.Ft wchar_t *
+.Fn wcsstr "const wchar_t *s1" "const wchar_t *s2"
+.Sh DESCRIPTION
+These functions implement string manipulation operations over wide character
+strings.
+For a detailed description, refer to documents for the respective single-byte
+counterpart, such as
+.Xr memchr 3 .
+.Sh SEE ALSO
+.Xr memchr 3 ,
+.Xr memcmp 3 ,
+.Xr memcpy 3 ,
+.Xr memmove 3 ,
+.Xr memset 3 ,
+.Xr strcat 3 ,
+.Xr strchr 3 ,
+.Xr strcmp 3 ,
+.Xr strcpy 3 ,
+.Xr strcspn 3 ,
+.Xr strlcat 3 ,
+.Xr strlcpy 3 ,
+.Xr strlen 3 ,
+.Xr strncat 3 ,
+.Xr strncmp 3 ,
+.Xr strncpy 3 ,
+.Xr strpbrk 3 ,
+.Xr strrchr 3 ,
+.Xr strspn 3 ,
+.Xr strstr 3
+.Sh STANDARDS
+These functions conform to
+.St -isoC-99
+and were first introduced in
+.St -isoC-amd1 ,
+with the exception of
+.Fn wcslcat
+and
+.Fn wcslcpy ,
+which are extensions.
diff --git a/src/lib/libc/string/wmemchr.c b/src/lib/libc/string/wmemchr.c
new file mode 100644
index 0000000000..8c9517861b
--- /dev/null
+++ b/src/lib/libc/string/wmemchr.c
@@ -0,0 +1,47 @@
+/*      $OpenBSD: wmemchr.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wmemchr.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wmemchr.c,v 1.2 2000/12/20 14:08:31 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wmemchr(const wchar_t *s, wchar_t c, size_t n)
+{
+        size_t i;
+
+        for (i = 0; i < n; i++) {
+                if (*s == c) {
+                        /* LINTED const castaway */
+                        return (wchar_t *)s;
+                }
+                s++;
+        }
+        return NULL;
+}
diff --git a/src/lib/libc/string/wmemcmp.c b/src/lib/libc/string/wmemcmp.c
new file mode 100644
index 0000000000..39419aeddc
--- /dev/null
+++ b/src/lib/libc/string/wmemcmp.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: wmemcmp.c,v 1.4 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wmemcmp.c,v 1.3 2003/04/06 18:33:23 tshiozak Exp $     */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wmemcmp.c,v 1.2 2000/12/20 14:08:31 itojun Exp
+ */
+
+#include <wchar.h>
+#include "locale/runetype.h"
+
+int
+wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n)
+{
+        size_t i;
+
+        for (i = 0; i < n; i++) {
+                if (*s1 != *s2) {
+                        /* wchar might be unsigned */
+                        return *(const rune_t *)s1 >
+                               *(const rune_t *)s2 ? 1 : -1;
+                }
+                s1++;
+                s2++;
+        }
+        return 0;
+}
diff --git a/src/lib/libc/string/wmemcpy.c b/src/lib/libc/string/wmemcpy.c
new file mode 100644
index 0000000000..9bbd83648e
--- /dev/null
+++ b/src/lib/libc/string/wmemcpy.c
@@ -0,0 +1,40 @@
+/*      $OpenBSD: wmemcpy.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wmemcpy.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wmemcpy.c,v 1.2 2000/12/20 14:08:31 itojun Exp
+ */
+
+#include <string.h>
+#include <wchar.h>
+
+wchar_t *
+wmemcpy(wchar_t *d, const wchar_t *s, size_t n)
+{
+
+        return (wchar_t *)memcpy(d, s, n * sizeof(wchar_t));
+}
diff --git a/src/lib/libc/string/wmemmove.c b/src/lib/libc/string/wmemmove.c
new file mode 100644
index 0000000000..21bbabcd0c
--- /dev/null
+++ b/src/lib/libc/string/wmemmove.c
@@ -0,0 +1,40 @@
+/*      $OpenBSD: wmemmove.c,v 1.3 2005/08/08 08:05:37 espie Exp $      */
+/*      $NetBSD: wmemmove.c,v 1.2 2001/01/03 14:29:37 lukem Exp $       */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wmemmove.c,v 1.2 2000/12/20 14:08:31 itojun Exp
+ */
+
+#include <string.h>
+#include <wchar.h>
+
+wchar_t *
+wmemmove(wchar_t *d, const wchar_t *s, size_t n)
+{
+
+        return (wchar_t *)memmove(d, s, n * sizeof(wchar_t));
+}
diff --git a/src/lib/libc/string/wmemset.c b/src/lib/libc/string/wmemset.c
new file mode 100644
index 0000000000..ac476dba6a
--- /dev/null
+++ b/src/lib/libc/string/wmemset.c
@@ -0,0 +1,46 @@
+/*      $OpenBSD: wmemset.c,v 1.3 2005/08/08 08:05:37 espie Exp $       */
+/*      $NetBSD: wmemset.c,v 1.2 2001/01/03 14:29:37 lukem Exp $        */
+
+/*-
+ * Copyright (c)1999 Citrus 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ *      citrus Id: wmemset.c,v 1.2 2000/12/20 14:08:31 itojun Exp
+ */
+
+#include <wchar.h>
+
+wchar_t *
+wmemset(wchar_t *s, wchar_t c, size_t n)
+{
+        size_t i;
+        wchar_t *p;
+
+        p = s;
+        for (i = 0; i < n; i++) {
+                *p = c;
+                p++;
+        }
+        return s;
+}