335 files changed, 31724 insertions, 10667 deletions

diff --git a/src/lib/libc/crypt/Makefile.inc b/src/lib/libc/crypt/Makefile.inc
new file mode 100644
index 0000000000..5dbd240bf5
--- /dev/null
+++ b/src/lib/libc/crypt/Makefile.inc
@@ -0,0 +1,15 @@
+#       $OpenBSD: Makefile.inc,v 1.18 2010/10/28 08:34:37 mikeb Exp $
+
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_CPU}/crypt ${LIBCSRCDIR}/crypt
+
+SRCS+=  crypt.c crypt2.c md5crypt.c arc4random.c blowfish.c bcrypt.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
+MLINKS+=arc4random.3 arc4random_buf.3 arc4random.3 arc4random_uniform.3
diff --git a/src/lib/libc/crypt/arc4random.3 b/src/lib/libc/crypt/arc4random.3
new file mode 100644
index 0000000000..d9f07ade6e
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.3
@@ -0,0 +1,138 @@
+.\" $OpenBSD: arc4random.3,v 1.27 2008/12/23 18:31:02 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.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd $Mdocdate: December 23 2008 $
+.Dt ARC4RANDOM 3
+.Os
+.Sh NAME
+.Nm arc4random ,
+.Nm arc4random_buf ,
+.Nm arc4random_uniform ,
+.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_buf "void *buf" "size_t nbytes"
+.Ft u_int32_t
+.Fn arc4random_uniform "u_int32_t upper_bound"
+.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
+.Fn arc4random_buf
+fills the region
+.Fa buf
+of length
+.Fa nbytes
+with ARC4-derived random data.
+.Pp
+.Fn arc4random_uniform
+will return a uniformly distributed random number less than
+.Fa upper_bound .
+.Fn arc4random_uniform
+is recommended over constructions like
+.Dq Li arc4random() % upper_bound
+as it avoids "modulo bias" when the upper bound is not a power of two.
+.Pp
+The
+.Fn arc4random_stir
+function reads data using
+.Xr sysctl 3
+from
+.Va kern.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 RETURN VALUES
+These functions are always successful, and no return value is
+reserved to indicate an error.
+.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. could
+do nothing about the release of the
+.Ql Alleged RC4
+algorithm.
+Since
+.Pa RC4
+was trademarked, 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..43c6fc0435
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.c
@@ -0,0 +1,263 @@
+/*      $OpenBSD: arc4random.c,v 1.22 2010/12/22 08:23:42 otto Exp $    */
+
+/*
+ * Copyright (c) 1996, David Mazieres <dm@uun.org>
+ * Copyright (c) 2008, Damien Miller <djm@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * 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.
+ *
+ * RC4 is a registered trademark of RSA Laboratories.
+ */
+
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/sysctl.h>
+#include "thread_private.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(void);
+
+static inline void
+arc4_init(void)
+{
+        int     n;
+
+        for (n = 0; n < 256; n++)
+                rs.s[n] = n;
+        rs.i = 0;
+        rs.j = 0;
+}
+
+static inline void
+arc4_addrandom(u_char *dat, int datlen)
+{
+        int     n;
+        u_int8_t si;
+
+        rs.i--;
+        for (n = 0; n < 256; n++) {
+                rs.i = (rs.i + 1);
+                si = rs.s[rs.i];
+                rs.j = (rs.j + si + dat[n % datlen]);
+                rs.s[rs.i] = rs.s[rs.j];
+                rs.s[rs.j] = si;
+        }
+        rs.j = rs.i;
+}
+
+static void
+arc4_stir(void)
+{
+        int     i, mib[2];
+        size_t  len;
+        u_char rnd[128];
+
+        if (!rs_initialized) {
+                arc4_init();
+                rs_initialized = 1;
+        }
+
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_ARND;
+
+        len = sizeof(rnd);
+        sysctl(mib, 2, rnd, &len, NULL, 0);
+
+        arc4_addrandom(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();
+        arc4_count = 1600000;
+}
+
+static void
+arc4_stir_if_needed(void)
+{
+        pid_t pid = getpid();
+
+        if (arc4_count <= 0 || !rs_initialized || arc4_stir_pid != pid)
+        {
+                arc4_stir_pid = pid;
+                arc4_stir();
+        }
+}
+
+static inline u_int8_t
+arc4_getbyte(void)
+{
+        u_int8_t si, sj;
+
+        rs.i = (rs.i + 1);
+        si = rs.s[rs.i];
+        rs.j = (rs.j + si);
+        sj = rs.s[rs.j];
+        rs.s[rs.i] = sj;
+        rs.s[rs.j] = si;
+        return (rs.s[(si + sj) & 0xff]);
+}
+
+static inline u_int32_t
+arc4_getword(void)
+{
+        u_int32_t val;
+        val = arc4_getbyte() << 24;
+        val |= arc4_getbyte() << 16;
+        val |= arc4_getbyte() << 8;
+        val |= arc4_getbyte();
+        return val;
+}
+
+void
+arc4random_stir(void)
+{
+        _ARC4_LOCK();
+        arc4_stir();
+        _ARC4_UNLOCK();
+}
+
+void
+arc4random_addrandom(u_char *dat, int datlen)
+{
+        _ARC4_LOCK();
+        if (!rs_initialized)
+                arc4_stir();
+        arc4_addrandom(dat, datlen);
+        _ARC4_UNLOCK();
+}
+
+u_int32_t
+arc4random(void)
+{
+        u_int32_t val;
+        _ARC4_LOCK();
+        arc4_count -= 4;
+        arc4_stir_if_needed();
+        val = arc4_getword();
+        _ARC4_UNLOCK();
+        return val;
+}
+
+void
+arc4random_buf(void *_buf, size_t n)
+{
+        u_char *buf = (u_char *)_buf;
+        _ARC4_LOCK();
+        arc4_stir_if_needed();
+        while (n--) {
+                if (--arc4_count <= 0)
+                        arc4_stir();
+                buf[n] = arc4_getbyte();
+        }
+        _ARC4_UNLOCK();
+}
+
+/*
+ * Calculate a uniformly distributed random number less than upper_bound
+ * avoiding "modulo bias".
+ *
+ * Uniformity is achieved by generating new random numbers until the one
+ * returned is outside the range [0, 2**32 % upper_bound).  This
+ * guarantees the selected random number will be inside
+ * [2**32 % upper_bound, 2**32) which maps back to [0, upper_bound)
+ * after reduction modulo upper_bound.
+ */
+u_int32_t
+arc4random_uniform(u_int32_t upper_bound)
+{
+        u_int32_t r, min;
+
+        if (upper_bound < 2)
+                return 0;
+
+#if (ULONG_MAX > 0xffffffffUL)
+        min = 0x100000000UL % upper_bound;
+#else
+        /* Calculate (2**32 % upper_bound) avoiding 64-bit math */
+        if (upper_bound > 0x80000000)
+                min = 1 + ~upper_bound;         /* 2**32 - upper_bound */
+        else {
+                /* (2**32 - (x * 2)) % x == 2**32 % x when x <= 2**31 */
+                min = ((0xffffffff - (upper_bound * 2)) + 1) % upper_bound;
+        }
+#endif
+
+        /*
+         * This could theoretically loop forever but each retry has
+         * p > 0.5 (worst case, usually far better) of selecting a
+         * number inside the range we need, so it should rarely need
+         * to re-roll.
+         */
+        for (;;) {
+                r = arc4random();
+                if (r >= min)
+                        break;
+        }
+
+        return r % upper_bound;
+}
+
+#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..207e76ea46
--- /dev/null
+++ b/src/lib/libc/crypt/bcrypt.c
@@ -0,0 +1,338 @@
+/*      $OpenBSD: bcrypt.c,v 1.24 2008/04/02 19:54:05 millert 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);
+ *
+ */
+
+#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[7 + (BCRYPT_MAXSALT * 4 + 2) / 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);
+        memset(&state, 0, sizeof(state));
+        memset(ciphertext, 0, sizeof(ciphertext));
+        memset(csalt, 0, sizeof(csalt));
+        memset(cdata, 0, sizeof(cdata));
+        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, sizeof(salt) - 6, stdin);
+        salt[99] = 0;
+        printf("72 bytes of password: ");
+        fpurge(stdin);
+        fgets(blubber, sizeof(blubber), 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..4defaecc34
--- /dev/null
+++ b/src/lib/libc/crypt/blowfish.3
@@ -0,0 +1,106 @@
+.\" $OpenBSD: blowfish.3,v 1.20 2007/05/31 19:19:27 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 $Mdocdate: May 31 2007 $
+.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 blocks"
+.Ft void
+.Fn blf_dec "blf_ctx *state" "u_int32_t *data" "u_int16_t blocks"
+.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
+.Em 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
+.Fa blocks
+is the number of 64-bit blocks in the stream.
+.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).
+For these functions
+.Fa datalen
+specifies the number of octets of data to encrypt or decrypt.
+It must be a multiple of 8 (64-bit block).
+The initialisation vector
+.Fa iv
+points to an 8-byte buffer.
+.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/crypt.3 b/src/lib/libc/crypt/crypt.3
new file mode 100644
index 0000000000..b58894d9ad
--- /dev/null
+++ b/src/lib/libc/crypt/crypt.3
@@ -0,0 +1,324 @@
+.\" $OpenBSD: crypt.3,v 1.27 2007/10/08 11:55:27 pyr 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 $Mdocdate: October 8 2007 $
+.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
+.Fn crypt ,
+.Fn setkey ,
+and
+.Fn des_setkey
+functions all manipulate the same key space.
+.Sh RETURN VALUES
+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.
+.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..b32cd2115f
--- /dev/null
+++ b/src/lib/libc/crypt/md5crypt.c
@@ -0,0 +1,149 @@
+/*      $OpenBSD: md5crypt.c,v 1.15 2009/10/31 13:29:07 sobrado 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/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
index 803657e006..4a51f15ddf 100644
--- a/src/lib/libc/include/namespace.h
+++ b/src/lib/libc/include/namespace.h
@@ -1,4 +1,4 @@
-/*      $NetBSD: namespace.h,v 1.2 1995/02/27 13:02:12 cgd Exp $        */
+/*      $OpenBSD: namespace.h,v 1.2 1996/08/19 08:28:08 tholo Exp $     */
 
 #define catclose        _catclose
 #define catgets         _catgets
diff --git a/src/lib/libc/include/thread_private.h b/src/lib/libc/include/thread_private.h
new file mode 100644
index 0000000000..673fb9c6a6
--- /dev/null
+++ b/src/lib/libc/include/thread_private.h
@@ -0,0 +1,175 @@
+/* $OpenBSD: thread_private.h,v 1.25 2011/10/16 06:29:56 guenther 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
+
+/*
+ * Ditto for hand-written syscall stubs:
+ * 
+ * Use STUB_NAME(n) to get the strong name of the stub: _thread_sys_n
+ *     STUB_ALIAS(n) to generate the weak symbol n pointing to _thread_sys_n,
+ *     STUB_PROTOTYPE(n) to generate a prototype for _thread_sys_n (based on n).
+ */
+#define STUB_NAME(name)         __CONCAT(_thread_sys_,name)
+#define STUB_ALIAS(name)        __weak_alias(name, STUB_NAME(name))
+#ifdef __GNUC__
+#define STUB_PROTOTYPE(name)    __typeof__(name) STUB_NAME(name)
+#else
+#define STUB_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.
+ *
+ * _thread_mutex_lock:
+ *      lock the given mutex. If the given mutex is NULL,
+ *      rely on rthreads/pthreads implementation to initialize
+ *      the mutex before locking.
+ *
+ * _thread_mutex_unlock:
+ *      unlock the given mutex.
+ *
+ * _thread_mutex_destroy:
+ *      destroy the given mutex.
+ */
+void    _thread_tag_lock(void **);
+void    _thread_tag_unlock(void **);
+void   *_thread_tag_storage(void **, void *, size_t, void *);
+void    _thread_mutex_lock(void **);
+void    _thread_mutex_unlock(void **);
+void    _thread_mutex_destroy(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)
+
+/*
+ * Macros used in libc to access mutexes.
+ */
+#define _MUTEX_LOCK(mutex)                                              \
+        do {                                                            \
+                if (__isthreaded)                                       \
+                        _thread_mutex_lock(mutex);                      \
+        } while (0)
+#define _MUTEX_UNLOCK(mutex)                                            \
+        do {                                                            \
+                if (__isthreaded)                                       \
+                        _thread_mutex_unlock(mutex);                    \
+        } while (0)
+#define _MUTEX_DESTROY(mutex)                                           \
+        do {                                                            \
+                if (__isthreaded)                                       \
+                        _thread_mutex_destroy(mutex);                   \
+        } while (0)
+
+/*
+ * 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);
+
+/*
+ * malloc lock/unlock prototypes and definitions
+ */
+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)
+
+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)
+
+void    _thread_arc4_lock(void);
+void    _thread_arc4_unlock(void);
+
+#define _ARC4_LOCK()            do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_arc4_lock();    \
+                                } while (0)
+#define _ARC4_UNLOCK()          do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_arc4_unlock();\
+                                } while (0)
+
+#endif /* _THREAD_PRIVATE_H_ */
diff --git a/src/lib/libc/net/Makefile.inc b/src/lib/libc/net/Makefile.inc
index 2d220067e4..530bc3f3f0 100644
--- a/src/lib/libc/net/Makefile.inc
+++ b/src/lib/libc/net/Makefile.inc
@@ -1,46 +1,101 @@
-#       $NetBSD: Makefile.inc,v 1.23 1995/03/02 09:09:07 chopps Exp $
-#       @(#)Makefile.inc        8.2 (Berkeley) 9/5/93
+#       $OpenBSD: Makefile.inc,v 1.48 2010/07/01 19:15:30 deraadt Exp $
 
 # net sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/net ${.CURDIR}/net
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_CPU}/net ${LIBCSRCDIR}/net
 
-SRCS+=  gethostnamadr.c getnetbyaddr.c getnetbyname.c getnetent.c \
-        getproto.c getprotoent.c getprotoname.c getservbyname.c \
-        getservbyport.c getservent.c herror.c inet_addr.c inet_lnaof.c \
-        inet_makeaddr.c inet_netof.c inet_network.c inet_ntoa.c \
-        iso_addr.c linkaddr.c ns_addr.c ns_ntoa.c rcmd.c recv.c res_comp.c \
-        res_debug.c res_init.c res_mkquery.c res_query.c res_send.c \
-        send.c sethostent.c ethers.c
+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 getpeereid.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 \
+        linkaddr.c net_addrcmp.c nsap_addr.c \
+        rcmd.c ruserok.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 "${.CURDIR}/arch/${MACHINE_ARCH}/net/Makefile.inc"
+.include "${LIBCSRCDIR}/arch/${MACHINE_CPU}/net/Makefile.inc"
 
-MAN+=   byteorder.3 gethostbyname.3 getnetent.3 getprotoent.3 getservent.3 \
-        inet.3 linkaddr.3 ns.3 rcmd.3 resolver.3 ethers.3
+MAN+=   byteorder.3 ethers.3 gai_strerror.3 getaddrinfo.3 gethostbyname.3 \
+        getifaddrs.3 getnameinfo.3 getnetent.3 getpeereid.3 getprotoent.3 \
+        getrrsetbyname.3 getservent.3 if_indextoname.3 inet.3 \
+        inet_net.3 inet6_option_space.3 inet6_rthdr_space.3 \
+        inet6_opt_init.3 inet6_rth_space.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 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 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 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 getservbyport.3 getservent.3 setservent.3 \
+        getservent.3 getservent_r.3 getservent.3 getservbyname_r.3 \
+        getservent.3 getservbyport_r.3 getservent.3 setservent_r.3 \
+        getservent.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
-MLINKS+=linkaddr.3 linkntoa.3
-MLINKS+=ns.3 ns_addr.3 ns.3 ns_ntoa.3
-MLINKS+=rcmd.3 iruserok.3 rcmd.3 rresvport.3 rcmd.3 ruserok.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+=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
+MLINKS+=inet6_opt_init.3 inet6_opt_append.3 \
+        inet6_opt_init.3 inet6_opt_finish.3 \
+        inet6_opt_init.3 inet6_opt_set_val.3 \
+        inet6_opt_init.3 inet6_opt_next.3 \
+        inet6_opt_init.3 inet6_opt_find.3 \
+        inet6_opt_init.3 inet6_opt_get_val.3
+MLINKS+=inet6_rth_space.3 inet6_rth_init.3 \
+        inet6_rth_space.3 inet6_rth_add.3 \
+        inet6_rth_space.3 inet6_rth_reverse.3 \
+        inet6_rth_space.3 inet6_rth_segments.3 \
+        inet6_rth_space.3 inet6_rth_getaddr.3 \
diff --git a/src/lib/libc/net/base64.c b/src/lib/libc/net/base64.c
new file mode 100644
index 0000000000..d432c48d5c
--- /dev/null
+++ b/src/lib/libc/net/base64.c
@@ -0,0 +1,308 @@
+/*      $OpenBSD: base64.c,v 1.5 2006/10/21 09:55:03 otto 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>
+
+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;
+
+                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);
+
+                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
index 701a69f688..6625ea1442 100644
--- a/src/lib/libc/net/byteorder.3
+++ b/src/lib/libc/net/byteorder.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: byteorder.3,v 1.3 1995/02/25 06:20:27 cgd Exp $
+.\"     $OpenBSD: byteorder.3,v 1.16 2009/03/17 21:33:04 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,48 +27,180 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)byteorder.3 8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
+.Dd $Mdocdate: March 17 2009 $
 .Dt BYTEORDER 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm htonl ,
 .Nm htons ,
 .Nm ntohl ,
-.Nm ntohs
-.Nd convert values between host and network byte order
+.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/param.h>
-.Ft u_long
-.Fn htonl "u_long hostlong"
-.Ft u_short
-.Fn htons "u_short hostshort"
-.Ft u_long
-.Fn ntohl "u_long netlong"
-.Ft u_short
-.Fn ntohs "u_short netshort"
+.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_int64_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 and 32 bit quantities between network
+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
-These routines are most often used in conjunction with Internet
-addresses and ports as returned by
+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 
+functions appeared in
 .Bx 4.2 .
 .Sh BUGS
-On the
-.Tn VAX
-bytes are handled backwards from most everyone else in
-the world.  This is not expected to be fixed in the near future.
+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
index 81e6c65935..041ee981ec 100644
--- a/src/lib/libc/net/ethers.3
+++ b/src/lib/libc/net/ethers.3
@@ -1,65 +1,87 @@
+.\"     $OpenBSD: ethers.3,v 1.21 2011/04/19 22:38:26 matthew Exp $
 .\"
 .\" Written by roland@frob.com.  Public domain.
 .\"
-.Dd December 16, 1993
+.Dd $Mdocdate: April 19 2011 $
 .Dt ETHERS 3
-.Os NetBSD
+.Os
 .Sh NAME
+.Nm ether_aton ,
 .Nm ether_ntoa ,
-.Nm ether_addr ,
 .Nm ether_ntohost ,
 .Nm ether_hostton ,
-.Nm ether_line ,
+.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 "char *s"
+.Fn ether_aton "const char *s"
+.Ft int
 .Fn ether_ntohost "char *hostname" "struct ether_addr *e"
-.Fn ether_hostton "char *hostname" "struct ether_addr *e"
-.Fn ether_line "char *l" "struct ether_addr *e" "char *hostname"
+.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 
+Ethernet addresses are represented by the
 following structure:
 .Bd -literal -offset indent
 struct ether_addr {
-        u_char  ether_addr_octet[6];
+        u_int8_t  ether_addr_octet[6];
 };
 .Ed
 .Pp
 The
 .Fn ether_ntoa
-function converts this structure into an ASCII string of the form
-``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.
+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 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.
+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.
+.Fn ether_aton
+will return NULL if the string does not represent a valid address.
 .Pp
 The
 .Fn ether_ntohost
 and
 .Fn ether_hostton
-functions interrogate the data base mapping host names to Ethernet
+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.
+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 + appears alone on a line in the file, then
+.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
@@ -73,9 +95,13 @@ The
 .Fn ether_line
 function parses a line from the
 .Pa /etc/ethers
-file and fills in the passed ``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.
+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
@@ -91,12 +117,8 @@ The
 and
 .Fn ether_line
 functions were adopted from SunOS and appeared in
-NetBSD 0.9b.
+.Nx 0.9b .
 .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.  There is no way to restrict how many
-character will be written into the host name buffer passed.  A very
-long line in
-.Pa /etc/ethers
-could overflow your buffer.
+these functions overwrite it.
diff --git a/src/lib/libc/net/ethers.c b/src/lib/libc/net/ethers.c
index 0f32b9b71b..d4243ff1da 100644
--- a/src/lib/libc/net/ethers.c
+++ b/src/lib/libc/net/ethers.c
@@ -1,10 +1,25 @@
-/*      $NetBSD: ethers.c,v 1.5 1995/02/25 06:20:28 cgd Exp $   */
+/*      $OpenBSD: ethers.c,v 1.20 2005/08/06 20:30:03 espie Exp $       */
 
-/* 
- * ethers(3N) a la Sun.
+/*
+ * 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.
  *
- * Written by Roland McGrath <roland@frob.com> 10/14/93.
- * Public domain.
+ * 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>
@@ -18,57 +33,77 @@
 #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"
+#define _PATH_ETHERS    "/etc/ethers"
 #endif
 
+static char * _ether_aton(const char *, struct ether_addr *);
+
 char *
-ether_ntoa(e)
-        struct ether_addr *e;
+ether_ntoa(struct ether_addr *e)
 {
         static char a[] = "xx:xx:xx:xx:xx:xx";
 
-        sprintf(a, "%02x:%02x:%02x:%02x:%02x:%02x",
+        (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;
+
+        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(s)
-        char *s;
+ether_aton(const char *s)
 {
         static struct ether_addr n;
-        u_int i[6];
-
-        if (sscanf(s, " %x:%x:%x:%x:%x:%x ", &i[0], &i[1],
-            &i[2], &i[3], &i[4], &i[5]) == 6) {
-                n.ether_addr_octet[0] = (u_char)i[0];
-                n.ether_addr_octet[1] = (u_char)i[1];
-                n.ether_addr_octet[2] = (u_char)i[2];
-                n.ether_addr_octet[3] = (u_char)i[3];
-                n.ether_addr_octet[4] = (u_char)i[4];
-                n.ether_addr_octet[5] = (u_char)i[5];
-                return &n;
-        }
-        return NULL;
+
+        return (_ether_aton(s, &n) ? &n : NULL);
 }
 
-ether_ntohost(hostname, e)
-        char *hostname;
-        struct ether_addr *e;
+int
+ether_ntohost(char *hostname, struct ether_addr *e)
 {
         FILE *f; 
-        char buf[BUFSIZ];
+        char buf[BUFSIZ+1], *p;
+        size_t len;
         struct ether_addr try;
-
 #ifdef YP
-        char trybuf[sizeof "xx:xx:xx:xx:xx:xx"];
+        char trybuf[sizeof("xx:xx:xx:xx:xx:xx")];
         int trylen;
+#endif
 
-        sprintf(trybuf, "%x:%x:%x:%x:%x:%x", 
+#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]);
@@ -76,12 +111,19 @@ ether_ntohost(hostname, e)
 #endif
 
         f = fopen(_PATH_ETHERS, "r");
-        if (f==NULL)
-                return -1;
-        while (fgets(buf, sizeof buf, f)) {
+        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)) {
+                if (!strncmp(buf, "+\n", sizeof(buf))) {
                         char *ypbuf, *ypdom;
                         int ypbuflen;
 
@@ -93,42 +135,49 @@ ether_ntohost(hostname, e)
                         if (ether_line(ypbuf, &try, hostname) == 0) {
                                 free(ypbuf);
                                 (void)fclose(f);
-                                return 0;
+                                return (0);
                         }
                         free(ypbuf);
                         continue;
                 }
 #endif
                 if (ether_line(buf, &try, hostname) == 0 &&
-                    bcmp((char *)&try, (char *)e, sizeof try) == 0) {
+                    memcmp((void *)&try, (void *)e, sizeof(try)) == 0) {
                         (void)fclose(f);
-                        return 0;
+                        return (0);
                 }     
         }
         (void)fclose(f);
         errno = ENOENT;
-        return -1;
+        return (-1);
 }
 
-ether_hostton(hostname, e)
-        char *hostname;
-        struct ether_addr *e;
+int
+ether_hostton(const char *hostname, struct ether_addr *e)
 {
         FILE *f;
-        char buf[BUFSIZ];
+        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;
+                return (-1);
 
-        while (fgets(buf, sizeof buf, f)) {
+        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)) {
+                if (!strncmp(buf, "+\n", sizeof(buf))) {
                         char *ypbuf, *ypdom;
                         int ypbuflen;
 
@@ -140,7 +189,7 @@ ether_hostton(hostname, e)
                         if (ether_line(ypbuf, e, try) == 0) {
                                 free(ypbuf);
                                 (void)fclose(f);
-                                return 0;
+                                return (0);
                         }
                         free(ypbuf);
                         continue;
@@ -148,31 +197,36 @@ ether_hostton(hostname, e)
 #endif
                 if (ether_line(buf, e, try) == 0 && strcmp(hostname, try) == 0) {
                         (void)fclose(f);
-                        return 0;
+                        return (0);
                 }
         }
         (void)fclose(f);
         errno = ENOENT;
-        return -1;
+        return (-1);
 }
 
-ether_line(l, e, hostname)
-        char *l;
-        struct ether_addr *e;
-        char *hostname;
+int
+ether_line(const char *line, struct ether_addr *e, char *hostname)
 {
-        u_int i[6];
-
-        if (sscanf(l, " %x:%x:%x:%x:%x:%x %s\n", &i[0], &i[1],
-            &i[2], &i[3], &i[4], &i[5], hostname) == 7) {
-                e->ether_addr_octet[0] = (u_char)i[0];
-                e->ether_addr_octet[1] = (u_char)i[1];
-                e->ether_addr_octet[2] = (u_char)i[2];
-                e->ether_addr_octet[3] = (u_char)i[3];
-                e->ether_addr_octet[4] = (u_char)i[4];
-                e->ether_addr_octet[5] = (u_char)i[5];
-                return 0;
-        }
+        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;
+        return (-1);
 }
diff --git a/src/lib/libc/stdlib/calloc.c b/src/lib/libc/net/freeaddrinfo.c
index 3353fab052..58702d0b18 100644
--- a/src/lib/libc/stdlib/calloc.c
+++ b/src/lib/libc/net/freeaddrinfo.c
@@ -1,6 +1,7 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
+/*      $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
@@ -12,9 +13,9 @@
  *    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
+ *      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.
  *
@@ -31,23 +32,19 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)calloc.c     5.6 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: calloc.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
-#include <string.h>
+#include <netdb.h>
 
-void *
-calloc(num, size)
-        size_t num;
-        register size_t size;
+void
+freeaddrinfo(struct addrinfo *ai)
 {
-        register void *p;
+        struct addrinfo *p;
 
-        size *= num;
-        if (p = malloc(size))
-                memset(p, '\0', size);
-        return(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..6ce94e30a1
--- /dev/null
+++ b/src/lib/libc/net/gai_strerror.3
@@ -0,0 +1,95 @@
+.\"     $OpenBSD: gai_strerror.3,v 1.7 2009/06/02 16:47:50 jasper 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 $Mdocdate: June 2 2009 $
+.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_OVERFLOW
+argument buffer overflow
+.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/string/__strsignal.c b/src/lib/libc/net/gai_strerror.c
index 1937e2d608..f4126413f8 100644
--- a/src/lib/libc/string/__strsignal.c
+++ b/src/lib/libc/net/gai_strerror.c
@@ -1,6 +1,7 @@
+/*      $OpenBSD: gai_strerror.c,v 1.7 2009/06/02 16:47:50 jasper Exp $ */
+
 /*
- * Copyright (c) 1988 Regents of the University of California.
- * All rights reserved.
+ * 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
@@ -12,9 +13,9 @@
  *    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
+ *      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.
  *
@@ -31,56 +32,47 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strerror.c   5.6 (Berkeley) 5/4/91";*/
-static char *rcsid = "$Id: __strsignal.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#ifdef NLS
-#define catclose        _catclose
-#define catgets         _catgets
-#define catopen         _catopen
-#include <nl_types.h>
-#endif
+/* gai_strerror() v1.38 */
 
-#define sys_siglist     _sys_siglist
+#include <sys/types.h>
+#include <netdb.h>
+#include <errno.h>
 
-#include <stdio.h>
-#include <signal.h>
-#include <string.h>
-
-char *
-__strsignal(num, buf)
-        int num;
-        char *buf;
+const char *
+gai_strerror(int errnum)
 {
-#define UPREFIX "Unknown signal: %u"
-        register unsigned int signum;
-
-#ifdef NLS
-        nl_catd catd ;
-        catd = catopen("libc", 0);
-#endif
-
-        signum = num;                           /* convert to unsigned */
-        if (signum < NSIG) {
-#ifdef NLS
-                strcpy(buf, catgets(catd, 2, signum,
-                    (char *)sys_siglist[signum])); 
-#else
-                return((char *)sys_siglist[signum]);
-#endif
-        } else {
-#ifdef NLS
-                sprintf(buf, catgets(catd, 1, 0xffff, UPREFIX), signum);
-#else
-                sprintf(buf, UPREFIX, signum);
-#endif
+        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";
+        case EAI_OVERFLOW:
+                return "argument buffer overflow";
+        default:
+                return "unknown/invalid error";
         }
-
-#ifdef NLS
-        catclose(catd);
-#endif
-
-        return buf;
 }
diff --git a/src/lib/libc/net/getaddrinfo.3 b/src/lib/libc/net/getaddrinfo.3
new file mode 100644
index 0000000000..da6e64683f
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.3
@@ -0,0 +1,470 @@
+.\"     $OpenBSD: getaddrinfo.3,v 1.48 2011/04/05 00:46:06 matthew 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 $Mdocdate: April 5 2011 $
+.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 host name in the
+.Fa ai_canonname
+element of the first
+.Li addrinfo
+structure returned.
+.It Dv AI_FQDN
+If the
+.Dv AI_FQDN
+bit is set, a successful call to
+.Fn getaddrinfo
+will return a NUL-terminated string containing the fully qualified domain name
+of the specified host name in the
+.Fa ai_canonname
+element of the first
+.Li addrinfo
+structure returned.
+.Pp
+This is different from the
+.Dv AI_CANONNAME
+bit flag that returns the canonical name registered in DNS,
+which may be different from the fully qualified domain name
+that the host name resolved to.
+Only one of the
+.Dv AI_FQDN
+and
+.Dv AI_CANONNAME
+bits can be set.
+.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_NUMERICSERV
+If the
+.Dv AI_NUMERICSERV
+bit is set, it indicates that
+.Fa servname
+should be treated as a numeric port string
+and no service 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));
+s = -1;
+for (res = res0; res; res = res->ai_next) {
+        s = socket(res->ai_family, res->ai_socktype,
+            res->ai_protocol);
+        if (s == -1) {
+                cause = "socket";
+                continue;
+        }
+
+        if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
+                cause = "connect";
+                save_errno = errno;
+                close(s);
+                errno = save_errno;
+                s = -1;
+                continue;
+        }
+
+        break;  /* okay we got one */
+}
+if (s == -1)
+        err(1, "%s", cause);
+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));
+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] == -1) {
+                cause = "socket";
+                continue;
+        }
+
+        if (bind(s[nsock], res->ai_addr, res->ai_addrlen) == -1) {
+                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);
+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 .
+.Pp
+The
+.Dv AI_FQDN
+flag bit first appeared in Windows 7.
+.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..29cc1f463e
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.c
@@ -0,0 +1,1755 @@
+/*      $OpenBSD: getaddrinfo.c,v 1.72 2011/04/05 00:46:06 matthew 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 (allows
+ *   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 struct addrinfo * _gethtent(const char *, const struct addrinfo *,
+        FILE *);
+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 *,
+        const struct __res_state *);
+
+
+/* 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) != 0 ||
+                    (hints->ai_flags & (AI_CANONNAME | AI_FQDN)) ==
+                    (AI_CANONNAME | AI_FQDN))
+                        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 an
+         * 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 == 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, _resp);
+                        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");
+                 */
+        } 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:
+                error = inet_aton(hostname, (struct in_addr *)pton);
+                break;
+#endif
+        default:
+                error = inet_pton(afd->a_af, hostname, pton);
+                break;
+        }
+        if (error == 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);
+                        /*
+                         * 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*/
+        }
+
+        *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 | AI_FQDN)) != 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;
+        int port;
+        int allownumeric;
+
+        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:
+        case ANY:
+                allownumeric = 1;
+                break;
+        default:
+                return EAI_SOCKTYPE;
+        }
+
+        port = (int)strtonum(servname, 0, USHRT_MAX, &errstr);
+        if (!errstr) {
+                if (!allownumeric)
+                        return EAI_SERVICE;
+                port = htons(port);
+        } else {
+                struct servent sp;
+                struct servent_data sd;
+
+                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;
+                }
+
+                (void)memset(&sd, 0, sizeof(sd));
+                if (getservbyname_r(servname, proto, &sp, &sd) == -1)
+                        return EAI_SERVICE;
+                port = sp.s_port;
+                endservent_r(&sd);
+        }
+
+        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) ||
+            IN6_IS_ADDR_MC_INTFACELOCAL(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 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) {
+                size_t len;
+
+                /* 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).
+                 */
+                len = strlen(bp) + 1;           /* for the \0 */
+                if (len >= MAXHOSTNAMELEN) {
+                        h_errno = NO_RECOVERY;
+                        return (NULL);
+                }
+                canonname = bp;
+                bp += len;
+                /* 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) {
+                        size_t len;
+
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+                        if ((n < 0) || !(*name_ok)(tbuf)) {
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Get canonical name. */
+                        len = strlen(tbuf) + 1; /* for the \0 */
+                        if (len > ep - bp || len >= MAXHOSTNAMELEN) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        canonname = bp;
+                        bp += len;
+                        continue;
+                }
+                if (qtype == T_ANY) {
+                        if (!(type == T_A || type == T_AAAA)) {
+                                cp += n;
+                                continue;
+                        }
+                } else if (type != qtype) {
+#ifndef NO_LOG_BAD_DNS_RESPONSES
+                        if (type != T_KEY && type != T_SIG) {
+                                struct syslog_data sdata = SYSLOG_DATA_INIT;
+
+                                syslog_r(LOG_NOTICE|LOG_AUTH, &sdata,
+               "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
+                                       qname, p_class(C_IN), p_type(qtype),
+                                       p_type(type));
+                        }
+#endif /* NO_LOG_BAD_DNS_RESPONSES */
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                switch (type) {
+                case T_A:
+                case T_AAAA:
+                        if (strcasecmp(canonname, bp) != 0) {
+                                struct syslog_data sdata = SYSLOG_DATA_INIT;
+
+                                syslog_r(LOG_NOTICE|LOG_AUTH, &sdata,
+                                       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) {
+                                canonname = bp;
+                                bp += strlen(bp) + 1;   /* for the \0 */
+                        }
+
+                        /* 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 || (pai->ai_flags & AI_FQDN) != 0)
+                        (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,
+        const struct __res_state *_resp)
+{
+        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:
+                /* respect user supplied order */
+                q.qclass = C_IN;
+                q.qtype = (_resp->family[0] == AF_INET6) ? T_AAAA : T_A;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                q.next = &q2;
+
+                if (_resp->family[1] == -1) {
+                        /* stop here if only one family was given */
+                        q.next = NULL;
+                        break;
+                }
+
+                q2.qclass = C_IN;
+                q2.qtype = (_resp->family[1] == AF_INET6) ? T_AAAA : 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 struct addrinfo *
+_gethtent(const char *name, const struct addrinfo *pai, FILE *hostf)
+{
+        char *p;
+        char *cp, *tname, *cname;
+        struct addrinfo hints, *res0, *res;
+        int error;
+        const char *addr;
+        char hostbuf[8*1024];
+
+ 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 (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;
+        FILE *hostf;
+
+        hostf = fopen(_PATH_HOSTS, "r");
+        if (hostf == NULL)
+                return NULL;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        while ((p = _gethtent(name, pai, hostf)) != NULL) {
+                cur->ai_next = p;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+        fclose(hostf);
+
+        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;
+
+                        (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
index bac0368296..1a05460da4 100644
--- a/src/lib/libc/net/gethostbyname.3
+++ b/src/lib/libc/net/gethostbyname.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: gethostbyname.3,v 1.6 1995/02/25 06:20:28 cgd Exp $
+.\"     $OpenBSD: gethostbyname.3,v 1.25 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1987, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,58 +27,66 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)gethostbyname.3     8.2 (Berkeley) 4/19/94
-.\"
-.Dd April 19, 1994
+.Dd $Mdocdate: May 31 2007 $
 .Dt GETHOSTBYNAME 3
-.Os BSD 4.2
+.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>
-.Fd extern int h_errno;
+.Vt extern int h_errno ;
 .Ft struct hostent *
 .Fn gethostbyname "const char *name"
 .Ft struct hostent *
-.Fn gethostbyaddr "const char *addr" "int len" "int type"
+.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
-.Fn herror "char *string"
+.Ft void
+.Fn herror "const char *string"
+.Ft const char *
+.Fn hstrerror "int err"
 .Sh DESCRIPTION
 The
-.Fn gethostbyname
+.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 the information obtained from the name server,
-.Xr named 8 ,
-broken-out fields from a line in 
+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 .
-If the local name server is not running these routines do a lookup in
-.Pa /etc/hosts .
-.Bd -literal
+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 addresses from name server */
+        char    **h_addr_list;  /* list of returned addresses */
 };
-#define h_addr  h_addr_list[0]  /* address, for backward compatibility */
+#define h_addr  h_addr_list[0]  /* address, for backward compat */
 .Ed
 .Pp
 The members of this structure are:
@@ -90,36 +94,50 @@ The members of this structure are:
 .It Fa h_name
 Official name of the host.
 .It Fa h_aliases
-A zero terminated array of alternate names for the host.
+A null-terminated array of alternate names for the host.
 .It Fa h_addrtype
-The type of address being returned; currently always
-.Dv AF_INET .
+The type of address being returned.
 .It Fa h_length
 The length, in bytes, of the address.
 .It Fa h_addr_list
-A zero terminated array of network addresses for the host.
+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
-When using the nameserver,
+The function
 .Fn gethostbyname
 will search for the named host in the current domain and its parents
-unless the name ends in a dot.
-If the name contains no dot, and if the environment variable
-.Dq Ev HOSTALIASES
-contains the name of an alias file, the alias file will first be searched
-for an alias matching the input name.
-See
-.Xr hostname 7
-for the domain search procedure and the alias file format.
+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
+function may be used to request the use of a connected
 .Tn TCP
 socket for queries.
 If the
@@ -127,7 +145,7 @@ If the
 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 
+and to retain the connection after each call to
 .Fn gethostbyname
 or
 .Fn gethostbyaddr .
@@ -137,17 +155,46 @@ datagrams.
 .Pp
 The
 .Fn endhostent
-function
-closes the
+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/hosts -compact
+.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
+Error return status from
+.Fn gethostbyname ,
+.Fn gethostbyname2 ,
 and
 .Fn gethostbyaddr
 is indicated by return of a null pointer.
@@ -155,15 +202,6 @@ The external integer
 .Va h_errno
 may then be checked to see whether this is a temporary failure
 or an invalid or unknown host.
-The routine
-.Fn herror
-can be used to print an error message describing the failure.
-If its argument
-.Fa string
-is
-.Pf non Dv -NULL ,
-it is printed, followed by a colon and a space.
-The error message is printed with a trailing newline.
 .Pp
 The variable
 .Va h_errno
@@ -180,75 +218,80 @@ A retry at some later time may succeed.
 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.  
+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 CAVEAT
+.Sh HISTORY
 The
-.Fn gethostent
-function
-is defined, and
-.Fn sethostent
+.Fn herror
+function appeared in
+.Bx 4.3 .
+The
+.Fn endhostent ,
+.Fn gethostbyaddr ,
+.Fn gethostbyname ,
+.Fn gethostent ,
 and
-.Fn endhostent
-are redefined,
-when
-.Xr libc 3
-is built to use only the routines to lookup in
+.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
-and not the name server.
-.Pp
-The
+file,
 .Fn gethostent
-function
-reads the next line of
-.Pa /etc/hosts ,
-opening the file if necessary.
+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
+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
+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 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 .
+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 format is currently understood.
+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
index ec3f14a900..f4e655eeaf 100644
--- a/src/lib/libc/net/gethostnamadr.c
+++ b/src/lib/libc/net/gethostnamadr.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: gethostnamadr.c,v 1.13 1995/05/21 16:21:14 mycroft Exp $       */
-
+/*      $OpenBSD: gethostnamadr.c,v 1.73 2009/11/18 07:43:22 guenther Exp $ */
 /*-
  * Copyright (c) 1985, 1988, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -53,15 +48,6 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)gethostnamadr.c     8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: gethnamaddr.c,v 4.9.1.1 1993/05/02 22:43:03 vixie Rel ";
-#else
-static char rcsid[] = "$NetBSD: gethostnamadr.c,v 1.13 1995/05/21 16:21:14 mycroft Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -73,11 +59,17 @@ static char rcsid[] = "$NetBSD: gethostnamadr.c,v 1.13 1995/05/21 16:21:14 mycro
 #include <ctype.h>
 #include <errno.h>
 #include <string.h>
+#include <syslog.h>
+#include <stdlib.h>
 #ifdef YP
 #include <rpc/rpc.h>
-#include <rpcsvc/yp_prot.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
@@ -91,47 +83,101 @@ static char *__ypdomain;
 static struct hostent host;
 static char *host_aliases[MAXALIASES];
 static char hostbuf[BUFSIZ+1];
-static struct in_addr host_addr;
+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;
 
-#if PACKETSZ > 1024
-#define MAXPACKET       PACKETSZ
-#else
-#define MAXPACKET       1024
+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;
+        int32_t al;
+        char ac;
 } align;
 
-static int qcomp __P((struct in_addr **, struct in_addr **));
-static struct hostent *getanswer __P((querybuf *, int, int));
+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(answer, anslen, iquery)
-        querybuf *answer;
-        int anslen;
-        int iquery;
+getanswer(const querybuf *answer, int anslen, const char *qname, int qtype)
 {
-        register HEADER *hp;
-        register u_char *cp;
-        register int n;
-        u_char *eom;
-        char *bp, **ap;
-        int type, class, buflen, ancount, qdcount;
-        int haveanswer, getclass = C_ANY;
-        char **hap;
+        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
          */
@@ -139,31 +185,27 @@ getanswer(answer, anslen, iquery)
         ancount = ntohs(hp->ancount);
         qdcount = ntohs(hp->qdcount);
         bp = hostbuf;
-        buflen = sizeof(hostbuf);
-        cp = answer->buf + sizeof(HEADER);
-        if (qdcount) {
-                if (iquery) {
-                        if ((n = dn_expand((u_char *)answer->buf,
-                            (u_char *)eom, (u_char *)cp, (u_char *)bp,
-                            buflen)) < 0) {
-                                h_errno = NO_RECOVERY;
-                                return ((struct hostent *) NULL);
-                        }
-                        cp += n + QFIXEDSZ;
-                        host.h_name = bp;
-                        n = strlen(bp) + 1;
-                        bp += n;
-                        buflen -= n;
-                } else
-                        cp += __dn_skipname(cp, eom) + QFIXEDSZ;
-                while (--qdcount > 0)
-                        cp += __dn_skipname(cp, eom) + QFIXEDSZ;
-        } else if (iquery) {
-                if (hp->aa)
-                        h_errno = HOST_NOT_FOUND;
-                else
-                        h_errno = TRY_AGAIN;
-                return ((struct hostent *) NULL);
+        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).
+                 */
+                host.h_name = bp;
+                bp += strlen(bp) + 1;           /* for the \0 */
+                /* The qname can be abbreviated, but h_name is now absolute. */
+                qname = host.h_name;
         }
         ap = host_aliases;
         *ap = NULL;
@@ -172,103 +214,325 @@ getanswer(answer, anslen, iquery)
         *hap = NULL;
         host.h_addr_list = h_addr_ptrs;
         haveanswer = 0;
-        while (--ancount >= 0 && cp < eom) {
-                if ((n = dn_expand((u_char *)answer->buf, (u_char *)eom,
-                    (u_char *)cp, (u_char *)bp, buflen)) < 0)
+        had_error = 0;
+        while (ancount-- > 0 && cp < eom && !had_error) {
+                size_t len;
+
+                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;
-                cp += n;
                 type = _getshort(cp);
-                cp += sizeof(u_int16_t);
+                cp += INT16SZ;                  /* type */
+                if (cp >= eom)
+                        break;
                 class = _getshort(cp);
-                cp += sizeof(u_int16_t) + sizeof(u_int32_t);
+                cp += INT16SZ + INT32SZ;        /* class, TTL */
+                if (cp >= eom)
+                        break;
                 n = _getshort(cp);
-                cp += sizeof(u_int16_t);
-                if (type == T_CNAME) {
+                cp += INT16SZ;                  /* len */
+                if (cp >= eom)
+                        break;
+                if (type == T_SIG || type == T_RRSIG) {
+                        /* XXX - ignore signatures as we don't use them yet */
                         cp += n;
-                        if (ap >= &host_aliases[MAXALIASES-1])
-                                continue;
-                        *ap++ = bp;
-                        n = strlen(bp) + 1;
-                        bp += n;
-                        buflen -= n;
                         continue;
                 }
-                if (iquery && type == T_PTR) {
-                        if ((n = dn_expand((u_char *)answer->buf,
-                            (u_char *)eom, (u_char *)cp, (u_char *)bp,
-                            buflen)) < 0)
-                                break;
+                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;
+                        bp += strlen(bp) + 1;   /* for the \0 */
+                        /* Get canonical name. */
+                        len = strlen(tbuf) + 1; /* for the \0 */
+                        if (len > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
                         host.h_name = bp;
-                        return(&host);
+                        bp += len;
+                        continue;
                 }
-                if (iquery || type != T_A)  {
-#ifdef DEBUG
-                        if (_res.options & RES_DEBUG)
-                                printf("unexpected answer type %d, size %d\n",
-                                        type, n);
+                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. */
+                        len = strlen(tbuf) + 1; /* for the \0 */
+                        if (len > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        tname = bp;
+                        bp += len;
                         continue;
                 }
-                if (haveanswer) {
-                        if (n != host.h_length) {
+                if (type != qtype) {
+#ifndef NO_LOG_BAD_DNS_RESPONSES
+                        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));
+#endif /* NO_LOG_BAD_DNS_RESPONSES */
+                        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;
+                                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 (class != getclass) {
+                        if (n != host.h_length) {
                                 cp += n;
                                 continue;
                         }
-                } else {
-                        host.h_length = n;
-                        getclass = class;
-                        host.h_addrtype = (class == C_IN) ? AF_INET : AF_UNSPEC;
-                        if (!iquery) {
+                        if (type == T_AAAA) {
+                                struct in6_addr in6;
+                                memcpy(&in6, cp, IN6ADDRSZ);
+                                if (IN6_IS_ADDR_V4MAPPED(&in6)) {
+                                        cp += n;
+                                        continue;
+                                }
+                        }
+                        if (!haveanswer) {
                                 host.h_name = bp;
-                                bp += strlen(bp) + 1;
+                                bp += strlen(bp) + 1;   /* for the \0 */
                         }
-                }
 
-                bp += sizeof(align) - ((u_long)bp % sizeof(align));
+                        bp += sizeof(align) - ((u_long)bp % sizeof(align));
 
-                if (bp + n >= &hostbuf[sizeof(hostbuf)]) {
+                        if (bp + n >= &hostbuf[sizeof hostbuf]) {
 #ifdef DEBUG
-                        if (_res.options & RES_DEBUG)
-                                printf("size (%d) too big\n", n);
+                                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;
                 }
-                bcopy(cp, *hap++ = bp, n);
-                bp +=n;
-                cp += n;
-                haveanswer++;
+                if (!had_error)
+                        haveanswer++;
         }
         if (haveanswer) {
                 *ap = NULL;
                 *hap = NULL;
-                if (_res.nsort) {
-                        qsort(host.h_addr_list, haveanswer,
-                            sizeof(struct in_addr),
-                            (int (*)__P((const void *, const void *)))qcomp);
+# 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) {
+                        size_t len;
+
+                        len = strlen(qname) + 1;
+                        if (len > ep - bp)      /* for the \0 */
+                                goto try_again;
+                        strlcpy(bp, qname, ep - bp);
+                        host.h_name = bp;
+                        bp += len;
                 }
+                if (_resp->options & RES_USE_INET6)
+                        map_v4v6_hostent(&host, &bp, ep);
+                h_errno = NETDB_SUCCESS;
                 return (&host);
-        } else {
-                h_errno = TRY_AGAIN;
-                return ((struct hostent *) NULL);
         }
+ 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 *
-gethostbyname(name)
-        const char *name;
+gethostbyaddr_r(const char *addr, int len, int af, struct hostent *he,
+    char *buf, int buflen, int *errorp)
 {
-        querybuf buf;
-        register const char *cp;
-        int n, i;
-        extern struct hostent *_gethtbyname(), *_yp_gethtbyname();
-        register struct hostent *hp;
+        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);
+#ifdef YP
+        extern struct hostent *_yp_gethtbyname(const char *);
+#endif
+
+        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
@@ -284,122 +548,229 @@ gethostbyname(name)
                                  * Fake up a hostent as if we'd actually
                                  * done a lookup.
                                  */
-                                if (!inet_aton(name, &host_addr)) {
+                                if (inet_pton(af, name, host_addr) <= 0) {
                                         h_errno = HOST_NOT_FOUND;
-                                        return((struct hostent *) NULL);
+                                        return (NULL);
                                 }
-                                host.h_name = (char *)name;
+                                strlcpy(hostbuf, name, MAXHOSTNAMELEN);
+                                bp = hostbuf + MAXHOSTNAMELEN;
+                                ep = hostbuf + sizeof(hostbuf);
+                                host.h_name = hostbuf;
                                 host.h_aliases = host_aliases;
                                 host_aliases[0] = NULL;
-                                host.h_addrtype = AF_INET;
-                                host.h_length = sizeof(u_int32_t);
-                                h_addr_ptrs[0] = (char *)&host_addr;
+                                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;
+                }
 
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
-                return (_gethtbyname(name));
-
-        bcopy(_res.lookups, lookups, sizeof lookups);
+        bcopy(_resp->lookups, lookups, sizeof lookups);
         if (lookups[0] == '\0')
-                strncpy(lookups, "bf", sizeof lookups);
+                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':
-                        hp = _yp_gethtbyname(name);
+                        /* YP only supports AF_INET. */
+                        if (af == AF_INET)
+                                hp = _yp_gethtbyname(name);
                         break;
 #endif
                 case 'b':
-                        if ((n = res_search(name, C_IN, T_A, buf.buf,
-                            sizeof(buf))) < 0) {
+                        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 (_res.options & RES_DEBUG)
+                                if (_resp->options & RES_DEBUG)
                                         printf("res_search failed\n");
 #endif
                                 break;
                         }
-                        hp = getanswer(&buf, n, 0);
+                        hp = getanswer(buf, n, name, type);
+                        free(buf);
                         break;
                 case 'f':
-                        hp = _gethtbyname(name);
+                        hp = _gethtbyname2(name, af);
                         break;
                 }
         }
+        /* XXX h_errno not correct in all cases... */
         return (hp);
 }
 
 struct hostent *
-gethostbyaddr(addr, len, type)
-        const char *addr;
-        int len, type;
+gethostbyaddr(const void *addr, socklen_t len, int af)
 {
-        int n, i;
-        querybuf buf;
-        register struct hostent *hp;
-        char qbuf[MAXDNAME];
-        extern struct hostent *_gethtbyaddr(), *_yp_gethtbyaddr();
+        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);
+#ifdef YP
+        extern struct hostent *_yp_gethtbyaddr(const void *);
+#endif
         
-        if (type != AF_INET)
-                return ((struct hostent *) NULL);
-        (void)sprintf(qbuf, "%u.%u.%u.%u.in-addr.arpa",
-                ((unsigned)addr[3] & 0xff),
-                ((unsigned)addr[2] & 0xff),
-                ((unsigned)addr[1] & 0xff),
-                ((unsigned)addr[0] & 0xff));
-
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
-                return (_gethtbyaddr(addr, len, type));
-
-        bcopy(_res.lookups, lookups, sizeof lookups);
+        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')
-                strncpy(lookups, "bf", sizeof lookups);
+                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':
-                        hp = _yp_gethtbyaddr(addr, len, type);
+                        /* YP only supports AF_INET. */
+                        if (af == AF_INET)
+                                hp = _yp_gethtbyaddr(uaddr);
                         break;
 #endif
                 case 'b':
-                        n = res_query(qbuf, C_IN, T_PTR, (char *)&buf, sizeof(buf));
+                        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 (_res.options & RES_DEBUG)
+                                if (_resp->options & RES_DEBUG)
                                         printf("res_query failed\n");
 #endif
                                 break;
                         }
-                        hp = getanswer(&buf, n, 1);
-                        if (hp == NULL)
+                        if (!(hp = getanswer(buf, n, qbuf, T_PTR))) {
+                                free(buf);
                                 break;
-                        hp->h_addrtype = type;
+                        }
+                        free(buf);
+                        hp->h_addrtype = af;
                         hp->h_length = len;
-                        h_addr_ptrs[0] = (char *)&host_addr;
-                        h_addr_ptrs[1] = (char *)0;
-                        host_addr = *(struct in_addr *)addr;
+                        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(addr, len, type);
+                        hp = _gethtbyaddr(uaddr, len, af);
                         break;
                 }
         }
+        /* XXX h_errno not correct in all cases... */
         return (hp);
 }
 
 void
-_sethtent(f)
-        int f;
+_sethtent(int f)
 {
         if (hostf == NULL)
                 hostf = fopen(_PATH_HOSTS, "r" );
@@ -409,7 +780,7 @@ _sethtent(f)
 }
 
 void
-_endhtent()
+_endhtent(void)
 {
         if (hostf && !stayopen) {
                 (void) fclose(hostf);
@@ -417,40 +788,66 @@ _endhtent()
         }
 }
 
-struct hostent *
-_gethtent()
+static struct hostent *
+_gethtent(void)
 {
-        char *p;
-        register char *cp, **q;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char *p, *cp, **q;
+        int af;
+        size_t len;
 
-        if (hostf == NULL && (hostf = fopen(_PATH_HOSTS, "r" )) == NULL)
+        if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
+                h_errno = NETDB_INTERNAL;
                 return (NULL);
-again:
-        if ((p = fgets(hostbuf, BUFSIZ, hostf)) == NULL)
+        }
+ again:
+        if ((p = fgetln(hostf, &len)) == NULL) {
+                h_errno = HOST_NOT_FOUND;
                 return (NULL);
-        if (*p == '#')
+        }
+        if (p[len-1] == '\n')
+                len--;
+        if (len >= sizeof(hostbuf) || len == 0)
                 goto again;
-        cp = strpbrk(p, "#\n");
-        if (cp == NULL)
+        p = memcpy(hostbuf, p, len);
+        hostbuf[len] = '\0';
+        if (*p == '#')
                 goto again;
-        *cp = '\0';
-        cp = strpbrk(p, " \t");
-        if (cp == NULL)
+        if ((cp = strchr(p, '#')))
+                *cp = '\0';
+        if (!(cp = strpbrk(p, " \t")))
                 goto again;
         *cp++ = '\0';
-        /* THIS STUFF IS INTERNET SPECIFIC */
-        h_addr_ptrs[0] = (char *)&host_addr;
+        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;
-        (void) inet_aton(p, &host_addr);
         host.h_addr_list = h_addr_ptrs;
-        host.h_length = sizeof(u_int32_t);
-        host.h_addrtype = AF_INET;
+        host.h_length = len;
+        host.h_addrtype = af;
         while (*cp == ' ' || *cp == '\t')
                 cp++;
         host.h_name = cp;
         q = host.h_aliases = host_aliases;
-        cp = strpbrk(cp, " \t");
-        if (cp != NULL) 
+        if ((cp = strpbrk(cp, " \t")))
                 *cp++ = '\0';
         while (cp && *cp) {
                 if (*cp == ' ' || *cp == '\t') {
@@ -459,74 +856,61 @@ again:
                 }
                 if (q < &host_aliases[MAXALIASES - 1])
                         *q++ = cp;
-                cp = strpbrk(cp, " \t");
-                if (cp != NULL)
+                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 *
-_gethtbyname(name)
-        char *name;
+_gethtbyname2(const char *name, int af)
 {
-        register struct hostent *p;
-        register char **cp;
+        struct hostent *p;
+        char **cp;
         
         _sethtent(0);
-        while (p = _gethtent()) {
+        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:
+ found:
         _endhtent();
-        if (p==NULL)
-                h_errno = HOST_NOT_FOUND;
         return (p);
 }
 
 struct hostent *
-_gethtbyaddr(addr, len, type)
-        const char *addr;
-        int len, type;
+_gethtbyaddr(const void *addr, socklen_t len, int af)
 {
-        register struct hostent *p;
+        struct hostent *p;
+
+        host.h_length = len;
+        host.h_addrtype = af;
 
         _sethtent(0);
-        while (p = _gethtent())
-                if (p->h_addrtype == type && !bcmp(p->h_addr, addr, len))
+        while ((p = _gethtent()))
+                if (p->h_addrtype == af && p->h_length == len &&
+                    !bcmp(p->h_addr, addr, len))
                         break;
         _endhtent();
-        if (p==NULL)
-                h_errno = HOST_NOT_FOUND;
         return (p);
 }
 
-static int
-qcomp(a1, a2)
-        struct in_addr **a1, **a2;
-{
-        int pos1, pos2;
-
-        for (pos1 = 0; pos1 < _res.nsort; pos1++)
-                if (_res.sort_list[pos1].addr.s_addr ==
-                    ((*a1)->s_addr & _res.sort_list[pos1].mask))
-                        break;
-        for (pos2 = 0; pos2 < _res.nsort; pos2++)
-                if (_res.sort_list[pos2].addr.s_addr ==
-                    ((*a2)->s_addr & _res.sort_list[pos2].mask))
-                        break;
-        return pos1 - pos2;
-}
-
 #ifdef YP
 struct hostent *
-_yphostent(line)
-        char *line;
+_yphostent(char *line)
 {
         static struct in_addr host_addrs[MAXADDRS];
         char *p = line;
@@ -537,21 +921,21 @@ _yphostent(line)
 
         host.h_name = NULL;
         host.h_addr_list = h_addr_ptrs;
-        host.h_length = sizeof(u_int32_t);
+        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) {
-                if (host.h_name == NULL)
-                        return (NULL);
-                else
-                        goto done;
-        }
+        if (cp == NULL)
+                goto done;
         *cp++ = '\0';
 
         *hap++ = (char *)buf;
@@ -592,30 +976,28 @@ nextline:
                         *cp++ = '\0';
         }
 done:
+        if (host.h_name == NULL)
+                return (NULL);
         *q = NULL;
         *hap = NULL;
         return (&host);
 }
 
 struct hostent *
-_yp_gethtbyaddr(addr, len, type)
-        const char *addr;
-        int len, type;
+_yp_gethtbyaddr(const void *addr)
 {
-        struct hostent *hp = (struct hostent *)NULL;
+        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") + 1];
+        char name[sizeof("xxx.xxx.xxx.xxx")];
         
         if (!__ypdomain) {
                 if (_yp_check(&__ypdomain) == 0)
                         return (hp);
         }
-        sprintf(name, "%u.%u.%u.%u",
-                ((unsigned)addr[0] & 0xff),
-                ((unsigned)addr[1] & 0xff),
-                ((unsigned)addr[2] & 0xff),
-                ((unsigned)addr[3] & 0xff));
+        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;
@@ -629,13 +1011,14 @@ _yp_gethtbyaddr(addr, len, type)
 }
 
 struct hostent *
-_yp_gethtbyname(name)
-        const char *name;
+_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);
@@ -645,10 +1028,104 @@ _yp_gethtbyname(name)
         __ypcurrent = NULL;
         r = yp_match(__ypdomain, "hosts.byname", name,
                 strlen(name), &__ypcurrent, &__ypcurrentlen);
-        if (r==0)
+        if (r == 0)
                 hp = _yphostent(__ypcurrent);
-        if (hp==NULL)
+        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..f282e26960
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.3
@@ -0,0 +1,157 @@
+.\"     $OpenBSD: getifaddrs.3,v 1.14 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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,
+.Fa ifa_data
+is
+.Dv NULL .
+.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..6f7ea15721
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.c
@@ -0,0 +1,284 @@
+/*      $OpenBSD: getifaddrs.c,v 1.10 2008/11/24 20:08:49 claudio 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 <stddef.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, dlen;
+        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 *)(next +
+                                    rtm->rtm_hdrlen);
+                                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 = next + rtm->rtm_hdrlen;
+                        ++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 *)(next +
+                                    rtm->rtm_hdrlen);
+
+                                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);
+                                dlen = rtm->rtm_hdrlen -
+                                    offsetof(struct if_msghdr, ifm_data);
+                                if (dlen > sizeof(ifm->ifm_data))
+                                        dlen = sizeof(ifm->ifm_data);
+                                memcpy(data, &ifm->ifm_data, dlen);
+                                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 = next + rtm->rtm_hdrlen;
+                        /* 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..a91e8896b6
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.3
@@ -0,0 +1,265 @@
+.\"     $OpenBSD: getnameinfo.3,v 1.41 2008/12/22 12:18:56 jacekm 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 $Mdocdate: December 22 2008 $
+.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");
+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");
+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;
+char addr[NI_MAXHOST];
+struct addrinfo hints, *res;
+int error;
+
+error = getnameinfo(sa, sa->sa_len, 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, sa->sa_len, 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..7041a4ee48
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.c
@@ -0,0 +1,351 @@
+/*      $OpenBSD: getnameinfo.c,v 1.33 2007/02/15 04:25:35 ray 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
+
+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 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)) {
+                struct servent sp;
+                struct servent_data sd;
+
+                (void)memset(&sd, 0, sizeof(sd));
+                if (getservbyport_r(port,
+                    (flags & NI_DGRAM) ? "udp" : "tcp", &sp, &sd) == -1)
+                        goto numeric;
+
+                if (strlen(sp.s_name) + 1 > servlen) {
+                        endservent_r(&sd);
+                        return EAI_MEMORY;
+                }
+                strlcpy(serv, sp.s_name, servlen);
+                endservent_r(&sd);
+        } else {
+ numeric:
+                i = snprintf(numserv, sizeof(numserv), "%u", ntohs(port));
+                if (i < 0 || i >= servlen || i >= sizeof(numserv))
+                        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) ||
+            IN6_IS_ADDR_MC_INTFACELOCAL(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
index c193860e36..a85106630c 100644
--- a/src/lib/libc/net/getnetbyaddr.c
+++ b/src/lib/libc/net/getnetbyaddr.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getnetbyaddr.c,v 1.4 1995/02/25 06:20:30 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,27 +28,17 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getnetbyaddr.c      8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getnetbyaddr.c,v 1.4 1995/02/25 06:20:30 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
 
 extern int _net_stayopen;
 
 struct netent *
-getnetbyaddr(net, type)
-        register long net;
-        register int type;
+_getnetbyaddr(in_addr_t net, int type)
 {
-        register struct netent *p;
+        struct netent *p;
 
         setnetent(_net_stayopen);
-        while (p = getnetent())
+        while ((p = getnetent()))
                 if (p->n_addrtype == type && p->n_net == net)
                         break;
         if (!_net_stayopen)
diff --git a/src/lib/libc/net/getnetbyname.c b/src/lib/libc/net/getnetbyname.c
index 93a2e1256c..e6540cf12c 100644
--- a/src/lib/libc/net/getnetbyname.c
+++ b/src/lib/libc/net/getnetbyname.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getnetbyname.c,v 1.4 1995/02/25 06:20:31 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,32 +28,23 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getnetbyname.c      8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getnetbyname.c,v 1.4 1995/02/25 06:20:31 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
 #include <string.h>
 
 extern int _net_stayopen;
 
 struct netent *
-getnetbyname(name)
-        register const char *name;
+_getnetbyname(const char *name)
 {
-        register struct netent *p;
-        register char **cp;
+        struct netent *p;
+        char **cp;
 
         setnetent(_net_stayopen);
-        while (p = getnetent()) {
-                if (strcmp(p->n_name, name) == 0)
+        while ((p = getnetent())) {
+                if (strcasecmp(p->n_name, name) == 0)
                         break;
                 for (cp = p->n_aliases; *cp != 0; cp++)
-                        if (strcmp(*cp, name) == 0)
+                        if (strcasecmp(*cp, name) == 0)
                                 goto found;
         }
 found:
diff --git a/src/lib/libc/net/getnetent.3 b/src/lib/libc/net/getnetent.3
index d4f0bedbf9..00fd543ec4 100644
--- a/src/lib/libc/net/getnetent.3
+++ b/src/lib/libc/net/getnetent.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: getnetent.3,v 1.3 1995/02/25 06:20:32 cgd Exp $
+.\"     $OpenBSD: getnetent.3,v 1.15 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,11 +27,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)getnetent.3 8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt GETNETENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getnetent ,
 .Nm getnetbyaddr ,
@@ -46,31 +40,30 @@
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct netent *
-.Fn getnetent 
+.Fn getnetent "void"
 .Ft struct netent *
-.Fn getnetbyname "char *name"
+.Fn getnetbyname "const char *name"
 .Ft struct netent *
-.Fn getnetbyaddr "long net" "int type"
+.Fn getnetbyaddr "in_addr_t net" "int type"
+.Ft void
 .Fn setnetent "int stayopen"
-.Fn endnetent 
+.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 data base,
+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 */
-        unsigned long   n_net;          /* net number */
+        in_addr_t       n_net;          /* net number */
 };
 .Ed
 .Pp
@@ -79,45 +72,42 @@ The members of this structure are:
 .It Fa n_name
 The official name of the network.
 .It Fa n_aliases
-A zero terminated list of alternate names for the network.
+A null-terminated list of alternate names for the network.
 .It Fa n_addrtype
-The type of the network number returned; currently only AF_INET.
+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.
+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.
+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
+function opens and rewinds the file.
+If the
 .Fa stayopen
 flag is non-zero,
-the net data base will not be closed after each call to 
+the net database will not be closed after each call to
 .Fn getnetbyname
 or
 .Fn getnetbyaddr .
 .Pp
 The
 .Fn endnetent
-function
-closes the file.
+function closes the file.
 .Pp
 The
 .Fn getnetbyname
-function
 and
 .Fn getnetbyaddr
-sequentially search from the beginning
-of the file until a matching
-net name or
-net address and type is found,
-or until
+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.
@@ -126,11 +116,11 @@ Network numbers are supplied in host order.
 .It Pa /etc/networks
 .El
 .Sh DIAGNOSTICS
-Null pointer
-(0) returned on
+Null pointer (0) returned on
 .Dv EOF
 or error.
 .Sh SEE ALSO
+.Xr resolver 3 ,
 .Xr networks 5
 .Sh HISTORY
 The
@@ -140,14 +130,11 @@ The
 .Fn setnetent ,
 and
 .Fn endnetent
-functions appeared in 
+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 probably
-naive.
+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
index b4e16b8f5d..1bec6fb98c 100644
--- a/src/lib/libc/net/getnetent.c
+++ b/src/lib/libc/net/getnetent.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getnetent.c,v 1.4 1995/02/25 06:20:33 cgd Exp $        */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,15 +28,7 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getnetent.c 8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getnetent.c,v 1.4 1995/02/25 06:20:33 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
-#include <sys/types.h>
+#include <sys/param.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -58,8 +45,7 @@ static char *net_aliases[MAXALIASES];
 int _net_stayopen;
 
 void
-setnetent(f)
-        int f;
+setnetent(int f)
 {
         if (netf == NULL)
                 netf = fopen(_PATH_NETWORKS, "r" );
@@ -69,7 +55,7 @@ setnetent(f)
 }
 
 void
-endnetent()
+endnetent(void)
 {
         if (netf) {
                 fclose(netf);
@@ -79,24 +65,29 @@ endnetent()
 }
 
 struct netent *
-getnetent()
+getnetent(void)
 {
-        char *p;
-        register char *cp, **q;
+        char *p, *cp, **q;
+        size_t len;
 
         if (netf == NULL && (netf = fopen(_PATH_NETWORKS, "r" )) == NULL)
                 return (NULL);
 again:
-        p = fgets(line, BUFSIZ, netf);
-        if (p == NULL)
+        if ((p = fgetln(netf, &len)) == NULL)
                 return (NULL);
-        if (*p == '#')
+        if (p[len-1] == '\n')
+                len--;
+        if (len >= sizeof(line) || len == 0)
                 goto again;
-        cp = strpbrk(p, "#\n");
-        if (cp == NULL)
+        p = memcpy(line, p, len);
+        line[len] = '\0';
+        if (*p == '#')
                 goto again;
-        *cp = '\0';
+        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;
@@ -116,8 +107,11 @@ again:
                         cp++;
                         continue;
                 }
-                if (q < &net_aliases[MAXALIASES - 1])
+                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';
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/getpeereid.3 b/src/lib/libc/net/getpeereid.3
new file mode 100644
index 0000000000..c1671a7516
--- /dev/null
+++ b/src/lib/libc/net/getpeereid.3
@@ -0,0 +1,119 @@
+.\"     $OpenBSD: getpeereid.3,v 1.1 2010/07/01 19:15:30 deraadt 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 $Mdocdate: July 1 2010 $
+.Dt GETPEEREID 3
+.Os
+.Sh NAME
+.Nm getpeereid
+.Nd get effective user and group identification of locally-connected peer
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Ft int
+.Fn getpeereid "int s" "uid_t *euid" "gid_t *egid"
+.Sh DESCRIPTION
+.Fn getpeereid
+returns the effective user ID and group ID of the peer connected to
+a
+.Ux Ns -domain
+socket (see
+.Xr unix 4 ) .
+The argument
+.Fa s
+must be of type
+.Dv SOCK_STREAM .
+.Pp
+One common use is for
+.Ux Ns -domain
+servers to determine the credentials of clients that have connected to it.
+.Pp
+.Fn getpeereid
+takes three parameters:
+.Bl -bullet
+.It
+.Fa s
+contains the file descriptor of the socket whose peer credentials
+should be looked up.
+.It
+.Fa euid
+points to a
+.Li uid_t
+variable into which the effective user ID for the connected peer will
+be stored.
+.It
+.Fa egid
+points to a
+.Li gid_t
+variable into which the effective group ID for the connected peer will
+be stored.
+.El
+.Sh RETURN VALUES
+If the call succeeds, a 0 is returned and
+.Fa euid
+and
+.Fa egid
+are set to the effective user ID and group ID of the connected peer.
+Otherwise,
+.Va errno
+is set and a value of \-1 is returned.
+.Sh ERRORS
+On failure,
+.Va errno
+is set to one of the following:
+.Bl -tag -width Er
+.It Bq Er EBADF
+The argument
+.Fa s
+is not a valid descriptor.
+.It Bq Er ENOTSOCK
+The argument
+.Fa s
+is a file, not a socket.
+.It Bq Er EOPNOTSUPP
+The socket is not in the
+.Ux Ns -domain .
+.It Bq Er ENOTCONN
+The socket is not connected.
+.It Bq Er ENOBUFS
+Insufficient resources were available in the system
+to perform the operation.
+.El
+.Sh SEE ALSO
+.Xr accept 2 ,
+.Xr bind 2 ,
+.Xr getpeername 2 ,
+.Xr getsockname 2 ,
+.Xr getsockopt 2 ,
+.Xr socket 2 ,
+.Xr unix 4
+.Sh HISTORY
+The
+.Fn getpeereid
+function call appeared in
+.Ox 3.0 .
diff --git a/src/lib/libc/net/getpeereid.c b/src/lib/libc/net/getpeereid.c
new file mode 100644
index 0000000000..208e541f17
--- /dev/null
+++ b/src/lib/libc/net/getpeereid.c
@@ -0,0 +1,36 @@
+/*      $OpenBSD: getpeereid.c,v 1.1 2010/07/01 19:15:30 deraadt Exp $  */
+
+/*
+ * Copyright (c) 2010 Theo de Raadt <deraadt@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int
+getpeereid(int s, uid_t *euid, gid_t *egid)
+{
+        struct sockpeercred creds;
+        socklen_t credslen = sizeof(creds);
+        int error;
+
+        error = getsockopt(s, SOL_SOCKET, SO_PEERCRED,
+            &creds, &credslen);
+        if (error)
+                return (error);
+        *euid = creds.uid;
+        *egid = creds.gid;
+        return (0);
+}
diff --git a/src/lib/libc/net/getproto.c b/src/lib/libc/net/getproto.c
index 49c09b0806..07fa33288d 100644
--- a/src/lib/libc/net/getproto.c
+++ b/src/lib/libc/net/getproto.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getproto.c,v 1.4 1995/02/25 06:20:33 cgd Exp $ */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,29 +28,32 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getproto.c  8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getproto.c,v 1.4 1995/02/25 06:20:33 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
+#include <stdio.h>
 
-extern int _proto_stayopen;
+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(proto)
-        register int proto;
+getprotobynumber(int num)
 {
-        register struct protoent *p;
+        extern struct protoent_data _protoent_data;
+        static struct protoent proto;
 
-        setprotoent(_proto_stayopen);
-        while (p = getprotoent())
-                if (p->p_proto == proto)
-                        break;
-        if (!_proto_stayopen)
-                endprotoent();
-        return (p);
+        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
index 8d607199ef..df4cd0c323 100644
--- a/src/lib/libc/net/getprotoent.3
+++ b/src/lib/libc/net/getprotoent.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: getprotoent.3,v 1.3 1995/02/25 06:20:34 cgd Exp $
+.\"     $OpenBSD: getprotoent.3,v 1.17 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,39 +27,51 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)getprotoent.3       8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt GETPROTOENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getprotoent ,
+.Nm getprotoent_r ,
 .Nm getprotobynumber ,
+.Nm getprotobynumber_r ,
 .Nm getprotobyname ,
+.Nm getprotobyname_r ,
 .Nm setprotoent ,
-.Nm endprotoent
+.Nm setprotoent_r ,
+.Nm endprotoent ,
+.Nm endprotoent_r
 .Nd get protocol entry
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct protoent *
-.Fn getprotoent 
+.Fn getprotoent "void"
+.Ft int
+.Fn getprotoent_r "struct protoent *protoent" "struct protoent_data *protoent_data"
 .Ft struct protoent *
-.Fn getprotobyname "char *name"
+.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"
-.Fn endprotoent 
+.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 data base,
+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
@@ -79,55 +87,106 @@ The members of this structure are:
 .It Fa p_name
 The official name of the protocol.
 .It Fa p_aliases
-A zero terminated list of alternate names for the protocol.
+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.
+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
+function opens and rewinds the file.
+If the
 .Fa stayopen
 flag is non-zero,
-the net data base will not be closed after each call to 
+the protocol database will not be closed after each call to
 .Fn getprotobyname
 or
 .Fn getprotobynumber .
 .Pp
 The
 .Fn endprotoent
-function
-closes the file.
+function closes the file.
 .Pp
 The
 .Fn getprotobyname
-function
 and
 .Fn getprotobynumber
-sequentially search from the beginning
-of the file until a matching
-protocol name or
-protocol number is found,
-or until
+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
-Null pointer
-(0) returned on
-.Dv EOF
-or error.
+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 ,
@@ -136,11 +195,19 @@ The
 .Fn setprotoent ,
 and
 .Fn endprotoent
-functions appeared in 
+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
-These 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.
+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
index 1179b9029b..f0705e0765 100644
--- a/src/lib/libc/net/getprotoent.c
+++ b/src/lib/libc/net/getprotoent.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getprotoent.c,v 1.4 1995/02/25 06:20:35 cgd Exp $      */
-
+/*      $OpenBSD: getprotoent.c,v 1.10 2007/09/02 15:19:17 deraadt Exp $ */
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,69 +28,66 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getprotoent.c       8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getprotoent.c,v 1.4 1995/02/25 06:20:35 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #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>
 
-#define MAXALIASES      35
-
-static FILE *protof = NULL;
-static char line[BUFSIZ+1];
-static struct protoent proto;
-static char *proto_aliases[MAXALIASES];
-int _proto_stayopen;
-
 void
-setprotoent(f)
-        int f;
+setprotoent_r(int f, struct protoent_data *pd)
 {
-        if (protof == NULL)
-                protof = fopen(_PATH_PROTOCOLS, "r" );
+        if (pd->fp == NULL)
+                pd->fp = fopen(_PATH_PROTOCOLS, "r" );
         else
-                rewind(protof);
-        _proto_stayopen |= f;
+                rewind(pd->fp);
+        pd->stayopen |= f;
 }
 
 void
-endprotoent()
+endprotoent_r(struct protoent_data *pd)
 {
-        if (protof) {
-                fclose(protof);
-                protof = NULL;
+        if (pd->fp) {
+                fclose(pd->fp);
+                pd->fp = NULL;
         }
-        _proto_stayopen = 0;
+        free(pd->aliases);
+        pd->aliases = NULL;
+        pd->maxaliases = 0;
+        free(pd->line);
+        pd->line = NULL;
+        pd->stayopen = 0;
 }
 
-struct protoent *
-getprotoent()
+int
+getprotoent_r(struct protoent *pe, struct protoent_data *pd)
 {
-        char *p;
-        register char *cp, **q;
+        char *p, *cp, **q, *endp;
+        size_t len;
+        long l;
+        int serrno;
 
-        if (protof == NULL && (protof = fopen(_PATH_PROTOCOLS, "r" )) == NULL)
-                return (NULL);
+        if (pd->fp == NULL && (pd->fp = fopen(_PATH_PROTOCOLS, "r" )) == NULL)
+                return (-1);
 again:
-        if ((p = fgets(line, BUFSIZ, protof)) == NULL)
-                return (NULL);
-        if (*p == '#')
+        if ((p = fgetln(pd->fp, &len)) == NULL)
+                return (-1);
+        if (len == 0 || *p == '#' || *p == '\n')
                 goto again;
-        cp = strpbrk(p, "#\n");
+        if (p[len-1] == '\n')
+                len--;
+        if ((cp = memchr(p, '#', len)) != NULL)
+                len = cp - p;
+        cp = realloc(pd->line, len + 1);
         if (cp == NULL)
-                goto again;
-        *cp = '\0';
-        proto.p_name = p;
-        cp = strpbrk(p, " \t");
+                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';
@@ -104,8 +96,21 @@ again:
         p = strpbrk(cp, " \t");
         if (p != NULL)
                 *p++ = '\0';
-        proto.p_proto = atoi(cp);
-        q = proto.p_aliases = proto_aliases;
+        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 = calloc(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) {
@@ -113,13 +118,49 @@ again:
                                 cp++;
                                 continue;
                         }
-                        if (q < &proto_aliases[MAXALIASES - 1])
-                                *q++ = cp;
+                        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
index 4f8cf21c3f..749b6b3f13 100644
--- a/src/lib/libc/net/getprotoname.c
+++ b/src/lib/libc/net/getprotoname.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getprotoname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,36 +28,40 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getprotoname.c      8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getprotoname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
+#include <stdio.h>
 #include <string.h>
 
-extern int _proto_stayopen;
-
-struct protoent *
-getprotobyname(name)
-        register const char *name;
+int
+getprotobyname_r(const char *name, struct protoent *pe,
+    struct protoent_data *pd)
 {
-        register struct protoent *p;
-        register char **cp;
+        char **cp;
+        int error;
 
-        setprotoent(_proto_stayopen);
-        while (p = getprotoent()) {
-                if (strcmp(p->p_name, name) == 0)
+        setprotoent_r(pd->stayopen, pd);
+        while ((error = getprotoent_r(pe, pd)) == 0) {
+                if (strcmp(pe->p_name, name) == 0)
                         break;
-                for (cp = p->p_aliases; *cp != 0; cp++)
+                for (cp = pe->p_aliases; *cp != 0; cp++)
                         if (strcmp(*cp, name) == 0)
                                 goto found;
         }
 found:
-        if (!_proto_stayopen)
-                endprotoent();
-        return (p);
+        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..121cb67fcc
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.3
@@ -0,0 +1,166 @@
+.\" $OpenBSD: getrrsetbyname.3,v 1.15 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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..2bbb6ccf83
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.c
@@ -0,0 +1,517 @@
+/* $OpenBSD: getrrsetbyname.c,v 1.12 2010/06/29 09:22:06 deraadt 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 MAXPACKET 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;
+        union {
+                HEADER hdr;
+                u_char buf[MAXPACKET];
+        } answer;
+
+        /* 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.buf, sizeof(answer.buf));
+        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.buf, 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_RRSIG);
+
+        /* 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_RRSIG)
+                        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
index b4a6311966..beb8943af6 100644
--- a/src/lib/libc/net/getservbyname.c
+++ b/src/lib/libc/net/getservbyname.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getservbyname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $    */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,39 +28,43 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getservbyname.c     8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getservbyname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
+#include <stdio.h>
 #include <string.h>
 
-extern int _serv_stayopen;
-
-struct servent *
-getservbyname(name, proto)
-        const char *name, *proto;
+int
+getservbyname_r(const char *name, const char *proto, struct servent *se,
+    struct servent_data *sd)
 {
-        register struct servent *p;
-        register char **cp;
+        char **cp;
+        int error;
 
-        setservent(_serv_stayopen);
-        while (p = getservent()) {
-                if (strcmp(name, p->s_name) == 0)
+        setservent_r(sd->stayopen, sd);
+        while ((error = getservent_r(se, sd)) == 0) {
+                if (strcmp(name, se->s_name) == 0)
                         goto gotname;
-                for (cp = p->s_aliases; *cp; cp++)
+                for (cp = se->s_aliases; *cp; cp++)
                         if (strcmp(name, *cp) == 0)
                                 goto gotname;
                 continue;
 gotname:
-                if (proto == 0 || strcmp(p->s_proto, proto) == 0)
+                if (proto == 0 || strcmp(se->s_proto, proto) == 0)
                         break;
         }
-        if (!_serv_stayopen)
-                endservent();
-        return (p);
+        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
index c34790737b..46679ba366 100644
--- a/src/lib/libc/net/getservbyport.c
+++ b/src/lib/libc/net/getservbyport.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getservbyport.c,v 1.4 1995/02/25 06:20:37 cgd Exp $    */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,34 +28,37 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getservbyport.c     8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getservbyport.c,v 1.4 1995/02/25 06:20:37 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <netdb.h>
+#include <stdio.h>
 #include <string.h>
 
-extern int _serv_stayopen;
-
-struct servent *
-getservbyport(port, proto)
-        int port;
-        const char *proto;
+int
+getservbyport_r(int port, const char *proto, struct servent *se,
+    struct servent_data *sd)
 {
-        register struct servent *p;
+        int error;
 
-        setservent(_serv_stayopen);
-        while (p = getservent()) {
-                if (p->s_port != port)
+        setservent_r(sd->stayopen, sd);
+        while ((error = getservent_r(se, sd)) == 0) {
+                if (se->s_port != port)
                         continue;
-                if (proto == 0 || strcmp(p->s_proto, proto) == 0)
+                if (proto == 0 || strcmp(se->s_proto, proto) == 0)
                         break;
         }
-        if (!_serv_stayopen)
-                endservent();
-        return (p);
+        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
index 9e0656be00..7888b5f1b8 100644
--- a/src/lib/libc/net/getservent.3
+++ b/src/lib/libc/net/getservent.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: getservent.3,v 1.3 1995/02/25 06:20:38 cgd Exp $
+.\"     $OpenBSD: getservent.3,v 1.20 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,41 +27,51 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)getservent.3        8.3 (Berkeley) 1/12/94
-.\"
-.Dd January 12, 1994
+.Dd $Mdocdate: May 31 2007 $
 .Dt GETSERVENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getservent ,
+.Nm getservent_r ,
 .Nm getservbyport ,
+.Nm getservbyport_r ,
 .Nm getservbyname ,
+.Nm getservbyname_r ,
 .Nm setservent ,
-.Nm endservent
+.Nm setservent_r ,
+.Nm endservent ,
+.Nm endservent_r
 .Nd get service entry
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct servent *
-.Fn getservent 
+.Fn getservent "void"
+.Ft int
+.Fn getservent_r "struct servent *servent" "struct servent_data *servent_data"
 .Ft struct servent *
-.Fn getservbyname "char *name" "char *proto"
+.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" proto
+.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 endservent 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 data base,
+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 {
@@ -81,64 +87,113 @@ The members of this structure are:
 .It Fa s_name
 The official name of the service.
 .It Fa s_aliases
-A zero terminated list of alternate names for the service.
+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.
+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.
+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
+function opens and rewinds the file.
+If the
 .Fa stayopen
 flag is non-zero,
-the net data base will not be closed after each call to 
+the services database will not be closed after each call to
 .Fn getservbyname
 or
 .Fn getservbyport .
 .Pp
 The
 .Fn endservent
-function
-closes the file.
+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 is found,
-or until
+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-
-.Dv NULL ) , 
+If a protocol name is also supplied (non-null),
 searches must also match the protocol.
-.ne 1i
+.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 DIAGNOSTICS
-Null pointer
-(0) returned on
-.Dv EOF
-or error.
 .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 ,
@@ -147,11 +202,19 @@ The
 .Fn setservent ,
 and
 .Fn endservent
-functions appeared in 
+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
-These 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.
+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
index 316891450e..c81a4cf3e2 100644
--- a/src/lib/libc/net/getservent.c
+++ b/src/lib/libc/net/getservent.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: getservent.c,v 1.4 1995/02/25 06:20:38 cgd Exp $       */
-
+/*      $OpenBSD: getservent.c,v 1.12 2007/09/02 15:19:17 deraadt Exp $ */
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,69 +28,66 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)getservent.c        8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: getservent.c,v 1.4 1995/02/25 06:20:38 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #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>
 
-#define MAXALIASES      35
-
-static FILE *servf = NULL;
-static char line[BUFSIZ+1];
-static struct servent serv;
-static char *serv_aliases[MAXALIASES];
-int _serv_stayopen;
-
 void
-setservent(f)
-        int f;
+setservent_r(int f, struct servent_data *sd)
 {
-        if (servf == NULL)
-                servf = fopen(_PATH_SERVICES, "r" );
+        if (sd->fp == NULL)
+                sd->fp = fopen(_PATH_SERVICES, "r" );
         else
-                rewind(servf);
-        _serv_stayopen |= f;
+                rewind(sd->fp);
+        sd->stayopen |= f;
 }
 
 void
-endservent()
+endservent_r(struct servent_data *sd)
 {
-        if (servf) {
-                fclose(servf);
-                servf = NULL;
+        if (sd->fp) {
+                fclose(sd->fp);
+                sd->fp = NULL;
         }
-        _serv_stayopen = 0;
+        free(sd->aliases);
+        sd->aliases = NULL;
+        sd->maxaliases = 0;
+        free(sd->line);
+        sd->line = NULL;
+        sd->stayopen = 0;
 }
 
-struct servent *
-getservent()
+int
+getservent_r(struct servent *se, struct servent_data *sd)
 {
-        char *p;
-        register char *cp, **q;
+        char *p, *cp, **q, *endp;
+        size_t len;
+        long l;
+        int serrno;
 
-        if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL)
-                return (NULL);
+        if (sd->fp == NULL && (sd->fp = fopen(_PATH_SERVICES, "r" )) == NULL)
+                return (-1);
 again:
-        if ((p = fgets(line, BUFSIZ, servf)) == NULL)
-                return (NULL);
-        if (*p == '#')
+        if ((p = fgetln(sd->fp, &len)) == NULL)
+                return (-1);
+        if (len == 0 || *p == '#' || *p == '\n')
                 goto again;
-        cp = strpbrk(p, "#\n");
+        if (p[len-1] == '\n')
+                len--;
+        if ((cp = memchr(p, '#', len)) != NULL)
+                len = cp - p;
+        cp = realloc(sd->line, len + 1);
         if (cp == NULL)
-                goto again;
-        *cp = '\0';
-        serv.s_name = p;
-        p = strpbrk(p, " \t");
+                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';
@@ -105,9 +97,22 @@ again:
         if (cp == NULL)
                 goto again;
         *cp++ = '\0';
-        serv.s_port = htons((u_short)atoi(p));
-        serv.s_proto = cp;
-        q = serv.s_aliases = serv_aliases;
+        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 = calloc(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';
@@ -116,12 +121,48 @@ again:
                         cp++;
                         continue;
                 }
-                if (q < &serv_aliases[MAXALIASES - 1])
-                        *q++ = cp;
+                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
index 41adbf1055..7787115a9d 100644
--- a/src/lib/libc/net/herror.c
+++ b/src/lib/libc/net/herror.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: herror.c,v 1.5 1995/02/25 06:20:39 cgd Exp $   */
+/*      $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.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,29 +51,21 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)herror.c    8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: herror.c,v 4.9.1.1 1993/05/02 23:14:35 vixie Rel ";
-#else
-static char rcsid[] = "$NetBSD: herror.c,v 1.5 1995/02/25 06:20:39 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
+#include <sys/param.h>
 #include <sys/uio.h>
 #include <netdb.h>
 #include <unistd.h>
 #include <string.h>
 
-char    *h_errlist[] = {
-        "Error 0",
+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 */
 };
-int     h_nerr = { sizeof(h_errlist)/sizeof(h_errlist[0]) };
+const int       h_nerr = { sizeof h_errlist / sizeof h_errlist[0] };
 
 extern int      h_errno;
 
@@ -84,11 +74,10 @@ extern int	h_errno;
  *      print the error indicated by the h_errno value.
  */
 void
-herror(s)
-        const char *s;
+herror(const char *s)
 {
         struct iovec iov[4];
-        register struct iovec *v = iov;
+        struct iovec *v = iov;
 
         if (s && *s) {
                 v->iov_base = (char *)s;
@@ -98,8 +87,7 @@ herror(s)
                 v->iov_len = 2;
                 v++;
         }
-        v->iov_base = (u_int)h_errno < h_nerr ?
-            h_errlist[h_errno] : "Unknown error";
+        v->iov_base = (char *)hstrerror(h_errno);
         v->iov_len = strlen(v->iov_base);
         v++;
         v->iov_base = "\n";
@@ -107,9 +95,12 @@ herror(s)
         writev(STDERR_FILENO, iov, (v - iov) + 1);
 }
 
-char *
-hstrerror(err)
-        int err;
+const char *
+hstrerror(int err)
 {
-        return (u_int)err < h_nerr ? h_errlist[err] : "Unknown resolver error";
+        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
index ac85cb0fd7..5ab4189597 100644
--- a/src/lib/libc/net/htonl.c
+++ b/src/lib/libc/net/htonl.c
@@ -1,29 +1,21 @@
-/*      $NetBSD: htonl.c,v 1.5 1995/04/28 23:25:14 jtc Exp $    */
-
+/*      $OpenBSD: htonl.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
 /*
  * Written by J.T. Conklin <jtc@netbsd.org>.
  * Public domain.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: htonl.c,v 1.5 1995/04/28 23:25:14 jtc Exp $";
-#endif
-
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef htonl
 
-unsigned long
-htonl(x)
-        unsigned long x;
+u_int32_t
+htonl(u_int32_t x)
 {
-        u_int32_t y = x;
-
 #if BYTE_ORDER == LITTLE_ENDIAN
-        u_char *s = (u_char *)&y;
-        return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
+        u_char *s = (u_char *)&x;
+        return (u_int32_t)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
 #else
-        return y;
+        return x;
 #endif
 }
diff --git a/src/lib/libc/net/htons.c b/src/lib/libc/net/htons.c
index b2500a51d1..c8b73fdbb7 100644
--- a/src/lib/libc/net/htons.c
+++ b/src/lib/libc/net/htons.c
@@ -1,26 +1,20 @@
-/*      $NetBSD: htons.c,v 1.5 1995/04/28 23:25:19 jtc Exp $    */
-
+/*      $OpenBSD: htons.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
 /*
  * Written by J.T. Conklin <jtc@netbsd.org>.
  * Public domain.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: htons.c,v 1.5 1995/04/28 23:25:19 jtc Exp $";
-#endif
-
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef htons
 
-unsigned short
-htons(x)
-        unsigned short x;
+u_int16_t
+htons(u_int16_t x)
 {
 #if BYTE_ORDER == LITTLE_ENDIAN
         u_char *s = (u_char *) &x;
-        return s[0] << 8 | s[1];
+        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..8ffc35a5fa
--- /dev/null
+++ b/src/lib/libc/net/if_indextoname.3
@@ -0,0 +1,144 @@
+.\"     $OpenBSD: if_indextoname.3,v 1.11 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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..c5a771869b
--- /dev/null
+++ b/src/lib/libc/net/if_nameindex.c
@@ -0,0 +1,146 @@
+/*      $OpenBSD: if_nameindex.c,v 1.10 2010/09/24 13:29:29 claudio 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);
+}
+
+void
+if_freenameindex(struct if_nameindex *ptr)
+{
+        free(ptr);
+}
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
index 49bac97e96..3f198ae8e0 100644
--- a/src/lib/libc/net/inet.3
+++ b/src/lib/libc/net/inet.3
@@ -1,4 +1,5 @@
-.\"     $NetBSD: inet.3,v 1.4 1995/02/27 09:45:26 chopps Exp $
+.\"     $OpenBSD: inet.3,v 1.22 2008/12/09 19:38:38 otto 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.
@@ -11,11 +12,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,52 +30,74 @@
 .\"
 .\"     @(#)inet.3      8.1 (Berkeley) 6/4/93
 .\"
-.Dd June 4, 1993
+.Dd $Mdocdate: December 9 2008 $
 .Dt INET 3
-.Os BSD 4.2
+.Os
 .Sh NAME
-.Nm inet_aton ,
 .Nm inet_addr ,
+.Nm inet_aton ,
+.Nm inet_lnaof ,
+.Nm inet_makeaddr ,
+.Nm inet_netof ,
 .Nm inet_network ,
 .Nm inet_ntoa ,
-.Nm inet_makeaddr ,
-.Nm inet_lnaof ,
-.Nm inet_netof
+.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 int 
-.Fn inet_aton "const char *cp" "struct in_addr *pin"
-.Ft unsigned long 
+.Ft in_addr_t
 .Fn inet_addr "const char *cp"
-.Ft unsigned long 
+.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 struct in_addr 
-.Fn inet_makeaddr "int net" "int lna"
-.Ft unsigned long 
-.Fn inet_lnaof "struct in_addr in"
-.Ft unsigned long 
-.Fn inet_netof "struct in_addr in"
+.Ft const char *
+.Fn inet_ntop "int af" "const void *src" "char *dst" "socklen_t size"
+.Ft int
+.Fn inet_pton "int af" "const char *src" "void *dst"
 .Sh DESCRIPTION
 The routines
 .Fn inet_aton ,
-.Fn inet_addr
+.Fn inet_addr ,
 and
 .Fn inet_network
 interpret character strings representing
 numbers expressed in the Internet standard
-.Ql \&.
+.Dq dot
 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 is invalid.
+or 0 if the string was invalid.
 The
 .Fn inet_addr
 and
@@ -86,17 +105,29 @@ and
 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
+ASCII string representing the address in dot 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
+from it.
+The routines
 .Fn inet_netof
 and
 .Fn inet_lnaof
@@ -108,11 +139,8 @@ 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
-Values specified using the
-.Ql \&.
-notation take one
-of the following forms:
+.Sh INTERNET ADDRESSES (IP VERSION 4)
+Values specified using dot notation take one of the following forms:
 .Bd -literal -offset indent
 a.b.c.d
 a.b.c
@@ -122,28 +150,25 @@ a
 .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 the
-.Tn VAX
-the bytes referred to
-above appear as
+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 Intel 386, 486 and Pentium processors)
+the bytes referred to above appear as
 .Dq Li d.c.b.a .
-That is,
-.Tn VAX
-bytes are
-ordered from right to left.
+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 right-most two bytes of the network address.
+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 right most three bytes of the network address.
+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 .
@@ -154,13 +179,88 @@ rearrangement.
 .Pp
 All numbers supplied as
 .Dq parts
-in a
-.Ql  \&.
-notation
+in a dot 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;
+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
@@ -170,28 +270,76 @@ 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 ,
+.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
-These
-functions appeared in 
+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 this problem.
+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.
-.Pp
-Inet_addr should return a
-.Fa struct in_addr .
diff --git a/src/lib/libc/net/inet6_opt_init.3 b/src/lib/libc/net/inet6_opt_init.3
new file mode 100644
index 0000000000..21880a6382
--- /dev/null
+++ b/src/lib/libc/net/inet6_opt_init.3
@@ -0,0 +1,338 @@
+.\"     $OpenBSD: inet6_opt_init.3,v 1.3 2007/05/31 19:19:30 jmc Exp $
+.\"     $KAME: inet6_opt_init.3,v 1.7 2004/12/27 05:08:23 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 $Mdocdate: May 31 2007 $
+.Dt INET6_OPT_INIT 3
+.Os
+.\"
+.Sh NAME
+.Nm inet6_opt_init ,
+.Nm inet6_opt_append ,
+.Nm inet6_opt_finish ,
+.Nm inet6_opt_set_val ,
+.Nm inet6_opt_next ,
+.Nm inet6_opt_find ,
+.Nm inet6_opt_get_val
+.Nd IPv6 Hop-by-Hop and Destination Options manipulation
+.\"
+.Sh SYNOPSIS
+.In netinet/in.h
+.Ft "int"
+.Fn inet6_opt_init "void *extbuf" "socklen_t extlen"
+.Ft "int"
+.Fn inet6_opt_append "void *extbuf" "socklen_t extlen" "int offset" "u_int8_t type" "socklen_t len" "u_int8_t align" "void **databufp"
+.Ft "int"
+.Fn inet6_opt_finish "void *extbuf" "socklen_t extlen" "int offset"
+.Ft "int"
+.Fn inet6_opt_set_val "void *databuf" "int offset" "void *val" "socklen_t vallen"
+.Ft "int"
+.Fn inet6_opt_next "void *extbuf" "socklen_t extlen" "int offset" "u_int8_t *typep" "socklen_t *lenp" "void **databufp"
+.Ft "int"
+.Fn inet6_opt_find "void *extbuf" "socklen_t extlen" "int offset" "u_int8_t type" "socklen_t *lenp" "void **databufp"
+.Ft "int"
+.Fn inet6_opt_get_val "void *databuf" "socklen_t offset" "void *val" "socklen_t vallen"
+.\"
+.Sh DESCRIPTION
+Building and parsing the Hop-by-Hop and Destination options is
+complicated.
+The advanced sockets API defines a set of functions to
+help applications create and manipulate Hop-by-Hop and Destination
+options.
+.\"This man page describes the functions specified in
+.\"IETF Draft RFC 3542 while the
+.\".Xr inet6_options_space 3
+.\"man page documents the functions defined in RFC 2292.
+.\"It is expected
+.\"that this set of functions will supersede those in RFC 2292 but for
+.\"the time being both APIs are retained.
+These functions use the
+formatting rules specified in Appendix B in RFC 2460, i.e. that the
+largest field is placed last in the option.
+The function prototypes
+for these functions are all contained in the header file
+.Aq Pa netinet/in.h .
+.\"
+.Ss inet6_opt_init
+The
+.Fn inet6_opt_init
+function
+returns the number of bytes needed for an empty
+extension header, one without any options.
+If the
+.Va extbuf
+argument points to a valid section of memory
+then the
+.Fn inet6_opt_init
+function also initializes the extension header's length field.
+When attempting to initialize an extension buffer passed in the
+.Va extbuf
+argument,
+.Fa extlen
+must be a positive multiple of 8 or else the function fails and
+returns \-1 to the caller.
+.\"
+.Ss inet6_opt_append
+The
+.Fn inet6_opt_append
+function can perform different jobs.
+When a valid
+.Fa extbuf
+argument is supplied it appends an option to the extension buffer and
+returns the updated total length as well as a pointer to the newly
+created option in
+.Fa databufp .
+If the value
+of
+.Fa extbuf
+is
+.Dv NULL
+then the
+.Fn inet6_opt_append
+function only reports what the total length would
+be if the option were actually appended.
+The
+.Fa len
+and
+.Fa align
+arguments specify the length of the option and the required data
+alignment which must be used when appending the option.
+The
+.Fa offset
+argument should be the length returned by the
+.Fn inet6_opt_init
+function or a previous call to
+.Fn inet6_opt_append .
+.Pp
+The
+.Fa type
+argument is the 8-bit option type.
+.Pp
+After
+.Fn inet6_opt_append
+has been called, the application can use the buffer pointed to by
+.Fa databufp
+directly, or use
+.Fn inet6_opt_set_val
+to specify the data to be contained in the option.
+.Pp
+Option types of
+.Li 0
+and
+.Li 1
+are reserved for the
+.Li Pad1
+and
+.Li PadN
+options.
+All other values from 2 through 255 may be used by applications.
+.Pp
+The length of the option data is contained in an 8-bit value and so
+may contain any value from 0 through 255.
+.Pp
+The
+.Fa align
+parameter must have a value of 1, 2, 4, or 8 and cannot exceed the
+value of
+.Fa len .
+The alignment values represent no alignment, 16-bit, 32-bit and 64-bit
+alignments respectively.
+.\"
+.Ss inet6_opt_finish
+The
+.Fn inet6_opt_finish
+calculates the final padding necessary to make the extension header a
+multiple of 8 bytes, as required by the IPv6 extension header
+specification, and returns the extension header's updated total
+length.
+The
+.Fa offset
+argument should be the length returned by
+.Fn inet6_opt_init
+or
+.Fn inet6_opt_append .
+When
+.Fa extbuf
+is not
+.Dv NULL
+the function also sets up the appropriate padding bytes by inserting a
+Pad1 or PadN option of the proper length.
+.Pp
+If the extension header is too small to contain the proper padding
+then an error of \-1 is returned to the caller.
+.\"
+.Ss inet6_opt_set_val
+The
+.Fn inet6_opt_set_val
+function inserts data items of various sizes into the data portion of
+the option.
+The
+.Fa databuf
+argument is a pointer to memory that was returned by the
+.Fn inet6_opt_append
+call and the
+.Fa offset
+argument specifies where the option should be placed in the
+data buffer.
+The
+.Fa val
+argument points to an area of memory containing the data to be
+inserted into the extension header, and the
+.Fa vallen
+argument indicates how much data to copy.
+.Pp
+The caller should ensure that each field is aligned on its natural
+boundaries as described in Appendix B of RFC 2460.
+.Pp
+The function returns the offset for the next field which is calculated as
+.Fa offset
++
+.Fa vallen
+and is used when composing options with multiple fields.
+.\"
+.Ss inet6_opt_next
+The
+.Fn inet6_opt_next
+function parses received extension headers.
+The
+.Fa extbuf
+and
+.Fa extlen
+arguments specify the location and length of the extension header
+being parsed.
+The
+.Fa offset
+argument should either be zero, for the first option, or the length value
+returned by a previous call to
+.Fn inet6_opt_next
+or
+.Fn inet6_opt_find .
+The return value specifies the position where to continue scanning the
+extension buffer.
+The option is returned in the arguments
+.Fa typep , lenp ,
+and
+.Fa databufp .
+.Fa typep , lenp ,
+and
+.Fa databufp
+point to the 8-bit option type, the 8-bit option length and the option
+data respectively.
+This function does not return any PAD1 or PADN options.
+When an error occurs or there are no more options the return
+value is \-1.
+.\"
+.Ss inet6_opt_find
+The
+.Fn inet6_opt_find
+function searches the extension buffer for a particular option type,
+passed in through the
+.Fa type
+argument.
+If the option is found then the
+.Fa lenp
+and
+.Fa databufp
+arguments are updated to point to the option's length and data
+respectively.
+.Fa extbuf
+and
+.Fa extlen
+must point to a valid extension buffer and give its length.
+The
+.Fa offset
+argument can be used to search from a location anywhere in the
+extension header.
+.Ss inet6_opt_get_val
+The
+.Fn inet6_opt_get_val
+function extracts data items of various sizes in the data portion of
+the option.
+The
+.Fa databuf
+is a pointer returned by the
+.Fn inet6_opt_next
+or
+.Fn inet6_opt_find
+functions.
+The
+.Fa val
+argument points to where the data will be extracted.
+The
+.Fa offset
+argument specifies from where in the data portion of the option the
+value should be extracted; the first byte of option data is specified
+by an offset of zero.
+.Pp
+It is expected that each field is aligned on its natural boundaries as
+described in Appendix B of RFC 2460.
+.Pp
+The function returns the offset for the next field
+by calculating
+.Fa offset
++
+.Fa vallen
+which can be used when extracting option content with multiple fields.
+Robust receivers must verify alignment before calling this function.
+.\"
+.Sh EXAMPLES
+RFC 3542 gives comprehensive examples in Section 23.
+KAME also provides examples in the
+.Pa advapitest
+directory of its kit.
+.\"
+.Sh DIAGNOSTICS
+All the functions return
+\-1
+on an error.
+.\"
+.Sh SEE ALSO
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%A E. Nordmark
+.%A T. Jinmei
+.%T "Advanced Sockets API for IPv6"
+.%N RFC 3542
+.%D October 2002
+.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
+.Pq RFC 3542 .
+.Sh HISTORY
+The implementation first appeared in KAME advanced networking kit.
+.\"
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..8aa79a6d0b
--- /dev/null
+++ b/src/lib/libc/net/inet6_option_space.3
@@ -0,0 +1,444 @@
+.\"     $OpenBSD: inet6_option_space.3,v 1.21 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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
+.\"
+Note:
+RFC 2292 has been superseded by RFC 3542.
+The use of functions described in this page is deprecated.
+See
+.Xr inet6_opt_init 3 .
+.Pp
+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_rth_space.3 b/src/lib/libc/net/inet6_rth_space.3
new file mode 100644
index 0000000000..326521def7
--- /dev/null
+++ b/src/lib/libc/net/inet6_rth_space.3
@@ -0,0 +1,219 @@
+.\"     $OpenBSD: inet6_rth_space.3,v 1.3 2007/05/31 19:19:30 jmc Exp $
+.\"     $KAME: inet6_rth_space.3,v 1.7 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 $Mdocdate: May 31 2007 $
+.Dt INET6_RTH_SPACE 3
+.Os
+.\"
+.Sh NAME
+.Nm inet6_rth_space ,
+.Nm inet6_rth_init ,
+.Nm inet6_rth_add ,
+.Nm inet6_rth_reverse ,
+.Nm inet6_rth_segments ,
+.Nm inet6_rth_getaddr
+.Nd IPv6 Routing Header Options manipulation
+.\"
+.Sh SYNOPSIS
+.In netinet/in.h
+.Ft socklen_t
+.Fn inet6_rth_space "int" "int"
+.Ft "void *"
+.Fn inet6_rth_init "void *" "socklen_t" "int" "int"
+.Ft int
+.Fn inet6_rth_add "void *" "const struct in6_addr *"
+.Ft int
+.Fn inet6_rth_reverse "const void *" "void *"
+.Ft int
+.Fn inet6_rth_segments "const void *"
+.Ft "struct in6_addr *"
+.Fn inet6_rth_getaddr "const void *" "int"
+.\"
+.Sh DESCRIPTION
+The IPv6 Advanced API, RFC 3542, defines the functions that an
+application calls to build and examine IPv6 Routing headers.
+Routing headers are used to perform source routing in IPv6 networks.
+The RFC uses the word
+.Dq segments
+to describe addresses and that is the term used here as well.
+All of the functions are defined in the header file
+.Aq Pa netinet/in.h .
+The functions described in this manual page all operate
+on routing header structures which are defined in
+.Aq Pa netinet/ip6.h
+but which should not need to be modified outside the use of this API.
+The size and shape of the route header structures may change, so using
+the APIs is a more portable, long term, solution.
+.Pp
+The functions in the API are split into two groups, those that build a
+routing header and those that parse a received routing header.
+The builder functions are described first, followed by the parser functions.
+.Ss inet6_rth_space
+The
+.Fn inet6_rth_space
+function returns the number of bytes required to hold a Routing Header
+of the type, specified in the
+.Fa type
+argument and containing the number of addresses specified in the
+.Fa segments
+argument.
+When the type is
+.Dv IPV6_RTHDR_TYPE_0
+the number of segments must be from 0 through 127.
+The return value from this function is the number of bytes required to
+store the routing header.
+If the value 0 is returned then either the
+route header type was not recognized or another error occurred.
+.Ss inet6_rth_init
+The
+.Fn inet6_rth_init
+function initializes the pre-allocated buffer pointed to by
+.Fa bp
+to contain a routing header of the specified type.
+The
+.Fa bp_len
+argument is used to verify that the buffer is large enough.
+The caller must allocate the buffer pointed to by bp.
+The necessary buffer size should be determined by calling
+.Fn inet6_rth_space
+described in the previous sections.
+.Pp
+The
+.Fn inet6_rth_init
+function returns a pointer to
+.Fa bp
+on success and
+.Dv NULL
+when there is an error.
+.Ss inet6_rth_add
+The
+.Fn inet6_rth_add
+function adds the IPv6 address pointed to by
+.Fa addr
+to the end of the routing header being constructed.
+.Pp
+A successful addition results in the function returning 0, otherwise
+\-1 is returned.
+.Ss inet6_rth_reverse
+The
+.Fn inet6_rth_reverse
+function takes a routing header, pointed to by the
+argument
+.Fa in ,
+and writes a new routing header into the argument pointed to by
+.Fa out .
+The routing header at that sends datagrams along the reverse of that
+route.
+Both arguments are allowed to point to the same buffer meaning
+that the reversal can occur in place.
+.Pp
+The return value of the function is 0 on success, or \-1 when
+there is an error.
+.\"
+.Pp
+The next set of functions operate on a routing header that the
+application wants to parse.
+In the usual case such a routing header
+is received from the network, although these functions can also be
+used with routing headers that the application itself created.
+.Ss inet6_rth_segments
+The
+.Fn inet6_rth_segments
+function returns the number of segments contained in the
+routing header pointed to by
+.Fa bp .
+The return value is the number of segments contained in the routing
+header, or \-1 if an error occurred.
+It is not an error for 0 to be
+returned as a routing header may contain 0 segments.
+.\"
+.Ss inet6_rth_getaddr
+The
+.Fn inet6_rth_getaddr
+function is used to retrieve a single address from a routing header.
+The
+.Fa index
+is the location in the routing header from which the application wants
+to retrieve an address.
+The
+.Fa index
+parameter must have a value between 0 and one less than the number of
+segments present in the routing header.
+The
+.Fn inet6_rth_segments
+function, described in the last section, should be used to determine
+the total number of segments in the routing header.
+The
+.Fn inet6_rth_getaddr
+function returns a pointer to an IPv6 address on success or
+.Dv NULL
+when an error has occurred.
+.\"
+.Sh EXAMPLES
+RFC 3542 gives extensive examples in Section 21, Appendix B.
+KAME also provides examples in the advapitest directory of its kit.
+.\"
+.Sh DIAGNOSTICS
+The
+.Fn inet6_rth_space
+and
+.Fn inet6_rth_getaddr
+functions return 0 on errors.
+.Pp
+The
+.Fn inet6_rthdr_init
+function returns
+.Dv NULL
+on error.
+The
+.Fn inet6_rth_add
+and
+.Fn inet6_rth_reverse
+functions return 0 on success, or \-1 upon an error.
+.\"
+.Sh SEE ALSO
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%A E. Nordmark
+.%A T. Jinmei
+.%T "Advanced Sockets API for IPv6"
+.%N RFC 3542
+.%D May 2003
+.Re
+.Rs
+.%A S. Deering
+.%A R. Hinden
+.%T "Internet Protocol, Version 6 (IPv6) Specification"
+.%N RFC 2460
+.%D December 1998
+.Re
+.Sh HISTORY
+The implementation first appeared in 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..3287bfe009
--- /dev/null
+++ b/src/lib/libc/net/inet6_rthdr_space.3
@@ -0,0 +1,314 @@
+.\"     $OpenBSD: inet6_rthdr_space.3,v 1.20 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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
+Note:
+RFC 2292 has been superseded by RFC 3542.
+The use of functions described in this page is deprecated.
+See
+.Xr inet6_rth_space 3 .
+.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
index b5b9d8302f..c962a03382 100644
--- a/src/lib/libc/net/inet_addr.c
+++ b/src/lib/libc/net/inet_addr.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: inet_addr.c,v 1.5 1995/02/25 06:20:41 cgd Exp $        */
+/*      $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.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -31,16 +29,29 @@
  * 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--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_addr.c 8.1 (Berkeley) 6/17/93";
-#else
-static char rcsid[] = "$NetBSD: inet_addr.c,v 1.5 1995/02/25 06:20:41 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -50,9 +61,8 @@ static char rcsid[] = "$NetBSD: inet_addr.c,v 1.5 1995/02/25 06:20:41 cgd Exp $"
  * Ascii internet address interpretation routine.
  * The value returned is in network order.
  */
-u_long
-inet_addr(cp)
-        register const char *cp;
+in_addr_t
+inet_addr(const char *cp)
 {
         struct in_addr val;
 
@@ -69,60 +79,60 @@ inet_addr(cp)
  * cannot distinguish between failure and a local broadcast address.
  */
 int
-inet_aton(cp, addr)
-        register const char *cp;
-        struct in_addr *addr;
+inet_aton(const char *cp, struct in_addr *addr)
 {
-        register u_long val;
-        register int base, n;
-        register char c;
+        in_addr_t val;
+        int base, n;
+        char c;
         u_int parts[4];
-        register u_int *pp = parts;
+        u_int *pp = parts;
 
+        c = *cp;
         for (;;) {
                 /*
                  * Collect number up to ``.''.
                  * Values are specified as for C:
-                 * 0x=hex, 0=octal, other=decimal.
+                 * 0x=hex, 0=octal, isdigit=decimal.
                  */
+                if (!isdigit(c))
+                        return (0);
                 val = 0; base = 10;
-                if (*cp == '0') {
-                        if (*++cp == 'x' || *cp == 'X')
-                                base = 16, cp++;
+                if (c == '0') {
+                        c = *++cp;
+                        if (c == 'x' || c == 'X')
+                                base = 16, c = *++cp;
                         else
                                 base = 8;
                 }
-                while ((c = *cp) != '\0') {
+                for (;;) {
                         if (isascii(c) && isdigit(c)) {
                                 val = (val * base) + (c - '0');
-                                cp++;
-                                continue;
-                        }
-                        if (base == 16 && isascii(c) && isxdigit(c)) {
-                                val = (val << 4) + 
+                                c = *++cp;
+                        } else if (base == 16 && isascii(c) && isxdigit(c)) {
+                                val = (val << 4) |
                                         (c + 10 - (islower(c) ? 'a' : 'A'));
-                                cp++;
-                                continue;
-                        }
-                        break;
+                                c = *++cp;
+                        } else
+                                break;
                 }
-                if (*cp == '.') {
+                if (c == '.') {
                         /*
                          * Internet format:
                          *      a.b.c.d
-                         *      a.b.c   (with c treated as 16-bits)
+                         *      a.b.c   (with c treated as 16 bits)
                          *      a.b     (with b treated as 24 bits)
                          */
-                        if (pp >= parts + 3 || val > 0xff)
+                        if (pp >= parts + 3)
                                 return (0);
-                        *pp++ = val, cp++;
+                        *pp++ = val;
+                        c = *++cp;
                 } else
                         break;
         }
         /*
          * Check for trailing characters.
          */
-        if (*cp && (!isascii(*cp) || !isspace(*cp)))
+        if (c != '\0' && (!isascii(c) || !isspace(c)))
                 return (0);
         /*
          * Concoct the address according to
@@ -131,23 +141,26 @@ inet_aton(cp, addr)
         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)
+                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)
+                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)
+                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;
diff --git a/src/lib/libc/net/inet_lnaof.c b/src/lib/libc/net/inet_lnaof.c
index ce1257bf68..b1a58cd2c1 100644
--- a/src/lib/libc/net/inet_lnaof.c
+++ b/src/lib/libc/net/inet_lnaof.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: inet_lnaof.c,v 1.4 1995/02/25 06:20:42 cgd Exp $       */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_lnaof.c        8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: inet_lnaof.c,v 1.4 1995/02/25 06:20:42 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -50,11 +37,10 @@ static char rcsid[] = "$NetBSD: inet_lnaof.c,v 1.4 1995/02/25 06:20:42 cgd Exp $
  * internet address; handles class a/b/c network
  * number formats.
  */
-u_long
-inet_lnaof(in)
-        struct in_addr in;
+in_addr_t
+inet_lnaof(struct in_addr in)
 {
-        register u_long i = ntohl(in.s_addr);
+        in_addr_t i = ntohl(in.s_addr);
 
         if (IN_CLASSA(i))
                 return ((i)&IN_CLASSA_HOST);
diff --git a/src/lib/libc/net/inet_makeaddr.c b/src/lib/libc/net/inet_makeaddr.c
index 84d366e03a..87d9325231 100644
--- a/src/lib/libc/net/inet_makeaddr.c
+++ b/src/lib/libc/net/inet_makeaddr.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: inet_makeaddr.c,v 1.4 1995/02/25 06:20:42 cgd Exp $    */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_makeaddr.c     8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: inet_makeaddr.c,v 1.4 1995/02/25 06:20:42 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -50,10 +37,9 @@ static char rcsid[] = "$NetBSD: inet_makeaddr.c,v 1.4 1995/02/25 06:20:42 cgd Ex
  * building addresses stored in the ifnet structure.
  */
 struct in_addr
-inet_makeaddr(net, host)
-        u_long net, host;
+inet_makeaddr(in_addr_t net, in_addr_t host)
 {
-        u_long addr;
+        in_addr_t addr;
 
         if (net < 128)
                 addr = (net << IN_CLASSA_NSHIFT) | (host & IN_CLASSA_HOST);
diff --git a/src/lib/libc/net/inet_net.3 b/src/lib/libc/net/inet_net.3
new file mode 100644
index 0000000000..648d82c780
--- /dev/null
+++ b/src/lib/libc/net/inet_net.3
@@ -0,0 +1,176 @@
+.\"     $OpenBSD: inet_net.3,v 1.14 2008/06/26 05:42:05 ray 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.
+.\"
+.\" 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 $Mdocdate: June 26 2008 $
+.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..3105c33b43
--- /dev/null
+++ b/src/lib/libc/net/inet_net_pton.c
@@ -0,0 +1,191 @@
+/*      $OpenBSD: inet_net_pton.c,v 1.6 2008/09/01 09:40:43 markus 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;
+                        if (bits > 32)
+                                goto emsgsize;
+                } while ((ch = *src++) != '\0' &&
+                         isascii(ch) && isdigit(ch));
+                if (ch != '\0')
+                        goto enoent;
+        }
+
+        /* 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
index 02f52ca318..2f468c3aca 100644
--- a/src/lib/libc/net/inet_netof.c
+++ b/src/lib/libc/net/inet_netof.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: inet_netof.c,v 1.4 1995/02/25 06:20:43 cgd Exp $       */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_netof.c        8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: inet_netof.c,v 1.4 1995/02/25 06:20:43 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -49,11 +36,10 @@ static char rcsid[] = "$NetBSD: inet_netof.c,v 1.4 1995/02/25 06:20:43 cgd Exp $
  * Return the network number from an internet
  * address; handles class a/b/c network #'s.
  */
-u_long
-inet_netof(in)
-        struct in_addr in;
+in_addr_t
+inet_netof(struct in_addr in)
 {
-        register u_long i = ntohl(in.s_addr);
+        in_addr_t i = ntohl(in.s_addr);
 
         if (IN_CLASSA(i))
                 return (((i)&IN_CLASSA_NET) >> IN_CLASSA_NSHIFT);
diff --git a/src/lib/libc/net/inet_network.c b/src/lib/libc/net/inet_network.c
index 35105fa75a..8b26ba8ff9 100644
--- a/src/lib/libc/net/inet_network.c
+++ b/src/lib/libc/net/inet_network.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: inet_network.c,v 1.4 1995/02/25 06:20:45 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_network.c      8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: inet_network.c,v 1.4 1995/02/25 06:20:45 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -51,14 +38,13 @@ static char rcsid[] = "$NetBSD: inet_network.c,v 1.4 1995/02/25 06:20:45 cgd Exp
  * The library routines call this routine to interpret
  * network numbers.
  */
-u_long
-inet_network(cp)
-        register const char *cp;
+in_addr_t
+inet_network(const char *cp)
 {
-        register u_long val, base, n;
-        register char c;
-        u_long parts[4], *pp = parts;
-        register int i;
+        in_addr_t val, base, n;
+        char c;
+        in_addr_t parts[4], *pp = parts;
+        int i;
 
 again:
         val = 0; base = 10;
@@ -66,7 +52,7 @@ again:
                 base = 8, cp++;
         if (*cp == 'x' || *cp == 'X')
                 base = 16, cp++;
-        while (c = *cp) {
+        while ((c = *cp)) {
                 if (isdigit(c)) {
                         val = (val * base) + (c - '0');
                         cp++;
@@ -80,7 +66,7 @@ again:
                 break;
         }
         if (*cp == '.') {
-                if (pp >= parts + 4)
+                if (pp >= parts + 3)
                         return (INADDR_NONE);
                 *pp++ = val, cp++;
                 goto again;
@@ -89,11 +75,10 @@ again:
                 return (INADDR_NONE);
         *pp++ = val;
         n = pp - parts;
-        if (n > 4)
-                return (INADDR_NONE);
-        for (val = 0, i = 0; i < n; i++) {
+        for (val = 0, i = 0; i < 4; i++) {
                 val <<= 8;
-                val |= parts[i] & 0xff;
+                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
index 2da0ab00ff..ff5d93ded2 100644
--- a/src/lib/libc/net/inet_ntoa.c
+++ b/src/lib/libc/net/inet_ntoa.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: inet_ntoa.c,v 1.4 1995/02/25 06:20:46 cgd Exp $        */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)inet_ntoa.c 8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: inet_ntoa.c,v 1.4 1995/02/25 06:20:46 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 /*
  * Convert network-format internet address
  * to base 256 d.d.d.d representation.
@@ -51,15 +38,14 @@ static char rcsid[] = "$NetBSD: inet_ntoa.c,v 1.4 1995/02/25 06:20:46 cgd Exp $"
 #include <stdio.h>
 
 char *
-inet_ntoa(in)
-        struct in_addr in;
+inet_ntoa(struct in_addr in)
 {
         static char b[18];
-        register char *p;
+        char *p;
 
         p = (char *)&in;
 #define UC(b)   (((int)b)&0xff)
         (void)snprintf(b, sizeof(b),
-            "%d.%d.%d.%d", UC(p[0]), UC(p[1]), UC(p[2]), UC(p[3]));
+            "%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..9deb352e24
--- /dev/null
+++ b/src/lib/libc/net/inet_ntop.c
@@ -0,0 +1,195 @@
+/*      $OpenBSD: inet_ntop.c,v 1.8 2008/12/09 19:38:38 otto 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, socklen_t size)
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_ntop4(src, dst, (size_t)size));
+        case AF_INET6:
+                return (inet_ntop6(src, dst, (size_t)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..7e521c3286
--- /dev/null
+++ b/src/lib/libc/net/inet_pton.c
@@ -0,0 +1,213 @@
+/*      $OpenBSD: inet_pton.c,v 1.8 2010/05/06 15:47:14 claudio 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:
+ *      does not touch `dst' unless it's returning 1.
+ * 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, count_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 = count_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) {
+                        if (count_xdigit >= 4)
+                                return (0);
+                        val <<= 4;
+                        val |= (pch - xdigits);
+                        if (val > 0xffff)
+                                return (0);
+                        saw_xdigit = 1;
+                        count_xdigit++;
+                        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;
+                        count_xdigit = 0;
+                        val = 0;
+                        continue;
+                }
+                if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
+                    inet_pton4(curtok, tp) > 0) {
+                        tp += INADDRSZ;
+                        saw_xdigit = 0;
+                        count_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;
+
+                if (tp == endp)
+                        return (0);
+                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..b215f9ac3e
--- /dev/null
+++ b/src/lib/libc/net/ip6opt.c
@@ -0,0 +1,596 @@
+/*      $OpenBSD: ip6opt.c,v 1.4 2006/12/09 01:12:28 itojun Exp $       */
+/*      $KAME: ip6opt.c,v 1.18 2005/06/15 07:11:35 keiichi 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 0
+        if (typep[0] > 255)
+                return (-1);
+#endif
+
+        /*
+         * 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;
+        }
+}
+
+/*
+ * The following functions are defined in RFC3542, which is a successor
+ * of RFC2292.
+ */
+
+int
+inet6_opt_init(void *extbuf, socklen_t extlen)
+{
+        struct ip6_ext *ext = (struct ip6_ext *)extbuf;
+
+        if (extlen < 0 || (extlen % 8))
+                return (-1);
+
+        if (ext) {
+                if (extlen == 0)
+                        return (-1);
+                ext->ip6e_len = (extlen >> 3) - 1;
+        }
+
+        return (2);             /* sizeof the next and the length fields */
+}
+
+int
+inet6_opt_append(void *extbuf, socklen_t extlen, int offset, u_int8_t type,
+                 socklen_t len, u_int8_t align, void **databufp)
+{
+        int currentlen = offset, padlen = 0;
+
+        /*
+         * The option type must have a value from 2 to 255, inclusive.
+         * (0 and 1 are reserved for the Pad1 and PadN options, respectively.)
+         */
+#if 0 /* always false */
+        if (type < 2 || type > 255)
+#else
+        if (type < 2)
+#endif
+                return (-1);
+
+        /*
+         * The option data length must have a value between 0 and 255,
+         * inclusive, and is the length of the option data that follows.
+         */
+        if (len < 0 || len > 255)
+                return (-1);
+
+        /*
+         * The align parameter must have a value of 1, 2, 4, or 8.
+         * The align value can not exceed the value of len.
+         */
+        if (align != 1 && align != 2 && align != 4 && align != 8)
+                return (-1);
+        if (align > len)
+                return (-1);
+
+        /* Calculate the padding length. */
+        currentlen += 2 + len;  /* 2 means "type + len" */
+        if (currentlen % align)
+                padlen = align - (currentlen % align);
+
+        /* The option must fit in the extension header buffer. */
+        currentlen += padlen;
+        if (extlen &&           /* XXX: right? */
+            currentlen > extlen)
+                return (-1);
+
+        if (extbuf) {
+                u_int8_t *optp = (u_int8_t *)extbuf + offset;
+
+                if (padlen == 1) {
+                        /* insert a Pad1 option */
+                        *optp = IP6OPT_PAD1;
+                        optp++;
+                } else if (padlen > 0) {
+                        /* insert a PadN option for alignment */
+                        *optp++ = IP6OPT_PADN;
+                        *optp++ = padlen - 2;
+                        memset(optp, 0, padlen - 2);
+                        optp += (padlen - 2);
+                }
+
+                *optp++ = type;
+                *optp++ = len;
+
+                *databufp = optp;
+        }
+
+        return (currentlen);
+}
+
+int
+inet6_opt_finish(void *extbuf, socklen_t extlen, int offset)
+{
+        int updatelen = offset > 0 ? (1 + ((offset - 1) | 7)) : 0;;
+
+        if (extbuf) {
+                u_int8_t *padp;
+                int padlen = updatelen - offset;
+
+                if (updatelen > extlen)
+                        return (-1);
+
+                padp = (u_int8_t *)extbuf + offset;
+                if (padlen == 1)
+                        *padp = IP6OPT_PAD1;
+                else if (padlen > 0) {
+                        *padp++ = IP6OPT_PADN;
+                        *padp++ = (padlen - 2);
+                        memset(padp, 0, padlen - 2);
+                }
+        }
+
+        return (updatelen);
+}
+
+int
+inet6_opt_set_val(void *databuf, int offset, void *val, socklen_t vallen)
+{
+
+        memcpy((u_int8_t *)databuf + offset, val, vallen);
+        return (offset + vallen);
+}
+
+int
+inet6_opt_next(void *extbuf, socklen_t extlen, int offset, u_int8_t *typep,
+               socklen_t *lenp, void **databufp)
+{
+        u_int8_t *optp, *lim;
+        int optlen;
+
+        /* Validate extlen. XXX: is the variable really necessary?? */
+        if (extlen == 0 || (extlen % 8))
+                return (-1);
+        lim = (u_int8_t *)extbuf + extlen;
+
+        /*
+         * If this is the first time this function called for this options
+         * header, simply return the 1st option.
+         * Otherwise, search the option list for the next option.
+         */
+        if (offset == 0)
+                optp = (u_int8_t *)((struct ip6_hbh *)extbuf + 1);
+        else
+                optp = (u_int8_t *)extbuf + offset;
+
+        /* Find the next option skipping any padding options. */
+        while (optp < lim) {
+                switch(*optp) {
+                case IP6OPT_PAD1:
+                        optp++;
+                        break;
+                case IP6OPT_PADN:
+                        if ((optlen = ip6optlen(optp, lim)) == 0)
+                                goto optend;
+                        optp += optlen;
+                        break;
+                default:        /* found */
+                        if ((optlen = ip6optlen(optp, lim)) == 0)
+                                goto optend;
+                        *typep = *optp;
+                        *lenp = optlen - 2;
+                        *databufp = optp + 2;
+                        return (optp + optlen - (u_int8_t *)extbuf);
+                }
+        }
+
+  optend:
+        *databufp = NULL; /* for safety */
+        return (-1);
+}
+
+int
+inet6_opt_find(void *extbuf, socklen_t extlen, int offset, u_int8_t type,
+               socklen_t *lenp, void **databufp)
+{
+        u_int8_t *optp, *lim;
+        int optlen;
+
+        /* Validate extlen. XXX: is the variable really necessary?? */
+        if (extlen == 0 || (extlen % 8))
+                return (-1);
+        lim = (u_int8_t *)extbuf + extlen;
+
+        /*
+         * If this is the first time this function called for this options
+         * header, simply return the 1st option.
+         * Otherwise, search the option list for the next option.
+         */
+        if (offset == 0)
+                optp = (u_int8_t *)((struct ip6_hbh *)extbuf + 1);
+        else
+                optp = (u_int8_t *)extbuf + offset;
+
+        /* Find the specified option */
+        while (optp < lim) {
+                if ((optlen = ip6optlen(optp, lim)) == 0)
+                        goto optend;
+
+                if (*optp == type) { /* found */
+                        *lenp = optlen - 2;
+                        *databufp = optp + 2;
+                        return (optp + optlen - (u_int8_t *)extbuf);
+                }
+
+                optp += optlen;
+        }
+
+  optend:
+        *databufp = NULL; /* for safety */
+        return (-1);
+}
+
+int
+inet6_opt_get_val(void *databuf, int offset, void *val, socklen_t vallen)
+{
+
+        /* we can't assume alignment here */
+        memcpy(val, (u_int8_t *)databuf + offset, vallen);
+
+        return (offset + vallen);
+}
diff --git a/src/lib/libc/net/iso_addr.3 b/src/lib/libc/net/iso_addr.3
deleted file mode 100644
index 95c136e5fc..0000000000
--- a/src/lib/libc/net/iso_addr.3
+++ /dev/null
@@ -1,112 +0,0 @@
-.\"     $NetBSD: iso_addr.3,v 1.2 1995/02/25 06:20:46 cgd Exp $
-.\"
-.\" Copyright (c) 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. 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.
-.\"
-.\"     @(#)iso_addr.3  8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
-.Dt ISO_ADDR 3
-.Os
-.Sh NAME
-.Nm iso_addr ,
-.Nm iso_ntoa
-.Nd "elementary network address conversion routines for Open System Interconnection
-.Sh SYNOPSIS
-.Fd #include <sys/types.h>
-.Fd #include <netiso/iso.h>
-.Ft struct iso_addr *
-.Fn iso_addr "char *cp"
-.Ft char *
-.Fn iso_ntoa "struct iso_addr *isoa"
-.Sh DESCRIPTION
-The routine
-.Fn iso_addr
-interprets character strings representing
-.Tn OSI
-addresses, returning binary information suitable
-for use in system calls.
-The routine
-.Fn iso_ntoa
-takes
-.Tn OSI
-addresses and returns
-.Tn ASCII
-strings representing NSAPs (network service
-access points) in a
-notation inverse to that accepted by 
-.Fn iso_addr .
-.Pp
-Unfortunately, no universal standard exists for representing
-.Tn OSI
-network addresses.
-.Pp
-The format employed by
-.Fn iso_addr
-is a sequence of hexadecimal
-.Dq digits
-(optionally separated by periods),
-of the form:
-.Bd -filled -offset indent
-<hex digits>.<hex digits>.<hex digits>
-.Ed
-.Pp
-Each pair of hexadecimal digits represents a byte
-with the leading digit indicating the higher-ordered bits.
-A period following an even number of bytes has no
-effect (but may be used to increase legibility).
-A period following an odd number of bytes has the
-effect of causing the byte of address being translated
-to have its higher order bits filled with zeros.
-.Sh RETURN VALUES
-.Fn iso_ntoa
-always returns a null terminated string.
-.Fn iso_addr
-always returns a pointer to a struct iso_addr.
-(See
-.Sx BUGS . )
-.Sh SEE ALSO
-.Xr iso 4
-.Sh HISTORY
-The
-.Fn iso_addr
-and
-.Fn iso_ntoa
-functions appeared in 
-.Bx 4.3 Reno .
-.Sh BUGS
-The returned values
-reside in a static memory area.
-.Pp
-The function
-.Fn iso_addr
-should diagnose improperly formed input, and there should be an unambiguous
-way to recognize this.
diff --git a/src/lib/libc/net/iso_addr.c b/src/lib/libc/net/iso_addr.c
deleted file mode 100644
index c26ec1a64a..0000000000
--- a/src/lib/libc/net/iso_addr.c
+++ /dev/null
@@ -1,125 +0,0 @@
-/*      $NetBSD: iso_addr.c,v 1.4 1995/02/25 06:20:47 cgd 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)iso_addr.c  8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: iso_addr.c,v 1.4 1995/02/25 06:20:47 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
-#include <sys/types.h>
-#include <netiso/iso.h>
-#include <string.h>
-
-/* States*/
-#define VIRGIN  0
-#define GOTONE  1
-#define GOTTWO  2
-/* Inputs */
-#define DIGIT   (4*0)
-#define END     (4*1)
-#define DELIM   (4*2)
-
-struct iso_addr *
-iso_addr(addr)
-        register const char *addr;
-{
-        static struct iso_addr out_addr;
-        register char *cp = out_addr.isoa_genaddr;
-        char *cplim = cp + sizeof(out_addr.isoa_genaddr);
-        register int byte = 0, state = VIRGIN, new;
-
-        bzero((char *)&out_addr, sizeof(out_addr));
-        do {
-                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
-                        state |= DELIM;
-                addr++;
-                switch (state /* | INPUT */) {
-                case GOTTWO | DIGIT:
-                        *cp++ = byte; /*FALLTHROUGH*/
-                case VIRGIN | DIGIT:
-                        state = GOTONE; byte = new; continue;
-                case GOTONE | DIGIT:
-                        state = GOTTWO; byte = new + (byte << 4); continue;
-                default: /* | DELIM */
-                        state = VIRGIN; *cp++ = byte; byte = 0; continue;
-                case GOTONE | END:
-                case GOTTWO | END:
-                        *cp++ = byte; /* FALLTHROUGH */
-                case VIRGIN | END:
-                        break;
-                }
-                break;
-        } while (cp < cplim); 
-        out_addr.isoa_len = cp - out_addr.isoa_genaddr;
-        return (&out_addr);
-}
-static char hexlist[] = "0123456789abcdef";
-
-char *
-iso_ntoa(isoa)
-        const struct iso_addr *isoa;
-{
-        static char obuf[64];
-        register char *out = obuf; 
-        register int i;
-        register u_char *in = (u_char *)isoa->isoa_genaddr;
-        u_char *inlim = in + isoa->isoa_len;
-
-        out[1] = 0;
-        while (in < inlim) {
-                i = *in++;
-                *out++ = '.';
-                if (i > 0xf) {
-                        out[1] = hexlist[i & 0xf];
-                        i >>= 4;
-                        out[0] = hexlist[i];
-                        out += 2;
-                } else
-                        *out++ = hexlist[i];
-        }
-        *out = 0;
-        return(obuf + 1);
-}
diff --git a/src/lib/libc/net/linkaddr.3 b/src/lib/libc/net/link_addr.3
index 1a2af9b30d..e6210ef2d0 100644
--- a/src/lib/libc/net/linkaddr.3
+++ b/src/lib/libc/net/link_addr.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: linkaddr.3,v 1.2 1995/02/25 06:20:48 cgd Exp $
+.\"     $OpenBSD: link_addr.3,v 1.12 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -14,11 +14,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -34,11 +30,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)linkaddr.3  8.1 (Berkeley) 7/28/93
-.\"
-.Dd July 28, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt LINK_ADDR 3
-.Os BSD 4.4
+.Os
 .Sh NAME
 .Nm link_addr ,
 .Nm link_ntoa
@@ -52,12 +46,11 @@
 .Ft char *
 .Fn link_ntoa "const struct sockaddr_dl *sdl"
 .Sh DESCRIPTION
-The routine
+The
 .Fn link_addr
-interprets character strings representing
+function interprets character strings representing
 link-level addresses, returning binary information suitable
 for use in system calls.
-The routine
 .Fn link_ntoa
 takes
 a link-level
@@ -75,9 +68,9 @@ the string
 .Fa addr
 may contain
 an optional network interface identifier of the form
-.Dq "name unit-number" ,
+.Dq name unit-number ,
 suitable for the first argument to
-.Xr ifconfig 4 ,
+.Xr ifconfig 8 ,
 followed in all cases by a colon and
 an interface address in the form of
 groups of hexadecimal digits
@@ -93,26 +86,27 @@ low order bytes through high order bytes.
 .\" .Pp
 Thus
 .Li le0:8.0.9.13.d.30
-represents an ethernet address
-to be transmitted on the first Lance ethernet interface.
+represents an Ethernet address
+to be transmitted on the first Lance Ethernet interface.
 .Sh RETURN VALUES
 .Fn link_ntoa
-always returns a null terminated string.
+always returns a NUL-terminated string.
 .Fn link_addr
 has no return value.
 (See
 .Sx BUGS . )
 .Sh SEE ALSO
-.Xr iso 4 ,
+.Xr ifconfig 8
 .Sh HISTORY
 The
 .Fn link_addr
 and
 .Fn link_ntoa
-functions appeared in 
-.Bx 4.3 Reno  .
+functions appeared in
+.Bx 4.3 Reno .
 .Sh BUGS
-The returned values for link_ntoa
+The returned values for
+.Fn link_ntoa
 reside in a static memory area.
 .Pp
 The function
@@ -121,7 +115,7 @@ should diagnose improperly formed input, and there should be an unambiguous
 way to recognize this.
 .Pp
 If the
-.Va sdl_len
+.Fa sdl_len
 field of the link socket address
 .Fa sdl
 is 0,
diff --git a/src/lib/libc/net/linkaddr.c b/src/lib/libc/net/linkaddr.c
index 19a0de3abd..ac96f3acdf 100644
--- a/src/lib/libc/net/linkaddr.c
+++ b/src/lib/libc/net/linkaddr.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: linkaddr.c,v 1.5 1995/02/25 06:20:49 cgd Exp $ */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)linkaddr.c  8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: linkaddr.c,v 1.5 1995/02/25 06:20:49 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <net/if_dl.h>
@@ -58,13 +45,11 @@ static char rcsid[] = "$NetBSD: linkaddr.c,v 1.5 1995/02/25 06:20:49 cgd Exp $";
 #define LETTER  (4*3)
 
 void
-link_addr(addr, sdl)
-        register const char *addr;
-        register struct sockaddr_dl *sdl;
+link_addr(const char *addr, struct sockaddr_dl *sdl)
 {
-        register char *cp = sdl->sdl_data;
+        char *cp = sdl->sdl_data;
         char *cplim = sdl->sdl_len + (char *)sdl;
-        register int byte = 0, state = NAMING, new;
+        int byte = 0, state = NAMING, new;
 
         bzero((char *)&sdl->sdl_family, sdl->sdl_len - 1);
         sdl->sdl_family = AF_LINK;
@@ -129,13 +114,12 @@ link_addr(addr, sdl)
 static char hexlist[] = "0123456789abcdef";
 
 char *
-link_ntoa(sdl)
-        register const struct sockaddr_dl *sdl;
+link_ntoa(const struct sockaddr_dl *sdl)
 {
         static char obuf[64];
-        register char *out = obuf; 
-        register int i;
-        register u_char *in = (u_char *)LLADDR(sdl);
+        char *out = obuf; 
+        int i;
+        u_char *in = (u_char *)LLADDR(sdl);
         u_char *inlim = in + sdl->sdl_alen;
         int firsttime = 1;
 
diff --git a/src/lib/libc/net/net_addrcmp.3 b/src/lib/libc/net/net_addrcmp.3
new file mode 100644
index 0000000000..a02e6e2619
--- /dev/null
+++ b/src/lib/libc/net/net_addrcmp.3
@@ -0,0 +1,91 @@
+.\"     $OpenBSD: net_addrcmp.3,v 1.4 2007/05/31 19:19:30 jmc 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 $Mdocdate: May 31 2007 $
+.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/ns.3 b/src/lib/libc/net/ns.3
deleted file mode 100644
index f89b4fe042..0000000000
--- a/src/lib/libc/net/ns.3
+++ /dev/null
@@ -1,132 +0,0 @@
-.\"     $NetBSD: ns.3,v 1.3 1995/02/25 06:20:50 cgd 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. 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.
-.\"
-.\"     @(#)ns.3        8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
-.Dt NS 3
-.Os BSD 4.3
-.Sh NAME
-.Nm ns_addr ,
-.Nm ns_ntoa
-.Nd Xerox
-.Tn NS Ns (tm)
-address conversion routines
-.Sh SYNOPSIS
-.Fd #include <sys/types.h>
-.Fd #include <netns/ns.h>
-.Ft struct ns_addr 
-.Fn ns_addr "char *cp"
-.Ft char *
-.Fn ns_ntoa "struct ns_addr ns"
-.Sh DESCRIPTION
-The routine
-.Fn ns_addr
-interprets character strings representing
-.Tn XNS
-addresses, returning binary information suitable
-for use in system calls.
-The routine
-.Fn ns_ntoa
-takes
-.Tn XNS
-addresses and returns
-.Tn ASCII
-strings representing the address in a
-notation in common use in the Xerox Development Environment:
-.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 ns_addr .
-Any fields lacking super-decimal digits will have a
-trailing
-.Ql H
-appended.
-.Pp
-Unfortunately, no universal standard exists for representing
-.Tn XNS
-addresses.
-An effort has been made to insure that
-.Fn ns_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
-.Ql \&. ,
-colon
-.Ql \&:
-or pound-sign
-.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
-.Ql H
-(as in Mesa), or there are any super-decimal digits present.
-It is interpreted as octal is 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
-.Fn ns_addr
-and
-.Fn ns_toa
-functions appeared in 
-.Bx 4.3 .
-.Sh BUGS
-The string returned by
-.Fn ns_ntoa
-resides in a static memory area.
-The function
-.Fn ns_addr
-should diagnose improperly formed input, and there should be an unambiguous
-way to recognize this.
diff --git a/src/lib/libc/net/ns_addr.c b/src/lib/libc/net/ns_addr.c
deleted file mode 100644
index f75ddb23b7..0000000000
--- a/src/lib/libc/net/ns_addr.c
+++ /dev/null
@@ -1,233 +0,0 @@
-/*      $NetBSD: ns_addr.c,v 1.5 1995/02/25 06:20:51 cgd 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)ns_addr.c   8.1 (Berkeley) 6/7/93";
-#else
-static char rcsid[] = "$NetBSD: ns_addr.c,v 1.5 1995/02/25 06:20:51 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
-#include <sys/param.h>
-#include <netns/ns.h>
-#include <stdio.h>
-#include <string.h>
-
-static struct ns_addr addr, zero_addr;
-
-static void Field(), cvtbase();
-
-struct ns_addr 
-ns_addr(name)
-        const char *name;
-{
-        char separator;
-        char *hostname, *socketname, *cp;
-        char buf[50];
-
-        (void)strncpy(buf, name, sizeof(buf) - 1);
-        buf[sizeof(buf) - 1] = '\0';
-
-        /*
-         * 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 compatability.
-         */
-        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.x_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.x_port, 2);
-        }
-
-        Field(hostname, addr.x_host.c_host, 6);
-
-        return (addr);
-}
-
-static void
-Field(buf, out, len)
-        char *buf;
-        u_char *out;
-        int len;
-{
-        register 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(oldbase,newbase,input,inlen,result,reslen)
-        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/ns_ntoa.c b/src/lib/libc/net/ns_ntoa.c
deleted file mode 100644
index ad3265399b..0000000000
--- a/src/lib/libc/net/ns_ntoa.c
+++ /dev/null
@@ -1,106 +0,0 @@
-/*      $NetBSD: ns_ntoa.c,v 1.4 1995/02/25 06:20:51 cgd 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)ns_ntoa.c   8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: ns_ntoa.c,v 1.4 1995/02/25 06:20:51 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
-#include <sys/param.h>
-#include <netns/ns.h>
-#include <stdio.h>
-
-char *
-ns_ntoa(addr)
-        struct ns_addr addr;
-{
-        static char obuf[40];
-        union { union ns_net net_e; u_long long_e; } net;
-        u_short port = htons(addr.x_port);
-        register char *cp;
-        char *cp2;
-        register u_char *up = addr.x_host.c_host;
-        u_char *uplim = up + 6;
-        static char *spectHex();
-
-        net.net_e = addr.x_net;
-        sprintf(obuf, "%lx", ntohl(net.long_e));
-        cp = spectHex(obuf);
-        cp2 = cp + 1;
-        while (*up==0 && up < uplim) up++;
-        if (up == uplim) {
-                if (port) {
-                        sprintf(cp, ".0");
-                        cp += 2;
-                }
-        } else {
-                sprintf(cp, ".%x", *up++);
-                while (up < uplim) {
-                        while (*cp) cp++;
-                        sprintf(cp, "%02x", *up++);
-                }
-                cp = spectHex(cp2);
-        }
-        if (port) {
-                sprintf(cp, ".%x", port);
-                spectHex(cp + 1);
-        }
-        return (obuf);
-}
-
-static char *
-spectHex(p0)
-        char *p0;
-{
-        int ok = 0;
-        int nonzero = 0;
-        register char *p = p0;
-        for (; *p; p++) switch (*p) {
-
-        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-                *p += ('A' - 'a');
-                /* fall into . . . */
-        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-                ok = 1;
-        case '1': case '2': case '3': case '4': case '5':
-        case '6': case '7': case '8': case '9':
-                nonzero = 1;
-        }
-        if (nonzero && !ok) { *p++ = 'H'; *p = 0; }
-        return (p);
-}
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
index 05b7f4c9a3..36414b7a13 100644
--- a/src/lib/libc/net/ntohl.c
+++ b/src/lib/libc/net/ntohl.c
@@ -1,29 +1,21 @@
-/*      $NetBSD: ntohl.c,v 1.5 1995/04/28 23:25:21 jtc Exp $    */
-
+/*      $OpenBSD: ntohl.c,v 1.6 2005/08/06 20:30:03 espie Exp $ */
 /*
  * Written by J.T. Conklin <jtc@netbsd.org>.
  * Public domain.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: ntohl.c,v 1.5 1995/04/28 23:25:21 jtc Exp $";
-#endif
-
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef ntohl
 
-unsigned long
-ntohl(x)
-        unsigned long x;
+u_int32_t
+ntohl(u_int32_t x)
 {
-        u_int32_t y = x;
-
 #if BYTE_ORDER == LITTLE_ENDIAN
-        u_char *s = (u_char *)&y;
-        return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
+        u_char *s = (u_char *)&x;
+        return (u_int32_t)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
 #else
-        return y;
+        return x;
 #endif
 }
diff --git a/src/lib/libc/net/ntohs.c b/src/lib/libc/net/ntohs.c
index 93ab83ee4d..8f345e84ad 100644
--- a/src/lib/libc/net/ntohs.c
+++ b/src/lib/libc/net/ntohs.c
@@ -1,26 +1,20 @@
-/*      $NetBSD: ntohs.c,v 1.5 1995/04/28 23:25:23 jtc Exp $    */
-
+/*      $OpenBSD: ntohs.c,v 1.8 2005/08/06 20:30:03 espie Exp $ */
 /*
  * Written by J.T. Conklin <jtc@netbsd.org>.
  * Public domain.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: ntohs.c,v 1.5 1995/04/28 23:25:23 jtc Exp $";
-#endif
-
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef ntohs
 
-unsigned short
-ntohs(x)
-        unsigned short x;
+u_int16_t
+ntohs(u_int16_t x)
 {
 #if BYTE_ORDER == LITTLE_ENDIAN
         u_char *s = (u_char *) &x;
-        return s[0] << 8 | s[1];
+        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
index 4db847c392..87e9a760a8 100644
--- a/src/lib/libc/net/rcmd.3
+++ b/src/lib/libc/net/rcmd.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: rcmd.3,v 1.8 1995/02/25 06:20:52 cgd Exp $
+.\"     $OpenBSD: rcmd.3,v 1.27 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,38 +27,67 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)rcmd.3      8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt RCMD 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm rcmd ,
+.Nm rcmd_af ,
 .Nm rresvport ,
+.Nm rresvport_af ,
 .Nm iruserok ,
-.Nm ruserok
+.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 iruserok "u_long raddr" "int superuser" "const char *ruser" "const char *luser"
+.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 super-user to execute a command on
-a remote machine using an authentication scheme based
-on reserved port numbers.
+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
-function
-returns a descriptor to a socket
+and
+.Fn rresvport_af
+functions return a descriptor to a socket
 with an address in the privileged port space.
 The
 .Fn iruserok
@@ -75,11 +100,13 @@ 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
+function looks up the host
 .Fa *ahost
 using
 .Xr gethostbyname 3 ,
@@ -90,15 +117,15 @@ 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 
-.Em stdin
-and
-.Em stdout .
+command as stdin and stdout.
 If
 .Fa fd2p
 is non-zero, then an auxiliary channel to a control
@@ -113,27 +140,46 @@ signal numbers, to be
 forwarded to the process group of the command.
 If
 .Fa fd2p
-is 0, then the 
-.Em stderr
-(unit 2 of the remote
-command) will be made the same as the 
-.Em stdout
-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.
+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
-function is used to obtain a socket with a privileged
-address bound to it.  This socket is suitable for use
-by 
+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 1023.  Only the super-user
-is allowed to bind an address of this sort to a socket.
+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
@@ -141,10 +187,10 @@ 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 super-user.
+name is that of the superuser.
 Then, if the user is
-.Em NOT
-the super-user, it checks the
+.Em not
+the superuser, it checks the
 .Pa /etc/hosts.equiv
 file.
 If that lookup is not done, or is unsuccessful, the
@@ -153,19 +199,19 @@ 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 super-user, or is writeable by anyone other
+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
-.Dq Pa hosts.equiv
+.Pa hosts.equiv
 file, or the host and remote user name are found in the
-.Dq Pa .rhosts
+.Pa .rhosts
 file; otherwise
 .Fn iruserok
 and
 .Fn ruserok
 return \-1.
 If the local domain (as obtained from
-.Xr gethostname 2 )
+.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,
@@ -173,32 +219,48 @@ If the IP address of the remote host is known,
 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.
+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
-function
-returns a valid, bound socket descriptor on success.
+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
-.Dv EAGAIN
-is overloaded to mean ``All network ports in use.''
+.Er EAGAIN
+is overloaded to mean
+.Dq all network ports in use .
 .Sh SEE ALSO
-.Xr rlogin 1 ,
 .Xr rsh 1 ,
 .Xr intro 2 ,
-.Xr rexec 3 ,
-.Xr rexecd 8 ,
-.Xr rlogind 8 ,
+.Xr bindresvport 3 ,
+.Xr bindresvport_sa 3 ,
+.Xr rcmdsh 3 ,
 .Xr rshd 8
 .Sh HISTORY
 These
-functions appeared in 
+functions appeared in
 .Bx 4.2 .
diff --git a/src/lib/libc/net/rcmd.c b/src/lib/libc/net/rcmd.c
index e0310031b0..d566e0ca4c 100644
--- a/src/lib/libc/net/rcmd.c
+++ b/src/lib/libc/net/rcmd.c
@@ -1,6 +1,5 @@
-/*      $NetBSD: rcmd.c,v 1.12 1995/06/03 22:33:34 mycroft 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.
  *
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,14 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)rcmd.c      8.3 (Berkeley) 3/26/94";
-#else
-static char *rcsid = "$NetBSD: rcmd.c,v 1.12 1995/06/03 22:33:34 mycroft Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ -57,35 +44,77 @@ static char *rcsid = "$NetBSD: rcmd.c,v 1.12 1995/06/03 22:33:34 mycroft Exp $";
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#include <syslog.h>
+#include <stdlib.h>
 
-int     __ivaliduser __P((FILE *, u_long, const char *, const char *));
-static int __icheckhost __P((u_long, const char *));
+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(ahost, rport, locuser, remuser, cmd, fd2p)
-        char **ahost;
-        u_short rport;
-        const char *locuser, *remuser, *cmd;
-        int *fd2p;
+rcmd_af(char **ahost, int porta, const char *locuser, const char *remuser,
+    const char *cmd, int *fd2p, int af)
 {
-        struct hostent *hp;
-        struct sockaddr_in sin, from;
-        fd_set reads;
-        long oldmask;
+        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;
+        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();
-        hp = gethostbyname(*ahost);
-        if (hp == NULL) {
-                herror(*ahost);
+        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);
         }
-        *ahost = hp->h_name;
-        oldmask = sigblock(sigmask(SIGURG));
+        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(&lport);
+                s = rresvport_af(&lport, r->ai_family);
                 if (s < 0) {
                         if (errno == EAGAIN)
                                 (void)fprintf(stderr,
@@ -93,54 +122,84 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                         else
                                 (void)fprintf(stderr, "rcmd: socket: %s\n",
                                     strerror(errno));
-                        sigsetmask(oldmask);
-                        return (-1);
+                        if (r->ai_next) {
+                                r = r->ai_next;
+                                continue;
+                        } else {
+                                sigprocmask(SIG_SETMASK, &oldmask, NULL);
+                                freeaddrinfo(res);
+                                return (-1);
+                        }
                 }
                 fcntl(s, F_SETOWN, pid);
-                sin.sin_len = sizeof(struct sockaddr_in);
-                sin.sin_family = hp->h_addrtype;
-                sin.sin_port = rport;
-                bcopy(hp->h_addr_list[0], &sin.sin_addr, hp->h_length);
-                if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
+                if (connect(s, r->ai_addr, r->ai_addrlen) >= 0)
                         break;
                 (void)close(s);
                 if (errno == EADDRINUSE) {
                         lport--;
                         continue;
                 }
-                if (errno == ECONNREFUSED && timo <= 16) {
-                        (void)sleep(timo);
-                        timo *= 2;
-                        continue;
-                }
-                if (hp->h_addr_list[1] != NULL) {
+                if (errno == ECONNREFUSED)
+                        refused++;
+                if (r->ai_next) {
                         int oerrno = errno;
-
-                        (void)fprintf(stderr, "connect to address %s: ",
-                            inet_ntoa(sin.sin_addr));
+                        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);
-                        hp->h_addr_list++;
-                        bcopy(hp->h_addr_list[0], &sin.sin_addr, hp->h_length);
-                        (void)fprintf(stderr, "Trying %s...\n",
-                            inet_ntoa(sin.sin_addr));
+                        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;
                 }
-                (void)fprintf(stderr, "%s: %s\n", hp->h_name, strerror(errno));
-                sigsetmask(oldmask);
+                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(&lport), s3;
-                int len = sizeof(from);
+                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) {
@@ -150,12 +209,13 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                         (void)close(s2);
                         goto bad;
                 }
-                FD_ZERO(&reads);
-                FD_SET(s, &reads);
-                FD_SET(s2, &reads);
+again:
+                bzero(readsp, fdssize);
+                FD_SET(s, readsp);
+                FD_SET(s2, readsp);
                 errno = 0;
-                if (select(MAX(s, s2) + 1, &reads, 0, 0, 0) < 1 ||
-                    !FD_ISSET(s2, &reads)) {
+                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",
@@ -167,21 +227,48 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                         goto bad;
                 }
                 s3 = accept(s2, (struct sockaddr *)&from, &len);
-                (void)close(s2);
                 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;
-                from.sin_port = ntohs(from.sin_port);
-                if (from.sin_family != AF_INET ||
-                    from.sin_port >= IPPORT_RESERVED ||
-                    from.sin_port < IPPORT_RESERVED / 2) {
-                        (void)fprintf(stderr,
-                            "socket: protocol failure in circuit setup.\n");
-                        goto bad2;
+                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);
@@ -200,318 +287,17 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                 }
                 goto bad2;
         }
-        sigsetmask(oldmask);
+        sigprocmask(SIG_SETMASK, &oldmask, NULL);
+        free(readsp);
         return (s);
 bad2:
         if (lport)
                 (void)close(*fd2p);
 bad:
+        if (readsp)
+                free(readsp);
         (void)close(s);
-        sigsetmask(oldmask);
-        return (-1);
-}
-
-int
-rresvport(alport)
-        int *alport;
-{
-        struct sockaddr_in sin;
-        int s;
-
-        sin.sin_len = sizeof(struct sockaddr_in);
-        sin.sin_family = AF_INET;
-        sin.sin_addr.s_addr = INADDR_ANY;
-        s = socket(AF_INET, SOCK_STREAM, 0);
-        if (s < 0)
-                return (-1);
-        for (;;) {
-                sin.sin_port = htons((u_short)*alport);
-                if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
-                        return (s);
-                if (errno != EADDRINUSE) {
-                        (void)close(s);
-                        return (-1);
-                }
-                (*alport)--;
-                if (*alport == IPPORT_RESERVED/2) {
-                        (void)close(s);
-                        errno = EAGAIN;         /* close */
-                        return (-1);
-                }
-        }
-}
-
-int     __check_rhosts_file = 1;
-char    *__rcmd_errstr;
-
-int
-ruserok(rhost, superuser, ruser, luser)
-        const char *rhost, *ruser, *luser;
-        int superuser;
-{
-        struct hostent *hp;
-        char **ap;
-        int i;
-#define MAXADDRS        35
-        u_long addrs[MAXADDRS + 1];
-
-        if ((hp = gethostbyname(rhost)) == NULL)
-                return (-1);
-        for (i = 0, ap = hp->h_addr_list; *ap && i < MAXADDRS; ++ap, ++i)
-                bcopy(*ap, &addrs[i], sizeof(addrs[i]));
-        addrs[i] = 0;
-
-        for (i = 0; i < MAXADDRS && addrs[i]; i++)
-                if (iruserok(addrs[i], superuser, ruser, luser) == 0)
-                        return (0);
-        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(raddr, superuser, ruser, luser)
-        u_long raddr;
-        int superuser;
-        const char *ruser, *luser;
-{
-        register char *cp;
-        struct stat sbuf;
-        struct passwd *pwd;
-        FILE *hostf;
-        uid_t uid;
-        int first;
-        char pbuf[MAXPATHLEN];
-
-        first = 1;
-        hostf = superuser ? NULL : fopen(_PATH_HEQUIV, "r");
-again:
-        if (hostf) {
-                if (__ivaliduser(hostf, raddr, 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);
-                (void)strcpy(pbuf, pwd->pw_dir);
-                (void)strcat(pbuf, "/.rhosts");
-
-                /*
-                 * 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 writeable by other than owner";
-                /* If there were any problems, quit. */
-                if (cp) {
-                        __rcmd_errstr = cp;
-                        (void)fclose(hostf);
-                        return (-1);
-                }
-                goto again;
-        }
+        sigprocmask(SIG_SETMASK, &oldmask, NULL);
         return (-1);
 }
 
-/*
- * XXX
- * Don't make static, used by lpd(8).
- *
- * Returns 0 if ok, -1 if not ok.
- */
-int
-__ivaliduser(hostf, raddr, luser, ruser)
-        FILE *hostf;
-        u_long raddr;
-        const char *luser, *ruser;
-{
-        register char *user, *p;
-        int ch;
-        char buf[MAXHOSTNAMELEN + 128];         /* host + login */
-        const char *auser, *ahost;
-        int hostok, userok;
-        char rhost[MAXHOSTNAMELEN];
-        struct hostent *hp;
-        char domain[MAXHOSTNAMELEN];
-
-        getdomainname(domain, sizeof(domain));
-
-        while (fgets(buf, sizeof(buf), hostf)) {
-                p = buf;
-                /* Skip lines that are too long. */
-                if (strchr(p, '\n') == NULL) {
-                        while ((ch = getc(hostf)) != '\n' && ch != EOF);
-                        continue;
-                }
-                while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0') {
-                        *p = isupper(*p) ? tolower(*p) : *p;
-                        p++;
-                }
-                if (*p == ' ' || *p == '\t') {
-                        *p++ = '\0';
-                        while (*p == ' ' || *p == '\t')
-                                p++;
-                        user = p;
-                        while (*p != '\n' && *p != ' ' &&
-                            *p != '\t' && *p != '\0')
-                                p++;
-                } else
-                        user = p;
-                *p = '\0';
-
-                if (p == buf)
-                        continue;
-
-                auser = *user ? user : luser;
-                ahost = buf;
-
-                if ((hp = gethostbyaddr((char *) &raddr,
-                                        sizeof(raddr), AF_INET)) == NULL) {
-                        abort();
-                        return -1;
-                }
-                (void) strncpy(rhost, hp->h_name, sizeof(rhost));
-                rhost[sizeof(rhost) - 1] = '\0';
-
-                if (ahost[0] == '+')
-                        switch (ahost[1]) {
-                        case '\0':
-                                hostok = 1;
-                                break;
-
-                        case '@':
-                                hostok = innetgr(&ahost[2], rhost, NULL,
-                                                 domain);
-                                break;
-
-                        default:
-                                hostok = __icheckhost(raddr, &ahost[1]);
-                                break;
-                        }
-                else if (ahost[0] == '-')
-                        switch (ahost[1]) {
-                        case '\0':
-                                hostok = -1;
-                                break;
-
-                        case '@':
-                                hostok = -innetgr(&ahost[2], rhost, NULL,
-                                                  domain);
-                                break;
-
-                        default:
-                                hostok = -__icheckhost(raddr, &ahost[1]);
-                                break;
-                        }
-                else
-                        hostok = __icheckhost(raddr, 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;
-                                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);
-                                break;
-                        }
-                else
-                        userok = strcmp(ruser, auser) == 0;
-
-                /* 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;
-        }
-        return -1;
-}
-
-/*
- * Returns "true" if match, 0 if no match.
- */
-static int
-__icheckhost(raddr, lhost)
-        u_long raddr;
-        const char *lhost;
-{
-        register struct hostent *hp;
-        register u_long laddr;
-        register char **pp;
-
-        /* Try for raw ip address first. */
-        if (isdigit(*lhost) && (long)(laddr = inet_addr(lhost)) != -1)
-                return (raddr == laddr);
-
-        /* Better be a hostname. */
-        if ((hp = gethostbyname(lhost)) == NULL)
-                return (0);
-
-        /* Spin through ip addresses. */
-        for (pp = hp->h_addr_list; *pp; ++pp)
-                if (!bcmp(&raddr, *pp, sizeof(u_long)))
-                        return (1);
-
-        /* No match. */
-        return (0);
-}
diff --git a/src/lib/libc/net/rcmdsh.3 b/src/lib/libc/net/rcmdsh.3
new file mode 100644
index 0000000000..f7de0808f5
--- /dev/null
+++ b/src/lib/libc/net/rcmdsh.3
@@ -0,0 +1,96 @@
+.\"     $OpenBSD: rcmdsh.3,v 1.13 2009/12/29 10:25:43 sobrado 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 $Mdocdate: December 29 2009 $
+.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
+.Ux Ns -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..a472162711
--- /dev/null
+++ b/src/lib/libc/net/rcmdsh.c
@@ -0,0 +1,186 @@
+/*      $OpenBSD: rcmdsh.c,v 1.12 2007/09/02 15:19:17 deraadt 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 = calloc(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
index 44296378cb..6241cc6b12 100644
--- a/src/lib/libc/net/recv.c
+++ b/src/lib/libc/net/recv.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: recv.c,v 1.6 1995/02/25 06:20:54 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,24 +28,13 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)recv.c      8.2 (Berkeley) 2/21/94";
-#else
-static char rcsid[] = "$NetBSD: recv.c,v 1.6 1995/02/25 06:20:54 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #include <stddef.h>
 
 ssize_t
-recv(s, buf, len, flags)
-        int s, flags;
-        size_t len;
-        void *buf;
+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
index 9d7bbecdda..69a6ce0abb 100644
--- a/src/lib/libc/net/res_comp.c
+++ b/src/lib/libc/net/res_comp.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_comp.c,v 1.6 1995/02/25 06:20:55 cgd Exp $ */
+/*      $OpenBSD: res_comp.c,v 1.14 2008/04/16 22:35:23 deraadt Exp $   */
 
-/*-
+/*
+ * ++Copyright++ 1985, 1993
+ * -
  * Copyright (c) 1985, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,22 +51,19 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_comp.c  8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: res_comp.c,v 4.9.1.1 1993/05/02 22:43:03 vixie Rel ";
-#else
-static char rcsid[] = "$NetBSD: res_comp.c,v 1.6 1995/02/25 06:20:55 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
 #include <sys/param.h>
-#include <arpa/nameser.h>
 #include <netinet/in.h>
-#include <resolv.h>
+#include <arpa/nameser.h>
+
 #include <stdio.h>
+#include <resolv.h>
+#include <ctype.h>
+
+#include <unistd.h>
+#include <string.h>
 
-static int dn_find();
+static int dn_find(u_char *, u_char *, u_char **, u_char **);
 
 /*
  * Expand compressed domain name 'comp_dn' to full domain name.
@@ -77,23 +72,25 @@ static int dn_find();
  * '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.
  */
-dn_expand(msg, eomorig, comp_dn, exp_dn, length)
-        const u_char *msg, *eomorig, *comp_dn;
-        u_char *exp_dn;
-        int length;
+int
+dn_expand(const u_char *msg, const u_char *eomorig, const u_char *comp_dn,
+    char *exp_dn, int length)
 {
-        register u_char *cp, *dn;
-        register int n, c;
-        u_char *eom;
+        const u_char *cp;
+        char *dn;
+        int n, c;
+        char *eom;
         int len = -1, checked = 0;
 
         dn = exp_dn;
-        cp = (u_char *)comp_dn;
+        cp = comp_dn;
+        if (length > MAXHOSTNAMELEN-1)
+                length = MAXHOSTNAMELEN-1;
         eom = exp_dn + length;
         /*
          * fetch next label in domain name
          */
-        while (n = *cp++) {
+        while ((n = *cp++)) {
                 /*
                  * Check for indirection
                  */
@@ -108,23 +105,23 @@ dn_expand(msg, eomorig, comp_dn, exp_dn, length)
                                 return (-1);
                         checked += n + 1;
                         while (--n >= 0) {
-                                if ((c = *cp++) == '.') {
+                                if (((c = *cp++) == '.') || (c == '\\')) {
                                         if (dn + n + 2 >= eom)
                                                 return (-1);
                                         *dn++ = '\\';
                                 }
                                 *dn++ = c;
                                 if (cp >= eomorig)      /* out of range */
-                                        return(-1);
+                                        return (-1);
                         }
                         break;
 
                 case INDIR_MASK:
                         if (len < 0)
                                 len = cp - comp_dn + 1;
-                        cp = (u_char *)msg + (((n & 0x3f) << 8) | (*cp & 0xff));
+                        cp = msg + (((n & 0x3f) << 8) | (*cp & 0xff));
                         if (cp < msg || cp >= eomorig)  /* out of range */
-                                return(-1);
+                                return (-1);
                         checked += 2;
                         /*
                          * Check for loops in the compressed name;
@@ -157,19 +154,19 @@ dn_expand(msg, eomorig, comp_dn, exp_dn, length)
  * If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
  * is NULL, we don't update the list.
  */
-dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
-        const u_char *exp_dn;
-        u_char *comp_dn, **dnptrs, **lastdnptr;
-        int length;
+int
+dn_comp(const char *exp_dn, u_char *comp_dn, int length, u_char **dnptrs,
+    u_char **lastdnptr)
 {
-        register u_char *cp, *dn;
-        register int c, l;
+        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++)
@@ -235,13 +232,13 @@ dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
 /*
  * Skip over a compressed domain name. Return the size or -1.
  */
-__dn_skipname(comp_dn, eom)
-        const u_char *comp_dn, *eom;
+int
+__dn_skipname(const u_char *comp_dn, const u_char *eom)
 {
-        register u_char *cp;
-        register int n;
+        const u_char *cp;
+        int n;
 
-        cp = (u_char *)comp_dn;
+        cp = comp_dn;
         while (cp < eom && (n = *cp++)) {
                 /*
                  * check for indirection
@@ -259,10 +256,18 @@ __dn_skipname(comp_dn, eom)
                 break;
         }
         if (cp > eom)
-                return -1;
+                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.
@@ -270,18 +275,16 @@ __dn_skipname(comp_dn, eom)
  * not the pointer to the start of the message.
  */
 static int
-dn_find(exp_dn, msg, dnptrs, lastdnptr)
-        u_char *exp_dn, *msg;
-        u_char **dnptrs, **lastdnptr;
+dn_find(u_char *exp_dn, u_char *msg, u_char **dnptrs, u_char **lastdnptr)
 {
-        register u_char *dn, *cp, **cpp;
-        register int n;
+        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++) {
+                while ((n = *cp++)) {
                         /*
                          * check for indirection
                          */
@@ -292,7 +295,7 @@ dn_find(exp_dn, msg, dnptrs, lastdnptr)
                                                 goto next;
                                         if (*dn == '\\')
                                                 dn++;
-                                        if (*dn++ != *cp++)
+                                        if (mklower(*dn++) != mklower(*cp++))
                                                 goto next;
                                 }
                                 if ((n = *dn++) == '\0' && *cp == '\0')
@@ -301,11 +304,12 @@ dn_find(exp_dn, msg, dnptrs, lastdnptr)
                                         continue;
                                 goto next;
 
-                        default:        /* illegal type */
-                                return (-1);
-
                         case INDIR_MASK:        /* indirection */
                                 cp = msg + (((n & 0x3f) << 8) | *cp);
+                                break;
+
+                        default:        /* illegal type */
+                                return (-1);
                         }
                 }
                 if (*dn == '\0')
@@ -316,49 +320,156 @@ dn_find(exp_dn, msg, dnptrs, lastdnptr)
 }
 
 /*
- * Routines to insert/extract short/long's. Must account for byte
- * order and non-alignment problems. This code at least has the
- * advantage of being portable.
- *
- * used by sendmail.
+ * 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 underscorechar(c) ((c) == 0x5f)
+#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) || underscorechar(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));
+}
 
-u_short
-_getshort(msgp)
-        register u_char *msgp;
+/*
+ * 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)
 {
-        register u_int16_t u;
+        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(msgp)
-        register u_char *msgp;
+_getlong(const u_char *msgp)
 {
-        register u_int32_t u;
+        u_int32_t u;
 
         GETLONG(u, msgp);
         return (u);
 }
 
 void
-#if defined(__STDC__) || defined(__cplusplus)
-__putshort(register u_int16_t s, register u_char *msgp)
-#else
-__putshort(s, msgp)
-        register u_int16_t s;
-        register u_char *msgp;
-#endif
+__putshort(u_int16_t s, u_char *msgp)
 {
         PUTSHORT(s, msgp);
 }
 
 void
-__putlong(l, msgp)
-        register u_int32_t l;
-        register u_char *msgp;
+__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
index d841293f18..246fefef3c 100644
--- a/src/lib/libc/net/res_debug.c
+++ b/src/lib/libc/net/res_debug.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_debug.c,v 1.7 1995/02/25 06:20:56 cgd Exp $        */
+/*      $OpenBSD: res_debug.c,v 1.22 2007/10/11 18:36:41 jakob Exp $    */
 
-/*-
+/*
+ * ++Copyright++ 1985, 1990, 1993
+ * -
  * Copyright (c) 1985, 1990, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    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:
@@ -12,11 +14,7 @@
  * 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
+ * 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.
  * 
@@ -50,174 +48,179 @@
  * 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--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_debug.c 8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: res_debug.c,v 1.7 1995/02/25 06:20:56 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #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>
 
-void __fp_query();
-char *__p_class(), *__p_time(), *__p_type();
-char *p_cdname(), *p_fqname(), *p_rr();
-static char *p_option __P((u_int32_t));
-
-char *_res_opcodes[] = {
-        "QUERY",
-        "IQUERY",
-        "CQUERYM",
-        "CQUERYU",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8",
-        "UPDATEA",
-        "UPDATED",
-        "UPDATEDA",
-        "UPDATEM",
-        "UPDATEMA",
-        "ZONEINIT",
-        "ZONEREF",
-};
-
-char *_res_resultcodes[] = {
-        "NOERROR",
-        "FORMERR",
-        "SERVFAIL",
-        "NXDOMAIN",
-        "NOTIMP",
-        "REFUSED",
-        "6",
-        "7",
-        "8",
-        "9",
-        "10",
-        "11",
-        "12",
-        "13",
-        "14",
-        "NOCHANGE",
-};
-
-static char retbuf[16];
-
-static char *
-dewks(wks)
-        int wks;
+#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) sprintf(retbuf, "%d", wks); return(retbuf);
+        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);
         }
 }
 
-static char *
-deproto(protonum)
-        int protonum;
+/* 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) sprintf(retbuf, "%d", protonum); return(retbuf);
+        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 char *
-do_rrset(msg, cp, cnt, pflag, file, hs)
-        int cnt, pflag;
-        char *cp,*msg, *hs;
-        FILE *file;
+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
+         * Print answer records.
          */
-        sflag = (_res.pfcode & pflag);
-        if (n = ntohs(cnt)) {
-                if ((!_res.pfcode) || ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
-                        fprintf(file, hs);
+        sflag = (_resp->pfcode & pflag);
+        if ((n = ntohs(cnt))) {
+                if ((!_resp->pfcode) ||
+                    ((sflag) && (_resp->pfcode & RES_PRF_HEAD1)))
+                        fprintf(file, "%s", hs);
                 while (--n >= 0) {
-                        cp = p_rr(cp, msg, file);
-                        if ((cp-msg) > PACKETSZ)
+                        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 ((!_res.pfcode) || ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
+                if ((!_resp->pfcode) ||
+                    ((sflag) && (_resp->pfcode & RES_PRF_HEAD1)))
                         putc('\n', file);
         }
-        return(cp);
+        return (cp);
 }
 
-__p_query(msg)
-        char *msg;
+void
+__p_query(const u_char *msg)
 {
         __fp_query(msg, stdout);
 }
@@ -227,19 +230,16 @@ __p_query(msg)
  * This is intended to be primarily a debugging routine.
  */
 void
-__fp_resstat(statp, file)
-        struct __res_state *statp;
-        FILE *file;
+__fp_resstat(struct __res_state *statp, FILE *file)
 {
-        int bit;
+        u_long mask;
 
         fprintf(file, ";; res options:");
         if (!statp)
                 statp = &_res;
-        for (bit = 0;  bit < 32;  bit++) {      /* XXX 32 - bad assumption! */
-                if (statp->options & (1<<bit))
-                        fprintf(file, " %s", p_option(1<<bit));
-        }
+        for (mask = 1;  mask != 0;  mask <<= 1)
+                if (statp->options & mask)
+                        fprintf(file, " %s", p_option(mask));
         putc('\n', file);
 }
 
@@ -248,109 +248,144 @@ __fp_resstat(statp, file)
  * This is intended to be primarily a debugging routine.
  */
 void
-__fp_query(msg,file)
-        char *msg;
-        FILE *file;
+__fp_nquery(const u_char *msg, int len, FILE *file)
 {
-        register char *cp;
-        register HEADER *hp;
-        register int n;
+        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 + sizeof(HEADER);
-        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX) || hp->rcode) {
-                fprintf(file,";; ->>HEADER<<- opcode: %s, status: %s, id: %d",
+        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);
         }
-        putc(';', file);
-        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD2)) {
-                fprintf(file,"; flags:");
+        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");
+                        fprintf(file, " qr");
                 if (hp->aa)
-                        fprintf(file," aa");
+                        fprintf(file, " aa");
                 if (hp->tc)
-                        fprintf(file," tc");
+                        fprintf(file, " tc");
                 if (hp->rd)
-                        fprintf(file," rd");
+                        fprintf(file, " rd");
                 if (hp->ra)
-                        fprintf(file," ra");
-                if (hp->pr)
-                        fprintf(file," pr");
+                        fprintf(file, " ra");
+                if (hp->unused)
+                        fprintf(file, " UNUSED-BIT-ON");
+                if (hp->ad)
+                        fprintf(file, " ad");
+                if (hp->cd)
+                        fprintf(file, " cd");
         }
-        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD1)) {
-                fprintf(file,"; Ques: %d", ntohs(hp->qdcount));
-                fprintf(file,", Ans: %d", ntohs(hp->ancount));
-                fprintf(file,", Auth: %d", ntohs(hp->nscount));
-                fprintf(file,", Addit: %d\n", ntohs(hp->arcount));
+        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 0
-        if (_res.pfcode & (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1)) {
+        if ((!_resp->pfcode) || (_resp->pfcode & 
+                (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
                 putc('\n',file);
         }
-#endif
         /*
          * Print question records.
          */
-        if (n = ntohs(hp->qdcount)) {
-                if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
-                        fprintf(file,";; QUESTIONS:\n");
+        if ((n = ntohs(hp->qdcount))) {
+                if ((!_resp->pfcode) || (_resp->pfcode & RES_PRF_QUES))
+                        fprintf(file, ";; QUESTIONS:\n");
                 while (--n >= 0) {
-                        fprintf(file,";;\t");
-                        cp = p_cdname(cp, msg, file);
-                        if (cp == NULL)
-                                return;
-                        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
+                        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(cp)));
-                        cp += sizeof(u_int16_t);
-                        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
-                                fprintf(file, ", class = %s\n\n",
-                                        __p_class(_getshort(cp)));
-                        cp += sizeof(u_int16_t);
+                                        __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
          */
-        cp = do_rrset(msg, cp, hp->ancount, RES_PRF_ANS, file,
+        TruncTest(cp);
+        cp = do_rrset(msg, len, cp, hp->ancount, RES_PRF_ANS, file,
                       ";; ANSWERS:\n");
-        if (cp == NULL)
-                return;
+        ErrorTest(cp);
 
         /*
          * print name server records
          */
-        cp = do_rrset(msg, cp, hp->nscount, RES_PRF_AUTH, file,
+        TruncTest(cp);
+        cp = do_rrset(msg, len, cp, hp->nscount, RES_PRF_AUTH, file,
                       ";; AUTHORITY RECORDS:\n");
-        if (!cp)
-                return;
+        ErrorTest(cp);
 
+        TruncTest(cp);
         /*
          * print additional records
          */
-        cp = do_rrset(msg, cp, hp->arcount, RES_PRF_ADD, file,
+        cp = do_rrset(msg, len, cp, hp->arcount, RES_PRF_ADD, file,
                       ";; ADDITIONAL RECORDS:\n");
-        if (!cp)
-                return;
+        ErrorTest(cp);
+        return;
+ trunc:
+        fprintf(file, "\n;; ...truncated\n");
+        return;
+ error:
+        fprintf(file, "\n;; ...malformed\n");
 }
 
-char *
-p_cdname(cp, msg, file)
-        char *cp, *msg;
-        FILE *file;
+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((u_char *)msg, (u_char *)cp + MAXCDNAME,
-            (u_char *)cp, (u_char *)name, sizeof(name))) < 0)
+        if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0)
                 return (NULL);
         if (name[0] == '\0')
                 putc('.', file);
@@ -359,55 +394,86 @@ p_cdname(cp, msg, file)
         return (cp + n);
 }
 
-char *
-p_fqname(cp, msg, file)
-        char *cp, *msg;
-        FILE *file;
+const u_char *
+__p_cdname(const u_char *cp, const u_char *msg, FILE *file)
 {
-        char name[MAXDNAME];
-        int n, len;
+        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((u_char *)msg, (u_char *)cp + MAXCDNAME,
-            (u_char *)cp, (u_char *)name, sizeof(name))) < 0)
+        if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0)
                 return (NULL);
-        if (name[0] == '\0') {
-                putc('.', file);
-        } else {
-                fputs(name, file);
-                if (name[strlen(name) - 1] != '.')
-                        putc('.', file);
+        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.
  */
-char *
-p_rr(cp, msg, file)
-        char *cp, *msg;
-        FILE *file;
+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;
-        char *cp1, *cp2;
+        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 ((cp = p_fqname(cp, msg, file)) == NULL)
+        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 */
-        type = _getshort(cp);
-        cp += sizeof(u_int16_t);
-        class = _getshort(cp);
-        cp += sizeof(u_int16_t);
-        tmpttl = _getlong(cp);
-        cp += sizeof(u_int32_t);
-        dlen = _getshort(cp);
-        cp += sizeof(u_int16_t);
+        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 ((!_res.pfcode) || (_res.pfcode & RES_PRF_TTLID))
-                fprintf(file, "\t%lu", tmpttl);
-        if ((!_res.pfcode) || (_res.pfcode & RES_PRF_CLASS))
+        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));
         /*
@@ -418,22 +484,22 @@ p_rr(cp, msg, file)
                 switch (class) {
                 case C_IN:
                 case C_HS:
-                        bcopy(cp, (char *)&inaddr, sizeof(inaddr));
+                        bcopy(cp, (char *)&inaddr, INADDRSZ);
                         if (dlen == 4) {
-                                fprintf(file,"\t%s", inet_ntoa(inaddr));
+                                fprintf(file, "\t%s", inet_ntoa(inaddr));
                                 cp += dlen;
                         } else if (dlen == 7) {
                                 char *address;
                                 u_char protocol;
-                                u_short port;
+                                in_port_t port;
 
                                 address = inet_ntoa(inaddr);
-                                cp += sizeof(inaddr);
+                                cp += INADDRSZ;
                                 protocol = *(u_char*)cp;
-                                cp += sizeof(u_char);
-                                port = _getshort(cp);
-                                cp += sizeof(u_int16_t);
-                                fprintf(file, "\t%s\t; proto %d, port %d",
+                                cp += sizeof (u_char);
+                                port = _getshort((u_char*)cp);
+                                cp += INT16SZ;
+                                fprintf(file, "\t%s\t; proto %u, port %u",
                                         address, protocol, port);
                         }
                         break;
@@ -448,98 +514,205 @@ p_rr(cp, msg, file)
         case T_NS:
         case T_PTR:
                 putc('\t', file);
-                cp = p_fqname(cp, msg, file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
                 break;
 
         case T_HINFO:
-                if (n = *cp++) {
-                        fprintf(file,"\t%.*s", n, cp);
-                        cp += n;
+        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);
+                        }
                 }
-                if (n = *cp++) {
-                        fprintf(file,"\t%.*s", n, cp);
-                        cp += n;
+                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);
-                cp = p_fqname(cp, msg, file);   /* origin */
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
                 putc(' ', file);
-                cp = p_fqname(cp, msg, file);   /* mail addr */
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
                 fputs(" (\n", file);
-                t = _getlong(cp);  cp += sizeof(u_int32_t);
-                fprintf(file,"\t\t\t%lu\t; serial\n", t);
-                t = _getlong(cp);  cp += sizeof(u_int32_t);
-                fprintf(file,"\t\t\t%lu\t; refresh (%s)\n", t, __p_time(t));
-                t = _getlong(cp);  cp += sizeof(u_int32_t);
-                fprintf(file,"\t\t\t%lu\t; retry (%s)\n", t, __p_time(t));
-                t = _getlong(cp);  cp += sizeof(u_int32_t);
-                fprintf(file,"\t\t\t%lu\t; expire (%s)\n", t, __p_time(t));
-                t = _getlong(cp);  cp += sizeof(u_int32_t);
-                fprintf(file,"\t\t\t%lu )\t; minimum (%s)", t, __p_time(t));
+                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:
-                fprintf(file,"\t%d ", _getshort(cp));
-                cp += sizeof(u_int16_t);
-                cp = p_fqname(cp, msg, file);
+        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_TXT:
+        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) {
-                        if (n = (unsigned char) *cp++) {
-                                for (c = n; c > 0 && cp < cp2; c--)
-                                        if (*cp == '\n') {
-                                            (void) putc('\\', file);
-                                            (void) putc(*cp++, file);
-                                        } else
-                                            (void) putc(*cp++, file);
+                        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);
                 }
-                putc('"', file);
-                break;
+                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);
-                cp = p_fqname(cp, msg, file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
                 putc(' ', file);
-                cp = p_fqname(cp, msg, file);
+                if ((cp = p_fqname(cp, msg, file)) == NULL)
+                        return (NULL);
                 break;
 
         case T_UINFO:
                 putc('\t', file);
-                fputs(cp, file);
+                fputs((char *)cp, file);
                 cp += dlen;
                 break;
 
         case T_UID:
         case T_GID:
                 if (dlen == 4) {
-                        fprintf(file,"\t%u", _getlong(cp));
-                        cp += sizeof(int32_t);
+                        fprintf(file, "\t%u", _getlong((u_char*)cp));
+                        cp += INT32SZ;
                 }
                 break;
 
         case T_WKS:
-                if (dlen < sizeof(u_int32_t) + 1)
+                if (dlen < INT32SZ + 1)
                         break;
-                bcopy(cp, (char *)&inaddr, sizeof(inaddr));
-                cp += sizeof(u_int32_t);
+                bcopy(cp, (char *)&inaddr, INADDRSZ);
+                cp += INT32SZ;
                 fprintf(file, "\t%s %s ( ",
                         inet_ntoa(inaddr),
                         deproto((int) *cp));
-                cp += sizeof(u_char);
+                cp += sizeof (u_char);
                 n = 0;
                 lcnt = 0;
                 while (cp < cp1 + dlen) {
                         c = *cp++;
                         do {
-                                if (c & 0200) {
+                                if (c & 0200) {
                                         if (lcnt == 0) {
                                                 fputs("\n\t\t\t", file);
                                                 lcnt = 5;
@@ -548,17 +721,84 @@ p_rr(cp, msg, file)
                                         putc(' ', file);
                                         lcnt--;
                                 }
-                                c <<= 1;
+                                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:
+        case T_RRSIG:
+                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;
-                        char *DataPtr;
+                        u_char *DataPtr;
                         int i;
 
                         if (dlen < NumBytes) NumBytes = dlen;
@@ -572,7 +812,7 @@ p_rr(cp, msg, file)
 #endif /* ALLOW_T_UNSPEC */
 
         default:
-                fprintf(file,"\t?%d?", type);
+                fprintf(file, "\t?%d?", type);
                 cp += dlen;
         }
 #if 0
@@ -581,136 +821,91 @@ p_rr(cp, msg, file)
         putc('\n', file);
 #endif
         if (cp - cp1 != dlen) {
-                fprintf(file,";; packet size error (found %d, dlen was %d)\n",
-                        cp - cp1, dlen);
+                fprintf(file, ";; packet size error (found %ld, dlen was %d)\n",
+                        (long)(cp - cp1), dlen);
                 cp = NULL;
         }
         return (cp);
 }
 
-static  char nbuf[40];
-
-/*
- * Return a string for the type
- */
-char *
-__p_type(type)
-        int type;
+int
+__sym_ston(const struct res_sym *syms, char *name, int *success)
 {
-        switch (type) {
-        case T_A:
-                return("A");
-        case T_NS:              /* authoritative server */
-                return("NS");
-        case T_CNAME:           /* canonical name */
-                return("CNAME");
-        case T_SOA:             /* start of authority zone */
-                return("SOA");
-        case T_MB:              /* mailbox domain name */
-                return("MB");
-        case T_MG:              /* mail group member */
-                return("MG");
-        case T_MR:              /* mail rename name */
-                return("MR");
-        case T_NULL:            /* null resource record */
-                return("NULL");
-        case T_WKS:             /* well known service */
-                return("WKS");
-        case T_PTR:             /* domain name pointer */
-                return("PTR");
-        case T_HINFO:           /* host information */
-                return("HINFO");
-        case T_MINFO:           /* mailbox information */
-                return("MINFO");
-        case T_MX:              /* mail routing info */
-                return("MX");
-        case T_TXT:             /* text */
-                return("TXT");
-        case T_RP:              /* responsible person */
-                return("RP");
-        case T_AFSDB:           /* AFS cell database */
-                return("AFSDB");
-        case T_AXFR:            /* zone transfer */
-                return("AXFR");
-        case T_MAILB:           /* mail box */
-                return("MAILB");
-        case T_MAILA:           /* mail address */
-                return("MAILA");
-        case T_ANY:             /* matches any type */
-                return("ANY");
-        case T_UINFO:
-                return("UINFO");
-        case T_UID:
-                return("UID");
-        case T_GID:
-                return("GID");
-#ifdef ALLOW_T_UNSPEC
-        case T_UNSPEC:
-                return("UNSPEC");
-#endif /* ALLOW_T_UNSPEC */
-
-        default:
-                (void)sprintf(nbuf, "%d", type);
-                return(nbuf);
+        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. */
 }
 
-/*
- * Return a mnemonic for class
- */
-char *
-__p_class(class)
-        int class;
+
+const char *
+__sym_ntop(const struct res_sym *syms, int number, int *success)
 {
+        static char unname[20];
 
-        switch (class) {
-        case C_IN:              /* internet class */
-                return("IN");
-        case C_HS:              /* hesiod class */
-                return("HS");
-        case C_ANY:             /* matches any class */
-                return("ANY");
-        default:
-                (void)sprintf(nbuf, "%d", class);
-                return(nbuf);
+        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
  */
-static char *
-p_option(option)
-        u_int32_t 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";
+        case RES_AAONLY:        return "aaonly(unimpl)";
         case RES_USEVC:         return "usevc";
-        case RES_PRIMARY:       return "primry";
+        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";
-        default:                sprintf(nbuf, "?0x%x?", option); return nbuf;
+        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
  */
-char *
-__p_time(value)
-        u_int32_t value;
+const char *
+p_time(u_int32_t value)
 {
+        static char nbuf[40];
+        char *ebuf;
         int secs, mins, hours, days;
-        register char *p;
+        char *p;
+        int tmp;
 
         if (value == 0) {
-                strcpy(nbuf, "0 secs");
-                return(nbuf);
+                strlcpy(nbuf, "0 secs", sizeof nbuf);
+                return (nbuf);
         }
 
         secs = value % 60;
@@ -724,26 +919,477 @@ __p_time(value)
 
 #define PLURALIZE(x)    x, (x == 1) ? "" : "s"
         p = nbuf;
+        ebuf = nbuf + sizeof(nbuf);
         if (days) {
-                (void)sprintf(p, "%d day%s", PLURALIZE(days));
-                while (*++p);
+                if ((tmp = snprintf(p, ebuf - p, "%d day%s",
+                    PLURALIZE(days))) >= ebuf - p || tmp < 0)
+                        goto full;
+                p += tmp;
         }
         if (hours) {
                 if (days)
                         *p++ = ' ';
-                (void)sprintf(p, "%d hour%s", PLURALIZE(hours));
-                while (*++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++ = ' ';
-                (void)sprintf(p, "%d min%s", PLURALIZE(mins));
-                while (*++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++ = ' ';
-                (void)sprintf(p, "%d sec%s", PLURALIZE(secs));
+                if (p >= ebuf)
+                        goto full;
+                if ((tmp = snprintf(p, ebuf - p, "%d sec%s",
+                    PLURALIZE(secs))) >= ebuf - p || tmp < 0)
+                        goto full;
         }
-        return(nbuf);
+        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
index 33cc8d39f1..18de3550e6 100644
--- a/src/lib/libc/net/res_init.c
+++ b/src/lib/libc/net/res_init.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_init.c,v 1.8 1995/06/03 22:33:36 mycroft Exp $     */
+/*      $OpenBSD: res_init.c,v 1.40 2009/06/05 09:52:26 pyr Exp $       */
 
-/*-
+/*
+ * ++Copyright++ 1985, 1989, 1993
+ * -
  * Copyright (c) 1985, 1989, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,80 +51,200 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_init.c  8.1 (Berkeley) 6/7/93";
-static char rcsid[] = "$Id: res_init.c,v 4.9.1.1 1993/05/02 22:43:03 vixie Rel ";
-#else
-static char rcsid[] = "$NetBSD: res_init.c,v 1.8 1995/06/03 22:33:36 mycroft Exp $";
+#ifndef INET6
+#define INET6
 #endif
-#endif /* LIBC_SCCS and not lint */
 
+#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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef INET6
+#include <netdb.h>
+#endif /* INET6 */
 
-static void res_setoptions __P((char *, char *));
-static u_int32_t net_mask __P((struct in_addr));
+#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
+ * 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 _res = {
-        RES_TIMEOUT,                    /* retransmition time interval */
-        4,                              /* number of times to retransmit */
-        RES_DEFAULT,                    /* options flags */
-        1,                              /* number of name servers */
-};
+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().
  *
- * The configuration file should only be used if you want to redefine your
- * domain or run without a server on your machine.
+ * 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
  */
-res_init()
+int
+res_init(void)
 {
-        register FILE *fp;
-        register char *cp, **pp, *net;
-        register int n;
-        char buf[BUFSIZ], buf2[BUFSIZ];
+
+        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;
+        int findex;
+        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;
-        u_long mask;
+        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;
 
-        _res.nsaddr.sin_len = sizeof(struct sockaddr_in);
-        _res.nsaddr.sin_family = AF_INET;
-        _res.nsaddr.sin_port = htons(NAMESERVER_PORT);
 #ifdef USELOOPBACK
-        _res.nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
+        _resp->nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
 #else
-        _res.nsaddr.sin_addr.s_addr = INADDR_ANY;
+        _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
-        _res.nscount = 1;
-        _res.ndots = 1;
-        _res.pfcode = 0;
-        strncpy(_res.lookups, "f", sizeof _res.lookups);
+        _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 ((cp = getenv("LOCALDOMAIN")) != NULL) {
-                (void)strncpy(_res.defdname, cp, sizeof(_res.defdname) - 1);
-                if ((cp = strpbrk(_res.defdname, " \t\n")) != NULL)
-                        *cp = '\0';
+        if (issetugid() == 0 && (cp = getenv("LOCALDOMAIN")) != NULL) {
+                strlcpy(_resp->defdname, cp, sizeof(_resp->defdname));
                 haveenv++;
 
                 /*
@@ -136,11 +254,11 @@ res_init()
                  * one that they want to use as an individual (even more
                  * important now that the rfc1535 stuff restricts searches)
                  */
-                cp = _res.defdname;
-                pp = _res.dnsrch;
+                cp = _resp->defdname;
+                pp = _resp->dnsrch;
                 *pp++ = cp;
-                for (n = 0; *cp && pp < _res.dnsrch + MAXDNSRCH; cp++) {
-                        if (*cp == '\n')        /* silly backwards compat */
+                for (n = 0; *cp && pp < _resp->dnsrch + MAXDNSRCH; cp++) {
+                        if (*cp == '\n')        /* silly backwards compat */
                                 break;
                         else if (*cp == ' ' || *cp == '\t') {
                                 *cp = 0;
@@ -158,16 +276,67 @@ res_init()
                 *pp++ = 0;
         }
 
+#define MATCH(line, name) \
+        (!strncmp(line, name, sizeof(name) - 1) && \
+        (line[sizeof(name) - 1] == ' ' || \
+         line[sizeof(name) - 1] == '\t'))
+
+        /* initialize family lookup preference: inet4 first */
+        _resp->family[0] = AF_INET;
+        _resp->family[1] = AF_INET6;
         if ((fp = fopen(_PATH_RESCONF, "r")) != NULL) {
-            strncpy(_res.lookups, "bf", sizeof _res.lookups);
+            strlcpy(_resp->lookups, "bf", sizeof _resp->lookups);
 
             /* read the config file */
-            while (fgets(buf, sizeof(buf), fp) != NULL) {
+            buf[0] = '\0';
+            while ((cp = fgetln(fp, &len)) != NULL) {
+                /* skip lines that are too long */
+                if (len >= sizeof(buf))
+                    continue;
+                (void)memcpy(buf, cp, len);
+                buf[len] = '\0';
                 /* skip comments */
-                if ((*buf == ';') || (*buf == '#'))
+                if ((cp = strpbrk(buf, ";#")) != NULL)
+                        *cp = '\0';
+                if (buf[0] == '\0')
                         continue;
+                /* set family lookup order */
+                if (MATCH(buf, "family")) {
+                        cp = buf + sizeof("family") - 1;
+                        cp += strspn(cp, " \t");
+                        cp[strcspn(cp, "\n")] = '\0';
+                        findex = 0;
+                        _resp->family[0] = _resp->family[1] = -1;
+#define INETLEN (sizeof("inetX") - 1)
+                        while (*cp != '\0' && findex < 2) {
+                                if (!strncmp(cp, "inet6", INETLEN)) {
+                                        _resp->family[findex] = AF_INET6;
+                                        cp += INETLEN;
+                                } else if (!strncmp(cp, "inet4", INETLEN)) {
+                                        _resp->family[findex] = AF_INET;
+                                        cp += INETLEN;
+                                } else {
+                                        _resp->family[0] = -1;
+                                        break;
+                                }
+                                if (*cp != ' ' && *cp != '\t' && *cp != '\0') {
+                                        _resp->family[findex] = -1;
+                                        break;
+                                }
+                                findex++;
+                                cp += strspn(cp, " \t");
+                        }
+
+                        if (_resp->family[0] == -1) {
+                                /* line contains errors, reset to defaults */
+                                _resp->family[0] = AF_INET;
+                                _resp->family[1] = AF_INET6;
+                        }
+                        if (_resp->family[0] == _resp->family[1])
+                                _resp->family[1] = -1;
+                }
                 /* read default domain name */
-                if (!strncmp(buf, "domain", sizeof("domain") - 1)) {
+                if (MATCH(buf, "domain")) {
                     if (haveenv)        /* skip if have from environ */
                             continue;
                     cp = buf + sizeof("domain") - 1;
@@ -175,18 +344,17 @@ res_init()
                             cp++;
                     if ((*cp == '\0') || (*cp == '\n'))
                             continue;
-                    (void)strncpy(_res.defdname, cp,
-                                  sizeof(_res.defdname) - 1);
-                    if ((cp = strpbrk(_res.defdname, " \t\n")) != NULL)
+                    strlcpy(_resp->defdname, cp, sizeof(_resp->defdname));
+                    if ((cp = strpbrk(_resp->defdname, " \t\n")) != NULL)
                             *cp = '\0';
                     havesearch = 0;
                     continue;
                 }
                 /* lookup types */
-                if (!strncmp(buf, "lookup", sizeof("lookup") -1)) {
+                if (MATCH(buf, "lookup")) {
                     char *sp = NULL;
 
-                    bzero(_res.lookups, sizeof _res.lookups);
+                    bzero(_resp->lookups, sizeof _resp->lookups);
                     cp = buf + sizeof("lookup") - 1;
                     for (n = 0;; cp++) {
                             if (n == MAXDNSLUS)
@@ -194,14 +362,14 @@ res_init()
                             if ((*cp == '\0') || (*cp == '\n')) {
                                     if (sp) {
                                             if (*sp=='y' || *sp=='b' || *sp=='f')
-                                                    _res.lookups[n++] = *sp;
+                                                    _resp->lookups[n++] = *sp;
                                             sp = NULL;
                                     }
                                     break;
                             } else if ((*cp == ' ') || (*cp == '\t') || (*cp == ',')) {
                                     if (sp) {
                                             if (*sp=='y' || *sp=='b' || *sp=='f')
-                                                    _res.lookups[n++] = *sp;
+                                                    _resp->lookups[n++] = *sp;
                                             sp = NULL;
                                     }
                             } else if (sp == NULL)
@@ -210,7 +378,7 @@ res_init()
                     continue;
                 }
                 /* set search list */
-                if (!strncmp(buf, "search", sizeof("search") - 1)) {
+                if (MATCH(buf, "search")) {
                     if (haveenv)        /* skip if have from environ */
                             continue;
                     cp = buf + sizeof("search") - 1;
@@ -218,18 +386,17 @@ res_init()
                             cp++;
                     if ((*cp == '\0') || (*cp == '\n'))
                             continue;
-                    (void)strncpy(_res.defdname, cp,
-                                  sizeof(_res.defdname) - 1);
-                    if ((cp = strchr(_res.defdname, '\n')) != NULL)
+                    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 = _res.defdname;
-                    pp = _res.dnsrch;
+                    cp = _resp->defdname;
+                    pp = _resp->dnsrch;
                     *pp++ = cp;
-                    for (n = 0; *cp && pp < _res.dnsrch + MAXDNSRCH; cp++) {
+                    for (n = 0; *cp && pp < _resp->dnsrch + MAXDNSRCH; cp++) {
                             if (*cp == ' ' || *cp == '\t') {
                                     *cp = 0;
                                     n = 1;
@@ -247,130 +414,274 @@ res_init()
                     continue;
                 }
                 /* read nameservers to query */
-                if (!strncmp(buf, "nameserver", sizeof("nameserver") - 1) &&
-                   nserv < MAXNS) {
-                   struct in_addr a;
+                if (MATCH(buf, "nameserver") && nserv < MAXNS) {
+                    char *q;
+                    struct addrinfo hints, *res;
+                    char pbuf[NI_MAXSERV];
 
                     cp = buf + sizeof("nameserver") - 1;
                     while (*cp == ' ' || *cp == '\t')
                         cp++;
-                    if ((*cp != '\0') && (*cp != '\n') && inet_aton(cp, &a)) {
-                        _res.nsaddr_list[nserv].sin_len = sizeof(struct sockaddr_in);
-                        _res.nsaddr_list[nserv].sin_family = AF_INET;
-                        _res.nsaddr_list[nserv].sin_port =
-                                htons(NAMESERVER_PORT);
-                        _res.nsaddr_list[nserv].sin_addr = a;
+                    if ((*cp == '\0') || (*cp == '\n'))
+                        continue;
+                    for (q = cp; *q; q++) {
+                        if (isspace(*q)) {
+                            *q = '\0';
+                            break;
+                        }
+                    }
+
+                    /* Handle addresses enclosed in [] */
+                    *pbuf = '\0';
+                    if (*cp == '[') {
+                        cp++;
+                        if ((q = strchr(cp, ']')) == NULL)
+                                continue;
+                        *q++ = '\0';
+                        /* Extract port, if specified */
+                        if (*q++ == ':') {
+                            if (strlcpy(pbuf, q, sizeof(pbuf)) >= sizeof(pbuf))
+                                continue;
+                        }
+                    }
+                    if (*pbuf == '\0')
+                        snprintf(pbuf, sizeof(pbuf), "%u", NAMESERVER_PORT);
+
+                    memset(&hints, 0, sizeof(hints));
+                    hints.ai_flags = AI_NUMERICHOST;
+                    hints.ai_socktype = SOCK_DGRAM;
+                    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);
                     continue;
                 }
-                if (!strncmp(buf, "sortlist", sizeof("sortlist") - 1)) {
+#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 (*cp == ' ' || *cp == '\t')
-                        cp++;
-                    while (sscanf(cp,"%[0-9./]s", buf2) && nsort < MAXRESOLVSORT) {
-                        if (net = strchr(buf2, '/'))
-                            *net = '\0';
-                        if (inet_aton(buf2, &a)) {
-                            _res.sort_list[nsort].addr = a;
-                            if (net && inet_aton(net+1, &a)) {
-                                _res.sort_list[nsort].mask = a.s_addr;
+                    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 {
-                                _res.sort_list[nsort].mask =
-                                        net_mask(_res.sort_list[nsort].addr);
+                                _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++;
                         }
-                        if (net)
-                                *net = '/';
-                        cp += strlen(buf2);
-                        while (*cp == ' ' || *cp == '\t')
-                            cp++;
+#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;
+                                }
+                                /* FALLTHROUGH */
+                            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;
                 }
-                if (!strncmp(buf, "options", sizeof("options") -1)) {
+#endif
+                if (MATCH(buf, "options")) {
                     res_setoptions(buf + sizeof("options") - 1, "conf");
                     continue;
                 }
             }
             if (nserv > 1) 
-                _res.nscount = nserv;
-            _res.nsort = nsort;
+                _resp->nscount = nserv;
+#ifdef RESOLVSORT
+            _resp->nsort = nsort;
+#endif
             (void) fclose(fp);
         }
-        if (_res.defdname[0] == 0) {
-                if (gethostname(buf, sizeof(_res.defdname) - 1) == 0 &&
-                   (cp = strchr(buf, '.')))
-                        (void)strcpy(_res.defdname, cp + 1);
+        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 = _res.dnsrch;
-                *pp++ = _res.defdname;
-#ifndef SEARCH_LOCAL_DOMAINS
+                pp = _resp->dnsrch;
+                *pp++ = _resp->defdname;
                 *pp = NULL;
-#else
-                for (cp = _res.defdname, n = 0; *cp; cp++)
-                        if (*cp == '.')
-                                n++;
-                cp = _res.defdname;
-                for (; n >= LOCALDOMAINPARTS && pp < _res.dnsrch + MAXDFLSRCH;
-                    n--) {
-                        cp = strchr(cp, '.');
-                        *pp++ = ++cp;
+
+#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++ = 0;
-#endif
+                *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 ((cp = getenv("RES_OPTIONS")) != NULL)
+        if (issetugid())
+                _resp->options |= RES_NOALIASES;
+        else if ((cp = getenv("RES_OPTIONS")) != NULL)
                 res_setoptions(cp, "env");
-        _res.options |= RES_INIT;
+        _resp->options |= RES_INIT;
         return (0);
 }
 
+/* ARGSUSED */
 static void
-res_setoptions(options, source)
-        char *options, *source;
+res_setoptions(char *options, char *source)
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
         char *cp = options;
-        int i;
+        char *endp;
+        long l;
 
 #ifdef DEBUG
-        if (_res.options & RES_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)) {
-                        i = atoi(cp + sizeof("ndots:") - 1);
-                        if (i <= RES_MAXNDOTS)
-                                _res.ndots = i;
-                        else
-                                _res.ndots = RES_MAXNDOTS;
+                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 (_res.options & RES_DEBUG) {
-                                printf(";;\tndots=%d\n", _res.ndots);
-                        }
+                                if (_resp->options & RES_DEBUG)
+                                        printf(";;\tndots=%u\n", _resp->ndots);
 #endif
-                } else if (!strncmp(cp, "debug", sizeof("debug")-1)) {
+                        }
+                } else if (!strncmp(cp, "debug", sizeof("debug") - 1)) {
 #ifdef DEBUG
-                        if (!(_res.options & RES_DEBUG)) {
+                        if (!(_resp->options & RES_DEBUG)) {
                                 printf(";; res_setoptions(\"%s\", \"%s\")..\n",
                                        options, source);
-                                _res.options |= RES_DEBUG;
+                                _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 if (!strncmp(cp, "tcp", sizeof("tcp") - 1)) {
+                        _resp->options |= RES_USEVC;
                 } else {
                         /* XXX - print a warning here? */
                 }
@@ -380,15 +691,17 @@ res_setoptions(options, source)
         }
 }
 
+#ifdef RESOLVSORT
+/* XXX - should really support CIDR which means explicit masks always. */
 static u_int32_t
-net_mask(in)            /* XXX - should really use system's version of this */
-        struct in_addr in;
+net_mask(struct in_addr in)     /* XXX - should really use system's version of this */
 {
-        register u_int32_t i = ntohl(in.s_addr);
+        u_int32_t i = ntohl(in.s_addr);
 
         if (IN_CLASSA(i))
                 return (htonl(IN_CLASSA_NET));
-        if (IN_CLASSB(i))
+        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
index 25f025e147..5c6b273abe 100644
--- a/src/lib/libc/net/res_mkquery.c
+++ b/src/lib/libc/net/res_mkquery.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_mkquery.c,v 1.5 1995/02/25 06:20:58 cgd Exp $      */
+/*      $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.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,101 +51,109 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_mkquery.c       8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: res_mkquery.c,v 4.9.1.2 1993/05/17 10:00:01 vixie Exp ";
-#else
-static char rcsid[] = "$NetBSD: res_mkquery.c,v 1.5 1995/02/25 06:20:58 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/nameser.h>
-#include <resolv.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.
  */
-res_mkquery(op, dname, class, type, data, datalen, newrr_in, buf, buflen)
-        int op;                 /* opcode of query */
-        const char *dname;              /* domain name */
-        int class, type;        /* class and type of query */
-        const char *data;               /* resource record data */
-        int datalen;            /* length of data */
-        const char *newrr_in;   /* new rr for modify or append */
-        char *buf;              /* buffer to put query */
-        int buflen;             /* size of buffer */
+/* 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 */
 {
-        register HEADER *hp;
-        register char *cp;
-        register int n;
-        struct rrec *newrr = (struct rrec *) newrr_in;
-        char *dnptrs[10], **dpp, **lastdnptr;
+        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 (_res.options & RES_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 < sizeof(HEADER)))
-                return(-1);
-        bzero(buf, sizeof(HEADER));
+
+        if ((buf == NULL) || (buflen < HFIXEDSZ))
+                return (-1);
+        bzero(buf, HFIXEDSZ);
         hp = (HEADER *) buf;
-        hp->id = htons(++_res.id);
+        _resp->id = res_randomid();
+        hp->id = htons(_resp->id);
         hp->opcode = op;
-        hp->pr = (_res.options & RES_PRIMARY) != 0;
-        hp->rd = (_res.options & RES_RECURSE) != 0;
+        hp->rd = (_resp->options & RES_RECURSE) != 0;
         hp->rcode = NOERROR;
-        cp = buf + sizeof(HEADER);
-        buflen -= sizeof(HEADER);
+        cp = buf + HFIXEDSZ;
+        ep = buf + buflen;
         dpp = dnptrs;
         *dpp++ = buf;
         *dpp++ = NULL;
-        lastdnptr = dnptrs + sizeof(dnptrs)/sizeof(dnptrs[0]);
+        lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
         /*
          * perform opcode specific processing
          */
         switch (op) {
-        case QUERY:
-                if ((buflen -= QFIXEDSZ) < 0)
-                        return(-1);
-                if ((n = dn_comp((u_char *)dname, (u_char *)cp, buflen,
-                    (u_char **)dnptrs, (u_char **)lastdnptr)) < 0)
+        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;
-                buflen -= n;
-                __putshort(type, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                __putshort(class, (u_char *)cp);
-                cp += sizeof(u_int16_t);
+                __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.
                  */
-                buflen -= RRFIXEDSZ;
-                if ((n = dn_comp((u_char *)data, (u_char *)cp, buflen,
-                    (u_char **)dnptrs, (u_char **)lastdnptr)) < 0)
+                if (ep - cp < RRFIXEDSZ)
+                        return (-1);
+                n = dn_comp((char *)data, cp, ep - cp - RRFIXEDSZ, dnptrs,
+                    lastdnptr);
+                if (n < 0)
                         return (-1);
                 cp += n;
-                buflen -= n;
-                __putshort(T_NULL, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                __putshort(class, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                __putlong(0, (u_char *)cp);
-                cp += sizeof(u_int32_t);
-                __putshort(0, (u_char *)cp);
-                cp += sizeof(u_int16_t);
+                __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;
 
@@ -155,82 +161,72 @@ res_mkquery(op, dname, class, type, data, datalen, newrr_in, buf, buflen)
                 /*
                  * Initialize answer section
                  */
-                if (buflen < 1 + RRFIXEDSZ + datalen)
+                if (ep - cp < 1 + RRFIXEDSZ + datalen)
                         return (-1);
                 *cp++ = '\0';   /* no domain name */
-                __putshort(type, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                __putshort(class, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                __putlong(0, (u_char *)cp);
-                cp += sizeof(u_int32_t);
-                __putshort(datalen, (u_char *)cp);
-                cp += sizeof(u_int16_t);
-                if (datalen) {
-                        bcopy(data, cp, datalen);
-                        cp += datalen;
-                }
-                hp->ancount = htons(1);
-                break;
-
-#ifdef ALLOW_UPDATES
-        /*
-         * For UPDATEM/UPDATEMA, do UPDATED/UPDATEDA followed by UPDATEA
-         * (Record to be modified is followed by its replacement in msg.)
-         */
-        case UPDATEM:
-        case UPDATEMA:
-
-        case UPDATED:
-                /*
-                 * The res code for UPDATED and UPDATEDA is the same; user
-                 * calls them differently: specifies data for UPDATED; server
-                 * ignores data if specified for UPDATEDA.
-                 */
-        case UPDATEDA:
-                buflen -= RRFIXEDSZ + datalen;
-                if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
-                        return (-1);
-                cp += n;
                 __putshort(type, cp);
-                cp += sizeof(u_int16_t);
-                __putshort(class, cp);
-                cp += sizeof(u_int16_t);
+                cp += INT16SZ;
+                __putshort(class, cp);
+                cp += INT16SZ;
                 __putlong(0, cp);
-                cp += sizeof(u_int32_t);
+                cp += INT32SZ;
                 __putshort(datalen, cp);
-                cp += sizeof(u_int16_t);
+                cp += INT16SZ;
                 if (datalen) {
                         bcopy(data, cp, datalen);
                         cp += datalen;
                 }
-                if ( (op == UPDATED) || (op == UPDATEDA) ) {
-                        hp->ancount = htons(0);
-                        break;
-                }
-                /* Else UPDATEM/UPDATEMA, so drop into code for UPDATEA */
-
-        case UPDATEA:   /* Add new resource record */
-                buflen -= RRFIXEDSZ + datalen;
-                if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
-                        return (-1);
-                cp += n;
-                __putshort(newrr->r_type, cp);
-                cp += sizeof(u_int16_t);
-                __putshort(newrr->r_class, cp);
-                cp += sizeof(u_int16_t);
-                __putlong(0, cp);
-                cp += sizeof(u_int32_t);
-                __putshort(newrr->r_size, cp);
-                cp += sizeof(u_int16_t);
-                if (newrr->r_size) {
-                        bcopy(newrr->r_data, cp, newrr->r_size);
-                        cp += newrr->r_size;
-                }
-                hp->ancount = htons(0);
+                hp->ancount = htons(1);
                 break;
 
-#endif /* ALLOW_UPDATES */
+        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
index 7649462e56..1485abb2d7 100644
--- a/src/lib/libc/net/res_query.c
+++ b/src/lib/libc/net/res_query.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $        */
+/*      $OpenBSD: res_query.c,v 1.26 2010/06/29 21:08:54 deraadt Exp $  */
 
-/*-
+/*
+ * ++Copyright++ 1988, 1993
+ * -
  * Copyright (c) 1988, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,26 +51,22 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_query.c 8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: res_query.c,v 1.1 1993/06/01 09:42:14 vixie Exp vixie ";
-#else
-static char rcsid[] = "$NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
+#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 <stdio.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
@@ -80,8 +74,9 @@ static char rcsid[] = "$NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $"
 #define MAXPACKET       1024
 #endif
 
-char *__hostalias __P((const char *));
+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.
@@ -90,68 +85,82 @@ int h_errno;
  * 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.
  */
-res_query(name, class, type, answer, anslen)
-        char *name;             /* domain name */
-        int class, type;        /* class and type of query */
-        u_char *answer;         /* buffer to put answer */
-        int anslen;             /* size of answer buffer */
+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 */
 {
-        char buf[MAXPACKET];
-        HEADER *hp;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        union {
+                HEADER hdr;
+                u_char buf[MAXPACKET];
+        } buf;
+        HEADER *hp = (HEADER *) answer;
         int n;
 
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
+        hp->rcode = NOERROR;    /* default */
+
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
                 return (-1);
+        }
 #ifdef DEBUG
-        if (_res.options & RES_DEBUG)
+        if (_resp->options & RES_DEBUG)
                 printf(";; res_query(%s, %d, %d)\n", name, class, type);
 #endif
-        n = res_mkquery(QUERY, name, class, type, (char *)NULL, 0, NULL,
-            buf, sizeof(buf));
+
+        n = res_mkquery(QUERY, name, class, type, NULL, 0, NULL,
+                        buf.buf, sizeof(buf.buf));
+        if (n > 0 && ((_resp->options & RES_USE_EDNS0) ||
+            (_resp->options & RES_USE_DNSSEC))) {
+                n = res_opt(n, buf.buf, sizeof(buf.buf), anslen);
+        }
 
         if (n <= 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
+                if (_resp->options & RES_DEBUG)
                         printf(";; res_query: mkquery failed\n");
 #endif
                 h_errno = NO_RECOVERY;
                 return (n);
         }
-        n = res_send(buf, n, (char *)answer, anslen);
+        n = res_send(buf.buf, n, answer, anslen);
         if (n < 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
+                if (_resp->options & RES_DEBUG)
                         printf(";; res_query: send error\n");
 #endif
                 h_errno = TRY_AGAIN;
                 return (n);
         }
 
-        hp = (HEADER *) answer;
         if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
 #ifdef DEBUG
-                if (_res.options & RES_DEBUG)
-                        printf(";; rcode = %d, ancount=%d\n", hp->rcode,
+                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;
+                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);
         }
@@ -162,39 +171,39 @@ res_query(name, class, type, answer, anslen)
  * 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 number is left in h_errno.
- * Only useful for queries in the same name hierarchy as the local host
- * (not, for example, for host address-to-name lookups in domain in-addr.arpa).
+ * is detected.  Error code, if any, is left in h_errno.
  */
 int
-res_search(name, class, type, answer, anslen)
-        const char *name;       /* domain name */
-        int class, type;        /* class and type of query */
-        u_char *answer;         /* buffer to put answer */
-        int anslen;             /* size of answer */
+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 */
 {
-        register char *cp, **domain;
-        int dots, trailing_dot, ret, got_nodata, saved_herrno, tried_as_is;
+        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.options & RES_INIT) == 0 && res_init() == -1)
+        if (_res_init(0) == -1) {
+                h_errno = NETDB_INTERNAL;
                 return (-1);
-
-        got_nodata = 0;
+        }
         errno = 0;
         h_errno = HOST_NOT_FOUND;       /* default, if we never query */
         dots = 0;
-        for (cp = (char *)name; *cp; cp++) {
-                if (*cp == '.')
-                        dots++;
-        }
+        for (cp = name; *cp; cp++)
+                dots += (*cp == '.');
         trailing_dot = 0;
-        if ((cp > name) && (*--cp == '.'))
+        if (cp > name && *--cp == '.')
                 trailing_dot++;
 
         /*
          * if there aren't any dots, it could be a user-level alias
          */
-        if (!dots && (cp = __hostalias(name)))
+        if (!dots && (cp = __hostalias(name)) != NULL)
                 return (res_query(cp, class, type, answer, anslen));
 
         /*
@@ -202,8 +211,7 @@ res_search(name, class, type, answer, anslen)
          * 'as is'.  The threshold can be set with the "ndots" option.
          */
         saved_herrno = -1;
-        tried_as_is = 0;
-        if (dots >= _res.ndots) {
+        if (dots >= _resp->ndots) {
                 ret = res_querydomain(name, NULL, class, type, answer, anslen);
                 if (ret > 0)
                         return (ret);
@@ -217,15 +225,19 @@ res_search(name, class, type, answer, anslen)
          *      - there is at least one dot, there is no trailing dot,
          *        and RES_DNSRCH is set.
          */
-        if ((!dots && (_res.options & RES_DEFNAMES)) ||
-            (dots && !trailing_dot && (_res.options & RES_DNSRCH))) {
-                for (domain = _res.dnsrch; *domain; domain++) {
-                        int done = 0;
+        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);
+                                              answer, anslen);
                         if (ret > 0)
                                 return (ret);
+
                         /*
                          * If no server present, give up.
                          * If name isn't found in this domain,
@@ -251,24 +263,27 @@ res_search(name, class, type, answer, anslen)
                         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,
+
+                        /* if we got here for some reason other than DNSRCH,
                          * we only wanted one iteration of the loop, so stop.
                          */
-                        if (!(_res.options & RES_DNSRCH))
-                                done++;
-
-                        if (done)
-                                break;
+                        if (!(_resp->options & RES_DNSRCH))
+                                done++;
                 }
         }
 
-        /*
-         * if we have not already tried the name "as is", do that now.
+        /* 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.
          */
@@ -276,11 +291,9 @@ res_search(name, class, type, answer, anslen)
                 ret = res_querydomain(name, NULL, class, type, answer, anslen);
                 if (ret > 0)
                         return (ret);
-                saved_herrno = h_errno;
         }
 
-        /*
-         * if we got here, we didn't satisfy the search.
+        /* 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.
@@ -291,6 +304,8 @@ res_search(name, class, type, answer, anslen)
                 h_errno = saved_herrno;
         else if (got_nodata)
                 h_errno = NO_DATA;
+        else if (got_servfail)
+                h_errno = TRY_AGAIN;
         return (-1);
 }
 
@@ -298,20 +313,29 @@ res_search(name, class, type, answer, anslen)
  * Perform a call on res_query on the concatenation of name and domain,
  * removing a trailing dot from name if domain is NULL.
  */
-res_querydomain(name, domain, class, type, answer, anslen)
-        char *name, *domain;
-        int class, type;        /* class and type of query */
-        u_char *answer;         /* buffer to put answer */
-        int anslen;             /* size of answer */
+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 */
 {
-        char nbuf[2*MAXDNAME+2];
-        char *longname = nbuf;
+#ifdef DEBUG
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+#endif
+        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 (_res.options & RES_DEBUG)
+        if (_resp->options & RES_DEBUG)
                 printf(";; res_querydomain(%s, %s, %d, %d)\n",
-                    name, domain, class, type);
+                       name, domain?domain:"<Nil>", class, type);
 #endif
         if (domain == NULL) {
                 /*
@@ -325,38 +349,51 @@ res_querydomain(name, domain, class, type, answer, anslen)
                 } else
                         longname = name;
         } else
-                (void)sprintf(nbuf, "%.*s.%.*s",
+                snprintf(nbuf, sizeof nbuf, "%.*s.%.*s",
                     MAXDNAME, name, MAXDNAME, domain);
 
         return (res_query(longname, class, type, answer, anslen));
 }
 
-char *
-__hostalias(name)
-        register const char *name;
+const char *
+hostalias(const char *name)
 {
-        register char *cp1, *cp2;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char *cp1, *cp2;
         FILE *fp;
-        char *file, *getenv(), *strcpy(), *strncpy();
+        char *file;
         char buf[BUFSIZ];
         static char abuf[MAXDNAME];
+        size_t len;
 
+        if (_resp->options & RES_NOALIASES)
+                return (NULL);
         file = getenv("HOSTALIASES");
-        if (file == NULL || (fp = fopen(file, "r")) == NULL)
+        if (issetugid() != 0 || file == NULL || (fp = fopen(file, "r")) == NULL)
                 return (NULL);
-        buf[sizeof(buf) - 1] = '\0';
-        while (fgets(buf, sizeof(buf), fp)) {
-                for (cp1 = buf; *cp1 && !isspace(*cp1); ++cp1);
+        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));
+                        while (isspace(*++cp1))
+                                ;
                         if (!*cp1)
                                 break;
-                        for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2);
-                        abuf[sizeof(abuf) - 1] = *cp2 = '\0';
-                        (void)strncpy(abuf, cp1, sizeof(abuf) - 1);
+                        for (cp2 = cp1 + 1; *cp2 && !isspace(*cp2); ++cp2)
+                                ;
+                        *cp2 = '\0';
+                        strlcpy(abuf, cp1, sizeof(abuf));
                         fclose(fp);
                         return (abuf);
                 }
diff --git a/src/lib/libc/net/res_random.c b/src/lib/libc/net/res_random.c
new file mode 100644
index 0000000000..f0beb7a573
--- /dev/null
+++ b/src/lib/libc/net/res_random.c
@@ -0,0 +1,264 @@
+/* $OpenBSD: res_random.c,v 1.17 2008/04/13 00:28:35 djm Exp $ */
+
+/*
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * Copyright 2008 Damien Miller <djm@openbsd.org>
+ * 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.
+ *
+ * Later modified by Damien Miller to wrap the LCG output in a 15-bit
+ * permutation generator based on a Luby-Rackoff block cipher. This
+ * ensures the output is non-repeating and preserves the MSB twiddle
+ * trick, but makes it more resistant to LCG prediction.
+ *
+ * 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 output of this generator is then randomly permuted though a
+ * custom 15 bit Luby-Rackoff block cipher.
+ */
+
+#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 RU_ROUNDS       11      /* Number of rounds for permute (odd) */
+
+struct prf_ctx {
+        /* PRF lookup table for odd rounds (7 bits input to 8 bits output) */
+        u_char prf7[(RU_ROUNDS / 2) * (1 << 7)];
+
+        /* PRF lookup table for even rounds (8 bits input to 7 bits output) */
+        u_char prf8[((RU_ROUNDS + 1) / 2) * (1 << 8)];
+};
+
+#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 struct prf_ctx *ru_prf = NULL;
+static long ru_reseed;
+
+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);
+}
+
+/*
+ * 15-bit permutation based on Luby-Rackoff block cipher
+ */
+u_int
+permute15(u_int in)
+{
+        int i;
+        u_int left, right, tmp;
+
+        if (ru_prf == NULL)
+                return in;
+
+        left = (in >> 8) & 0x7f;
+        right = in & 0xff;
+
+        /*
+         * Each round swaps the width of left and right. Even rounds have
+         * a 7-bit left, odd rounds have an 8-bit left. Since this uses an
+         * odd number of rounds, left is always 8 bits wide at the end.
+         */
+        for (i = 0; i < RU_ROUNDS; i++) {
+                if ((i & 1) == 0)
+                        tmp = ru_prf->prf8[(i << (8 - 1)) | right] & 0x7f;
+                else
+                        tmp = ru_prf->prf7[((i - 1) << (7 - 1)) | right];
+                tmp ^= left;
+                left = right;
+                right = tmp;
+        }
+
+        return (right << 8) | left;
+}
+
+/* 
+ * 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;
+        u_int32_t tmp;
+        int noprime = 1;
+        struct timeval tv;
+
+        ru_x = arc4random_uniform(RU_M);
+
+        /* 15 bits of random seed */
+        tmp = arc4random();
+        ru_seed = (tmp >> 16) & 0x7FFF;
+        ru_seed2 = tmp & 0x7FFF;
+
+        /* Determine the LCG we use */
+        tmp = arc4random();
+        ru_b = (tmp & 0xfffe) | 1;
+        ru_a = pmod(RU_AGEN, (tmp >> 16) & 0xfffe, RU_M);
+        while (ru_b % 3 == 0)
+                ru_b += 2;
+        
+        j = arc4random_uniform(RU_N);
+
+        /* 
+         * 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;
+
+        /* Initialise PRF for Luby-Rackoff permutation */
+        if (ru_prf == NULL)
+                ru_prf = malloc(sizeof(*ru_prf));
+        if (ru_prf != NULL)
+                arc4random_buf(ru_prf, sizeof(*ru_prf));
+
+        gettimeofday(&tv, NULL);
+        ru_reseed = tv.tv_sec + RU_OUT;
+        ru_msb = ru_msb == 0x8000 ? 0 : 0x8000; 
+}
+
+u_int
+res_randomid(void)
+{
+        struct timeval tv;
+
+        gettimeofday(&tv, NULL);
+        if (ru_counter >= RU_MAX || tv.tv_sec > ru_reseed)
+                res_initid();
+
+        /* Linear Congruential Generator */
+        ru_x = (ru_a * ru_x + ru_b) % RU_M;
+        ru_counter++;
+
+        return permute15(ru_seed ^ pmod(ru_g, ru_seed2 + ru_x, RU_N)) | ru_msb;
+}
+
+#if 0
+int
+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 = argc > 1 ? atoi(argv[1]) : 60001;
+        for (i=0;i<n;i++) {
+                wert = res_randomid();
+                printf("%u\n", wert);
+        }
+        return 0;
+}
+#endif
+
diff --git a/src/lib/libc/net/res_send.c b/src/lib/libc/net/res_send.c
index e608358180..09b1385892 100644
--- a/src/lib/libc/net/res_send.c
+++ b/src/lib/libc/net/res_send.c
@@ -1,9 +1,11 @@
-/*      $NetBSD: res_send.c,v 1.4 1995/02/25 06:21:01 cgd Exp $ */
+/*      $OpenBSD: res_send.c,v 1.21 2008/05/11 05:03:03 brad Exp $      */
 
-/*-
+/*
+ * ++Copyright++ 1985, 1989, 1993
+ * -
  * Copyright (c) 1985, 1989, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
+ *    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:
@@ -12,14 +14,10 @@
  * 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
+ * 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
@@ -53,19 +51,22 @@
  * --Copyright--
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)res_send.c  8.1 (Berkeley) 6/4/93";
-static char rcsid[] = "$Id: res_send.c,v 4.9.1.1 1993/05/02 22:43:03 vixie Rel ";
-#else
-static char rcsid[] = "$NetBSD: res_send.c,v 1.4 1995/02/25 06:21:01 cgd Exp $";
+#ifndef INET6
+#define INET6
 #endif
-#endif /* LIBC_SCCS and not lint */
+
+        /* 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>
@@ -73,139 +74,401 @@ static char rcsid[] = "$NetBSD: res_send.c,v 1.4 1995/02/25 06:21:01 cgd Exp $";
 #include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <arpa/inet.h>
-#include <stdio.h>
+
 #include <errno.h>
+#include <netdb.h>
+#include <poll.h>
 #include <resolv.h>
-#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#include "thread_private.h"
 
 static int s = -1;      /* socket used for communications */
-static struct sockaddr no_addr;
-
-#ifndef FD_SET
-#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)))
+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 */
+
+#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
 
-res_send(buf, buflen, answer, anslen)
-        const char *buf;
-        int buflen;
-        char *answer;
-        int anslen;
+static res_send_qhook Qhook = NULL;
+static res_send_rhook Rhook = NULL;
+
+void
+res_send_setqhook(res_send_qhook hook)
 {
-        register int n;
-        int try, v_circuit, resplen, ns;
-        int gotsomewhere = 0, connected = 0;
-        int connreset = 0;
-        u_short id, len;
-        char *cp;
-        fd_set dsmask;
-        struct timeval timeout;
-        HEADER *hp = (HEADER *) buf;
-        HEADER *anhp = (HEADER *) answer;
-        u_int badns;            /* XXX NSMAX can't exceed #/bits per this */
-        struct iovec iov[2];
-        int terrno = ETIMEDOUT;
-        char junk[512];
-
-#ifdef DEBUG
-        if ((_res.options & RES_DEBUG) || (_res.pfcode & RES_PRF_QUERY)) {
-                printf(";; res_send()\n");
-                __p_query(buf);
+
+        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
-        if (!(_res.options & RES_INIT))
-                if (res_init() == -1) {
-                        return(-1);
+        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;
+                        }
                 }
-        v_circuit = (_res.options & RES_USEVC) || buflen > PACKETSZ;
-        id = hp->id;
+                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 < _res.retry; try++) {
-            for (ns = 0; ns < _res.nscount; ns++) {
-                if (badns & (1<<ns))
-                        continue;
-#ifdef DEBUG
-                if (_res.options & RES_DEBUG)
-                        printf(";; Querying server (# %d) address = %s\n",
-                               ns+1,
-                               inet_ntoa(_res.nsaddr_list[ns].sin_addr));
+        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
-        usevc:
+                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 = 0;
+                        int truncated;
+                        struct iovec iov[2];
+                        u_short len;
+                        u_char *cp;
 
                         /*
                          * Use virtual circuit;
                          * at most one attempt per server.
                          */
-                        try = _res.retry;
-                        if (s < 0) {
-                                s = socket(AF_INET, SOCK_STREAM, 0);
+                        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;
-#ifdef DEBUG
-                                        if (_res.options & RES_DEBUG)
-                                            perror("socket (vc) failed");
+                                        Perror(stderr, "socket(vc)", errno);
+#if 0
+                                        return (-1);
+#else
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
 #endif
-                                        continue;
                                 }
-                                if (connect(s,
-                                    (struct sockaddr *)&(_res.nsaddr_list[ns]),
-                                    sizeof(struct sockaddr)) < 0) {
+                                errno = 0;
+                                if (connect(s, nsap, salen) < 0) {
                                         terrno = errno;
-#ifdef DEBUG
-                                        if (_res.options & RES_DEBUG)
-                                            perror("connect failed");
-#endif
-                                        (void) close(s);
-                                        s = -1;
-                                        continue;
+                                        Aerror(stderr, "connect/vc",
+                                               errno, nsap);
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
                                 }
+                                vc = 1;
                         }
                         /*
                          * Send length & message
                          */
-                        len = htons((u_short)buflen);
+                        putshort((u_short)buflen, (u_char*)&len);
                         iov[0].iov_base = (caddr_t)&len;
-                        iov[0].iov_len = sizeof(len);
-                        iov[1].iov_base = (char *)buf;
+                        iov[0].iov_len = INT16SZ;
+                        iov[1].iov_base = (caddr_t)buf;
                         iov[1].iov_len = buflen;
-                        if (writev(s, iov, 2) != sizeof(len) + buflen) {
+                        if (writev(s, iov, 2) != (INT16SZ + buflen)) {
                                 terrno = errno;
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("write failed");
-#endif
-                                (void) close(s);
-                                s = -1;
-                                continue;
+                                Perror(stderr, "write failed", errno);
+                                badns |= (1 << ns);
+                                res_close();
+                                goto next_ns;
                         }
                         /*
                          * Receive length & response
                          */
-                        cp = answer;
-                        len = sizeof(short);
-                        while (len != 0 &&
-                            (n = read(s, (char *)cp, (int)len)) > 0) {
+ read_len:
+                        cp = ans;
+                        len = INT16SZ;
+                        while ((n = read(s, (char *)cp, (int)len)) > 0) {
                                 cp += n;
-                                len -= n;
+                                if ((len -= n) <= 0)
+                                        break;
                         }
                         if (n <= 0) {
                                 terrno = errno;
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("read failed");
-#endif
-                                (void) close(s);
-                                s = -1;
+                                Perror(stderr, "read failed", errno);
+                                res_close();
                                 /*
                                  * A long running process might get its TCP
                                  * connection reset if the remote server was
@@ -217,35 +480,32 @@ res_send(buf, buflen, answer, anslen)
                                  */
                                 if (terrno == ECONNRESET && !connreset) {
                                         connreset = 1;
-                                        ns--;
+                                        res_close();
+                                        goto same_ns;
                                 }
-                                continue;
+                                res_close();
+                                goto next_ns;
                         }
-                        cp = answer;
-                        if ((resplen = ntohs(*(u_short *)cp)) > anslen) {
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        fprintf(stderr,
-                                                ";; response truncated\n");
-#endif
-                                len = anslen;
+                        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) {
+                               (n = read(s, (char *)cp, (int)len)) > 0) {
                                 cp += n;
                                 len -= n;
                         }
                         if (n <= 0) {
                                 terrno = errno;
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("read failed");
-#endif
-                                (void) close(s);
-                                s = -1;
-                                continue;
+                                Perror(stderr, "read(vc)", errno);
+                                res_close();
+                                goto next_ns;
                         }
                         if (truncated) {
                                 /*
@@ -253,40 +513,79 @@ res_send(buf, buflen, answer, anslen)
                                  * so connection stays in synch.
                                  */
                                 anhp->tc = 1;
-                                len = resplen - anslen;
+                                len = resplen - anssiz;
                                 while (len != 0) {
-                                        n = (len > sizeof(junk) ?
-                                            sizeof(junk) : len);
+                                        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.
                          */
-                        if (s < 0) {
-                                s = socket(AF_INET, SOCK_DGRAM, 0);
+                        struct pollfd pfd;
+                        int timeout;
+                        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;
-#ifdef DEBUG
-                                        if (_res.options & RES_DEBUG)
-                                            perror("socket (dg) failed");
+                                        Perror(stderr, "socket(dg)", errno);
+#if 0
+                                        return (-1);
+#else
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
 #endif
-                                        continue;
                                 }
+#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;
                         }
                         /*
-                         * I'm tired of answering this question, so:
                          * 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
+                         * socket operation, and poll 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,
@@ -294,31 +593,28 @@ res_send(buf, buflen, answer, anslen)
                          * as we wish to receive answers from the first
                          * server to respond.
                          */
-                        if (_res.nscount == 1 || (try == 0 && ns == 0)) {
+                        if (!(_resp->options & RES_INSECURE1) &&
+                            (_resp->nscount == 1 || (try == 0 && ns == 0))) {
                                 /*
-                                 * Don't use connect if we might
-                                 * still receive a response
-                                 * from another server.
+                                 * Connect only if we are sure we won't
+                                 * receive a response from another server.
                                  */
-                                if (connected == 0) {
-                                        if (connect(s,
-                                            (struct sockaddr *)
-                                            &_res.nsaddr_list[ns],
-                                            sizeof(struct sockaddr)) < 0) {
-#ifdef DEBUG
-                                                if (_res.options & RES_DEBUG)
-                                                        perror("connect");
-#endif
-                                                continue;
+                                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, buf, buflen, 0) != buflen) {
-#ifdef DEBUG
-                                        if (_res.options & RES_DEBUG)
-                                                perror("send");
-#endif
-                                        continue;
+                                if (send(s, (char*)buf, buflen, 0) != buflen) {
+                                        Perror(stderr, "send", errno);
+                                        badns |= (1 << ns);
+                                        res_close();
+                                        goto next_ns;
                                 }
                         } else {
                                 /*
@@ -326,134 +622,213 @@ res_send(buf, buflen, answer, anslen)
                                  * for responses from more than one server.
                                  */
                                 if (connected) {
-                                        (void) connect(s, &no_addr,
-                                            sizeof(no_addr));
+#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, buf, buflen, 0,
-                                    (struct sockaddr *)&_res.nsaddr_list[ns],
-                                    sizeof(struct sockaddr)) != buflen) {
-#ifdef DEBUG
-                                        if (_res.options & RES_DEBUG)
-                                                perror("sendto");
-#endif
-                                        continue;
+                                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 = (_res.retrans << try);
+                        timeout = 1000 * (_resp->retrans << try);
                         if (try > 0)
-                                timeout.tv_sec /= _res.nscount;
-                        if ((long) timeout.tv_sec <= 0)
-                                timeout.tv_sec = 1;
-                        timeout.tv_usec = 0;
-wait:
-                        FD_ZERO(&dsmask);
-                        FD_SET(s, &dsmask);
-                        n = select(s+1, &dsmask, (fd_set *)NULL,
-                                (fd_set *)NULL, &timeout);
+                                timeout /= _resp->nscount;
+                        if (timeout < 1000)
+                                timeout = 1000;
+    wait:
+                        pfd.fd = s;
+                        pfd.events = POLLIN;
+                        n = poll(&pfd, 1, timeout);
                         if (n < 0) {
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("select");
-#endif
-                                continue;
+                                if (errno == EINTR)
+                                        goto wait;
+                                Perror(stderr, "poll", errno);
+                                res_close();
+                                goto next_ns;
                         }
                         if (n == 0) {
                                 /*
                                  * timeout
                                  */
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        printf(";; timeout\n");
-#endif
+                                Dprint(_resp->options & RES_DEBUG,
+                                       (stdout, ";; timeout\n"));
                                 gotsomewhere = 1;
-                                continue;
+                                res_close();
+                                goto next_ns;
                         }
-                        if ((resplen = recv(s, answer, anslen, 0)) <= 0) {
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("recvfrom");
-#endif
-                                continue;
+                        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 (id != anhp->id) {
+                        if (hp->id != anhp->id) {
                                 /*
-                                 * response from old query, ignore it
+                                 * response from old query, ignore it.
+                                 * XXX - potential security hazard could
+                                 *       be detected here.
                                  */
-#ifdef DEBUG
-                                if ((_res.options & RES_DEBUG) ||
-                                    (_res.pfcode & RES_PRF_REPLY)) {
-                                        printf(";; old answer:\n");
-                                        __p_query(answer);
-                                }
+                                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 ||
+                        if (anhp->rcode == SERVFAIL ||
+                            anhp->rcode == NOTIMP ||
                             anhp->rcode == REFUSED) {
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG) {
-                                        printf("server rejected query:\n");
-                                        __p_query(answer);
-                                }
-#endif
-                                badns |= (1<<ns);
-                                continue;
+                                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 (!(_res.options & RES_IGNTC) && anhp->tc) {
+                        if (!(_resp->options & RES_IGNTC) && anhp->tc) {
                                 /*
                                  * get rest of answer;
                                  * use TCP with same server.
                                  */
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        printf(";; truncated answer\n");
-#endif
-                                (void) close(s);
-                                s = -1;
+                                Dprint(_resp->options & RES_DEBUG,
+                                       (stdout, ";; truncated answer\n"));
                                 v_circuit = 1;
-                                goto usevc;
+                                res_close();
+                                goto same_ns;
                         }
-                }
-#ifdef DEBUG
-                if (_res.options & RES_DEBUG)
-                        printf(";; got answer:\n");
-                if ((_res.options & RES_DEBUG) ||
-                    (_res.pfcode & RES_PRF_REPLY))
-                        __p_query(answer);
-#endif
+                } /*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
+                 * 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 &&
-                    ((_res.options & RES_USEVC) == 0 || ns != 0)) ||
-                    (_res.options & RES_STAYOPEN) == 0) {
-                        (void) close(s);
-                        s = -1;
+                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);
-           }
-        }
-        if (s >= 0) {
-                (void) close(s);
-                s = -1;
-        }
-        if (v_circuit == 0)
-                if (gotsomewhere == 0)
+    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
+        } else
                 errno = terrno;
         return (-1);
 }
@@ -465,10 +840,14 @@ wait:
  *
  * This routine is not expected to be user visible.
  */
-_res_close()
+void
+res_close(void)
 {
-        if (s != -1) {
+        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
index 99abe17f03..e820ea25ed 100644
--- a/src/lib/libc/net/resolver.3
+++ b/src/lib/libc/net/resolver.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: resolver.3,v 1.5 1995/02/25 06:21:02 cgd Exp $
+.\"     $OpenBSD: resolver.3,v 1.21 2007/05/31 19:19:30 jmc Exp $
 .\"
 .\" Copyright (c) 1985, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,11 +27,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)resolver.3  8.1 (Berkeley) 6/4/93
-.\"
-.Dd June 4, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt RESOLVER 3
-.Os BSD 4.3
+.Os
 .Sh NAME
 .Nm res_query ,
 .Nm res_search ,
@@ -50,69 +44,76 @@
 .Fd #include <netinet/in.h>
 .Fd #include <arpa/nameser.h>
 .Fd #include <resolv.h>
+.Ft int
 .Fo res_query
-.Fa "char *dname"
+.Fa "const char *dname"
 .Fa "int class"
 .Fa "int type"
-.Fa "u_char *answer"
+.Fa "unsigned char *answer"
 .Fa "int anslen"
 .Fc
+.Ft int
 .Fo res_search
-.Fa "char *dname"
+.Fa "const char *dname"
 .Fa "int class"
 .Fa "int type"
-.Fa "u_char *answer"
+.Fa "unsigned char *answer"
 .Fa "int anslen"
 .Fc
+.Ft int
 .Fo res_mkquery
 .Fa "int op"
-.Fa "char *dname"
+.Fa "const char *dname"
 .Fa "int class"
 .Fa "int type"
-.Fa "char *data"
+.Fa "const unsigned char *data"
 .Fa "int datalen"
-.Fa "struct rrec *newrr"
-.Fa "char *buf"
+.Fa "const unsigned char *newrr"
+.Fa "unsigned char *buf"
 .Fa "int buflen"
 .Fc
+.Ft int
 .Fo res_send
-.Fa "char *msg"
+.Fa "const unsigned char *msg"
 .Fa "int msglen"
-.Fa "char *answer"
+.Fa "unsigned char *answer"
 .Fa "int anslen"
 .Fc
-.Fn res_init 
+.Ft int
+.Fn res_init "void"
+.Ft int
 .Fo dn_comp
-.Fa "char *exp_dn"
-.Fa "char *comp_dn"
+.Fa "const char *exp_dn"
+.Fa "unsigned char *comp_dn"
 .Fa "int length"
-.Fa "char **dnptrs"
-.Fa "char **lastdnptr"
+.Fa "unsigned char **dnptrs"
+.Fa "unsigned char **lastdnptr"
 .Fc
+.Ft int
 .Fo dn_expand
-.Fa "u_char *msg"
-.Fa "u_char *eomorig"
-.Fa "u_char *comp_dn"
-.Fa "u_char *exp_dn"
+.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
+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
-.Em _res .
+.Li _res .
 Most of the values have reasonable defaults and can be ignored.
-Options
-stored in
-.Em _res.options
+Options stored in
+.Li _res.options
 are defined in
-.Pa resolv.h
+.Aq Pa resolv.h
 and are as follows.
-Options are stored as a simple bit mask containing the bitwise ``or''
+Options are stored as a simple bit mask containing the bitwise
+.Tn OR
 of the options enabled.
-.Bl -tag -width RES_DEFNAMES
+.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.,
@@ -137,8 +138,7 @@ Used with
 .Dv RES_USEVC
 to keep the
 .Tn TCP
-connection open between
-queries.
+connection open between queries.
 This is useful only in programs that regularly do many queries.
 .Tn UDP
 should be the normal mode used.
@@ -165,16 +165,28 @@ will search for host names in the current domain and in parent domains; see
 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
+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).
+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
@@ -212,20 +224,26 @@ The query requests information of the specified
 .Fa type
 and
 .Fa class
-for the specified fully-qualified domain name
+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
+but in addition, it implements the default and search rules controlled by the
 .Dv RES_DEFNAMES
 and
 .Dv RES_DNSRCH
@@ -236,11 +254,9 @@ 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
+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
+It returns the size of the query, or \-1 if the query is larger than
 .Fa buflen .
 The query type
 .Fa op
@@ -250,26 +266,23 @@ 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
+.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.
+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.
+The length of the reply message is returned, or \-1 if there were errors.
 .Pp
 The
 .Fn dn_comp
-function
-compresses the domain name
+function compresses the domain name
 .Fa exp_dn
 and stores it in
 .Fa comp_dn .
@@ -278,24 +291,23 @@ The size of the array pointed to by
 .Fa comp_dn
 is given by
 .Fa length .
-The compression uses
-an array of pointers
+The compression uses an array of pointers
 .Fa dnptrs
-to previously-compressed names in the current message.
-The first pointer points to
+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
+is to update the list of pointers for labels inserted into the message
 as the name is compressed.
 If
-.Em dnptr
+.Fa dnptrs
 is
-.Dv NULL, names are not compressed.
+.Dv NULL ,
+names are not compressed.
 If
 .Fa lastdnptr
 is
@@ -304,10 +316,9 @@ the list of labels is not updated.
 .Pp
 The
 .Fn dn_expand
-entry
-expands the compressed domain name
+entry expands the compressed domain name
 .Fa comp_dn
-to a full domain name
+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.
@@ -317,28 +328,27 @@ 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 Pa
-/etc/resolv.conf
-The configuration file
-see
-.Xr resolv.conf 5 .
+.Bl -tag -width "/etc/resolv.confXX"
+.It Pa /etc/resolv.conf
+The configuration file.
 .El
 .Sh SEE ALSO
 .Xr gethostbyname 3 ,
-.Xr named 8 ,
 .Xr resolv.conf 5 ,
 .Xr hostname 7 ,
+.Xr named 8
 .Pp
-.%T RFC1032 ,
-.%T RFC1033 ,
-.%T RFC1034 ,
-.%T RFC1035 ,
-.%T RFC974
+.%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 
+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..d10334e027
--- /dev/null
+++ b/src/lib/libc/net/rthdr.c
@@ -0,0 +1,378 @@
+/*      $OpenBSD: rthdr.c,v 1.8 2006/12/09 01:12:28 itojun Exp $        */
+/*      $KAME: rthdr.c,v 1.22 2006/02/09 08:18:58 keiichi 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>
+
+/*
+ * RFC2292 API
+ */
+
+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);
+        }
+}
+
+/*
+ * RFC3542 (2292bis) API
+ */
+
+socklen_t
+inet6_rth_space(int type, int segments)
+{
+        switch (type) {
+        case IPV6_RTHDR_TYPE_0:
+                return (((segments * 2) + 1) << 3);
+        default:
+                return (0);     /* type not suppported */
+        }
+}
+
+void *
+inet6_rth_init(void *bp, socklen_t bp_len, int type, int segments)
+{
+        struct ip6_rthdr *rth = (struct ip6_rthdr *)bp;
+        struct ip6_rthdr0 *rth0;
+
+        switch (type) {
+        case IPV6_RTHDR_TYPE_0:
+                /* length validation */
+                if (bp_len < inet6_rth_space(IPV6_RTHDR_TYPE_0, segments))
+                        return (NULL);
+
+                memset(bp, 0, bp_len);
+                rth0 = (struct ip6_rthdr0 *)rth;
+                rth0->ip6r0_len = segments * 2;
+                rth0->ip6r0_type = IPV6_RTHDR_TYPE_0;
+                rth0->ip6r0_segleft = 0;
+                rth0->ip6r0_reserved = 0;
+                break;
+        default:
+                return (NULL);  /* type not supported */
+        }
+
+        return (bp);
+}
+
+int
+inet6_rth_add(void *bp, const struct in6_addr *addr)
+{
+        struct ip6_rthdr *rth = (struct ip6_rthdr *)bp;
+        struct ip6_rthdr0 *rth0;
+        struct in6_addr *nextaddr;
+
+        switch (rth->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+                rth0 = (struct ip6_rthdr0 *)rth;
+                nextaddr = (struct in6_addr *)(rth0 + 1) + rth0->ip6r0_segleft;
+                *nextaddr = *addr;
+                rth0->ip6r0_segleft++;
+                break;
+        default:
+                return (-1);    /* type not supported */
+        }
+
+        return (0);
+}
+
+int
+inet6_rth_reverse(const void *in, void *out)
+{
+        struct ip6_rthdr *rth_in = (struct ip6_rthdr *)in;
+        struct ip6_rthdr0 *rth0_in, *rth0_out;
+        int i, segments;
+
+        switch (rth_in->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+                rth0_in = (struct ip6_rthdr0 *)in;
+                rth0_out = (struct ip6_rthdr0 *)out;
+
+                /* parameter validation XXX too paranoid? */
+                if (rth0_in->ip6r0_len % 2)
+                        return (-1);
+                segments = rth0_in->ip6r0_len / 2;
+
+                /* we can't use memcpy here, since in and out may overlap */
+                memmove((void *)rth0_out, (void *)rth0_in,
+                        ((rth0_in->ip6r0_len) + 1) << 3);
+                rth0_out->ip6r0_segleft = segments;
+
+                /* reverse the addresses */
+                for (i = 0; i < segments / 2; i++) {
+                        struct in6_addr addr_tmp, *addr1, *addr2;
+
+                        addr1 = (struct in6_addr *)(rth0_out + 1) + i;
+                        addr2 = (struct in6_addr *)(rth0_out + 1) +
+                            (segments - i - 1);
+                        addr_tmp = *addr1;
+                        *addr1 = *addr2;
+                        *addr2 = addr_tmp;
+                }
+                
+                break;
+        default:
+                return (-1);    /* type not supported */
+        }
+
+        return (0);
+}
+
+int
+inet6_rth_segments(const void *bp)
+{
+        struct ip6_rthdr *rh = (struct ip6_rthdr *)bp;
+        struct ip6_rthdr0 *rh0;
+        int addrs;
+
+        switch (rh->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+                rh0 = (struct ip6_rthdr0 *)bp;
+
+                /*
+                 * Validation for a type-0 routing header.
+                 * Is this too strict?
+                 */
+                if ((rh0->ip6r0_len % 2) != 0 ||
+                    (addrs = (rh0->ip6r0_len >> 1)) < rh0->ip6r0_segleft)
+                        return (-1);
+
+                return (addrs);
+        default:
+                return (-1);    /* unknown type */
+        }
+}
+
+struct in6_addr *
+inet6_rth_getaddr(const void *bp, int idx)
+{
+        struct ip6_rthdr *rh = (struct ip6_rthdr *)bp;
+        struct ip6_rthdr0 *rh0;
+        int addrs;
+
+        switch (rh->ip6r_type) {
+        case IPV6_RTHDR_TYPE_0:
+                 rh0 = (struct ip6_rthdr0 *)bp;
+                 
+                /*
+                 * Validation for a type-0 routing header.
+                 * Is this too strict?
+                 */
+                if ((rh0->ip6r0_len % 2) != 0 ||
+                    (addrs = (rh0->ip6r0_len >> 1)) < rh0->ip6r0_segleft)
+                        return (NULL);
+
+                if (idx < 0 || addrs <= idx)
+                        return (NULL);
+
+                return (((struct in6_addr *)(rh0 + 1)) + idx);
+        default:
+                return (NULL);  /* unknown type */
+                break;
+        }
+}
diff --git a/src/lib/libc/net/ruserok.c b/src/lib/libc/net/ruserok.c
new file mode 100644
index 0000000000..5ef078ac95
--- /dev/null
+++ b/src/lib/libc/net/ruserok.c
@@ -0,0 +1,437 @@
+/*
+ * 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     __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)) {
+                int len;
+
+                first = 0;
+                if ((pwd = getpwnam(luser)) == NULL)
+                        return (-1);
+                len = snprintf(pbuf, sizeof pbuf, "%s/.rhosts", pwd->pw_dir);
+                if (len < 0 || len >= sizeof pbuf)
+                        return (-1);
+
+                /*
+                 * 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/send.c b/src/lib/libc/net/send.c
index 88f3550ec6..1bfc80b87a 100644
--- a/src/lib/libc/net/send.c
+++ b/src/lib/libc/net/send.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: send.c,v 1.6 1995/02/25 06:21:02 cgd Exp $     */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,24 +28,13 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)send.c      8.2 (Berkeley) 2/21/94";
-#else
-static char rcsid[] = "$NetBSD: send.c,v 1.6 1995/02/25 06:21:02 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #include <stddef.h>
 
 ssize_t
-send(s, msg, len, flags)
-        int s, flags;
-        size_t len;
-        const void *msg;
+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
index 00f6499695..6f6d0e405a 100644
--- a/src/lib/libc/net/sethostent.c
+++ b/src/lib/libc/net/sethostent.c
@@ -1,5 +1,4 @@
-/*      $NetBSD: sethostent.c,v 1.4 1995/02/25 06:21:03 cgd Exp $       */
-
+/*      $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.
@@ -12,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -33,30 +28,30 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
-static char sccsid[] = "@(#)sethostent.c        8.1 (Berkeley) 6/4/93";
-#else
-static char rcsid[] = "$NetBSD: sethostent.c,v 1.4 1995/02/25 06:21:03 cgd Exp $";
-#endif
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <netdb.h>
 #include <resolv.h>
 
+#include "thread_private.h"
+
 void
-sethostent(stayopen)
+sethostent(int stayopen)
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+
+        if (_res_init(0) == -1)
+                return;
         if (stayopen)
-                _res.options |= RES_STAYOPEN | RES_USEVC;
+                _resp->options |= RES_STAYOPEN | RES_USEVC;
 }
 
 void
-endhostent()
+endhostent(void)
 {
-        _res.options &= ~(RES_STAYOPEN | RES_USEVC);
-        _res_close();
+        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
index 782a4ab022..81d1962026 100644
--- a/src/lib/libc/stdlib/Makefile.inc
+++ b/src/lib/libc/stdlib/Makefile.inc
@@ -1,45 +1,73 @@
-#       from: @(#)Makefile.inc  5.6 (Berkeley) 6/4/91
-#       $Id: Makefile.inc,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+#       $OpenBSD: Makefile.inc,v 1.44 2010/05/18 22:24:55 tedu Exp $
 
 # stdlib sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/stdlib ${.CURDIR}/stdlib
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_CPU}/stdlib ${LIBCSRCDIR}/stdlib
 
-SRCS+=  a64l.c abort.c atexit.c atoi.c atof.c atol.c bsearch.c calloc.c \
-        exit.c getenv.c getopt.c heapsort.c l64a.c malloc.c merge.c \
-        multibyte.c putenv.c qsort.c radixsort.c rand.c random.c realpath.c \
-        setenv.c strtod.c strtol.c strtoq.c strtoul.c strtouq.c system.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
+SRCS+=  a64l.c abort.c atexit.c atoi.c atof.c atol.c atoll.c bsearch.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 qsort.c radixsort.c rand.c \
+        random.c realpath.c setenv.c strtoimax.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")
+.if   (${MACHINE_CPU} == "m68k")
 SRCS+=  abs.S div.c labs.c ldiv.c
-.elif (${MACHINE_ARCH} == "i386")
+LSRCS+= abs.c
+.elif (${MACHINE_CPU} == "i386")
 SRCS+=  abs.S div.S labs.S ldiv.S
-.elif (${MACHINE_ARCH} == "ns32k")
+LSRCS+= abs.c div.c labs.c ldiv.c
+.elif (${MACHINE_CPU} == "ns32k")
 SRCS+=  abs.S div.c labs.c ldiv.c
-.elif (${MACHINE_ARCH} == "tahoe")
+LSRCS+= abs.c
+.elif (${MACHINE_CPU} == "tahoe")
 SRCS+=  abs.S div.c labs.c ldiv.c
-.elif (${MACHINE_ARCH} == "vax")
+LSRCS+= abs.c
+.elif (${MACHINE_CPU} == "vax")
 SRCS+=  abs.c div.c labs.c ldiv.c
-.elif (${MACHINE_ARCH} == "alpha")
+.elif (${MACHINE_CPU} == "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
 
-MAN+=   abort.3 abs.3 alloca.3 atexit.3 atof.3 atoi.3 atol.3 bsearch.3 \
-        calloc.3 div.3 exit.3 free.3 getenv.3 getopt.3 labs.3 ldiv.3 \
-        malloc.3 memory.3 qabs.3 qdiv.3 qsort.3 radixsort.3 rand48.3 \
-        rand.3 random.3 realloc.3 realpath.3 strtod.3 strtol.3 strtoul.3 \
-        system.3
+.if (${MACHINE_CPU} == "vax") || (${MACHINE_CPU} == "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 posix_memalign.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+=rand.3 srand.3
-MLINKS+=strtol.3 strtoq.3
-MLINKS+=strtoul.3 strtouq.3
-MLINKS+=random.3 initstate.3 random.3 setstate.3 random.3 srandom.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+=strtod.3 strtof.3 strtod.3 strtold.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
index 83ade4645a..7c950f7cee 100644
--- a/src/lib/libc/stdlib/_rand48.c
+++ b/src/lib/libc/stdlib/_rand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: _rand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/a64l.3 b/src/lib/libc/stdlib/a64l.3
new file mode 100644
index 0000000000..da0aae33c9
--- /dev/null
+++ b/src/lib/libc/stdlib/a64l.3
@@ -0,0 +1,133 @@
+.\" $OpenBSD: a64l.3,v 1.11 2010/04/01 17:06:55 jmc 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 $Mdocdate: April 1 2010 $
+.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 STANDARDS
+The
+.Fn a64l
+and
+.Fn l64a
+functions conform to
+.St -xpg4.2 .
+.Sh CAVEATS
+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.
diff --git a/src/lib/libc/stdlib/a64l.c b/src/lib/libc/stdlib/a64l.c
index 03fc77e034..5312929c6f 100644
--- a/src/lib/libc/stdlib/a64l.c
+++ b/src/lib/libc/stdlib/a64l.c
@@ -1,34 +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.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: a64l.c,v 1.3 1995/05/11 23:04:47 jtc Exp $";
-#endif
+#include <errno.h>
+#include <stdlib.h>
 
 long
-a64l(s)
-        const char *s;
+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 <= '/')
+                if (*s >= '.' && *s <= '/')
                         digit = *s - '.';
-                else if (*s <= '9')
+                else if (*s >= '0' && *s <= '9')
                         digit = *s - '0' + 2;
-                else if (*s <= 'Z')
+                else if (*s >= 'A' && *s <= 'Z')
                         digit = *s - 'A' + 12;
-                else
-                        digit = *s - 'a' + 38; 
+                else if (*s >= 'a' && *s <= 'z')
+                        digit = *s - 'a' + 38;
+                else {
+                        errno = EINVAL;
+                        return(-1L);
+                }
 
                 value |= digit << shift;
                 shift += 6;
         }
 
-        return (long) value;
+        return(value);
 }
diff --git a/src/lib/libc/stdlib/abort.3 b/src/lib/libc/stdlib/abort.3
index ab57327585..4ec85882b2 100644
--- a/src/lib/libc/stdlib/abort.3
+++ b/src/lib/libc/stdlib/abort.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)abort.3       6.7 (Berkeley) 6/29/91
-.\"     $Id: abort.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: abort.3,v 1.8 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ABORT 3
 .Os
 .Sh NAME
@@ -49,23 +44,20 @@
 .Sh DESCRIPTION
 The
 .Fn abort
-function causes abnormal program termination to occur, unless the
-signal
+function causes abnormal program termination to occur, unless the signal
 .Dv SIGABRT
 is being caught and the signal handler does not return.
 .Pp
-No open streams are closed or flushed.
+Any open streams are flushed and closed.
 .Sh RETURN VALUES
 The
-.Nm abort
-function
-never returns.
+.Fn abort
+function never returns.
 .Sh SEE ALSO
 .Xr sigaction 2 ,
-.Xr exit 2
+.Xr exit 3
 .Sh STANDARDS
 The
 .Fn abort
-function
-conforms to
-.St -ansiC .
+function conforms to
+.St -p1003.1-90 .
diff --git a/src/lib/libc/stdlib/abort.c b/src/lib/libc/stdlib/abort.c
index c298e016b4..244e3b28aa 100644
--- a/src/lib/libc/stdlib/abort.c
+++ b/src/lib/libc/stdlib/abort.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: abort.c,v 1.15 2007/09/03 14:40:16 millert Exp $ */
 /*
  * Copyright (c) 1985 Regents of the University of California.
  * All rights reserved.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,27 +28,43 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)abort.c      5.11 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: abort.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <signal.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include "thread_private.h"
+#include "atexit.h"
 
 void
-abort()
+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)sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
+        (void)_thread_sys_sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
+
+        /*
+         * POSIX requires we flush stdio buffers on abort
+         */
+        if (cleanup_called == 0) {
+                /* the cleanup routine lives in fns[0] on the last page */
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                /* the check for fn_dso == NULL is mostly paranoia */
+                if (p != NULL && p->fns[0].fn_dso == NULL &&
+                    p->fns[0].fn_ptr.std_func != NULL) {
+                        cleanup_called = 1;
+                        (*p->fns[0].fn_ptr.std_func)();
+                }
+        }
+
         (void)kill(getpid(), SIGABRT);
 
         /*
@@ -59,7 +72,7 @@ abort()
          * it again, only harder.
          */
         (void)signal(SIGABRT, SIG_DFL);
-        (void)sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
+        (void)_thread_sys_sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL);
         (void)kill(getpid(), SIGABRT);
-        exit(1);
+        _exit(1);
 }
diff --git a/src/lib/libc/stdlib/abs.3 b/src/lib/libc/stdlib/abs.3
index 4748d89e77..473aea1cd6 100644
--- a/src/lib/libc/stdlib/abs.3
+++ b/src/lib/libc/stdlib/abs.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)abs.3 6.4 (Berkeley) 6/29/91
-.\"     $Id: abs.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: abs.3,v 1.9 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt ABS 3
 .Os
 .Sh NAME
@@ -49,22 +44,18 @@
 .Sh DESCRIPTION
 The
 .Fn abs
-function
-computes
-the absolute value of the integer
-.Ar j .
+function computes the absolute value of the integer
+.Fa j .
 .Sh RETURN VALUES
 The
 .Fn abs
-function
-returns
-the absolute value.
+function returns the absolute value.
 .Sh SEE ALSO
-.Xr floor 3 ,
-.Xr labs 3 ,
 .Xr cabs 3 ,
+.Xr floor 3 ,
 .Xr hypot 3 ,
-.Xr math 3
+.Xr imaxabs 3 ,
+.Xr labs 3
 .Sh STANDARDS
 The
 .Fn abs
diff --git a/src/lib/libc/stdlib/abs.c b/src/lib/libc/stdlib/abs.c
index 64468e0224..5d2fbae69f 100644
--- a/src/lib/libc/stdlib/abs.c
+++ b/src/lib/libc/stdlib/abs.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)abs.c        5.2 (Berkeley) 5/17/90";*/
-static char *rcsid = "$Id: abs.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 int
-abs(j)
-        int j;
+abs(int j)
 {
         return(j < 0 ? -j : j);
 }
diff --git a/src/lib/libc/stdlib/alloca.3 b/src/lib/libc/stdlib/alloca.3
index dcb97ab11c..d7fddb04c2 100644
--- a/src/lib/libc/stdlib/alloca.3
+++ b/src/lib/libc/stdlib/alloca.3
@@ -9,11 +9,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,12 +25,11 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)alloca.3      5.1 (Berkeley) 5/2/91
-.\"     $Id: alloca.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: alloca.3,v 1.11 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd May 2, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ALLOCA 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm alloca
 .Nd memory allocator
@@ -45,35 +40,41 @@
 .Sh DESCRIPTION
 The
 .Fn alloca
-function
-allocates 
+function allocates
 .Fa size
 bytes of space in the stack frame of the caller.
-This temporary space is automatically freed on
-return.
+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.
-If the allocation failed, a
-.Dv NULL
-pointer is returned.
 .Sh SEE ALSO
+.Xr pagesize 1 ,
 .Xr brk 2 ,
-.Xr pagesize 2
 .Xr calloc 3 ,
 .Xr malloc 3 ,
-.Xr realloc 3 ,
+.Xr realloc 3
 .Sh BUGS
 The
 .Fn alloca
-function
-is machine dependent; its use is discouraged.
+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 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
index 07de054d3c..0615feabb1 100644
--- a/src/lib/libc/stdlib/atexit.3
+++ b/src/lib/libc/stdlib/atexit.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)atexit.3      5.3 (Berkeley) 6/29/91
-.\"     $Id: atexit.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: atexit.3,v 1.8 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ATEXIT 3
 .Os
 .Sh NAME
@@ -49,17 +44,22 @@
 .Sh DESCRIPTION
 The
 .Fn atexit
-function
-registers the given
-.Ar function
+function registers the given
+.Fa function
 to be called at program exit, whether via
 .Xr exit 3
 or via return from the program's
-.Em main .
+.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
@@ -73,6 +73,5 @@ The existing list of functions is unmodified.
 .Sh STANDARDS
 The
 .Fn atexit
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/atexit.c b/src/lib/libc/stdlib/atexit.c
index 4da1eb0d9c..e28ccf29d0 100644
--- a/src/lib/libc/stdlib/atexit.c
+++ b/src/lib/libc/stdlib/atexit.c
@@ -1,68 +1,209 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
+/*      $OpenBSD: atexit.c,v 1.15 2011/03/02 18:34:05 matthew Exp $ */
+/*
+ * Copyright (c) 2002 Daniel Hartmeier
  * 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. 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.
+ *    - 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.
+ *
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)atexit.c     5.2 (Berkeley) 11/14/90";*/
-static char *rcsid = "$Id: atexit.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
+#include <sys/mman.h>
 #include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 #include "atexit.h"
+#include "thread_private.h"
 
+int __atexit_invalid = 1;
 struct atexit *__atexit;
 
 /*
- * Register a function to be performed at exit.
+ * 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 functions, all pages are mprotect()'ed
+ * to prevent unintentional/malicious corruption.
+ */
+
+/*
+ * Register a function to be performed at exit or when a shared object
+ * with the given dso handle is unloaded dynamically.  Also used as
+ * the backend for atexit().  For more info on this API, see:
+ *
+ *      http://www.codesourcery.com/cxx-abi/abi.html#dso-dtor
  */
 int
-atexit(fn)
-        void (*fn)();
+__cxa_atexit(void (*func)(void *), void *arg, void *dso)
 {
-        static struct atexit __atexit0; /* one guaranteed table */
-        register struct atexit *p;
+        struct atexit *p = __atexit;
+        struct atexit_fn *fnp;
+        int pgsize = getpagesize();
+        int ret = -1;
 
-        if ((p = __atexit) == NULL)
-                __atexit = p = &__atexit0;
-        else if (p->ind >= ATEXIT_SIZE) {
-                if ((p = malloc(sizeof(*p))) == NULL)
-                        return (-1);
-                p->ind = 0;
+        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) {
+                        memset(&p->fns[0], 0, sizeof(p->fns[0]));
+                        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;
+        }
+        fnp = &p->fns[p->ind++];
+        fnp->fn_ptr.cxa_func = func;
+        fnp->fn_arg = arg;
+        fnp->fn_dso = dso;
+        if (mprotect(p, pgsize, PROT_READ))
+                goto unlock;
+        ret = 0;
+unlock:
+        _ATEXIT_UNLOCK();
+        return (ret);
+}
+
+/*
+ * Register a function to be performed at exit.
+ */
+int
+atexit(void (*func)(void))
+{
+        return (__cxa_atexit((void (*)(void *))func, NULL, NULL));
+}
+
+/*
+ * Call all handlers registered with __cxa_atexit() for the shared
+ * object owning 'dso'.
+ * Note: if 'dso' is NULL, then all remaining handlers are called.
+ */
+void
+__cxa_finalize(void *dso)
+{
+        struct atexit *p, *q;
+        struct atexit_fn fn;
+        int n, pgsize = getpagesize();
+        static int call_depth;
+
+        if (__atexit_invalid)
+                return;
+
+        call_depth++;
+
+        for (p = __atexit; p != NULL; p = p->next) {
+                for (n = p->ind; --n >= 0;) {
+                        if (p->fns[n].fn_ptr.cxa_func == NULL)
+                                continue;       /* already called */
+                        if (dso != NULL && dso != p->fns[n].fn_dso)
+                                continue;       /* wrong DSO */
+
+                        /*
+                         * Mark handler as having been already called to avoid
+                         * dupes and loops, then call the appropriate function.
+                         */
+                        fn = p->fns[n];
+                        if (mprotect(p, pgsize, PROT_READ | PROT_WRITE) == 0) {
+                                p->fns[n].fn_ptr.cxa_func = NULL;
+                                mprotect(p, pgsize, PROT_READ);
+                        }
+                        if (fn.fn_dso != NULL)
+                                (*fn.fn_ptr.cxa_func)(fn.fn_arg);
+                        else
+                                (*fn.fn_ptr.std_func)();
+                }
+        }
+
+        /*
+         * If called via exit(), unmap the pages since we have now run
+         * all the handlers.  We defer this until calldepth == 0 so that
+         * we don't unmap things prematurely if called recursively.
+         */
+        if (dso == NULL && --call_depth == 0) {
+                for (p = __atexit; p != NULL; ) {
+                        q = p;
+                        p = p->next;
+                        munmap(q, pgsize);
+                }
+                __atexit = NULL;
+        }
+}
+
+/*
+ * Register the cleanup function
+ */
+void
+__atexit_register_cleanup(void (*func)(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[p->ind++] = fn;
-        return (0);
+        p->fns[0].fn_ptr.std_func = func;
+        p->fns[0].fn_arg = NULL;
+        p->fns[0].fn_dso = NULL;
+        mprotect(p, pgsize, PROT_READ);
+unlock:
+        _ATEXIT_UNLOCK();
 }
diff --git a/src/lib/libc/stdlib/atexit.h b/src/lib/libc/stdlib/atexit.h
index 8b756e8fe2..1b23565dd0 100644
--- a/src/lib/libc/stdlib/atexit.h
+++ b/src/lib/libc/stdlib/atexit.h
@@ -1,46 +1,51 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
+/*      $OpenBSD: atexit.h,v 1.7 2007/09/03 14:40:16 millert 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:
- * 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.
+ *    - 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.
  *
- *      from: @(#)atexit.h      5.1 (Berkeley) 5/15/90
- *      $Id: atexit.h,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
  */
 
-/* must be at least 32 to guarantee ANSI conformance */
-#define ATEXIT_SIZE     32
-
 struct atexit {
         struct atexit *next;            /* next in list */
         int ind;                        /* next index in this table */
-        void (*fns[ATEXIT_SIZE])();     /* the table itself */
+        int max;                        /* max entries >= ATEXIT_SIZE */
+        struct atexit_fn {
+                union {
+                        void (*std_func)(void);
+                        void (*cxa_func)(void *);
+                } fn_ptr;
+                void *fn_arg;           /* argument for CXA callback */
+                void *fn_dso;           /* shared module handle */
+        } fns[1];                       /* the table itself */
 };
 
+extern int __atexit_invalid;
 extern struct atexit *__atexit;         /* points to head of LIFO stack */
+
+int     __cxa_atexit(void (*)(void *), void *, void *);
+void    __cxa_finalize(void *);
diff --git a/src/lib/libc/stdlib/atof.3 b/src/lib/libc/stdlib/atof.3
index 53e04f71c5..2538d0c879 100644
--- a/src/lib/libc/stdlib/atof.3
+++ b/src/lib/libc/stdlib/atof.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)atof.3        6.4 (Berkeley) 6/29/91
-.\"     $Id: atof.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: atof.3,v 1.5 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ATOF 3
 .Os
 .Sh NAME
@@ -52,9 +47,9 @@ string to double
 The
 .Fn atof
 function converts the initial portion of the string pointed to by
-.Ar nptr
+.Fa nptr
 to
-.Ar double
+.Li double
 representation.
 .Pp
 It is equivalent to:
diff --git a/src/lib/libc/stdlib/atof.c b/src/lib/libc/stdlib/atof.c
index 9202de50bb..d14b58b070 100644
--- a/src/lib/libc/stdlib/atof.c
+++ b/src/lib/libc/stdlib/atof.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)atof.c       5.3 (Berkeley) 1/8/93";*/
-static char *rcsid = "$Id: atof.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 double
-atof(ascii)
-        const char *ascii;
+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
index 219ba73c00..0c6b62b25f 100644
--- a/src/lib/libc/stdlib/atoi.3
+++ b/src/lib/libc/stdlib/atoi.3
@@ -1,5 +1,5 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" 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
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)atoi.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: atoi.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: atoi.3,v 1.9 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ATOI 3
 .Os
 .Sh NAME
@@ -52,13 +47,12 @@ string to integer
 The
 .Fn atoi
 function converts the initial portion of the string pointed to by
-.Em nptr
+.Fa nptr
 to
-.Em integer
+.Li integer
 representation.
 .Pp
 It is equivalent to:
-.Pp
 .Bd -literal -offset indent
 (int)strtol(nptr, (char **)NULL, 10);
 .Ed
@@ -67,9 +61,26 @@ It is equivalent to:
 .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
index df7845f90c..b0842678e2 100644
--- a/src/lib/libc/stdlib/atoi.c
+++ b/src/lib/libc/stdlib/atoi.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)atoi.c       5.7 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: atoi.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 int
-atoi(str)
-        const char *str;
+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
index 86e3d324a3..3c5551182d 100644
--- a/src/lib/libc/stdlib/atol.3
+++ b/src/lib/libc/stdlib/atol.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)atol.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: atol.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: atol.3,v 1.7 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt ATOL 3
 .Os
 .Sh NAME
@@ -52,9 +47,9 @@ string to long integer
 The
 .Fn atol
 function converts the initial portion of the string pointed to by
-.Ar nptr
+.Fa nptr
 to
-.Em long integer
+.Li long integer
 representation.
 .Pp
 It is equivalent to:
@@ -64,12 +59,12 @@ strtol(nptr, (char **)NULL, 10);
 .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 .
+function conforms to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/atol.c b/src/lib/libc/stdlib/atol.c
index 31ed06298b..1970804401 100644
--- a/src/lib/libc/stdlib/atol.c
+++ b/src/lib/libc/stdlib/atol.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)atol.c       5.7 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: atol.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 long
-atol(str)
-        const char *str;
+atol(const char *str)
 {
         return(strtol(str, (char **)NULL, 10));
 }
diff --git a/src/lib/libc/stdlib/calloc.3 b/src/lib/libc/stdlib/atoll.3
index d0754b46a0..608a61f4ce 100644
--- a/src/lib/libc/stdlib/calloc.3
+++ b/src/lib/libc/stdlib/atoll.3
@@ -1,4 +1,4 @@
-.\" Copyright (c) 1991 The Regents of the University of California.
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to Berkeley by
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,39 +29,42 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)calloc.3      5.2 (Berkeley) 6/29/91
-.\"     $Id: calloc.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: atoll.3,v 1.5 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
-.Dt CALLOC 3
+.Dd $Mdocdate: May 31 2007 $
+.Dt ATOLL 3
 .Os
 .Sh NAME
-.Nm calloc
-.Nd allocate clean memory (zero initialized space)
+.Nm atoll
+.Nd convert
+.Tn ASCII
+string to long long integer
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
-.Ft void *
-.Fn calloc "size_t nmemb" "size_t size"
+.Ft long long
+.Fn atoll "const char *nptr"
 .Sh DESCRIPTION
 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.
-.Sh RETURN VALUES
-The
-.Fn calloc
-function returns
-a pointer to the
-the allocated space if successful; otherwise a null pointer is returned.
+.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 malloc 3 ,
-.Xr realloc 3 ,
-.Xr free 3
+.Xr atof 3 ,
+.Xr atoi 3 ,
+.Xr atol 3 ,
+.Xr strtod 3 ,
+.Xr strtol 3 ,
+.Xr strtoul 3
 .Sh STANDARDS
 The
-.Fn calloc
+.Fn atoll
 function conforms to
-.St -ansiC .
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/putenv.c b/src/lib/libc/stdlib/atoll.c
index 2194c2c608..a65e682cfb 100644
--- a/src/lib/libc/stdlib/putenv.c
+++ b/src/lib/libc/stdlib/atoll.c
@@ -1,5 +1,6 @@
-/*-
- * Copyright (c) 1988 The Regents of the University of California.
+/*      $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
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,29 +28,11 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)putenv.c     5.4 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: putenv.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
-#include <string.h>
 
-int
-putenv(str)
+long long
+atoll(str)
         const char *str;
 {
-        register char *p, *equal;
-        int rval;
-
-        if (!(p = strdup(str)))
-                return(1);
-        if (!(equal = strchr(p, '='))) {
-                (void)free(p);
-                return(1);
-        }
-        *equal = '\0';
-        rval = setenv(p, equal + 1, 1);
-        (void)free(p);
-        return(rval);
+        return(strtoll(str, (char **)NULL, 10));
 }
diff --git a/src/lib/libc/stdlib/bsearch.3 b/src/lib/libc/stdlib/bsearch.3
index 1622c96c6b..4877a1023e 100644
--- a/src/lib/libc/stdlib/bsearch.3
+++ b/src/lib/libc/stdlib/bsearch.3
@@ -1,5 +1,5 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" 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
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bsearch.3     5.6 (Berkeley) 6/29/91
-.\"     $Id: bsearch.3,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
+.\"     $OpenBSD: bsearch.3,v 1.7 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt BSEARCH 3
 .Os
 .Sh NAME
@@ -51,12 +46,12 @@ The
 .Fn bsearch
 function searches an array of
 .Fa nmemb
-objects, the initial member of which is 
+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 
+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
@@ -64,9 +59,7 @@ to the comparison function referenced by
 .Fa compar .
 The
 .Fa compar
-routine
-is expected to have two
-two arguments which point to the
+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
@@ -83,7 +76,7 @@ If two members compare as equal, which member is matched is unspecified.
 .Xr db 3 ,
 .Xr lsearch 3 ,
 .Xr qsort 3 ,
-.\" .Xr tsearch 3
+.Xr tsearch 3
 .Sh STANDARDS
 The
 .Fn bsearch
diff --git a/src/lib/libc/stdlib/bsearch.c b/src/lib/libc/stdlib/bsearch.c
index fac03f694f..b48747236e 100644
--- a/src/lib/libc/stdlib/bsearch.c
+++ b/src/lib/libc/stdlib/bsearch.c
@@ -10,11 +10,7 @@
  * 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
+ * 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.
  *
@@ -31,11 +27,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)bsearch.c    5.4 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: bsearch.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 /*
@@ -46,7 +37,7 @@ static char *rcsid = "$Id: bsearch.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
  * 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
+ * is odd, moving right again involves 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
@@ -55,16 +46,12 @@ static char *rcsid = "$Id: bsearch.c,v 1.1.1.1 1995/10/18 08:42:16 deraadt Exp $
  * look at item 3.
  */
 void *
-bsearch(key, base0, nmemb, size, compar)
-        register const void *key;
-        const void *base0;
-        size_t nmemb;
-        register size_t size;
-        register int (*compar) __P((const void *, const void *));
+bsearch(const void *key, const void *base0, size_t nmemb, size_t size,
+    int (*compar)(const void *, const void *))
 {
-        register const char *base = base0;
-        register int lim, cmp;
-        register const void *p;
+        const char *base = base0;
+        int lim, cmp;
+        const void *p;
 
         for (lim = nmemb; lim != 0; lim >>= 1) {
                 p = base + (lim >> 1) * size;
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
index a4730694a5..2403fcb0e8 100644
--- a/src/lib/libc/stdlib/div.3
+++ b/src/lib/libc/stdlib/div.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,10 +27,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)div.3 5.2 (Berkeley) 4/19/91
-.\"     $Id: div.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: div.3,v 1.10 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt DIV 3
 .Os
 .Sh NAME
@@ -47,24 +42,23 @@
 .Sh DESCRIPTION
 The
 .Fn div
-function
-computes the value
-.Fa num/denom
+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
-.Em int
+.Li int
 members named
 .Fa quot
 and
 .Fa rem .
 .Sh SEE ALSO
+.Xr imaxdiv 3 ,
 .Xr ldiv 3 ,
-.Xr qdiv 3 ,
-.Xr math 3
+.Xr lldiv 3 ,
+.Xr qdiv 3
 .Sh STANDARDS
 The
 .Fn div
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/div.c b/src/lib/libc/stdlib/div.c
index 122ac0deec..f7ac2db4b0 100644
--- a/src/lib/libc/stdlib/div.c
+++ b/src/lib/libc/stdlib/div.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,16 +31,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)div.c        5.2 (Berkeley) 4/16/91";*/
-static char *rcsid = "$Id: div.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>             /* div_t */
 
 div_t
-div(num, denom)
-        int num, denom;
+div(int num, int denom)
 {
         div_t r;
 
diff --git a/src/lib/libc/stdlib/drand48.c b/src/lib/libc/stdlib/drand48.c
index ae1a8634dc..b6c046c831 100644
--- a/src/lib/libc/stdlib/drand48.c
+++ b/src/lib/libc/stdlib/drand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: drand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/ecvt.3 b/src/lib/libc/stdlib/ecvt.3
new file mode 100644
index 0000000000..2f107e11fd
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.3
@@ -0,0 +1,165 @@
+.\" $OpenBSD: ecvt.3,v 1.9 2010/04/01 17:06:55 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 $Mdocdate: April 1 2010 $
+.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 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 .
+.Sh CAVEATS
+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.
diff --git a/src/lib/libc/stdlib/ecvt.c b/src/lib/libc/stdlib/ecvt.c
new file mode 100644
index 0000000000..03ff918967
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.c
@@ -0,0 +1,107 @@
+/*      $OpenBSD: ecvt.c,v 1.7 2009/10/16 12:15:03 martynas 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 **);
+extern void  __freedtoa(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, c;
+        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 (p == NULL)
+                        return (NULL);
+                if (*decpt == 9999) {
+                        /* Infinity or Nan, convert to inf or nan like printf */
+                        *decpt = 0;
+                        c = *p;
+                        __freedtoa(p);
+                        return(c == '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) {
+                        __freedtoa(p);
+                        return(NULL);
+                }
+                (void) strlcpy(s, p, siz);
+                rve = s + (rve - p);
+                __freedtoa(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
index cc9fbf770c..2ffeaa6e71 100644
--- a/src/lib/libc/stdlib/erand48.c
+++ b/src/lib/libc/stdlib/erand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: erand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/exit.3 b/src/lib/libc/stdlib/exit.3
index adb81ffcb4..45eae80a08 100644
--- a/src/lib/libc/stdlib/exit.3
+++ b/src/lib/libc/stdlib/exit.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,25 +29,30 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)exit.3        6.6 (Berkeley) 6/29/91
-.\"     $Id: exit.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: exit.3,v 1.11 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt EXIT 3
 .Os
 .Sh NAME
-.Nm exit
+.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
-.Fn Exit
-terminates a process.
+The
+.Fn exit
+and
+.Fn _Exit
+functions terminate a process.
 .Pp
-Before termination it performs the following functions in the
-order listed:
+Before termination,
+.Fn exit
+performs the following operations in the order listed:
 .Bl -enum -offset indent
 .It
 Call the functions registered with the
@@ -66,19 +67,48 @@ 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
-function
-never returns.
+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
-function
-conforms to
-.St -ansiC .
+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
index b1412f42bb..83fe3d2de5 100644
--- a/src/lib/libc/stdlib/exit.c
+++ b/src/lib/libc/stdlib/exit.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: exit.c,v 1.12 2007/09/03 14:40:16 millert Exp $ */
 /*-
  * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,31 +28,32 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)exit.c       5.4 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: exit.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
+#include <sys/mman.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include "atexit.h"
+#include "thread_private.h"
 
-void (*__cleanup)();
+/*
+ * 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(status)
-        int status;
+exit(int status)
 {
-        register struct atexit *p;
-        register int n;
-
-        for (p = __atexit; p; p = p->next)
-                for (n = p->ind; --n >= 0;)
-                        (*p->fns[n])();
-        if (__cleanup)
-                (*__cleanup)();
+        /*
+         * Call functions registered by atexit() or _cxa_atexit()
+         * (including the stdio cleanup routine) and then _exit().
+         */
+        __cxa_finalize(NULL);
         _exit(status);
 }
diff --git a/src/lib/libc/stdlib/gcvt.c b/src/lib/libc/stdlib/gcvt.c
new file mode 100644
index 0000000000..d9081a7d39
--- /dev/null
+++ b/src/lib/libc/stdlib/gcvt.c
@@ -0,0 +1,125 @@
+/*      $OpenBSD: gcvt.c,v 1.12 2010/09/25 13:19:19 millert Exp $       */
+
+/*
+ * Copyright (c) 2002, 2003, 2006, 2010
+ *      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 **);
+extern void  __freedtoa(char *);
+
+#define DEFPREC 6
+
+char *
+gcvt(double value, int ndigit, char *buf)
+{
+        char *digits, *dst, *src;
+        int i, decpt, sign;
+        struct lconv *lconv;
+
+        lconv = localeconv();
+        if (ndigit <= 0) {
+                /* Match printf(3) behavior. */
+                ndigit = ndigit ? DEFPREC : 1;
+        }
+
+        digits = __dtoa(value, 2, ndigit, &decpt, &sign, NULL);
+        if (digits == NULL)
+                return (NULL);
+        if (decpt == 9999) {
+                /*
+                 * Infinity or NaN, convert to inf or nan with sign.
+                 * We can't infer buffer size based on ndigit.
+                 * We have to assume it is at least 5 chars.
+                 */
+                snprintf(buf, 5, "%s%s", sign ? "-" : "",
+                    *digits == 'I' ? "inf" : "nan");
+                __freedtoa(digits);
+                return (buf);
+        }
+
+        dst = buf;
+        if (sign)
+                *dst++ = '-';
+
+        /* Match printf(3) behavior for exponential vs. regular fomatting. */
+        if (decpt <= -4 || decpt > ndigit) {
+                /* exponential format (e.g. 1.2345e+13) */
+                if (--decpt < 0) {
+                        sign = 1;
+                        decpt = -decpt;
+                } else
+                        sign = 0;
+                src = digits;
+                *dst++ = *src++;
+                if (*src != '\0') {
+                        *dst++ = *lconv->decimal_point;
+                        do {
+                                *dst++ = *src++;
+                        } while (*src != '\0');
+                }
+                *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;
+                        while (decpt < 0) {
+                                *dst++ = '0';
+                                decpt++;
+                        }
+                        for (i = decpt; digits[i] != '\0'; i++) {
+                                *dst++ = digits[i];
+                        }
+                }
+                *dst = '\0';
+        }
+        __freedtoa(digits);
+        return (buf);
+}
diff --git a/src/lib/libc/stdlib/getenv.3 b/src/lib/libc/stdlib/getenv.3
index 411eb35da4..9da27ec11c 100644
--- a/src/lib/libc/stdlib/getenv.3
+++ b/src/lib/libc/stdlib/getenv.3
@@ -1,5 +1,5 @@
-.\" Copyright (c) 1988, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" 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
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)getenv.3      6.11 (Berkeley) 6/29/91
-.\"     $Id: getenv.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: getenv.3,v 1.16 2011/04/27 13:40:15 otto Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: April 27 2011 $
 .Dt GETENV 3
 .Os
 .Sh NAME
@@ -52,82 +47,109 @@
 .Ft int
 .Fn setenv "const char *name" "const char *value" "int overwrite"
 .Ft int
-.Fn putenv "const char *string"
-.Ft void
+.Fn putenv "char *string"
+.Ft int
 .Fn unsetenv "const char *name"
 .Sh DESCRIPTION
-These functions set, unset and fetch environment variables from the
-host
+These functions set, unset, and fetch environment variables from the host
 .Em environment list .
-For compatibility with differing environment conventions,
-the given arguments
-.Ar name
+For compatibility with differing environment conventions, the given argument
+.Fa name
+may be appended with an equal sign
+.Dq Li \&=
+followed by zero or more characters,
 and
-.Ar value
-may be appended and prepended, 
-respectively,
-with an equal sign
-.Dq Li \&= .
+.Fa value
+may be prepended with an equal sign.
 .Pp
 The
 .Fn getenv
-function obtains the current value of the environment variable,
-.Ar name .
+function obtains the current value of the environment variable
+.Fa name .
 If the variable
-.Ar name
-is not in the current environment ,
-a null pointer is returned.
+.Fa name
+is not in the current environment, a null pointer is returned.
 .Pp
 The
 .Fn setenv
 function inserts or resets the environment variable
-.Ar name
+.Fa name
 in the current environment list.
 If the variable
-.Ar name
-does not exist in the list,
-it is inserted with the given
-.Ar value.
+.Fa name
+does not exist in the list, it is inserted with the given
+.Fa value .
 If the variable does exist, the argument
-.Ar overwrite
+.Fa overwrite
 is tested; if
-.Ar overwrite is
-zero, the
-variable is not reset, otherwise it is reset
-to the given
-.Ar value .
+.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 ``name=value'' and is
-equivalent to:
-.Bd -literal -offset indent
-setenv(name, value, 1);
-.Ed
+function takes an argument of the form
+.Ar name Ns = Ns Ar value .
+The memory pointed to by
+.Ar string
+becomes part of the environment and must not be deallocated by the caller.
+If the variable already exists, it will be overwritten.
+A common source of bugs is to pass a
+.Ar string
+argument that is a locally scoped string buffer.
+This will result in corruption of the environment after leaving
+the scope in which the variable is defined.
+For this reason, the
+.Fn setenv
+function is preferred over
+.Fn putenv .
 .Pp
 The
 .Fn unsetenv
-function
-deletes all instances of the variable name pointed to by
+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
+These functions
 return zero if successful; otherwise the global variable
 .Va errno
-is set to indicate the error and a
-\-1 is returned.
+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 EINVAL
+The
+.Fn setenv
+or
+.Fn unsetenv
+function was passed a
+.Ar name
+containing an
+.Sq =
+character.
+.Pp
+The
+.Fn unsetenv
+function was passed an empty
+.Ar name
+or a NULL pointer.
+.Pp
+The
+.Fn putenv
+function was passed a
+.Ar string
+that did not contain an
+.Sq =
+character.
 .It Bq Er ENOMEM
-The function
+The
 .Fn setenv
 or
 .Fn putenv
-failed because they were unable to allocate memory for the environment.
+function failed because it was unable to allocate memory for the environment.
 .El
 .Sh SEE ALSO
 .Xr csh 1 ,
@@ -140,12 +162,18 @@ The
 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
-.At v7 .
+.Bx 4.3 Tahoe .
 The
 .Fn putenv
 function appeared in
diff --git a/src/lib/libc/stdlib/getenv.c b/src/lib/libc/stdlib/getenv.c
index 09d47f2149..fd8482e9e3 100644
--- a/src/lib/libc/stdlib/getenv.c
+++ b/src/lib/libc/stdlib/getenv.c
@@ -1,6 +1,7 @@
+/*      $OpenBSD: getenv.c,v 1.10 2010/08/23 22:31:50 millert Exp $ */
 /*
- * Copyright (c) 1987 Regents of the University of California.
- * All rights reserved.
+ * 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
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,52 +28,54 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)getenv.c     5.8 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: getenv.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 #include <string.h>
 
-/*
- * getenv --
- *      Returns ptr to value associated with name, if any, else NULL.
- */
-char *
-getenv(name)
-        const char *name;
-{
-        int offset;
-        char *__findenv();
-
-        return(__findenv(name, &offset));
-}
+char *__findenv(const char *name, int len, int *offset);
 
 /*
  * __findenv --
  *      Returns pointer to value associated with name, if any, else NULL.
+ *      Starts searching within the environmental array at offset.
  *      Sets offset to be the offset of the name/value combination in the
- *      environmental array, for use by setenv(3) and unsetenv(3).
+ *      environmental array, for use by putenv(3), setenv(3) and unsetenv(3).
  *      Explicitly removes '=' in argument name.
  *
  *      This routine *should* be a static; don't use it.
  */
 char *
-__findenv(name, offset)
-        register char *name;
-        int *offset;
+__findenv(const char *name, int len, int *offset)
 {
         extern char **environ;
-        register int len;
-        register char **P, *C;
+        int i;
+        const char *np;
+        char **p, *cp;
+
+        if (name == NULL || environ == NULL)
+                return (NULL);
+        for (p = environ + *offset; (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 = 0;
+        const char *np;
 
-        for (C = name, len = 0; *C && *C != '='; ++C, ++len);
-        for (P = environ; *P; ++P)
-                if (!strncmp(*P, name, len))
-                        if (*(C = *P + len) == '=') {
-                                *offset = P - environ;
-                                return(++C);
-                        }
-        return(NULL);
+        for (np = name; *np && *np != '='; ++np)
+                ;
+        return (__findenv(name, (int)(np - name), &offset));
 }
diff --git a/src/lib/libc/stdlib/getopt.3 b/src/lib/libc/stdlib/getopt.3
index f843881afd..ecdf42ab76 100644
--- a/src/lib/libc/stdlib/getopt.3
+++ b/src/lib/libc/stdlib/getopt.3
@@ -9,11 +9,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,20 +25,20 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     @(#)getopt.3    8.4 (Berkeley) 4/19/94
+.\"     $OpenBSD: getopt.3,v 1.42 2011/03/05 22:10:11 guenther Exp $
 .\"
-.Dd April 19, 1994
+.Dd $Mdocdate: March 5 2011 $
 .Dt GETOPT 3
-.Os BSD 4.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   opterr;
 .Vt extern int   optreset;
 .Ft int
 .Fn getopt "int argc" "char * const *argv" "const char *optstring"
@@ -61,20 +57,25 @@ if it has been specified in the string of accepted option characters,
 .Pp
 The option string
 .Fa optstring
-may contain the following elements: individual characters, and
-characters followed by a colon to indicate an option argument
-is to follow.
+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
-.Li "\&""x""
+.Qq x
 recognizes an option
-.Dq Fl x ,
+.Fl x ,
 and an option string
-.Li "\&""x:""
+.Qq Li x:
 recognizes an option and argument
-.Dq Fl x Ar argument .
+.Fl x Ar argument .
 It does not matter to
 .Fn getopt
-if a following argument has leading white space.
+if a following argument has leading whitespace; except in the case where
+the argument is optional, denoted with two colons, no leading whitespace
+is permitted.
 .Pp
 On return from
 .Fn getopt ,
@@ -87,23 +88,23 @@ contains the index to the next
 argument for a subsequent call
 to
 .Fn getopt .
-The variable
-.Va optopt
-saves the last
-.Em known
-option character returned by
-.Fn getopt .
 .Pp
-The variable
+The variables
 .Va opterr
 and
 .Va optind
 are both initialized to 1.
 The
 .Va optind
-variable may be set to another value before a set of calls to
+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 argv entries.
+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
@@ -119,101 +120,154 @@ must be reinitialized.
 .Pp
 The
 .Fn getopt
-function
-returns \-1
-when the argument list is exhausted, or a non-recognized
-option is encountered.
+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 returns \-1.
+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 DIAGNOSTICS
-If the
+.Sh RETURN VALUES
+The
 .Fn getopt
-function encounters a character not found in the string
-.Va optarg
-or detects
-a missing option argument it writes an error message and returns
-.Ql ?
-to the
-.Em stderr .
-Setting
-.Va opterr
-to a zero will disable these error messages.
+function returns the next known option character in
+.Fa optstring .
 If
-.Va 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
-.Dq Li \- ;
-this is reasonable but
-reduces the amount of error checking possible.
-.Sh EXTENSIONS
+.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
-.Va optreset
-variable was added to make it possible to call the
 .Fn getopt
-function multiple times.
-This is an extension to the
-.St -p1003.2
-specification.
-.Sh EXAMPLE
-.Bd -literal -compact
-extern char *optarg;
-extern int optind;
+function returns \-1 when the argument list is exhausted.
+.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) {
+while ((ch = getopt(argc, argv, "bf:")) != -1) {
+        switch (ch) {
         case 'b':
                 bflag = 1;
                 break;
         case 'f':
-                if ((fd = open(optarg, O_RDONLY, 0)) < 0) {
-                        (void)fprintf(stderr,
-                            "myname: %s: %s\en", optarg, strerror(errno));
-                        exit(1);
-                }
+                if ((fd = open(optarg, O_RDONLY, 0)) == -1)
+                        err(1, "%s", optarg);
                 break;
-        case '?':
         default:
                 usage();
+                /* NOTREACHED */
+        }
 }
 argc -= optind;
 argv += optind;
 .Ed
-.Sh HISTORY
+.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 appeared
-.Bx 4.3 .
-.Sh BUGS
+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 was once specified to return
-.Dv EOF 
-instead of \-1.
-This was changed by
-.St -p1003.2-92
-to decouple 
+function multiple times.
+.It Li o
+If the
+.Va optind
+variable is set to 0,
 .Fn getopt
-from 
-.Pa <stdio.h> .
-.Pp
+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
-.Dq Li -
-may be specified as an character in
+.Pq Ql -
+may be specified as a character in
 .Fa optstring ,
 however it should
 .Em never
@@ -221,40 +275,90 @@ have an argument associated with it.
 This allows
 .Fn getopt
 to be used with programs that expect
-.Dq Li -
+.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.
-This is, we believe, compatible with System V.
+.El
+.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 also possible to handle digits as option letters.
+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
+.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.
+The following code fragment works in most cases and can handle mixed
+number and letter arguments.
 .Bd -literal -offset indent
-int length;
-char *p;
+int aflag = 0, bflag = 0, ch, lastch = '\e0';
+int length = -1, newarg = 1, prevoptind = 1;
 
-while ((c = getopt(argc, argv, "0123456789")) != -1)
-        switch (c) {
+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':
-                p = argv[optind - 1];
-                if (p[0] == '-' && p[1] == ch && !p[2])
-                        length = atoi(++p);
-                else
-                        length = atoi(argv[optind] + 1);
+                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.c b/src/lib/libc/stdlib/getopt.c
deleted file mode 100644
index 63c5e6a479..0000000000
--- a/src/lib/libc/stdlib/getopt.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 1987, 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-/* static char sccsid[] = "from: @(#)getopt.c   8.2 (Berkeley) 4/2/94"; */
-static char *rcsid = "$Id: getopt.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int     opterr = 1,             /* if error message should be printed */
-        optind = 1,             /* index into parent argv vector */
-        optopt,                 /* character checked for validity */
-        optreset;               /* reset getopt */
-char    *optarg;                /* argument associated with option */
-
-#define BADCH   (int)'?'
-#define BADARG  (int)':'
-#define EMSG    ""
-
-/*
- * getopt --
- *      Parse argc/argv argument vector.
- */
-int
-getopt(nargc, nargv, ostr)
-        int nargc;
-        char * const *nargv;
-        const char *ostr;
-{
-        extern char *__progname;
-        static char *place = EMSG;              /* option letter processing */
-        char *oli;                              /* option letter list index */
-
-        if (optreset || !*place) {              /* update scanning pointer */
-                optreset = 0;
-                if (optind >= nargc || *(place = nargv[optind]) != '-') {
-                        place = EMSG;
-                        return (-1);
-                }
-                if (place[1] && *++place == '-') {      /* found "--" */
-                        ++optind;
-                        place = EMSG;
-                        return (-1);
-                }
-        }                                       /* option letter okay? */
-        if ((optopt = (int)*place++) == (int)':' ||
-            !(oli = strchr(ostr, optopt))) {
-                /*
-                 * if the user didn't specify '-' as an option,
-                 * assume it means -1.
-                 */
-                if (optopt == (int)'-')
-                        return (-1);
-                if (!*place)
-                        ++optind;
-                if (opterr && *ostr != ':')
-                        (void)fprintf(stderr,
-                            "%s: illegal option -- %c\n", __progname, optopt);
-                return (BADCH);
-        }
-        if (*++oli != ':') {                    /* don't need argument */
-                optarg = NULL;
-                if (!*place)
-                        ++optind;
-        }
-        else {                                  /* need an argument */
-                if (*place)                     /* no white space */
-                        optarg = place;
-                else if (nargc <= ++optind) {   /* no arg */
-                        place = EMSG;
-                        if (*ostr == ':')
-                                return (BADARG);
-                        if (opterr)
-                                (void)fprintf(stderr,
-                                    "%s: option requires an argument -- %c\n",
-                                    __progname, optopt);
-                        return (BADCH);
-                }
-                else                            /* white space */
-                        optarg = nargv[optind];
-                place = EMSG;
-                ++optind;
-        }
-        return (optopt);                        /* dump back option letter */
-}
diff --git a/src/lib/libc/stdlib/getopt_long.3 b/src/lib/libc/stdlib/getopt_long.3
new file mode 100644
index 0000000000..eaa5ead1c7
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.3
@@ -0,0 +1,445 @@
+.\"     $OpenBSD: getopt_long.3,v 1.19 2011/03/21 13:41:50 espie 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 $Mdocdate: March 21 2011 $
+.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
+Abbreviated long option names are accepted when
+.Fn getopt_long
+processes long options if the abbreviation is unique.
+An exact match is always preferred for a defined long option.
+.Pp
+The
+.Fn getopt_long
+call requires an array to be initialized describing the long
+options.
+Each element of the array is a structure:
+.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 IMPLEMENTATION DIFFERENCES
+This section describes differences to the GNU implementation
+found in glibc-2.1.3:
+.Bl -bullet
+.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 +
+in the
+.Ar optstring
+is ignored.
+.El
+.Sh EXAMPLES
+.Bd -literal
+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 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..e149fe0ace
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.c
@@ -0,0 +1,511 @@
+/*      $OpenBSD: getopt_long.c,v 1.25 2011/03/05 22:10:11 guenther 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.
+ *
+ * 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>
+
+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 */
+
+#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);
+
+        /*
+         * 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;
+
+        /*
+         * Disable GNU extensions if POSIXLY_CORRECT is set or options
+         * string begins with a '+'.
+         */
+        if (posixly_correct == -1 || optreset)
+                posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+        if (*options == '-')
+                flags |= FLAG_ALLARGS;
+        else if (posixly_correct || *options == '+')
+                flags &= ~FLAG_PERMUTE;
+        if (*options == '+' || *options == '-')
+                options++;
+
+        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;
+                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];
+                }
+                place = EMSG;
+                ++optind;
+        }
+        /* dump back option letter */
+        return (optchar);
+}
+
+/*
+ * 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));
+}
+
+/*
+ * 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..9f35df703f
--- /dev/null
+++ b/src/lib/libc/stdlib/getsubopt.3
@@ -0,0 +1,145 @@
+.\" $OpenBSD: getsubopt.3,v 1.12 2007/05/31 19:19:31 jmc 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 $Mdocdate: May 31 2007 $
+.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..ea264b57c8
--- /dev/null
+++ b/src/lib/libc/stdlib/hcreate.3
@@ -0,0 +1,239 @@
+.\"     $OpenBSD: hcreate.3,v 1.6 2010/07/28 09:00:20 ray Exp $
+.\"     $NetBSD: hcreate.3,v 1.8 2010/05/01 06:18:03 jruoho 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.
+.\"
+.\" 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 $Mdocdate: July 28 2010 $
+.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
+.Vt ENTRY ,
+defined in the
+.In search.h
+header.
+This is a structure type that contains two pointers:
+.Pp
+.Bl -tag -compact -offset indent -width "void *data "
+.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
+.Vt 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
+.Pp
+Note that the comparison
+.Fa key
+must be allocated using
+.Xr malloc 3
+or
+.Xr calloc 3
+if action is
+.Dv ENTER
+and
+.Fn hdestroy
+will be called.
+This is because
+.Fn hdestroy
+will call
+.Xr free 3
+for each comparison
+.Fa key
+(but not
+.Fa data ) .
+Typically the comparison
+.Fa key
+is allocated by using
+.Xr strdup 3 .
+.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
+The
+.Fn hcreate ,
+.Fn hdestroy
+and
+.Fn hsearch
+functions conform to
+.St -xpg4.2 .
+.Sh HISTORY
+The
+.Fn hcreate ,
+.Fn hdestroy
+and
+.Fn hsearch
+functions first appeared in
+.At V .
+.Sh CAVEATS
+At least the following limitations can be mentioned:
+.Bl -bullet
+.It
+The interface permits the use of only one hash table at a time.
+.It
+Individual hash table entries can be added, but not deleted.
+.It
+The standard is indecipherable about the
+internal memory usage of the functions,
+mentioning only that
+.Do
+.Fn hcreate
+and
+.Fn hsearch
+functions may use
+.Fn malloc
+to allocate space
+.Dc .
+This limits the portability of the functions,
+given that other implementations may not
+.Xr free 3
+the buffer pointed by
+.Fa key .
+.El
diff --git a/src/lib/libc/stdlib/hcreate.c b/src/lib/libc/stdlib/hcreate.c
new file mode 100644
index 0000000000..094f32c173
--- /dev/null
+++ b/src/lib/libc/stdlib/hcreate.c
@@ -0,0 +1,191 @@
+/*      $OpenBSD: hcreate.c,v 1.4 2007/09/02 15:19:17 deraadt 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 = calloc(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
index bd998fa357..ad3fffbcd9 100644
--- a/src/lib/libc/stdlib/heapsort.c
+++ b/src/lib/libc/stdlib/heapsort.c
@@ -13,11 +13,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +30,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char sccsid[] = "from: @(#)heapsort.c  8.1 (Berkeley) 6/4/93";*/
-static char *rcsid = "$Id: heapsort.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <errno.h>
 #include <stdlib.h>
@@ -73,7 +64,7 @@ static char *rcsid = "$Id: heapsort.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp
  * 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 two cases.  If j == nmemb, select largest of Ki and Kj.  If
+ * 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) { \
@@ -95,12 +86,12 @@ static char *rcsid = "$Id: heapsort.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp
  * 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
- * elememt, is ususally quite small, so it would be preferable to first
+ * 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 maintianing the invariant.  As a result of the invariant no element
+ * 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
@@ -139,13 +130,11 @@ static char *rcsid = "$Id: heapsort.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp
  * only advantage over quicksort is that it requires little additional memory.
  */
 int
-heapsort(vbase, nmemb, size, compar)
-        void *vbase;
-        size_t nmemb, size;
-        int (*compar) __P((const void *, const void *));
+heapsort(void *vbase, size_t nmemb, size_t size,
+    int (*compar)(const void *, const void *))
 {
-        register int cnt, i, j, l;
-        register char tmp, *tmp1, *tmp2;
+        size_t cnt, i, j, l;
+        char tmp, *tmp1, *tmp2;
         char *base, *k, *p, *t;
 
         if (nmemb <= 1)
diff --git a/src/lib/libc/stdlib/free.3 b/src/lib/libc/stdlib/imaxabs.3
index 3d0131d7de..74b724fcbf 100644
--- a/src/lib/libc/stdlib/free.3
+++ b/src/lib/libc/stdlib/imaxabs.3
@@ -1,4 +1,4 @@
-.\" Copyright (c) 1991 The Regents of the University of California.
+.\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to Berkeley by
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,50 +29,37 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)free.3        5.2 (Berkeley) 6/29/91
-.\"     $Id: free.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: imaxabs.3,v 1.5 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
-.Dt FREE 3
+.Dd $Mdocdate: July 7 2011 $
+.Dt IMAXABS 3
 .Os
 .Sh NAME
-.Nm free
-.Nd free up memory allocated with malloc, calloc or realloc
+.Nm imaxabs
+.Nd integer absolute value function
 .Sh SYNOPSIS
-.Fd #include <stdlib.h>
-.Ft void
-.Fn free "void *ptr"
+.Fd #include <inttypes.h>
+.Ft intmax_t
+.Fn imaxabs "intmax_t j"
 .Sh DESCRIPTION
 The
-.Fn free
-function causes the space pointed to by
-.Fa ptr
-to be deallocated, that is, made available
-for further allocation.
-If
-.Fa ptr
-is a null pointer, no action occurs.
-Otherwise, if the argument does not match a pointer earlier
-returned by the
-.Xr calloc ,
-.Xr malloc ,
-or
-.Xr realloc
-function, or if the space has been deallocated by a call to
-.Fn free
-or
-.Xr realloc ,
-general havoc may occur.
+.Fn imaxabs
+function computes the absolute value of the intmax_t variable
+.Fa j .
 .Sh RETURN VALUES
 The
-.Fn free
-function returns no value.
+.Fn imaxabs
+function returns the absolute value.
 .Sh SEE ALSO
-.Xr calloc 3 ,
-.Xr malloc 3 ,
-.Xr realloc 3
+.Xr abs 3 ,
+.Xr cabs 3 ,
+.Xr floor 3 ,
+.Xr hypot 3 ,
+.Xr labs 3
 .Sh STANDARDS
 The
-.Fn free
+.Fn imaxabs
 function conforms to
-.St -ansiC .
+.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..2448f3f054
--- /dev/null
+++ b/src/lib/libc/stdlib/imaxdiv.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 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.4 2011/07/07 13:30:28 jmc Exp $
+.\"
+.Dd $Mdocdate: July 7 2011 $
+.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 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..dbda059c43
--- /dev/null
+++ b/src/lib/libc/stdlib/insque.3
@@ -0,0 +1,106 @@
+.\"     $OpenBSD: insque.3,v 1.8 2011/01/14 07:33:47 jmc 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 $Mdocdate: January 14 2011 $
+.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 superseded 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
index 205781e0ee..cb8c592750 100644
--- a/src/lib/libc/stdlib/jrand48.c
+++ b/src/lib/libc/stdlib/jrand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: jrand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/l64a.c b/src/lib/libc/stdlib/l64a.c
index 3069b31bf6..4f33df37b2 100644
--- a/src/lib/libc/stdlib/l64a.c
+++ b/src/lib/libc/stdlib/l64a.c
@@ -1,25 +1,24 @@
+/*      $OpenBSD: l64a.c,v 1.5 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Written by J.T. Conklin <jtc@netbsd.org>.
  * Public domain.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: l64a.c,v 1.4 1995/05/11 23:04:52 jtc Exp $";
-#endif
-
+#include <errno.h>
 #include <stdlib.h>
 
 char *
-l64a (value)
-        long value;
+l64a(long value)
 {
         static char buf[8];
         char *s = buf;
         int digit;
         int i;
 
-        if (!value) 
-                return NULL;
+        if (value < 0) {
+                errno = EINVAL;
+                return(NULL);
+        }
 
         for (i = 0; value != 0 && i < 6; i++) {
                 digit = value & 0x3f;
@@ -39,5 +38,5 @@ l64a (value)
 
         *s = '\0';
 
-        return buf;
+        return(buf);
 }
diff --git a/src/lib/libc/stdlib/labs.3 b/src/lib/libc/stdlib/labs.3
index 28e4d2053c..9658c3ad51 100644
--- a/src/lib/libc/stdlib/labs.3
+++ b/src/lib/libc/stdlib/labs.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,35 +29,40 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)labs.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: labs.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
+.\"     $OpenBSD: labs.3,v 1.10 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt LABS 3
 .Os
 .Sh NAME
-.Nm labs
+.Nm labs, llabs
 .Nd return the absolute value of a long integer
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
 .Ft long
-.Fn labs "long j"
+.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
-.Ar j .
+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 floor 3 ,
 .Xr cabs 3 ,
-.Xr math 3
+.Xr floor 3 ,
+.Xr imaxabs 3
 .Sh STANDARDS
 The
 .Fn labs
-function
-conforms to
-.St -ansiC .
+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
index ccf1415792..ca60b9aba2 100644
--- a/src/lib/libc/stdlib/labs.c
+++ b/src/lib/libc/stdlib/labs.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)labs.c       5.2 (Berkeley) 5/17/90";*/
-static char *rcsid = "$Id: labs.c,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 long
-labs(j)
-        long j;
+labs(long j)
 {
         return(j < 0 ? -j : j);
 }
diff --git a/src/lib/libc/stdlib/lcong48.c b/src/lib/libc/stdlib/lcong48.c
index 965d46b17a..2cf5c271ba 100644
--- a/src/lib/libc/stdlib/lcong48.c
+++ b/src/lib/libc/stdlib/lcong48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: lcong48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/ldiv.3 b/src/lib/libc/stdlib/ldiv.3
index a7b5ccf878..d300187887 100644
--- a/src/lib/libc/stdlib/ldiv.3
+++ b/src/lib/libc/stdlib/ldiv.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)ldiv.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: ldiv.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: ldiv.3,v 1.10 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt LDIV 3
 .Os
 .Sh NAME
@@ -49,24 +44,23 @@
 .Sh DESCRIPTION
 The
 .Fn ldiv
-function
-computes the value
-.Ar num/denom
+function computes the value
+.Fa num Ns / Ns Fa denom
 and returns the quotient and remainder in a structure named
-.Ar ldiv_t
+.Li ldiv_t
 that contains two
-.Em long integer
+.Li long integer
 members named
-.Ar quot
+.Fa quot
 and
-.Ar rem .
+.Fa rem .
 .Sh SEE ALSO
 .Xr div 3 ,
-.Xr qdiv 3 ,
-.Xr math 3
+.Xr imaxdiv 3 ,
+.Xr lldiv 3 ,
+.Xr qdiv 3
 .Sh STANDARDS
 The
 .Fn ldiv
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/ldiv.c b/src/lib/libc/stdlib/ldiv.c
index f7074507e5..775065f525 100644
--- a/src/lib/libc/stdlib/ldiv.c
+++ b/src/lib/libc/stdlib/ldiv.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,16 +31,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)ldiv.c       5.2 (Berkeley) 4/16/91";*/
-static char *rcsid = "$Id: ldiv.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>             /* ldiv_t */
 
 ldiv_t
-ldiv(num, denom)
-        long num, denom;
+ldiv(long num, long denom)
 {
         ldiv_t r;
 
diff --git a/src/lib/libc/stdlib/llabs.c b/src/lib/libc/stdlib/llabs.c
new file mode 100644
index 0000000000..fc2cd8261c
--- /dev/null
+++ b/src/lib/libc/stdlib/llabs.c
@@ -0,0 +1,38 @@
+/*      $OpenBSD: llabs.c,v 1.3 2007/01/08 19:39:25 deraadt 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 long
+llabs(long long j)
+{
+        return (j < 0 ? -j : j);
+}
diff --git a/src/lib/libc/stdlib/memory.3 b/src/lib/libc/stdlib/lldiv.3
index 735252c837..4c97d7c9b7 100644
--- a/src/lib/libc/stdlib/memory.3
+++ b/src/lib/libc/stdlib/lldiv.3
@@ -1,6 +1,10 @@
-.\" Copyright (c) 1991 Regents of the University of California.
+.\" 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:
@@ -9,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,43 +29,38 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memory.3      5.1 (Berkeley) 5/2/91
-.\"     $Id: memory.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: lldiv.3,v 1.3 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd May 2, 1991
-.Dt MEMORY 3
-.Os BSD 4
+.Dd $Mdocdate: July 7 2011 $
+.Dt LLDIV 3
+.Os
 .Sh NAME
-.Nm malloc ,
-.Nm free ,
-.Nm realloc ,
-.Nm calloc ,
-.Nm alloca
-.Nd general memory allocation operations
+.Nm lldiv
+.Nd return quotient and remainder from division
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
-.Ft void *
-.Fn malloc "size_t size"
-.Ft void
-.Fn free "void *ptr"
-.Ft void *
-.Fn realloc "void *ptr" "size_t size"
-.Ft void *
-.Fn calloc "size_t nelem" "size_t elsize"
-.Ft void *
-.Fn alloca "size_t size"
+.Ft lldiv_t
+.Fn lldiv "long long num" "long long denom"
 .Sh DESCRIPTION
-These functions allocate and free memory for the calling process.
-They are described in the
-individual manual pages.
+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 calloc 3 ,
-.Xr free 3 ,
-.Xr malloc 3 ,
-.Xr realloc 3 ,
-.Xr alloca 3 ,
+.Xr div 3 ,
+.Xr imaxdiv 3 ,
+.Xr ldiv 3 ,
+.Xr qdiv 3
 .Sh STANDARDS
-These functions, with the exception of
-.Fn alloca
-conform to
-.St -ansiC .
+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
index 8e7f26237f..21beb858ca 100644
--- a/src/lib/libc/stdlib/lrand48.c
+++ b/src/lib/libc/stdlib/lrand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: lrand48.c,v 1.3 2005/08/08 08:05:36 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/lsearch.3 b/src/lib/libc/stdlib/lsearch.3
new file mode 100644
index 0000000000..86638ae621
--- /dev/null
+++ b/src/lib/libc/stdlib/lsearch.3
@@ -0,0 +1,108 @@
+.\"     $OpenBSD: lsearch.3,v 1.9 2009/02/10 21:47:56 jmc 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 $Mdocdate: February 10 2009 $
+.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)(const void *, const void *)"
+.Ft char *
+.Fn lfind "const void *key" "const void *base" "size_t *nelp" \
+    "size_t width" "int (*compar)(const void *, const 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..a01d80e008
--- /dev/null
+++ b/src/lib/libc/stdlib/lsearch.c
@@ -0,0 +1,84 @@
+/*      $OpenBSD: lsearch.c,v 1.4 2009/10/27 23:59:59 deraadt 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.
+ */
+
+#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
index 3bbf2bf65e..6a012fd23d 100644
--- a/src/lib/libc/stdlib/malloc.3
+++ b/src/lib/libc/stdlib/malloc.3
@@ -1,5 +1,6 @@
-.\" Copyright (c) 1980, 1991 Regents of the University of California.
-.\" All rights reserved.
+.\"
+.\" 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
@@ -13,11 +14,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,19 +30,32 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)malloc.3      6.7 (Berkeley) 6/29/91
-.\"     $Id: malloc.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: malloc.3,v 1.70 2011/07/22 07:00:44 otto Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 22 2011 $
 .Dt MALLOC 3
-.Os BSD 4
+.Os
 .Sh NAME
-.Nm malloc
-.Nd general memory allocation function
+.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
@@ -59,33 +69,390 @@ 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
+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 (size && num > SIZE_MAX / 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 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 either placed on a list of free pages to make it available for future
+allocation or, if required, to be returned to the kernel using
+.Xr munmap 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
+.Sh MALLOC_OPTIONS
+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 internal
+inconsistencies or incorrect usage.
+This is the default and a very handy debugging aid,
+since the core file represents the time of failure,
+rather than when the bogus pointer was used.
+.It Cm D
+.Dq Dump .
+.Fn malloc
+will dump statistics to the file
+.Pa ./malloc.out ,
+if it already exists,
+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.
+This will also switch off the delayed freeing of chunks,
+reducing random behaviour but detecting double
+.Fn free
+calls as early as possible.
+.It Cm G
+.Dq Guard .
+Enable guard pages.
+Each page size or larger allocation is followed by a guard page that will
+cause a segmentation fault upon any access.
+.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 when allocating; this is pronounced
+.Dq Duh .
+\&:-)
+Freed chunks are filled with 0xdf.
+.It Cm P
+.Dq Move allocations within a page.
+Allocations larger than half a page but smaller than a page
+are aligned to the end of a page to catch buffer overruns in more
+cases.
+This is the default.
+.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 S
+Enable all options suitable for security auditing.
+.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
+.Pp
+Note that this will cause code that is supposed to handle
+out-of-memory conditions gracefully to abort instead.
+.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 the cache to a quarter of the
+default size and use guard pages:
+.Dl # ln -s 'G\*(Lt\*(Lt' /etc/malloc.conf
+.Pp
+The flags are mostly for testing and debugging.
+If a program changes behavior if any of these options (except
+.Cm X )
+are used,
+it is buggy.
+.Pp
+The default number of free pages cached is 64.
 .Sh RETURN VALUES
 The
 .Fn malloc
-function returns
-a pointer to the allocated space if successful; otherwise
-a null pointer is returned.
+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 condition,
+a message will be printed to file descriptor
+2 (not using stdio).
+Errors will result in the process being aborted,
+unless the
+.Cm a
+option has been specified.
+.Pp
+Here is a brief description of the error messages and what they mean:
+.Bl -tag -width Ds
+.It Dq out of memory
+If the
+.Cm X
+option is specified it is an error for
+.Fn malloc ,
+.Fn calloc ,
+or
+.Fn realloc
+to return
+.Dv NULL .
+.It Dq malloc init mmap failed
+This is a rather weird condition that is most likely to indicate a
+seriously overloaded system or a ulimit restriction.
+.It Dq bogus pointer (double free?)
+An attempt to
+.Fn free
+or
+.Fn realloc
+an unallocated pointer was made.
+.It Dq chunk is already free
+There was an attempt to free a chunk that had already been freed.
+.It Dq modified chunk-pointer
+The pointer passed to
+.Fn free
+or
+.Fn realloc
+has been modified.
+.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.
+.It Dq malloc cache overflow/underflow
+The internal malloc page cache has been corrupted.
+.It Dq malloc free slot lost
+The internal malloc page cache has been corrupted.
+.It Dq guard size
+An inconsistent guard size was detected.
+.It any other error
+.Fn malloc
+detected an internal error;
+consult sources and/or wizards.
+.El
 .Sh SEE ALSO
 .Xr brk 2 ,
-.Xr getpagesize 2 ,
-.Xr free 3 ,
-.Xr calloc 3 ,
+.Xr mmap 2 ,
+.Xr munmap 2 ,
 .Xr alloca 3 ,
-.Xr realloc 3 ,
-.Xr memory 3
+.Xr getpagesize 3 ,
+.Xr posix_memalign 3
 .Sh STANDARDS
 The
 .Fn malloc
 function conforms to
 .St -ansiC .
-.Sh BUGS
-The current implementation of
-.Xr malloc
-does not always fail gracefully when system
-memory limits are approached.
-It may fail to allocate memory when larger free blocks could be broken
-up, or when limits are exceeded because the size is rounded up.
-It is optimized for sizes that are powers of two.
+.Sh HISTORY
+The
+.Nm
+family of functions first appeared in
+.At v7 .
+A new implementation by Chris Kingsley was introduced in
+.Bx 4.2 ,
+followed by a complete rewrite by Poul-Henning Kamp which appeared in
+.Fx 2.2
+and was included in
+.Ox 2.0 .
+These implementations were all
+.Xr sbrk 2
+based.
+In
+.Ox 3.8 ,
+Thierry Deval rewrote
+.Nm
+to use the
+.Xr mmap 2
+system call,
+making the page addresses returned by
+.Nm
+random.
+A rewrite by Otto Moerbeek introducing a new central data structure and more
+randomization appeared in
+.Ox 4.4 .
diff --git a/src/lib/libc/stdlib/malloc.c b/src/lib/libc/stdlib/malloc.c
index 3c57fad024..5fc75c2c75 100644
--- a/src/lib/libc/stdlib/malloc.c
+++ b/src/lib/libc/stdlib/malloc.c
@@ -1,421 +1,1693 @@
+/*      $OpenBSD: malloc.c,v 1.140 2011/10/06 14:37:04 otto Exp $       */
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 2008 Otto Moerbeek <otto@drijf.net>
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)malloc.c     5.11 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: malloc.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 /*
- * malloc.c (Caltech) 2/21/82
- * Chris Kingsley, kingsley@cit-20.
- *
- * This is a very fast storage allocator.  It allocates blocks of a small 
- * number of different sizes, and keeps free lists of each size.  Blocks that
- * don't exactly fit are passed up to the next larger size.  In this 
- * implementation, the available sizes are 2^n-4 (or 2^n-10) bytes long.
- * This is designed for use in a virtual memory environment.
+ * Parts of this code, mainly the sub page sized chunk management code is
+ * derived from the malloc implementation with the following license:
+ */
+/*
+ * ----------------------------------------------------------------------------
+ * "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
+ * ----------------------------------------------------------------------------
  */
 
+/* #define MALLOC_STATS */
+
 #include <sys/types.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+#include <errno.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 #include <unistd.h>
 
-#define NULL 0
+#ifdef MALLOC_STATS
+#include <sys/tree.h>
+#include <fcntl.h>
+#endif
+
+#include "thread_private.h"
+
+#if defined(__sparc__) && !defined(__sparcv9__)
+#define MALLOC_PAGESHIFT        (13U)
+#elif defined(__mips64__)
+#define MALLOC_PAGESHIFT        (14U)
+#else
+#define MALLOC_PAGESHIFT        (PGSHIFT)
+#endif
+
+#define MALLOC_MINSHIFT         4
+#define MALLOC_MAXSHIFT         (MALLOC_PAGESHIFT - 1)
+#define MALLOC_PAGESIZE         (1UL << MALLOC_PAGESHIFT)
+#define MALLOC_MINSIZE          (1UL << MALLOC_MINSHIFT)
+#define MALLOC_PAGEMASK         (MALLOC_PAGESIZE - 1)
+#define MASK_POINTER(p)         ((void *)(((uintptr_t)(p)) & ~MALLOC_PAGEMASK))
 
-static void morecore();
-static int findbucket();
+#define MALLOC_MAXCHUNK         (1 << MALLOC_MAXSHIFT)
+#define MALLOC_MAXCACHE         256
+#define MALLOC_DELAYED_CHUNKS   15      /* max of getrnibble() */
+#define MALLOC_INITIAL_REGIONS  512
+#define MALLOC_DEFAULT_CACHE    64
 
 /*
- * The overhead on a block is at least 4 bytes.  When free, this space
- * contains a pointer to the next free block, and the bottom two bits must
- * be zero.  When in use, the first byte is set to MAGIC, and the second
- * byte is the size index.  The remaining bytes are for alignment.
- * If range checking is enabled then a second word holds the size of the
- * requested block, less 1, rounded up to a multiple of sizeof(RMAGIC).
- * The order of elements is critical: ov_magic must overlay the low order
- * bits of ov_next, and ov_magic can not be a valid ov_next bit pattern.
+ * When the P option is active, we move allocations between half a page
+ * and a whole page towards the end, subject to alignment constraints.
+ * This is the extra headroom we allow. Set to zero to be the most
+ * strict.
  */
-union   overhead {
-        union   overhead *ov_next;      /* when free */
-        struct {
-                u_char  ovu_magic;      /* magic number */
-                u_char  ovu_index;      /* bucket # */
-#ifdef RCHECK
-                u_short ovu_rmagic;     /* range magic number */
-                u_long  ovu_size;       /* actual block size */
+#define MALLOC_LEEWAY           0
+
+#define PAGEROUND(x)  (((x) + (MALLOC_PAGEMASK)) & ~MALLOC_PAGEMASK)
+
+/*
+ * What to use for Junk.  This is the byte value we use to fill with
+ * when the 'J' option is enabled. Use SOME_JUNK right after alloc,
+ * and SOME_FREEJUNK right before free.
+ */
+#define SOME_JUNK               0xd0    /* as in "Duh" :-) */
+#define SOME_FREEJUNK           0xdf
+
+#define MMAP(sz)        mmap(NULL, (size_t)(sz), PROT_READ | PROT_WRITE, \
+    MAP_ANON | MAP_PRIVATE, -1, (off_t) 0)
+
+#define MMAPA(a,sz)     mmap((a), (size_t)(sz), PROT_READ | PROT_WRITE, \
+    MAP_ANON | MAP_PRIVATE, -1, (off_t) 0)
+
+struct region_info {
+        void *p;                /* page; low bits used to mark chunks */
+        uintptr_t size;         /* size for pages, or chunk_info pointer */
+#ifdef MALLOC_STATS
+        void *f;                /* where allocated from */
 #endif
-        } ovu;
-#define ov_magic        ovu.ovu_magic
-#define ov_index        ovu.ovu_index
-#define ov_rmagic       ovu.ovu_rmagic
-#define ov_size         ovu.ovu_size
 };
 
-#define MAGIC           0xef            /* magic # on accounting info */
-#define RMAGIC          0x5555          /* magic # on range info */
+LIST_HEAD(chunk_head, chunk_info);
 
-#ifdef RCHECK
-#define RSLOP           sizeof (u_short)
+struct dir_info {
+        u_int32_t canary1;
+        struct region_info *r;          /* region slots */
+        size_t regions_total;           /* number of region slots */
+        size_t regions_free;            /* number of free slots */
+                                        /* lists of free chunk info structs */
+        struct chunk_head chunk_info_list[MALLOC_MAXSHIFT + 1];
+                                        /* lists of chunks with free slots */
+        struct chunk_head chunk_dir[MALLOC_MAXSHIFT + 1];
+        size_t free_regions_size;       /* free pages cached */
+                                        /* free pages cache */
+        struct region_info free_regions[MALLOC_MAXCACHE];
+                                        /* delayed free chunk slots */
+        void *delayed_chunks[MALLOC_DELAYED_CHUNKS + 1];
+        u_short chunk_start;
+#ifdef MALLOC_STATS
+        size_t inserts;
+        size_t insert_collisions;
+        size_t finds;
+        size_t find_collisions;
+        size_t deletes;
+        size_t delete_moves;
+        size_t cheap_realloc_tries;
+        size_t cheap_reallocs;
+#define STATS_INC(x) ((x)++)
+#define STATS_ZERO(x) ((x) = 0)
+#define STATS_SETF(x,y) ((x)->f = (y))
 #else
-#define RSLOP           0
-#endif
+#define STATS_INC(x)    /* nothing */
+#define STATS_ZERO(x)   /* nothing */
+#define STATS_SETF(x,y) /* nothing */
+#endif /* MALLOC_STATS */
+        u_int32_t canary2;
+};
+#define DIR_INFO_RSZ    ((sizeof(struct dir_info) + MALLOC_PAGEMASK) & \
+                        ~MALLOC_PAGEMASK)
 
 /*
- * nextf[i] is the pointer to the next free block of size 2^(i+3).  The
- * smallest allocatable block is 8 bytes.  The overhead information
- * precedes the data area returned to the user.
+ * This structure describes a page worth of chunks.
+ *
+ * How many bits per u_short in the bitmap
  */
-#define NBUCKETS 30
-static  union overhead *nextf[NBUCKETS];
-extern  char *sbrk();
+#define MALLOC_BITS             (NBBY * sizeof(u_short))
+struct chunk_info {
+        LIST_ENTRY(chunk_info) entries;
+        void *page;                     /* pointer to the page */
+        u_int32_t canary;
+        u_short size;                   /* size of this page's chunks */
+        u_short shift;                  /* how far to shift for this size */
+        u_short free;                   /* how many free chunks */
+        u_short total;                  /* how many chunk */
+                                        /* which chunks are free */
+        u_short bits[1];
+};
+
+struct malloc_readonly {
+        struct dir_info *g_pool;        /* Main bookkeeping information */
+        int     malloc_abort;           /* abort() on error */
+        int     malloc_freeprot;        /* mprotect free pages PROT_NONE? */
+        int     malloc_hint;            /* call madvice on free pages?  */
+        int     malloc_junk;            /* junk fill? */
+        int     malloc_move;            /* move allocations to end of page? */
+        int     malloc_realloc;         /* always realloc? */
+        int     malloc_xmalloc;         /* xmalloc behaviour? */
+        int     malloc_zero;            /* zero fill? */
+        size_t  malloc_guard;           /* use guard pages after allocations? */
+        u_int   malloc_cache;           /* free pages we cache */
+#ifdef MALLOC_STATS
+        int     malloc_stats;           /* dump statistics at end */
+#endif
+        u_int32_t malloc_canary;        /* Matched against ones in g_pool */
+};
 
-static  int pagesz;                     /* page size */
-static  int pagebucket;                 /* page size bucket */
+/* This object is mapped PROT_READ after initialisation to prevent tampering */
+static union {
+        struct malloc_readonly mopts;
+        u_char _pad[MALLOC_PAGESIZE];
+} malloc_readonly __attribute__((aligned(MALLOC_PAGESIZE)));
+#define mopts   malloc_readonly.mopts
+#define g_pool  mopts.g_pool
 
-#ifdef MSTATS
-/*
- * nmalloc[i] is the difference between the number of mallocs and frees
- * for a given block size.
+char            *malloc_options;        /* compile-time options */
+
+static char     *malloc_func;           /* current function */
+static int      malloc_active;          /* status of malloc */
+
+static size_t   malloc_guarded;         /* bytes used for guards */
+static size_t   malloc_used;            /* bytes allocated */
+
+static size_t rnibblesused;             /* random nibbles used */
+static u_char rbytes[512];              /* random bytes */
+static u_char getrnibble(void);
+
+extern char     *__progname;
+
+#ifdef MALLOC_STATS
+void malloc_dump(int);
+static void malloc_exit(void);
+#define CALLER  __builtin_return_address(0)
+#else
+#define CALLER  NULL
+#endif
+
+/* low bits of r->p determine size: 0 means >= page size and p->size holding
+ *  real size, otherwise r->size is a shift count, or 1 for malloc(0)
  */
-static  u_int nmalloc[NBUCKETS];
-#include <stdio.h>
+#define REALSIZE(sz, r)                                         \
+        (sz) = (uintptr_t)(r)->p & MALLOC_PAGEMASK,             \
+        (sz) = ((sz) == 0 ? (r)->size : ((sz) == 1 ? 0 : (1 << ((sz)-1))))
+
+static inline size_t
+hash(void *p)
+{
+        size_t sum;
+        union {
+                uintptr_t p;
+                unsigned short a[sizeof(void *) / sizeof(short)];
+        } u;
+        u.p = (uintptr_t)p >> MALLOC_PAGESHIFT;
+        sum = u.a[0];
+        sum = (sum << 7) - sum + u.a[1];
+#ifdef __LP64__
+        sum = (sum << 7) - sum + u.a[2];
+        sum = (sum << 7) - sum + u.a[3];
 #endif
+        return sum;
+}
 
-#if defined(DEBUG) || defined(RCHECK)
-#define ASSERT(p)   if (!(p)) botch("p")
-#include <stdio.h>
-static
-botch(s)
-        char *s;
+static void
+wrterror(char *msg, void *p)
 {
-        fprintf(stderr, "\r\nassertion botched: %s\r\n", s);
-        (void) fflush(stderr);          /* just in case user buffered it */
-        abort();
+        char            *q = " error: ";
+        struct iovec    iov[6];
+        char            buf[20];
+        int             saved_errno = errno;
+
+        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 = msg;
+        iov[3].iov_len = strlen(msg);
+        iov[4].iov_base = buf;
+        if (p == NULL)
+                iov[4].iov_len = 0;
+        else {
+                snprintf(buf, sizeof(buf), " %p", p);
+                iov[4].iov_len = strlen(buf);
+        }
+        iov[5].iov_base = "\n";
+        iov[5].iov_len = 1;
+        writev(STDERR_FILENO, iov, 6);
+
+#ifdef MALLOC_STATS
+        if (mopts.malloc_stats)
+                malloc_dump(STDERR_FILENO);
+#endif /* MALLOC_STATS */
+
+        errno = saved_errno;
+        if (mopts.malloc_abort)
+                abort();
 }
-#else
-#define ASSERT(p)
-#endif
 
-void *
-malloc(nbytes)
-        size_t nbytes;
+static void
+rbytes_init(void)
+{
+        arc4random_buf(rbytes, sizeof(rbytes));
+        rnibblesused = 0;
+}
+
+static inline u_char
+getrnibble(void)
+{
+        u_char x;
+
+        if (rnibblesused >= 2 * sizeof(rbytes))
+                rbytes_init();
+        x = rbytes[rnibblesused++ / 2];
+        return (rnibblesused & 1 ? x & 0xf : x >> 4);
+}
+
+/*
+ * Cache maintenance. We keep at most malloc_cache pages cached.
+ * If the cache is becoming full, unmap pages in the cache for real,
+ * and then add the region to the cache
+ * Opposed to the regular region data structure, the sizes in the
+ * cache are in MALLOC_PAGESIZE units.
+ */
+static void
+unmap(struct dir_info *d, void *p, size_t sz)
 {
-        register union overhead *op;
-        register long bucket, n;
-        register unsigned amt;
+        size_t psz = sz >> MALLOC_PAGESHIFT;
+        size_t rsz, tounmap;
+        struct region_info *r;
+        u_int i, offset;
+
+        if (sz != PAGEROUND(sz)) {
+                wrterror("munmap round", NULL);
+                return;
+        }
+
+        if (psz > mopts.malloc_cache) {
+                if (munmap(p, sz))
+                        wrterror("munmap", p);
+                malloc_used -= sz;
+                return;
+        }
+        tounmap = 0;
+        rsz = mopts.malloc_cache - d->free_regions_size;
+        if (psz > rsz)
+                tounmap = psz - rsz;
+        offset = getrnibble();
+        for (i = 0; tounmap > 0 && i < mopts.malloc_cache; i++) {
+                r = &d->free_regions[(i + offset) & (mopts.malloc_cache - 1)];
+                if (r->p != NULL) {
+                        rsz = r->size << MALLOC_PAGESHIFT;
+                        if (munmap(r->p, rsz))
+                                wrterror("munmap", r->p);
+                        r->p = NULL;
+                        if (tounmap > r->size)
+                                tounmap -= r->size;
+                        else
+                                tounmap = 0;
+                        d->free_regions_size -= r->size;
+                        r->size = 0;
+                        malloc_used -= rsz;
+                }
+        }
+        if (tounmap > 0)
+                wrterror("malloc cache underflow", NULL);
+        for (i = 0; i < mopts.malloc_cache; i++) {
+                r = &d->free_regions[i];
+                if (r->p == NULL) {
+                        if (mopts.malloc_hint)
+                                madvise(p, sz, MADV_FREE);
+                        if (mopts.malloc_freeprot)
+                                mprotect(p, sz, PROT_NONE);
+                        r->p = p;
+                        r->size = psz;
+                        d->free_regions_size += psz;
+                        break;
+                }
+        }
+        if (i == mopts.malloc_cache)
+                wrterror("malloc free slot lost", NULL);
+        if (d->free_regions_size > mopts.malloc_cache)
+                wrterror("malloc cache overflow", NULL);
+}
+
+static void
+zapcacheregion(struct dir_info *d, void *p)
+{
+        u_int i;
+        struct region_info *r;
+        size_t rsz;
+
+        for (i = 0; i < mopts.malloc_cache; i++) {
+                r = &d->free_regions[i];
+                if (r->p == p) {
+                        rsz = r->size << MALLOC_PAGESHIFT;
+                        if (munmap(r->p, rsz))
+                                wrterror("munmap", r->p);
+                        r->p = NULL;
+                        d->free_regions_size -= r->size;
+                        r->size = 0;
+                        malloc_used -= rsz;
+                }
+        }
+}
+
+static void *
+map(struct dir_info *d, size_t sz, int zero_fill)
+{
+        size_t psz = sz >> MALLOC_PAGESHIFT;
+        struct region_info *r, *big = NULL;
+        u_int i, offset;
+        void *p;
+
+        if (mopts.malloc_canary != (d->canary1 ^ (u_int32_t)(uintptr_t)d) ||
+            d->canary1 != ~d->canary2)
+                wrterror("internal struct corrupt", NULL);
+        if (sz != PAGEROUND(sz)) {
+                wrterror("map round", NULL);
+                return NULL;
+        }
+        if (psz > d->free_regions_size) {
+                p = MMAP(sz);
+                if (p != MAP_FAILED)
+                        malloc_used += sz;
+                /* zero fill not needed */
+                return p;
+        }
+        offset = getrnibble();
+        for (i = 0; i < mopts.malloc_cache; i++) {
+                r = &d->free_regions[(i + offset) & (mopts.malloc_cache - 1)];
+                if (r->p != NULL) {
+                        if (r->size == psz) {
+                                p = r->p;
+                                if (mopts.malloc_freeprot)
+                                        mprotect(p, sz, PROT_READ | PROT_WRITE);
+                                if (mopts.malloc_hint)
+                                        madvise(p, sz, MADV_NORMAL);
+                                r->p = NULL;
+                                r->size = 0;
+                                d->free_regions_size -= psz;
+                                if (zero_fill)
+                                        memset(p, 0, sz);
+                                else if (mopts.malloc_junk &&
+                                    mopts.malloc_freeprot)
+                                        memset(p, SOME_FREEJUNK, sz);
+                                return p;
+                        } else if (r->size > psz)
+                                big = r;
+                }
+        }
+        if (big != NULL) {
+                r = big;
+                p = (char *)r->p + ((r->size - psz) << MALLOC_PAGESHIFT);
+                if (mopts.malloc_freeprot)
+                        mprotect(p, sz, PROT_READ | PROT_WRITE);
+                if (mopts.malloc_hint)
+                        madvise(p, sz, MADV_NORMAL);
+                r->size -= psz;
+                d->free_regions_size -= psz;
+                if (zero_fill)
+                        memset(p, 0, sz);
+                else if (mopts.malloc_junk && mopts.malloc_freeprot)
+                        memset(p, SOME_FREEJUNK, sz);
+                return p;
+        }
+        p = MMAP(sz);
+        if (p != MAP_FAILED)
+                malloc_used += sz;
+        if (d->free_regions_size > mopts.malloc_cache)
+                wrterror("malloc cache", NULL);
+        /* zero fill not needed */
+        return p;
+}
+
+/*
+ * Initialize a dir_info, which should have been cleared by caller
+ */
+static int
+omalloc_init(struct dir_info **dp)
+{
+        char *p, b[64];
+        int i, j;
+        size_t d_avail, regioninfo_size;
+        struct dir_info *d;
+
+        rbytes_init();
 
         /*
-         * First time malloc is called, setup page size and
-         * align break pointer so all data will be page aligned.
+         * Default options
          */
-        if (pagesz == 0) {
-                pagesz = n = getpagesize();
-                op = (union overhead *)sbrk(0);
-                n = n - sizeof (*op) - ((long)op & (n - 1));
-                if (n < 0)
-                        n += pagesz;
-                if (n) {
-                        if (sbrk(n) == (char *)-1)
-                                return (NULL);
+        mopts.malloc_abort = 1;
+        mopts.malloc_move = 1;
+        mopts.malloc_cache = MALLOC_DEFAULT_CACHE;
+
+        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;
                 }
-                bucket = 0;
-                amt = 8;
-                while (pagesz > amt) {
-                        amt <<= 1;
-                        bucket++;
+
+                for (; p != NULL && *p != '\0'; p++) {
+                        switch (*p) {
+                        case '>':
+                                mopts.malloc_cache <<= 1;
+                                if (mopts.malloc_cache > MALLOC_MAXCACHE)
+                                        mopts.malloc_cache = MALLOC_MAXCACHE;
+                                break;
+                        case '<':
+                                mopts.malloc_cache >>= 1;
+                                break;
+                        case 'a':
+                                mopts.malloc_abort = 0;
+                                break;
+                        case 'A':
+                                mopts.malloc_abort = 1;
+                                break;
+#ifdef MALLOC_STATS
+                        case 'd':
+                                mopts.malloc_stats = 0;
+                                break;
+                        case 'D':
+                                mopts.malloc_stats = 1;
+                                break;
+#endif /* MALLOC_STATS */
+                        case 'f':
+                                mopts.malloc_freeprot = 0;
+                                break;
+                        case 'F':
+                                mopts.malloc_freeprot = 1;
+                                break;
+                        case 'g':
+                                mopts.malloc_guard = 0;
+                                break;
+                        case 'G':
+                                mopts.malloc_guard = MALLOC_PAGESIZE;
+                                break;
+                        case 'h':
+                                mopts.malloc_hint = 0;
+                                break;
+                        case 'H':
+                                mopts.malloc_hint = 1;
+                                break;
+                        case 'j':
+                                mopts.malloc_junk = 0;
+                                break;
+                        case 'J':
+                                mopts.malloc_junk = 1;
+                                break;
+                        case 'n':
+                        case 'N':
+                                break;
+                        case 'p':
+                                mopts.malloc_move = 0;
+                                break;
+                        case 'P':
+                                mopts.malloc_move = 1;
+                                break;
+                        case 'r':
+                                mopts.malloc_realloc = 0;
+                                break;
+                        case 'R':
+                                mopts.malloc_realloc = 1;
+                                break;
+                        case 's':
+                                mopts.malloc_freeprot = mopts.malloc_junk = 0;
+                                mopts.malloc_guard = 0;
+                                mopts.malloc_cache = MALLOC_DEFAULT_CACHE;
+                                break;
+                        case 'S':
+                                mopts.malloc_freeprot = mopts.malloc_junk = 1;
+                                mopts.malloc_guard = MALLOC_PAGESIZE;
+                                mopts.malloc_cache = 0;
+                                break;
+                        case 'x':
+                                mopts.malloc_xmalloc = 0;
+                                break;
+                        case 'X':
+                                mopts.malloc_xmalloc = 1;
+                                break;
+                        case 'z':
+                                mopts.malloc_zero = 0;
+                                break;
+                        case 'Z':
+                                mopts.malloc_zero = 1;
+                                break;
+                        default: {
+                                static const char q[] = "malloc() warning: "
+                                    "unknown char in MALLOC_OPTIONS\n";
+                                write(STDERR_FILENO, q, sizeof(q) - 1);
+                                break;
+                        }
+                        }
                 }
-                pagebucket = bucket;
         }
+
         /*
-         * Convert amount of memory requested into closest block size
-         * stored in hash buckets which satisfies request.
-         * Account for space used per block for accounting.
+         * We want junk in the entire allocation, and zero only in the part
+         * the user asked for.
          */
-        if (nbytes <= (n = pagesz - sizeof (*op) - RSLOP)) {
-#ifndef RCHECK
-                amt = 8;        /* size of first bucket */
-                bucket = 0;
-#else
-                amt = 16;       /* size of first bucket */
-                bucket = 1;
-#endif
-                n = -((long)sizeof (*op) + RSLOP);
-        } else {
-                amt = pagesz;
-                bucket = pagebucket;
-        }
-        while (nbytes > amt + n) {
-                amt <<= 1;
-                if (amt == 0)
-                        return (NULL);
-                bucket++;
+        if (mopts.malloc_zero)
+                mopts.malloc_junk = 1;
+
+#ifdef MALLOC_STATS
+        if (mopts.malloc_stats && (atexit(malloc_exit) == -1)) {
+                static const char q[] = "malloc() warning: atexit(2) failed."
+                    " Will not be able to dump stats on exit\n";
+                write(STDERR_FILENO, q, sizeof(q) - 1);
         }
+#endif /* MALLOC_STATS */
+
+        while ((mopts.malloc_canary = arc4random()) == 0)
+                ;
+
         /*
-         * If nothing in hash bucket right now,
-         * request more memory from the system.
+         * Allocate dir_info with a guard page on either side. Also
+         * randomise offset inside the page at which the dir_info
+         * lies (subject to alignment by 1 << MALLOC_MINSHIFT)
          */
-        if ((op = nextf[bucket]) == NULL) {
-                morecore(bucket);
-                if ((op = nextf[bucket]) == NULL)
-                        return (NULL);
-        }
-        /* remove from linked list */
-        nextf[bucket] = op->ov_next;
-        op->ov_magic = MAGIC;
-        op->ov_index = bucket;
-#ifdef MSTATS
-        nmalloc[bucket]++;
-#endif
-#ifdef RCHECK
+        if ((p = MMAP(DIR_INFO_RSZ + (MALLOC_PAGESIZE * 2))) == MAP_FAILED)
+                return -1;
+        mprotect(p, MALLOC_PAGESIZE, PROT_NONE);
+        mprotect(p + MALLOC_PAGESIZE + DIR_INFO_RSZ,
+            MALLOC_PAGESIZE, PROT_NONE);
+        d_avail = (DIR_INFO_RSZ - sizeof(*d)) >> MALLOC_MINSHIFT;
+        d = (struct dir_info *)(p + MALLOC_PAGESIZE +
+            (arc4random_uniform(d_avail) << MALLOC_MINSHIFT));
+
+        d->regions_free = d->regions_total = MALLOC_INITIAL_REGIONS;
+        regioninfo_size = d->regions_total * sizeof(struct region_info);
+        d->r = MMAP(regioninfo_size);
+        if (d->r == MAP_FAILED) {
+                wrterror("malloc init mmap failed", NULL);
+                d->regions_total = 0;
+                return 1;
+        }
+        for (i = 0; i <= MALLOC_MAXSHIFT; i++) {
+                LIST_INIT(&d->chunk_info_list[i]);
+                LIST_INIT(&d->chunk_dir[i]);
+        }
+        malloc_used += regioninfo_size;
+        d->canary1 = mopts.malloc_canary ^ (u_int32_t)(uintptr_t)d;
+        d->canary2 = ~d->canary1;
+
+        *dp = d;
+
         /*
-         * Record allocated size of block and
-         * bound space with magic numbers.
+         * Options have been set and will never be reset.
+         * Prevent further tampering with them.
          */
-        op->ov_size = (nbytes + RSLOP - 1) & ~(RSLOP - 1);
-        op->ov_rmagic = RMAGIC;
-        *(u_short *)((caddr_t)(op + 1) + op->ov_size) = RMAGIC;
-#endif
-        return ((char *)(op + 1));
+        if (((uintptr_t)&malloc_readonly & MALLOC_PAGEMASK) == 0)
+                mprotect(&malloc_readonly, sizeof(malloc_readonly), PROT_READ);
+
+        return 0;
 }
 
-/*
- * Allocate more memory to the indicated bucket.
- */
-static void
-morecore(bucket)
-        int bucket;
+static int
+omalloc_grow(struct dir_info *d)
 {
-        register union overhead *op;
-        register long sz;               /* size of desired block */
-        long amt;                       /* amount to allocate */
-        int nblks;                      /* how many blocks we get */
+        size_t newtotal;
+        size_t newsize;
+        size_t mask;
+        size_t i;
+        struct region_info *p;
 
-        /*
-         * sbrk_size <= 0 only for big, FLUFFY, requests (about
-         * 2^30 bytes on a VAX, I think) or for a negative arg.
-         */
-        sz = 1 << (bucket + 3);
-#ifdef DEBUG
-        ASSERT(sz > 0);
-#else
-        if (sz <= 0)
-                return;
-#endif
-        if (sz < pagesz) {
-                amt = pagesz;
-                nblks = amt / sz;
-        } else {
-                amt = sz + pagesz;
-                nblks = 1;
+        if (d->regions_total > SIZE_MAX / sizeof(struct region_info) / 2 )
+                return 1;
+
+        newtotal = d->regions_total * 2;
+        newsize = newtotal * sizeof(struct region_info);
+        mask = newtotal - 1;
+
+        p = MMAP(newsize);
+        if (p == MAP_FAILED)
+                return 1;
+        
+        malloc_used += newsize;
+        memset(p, 0, newsize);
+        STATS_ZERO(d->inserts);
+        STATS_ZERO(d->insert_collisions);
+        for (i = 0; i < d->regions_total; i++) { 
+                void *q = d->r[i].p;
+                if (q != NULL) {
+                        size_t index = hash(q) & mask;
+                        STATS_INC(d->inserts);
+                        while (p[index].p != NULL) {
+                                index = (index - 1) & mask;
+                                STATS_INC(d->insert_collisions);
+                        }
+                        p[index] = d->r[i];
+                }
         }
-        op = (union overhead *)sbrk(amt);
-        /* no more room! */
-        if ((long)op == -1)
-                return;
-        /*
-         * Add new memory allocated to that on
-         * free list for this hash bucket.
-         */
-        nextf[bucket] = op;
-        while (--nblks > 0) {
-                op->ov_next = (union overhead *)((caddr_t)op + sz);
-                op = (union overhead *)((caddr_t)op + sz);
-        }
+        /* avoid pages containing meta info to end up in cache */
+        if (munmap(d->r, d->regions_total * sizeof(struct region_info))) 
+                wrterror("munmap", d->r);
+        else
+                malloc_used -= d->regions_total * sizeof(struct region_info);
+        d->regions_free = d->regions_free + d->regions_total;
+        d->regions_total = newtotal;
+        d->r = p;
+        return 0;
 }
 
-void
-free(cp)
-        void *cp;
-{   
-        register long size;
-        register union overhead *op;
-
-        if (cp == NULL)
-                return;
-        op = (union overhead *)((caddr_t)cp - sizeof (union overhead));
-#ifdef DEBUG
-        ASSERT(op->ov_magic == MAGIC);          /* make sure it was in use */
-#else
-        if (op->ov_magic != MAGIC)
-                return;                         /* sanity */
-#endif
-#ifdef RCHECK
-        ASSERT(op->ov_rmagic == RMAGIC);
-        ASSERT(*(u_short *)((caddr_t)(op + 1) + op->ov_size) == RMAGIC);
-#endif
-        size = op->ov_index;
-        ASSERT(size < NBUCKETS);
-        op->ov_next = nextf[size];      /* also clobbers ov_magic */
-        nextf[size] = op;
-#ifdef MSTATS
-        nmalloc[size]--;
+static struct chunk_info *
+alloc_chunk_info(struct dir_info *d, int bits)
+{
+        struct chunk_info *p;
+        size_t size, count;
+
+        if (bits == 0)
+                count = MALLOC_PAGESIZE / MALLOC_MINSIZE;
+        else
+                count = MALLOC_PAGESIZE >> bits;
+
+        size = howmany(count, MALLOC_BITS);
+        size = sizeof(struct chunk_info) + (size - 1) * sizeof(u_short);
+        size = ALIGN(size);
+
+        if (LIST_EMPTY(&d->chunk_info_list[bits])) {
+                void *q;
+                int i;
+
+                q = MMAP(MALLOC_PAGESIZE);
+                if (q == MAP_FAILED)
+                        return NULL;
+                malloc_used += MALLOC_PAGESIZE;
+                count = MALLOC_PAGESIZE / size;
+                for (i = 0; i < count; i++, q += size)
+                        LIST_INSERT_HEAD(&d->chunk_info_list[bits],
+                            (struct chunk_info *)q, entries);
+        }
+        p = LIST_FIRST(&d->chunk_info_list[bits]);
+        LIST_REMOVE(p, entries);
+        memset(p, 0, size);
+        p->canary = d->canary1;
+        return p;
+}
+
+static int
+insert(struct dir_info *d, void *p, size_t sz, void *f)
+{
+        size_t index;
+        size_t mask;
+        void *q;
+
+        if (d->regions_free * 4 < d->regions_total) {
+                if (omalloc_grow(d))
+                        return 1;
+        }
+        mask = d->regions_total - 1;
+        index = hash(p) & mask;
+        q = d->r[index].p;
+        STATS_INC(d->inserts);
+        while (q != NULL) {
+                index = (index - 1) & mask;
+                q = d->r[index].p;
+                STATS_INC(d->insert_collisions);
+        }
+        d->r[index].p = p;
+        d->r[index].size = sz;
+#ifdef MALLOC_STATS
+        d->r[index].f = f;
 #endif
+        d->regions_free--;
+        return 0;
 }
 
+static struct region_info *
+find(struct dir_info *d, void *p)
+{
+        size_t index;
+        size_t mask = d->regions_total - 1;
+        void *q, *r;
+
+        if (mopts.malloc_canary != (d->canary1 ^ (u_int32_t)(uintptr_t)d) ||
+            d->canary1 != ~d->canary2)
+                wrterror("internal struct corrupt", NULL);
+        p = MASK_POINTER(p);
+        index = hash(p) & mask;
+        r = d->r[index].p;
+        q = MASK_POINTER(r);
+        STATS_INC(d->finds);
+        while (q != p && r != NULL) {
+                index = (index - 1) & mask;
+                r = d->r[index].p;
+                q = MASK_POINTER(r);
+                STATS_INC(d->find_collisions);
+        }
+        return q == p ? &d->r[index] : NULL;
+}
+
+static void
+delete(struct dir_info *d, struct region_info *ri)
+{
+        /* algorithm R, Knuth Vol III section 6.4 */
+        size_t mask = d->regions_total - 1;
+        size_t i, j, r;
+
+        if (d->regions_total & (d->regions_total - 1))
+                wrterror("regions_total not 2^x", NULL);
+        d->regions_free++;
+        STATS_INC(g_pool->deletes);
+
+        i = ri - d->r;
+        for (;;) {
+                d->r[i].p = NULL;
+                d->r[i].size = 0;
+                j = i;
+                for (;;) {
+                        i = (i - 1) & mask;
+                        if (d->r[i].p == NULL)
+                                return;
+                        r = hash(d->r[i].p) & mask;
+                        if ((i <= r && r < j) || (r < j && j < i) ||
+                            (j < i && i <= r))
+                                continue;
+                        d->r[j] = d->r[i];
+                        STATS_INC(g_pool->delete_moves);
+                        break;
+                }
+
+        }
+}
+ 
 /*
- * When a program attempts "storage compaction" as mentioned in the
- * old malloc man page, it realloc's an already freed block.  Usually
- * this is the last block it freed; occasionally it might be farther
- * back.  We have to search all the free lists for the block in order
- * to determine its bucket: 1st we make one pass thru the lists
- * checking only the first block in each; if that fails we search
- * ``realloc_srchlen'' blocks in each list for a match (the variable
- * is extern so the caller can modify it).  If that fails we just copy
- * however many bytes was given to realloc() and hope it's not huge.
+ * Allocate a page of chunks
  */
-int realloc_srchlen = 4;        /* 4 should be plenty, -1 =>'s whole list */
+static struct chunk_info *
+omalloc_make_chunks(struct dir_info *d, int bits)
+{
+        struct chunk_info *bp;
+        void            *pp;
+        int             i, k;
 
-void *
-realloc(cp, nbytes)
-        void *cp; 
-        size_t nbytes;
-{   
-        register u_long onb;
-        register long i;
-        union overhead *op;
-        char *res;
-        int was_alloced = 0;
-
-        if (cp == NULL)
-                return (malloc(nbytes));
-        op = (union overhead *)((caddr_t)cp - sizeof (union overhead));
-        if (op->ov_magic == MAGIC) {
-                was_alloced++;
-                i = op->ov_index;
-        } else {
-                /*
-                 * Already free, doing "compaction".
-                 *
-                 * Search for the old block of memory on the
-                 * free list.  First, check the most common
-                 * case (last element free'd), then (this failing)
-                 * the last ``realloc_srchlen'' items free'd.
-                 * If all lookups fail, then assume the size of
-                 * the memory block being realloc'd is the
-                 * largest possible (so that all "nbytes" of new
-                 * memory are copied into).  Note that this could cause
-                 * a memory fault if the old area was tiny, and the moon
-                 * is gibbous.  However, that is very unlikely.
-                 */
-                if ((i = findbucket(op, 1)) < 0 &&
-                    (i = findbucket(op, realloc_srchlen)) < 0)
-                        i = NBUCKETS;
-        }
-        onb = 1 << (i + 3);
-        if (onb < pagesz)
-                onb -= sizeof (*op) + RSLOP;
-        else
-                onb += pagesz - sizeof (*op) - RSLOP;
-        /* avoid the copy if same size block */
-        if (was_alloced) {
-                if (i) {
-                        i = 1 << (i + 2);
-                        if (i < pagesz)
-                                i -= sizeof (*op) + RSLOP;
-                        else
-                                i += pagesz - sizeof (*op) - RSLOP;
+        /* Allocate a new bucket */
+        pp = map(d, MALLOC_PAGESIZE, 0);
+        if (pp == MAP_FAILED)
+                return NULL;
+
+        bp = alloc_chunk_info(d, bits);
+        if (bp == NULL) {
+                unmap(d, pp, MALLOC_PAGESIZE);
+                return NULL;
+        }
+
+        /* 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) {
+                        unmap(d, pp, MALLOC_PAGESIZE);
+                        LIST_INSERT_HEAD(&d->chunk_info_list[0], bp, entries);
+                        return NULL;
                 }
-                if (nbytes <= onb && nbytes > i) {
-#ifdef RCHECK
-                        op->ov_size = (nbytes + RSLOP - 1) & ~(RSLOP - 1);
-                        *(u_short *)((caddr_t)(op + 1) + op->ov_size) = RMAGIC;
-#endif
-                        return(cp);
-                } else
-                        free(cp);
+        } else {
+                bp->size = 1U << bits;
+                bp->shift = bits;
+                bp->total = bp->free = MALLOC_PAGESIZE >> bits;
+                bp->page = pp;
         }
-        if ((res = malloc(nbytes)) == NULL)
-                return (NULL);
-        if (cp != res)          /* common optimization if "compacting" */
-                bcopy(cp, res, (nbytes < onb) ? nbytes : onb);
-        return (res);
+
+        /* 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] = (u_short)~0U;
+
+        for (; i < k; i++)
+                bp->bits[i / MALLOC_BITS] |= (u_short)1U << (i % MALLOC_BITS);
+
+        LIST_INSERT_HEAD(&d->chunk_dir[bits], bp, entries);
+
+        bits++;
+        if ((uintptr_t)pp & bits)
+                wrterror("pp & bits", pp);
+
+        insert(d, (void *)((uintptr_t)pp | bits), (uintptr_t)bp, NULL);
+        return bp;
 }
 
+
 /*
- * Search ``srchlen'' elements of each free list for a block whose
- * header starts at ``freep''.  If srchlen is -1 search the whole list.
- * Return bucket number, or -1 if not found.
+ * Allocate a chunk
  */
-static
-findbucket(freep, srchlen)
-        union overhead *freep;
-        int srchlen;
+static void *
+malloc_bytes(struct dir_info *d, size_t size, void *f)
 {
-        register union overhead *p;
-        register int i, j;
+        int             i, j;
+        size_t          k;
+        u_short         u, *lp;
+        struct chunk_info *bp;
+
+        if (mopts.malloc_canary != (d->canary1 ^ (u_int32_t)(uintptr_t)d) ||
+            d->canary1 != ~d->canary2)
+                wrterror("internal struct corrupt", NULL);
+        /* Don't bother with anything less than this */
+        /* unless we have a malloc(0) requests */
+        if (size != 0 && size < MALLOC_MINSIZE)
+                size = MALLOC_MINSIZE;
 
-        for (i = 0; i < NBUCKETS; i++) {
+        /* Find the right bucket */
+        if (size == 0)
                 j = 0;
-                for (p = nextf[i]; p && j != srchlen; p = p->ov_next) {
-                        if (p == freep)
-                                return (i);
+        else {
+                j = MALLOC_MINSHIFT;
+                i = (size - 1) >> (MALLOC_MINSHIFT - 1);
+                while (i >>= 1)
                         j++;
+        }
+
+        /* If it's empty, make a page more of that size chunks */
+        if (LIST_EMPTY(&d->chunk_dir[j])) {
+                bp = omalloc_make_chunks(d, j);
+                if (bp == NULL)
+                        return NULL;
+        } else
+                bp = LIST_FIRST(&d->chunk_dir[j]);
+
+        if (bp->canary != d->canary1)
+                wrterror("chunk info corrupted", NULL);
+
+        i = d->chunk_start;
+        if (bp->free > 1)
+                i += getrnibble();
+        if (i >= bp->total)
+                i &= bp->total - 1;
+        for (;;) {
+                for (;;) {
+                        lp = &bp->bits[i / MALLOC_BITS];
+                        if (!*lp) {
+                                i += MALLOC_BITS;
+                                i &= ~(MALLOC_BITS - 1); 
+                                if (i >= bp->total)
+                                        i = 0;
+                        } else
+                                break;
+                }
+                k = i % MALLOC_BITS;
+                u = 1 << k;
+                if (*lp & u)
+                        break;
+                if (++i >= bp->total)
+                        i = 0;
+        }
+        d->chunk_start += i + 1;
+#ifdef MALLOC_STATS
+        if (i == 0) {
+                struct region_info *r = find(d, bp->page);
+                r->f = f;
+        }
+#endif
+
+        *lp ^= u;
+
+        /* If there are no more free, remove from free-list */
+        if (!--bp->free)
+                LIST_REMOVE(bp, entries);
+
+        /* Adjust to the real offset of that chunk */
+        k += (lp - bp->bits) * MALLOC_BITS;
+        k <<= bp->shift;
+
+        if (mopts.malloc_junk && bp->size > 0)
+                memset((char *)bp->page + k, SOME_JUNK, bp->size);
+        return ((char *)bp->page + k);
+}
+
+
+/*
+ * Free a chunk, and possibly the page it's on, if the page becomes empty.
+ */
+static void
+free_bytes(struct dir_info *d, struct region_info *r, void *ptr)
+{
+        struct chunk_head *mp;
+        struct chunk_info *info;
+        int i;
+
+        info = (struct chunk_info *)r->size;
+        if (info->canary != d->canary1)
+                wrterror("chunk info corrupted", NULL);
+
+        /* Find the chunk number on the page */
+        i = ((uintptr_t)ptr & MALLOC_PAGEMASK) >> info->shift;
+
+        if ((uintptr_t)ptr & ((1U << (info->shift)) - 1)) {
+                wrterror("modified chunk-pointer", ptr);
+                return;
+        }
+        if (info->bits[i / MALLOC_BITS] & (1U << (i % MALLOC_BITS))) {
+                wrterror("chunk is already free", ptr);
+                return;
+        }
+
+        info->bits[i / MALLOC_BITS] |= 1U << (i % MALLOC_BITS);
+        info->free++;
+
+        if (info->size != 0)
+                mp = d->chunk_dir + info->shift;
+        else
+                mp = d->chunk_dir;
+
+        if (info->free == 1) {
+                /* Page became non-full */
+                LIST_INSERT_HEAD(mp, info, entries);
+                return;
+        }
+        if (info->free != info->total)
+                return;
+
+        LIST_REMOVE(info, entries);
+
+        if (info->size == 0 && !mopts.malloc_freeprot)
+                mprotect(info->page, MALLOC_PAGESIZE, PROT_READ | PROT_WRITE);
+        unmap(d, info->page, MALLOC_PAGESIZE);
+
+        delete(d, r);
+        if (info->size != 0)
+                mp = &d->chunk_info_list[info->shift];
+        else
+                mp = &d->chunk_info_list[0];
+        LIST_INSERT_HEAD(mp, info, entries);
+}
+
+
+
+static void *
+omalloc(size_t sz, int zero_fill, void *f)
+{
+        void *p;
+        size_t psz;
+
+        if (sz > MALLOC_MAXCHUNK) {
+                if (sz >= SIZE_MAX - mopts.malloc_guard - MALLOC_PAGESIZE) {
+                        errno = ENOMEM;
+                        return NULL;
+                }
+                sz += mopts.malloc_guard;
+                psz = PAGEROUND(sz);
+                p = map(g_pool, psz, zero_fill);
+                if (p == MAP_FAILED) {
+                        errno = ENOMEM;
+                        return NULL;
+                }
+                if (insert(g_pool, p, sz, f)) {
+                        unmap(g_pool, p, psz);
+                        errno = ENOMEM;
+                        return NULL;
                 }
+                if (mopts.malloc_guard) {
+                        if (mprotect((char *)p + psz - mopts.malloc_guard,
+                            mopts.malloc_guard, PROT_NONE))
+                                wrterror("mprotect", NULL);
+                        malloc_guarded += mopts.malloc_guard;
+                }
+
+                if (mopts.malloc_move &&
+                    sz - mopts.malloc_guard < MALLOC_PAGESIZE -
+                    MALLOC_LEEWAY) {
+                        /* fill whole allocation */
+                        if (mopts.malloc_junk)
+                                memset(p, SOME_JUNK, psz - mopts.malloc_guard);
+                        /* shift towards the end */
+                        p = ((char *)p) + ((MALLOC_PAGESIZE - MALLOC_LEEWAY -
+                            (sz - mopts.malloc_guard)) & ~(MALLOC_MINSIZE-1));
+                        /* fill zeros if needed and overwritten above */
+                        if (zero_fill && mopts.malloc_junk)
+                                memset(p, 0, sz - mopts.malloc_guard);
+                } else {
+                        if (mopts.malloc_junk) {
+                                if (zero_fill)
+                                        memset((char *)p + sz - mopts.malloc_guard,
+                                            SOME_JUNK, psz - sz);
+                                else
+                                        memset(p, SOME_JUNK,
+                                            psz - mopts.malloc_guard);
+                        }
+                }
+
+        } else {
+                /* takes care of SOME_JUNK */
+                p = malloc_bytes(g_pool, sz, f);
+                if (zero_fill && p != NULL && sz > 0)
+                        memset(p, 0, sz);
         }
-        return (-1);
+
+        return p;
 }
 
-#ifdef MSTATS
 /*
- * mstats - print out statistics about malloc
- * 
- * Prints two lines of numbers, one showing the length of the free list
- * for each size category, the second showing the number of mallocs -
- * frees for each size category.
+ * Common function for handling recursion.  Only
+ * print the error message once, to avoid making the problem
+ * potentially worse.
  */
-mstats(s)
-        char *s;
-{
-        register int i, j;
-        register union overhead *p;
-        int totfree = 0,
-        totused = 0;
-
-        fprintf(stderr, "Memory allocation statistics %s\nfree:\t", s);
-        for (i = 0; i < NBUCKETS; i++) {
-                for (j = 0, p = nextf[i]; p; p = p->ov_next, j++)
-                        ;
-                fprintf(stderr, " %d", j);
-                totfree += j * (1 << (i + 3));
-        }
-        fprintf(stderr, "\nused:\t");
-        for (i = 0; i < NBUCKETS; i++) {
-                fprintf(stderr, " %d", nmalloc[i]);
-                totused += nmalloc[i] * (1 << (i + 3));
-        }
-        fprintf(stderr, "\n\tTotal in use: %d, total free: %d\n",
-            totused, totfree);
+static void  
+malloc_recurse(void)
+{
+        static int noprint;
+
+        if (noprint == 0) {
+                noprint = 1;
+                wrterror("recursive call", NULL);
+        }
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        errno = EDEADLK;
+}
+
+static int
+malloc_init(void)
+{
+        if (omalloc_init(&g_pool)) {
+                _MALLOC_UNLOCK();
+                if (mopts.malloc_xmalloc)
+                        wrterror("out of memory", NULL);
+                errno = ENOMEM;
+                return -1;
+        }
+        return 0;
 }
+
+void *
+malloc(size_t size)
+{
+        void *r;
+        int saved_errno = errno;
+
+        _MALLOC_LOCK();
+        malloc_func = " in malloc():";
+        if (g_pool == NULL) {
+                if (malloc_init() != 0)
+                        return NULL;
+        }
+        if (malloc_active++) {
+                malloc_recurse();
+                return NULL;
+        }
+        r = omalloc(size, mopts.malloc_zero, CALLER);
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        if (r == NULL && mopts.malloc_xmalloc) {
+                wrterror("out of memory", NULL);
+                errno = ENOMEM;
+        }
+        if (r != NULL)
+                errno = saved_errno;
+        return r;
+}
+
+static void
+ofree(void *p)
+{
+        struct region_info *r;
+        size_t sz;
+
+        r = find(g_pool, p);
+        if (r == NULL) {
+                wrterror("bogus pointer (double free?)", p);
+                return;
+        }
+        REALSIZE(sz, r);
+        if (sz > MALLOC_MAXCHUNK) {
+                if (sz - mopts.malloc_guard >= MALLOC_PAGESIZE -
+                    MALLOC_LEEWAY) {
+                        if (r->p != p) {
+                                wrterror("bogus pointer", p);
+                                return;
+                        }
+                } else {
+#if notyetbecause_of_realloc
+                        /* shifted towards the end */
+                        if (p != ((char *)r->p) + ((MALLOC_PAGESIZE -
+                            MALLOC_MINSIZE - sz - mopts.malloc_guard) &
+                            ~(MALLOC_MINSIZE-1))) {
+                        }
 #endif
+                        p = r->p;
+                }
+                if (mopts.malloc_guard) {
+                        if (sz < mopts.malloc_guard)
+                                wrterror("guard size", NULL);
+                        if (!mopts.malloc_freeprot) {
+                                if (mprotect((char *)p + PAGEROUND(sz) -
+                                    mopts.malloc_guard, mopts.malloc_guard,
+                                    PROT_READ | PROT_WRITE))
+                                        wrterror("mprotect", NULL);
+                        }
+                        malloc_guarded -= mopts.malloc_guard;
+                }
+                if (mopts.malloc_junk && !mopts.malloc_freeprot)
+                        memset(p, SOME_FREEJUNK,
+                            PAGEROUND(sz) - mopts.malloc_guard);
+                unmap(g_pool, p, PAGEROUND(sz));
+                delete(g_pool, r);
+        } else {
+                void *tmp;
+                int i;
+
+                if (mopts.malloc_junk && sz > 0)
+                        memset(p, SOME_FREEJUNK, sz);
+                if (!mopts.malloc_freeprot) {
+                        i = getrnibble();
+                        tmp = p;
+                        p = g_pool->delayed_chunks[i];
+                        g_pool->delayed_chunks[i] = tmp;
+                }
+                if (p != NULL) {
+                        r = find(g_pool, p);
+                        if (r == NULL) {
+                                wrterror("bogus pointer (double free?)", p);
+                                return;
+                        }
+                        free_bytes(g_pool, r, p);
+                }
+        }
+}
+
+void
+free(void *ptr)
+{
+        int saved_errno = errno;
+
+        /* This is legal. */
+        if (ptr == NULL)
+                return;
+
+        _MALLOC_LOCK();
+        malloc_func = " in free():";  
+        if (g_pool == NULL) {
+                _MALLOC_UNLOCK();
+                wrterror("free() called before allocation", NULL);
+                return;
+        }
+        if (malloc_active++) {
+                malloc_recurse();
+                return;
+        }
+        ofree(ptr);
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        errno = saved_errno;
+}
+
+
+static void *
+orealloc(void *p, size_t newsz, void *f)
+{
+        struct region_info *r;
+        size_t oldsz, goldsz, gnewsz;
+        void *q;
+
+        if (p == NULL)
+                return omalloc(newsz, 0, f);
+
+        r = find(g_pool, p);
+        if (r == NULL) {
+                wrterror("bogus pointer (double free?)", p);
+                return NULL;
+        }
+        if (newsz >= SIZE_MAX - mopts.malloc_guard - MALLOC_PAGESIZE) {
+                errno = ENOMEM;
+                return NULL;
+        }
+
+        REALSIZE(oldsz, r);
+        goldsz = oldsz;
+        if (oldsz > MALLOC_MAXCHUNK) {
+                if (oldsz < mopts.malloc_guard)
+                        wrterror("guard size", NULL);
+                oldsz -= mopts.malloc_guard;
+        }
+
+        gnewsz = newsz;
+        if (gnewsz > MALLOC_MAXCHUNK)
+                gnewsz += mopts.malloc_guard;
+
+        if (newsz > MALLOC_MAXCHUNK && oldsz > MALLOC_MAXCHUNK && p == r->p &&
+            !mopts.malloc_realloc) {
+                size_t roldsz = PAGEROUND(goldsz);
+                size_t rnewsz = PAGEROUND(gnewsz);
+
+                if (rnewsz > roldsz) {
+                        if (!mopts.malloc_guard) {
+                                STATS_INC(g_pool->cheap_realloc_tries);
+                                zapcacheregion(g_pool, (char *)p + roldsz);
+                                q = MMAPA((char *)p + roldsz, rnewsz - roldsz);
+                                if (q == (char *)p + roldsz) {
+                                        malloc_used += rnewsz - roldsz;
+                                        if (mopts.malloc_junk)
+                                                memset(q, SOME_JUNK,
+                                                    rnewsz - roldsz);
+                                        r->size = newsz;
+                                        STATS_SETF(r, f);
+                                        STATS_INC(g_pool->cheap_reallocs);
+                                        return p;
+                                } else if (q != MAP_FAILED)
+                                        munmap(q, rnewsz - roldsz);
+                        }
+                } else if (rnewsz < roldsz) {
+                        if (mopts.malloc_guard) {
+                                if (mprotect((char *)p + roldsz -
+                                    mopts.malloc_guard, mopts.malloc_guard,
+                                    PROT_READ | PROT_WRITE))
+                                        wrterror("mprotect", NULL);
+                                if (mprotect((char *)p + rnewsz -
+                                    mopts.malloc_guard, mopts.malloc_guard,
+                                    PROT_NONE))
+                                        wrterror("mprotect", NULL);
+                        }
+                        unmap(g_pool, (char *)p + rnewsz, roldsz - rnewsz);
+                        r->size = gnewsz;
+                        STATS_SETF(r, f);
+                        return p;
+                } else {
+                        if (newsz > oldsz && mopts.malloc_junk)
+                                memset((char *)p + newsz, SOME_JUNK,
+                                    rnewsz - mopts.malloc_guard - newsz);
+                        r->size = gnewsz;
+                        STATS_SETF(r, f);
+                        return p;
+                }
+        }
+        if (newsz <= oldsz && newsz > oldsz / 2 && !mopts.malloc_realloc) {
+                if (mopts.malloc_junk && newsz > 0)
+                        memset((char *)p + newsz, SOME_JUNK, oldsz - newsz);
+                STATS_SETF(r, f);
+                return p;
+        } else if (newsz != oldsz || mopts.malloc_realloc) {
+                q = omalloc(newsz, 0, f);
+                if (q == NULL)
+                        return NULL;
+                if (newsz != 0 && oldsz != 0)
+                        memcpy(q, p, oldsz < newsz ? oldsz : newsz);
+                ofree(p);
+                return q;
+        } else {
+                STATS_SETF(r, f);
+                return p;
+        }
+}
+
+void *
+realloc(void *ptr, size_t size)
+{
+        void *r;
+        int saved_errno = errno;
+  
+        _MALLOC_LOCK();
+        malloc_func = " in realloc():";  
+        if (g_pool == NULL) {
+                if (malloc_init() != 0)
+                        return NULL;
+        }
+        if (malloc_active++) {
+                malloc_recurse();
+                return NULL;
+        }
+        r = orealloc(ptr, size, CALLER);
+  
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        if (r == NULL && mopts.malloc_xmalloc) {
+                wrterror("out of memory", NULL);
+                errno = ENOMEM;
+        }
+        if (r != NULL)
+                errno = saved_errno;
+        return r;
+}
+
+
+#define MUL_NO_OVERFLOW (1UL << (sizeof(size_t) * 4))
+
+void *
+calloc(size_t nmemb, size_t size)
+{
+        void *r;
+        int saved_errno = errno;
+
+        _MALLOC_LOCK();
+        malloc_func = " in calloc():";  
+        if (g_pool == NULL) {
+                if (malloc_init() != 0)
+                        return NULL;
+        }
+        if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
+            nmemb > 0 && SIZE_MAX / nmemb < size) {
+                _MALLOC_UNLOCK();
+                if (mopts.malloc_xmalloc)
+                        wrterror("out of memory", NULL);
+                errno = ENOMEM;
+                return NULL;
+        }
+
+        if (malloc_active++) {
+                malloc_recurse();
+                return NULL;
+        }
+
+        size *= nmemb;
+        r = omalloc(size, 1, CALLER);
+  
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        if (r == NULL && mopts.malloc_xmalloc) {
+                wrterror("out of memory", NULL);
+                errno = ENOMEM;
+        }
+        if (r != NULL)
+                errno = saved_errno;
+        return r;
+}
+
+int
+posix_memalign(void **memptr, size_t alignment, size_t size)
+{
+        void *result;
+
+        /* Make sure that alignment is a large enough power of 2. */
+        if (((alignment - 1) & alignment) != 0 || alignment < sizeof(void *) ||
+            alignment > MALLOC_PAGESIZE)
+                return EINVAL;
+
+        /* 
+         * max(size, alignment) is enough to assure the requested alignment,
+         * since the allocator always allocates power-of-two blocks.
+         */
+        if (size < alignment)
+                size = alignment;
+        result = malloc(size);
+
+        if (result == NULL)
+                return ENOMEM;
+
+        *memptr = result;
+        return 0;
+}
+
+#ifdef MALLOC_STATS
+
+struct malloc_leak {
+        void (*f)();
+        size_t total_size;
+        int count;
+};
+
+struct leaknode {
+        RB_ENTRY(leaknode) entry;
+        struct malloc_leak d;
+};
+
+static int
+leakcmp(struct leaknode *e1, struct leaknode *e2)
+{
+        return e1->d.f < e2->d.f ? -1 : e1->d.f > e2->d.f;
+}
+
+static RB_HEAD(leaktree, leaknode) leakhead;
+RB_GENERATE_STATIC(leaktree, leaknode, entry, leakcmp)
+
+static void
+putleakinfo(void *f, size_t sz, int cnt)
+{
+        struct leaknode key, *p;
+        static struct leaknode *page;
+        static int used;
+
+        if (cnt == 0)
+                return;
+
+        key.d.f = f;
+        p = RB_FIND(leaktree, &leakhead, &key);
+        if (p == NULL) {
+                if (page == NULL ||
+                    used >= MALLOC_PAGESIZE / sizeof(struct leaknode)) {
+                        page = MMAP(MALLOC_PAGESIZE);
+                        if (page == MAP_FAILED)
+                                return;
+                        used = 0;
+                }
+                p = &page[used++];
+                p->d.f = f;
+                p->d.total_size = sz * cnt;
+                p->d.count = cnt;
+                RB_INSERT(leaktree, &leakhead, p);
+        } else {
+                p->d.total_size += sz * cnt;
+                p->d.count += cnt;
+        }
+}
+
+static struct malloc_leak *malloc_leaks;
+
+static void
+dump_leaks(int fd)
+{
+        struct leaknode *p;
+        char buf[64];
+        int i = 0;
+
+        snprintf(buf, sizeof(buf), "Leak report\n");
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "           f     sum      #    avg\n");
+        write(fd, buf, strlen(buf));
+        /* XXX only one page of summary */
+        if (malloc_leaks == NULL)
+                malloc_leaks = MMAP(MALLOC_PAGESIZE);
+        if (malloc_leaks != MAP_FAILED)
+                memset(malloc_leaks, 0, MALLOC_PAGESIZE);
+        RB_FOREACH(p, leaktree, &leakhead) {
+                snprintf(buf, sizeof(buf), "%12p %7zu %6u %6zu\n", p->d.f,
+                    p->d.total_size, p->d.count, p->d.total_size / p->d.count);
+                write(fd, buf, strlen(buf));
+                if (malloc_leaks == MAP_FAILED ||
+                    i >= MALLOC_PAGESIZE / sizeof(struct malloc_leak))
+                        continue;
+                malloc_leaks[i].f = p->d.f;
+                malloc_leaks[i].total_size = p->d.total_size;
+                malloc_leaks[i].count = p->d.count;
+                i++;
+        }
+}
+
+static void
+dump_chunk(int fd, struct chunk_info *p, void *f, int fromfreelist)
+{
+        char buf[64];
+
+        while (p != NULL) {
+                snprintf(buf, sizeof(buf), "chunk %12p %12p %4d %d/%d\n",
+                    p->page, ((p->bits[0] & 1) ? NULL : f),
+                    p->size, p->free, p->total);
+                write(fd, buf, strlen(buf));
+                if (!fromfreelist) {
+                        if (p->bits[0] & 1) 
+                                putleakinfo(NULL, p->size, p->total - p->free);
+                        else {
+                                putleakinfo(f, p->size, 1);
+                                putleakinfo(NULL, p->size,
+                                    p->total - p->free - 1);
+                        }
+                        break;
+                }
+                p = LIST_NEXT(p, entries);
+                if (p != NULL) {
+                        snprintf(buf, sizeof(buf), "        ");
+                        write(fd, buf, strlen(buf));
+                }
+        }
+}
+
+static void
+dump_free_chunk_info(int fd, struct dir_info *d)
+{
+        char buf[64];
+        int i, count;
+
+        snprintf(buf, sizeof(buf), "Free chunk structs:\n");
+        write(fd, buf, strlen(buf));
+        for (i = 0; i <= MALLOC_MAXSHIFT; i++) {
+                struct chunk_info *p;
+
+                count = 0;
+                LIST_FOREACH(p, &d->chunk_info_list[i], entries)
+                        count++;
+                p = LIST_FIRST(&d->chunk_dir[i]);
+                if (p == NULL && count == 0)
+                        continue;
+                snprintf(buf, sizeof(buf), "%2d) %3d ", i, count);
+                write(fd, buf, strlen(buf));
+                if (p != NULL)
+                        dump_chunk(fd, p, NULL, 1);
+                else
+                        write(fd, "\n", 1);
+        }
+
+}
+
+static void
+dump_free_page_info(int fd, struct dir_info *d)
+{
+        char buf[64];
+        int i;
+
+        snprintf(buf, sizeof(buf), "Free pages cached: %zu\n",
+            d->free_regions_size);
+        write(fd, buf, strlen(buf));
+        for (i = 0; i < mopts.malloc_cache; i++) {
+                if (d->free_regions[i].p != NULL) {
+                        snprintf(buf, sizeof(buf), "%2d) ", i);
+                        write(fd, buf, strlen(buf));
+                        snprintf(buf, sizeof(buf), "free at %p: %zu\n",
+                            d->free_regions[i].p, d->free_regions[i].size);
+                        write(fd, buf, strlen(buf));
+                }
+        }
+}
+
+static void
+malloc_dump1(int fd, struct dir_info *d)
+{
+        char buf[64];
+        size_t i, realsize;
+
+        snprintf(buf, sizeof(buf), "Malloc dir of %s at %p\n", __progname, d);
+        write(fd, buf, strlen(buf));
+        if (d == NULL)
+                return;
+        snprintf(buf, sizeof(buf), "Region slots free %zu/%zu\n",
+                d->regions_free, d->regions_total);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "Finds %zu/%zu\n", d->finds,
+            d->find_collisions);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "Inserts %zu/%zu\n", d->inserts,
+            d->insert_collisions);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "Deletes %zu/%zu\n", d->deletes,
+             d->delete_moves);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "Cheap reallocs %zu/%zu\n",
+            d->cheap_reallocs, d->cheap_realloc_tries);
+        write(fd, buf, strlen(buf));
+        dump_free_chunk_info(fd, d);
+        dump_free_page_info(fd, d);
+        snprintf(buf, sizeof(buf),
+            "slot)  hash d  type         page            f size [free/n]\n");
+        write(fd, buf, strlen(buf));
+        for (i = 0; i < d->regions_total; i++) {
+                if (d->r[i].p != NULL) {
+                        size_t h = hash(d->r[i].p) &
+                            (d->regions_total - 1);
+                        snprintf(buf, sizeof(buf), "%4zx) #%4zx %zd ",
+                            i, h, h - i);
+                        write(fd, buf, strlen(buf));
+                        REALSIZE(realsize, &d->r[i]);
+                        if (realsize > MALLOC_MAXCHUNK) {
+                                putleakinfo(d->r[i].f, realsize, 1);
+                                snprintf(buf, sizeof(buf),
+                                    "pages %12p %12p %zu\n", d->r[i].p, 
+                                    d->r[i].f, realsize);
+                                write(fd, buf, strlen(buf));
+                        } else
+                                dump_chunk(fd,
+                                    (struct chunk_info *)d->r[i].size, 
+                                    d->r[i].f, 0);
+                }
+        }
+        snprintf(buf, sizeof(buf), "In use %zu\n", malloc_used);
+        write(fd, buf, strlen(buf));
+        snprintf(buf, sizeof(buf), "Guarded %zu\n", malloc_guarded);
+        write(fd, buf, strlen(buf));
+        dump_leaks(fd);
+        write(fd, "\n", 1);
+}
+
+void
+malloc_dump(int fd)
+{
+        int i;
+        void *p;
+        struct region_info *r;
+        int saved_errno = errno;
+
+        for (i = 0; i <= MALLOC_DELAYED_CHUNKS; i++) {
+                p = g_pool->delayed_chunks[i];
+                if (p == NULL)
+                        continue;
+                r = find(g_pool, p);
+                if (r == NULL) 
+                        wrterror("bogus pointer in malloc_dump", p);
+                free_bytes(g_pool, r, p);
+                g_pool->delayed_chunks[i] = NULL;
+        }
+        /* XXX leak when run multiple times */
+        RB_INIT(&leakhead);
+        malloc_dump1(fd, g_pool);
+        errno = saved_errno;
+}
+
+static void
+malloc_exit(void)
+{
+        static const 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, sizeof(q) - 1);
+        errno = save_errno;
+}
+
+#endif /* MALLOC_STATS */
diff --git a/src/lib/libc/stdlib/merge.c b/src/lib/libc/stdlib/merge.c
index 381fdc0830..43ef8b08e2 100644
--- a/src/lib/libc/stdlib/merge.c
+++ b/src/lib/libc/stdlib/merge.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: merge.c,v 1.9 2011/03/06 00:55:38 deraadt Exp $ */
 /*-
  * Copyright (c) 1992, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char sccsid[] = "from: @(#)merge.c     8.2 (Berkeley) 2/14/94";*/
-static char *rcsid = "$Id: merge.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 /*
  * Hybrid exponential search/linear search merge sort with hybrid
  * natural/pairwise first pass.  Requires about .3% more comparisons
@@ -59,8 +51,8 @@ static char *rcsid = "$Id: merge.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
 #include <stdlib.h>
 #include <string.h>
 
-static void setup __P((u_char *, u_char *, size_t, size_t, int (*)()));
-static void insertionsort __P((u_char *, size_t, size_t, int (*)()));
+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 *)
@@ -96,15 +88,12 @@ static void insertionsort __P((u_char *, size_t, size_t, int (*)()));
  * Arguments are as for qsort.
  */
 int
-mergesort(base, nmemb, size, cmp)
-        void *base;
-        size_t nmemb;
-        register size_t size;
-        int (*cmp) __P((const void *, const void *));
+mergesort(void *base, size_t nmemb, size_t size,
+    int (*cmp)(const void *, const void *))
 {
-        register int i, sense;
+        int i, sense;
         int big, iflag;
-        register u_char *f1, *f2, *t, *b, *tp2, *q, *l1, *l2;
+        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. */
@@ -148,7 +137,7 @@ mergesort(base, nmemb, size, cmp)
                                 sense = 0;
                         }
                         if (!big) {     /* here i = 0 */
-LINEAR:                         while ((b += size) < t && cmp(q, b) >sense)
+                                while ((b += size) < t && cmp(q, b) >sense)
                                         if (++i == 6) {
                                                 big = 1;
                                                 goto EXPONENTIAL;
@@ -169,7 +158,7 @@ EXPONENTIAL:	    		for (i = size; ; i <<= 1)
                                                 goto FASTCASE;
                                         } else
                                                 b = p;
-SLOWCASE:                       while (t > b+size) {
+                                while (t > b+size) {
                                         i = (((t - b) / size) >> 1) * size;
                                         if ((*cmp)(q, p = b + i) <= sense)
                                                 t = p;
@@ -256,13 +245,11 @@ COPY:	    			b = t;
  * is defined.  Otherwise simple pairwise merging is used.)
  */
 void
-setup(list1, list2, n, size, cmp)
-        size_t n, size;
-        int (*cmp) __P((const void *, const void *));
-        u_char *list1, *list2;
+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;
+        int i, length, size2, sense;
+        u_char tmp, *f1, *f2, *s, *l2, *last, *p2;
 
         size2 = size*2;
         if (n <= 5) {
@@ -330,10 +317,8 @@ setup(list1, list2, n, size, cmp)
  * last 4 elements.
  */
 static void
-insertionsort(a, n, size, cmp)
-        u_char *a;
-        size_t n, size;
-        int (*cmp) __P((const void *, const 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;
diff --git a/src/lib/libc/stdlib/mrand48.c b/src/lib/libc/stdlib/mrand48.c
index 43356e66b3..977264aba5 100644
--- a/src/lib/libc/stdlib/mrand48.c
+++ b/src/lib/libc/stdlib/mrand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: mrand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/multibyte.c b/src/lib/libc/stdlib/multibyte.c
deleted file mode 100644
index fe1cd5781b..0000000000
--- a/src/lib/libc/stdlib/multibyte.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (c) 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)multibyte.c  5.1 (Berkeley) 2/18/91";*/
-static char *rcsid = "$Id: multibyte.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <stdlib.h>
-
-/*
- * Stub multibyte character functions.
- * This cheezy implementation is fixed to the native single-byte
- * character set.
- */
-
-int
-mblen(s, n)
-        const char *s;
-        size_t n;
-{
-        if (s == NULL || *s == '\0')
-                return 0;
-        if (n == 0)
-                return -1;
-        return 1;
-}
-
-/*ARGSUSED*/
-int
-mbtowc(pwc, s, n)
-        wchar_t *pwc;
-        const char *s;
-        size_t n;
-{
-        if (s == NULL)
-                return 0;
-        if (n == 0)
-                return -1;
-        if (pwc)
-                *pwc = (wchar_t) *s;
-        return (*s != '\0');
-}
-
-/*ARGSUSED*/
-int
-#ifdef __STDC__
-wctomb(char *s, wchar_t wchar)
-#else
-wctomb(s, wchar)
-        char *s;
-        wchar_t wchar;
-#endif
-{
-        if (s == NULL)
-                return 0;
-
-        *s = (char) wchar;
-        return 1;
-}
-
-/*ARGSUSED*/
-size_t
-mbstowcs(pwcs, s, n)
-        wchar_t *pwcs;
-        const char *s;
-        size_t n;
-{
-        int count = 0;
-
-        if (n != 0) {
-                do {
-                        if ((*pwcs++ = (wchar_t) *s++) == 0)
-                                break;
-                        count++;
-                } while (--n != 0);
-        }
-        
-        return count;
-}
-
-/*ARGSUSED*/
-size_t
-wcstombs(s, pwcs, n)
-        char *s;
-        const wchar_t *pwcs;
-        size_t n;
-{
-        int count = 0;
-
-        if (n != 0) {
-                do {
-                        if ((*s++ = (char) *pwcs++) == 0)
-                                break;
-                        count++;
-                } while (--n != 0);
-        }
-
-        return count;
-}
-
diff --git a/src/lib/libc/stdlib/nrand48.c b/src/lib/libc/stdlib/nrand48.c
index 63f839cb05..f1f548c3af 100644
--- a/src/lib/libc/stdlib/nrand48.c
+++ b/src/lib/libc/stdlib/nrand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: nrand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/posix_memalign.3 b/src/lib/libc/stdlib/posix_memalign.3
new file mode 100644
index 0000000000..46b74af7be
--- /dev/null
+++ b/src/lib/libc/stdlib/posix_memalign.3
@@ -0,0 +1,94 @@
+.\"     $OpenBSD: posix_memalign.3,v 1.2 2010/05/19 06:32:43 jmc Exp $
+.\" Copyright (C) 2006 Jason Evans <jasone@FreeBSD.org>.
+.\" 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(s), this list of conditions and the following disclaimer as
+.\"    the first lines of this file unmodified other than the possible
+.\"    addition of one or more copyright notices.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice(s), 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 HOLDER(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 COPYRIGHT HOLDER(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.
+.\"
+.\" $FreeBSD: src/lib/libc/stdlib/posix_memalign.3,v 1.3 2007/03/28 04:32:51 jasone Exp $
+.\"
+.Dd $Mdocdate: May 19 2010 $
+.Dt POSIX_MEMALIGN 3
+.Os
+.Sh NAME
+.Nm posix_memalign
+.Nd aligned memory allocation
+.Sh SYNOPSIS
+.In stdlib.h
+.Ft int
+.Fn posix_memalign "void **ptr" "size_t alignment" "size_t size"
+.Sh DESCRIPTION
+The
+.Fn posix_memalign
+function allocates
+.Fa size
+bytes of memory such that the allocation's base address is a multiple of
+.Fa alignment ,
+and returns the allocation in the value pointed to by
+.Fa ptr .
+.Pp
+The requested
+.Fa alignment
+must be a power of 2 at least as large as
+.Fn sizeof "void *" .
+.Pp
+Memory that is allocated via
+.Fn posix_memalign
+can be used as an argument in subsequent calls to
+.Xr realloc 3
+and
+.Xr free 3 .
+.Sh RETURN VALUES
+The
+.Fn posix_memalign
+function returns the value 0 if successful; otherwise it returns an error value.
+.Sh ERRORS
+The
+.Fn posix_memalign
+function will fail if:
+.Bl -tag -width Er
+.It Bq Er EINVAL
+The
+.Fa alignment
+parameter is not a power of 2 at least as large as
+.Fn sizeof "void *" .
+.It Bq Er ENOMEM
+Memory allocation error.
+.El
+.Sh SEE ALSO
+.Xr free 3 ,
+.Xr malloc 3 ,
+.Xr realloc 3
+.Sh STANDARDS
+The
+.Fn posix_memalign
+function conforms to
+.St -p1003.1-2001 .
+.Sh HISTORY
+The
+.Fn posix_memalign
+function first appeared in
+.Ox 4.8 .
+.Sh BUGS
+Only alignments up to the page size can be specified.
diff --git a/src/lib/libc/stdlib/qabs.3 b/src/lib/libc/stdlib/qabs.3
index cb1e052191..b12dc59276 100644
--- a/src/lib/libc/stdlib/qabs.3
+++ b/src/lib/libc/stdlib/qabs.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)labs.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: qabs.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: qabs.3,v 1.12 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt QABS 3
 .Os
 .Sh NAME
@@ -49,14 +44,13 @@
 .Sh DESCRIPTION
 The
 .Fn qabs
-function
-returns the absolute value of the quad integer
-.Ar j .
+function returns the absolute value of the quad integer
+.Fa j .
 .Sh SEE ALSO
 .Xr abs 3 ,
-.Xr labs 3 ,
-.Xr floor 3 ,
 .Xr cabs 3 ,
-.Xr math 3
+.Xr floor 3 ,
+.Xr imaxabs 3 ,
+.Xr labs 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
index 9c51a8baa9..656b93c822 100644
--- a/src/lib/libc/stdlib/qabs.c
+++ b/src/lib/libc/stdlib/qabs.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)labs.c       5.2 (Berkeley) 5/17/90";*/
-static char *rcsid = "$Id: qabs.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>
 
 quad_t
-qabs(j)
-        quad_t j;
+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
index 0efcfc96ef..94e3bdffb6 100644
--- a/src/lib/libc/stdlib/qdiv.3
+++ b/src/lib/libc/stdlib/qdiv.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)qdiv.3        5.3 (Berkeley) 6/29/91
-.\"     $Id: qdiv.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: qdiv.3,v 1.9 2011/07/07 13:30:28 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 7 2011 $
 .Dt QDIV 3
 .Os
 .Sh NAME
@@ -49,18 +44,18 @@
 .Sh DESCRIPTION
 The
 .Fn qdiv
-function
-computes the value
-.Ar num/denom
+function computes the value
+.Fa num Ns / Ns Fa denom
 and returns the quotient and remainder in a structure named
-.Ar qdiv_t
+.Li qdiv_t
 that contains two
-.Em quad integer
+.Li quad integer
 members named
-.Ar quot
+.Fa quot
 and
-.Ar rem .
+.Fa rem .
 .Sh SEE ALSO
 .Xr div 3 ,
+.Xr imaxdiv 3 ,
 .Xr ldiv 3 ,
-.Xr math 3
+.Xr lldiv 3
diff --git a/src/lib/libc/stdlib/qdiv.c b/src/lib/libc/stdlib/qdiv.c
index 8f8e3f89c4..f3db0915ed 100644
--- a/src/lib/libc/stdlib/qdiv.c
+++ b/src/lib/libc/stdlib/qdiv.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,16 +31,10 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)ldiv.c       5.2 (Berkeley) 4/16/91";*/
-static char *rcsid = "$Id: qdiv.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <stdlib.h>             /* qdiv_t */
 
 qdiv_t
-qdiv(num, denom)
-        quad_t num, denom;
+qdiv(quad_t num, quad_t denom)
 {
         qdiv_t r;
 
diff --git a/src/lib/libc/stdlib/qsort.3 b/src/lib/libc/stdlib/qsort.3
index eb122cde12..92c75d5365 100644
--- a/src/lib/libc/stdlib/qsort.3
+++ b/src/lib/libc/stdlib/qsort.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,14 +29,15 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)qsort.3       8.1 (Berkeley) 6/4/93
-.\"     $Id: qsort.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: qsort.3,v 1.15 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 4, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt QSORT 3
 .Os
 .Sh NAME
-.Nm qsort, heapsort, mergesort
+.Nm qsort ,
+.Nm heapsort ,
+.Nm mergesort
 .Nd sort functions
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
@@ -72,7 +69,7 @@ objects, the initial member of which is pointed to by
 .Fa base .
 The size of each object is specified by
 .Fa size .
-.Fn Mergesort
+.Fn mergesort
 behaves similarly, but
 .Em requires
 that
@@ -106,51 +103,49 @@ is stable.
 .Pp
 The
 .Fn qsort
-function is an implementation of C.A.R. Hoare's ``quicksort'' algorithm,
+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
+.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 ``heapsort'' algorithm,
+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
+.Fn heapsort
 takes O N lg N worst-case time.
-Its
-.Em only
-advantage over
-.Fn qsort
-is that it uses almost no additional memory; while
-.Fn qsort
-does not allocate memory, it is implemented using recursion.
+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 
+.Fa size
 bytes; it should be used only when space is not at a premium.
-.Fn Mergesort
+.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
-is faster than
+.Fn mergesort ,
+which is faster than
 .Fn heapsort .
-Memory availability and pre-existing order in the data can make this
-untrue.
+Memory availability and pre-existing order in the data can make this untrue.
 .Sh RETURN VALUES
 The
 .Fn qsort
-function
-returns no value.
+function returns no value.
 .Pp
 Upon successful completion,
 .Fn heapsort
@@ -163,30 +158,25 @@ is set to indicate the error.
 .Sh ERRORS
 The
 .Fn heapsort
-function succeeds unless:
+and
+.Fn mergesort
+functions succeed unless:
 .Bl -tag -width Er
 .It Bq Er EINVAL
 The
 .Fa size
-argument is zero, or,
-the
+argument is zero, or the
 .Fa size
 argument to
 .Fn mergesort
 is less than
 .Dq "sizeof(void *) / 2" .
 .It Bq Er ENOMEM
-.Fn Heapsort
+.Fn heapsort
 or
 .Fn mergesort
 were unable to allocate memory.
 .El
-.Sh COMPATIBILITY
-Previous versions of
-.Fn qsort
-did not permit the comparison routine itself to call
-.Fn qsort 3 .
-This is no longer true.
 .Sh SEE ALSO
 .Xr sort 1 ,
 .Xr radixsort 3
@@ -204,7 +194,7 @@ This is no longer true.
 .%T "Heapsort"
 .%J "Communications of the ACM"
 .%V 7:1
-.%P pp. 347-348
+.%P pp. 347\-348
 .Re
 .Rs
 .%A Knuth, D.E.
@@ -212,23 +202,32 @@ This is no longer true.
 .%B "The Art of Computer Programming"
 .%V Vol. 3
 .%T "Sorting and Searching"
-.%P pp. 114-123, 145-149
+.%P pp. 114\-123, 145\-149
 .Re
 .Rs
-.%A Mcilroy, P.M.
+.%A McIlroy, P.M.
 .%T "Optimistic Sorting and Information Theoretic Complexity"
 .%J "Fourth Annual ACM-SIAM Symposium on Discrete Algorithms"
-.%V January 1992
+.%P pp. 467\-464
+.%D January 1993
 .Re
 .Rs
 .%A Bentley, J.L.
+.%A McIlroy, M.D.
 .%T "Engineering a Sort Function"
-.%J "bentley@research.att.com"
-.%V January 1992
+.%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
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/qsort.c b/src/lib/libc/stdlib/qsort.c
index c06bd54054..f28449fb5b 100644
--- a/src/lib/libc/stdlib/qsort.c
+++ b/src/lib/libc/stdlib/qsort.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: qsort.c,v 1.11 2010/02/08 11:04:07 otto Exp $ */
 /*-
  * Copyright (c) 1992, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,16 +28,11 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char sccsid[] = "from: @(#)qsort.c     8.1 (Berkeley) 6/4/93";*/
-static char *rcsid = "$Id: qsort.c,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <stdlib.h>
 
-static inline char      *med3 __P((char *, char *, char *, int (*)()));
-static inline void       swapfunc __P((char *, char *, int, int));
+static __inline char    *med3(char *, char *, char *, int (*)(const void *, const void *));
+static __inline void     swapfunc(char *, char *, size_t, int);
 
 #define min(a, b)       (a) < (b) ? a : b
 
@@ -48,11 +40,11 @@ static inline void	 swapfunc __P((char *, char *, int, int));
  * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  */
 #define swapcode(TYPE, parmi, parmj, n) {               \
-        long i = (n) / sizeof (TYPE);                   \
-        register TYPE *pi = (TYPE *) (parmi);           \
-        register TYPE *pj = (TYPE *) (parmj);           \
+        size_t i = (n) / sizeof (TYPE);                 \
+        TYPE *pi = (TYPE *) (parmi);                    \
+        TYPE *pj = (TYPE *) (parmj);                    \
         do {                                            \
-                register TYPE   t = *pi;                \
+                TYPE    t = *pi;                        \
                 *pi++ = *pj;                            \
                 *pj++ = t;                              \
         } while (--i > 0);                              \
@@ -61,12 +53,10 @@ static inline void	 swapfunc __P((char *, char *, int, int));
 #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
         es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
 
-static inline void
-swapfunc(a, b, n, swaptype)
-        char *a, *b;
-        int n, swaptype;
+static __inline void
+swapfunc(char *a, char *b, size_t n, int swaptype)
 {
-        if(swaptype <= 1) 
+        if (swaptype <= 1) 
                 swapcode(long, a, b, n)
         else
                 swapcode(char, a, b, n)
@@ -82,10 +72,8 @@ swapfunc(a, b, n, swaptype)
 
 #define vecswap(a, b, n)        if ((n) > 0) swapfunc(a, b, n, swaptype)
 
-static inline char *
-med3(a, b, c, cmp)
-        char *a, *b, *c;
-        int (*cmp)();
+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 ))
@@ -93,27 +81,26 @@ med3(a, b, c, cmp)
 }
 
 void
-qsort(a, n, es, cmp)
-        void *a;
-        size_t n, es;
-        int (*cmp)();
+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;
+        int cmp_result, swaptype, swap_cnt;
+        size_t d, r;
+        char *a = aa;
 
 loop:   SWAPINIT(a, es);
         swap_cnt = 0;
         if (n < 7) {
-                for (pm = a + es; pm < (char *) a + n * es; pm += es)
+                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 = a + (n / 2) * es;
+        pm = (char *)a + (n / 2) * es;
         if (n > 7) {
-                pl = a;
-                pn = a + (n - 1) * es;
+                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);
@@ -123,20 +110,20 @@ loop:	SWAPINIT(a, es);
                 pm = med3(pl, pm, pn, cmp);
         }
         swap(a, pm);
-        pa = pb = a + es;
+        pa = pb = (char *)a + es;
 
-        pc = pd = a + (n - 1) * es;
+        pc = pd = (char *)a + (n - 1) * es;
         for (;;) {
-                while (pb <= pc && (r = cmp(pb, a)) <= 0) {
-                        if (r == 0) {
+                while (pb <= pc && (cmp_result = cmp(pb, a)) <= 0) {
+                        if (cmp_result == 0) {
                                 swap_cnt = 1;
                                 swap(pa, pb);
                                 pa += es;
                         }
                         pb += es;
                 }
-                while (pb <= pc && (r = cmp(pc, a)) >= 0) {
-                        if (r == 0) {
+                while (pb <= pc && (cmp_result = cmp(pc, a)) >= 0) {
+                        if (cmp_result == 0) {
                                 swap_cnt = 1;
                                 swap(pc, pd);
                                 pd -= es;
@@ -151,14 +138,14 @@ loop:	SWAPINIT(a, es);
                 pc -= es;
         }
         if (swap_cnt == 0) {  /* Switch to insertion sort */
-                for (pm = a + es; pm < (char *) a + n * es; pm += es)
+                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 = a + n * es;
+        pn = (char *)a + n * es;
         r = min(pa - (char *)a, pb - pa);
         vecswap(a, pb - r, r);
         r = min(pd - pc, pn - pd - es);
diff --git a/src/lib/libc/stdlib/radixsort.3 b/src/lib/libc/stdlib/radixsort.3
index a2af9f17a4..b90a557718 100644
--- a/src/lib/libc/stdlib/radixsort.3
+++ b/src/lib/libc/stdlib/radixsort.3
@@ -9,11 +9,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,32 +25,33 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)radixsort.3   8.2 (Berkeley) 1/27/94
-.\"     $Id: radixsort.3,v 1.1.1.1 1995/10/18 08:42:18 deraadt Exp $
+.\"     $OpenBSD: radixsort.3,v 1.11 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd January 27, 1994
+.Dd $Mdocdate: May 31 2007 $
 .Dt RADIXSORT 3
 .Os
 .Sh NAME
-.Nm radixsort
+.Nm radixsort ,
+.Nm sradixsort
 .Nd radix sort
 .Sh SYNOPSIS
 .Fd #include <limits.h>
 .Fd #include <stdlib.h>
 .Ft int
-.Fn radixsort "u_char **base" "int nmemb" "u_char *table" "u_int endbyte"
+.Fn radixsort "const u_char **base" "int nmemb" "const u_char *table" "u_int endbyte"
 .Ft int
-.Fn sradixsort "u_char **base" "int nmemb" "u_char *table" "u_int endbyte"
+.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.
+functions are implementations of radix sort.
 .Pp
-These functions sort an array of pointers to byte strings, the initial
-member of which is referenced by
+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
@@ -63,26 +60,24 @@ is denoted by the user-specified value
 Applications may specify a sort order by providing the
 .Fa table
 argument.
-If
-.Pf non- Dv NULL , 
+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.
++ 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.
+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 NULL, the contents of the array are sorted in ascending order
-according to the
+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
@@ -90,7 +85,7 @@ has a sorting weight of 0.
 .Pp
 The
 .Fn sradixsort
-function is stable, that is, if two elements compare as equal, their
+function is stable; that is, if two elements compare as equal, their
 order in the sorted array is unchanged.
 The
 .Fn sradixsort
@@ -107,7 +102,7 @@ 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 
+Otherwise, \-1 is returned and the global variable
 .Va errno
 is set to indicate the error.
 .Sh ERRORS
@@ -122,15 +117,13 @@ is not 0 or 255.
 .Pp
 Additionally, the
 .Fn sradixsort
-function
-may fail and set
+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
-.Pp
 .Rs
 .%A Knuth, D.E.
 .%D 1968
@@ -158,4 +151,5 @@ for any of the errors specified for the library routine
 .Sh HISTORY
 The
 .Fn radixsort
-function first appeared in 4.4BSD.
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/stdlib/radixsort.c b/src/lib/libc/stdlib/radixsort.c
index dd51013c94..49d03b52d5 100644
--- a/src/lib/libc/stdlib/radixsort.c
+++ b/src/lib/libc/stdlib/radixsort.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: radixsort.c,v 1.9 2007/09/02 15:19:17 deraadt Exp $ */
 /*-
  * Copyright (c) 1990, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char sccsid[] = "from: @(#)radixsort.c 8.1 (Berkeley) 6/4/93";*/
-static char *rcsid = "$Id: radixsort.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 /*
  * Radixsort routines.
  * 
@@ -61,11 +53,11 @@ typedef struct {
         int sn, si;
 } stack;
 
-static inline void simplesort
-            __P((const u_char **, int, int, const u_char *, u_int));
-static void r_sort_a __P((const u_char **, int, int, const u_char *, u_int));
-static void r_sort_b __P((const u_char **,
-            const u_char **, int, int, const u_char *, u_int));
+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. */
@@ -90,10 +82,7 @@ static void r_sort_b __P((const u_char **,
 }
 
 int
-radixsort(a, n, tab, endch)
-        const u_char **a, *tab;
-        int n;
-        u_int endch;
+radixsort(const u_char **a, int n, const u_char *tab, u_int endch)
 {
         const u_char *tr;
         int c;
@@ -105,10 +94,7 @@ radixsort(a, n, tab, endch)
 }
 
 int
-sradixsort(a, n, tab, endch)
-        const u_char **a, *tab;
-        int n;
-        u_int endch;
+sradixsort(const u_char **a, int n, const u_char *tab, u_int endch)
 {
         const u_char *tr, **ta;
         int c;
@@ -118,7 +104,7 @@ sradixsort(a, n, tab, endch)
         if (n < THRESHOLD)
                 simplesort(a, n, 0, tr, endch);
         else {
-                if ((ta = malloc(n * sizeof(a))) == NULL)
+                if ((ta = calloc(n, sizeof(a))) == NULL)
                         return (-1);
                 r_sort_b(a, ta, n, 0, tr, endch);
                 free(ta);
@@ -133,15 +119,11 @@ sradixsort(a, n, tab, endch)
 
 /* Unstable, in-place sort. */
 void
-r_sort_a(a, n, i, tr, endch)
-        const u_char **a;
-        int n, i;
-        const u_char *tr;
-        u_int endch;
+r_sort_a(const u_char **a, int n, int i, const u_char *tr, u_int endch)
 {
         static int count[256], nc, bmin;
-        register int c;
-        register const u_char **ak, *r;
+        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];
@@ -224,15 +206,12 @@ r_sort_a(a, n, i, tr, endch)
 
 /* Stable sort, requiring additional memory. */
 void
-r_sort_b(a, ta, n, i, tr, endch)
-        const u_char **a, **ta;
-        int n, i;
-        const u_char *tr;
-        u_int endch;
+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;
-        register int c;
-        register const u_char **ak, **ai;
+        int c;
+        const u_char **ak, **ai;
         stack s[512], *sp, *sp0, *sp1, temp;
         const u_char **top[256];
         int *cp, bigc;
@@ -295,14 +274,11 @@ r_sort_b(a, ta, n, i, tr, endch)
         }
 }
                 
-static inline void
-simplesort(a, n, b, tr, endch)  /* insertion sort */
-        register const u_char **a;
-        int n, b;
-        register const u_char *tr;
-        u_int endch;
+static __inline void
+simplesort(const u_char **a, int n, int b, const u_char *tr, u_int endch)
+    /* insertion sort */
 {
-        register u_char ch;
+        u_char ch;
         const u_char  **ak, **ai, *s, *t;
 
         for (ak = a+1; --n >= 1; ak++)
diff --git a/src/lib/libc/stdlib/rand.3 b/src/lib/libc/stdlib/rand.3
index a0e7740e66..df4feaacdb 100644
--- a/src/lib/libc/stdlib/rand.3
+++ b/src/lib/libc/stdlib/rand.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)rand.3        6.7 (Berkeley) 6/29/91
-.\"     $Id: rand.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: rand.3,v 1.10 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt RAND 3
 .Os
 .Sh NAME
@@ -46,12 +41,15 @@
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
 .Ft void
-.Fn srand "unsigned seed"
+.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 random(3).
+These interfaces are obsoleted by
+.Xr random 3 .
 .Ef
 .Pp
 The
@@ -73,13 +71,28 @@ 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
+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
index 361d473448..0f9c100807 100644
--- a/src/lib/libc/stdlib/rand.c
+++ b/src/lib/libc/stdlib/rand.c
@@ -10,11 +10,7 @@
  * 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
+ * 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.
  *
@@ -31,25 +27,26 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)rand.c       5.6 (Berkeley) 6/24/91";*/
-static char *rcsid = "$Id: rand.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <stdlib.h>
 
-static u_long next = 1;
+static u_int next = 1;
+
+int
+rand_r(u_int *seed)
+{
+        *seed = *seed * 1103515245 + 12345;
+        return (*seed % ((u_int)RAND_MAX + 1));
+}
 
 int
-rand()
+rand(void)
 {
-        return ((next = next * 1103515245 + 12345) % ((u_int)RAND_MAX + 1));
+        return (rand_r(&next));
 }
 
 void
-srand(seed)
-u_int seed;
+srand(u_int seed)
 {
         next = seed;
 }
diff --git a/src/lib/libc/stdlib/rand48.3 b/src/lib/libc/stdlib/rand48.3
index 5a772c9a8c..0e8ca5389b 100644
--- a/src/lib/libc/stdlib/rand48.3
+++ b/src/lib/libc/stdlib/rand48.3
@@ -1,4 +1,4 @@
-\" Copyright (c) 1993 Martin Birgmeier
+.\" Copyright (c) 1993 Martin Birgmeier
 .\" All rights reserved.
 .\"
 .\" You may redistribute unmodified or modified versions of this source
@@ -9,9 +9,9 @@
 .\" of any kind. I shall in no event be liable for anything that happens
 .\" to anyone/anything when using this software.
 .\"
-.\"     $Id: rand48.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: rand48.3,v 1.11 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd October 8, 1993
+.Dd $Mdocdate: May 31 2007 $
 .Dt RAND48 3
 .Os
 .Sh NAME
@@ -24,10 +24,10 @@
 .Nm srand48 ,
 .Nm seed48 ,
 .Nm lcong48
-.Nd pseudo random number generators and initialization routines
+.Nd pseudo-random number generators and initialization routines
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
-.Ft double 
+.Ft double
 .Fn drand48 void
 .Ft double
 .Fn erand48 "unsigned short xseed[3]"
@@ -49,12 +49,13 @@
 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
+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.
+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
@@ -63,15 +64,17 @@ computational step is to perform a single iteration of the algorithm.
 .Fn drand48
 and
 .Fn erand48
-return values of type double. The full 48 bits of r(n+1) are
+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).
+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
+[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
@@ -79,14 +82,15 @@ the topmost (sign) bit set to zero.
 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.
+[-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
+use an internal buffer to store r(n).
+For these functions
 the initial value of r(0) = 0x1234abcd330e = 20017429951246.
 .Pp
 On the other hand,
@@ -118,12 +122,12 @@ also initializes the internal buffer r(n) of
 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
+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, thus its contents are lost after
+This array is statically allocated, so its contents are lost after
 each new call to
 .Fn seed48 .
 .Pp
@@ -152,9 +156,10 @@ 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 AUTHOR
-Martin Birgmeier
+.Xr random 3 .
 .Sh SEE ALSO
+.Xr arc4random 3 ,
 .Xr rand 3 ,
-.Xr random 3 .
+.Xr random 3
+.Sh AUTHORS
+Martin Birgmeier
diff --git a/src/lib/libc/stdlib/rand48.h b/src/lib/libc/stdlib/rand48.h
index 12496d1c8c..afa49f65f3 100644
--- a/src/lib/libc/stdlib/rand48.h
+++ b/src/lib/libc/stdlib/rand48.h
@@ -9,6 +9,8 @@
  * 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_
@@ -17,7 +19,7 @@
 #include <math.h>
 #include <stdlib.h>
 
-void            __dorand48 __P((unsigned short[3]));
+void            __dorand48(unsigned short[3]);
 
 #define RAND48_SEED_0   (0x330e)
 #define RAND48_SEED_1   (0xabcd)
diff --git a/src/lib/libc/stdlib/random.3 b/src/lib/libc/stdlib/random.3
index 38c15a9803..ed05df162b 100644
--- a/src/lib/libc/stdlib/random.3
+++ b/src/lib/libc/stdlib/random.3
@@ -9,11 +9,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,97 +25,105 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)random.3      6.5 (Berkeley) 4/19/91
-.\"     $Id: random.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: random.3,v 1.19 2007/05/31 19:19:31 jmc Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt RANDOM 3
-.Os BSD 4.2
+.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 
+.Ft long
 .Fn random void
 .Ft void
-.Fn srandom "unsigned seed"
+.Fn srandom "unsigned int seed"
+.Ft void
+.Fn srandomdev void
 .Ft char *
-.Fn initstate "unsigned seed" "char *state" "int n"
+.Fn initstate "unsigned int seed" "char *state" "size_t n"
 .Ft char *
-.Fn setstate "char *state"
+.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
-.if t 2\u\s731\s10\d\(mi1.
-.if n (2**31)\(mi1.
+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
-.if t 16\(mu(2\u\s731\s10\d\(mi1).
-.if n 16*((2**31)\(mi1).
+16*((2**31)\-1).
 .Pp
 The
-.Fn random Ns / Fn srandom
-have (almost) the same calling sequence and initialization properties as
-.Xr rand 3 Ns / Xr srand 3 .
+.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
+generated by rand go through a cyclic pattern.
+All the bits generated by
 .Fn random
-are usable.  For example,
+are usable.
+For example,
 .Sq Li random()&01
 will produce a random binary
 value.
 .Pp
-Unlike
-.Xr srand ,
-.Fn srandom
-does not return the old seed; the reason for this is that the amount of
-state information used is much more than a single word.  (Two other
-routines are provided to deal with restarting/changing random
-number generators).  Like
+Like
 .Xr rand 3 ,
-however,
 .Fn random
 will by default produce a sequence of numbers that can be duplicated
 by calling
 .Fn srandom
-with 
+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
+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 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.
+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
+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
@@ -143,12 +147,8 @@ 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
-.if t 2\u\s769\s10\d,
-.if n 2**69
+generator is greater than 2**69
 which should be sufficient for most purposes.
-.Sh AUTHOR
-Earl T. Cohen
 .Sh DIAGNOSTICS
 If
 .Fn initstate
@@ -157,11 +157,29 @@ is called with less than 8 bytes of state information, or if
 detects that the state information has been garbled, error
 messages are printed on the standard error output.
 .Sh SEE ALSO
-.Xr rand 3
+.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 
+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
index 469b6d976a..48e892042b 100644
--- a/src/lib/libc/stdlib/random.c
+++ b/src/lib/libc/stdlib/random.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,13 +28,13 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)random.c     5.9 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#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:
@@ -55,10 +52,10 @@ static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
  * 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 longs; the
+ * 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 longs worth of
+ * 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).
@@ -134,14 +131,14 @@ static int seps [MAX_TYPES] =	{ SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
  *      MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3.
  */
 
-static long randtbl[DEG_3 + 1] = {
+static int32_t randtbl[DEG_3 + 1] = {
         TYPE_3,
-        0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 0xde3b81e0, 0xdf0a6fb5,
-        0xf103bc02, 0x48f340fb, 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
-        0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 0xda672e2a, 0x1588ca88,
-        0xe369735d, 0x904f35f7, 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
-        0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 0xf5ad9d0e, 0x8999220b,
-        0x27fb47b9,
+        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,
 };
 
 /*
@@ -158,8 +155,8 @@ static long randtbl[DEG_3 + 1] = {
  * in the initialization of randtbl) because the state table pointer is set
  * to point to randtbl[1] (as explained below).
  */
-static long *fptr = &randtbl[SEP_3 + 1];
-static long *rptr = &randtbl[1];
+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
@@ -171,11 +168,11 @@ static long *rptr = &randtbl[1];
  * 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 long *state = &randtbl[1];
+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;
-static long *end_ptr = &randtbl[DEG_3 + 1];
 
 /*
  * srandom:
@@ -190,18 +187,28 @@ static long *end_ptr = &randtbl[DEG_3 + 1];
  * for default usage relies on values produced by this routine.
  */
 void
-srandom(x)
-        u_int x;
+srandom(unsigned int x)
 {
-        register int i, j;
+        int i;
+        int32_t test;
+        div_t val;
 
         if (rand_type == TYPE_0)
                 state[0] = x;
         else {
-                j = 1;
                 state[0] = x;
-                for (i = 1; i < rand_deg; i++)
-                        state[i] = 1103515245 * state[i - 1] + 12345;
+                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++)
@@ -210,6 +217,38 @@ srandom(x)
 }
 
 /*
+ * 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
@@ -229,22 +268,16 @@ srandom(x)
  * Returns a pointer to the old state.
  */
 char *
-initstate(seed, arg_state, n)
-        u_int seed;                     /* seed for R.N.G. */
-        char *arg_state;                /* pointer to state array */
-        int n;                          /* # bytes of state info */
+initstate(u_int seed, char *arg_state, size_t n)
 {
-        register char *ostate = (char *)(&state[-1]);
+        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) {
-                (void)fprintf(stderr,
-                    "random: not enough state (%d bytes); ignored.\n", n);
-                return(0);
-        }
+        if (n < BREAK_0)
+                return(NULL);
         if (n < BREAK_1) {
                 rand_type = TYPE_0;
                 rand_deg = DEG_0;
@@ -266,7 +299,7 @@ initstate(seed, arg_state, n)
                 rand_deg = DEG_4;
                 rand_sep = SEP_4;
         }
-        state = &(((long *)arg_state)[1]);      /* first location */
+        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)
@@ -292,12 +325,11 @@ initstate(seed, arg_state, n)
  * Returns a pointer to the old state information.
  */
 char *
-setstate(arg_state)
-        char *arg_state;
+setstate(const char *arg_state)
 {
-        register long *new_state = (long *)arg_state;
-        register int type = new_state[0] % MAX_TYPES;
-        register int rear = new_state[0] / MAX_TYPES;
+        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)
@@ -315,8 +347,7 @@ setstate(arg_state)
                 rand_sep = seps[type];
                 break;
         default:
-                (void)fprintf(stderr,
-                    "random: state info corrupted; not changed.\n");
+                return(NULL);
         }
         state = &new_state[1];
         if (rand_type != TYPE_0) {
@@ -345,9 +376,9 @@ setstate(arg_state)
  * Returns a 31-bit random number.
  */
 long
-random()
+random(void)
 {
-        long i;
+        int32_t i;
 
         if (rand_type == TYPE_0)
                 i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
@@ -360,5 +391,5 @@ random()
                 } else if (++rptr >= end_ptr)
                         rptr = state;
         }
-        return(i);
+        return((long)i);
 }
diff --git a/src/lib/libc/stdlib/realloc.3 b/src/lib/libc/stdlib/realloc.3
deleted file mode 100644
index 66f09b2081..0000000000
--- a/src/lib/libc/stdlib/realloc.3
+++ /dev/null
@@ -1,100 +0,0 @@
-.\" Copyright (c) 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. 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.
-.\"
-.\"     from: @(#)realloc.3     5.1 (Berkeley) 5/2/91
-.\"     $Id: realloc.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
-.\"
-.Dd May 2, 1991
-.Dt REALLOC 3
-.Os
-.Sh NAME
-.Nm realloc
-.Nd reallocation of memory function
-.Sh SYNOPSIS
-.Fd #include <stdlib.h>
-.Ft void *
-.Fn realloc "void *ptr" "size_t size"
-.Sh DESCRIPTION
-The
-.Fn realloc
-function changes the size of the object pointed to by
-.Fa ptr
-to the size specified by
-.Fa size .
-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.
-If
-.Fa ptr
-is a null pointer, the
-.Fn realloc
-function behaves like the
-.Xr malloc 3
-function for the specified size.
-Otherwise, if
-.Fa ptr
-does not match a pointer earlier returned by the
-.Xr calloc 3 ,
-.Xr malloc 3 ,
-or 
-.Fn realloc
-function, or if the space has been deallocated
-by a call to the
-.Xr free
-or
-.Fn realloc
-function, unpredictable and usually detrimental
-behavior will occur.
-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.
-.Pp
-The
-.Fn realloc
-function returns either a null pointer or a pointer
-to the possibly moved allocated space.
-.Sh SEE ALSO
-.Xr alloca 3 ,
-.Xr calloc 3 ,
-.Xr free 3 ,
-.Xr malloc 3 ,
-.Sh STANDARDS
-The
-.Fn realloc
-function conforms to
-.St -ansiC .
diff --git a/src/lib/libc/stdlib/realpath.3 b/src/lib/libc/stdlib/realpath.3
index 9d8b1ff2ce..68ed088161 100644
--- a/src/lib/libc/stdlib/realpath.3
+++ b/src/lib/libc/stdlib/realpath.3
@@ -12,11 +12,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -32,20 +28,19 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)realpath.3    8.2 (Berkeley) 2/16/94
-.\"     $Id: realpath.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: realpath.3,v 1.17 2011/07/24 22:29:05 jmc Exp $
 .\"
-.Dd "February 16, 1994"
+.Dd $Mdocdate: July 24 2011 $
 .Dt REALPATH 3
 .Os
 .Sh NAME
 .Nm realpath
 .Nd returns the canonicalized absolute pathname
 .Sh SYNOPSIS
-.Fd #include <sys/param.h>
+.Fd #include <limits.h>
 .Fd #include <stdlib.h>
 .Ft "char *"
-.Fn realpath "const char *pathname" "char resolvedname[MAXPATHLEN]"
+.Fn realpath "const char *pathname" "char *resolved"
 .Sh DESCRIPTION
 The
 .Fn realpath
@@ -57,18 +52,18 @@ and
 .Pa /../
 in
 .Fa pathname ,
-and copies the resulting absolute pathname into
-the memory referenced by
-.Fa resolvedname .
+and copies the resulting absolute pathname into the memory referenced by
+.Fa resolved .
 The
-.Fa resolvedname
+.Fa resolved
 argument
 .Em must
 refer to a buffer capable of storing at least
-.Dv MAXPATHLEN
-characters.
+.Dv PATH_MAX
+characters, or be
+.Dv NULL .
 .Pp
-The 
+The
 .Fn realpath
 function will resolve both absolute and relative paths
 and return the absolute pathname corresponding to
@@ -78,33 +73,49 @@ All but the last component of
 must exist when
 .Fn realpath
 is called.
-.Sh "RETURN VALUES"
+.Sh RETURN VALUES
 The
 .Fn realpath
 function returns
-.Fa resolved_name
+.Fa resolved
 on success.
+If
+.Fa resolved
+is
+.Dv NULL
+and no error occurred, then
+.Fa realpath
+returns a NUL-terminated string in a newly allocated buffer.
 If an error occurs,
 .Fn realpath
 returns
-.Dv NULL ,
-and
-.Fa resolved_name
-contains the pathname which caused the problem.
+.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 chdir 2 ,
-.Xr close 2 ,
-.Xr fchdir 2 ,
 .Xr lstat 2 ,
-.Xr open 2 ,
-.Xr readlink 2
+.Xr readlink 2 ,
 and
 .Xr getcwd 3 .
+.Sh SEE ALSO
+.Xr readlink 1 ,
+.Xr getcwd 3
+.Sh STANDARDS
+The
+.Fn realpath
+function conforms to
+.St -p1003.1-2008 .
+.Sh HISTORY
+The
+.Fn realpath
+function call first appeared in
+.Bx 4.4 .
 .Sh CAVEATS
 This implementation of
 .Fn realpath
@@ -114,13 +125,6 @@ The
 version always returns absolute pathnames,
 whereas the Solaris implementation will,
 under certain circumstances, return a relative
-.Fa resolved_path
+.Fa resolved
 when given a relative
 .Fa pathname .
-.Sh "SEE ALSO"
-.Xr getcwd 3
-.Sh HISTORY
-The
-.Fn realpath
-function call first appeared in
-.Bx 4.4 .
diff --git a/src/lib/libc/stdlib/realpath.c b/src/lib/libc/stdlib/realpath.c
index e349b7e068..21af4cf005 100644
--- a/src/lib/libc/stdlib/realpath.c
+++ b/src/lib/libc/stdlib/realpath.c
@@ -1,9 +1,6 @@
+/*      $OpenBSD: realpath.c,v 1.14 2011/07/24 21:03:00 miod Exp $ */
 /*
- * 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.
+ * 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
@@ -13,18 +10,14 @@
  * 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.
+ * 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 REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * 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 REGENTS OR CONTRIBUTORS BE LIABLE
+ * 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)
@@ -34,126 +27,186 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char sccsid[] = "from: @(#)realpath.c  8.1 (Berkeley) 2/16/94";*/
-static char *rcsid = "$Id: realpath.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/param.h>
 #include <sys/stat.h>
 
 #include <errno.h>
-#include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 /*
- * char *realpath(const char *path, char resolved_path[MAXPATHLEN]);
+ * 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(path, resolved)
-        const char *path;
-        char *resolved;
+realpath(const char *path, char *resolved)
 {
         struct stat sb;
-        int fd, n, rootd, serrno;
-        char *p, *q, wbuf[MAXPATHLEN];
+        char *p, *q, *s;
+        size_t left_len, resolved_len;
+        unsigned symlinks;
+        int serrno, slen, mem_allocated;
+        char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
 
-        /* Save the starting point. */
-        if ((fd = open(".", O_RDONLY)) < 0) {
-                (void)strcpy(resolved, ".");
+        if (path[0] == '\0') {
+                errno = ENOENT;
                 return (NULL);
         }
 
-        /*
-         * Find the dirname and basename from the path to be resolved.
-         * Change directory to the dirname component.
-         * lstat the basename part.
-         *     if it is a symlink, read in the value and loop.
-         *     if it is a directory, then change to that directory.
-         * get the current directory name and append the basename.
-         */
-        (void)strncpy(resolved, path, MAXPATHLEN - 1);
-        resolved[MAXPATHLEN - 1] = '\0';
-loop:
-        q = strrchr(resolved, '/');
-        if (q != NULL) {
-                p = q + 1;
-                if (q == resolved)
-                        q = "/";
-                else {
-                        do {
-                                --q;
-                        } while (q > resolved && *q == '/');
-                        q[1] = '\0';
-                        q = resolved;
-                }
-                if (chdir(q) < 0)
-                        goto err1;
+        serrno = errno;
+
+        if (resolved == NULL) {
+                resolved = malloc(PATH_MAX);
+                if (resolved == NULL)
+                        return (NULL);
+                mem_allocated = 1;
         } else
-                p = resolved;
+                mem_allocated = 0;
 
-        /* Deal with the last component. */
-        if (lstat(p, &sb) == 0) {
-                if (S_ISLNK(sb.st_mode)) {
-                        n = readlink(p, resolved, MAXPATHLEN);
-                        if (n < 0)
-                                goto err1;
-                        resolved[n] = '\0';
-                        goto loop;
-                }
-                if (S_ISDIR(sb.st_mode)) {
-                        if (chdir(p) < 0)
-                                goto err1;
-                        p = "";
+        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) {
+                        if (mem_allocated)
+                                free(resolved);
+                        else
+                                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;
+                goto err;
         }
 
         /*
-         * Save the last component name and get the full pathname of
-         * the current directory.
-         */
-        (void)strcpy(wbuf, p);
-        if (getcwd(resolved, MAXPATHLEN) == 0)
-                goto err1;
-
-        /*
-         * Join the two strings together, ensuring that the right thing
-         * happens if the last component is empty, or the dirname is root.
+         * Iterate over path components in `left'.
          */
-        if (resolved[0] == '/' && resolved[1] == '\0')
-                rootd = 1;
-        else
-                rootd = 0;
+        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;
+                        goto err;
+                }
+                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;
+                                goto err;
+                        }
+                        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;
+                }
 
-        if (*wbuf) {
-                if (strlen(resolved) + strlen(wbuf) + rootd + 1 > MAXPATHLEN) {
+                /*
+                 * 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;
-                        goto err1;
+                        goto err;
                 }
-                if (rootd == 0)
-                        (void)strcat(resolved, "/");
-                (void)strcat(resolved, wbuf);
-        }
+                if (lstat(resolved, &sb) != 0) {
+                        if (errno == ENOENT && p == NULL) {
+                                errno = serrno;
+                                return (resolved);
+                        }
+                        goto err;
+                }
+                if (S_ISLNK(sb.st_mode)) {
+                        if (symlinks++ > MAXSYMLINKS) {
+                                errno = ELOOP;
+                                goto err;
+                        }
+                        slen = readlink(resolved, symlink, sizeof(symlink) - 1);
+                        if (slen < 0)
+                                goto err;
+                        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;
+                        }
 
-        /* Go back to where we came from. */
-        if (fchdir(fd) < 0) {
-                serrno = errno;
-                goto err2;
+                        /*
+                         * 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;
+                                                goto err;
+                                        }
+                                        symlink[slen] = '/';
+                                        symlink[slen + 1] = 0;
+                                }
+                                left_len = strlcat(symlink, left, sizeof(left));
+                                if (left_len >= sizeof(left)) {
+                                        errno = ENAMETOOLONG;
+                                        goto err;
+                                }
+                        }
+                        left_len = strlcpy(left, symlink, sizeof(left));
+                }
         }
 
-        /* It's okay if the close fails, what's an fd more or less? */
-        (void)close(fd);
+        /*
+         * 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);
 
-err1:   serrno = errno;
-        (void)fchdir(fd);
-err2:   (void)close(fd);
-        errno = serrno;
+err:
+        if (mem_allocated)
+                free(resolved);
         return (NULL);
 }
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
index e3d31901dd..583262f2d5 100644
--- a/src/lib/libc/stdlib/seed48.c
+++ b/src/lib/libc/stdlib/seed48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: seed48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/setenv.c b/src/lib/libc/stdlib/setenv.c
index a36669888d..089ab92d38 100644
--- a/src/lib/libc/stdlib/setenv.c
+++ b/src/lib/libc/stdlib/setenv.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: setenv.c,v 1.13 2010/08/23 22:31:50 millert Exp $ */
 /*
  * Copyright (c) 1987 Regents of the University of California.
  * All rights reserved.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,71 +28,120 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)setenv.c     5.6 (Berkeley) 6/4/91";*/
-static char *rcsid = "$Id: setenv.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
+char *__findenv(const char *name, int len, int *offset);
+
+extern char **environ;
+static char **lastenv;                          /* last value of environ */
+
+/*
+ * putenv --
+ *      Add a name=value string directly to the environmental, replacing
+ *      any current value.
+ */
+int
+putenv(char *str)
+{
+        char **P, *cp;
+        size_t cnt;
+        int offset = 0;
+
+        for (cp = str; *cp && *cp != '='; ++cp)
+                ;
+        if (*cp != '=') {
+                errno = EINVAL;
+                return (-1);                    /* missing `=' in string */
+        }
+
+        if (__findenv(str, (int)(cp - str), &offset) != NULL) {
+                environ[offset++] = str;
+                /* could be set multiple times */
+                while (__findenv(str, (int)(cp - str), &offset)) {
+                        for (P = &environ[offset];; ++P)
+                                if (!(*P = *(P + 1)))
+                                        break;
+                }
+                return (0);
+        }
+
+        /* create new slot for string */
+        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;
+        environ[cnt] = str;
+        environ[cnt + 1] = NULL;
+        return (0);
+}
+
 /*
  * setenv --
  *      Set the value of the environmental variable "name" to be
  *      "value".  If rewrite is set, replace any current value.
  */
 int
-setenv(name, value, rewrite)
-        register const char *name;
-        register const char *value;
-        int rewrite;
+setenv(const char *name, const char *value, int rewrite)
 {
-        extern char **environ;
-        static int alloced;                     /* if allocated space before */
-        register char *C;
-        int l_value, offset;
-        char *__findenv();
+        char *C, **P;
+        const char *np;
+        int l_value, offset = 0;
+
+        for (np = name; *np && *np != '='; ++np)
+                ;
+#ifdef notyet
+        if (*np) {
+                errno = EINVAL;
+                return (-1);                    /* has `=' in name */
+        }
+#endif
 
-        if (*value == '=')                      /* no `=' in value */
-                ++value;
         l_value = strlen(value);
-        if ((C = __findenv(name, &offset))) {   /* find if already exists */
+        if ((C = __findenv(name, (int)(np - name), &offset)) != NULL) {
+                int tmpoff = offset + 1;
                 if (!rewrite)
                         return (0);
+#if 0 /* XXX - existing entry may not be writable */
                 if (strlen(C) >= l_value) {     /* old larger; copy over */
-                        while (*C++ = *value++);
+                        while ((*C++ = *value++))
+                                ;
                         return (0);
                 }
+#endif
+                /* could be set multiple times */
+                while (__findenv(name, (int)(np - name), &tmpoff)) {
+                        for (P = &environ[tmpoff];; ++P)
+                                if (!(*P = *(P + 1)))
+                                        break;
+                }
         } else {                                        /* create new slot */
-                register int    cnt;
-                register char   **P;
+                size_t cnt;
 
-                for (P = environ, cnt = 0; *P; ++P, ++cnt);
-                if (alloced) {                  /* just increase size */
-                        environ = (char **)realloc((char *)environ,
-                            (size_t)(sizeof(char *) * (cnt + 2)));
-                        if (!environ)
-                                return (-1);
-                }
-                else {                          /* get new space */
-                        alloced = 1;            /* copy old entries into it */
-                        P = (char **)malloc((size_t)(sizeof(char *) *
-                            (cnt + 2)));
-                        if (!P)
-                                return (-1);
-                        bcopy(environ, P, cnt * sizeof(char *));
-                        environ = P;
-                }
-                environ[cnt + 1] = NULL;
+                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))))
+            malloc((size_t)((int)(np - name) + l_value + 2))))
                 return (-1);
         for (C = environ[offset]; (*C = *name++) && *C != '='; ++C)
                 ;
-        for (*C++ = '='; *C++ = *value++; )
+        for (*C++ = '='; (*C++ = *value++); )
                 ;
         return (0);
 }
@@ -104,17 +150,29 @@ setenv(name, value, rewrite)
  * unsetenv(name) --
  *      Delete environmental variable "name".
  */
-void
-unsetenv(name)
-        const char      *name;
+int
+unsetenv(const char *name)
 {
-        extern char **environ;
-        register char **P;
-        int offset;
-        char *__findenv();
+        char **P;
+        const char *np;
+        int offset = 0;
+
+        if (!name || !*name) {
+                errno = EINVAL;
+                return (-1);
+        }
+        for (np = name; *np && *np != '='; ++np)
+                ;
+        if (*np) {
+                errno = EINVAL;
+                return (-1);                    /* has `=' in name */
+        }
 
-        while (__findenv(name, &offset))                /* if set multiple times */
+        /* could be set multiple times */
+        while (__findenv(name, (int)(np - name), &offset)) {
                 for (P = &environ[offset];; ++P)
                         if (!(*P = *(P + 1)))
                                 break;
+        }
+        return (0);
 }
diff --git a/src/lib/libc/stdlib/srand48.c b/src/lib/libc/stdlib/srand48.c
index daf733f93e..f76b6cca86 100644
--- a/src/lib/libc/stdlib/srand48.c
+++ b/src/lib/libc/stdlib/srand48.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: srand48.c,v 1.3 2005/08/08 08:05:37 espie Exp $ */
 /*
  * Copyright (c) 1993 Martin Birgmeier
  * All rights reserved.
diff --git a/src/lib/libc/stdlib/strtod.3 b/src/lib/libc/stdlib/strtod.3
index 0b7f973857..f1fc781f7d 100644
--- a/src/lib/libc/stdlib/strtod.3
+++ b/src/lib/libc/stdlib/strtod.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,44 +29,74 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strtod.3      5.3 (Berkeley) 6/29/91
-.\"     $Id: strtod.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: strtod.3,v 1.14 2008/09/13 22:48:45 martynas Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: September 13 2008 $
 .Dt STRTOD 3
 .Os
 .Sh NAME
-.Nm strtod
+.Nm strtod ,
+.Nm strtof ,
+.Nm strtold
 .Nd convert
 .Tn ASCII
-string to double
+string to double, float or long double
 .Sh SYNOPSIS
+.Fd #include <math.h>
 .Fd #include <stdlib.h>
 .Ft double
 .Fn strtod "const char *nptr" "char **endptr"
+.Pp
+.Ft float
+.Fn strtof "const char *nptr" "char **endptr"
+.Pp
+.Ft long double
+.Fn strtold "const char *nptr" "char **endptr"
 .Sh DESCRIPTION
 The
 .Fn strtod
-function converts the initial portion of the string 
-pointed to by
+function converts the initial portion of the string pointed to by
 .Fa nptr
 to
-.Em double
+.Li double
+representation.
+The
+.Fn strtof
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li float
+representation.
+The
+.Fn strtold
+function converts the initial portion of the string pointed to by
+.Fa nptr
+to
+.Li long double
 representation.
 .Pp
-The expected form of the string is an optional plus (``+'') or minus
-sign (``-'') followed by a sequence of digits optionally containing
+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 ``E'' or ``e'', followed by an optional plus
-or minus sign, followed by a sequence of digits.
+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 white-space characters in the string (as defined by the
+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.
+.Fn strtod ,
+.Fn strtof
+and
+.Fn strtold
+functions return the converted value, if any.
 .Pp
 If
 .Fa endptr
@@ -88,18 +114,18 @@ is stored in the location referenced by
 If the correct value would cause overflow, plus or minus
 .Dv HUGE_VAL
 is returned (according to the sign of the value), and
-.Dv ERANGE
+.Er ERANGE
 is stored in
 .Va errno .
-If the correct value would cause underflow, zero is
-returned and
-.Dv ERANGE
-is stored in 
+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 ,
@@ -109,6 +135,11 @@ Overflow or underflow occurred.
 .Sh STANDARDS
 The
 .Fn strtod
-function
-conforms to
-.St -ansiC .
+function conforms to
+.St -ansiC-89 .
+The
+.Fn strtof
+and
+.Fn strtold
+functions conform to
+.St -ansiC-99 .
diff --git a/src/lib/libc/stdlib/strtod.c b/src/lib/libc/stdlib/strtod.c
deleted file mode 100644
index b13fa128f5..0000000000
--- a/src/lib/libc/stdlib/strtod.c
+++ /dev/null
@@ -1,2499 +0,0 @@
-/****************************************************************
- *
- * 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 KR_headers for old-style C function headers.
- * #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(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$Id: strtod.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \
-    defined(__mips__) || defined(__ns32k__) || defined(__alpha__)
-#include <machine/endian.h>
-#if BYTE_ORDER == BIG_ENDIAN
-#define IEEE_BIG_ENDIAN
-#else
-#define IEEE_LITTLE_ENDIAN
-#endif
-#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
-#ifndef KR_headers
-#include "stdlib.h"
-#include "string.h"
-#include "locale.h"
-#else
-#include "malloc.h"
-#include "memory.h"
-#endif
-#endif
-
-#ifdef MALLOC
-#ifdef KR_headers
-extern char *MALLOC();
-#else
-extern void *MALLOC(size_t);
-#endif
-#else
-#define MALLOC malloc
-#endif
-
-#include "ctype.h"
-#include "errno.h"
-
-#ifdef Bad_float_h
-#undef __STDC__
-#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
-#ifdef KR_headers
-#define CONST /* blank */
-#else
-#define CONST const
-#endif
-#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
-
-#ifdef IEEE_LITTLE_ENDIAN
-#define word0(x) ((ULong *)&x)[1]
-#define word1(x) ((ULong *)&x)[0]
-#else
-#define word0(x) ((ULong *)&x)[0]
-#define word1(x) ((ULong *)&x)[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)
-#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)
-#ifdef KR_headers
-extern double rnd_prod(), rnd_quot();
-#else
-extern double rnd_prod(double, double), rnd_quot(double, double);
-#endif
-#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
-#ifdef KR_headers
-        (k) int k;
-#else
-        (int k)
-#endif
-{
-        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
-#ifdef KR_headers
-        (v) Bigint *v;
-#else
-        (Bigint *v)
-#endif
-{
-        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
-#ifdef KR_headers
-        (b, m, a) Bigint *b; int m, a;
-#else
-        (Bigint *b, int m, int a)       /* multiply by m and add a */
-#endif
-{
-        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
-#ifdef KR_headers
-        (s, nd0, nd, y9) CONST char *s; int nd0, nd; ULong y9;
-#else
-        (CONST char *s, int nd0, int nd, ULong y9)
-#endif
-{
-        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
-#ifdef KR_headers
-        (x) register ULong x;
-#else
-        (register ULong x)
-#endif
-{
-        register 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
-#ifdef KR_headers
-        (y) ULong *y;
-#else
-        (ULong *y)
-#endif
-{
-        register int k;
-        register 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
-#ifdef KR_headers
-        (i) int i;
-#else
-        (int i)
-#endif
-{
-        Bigint *b;
-
-        b = Balloc(1);
-        b->x[0] = i;
-        b->wds = 1;
-        return b;
-        }
-
- static Bigint *
-mult
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
-{
-        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
-#ifdef KR_headers
-        (b, k) Bigint *b; int k;
-#else
-        (Bigint *b, int k)
-#endif
-{
-        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
-#ifdef KR_headers
-        (b, k) Bigint *b; int k;
-#else
-        (Bigint *b, int k)
-#endif
-{
-        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
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
-{
-        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
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
-{
-        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
-#ifdef KR_headers
-        (x) double x;
-#else
-        (double x)
-#endif
-{
-        register Long L;
-        double a;
-
-        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 a;
-        }
-
- static double
-b2d
-#ifdef KR_headers
-        (a, e) Bigint *a; int *e;
-#else
-        (Bigint *a, int *e)
-#endif
-{
-        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 d;
-        }
-
- static Bigint *
-d2b
-#ifdef KR_headers
-        (d, e, bits) double d; int *e, *bits;
-#else
-        (double d, int *e, int *bits)
-#endif
-{
-        Bigint *b;
-        int de, i, k;
-        ULong *x, y, z;
-#ifdef VAX
-        ULong d0, d1;
-        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
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
-{
-        double da, db;
-        int k, ka, kb;
-
-        da = b2d(a, &ka);
-        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 da / 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
-#ifdef KR_headers
-        (s00, se) CONST char *s00; char **se;
-#else
-        (CONST char *s00, char **se)
-#endif
-{
-        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, rv, rv0;
-        Long L;
-        ULong y, z;
-        Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
-
-#ifndef KR_headers
-        CONST char decimal_point = localeconv()->decimal_point[0];
-#else
-        CONST char decimal_point = '.';
-#endif
-
-        sign = nz0 = nz = 0;
-        rv = 0.;
-
-
-        for(s = s00; isspace(*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;
-        rv = y;
-        if (k > 9)
-                rv = tens[k - 9] * 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
-                                /* rv = */ rounded_product(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;
-                                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;
-                                /* rv = */ rounded_product(rv, tens[e]);
-                                if ((word0(rv) & Exp_mask)
-                                 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
-                                        goto ovfl;
-                                word0(rv) += P*Exp_msk1;
-#else
-                                /* rv = */ rounded_product(rv, tens[e]);
-#endif
-                                goto ret;
-                                }
-                        }
-#ifndef Inaccurate_Divide
-                else if (e >= -Ten_pmax) {
-                        /* rv = */ rounded_quotient(rv, tens[-e]);
-                        goto ret;
-                        }
-#endif
-                }
-        e1 += nd - k;
-
-        /* Get starting approximation = rv * 10**e1 */
-
-        if (e1 > 0) {
-                if (i = e1 & 15)
-                        rv *= tens[i];
-                if (e1 &= ~15) {
-                        if (e1 > DBL_MAX_10_EXP) {
- ovfl:
-                                errno = ERANGE;
-#ifdef __STDC__
-                                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)
-                                                rv *= bigtens[j];
-                        /* The last multiplication could overflow. */
-                                word0(rv) -= P*Exp_msk1;
-                                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)
-                        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)
-                                        rv *= tinytens[j];
-                        /* The last multiplication could underflow. */
-                        rv0 = rv;
-                        rv *= tinytens[j];
-                        if (!rv) {
-                                rv = 2.*rv0;
-                                rv *= tinytens[j];
-                                if (!rv) {
- undfl:
-                                        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(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)
-                                rv += ulp(rv);
-#ifndef ROUND_BIASED
-                        else {
-                                rv -= ulp(rv);
-#ifndef Sudden_Underflow
-                                if (!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)) {
-                        rv0 = rv;
-                        word0(rv) -= P*Exp_msk1;
-                        adj = aadj1 * ulp(rv);
-                        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) {
-                                rv0 = rv;
-                                word0(rv) += P*Exp_msk1;
-                                adj = aadj1 * ulp(rv);
-                                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(rv);
-                                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(rv);
-                        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 ? -rv : rv;
-        }
-
- static int
-quorem
-#ifdef KR_headers
-        (b, S) Bigint *b, *S;
-#else
-        (Bigint *b, Bigint *S)
-#endif
-{
-        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
-#ifdef KR_headers
-        (d, mode, ndigits, decpt, sign, rve)
-        double d; int mode, ndigits, *decpt, *sign; char **rve;
-#else
-        (double d, int mode, int ndigits, int *decpt, int *sign, char **rve)
-#endif
-{
- /*     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 d2, ds, eps;
-        char *s, *s0;
-        static Bigint *result;
-        static int result_k;
-
-        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) ? "Infinity" :
-#endif
-                                "NaN";
-                if (rve)
-                        *rve =
-#ifdef IEEE_Arith
-                                s[3] ? s + 8 :
-#endif
-                                                s + 3;
-                return s;
-                }
-#endif
-#ifdef IBM
-        d += 0; /* normalize */
-#endif
-        if (!d) {
-                *decpt = 1;
-                s = "0";
-                if (rve)
-                        *rve = s + 1;
-                return s;
-                }
-
-        b = d2b(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
-                d2 = d;
-                word0(d2) &= Frac_mask1;
-                word0(d2) |= Exp_11;
-#ifdef IBM
-                if (j = 11 - hi0bits(word0(d2) & Frac_mask))
-                        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;
-                d2 = x;
-                word0(d2) -= 31*Exp_msk1; /* adjust exponent */
-                i -= (Bias + (P-1) - 1) + 1;
-                denorm = 1;
-                }
-#endif
-        ds = (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 (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;
-                d2 = 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;
-                                d /= bigtens[n_bigtens-1];
-                                ieps++;
-                                }
-                        for(; j; j >>= 1, i++)
-                                if (j & 1) {
-                                        ieps++;
-                                        ds *= bigtens[i];
-                                        }
-                        d /= ds;
-                        }
-                else if (j1 = -k) {
-                        d *= tens[j1 & 0xf];
-                        for(j = j1 >> 4; j; j >>= 1, i++)
-                                if (j & 1) {
-                                        ieps++;
-                                        d *= bigtens[i];
-                                        }
-                        }
-                if (k_check && d < 1. && ilim > 0) {
-                        if (ilim1 <= 0)
-                                goto fast_failed;
-                        ilim = ilim1;
-                        k--;
-                        d *= 10.;
-                        ieps++;
-                        }
-                eps = ieps*d + 7.;
-                word0(eps) -= (P-1)*Exp_msk1;
-                if (ilim == 0) {
-                        S = mhi = 0;
-                        d -= 5.;
-                        if (d > eps)
-                                goto one_digit;
-                        if (d < -eps)
-                                goto no_digits;
-                        goto fast_failed;
-                        }
-#ifndef No_leftright
-                if (leftright) {
-                        /* Use Steele & White method of only
-                         * generating digits needed.
-                         */
-                        eps = 0.5/tens[ilim-1] - eps;
-                        for(i = 0;;) {
-                                L = d;
-                                d -= L;
-                                *s++ = '0' + (int)L;
-                                if (d < eps)
-                                        goto ret1;
-                                if (1. - d < eps)
-                                        goto bump_up;
-                                if (++i >= ilim)
-                                        break;
-                                eps *= 10.;
-                                d *= 10.;
-                                }
-                        }
-                else {
-#endif
-                        /* Generate ilim digits, then fix them up. */
-                        eps *= tens[ilim-1];
-                        for(i = 1;; i++, d *= 10.) {
-                                L = d;
-                                d -= L;
-                                *s++ = '0' + (int)L;
-                                if (i == ilim) {
-                                        if (d > 0.5 + eps)
-                                                goto bump_up;
-                                        else if (d < 0.5 - eps) {
-                                                while(*--s == '0');
-                                                s++;
-                                                goto ret1;
-                                                }
-                                        break;
-                                        }
-                                }
-#ifndef No_leftright
-                        }
-#endif
- fast_failed:
-                s = s0;
-                d = 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 || d <= 5*ds)
-                                goto no_digits;
-                        goto one_digit;
-                        }
-                for(i = 1;; i++) {
-                        L = d / ds;
-                        d -= L*ds;
-#ifdef Check_FLT_ROUNDS
-                        /* If FLT_ROUNDS == 2, L will usually be high by 1 */
-                        if (d < 0) {
-                                L--;
-                                d += ds;
-                                }
-#endif
-                        *s++ = '0' + (int)L;
-                        if (i == ilim) {
-                                d += d;
-                                if (d > ds || d == ds && L & 1) {
- bump_up:
-                                        while(*--s == '9')
-                                                if (s == s0) {
-                                                        k++;
-                                                        *s = '0';
-                                                        break;
-                                                        }
-                                        ++*s++;
-                                        }
-                                break;
-                                }
-                        if (!(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
index 808ba90165..6f9037a645 100644
--- a/src/lib/libc/stdlib/strtol.3
+++ b/src/lib/libc/stdlib/strtol.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,49 +29,67 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strtol.3      5.4 (Berkeley) 6/25/92
-.\"     $Id: strtol.3,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $
+.\"     $OpenBSD: strtol.3,v 1.22 2011/09/03 23:24:51 jmc Exp $
 .\"
-.Dd June 25, 1992
+.Dd $Mdocdate: September 3 2011 $
 .Dt STRTOL 3
 .Os
 .Sh NAME
-.Nm strtol, strtoq
-.Nd convert string value to a long or quad_t integer
+.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>
+.Fd #include <stdlib.h>
 .Ft long
-.Fn strtol "char *nptr" "char **endptr" "int base"
-
+.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>
+.Fd #include <stdlib.h>
 .Ft quad_t
-.Fn strtoq "char *nptr" "char **endptr" "int base"
+.Fn strtoq "const char *nptr" "char **endptr" "int base"
 .Sh DESCRIPTION
 The
 .Fn strtol
-function
-converts the string in
+function converts the string in
 .Fa nptr
 to a
-.Em long
+.Li long
 value.
 The
-.Fn strtoq
-function
-converts the string in
+.Fn strtoll
+function converts the string in
 .Fa nptr
 to a
-.Em quad_t
+.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 between 2 and 36 inclusive,
-or be the special value 0.
+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 white space
+The string may begin with an arbitrary amount of whitespace
 (as determined by
 .Xr isspace 3 )
 followed by a single optional
@@ -85,25 +99,25 @@ or
 sign.
 If
 .Fa base
-is zero or 16,
-the string may then include a
+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
+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
-.Em long
+.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,
+in either upper or lower case represents 10,
 .Ql B
 represents 11, and so forth, with
 .Ql Z
@@ -111,7 +125,7 @@ representing 35.)
 .Pp
 If
 .Fa endptr
-is non nil,
+is non-null,
 .Fn strtol
 stores the address of the first invalid character in
 .Fa *endptr .
@@ -132,22 +146,93 @@ is
 on return, the entire string was valid.)
 .Sh RETURN VALUES
 The
-.Fn strtol
-function
-returns the result of the conversion,
+.Fn strtol ,
+.Fn strtoll ,
+.Fn strtoimax ,
+and
+.Fn strtoq
+functions return the result of the conversion,
 unless the value would underflow or overflow.
-If an underflow occurs,
-.Fn strtol
-returns
-.Dv LONG_MIN .
-If an overflow occurs,
-.Fn strtol
-returns
-.Dv LONG_MAX .
-In both cases,
+If no conversion could be performed, 0 is returned;
+the global variable
+.Va errno
+is also set to
+.Er EINVAL ,
+though this is not portable across all platforms.
+If overflow or underflow occurs,
 .Va errno
 is set to
-.Er ERANGE .
+.Er ERANGE
+and the function return value is as follows:
+.Bl -column "strtoimaxXX" "INTMAX_MIN" "INTMAX_MAX" -offset indent
+.It Sy Function Ta Sy underflow Ta Sy overflow
+.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
@@ -157,13 +242,23 @@ The given string was out of range; the value converted has been clamped.
 .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
-function
-conforms to
-.St -ansiC .
+.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
index 6f374abd5f..5a244766db 100644
--- a/src/lib/libc/stdlib/strtol.c
+++ b/src/lib/libc/stdlib/strtol.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,14 +28,9 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strtol.c     5.4 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: strtol.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <limits.h>
 #include <ctype.h>
 #include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 
@@ -49,30 +41,30 @@ static char *rcsid = "$Id: strtol.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $"
  * alphabets and digits are each contiguous.
  */
 long
-strtol(nptr, endptr, base)
-        const char *nptr;
-        char **endptr;
-        register int base;
+strtol(const char *nptr, char **endptr, int base)
 {
-        register const char *s = nptr;
-        register unsigned long acc;
-        register int c;
-        register unsigned long cutoff;
-        register int neg = 0, any, cutlim;
+        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 = *s++;
+                c = (unsigned char) *s++;
         } while (isspace(c));
         if (c == '-') {
                 neg = 1;
                 c = *s++;
-        } else if (c == '+')
-                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
         if ((base == 0 || base == 16) &&
             c == '0' && (*s == 'x' || *s == 'X')) {
                 c = s[1];
@@ -99,10 +91,17 @@ strtol(nptr, endptr, base)
          * Set any if any `digits' consumed; make it negative to indicate
          * overflow.
          */
-        cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
-        cutlim = cutoff % (unsigned long)base;
-        cutoff /= (unsigned long)base;
-        for (acc = 0, any = 0;; c = *s++) {
+        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))
@@ -111,19 +110,30 @@ strtol(nptr, endptr, base)
                         break;
                 if (c >= base)
                         break;
-                if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
-                        any = -1;
-                else {
-                        any = 1;
-                        acc *= base;
-                        acc += c;
+                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 (any < 0) {
-                acc = neg ? LONG_MIN : LONG_MAX;
-                errno = ERANGE;
-        } else if (neg)
-                acc = -acc;
         if (endptr != 0)
                 *endptr = (char *) (any ? s - 1 : nptr);
         return (acc);
diff --git a/src/lib/libc/stdlib/strtoq.c b/src/lib/libc/stdlib/strtoll.c
index fc559e9d7f..37379252e3 100644
--- a/src/lib/libc/stdlib/strtoq.c
+++ b/src/lib/libc/stdlib/strtoll.c
@@ -1,3 +1,4 @@
+/* $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,34 +28,26 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strtoq.c    5.1 (Berkeley) 6/26/92";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 
-#include <limits.h>
-#include <errno.h>
 #include <ctype.h>
+#include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 /*
- * Convert a string to a quad integer.
+ * Convert a string to a long long.
  *
  * Ignores `locale' stuff.  Assumes that the upper and lower case
  * alphabets and digits are each contiguous.
  */
-quad_t
-strtoq(nptr, endptr, base)
-        const char *nptr;
-        char **endptr;
-        register int base;
+long long
+strtoll(const char *nptr, char **endptr, int base)
 {
-        register const char *s;
-        register u_quad_t acc;
-        register int c;
-        register u_quad_t qbase, cutoff;
-        register int neg, any, cutlim;
+        const char *s;
+        long long acc, cutoff;
+        int c;
+        int neg, any, cutlim;
 
         /*
          * Skip white space and pick up leading +/- sign if any.
@@ -67,7 +56,7 @@ strtoq(nptr, endptr, base)
          */
         s = nptr;
         do {
-                c = *s++;
+                c = (unsigned char) *s++;
         } while (isspace(c));
         if (c == '-') {
                 neg = 1;
@@ -93,7 +82,7 @@ strtoq(nptr, endptr, base)
          * 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 quads is
+         * 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
@@ -104,11 +93,17 @@ strtoq(nptr, endptr, base)
          * Set any if any `digits' consumed; make it negative to indicate
          * overflow.
          */
-        qbase = (unsigned)base;
-        cutoff = neg ? -(u_quad_t)QUAD_MIN : QUAD_MAX;
-        cutlim = cutoff % qbase;
-        cutoff /= qbase;
-        for (acc = 0, any = 0;; c = *s++) {
+        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))
@@ -117,20 +112,42 @@ strtoq(nptr, endptr, base)
                         break;
                 if (c >= base)
                         break;
-                if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
-                        any = -1;
-                else {
-                        any = 1;
-                        acc *= qbase;
-                        acc += c;
+                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 (any < 0) {
-                acc = neg ? QUAD_MIN : QUAD_MAX;
-                errno = ERANGE;
-        } else if (neg)
-                acc = -acc;
         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..58b4112ac3
--- /dev/null
+++ b/src/lib/libc/stdlib/strtonum.3
@@ -0,0 +1,152 @@
+.\" $OpenBSD: strtonum.3,v 1.14 2007/05/31 19:19:31 jmc 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 $Mdocdate: May 31 2007 $
+.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
index db551b0141..5e86772ef0 100644
--- a/src/lib/libc/stdlib/strtoul.3
+++ b/src/lib/libc/stdlib/strtoul.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,49 +29,70 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strtoul.3     5.4 (Berkeley) 6/25/92
-.\"     $Id: strtoul.3,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+.\"     $OpenBSD: strtoul.3,v 1.20 2010/04/07 18:32:53 jmc Exp $
 .\"
-.Dd June 25, 1992
+.Dd $Mdocdate: April 7 2010 $
 .Dt STRTOUL 3
 .Os
 .Sh NAME
-.Nm strtoul, strtouq
-.Nd convert a string to an unsigned long or uquad_t integer
+.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>
+.Fd #include <stdlib.h>
 .Ft unsigned long
 .Fn strtoul "const char *nptr" "char **endptr" "int base"
-
+.Ft unsigned long long
+.Fn strtoull "const char *nptr" "char **endptr" "int base"
+.Fd #include <inttypes.h>
+.Ft uintmax_t
+.Fn strtoumax "const char *nptr" "char **endptr" "int base"
 .Fd #include <sys/types.h>
-.Fd #include <stdlib.h>
 .Fd #include <limits.h>
+.Fd #include <stdlib.h>
 .Ft u_quad_t
 .Fn strtouq "const char *nptr" "char **endptr" "int base"
 .Sh DESCRIPTION
 The
 .Fn strtoul
-function
-converts the string in
+function converts the string in
 .Fa nptr
 to an
-.Em unsigned long
+.Li unsigned long
 value.
 The
-.Fn strtouq
-function
-converts the string in
+.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
-.Em u_quad_t
+.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 between 2 and 36 inclusive,
-or be the special value 0.
+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 white space
+The string may begin with an arbitrary amount of whitespace
 (as determined by
 .Xr isspace 3 )
 followed by a single optional
@@ -85,26 +102,22 @@ or
 sign.
 If
 .Fa base
-is zero or 16,
-the string may then include a
+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
+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
-.Em unsigned long
-value in the obvious manner,
-stopping at the end of the string
+.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,
+in either upper or lower case represents 10,
 .Ql B
 represents 11, and so forth, with
 .Ql Z
@@ -112,7 +125,7 @@ representing 35.)
 .Pp
 If
 .Fa endptr
-is non nil,
+is non-null,
 .Fn strtoul
 stores the address of the first invalid character in
 .Fa *endptr .
@@ -133,32 +146,100 @@ is
 on return, the entire string was valid.)
 .Sh RETURN VALUES
 The
-.Fn strtoul
-function
-returns either the result of the conversion
-or, if there was a leading minus sign,
+.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;
-in the latter case,
+unless the original (non-negated) value would overflow.
+If overflow occurs,
 .Fn strtoul
 returns
-.Dv ULONG_MAX
-and sets the global variable
+.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
-to
+is set to
 .Er ERANGE .
+If no conversion could be performed, 0 is returned;
+the global variable
+.Va errno
+is also set to
+.Er EINVAL ,
+though this is not portable across all platforms.
+.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
-function
-conforms to
-.St -ansiC .
+.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
index 00f7210fa1..d7dddab778 100644
--- a/src/lib/libc/stdlib/strtoul.c
+++ b/src/lib/libc/stdlib/strtoul.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,14 +28,9 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strtoul.c    5.3 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: strtoul.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <limits.h>
 #include <ctype.h>
 #include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 /*
@@ -48,28 +40,28 @@ static char *rcsid = "$Id: strtoul.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
  * alphabets and digits are each contiguous.
  */
 unsigned long
-strtoul(nptr, endptr, base)
-        const char *nptr;
-        char **endptr;
-        register int base;
+strtoul(const char *nptr, char **endptr, int base)
 {
-        register const char *s = nptr;
-        register unsigned long acc;
-        register int c;
-        register unsigned long cutoff;
-        register int neg = 0, any, cutlim;
+        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 = *s++;
+                c = (unsigned char) *s++;
         } while (isspace(c));
         if (c == '-') {
                 neg = 1;
                 c = *s++;
-        } else if (c == '+')
-                c = *s++;
+        } else {
+                neg = 0;
+                if (c == '+')
+                        c = *s++;
+        }
         if ((base == 0 || base == 16) &&
             c == '0' && (*s == 'x' || *s == 'X')) {
                 c = s[1];
@@ -78,9 +70,10 @@ strtoul(nptr, endptr, base)
         }
         if (base == 0)
                 base = c == '0' ? 8 : 10;
-        cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
-        cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
-        for (acc = 0, any = 0;; c = *s++) {
+
+        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))
@@ -89,18 +82,19 @@ strtoul(nptr, endptr, base)
                         break;
                 if (c >= base)
                         break;
-                if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
+                if (any < 0)
+                        continue;
+                if (acc > cutoff || acc == cutoff && c > cutlim) {
                         any = -1;
-                else {
+                        acc = ULONG_MAX;
+                        errno = ERANGE;
+                } else {
                         any = 1;
-                        acc *= base;
+                        acc *= (unsigned long)base;
                         acc += c;
                 }
         }
-        if (any < 0) {
-                acc = ULONG_MAX;
-                errno = ERANGE;
-        } else if (neg)
+        if (neg && any > 0)
                 acc = -acc;
         if (endptr != 0)
                 *endptr = (char *) (any ? s - 1 : nptr);
diff --git a/src/lib/libc/stdlib/strtouq.c b/src/lib/libc/stdlib/strtoull.c
index cc647d8d28..37859776f9 100644
--- a/src/lib/libc/stdlib/strtouq.c
+++ b/src/lib/libc/stdlib/strtoull.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,41 +28,33 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strtouq.c   5.1 (Berkeley) 6/26/92";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 
-#include <limits.h>
-#include <errno.h>
 #include <ctype.h>
+#include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 /*
- * Convert a string to an unsigned quad integer.
+ * Convert a string to an unsigned long long.
  *
  * Ignores `locale' stuff.  Assumes that the upper and lower case
  * alphabets and digits are each contiguous.
  */
-u_quad_t
-strtouq(nptr, endptr, base)
-        const char *nptr;
-        char **endptr;
-        register int base;
+unsigned long long
+strtoull(const char *nptr, char **endptr, int base)
 {
-        register const char *s = nptr;
-        register u_quad_t acc;
-        register int c;
-        register u_quad_t qbase, cutoff;
-        register int neg, any, cutlim;
+        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 = *s++;
+                c = (unsigned char) *s++;
         } while (isspace(c));
         if (c == '-') {
                 neg = 1;
@@ -83,10 +72,10 @@ strtouq(nptr, endptr, base)
         }
         if (base == 0)
                 base = c == '0' ? 8 : 10;
-        qbase = (unsigned)base;
-        cutoff = (u_quad_t)UQUAD_MAX / qbase;
-        cutlim = (u_quad_t)UQUAD_MAX % qbase;
-        for (acc = 0, any = 0;; c = *s++) {
+
+        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))
@@ -95,20 +84,32 @@ strtouq(nptr, endptr, base)
                         break;
                 if (c >= base)
                         break;
-                if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
+                if (any < 0)
+                        continue;
+                if (acc > cutoff || (acc == cutoff && c > cutlim)) {
                         any = -1;
-                else {
+                        acc = ULLONG_MAX;
+                        errno = ERANGE;
+                } else {
                         any = 1;
-                        acc *= qbase;
+                        acc *= (unsigned long long)base;
                         acc += c;
                 }
         }
-        if (any < 0) {
-                acc = UQUAD_MAX;
-                errno = ERANGE;
-        } else if (neg)
+        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
index 520f51db0a..a49e595bc0 100644
--- a/src/lib/libc/stdlib/system.3
+++ b/src/lib/libc/stdlib/system.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)system.3      6.5 (Berkeley) 6/29/91
-.\"     $Id: system.3,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+.\"     $OpenBSD: system.3,v 1.11 2008/04/04 19:30:41 kurt Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: April 4 2008 $
 .Dt SYSTEM 3
 .Os
 .Sh NAME
@@ -49,8 +44,7 @@
 .Sh DESCRIPTION
 The
 .Fn system
-function
-hands the argument
+function hands the argument
 .Fa string
 to the command interpreter
 .Xr sh 1 .
@@ -64,36 +58,47 @@ and blocking
 .Pp
 If
 .Fa string
-is a
-.Dv NULL
-pointer,
+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 3 .
-.Sh RETURN VALUES 
+returns the termination status of the shell in the format specified by
+.Xr waitpid 2 .
+.Pp
+Note that fork handlers established using
+.Xr pthread_atfork 3
+are not called when a multithreaded program calls
+.Fn system .
+.Sh RETURN VALUES
 If a child process cannot be created, or the termination status of
-the shell cannot be obtained, 
+the shell cannot be obtained,
 .Fn system
-returns -1 and sets
+returns \-1 and sets
 .Va errno
 to indicate the error.
-If execution of the shell fails, 
+If execution of the shell fails,
 .Fn system
-returns the termination status for a program that terminates with a call of 
+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 popen 3 ,
-.Xr waitpid 3 ,
+.Xr waitpid 2 ,
+.Xr popen 3
 .Sh STANDARDS
 The
 .Fn system
-function
-conforms to
-.St -ansiC 
+function conforms to
+.St -ansiC
 and
-.St -1003.2-92 .
+.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
index c2f39325f6..14ddcae8d3 100644
--- a/src/lib/libc/stdlib/system.c
+++ b/src/lib/libc/stdlib/system.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,11 +28,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)system.c     5.10 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: system.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
@@ -46,25 +38,28 @@ static char *rcsid = "$Id: system.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $"
 extern char **environ;
 
 int
-system(command)
-        const char *command;
+system(const char *command)
 {
         pid_t pid;
         sig_t intsave, quitsave;
-        int omask;
+        sigset_t mask, omask;
         int pstat;
-        char *argp[] = {"sh", "-c", (char *) command, NULL};
+        char *argp[] = {"sh", "-c", NULL, NULL};
 
         if (!command)           /* just checking... */
                 return(1);
 
-        omask = sigblock(sigmask(SIGCHLD));
-        switch(pid = vfork()) {
+        argp[2] = (char *)command;
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &mask, &omask);
+        switch (pid = vfork()) {
         case -1:                        /* error */
-                (void)sigsetmask(omask);
+                sigprocmask(SIG_SETMASK, &omask, NULL);
                 return(-1);
         case 0:                         /* child */
-                (void)sigsetmask(omask);
+                sigprocmask(SIG_SETMASK, &omask, NULL);
                 execve(_PATH_BSHELL, argp, environ);
                 _exit(127);
         }
@@ -72,8 +67,8 @@ system(command)
         intsave = signal(SIGINT, SIG_IGN);
         quitsave = signal(SIGQUIT, SIG_IGN);
         pid = waitpid(pid, (int *)&pstat, 0);
-        (void)sigsetmask(omask);
+        sigprocmask(SIG_SETMASK, &omask, NULL);
         (void)signal(SIGINT, intsave);
         (void)signal(SIGQUIT, quitsave);
-        return(pid == -1 ? -1 : pstat);
+        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..0a52822620
--- /dev/null
+++ b/src/lib/libc/stdlib/tsearch.3
@@ -0,0 +1,127 @@
+.\" $OpenBSD: tsearch.3,v 1.16 2007/05/31 19:19:32 jmc 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 $Mdocdate: May 31 2007 $
+.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
index 2b7ce63a63..40713956e5 100644
--- a/src/lib/libc/string/Makefile.inc
+++ b/src/lib/libc/string/Makefile.inc
@@ -1,36 +1,45 @@
-#       from: @(#)Makefile.inc  5.6 (Berkeley) 3/5/91
-#       $Id: Makefile.inc,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+#       $OpenBSD: Makefile.inc,v 1.27 2011/07/09 16:32:11 nicm Exp $
 
 # string sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/string ${.CURDIR}/string
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_CPU}/string ${LIBCSRCDIR}/string
 
-SRCS+=  bm.c memccpy.c strcasecmp.c strcoll.c strdup.c strerror.c \
-        strftime.c strmode.c strsignal.c strtok.c strxfrm.c \
-        __strerror.c __strsignal.c
+SRCS+=  bm.c memccpy.c memrchr.c strcasecmp.c strcasestr.c strcoll.c strdup.c \
+        strerror.c strerror_r.c strlcat.c strmode.c strndup.c strnlen.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 wcsdup.c \
+        timingsafe_bcmp.c wcscasecmp.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()
+#       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 "${.CURDIR}/arch/${MACHINE_ARCH}/string/Makefile.inc"
+.include "${LIBCSRCDIR}/arch/${MACHINE_CPU}/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}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
+
+memmove.go: bcopy.c
+        ${CC} -g -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 memmove.po: bcopy.c
         ${CC} -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
-        @${LD} -X -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 memmove.so: bcopy.c
         ${CC} ${PICFLAG} -DPIC -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
@@ -45,13 +54,18 @@ memmove.so: bcopy.c
 OBJS+=  memcpy.o
 memcpy.o: bcopy.c
         ${CC} -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
-        @${LD} -x -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
+
+memcpy.go: bcopy.c
+        ${CC} -g -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 memcpy.po: bcopy.c
         ${CC} -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
-        @${LD} -X -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 memcpy.so: bcopy.c
         ${CC} ${PICFLAG} -DPIC -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
@@ -64,13 +78,18 @@ memcpy.so: bcopy.c
 OBJS+=  strchr.o
 strchr.o: index.c
         ${CC} -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
-        @${LD} -x -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
+
+strchr.go: index.c
+        ${CC} -g -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 strchr.po: index.c
         ${CC} -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
-        @${LD} -X -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 strchr.so: index.c
         ${CC} ${PICFLAG} -DPIC -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
@@ -82,27 +101,70 @@ strchr.so: index.c
 OBJS+=  strrchr.o
 strrchr.o: rindex.c
         ${CC} -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
-        @${LD} -x -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
+
+strrchr.go: rindex.c
+        ${CC} -g -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 strrchr.po: rindex.c
         ${CC} -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
-        @${LD} -X -r ${.TARGET}
-        @mv a.out ${.TARGET}
+        @${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
+        @mv ${.TARGET}.tmp ${.TARGET}
 
 strrchr.so: rindex.c
         ${CC} ${PICFLAG} -DPIC -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} \
             -o ${.TARGET}
 .endif
 
-MAN+=   bm.3 bcmp.3 bcopy.3 bstring.3 bzero.3 ffs.3 index.3 memccpy.3 memchr.3 \
-        memcmp.3 memcpy.3 memmove.3 memset.3 rindex.3 strcasecmp.3 strcat.3 \
-        strchr.3 strcmp.3 strcoll.3 strcpy.3 strcspn.3 strerror.3 strftime.3 \
+# 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
+        strsignal.3 strspn.3 strstr.3 strtok.3 strxfrm.3 swab.3 strlcpy.3 \
+        wcscasecmp.3 wcscat.3 wcschr.3 wcscmp.3 wcscpy.3 wcscspn.3 wcsdup.3 \
+        wcslcpy.3 wcslen.3 wcspbrk.3 wcsrchr.3 wcsspn.3 wcsstr.3 wcstok.3 \
+        wcswidth.3 wmemchr.3 wmemcmp.3 wmemcpy.3 wmemmove.3 wmemset.3
 
 MLINKS+=bm.3 bm_comp.3 bm.3 bm_exec.3 bm.3 bm_free.3
+MLINKS+=memchr.3 memrchr.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+=strdup.3 strndup.3
+MLINKS+=strlcpy.3 strlcat.3
+MLINKS+=strlen.3 strnlen.3
+MLINKS+=strstr.3 strcasestr.3
+MLINKS+=strtok.3 strtok_r.3
+MLINKS+=strerror.3 strerror_r.3
+MLINKS+=wcscasecmp.3 wcsncasecmp.3
+MLINKS+=wcscat.3 wcsncat.3
+MLINKS+=wcscmp.3 wcsncmp.3
+MLINKS+=wcscpy.3 wcsncpy.3
+MLINKS+=wcslcpy.3 wcslcat.3
+MLINKS+=bcmp.3 timingsafe_bcmp.3
diff --git a/src/lib/libc/string/__strerror.c b/src/lib/libc/string/__strerror.c
deleted file mode 100644
index cd604906db..0000000000
--- a/src/lib/libc/string/__strerror.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strerror.c   5.6 (Berkeley) 5/4/91";*/
-static char *rcsid = "$Id: __strerror.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#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
-
-#include <stdio.h>
-#include <string.h>
-
-/*
- * Since perror() is not allowed to change the contents of strerror()'s
- * static buffer, both functions supply their own buffers to the
- * internal function __strerror().
- */
-
-char *
-__strerror(num, buf)
-        int num;
-        char *buf;
-{
-#define UPREFIX "Unknown error: %u"
-        register unsigned int errnum;
-
-#ifdef NLS
-        nl_catd catd ;
-        catd = catopen("libc", 0);
-#endif
-
-        errnum = num;                           /* convert to unsigned */
-        if (errnum < sys_nerr) {
-#ifdef NLS
-                strcpy(buf, catgets(catd, 1, errnum,
-                    (char *)sys_errlist[errnum])); 
-#else
-                return(sys_errlist[errnum]);
-#endif
-        } else {
-#ifdef NLS
-                sprintf(buf, catgets(catd, 1, 0xffff, UPREFIX), errnum);
-#else
-                sprintf(buf, UPREFIX, errnum);
-#endif
-        }
-
-#ifdef NLS
-        catclose(catd);
-#endif
-
-        return buf;
-}
diff --git a/src/lib/libc/string/bcmp.3 b/src/lib/libc/string/bcmp.3
index 118c55c579..1660b4356b 100644
--- a/src/lib/libc/string/bcmp.3
+++ b/src/lib/libc/string/bcmp.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,24 +27,25 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bcmp.3        5.4 (Berkeley) 4/19/91
-.\"     $Id: bcmp.3,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+.\"     $OpenBSD: bcmp.3,v 1.9 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt BCMP 3
-.Os BSD 4.2
+.Os
 .Sh NAME
-.Nm bcmp
+.Nm bcmp ,
+.Nm timingsafe_bcmp
 .Nd compare byte string
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft int
 .Fn bcmp "const void *b1" "const void *b2" "size_t len"
+.Ft int
+.Fn timingsafe_bcmp "const void *b1" "const void *b2" "size_t len"
 .Sh DESCRIPTION
 The
 .Fn bcmp
-function
-compares byte string
+function compares byte string
 .Fa b1
 against byte string
 .Fa b2 ,
@@ -59,6 +56,20 @@ bytes long.
 Zero-length strings are always identical.
 .Pp
 The strings may overlap.
+.Pp
+The
+.Fn timingsafe_bcmp
+function has the same semantics as
+.Fn bcmp ,
+but its running time is independent of the contents of
+.Fa b1
+and
+.Fa b2 ,
+making it safe to use for comparing secret values such as cryptographic MACs.
+In contrast,
+.Fn bcmp
+returns after finding the first differing byte,
+making it vulnerable to timing attacks.
 .Sh SEE ALSO
 .Xr memcmp 3 ,
 .Xr strcasecmp 3 ,
@@ -66,7 +77,12 @@ The strings may overlap.
 .Xr strcoll 3 ,
 .Xr strxfrm 3
 .Sh HISTORY
-A
+The
 .Fn bcmp
-function first appeared in 
+function first appeared in
 .Bx 4.2 .
+.Pp
+The
+.Fn timingsafe_bcmp
+function first appeared in
+.Ox 4.9 .
diff --git a/src/lib/libc/string/bcmp.c b/src/lib/libc/string/bcmp.c
index 2cc38baee3..fd5c93121e 100644
--- a/src/lib/libc/string/bcmp.c
+++ b/src/lib/libc/string/bcmp.c
@@ -1,3 +1,5 @@
+/*      $OpenBSD: bcmp.c,v 1.9 2008/03/19 03:00:23 ray Exp $    */
+
 /*
  * Copyright (c) 1987 Regents of the University of California.
  * All rights reserved.
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,29 +29,27 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)bcmp.c       5.6 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: bcmp.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * bcmp -- vax cmpc3 instruction
  */
-bcmp(b1, b2, length)
-        const void *b1, *b2;
-        register size_t length;
+int
+bcmp(const void *b1, const void *b2, size_t length)
 {
-        register char *p1, *p2;
+        char *p1, *p2;
 
         if (length == 0)
-                return(0);
+                return (0);
         p1 = (char *)b1;
         p2 = (char *)b2;
         do
                 if (*p1++ != *p2++)
-                        break;
+                        return (1);
         while (--length);
-        return(length);
+        return (0);
 }
diff --git a/src/lib/libc/string/bcopy.3 b/src/lib/libc/string/bcopy.3
index 6db3812caf..3beaf09aca 100644
--- a/src/lib/libc/string/bcopy.3
+++ b/src/lib/libc/string/bcopy.3
@@ -12,11 +12,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -32,15 +28,14 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bcopy.3       5.3 (Berkeley) 4/19/91
-.\"     $Id: bcopy.3,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+.\"     $OpenBSD: bcopy.3,v 1.10 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt BCOPY 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm bcopy
-.Nd copy byte string
+.Nd copy bytes
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft void
@@ -48,14 +43,13 @@
 .Sh DESCRIPTION
 The
 .Fn bcopy
-function
-copies
+function copies
 .Fa len
-bytes from string
+bytes from buffer
 .Fa src
-to string
+to buffer
 .Fa dst .
-The two strings may overlap.
+The two buffers may overlap.
 If
 .Fa len
 is zero, no bytes are copied.
@@ -64,9 +58,10 @@ is zero, no bytes are copied.
 .Xr memcpy 3 ,
 .Xr memmove 3 ,
 .Xr strcpy 3 ,
+.Xr strlcpy 3 ,
 .Xr strncpy 3
 .Sh HISTORY
-A
+The
 .Fn bcopy
-function appeared in 
+function first appeared in
 .Bx 4.2 .
diff --git a/src/lib/libc/string/bcopy.c b/src/lib/libc/string/bcopy.c
index 92feed66ea..4308c6484a 100644
--- a/src/lib/libc/string/bcopy.c
+++ b/src/lib/libc/string/bcopy.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)bcopy.c      5.11 (Berkeley) 6/21/91";*/
-static char *rcsid = "$Id: bcopy.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
@@ -57,23 +49,20 @@ typedef	long word;		/* "word" used for optimal copy speed */
  */
 #ifdef MEMCOPY
 void *
-memcpy(dst0, src0, length)
+memcpy(void *dst0, const void *src0, size_t length)
 #else
 #ifdef MEMMOVE
 void *
-memmove(dst0, src0, length)
+memmove(void *dst0, const void *src0, size_t length)
 #else
 void
-bcopy(src0, dst0, length)
+bcopy(const void *src0, void *dst0, size_t length)
 #endif
 #endif
-        void *dst0;
-        const void *src0;
-        register size_t length;
 {
-        register char *dst = dst0;
-        register const char *src = src0;
-        register size_t t;
+        char *dst = dst0;
+        const char *src = src0;
+        size_t t;
 
         if (length == 0 || dst == src)          /* nothing to do */
                 goto done;
diff --git a/src/lib/libc/string/bm.3 b/src/lib/libc/string/bm.3
index 2264a6a1c4..6c74848ecc 100644
--- a/src/lib/libc/string/bm.3
+++ b/src/lib/libc/string/bm.3
@@ -12,11 +12,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -32,83 +28,93 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bm.3  8.4 (Berkeley) 6/21/94
-.\"     $Id: bm.3,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $
+.\"     $OpenBSD: bm.3,v 1.10 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.TH BM 3
-.SH NAME
-bm_comp, bm_exec, bm_free \- Boyer-Moore string search
-.SH SYNOPSIS
-.ft B
-#include <sys/types.h>
-.br
-#include <bm.h>
-.sp
-bm_pat *
-.br
-bm_comp(u_char *pattern, size_t patlen, u_char freq[256]);
-.sp
-u_char *
-.br
-bm_exec(bm_pat *pdesc, u_char *text, size_t len);
-.sp
-void
-.br
-bm_free(bm_pat *pdesc);
-.SH DESCRIPTION
+.Dd $Mdocdate: July 25 2011 $
+.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
-.I Bm_comp
-evaluates the
-.I patlen
+.Pp
+.Fn bm_comp
+evaluates
+.Fa patlen
 bytes starting at
-.IR pattern ,
+.Fa pattern
 and returns a pointer to a structure describing them.
 The bytes referenced by
-.I pattern
+.Fa pattern
 may be of any value.
-.PP
+.Pp
 The search takes advantage of the frequency distribution of the
 bytes in the text to be searched.
 If specified,
-.I freq
+.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
-.I freq
-is NULL,
+.Ar freq
+is
+.Dv NULL ,
 a system default table is used.
-.PP
-.I Bm_exec
+.Pp
+.Fn bm_exec
 returns a pointer to the leftmost occurrence of the string given to
-.I bm_comp
+.Fn bm_comp
 within
-.IR text ,
-or NULL if none occurs.
+.Ar text ,
+or
+.Dv NULL
+if none occurs.
 The number of bytes in
-.I text
+.Ar text
 must be specified by
-.IR len .
-.PP
+.Ar len .
+.Pp
 Space allocated for the returned description is discarded
 by calling
-.I bm_free
+.Fn bm_free
 with the returned description as an argument.
-.PP
+.Pp
 The asymptotic speed of
-.I bm_exec
+.Fn bm_exec
 is
-.RI O( len / patlen ).
-.PP
-.SH "SEE ALSO"
-.IR regexp (3),
-.IR strstr (3)
-.sp
-.IR "Fast String Searching" ,
-Hume and Sunday,
-Software Practice and Experience,
-Vol. 21, 11 (November 1991) pp. 1221-48.
+.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
+.Sh HISTORY
+The
+.Fn bm_comp ,
+.Fn bm_exec ,
+and
+.Fn bm_free
+functions first appeared in
+.Nx 1.0 .
diff --git a/src/lib/libc/string/bm.c b/src/lib/libc/string/bm.c
index 68eac22ecc..2c4c6ca720 100644
--- a/src/lib/libc/string/bm.c
+++ b/src/lib/libc/string/bm.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: bm.c,v 1.7 2007/09/02 15:19:18 deraadt Exp $ */
 /*-
  * Copyright (c) 1994
  *      The Regents of the University of California.  All rights reserved.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#ifndef lint
-/* from: static char sccsid[] = "@(#)bm.c       8.7 (Berkeley) 6/21/94"; */
-static char *rcsid = "$Id: bm.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Exp $";
-#endif /* not lint */
-
 #include <sys/types.h>
 
 #include <bm.h>
@@ -90,14 +82,11 @@ static u_char const freq_def[256] = {
 };
 
 bm_pat *
-bm_comp(pb, len, freq)
-        u_char const *pb;
-        size_t len;
-        u_char const *freq;
+bm_comp(u_char const *pb, size_t len, u_char const *freq)
 {
-        register u_char const *pe, *p;
-        register size_t *d, r;
-        register int j;
+        u_char const *pe, *p;
+        size_t *d, r;
+        int j;
         int sv_errno;
         bm_pat *pat;
 
@@ -115,7 +104,7 @@ bm_comp(pb, len, freq)
                 goto mem;
         memcpy(pat->pat, pb, pat->patlen);
                                                 /* get skip delta */
-        if ((pat->delta = malloc(256 * sizeof(*d))) == NULL)
+        if ((pat->delta = calloc(256, sizeof(*d))) == NULL)
                 goto mem;
         for (j = 0, d = pat->delta; j < 256; j++)
                 d[j] = pat->patlen;
@@ -147,8 +136,7 @@ mem:	sv_errno = errno;
 }
 
 void
-bm_free(pat)
-        bm_pat *pat;
+bm_free(bm_pat *pat)
 {
         if (pat->pat != NULL)
                 free(pat->pat);
@@ -158,14 +146,11 @@ bm_free(pat)
 }
 
 u_char *
-bm_exec(pat, base, n)
-        bm_pat *pat;
-        u_char *base;
-        size_t n;
+bm_exec(bm_pat *pat, u_char *base, size_t n)
 {
-        register u_char *e, *ep, *p, *q, *s;
-        register size_t *d0, k, md2, n1, ro;
-        register int rc;
+        u_char *e, *ep, *p, *q, *s;
+        size_t *d0, k, md2, n1, ro;
+        int rc;
 
         if (n == 0)
                 return (NULL);
diff --git a/src/lib/libc/string/bstring.3 b/src/lib/libc/string/bstring.3
index 12fcfb0cc1..c44c5386c6 100644
--- a/src/lib/libc/string/bstring.3
+++ b/src/lib/libc/string/bstring.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,22 +27,13 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bstring.3     6.8 (Berkeley) 4/19/91
-.\"     $Id: bstring.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
+.\"     $OpenBSD: bstring.3,v 1.9 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt BSTRING 3
 .Os
 .Sh NAME
-.Nm bcmp ,
-.Nm bcopy ,
-.Nm bzero ,
-.Nm memccpy ,
-.Nm memchr ,
-.Nm memcmp ,
-.Nm memcpy ,
-.Nm memmove,
-.Nm memset
+.Nm bstring
 .Nd byte string operations
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -70,7 +57,7 @@
 .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 null bytes as the routines
+They do not check for terminating NUL bytes as the routines
 listed in
 .Xr string 3
 do.
@@ -97,14 +84,25 @@ and
 conform to
 .St -ansiC .
 .Sh HISTORY
-The functions
-.Fn bzero
-and
-.Fn memccpy
-appeared in
-.Bx 4.3 ;
-the functions
+The
 .Fn bcmp ,
 .Fn bcopy ,
-appeared in
+and
+.Fn bzero
+functions first appeared in
 .Bx 4.2 .
+The
+.Fn memchr ,
+.Fn memcmp ,
+.Fn memccpy ,
+.Fn memcpy ,
+and
+.Fn memset
+functions first appeared in
+.At V
+and were reimplemented for
+.Bx 4.3 Tahoe .
+The
+.Fn memmove
+function first appeared in
+.Bx 4.3 Reno .
diff --git a/src/lib/libc/string/bzero.3 b/src/lib/libc/string/bzero.3
index 4f0141e051..c79470377f 100644
--- a/src/lib/libc/string/bzero.3
+++ b/src/lib/libc/string/bzero.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,12 +27,11 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)bzero.3       5.3 (Berkeley) 4/19/91
-.\"     $Id: bzero.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
+.\"     $OpenBSD: bzero.3,v 1.8 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt BZERO 3
-.Os BSD 4.3
+.Os
 .Sh NAME
 .Nm bzero
 .Nd write zeroes to a byte string
@@ -47,8 +42,7 @@
 .Sh DESCRIPTION
 The
 .Fn bzero
-function
-writes
+function writes
 .Fa len
 zero bytes to the string
 .Fa b .
@@ -61,8 +55,7 @@ does nothing.
 .Xr memset 3 ,
 .Xr swab 3
 .Sh HISTORY
-A
+The
 .Fn bzero
-function
-appeared in 
-.Bx 4.3 .
+function first appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/string/bzero.c b/src/lib/libc/string/bzero.c
index 4865e396ef..4d267d4f40 100644
--- a/src/lib/libc/string/bzero.c
+++ b/src/lib/libc/string/bzero.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,22 +29,19 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)bzero.c      5.7 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: bzero.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * bzero -- vax movc5 instruction
  */
 void
-bzero(b, length)
-        void *b;
-        register size_t length;
+bzero(void *b, size_t length)
 {
-        register char *p;
+        char *p;
 
         for (p = b; length--;)
                 *p++ = '\0';
diff --git a/src/lib/libc/string/ffs.3 b/src/lib/libc/string/ffs.3
index 6464bea2b1..6f150c46c4 100644
--- a/src/lib/libc/string/ffs.3
+++ b/src/lib/libc/string/ffs.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,10 +27,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)ffs.3 5.3 (Berkeley) 4/19/91
-.\"     $Id: ffs.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
+.\"     $OpenBSD: ffs.3,v 1.6 2011/07/25 00:38:52 schwarze Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt FFS 3
 .Os
 .Sh NAME
@@ -47,17 +42,15 @@
 .Sh DESCRIPTION
 The
 .Fn ffs
-function
-finds the first bit set in
+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 right-most
-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 .
+function first appeared in
+.Bx 4.2 .
diff --git a/src/lib/libc/string/ffs.c b/src/lib/libc/string/ffs.c
index 42bc87ddea..7dec1613a8 100644
--- a/src/lib/libc/string/ffs.c
+++ b/src/lib/libc/string/ffs.c
@@ -1,55 +1,44 @@
-/*-
- * 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.
- */
+/*      $OpenBSD: ffs.c,v 1.7 2005/08/08 08:05:37 espie Exp $   */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)ffs.c        5.4 (Berkeley) 5/17/90";*/
-static char *rcsid = "$Id: ffs.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
+/*
+ * 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(mask)
-        register int mask;
+ffs(int mask)
 {
-        register int bit;
+        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;
+        }
 
-        if (mask == 0)
-                return(0);
-        for (bit = 1; !(mask & 1); bit++)
-                mask >>= 1;
-        return(bit);
+        return (bit + t[ r & 0xf ]);
 }
diff --git a/src/lib/libc/string/index.c b/src/lib/libc/string/index.c
index 3d9c05f961..50e9ca35ab 100644
--- a/src/lib/libc/string/index.c
+++ b/src/lib/libc/string/index.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,20 +28,14 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)index.c      5.7 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: index.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 char *
 #ifdef STRCHR
-strchr(p, ch)
+strchr(const char *p, int ch)
 #else
-index(p, ch)
+index(const char *p, int ch)
 #endif
-        register const char *p, ch;
 {
         for (;; ++p) {
                 if (*p == ch)
diff --git a/src/lib/libc/string/memccpy.3 b/src/lib/libc/string/memccpy.3
index 61df704028..f8f880e3b1 100644
--- a/src/lib/libc/string/memccpy.3
+++ b/src/lib/libc/string/memccpy.3
@@ -1,5 +1,7 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\"     $OpenBSD: memccpy.3,v 1.10 2011/07/25 00:38:52 schwarze 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
@@ -9,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,14 +27,14 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memccpy.3     5.4 (Berkeley) 4/19/91
-.\"     $Id: memccpy.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
+.\"     @(#)memccpy.3   8.1 (Berkeley) 6/9/93
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMCCPY 3
 .Os
 .Sh NAME
 .Nm memccpy
+.Nd copy string until character found
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft void *
@@ -44,14 +42,15 @@
 .Sh DESCRIPTION
 The
 .Fn memccpy
-function
-copies bytes from string
+function copies bytes from string
 .Fa src
 to string
 .Fa dst .
 If the character
 .Fa c
-(as converted to an unsigned char) occurs in the string
+(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
@@ -60,14 +59,17 @@ in the string
 is returned.
 Otherwise,
 .Fa len
-bytes are copied, and a NULL pointer is returned.
+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 strcpy 3 ,
+.Xr strlcpy 3
 .Sh HISTORY
 The
 .Fn memccpy
-function is
-.Ud .
+function first appeared in
+.At V
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/memccpy.c b/src/lib/libc/string/memccpy.c
index 3a1d7bcca1..485c55fcab 100644
--- a/src/lib/libc/string/memccpy.c
+++ b/src/lib/libc/string/memccpy.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: memccpy.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.
+ * 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
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,25 +29,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)memccpy.c    5.8 (Berkeley) 5/30/91";*/
-static char *rcsid = "$Id: memccpy.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 void *
-memccpy(t, f, c, n)
-        void *t;
-        const void *f;
-        int c;
-        register size_t n;
+memccpy(void *t, const void *f, int c, size_t n)
 {
 
         if (n) {
-                register unsigned char *tp = t;
-                register const unsigned char *fp = f;
-                register unsigned char uc = c;
+                unsigned char *tp = t;
+                const unsigned char *fp = f;
+                unsigned char uc = c;
                 do {
                         if ((*tp++ = *fp++) == uc)
                                 return (tp);
diff --git a/src/lib/libc/string/memchr.3 b/src/lib/libc/string/memchr.3
index 265711e3b5..56a4e4780e 100644
--- a/src/lib/libc/string/memchr.3
+++ b/src/lib/libc/string/memchr.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: memchr.3,v 1.10 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memchr.3      5.4 (Berkeley) 6/29/91
-.\"     $Id: memchr.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMCHR 3
 .Os
 .Sh NAME
@@ -46,26 +41,37 @@
 .Fd #include <string.h>
 .Ft void *
 .Fn memchr "const void *b" "int c" "size_t len"
+.Ft void *
+.Fn memrchr "const void *b" "int c" "size_t len"
 .Sh DESCRIPTION
 The
 .Fn memchr
-function
-locates the first occurrence of
+function locates the first occurrence of
+.Fa c
+(converted to an
+.Li unsigned char )
+in string
+.Fa b .
+.Pp
+The
+.Fn memrchr
+function behaves like
+.Fn memchr ,
+except that it locates the last occurrence of
 .Fa c
-(converted to an unsigned char)
 in string
 .Fa b .
 .Sh RETURN VALUES
 The
 .Fn memchr
-function
-returns a pointer to the byte located,
-or NULL if no such byte exists within
+and
+.Fn memrchr
+functions return a pointer to the byte located, or
+.Dv NULL
+if no such byte exists within
 .Fa len
 bytes.
 .Sh SEE ALSO
-.Xr index 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
@@ -73,10 +79,23 @@ bytes.
 .Xr strsep 3 ,
 .Xr strspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wmemchr 3
 .Sh STANDARDS
 The
 .Fn memchr
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Pp
+The
+.Fn memrchr
+function is an
+.Ox
+extension.
+.Sh HISTORY
+The
+.Fn memchr
+function first appeared in
+.At V
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/memchr.c b/src/lib/libc/string/memchr.c
index 61652c6bb1..4573e3ceb1 100644
--- a/src/lib/libc/string/memchr.c
+++ b/src/lib/libc/string/memchr.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,24 +31,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)memchr.c     5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: memchr.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 void *
-memchr(s, c, n)
-        const void *s;
-        register unsigned char c;
-        register size_t n;
+memchr(const void *s, int c, size_t n)
 {
         if (n != 0) {
-                register const unsigned char *p = s;
+                const unsigned char *p = s;
 
                 do {
-                        if (*p++ == c)
+                        if (*p++ == (unsigned char)c)
                                 return ((void *)(p - 1));
                 } while (--n != 0);
         }
diff --git a/src/lib/libc/string/memcmp.3 b/src/lib/libc/string/memcmp.3
index 13901c1009..951a04ed8a 100644
--- a/src/lib/libc/string/memcmp.3
+++ b/src/lib/libc/string/memcmp.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: memcmp.3,v 1.7 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memcmp.3      5.5 (Berkeley) 6/29/91
-.\"     $Id: memcmp.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMCMP 3
 .Os
 .Sh NAME
@@ -49,8 +44,7 @@
 .Sh DESCRIPTION
 The
 .Fn memcmp
-function
-compares byte string
+function compares byte string
 .Fa b1
 against byte string
 .Fa b2 .
@@ -60,10 +54,11 @@ bytes long.
 .Sh RETURN VALUES
 The
 .Fn memcmp
-function
-returns zero if the the two strings are identical,
+function returns zero if the two strings are identical,
 otherwise returns the difference between the first two differing bytes
-(treated as unsigned char values, so that
+(treated as
+.Li unsigned char
+values, so that
 .Sq Li \e200
 is greater than
 .Sq Li \&\e0 ,
@@ -74,10 +69,17 @@ Zero-length strings are always identical.
 .Xr strcasecmp 3 ,
 .Xr strcmp 3 ,
 .Xr strcoll 3 ,
-.Xr strxfrm 3
+.Xr strxfrm 3 ,
+.Xr wmemcmp 3
 .Sh STANDARDS
 The
 .Fn memcmp
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn memcmp
+function first appeared in
+.At V
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/memcmp.c b/src/lib/libc/string/memcmp.c
index 23d2ab2393..49384a6fb9 100644
--- a/src/lib/libc/string/memcmp.c
+++ b/src/lib/libc/string/memcmp.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,23 +31,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)memcmp.c     5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: memcmp.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Compare memory regions.
  */
 int
-memcmp(s1, s2, n)
-        const void *s1, *s2;
-        size_t n;
+memcmp(const void *s1, const void *s2, size_t n)
 {
         if (n != 0) {
-                register const unsigned char *p1 = s1, *p2 = s2;
+                const unsigned char *p1 = s1, *p2 = s2;
 
                 do {
                         if (*p1++ != *p2++)
diff --git a/src/lib/libc/string/memcpy.3 b/src/lib/libc/string/memcpy.3
index 3f4bb643c9..e95d670ad9 100644
--- a/src/lib/libc/string/memcpy.3
+++ b/src/lib/libc/string/memcpy.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: memcpy.3,v 1.8 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,15 +31,12 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memcpy.3      5.5 (Berkeley) 6/29/91
-.\"     $Id: memcpy.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMCPY 3
 .Os
 .Sh NAME
 .Nm memcpy
-.Nd copy byte string
+.Nd copy bytes
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft void *
@@ -49,36 +44,42 @@
 .Sh DESCRIPTION
 The
 .Fn memcpy
-function
-copies
+function copies
 .Fa len
-bytes from string
+bytes from buffer
 .Fa src
-to string
+to buffer
 .Fa dst .
 .Sh RETURN VALUES
 The
 .Fn memcpy
-function
-returns the original value of
+function returns the original value of
 .Fa dst .
 .Sh SEE ALSO
 .Xr bcopy 3 ,
 .Xr memccpy 3 ,
 .Xr memmove 3 ,
-.Xr strcpy 3
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr wmemcpy 3
 .Sh STANDARDS
 The
 .Fn memcpy
-function
-conforms to
+function conforms to
 .St -ansiC .
-.Sh BUGS
+.Sh HISTORY
+The
+.Fn memcpy
+function first appeared in
+.At V
+and was reimplemented for
+.Bx 4.3 Tahoe .
+.Sh CAVEATS
 In this implementation
 .Fn memcpy
 is implemented using
 .Xr bcopy 3 ,
-and therefore the strings may overlap.
-On other systems, copying overlapping strings may produce surprises.
-A simpler solution is to not use
-.Fn memcpy .
+and therefore the buffers may overlap.
+On other systems, copying overlapping buffers may produce surprises.
+A portable, safe solution is to use
+.Xr memmove 3 .
diff --git a/src/lib/libc/string/memmove.3 b/src/lib/libc/string/memmove.3
index 24422e7971..ae8569a1c7 100644
--- a/src/lib/libc/string/memmove.3
+++ b/src/lib/libc/string/memmove.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: memmove.3,v 1.8 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,15 +31,12 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memmove.3     5.5 (Berkeley) 6/29/91
-.\"     $Id: memmove.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMMOVE 3
 .Os
 .Sh NAME
 .Nm memmove
-.Nd copy byte string
+.Nd copy bytes
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft void *
@@ -49,14 +44,13 @@
 .Sh DESCRIPTION
 The
 .Fn memmove
-function
-copies
+function copies
 .Fa len
-bytes from string
+bytes from buffer
 .Fa src
-to string
+to buffer
 .Fa dst .
-The two strings may overlap;
+The two buffers may overlap;
 the copy is always done in a non-destructive manner.
 .Sh RETURN VALUES
 The
@@ -67,10 +61,16 @@ function returns the original value of
 .Xr bcopy 3 ,
 .Xr memccpy 3 ,
 .Xr memcpy 3 ,
-.Xr strcpy 3
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr wmemmove 3
 .Sh STANDARDS
 The
 .Fn memmove
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn memmove
+function first appeared in
+.Bx 4.3 Reno .
diff --git a/src/lib/libc/string/memrchr.c b/src/lib/libc/string/memrchr.c
new file mode 100644
index 0000000000..bd27ebc620
--- /dev/null
+++ b/src/lib/libc/string/memrchr.c
@@ -0,0 +1,38 @@
+/*      $OpenBSD: memrchr.c,v 1.2 2007/11/27 16:22:12 martynas Exp $    */
+
+/*
+ * Copyright (c) 2007 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 <string.h>
+
+/*
+ * Reverse memchr()
+ * Find the last occurrence of 'c' in the buffer 's' of size 'n'.
+ */
+void *
+memrchr(const void *s, int c, size_t n)
+{
+        const unsigned char *cp;
+
+        if (n != 0) {
+                cp = (unsigned char *)s + n;
+                do {
+                        if (*(--cp) == (unsigned char)c)
+                                return((void *)cp);
+                } while (--n != 0);
+        }
+        return(NULL);
+}
diff --git a/src/lib/libc/string/memset.3 b/src/lib/libc/string/memset.3
index 1afc052182..db94cb9ba6 100644
--- a/src/lib/libc/string/memset.3
+++ b/src/lib/libc/string/memset.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: memset.3,v 1.7 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)memset.3      5.4 (Berkeley) 6/29/91
-.\"     $Id: memset.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt MEMSET 3
 .Os
 .Sh NAME
@@ -49,19 +44,32 @@
 .Sh DESCRIPTION
 The
 .Fn memset
-function
-writes
+function writes
 .Fa len
 bytes of value
 .Fa c
-(converted to an unsigned char) to the string
+(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
+.Xr swab 3 ,
+.Xr wmemset 3
 .Sh STANDARDS
 The
 .Fn memset
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn memset
+function first appeared in
+.At V
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/memset.c b/src/lib/libc/string/memset.c
index 117de2e80b..61709c139d 100644
--- a/src/lib/libc/string/memset.c
+++ b/src/lib/libc/string/memset.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: memset.c,v 1.6 2008/03/15 21:40:39 ray Exp $ */
 /*-
  * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,25 +31,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)memset.c     5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: memset.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 void *
-memset(dst, c, n)
-        void *dst;
-        register int c;
-        register size_t n;
+memset(void *dst, int c, size_t n)
 {
-
         if (n != 0) {
-                register char *d = dst;
+                unsigned char *d = dst;
 
                 do
-                        *d++ = c;
+                        *d++ = (unsigned char)c;
                 while (--n != 0);
         }
         return (dst);
diff --git a/src/lib/libc/string/rindex.c b/src/lib/libc/string/rindex.c
index 1b84c92072..bf9d6f7cf1 100644
--- a/src/lib/libc/string/rindex.c
+++ b/src/lib/libc/string/rindex.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,22 +28,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)rindex.c     5.9 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: rindex.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 char *
 #ifdef STRRCHR
-strrchr(p, ch)
+strrchr(const char *p, int ch)
 #else
-rindex(p, ch)
+rindex(const char *p, int ch)
 #endif
-        register const char *p, ch;
 {
-        register char *save;
+        char *save;
 
         for (save = NULL;; ++p) {
                 if (*p == ch)
diff --git a/src/lib/libc/string/strcasecmp.3 b/src/lib/libc/string/strcasecmp.3
index 46e9010e4f..0900c8a97a 100644
--- a/src/lib/libc/string/strcasecmp.3
+++ b/src/lib/libc/string/strcasecmp.3
@@ -1,5 +1,7 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\"     $OpenBSD: strcasecmp.3,v 1.11 2011/07/25 00:38:52 schwarze 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.
@@ -11,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,14 +29,14 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcasecmp.3  5.4 (Berkeley) 4/19/91
-.\"     $Id: strcasecmp.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
+.\"     @(#)strcasecmp.3        8.1 (Berkeley) 6/9/93
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCASECMP 3
 .Os
 .Sh NAME
-.Nm strcasecmp
+.Nm strcasecmp ,
+.Nm strncasecmp
 .Nd compare strings, ignoring case
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -51,13 +49,12 @@ The
 .Fn strcasecmp
 and
 .Fn strncasecmp
-functions
-compare the null-terminated strings
+functions compare the NUL-terminated strings
 .Fa s1
 and
 .Fa s2
 and return an integer greater than, equal to, or less than 0,
-according as
+according to whether
 .Fa s1
 is lexicographically greater than, equal to, or less than
 .Fa s2
@@ -68,7 +65,6 @@ The comparison is done using unsigned characters, so that
 is greater than
 .Ql \e0 .
 .Pp
-The
 .Fn strncasecmp
 compares at most
 .Fa len
@@ -78,11 +74,19 @@ characters.
 .Xr memcmp 3 ,
 .Xr strcmp 3 ,
 .Xr strcoll 3 ,
-.Xr strxfrm 3
+.Xr strxfrm 3 ,
+.Xr wcscasecmp 3
+.Sh STANDARDS
+The
+.Fn strcasecmp
+and
+.Fn strncasecmp
+functions conform to
+.St -p1003.1-2008 .
 .Sh HISTORY
 The
 .Fn strcasecmp
 and
 .Fn strncasecmp
-functions are
-.Ud .
+functions first appeared in
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strcasecmp.c b/src/lib/libc/string/strcasecmp.c
index 79bd0081e3..2be09136c0 100644
--- a/src/lib/libc/string/strcasecmp.c
+++ b/src/lib/libc/string/strcasecmp.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strcasecmp.c,v 1.6 2005/08/08 08:05:37 espie Exp $    */
+
 /*
- * Copyright (c) 1987 Regents of the University of California.
- * All rights reserved.
+ * 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
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,11 +29,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static const char sccsid[] = "from: @(#)strcasecmp.c  5.10 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strcasecmp.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 typedef unsigned char u_char;
@@ -81,12 +74,11 @@ static const u_char charmap[] = {
 };
 
 int
-strcasecmp(s1, s2)
-        const char *s1, *s2;
+strcasecmp(const char *s1, const char *s2)
 {
-        register const u_char *cm = charmap,
-                        *us1 = (const u_char *)s1,
-                        *us2 = (const u_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')
@@ -95,14 +87,12 @@ strcasecmp(s1, s2)
 }
 
 int
-strncasecmp(s1, s2, n)
-        const char *s1, *s2;
-        register size_t n;
+strncasecmp(const char *s1, const char *s2, size_t n)
 {
         if (n != 0) {
-                register const u_char *cm = charmap,
-                                *us1 = (const u_char *)s1,
-                                *us2 = (const u_char *)s2;
+                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++])
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
index 5357d65754..81aae19a63 100644
--- a/src/lib/libc/string/strcat.3
+++ b/src/lib/libc/string/strcat.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strcat.3,v 1.13 2011/07/25 00:38:52 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,14 +31,12 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcat.3      5.6 (Berkeley) 6/29/91
-.\"     $Id: strcat.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCAT 3
 .Os
 .Sh NAME
-.Nm strcat
+.Nm strcat ,
+.Nm strncat
 .Nd concatenate strings
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -53,10 +49,9 @@ The
 .Fn strcat
 and
 .Fn strncat
-functions
-append a copy of the null-terminated string
+functions append a copy of the NUL-terminated string
 .Fa append
-to the end of the null-terminated string
+to the end of the NUL-terminated string
 .Fa s ,
 then add a terminating
 .Ql \e0 .
@@ -66,29 +61,81 @@ must have sufficient space to hold the result.
 .Pp
 The
 .Fn strncat
-function
-appends not more than
+function appends not more than
 .Fa count
-characters.
+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
+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 strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr wcscat 3 ,
+.Xr wcslcpy 3
 .Sh STANDARDS
 The
 .Fn strcat
 and
 .Fn strncat
-functions
-conform to
+functions conform to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strcat
+and
+.Fn strncat
+functions first appeared in
+.At v7 .
diff --git a/src/lib/libc/string/strcat.c b/src/lib/libc/string/strcat.c
index e741b84f03..7cea5229fb 100644
--- a/src/lib/libc/string/strcat.c
+++ b/src/lib/libc/string/strcat.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,21 +29,23 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strcat.c     5.6 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: strcat.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#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(s, append)
-        register char *s;
-        register const char *append;
+strcat(char *s, const char *append)
 {
         char *save = s;
 
         for (; *s; ++s);
-        while (*s++ = *append++);
+        while ((*s++ = *append++) != '\0');
         return(save);
 }
diff --git a/src/lib/libc/string/strchr.3 b/src/lib/libc/string/strchr.3
index 18b50301f3..d3194dffab 100644
--- a/src/lib/libc/string/strchr.3
+++ b/src/lib/libc/string/strchr.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strchr.3,v 1.10 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,29 +31,27 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strchr.3      5.4 (Berkeley) 6/29/91
-.\"     $Id: strchr.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCHR 3
 .Os
 .Sh NAME
-.Nm strchr
-.Nd locate character in string
+.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
-.Ar c
-in the string pointed to by
-.Ar s .
-The terminating
-.Dv NULL
-character is considered part of the string.
+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
@@ -63,26 +59,56 @@ is
 .Fn strchr
 locates the terminating
 .Ql \e0 .
+.Pp
+The
+.Fn index
+function is an old synonym for
+.Fn strchr .
 .Sh RETURN VALUES
-The function
+The
 .Fn strchr
-returns a pointer to the located character, or
+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 index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcschr 3
 .Sh STANDARDS
 The
 .Fn strchr
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Pp
+The
+.Fn index
+function is deprecated and shouldn't be used in new code.
+.Sh HISTORY
+The
+.Fn index
+function first appeared in
+.At v7 .
+The
+.Fn strchr
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strcmp.3 b/src/lib/libc/string/strcmp.3
index fecaa85410..5b0794208a 100644
--- a/src/lib/libc/string/strcmp.3
+++ b/src/lib/libc/string/strcmp.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strcmp.3,v 1.12 2011/07/25 07:51:30 jmc Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,14 +31,12 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcmp.3      5.6 (Berkeley) 6/29/91
-.\"     $Id: strcmp.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCMP 3
 .Os
 .Sh NAME
-.Nm strcmp
+.Nm strcmp ,
+.Nm strncmp
 .Nd compare strings
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -53,18 +49,22 @@ The
 .Fn strcmp
 and
 .Fn strncmp
-functions
-lexicographically compare the null-terminated strings
+functions lexicographically compare the NUL-terminated strings
 .Fa s1
 and
 .Fa s2 .
+The
+.Fn strncmp
+function compares at most
+.Fa len
+characters.
 .Sh RETURN VALUES
 The
 .Fn strcmp
 and
 .Fn strncmp
-return an integer greater than, equal to, or less than 0, according
-as the string
+functions 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 .
@@ -72,23 +72,24 @@ The comparison is done using unsigned characters, so that
 .Ql \e200
 is greater than
 .Ql \e0 .
-.Pp
-The
-.Fn strncmp
-compares not more than
-.Fa len
-characters.
 .Sh SEE ALSO
 .Xr bcmp 3 ,
 .Xr memcmp 3 ,
 .Xr strcasecmp 3 ,
 .Xr strcoll 3 ,
-.Xr strxfrm 3
+.Xr strxfrm 3 ,
+.Xr wcscmp 3
 .Sh STANDARDS
 The
 .Fn strcmp
 and
 .Fn strncmp
-functions
-conform to
+functions conform to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strcmp
+and
+.Fn strncmp
+functions first appeared in
+.At v7 .
diff --git a/src/lib/libc/string/strcmp.c b/src/lib/libc/string/strcmp.c
index ae19e2e26e..816fd111ac 100644
--- a/src/lib/libc/string/strcmp.c
+++ b/src/lib/libc/string/strcmp.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -13,11 +15,7 @@
  * 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
+ * 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.
  *
@@ -34,19 +32,17 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strcmp.c     5.5 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strcmp.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * Compare strings.
  */
 int
-strcmp(s1, s2)
-        register const char *s1, *s2;
+strcmp(const char *s1, const char *s2)
 {
         while (*s1 == *s2++)
                 if (*s1++ == 0)
diff --git a/src/lib/libc/string/strcoll.3 b/src/lib/libc/string/strcoll.3
index 12f73f98f2..72e398c44c 100644
--- a/src/lib/libc/string/strcoll.3
+++ b/src/lib/libc/string/strcoll.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcoll.3     5.6 (Berkeley) 6/29/91
-.\"     $Id: strcoll.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
+.\"     $OpenBSD: strcoll.3,v 1.8 2011/07/25 00:38:53 schwarze Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCOLL 3
 .Os
 .Sh NAME
@@ -49,14 +44,13 @@
 .Sh DESCRIPTION
 The
 .Fn strcoll
-function
-lexicographically compares the null-terminated strings
+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 as
+according to whether
 .Fa s1
 is greater than, equal to, or less than
 .Fa s2 .
@@ -70,6 +64,10 @@ is greater than, equal to, or less than
 .Sh STANDARDS
 The
 .Fn strcoll
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strcoll
+function first appeared in
+.Bx 4.3 Reno .
diff --git a/src/lib/libc/string/strcoll.c b/src/lib/libc/string/strcoll.c
index 86c742cba9..2df983bd65 100644
--- a/src/lib/libc/string/strcoll.c
+++ b/src/lib/libc/string/strcoll.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,19 +31,13 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strcoll.c    5.2 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strcoll.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Compare strings according to LC_COLLATE category of current locale.
  */
 int
-strcoll(s1, s2)
-        const char *s1, *s2;
+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
index 1ca12c2707..400eeee622 100644
--- a/src/lib/libc/string/strcpy.3
+++ b/src/lib/libc/string/strcpy.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strcpy.3,v 1.16 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,14 +31,12 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcpy.3      5.4 (Berkeley) 6/29/91
-.\"     $Id: strcpy.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCPY 3
-.Os BSD 4
+.Os
 .Sh NAME
-.Nm strcpy
+.Nm strcpy ,
+.Nm strncpy
 .Nd copy strings
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -53,8 +49,7 @@ The
 .Fn strcpy
 and
 .Fn strncpy
-functions
-copy the string
+functions copy the string
 .Fa src
 to
 .Fa dst
@@ -64,7 +59,7 @@ character).
 .Pp
 The
 .Fn strncpy
-copies not more than
+function copies not more than
 .Fa len
 characters into
 .Fa dst ,
@@ -78,45 +73,90 @@ characters long, and
 .Em not
 terminating
 .Fa dst
-if
+if the length of
 .Fa src
-is more than
-.Fa len
-characters long.
+is greater than or equal to
+.Fa len .
 .Sh RETURN VALUES
 The
 .Fn strcpy
 and
 .Fn strncpy
-functions
-return
+functions return
 .Fa dst .
 .Sh EXAMPLES
 The following sets
-.Dq Li chararray
+.Va chararray
 to
-.Dq Li abc\e0\e0\e0 :
+.Dq abc\e0\e0\e0 :
 .Bd -literal -offset indent
-(void)strncpy(chararray, "abc", 6).
+(void)strncpy(chararray, "abc", 6);
 .Ed
 .Pp
 The following sets
-.Dq Li chararray
+.Va chararray
 to
-.Dq Li abcdef :
+.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 memmove 3 ,
+.Xr strcat 3 ,
+.Xr strlcpy 3 ,
+.Xr wcscpy 3 ,
+.Xr wcslcpy 3
 .Sh STANDARDS
 The
 .Fn strcpy
 and
 .Fn strncpy
-functions
-conform to
+functions conform to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strcpy
+and
+.Fn strncpy
+functions first appeared in
+.At v7 .
diff --git a/src/lib/libc/string/strcpy.c b/src/lib/libc/string/strcpy.c
index 669bfde23e..71d90d4100 100644
--- a/src/lib/libc/string/strcpy.c
+++ b/src/lib/libc/string/strcpy.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,20 +29,22 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strcpy.c     5.7 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: strcpy.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#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(to, from)
-        register char *to;
-        register const char *from;
+strcpy(char *to, const char *from)
 {
         char *save = to;
 
-        for (; *to = *from; ++from, ++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
index cc9e5c2fe3..70c8ef7612 100644
--- a/src/lib/libc/string/strcspn.3
+++ b/src/lib/libc/string/strcspn.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strcspn.3,v 1.10 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strcspn.3     5.3 (Berkeley) 6/29/91
-.\"     $Id: strcspn.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRCSPN 3
 .Os
 .Sh NAME
@@ -49,37 +44,65 @@
 .Sh DESCRIPTION
 The
 .Fn strcspn
-function
-spans the initial part of the null-terminated string
+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
+(it spans the
 .Em complement
 of
 .Fa charset ) .
 .Sh RETURN VALUES
 The
 .Fn strcspn
-function
-returns the number of characters spanned.
+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
+.Pp
+The following removes the first (if any) newline character from string
+.Fa line .
+This is useful for trimming the newline after a
+.Xr fgets 3
+call.
+.Bd -literal -offset indent
+char line[BUFSIZ];
+
+if (fgets(line, sizeof(line), fp) != NULL)
+        line[strcspn(line, "\en")] = '\e0';
+.Ed
 .Sh SEE ALSO
-.Xr index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcscspn 3
 .Sh STANDARDS
 The
 .Fn strcspn
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strcspn
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strcspn.c b/src/lib/libc/string/strcspn.c
index acb4d2a3af..1eb233614d 100644
--- a/src/lib/libc/string/strcspn.c
+++ b/src/lib/libc/string/strcspn.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,23 +31,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strcspn.c    5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strcspn.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Span the complement of string s2.
  */
 size_t
-strcspn(s1, s2)
-        const char *s1;
-        register const char *s2;
+strcspn(const char *s1, const char *s2)
 {
-        register const char *p, *spanp;
-        register char c, sc;
+        const char *p, *spanp;
+        char c, sc;
 
         /*
          * Stop as soon as we find any character from s2.  Note that there
diff --git a/src/lib/libc/string/strdup.3 b/src/lib/libc/string/strdup.3
index 925cbf3d46..02d5666a9c 100644
--- a/src/lib/libc/string/strdup.3
+++ b/src/lib/libc/string/strdup.3
@@ -1,5 +1,7 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\"     $OpenBSD: strdup.3,v 1.18 2011/07/25 00:38:53 schwarze 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
@@ -9,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,37 +27,84 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strdup.3      5.3 (Berkeley) 4/19/91
-.\"     $Id: strdup.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
+.\"     @(#)strdup.3    8.1 (Berkeley) 6/9/93
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRDUP 3
 .Os
 .Sh NAME
-.Nm strdup
+.Nm strdup ,
+.Nm strndup
 .Nd save a copy of a string
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft char *
-.Fn strdup "const char *str"
+.Fn strdup "const char *s"
+.Ft char *
+.Fn strndup "const char *s" "size_t maxlen"
 .Sh DESCRIPTION
 The
 .Fn strdup
-function
-allocates sufficient memory for a copy
-of the string
-.Fa str ,
+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
+The pointer may subsequently be used as an argument to the function
 .Xr free 3 .
+.Pp
+The
+.Fn strndup
+function behaves similarly to
+.Nm strdup
+but only copies up to
+.Fa maxlen
+characters from
+.Fa s .
+The resulting string is always NUL-terminated.
+.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;
+
+p = strdup("foobar");
+if (p == NULL)
+        err(1, NULL);
+.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 ,
-.Xt strcpy 3 ,
-.Xt strlen 3
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr strlen 3 ,
+.Xr wcsdup 3
+.Sh STANDARDS
+The
+.Fn strdup
+and
+.Fn strndup
+functions conform to
+.St -p1003.1-2008 .
 .Sh HISTORY
 The
 .Fn strdup
-function
-.Ud .
+function first appeared in
+.Bx 4.3 Reno .
+The
+.Fn strndup
+function appeared in glibc 2.0, was reimplemented for
+.Nx 4.0 ,
+and ported to
+.Ox 4.8 .
diff --git a/src/lib/libc/string/strdup.c b/src/lib/libc/string/strdup.c
index 27ede44110..a6aa1e03b0 100644
--- a/src/lib/libc/string/strdup.c
+++ b/src/lib/libc/string/strdup.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strdup.c,v 1.6 2005/08/08 08:05:37 espie Exp $        */
+
 /*
- * Copyright (c) 1988 The Regents of the University of California.
- * All rights reserved.
+ * 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
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,24 +29,21 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strdup.c     5.4 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: strdup.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
+#include <sys/types.h>
 
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
 char *
-strdup(str)
-        const char *str;
+strdup(const char *str)
 {
-        size_t len;
+        size_t siz;
         char *copy;
 
-        len = strlen(str) + 1;
-        if (!(copy = malloc(len)))
-                return((char *)NULL);
-        memcpy(copy, str, len);
+        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
index c9d8504dbb..f3f80432c3 100644
--- a/src/lib/libc/string/strerror.3
+++ b/src/lib/libc/string/strerror.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,12 +29,11 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strerror.3    6.9 (Berkeley) 6/29/91
-.\"     $Id: strerror.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
+.\"     $OpenBSD: strerror.3,v 1.10 2011/07/25 00:38:53 schwarze Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRERROR 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm strerror
 .Nd get error message string
@@ -46,15 +41,63 @@
 .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
-function returns a pointer to the language-dependent error message
-string affiliated with an error number.
+and
+.Fn strerror_r
+functions map the error number
+.Fa errnum
+to a language-dependent error message string.
 .Pp
-The array pointed to is not to be modified by the program, but may be
-overwritten by subsequent calls to
+.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 ,
@@ -64,3 +107,16 @@ The
 .Fn strerror
 function conforms to
 .St -ansiC .
+The
+.Fn strerror_r
+function conforms to
+.St -p1003.1 .
+.Sh HISTORY
+The
+.Fn strerror
+function first appeared in
+.Bx 4.3 Reno .
+The
+.Fn strerror_r
+function first appeared in
+.Ox 3.3 .
diff --git a/src/lib/libc/string/strerror.c b/src/lib/libc/string/strerror.c
index c3f5ab5d98..13996f08e9 100644
--- a/src/lib/libc/string/strerror.c
+++ b/src/lib/libc/string/strerror.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,26 +28,14 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strerror.c   5.6 (Berkeley) 5/4/91";*/
-static char *rcsid = "$Id: strerror.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 #include <limits.h>
 
-/*
- * Since perror() is not allowed to change the contents of strerror()'s
- * static buffer, both functions supply their own buffers to the
- * internal function __strerror().
- */
-
-extern char *__strerror __P((int, char *));
-
 char *
-strerror(num)
-        int num;
+strerror(int num)
 {
         static char buf[NL_TEXTMAX];
-        return __strerror(num, buf);
+
+        (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..aa63408ab8
--- /dev/null
+++ b/src/lib/libc/string/strerror_r.c
@@ -0,0 +1,137 @@
+/* $OpenBSD: strerror_r.c,v 1.7 2007/03/01 16:29:09 bluhm 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, list[num], 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/strftime.3 b/src/lib/libc/string/strftime.3
deleted file mode 100644
index f14db4bb13..0000000000
--- a/src/lib/libc/string/strftime.3
+++ /dev/null
@@ -1,202 +0,0 @@
-.\" Copyright (c) 1989, 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. 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.
-.\"
-.\"     from: @(#)strftime.3    5.12 (Berkeley) 6/29/91
-.\"     $Id: strftime.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
-.Dt STRFTIME 3
-.Os
-.Sh NAME
-.Nm strftime
-.Nd format date and time
-.Sh SYNOPSIS
-.Fd #include <time.h>
-.Ft size_t
-.Fn strftime "char *buf" "size_t maxsize" "const char *format" "const struct tm *timeptr"
-.Sh DESCRIPTION
-The
-.Fn strftime
-function formats the information from
-.Fa timeptr
-into the buffer
-.Fa buf
-according to the string pointed to by
-.Fa format .
-.Pp
-The
-.Fa format
-string consists of zero or more conversion specifications and
-ordinary characters.
-All ordinary characters are copied directly into the buffer.
-A conversion specification consists of a percent sign
-.Ql %
-and one other character.
-.Pp
-No more than
-.Fa maxsize
-characters will be placed into the array.
-If the total number of resulting characters, including the terminating
-null character, is not more than
-.Fa maxsize ,
-.Fn strftime
-returns the number of characters in the array, not counting the
-terminating null.
-Otherwise, zero is returned.
-.Pp
-Each conversion specification is replaced by the characters as
-follows which are then copied into the buffer.
-.Bl -tag -width "xxxx"
-.It Cm \&%A
-is replaced by the locale's full weekday name.
-.It Cm %a
-is replaced by the locale's abbreviated weekday name.
-.It Cm \&%B
-is replaced by the locale's full month name.
-.It Cm \&%b No or Cm \&%h
-is replaced by the locale's abbreviated month name.
-.It Cm \&%C
-is replaced by the century (a year divided by 100 and truncated to an integer)
-as a decimal number (00-99).
-.It Cm \&%c
-is replaced by the locale's appropriate date and time representation.
-.It Cm \&%D
-is replaced by the date in the format 
-.Dq Li %m/%d/%y .
-.It Cm \&%d
-is replaced by the day of the month as a decimal number (01-31).
-.It Cm \&%e
-is replaced by the day of month as a decimal number (1-31);
-single digits are preceded by a blank.
-.It Cm \&%H
-is replaced by the hour (24-hour clock) as a decimal number (00-23).
-.It Cm \&%I
-is replaced by the hour (12-hour clock) as a decimal number (01-12).
-.It Cm \&%j
-is replaced by the day of the year as a decimal number (001-366).
-.It Cm \&%k
-is replaced by the hour (24-hour clock) as a decimal number (0-23);
-single digits are preceded by a blank.
-.It Cm \&%l
-is replaced by the hour (12-hour clock) as a decimal number (1-12);
-single digits are preceded by a blank.
-.It Cm \&%M
-is replaced by the minute as a decimal number (00-59).
-.It Cm %m
-is replaced by the month as a decimal number (01-12).
-.It Cm %n
-is replaced by a newline.
-.It Cm %p
-is replaced by the locale's equivalent of either 
-.Dq Tn AM
-or
-.Dq Tn PM .
-.It Cm \&%R
-is replaced by the time in the format
-.Dq Li %H:%M .
-.It Cm \&%r
-is replaced by the locale's representation of 12-hour clock time 
-using AM/PM notation.
-.It Cm \&%T
-is replaced by the time in the format
-.Dq Li %H:%M:%S .
-.It Cm \&%t
-is replaced by a tab.
-.It Cm \&%S
-is replaced by the second as a decimal number (00-60).
-.It Cm %s
-is replaced by the number of seconds since the Epoch, UCT (see
-.Xr mktime 3 ) .
-.It Cm \&%U
-is replaced by the week number of the year (Sunday as the first day of
-the week) as a decimal number (00-53).
-.It Cm \&%u
-is replaced by the weekday (Monday as the first day of the week)
-as a decimal number (1-7).
-.It Cm \&%V
-is replaced by the week number of the year (Monday as the first day of
-the week) as a decimal number (01-53).  If the week containing January
-1 has four or more days in the new year, then it is week 1; otherwise
-it is week 53 of the previous year, and the next week is week 1.
-.It Cm \&%W
-is replaced by the week number of the year (Monday as the first day of
-the week) as a decimal number (00-53).
-.It Cm \&%w
-is replaced by the weekday (Sunday as the first day of the week)
-as a decimal number (0-6).
-.It Cm \&%X
-is replaced by the locale's appropriate date representation.
-.It Cm \&%x
-is replaced by the locale's appropriate time representation.
-.It Cm \&%Y
-is replaced by the year with century as a decimal number.
-.It Cm \&%y
-is replaced by the year without century as a decimal number (00-99).
-.It Cm \&%Z
-is replaced by the time zone name.
-.It Cm %%
-is replaced by
-.Ql % .
-.El
-.Sh SEE ALSO
-.Xr date 1 ,
-.Xr ctime 3 ,
-.Xr printf 1 ,
-.Xr printf 3
-.Sh STANDARDS
-The
-.Fn strftime
-function
-conforms to
-.St -ansiC .
-The
-.Ql \&%C ,
-.Ql \&%D ,
-.Ql \&%e ,
-.Ql \&%h ,
-.Ql \&%k ,
-.Ql \&%l , 
-.Ql \&%n ,
-.Ql \&%r ,
-.Ql \&%R ,
-.Ql \&%s .
-.Ql \&%t , 
-.Ql \&%T , 
-.Ql \&%u ,
-and
-.Ql \&%V
-conversion specifications are extensions.
-.Sh BUGS
-There is no conversion specification for the phase of the moon.
diff --git a/src/lib/libc/string/strftime.c b/src/lib/libc/string/strftime.c
deleted file mode 100644
index fffa9ecbb0..0000000000
--- a/src/lib/libc/string/strftime.c
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * 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. 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.
- */
-
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strftime.c   5.11 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: strftime.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <sys/localedef.h>
-#include <locale.h>
-#include <string.h>
-#include <tzfile.h>
-#include <time.h>
-
-static size_t gsize;
-static char *pt;
-static int _add(), _conv(), _secs();
-static size_t _fmt();
-
-size_t
-strftime(s, maxsize, format, t)
-        char *s;
-        size_t maxsize;
-        const char *format;
-        const struct tm *t;
-{
-        tzset();
-
-        pt = s;
-        if ((gsize = maxsize) < 1)
-                return(0);
-        if (_fmt(format, t)) {
-                *pt = '\0';
-                return(maxsize - gsize);
-        }
-        return(0);
-}
-
-#define SUN_WEEK(t)     (((t)->tm_yday + 7 - \
-                                ((t)->tm_wday)) / 7)
-#define MON_WEEK(t)     (((t)->tm_yday + 7 - \
-                                ((t)->tm_wday ? (t)->tm_wday - 1 : 6)) / 7)
-static size_t
-_fmt(format, t)
-        register char *format;
-        struct tm *t;
-{
-        for (; *format; ++format) {
-                if (*format == '%') {
-                        ++format;
-                        if (*format == 'E') {
-                                /* Alternate Era */
-                                ++format;
-                        } else if (*format == 'O') {
-                                /* Alternate numeric symbols */
-                                ++format;
-                        }
-                        switch(*format) {
-                        case '\0':
-                                --format;
-                                break;
-                        case 'A':
-                                if (t->tm_wday < 0 || t->tm_wday > 6)
-                                        return(0);
-                                if (!_add(_CurrentTimeLocale->day[t->tm_wday]))
-                                        return(0);
-                                continue;
-                        case 'a':
-                                if (t->tm_wday < 0 || t->tm_wday > 6)
-                                        return(0);
-                                if (!_add(_CurrentTimeLocale->abday[t->tm_wday]))
-                                        return(0);
-                                continue;
-                        case 'B':
-                                if (t->tm_mon < 0 || t->tm_mon > 11)
-                                        return(0);
-                                if (!_add(_CurrentTimeLocale->mon[t->tm_mon]))
-                                        return(0);
-                                continue;
-                        case 'b':
-                        case 'h':
-                                if (t->tm_mon < 0 || t->tm_mon > 11)
-                                        return(0);
-                                if (!_add(_CurrentTimeLocale->abmon[t->tm_mon]))
-                                        return(0);
-                                continue;
-                        case 'C':
-                                if (!_conv((t->tm_year + TM_YEAR_BASE) / 100,
-                                    2, '0'))
-                                        return(0);
-                                continue;
-                        case 'c':
-                                if (!_fmt(_CurrentTimeLocale->d_t_fmt, t))
-                                        return(0);
-                                continue;
-                        case 'D':
-                                if (!_fmt("%m/%d/%y", t))
-                                        return(0);
-                                continue;
-                        case 'd':
-                                if (!_conv(t->tm_mday, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'e':
-                                if (!_conv(t->tm_mday, 2, ' '))
-                                        return(0);
-                                continue;
-                        case 'H':
-                                if (!_conv(t->tm_hour, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'I':
-                                if (!_conv(t->tm_hour % 12 ?
-                                    t->tm_hour % 12 : 12, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'j':
-                                if (!_conv(t->tm_yday + 1, 3, '0'))
-                                        return(0);
-                                continue;
-                        case 'k':
-                                if (!_conv(t->tm_hour, 2, ' '))
-                                        return(0);
-                                continue;
-                        case 'l':
-                                if (!_conv(t->tm_hour % 12 ?
-                                    t->tm_hour % 12: 12, 2, ' '))
-                                        return(0);
-                                continue;
-                        case 'M':
-                                if (!_conv(t->tm_min, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'm':
-                                if (!_conv(t->tm_mon + 1, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'n':
-                                if (!_add("\n"))
-                                        return(0);
-                                continue;
-                        case 'p':
-                                if (!_add(_CurrentTimeLocale->am_pm[t->tm_hour >= 12]))
-                                        return(0);
-                                continue;
-                        case 'R':
-                                if (!_fmt("%H:%M", t))
-                                        return(0);
-                                continue;
-                        case 'r':
-                                if (!_fmt(_CurrentTimeLocale->t_fmt_ampm, t))
-                                        return(0);
-                                continue;
-                        case 'S':
-                                if (!_conv(t->tm_sec, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 's':
-                                if (!_secs(t))
-                                        return(0);
-                                continue;
-                        case 'T':
-                                if (!_fmt("%H:%M:%S", t))
-                                        return(0);
-                                continue;
-                        case 't':
-                                if (!_add("\t"))
-                                        return(0);
-                                continue;
-                        case 'U':
-                                if (!_conv(SUN_WEEK(t), 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'u':
-                                if (!_conv(t->tm_wday ? t->tm_wday : 7, 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'V':
-                                {
-                                /* ISO 8601 Week Of Year:
-                                   If the week (Monday - Sunday) containing
-                                   January 1 has four or more days in the new 
-                                   year, then it is week 1; otherwise it is 
-                                   week 53 of the previous year and the next
-                                   week is week one. */
-                                 
-                                int week = MON_WEEK(t);
-
-                                if (((t->tm_yday + 7 - (t->tm_wday + 1)) % 7) >= 4) {
-                                        week++;
-                                } else if (week == 0) {
-                                        week = 53;
-                                }
-
-                                if (!_conv(week, 2, '0'))
-                                        return(0);
-                                continue;
-                                }
-                        case 'W':
-                                if (!_conv(MON_WEEK(t), 2, '0'))
-                                        return(0);
-                                continue;
-                        case 'w':
-                                if (!_conv(t->tm_wday, 1, '0'))
-                                        return(0);
-                                continue;
-                        case 'x':
-                                if (!_fmt(_CurrentTimeLocale->d_fmt, t))
-                                        return(0);
-                                continue;
-                        case 'X':
-                                if (!_fmt(_CurrentTimeLocale->t_fmt, t))
-                                        return(0);
-                                continue;
-                        case 'y':
-                                if (!_conv((t->tm_year + TM_YEAR_BASE) % 100,
-                                    2, '0'))
-                                        return(0);
-                                continue;
-                        case 'Y':
-                                if (!_conv((t->tm_year + TM_YEAR_BASE), 4, '0'))
-                                        return(0);
-                                continue;
-                        case 'Z':
-                                if (t->tm_zone && !_add(t->tm_zone))
-                                        return(0);
-                                continue;
-                        case '%':
-                        /*
-                         * X311J/88-090 (4.12.3.5): if conversion char is
-                         * undefined, behavior is undefined.  Print out the
-                         * character itself as printf(3) does.
-                         */
-                        default:
-                                break;
-                        }
-                }
-                if (!gsize--)
-                        return(0);
-                *pt++ = *format;
-        }
-        return(gsize);
-}
-
-static
-_secs(t)
-        struct tm *t;
-{
-        static char buf[15];
-        register time_t s;
-        register char *p;
-        struct tm tmp;
-
-        /* Make a copy, mktime(3) modifies the tm struct. */
-        tmp = *t;
-        s = mktime(&tmp);
-        for (p = buf + sizeof(buf) - 2; s > 0 && p > buf; s /= 10)
-                *p-- = s % 10 + '0';
-        return(_add(++p));
-}
-
-static
-_conv(n, digits, pad)
-        int n, digits;
-        char pad;
-{
-        static char buf[10];
-        register char *p;
-
-        for (p = buf + sizeof(buf) - 2; n > 0 && p > buf; n /= 10, --digits)
-                *p-- = n % 10 + '0';
-        while (p > buf && digits-- > 0)
-                *p-- = pad;
-        return(_add(++p));
-}
-
-static
-_add(str)
-        register char *str;
-{
-        for (;; ++pt, --gsize) {
-                if (!gsize)
-                        return(0);
-                if (!(*pt = *str++))
-                        return(1);
-        }
-}
diff --git a/src/lib/libc/string/string.3 b/src/lib/libc/string/string.3
index aaf97e0321..4d47ad444d 100644
--- a/src/lib/libc/string/string.3
+++ b/src/lib/libc/string/string.3
@@ -11,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,38 +27,20 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)string.3      6.9 (Berkeley) 4/19/91
-.\"     $Id: string.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
+.\"     $OpenBSD: string.3,v 1.12 2007/05/31 19:19:32 jmc Exp $
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: May 31 2007 $
 .Dt STRING 3
-.Os BSD 4
+.Os
 .Sh NAME
-.Nm strcat ,
-.Nm strncat ,
-.Nm strchr ,
-.Nm strrchr ,
-.Nm strcmp ,
-.Nm strncmp ,
-.Nm strcasecmp,
-.Nm strncasecmp ,
-.Nm strcpy ,
-.Nm strncpy ,
-.Nm strerror ,
-.Nm strlen ,
-.Nm strpbrk ,
-.Nm strsep,
-.Nm strspn ,
-.Nm strcspn ,
-.Nm strstr ,
-.Nm strtok ,
-.Nm index ,
-.Nm rindex
+.Nm string
 .Nd string specific functions
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft char *
-.Fn strcat "char *s" "const char * append"
+.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 *
@@ -80,6 +58,8 @@
 .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"
@@ -103,35 +83,37 @@
 .Fn rindex "const char *s" "int c"
 .Sh DESCRIPTION
 The string functions
-functions manipulate strings terminated by a
-null byte.
+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 null byte check), see
+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 strrchr 3 ,
 .Xr strcmp 3 ,
-.Xr strcasecmp 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 strcspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3 ,
-.Xr rindex 3
-.Xr bstring 3
+.Xr strtok 3
 .Sh STANDARDS
 The
 .Fn strcat ,
@@ -145,12 +127,10 @@ The
 .Fn strerror ,
 .Fn strlen ,
 .Fn strpbrk ,
-.Fn strsep ,
 .Fn strspn ,
 .Fn strcspn ,
 .Fn strstr ,
 and
 .Fn strtok
-functions
-conform to
+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..ead54ec438
--- /dev/null
+++ b/src/lib/libc/string/strlcpy.3
@@ -0,0 +1,194 @@
+.\"     $OpenBSD: strlcpy.3,v 1.20 2011/07/25 00:38:53 schwarze 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 $Mdocdate: July 25 2011 $
+.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 ,
+.Xr wcslcpy 3
+.Sh HISTORY
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions first appeared in
+.Ox 2.4 .
+.Sh AUTHORS
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions were created by
+.An Todd C. Miller Aq Todd.Miller@courtesan.com .
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
index f4aff363ee..9187496a00 100644
--- a/src/lib/libc/string/strlen.3
+++ b/src/lib/libc/string/strlen.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strlen.3,v 1.10 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,39 +31,74 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strlen.3      5.4 (Berkeley) 6/29/91
-.\"     $Id: strlen.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRLEN 3
 .Os
 .Sh NAME
-.Nm strlen
-.Nd find length of string
+.Nm strlen ,
+.Nm strnlen
+.Nd find length of a string
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft size_t
 .Fn strlen "const char *s"
+.Ft size_t
+.Fn strnlen "const char *s" "size_t maxlen"
 .Sh DESCRIPTION
 The
 .Fn strlen
-function
-computes the length of the string
+function computes the length of the string
 .Fa s .
+.Pp
+The
+.Fn strnlen
+function computes the length of the string
+.Fa s ,
+up to
+.Fa maxlen
+characters.
+The
+.Fn strnlen
+function will never attempt to address more than
+.Fa maxlen
+characters, making it suitable for use with character arrays that are
+not guaranteed to be NUL-terminated.
 .Sh RETURN VALUES
 The
 .Fn strlen
-function
-returns
-the number of characters that precede the
-terminating
-.Dv NUL
+function returns the number of characters that precede the terminating
+.Tn NUL
 character.
+.Pp
+The
+.Fn strnlen
+function returns the number of characters that precede the terminating
+.Tn NUL
+or
+.Fa maxlen ,
+whichever is smaller.
 .Sh SEE ALSO
-.Xr string 3
+.Xr string 3 ,
+.Xr wcslen 3
 .Sh STANDARDS
 The
 .Fn strlen
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Pp
+The
+.Fn strlen
+and
+.Fn strnlen
+functions conform to
+.St -p1003.1-2008 .
+.Sh HISTORY
+The
+.Fn strlen
+function first appeared in
+.At v7 .
+The
+.Fn strnlen
+function appeared in glibc 2.0
+and was reimplemented for
+.Ox 4.8 .
diff --git a/src/lib/libc/string/strlen.c b/src/lib/libc/string/strlen.c
index d23aadafc0..12d9ec4dad 100644
--- a/src/lib/libc/string/strlen.c
+++ b/src/lib/libc/string/strlen.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strlen.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.
+ * 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
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,20 +29,19 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strlen.c     5.5 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strlen.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 size_t
-strlen(str)
-        const char *str;
+strlen(const char *str)
 {
-        register const char *s;
+        const char *s;
 
-        for (s = str; *s; ++s);
-        return(s - str);
+        for (s = str; *s; ++s)
+                ;
+        return (s - str);
 }
 
diff --git a/src/lib/libc/string/strmode.3 b/src/lib/libc/string/strmode.3
index 1907e7ab03..5d371b38c8 100644
--- a/src/lib/libc/string/strmode.3
+++ b/src/lib/libc/string/strmode.3
@@ -1,5 +1,7 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" $OpenBSD: strmode.3,v 1.15 2011/07/25 00:38:53 schwarze 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
@@ -9,11 +11,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,10 +27,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strmode.3     5.4 (Berkeley) 7/31/91
-.\"     $Id: strmode.3,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $
+.\"     @(#)strmode.3   8.3 (Berkeley) 7/28/94
 .\"
-.Dd July 31, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRMODE 3
 .Os
 .Sh NAME
@@ -45,15 +42,13 @@
 .Sh DESCRIPTION
 The
 .Fn strmode
-function
-converts a file
+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
-.Dv NULL .
+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
@@ -69,10 +64,10 @@ directory
 .It l
 symbolic link
 .It p
-fifo
+FIFO
 .It s
 socket
-.It ?
+.It \&?
 unknown inode type
 .El
 .Pp
@@ -80,46 +75,58 @@ 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 ``other'', or default, set of users.
+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 ``other'' permissions allow reading.
+permissions allow reading or the
+.Dq other
+permissions allow reading.
 .Pp
-If the first character of the three character set is an ``r'', the file is
-readable for that set of users; if a dash ``\-'', it is not readable.
+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 ``w'', the file is
-writable for that set of users; if a dash ``\-'', it is not writable.
+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.
+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.
+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 ``sticky''
+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
+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
+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 ``sticky''
+executable or the directory searchable by others, and the
+.Dq sticky
 .Pq Dv S_ISVTX
 bit is set.
 .It x
@@ -128,14 +135,15 @@ The file is executable or the directory is searchable.
 None of the above apply.
 .El
 .Pp
-The last character is a plus sign ``+'' if any there are any alternate
+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.
+function always returns 0.
 .Sh SEE ALSO
 .Xr chmod 1 ,
 .Xr find 1 ,
@@ -145,5 +153,5 @@ always returns 0.
 .Sh HISTORY
 The
 .Fn strmode
-function
-.Ud .
+function first appeared in
+.Bx 4.3 Reno .
diff --git a/src/lib/libc/string/strmode.c b/src/lib/libc/string/strmode.c
index 441fc76e90..6f0fa34ed8 100644
--- a/src/lib/libc/string/strmode.c
+++ b/src/lib/libc/string/strmode.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,19 +28,14 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strmode.c    5.3 (Berkeley) 5/18/90";*/
-static char *rcsid = "$Id: strmode.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <string.h>
 
+/* XXX mode should be mode_t */
+
 void
-strmode(mode, p)
-        register mode_t mode;
-        register char *p;
+strmode(int mode, char *p)
 {
          /* print type */
         switch (mode & S_IFMT) {
diff --git a/src/lib/libc/string/strncat.c b/src/lib/libc/string/strncat.c
index 3d96452af4..c4df4f2fad 100644
--- a/src/lib/libc/string/strncat.c
+++ b/src/lib/libc/string/strncat.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strncat.c    5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strncat.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
@@ -46,14 +38,11 @@ static char *rcsid = "$Id: strncat.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
  * are written at dst (at most n+1 bytes being appended).  Return dst.
  */
 char *
-strncat(dst, src, n)
-        char *dst;
-        const char *src;
-        register size_t n;
+strncat(char *dst, const char *src, size_t n)
 {
         if (n != 0) {
-                register char *d = dst;
-                register const char *s = src;
+                char *d = dst;
+                const char *s = src;
 
                 while (*d != 0)
                         d++;
diff --git a/src/lib/libc/string/strncmp.c b/src/lib/libc/string/strncmp.c
index 0638d4dcf2..0aea80d7d9 100644
--- a/src/lib/libc/string/strncmp.c
+++ b/src/lib/libc/string/strncmp.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,17 +29,14 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strncmp.c    5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strncmp.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 int
-strncmp(s1, s2, n)
-        register const char *s1, *s2;
-        register size_t n;
+strncmp(const char *s1, const char *s2, size_t n)
 {
 
         if (n == 0)
diff --git a/src/lib/libc/string/strncpy.c b/src/lib/libc/string/strncpy.c
index 5215311b75..4426cbe2e3 100644
--- a/src/lib/libc/string/strncpy.c
+++ b/src/lib/libc/string/strncpy.c
@@ -1,3 +1,5 @@
+/*      $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.
@@ -13,11 +15,7 @@
  * 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
+ * 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.
  *
@@ -34,26 +32,22 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strncpy.c    5.6 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strncpy.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#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(dst, src, n)
-        char *dst;
-        const char *src;
-        register size_t n;
+strncpy(char *dst, const char *src, size_t n)
 {
         if (n != 0) {
-                register char *d = dst;
-                register const char *s = src;
+                char *d = dst;
+                const char *s = src;
 
                 do {
                         if ((*d++ = *s++) == 0) {
diff --git a/src/lib/libc/string/strndup.c b/src/lib/libc/string/strndup.c
new file mode 100644
index 0000000000..27701ac555
--- /dev/null
+++ b/src/lib/libc/string/strndup.c
@@ -0,0 +1,39 @@
+/*      $OpenBSD: strndup.c,v 1.1 2010/05/18 22:24:55 tedu Exp $        */
+
+/*
+ * Copyright (c) 2010 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 <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *
+strndup(const char *str, size_t maxlen)
+{
+        char *copy;
+        size_t len;
+
+        len = strnlen(str, maxlen);
+        copy = malloc(len + 1);
+        if (copy != NULL) {
+                (void)memcpy(copy, str, len);
+                copy[len] = '\0';
+        }
+
+        return copy;
+}
diff --git a/src/lib/libc/string/strnlen.c b/src/lib/libc/string/strnlen.c
new file mode 100644
index 0000000000..2dc7b4fb32
--- /dev/null
+++ b/src/lib/libc/string/strnlen.c
@@ -0,0 +1,32 @@
+/*      $OpenBSD: strnlen.c,v 1.3 2010/06/02 12:58:12 millert Exp $     */
+
+/*
+ * Copyright (c) 2010 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>
+
+size_t
+strnlen(const char *str, size_t maxlen)
+{
+        const char *cp;
+
+        for (cp = str; maxlen != 0 && *cp != '\0'; cp++, maxlen--)
+                ;
+
+        return (size_t)(cp - str);
+}
diff --git a/src/lib/libc/string/strpbrk.3 b/src/lib/libc/string/strpbrk.3
index 8578546c05..9e13c42ad0 100644
--- a/src/lib/libc/string/strpbrk.3
+++ b/src/lib/libc/string/strpbrk.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strpbrk.3,v 1.9 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strpbrk.3     5.4 (Berkeley) 6/29/91
-.\"     $Id: strpbrk.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRPBRK 3
 .Os
 .Sh NAME
@@ -49,8 +44,7 @@
 .Sh DESCRIPTION
 The
 .Fn strpbrk
-function
-locates in the null-terminated string
+function locates in the NUL-terminated string
 .Fa s
 the first occurrence of any character in the string
 .Fa charset
@@ -58,23 +52,29 @@ and returns a pointer to this character.
 If no characters from
 .Fa charset
 occur anywhere in
-.Fa s
+.Fa s ,
 .Fn strpbrk
-returns NULL.
+returns
+.Dv NULL .
 .Sh SEE ALSO
-.Xr index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcspbrk 3
 .Sh STANDARDS
 The
 .Fn strpbrk
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strpbrk
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strpbrk.c b/src/lib/libc/string/strpbrk.c
index f1d542a525..cd3b71c0d3 100644
--- a/src/lib/libc/string/strpbrk.c
+++ b/src/lib/libc/string/strpbrk.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,22 +28,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strpbrk.c    5.8 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strpbrk.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Find the first occurrence in s1 of a character in s2 (excluding NUL).
  */
 char *
-strpbrk(s1, s2)
-        register const char *s1, *s2;
+strpbrk(const char *s1, const char *s2)
 {
-        register const char *scanp;
-        register int c, sc;
+        const char *scanp;
+        int c, sc;
 
         while ((c = *s1++) != 0) {
                 for (scanp = s2; (sc = *scanp++) != 0;)
diff --git a/src/lib/libc/string/strrchr.3 b/src/lib/libc/string/strrchr.3
index 1d98cbff24..9eea08b0a9 100644
--- a/src/lib/libc/string/strrchr.3
+++ b/src/lib/libc/string/strrchr.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strrchr.3,v 1.9 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,28 +31,29 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strrchr.3     5.3 (Berkeley) 6/29/91
-.\"     $Id: strrchr.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRRCHR 3
 .Os
 .Sh NAME
-.Nm strrchr
-.Nd locate character in string
+.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
+function locates the last occurrence of the character
 .Fa c
-(converted to a char)
 in the string
 .Fa s .
+The terminating
+.Tn NUL
+character is considered part of the string.
 If
 .Fa c
 is
@@ -62,30 +61,56 @@ is
 .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 character,
-or a null
-pointer if
-.Fa c
-does not occur anywhere in
-.Fa s .
+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 index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcsrchr 3
 .Sh STANDARDS
 The
 .Fn strrchr
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Pp
+The
+.Fn rindex
+function is deprecated and shouldn't be used in new code.
+.Sh HISTORY
+The
+.Fn rindex
+function first appeared in
+.At v7 .
+The
+.Fn strrchr
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strsep.3 b/src/lib/libc/string/strsep.3
index 21aa7376f2..63cdf2333a 100644
--- a/src/lib/libc/string/strsep.3
+++ b/src/lib/libc/string/strsep.3
@@ -1,8 +1,11 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" $OpenBSD: strsep.3,v 1.13 2011/07/25 00:38:53 schwarze 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:
@@ -11,11 +14,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,10 +30,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strsep.3      5.3 (Berkeley) 4/19/91
-.\"     $Id: strsep.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
+.\"     @(#)strsep.3    8.1 (Berkeley) 6/9/93
 .\"
-.Dd April 19, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRSEP 3
 .Os
 .Sh NAME
@@ -43,27 +41,37 @@
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft char *
-.Fn strsep "char **stringp" "char *delim"
+.Fn strsep "char **stringp" "const char *delim"
 .Sh DESCRIPTION
 The
 .Fn strsep
-locates in the null-terminated string at
-.Fa *stringp
-the first occurrence of any character in
-.Fa delim
-and replaces this with a
-.Ql \e0 ,
-records the location of the immediate following character in
+function locates, in the string referenced by
 .Fa *stringp ,
-then returns the original value of
+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 .
-If no delimiter characters are found,
-.Fn strsep
-sets
+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
-.Dv NULL ;
-if
+.Ql \e0 .
+.Pp
+If
 .Fa *stringp
 is initially
 .Dv NULL ,
@@ -73,20 +81,30 @@ returns
 .Sh EXAMPLES
 The following uses
 .Fn strsep
-to parse strings containing runs of white space,
-making up an argument vector:
+to parse a string, containing tokens delimited by whitespace, into an
+argument vector:
 .Bd -literal -offset indent
-char inputstring[100];
-char **argv[51], **ap = argv, *p, *val;
-/* set up inputstring */
-for (p = inputstring; p != NULL; ) {
-        while ((val = strsep(&p, " \et")) != NULL && *val == '\e0');
-        *ap++ = val;
+char **ap, *argv[10], *inputstring;
+
+for (ap = argv; ap < &argv[9] &&
+    (*ap = strsep(&inputstring, " \et")) != NULL;) {
+        if (**ap != '\e0')
+                ap++;
 }
-*ap = 0;
+*ap = NULL;
 .Ed
 .Sh HISTORY
 The
 .Fn strsep
-function is
-.Ud .
+function first appeared in
+.Bx 4.3 Reno .
+It is intended as a replacement for the
+.Xr strtok 3
+function.
+While the
+.Xr strtok 3
+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.
diff --git a/src/lib/libc/string/strsep.c b/src/lib/libc/string/strsep.c
index 69be7fe046..bcca681e03 100644
--- a/src/lib/libc/string/strsep.c
+++ b/src/lib/libc/string/strsep.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strsep.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.
+ * 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
@@ -10,11 +12,7 @@
  * 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
+ * 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.
  *
@@ -31,15 +29,11 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static const char sccsid[] = "from: @(#)strsep.c      5.4 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strsep.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
+#include <stdio.h>
 
 /*
- * Get next token from string *stringp, where tokens are nonempty
+ * 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.
@@ -47,16 +41,14 @@ static char *rcsid = "$Id: strsep.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $"
  * 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, strtoken returns NULL.
+ * If *stringp is NULL, strsep returns NULL.
  */
 char *
-strsep(stringp, delim)
-        register char **stringp;
-        register const char *delim;
+strsep(char **stringp, const char *delim)
 {
-        register char *s;
-        register const char *spanp;
-        register int c, sc;
+        char *s;
+        const char *spanp;
+        int c, sc;
         char *tok;
 
         if ((s = *stringp) == NULL)
diff --git a/src/lib/libc/string/strsignal.3 b/src/lib/libc/string/strsignal.3
index 3287fef53e..1f9cfc7ef5 100644
--- a/src/lib/libc/string/strsignal.3
+++ b/src/lib/libc/string/strsignal.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,12 +29,11 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strerror.3    6.9 (Berkeley) 6/29/91
-.\"     $Id: strsignal.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
+.\"     $OpenBSD: strsignal.3,v 1.6 2011/07/25 00:38:53 schwarze Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRSIGNAL 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm strsignal
 .Nd get signal description string
@@ -59,3 +54,10 @@ overwritten by subsequent calls to
 .Xr intro 2 ,
 .Xr psignal 3 ,
 .Xr setlocale 3
+.Sh HISTORY
+The
+.Fn strsignal
+function first appeared in
+.At V.4
+and was reimplemented for
+.Nx 1.0 .
diff --git a/src/lib/libc/string/strsignal.c b/src/lib/libc/string/strsignal.c
index ec4a267edf..aa541cefed 100644
--- a/src/lib/libc/string/strsignal.c
+++ b/src/lib/libc/string/strsignal.c
@@ -10,11 +10,7 @@
  * 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
+ * 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.
  *
@@ -31,20 +27,15 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strerror.c   5.6 (Berkeley) 5/4/91";*/
-static char *rcsid = "$Id: strsignal.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 #include <limits.h>
 
-extern char *__strsignal __P((int, char *));
+extern char *__strsignal(int, char *);
 
 char *
-strsignal(sig)
-        int sig;
+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
index 4de03aa58b..b1a2ae3014 100644
--- a/src/lib/libc/string/strspn.3
+++ b/src/lib/libc/string/strspn.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strspn.3,v 1.10 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +31,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strspn.3      5.3 (Berkeley) 6/29/91
-.\"     $Id: strspn.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRSPN 3
 .Os
 .Sh NAME
@@ -48,9 +43,8 @@
 .Fn strspn "const char *s" "const char *charset"
 .Sh DESCRIPTION
 The
-.Xr strcspn
-function
-spans the initial part of the null-terminated string
+.Fn strspn
+function spans the initial part of the NUL-terminated string
 .Fa s
 as long as the characters from
 .Fa s
@@ -59,22 +53,40 @@ occur in string
 .Sh RETURN VALUES
 The
 .Fn strspn
-function
-returns the number of characters spanned.
+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 index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strstr 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcsspn 3
 .Sh STANDARDS
 The
 .Fn strspn
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strspn
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
diff --git a/src/lib/libc/string/strspn.c b/src/lib/libc/string/strspn.c
index 6224b25c2a..385649c041 100644
--- a/src/lib/libc/string/strspn.c
+++ b/src/lib/libc/string/strspn.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -10,11 +11,7 @@
  * 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
+ * 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.
  *
@@ -31,23 +28,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strspn.c     5.8 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strspn.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Span the string s2 (skip characters that are in s2).
  */
 size_t
-strspn(s1, s2)
-        const char *s1;
-        register const char *s2;
+strspn(const char *s1, const char *s2)
 {
-        register const char *p = s1, *spanp;
-        register char c, sc;
+        const char *p = s1, *spanp;
+        char c, sc;
 
         /*
          * Skip any characters in s2, excluding the terminating \0.
diff --git a/src/lib/libc/string/strstr.3 b/src/lib/libc/string/strstr.3
index 24fdf540ed..4069d55ed2 100644
--- a/src/lib/libc/string/strstr.3
+++ b/src/lib/libc/string/strstr.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strstr.3,v 1.11 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1990, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,57 +31,70 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strstr.3      5.3 (Berkeley) 6/29/91
-.\"     $Id: strstr.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRSTR 3
 .Os
 .Sh NAME
-.Nm strstr
+.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 null-terminated string
+function locates the first occurrence of the NUL-terminated string
 .Fa little
-in the null-terminated string
+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 the empty string,
-.Fn strstr
-returns
-.Fa big ;
+is an empty string,
+.Fa big
+is returned;
 if
 .Fa little
 occurs nowhere in
 .Fa big ,
-.Fn strstr
-returns NULL;
-otherwise
-.Fn strstr
-returns a pointer to the first character of the first occurrence of
-.Fa little .
+.Dv NULL
+is returned;
+otherwise a pointer to the first character of the first occurrence of
+.Fa little
+is returned.
 .Sh SEE ALSO
-.Xr index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
-.Xr strtok 3
+.Xr strtok 3 ,
+.Xr wcsstr 3
 .Sh STANDARDS
 The
 .Fn strstr
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strstr
+function first appeared in
+.Bx 4.3 Reno .
+The
+.Fn strcasestr
+function appeared in glibc 2.1,
+was reimplemented for
+.Fx 4.5
+and ported to
+.Ox 3.8 .
diff --git a/src/lib/libc/string/strstr.c b/src/lib/libc/string/strstr.c
index 1ed59e357b..95a865bf79 100644
--- a/src/lib/libc/string/strstr.c
+++ b/src/lib/libc/string/strstr.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,22 +31,16 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strstr.c     5.2 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strstr.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
  * Find the first occurrence of find in s.
  */
 char *
-strstr(s, find)
-        register const char *s, *find;
+strstr(const char *s, const char *find)
 {
-        register char c, sc;
-        register size_t len;
+        char c, sc;
+        size_t len;
 
         if ((c = *find++) != 0) {
                 len = strlen(find);
diff --git a/src/lib/libc/string/strtok.3 b/src/lib/libc/string/strtok.3
index 644bd10aed..fbf0abfc26 100644
--- a/src/lib/libc/string/strtok.3
+++ b/src/lib/libc/string/strtok.3
@@ -1,3 +1,5 @@
+.\"     $OpenBSD: strtok.3,v 1.20 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" Copyright (c) 1988, 1991 The Regents of the University of California.
 .\" All rights reserved.
 .\"
@@ -13,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,29 +31,28 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strtok.3      5.8 (Berkeley) 6/29/91
-.\"     $Id: strtok.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
-.\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRTOK 3
-.Os BSD 3
+.Os
 .Sh NAME
 .Nm strtok ,
-.Nm strsep
+.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 strsep(3).
+This interface is obsoleted by
+.Xr strsep 3 .
 .Ef
 .Pp
 The
 .Fn strtok
-function
-is used to isolate sequential tokens in a null-terminated string,
+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
@@ -71,42 +68,99 @@ The separator string,
 must be supplied each time, and may change between calls.
 .Pp
 The
+.Fn strtok_r
+function is a version of
 .Fn strtok
-function
-returns a pointer to the beginning of each subsequent token in the string,
-after replacing the separator character itself with a
-.Dv NUL
+that takes an explicit context argument and is reentrant.
+.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 RETURN VALUES
+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.
+.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 index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
 .Xr strsep 3 ,
 .Xr strspn 3 ,
-.Xr strstr 3
+.Xr strstr 3 ,
+.Xr wcstok 3
 .Sh STANDARDS
 The
 .Fn strtok
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strtok
+function first appeared in
+.At III
+and was reimplemented for
+.Bx 4.3 Tahoe .
+The
+.Fn strtok_r
+function first appeared in
+.Nx 1.3
+and was reimplemented for
+.Ox 2.7 .
 .Sh BUGS
-There is no way to get tokens from multiple strings simultaneously.
-.Pp
 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
-.Pf non- Dv NULL
-value.
+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
index 9f712579bf..4e963a019e 100644
--- a/src/lib/libc/string/strtok.c
+++ b/src/lib/libc/string/strtok.c
@@ -10,11 +10,7 @@
  * 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
+ * 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.
  *
@@ -31,25 +27,25 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strtok.c     5.8 (Berkeley) 2/24/91";*/
-static char *rcsid = "$Id: strtok.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 char *
-strtok(s, delim)
-        register char *s;
-        register const char *delim;
+strtok(char *s, const char *delim)
 {
-        register char *spanp;
-        register int c, sc;
-        char *tok;
         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)
+        if (s == NULL && (s = *last) == NULL)
                 return (NULL);
 
         /*
@@ -63,7 +59,7 @@ cont:
         }
 
         if (c == 0) {           /* no non-delimiter characters */
-                last = NULL;
+                *last = NULL;
                 return (NULL);
         }
         tok = s - 1;
@@ -81,7 +77,7 @@ cont:
                                         s = NULL;
                                 else
                                         s[-1] = 0;
-                                last = s;
+                                *last = s;
                                 return (tok);
                         }
                 } while (sc != 0);
diff --git a/src/lib/libc/string/strxfrm.3 b/src/lib/libc/string/strxfrm.3
index 84fd945472..e4472946be 100644
--- a/src/lib/libc/string/strxfrm.3
+++ b/src/lib/libc/string/strxfrm.3
@@ -13,11 +13,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -33,10 +29,9 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)strxfrm.3     5.4 (Berkeley) 6/29/91
-.\"     $Id: strxfrm.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
+.\"     $OpenBSD: strxfrm.3,v 1.9 2011/07/25 00:38:53 schwarze Exp $
 .\"
-.Dd June 29, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt STRXFRM 3
 .Os
 .Sh NAME
@@ -47,23 +42,38 @@
 .Ft size_t
 .Fn strxfrm "char *dst" "const char *src" "size_t n"
 .Sh DESCRIPTION
-The
+The idea of
 .Fn strxfrm
-function
-does something horrible (see
-.Tn ANSI
-standard).
-In this implementation it just copies.
+is to
+.Dq un-localize
+a string: the function transforms
+.Ar src ,
+storing the result in
+.Ar dst ,
+such that
+.Xr strcmp 3
+on transformed strings returns what
+.Xr strcoll 3
+on the original untransformed strings would return.
 .Sh SEE ALSO
 .Xr bcmp 3 ,
 .Xr memcmp 3 ,
-.\" .Xr setlocale 3 ,
+.Xr setlocale 3 ,
 .Xr strcasecmp 3 ,
 .Xr strcmp 3 ,
 .Xr strcoll 3
 .Sh STANDARDS
 The
 .Fn strxfrm
-function
-conforms to
+function conforms to
 .St -ansiC .
+.Sh HISTORY
+The
+.Fn strxfrm
+function first appeared in
+.Bx 4.3 Reno .
+.Sh BUGS
+Since locales are not fully implemented on
+.Ox ,
+.Fn strxfrm
+just returns a copy of the original string.
diff --git a/src/lib/libc/string/strxfrm.c b/src/lib/libc/string/strxfrm.c
index d9df77b957..6f289c901e 100644
--- a/src/lib/libc/string/strxfrm.c
+++ b/src/lib/libc/string/strxfrm.c
@@ -1,3 +1,4 @@
+/*      $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.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,11 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)strxfrm.c    5.2 (Berkeley) 1/26/91";*/
-static char *rcsid = "$Id: strxfrm.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
 #include <string.h>
 
 /*
@@ -47,28 +39,13 @@ static char *rcsid = "$Id: strxfrm.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
  * on the original untransformed strings would return.
  */
 size_t
-strxfrm(dst, src, n)
-        register char *dst;
-        register const char *src;
-        register size_t n;
+strxfrm(char *dst, const char *src, size_t n)
 {
-        register size_t r = 0;
-        register int c;
 
         /*
          * Since locales are unimplemented, this is just a copy.
          */
-        if (n != 0) {
-                while ((c = *src++) != 0) {
-                        r++;
-                        if (--n == 0) {
-                                while (*src++ != 0)
-                                        r++;
-                                break;
-                        }
-                        *dst++ = c;
-                }
-                *dst = 0;
-        }
-        return (r);
+        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
index 133c487bbd..5ebaa485e9 100644
--- a/src/lib/libc/string/swab.3
+++ b/src/lib/libc/string/swab.3
@@ -9,11 +9,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -29,17 +25,16 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)swab.3        6.6 (Berkeley) 5/1/91
-.\"     $Id: swab.3,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $
+.\"     $OpenBSD: swab.3,v 1.7 2011/07/25 00:38:53 schwarze Exp $
 .\"
-.Dd May 1, 1991
+.Dd $Mdocdate: July 25 2011 $
 .Dt SWAB 3
 .Os
 .Sh NAME
 .Nm swab
 .Nd swap adjacent bytes
 .Sh SYNOPSIS
-.Fd #include <string.h>
+.Fd #include <unistd.h>
 .Ft void
 .Fn swab "const void *src" "void *dst" "size_t len"
 .Sh DESCRIPTION
@@ -55,12 +50,12 @@ swapping adjacent bytes.
 .Pp
 The argument
 .Fa len
-must be even number.
+must be an even number.
 .Sh SEE ALSO
 .Xr bzero 3 ,
 .Xr memset 3
 .Sh HISTORY
-A
+The
 .Fn swab
-function appeared in
+function first appeared in
 .At v7 .
diff --git a/src/lib/libc/string/swab.c b/src/lib/libc/string/swab.c
index f33fc53bd6..b74db7e62a 100644
--- a/src/lib/libc/string/swab.c
+++ b/src/lib/libc/string/swab.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: swab.c,v 1.8 2008/03/15 21:54:09 ray Exp $ */
 /*
  * Copyright (c) 1988 Regents of the University of California.
  * All rights reserved.
@@ -13,11 +14,7 @@
  * 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
+ * 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.
  *
@@ -34,32 +31,30 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)swab.c       5.10 (Berkeley) 3/6/91";*/
-static char *rcsid = "$Id: swab.c,v 1.1.1.1 1995/10/18 08:42:23 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
-#include <string.h>
+#include <unistd.h>
 
 void
-swab(from, to, len)
-        const void *from;
-        void *to;
-        size_t len;
+swab(const void *from, void *to, size_t len)
 {
-        register unsigned long temp;
-        register int n;
-        register char *fp, *tp;
+        size_t n;
+        char *fp, *tp;
+        char temp;
 
-        n = (len >> 1) + 1;
+        n = (len / 2) + 1;
         fp = (char *)from;
         tp = (char *)to;
-#define STEP    temp = *fp++,*tp++ = *fp++,*tp++ = temp
+#define STEP do {       \
+        temp = *fp++;   \
+        *tp++ = *fp++;  \
+        *tp++ = temp;   \
+} while (0)
         /* round to multiple of 8 */
         while ((--n) & 07)
                 STEP;
         n >>= 3;
-        while (--n >= 0) {
+        if (n == 0)
+                return;
+        while (n-- != 0) {
                 STEP; STEP; STEP; STEP;
                 STEP; STEP; STEP; STEP;
         }
diff --git a/src/lib/libc/string/timingsafe_bcmp.c b/src/lib/libc/string/timingsafe_bcmp.c
new file mode 100644
index 0000000000..9c4287cf63
--- /dev/null
+++ b/src/lib/libc/string/timingsafe_bcmp.c
@@ -0,0 +1,33 @@
+/*      $OpenBSD: timingsafe_bcmp.c,v 1.1 2010/09/24 13:33:00 matthew Exp $     */
+/*
+ * Copyright (c) 2010 Damien 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.
+ */
+
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
+
+int
+timingsafe_bcmp(const void *b1, const void *b2, size_t n)
+{
+        const unsigned char *p1 = b1, *p2 = b2;
+        int ret = 0;
+
+        for (; n > 0; n--)
+                ret |= *p1++ ^ *p2++;
+        return (ret != 0);
+}
diff --git a/src/lib/libc/string/wcscasecmp.3 b/src/lib/libc/string/wcscasecmp.3
new file mode 100644
index 0000000000..94cd6e0c38
--- /dev/null
+++ b/src/lib/libc/string/wcscasecmp.3
@@ -0,0 +1,94 @@
+.\"     $OpenBSD: wcscasecmp.3,v 1.2 2011/07/25 00:38:53 schwarze 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 $Mdocdate: July 25 2011 $
+.Dt WCSCASECMP 3
+.Os
+.Sh NAME
+.Nm wcscasecmp ,
+.Nm wcsncasecmp
+.Nd compare wide strings, ignoring case
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft int
+.Fn wcscasecmp "const wchar_t *s1" "const wchar_t *s2"
+.Ft int
+.Fn wcsncasecmp "const wchar_t *s1" "const wchar_t *s2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wcscasecmp
+and
+.Fn wcsncasecmp
+functions compare the wide 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 wide character to lower case.
+The wide strings themselves are not modified.
+.Pp
+.Fn wcsncasecmp
+compares at most
+.Fa len
+wide characters.
+.Sh SEE ALSO
+.Xr strcasecmp 3 ,
+.Xr wcscmp 3 ,
+.Xr wmemcmp 3
+.Sh STANDARDS
+The
+.Fn wcscasecmp
+and
+.Fn wcsncasecmp
+functions conform to
+.St -p1003.1-2008 .
+.Sh HISTORY
+The
+.Fn wcscasecmp
+and
+.Fn wcsncasecmp
+functions first appeared in
+.Ox 5.0 .
+.Sh AUTHORS
+The
+.Ox
+versions of
+.Fn wcscasecmp
+and
+.Fn wcsncasecmp
+were implemented by
+.An Marc Espie Aq espie@openbsd.org .
diff --git a/src/lib/libc/string/wcscasecmp.c b/src/lib/libc/string/wcscasecmp.c
new file mode 100644
index 0000000000..b14997ee75
--- /dev/null
+++ b/src/lib/libc/string/wcscasecmp.c
@@ -0,0 +1,61 @@
+/*      $OpenBSD: wcscasecmp.c,v 1.2 2011/06/01 19:29:48 naddy Exp $ */
+
+/*
+ * Copyright (c) 2011 Marc Espie
+ *
+ * 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 OPENBSD 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 OPENBSD
+ * 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 <wchar.h>
+#include <wctype.h>
+#include "locale/runetype.h"
+
+int
+wcscasecmp(const wchar_t *s1, const wchar_t *s2)
+{
+        wchar_t l1, l2;
+
+        while ((l1 = towlower(*s1++)) == (l2 = towlower(*s2++))) {
+                if (l1 == 0)
+                        return (0);
+        }
+        /* XXX assumes wchar_t = int */
+        return ((rune_t)l1 - (rune_t)l2);
+}
+
+int
+wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n)
+{
+        wchar_t l1, l2;
+
+        if (n == 0)
+                return (0);
+        do {
+                if (((l1 = towlower(*s1++))) != (l2 = towlower(*s2++))) {
+                        /* XXX assumes wchar_t = int */
+                        return ((rune_t)l1 - (rune_t)l2);
+                }
+                if (l1 == 0)
+                        break;
+        } while (--n != 0);
+        return (0);
+}
diff --git a/src/lib/libc/string/wcscat.3 b/src/lib/libc/string/wcscat.3
new file mode 100644
index 0000000000..d0281b8bd1
--- /dev/null
+++ b/src/lib/libc/string/wcscat.3
@@ -0,0 +1,115 @@
+.\"     $OpenBSD: wcscat.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSCAT 3
+.Os
+.Sh NAME
+.Nm wcscat ,
+.Nm wcsncat
+.Nd concatenate wide strings
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcscat "wchar_t * restrict s" "const wchar_t * restrict append"
+.Ft wchar_t *
+.Fo wcsncat
+.Fa "wchar_t * restrict s"
+.Fa "const wchar_t * restrict append"
+.Fa "size_t count"
+.Fc
+.Sh DESCRIPTION
+The
+.Fn wcscat
+and
+.Fn wcsncat
+functions append a copy of the wide string
+.Fa append
+to the end of the wide string
+.Fa s ,
+then add a terminating null wide character (L'\e0').
+The wide string
+.Fa s
+must have sufficient space to hold the result.
+.Pp
+The
+.Fn wcsncat
+function appends not more than
+.Fa count
+wide characters where space for the terminating null wide character
+should not be included in
+.Fa count .
+.Sh RETURN VALUES
+The
+.Fn wcscat
+and
+.Fn wcsncat
+functions return the pointer
+.Fa s .
+.Sh SEE ALSO
+.Xr strcat 3 ,
+.Xr strlcpy 3 ,
+.Xr wcscpy 3 ,
+.Xr wcslcpy 3 ,
+.Xr wmemcpy 3 ,
+.Xr wmemmove 3
+.Sh STANDARDS
+The
+.Fn wcscat
+and
+.Fn wcsncat
+functions conform to
+.St -isoC-99
+and were first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcscat
+and
+.Fn wcsncat
+functions were ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
+.Sh CAVEATS
+Using the functions
+.Fn wcscat
+and
+.Fn wcsncat
+is very error-prone with respect to buffer overflows;
+see the EXAMPLES section in
+.Xr strcat 3
+for correct usage.
+Using
+.Xr wcslcat 3
+is a better choice in most cases.
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.3 b/src/lib/libc/string/wcschr.3
new file mode 100644
index 0000000000..ca2c0ed743
--- /dev/null
+++ b/src/lib/libc/string/wcschr.3
@@ -0,0 +1,85 @@
+.\"     $OpenBSD: wcschr.3,v 1.3 2011/07/25 07:51:30 jmc Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSCHR 3
+.Os
+.Sh NAME
+.Nm wcschr
+.Nd locate first occurrence of a wide character in a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcschr "const wchar_t *s" "wchar_t c"
+.Sh DESCRIPTION
+The
+.Fn wcschr
+function locates the first occurrence of the wide character
+.Fa c
+in the wide string
+.Fa s .
+The terminating null wide character is considered part of the wide string.
+If
+.Fa c
+is the null wide character (L'\e0'),
+.Fn wcschr
+locates the terminating null wide character.
+.Sh RETURN VALUES
+The
+.Fn wcschr
+function returns a pointer to the located wide character or
+.Dv NULL
+if the wide character does not appear in the wide string.
+.Sh SEE ALSO
+.Xr strchr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcschr
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcschr
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
diff --git a/src/lib/libc/string/wcschr.c b/src/lib/libc/string/wcschr.c
new file mode 100644
index 0000000000..b84a2d32e3
--- /dev/null
+++ b/src/lib/libc/string/wcschr.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: wcschr.c,v 1.4 2008/08/23 05:34:36 djm 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;
+        for (;;) {
+                if (*p == c) {
+                        /* LINTED interface specification */
+                        return (wchar_t *)p;
+                }
+                if (!*p)
+                        return NULL;
+                p++;
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/string/wcscmp.3 b/src/lib/libc/string/wcscmp.3
new file mode 100644
index 0000000000..b34e5c2168
--- /dev/null
+++ b/src/lib/libc/string/wcscmp.3
@@ -0,0 +1,92 @@
+.\"     $OpenBSD: wcscmp.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSCMP 3
+.Os
+.Sh NAME
+.Nm wcscmp ,
+.Nm wcsncmp
+.Nd compare wide strings
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft int
+.Fn wcscmp "const wchar_t *s1" "const wchar_t *s2"
+.Ft int
+.Fn wcsncmp "const wchar_t *s1" "const wchar_t *s2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wcscmp
+and
+.Fn wcsncmp
+functions lexicographically compare the wide strings
+.Fa s1
+and
+.Fa s2 .
+The
+.Fn wcsncmp
+function compares at most
+.Fa len
+wide characters.
+.Sh RETURN VALUES
+The
+.Fn wcscmp
+and
+.Fn wcsncmp
+functions return an integer greater than, equal to, or less than 0, according
+to whether the wide string
+.Fa s1
+is greater than, equal to, or less than the wide string
+.Fa s2 .
+.Sh SEE ALSO
+.Xr strcmp 3 ,
+.Xr wcscasecmp 3 ,
+.Xr wmemcmp 3
+.Sh STANDARDS
+The
+.Fn wcscmp
+and
+.Fn wcsncmp
+functions conform to
+.St -isoC-99
+and were first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcscmp
+and
+.Fn wcsncmp
+functions were ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wcscpy.3
new file mode 100644
index 0000000000..dcc375acbf
--- /dev/null
+++ b/src/lib/libc/string/wcscpy.3
@@ -0,0 +1,123 @@
+.\"     $OpenBSD: wcscpy.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSCPY 3
+.Os
+.Sh NAME
+.Nm wcscpy ,
+.Nm wcsncpy
+.Nd copy wide strings
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcscpy "wchar_t * restrict dst" "const wchar_t * restrict src"
+.Ft wchar_t *
+.Fo wcsncpy
+.Fa "wchar_t * restrict dst"
+.Fa "const wchar_t * restrict src"
+.Fa "size_t len"
+.Fc
+.Sh DESCRIPTION
+The
+.Fn wcscpy
+and
+.Fn wcsncpy
+functions copy the wide string
+.Fa src
+to
+.Fa dst
+(including the terminating null wide character).
+.Pp
+The
+.Fn wcsncpy
+function copies not more than
+.Fa len
+wide characters to
+.Fa dst ,
+appending null wide characters if the length of
+.Fa src
+is less than
+.Fa len ,
+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 wcscpy
+and
+.Fn wcsncpy
+functions return
+.Fa dst .
+.Sh SEE ALSO
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr wcscat 3 ,
+.Xr wcslcpy 3 ,
+.Xr wmemcpy 3 ,
+.Xr wmemmove 3
+.Sh STANDARDS
+The
+.Fn wcscpy
+and
+.Fn wcsncpy
+functions conform to
+.St -isoC-99
+and were first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcscpy
+and
+.Fn wcsncpy
+functions were ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
+.Sh CAVEATS
+Using the functions
+.Fn wcscpy
+and
+.Fn wcsncpy
+is very error-prone with respect to buffer overflows;
+see the EXAMPLES section in
+.Xr strcpy 3
+for correct usage.
+Using
+.Xr wcslcpy 3
+is a better choice in most cases.
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.3 b/src/lib/libc/string/wcscspn.3
new file mode 100644
index 0000000000..c17992501f
--- /dev/null
+++ b/src/lib/libc/string/wcscspn.3
@@ -0,0 +1,83 @@
+.\"     $OpenBSD: wcscspn.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSCSPN 3
+.Os
+.Sh NAME
+.Nm wcscspn
+.Nd span the complement of a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft size_t
+.Fn wcscspn "const wchar_t *s" "const wchar_t *charset"
+.Sh DESCRIPTION
+The
+.Fn wcscspn
+function spans the initial part of the wide string
+.Fa s
+as long as the wide characters from
+.Fa s
+do not occur in string
+.Fa charset
+(it spans the
+.Em complement
+of
+.Fa charset ) .
+.Sh RETURN VALUES
+The
+.Fn wcscspn
+function returns the number of wide characters spanned.
+.Sh SEE ALSO
+.Xr strcspn 3 ,
+.Xr wcschr 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcscspn
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcscspn
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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/wcsdup.3 b/src/lib/libc/string/wcsdup.3
new file mode 100644
index 0000000000..588a2571db
--- /dev/null
+++ b/src/lib/libc/string/wcsdup.3
@@ -0,0 +1,97 @@
+.\"     $OpenBSD: wcsdup.3,v 1.4 2011/07/25 00:38:53 schwarze Exp $
+.\"     $NetBSD: wcsdup.3,v 1.3 2010/12/16 17:42:28 wiz 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 $Mdocdate: July 25 2011 $
+.Dt WCSDUP 3
+.Os
+.Sh NAME
+.Nm wcsdup
+.Nd save a copy of a wide string
+.Sh SYNOPSIS
+.In wchar.h
+.Ft wchar_t *
+.Fn wcsdup "const wchar_t *str"
+.Sh DESCRIPTION
+The
+.Fn wcsdup
+function
+allocates sufficient memory for a copy
+of the wide-character string
+.Fa str ,
+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
+const char      *o = "foobar";
+wchar_t         *p, b[32];
+size_t           blen;
+
+blen = sizeof(b) / sizeof(b[0]);
+if (mbstowcs(b, o, blen) == (size_t)-1)
+        err(1, NULL);
+b[blen - 1] = 0;
+if ((p = wcsdup(b)) == NULL)
+        err(1, NULL);
+.Ed
+.Sh ERRORS
+The
+.Fn wcsdup
+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 strdup 3
+.Sh STANDARDS
+The
+.Fn wcsdup
+function conforms to
+.St -p1003.1-2008 .
+.Sh HISTORY
+The
+.Fn wcsdup
+function was ported from
+.Nx
+and first appeared in
+.Ox 5.0 .
diff --git a/src/lib/libc/string/wcsdup.c b/src/lib/libc/string/wcsdup.c
new file mode 100644
index 0000000000..57a328a8c2
--- /dev/null
+++ b/src/lib/libc/string/wcsdup.c
@@ -0,0 +1,31 @@
+/*      $OpenBSD: wcsdup.c,v 1.1 2011/07/04 04:37:34 nicm Exp $ */
+/*      $NetBSD: wcsdup.c,v 1.3 2008/05/26 13:17:48 haad Exp $  */
+
+/*
+ * Copyright (C) 2006 Aleksey Cheusov
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee. Permission to modify the code and to distribute modified
+ * code is also granted without any restrictions.
+ */
+
+#include <stdlib.h>
+#include <wchar.h>
+
+wchar_t *
+wcsdup(const wchar_t *str)
+{
+        wchar_t *copy;
+        size_t len;
+
+        len = wcslen(str) + 1;
+        copy = malloc(len * sizeof (wchar_t));
+
+        if (!copy)
+                return (NULL);
+
+        return (wmemcpy(copy, str, len));
+}
diff --git a/src/lib/libc/string/wcslcat.c b/src/lib/libc/string/wcslcat.c
new file mode 100644
index 0000000000..ee8ff3c343
--- /dev/null
+++ b/src/lib/libc/string/wcslcat.c
@@ -0,0 +1,56 @@
+/*      $OpenBSD: wcslcat.c,v 1.4 2011/07/24 15:21:28 millert Exp $     */
+/*      $NetBSD: wcslcat.c,v 1.2 2001/01/03 14:33:02 lukem 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 <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 <= wcslen(dst)).
+ * Returns wcslen(src) + MIN(siz, wcslen(initial dst)).
+ * 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 (n-- != 0 && *d != '\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.3 b/src/lib/libc/string/wcslcpy.3
new file mode 100644
index 0000000000..98ecf0aabc
--- /dev/null
+++ b/src/lib/libc/string/wcslcpy.3
@@ -0,0 +1,147 @@
+.\"     $OpenBSD: wcslcpy.3,v 1.3 2011/07/25 07:51:30 jmc 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 $Mdocdate: July 25 2011 $
+.Dt WCSLCPY 3
+.Os
+.Sh NAME
+.Nm wcslcpy ,
+.Nm wcslcat
+.Nd size-bounded wide string copying and concatenation
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft size_t
+.Fn wcslcpy "wchar_t *dst" "const wchar_t *src" "size_t size"
+.Ft size_t
+.Fn wcslcat "wchar_t *dst" "const wchar_t *src" "size_t size"
+.Sh DESCRIPTION
+The
+.Fn wcslcpy
+and
+.Fn wcslcat
+functions copy and concatenate wide strings respectively.
+They are designed to be safer, more consistent, and less error prone
+replacements for
+.Xr wcsncpy 3
+and
+.Xr wcsncat 3 .
+Unlike those functions,
+.Fn wcslcpy
+and
+.Fn wcslcat
+take the full size of the buffer (not just the length) and guarantee to
+terminate the result with a null wide character (as long as
+.Fa size
+is larger than 0 or, in the case of
+.Fn wcslcat ,
+as long as there is at least one wide character free in
+.Fa dst ) .
+Note that a wide character for the null wide character should be included in
+.Fa size .
+Also note that
+.Fn wcslcpy
+and
+.Fn wcslcat
+only operate on wide strings that are terminated with a null wide character
+(L'\e0').
+This means that for
+.Fn wcslcpy
+.Fa src
+must be terminated with a null wide character and for
+.Fn wcslcat
+both
+.Fa src
+and
+.Fa dst
+must be terminated with a null wide character.
+.Pp
+The
+.Fn wcslcpy
+function copies up to
+.Fa size
+\(mi 1 wide characters from the wide string
+.Fa src
+to
+.Fa dst ,
+terminating the result with a null wide character.
+.Pp
+The
+.Fn wcslcat
+function appends the wide string
+.Fa src
+to the end of
+.Fa dst .
+It will append at most
+.Fa size
+\(mi wcslen(dst) \(mi 1 wide characters, terminating the result with a null
+wide character.
+.Sh RETURN VALUES
+The
+.Fn wcslcpy
+and
+.Fn wcslcat
+functions return the total length of the wide string they tried to create.
+For
+.Fn wcslcpy
+that means the length of
+.Fa src .
+For
+.Fn wcslcat
+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 wcslcat
+traverses
+.Fa size
+wide characters without finding a null wide character, the length of the
+string is considered to be
+.Fa size
+and the destination wide string will not be terminated with a null wide
+character (since there was no space for it).
+This keeps
+.Fn wcslcat
+from running off the end of a wide string.
+In practice this should not happen (as it means that either
+.Fa size
+is incorrect or that
+.Fa dst
+is not terminated with a null wide character).
+The check exists to prevent potential security problems in incorrect code.
+.Sh SEE ALSO
+.Xr strlcpy 3 ,
+.Xr swprintf 3 ,
+.Xr wcsncat 3 ,
+.Xr wcsncpy 3
+.Sh HISTORY
+The
+.Fn wcslcpy
+and
+.Fn wcslcat
+functions first appeared in
+.Ox 3.8 .
+.Sh AUTHORS
+The
+.Fn wcslcpy
+and
+.Fn wcslcat
+functions are based on code by
+.An Todd C. Miller Aq Todd.Miller@courtesan.com .
diff --git a/src/lib/libc/string/wcslcpy.c b/src/lib/libc/string/wcslcpy.c
new file mode 100644
index 0000000000..f49936a885
--- /dev/null
+++ b/src/lib/libc/string/wcslcpy.c
@@ -0,0 +1,52 @@
+/*      $OpenBSD: wcslcpy.c,v 1.5 2011/07/24 15:21:28 millert Exp $     */
+/*      $NetBSD: wcslcpy.c,v 1.2 2001/01/03 14:33:02 lukem 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 <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/rindex.3 b/src/lib/libc/string/wcslen.3
index b13b3513e0..1b2eceab93 100644
--- a/src/lib/libc/string/rindex.3
+++ b/src/lib/libc/string/wcslen.3
@@ -1,8 +1,12 @@
+.\"     $OpenBSD: wcslen.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" 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.
+.\" 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:
@@ -11,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,51 +31,40 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)rindex.3      5.2 (Berkeley) 4/19/91
-.\"     $Id: rindex.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd April 19, 1991
-.Dt RINDEX 3
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSLEN 3
 .Os
 .Sh NAME
-.Nm rindex
-.Nd locate character in string
+.Nm wcslen
+.Nd find length of a wide string
 .Sh SYNOPSIS
-.Fd #include <string.h>
-.Ft char *
-.Fn rindex "const char *s" "int c"
+.Fd #include <wchar.h>
+.Ft size_t
+.Fn wcslen "const wchar_t *s"
 .Sh DESCRIPTION
 The
-.Fn rindex
-function
-locates the last character
-matching
-.Fa c
-(converted to a
-.Em char )
-in the null-terminated string
+.Fn wcslen
+function computes the length of the wide string
 .Fa s .
-The character c is returned if it is found; otherwise NULL is returned.
-If
-.Fa c
-is
-.Ql \e0 ,
-.Fn rindex
-locates the terminating
-.Ql \e0 .
+.Sh RETURN VALUES
+The
+.Fn wcslen
+function returns the number of wide characters that precede the terminating
+null wide character.
 .Sh SEE ALSO
-.Xr index 3 ,
-.Xr memchr 3 ,
-.Xr strchr 3 ,
-.Xr strcspn 3 ,
-.Xr strpbrk 3 ,
-.Xr strrchr 3 ,
-.Xr strsep 3 ,
-.Xr strspn 3 ,
-.Xr strstr 3 ,
-.Xr strtok 3
+.Xr strlen 3 ,
+.Xr wcswidth 3
+.Sh STANDARDS
+The
+.Fn wcslen
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
 .Sh HISTORY
-A
-.Fn rindex
-function appeared in 
-.At v6 .
+The
+.Fn wcslen
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wcspbrk.3
new file mode 100644
index 0000000000..6589e83c83
--- /dev/null
+++ b/src/lib/libc/string/wcspbrk.3
@@ -0,0 +1,81 @@
+.\"     $OpenBSD: wcspbrk.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSPBRK 3
+.Os
+.Sh NAME
+.Nm wcspbrk
+.Nd locate multiple wide characters in a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcspbrk "const wchar_t *s" "const wchar_t *charset"
+.Sh DESCRIPTION
+The
+.Fn wcspbrk
+function locates in the wide string
+.Fa s
+the first occurrence of any wide character in the wide string
+.Fa charset
+and returns a pointer to this wide character.
+If no wide characters from
+.Fa charset
+occur anywhere in
+.Fa s ,
+.Fn wcspbrk
+returns
+.Dv NULL .
+.Sh SEE ALSO
+.Xr strpbrk 3 ,
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcspbrk
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcspbrk
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wcsrchr.3
new file mode 100644
index 0000000000..d65caa4292
--- /dev/null
+++ b/src/lib/libc/string/wcsrchr.3
@@ -0,0 +1,85 @@
+.\"     $OpenBSD: wcsrchr.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSRCHR 3
+.Os
+.Sh NAME
+.Nm wcsrchr
+.Nd locate last occurrence of a wide character in a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcsrchr "const wchar_t *s" "wchar_t c"
+.Sh DESCRIPTION
+The
+.Fn wcsrchr
+function locates the last occurrence of the wide character
+.Fa c
+in the wide string
+.Fa s .
+The terminating null wide character is considered part of the wide string.
+If
+.Fa c
+is the null wide character (L'\e0'),
+.Fn wcsrchr
+locates the terminating null wide character.
+.Sh RETURN VALUES
+The
+.Fn wcsrchr
+function returns a pointer to the located wide character or
+.Dv NULL
+if the wide character does not appear in the wide string.
+.Sh SEE ALSO
+.Xr strrchr 3 ,
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsspn 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcsrchr
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcsrchr
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wcsspn.3
new file mode 100644
index 0000000000..66505c59d1
--- /dev/null
+++ b/src/lib/libc/string/wcsspn.3
@@ -0,0 +1,79 @@
+.\"     $OpenBSD: wcsspn.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSSPN 3
+.Os
+.Sh NAME
+.Nm wcsspn
+.Nd span a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft size_t
+.Fn wcsspn "const wchar_t *s" "const wchar_t *charset"
+.Sh DESCRIPTION
+The
+.Fn wcsspn
+function spans the initial part of the wide string
+.Fa s
+as long as the wide characters from
+.Fa s
+occur in the wide string
+.Fa charset .
+.Sh RETURN VALUES
+The
+.Fn wcsspn
+function returns the number of wide characters spanned.
+.Sh SEE ALSO
+.Xr strspn 3 ,
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcsspn
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcsspn
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wcsstr.3
new file mode 100644
index 0000000000..73f85c3504
--- /dev/null
+++ b/src/lib/libc/string/wcsstr.3
@@ -0,0 +1,88 @@
+.\"     $OpenBSD: wcsstr.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSSTR 3
+.Os
+.Sh NAME
+.Nm wcsstr
+.Nd locate a wide substring in a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wcsstr "const wchar_t *big" "const wchar_t *little"
+.Sh DESCRIPTION
+The
+.Fn wcsstr
+function locates the first occurrence of the wide string
+.Fa little
+in the wide string
+.Fa big .
+.Pp
+If
+.Fa little
+is an empty wide string,
+.Fa big
+is returned;
+if
+.Fa little
+occurs nowhere in
+.Fa big ,
+.Dv NULL
+is returned;
+otherwise a pointer to the first wide character of the first occurrence of
+.Fa little
+is returned.
+.Sh SEE ALSO
+.Xr strstr 3 ,
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3 ,
+.Xr wcstok 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcsstr
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wcsstr
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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..33ba1318a1
--- /dev/null
+++ b/src/lib/libc/string/wcstok.3
@@ -0,0 +1,151 @@
+.\"     $OpenBSD: wcstok.3,v 1.7 2011/07/25 00:38:53 schwarze 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 $Mdocdate: July 25 2011 $
+.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
+.Xr strtok_r 3
+function.
+.Pp
+Since
+.Fn wcstok
+modifies the string,
+.Fa str
+should not point to an area in the initialized data segment.
+.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 ,
+.Xr wcsstr 3 ,
+.Xr wmemchr 3
+.Sh STANDARDS
+The
+.Fn wcstok
+function
+conforms to
+.St -isoC-99 .
+.Sh HISTORY
+The
+.Fn wcstok
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
+.Pp
+Some early implementations of
+.Fn wcstok
+omit the
+context pointer argument,
+.Fa last ,
+and maintain state across calls in a static variable like
+.Xr strtok 3
+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.3 b/src/lib/libc/string/wcswidth.3
new file mode 100644
index 0000000000..a2a5b2df86
--- /dev/null
+++ b/src/lib/libc/string/wcswidth.3
@@ -0,0 +1,69 @@
+.\"     $OpenBSD: wcswidth.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" Copyright (c) 2002 Tim J. Robbins
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WCSWIDTH 3
+.Os
+.Sh NAME
+.Nm wcswidth
+.Nd number of column positions in wide-character string
+.Sh SYNOPSIS
+.In wchar.h
+.Ft int
+.Fn wcswidth "const wchar_t *pwcs" "size_t n"
+.Sh DESCRIPTION
+The
+.Fn wcswidth
+function determines the number of column positions required for the first
+.Fa n
+characters of
+.Fa pwcs ,
+or until a null wide character (L'\e0') is encountered.
+.Sh RETURN VALUES
+The
+.Fn wcswidth
+function returns 0 if
+.Fa pwcs
+is an empty string (L""),
+\-1 if a non-printing wide character is encountered,
+otherwise it returns the number of column positions occupied.
+.Sh SEE ALSO
+.Xr iswprint 3 ,
+.Xr strlen 3 ,
+.Xr wcslen 3 ,
+.Xr wcwidth 3
+.Sh STANDARDS
+The
+.Fn wcswidth
+function conforms to
+.St -p1003.1-2001 .
+.Sh HISTORY
+The
+.Fn wcswidth
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
diff --git a/src/lib/libc/string/wcswidth.c b/src/lib/libc/string/wcswidth.c
new file mode 100644
index 0000000000..8ea1bdf6e6
--- /dev/null
+++ b/src/lib/libc/string/wcswidth.c
@@ -0,0 +1,50 @@
+/*      $OpenBSD: wcswidth.c,v 1.4 2011/04/04 18:16:24 stsp 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, q;
+
+        w = 0;
+        while (n && *s) {
+                q = wcwidth(*s);
+                if (q == -1)
+                        return (-1);
+                w += q;
+                s++;
+                n--;
+        }
+
+        return w;
+}
diff --git a/src/lib/libc/string/index.3 b/src/lib/libc/string/wmemchr.3
index 847b03628b..21df1aaa88 100644
--- a/src/lib/libc/string/index.3
+++ b/src/lib/libc/string/wmemchr.3
@@ -1,8 +1,12 @@
+.\"     $OpenBSD: wmemchr.3,v 1.9 2011/07/25 00:38:53 schwarze Exp $
+.\"
 .\" 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.
+.\" 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:
@@ -11,11 +15,7 @@
 .\" 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
+.\" 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.
 .\"
@@ -31,53 +31,51 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.\"     from: @(#)index.3       5.3 (Berkeley) 4/19/91
-.\"     $Id: index.3,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $
-.\"
-.Dd April 19, 1991
-.Dt INDEX 3
+.Dd $Mdocdate: July 25 2011 $
+.Dt WMEMCHR 3
 .Os
 .Sh NAME
-.Nm index
-.Nd locate character in string
+.Nm wmemchr
+.Nd locate wide character in wide string
 .Sh SYNOPSIS
-.Fd #include <string.h>
-.Ft char *
-.Fn index "const char *s" "int c"
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wmemchr "const wchar_t *b" "wchar_t c" "size_t len"
 .Sh DESCRIPTION
 The
-.Fn index
-function
-locates the first character matching
+.Fn wmemchr
+function locates the first occurrence of
 .Fa c
-(converted to a
-.Em char )
-in the null-terminated string
-.Fa s .
+in wide string
+.Fa b .
 .Sh RETURN VALUES
-The character
-.Fa c
-is returned if it is found; otherwise
+The
+.Fn wmemchr
+function returns a pointer to the wide character located, or
 .Dv NULL
-is returned.
-If
-.Fa c
-is '\e0',
-.Fn index
-locates the terminating '\e0'.
+if no such wide character exists within
+.Fa len
+wide characters.
 .Sh SEE ALSO
 .Xr memchr 3 ,
-.Xr rindex 3 ,
-.Xr strchr 3 ,
-.Xr strcspn 3 ,
-.Xr strpbrk 3 ,
-.Xr strrchr 3 ,
-.Xr strsep 3 ,
-.Xr strspn 3 ,
-.Xr strstr 3 ,
-.Xr strtok 3
+.Xr wcschr 3 ,
+.Xr wcscspn 3 ,
+.Xr wcspbrk 3 ,
+.Xr wcsrchr 3 ,
+.Xr wcsspn 3 ,
+.Xr wcsstr 3 ,
+.Xr wcstok 3
+.Sh STANDARDS
+The
+.Fn wmemchr
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
 .Sh HISTORY
-A
-.Fn index
-function appeared in 
-.At v6 .
+The
+.Fn wmemchr
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wmemcmp.3
new file mode 100644
index 0000000000..6006b4e5c1
--- /dev/null
+++ b/src/lib/libc/string/wmemcmp.3
@@ -0,0 +1,78 @@
+.\"     $OpenBSD: wmemcmp.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WMEMCMP 3
+.Os
+.Sh NAME
+.Nm wmemcmp
+.Nd compare wide strings
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft int
+.Fn wmemcmp "const wchar_t *s1" "const wchar_t *s2" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wmemcmp
+function compares the wide string
+.Fa s1
+against the wide string
+.Fa s2 .
+Both wide strings are assumed to be
+.Fa len
+wide characters long.
+.Sh RETURN VALUES
+The
+.Fn wmemcmp
+function returns zero if the two wide strings are identical,
+otherwise the difference between the first two differing wide characters is
+returned.
+Zero-length wide strings are always identical.
+.Sh SEE ALSO
+.Xr memcmp 3 ,
+.Xr wcscasecmp 3 ,
+.Xr wcscmp 3
+.Sh STANDARDS
+The
+.Fn wmemcmp
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wmemcmp
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wmemcpy.3
new file mode 100644
index 0000000000..1102640ad4
--- /dev/null
+++ b/src/lib/libc/string/wmemcpy.3
@@ -0,0 +1,85 @@
+.\"     $OpenBSD: wmemcpy.3,v 1.3 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WMEMCPY 3
+.Os
+.Sh NAME
+.Nm wmemcpy
+.Nd copy wide characters
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wmemcpy "wchar_t * restrict dst" "const wchar_t * restrict src" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wmemcpy
+function copies
+.Fa len
+wide characters from buffer
+.Fa src
+to buffer
+.Fa dst .
+.Sh RETURN VALUES
+The
+.Fn wmemcpy
+function returns the original value of
+.Fa dst .
+.Sh SEE ALSO
+.Xr memcpy 3 ,
+.Xr wcscpy 3 ,
+.Xr wcslcpy 3 ,
+.Xr wmemmove 3
+.Sh STANDARDS
+The
+.Fn wmemcpy
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wmemcpy
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
+.Sh CAVEATS
+In this implementation
+.Fn wmemcpy
+is implemented using
+.Xr bcopy 3 ,
+and therefore the buffers may overlap.
+On other systems, copying overlapping buffers may produce surprises.
+A portable, safe solution is to use
+.Xr wmemmove 3 .
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.3 b/src/lib/libc/string/wmemmove.3
new file mode 100644
index 0000000000..45daa854ba
--- /dev/null
+++ b/src/lib/libc/string/wmemmove.3
@@ -0,0 +1,78 @@
+.\"     $OpenBSD: wmemmove.3,v 1.2 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WMEMMOVE 3
+.Os
+.Sh NAME
+.Nm wmemmove
+.Nd copy wide characters
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wmemmove "wchar_t *dst" "const wchar_t *src" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wmemmove
+function copies
+.Fa len
+wide characters 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 wmemmove
+function returns the original value of
+.Fa dst .
+.Sh SEE ALSO
+.Xr memmove 3 ,
+.Xr wcscpy 3 ,
+.Xr wcslcpy 3 ,
+.Xr wmemcpy 3
+.Sh STANDARDS
+The
+.Fn wmemmove
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wmemmove
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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.3 b/src/lib/libc/string/wmemset.3
new file mode 100644
index 0000000000..1b840762ec
--- /dev/null
+++ b/src/lib/libc/string/wmemset.3
@@ -0,0 +1,73 @@
+.\"     $OpenBSD: wmemset.3,v 1.3 2011/07/25 00:38:53 schwarze Exp $
+.\"
+.\" 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.
+.\"
+.Dd $Mdocdate: July 25 2011 $
+.Dt WMEMSET 3
+.Os
+.Sh NAME
+.Nm wmemset
+.Nd write a wide string
+.Sh SYNOPSIS
+.Fd #include <wchar.h>
+.Ft wchar_t *
+.Fn wmemset "wchar_t *s" "wchar_t c" "size_t len"
+.Sh DESCRIPTION
+The
+.Fn wmemset
+function writes
+.Fa len
+wide characters of value
+.Fa c
+to the wide string
+.Fa s .
+.Sh RETURN VALUES
+The
+.Fn wmemset
+function returns the original value of
+.Fa s .
+.Sh SEE ALSO
+.Xr memset 3
+.Sh STANDARDS
+The
+.Fn wmemset
+function conforms to
+.St -isoC-99
+and was first introduced in
+.St -isoC-amd1 .
+.Sh HISTORY
+The
+.Fn wmemset
+function was ported from
+.Nx
+and first appeared in
+.Ox 3.8 .
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;
+}