272 files changed, 25776 insertions, 4902 deletions

diff --git a/src/lib/libc/crypt/Makefile.inc b/src/lib/libc/crypt/Makefile.inc
new file mode 100644
index 0000000000..e64117fbd7
--- /dev/null
+++ b/src/lib/libc/crypt/Makefile.inc
@@ -0,0 +1,14 @@
+#       $OpenBSD: Makefile.inc,v 1.13 1999/11/17 05:22:36 millert Exp $
+
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/crypt ${LIBCSRCDIR}/crypt
+
+SRCS+=  cast.c crypt.c morecrypt.c md5crypt.c arc4random.c blowfish.c
+SRCS+=  bcrypt.c skipjack.c
+
+MAN+=   crypt.3 blowfish.3 arc4random.3
+MLINKS+=crypt.3 encrypt.3 crypt.3 setkey.3 crypt.3 des_cipher.3
+MLINKS+=crypt.3 des_setkey.3 blowfish.3 blf_key.3 blowfish.3 blf_enc.3
+MLINKS+=blowfish.3 blf_dec.3 blowfish.3 blf_ecb_encrypt.3
+MLINKS+=blowfish.3 blf_ecb_decrypt.3 blowfish.3 blf_cbc_encrypt.3
+MLINKS+=blowfish.3 blf_cbc_decrypt.3
+MLINKS+=arc4random.3 arc4random_stir.3 arc4random.3 arc4random_addrandom.3
diff --git a/src/lib/libc/crypt/arc4random.3 b/src/lib/libc/crypt/arc4random.3
new file mode 100644
index 0000000000..d8e0f8cda6
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.3
@@ -0,0 +1,110 @@
+.\" $OpenBSD: arc4random.3,v 1.17 2000/12/21 14:07:41 aaron Exp $
+.\"
+.\" Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"      This product includes software developed by Niels Provos.
+.\" 4. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd April 15, 1997
+.Dt ARC4RANDOM 3
+.Os
+.Sh NAME
+.Nm arc4random ,
+.Nm arc4random_stir ,
+.Nm arc4random_addrandom
+.Nd arc4 random number generator
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft u_int32_t
+.Fn arc4random "void"
+.Ft void
+.Fn arc4random_stir "void"
+.Ft void
+.Fn arc4random_addrandom "u_char *dat" "int datlen"
+.Sh DESCRIPTION
+The
+.Fn arc4random
+function provides a high quality 32-bit pseudo-random
+number very quickly.
+.Fn arc4random
+seeds itself on a regular basis from the kernel strong random number
+subsystem described in
+.Xr random 4 .
+On each call, an ARC4 generator is used to generate a new result.
+The
+.Fn arc4random
+function uses the ARC4 cipher key stream generator,
+which uses 8*8 8 bit S-Boxes.
+The S-Boxes can be in about (2**1700) states.
+.Pp
+.Fn arc4random
+fits into a middle ground not covered by other subsystems such as
+the strong, slow, and resource expensive random
+devices described in
+.Xr random 4
+versus the fast but poor quality interfaces described in
+.Xr rand 3 ,
+.Xr random 3 ,
+and
+.Xr drand48 3 .
+.Pp
+The
+.Fn arc4random_stir
+function reads data from
+.Pa /dev/arandom
+and uses it to permute the S-Boxes via
+.Fn arc4random_addrandom .
+.Pp
+There is no need to call
+.Fn arc4random_stir
+before using
+.Fn arc4random ,
+since
+.Fn arc4random
+automatically initializes itself.
+.Sh SEE ALSO
+.Xr rand 3 ,
+.Xr rand48 3 ,
+.Xr random 3
+.Sh HISTORY
+An algorithm called
+.Pa RC4
+was designed by RSA Data Security, Inc.
+It was considered a trade secret, but not trademarked.
+Because it was a trade secret, it obviously could not be patented.
+A clone of this was posted anonymously to USENET and confirmed to
+be equivalent by several sources who had access to the original cipher.
+Because of the trade secret situation, RSA Data Security, Inc. can do
+nothing about the release of the ARC4 algorithm.
+Since
+.Pa RC4
+used to be a trade secret, the cipher is now referred to as
+.Pa ARC4 .
+.Pp
+These functions first appeared in
+.Ox 2.1 .
diff --git a/src/lib/libc/crypt/arc4random.c b/src/lib/libc/crypt/arc4random.c
new file mode 100644
index 0000000000..a41001bcc3
--- /dev/null
+++ b/src/lib/libc/crypt/arc4random.c
@@ -0,0 +1,195 @@
+/*      $OpenBSD: arc4random.c,v 1.7 2003/02/14 17:12:54 deraadt Exp $  */
+
+/*
+ * Arc4 random number generator for OpenBSD.
+ * Copyright 1996 David Mazieres <dm@lcs.mit.edu>.
+ *
+ * Modification and redistribution in source and binary forms is
+ * permitted provided that due credit is given to the author and the
+ * OpenBSD project by leaving this copyright notice intact.
+ */
+
+/*
+ * This code is derived from section 17.1 of Applied Cryptography,
+ * second edition, which describes a stream cipher allegedly
+ * compatible with RSA Labs "RC4" cipher (the actual description of
+ * which is a trade secret).  The same algorithm is used as a stream
+ * cipher called "arcfour" in Tatu Ylonen's ssh package.
+ *
+ * Here the stream cipher has been modified always to include the time
+ * when initializing the state.  That makes it impossible to
+ * regenerate the same random sequence twice, so this can't be used
+ * for encryption, but will generate good random numbers.
+ *
+ * RC4 is a registered trademark of RSA Laboratories.
+ */
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/sysctl.h>
+
+#ifdef __GNUC__
+#define inline __inline
+#else                           /* !__GNUC__ */
+#define inline
+#endif                          /* !__GNUC__ */
+
+struct arc4_stream {
+        u_int8_t i;
+        u_int8_t j;
+        u_int8_t s[256];
+};
+
+static int rs_initialized;
+static struct arc4_stream rs;
+static pid_t arc4_stir_pid;
+
+static inline void
+arc4_init(as)
+        struct arc4_stream *as;
+{
+        int     n;
+
+        for (n = 0; n < 256; n++)
+                as->s[n] = n;
+        as->i = 0;
+        as->j = 0;
+}
+
+static inline void
+arc4_addrandom(as, dat, datlen)
+        struct arc4_stream *as;
+        u_char *dat;
+        int     datlen;
+{
+        int     n;
+        u_int8_t si;
+
+        as->i--;
+        for (n = 0; n < 256; n++) {
+                as->i = (as->i + 1);
+                si = as->s[as->i];
+                as->j = (as->j + si + dat[n % datlen]);
+                as->s[as->i] = as->s[as->j];
+                as->s[as->j] = si;
+        }
+        as->j = as->i;
+}
+
+static void
+arc4_stir(as)
+        struct arc4_stream *as;
+{
+        int     fd;
+        struct {
+                struct timeval tv;
+                u_int rnd[(128 - sizeof(struct timeval)) / sizeof(u_int)];
+        }       rdat;
+
+        gettimeofday(&rdat.tv, NULL);
+        fd = open("/dev/arandom", O_RDONLY);
+        if (fd != -1) {
+                read(fd, rdat.rnd, sizeof(rdat.rnd));
+                close(fd);
+        } else {
+                int i, mib[2];
+                size_t len;
+
+                /* Device could not be opened, we might be chrooted, take
+                 * randomness from sysctl. */
+
+                mib[0] = CTL_KERN;
+                mib[1] = KERN_ARND;
+
+                for (i = 0; i < sizeof(rdat.rnd) / sizeof(u_int); i ++) {
+                        len = sizeof(u_int);
+                        if (sysctl(mib, 2, &rdat.rnd[i], &len, NULL, 0) == -1)
+                                break;
+                }
+        }
+        /* fd < 0 or failed sysctl ?  Ah, what the heck. We'll just take
+         * whatever was on the stack... */
+
+        arc4_stir_pid = getpid();
+        arc4_addrandom(as, (void *) &rdat, sizeof(rdat));
+}
+
+static inline u_int8_t
+arc4_getbyte(as)
+        struct arc4_stream *as;
+{
+        u_int8_t si, sj;
+
+        as->i = (as->i + 1);
+        si = as->s[as->i];
+        as->j = (as->j + si);
+        sj = as->s[as->j];
+        as->s[as->i] = sj;
+        as->s[as->j] = si;
+        return (as->s[(si + sj) & 0xff]);
+}
+
+static inline u_int32_t
+arc4_getword(as)
+        struct arc4_stream *as;
+{
+        u_int32_t val;
+        val = arc4_getbyte(as) << 24;
+        val |= arc4_getbyte(as) << 16;
+        val |= arc4_getbyte(as) << 8;
+        val |= arc4_getbyte(as);
+        return val;
+}
+
+void
+arc4random_stir()
+{
+        if (!rs_initialized) {
+                arc4_init(&rs);
+                rs_initialized = 1;
+        }
+        arc4_stir(&rs);
+}
+
+void
+arc4random_addrandom(dat, datlen)
+        u_char *dat;
+        int     datlen;
+{
+        if (!rs_initialized)
+                arc4random_stir();
+        arc4_addrandom(&rs, dat, datlen);
+}
+
+u_int32_t
+arc4random()
+{
+        if (!rs_initialized || arc4_stir_pid != getpid())
+                arc4random_stir();
+        return arc4_getword(&rs);
+}
+
+#if 0
+/*-------- Test code for i386 --------*/
+#include <stdio.h>
+#include <machine/pctr.h>
+int
+main(int argc, char **argv)
+{
+        const int iter = 1000000;
+        int     i;
+        pctrval v;
+
+        v = rdtsc();
+        for (i = 0; i < iter; i++)
+                arc4random();
+        v = rdtsc() - v;
+        v /= iter;
+
+        printf("%qd cycles\n", v);
+}
+#endif
diff --git a/src/lib/libc/crypt/bcrypt.c b/src/lib/libc/crypt/bcrypt.c
new file mode 100644
index 0000000000..dec0093dd8
--- /dev/null
+++ b/src/lib/libc/crypt/bcrypt.c
@@ -0,0 +1,334 @@
+/*      $OpenBSD: bcrypt.c,v 1.16 2002/02/19 19:39:36 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);
+ *
+ */
+
+#if 0
+#include <stdio.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <pwd.h>
+#include <blf.h>
+
+/* This implementation is adaptable to current computing power.
+ * You can have up to 2^31 rounds which should be enough for some
+ * time to come.
+ */
+
+#define BCRYPT_VERSION '2'
+#define BCRYPT_MAXSALT 16       /* Precomputation is just so nice */
+#define BCRYPT_BLOCKS 6         /* Ciphertext blocks */
+#define BCRYPT_MINROUNDS 16     /* we have log2(rounds) in salt */
+
+char   *bcrypt_gensalt(u_int8_t);
+
+static void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);
+static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t);
+static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *);
+
+static char    encrypted[_PASSWORD_LEN];
+static char    gsalt[BCRYPT_MAXSALT * 4 / 3 + 1];
+static char    error[] = ":";
+
+const static u_int8_t Base64Code[] =
+"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+const static u_int8_t index_64[128] =
+{
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 0, 1, 54, 55,
+        56, 57, 58, 59, 60, 61, 62, 63, 255, 255,
+        255, 255, 255, 255, 255, 2, 3, 4, 5, 6,
+        7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+        255, 255, 255, 255, 255, 255, 28, 29, 30,
+        31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+        41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+        51, 52, 53, 255, 255, 255, 255, 255
+};
+#define CHAR64(c)  ( (c) > 127 ? 255 : index_64[(c)])
+
+static void
+decode_base64(u_int8_t *buffer, u_int16_t len, u_int8_t *data)
+{
+        u_int8_t *bp = buffer;
+        u_int8_t *p = data;
+        u_int8_t c1, c2, c3, c4;
+        while (bp < buffer + len) {
+                c1 = CHAR64(*p);
+                c2 = CHAR64(*(p + 1));
+
+                /* Invalid data */
+                if (c1 == 255 || c2 == 255)
+                        break;
+
+                *bp++ = (c1 << 2) | ((c2 & 0x30) >> 4);
+                if (bp >= buffer + len)
+                        break;
+
+                c3 = CHAR64(*(p + 2));
+                if (c3 == 255)
+                        break;
+
+                *bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2);
+                if (bp >= buffer + len)
+                        break;
+
+                c4 = CHAR64(*(p + 3));
+                if (c4 == 255)
+                        break;
+                *bp++ = ((c3 & 0x03) << 6) | c4;
+
+                p += 4;
+        }
+}
+
+static void
+encode_salt(char *salt, u_int8_t *csalt, u_int16_t clen, u_int8_t logr)
+{
+        salt[0] = '$';
+        salt[1] = BCRYPT_VERSION;
+        salt[2] = 'a';
+        salt[3] = '$';
+
+        snprintf(salt + 4, 4, "%2.2u$", logr);
+
+        encode_base64((u_int8_t *) salt + 7, csalt, clen);
+}
+/* Generates a salt for this version of crypt.
+   Since versions may change. Keeping this here
+   seems sensible.
+ */
+
+char *
+bcrypt_gensalt(u_int8_t log_rounds)
+{
+        u_int8_t csalt[BCRYPT_MAXSALT];
+        u_int16_t i;
+        u_int32_t seed = 0;
+
+        for (i = 0; i < BCRYPT_MAXSALT; i++) {
+                if (i % 4 == 0)
+                        seed = arc4random();
+                csalt[i] = seed & 0xff;
+                seed = seed >> 8;
+        }
+
+        if (log_rounds < 4)
+                log_rounds = 4;
+
+        encode_salt(gsalt, csalt, BCRYPT_MAXSALT, log_rounds);
+        return gsalt;
+}
+/* We handle $Vers$log2(NumRounds)$salt+passwd$
+   i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */
+
+char   *
+bcrypt(key, salt)
+        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];
+
+        /* 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 */
+        if ((rounds = (u_int32_t) 1 << (logr = atoi(salt))) < BCRYPT_MINROUNDS)
+                return error;
+
+        /* Discard num rounds + "$" identifier */
+        salt += 3;
+
+        if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT)
+                return error;
+
+        /* We dont want the base64 salt but the raw data */
+        decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt);
+        salt_len = BCRYPT_MAXSALT;
+        key_len = strlen(key) + (minor >= 'a' ? 1 : 0);
+
+        /* Setting up S-Boxes and Subkeys */
+        Blowfish_initstate(&state);
+        Blowfish_expandstate(&state, csalt, salt_len,
+            (u_int8_t *) key, key_len);
+        for (k = 0; k < rounds; k++) {
+                Blowfish_expand0state(&state, (u_int8_t *) key, key_len);
+                Blowfish_expand0state(&state, csalt, salt_len);
+        }
+
+        /* This can be precomputed later */
+        j = 0;
+        for (i = 0; i < BCRYPT_BLOCKS; i++)
+                cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j);
+
+        /* Now do the encryption */
+        for (k = 0; k < 64; k++)
+                blf_enc(&state, cdata, BCRYPT_BLOCKS / 2);
+
+        for (i = 0; i < BCRYPT_BLOCKS; i++) {
+                ciphertext[4 * i + 3] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 2] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 1] = cdata[i] & 0xff;
+                cdata[i] = cdata[i] >> 8;
+                ciphertext[4 * i + 0] = cdata[i] & 0xff;
+        }
+
+
+        i = 0;
+        encrypted[i++] = '$';
+        encrypted[i++] = BCRYPT_VERSION;
+        if (minor)
+                encrypted[i++] = minor;
+        encrypted[i++] = '$';
+
+        snprintf(encrypted + i, 4, "%2.2u$", logr);
+
+        encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT);
+        encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext,
+            4 * BCRYPT_BLOCKS - 1);
+        return encrypted;
+}
+
+static void
+encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len)
+{
+        u_int8_t *bp = buffer;
+        u_int8_t *p = data;
+        u_int8_t c1, c2;
+        while (p < data + len) {
+                c1 = *p++;
+                *bp++ = Base64Code[(c1 >> 2)];
+                c1 = (c1 & 0x03) << 4;
+                if (p >= data + len) {
+                        *bp++ = Base64Code[c1];
+                        break;
+                }
+                c2 = *p++;
+                c1 |= (c2 >> 4) & 0x0f;
+                *bp++ = Base64Code[c1];
+                c1 = (c2 & 0x0f) << 2;
+                if (p >= data + len) {
+                        *bp++ = Base64Code[c1];
+                        break;
+                }
+                c2 = *p++;
+                c1 |= (c2 >> 6) & 0x03;
+                *bp++ = Base64Code[c1];
+                *bp++ = Base64Code[c2 & 0x3f];
+        }
+        *bp = '\0';
+}
+#if 0
+void
+main()
+{
+        char    blubber[73];
+        char    salt[100];
+        char   *p;
+        salt[0] = '$';
+        salt[1] = BCRYPT_VERSION;
+        salt[2] = '$';
+
+        snprintf(salt + 3, 4, "%2.2u$", 5);
+
+        printf("24 bytes of salt: ");
+        fgets(salt + 6, 94, stdin);
+        salt[99] = 0;
+        printf("72 bytes of password: ");
+        fpurge(stdin);
+        fgets(blubber, 73, stdin);
+        blubber[72] = 0;
+
+        p = crypt(blubber, salt);
+        printf("Passwd entry: %s\n\n", p);
+
+        p = bcrypt_gensalt(5);
+        printf("Generated salt: %s\n", p);
+        p = crypt(blubber, p);
+        printf("Passwd entry: %s\n", p);
+}
+#endif
diff --git a/src/lib/libc/crypt/blowfish.3 b/src/lib/libc/crypt/blowfish.3
new file mode 100644
index 0000000000..3e600658fa
--- /dev/null
+++ b/src/lib/libc/crypt/blowfish.3
@@ -0,0 +1,106 @@
+.\" $OpenBSD: blowfish.3,v 1.10 2001/08/06 10:42:25 mpech Exp $
+.\"
+.\" Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"      This product includes software developed by Niels Provos.
+.\" 4. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd February 13, 1997
+.Dt BLOWFISH 3
+.Os
+.Sh NAME
+.Nm blf_key ,
+.Nm blf_enc ,
+.Nm blf_dec
+.Nd Blowfish encryption
+.Sh SYNOPSIS
+.Fd #include <blf.h>
+.Ft void
+.Fn blf_key "blf_ctx *state" "const u_int8_t *key" "u_int16_t keylen"
+.Ft void
+.Fn blf_enc "blf_ctx *state" "u_int32_t *data" "u_int16_t datalen"
+.Ft void
+.Fn blf_dec "blf_ctx *state" "u_int32_t *data" "u_int16_t datalen"
+.Ft void
+.Fn blf_ecb_encrypt "blf_ctx *state" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_ecb_decrypt "blf_ctx *state" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_cbc_encrypt "blf_ctx *state" "u_int8_t *iv" "u_int8_t *data" "u_int32_t datalen"
+.Ft void
+.Fn blf_cbc_decrypt "blf_ctx *state" "u_int8_t *iv" "u_int8_t *data" "u_int32_t datalen"
+.Sh DESCRIPTION
+.Pa Blowfish
+is a fast unpatented block cipher designed by Bruce Schneier.
+It basically consists of a 16 times iterated Feistel network.
+The block size is 64 bit and the key size is maximal 448 bit.
+.Pp
+The
+.Fn blf_key
+function initializes the 4 8bit S-boxes and the 18 Subkeys with
+the hexadecimal digits of Pi.
+The key is used for further randomization.
+The first argument to
+.Fn blf_enc
+is the initialized state derived from
+.Fn blf_key .
+The stream of 32-bit words is encrypted in Electronic Codebook
+Mode (ECB) and
+.Pa datalen
+must be even.
+.Fn blf_dec
+is used for decrypting Blowfish encrypted blocks.
+.Pp
+The functions
+.Fn blf_ecb_encrypt
+and
+.Fn blf_ecb_decrypt
+are used for encrypting and decrypting octet streams in ECB mode.
+The functions
+.Fn blf_cbc_encrypt
+and
+.Fn blf_cbc_decrypt
+are used for encrypting and decrypting octet streams in
+Cipherblock Chaining Mode (CBC).
+.Pp
+The functions
+.Fn Blowfish_initstate ,
+.Fn Blowfish_expand0state ,
+.Fn Blowfish_expandstate ,
+.Fn Blowfish_encipher
+and
+.Fn Blowfish_decipher
+are used for customization of the
+.Pa Blowfish
+cipher, e.g., for the blowfish password hashing function.
+.Sh SEE ALSO
+.Xr passwd 1 ,
+.Xr crypt 3 ,
+.Xr passwd 5
+.Sh AUTHORS
+Niels Provos <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..12226b5215
--- /dev/null
+++ b/src/lib/libc/crypt/blowfish.c
@@ -0,0 +1,694 @@
+/* $OpenBSD: blowfish.c,v 1.17 2003/04/09 21:46:02 markus 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(c, xl, xr)
+        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(c, xl, xr)
+        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(c)
+        blf_ctx *c;
+{
+
+/* P-box and S-box tables initialized with digits of Pi */
+
+        static const blf_ctx initstate =
+
+        { {
+                {
+                        0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+                        0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+                        0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+                        0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+                        0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+                        0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+                        0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+                        0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+                        0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+                        0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+                        0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+                        0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+                        0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+                        0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+                        0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+                        0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+                        0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+                        0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+                        0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+                        0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+                        0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+                        0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+                        0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+                        0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+                        0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+                        0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+                        0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+                        0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+                        0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+                        0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+                        0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+                        0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+                        0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+                        0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+                        0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+                        0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+                        0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+                        0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+                        0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+                        0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+                        0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+                        0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+                        0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+                        0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+                        0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+                        0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+                        0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+                        0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+                        0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+                        0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+                        0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+                        0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+                        0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+                        0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+                        0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+                        0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+                        0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+                        0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+                        0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+                        0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+                        0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+                        0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+                        0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
+                {
+                        0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+                        0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+                        0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+                        0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+                        0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+                        0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+                        0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+                        0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+                        0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+                        0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+                        0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+                        0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+                        0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+                        0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+                        0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+                        0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+                        0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+                        0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+                        0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+                        0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+                        0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+                        0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+                        0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+                        0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+                        0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+                        0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+                        0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+                        0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+                        0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+                        0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+                        0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+                        0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+                        0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+                        0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+                        0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+                        0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+                        0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+                        0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+                        0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+                        0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+                        0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+                        0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+                        0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+                        0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+                        0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+                        0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+                        0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+                        0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+                        0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+                        0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+                        0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+                        0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+                        0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+                        0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+                        0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+                        0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+                        0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+                        0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+                        0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+                        0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+                        0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+                        0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+                        0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
+                {
+                        0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+                        0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+                        0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+                        0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+                        0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+                        0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+                        0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+                        0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+                        0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+                        0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+                        0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+                        0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+                        0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+                        0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+                        0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+                        0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+                        0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+                        0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+                        0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+                        0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+                        0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+                        0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+                        0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+                        0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+                        0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+                        0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+                        0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+                        0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+                        0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+                        0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+                        0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+                        0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+                        0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+                        0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+                        0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+                        0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+                        0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+                        0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+                        0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+                        0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+                        0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+                        0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+                        0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+                        0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+                        0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+                        0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+                        0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+                        0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+                        0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+                        0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+                        0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+                        0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+                        0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+                        0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+                        0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+                        0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+                        0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+                        0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+                        0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+                        0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+                        0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+                        0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+                        0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
+                {
+                        0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+                        0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+                        0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+                        0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+                        0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+                        0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+                        0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+                        0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+                        0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+                        0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+                        0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+                        0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+                        0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+                        0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+                        0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+                        0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+                        0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+                        0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+                        0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+                        0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+                        0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+                        0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+                        0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+                        0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+                        0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+                        0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+                        0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+                        0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+                        0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+                        0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+                        0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+                        0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+                        0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+                        0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+                        0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+                        0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+                        0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+                        0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+                        0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+                        0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+                        0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+                        0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+                        0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+                        0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+                        0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+                        0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+                        0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+                        0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+                        0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+                        0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+                        0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+                        0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+                        0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+                        0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+                        0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+                        0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+                        0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+                        0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+                        0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+                        0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+                        0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+                        0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+                        0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
+        },
+        {
+                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+                0x9216d5d9, 0x8979fb1b
+        } };
+
+        *c = initstate;
+
+}
+
+u_int32_t
+Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes, u_int16_t *current)
+{
+        u_int8_t i;
+        u_int16_t j;
+        u_int32_t temp;
+
+        temp = 0x00000000;
+        j = *current;
+
+        for (i = 0; i < 4; i++, j++) {
+                if (j >= databytes)
+                        j = 0;
+                temp = (temp << 8) | data[j];
+        }
+
+        *current = j;
+        return temp;
+}
+
+void
+Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
+{
+        u_int16_t i;
+        u_int16_t j;
+        u_int16_t k;
+        u_int32_t temp;
+        u_int32_t datal;
+        u_int32_t datar;
+
+        j = 0;
+        for (i = 0; i < BLF_N + 2; i++) {
+                /* Extract 4 int8 to 1 int32 from keystream */
+                temp = Blowfish_stream2word(key, keybytes, &j);
+                c->P[i] = c->P[i] ^ temp;
+        }
+
+        j = 0;
+        datal = 0x00000000;
+        datar = 0x00000000;
+        for (i = 0; i < BLF_N + 2; i += 2) {
+                Blowfish_encipher(c, &datal, &datar);
+
+                c->P[i] = datal;
+                c->P[i + 1] = datar;
+        }
+
+        for (i = 0; i < 4; i++) {
+                for (k = 0; k < 256; k += 2) {
+                        Blowfish_encipher(c, &datal, &datar);
+
+                        c->S[i][k] = datal;
+                        c->S[i][k + 1] = datar;
+                }
+        }
+}
+
+
+void
+Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
+                     const u_int8_t *key, u_int16_t keybytes)
+{
+        u_int16_t i;
+        u_int16_t j;
+        u_int16_t k;
+        u_int32_t temp;
+        u_int32_t datal;
+        u_int32_t datar;
+
+        j = 0;
+        for (i = 0; i < BLF_N + 2; i++) {
+                /* Extract 4 int8 to 1 int32 from keystream */
+                temp = Blowfish_stream2word(key, keybytes, &j);
+                c->P[i] = c->P[i] ^ temp;
+        }
+
+        j = 0;
+        datal = 0x00000000;
+        datar = 0x00000000;
+        for (i = 0; i < BLF_N + 2; i += 2) {
+                datal ^= Blowfish_stream2word(data, databytes, &j);
+                datar ^= Blowfish_stream2word(data, databytes, &j);
+                Blowfish_encipher(c, &datal, &datar);
+
+                c->P[i] = datal;
+                c->P[i + 1] = datar;
+        }
+
+        for (i = 0; i < 4; i++) {
+                for (k = 0; k < 256; k += 2) {
+                        datal ^= Blowfish_stream2word(data, databytes, &j);
+                        datar ^= Blowfish_stream2word(data, databytes, &j);
+                        Blowfish_encipher(c, &datal, &datar);
+
+                        c->S[i][k] = datal;
+                        c->S[i][k + 1] = datar;
+                }
+        }
+
+}
+
+void
+blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len)
+{
+        /* Initialize S-boxes and subkeys with Pi */
+        Blowfish_initstate(c);
+
+        /* Transform S-boxes and subkeys with key */
+        Blowfish_expand0state(c, k, len);
+}
+
+void
+blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+{
+        u_int32_t *d;
+        u_int16_t i;
+
+        d = data;
+        for (i = 0; i < blocks; i++) {
+                Blowfish_encipher(c, d, d + 1);
+                d += 2;
+        }
+}
+
+void
+blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+{
+        u_int32_t *d;
+        u_int16_t i;
+
+        d = data;
+        for (i = 0; i < blocks; i++) {
+                Blowfish_decipher(c, d, d + 1);
+                d += 2;
+        }
+}
+
+void
+blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i;
+
+        for (i = 0; i < len; i += 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_encipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                data += 8;
+        }
+}
+
+void
+blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i;
+
+        for (i = 0; i < len; i += 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_decipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                data += 8;
+        }
+}
+
+void
+blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int32_t i, j;
+
+        for (i = 0; i < len; i += 8) {
+                for (j = 0; j < 8; j++)
+                        data[j] ^= iv[j];
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_encipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                iv = data;
+                data += 8;
+        }
+}
+
+void
+blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
+{
+        u_int32_t l, r;
+        u_int8_t *iv;
+        u_int32_t i, j;
+
+        iv = data + len - 16;
+        data = data + len - 8;
+        for (i = len - 8; i >= 8; i -= 8) {
+                l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+                r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+                Blowfish_decipher(c, &l, &r);
+                data[0] = l >> 24 & 0xff;
+                data[1] = l >> 16 & 0xff;
+                data[2] = l >> 8 & 0xff;
+                data[3] = l & 0xff;
+                data[4] = r >> 24 & 0xff;
+                data[5] = r >> 16 & 0xff;
+                data[6] = r >> 8 & 0xff;
+                data[7] = r & 0xff;
+                for (j = 0; j < 8; j++)
+                        data[j] ^= iv[j];
+                iv -= 8;
+                data -= 8;
+        }
+        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
+        Blowfish_decipher(c, &l, &r);
+        data[0] = l >> 24 & 0xff;
+        data[1] = l >> 16 & 0xff;
+        data[2] = l >> 8 & 0xff;
+        data[3] = l & 0xff;
+        data[4] = r >> 24 & 0xff;
+        data[5] = r >> 16 & 0xff;
+        data[6] = r >> 8 & 0xff;
+        data[7] = r & 0xff;
+        for (j = 0; j < 8; j++)
+                data[j] ^= iva[j];
+}
+
+#if 0
+void
+report(u_int32_t data[], u_int16_t len)
+{
+        u_int16_t i;
+        for (i = 0; i < len; i += 2)
+                printf("Block %0hd: %08lx %08lx.\n",
+                    i / 2, data[i], data[i + 1]);
+}
+void
+main(void)
+{
+
+        blf_ctx c;
+        char    key[] = "AAAAA";
+        char    key2[] = "abcdefghijklmnopqrstuvwxyz";
+
+        u_int32_t data[10];
+        u_int32_t data2[] =
+        {0x424c4f57l, 0x46495348l};
+
+        u_int16_t i;
+
+        /* First test */
+        for (i = 0; i < 10; i++)
+                data[i] = i;
+
+        blf_key(&c, (u_int8_t *) key, 5);
+        blf_enc(&c, data, 5);
+        blf_dec(&c, data, 1);
+        blf_dec(&c, data + 2, 4);
+        printf("Should read as 0 - 9.\n");
+        report(data, 10);
+
+        /* Second test */
+        blf_key(&c, (u_int8_t *) key2, strlen(key2));
+        blf_enc(&c, data2, 1);
+        printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
+        report(data2, 2);
+        blf_dec(&c, data2, 1);
+        report(data2, 2);
+}
+#endif
diff --git a/src/lib/libc/crypt/cast.c b/src/lib/libc/crypt/cast.c
new file mode 100644
index 0000000000..264138f03e
--- /dev/null
+++ b/src/lib/libc/crypt/cast.c
@@ -0,0 +1,779 @@
+/*      $OpenBSD: cast.c,v 1.2 1998/07/21 22:42:03 provos Exp $       */
+/*
+ *      CAST-128 in C
+ *      Written by Steve Reid <sreid@sea-to-sky.net>
+ *      100% Public Domain - no warranty
+ *      Released 1997.10.11
+ */
+
+#include <sys/types.h>
+
+#include <cast.h>
+
+/* CAST S-Boxes */
+
+static const u_int32_t cast_sbox1[256] = {
+        0x30FB40D4, 0x9FA0FF0B, 0x6BECCD2F, 0x3F258C7A,
+        0x1E213F2F, 0x9C004DD3, 0x6003E540, 0xCF9FC949,
+        0xBFD4AF27, 0x88BBBDB5, 0xE2034090, 0x98D09675,
+        0x6E63A0E0, 0x15C361D2, 0xC2E7661D, 0x22D4FF8E,
+        0x28683B6F, 0xC07FD059, 0xFF2379C8, 0x775F50E2,
+        0x43C340D3, 0xDF2F8656, 0x887CA41A, 0xA2D2BD2D,
+        0xA1C9E0D6, 0x346C4819, 0x61B76D87, 0x22540F2F,
+        0x2ABE32E1, 0xAA54166B, 0x22568E3A, 0xA2D341D0,
+        0x66DB40C8, 0xA784392F, 0x004DFF2F, 0x2DB9D2DE,
+        0x97943FAC, 0x4A97C1D8, 0x527644B7, 0xB5F437A7,
+        0xB82CBAEF, 0xD751D159, 0x6FF7F0ED, 0x5A097A1F,
+        0x827B68D0, 0x90ECF52E, 0x22B0C054, 0xBC8E5935,
+        0x4B6D2F7F, 0x50BB64A2, 0xD2664910, 0xBEE5812D,
+        0xB7332290, 0xE93B159F, 0xB48EE411, 0x4BFF345D,
+        0xFD45C240, 0xAD31973F, 0xC4F6D02E, 0x55FC8165,
+        0xD5B1CAAD, 0xA1AC2DAE, 0xA2D4B76D, 0xC19B0C50,
+        0x882240F2, 0x0C6E4F38, 0xA4E4BFD7, 0x4F5BA272,
+        0x564C1D2F, 0xC59C5319, 0xB949E354, 0xB04669FE,
+        0xB1B6AB8A, 0xC71358DD, 0x6385C545, 0x110F935D,
+        0x57538AD5, 0x6A390493, 0xE63D37E0, 0x2A54F6B3,
+        0x3A787D5F, 0x6276A0B5, 0x19A6FCDF, 0x7A42206A,
+        0x29F9D4D5, 0xF61B1891, 0xBB72275E, 0xAA508167,
+        0x38901091, 0xC6B505EB, 0x84C7CB8C, 0x2AD75A0F,
+        0x874A1427, 0xA2D1936B, 0x2AD286AF, 0xAA56D291,
+        0xD7894360, 0x425C750D, 0x93B39E26, 0x187184C9,
+        0x6C00B32D, 0x73E2BB14, 0xA0BEBC3C, 0x54623779,
+        0x64459EAB, 0x3F328B82, 0x7718CF82, 0x59A2CEA6,
+        0x04EE002E, 0x89FE78E6, 0x3FAB0950, 0x325FF6C2,
+        0x81383F05, 0x6963C5C8, 0x76CB5AD6, 0xD49974C9,
+        0xCA180DCF, 0x380782D5, 0xC7FA5CF6, 0x8AC31511,
+        0x35E79E13, 0x47DA91D0, 0xF40F9086, 0xA7E2419E,
+        0x31366241, 0x051EF495, 0xAA573B04, 0x4A805D8D,
+        0x548300D0, 0x00322A3C, 0xBF64CDDF, 0xBA57A68E,
+        0x75C6372B, 0x50AFD341, 0xA7C13275, 0x915A0BF5,
+        0x6B54BFAB, 0x2B0B1426, 0xAB4CC9D7, 0x449CCD82,
+        0xF7FBF265, 0xAB85C5F3, 0x1B55DB94, 0xAAD4E324,
+        0xCFA4BD3F, 0x2DEAA3E2, 0x9E204D02, 0xC8BD25AC,
+        0xEADF55B3, 0xD5BD9E98, 0xE31231B2, 0x2AD5AD6C,
+        0x954329DE, 0xADBE4528, 0xD8710F69, 0xAA51C90F,
+        0xAA786BF6, 0x22513F1E, 0xAA51A79B, 0x2AD344CC,
+        0x7B5A41F0, 0xD37CFBAD, 0x1B069505, 0x41ECE491,
+        0xB4C332E6, 0x032268D4, 0xC9600ACC, 0xCE387E6D,
+        0xBF6BB16C, 0x6A70FB78, 0x0D03D9C9, 0xD4DF39DE,
+        0xE01063DA, 0x4736F464, 0x5AD328D8, 0xB347CC96,
+        0x75BB0FC3, 0x98511BFB, 0x4FFBCC35, 0xB58BCF6A,
+        0xE11F0ABC, 0xBFC5FE4A, 0xA70AEC10, 0xAC39570A,
+        0x3F04442F, 0x6188B153, 0xE0397A2E, 0x5727CB79,
+        0x9CEB418F, 0x1CACD68D, 0x2AD37C96, 0x0175CB9D,
+        0xC69DFF09, 0xC75B65F0, 0xD9DB40D8, 0xEC0E7779,
+        0x4744EAD4, 0xB11C3274, 0xDD24CB9E, 0x7E1C54BD,
+        0xF01144F9, 0xD2240EB1, 0x9675B3FD, 0xA3AC3755,
+        0xD47C27AF, 0x51C85F4D, 0x56907596, 0xA5BB15E6,
+        0x580304F0, 0xCA042CF1, 0x011A37EA, 0x8DBFAADB,
+        0x35BA3E4A, 0x3526FFA0, 0xC37B4D09, 0xBC306ED9,
+        0x98A52666, 0x5648F725, 0xFF5E569D, 0x0CED63D0,
+        0x7C63B2CF, 0x700B45E1, 0xD5EA50F1, 0x85A92872,
+        0xAF1FBDA7, 0xD4234870, 0xA7870BF3, 0x2D3B4D79,
+        0x42E04198, 0x0CD0EDE7, 0x26470DB8, 0xF881814C,
+        0x474D6AD7, 0x7C0C5E5C, 0xD1231959, 0x381B7298,
+        0xF5D2F4DB, 0xAB838653, 0x6E2F1E23, 0x83719C9E,
+        0xBD91E046, 0x9A56456E, 0xDC39200C, 0x20C8C571,
+        0x962BDA1C, 0xE1E696FF, 0xB141AB08, 0x7CCA89B9,
+        0x1A69E783, 0x02CC4843, 0xA2F7C579, 0x429EF47D,
+        0x427B169C, 0x5AC9F049, 0xDD8F0F00, 0x5C8165BF
+};
+
+static const u_int32_t cast_sbox2[256] = {
+        0x1F201094, 0xEF0BA75B, 0x69E3CF7E, 0x393F4380,
+        0xFE61CF7A, 0xEEC5207A, 0x55889C94, 0x72FC0651,
+        0xADA7EF79, 0x4E1D7235, 0xD55A63CE, 0xDE0436BA,
+        0x99C430EF, 0x5F0C0794, 0x18DCDB7D, 0xA1D6EFF3,
+        0xA0B52F7B, 0x59E83605, 0xEE15B094, 0xE9FFD909,
+        0xDC440086, 0xEF944459, 0xBA83CCB3, 0xE0C3CDFB,
+        0xD1DA4181, 0x3B092AB1, 0xF997F1C1, 0xA5E6CF7B,
+        0x01420DDB, 0xE4E7EF5B, 0x25A1FF41, 0xE180F806,
+        0x1FC41080, 0x179BEE7A, 0xD37AC6A9, 0xFE5830A4,
+        0x98DE8B7F, 0x77E83F4E, 0x79929269, 0x24FA9F7B,
+        0xE113C85B, 0xACC40083, 0xD7503525, 0xF7EA615F,
+        0x62143154, 0x0D554B63, 0x5D681121, 0xC866C359,
+        0x3D63CF73, 0xCEE234C0, 0xD4D87E87, 0x5C672B21,
+        0x071F6181, 0x39F7627F, 0x361E3084, 0xE4EB573B,
+        0x602F64A4, 0xD63ACD9C, 0x1BBC4635, 0x9E81032D,
+        0x2701F50C, 0x99847AB4, 0xA0E3DF79, 0xBA6CF38C,
+        0x10843094, 0x2537A95E, 0xF46F6FFE, 0xA1FF3B1F,
+        0x208CFB6A, 0x8F458C74, 0xD9E0A227, 0x4EC73A34,
+        0xFC884F69, 0x3E4DE8DF, 0xEF0E0088, 0x3559648D,
+        0x8A45388C, 0x1D804366, 0x721D9BFD, 0xA58684BB,
+        0xE8256333, 0x844E8212, 0x128D8098, 0xFED33FB4,
+        0xCE280AE1, 0x27E19BA5, 0xD5A6C252, 0xE49754BD,
+        0xC5D655DD, 0xEB667064, 0x77840B4D, 0xA1B6A801,
+        0x84DB26A9, 0xE0B56714, 0x21F043B7, 0xE5D05860,
+        0x54F03084, 0x066FF472, 0xA31AA153, 0xDADC4755,
+        0xB5625DBF, 0x68561BE6, 0x83CA6B94, 0x2D6ED23B,
+        0xECCF01DB, 0xA6D3D0BA, 0xB6803D5C, 0xAF77A709,
+        0x33B4A34C, 0x397BC8D6, 0x5EE22B95, 0x5F0E5304,
+        0x81ED6F61, 0x20E74364, 0xB45E1378, 0xDE18639B,
+        0x881CA122, 0xB96726D1, 0x8049A7E8, 0x22B7DA7B,
+        0x5E552D25, 0x5272D237, 0x79D2951C, 0xC60D894C,
+        0x488CB402, 0x1BA4FE5B, 0xA4B09F6B, 0x1CA815CF,
+        0xA20C3005, 0x8871DF63, 0xB9DE2FCB, 0x0CC6C9E9,
+        0x0BEEFF53, 0xE3214517, 0xB4542835, 0x9F63293C,
+        0xEE41E729, 0x6E1D2D7C, 0x50045286, 0x1E6685F3,
+        0xF33401C6, 0x30A22C95, 0x31A70850, 0x60930F13,
+        0x73F98417, 0xA1269859, 0xEC645C44, 0x52C877A9,
+        0xCDFF33A6, 0xA02B1741, 0x7CBAD9A2, 0x2180036F,
+        0x50D99C08, 0xCB3F4861, 0xC26BD765, 0x64A3F6AB,
+        0x80342676, 0x25A75E7B, 0xE4E6D1FC, 0x20C710E6,
+        0xCDF0B680, 0x17844D3B, 0x31EEF84D, 0x7E0824E4,
+        0x2CCB49EB, 0x846A3BAE, 0x8FF77888, 0xEE5D60F6,
+        0x7AF75673, 0x2FDD5CDB, 0xA11631C1, 0x30F66F43,
+        0xB3FAEC54, 0x157FD7FA, 0xEF8579CC, 0xD152DE58,
+        0xDB2FFD5E, 0x8F32CE19, 0x306AF97A, 0x02F03EF8,
+        0x99319AD5, 0xC242FA0F, 0xA7E3EBB0, 0xC68E4906,
+        0xB8DA230C, 0x80823028, 0xDCDEF3C8, 0xD35FB171,
+        0x088A1BC8, 0xBEC0C560, 0x61A3C9E8, 0xBCA8F54D,
+        0xC72FEFFA, 0x22822E99, 0x82C570B4, 0xD8D94E89,
+        0x8B1C34BC, 0x301E16E6, 0x273BE979, 0xB0FFEAA6,
+        0x61D9B8C6, 0x00B24869, 0xB7FFCE3F, 0x08DC283B,
+        0x43DAF65A, 0xF7E19798, 0x7619B72F, 0x8F1C9BA4,
+        0xDC8637A0, 0x16A7D3B1, 0x9FC393B7, 0xA7136EEB,
+        0xC6BCC63E, 0x1A513742, 0xEF6828BC, 0x520365D6,
+        0x2D6A77AB, 0x3527ED4B, 0x821FD216, 0x095C6E2E,
+        0xDB92F2FB, 0x5EEA29CB, 0x145892F5, 0x91584F7F,
+        0x5483697B, 0x2667A8CC, 0x85196048, 0x8C4BACEA,
+        0x833860D4, 0x0D23E0F9, 0x6C387E8A, 0x0AE6D249,
+        0xB284600C, 0xD835731D, 0xDCB1C647, 0xAC4C56EA,
+        0x3EBD81B3, 0x230EABB0, 0x6438BC87, 0xF0B5B1FA,
+        0x8F5EA2B3, 0xFC184642, 0x0A036B7A, 0x4FB089BD,
+        0x649DA589, 0xA345415E, 0x5C038323, 0x3E5D3BB9,
+        0x43D79572, 0x7E6DD07C, 0x06DFDF1E, 0x6C6CC4EF,
+        0x7160A539, 0x73BFBE70, 0x83877605, 0x4523ECF1
+};
+
+static const u_int32_t cast_sbox3[256] = {
+        0x8DEFC240, 0x25FA5D9F, 0xEB903DBF, 0xE810C907,
+        0x47607FFF, 0x369FE44B, 0x8C1FC644, 0xAECECA90,
+        0xBEB1F9BF, 0xEEFBCAEA, 0xE8CF1950, 0x51DF07AE,
+        0x920E8806, 0xF0AD0548, 0xE13C8D83, 0x927010D5,
+        0x11107D9F, 0x07647DB9, 0xB2E3E4D4, 0x3D4F285E,
+        0xB9AFA820, 0xFADE82E0, 0xA067268B, 0x8272792E,
+        0x553FB2C0, 0x489AE22B, 0xD4EF9794, 0x125E3FBC,
+        0x21FFFCEE, 0x825B1BFD, 0x9255C5ED, 0x1257A240,
+        0x4E1A8302, 0xBAE07FFF, 0x528246E7, 0x8E57140E,
+        0x3373F7BF, 0x8C9F8188, 0xA6FC4EE8, 0xC982B5A5,
+        0xA8C01DB7, 0x579FC264, 0x67094F31, 0xF2BD3F5F,
+        0x40FFF7C1, 0x1FB78DFC, 0x8E6BD2C1, 0x437BE59B,
+        0x99B03DBF, 0xB5DBC64B, 0x638DC0E6, 0x55819D99,
+        0xA197C81C, 0x4A012D6E, 0xC5884A28, 0xCCC36F71,
+        0xB843C213, 0x6C0743F1, 0x8309893C, 0x0FEDDD5F,
+        0x2F7FE850, 0xD7C07F7E, 0x02507FBF, 0x5AFB9A04,
+        0xA747D2D0, 0x1651192E, 0xAF70BF3E, 0x58C31380,
+        0x5F98302E, 0x727CC3C4, 0x0A0FB402, 0x0F7FEF82,
+        0x8C96FDAD, 0x5D2C2AAE, 0x8EE99A49, 0x50DA88B8,
+        0x8427F4A0, 0x1EAC5790, 0x796FB449, 0x8252DC15,
+        0xEFBD7D9B, 0xA672597D, 0xADA840D8, 0x45F54504,
+        0xFA5D7403, 0xE83EC305, 0x4F91751A, 0x925669C2,
+        0x23EFE941, 0xA903F12E, 0x60270DF2, 0x0276E4B6,
+        0x94FD6574, 0x927985B2, 0x8276DBCB, 0x02778176,
+        0xF8AF918D, 0x4E48F79E, 0x8F616DDF, 0xE29D840E,
+        0x842F7D83, 0x340CE5C8, 0x96BBB682, 0x93B4B148,
+        0xEF303CAB, 0x984FAF28, 0x779FAF9B, 0x92DC560D,
+        0x224D1E20, 0x8437AA88, 0x7D29DC96, 0x2756D3DC,
+        0x8B907CEE, 0xB51FD240, 0xE7C07CE3, 0xE566B4A1,
+        0xC3E9615E, 0x3CF8209D, 0x6094D1E3, 0xCD9CA341,
+        0x5C76460E, 0x00EA983B, 0xD4D67881, 0xFD47572C,
+        0xF76CEDD9, 0xBDA8229C, 0x127DADAA, 0x438A074E,
+        0x1F97C090, 0x081BDB8A, 0x93A07EBE, 0xB938CA15,
+        0x97B03CFF, 0x3DC2C0F8, 0x8D1AB2EC, 0x64380E51,
+        0x68CC7BFB, 0xD90F2788, 0x12490181, 0x5DE5FFD4,
+        0xDD7EF86A, 0x76A2E214, 0xB9A40368, 0x925D958F,
+        0x4B39FFFA, 0xBA39AEE9, 0xA4FFD30B, 0xFAF7933B,
+        0x6D498623, 0x193CBCFA, 0x27627545, 0x825CF47A,
+        0x61BD8BA0, 0xD11E42D1, 0xCEAD04F4, 0x127EA392,
+        0x10428DB7, 0x8272A972, 0x9270C4A8, 0x127DE50B,
+        0x285BA1C8, 0x3C62F44F, 0x35C0EAA5, 0xE805D231,
+        0x428929FB, 0xB4FCDF82, 0x4FB66A53, 0x0E7DC15B,
+        0x1F081FAB, 0x108618AE, 0xFCFD086D, 0xF9FF2889,
+        0x694BCC11, 0x236A5CAE, 0x12DECA4D, 0x2C3F8CC5,
+        0xD2D02DFE, 0xF8EF5896, 0xE4CF52DA, 0x95155B67,
+        0x494A488C, 0xB9B6A80C, 0x5C8F82BC, 0x89D36B45,
+        0x3A609437, 0xEC00C9A9, 0x44715253, 0x0A874B49,
+        0xD773BC40, 0x7C34671C, 0x02717EF6, 0x4FEB5536,
+        0xA2D02FFF, 0xD2BF60C4, 0xD43F03C0, 0x50B4EF6D,
+        0x07478CD1, 0x006E1888, 0xA2E53F55, 0xB9E6D4BC,
+        0xA2048016, 0x97573833, 0xD7207D67, 0xDE0F8F3D,
+        0x72F87B33, 0xABCC4F33, 0x7688C55D, 0x7B00A6B0,
+        0x947B0001, 0x570075D2, 0xF9BB88F8, 0x8942019E,
+        0x4264A5FF, 0x856302E0, 0x72DBD92B, 0xEE971B69,
+        0x6EA22FDE, 0x5F08AE2B, 0xAF7A616D, 0xE5C98767,
+        0xCF1FEBD2, 0x61EFC8C2, 0xF1AC2571, 0xCC8239C2,
+        0x67214CB8, 0xB1E583D1, 0xB7DC3E62, 0x7F10BDCE,
+        0xF90A5C38, 0x0FF0443D, 0x606E6DC6, 0x60543A49,
+        0x5727C148, 0x2BE98A1D, 0x8AB41738, 0x20E1BE24,
+        0xAF96DA0F, 0x68458425, 0x99833BE5, 0x600D457D,
+        0x282F9350, 0x8334B362, 0xD91D1120, 0x2B6D8DA0,
+        0x642B1E31, 0x9C305A00, 0x52BCE688, 0x1B03588A,
+        0xF7BAEFD5, 0x4142ED9C, 0xA4315C11, 0x83323EC5,
+        0xDFEF4636, 0xA133C501, 0xE9D3531C, 0xEE353783
+};
+
+static const u_int32_t cast_sbox4[256] = {
+        0x9DB30420, 0x1FB6E9DE, 0xA7BE7BEF, 0xD273A298,
+        0x4A4F7BDB, 0x64AD8C57, 0x85510443, 0xFA020ED1,
+        0x7E287AFF, 0xE60FB663, 0x095F35A1, 0x79EBF120,
+        0xFD059D43, 0x6497B7B1, 0xF3641F63, 0x241E4ADF,
+        0x28147F5F, 0x4FA2B8CD, 0xC9430040, 0x0CC32220,
+        0xFDD30B30, 0xC0A5374F, 0x1D2D00D9, 0x24147B15,
+        0xEE4D111A, 0x0FCA5167, 0x71FF904C, 0x2D195FFE,
+        0x1A05645F, 0x0C13FEFE, 0x081B08CA, 0x05170121,
+        0x80530100, 0xE83E5EFE, 0xAC9AF4F8, 0x7FE72701,
+        0xD2B8EE5F, 0x06DF4261, 0xBB9E9B8A, 0x7293EA25,
+        0xCE84FFDF, 0xF5718801, 0x3DD64B04, 0xA26F263B,
+        0x7ED48400, 0x547EEBE6, 0x446D4CA0, 0x6CF3D6F5,
+        0x2649ABDF, 0xAEA0C7F5, 0x36338CC1, 0x503F7E93,
+        0xD3772061, 0x11B638E1, 0x72500E03, 0xF80EB2BB,
+        0xABE0502E, 0xEC8D77DE, 0x57971E81, 0xE14F6746,
+        0xC9335400, 0x6920318F, 0x081DBB99, 0xFFC304A5,
+        0x4D351805, 0x7F3D5CE3, 0xA6C866C6, 0x5D5BCCA9,
+        0xDAEC6FEA, 0x9F926F91, 0x9F46222F, 0x3991467D,
+        0xA5BF6D8E, 0x1143C44F, 0x43958302, 0xD0214EEB,
+        0x022083B8, 0x3FB6180C, 0x18F8931E, 0x281658E6,
+        0x26486E3E, 0x8BD78A70, 0x7477E4C1, 0xB506E07C,
+        0xF32D0A25, 0x79098B02, 0xE4EABB81, 0x28123B23,
+        0x69DEAD38, 0x1574CA16, 0xDF871B62, 0x211C40B7,
+        0xA51A9EF9, 0x0014377B, 0x041E8AC8, 0x09114003,
+        0xBD59E4D2, 0xE3D156D5, 0x4FE876D5, 0x2F91A340,
+        0x557BE8DE, 0x00EAE4A7, 0x0CE5C2EC, 0x4DB4BBA6,
+        0xE756BDFF, 0xDD3369AC, 0xEC17B035, 0x06572327,
+        0x99AFC8B0, 0x56C8C391, 0x6B65811C, 0x5E146119,
+        0x6E85CB75, 0xBE07C002, 0xC2325577, 0x893FF4EC,
+        0x5BBFC92D, 0xD0EC3B25, 0xB7801AB7, 0x8D6D3B24,
+        0x20C763EF, 0xC366A5FC, 0x9C382880, 0x0ACE3205,
+        0xAAC9548A, 0xECA1D7C7, 0x041AFA32, 0x1D16625A,
+        0x6701902C, 0x9B757A54, 0x31D477F7, 0x9126B031,
+        0x36CC6FDB, 0xC70B8B46, 0xD9E66A48, 0x56E55A79,
+        0x026A4CEB, 0x52437EFF, 0x2F8F76B4, 0x0DF980A5,
+        0x8674CDE3, 0xEDDA04EB, 0x17A9BE04, 0x2C18F4DF,
+        0xB7747F9D, 0xAB2AF7B4, 0xEFC34D20, 0x2E096B7C,
+        0x1741A254, 0xE5B6A035, 0x213D42F6, 0x2C1C7C26,
+        0x61C2F50F, 0x6552DAF9, 0xD2C231F8, 0x25130F69,
+        0xD8167FA2, 0x0418F2C8, 0x001A96A6, 0x0D1526AB,
+        0x63315C21, 0x5E0A72EC, 0x49BAFEFD, 0x187908D9,
+        0x8D0DBD86, 0x311170A7, 0x3E9B640C, 0xCC3E10D7,
+        0xD5CAD3B6, 0x0CAEC388, 0xF73001E1, 0x6C728AFF,
+        0x71EAE2A1, 0x1F9AF36E, 0xCFCBD12F, 0xC1DE8417,
+        0xAC07BE6B, 0xCB44A1D8, 0x8B9B0F56, 0x013988C3,
+        0xB1C52FCA, 0xB4BE31CD, 0xD8782806, 0x12A3A4E2,
+        0x6F7DE532, 0x58FD7EB6, 0xD01EE900, 0x24ADFFC2,
+        0xF4990FC5, 0x9711AAC5, 0x001D7B95, 0x82E5E7D2,
+        0x109873F6, 0x00613096, 0xC32D9521, 0xADA121FF,
+        0x29908415, 0x7FBB977F, 0xAF9EB3DB, 0x29C9ED2A,
+        0x5CE2A465, 0xA730F32C, 0xD0AA3FE8, 0x8A5CC091,
+        0xD49E2CE7, 0x0CE454A9, 0xD60ACD86, 0x015F1919,
+        0x77079103, 0xDEA03AF6, 0x78A8565E, 0xDEE356DF,
+        0x21F05CBE, 0x8B75E387, 0xB3C50651, 0xB8A5C3EF,
+        0xD8EEB6D2, 0xE523BE77, 0xC2154529, 0x2F69EFDF,
+        0xAFE67AFB, 0xF470C4B2, 0xF3E0EB5B, 0xD6CC9876,
+        0x39E4460C, 0x1FDA8538, 0x1987832F, 0xCA007367,
+        0xA99144F8, 0x296B299E, 0x492FC295, 0x9266BEAB,
+        0xB5676E69, 0x9BD3DDDA, 0xDF7E052F, 0xDB25701C,
+        0x1B5E51EE, 0xF65324E6, 0x6AFCE36C, 0x0316CC04,
+        0x8644213E, 0xB7DC59D0, 0x7965291F, 0xCCD6FD43,
+        0x41823979, 0x932BCDF6, 0xB657C34D, 0x4EDFD282,
+        0x7AE5290C, 0x3CB9536B, 0x851E20FE, 0x9833557E,
+        0x13ECF0B0, 0xD3FFB372, 0x3F85C5C1, 0x0AEF7ED2
+};
+
+static const u_int32_t cast_sbox5[256] = {
+        0x7EC90C04, 0x2C6E74B9, 0x9B0E66DF, 0xA6337911,
+        0xB86A7FFF, 0x1DD358F5, 0x44DD9D44, 0x1731167F,
+        0x08FBF1FA, 0xE7F511CC, 0xD2051B00, 0x735ABA00,
+        0x2AB722D8, 0x386381CB, 0xACF6243A, 0x69BEFD7A,
+        0xE6A2E77F, 0xF0C720CD, 0xC4494816, 0xCCF5C180,
+        0x38851640, 0x15B0A848, 0xE68B18CB, 0x4CAADEFF,
+        0x5F480A01, 0x0412B2AA, 0x259814FC, 0x41D0EFE2,
+        0x4E40B48D, 0x248EB6FB, 0x8DBA1CFE, 0x41A99B02,
+        0x1A550A04, 0xBA8F65CB, 0x7251F4E7, 0x95A51725,
+        0xC106ECD7, 0x97A5980A, 0xC539B9AA, 0x4D79FE6A,
+        0xF2F3F763, 0x68AF8040, 0xED0C9E56, 0x11B4958B,
+        0xE1EB5A88, 0x8709E6B0, 0xD7E07156, 0x4E29FEA7,
+        0x6366E52D, 0x02D1C000, 0xC4AC8E05, 0x9377F571,
+        0x0C05372A, 0x578535F2, 0x2261BE02, 0xD642A0C9,
+        0xDF13A280, 0x74B55BD2, 0x682199C0, 0xD421E5EC,
+        0x53FB3CE8, 0xC8ADEDB3, 0x28A87FC9, 0x3D959981,
+        0x5C1FF900, 0xFE38D399, 0x0C4EFF0B, 0x062407EA,
+        0xAA2F4FB1, 0x4FB96976, 0x90C79505, 0xB0A8A774,
+        0xEF55A1FF, 0xE59CA2C2, 0xA6B62D27, 0xE66A4263,
+        0xDF65001F, 0x0EC50966, 0xDFDD55BC, 0x29DE0655,
+        0x911E739A, 0x17AF8975, 0x32C7911C, 0x89F89468,
+        0x0D01E980, 0x524755F4, 0x03B63CC9, 0x0CC844B2,
+        0xBCF3F0AA, 0x87AC36E9, 0xE53A7426, 0x01B3D82B,
+        0x1A9E7449, 0x64EE2D7E, 0xCDDBB1DA, 0x01C94910,
+        0xB868BF80, 0x0D26F3FD, 0x9342EDE7, 0x04A5C284,
+        0x636737B6, 0x50F5B616, 0xF24766E3, 0x8ECA36C1,
+        0x136E05DB, 0xFEF18391, 0xFB887A37, 0xD6E7F7D4,
+        0xC7FB7DC9, 0x3063FCDF, 0xB6F589DE, 0xEC2941DA,
+        0x26E46695, 0xB7566419, 0xF654EFC5, 0xD08D58B7,
+        0x48925401, 0xC1BACB7F, 0xE5FF550F, 0xB6083049,
+        0x5BB5D0E8, 0x87D72E5A, 0xAB6A6EE1, 0x223A66CE,
+        0xC62BF3CD, 0x9E0885F9, 0x68CB3E47, 0x086C010F,
+        0xA21DE820, 0xD18B69DE, 0xF3F65777, 0xFA02C3F6,
+        0x407EDAC3, 0xCBB3D550, 0x1793084D, 0xB0D70EBA,
+        0x0AB378D5, 0xD951FB0C, 0xDED7DA56, 0x4124BBE4,
+        0x94CA0B56, 0x0F5755D1, 0xE0E1E56E, 0x6184B5BE,
+        0x580A249F, 0x94F74BC0, 0xE327888E, 0x9F7B5561,
+        0xC3DC0280, 0x05687715, 0x646C6BD7, 0x44904DB3,
+        0x66B4F0A3, 0xC0F1648A, 0x697ED5AF, 0x49E92FF6,
+        0x309E374F, 0x2CB6356A, 0x85808573, 0x4991F840,
+        0x76F0AE02, 0x083BE84D, 0x28421C9A, 0x44489406,
+        0x736E4CB8, 0xC1092910, 0x8BC95FC6, 0x7D869CF4,
+        0x134F616F, 0x2E77118D, 0xB31B2BE1, 0xAA90B472,
+        0x3CA5D717, 0x7D161BBA, 0x9CAD9010, 0xAF462BA2,
+        0x9FE459D2, 0x45D34559, 0xD9F2DA13, 0xDBC65487,
+        0xF3E4F94E, 0x176D486F, 0x097C13EA, 0x631DA5C7,
+        0x445F7382, 0x175683F4, 0xCDC66A97, 0x70BE0288,
+        0xB3CDCF72, 0x6E5DD2F3, 0x20936079, 0x459B80A5,
+        0xBE60E2DB, 0xA9C23101, 0xEBA5315C, 0x224E42F2,
+        0x1C5C1572, 0xF6721B2C, 0x1AD2FFF3, 0x8C25404E,
+        0x324ED72F, 0x4067B7FD, 0x0523138E, 0x5CA3BC78,
+        0xDC0FD66E, 0x75922283, 0x784D6B17, 0x58EBB16E,
+        0x44094F85, 0x3F481D87, 0xFCFEAE7B, 0x77B5FF76,
+        0x8C2302BF, 0xAAF47556, 0x5F46B02A, 0x2B092801,
+        0x3D38F5F7, 0x0CA81F36, 0x52AF4A8A, 0x66D5E7C0,
+        0xDF3B0874, 0x95055110, 0x1B5AD7A8, 0xF61ED5AD,
+        0x6CF6E479, 0x20758184, 0xD0CEFA65, 0x88F7BE58,
+        0x4A046826, 0x0FF6F8F3, 0xA09C7F70, 0x5346ABA0,
+        0x5CE96C28, 0xE176EDA3, 0x6BAC307F, 0x376829D2,
+        0x85360FA9, 0x17E3FE2A, 0x24B79767, 0xF5A96B20,
+        0xD6CD2595, 0x68FF1EBF, 0x7555442C, 0xF19F06BE,
+        0xF9E0659A, 0xEEB9491D, 0x34010718, 0xBB30CAB8,
+        0xE822FE15, 0x88570983, 0x750E6249, 0xDA627E55,
+        0x5E76FFA8, 0xB1534546, 0x6D47DE08, 0xEFE9E7D4
+};
+
+static const u_int32_t cast_sbox6[256] = {
+        0xF6FA8F9D, 0x2CAC6CE1, 0x4CA34867, 0xE2337F7C,
+        0x95DB08E7, 0x016843B4, 0xECED5CBC, 0x325553AC,
+        0xBF9F0960, 0xDFA1E2ED, 0x83F0579D, 0x63ED86B9,
+        0x1AB6A6B8, 0xDE5EBE39, 0xF38FF732, 0x8989B138,
+        0x33F14961, 0xC01937BD, 0xF506C6DA, 0xE4625E7E,
+        0xA308EA99, 0x4E23E33C, 0x79CBD7CC, 0x48A14367,
+        0xA3149619, 0xFEC94BD5, 0xA114174A, 0xEAA01866,
+        0xA084DB2D, 0x09A8486F, 0xA888614A, 0x2900AF98,
+        0x01665991, 0xE1992863, 0xC8F30C60, 0x2E78EF3C,
+        0xD0D51932, 0xCF0FEC14, 0xF7CA07D2, 0xD0A82072,
+        0xFD41197E, 0x9305A6B0, 0xE86BE3DA, 0x74BED3CD,
+        0x372DA53C, 0x4C7F4448, 0xDAB5D440, 0x6DBA0EC3,
+        0x083919A7, 0x9FBAEED9, 0x49DBCFB0, 0x4E670C53,
+        0x5C3D9C01, 0x64BDB941, 0x2C0E636A, 0xBA7DD9CD,
+        0xEA6F7388, 0xE70BC762, 0x35F29ADB, 0x5C4CDD8D,
+        0xF0D48D8C, 0xB88153E2, 0x08A19866, 0x1AE2EAC8,
+        0x284CAF89, 0xAA928223, 0x9334BE53, 0x3B3A21BF,
+        0x16434BE3, 0x9AEA3906, 0xEFE8C36E, 0xF890CDD9,
+        0x80226DAE, 0xC340A4A3, 0xDF7E9C09, 0xA694A807,
+        0x5B7C5ECC, 0x221DB3A6, 0x9A69A02F, 0x68818A54,
+        0xCEB2296F, 0x53C0843A, 0xFE893655, 0x25BFE68A,
+        0xB4628ABC, 0xCF222EBF, 0x25AC6F48, 0xA9A99387,
+        0x53BDDB65, 0xE76FFBE7, 0xE967FD78, 0x0BA93563,
+        0x8E342BC1, 0xE8A11BE9, 0x4980740D, 0xC8087DFC,
+        0x8DE4BF99, 0xA11101A0, 0x7FD37975, 0xDA5A26C0,
+        0xE81F994F, 0x9528CD89, 0xFD339FED, 0xB87834BF,
+        0x5F04456D, 0x22258698, 0xC9C4C83B, 0x2DC156BE,
+        0x4F628DAA, 0x57F55EC5, 0xE2220ABE, 0xD2916EBF,
+        0x4EC75B95, 0x24F2C3C0, 0x42D15D99, 0xCD0D7FA0,
+        0x7B6E27FF, 0xA8DC8AF0, 0x7345C106, 0xF41E232F,
+        0x35162386, 0xE6EA8926, 0x3333B094, 0x157EC6F2,
+        0x372B74AF, 0x692573E4, 0xE9A9D848, 0xF3160289,
+        0x3A62EF1D, 0xA787E238, 0xF3A5F676, 0x74364853,
+        0x20951063, 0x4576698D, 0xB6FAD407, 0x592AF950,
+        0x36F73523, 0x4CFB6E87, 0x7DA4CEC0, 0x6C152DAA,
+        0xCB0396A8, 0xC50DFE5D, 0xFCD707AB, 0x0921C42F,
+        0x89DFF0BB, 0x5FE2BE78, 0x448F4F33, 0x754613C9,
+        0x2B05D08D, 0x48B9D585, 0xDC049441, 0xC8098F9B,
+        0x7DEDE786, 0xC39A3373, 0x42410005, 0x6A091751,
+        0x0EF3C8A6, 0x890072D6, 0x28207682, 0xA9A9F7BE,
+        0xBF32679D, 0xD45B5B75, 0xB353FD00, 0xCBB0E358,
+        0x830F220A, 0x1F8FB214, 0xD372CF08, 0xCC3C4A13,
+        0x8CF63166, 0x061C87BE, 0x88C98F88, 0x6062E397,
+        0x47CF8E7A, 0xB6C85283, 0x3CC2ACFB, 0x3FC06976,
+        0x4E8F0252, 0x64D8314D, 0xDA3870E3, 0x1E665459,
+        0xC10908F0, 0x513021A5, 0x6C5B68B7, 0x822F8AA0,
+        0x3007CD3E, 0x74719EEF, 0xDC872681, 0x073340D4,
+        0x7E432FD9, 0x0C5EC241, 0x8809286C, 0xF592D891,
+        0x08A930F6, 0x957EF305, 0xB7FBFFBD, 0xC266E96F,
+        0x6FE4AC98, 0xB173ECC0, 0xBC60B42A, 0x953498DA,
+        0xFBA1AE12, 0x2D4BD736, 0x0F25FAAB, 0xA4F3FCEB,
+        0xE2969123, 0x257F0C3D, 0x9348AF49, 0x361400BC,
+        0xE8816F4A, 0x3814F200, 0xA3F94043, 0x9C7A54C2,
+        0xBC704F57, 0xDA41E7F9, 0xC25AD33A, 0x54F4A084,
+        0xB17F5505, 0x59357CBE, 0xEDBD15C8, 0x7F97C5AB,
+        0xBA5AC7B5, 0xB6F6DEAF, 0x3A479C3A, 0x5302DA25,
+        0x653D7E6A, 0x54268D49, 0x51A477EA, 0x5017D55B,
+        0xD7D25D88, 0x44136C76, 0x0404A8C8, 0xB8E5A121,
+        0xB81A928A, 0x60ED5869, 0x97C55B96, 0xEAEC991B,
+        0x29935913, 0x01FDB7F1, 0x088E8DFA, 0x9AB6F6F5,
+        0x3B4CBF9F, 0x4A5DE3AB, 0xE6051D35, 0xA0E1D855,
+        0xD36B4CF1, 0xF544EDEB, 0xB0E93524, 0xBEBB8FBD,
+        0xA2D762CF, 0x49C92F54, 0x38B5F331, 0x7128A454,
+        0x48392905, 0xA65B1DB8, 0x851C97BD, 0xD675CF2F
+};
+
+static const u_int32_t cast_sbox7[256] = {
+        0x85E04019, 0x332BF567, 0x662DBFFF, 0xCFC65693,
+        0x2A8D7F6F, 0xAB9BC912, 0xDE6008A1, 0x2028DA1F,
+        0x0227BCE7, 0x4D642916, 0x18FAC300, 0x50F18B82,
+        0x2CB2CB11, 0xB232E75C, 0x4B3695F2, 0xB28707DE,
+        0xA05FBCF6, 0xCD4181E9, 0xE150210C, 0xE24EF1BD,
+        0xB168C381, 0xFDE4E789, 0x5C79B0D8, 0x1E8BFD43,
+        0x4D495001, 0x38BE4341, 0x913CEE1D, 0x92A79C3F,
+        0x089766BE, 0xBAEEADF4, 0x1286BECF, 0xB6EACB19,
+        0x2660C200, 0x7565BDE4, 0x64241F7A, 0x8248DCA9,
+        0xC3B3AD66, 0x28136086, 0x0BD8DFA8, 0x356D1CF2,
+        0x107789BE, 0xB3B2E9CE, 0x0502AA8F, 0x0BC0351E,
+        0x166BF52A, 0xEB12FF82, 0xE3486911, 0xD34D7516,
+        0x4E7B3AFF, 0x5F43671B, 0x9CF6E037, 0x4981AC83,
+        0x334266CE, 0x8C9341B7, 0xD0D854C0, 0xCB3A6C88,
+        0x47BC2829, 0x4725BA37, 0xA66AD22B, 0x7AD61F1E,
+        0x0C5CBAFA, 0x4437F107, 0xB6E79962, 0x42D2D816,
+        0x0A961288, 0xE1A5C06E, 0x13749E67, 0x72FC081A,
+        0xB1D139F7, 0xF9583745, 0xCF19DF58, 0xBEC3F756,
+        0xC06EBA30, 0x07211B24, 0x45C28829, 0xC95E317F,
+        0xBC8EC511, 0x38BC46E9, 0xC6E6FA14, 0xBAE8584A,
+        0xAD4EBC46, 0x468F508B, 0x7829435F, 0xF124183B,
+        0x821DBA9F, 0xAFF60FF4, 0xEA2C4E6D, 0x16E39264,
+        0x92544A8B, 0x009B4FC3, 0xABA68CED, 0x9AC96F78,
+        0x06A5B79A, 0xB2856E6E, 0x1AEC3CA9, 0xBE838688,
+        0x0E0804E9, 0x55F1BE56, 0xE7E5363B, 0xB3A1F25D,
+        0xF7DEBB85, 0x61FE033C, 0x16746233, 0x3C034C28,
+        0xDA6D0C74, 0x79AAC56C, 0x3CE4E1AD, 0x51F0C802,
+        0x98F8F35A, 0x1626A49F, 0xEED82B29, 0x1D382FE3,
+        0x0C4FB99A, 0xBB325778, 0x3EC6D97B, 0x6E77A6A9,
+        0xCB658B5C, 0xD45230C7, 0x2BD1408B, 0x60C03EB7,
+        0xB9068D78, 0xA33754F4, 0xF430C87D, 0xC8A71302,
+        0xB96D8C32, 0xEBD4E7BE, 0xBE8B9D2D, 0x7979FB06,
+        0xE7225308, 0x8B75CF77, 0x11EF8DA4, 0xE083C858,
+        0x8D6B786F, 0x5A6317A6, 0xFA5CF7A0, 0x5DDA0033,
+        0xF28EBFB0, 0xF5B9C310, 0xA0EAC280, 0x08B9767A,
+        0xA3D9D2B0, 0x79D34217, 0x021A718D, 0x9AC6336A,
+        0x2711FD60, 0x438050E3, 0x069908A8, 0x3D7FEDC4,
+        0x826D2BEF, 0x4EEB8476, 0x488DCF25, 0x36C9D566,
+        0x28E74E41, 0xC2610ACA, 0x3D49A9CF, 0xBAE3B9DF,
+        0xB65F8DE6, 0x92AEAF64, 0x3AC7D5E6, 0x9EA80509,
+        0xF22B017D, 0xA4173F70, 0xDD1E16C3, 0x15E0D7F9,
+        0x50B1B887, 0x2B9F4FD5, 0x625ABA82, 0x6A017962,
+        0x2EC01B9C, 0x15488AA9, 0xD716E740, 0x40055A2C,
+        0x93D29A22, 0xE32DBF9A, 0x058745B9, 0x3453DC1E,
+        0xD699296E, 0x496CFF6F, 0x1C9F4986, 0xDFE2ED07,
+        0xB87242D1, 0x19DE7EAE, 0x053E561A, 0x15AD6F8C,
+        0x66626C1C, 0x7154C24C, 0xEA082B2A, 0x93EB2939,
+        0x17DCB0F0, 0x58D4F2AE, 0x9EA294FB, 0x52CF564C,
+        0x9883FE66, 0x2EC40581, 0x763953C3, 0x01D6692E,
+        0xD3A0C108, 0xA1E7160E, 0xE4F2DFA6, 0x693ED285,
+        0x74904698, 0x4C2B0EDD, 0x4F757656, 0x5D393378,
+        0xA132234F, 0x3D321C5D, 0xC3F5E194, 0x4B269301,
+        0xC79F022F, 0x3C997E7E, 0x5E4F9504, 0x3FFAFBBD,
+        0x76F7AD0E, 0x296693F4, 0x3D1FCE6F, 0xC61E45BE,
+        0xD3B5AB34, 0xF72BF9B7, 0x1B0434C0, 0x4E72B567,
+        0x5592A33D, 0xB5229301, 0xCFD2A87F, 0x60AEB767,
+        0x1814386B, 0x30BCC33D, 0x38A0C07D, 0xFD1606F2,
+        0xC363519B, 0x589DD390, 0x5479F8E6, 0x1CB8D647,
+        0x97FD61A9, 0xEA7759F4, 0x2D57539D, 0x569A58CF,
+        0xE84E63AD, 0x462E1B78, 0x6580F87E, 0xF3817914,
+        0x91DA55F4, 0x40A230F3, 0xD1988F35, 0xB6E318D2,
+        0x3FFA50BC, 0x3D40F021, 0xC3C0BDAE, 0x4958C24C,
+        0x518F36B2, 0x84B1D370, 0x0FEDCE83, 0x878DDADA,
+        0xF2A279C7, 0x94E01BE8, 0x90716F4B, 0x954B8AA3
+};
+
+static const u_int32_t cast_sbox8[256] = {
+        0xE216300D, 0xBBDDFFFC, 0xA7EBDABD, 0x35648095,
+        0x7789F8B7, 0xE6C1121B, 0x0E241600, 0x052CE8B5,
+        0x11A9CFB0, 0xE5952F11, 0xECE7990A, 0x9386D174,
+        0x2A42931C, 0x76E38111, 0xB12DEF3A, 0x37DDDDFC,
+        0xDE9ADEB1, 0x0A0CC32C, 0xBE197029, 0x84A00940,
+        0xBB243A0F, 0xB4D137CF, 0xB44E79F0, 0x049EEDFD,
+        0x0B15A15D, 0x480D3168, 0x8BBBDE5A, 0x669DED42,
+        0xC7ECE831, 0x3F8F95E7, 0x72DF191B, 0x7580330D,
+        0x94074251, 0x5C7DCDFA, 0xABBE6D63, 0xAA402164,
+        0xB301D40A, 0x02E7D1CA, 0x53571DAE, 0x7A3182A2,
+        0x12A8DDEC, 0xFDAA335D, 0x176F43E8, 0x71FB46D4,
+        0x38129022, 0xCE949AD4, 0xB84769AD, 0x965BD862,
+        0x82F3D055, 0x66FB9767, 0x15B80B4E, 0x1D5B47A0,
+        0x4CFDE06F, 0xC28EC4B8, 0x57E8726E, 0x647A78FC,
+        0x99865D44, 0x608BD593, 0x6C200E03, 0x39DC5FF6,
+        0x5D0B00A3, 0xAE63AFF2, 0x7E8BD632, 0x70108C0C,
+        0xBBD35049, 0x2998DF04, 0x980CF42A, 0x9B6DF491,
+        0x9E7EDD53, 0x06918548, 0x58CB7E07, 0x3B74EF2E,
+        0x522FFFB1, 0xD24708CC, 0x1C7E27CD, 0xA4EB215B,
+        0x3CF1D2E2, 0x19B47A38, 0x424F7618, 0x35856039,
+        0x9D17DEE7, 0x27EB35E6, 0xC9AFF67B, 0x36BAF5B8,
+        0x09C467CD, 0xC18910B1, 0xE11DBF7B, 0x06CD1AF8,
+        0x7170C608, 0x2D5E3354, 0xD4DE495A, 0x64C6D006,
+        0xBCC0C62C, 0x3DD00DB3, 0x708F8F34, 0x77D51B42,
+        0x264F620F, 0x24B8D2BF, 0x15C1B79E, 0x46A52564,
+        0xF8D7E54E, 0x3E378160, 0x7895CDA5, 0x859C15A5,
+        0xE6459788, 0xC37BC75F, 0xDB07BA0C, 0x0676A3AB,
+        0x7F229B1E, 0x31842E7B, 0x24259FD7, 0xF8BEF472,
+        0x835FFCB8, 0x6DF4C1F2, 0x96F5B195, 0xFD0AF0FC,
+        0xB0FE134C, 0xE2506D3D, 0x4F9B12EA, 0xF215F225,
+        0xA223736F, 0x9FB4C428, 0x25D04979, 0x34C713F8,
+        0xC4618187, 0xEA7A6E98, 0x7CD16EFC, 0x1436876C,
+        0xF1544107, 0xBEDEEE14, 0x56E9AF27, 0xA04AA441,
+        0x3CF7C899, 0x92ECBAE6, 0xDD67016D, 0x151682EB,
+        0xA842EEDF, 0xFDBA60B4, 0xF1907B75, 0x20E3030F,
+        0x24D8C29E, 0xE139673B, 0xEFA63FB8, 0x71873054,
+        0xB6F2CF3B, 0x9F326442, 0xCB15A4CC, 0xB01A4504,
+        0xF1E47D8D, 0x844A1BE5, 0xBAE7DFDC, 0x42CBDA70,
+        0xCD7DAE0A, 0x57E85B7A, 0xD53F5AF6, 0x20CF4D8C,
+        0xCEA4D428, 0x79D130A4, 0x3486EBFB, 0x33D3CDDC,
+        0x77853B53, 0x37EFFCB5, 0xC5068778, 0xE580B3E6,
+        0x4E68B8F4, 0xC5C8B37E, 0x0D809EA2, 0x398FEB7C,
+        0x132A4F94, 0x43B7950E, 0x2FEE7D1C, 0x223613BD,
+        0xDD06CAA2, 0x37DF932B, 0xC4248289, 0xACF3EBC3,
+        0x5715F6B7, 0xEF3478DD, 0xF267616F, 0xC148CBE4,
+        0x9052815E, 0x5E410FAB, 0xB48A2465, 0x2EDA7FA4,
+        0xE87B40E4, 0xE98EA084, 0x5889E9E1, 0xEFD390FC,
+        0xDD07D35B, 0xDB485694, 0x38D7E5B2, 0x57720101,
+        0x730EDEBC, 0x5B643113, 0x94917E4F, 0x503C2FBA,
+        0x646F1282, 0x7523D24A, 0xE0779695, 0xF9C17A8F,
+        0x7A5B2121, 0xD187B896, 0x29263A4D, 0xBA510CDF,
+        0x81F47C9F, 0xAD1163ED, 0xEA7B5965, 0x1A00726E,
+        0x11403092, 0x00DA6D77, 0x4A0CDD61, 0xAD1F4603,
+        0x605BDFB0, 0x9EEDC364, 0x22EBE6A8, 0xCEE7D28A,
+        0xA0E736A0, 0x5564A6B9, 0x10853209, 0xC7EB8F37,
+        0x2DE705CA, 0x8951570F, 0xDF09822B, 0xBD691A6C,
+        0xAA12E4F2, 0x87451C0F, 0xE0F6A27A, 0x3ADA4819,
+        0x4CF1764F, 0x0D771C2B, 0x67CDB156, 0x350D8384,
+        0x5938FA0F, 0x42399EF3, 0x36997B07, 0x0E84093D,
+        0x4AA93E61, 0x8360D87B, 0x1FA98B0C, 0x1149382C,
+        0xE97625A5, 0x0614D1B7, 0x0E25244B, 0x0C768347,
+        0x589E8D82, 0x0D2059D1, 0xA466BB1E, 0xF8DA0A82,
+        0x04F19130, 0xBA6E4EC0, 0x99265164, 0x1EE7230D,
+        0x50B2AD80, 0xEAEE6801, 0x8DB2A283, 0xEA8BF59E
+};
+
+/* Macros to access 8-bit bytes out of a 32-bit word */
+#define U8a(x) ( (u_int8_t) (x>>24) )
+#define U8b(x) ( (u_int8_t) ((x>>16)&255) )
+#define U8c(x) ( (u_int8_t) ((x>>8)&255) )
+#define U8d(x) ( (u_int8_t) ((x)&255) )
+
+/* Circular left shift */
+#define ROL(x, n) ( ((x)<<(n)) | ((x)>>(32-(n))) )
+
+/* CAST-128 uses three different round functions */
+#define F1(l, r, i) \
+        t = ROL(key->xkey[i] + r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] ^ cast_sbox2[U8b(t)]) - \
+         cast_sbox3[U8c(t)]) + cast_sbox4[U8d(t)];
+#define F2(l, r, i) \
+        t = ROL(key->xkey[i] ^ r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] - cast_sbox2[U8b(t)]) + \
+         cast_sbox3[U8c(t)]) ^ cast_sbox4[U8d(t)];
+#define F3(l, r, i) \
+        t = ROL(key->xkey[i] - r, key->xkey[i+16]); \
+        l ^= ((cast_sbox1[U8a(t)] + cast_sbox2[U8b(t)]) ^ \
+         cast_sbox3[U8c(t)]) - cast_sbox4[U8d(t)];
+
+
+/***** Encryption Function *****/
+
+void cast_encrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock)
+{
+u_int32_t t, l, r;
+
+        /* Get inblock into l,r */
+        l = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) |
+         ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3];
+        r = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) |
+         ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7];
+        /* Do the work */
+        F1(l, r,  0);
+        F2(r, l,  1);
+        F3(l, r,  2);
+        F1(r, l,  3);
+        F2(l, r,  4);
+        F3(r, l,  5);
+        F1(l, r,  6);
+        F2(r, l,  7);
+        F3(l, r,  8);
+        F1(r, l,  9);
+        F2(l, r, 10);
+        F3(r, l, 11);
+        /* Only do full 16 rounds if key length > 80 bits */
+        if (key->rounds > 12) {
+                F1(l, r, 12);
+                F2(r, l, 13);
+                F3(l, r, 14);
+                F1(r, l, 15);
+        }
+        /* Put l,r into outblock */
+        outblock[0] = U8a(r);
+        outblock[1] = U8b(r);
+        outblock[2] = U8c(r);
+        outblock[3] = U8d(r);
+        outblock[4] = U8a(l);
+        outblock[5] = U8b(l);
+        outblock[6] = U8c(l);
+        outblock[7] = U8d(l);
+        /* Wipe clean */
+        t = l = r = 0;
+}
+
+
+/***** Decryption Function *****/
+
+void cast_decrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock)
+{
+u_int32_t t, l, r;
+
+        /* Get inblock into l,r */
+        r = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) |
+         ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3];
+        l = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) |
+         ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7];
+        /* Do the work */
+        /* Only do full 16 rounds if key length > 80 bits */
+        if (key->rounds > 12) {
+                F1(r, l, 15);
+                F3(l, r, 14);
+                F2(r, l, 13);
+                F1(l, r, 12);
+        }
+        F3(r, l, 11);
+        F2(l, r, 10);
+        F1(r, l,  9);
+        F3(l, r,  8);
+        F2(r, l,  7);
+        F1(l, r,  6);
+        F3(r, l,  5);
+        F2(l, r,  4);
+        F1(r, l,  3);
+        F3(l, r,  2);
+        F2(r, l,  1);
+        F1(l, r,  0);
+        /* Put l,r into outblock */
+        outblock[0] = U8a(l);
+        outblock[1] = U8b(l);
+        outblock[2] = U8c(l);
+        outblock[3] = U8d(l);
+        outblock[4] = U8a(r);
+        outblock[5] = U8b(r);
+        outblock[6] = U8c(r);
+        outblock[7] = U8d(r);
+        /* Wipe clean */
+        t = l = r = 0;
+}
+
+
+/***** Key Schedual *****/
+
+void cast_setkey(cast_key* key, u_int8_t* rawkey, int keybytes)
+{
+u_int32_t t[4], z[4], x[4];
+int i;
+
+        /* Set number of rounds to 12 or 16, depending on key length */
+        key->rounds = (keybytes <= 10 ? 12 : 16);
+
+        /* Copy key to workspace x */
+        for (i = 0; i < 4; i++) {
+                x[i] = 0;
+                if ((i*4+0) < keybytes) x[i] = (u_int32_t)rawkey[i*4+0] << 24;
+                if ((i*4+1) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+1] << 16;
+                if ((i*4+2) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+2] << 8;
+                if ((i*4+3) < keybytes) x[i] |= (u_int32_t)rawkey[i*4+3];
+        }
+        /* Generate 32 subkeys, four at a time */
+        for (i = 0; i < 32; i+=4) {
+                switch (i & 4) {
+                 case 0:
+                        t[0] = z[0] = x[0] ^ cast_sbox5[U8b(x[3])] ^
+                         cast_sbox6[U8d(x[3])] ^ cast_sbox7[U8a(x[3])] ^
+                         cast_sbox8[U8c(x[3])] ^ cast_sbox7[U8a(x[2])];
+                        t[1] = z[1] = x[2] ^ cast_sbox5[U8a(z[0])] ^
+                         cast_sbox6[U8c(z[0])] ^ cast_sbox7[U8b(z[0])] ^
+                         cast_sbox8[U8d(z[0])] ^ cast_sbox8[U8c(x[2])];
+                        t[2] = z[2] = x[3] ^ cast_sbox5[U8d(z[1])] ^
+                         cast_sbox6[U8c(z[1])] ^ cast_sbox7[U8b(z[1])] ^
+                         cast_sbox8[U8a(z[1])] ^ cast_sbox5[U8b(x[2])];
+                        t[3] = z[3] = x[1] ^ cast_sbox5[U8c(z[2])] ^
+                         cast_sbox6[U8b(z[2])] ^ cast_sbox7[U8d(z[2])] ^
+                         cast_sbox8[U8a(z[2])] ^ cast_sbox6[U8d(x[2])];
+                        break;
+                 case 4:
+                        t[0] = x[0] = z[2] ^ cast_sbox5[U8b(z[1])] ^
+                         cast_sbox6[U8d(z[1])] ^ cast_sbox7[U8a(z[1])] ^
+                         cast_sbox8[U8c(z[1])] ^ cast_sbox7[U8a(z[0])];
+                        t[1] = x[1] = z[0] ^ cast_sbox5[U8a(x[0])] ^
+                         cast_sbox6[U8c(x[0])] ^ cast_sbox7[U8b(x[0])] ^
+                         cast_sbox8[U8d(x[0])] ^ cast_sbox8[U8c(z[0])];
+                        t[2] = x[2] = z[1] ^ cast_sbox5[U8d(x[1])] ^
+                         cast_sbox6[U8c(x[1])] ^ cast_sbox7[U8b(x[1])] ^
+                         cast_sbox8[U8a(x[1])] ^ cast_sbox5[U8b(z[0])];
+                        t[3] = x[3] = z[3] ^ cast_sbox5[U8c(x[2])] ^
+                         cast_sbox6[U8b(x[2])] ^ cast_sbox7[U8d(x[2])] ^
+                         cast_sbox8[U8a(x[2])] ^ cast_sbox6[U8d(z[0])];
+                        break;
+                }
+                switch (i & 12) {
+                 case 0:
+                 case 12:
+                        key->xkey[i+0] = cast_sbox5[U8a(t[2])] ^ cast_sbox6[U8b(t[2])] ^
+                         cast_sbox7[U8d(t[1])] ^ cast_sbox8[U8c(t[1])];
+                        key->xkey[i+1] = cast_sbox5[U8c(t[2])] ^ cast_sbox6[U8d(t[2])] ^
+                         cast_sbox7[U8b(t[1])] ^ cast_sbox8[U8a(t[1])];
+                        key->xkey[i+2] = cast_sbox5[U8a(t[3])] ^ cast_sbox6[U8b(t[3])] ^
+                         cast_sbox7[U8d(t[0])] ^ cast_sbox8[U8c(t[0])];
+                        key->xkey[i+3] = cast_sbox5[U8c(t[3])] ^ cast_sbox6[U8d(t[3])] ^
+                         cast_sbox7[U8b(t[0])] ^ cast_sbox8[U8a(t[0])];
+                        break;
+                 case 4:
+                 case 8:
+                        key->xkey[i+0] = cast_sbox5[U8d(t[0])] ^ cast_sbox6[U8c(t[0])] ^
+                         cast_sbox7[U8a(t[3])] ^ cast_sbox8[U8b(t[3])];
+                        key->xkey[i+1] = cast_sbox5[U8b(t[0])] ^ cast_sbox6[U8a(t[0])] ^
+                         cast_sbox7[U8c(t[3])] ^ cast_sbox8[U8d(t[3])];
+                        key->xkey[i+2] = cast_sbox5[U8d(t[1])] ^ cast_sbox6[U8c(t[1])] ^
+                         cast_sbox7[U8a(t[2])] ^ cast_sbox8[U8b(t[2])];
+                        key->xkey[i+3] = cast_sbox5[U8b(t[1])] ^ cast_sbox6[U8a(t[1])] ^
+                         cast_sbox7[U8c(t[2])] ^ cast_sbox8[U8d(t[2])];
+                        break;
+                }
+                switch (i & 12) {
+                 case 0:
+                        key->xkey[i+0] ^= cast_sbox5[U8c(z[0])];
+                        key->xkey[i+1] ^= cast_sbox6[U8c(z[1])];
+                        key->xkey[i+2] ^= cast_sbox7[U8b(z[2])];
+                        key->xkey[i+3] ^= cast_sbox8[U8a(z[3])];
+                        break;
+                 case 4:
+                        key->xkey[i+0] ^= cast_sbox5[U8a(x[2])];
+                        key->xkey[i+1] ^= cast_sbox6[U8b(x[3])];
+                        key->xkey[i+2] ^= cast_sbox7[U8d(x[0])];
+                        key->xkey[i+3] ^= cast_sbox8[U8d(x[1])];
+                        break;
+                 case 8:
+                        key->xkey[i+0] ^= cast_sbox5[U8b(z[2])];
+                        key->xkey[i+1] ^= cast_sbox6[U8a(z[3])];
+                        key->xkey[i+2] ^= cast_sbox7[U8c(z[0])];
+                        key->xkey[i+3] ^= cast_sbox8[U8c(z[1])];
+                        break;
+                 case 12:
+                        key->xkey[i+0] ^= cast_sbox5[U8d(x[0])];
+                        key->xkey[i+1] ^= cast_sbox6[U8d(x[1])];
+                        key->xkey[i+2] ^= cast_sbox7[U8a(x[2])];
+                        key->xkey[i+3] ^= cast_sbox8[U8b(x[3])];
+                        break;
+                }
+                if (i >= 16) {
+                        key->xkey[i+0] &= 31;
+                        key->xkey[i+1] &= 31;
+                        key->xkey[i+2] &= 31;
+                        key->xkey[i+3] &= 31;
+                }
+        }
+        /* Wipe clean */
+        for (i = 0; i < 4; i++) {
+                t[i] = x[i] = z[i] = 0;
+        }
+}
+
+/* Made in Canada */
+
diff --git a/src/lib/libc/crypt/crypt.3 b/src/lib/libc/crypt/crypt.3
new file mode 100644
index 0000000000..5f0f1cdba8
--- /dev/null
+++ b/src/lib/libc/crypt/crypt.3
@@ -0,0 +1,314 @@
+.\" $OpenBSD: crypt.3,v 1.19 2002/01/24 20:33:45 mickey Exp $
+.\"
+.\" FreeSec: libcrypt
+.\"
+.\" Copyright (c) 1994 David Burren
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 4. Neither the name of the author nor the names of other contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" Manual page, using -mandoc macros
+.\"
+.Dd March 9, 1994
+.Dt CRYPT 3
+.Os
+.Sh NAME
+.Nm crypt ,
+.Nm setkey ,
+.Nm encrypt ,
+.Nm des_setkey ,
+.Nm des_cipher
+.Nd DES encryption
+.Sh SYNOPSIS
+.Fd #include <unistd.h>
+.Ft char *
+.Fn crypt "const char *key" "const char *setting"
+.Ft int
+.Fn setkey "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"
+.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 null 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 null Ns -terminated
+string, 20 or 13 bytes (plus null) in length, consisting of the
+.Ar setting
+followed by the encoded 64-bit encryption.
+.Pp
+The functions
+.Fn encrypt ,
+.Fn setkey ,
+.Fn des_setkey ,
+and
+.Fn des_cipher
+provide access to the
+.Tn DES
+algorithm itself.
+.Fn setkey
+is passed a 64-byte array of binary values (numeric 0 or 1).
+A 56-bit key is extracted from this array by dividing the
+array into groups of 8, and ignoring the last bit in each group.
+That bit is reserved for a byte parity check by DES, but is ignored
+by these functions.
+.Pp
+The
+.Fa block
+argument to
+.Fn encrypt
+is also a 64-byte array of binary values.
+If the value of
+.Fa flag
+is 0,
+.Fa block
+is encrypted otherwise it is decrypted.
+The result is returned in the original array
+.Fa block
+after using the key specified by
+.Fn setkey
+to process it.
+.Pp
+The argument to
+.Fn des_setkey
+is a character array of length 8.
+The least significant bit (the parity bit) in each character is ignored,
+and the remaining bits are concatenated to form a 56-bit key.
+The function
+.Fn des_cipher
+encrypts (or decrypts if
+.Fa count
+is negative) the 64-bits stored in the 8 characters at
+.Fa in
+using
+.Xr abs 3
+of
+.Fa count
+iterations of
+.Tn DES
+and stores the 64-bit result in the 8 characters at
+.Fa out
+(which may be the same as
+.Fa in ) .
+The
+.Fa salt
+specifies perturbations to the
+.Tn DES
+E-box output as described above.
+.Pp
+The function
+.Fn crypt
+returns a pointer to the encrypted value on success, and
+.Dv NULL
+on failure.
+The functions
+.Fn setkey ,
+.Fn encrypt ,
+.Fn des_setkey ,
+and
+.Fn des_cipher
+return 0 on success and 1 on failure.
+.Pp
+The
+.Fn crypt ,
+.Fn setkey ,
+and
+.Fn des_setkey
+functions all manipulate the same key space.
+.Sh SEE ALSO
+.Xr login 1 ,
+.Xr passwd 1 ,
+.Xr blowfish 3 ,
+.Xr getpass 3 ,
+.Xr md5 3 ,
+.Xr passwd 5
+.Sh AUTHORS
+David Burren <davidb@werj.com.au>
+.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 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..17b50b7f52
--- /dev/null
+++ b/src/lib/libc/crypt/crypt.c
@@ -0,0 +1,713 @@
+/*      $OpenBSD: crypt.c,v 1.16 2002/04/29 06:26:50 pvalchev 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.
+ *
+ * NOTE:
+ * This file has a static version of des_setkey() so that crypt.o exports
+ * only the crypt() interface. This is required to make binaries linked
+ * against crypt.o exportable or re-exportable from the USA.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: crypt.c,v 1.16 2002/04/29 06:26:50 pvalchev Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <pwd.h>
+#include <string.h>
+
+#ifdef DEBUG
+# include <stdio.h>
+#endif
+
+static 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   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 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 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 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 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
+};
+
+static u_int32_t 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
+};
+
+static u_char   bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+static u_int32_t saltbits;
+static int32_t  old_salt;
+static 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];
+static 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(ch)
+        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);
+}
+
+static void
+des_init()
+{
+        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 = 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 & bits8[j]) {
+                                        if ((obit = init_perm[inbit]) < 32)
+                                                *il |= bits32[obit];
+                                        else
+                                                *ir |= bits32[obit-32];
+                                        if ((obit = final_perm[inbit]) < 32)
+                                                *fl |= bits32[obit];
+                                        else
+                                                *fr |= 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 & 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 & 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 & bits8[j])
+                                        *p |= bits32[un_pbox[8 * b + j]];
+                        }
+                }
+
+        des_initialised = 1;
+}
+
+static void
+setup_salt(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;
+        }
+}
+
+static int
+des_setkey(key)
+        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);
+}
+
+static int
+do_des(l_in, r_in, l_out, r_out, count)
+        u_int32_t l_in, r_in, *l_out, *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);
+}
+
+static int
+des_cipher(in, out, salt, count)
+        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();
+
+        setup_salt(salt);
+
+        memcpy(x, in, sizeof x);
+        rawl = ntohl(x[0]);
+        rawr = ntohl(x[1]);
+        retval = 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(key, setting)
+        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((u_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((u_char*)keybuf, (u_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((u_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;
+        }
+        setup_salt(salt);
+        /*
+         * Do it.
+         */
+        if (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/md5crypt.c b/src/lib/libc/crypt/md5crypt.c
new file mode 100644
index 0000000000..048858494c
--- /dev/null
+++ b/src/lib/libc/crypt/md5crypt.c
@@ -0,0 +1,156 @@
+/*      $OpenBSD: md5crypt.c,v 1.11 2003/04/02 20:35:29 millert 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 $
+ *
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: md5crypt.c,v 1.11 2003/04/02 20:35:29 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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(s, v, n)
+        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(pw, salt)
+        register const char *pw;
+        register const char *salt;
+{
+        /*
+         * This string is magic for this algorithm.  Having
+         * it this way, we can get get better later on
+         */
+        static unsigned char    *magic = (unsigned char *)"$1$";
+
+        static char     passwd[120], *p;
+        static const unsigned char *sp,*ep;
+        unsigned char   final[16];
+        int sl,pl,i;
+        MD5_CTX ctx,ctx1;
+        u_int32_t l;
+
+        /* Refine the Salt first */
+        sp = (const unsigned char *)salt;
+
+        /* If it starts with the magic string, then skip that */
+        if(!strncmp((const char *)sp,(const char *)magic,strlen((const char *)magic)))
+                sp += strlen((const char *)magic);
+
+        /* It stops at the first '$', max 8 chars */
+        for(ep=sp;*ep && *ep != '$' && ep < (sp+8);ep++)
+                continue;
+
+        /* get the length of the true salt */
+        sl = ep - sp;
+
+        MD5Init(&ctx);
+
+        /* The password first, since that is what is most unknown */
+        MD5Update(&ctx,(const unsigned char *)pw,strlen(pw));
+
+        /* Then our magic string */
+        MD5Update(&ctx,magic,strlen((const char *)magic));
+
+        /* Then the raw salt */
+        MD5Update(&ctx,sp,sl);
+
+        /* Then just as many characters of the MD5(pw,salt,pw) */
+        MD5Init(&ctx1);
+        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+        MD5Update(&ctx1,sp,sl);
+        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+        MD5Final(final,&ctx1);
+        for(pl = strlen(pw); pl > 0; pl -= 16)
+                MD5Update(&ctx,final,pl>16 ? 16 : pl);
+
+        /* Don't leave anything around in vm they could use. */
+        memset(final,0,sizeof final);
+
+        /* Then something really weird... */
+        for (i = strlen(pw); i ; i >>= 1)
+                if(i&1)
+                    MD5Update(&ctx, final, 1);
+                else
+                    MD5Update(&ctx, (const unsigned char *)pw, 1);
+
+        /* Now make the output string */
+        snprintf(passwd, sizeof(passwd), "%s%.*s$", (char *)magic,
+            sl, (const char *)sp);
+
+        MD5Final(final,&ctx);
+
+        /*
+         * and now, just to make sure things don't run too fast
+         * On a 60 Mhz Pentium this takes 34 msec, so you would
+         * need 30 seconds to build a 1000 entry dictionary...
+         */
+        for(i=0;i<1000;i++) {
+                MD5Init(&ctx1);
+                if(i & 1)
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+                else
+                        MD5Update(&ctx1,final,16);
+
+                if(i % 3)
+                        MD5Update(&ctx1,sp,sl);
+
+                if(i % 7)
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+
+                if(i & 1)
+                        MD5Update(&ctx1,final,16);
+                else
+                        MD5Update(&ctx1,(const unsigned char *)pw,strlen(pw));
+                MD5Final(final,&ctx1);
+        }
+
+        p = passwd + strlen(passwd);
+
+        l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p,l,4); p += 4;
+        l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p,l,4); p += 4;
+        l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p,l,4); p += 4;
+        l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p,l,4); p += 4;
+        l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p,l,4); p += 4;
+        l =                    final[11]                ; to64(p,l,2); p += 2;
+        *p = '\0';
+
+        /* Don't leave anything around in vm they could use. */
+        memset(final,0,sizeof final);
+
+        return passwd;
+}
+
diff --git a/src/lib/libc/crypt/morecrypt.c b/src/lib/libc/crypt/morecrypt.c
new file mode 100644
index 0000000000..e9e0ced4c1
--- /dev/null
+++ b/src/lib/libc/crypt/morecrypt.c
@@ -0,0 +1,628 @@
+/*      $OpenBSD: morecrypt.c,v 1.9 1998/03/22 19:01:20 niklas 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.
+ *
+ * NOTE:
+ * This file must copy certain chunks of crypt.c for legal reasons.
+ * crypt.c can only export the interface crypt(), to make binaries
+ * exportable from the USA. Hence, to also have the other crypto interfaces
+ * available we have to copy pieces...
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: morecrypt.c,v 1.9 1998/03/22 19:01:20 niklas Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <pwd.h>
+#include <string.h>
+
+#ifdef DEBUG
+# include <stdio.h>
+#endif
+
+static 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   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 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 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 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 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
+};
+
+static u_int32_t 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
+};
+
+static u_char   bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+static u_int32_t saltbits;
+static int32_t  old_salt;
+static 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];
+static 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 __inline int
+ascii_to_bin(ch)
+        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()
+{
+        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 = 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 & bits8[j]) {
+                                        if ((obit = init_perm[inbit]) < 32)
+                                                *il |= bits32[obit];
+                                        else
+                                                *ir |= bits32[obit-32];
+                                        if ((obit = final_perm[inbit]) < 32)
+                                                *fl |= bits32[obit];
+                                        else
+                                                *fr |= 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 & 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 & 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 & bits8[j])
+                                        *p |= bits32[un_pbox[8 * b + j]];
+                        }
+                }
+
+        des_initialised = 1;
+}
+
+void
+setup_salt(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
+do_des(l_in, r_in, l_out, r_out, count)
+        u_int32_t l_in, r_in, *l_out, *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(in, out, salt, count)
+        const char *in;
+        char *out;
+        long salt;
+        int count;
+{
+        u_int32_t l_out, r_out, rawl, rawr;
+        u_int32_t x[2];
+        int     retval;
+
+        if (!des_initialised)
+                des_init();
+
+        setup_salt((int32_t)salt);
+
+        memcpy(x, in, sizeof x);
+        rawl = ntohl(x[0]);
+        rawr = ntohl(x[1]);
+        retval = 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);
+}
+
+int
+des_setkey(key)
+        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
+setkey(key)
+        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] |= bits8[j];
+        }
+        return(des_setkey(p));
+}
+
+int
+encrypt(block, flag)
+        char *block;
+        int flag;
+{
+        u_int32_t io[2];
+        u_char  *p;
+        int     i, j, retval;
+
+        if (!des_initialised)
+                des_init();
+
+        setup_salt((int32_t)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] |= bits32[j];
+        }
+        retval = 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] & bits32[j]) ? 1 : 0;
+        return(retval);
+}
diff --git a/src/lib/libc/crypt/skipjack.c b/src/lib/libc/crypt/skipjack.c
new file mode 100644
index 0000000000..e700f40c39
--- /dev/null
+++ b/src/lib/libc/crypt/skipjack.c
@@ -0,0 +1,258 @@
+/* 
+ * Further optimized test implementation of SKIPJACK algorithm 
+ * Mark Tillotson <markt@chaos.org.uk>, 25 June 98
+ * Optimizations suit RISC (lots of registers) machine best.
+ *
+ * based on unoptimized implementation of
+ * Panu Rissanen <bande@lut.fi> 960624
+ *
+ * SKIPJACK and KEA Algorithm Specifications 
+ * Version 2.0 
+ * 29 May 1998
+*/
+
+#include <sys/param.h>
+#include <skipjack.h>
+#include <stdlib.h>
+
+static const u_int8_t ftable[0x100] =
+{ 
+        0xa3, 0xd7, 0x09, 0x83, 0xf8, 0x48, 0xf6, 0xf4, 
+        0xb3, 0x21, 0x15, 0x78, 0x99, 0xb1, 0xaf, 0xf9, 
+        0xe7, 0x2d, 0x4d, 0x8a, 0xce, 0x4c, 0xca, 0x2e, 
+        0x52, 0x95, 0xd9, 0x1e, 0x4e, 0x38, 0x44, 0x28, 
+        0x0a, 0xdf, 0x02, 0xa0, 0x17, 0xf1, 0x60, 0x68, 
+        0x12, 0xb7, 0x7a, 0xc3, 0xe9, 0xfa, 0x3d, 0x53, 
+        0x96, 0x84, 0x6b, 0xba, 0xf2, 0x63, 0x9a, 0x19, 
+        0x7c, 0xae, 0xe5, 0xf5, 0xf7, 0x16, 0x6a, 0xa2, 
+        0x39, 0xb6, 0x7b, 0x0f, 0xc1, 0x93, 0x81, 0x1b, 
+        0xee, 0xb4, 0x1a, 0xea, 0xd0, 0x91, 0x2f, 0xb8, 
+        0x55, 0xb9, 0xda, 0x85, 0x3f, 0x41, 0xbf, 0xe0, 
+        0x5a, 0x58, 0x80, 0x5f, 0x66, 0x0b, 0xd8, 0x90, 
+        0x35, 0xd5, 0xc0, 0xa7, 0x33, 0x06, 0x65, 0x69, 
+        0x45, 0x00, 0x94, 0x56, 0x6d, 0x98, 0x9b, 0x76, 
+        0x97, 0xfc, 0xb2, 0xc2, 0xb0, 0xfe, 0xdb, 0x20, 
+        0xe1, 0xeb, 0xd6, 0xe4, 0xdd, 0x47, 0x4a, 0x1d, 
+        0x42, 0xed, 0x9e, 0x6e, 0x49, 0x3c, 0xcd, 0x43, 
+        0x27, 0xd2, 0x07, 0xd4, 0xde, 0xc7, 0x67, 0x18, 
+        0x89, 0xcb, 0x30, 0x1f, 0x8d, 0xc6, 0x8f, 0xaa, 
+        0xc8, 0x74, 0xdc, 0xc9, 0x5d, 0x5c, 0x31, 0xa4, 
+        0x70, 0x88, 0x61, 0x2c, 0x9f, 0x0d, 0x2b, 0x87, 
+        0x50, 0x82, 0x54, 0x64, 0x26, 0x7d, 0x03, 0x40, 
+        0x34, 0x4b, 0x1c, 0x73, 0xd1, 0xc4, 0xfd, 0x3b, 
+        0xcc, 0xfb, 0x7f, 0xab, 0xe6, 0x3e, 0x5b, 0xa5, 
+        0xad, 0x04, 0x23, 0x9c, 0x14, 0x51, 0x22, 0xf0, 
+        0x29, 0x79, 0x71, 0x7e, 0xff, 0x8c, 0x0e, 0xe2, 
+        0x0c, 0xef, 0xbc, 0x72, 0x75, 0x6f, 0x37, 0xa1, 
+        0xec, 0xd3, 0x8e, 0x62, 0x8b, 0x86, 0x10, 0xe8, 
+        0x08, 0x77, 0x11, 0xbe, 0x92, 0x4f, 0x24, 0xc5, 
+        0x32, 0x36, 0x9d, 0xcf, 0xf3, 0xa6, 0xbb, 0xac, 
+        0x5e, 0x6c, 0xa9, 0x13, 0x57, 0x25, 0xb5, 0xe3, 
+        0xbd, 0xa8, 0x3a, 0x01, 0x05, 0x59, 0x2a, 0x46
+};
+
+/*
+ * For each key byte generate a table to represent the function 
+ *    ftable [in ^ keybyte]
+ *
+ * These tables used to save an XOR in each stage of the G-function
+ * the tables are hopefully pointed to by register allocated variables
+ * k0, k1..k9
+ */
+void
+subkey_table_gen (u_int8_t *key, u_int8_t **key_tables)
+{
+        int i, k;
+
+        for (k = 0; k < 10; k++) {
+                u_int8_t   key_byte = key[k];
+                u_int8_t * table = (u_int8_t *) malloc(0x100);
+                /* XXX */
+
+                key_tables[k] = table;
+                for (i = 0; i < 0x100; i++)
+                        table[i] = ftable[i ^ key_byte];
+        }
+}
+
+
+#define g(k0, k1, k2, k3, ih, il, oh, ol) \
+{ \
+        oh = k##k0 [il] ^ ih; \
+        ol = k##k1 [oh] ^ il; \
+        oh = k##k2 [ol] ^ oh; \
+        ol = k##k3 [oh] ^ ol; \
+}
+
+#define g0(ih, il, oh, ol) g(0, 1, 2, 3, ih, il, oh, ol)
+#define g4(ih, il, oh, ol) g(4, 5, 6, 7, ih, il, oh, ol)
+#define g8(ih, il, oh, ol) g(8, 9, 0, 1, ih, il, oh, ol)
+#define g2(ih, il, oh, ol) g(2, 3, 4, 5, ih, il, oh, ol)
+#define g6(ih, il, oh, ol) g(6, 7, 8, 9, ih, il, oh, ol)
+
+ 
+#define g_inv(k0, k1, k2, k3, ih, il, oh, ol) \
+{ \
+        ol = k##k3 [ih] ^ il; \
+        oh = k##k2 [ol] ^ ih; \
+        ol = k##k1 [oh] ^ ol; \
+        oh = k##k0 [ol] ^ oh; \
+}
+
+
+#define g0_inv(ih, il, oh, ol) g_inv(0, 1, 2, 3, ih, il, oh, ol)
+#define g4_inv(ih, il, oh, ol) g_inv(4, 5, 6, 7, ih, il, oh, ol)
+#define g8_inv(ih, il, oh, ol) g_inv(8, 9, 0, 1, ih, il, oh, ol)
+#define g2_inv(ih, il, oh, ol) g_inv(2, 3, 4, 5, ih, il, oh, ol)
+#define g6_inv(ih, il, oh, ol) g_inv(6, 7, 8, 9, ih, il, oh, ol)
+
+/* optimized version of Skipjack algorithm
+ *
+ * the appropriate g-function is inlined for each round
+ *
+ * the data movement is minimized by rotating the names of the 
+ * variables w1..w4, not their contents (saves 3 moves per round)
+ *
+ * the loops are completely unrolled (needed to staticize choice of g)
+ *
+ * compiles to about 470 instructions on a Sparc (gcc -O)
+ * which is about 58 instructions per byte, 14 per round.
+ * gcc seems to leave in some unnecessary and with 0xFF operations
+ * but only in the latter part of the functions.  Perhaps it
+ * runs out of resources to properly optimize long inlined function?
+ * in theory should get about 11 instructions per round, not 14
+ */
+
+void
+skipjack_forwards(u_int8_t *plain, u_int8_t *cipher, u_int8_t **key_tables)
+{
+        u_int8_t wh1 = plain[0];  u_int8_t wl1 = plain[1];
+        u_int8_t wh2 = plain[2];  u_int8_t wl2 = plain[3];
+        u_int8_t wh3 = plain[4];  u_int8_t wl3 = plain[5];
+        u_int8_t wh4 = plain[6];  u_int8_t wl4 = plain[7];
+
+        u_int8_t * k0 = key_tables [0];
+        u_int8_t * k1 = key_tables [1];
+        u_int8_t * k2 = key_tables [2];
+        u_int8_t * k3 = key_tables [3];
+        u_int8_t * k4 = key_tables [4];
+        u_int8_t * k5 = key_tables [5];
+        u_int8_t * k6 = key_tables [6];
+        u_int8_t * k7 = key_tables [7];
+        u_int8_t * k8 = key_tables [8];
+        u_int8_t * k9 = key_tables [9];
+
+        /* first 8 rounds */
+        g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 1; wh4 ^= wh1;
+        g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 2; wh3 ^= wh4;
+        g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 3; wh2 ^= wh3;
+        g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 4; wh1 ^= wh2;
+        g6 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 5; wh4 ^= wh1;
+        g0 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 6; wh3 ^= wh4;
+        g4 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 7; wh2 ^= wh3;
+        g8 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 8; wh1 ^= wh2;
+
+        /* second 8 rounds */
+        wh2 ^= wh1; wl2 ^= wl1 ^ 9 ; g2 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 10; g6 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 11; g0 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 12; g4 (wh2,wl2, wh2,wl2);
+        wh2 ^= wh1; wl2 ^= wl1 ^ 13; g8 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 14; g2 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 15; g6 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 16; g0 (wh2,wl2, wh2,wl2);
+
+        /* third 8 rounds */
+        g4 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 17; wh4 ^= wh1;
+        g8 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 18; wh3 ^= wh4;
+        g2 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 19; wh2 ^= wh3;
+        g6 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 20; wh1 ^= wh2;
+        g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 21; wh4 ^= wh1;
+        g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 22; wh3 ^= wh4;
+        g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 23; wh2 ^= wh3;
+        g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 24; wh1 ^= wh2;
+
+        /* last 8 rounds */
+        wh2 ^= wh1; wl2 ^= wl1 ^ 25; g6 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 26; g0 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 27; g4 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 28; g8 (wh2,wl2, wh2,wl2);
+        wh2 ^= wh1; wl2 ^= wl1 ^ 29; g2 (wh1,wl1, wh1,wl1);
+        wh1 ^= wh4; wl1 ^= wl4 ^ 30; g6 (wh4,wl4, wh4,wl4);
+        wh4 ^= wh3; wl4 ^= wl3 ^ 31; g0 (wh3,wl3, wh3,wl3);
+        wh3 ^= wh2; wl3 ^= wl2 ^ 32; g4 (wh2,wl2, wh2,wl2);
+
+        /* pack into byte vector */
+        cipher [0] = wh1;  cipher [1] = wl1;
+        cipher [2] = wh2;  cipher [3] = wl2;
+        cipher [4] = wh3;  cipher [5] = wl3;
+        cipher [6] = wh4;  cipher [7] = wl4;
+}
+
+
+void
+skipjack_backwards (u_int8_t *cipher, u_int8_t *plain, u_int8_t **key_tables)
+{
+        /* setup 4 16-bit portions */
+        u_int8_t wh1 = cipher[0];  u_int8_t wl1 = cipher[1];
+        u_int8_t wh2 = cipher[2];  u_int8_t wl2 = cipher[3];
+        u_int8_t wh3 = cipher[4];  u_int8_t wl3 = cipher[5];
+        u_int8_t wh4 = cipher[6];  u_int8_t wl4 = cipher[7];
+
+        u_int8_t * k0 = key_tables [0];
+        u_int8_t * k1 = key_tables [1];
+        u_int8_t * k2 = key_tables [2];
+        u_int8_t * k3 = key_tables [3];
+        u_int8_t * k4 = key_tables [4];
+        u_int8_t * k5 = key_tables [5];
+        u_int8_t * k6 = key_tables [6];
+        u_int8_t * k7 = key_tables [7];
+        u_int8_t * k8 = key_tables [8];
+        u_int8_t * k9 = key_tables [9];
+
+        /* first 8 rounds */
+        g4_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 32; wh3 ^= wh2;
+        g0_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 31; wh4 ^= wh3;
+        g6_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 30; wh1 ^= wh4;
+        g2_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 29; wh2 ^= wh1;
+        g8_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 28; wh3 ^= wh2;
+        g4_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 27; wh4 ^= wh3;
+        g0_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 26; wh1 ^= wh4;
+        g6_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 25; wh2 ^= wh1;
+
+        /* second 8 rounds */
+        wh1 ^= wh2; wl1 ^= wl2 ^ 24; g2_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 23; g8_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 22; g4_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 21; g0_inv (wh1,wl1, wh1,wl1);
+        wh1 ^= wh2; wl1 ^= wl2 ^ 20; g6_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 19; g2_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 18; g8_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 17; g4_inv (wh1,wl1, wh1,wl1);
+
+        /* third 8 rounds */
+        g0_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 16; wh3 ^= wh2;
+        g6_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 15; wh4 ^= wh3;
+        g2_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 14; wh1 ^= wh4;
+        g8_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 13; wh2 ^= wh1;
+        g4_inv (wh2,wl2, wh2,wl2); wl3 ^= wl2 ^ 12; wh3 ^= wh2;
+        g0_inv (wh3,wl3, wh3,wl3); wl4 ^= wl3 ^ 11; wh4 ^= wh3;
+        g6_inv (wh4,wl4, wh4,wl4); wl1 ^= wl4 ^ 10; wh1 ^= wh4;
+        g2_inv (wh1,wl1, wh1,wl1); wl2 ^= wl1 ^ 9;  wh2 ^= wh1;
+
+        /* last 8 rounds */
+        wh1 ^= wh2; wl1 ^= wl2 ^ 8; g8_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 7; g4_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 6; g0_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 5; g6_inv (wh1,wl1, wh1,wl1);
+        wh1 ^= wh2; wl1 ^= wl2 ^ 4; g2_inv (wh2,wl2, wh2,wl2);
+        wh2 ^= wh3; wl2 ^= wl3 ^ 3; g8_inv (wh3,wl3, wh3,wl3);
+        wh3 ^= wh4; wl3 ^= wl4 ^ 2; g4_inv (wh4,wl4, wh4,wl4);
+        wh4 ^= wh1; wl4 ^= wl1 ^ 1; g0_inv (wh1,wl1, wh1,wl1);
+
+        /* pack into byte vector */
+        plain [0] = wh1;  plain [1] = wl1;
+        plain [2] = wh2;  plain [3] = wl2;
+        plain [4] = wh3;  plain [5] = wl3;
+        plain [6] = wh4;  plain [7] = wl4;
+}
diff --git a/src/lib/libc/include/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..4212e7dcb2
--- /dev/null
+++ b/src/lib/libc/include/thread_private.h
@@ -0,0 +1,134 @@
+/* $OpenBSD: thread_private.h,v 1.15 2003/01/28 04:58:00 marc Exp $ */
+
+#ifndef _THREAD_PRIVATE_H_
+#define _THREAD_PRIVATE_H_
+
+#include <pthread.h>
+
+/*
+ * This variable is initially 0 when there is exactly one thread.
+ * It should never decrease.
+ */
+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
+
+/*
+ * These macros help in making persistent storage thread-specific.
+ * Libc makes extensive use of private static data structures
+ * that hold state across function invocation, and these macros
+ * are no-ops when running single-threaded.
+ *
+ * Linking against the user-thread library causes these macros to
+ * allocate storage on a per-thread basis.
+ */
+        
+#define __THREAD_MUTEX_NAME(name)       __CONCAT(_libc_storage_mutex_,name)
+#define __THREAD_KEY_NAME(name)         __CONCAT(_libc_storage_key_,name)
+
+struct _thread_private_key_struct {
+        pthread_once_t          once;
+        void                    (*cleanfn)(void *);
+        pthread_key_t           key;
+};
+
+void    _libc_private_storage_lock(pthread_mutex_t *);
+void    _libc_private_storage_unlock(pthread_mutex_t *);
+void *  _libc_private_storage(volatile struct _thread_private_key_struct *,
+                              void *, size_t, void *);
+
+/* Declare a module mutex. */
+#define _THREAD_PRIVATE_MUTEX(name)                                     \
+        static pthread_mutex_t __THREAD_MUTEX_NAME(name) =              \
+                PTHREAD_MUTEX_INITIALIZER                       
+                
+/* Lock a module mutex against use by any other threads. */
+#define _THREAD_PRIVATE_MUTEX_LOCK(name)                                \
+        _libc_private_storage_lock(&__THREAD_MUTEX_NAME(name))
+                
+/* Unlock a module mutex. */
+#define _THREAD_PRIVATE_MUTEX_UNLOCK(name)                              \
+        _libc_private_storage_unlock(&__THREAD_MUTEX_NAME(name))
+
+/* Declare a thread-private storage key. */
+#define _THREAD_PRIVATE_KEY(name)                                       \
+        static volatile struct _thread_private_key_struct               \
+        __THREAD_KEY_NAME(name) = {                                     \
+                PTHREAD_ONCE_INIT,                                      \
+                0                                                       \
+        }
+
+/*
+ * In threaded mode, return a pointer to thread-private memory of
+ * the same size as, and (initially) with the same contents as 'storage'. If
+ * an error occurs, the 'error' parameter is returned.
+ * In single-threaded mode, no storage is allocated. Instead, a pointer
+ * to storage is always returned.
+ * The 'cleanfn' function of the key structure is called to free the storage.
+ * If 'cleanfn' is NULL, then free() is used. This hook can be useful for
+ * getting rid of memory leaks.
+ */
+#define _THREAD_PRIVATE(keyname, storage, error)                        \
+        _libc_private_storage(&__THREAD_KEY_NAME(keyname),              \
+                              &(storage), sizeof (storage), error)
+
+/*
+ * Keys used to access the per thread instances of resolver global data.
+ * These are not static as they are referenced in several places.
+ */
+extern volatile struct _thread_private_key_struct __THREAD_KEY_NAME(_res);
+#ifdef INET6
+extern volatile struct _thread_private_key_struct __THREAD_KEY_NAME(_res_ext);
+#endif
+
+/*
+ * File descriptor locking definitions.
+ */
+#define FD_READ             0x1
+#define FD_WRITE            0x2
+#define FD_RDWR             (FD_READ | FD_WRITE)
+
+#define _FD_LOCK(_fd,_type,_ts)                                         \
+                _thread_fd_lock(_fd, _type, _ts, __FILE__, __LINE__)
+#define _FD_UNLOCK(_fd,_type)                                           \
+                _thread_fd_unlock(_fd, _type, __FILE__, __LINE__)
+
+int     _thread_fd_lock(int, int, struct timespec *, const char *, int);
+void    _thread_fd_unlock(int, int, const char *, int);
+
+/*
+ * malloc lock/unlock definitions
+ */
+# define _MALLOC_LOCK()         do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_lock();  \
+                                } while (0)
+# define _MALLOC_UNLOCK()       do {                                    \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_unlock();\
+                                } while (0)
+# define _MALLOC_LOCK_INIT()do {                                        \
+                                        if (__isthreaded)               \
+                                                _thread_malloc_init();\
+                                } while (0)
+
+
+void    _thread_malloc_init(void);
+void    _thread_malloc_lock(void);
+void    _thread_malloc_unlock(void);
+
+#endif /* _THREAD_PRIVATE_H_ */
diff --git a/src/lib/libc/net/Makefile.inc b/src/lib/libc/net/Makefile.inc
index 2d220067e4..805ae5d224 100644
--- a/src/lib/libc/net/Makefile.inc
+++ b/src/lib/libc/net/Makefile.inc
@@ -1,46 +1,85 @@
-#       $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.31 2001/08/06 14:40:47 jakob Exp $
 
 # net sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/net ${.CURDIR}/net
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/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 getproto.c getprotoent.c getprotoname.c \
+        getservbyname.c getservbyport.c getservent.c getrrsetbyname.c \
+        herror.c if_indextoname.c if_nameindex.c if_nametoindex.c inet_addr.c \
+        inet_lnaof.c inet_makeaddr.c inet_neta.c inet_netof.c inet_network.c \
+        inet_net_ntop.c inet_net_pton.c inet_ntoa.c inet_ntop.c inet_pton.c \
+        ipx_addr.c ipx_ntoa.c iso_addr.c linkaddr.c ns_addr.c ns_ntoa.c \
+        nsap_addr.c \
+        net_addrcmp.c \
+        rcmd.c rresvport.c recv.c res_comp.c res_data.c res_debug.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_ARCH}/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 getaddrinfo.3 gethostbyname.3 getifaddrs.3 \
+        getnameinfo.3 getnetent.3 getprotoent.3 getservent.3 inet.3 \
+        if_indextoname.3 inet_net.3 iso_addr.3 link_addr.3 ns.3 ipx.3 \
+        rcmd.3 rcmdsh.3 resolver.3 net_addrcmp.3 \
+        inet6_option_space.3 inet6_rthdr_space.3 \
+        getrrsetbyname.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 betoh16.3 byteorder.3 betoh32.3 byteorder.3 htole16.3 \
+        byteorder.3 htole32.3 byteorder.3 letoh16.3 byteorder.3 letoh32.3 \
+        byteorder.3 swap16.3 byteorder.3 swap32.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
+        ethers.3 ether_ntoa.3 ethers.3 ether_ntohost.3 ethers.3 ether_addr.3
+MLINKS+= getaddrinfo.3 freeaddrinfo.3 getaddrinfo.3 gai_strerror.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
 MLINKS+=getservent.3 endservent.3 getservent.3 getservbyname.3 \
         getservent.3 getservbyport.3 getservent.3 setservent.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
+        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+=iso_addr.3 iso_ntoa.3
+MLINKS+=link_addr.3 link_ntoa.3
+MLINKS+=ipx.3 ipx_addr.3 ipx.3 ipx_ntoa.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
+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+=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+=getrrsetbyname.3 freerrset.3
diff --git a/src/lib/libc/net/base64.c b/src/lib/libc/net/base64.c
new file mode 100644
index 0000000000..33b6ffdc41
--- /dev/null
+++ b/src/lib/libc/net/base64.c
@@ -0,0 +1,318 @@
+/*      $OpenBSD: base64.c,v 1.4 2002/01/02 23:00:10 deraadt Exp $      */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+
+#include <ctype.h>
+#include <resolv.h>
+#include <stdio.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+/* XXX abort illegal in library */
+#define Assert(Cond) if (!(Cond)) abort()
+
+static const char Base64[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
+
+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
+   The following encoding technique is taken from RFC 1521 by Borenstein
+   and Freed.  It is reproduced here in a slightly edited form for
+   convenience.
+
+   A 65-character subset of US-ASCII is used, enabling 6 bits to be
+   represented per printable character. (The extra 65th character, "=",
+   is used to signify a special processing function.)
+
+   The encoding process represents 24-bit groups of input bits as output
+   strings of 4 encoded characters. Proceeding from left to right, a
+   24-bit input group is formed by concatenating 3 8-bit input groups.
+   These 24 bits are then treated as 4 concatenated 6-bit groups, each
+   of which is translated into a single digit in the base64 alphabet.
+
+   Each 6-bit group is used as an index into an array of 64 printable
+   characters. The character referenced by the index is placed in the
+   output string.
+
+                         Table 1: The Base64 Alphabet
+
+      Value Encoding  Value Encoding  Value Encoding  Value Encoding
+          0 A            17 R            34 i            51 z
+          1 B            18 S            35 j            52 0
+          2 C            19 T            36 k            53 1
+          3 D            20 U            37 l            54 2
+          4 E            21 V            38 m            55 3
+          5 F            22 W            39 n            56 4
+          6 G            23 X            40 o            57 5
+          7 H            24 Y            41 p            58 6
+          8 I            25 Z            42 q            59 7
+          9 J            26 a            43 r            60 8
+         10 K            27 b            44 s            61 9
+         11 L            28 c            45 t            62 +
+         12 M            29 d            46 u            63 /
+         13 N            30 e            47 v
+         14 O            31 f            48 w         (pad) =
+         15 P            32 g            49 x
+         16 Q            33 h            50 y
+
+   Special processing is performed if fewer than 24 bits are available
+   at the end of the data being encoded.  A full encoding quantum is
+   always completed at the end of a quantity.  When fewer than 24 input
+   bits are available in an input group, zero bits are added (on the
+   right) to form an integral number of 6-bit groups.  Padding at the
+   end of the data is performed using the '=' character.
+
+   Since all base64 input is an integral number of octets, only the
+         -------------------------------------------------                       
+   following cases can arise:
+   
+       (1) the final quantum of encoding input is an integral
+           multiple of 24 bits; here, the final unit of encoded
+           output will be an integral multiple of 4 characters
+           with no "=" padding,
+       (2) the final quantum of encoding input is exactly 8 bits;
+           here, the final unit of encoded output will be two
+           characters followed by two "=" padding characters, or
+       (3) the final quantum of encoding input is exactly 16 bits;
+           here, the final unit of encoded output will be three
+           characters followed by one "=" padding character.
+   */
+
+int
+b64_ntop(src, srclength, target, targsize)
+        u_char const *src;
+        size_t srclength;
+        char *target;
+        size_t targsize;
+{
+        size_t datalength = 0;
+        u_char input[3];
+        u_char output[4];
+        int i;
+
+        while (2 < srclength) {
+                input[0] = *src++;
+                input[1] = *src++;
+                input[2] = *src++;
+                srclength -= 3;
+
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                output[3] = input[2] & 0x3f;
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+                Assert(output[3] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                target[datalength++] = Base64[output[2]];
+                target[datalength++] = Base64[output[3]];
+        }
+    
+        /* Now we worry about padding. */
+        if (0 != srclength) {
+                /* Get what's left. */
+                input[0] = input[1] = input[2] = '\0';
+                for (i = 0; i < srclength; i++)
+                        input[i] = *src++;
+        
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                if (srclength == 1)
+                        target[datalength++] = Pad64;
+                else
+                        target[datalength++] = Base64[output[2]];
+                target[datalength++] = Pad64;
+        }
+        if (datalength >= targsize)
+                return (-1);
+        target[datalength] = '\0';      /* Returned value doesn't count \0. */
+        return (datalength);
+}
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+b64_pton(src, target, targsize)
+        char const *src;
+        u_char *target;
+        size_t targsize;
+{
+        int tarindex, state, ch;
+        char *pos;
+
+        state = 0;
+        tarindex = 0;
+
+        while ((ch = *src++) != '\0') {
+                if (isspace(ch))        /* Skip whitespace anywhere. */
+                        continue;
+
+                if (ch == Pad64)
+                        break;
+
+                pos = strchr(Base64, ch);
+                if (pos == 0)           /* A non-base64 character. */
+                        return (-1);
+
+                switch (state) {
+                case 0:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] = (pos - Base64) << 2;
+                        }
+                        state = 1;
+                        break;
+                case 1:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 4;
+                                target[tarindex+1]  = ((pos - Base64) & 0x0f)
+                                                        << 4 ;
+                        }
+                        tarindex++;
+                        state = 2;
+                        break;
+                case 2:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 2;
+                                target[tarindex+1]  = ((pos - Base64) & 0x03)
+                                                        << 6;
+                        }
+                        tarindex++;
+                        state = 3;
+                        break;
+                case 3:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] |= (pos - Base64);
+                        }
+                        tarindex++;
+                        state = 0;
+                        break;
+                }
+        }
+
+        /*
+         * We are done decoding Base-64 chars.  Let's see if we ended
+         * on a byte boundary, and/or with erroneous trailing characters.
+         */
+
+        if (ch == Pad64) {              /* We got a pad char. */
+                ch = *src++;            /* Skip it, get next. */
+                switch (state) {
+                case 0:         /* Invalid = in first position */
+                case 1:         /* Invalid = in second position */
+                        return (-1);
+
+                case 2:         /* Valid, means one byte of info */
+                        /* Skip any number of spaces. */
+                        for (; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        break;
+                        /* Make sure there is another trailing = sign. */
+                        if (ch != Pad64)
+                                return (-1);
+                        ch = *src++;            /* Skip the = */
+                        /* Fall through to "single trailing =" case. */
+                        /* FALLTHROUGH */
+
+                case 3:         /* Valid, means two bytes of info */
+                        /*
+                         * We know this char is an =.  Is there anything but
+                         * whitespace after it?
+                         */
+                        for (; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        return (-1);
+
+                        /*
+                         * Now make sure for cases 2 and 3 that the "extra"
+                         * bits that slopped past the last full byte were
+                         * zeros.  If we don't check them, they become a
+                         * subliminal channel.
+                         */
+                        if (target && target[tarindex] != 0)
+                                return (-1);
+                }
+        } else {
+                /*
+                 * We ended by seeing the end of the string.  Make sure we
+                 * have no partial bytes lying around.
+                 */
+                if (state != 0)
+                        return (-1);
+        }
+
+        return (tarindex);
+}
diff --git a/src/lib/libc/net/byteorder.3 b/src/lib/libc/net/byteorder.3
index 701a69f688..9d8fa7221f 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.8 2000/04/18 03:01:30 aaron Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,35 +31,141 @@
 .\" 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
 .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 htobe32 ,
+.Nm htobe16 ,
+.Nm betoh32 ,
+.Nm betoh16 ,
+.Nm htole32 ,
+.Nm htole16 ,
+.Nm letoh32 ,
+.Nm letoh16 ,
+.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>
+.Fd #include <machine/endian.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_int32_t
+.Fn htobe32 "u_int32_t host32"
+.Ft u_int16_t
+.Fn htobe16 "u_int16_t host16"
+.Ft u_int32_t
+.Fn betoh32 "u_int32_t big32"
+.Ft u_int16_t
+.Fn betoh16 "u_int16_t big16"
+.Ft u_int32_t
+.Fn htole32 "u_int32_t host32"
+.Ft u_int16_t
+.Fn htole16 "u_int16_t host16"
+.Ft u_int32_t
+.Fn letoh32 "u_int32_t little32"
+.Ft u_int16_t
+.Fn letoh16 "u_int16_t little16"
+.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- and 32-bit quantities between different
+byte orderings.
+The
+.Dq swap
+functions reverse the byte ordering of
+the given quantity, the others converts 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.
+.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 and 32 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 .
@@ -69,10 +175,9 @@ and
 .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 so far mips,
+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..0509c121b8 100644
--- a/src/lib/libc/net/ethers.3
+++ b/src/lib/libc/net/ethers.3
@@ -1,15 +1,17 @@
+.\"     $OpenBSD: ethers.3,v 1.14 2001/08/06 10:42:26 mpech Exp $
 .\"
 .\" Written by roland@frob.com.  Public domain.
 .\"
 .Dd December 16, 1993
 .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 <netinet/if_ether.h>
@@ -17,49 +19,64 @@
 .Fn ether_ntoa "struct ether_addr *e"
 .Ft struct ether_addr *
 .Fn ether_aton "char *s"
+.Ft int
 .Fn ether_ntohost "char *hostname" "struct ether_addr *e"
+.Ft int
 .Fn ether_hostton "char *hostname" "struct ether_addr *e"
+.Ft int
 .Fn ether_line "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.
 .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 +90,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 +112,8 @@ The
 and
 .Fn ether_line
 functions were adopted from SunOS and appeared in
-NetBSD 0.9b.
+.Nx 0.9 b.
 .Sh BUGS
 The data space used by these functions is static; if future use
 requires the data, it should be copied before any subsequent calls to
-these functions overwrite it.  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..858ac5b3f3 100644
--- a/src/lib/libc/net/ethers.c
+++ b/src/lib/libc/net/ethers.c
@@ -1,12 +1,42 @@
-/*      $NetBSD: ethers.c,v 1.5 1995/02/25 06:20:28 cgd Exp $   */
+/*      $OpenBSD: ethers.c,v 1.14 2002/05/24 21:22:37 deraadt Exp $     */
 
-/* 
- * ethers(3N) a la Sun.
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
  *
- * Written by Roland McGrath <roland@frob.com> 10/14/93.
- * Public domain.
+ * 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.
+ */
+
+/* 
+ * 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>
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: ethers.c,v 1.14 2002/05/24 21:22:37 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <net/if.h>
@@ -18,22 +48,63 @@
 #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(char *, struct ether_addr *);
+
 char *
 ether_ntoa(e)
         struct ether_addr *e;
 {
         static char a[] = "xx:xx:xx:xx:xx:xx";
 
-        sprintf(a, "%02x:%02x:%02x:%02x:%02x:%02x",
+        if (e->ether_addr_octet[0] > 0xFF || e->ether_addr_octet[1] > 0xFF ||
+            e->ether_addr_octet[2] > 0xFF || e->ether_addr_octet[3] > 0xFF ||
+            e->ether_addr_octet[4] > 0xFF || e->ether_addr_octet[5] > 0xFF) {
+                errno = EINVAL;
+                return (NULL);
+        }
+
+        (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(s, e)
+        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 *
@@ -41,34 +112,33 @@ ether_aton(s)
         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);
 }
 
+int
 ether_ntohost(hostname, e)
         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
+
+        if (e->ether_addr_octet[0] > 0xFF || e->ether_addr_octet[1] > 0xFF ||
+            e->ether_addr_octet[2] > 0xFF || e->ether_addr_octet[3] > 0xFF ||
+            e->ether_addr_octet[4] > 0xFF || e->ether_addr_octet[5] > 0xFF) {
+                errno = EINVAL;
+                return (-1);
+        }
 
-        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 +146,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 +170,51 @@ 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);
 }
 
+int
 ether_hostton(hostname, e)
         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 +226,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 +234,39 @@ 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;
+int
+ether_line(line, e, hostname)
+        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/net/freeaddrinfo.c b/src/lib/libc/net/freeaddrinfo.c
new file mode 100644
index 0000000000..30fbecb805
--- /dev/null
+++ b/src/lib/libc/net/freeaddrinfo.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996, 1997, 1998, 1999, Craig Metz, All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Craig Metz and
+ *      by other contributors.
+ * 4. Neither the name of the author nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <netdb.h>
+
+void
+freeaddrinfo(ai)
+        struct addrinfo *ai;
+{
+        struct addrinfo *p;
+
+        do {
+                p = ai;
+                ai = ai->ai_next;
+                if (p->ai_canonname)
+                        free(p->ai_canonname);
+                free((void *)p);
+        } while (ai);
+}
diff --git a/src/lib/libc/net/gai_strerror.c b/src/lib/libc/net/gai_strerror.c
new file mode 100644
index 0000000000..a191cb5b28
--- /dev/null
+++ b/src/lib/libc/net/gai_strerror.c
@@ -0,0 +1,76 @@
+/*      $OpenBSD: gai_strerror.c,v 1.5 2001/06/05 02:31:34 deraadt Exp $        */
+
+/*
+ * Copyright (c) 1997-1999, Craig Metz, All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Craig Metz and
+ *      by other contributors.
+ * 4. Neither the name of the author nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* gai_strerror() v1.38 */
+
+#include <sys/types.h>
+#include <netdb.h>
+#include <errno.h>
+
+char *
+gai_strerror(int errnum)
+{
+        switch (errnum) {
+        case 0:
+                return "no error";
+        case EAI_BADFLAGS:
+                return "invalid value for ai_flags";
+        case EAI_NONAME:
+                return "name or service is not known";
+        case EAI_AGAIN:
+                return "temporary failure in name resolution";
+        case EAI_FAIL:
+                return "non-recoverable failure in name resolution";
+        case EAI_NODATA:
+                return "no address associated with name";
+        case EAI_FAMILY:
+                return "ai_family not supported";
+        case EAI_SOCKTYPE:
+                return "ai_socktype not supported";
+        case EAI_SERVICE:
+                return "service not supported for ai_socktype";
+        case EAI_ADDRFAMILY:
+                return "address family for name not supported";
+        case EAI_MEMORY:
+                return "memory allocation failure";
+        case EAI_SYSTEM:
+                return "system error";
+        case EAI_BADHINTS:
+                return "invalid value for hints";
+        case EAI_PROTOCOL:
+                return "resolved protocol is unknown";
+        default:
+                return "unknown/invalid error";
+        }
+}
diff --git a/src/lib/libc/net/getaddrinfo.3 b/src/lib/libc/net/getaddrinfo.3
new file mode 100644
index 0000000000..12b5500436
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.3
@@ -0,0 +1,581 @@
+.\"     $OpenBSD: getaddrinfo.3,v 1.21 2003/05/01 19:10:09 jmc Exp $
+.\"     $KAME: getaddrinfo.3,v 1.29 2001/02/12 09:24:45 itojun Exp $
+.\"
+.\" Copyright (c) 1983, 1987, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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: @(#)gethostbyname.3       8.4 (Berkeley) 5/25/95
+.\"
+.Dd May 25, 1995
+.Dt GETADDRINFO 3
+.Os
+.\"
+.Sh NAME
+.Nm getaddrinfo ,
+.Nm freeaddrinfo ,
+.Nm gai_strerror
+.Nd nodename-to-address translation in protocol-independent manner
+.\"
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <netdb.h>
+.Ft int
+.Fn getaddrinfo "const char *nodename" "const char *servname" \
+"const struct addrinfo *hints" "struct addrinfo **res"
+.Ft void
+.Fn freeaddrinfo "struct addrinfo *ai"
+.Ft "char *"
+.Fn gai_strerror "int ecode"
+.\"
+.Sh DESCRIPTION
+The
+.Fn getaddrinfo
+function is defined for protocol-independent nodename-to-address translation.
+It performs the functionality of
+.Xr gethostbyname 3
+and
+.Xr getservbyname 3 ,
+but in a more sophisticated manner.
+.Pp
+The
+.Li addrinfo
+structure is defined as a result of including the
+.Aq Pa netdb.h
+header:
+.Bd -literal -offset
+struct addrinfo {                                                  *
+     int     ai_flags;     /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
+     int     ai_family;    /* PF_xxx */
+     int     ai_socktype;  /* SOCK_xxx */
+     int     ai_protocol;  /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+     size_t  ai_addrlen;   /* length of ai_addr */
+     char   *ai_canonname; /* canonical name for nodename */
+     struct sockaddr  *ai_addr; /* binary address */
+     struct addrinfo  *ai_next; /* next structure in linked list */
+};
+.Ed
+.Pp
+The
+.Fa nodename
+and
+.Fa servname
+arguments are pointers to NUL-terminated strings or
+.Dv NULL .
+One or both of these two arguments must be a non-null pointer.
+In the normal client scenario, both the
+.Fa nodename
+and
+.Fa servname
+are specified.
+In the normal server scenario, only the
+.Fa servname
+is specified.
+A non-null
+.Fa nodename
+string can be either a node name or a numeric host address string
+(i.e., a dotted-decimal IPv4 address or an IPv6 hex address).
+A non-null
+.Fa servname
+string can be either a service name or a decimal port number.
+.Pp
+The caller can optionally pass an
+.Li addrinfo
+structure, pointed to by the third argument,
+to provide hints concerning the type of socket that the caller supports.
+In this
+.Fa hints
+structure all members other than
+.Fa ai_flags ,
+.Fa ai_family ,
+.Fa ai_socktype ,
+and
+.Fa ai_protocol
+must be zero or a null pointer.
+A value of
+.Dv PF_UNSPEC
+for
+.Fa ai_family
+means the caller will accept any protocol family.
+A value of 0 for
+.Fa ai_socktype
+means the caller will accept any socket type.
+A value of 0 for
+.Fa ai_protocol
+means the caller will accept any protocol.
+For example, if the caller handles only TCP and not UDP, then the
+.Fa ai_socktype
+member of the hints structure should be set to
+.Dv SOCK_STREAM
+when
+.Fn getaddrinfo
+is called.
+If the caller handles only IPv4 and not IPv6, then the
+.Fa ai_family
+member of the
+.Fa hints
+structure should be set to
+.Dv PF_INET
+when
+.Fn getaddrinfo
+is called.
+If the third argument to
+.Fn getaddrinfo
+is a null pointer, this is the same as if the caller had filled in an
+.Li addrinfo
+structure initialized to zero with
+.Fa ai_family
+set to
+.Dv PF_UNSPEC .
+.Pp
+Upon successful return a pointer to a linked list of one or more
+.Li addrinfo
+structures is returned through the final argument.
+The caller can process each
+.Li addrinfo
+structure in this list by following the
+.Fa ai_next
+pointer, until a null pointer is encountered.
+In each returned
+.Li addrinfo
+structure the three members
+.Fa ai_family ,
+.Fa ai_socktype ,
+and
+.Fa ai_protocol
+are the corresponding arguments for a call to the
+.Fn socket
+function.
+In each
+.Li addrinfo
+structure the
+.Fa ai_addr
+member points to a filled-in socket address structure whose length is
+specified by the
+.Fa ai_addrlen
+member.
+.Pp
+If the
+.Dv AI_PASSIVE
+bit is set in the
+.Fa ai_flags
+member of the
+.Fa hints
+structure, then the caller plans to use the returned socket address
+structure in a call to
+.Fn bind .
+In this case, if the
+.Fa nodename
+argument is a 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 in the
+.Fa ai_flags
+member of the
+.Fa hints
+structure, then the returned socket address structure will be ready for a
+call to
+.Fn connect
+.Pq for a connection-oriented protocol
+or either
+.Fn connect ,
+.Fn sendto ,
+or
+.Fn sendmsg
+.Pq for a connectionless protocol .
+In this case, if the
+.Fa nodename
+argument is a null pointer, then the IP address portion of the
+socket address structure will be set to the loopback address.
+.Pp
+If the
+.Dv AI_CANONNAME
+bit is set in the
+.Fa ai_flags
+member of the
+.Fa hints
+structure, then upon successful return the
+.Fa ai_canonname
+member of the first
+.Li addrinfo
+structure in the linked list will point to a NUL-terminated string
+containing the canonical name of the specified
+.Fa nodename .
+.Pp
+If the
+.Dv AI_NUMERICHOST
+bit is set in the
+.Fa ai_flags
+member of the
+.Fa hints
+structure, then a non-null
+.Fa nodename
+string must be a numeric host address string.
+Otherwise an error of
+.Dv EAI_NONAME
+is returned.
+This flag prevents any type of name resolution service (e.g., the DNS)
+from being called.
+.Pp
+The arguments to
+.Fn getaddrinfo
+must sufficiently be consistent and unambiguous.
+Here are pitfall cases you may encounter:
+.Bl -bullet
+.It
+.Fn getaddrinfo
+will raise an error if members of the
+.Fa hints
+structure are not consistent.
+For example, for internet address families,
+.Fn getaddrinfo
+will raise an error if you specify
+.Dv SOCK_STREAM
+to
+.Fa ai_socktype
+while you specify
+.Dv IPPROTO_UDP
+to
+.Fa ai_protocol .
+.It
+If you specify a
+.Fa servname
+which is defined only for certain
+.Fa ai_socktype ,
+.Fn getaddrinfo
+will raise an error because the arguments are not consistent.
+For example,
+.Fn getaddrinfo
+will raise an error if you ask for
+.Dq Li tftp
+service on
+.Dv SOCK_STREAM .
+.It
+For internet address families, if you specify
+.Fa servname
+while you set
+.Fa ai_socktype
+to
+.Dv SOCK_RAW ,
+.Fn getaddrinfo
+will raise an error, because service names are not defined for the internet
+.Dv SOCK_RAW
+space.
+.It
+If you specify a numeric
+.Fa servname ,
+while leaving
+.Fa ai_socktype
+and
+.Fa ai_protocol
+unspecified,
+.Fn getaddrinfo
+will raise an error.
+This is because the numeric
+.Fa servname
+does not identify any socket type, and
+.Fn getaddrinfo
+is not allowed to glob the argument in such case.
+.El
+.Pp
+All of the information returned by
+.Fn getaddrinfo
+is dynamically allocated:
+the
+.Li addrinfo
+structures, the socket address structures, and canonical node name
+strings pointed to by the addrinfo structures.
+To return this information to the system the function
+.Fn freeaddrinfo
+is called.
+The
+.Fa addrinfo
+structure pointed to by the
+.Fa ai argument
+is freed, along with any dynamic storage pointed to by the structure.
+This operation is repeated until a
+.Dv NULL
+.Fa ai_next
+pointer is encountered.
+.Pp
+To aid applications in printing error messages based on the
+.Dv EAI_xxx
+codes returned by
+.Fn getaddrinfo ,
+.Fn gai_strerror
+is defined.
+The argument is one of the
+.Dv EAI_xxx
+values defined earlier and the return value points to a string describing
+the error.
+If the argument is not one of the
+.Dv EAI_xxx
+values, the function still returns a pointer to a string whose contents
+indicate an unknown error.
+.\"
+.Ss Extension for scoped IPv6 address
+The implementation allows experimental numeric IPv6 address notation with
+scope identifier.
+By appending the percent character and scope identifier to addresses,
+you can fill the
+.Li sin6_scope_id
+field for addresses.
+This would make management of scoped address easier,
+and allows cut-and-paste input of scoped address.
+.Pp
+At this moment the code supports only link-local addresses with the format.
+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 implementation is still very experimental and non-standard.
+The current implementation assumes a one-to-one relationship between
+the interface and link, which is not necessarily true from the specification.
+.\"
+.Sh EXAMPLES
+The following code tries to connect to
+.Dq Li www.kame.net
+service
+.Dq Li http .
+via stream socket.
+It loops through all the addresses available, regardless of address family.
+If the destination resolves to an IPv4 address, it will use
+.Dv AF_INET
+socket.
+Similarly, if it resolves to IPv6,
+.Dv AF_INET6
+socket is used.
+Observe that there is no hardcoded reference to a particular address family.
+The code works even if
+.Nm getaddrinfo
+returns addresses that are not IPv4/v6.
+.Bd -literal -offset indent
+struct addrinfo hints, *res, *res0;
+int error;
+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", "http", &hints, &res0);
+if (error) {
+        errx(1, "%s", gai_strerror(error));
+        /*NOTREACHED*/
+}
+s = -1;
+for (res = res0; res; res = res->ai_next) {
+        s = socket(res->ai_family, res->ai_socktype,
+            res->ai_protocol);
+        if (s < 0) {
+                cause = "socket";
+                continue;
+        }
+
+        if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
+                cause = "connect";
+                close(s);
+                s = -1;
+                continue;
+        }
+
+        break;  /* okay we got one */
+}
+if (s < 0) {
+        err(1, cause);
+        /*NOTREACHED*/
+}
+freeaddrinfo(res0);
+.Ed
+.Pp
+The following example tries to open a wildcard listening socket onto service
+.Dq Li http ,
+for all the address families available.
+.Bd -literal -offset indent
+struct addrinfo hints, *res, *res0;
+int error;
+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, "http", &hints, &res0);
+if (error) {
+        errx(1, "%s", gai_strerror(error));
+        /*NOTREACHED*/
+}
+nsock = 0;
+for (res = res0; res && nsock < MAXSOCK; res = res->ai_next) {
+        s[nsock] = socket(res->ai_family, res->ai_socktype,
+            res->ai_protocol);
+        if (s[nsock] < 0) {
+                cause = "socket";
+                continue;
+        }
+
+        if (bind(s[nsock], res->ai_addr, res->ai_addrlen) < 0) {
+                cause = "bind";
+                close(s[nsock]);
+                continue;
+        }
+        (void) listen(s[nsock], 5);
+
+        nsock++;
+}
+if (nsock == 0) {
+        err(1, cause);
+        /*NOTREACHED*/
+}
+freeaddrinfo(res0);
+.Ed
+.\"
+.Sh DIAGNOSTICS
+Error return status from
+.Fn getaddrinfo
+is zero on success and non-zero on errors.
+Non-zero error codes are defined in
+.Aq Pa netdb.h ,
+and as follows:
+.Pp
+.Bl -tag -width EAI_ADDRFAMILY -compact
+.It Dv EAI_ADDRFAMILY
+Address family for
+.Fa nodename
+not supported.
+.It Dv EAI_AGAIN
+Temporary failure in name resolution.
+.It Dv EAI_BADFLAGS
+Invalid value for
+.Fa ai_flags .
+.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 nodename .
+.It Dv EAI_NONAME
+.Fa nodename
+nor
+.Fa servname
+provided, or not known.
+.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
+.Pp
+If called with proper argument,
+.Fn gai_strerror
+returns a pointer to a string describing the given error code.
+If the argument is not one of the
+.Dv EAI_xxx
+values, the function still returns a pointer to a string whose contents
+indicate an unknown error.
+.\"
+.Sh SEE ALSO
+.Xr gethostbyname 3 ,
+.Xr getnameinfo 3 ,
+.Xr getservbyname 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 RFC2553
+.%D March 1999
+.Re
+.Rs
+.%A Tatsuya Jinmei
+.%A Atsushi Onoe
+.%T "An Extension of Format for IPv6 Scoped Addresses"
+.%R internet draft
+.%N draft-ietf-ipngwg-scopedaddr-format-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 HISTORY
+The implementation first appeared in WIDE Hydrangea IPv6 protocol stack kit.
+.\"
+.Sh STANDARDS
+The
+.Fn getaddrinfo
+function is defined in IEEE POSIX 1003.1g draft specification,
+and documented in
+.Dq Basic Socket Interface Extensions for IPv6
+.Pq RFC2553 .
+.\"
+.Sh BUGS
+The current implementation is not thread-safe.
+.Pp
+The text was shamelessly copied from RFC2553.
diff --git a/src/lib/libc/net/getaddrinfo.c b/src/lib/libc/net/getaddrinfo.c
new file mode 100644
index 0000000000..490b9861ae
--- /dev/null
+++ b/src/lib/libc/net/getaddrinfo.c
@@ -0,0 +1,1866 @@
+/*      $OpenBSD: getaddrinfo.c,v 1.46 2003/03/17 23:16:36 jason Exp $  */
+/*      $KAME: getaddrinfo.c,v 1.31 2000/08/31 17:36:43 itojun Exp $    */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Issues to be discussed:
+ * - Thread safe-ness must be checked.
+ * - Return values.  There are nonstandard return values defined and used
+ *   in the source code.  This is because RFC2553 is silent about which error
+ *   code must be returned for which situation.
+ * - IPv4 classful (shortened) form.  RFC2553 is silent about it.  XNET 5.2
+ *   says to use inet_aton() to convert IPv4 numeric to binary (alows
+ *   classful form as a result).
+ *   current code - disallow classful form for IPv4 (due to use of inet_pton).
+ * - freeaddrinfo(NULL).  RFC2553 is silent about it.  XNET 5.2 says it is
+ *   invalid.
+ *   current code - SEGV on freeaddrinfo(NULL)
+ * Note:
+ * - We use getipnodebyname() just for thread-safeness.  There's no intent
+ *   to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to
+ *   getipnodebyname().
+ * - The code filters out AFs that are not supported by the kernel,
+ *   when globbing NULL hostname (to loopback, or wildcard).  Is it the right
+ *   thing to do?  What is the relationship with post-RFC2553 AI_ADDRCONFIG
+ *   in ai_flags?
+ * - (post-2553) semantics of AI_ADDRCONFIG itself is too vague.
+ *   (1) what should we do against numeric hostname (2) what should we do
+ *   against NULL hostname (3) what is AI_ADDRCONFIG itself.  AF not ready?
+ *   non-loopback address configured?  global address configured?
+ * - To avoid search order issue, we have a big amount of code duplicate
+ *   from gethnamaddr.c and some other places.  The issues that there's no
+ *   lower layer function to lookup "IPv4 or IPv6" record.  Calling
+ *   gethostbyname2 from getaddrinfo will end up in wrong search order, as
+ *   follows:
+ *      - The code makes use of following calls when asked to resolver with
+ *        ai_family  = PF_UNSPEC:
+ *              getipnodebyname(host, AF_INET6);
+ *              getipnodebyname(host, AF_INET);
+ *        This will result in the following queries if the node is configure to
+ *        prefer /etc/hosts than DNS:
+ *              lookup /etc/hosts for IPv6 address
+ *              lookup DNS for IPv6 address
+ *              lookup /etc/hosts for IPv4 address
+ *              lookup DNS for IPv4 address
+ *        which may not meet people's requirement.
+ *        The right thing to happen is to have underlying layer which does
+ *        PF_UNSPEC lookup (lookup both) and return chain of addrinfos.
+ *        This would result in a bit of code duplicate with _dns_ghbyname() and
+ *        friends.
+ */
+
+#ifndef INET6
+#define INET6
+#endif
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <string.h>
+#include <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 str_isnumber(const char *);
+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 **);
+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);
+#if 0
+static int addrconfig(const struct addrinfo *);
+#endif
+#ifdef INET6
+static int ip6_str2scopeid(char *, struct sockaddr_in6 *, u_int32_t *);
+#endif
+
+static void _sethtent(void);
+static void _endhtent(void);
+static struct addrinfo * _gethtent(const char *, const struct addrinfo *);
+static struct addrinfo *_files_getaddrinfo(const char *,
+        const struct addrinfo *);
+
+#ifdef YP
+static struct addrinfo *_yphostent(char *, const struct addrinfo *);
+static struct addrinfo *_yp_getaddrinfo(const char *,
+        const struct addrinfo *);
+#endif
+
+static struct addrinfo *getanswer(const querybuf *, int, const char *, int,
+        const struct addrinfo *);
+static int res_queryN(const char *, struct res_target *);
+static int res_searchN(const char *, struct res_target *);
+static int res_querydomainN(const char *, const char *, struct res_target *);
+static struct addrinfo *_dns_getaddrinfo(const char *, const struct addrinfo *);
+
+
+/* XXX macros that make external reference is BAD. */
+
+#define GET_AI(ai, afd, addr) \
+do { \
+        /* external reference: pai, error, and label free */ \
+        (ai) = get_ai(pai, (afd), (addr)); \
+        if ((ai) == NULL) { \
+                error = EAI_MEMORY; \
+                goto free; \
+        } \
+} while (/*CONSTCOND*/0)
+
+#define GET_PORT(ai, serv) \
+do { \
+        /* external reference: error and label free */ \
+        error = get_port((ai), (serv), 0); \
+        if (error != 0) \
+                goto free; \
+} while (/*CONSTCOND*/0)
+
+#define GET_CANONNAME(ai, str) \
+do { \
+        /* external reference: pai, error and label free */ \
+        error = get_canonname(pai, (ai), (str)); \
+        if (error != 0) \
+                goto free; \
+} while (/*CONSTCOND*/0)
+
+#define ERR(err) \
+do { \
+        /* external reference: error, and label bad */ \
+        error = (err); \
+        goto bad; \
+        /*NOTREACHED*/ \
+} while (/*CONSTCOND*/0)
+
+#define MATCH_FAMILY(x, y, w) \
+        ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC)))
+#define MATCH(x, y, w) \
+        ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))
+
+static int
+str_isnumber(p)
+        const char *p;
+{
+        char *ep;
+
+        if (*p == '\0')
+                return NO;
+        ep = NULL;
+        errno = 0;
+        (void)strtoul(p, &ep, 10);
+        if (errno == 0 && ep && *ep == '\0')
+                return YES;
+        else
+                return NO;
+}
+
+int
+getaddrinfo(hostname, servname, hints, res)
+        const char *hostname, *servname;
+        const struct addrinfo *hints;
+        struct addrinfo **res;
+{
+        struct addrinfo sentinel;
+        struct addrinfo *cur;
+        int error = 0;
+        struct addrinfo ai;
+        struct addrinfo ai0;
+        struct addrinfo *pai;
+        const struct explore *ex;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+        pai = &ai;
+        pai->ai_flags = 0;
+        pai->ai_family = PF_UNSPEC;
+        pai->ai_socktype = ANY;
+        pai->ai_protocol = ANY;
+        pai->ai_addrlen = 0;
+        pai->ai_canonname = NULL;
+        pai->ai_addr = NULL;
+        pai->ai_next = NULL;
+        
+        if (hostname == NULL && servname == NULL)
+                return EAI_NONAME;
+        if (hints) {
+                /* error check for hints */
+                if (hints->ai_addrlen || hints->ai_canonname ||
+                    hints->ai_addr || hints->ai_next)
+                        ERR(EAI_BADHINTS); /* xxx */
+                if (hints->ai_flags & ~AI_MASK)
+                        ERR(EAI_BADFLAGS);
+                switch (hints->ai_family) {
+                case PF_UNSPEC:
+                case PF_INET:
+#ifdef INET6
+                case PF_INET6:
+#endif
+                        break;
+                default:
+                        ERR(EAI_FAMILY);
+                }
+                memcpy(pai, hints, sizeof(*pai));
+
+                /*
+                 * if both socktype/protocol are specified, check if they
+                 * are meaningful combination.
+                 */
+                if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
+                        for (ex = explore; ex->e_af >= 0; ex++) {
+                                if (pai->ai_family != ex->e_af)
+                                        continue;
+                                if (ex->e_socktype == ANY)
+                                        continue;
+                                if (ex->e_protocol == ANY)
+                                        continue;
+                                if (pai->ai_socktype == ex->e_socktype
+                                 && pai->ai_protocol != ex->e_protocol) {
+                                        ERR(EAI_BADHINTS);
+                                }
+                        }
+                }
+        }
+
+        /*
+         * check for special cases.  (1) numeric servname is disallowed if
+         * socktype/protocol are left unspecified. (2) servname is disallowed
+         * for raw and other inet{,6} sockets.
+         */
+        if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
+#ifdef PF_INET6
+         || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
+#endif
+            ) {
+                ai0 = *pai;     /* backup *pai */
+
+                if (pai->ai_family == PF_UNSPEC) {
+#ifdef PF_INET6
+                        pai->ai_family = PF_INET6;
+#else
+                        pai->ai_family = PF_INET;
+#endif
+                }
+                error = get_portmatch(pai, servname);
+                if (error)
+                        ERR(error);
+
+                *pai = ai0;
+        }
+
+        ai0 = *pai;
+
+        /* NULL hostname, or numeric hostname */
+        for (ex = explore; ex->e_af >= 0; ex++) {
+                *pai = ai0;
+
+                /* PF_UNSPEC entries are prepared for DNS queries only */
+                if (ex->e_af == PF_UNSPEC)
+                        continue;
+
+                if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
+                        continue;
+                if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
+                        continue;
+                if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
+                        continue;
+
+                if (pai->ai_family == PF_UNSPEC)
+                        pai->ai_family = ex->e_af;
+                if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+                        pai->ai_socktype = ex->e_socktype;
+                if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+                        pai->ai_protocol = ex->e_protocol;
+
+                if (hostname == NULL)
+                        error = explore_null(pai, servname, &cur->ai_next);
+                else
+                        error = explore_numeric_scope(pai, hostname, servname, &cur->ai_next);
+
+                if (error)
+                        goto free;
+
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        /*
+         * XXX
+         * If numreic representation of AF1 can be interpreted as FQDN
+         * representation of AF2, we need to think again about the code below.
+         */
+        if (sentinel.ai_next)
+                goto good;
+
+        if (hostname == NULL)
+                ERR(EAI_NODATA);
+        if (pai->ai_flags & AI_NUMERICHOST)
+                ERR(EAI_NONAME);
+
+        /*
+         * hostname as alphabetical name.
+         * we would like to prefer AF_INET6 than AF_INET, so we'll make a
+         * outer loop by AFs.
+         */
+        for (ex = explore; ex->e_af >= 0; ex++) {
+                *pai = ai0;
+
+                /* require exact match for family field */
+                if (pai->ai_family != ex->e_af)
+                        continue;
+
+                if (!MATCH(pai->ai_socktype, ex->e_socktype,
+                                WILD_SOCKTYPE(ex))) {
+                        continue;
+                }
+                if (!MATCH(pai->ai_protocol, ex->e_protocol,
+                                WILD_PROTOCOL(ex))) {
+                        continue;
+                }
+
+                if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+                        pai->ai_socktype = ex->e_socktype;
+                if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+                        pai->ai_protocol = ex->e_protocol;
+
+                error = explore_fqdn(pai, hostname, servname,
+                        &cur->ai_next);
+
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        /* XXX */
+        if (sentinel.ai_next)
+                error = 0;
+
+        if (error)
+                goto free;
+        if (error == 0) {
+                if (sentinel.ai_next) {
+ good:
+                        *res = sentinel.ai_next;
+                        return SUCCESS;
+                } else
+                        error = EAI_FAIL;
+        }
+ free:
+ bad:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        *res = NULL;
+        return error;
+}
+
+/*
+ * FQDN hostname, DNS lookup
+ */
+
+static int
+explore_fqdn(pai, hostname, servname, res)
+        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 0
+        /*
+         * If AI_ADDRCONFIG is specified, check if we are expected to
+         * return the address family or not.
+         * XXX does not handle PF_UNSPEC case, should filter final result
+         */
+        if ((pai->ai_flags & AI_ADDRCONFIG) != 0 && !addrconfig(pai)) {
+                return 0;
+        }
+#endif
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0) {
+                return 0;
+        }
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1)
+                strlcpy(lookups, "f", sizeof lookups);
+        else {
+                bcopy(_resp->lookups, lookups, sizeof lookups);
+                if (lookups[0] == '\0')
+                        strlcpy(lookups, "bf", sizeof lookups);
+        }
+
+        /*
+         * The yp/dns/files getaddrinfo functions are not thread safe.
+         * Protect them with a mutex.
+         */
+        _THREAD_PRIVATE_MUTEX_LOCK(_explore_mutex);
+        for (i = 0; i < MAXDNSLUS && result == NULL && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        result = _yp_getaddrinfo(hostname, pai);
+                        break;
+#endif
+                case 'b':
+                        result = _dns_getaddrinfo(hostname, pai);
+                        break;
+                case 'f':
+                        result = _files_getaddrinfo(hostname, pai);
+                        break;
+                }
+        }
+        _THREAD_PRIVATE_MUTEX_UNLOCK(_explore_mutex);
+        if (result) {
+                for (cur = result; cur; cur = cur->ai_next) {
+                        GET_PORT(cur, servname);
+                        /* canonname should be filled already */
+                }
+                *res = result;
+                return 0;
+        } else {
+                /* translate error code */
+                switch (h_errno) {
+                case NETDB_SUCCESS:
+                        error = EAI_FAIL;       /*XXX strange */
+                        break;
+                case HOST_NOT_FOUND:
+                        error = EAI_NODATA;
+                        break;
+                case TRY_AGAIN:
+                        error = EAI_AGAIN;
+                        break;
+                case NO_RECOVERY:
+                        error = EAI_FAIL;
+                        break;
+                case NO_DATA:
+#if NO_ADDRESS != NO_DATA
+                case NO_ADDRESS:
+#endif
+                        error = EAI_NODATA;
+                        break;
+                default:                        /* unknown ones */
+                        error = EAI_FAIL;
+                        break;
+                }
+        }
+
+free:
+        if (result)
+                freeaddrinfo(result);
+        return error;
+}
+
+/*
+ * hostname == NULL.
+ * passive socket -> anyaddr (0.0.0.0 or ::)
+ * non-passive socket -> localhost (127.0.0.1 or ::1)
+ */
+static int
+explore_null(pai, servname, res)
+        const struct addrinfo *pai;
+        const char *servname;
+        struct addrinfo **res;
+{
+        int s;
+        const struct afd *afd;
+        struct addrinfo *cur;
+        struct addrinfo sentinel;
+        int error;
+
+        *res = NULL;
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
+
+        /*
+         * filter out AFs that are not supported by the kernel
+         * XXX errno?
+         */
+        s = socket(pai->ai_family, SOCK_DGRAM, 0);
+        if (s < 0) {
+                if (errno != EMFILE)
+                        return 0;
+        } else
+                close(s);
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0)
+                return 0;
+
+        afd = find_afd(pai->ai_family);
+        if (afd == NULL)
+                return 0;
+
+        if (pai->ai_flags & AI_PASSIVE) {
+                GET_AI(cur->ai_next, afd, afd->a_addrany);
+                /* xxx meaningless?
+                 * GET_CANONNAME(cur->ai_next, "anyaddr");
+                 */
+                GET_PORT(cur->ai_next, servname);
+        } else {
+                GET_AI(cur->ai_next, afd, afd->a_loopback);
+                /* xxx meaningless?
+                 * GET_CANONNAME(cur->ai_next, "localhost");
+                 */
+                GET_PORT(cur->ai_next, servname);
+        }
+        cur = cur->ai_next;
+
+        *res = sentinel.ai_next;
+        return 0;
+
+free:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        return error;
+}
+
+/*
+ * numeric hostname
+ */
+static int
+explore_numeric(pai, hostname, servname, res)
+        const struct addrinfo *pai;
+        const char *hostname;
+        const char *servname;
+        struct addrinfo **res;
+{
+        const struct afd *afd;
+        struct addrinfo *cur;
+        struct addrinfo sentinel;
+        int error;
+        char pton[PTON_MAX];
+
+        *res = NULL;
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
+
+        /*
+         * if the servname does not match socktype/protocol, ignore it.
+         */
+        if (get_portmatch(pai, servname) != 0)
+                return 0;
+
+        afd = find_afd(pai->ai_family);
+        if (afd == NULL)
+                return 0;
+
+        switch (afd->a_af) {
+#if 0 /*X/Open spec*/
+        case AF_INET:
+                if (inet_aton(hostname, (struct in_addr *)pton) == 1) {
+                        if (pai->ai_family == afd->a_af ||
+                            pai->ai_family == PF_UNSPEC /*?*/) {
+                                GET_AI(cur->ai_next, afd, pton);
+                                GET_PORT(cur->ai_next, servname);
+                                while (cur && cur->ai_next)
+                                        cur = cur->ai_next;
+                        } else
+                                ERR(EAI_FAMILY);        /*xxx*/
+                }
+                break;
+#endif
+        default:
+                if (inet_pton(afd->a_af, hostname, pton) == 1) {
+                        if (pai->ai_family == afd->a_af ||
+                            pai->ai_family == PF_UNSPEC /*?*/) {
+                                GET_AI(cur->ai_next, afd, pton);
+                                GET_PORT(cur->ai_next, servname);
+                                while (cur && cur->ai_next)
+                                        cur = cur->ai_next;
+                        } else
+                                ERR(EAI_FAMILY);        /*xxx*/
+                }
+                break;
+        }
+
+        *res = sentinel.ai_next;
+        return 0;
+
+free:
+bad:
+        if (sentinel.ai_next)
+                freeaddrinfo(sentinel.ai_next);
+        return error;
+}
+
+/*
+ * numeric hostname with scope
+ */
+static int
+explore_numeric_scope(pai, hostname, servname, res)
+        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);
+#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);
+
+        cp = strchr(hostname, SCOPE_DELIMITER);
+        if (cp == NULL)
+                return explore_numeric(pai, hostname, servname, res);
+
+        /*
+         * 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);
+        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(pai, ai, str)
+        const struct addrinfo *pai;
+        struct addrinfo *ai;
+        const char *str;
+{
+        if ((pai->ai_flags & AI_CANONNAME) != 0) {
+                ai->ai_canonname = strdup(str);
+                if (ai->ai_canonname == NULL)
+                        return EAI_MEMORY;
+        }
+        return 0;
+}
+
+static struct addrinfo *
+get_ai(pai, afd, addr)
+        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(ai, servname)
+        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(ai, servname, matchonly)
+        struct addrinfo *ai;
+        const char *servname;
+        int matchonly;
+{
+        const char *proto;
+        struct servent *sp;
+        int port;
+        int allownumeric;
+        _THREAD_PRIVATE_MUTEX(serv_mutex);
+
+        if (servname == NULL)
+                return 0;
+        switch (ai->ai_family) {
+        case AF_INET:
+#ifdef AF_INET6
+        case AF_INET6:
+#endif
+                break;
+        default:
+                return 0;
+        }
+
+        switch (ai->ai_socktype) {
+        case SOCK_RAW:
+                return EAI_SERVICE;
+        case SOCK_DGRAM:
+        case SOCK_STREAM:
+                allownumeric = 1;
+                break;
+        case ANY:
+                allownumeric = 0;
+                break;
+        default:
+                return EAI_SOCKTYPE;
+        }
+
+        if (str_isnumber(servname)) {
+                if (!allownumeric)
+                        return EAI_SERVICE;
+                port = atoi(servname);
+                if (port < 0 || port > 65535)
+                        return EAI_SERVICE;
+                port = htons(port);
+        } else {
+                switch (ai->ai_socktype) {
+                case SOCK_DGRAM:
+                        proto = "udp";
+                        break;
+                case SOCK_STREAM:
+                        proto = "tcp";
+                        break;
+                default:
+                        proto = NULL;
+                        break;
+                }
+
+                _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                sp = getservbyname(servname, proto);
+                _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+                if (sp == NULL)
+                        return EAI_SERVICE;
+                port = sp->s_port;
+        }
+
+        if (!matchonly) {
+                switch (ai->ai_family) {
+                case AF_INET:
+                        ((struct sockaddr_in *)(void *)
+                            ai->ai_addr)->sin_port = port;
+                        break;
+#ifdef INET6
+                case AF_INET6:
+                        ((struct sockaddr_in6 *)(void *)
+                            ai->ai_addr)->sin6_port = port;
+                        break;
+#endif
+                }
+        }
+
+        return 0;
+}
+
+static const struct afd *
+find_afd(af)
+        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;
+}
+
+#if 0
+/*
+ * post-2553: AI_ADDRCONFIG check.  if we use getipnodeby* as backend, backend
+ * will take care of it.
+ * the semantics of AI_ADDRCONFIG is not defined well.  we are not sure
+ * if the code is right or not.
+ */
+static int
+addrconfig(pai)
+        const struct addrinfo *pai;
+{
+        int s;
+
+        /* XXX errno */
+        s = socket(pai->ai_family, SOCK_DGRAM, 0);
+        if (s < 0)
+                return 0;
+        close(s);
+        return 1;
+}
+#endif
+
+#ifdef INET6
+/* convert a string to a scope identifier. XXX: IPv6 specific */
+static int
+ip6_str2scopeid(scope, sin6, scopeid)
+        char *scope;
+        struct sockaddr_in6 *sin6;
+        u_int32_t *scopeid;
+{
+        u_long lscopeid;
+        struct in6_addr *a6 = &sin6->sin6_addr;
+        char *ep;
+
+        /* empty scopeid portion is invalid */
+        if (*scope == '\0')
+                return -1;
+
+        if (IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) {
+                /*
+                 * We currently assume a one-to-one mapping between links
+                 * and interfaces, so we simply use interface indices for
+                 * like-local scopes.
+                 */
+                *scopeid = if_nametoindex(scope);
+                if (*scopeid == 0)
+                        goto trynumeric;
+                return 0;
+        }
+
+        /* still unclear about literal, allow numeric only - placeholder */
+        if (IN6_IS_ADDR_SITELOCAL(a6) || IN6_IS_ADDR_MC_SITELOCAL(a6))
+                goto trynumeric;
+        if (IN6_IS_ADDR_MC_ORGLOCAL(a6))
+                goto trynumeric;
+        else
+                goto trynumeric;        /* global */
+
+        /* try to convert to a numeric id as a last resort */
+  trynumeric:
+        errno = 0;
+        lscopeid = strtoul(scope, &ep, 10);
+        *scopeid = (u_int32_t)(lscopeid & 0xffffffffUL);
+        if (errno == 0 && ep && *ep == '\0' && *scopeid == lscopeid)
+                return 0;
+        else
+                return -1;
+}
+#endif
+
+/* code duplicate with gethnamaddr.c */
+
+static const char AskedForGot[] =
+        "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
+static FILE *hostf = NULL;
+
+static struct addrinfo *
+getanswer(answer, anslen, qname, qtype, pai)
+        const querybuf *answer;
+        int anslen;
+        const char *qname;
+        int qtype;
+        const struct addrinfo *pai;
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo ai;
+        const struct afd *afd;
+        char *canonname;
+        const HEADER *hp;
+        const u_char *cp;
+        int n;
+        const u_char *eom;
+        char *bp, *ep;
+        int type, class, ancount, qdcount;
+        int haveanswer, had_error;
+        char tbuf[MAXDNAME];
+        int (*name_ok)(const char *);
+        char hostbuf[8*1024];
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        canonname = NULL;
+        eom = answer->buf + anslen;
+        switch (qtype) {
+        case T_A:
+        case T_AAAA:
+        case T_ANY:     /*use T_ANY only for T_A/T_AAAA lookup*/
+                name_ok = res_hnok;
+                break;
+        default:
+                return (NULL);  /* XXX should be abort() -- but that is illegal */
+        }
+        /*
+         * find first satisfactory answer
+         */
+        hp = &answer->hdr;
+        ancount = ntohs(hp->ancount);
+        qdcount = ntohs(hp->qdcount);
+        bp = hostbuf;
+        ep = hostbuf + sizeof hostbuf;
+        cp = answer->buf + HFIXEDSZ;
+        if (qdcount != 1) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+        if ((n < 0) || !(*name_ok)(bp)) {
+                h_errno = NO_RECOVERY;
+                return (NULL);
+        }
+        cp += n + QFIXEDSZ;
+        if (qtype == T_A || qtype == T_AAAA || qtype == T_ANY) {
+                /* res_send() has already verified that the query name is the
+                 * same as the one we sent; this just gets the expanded name
+                 * (i.e., with the succeeding search-domain tacked on).
+                 */
+                n = strlen(bp) + 1;             /* for the \0 */
+                if (n >= MAXHOSTNAMELEN) {
+                        h_errno = NO_RECOVERY;
+                        return (NULL);
+                }
+                canonname = bp;
+                bp += n;
+                /* The qname can be abbreviated, but h_name is now absolute. */
+                qname = canonname;
+        }
+        haveanswer = 0;
+        had_error = 0;
+        while (ancount-- > 0 && cp < eom && !had_error) {
+                n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
+                if ((n < 0) || !(*name_ok)(bp)) {
+                        had_error++;
+                        continue;
+                }
+                cp += n;                        /* name */
+                type = _getshort(cp);
+                cp += INT16SZ;                  /* type */
+                class = _getshort(cp);
+                cp += INT16SZ + INT32SZ;        /* class, TTL */
+                n = _getshort(cp);
+                cp += INT16SZ;                  /* len */
+                if (class != C_IN) {
+                        /* XXX - debug? syslog? */
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                if ((qtype == T_A || qtype == T_AAAA || qtype == T_ANY) &&
+                    type == T_CNAME) {
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+                        if ((n < 0) || !(*name_ok)(tbuf)) {
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Get canonical name. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp || n >= MAXHOSTNAMELEN) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        canonname = bp;
+                        bp += n;
+                        continue;
+                }
+                if (qtype == T_ANY) {
+                        if (!(type == T_A || type == T_AAAA)) {
+                                cp += n;
+                                continue;
+                        }
+                } else if (type != qtype) {
+                        if (type != T_KEY && type != T_SIG)
+                                syslog(LOG_NOTICE|LOG_AUTH,
+               "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
+                                       qname, p_class(C_IN), p_type(qtype),
+                                       p_type(type));
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                switch (type) {
+                case T_A:
+                case T_AAAA:
+                        if (strcasecmp(canonname, bp) != 0) {
+                                syslog(LOG_NOTICE|LOG_AUTH,
+                                       AskedForGot, canonname, bp);
+                                cp += n;
+                                continue;       /* XXX - had_error++ ? */
+                        }
+                        if (type == T_A && n != INADDRSZ) {
+                                cp += n;
+                                continue;
+                        }
+                        if (type == T_AAAA && n != IN6ADDRSZ) {
+                                cp += n;
+                                continue;
+                        }
+                        if (type == T_AAAA) {
+                                struct in6_addr in6;
+                                memcpy(&in6, cp, IN6ADDRSZ);
+                                if (IN6_IS_ADDR_V4MAPPED(&in6)) {
+                                        cp += n;
+                                        continue;
+                                }
+                        }
+                        if (!haveanswer) {
+                                int nn;
+
+                                canonname = bp;
+                                nn = strlen(bp) + 1;    /* for the \0 */
+                                bp += nn;
+                        }
+
+                        /* don't overwrite pai */
+                        ai = *pai;
+                        ai.ai_family = (type == T_A) ? AF_INET : AF_INET6;
+                        afd = find_afd(ai.ai_family);
+                        if (afd == NULL) {
+                                cp += n;
+                                continue;
+                        }
+                        cur->ai_next = get_ai(&ai, afd, (const char *)cp);
+                        if (cur->ai_next == NULL)
+                                had_error++;
+                        while (cur && cur->ai_next)
+                                cur = cur->ai_next;
+                        cp += n;
+                        break;
+                default:
+                        abort();        /* XXX abort illegal in library */
+                }
+                if (!had_error)
+                        haveanswer++;
+        }
+        if (haveanswer) {
+                if (!canonname)
+                        (void)get_canonname(pai, sentinel.ai_next, qname);
+                else
+                        (void)get_canonname(pai, sentinel.ai_next, canonname);
+                h_errno = NETDB_SUCCESS;
+                return sentinel.ai_next;
+        }
+
+        h_errno = NO_RECOVERY;
+        return NULL;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_dns_getaddrinfo(name, pai)
+        const char *name;
+        const struct addrinfo *pai;
+{
+        struct addrinfo *ai;
+        querybuf *buf, *buf2;
+        struct addrinfo sentinel, *cur;
+        struct res_target q, q2;
+
+        memset(&q, 0, sizeof(q2));
+        memset(&q2, 0, sizeof(q2));
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        buf = malloc(sizeof(*buf));
+        if (buf == NULL) {
+                h_errno = NETDB_INTERNAL;
+                return NULL;
+        }
+        buf2 = malloc(sizeof(*buf2));
+        if (buf2 == NULL) {
+                free(buf);
+                h_errno = NETDB_INTERNAL;
+                return NULL;
+        }
+
+        switch (pai->ai_family) {
+        case AF_UNSPEC:
+                /* prefer IPv6 */
+                q.qclass = C_IN;
+                q.qtype = T_AAAA;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                q.next = &q2;
+                q2.qclass = C_IN;
+                q2.qtype = T_A;
+                q2.answer = buf2->buf;
+                q2.anslen = sizeof(buf2->buf);
+                break;
+        case AF_INET:
+                q.qclass = C_IN;
+                q.qtype = T_A;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                break;
+        case AF_INET6:
+                q.qclass = C_IN;
+                q.qtype = T_AAAA;
+                q.answer = buf->buf;
+                q.anslen = sizeof(buf->buf);
+                break;
+        default:
+                free(buf);
+                free(buf2);
+                return NULL;
+        }
+        if (res_searchN(name, &q) < 0) {
+                free(buf);
+                free(buf2);
+                return NULL;
+        }
+        ai = getanswer(buf, q.n, q.name, q.qtype, pai);
+        if (ai) {
+                cur->ai_next = ai;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+        if (q.next) {
+                ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai);
+                if (ai)
+                        cur->ai_next = ai;
+        }
+        free(buf);
+        free(buf2);
+        return sentinel.ai_next;
+}
+
+static FILE *hostf;
+
+static void
+_sethtent()
+{
+        if (!hostf)
+                hostf = fopen(_PATH_HOSTS, "r" );
+        else
+                rewind(hostf);
+}
+
+static void
+_endhtent()
+{
+        if (hostf) {
+                (void) fclose(hostf);
+                hostf = NULL;
+        }
+}
+
+static struct addrinfo *
+_gethtent(name, pai)
+        const char *name;
+        const struct addrinfo *pai;
+{
+        char *p;
+        char *cp, *tname, *cname;
+        struct addrinfo hints, *res0, *res;
+        int error;
+        const char *addr;
+        char hostbuf[8*1024];
+
+        if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" )))
+                return (NULL);
+ again:
+        if (!(p = fgets(hostbuf, sizeof hostbuf, hostf)))
+                return (NULL);
+        if (*p == '#')
+                goto again;
+        if (!(cp = strpbrk(p, "#\n")))
+                goto again;
+        *cp = '\0';
+        if (!(cp = strpbrk(p, " \t")))
+                goto again;
+        *cp++ = '\0';
+        addr = p;
+        /* if this is not something we're looking for, skip it. */
+        cname = NULL;
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (!cname)
+                        cname = cp;
+                tname = cp;
+                if ((cp = strpbrk(cp, " \t")) != NULL)
+                        *cp++ = '\0';
+                if (strcasecmp(name, tname) == 0)
+                        goto found;
+        }
+        goto again;
+
+found:
+        hints = *pai;
+        hints.ai_flags = AI_NUMERICHOST;
+        error = getaddrinfo(addr, NULL, &hints, &res0);
+        if (error)
+                goto again;
+        for (res = res0; res; res = res->ai_next) {
+                /* cover it up */
+                res->ai_flags = pai->ai_flags;
+
+                if (pai->ai_flags & AI_CANONNAME) {
+                        if (get_canonname(pai, res, cname) != 0) {
+                                freeaddrinfo(res0);
+                                goto again;
+                        }
+                }
+        }
+        return res0;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_files_getaddrinfo(name, pai)
+        const char *name;
+        const struct addrinfo *pai;
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo *p;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+        _sethtent();
+        while ((p = _gethtent(name, pai)) != NULL) {
+                cur->ai_next = p;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+        _endhtent();
+
+        return sentinel.ai_next;
+}
+
+#ifdef YP
+static char *__ypdomain;
+
+/*ARGSUSED*/
+static struct addrinfo *
+_yphostent(line, pai)
+        char *line;
+        const struct addrinfo *pai;
+{
+        struct addrinfo sentinel, *cur;
+        struct addrinfo hints, *res, *res0;
+        int error;
+        char *p = line;
+        const char *addr, *canonname;
+        char *nextline;
+        char *cp;
+
+        addr = canonname = NULL;
+
+        memset(&sentinel, 0, sizeof(sentinel));
+        cur = &sentinel;
+
+nextline:
+        /* terminate line */
+        cp = strchr(p, '\n');
+        if (cp) {
+                *cp++ = '\0';
+                nextline = cp;
+        } else
+                nextline = NULL;
+
+        cp = strpbrk(p, " \t");
+        if (cp == NULL) {
+                if (canonname == NULL)
+                        return (NULL);
+                else
+                        goto done;
+        }
+        *cp++ = '\0';
+
+        addr = p;
+
+        while (cp && *cp) {
+                if (*cp == ' ' || *cp == '\t') {
+                        cp++;
+                        continue;
+                }
+                if (!canonname)
+                        canonname = cp;
+                if ((cp = strpbrk(cp, " \t")) != NULL)
+                        *cp++ = '\0';
+        }
+
+        hints = *pai;
+        hints.ai_flags = AI_NUMERICHOST;
+        error = getaddrinfo(addr, NULL, &hints, &res0);
+        if (error == 0) {
+                for (res = res0; res; res = res->ai_next) {
+                        /* cover it up */
+                        res->ai_flags = pai->ai_flags;
+
+                        if (pai->ai_flags & AI_CANONNAME)
+                                (void)get_canonname(pai, res, canonname);
+                }
+        } else
+                res0 = NULL;
+        if (res0) {
+                cur->ai_next = res0;
+                while (cur && cur->ai_next)
+                        cur = cur->ai_next;
+        }
+
+        if (nextline) {
+                p = nextline;
+                goto nextline;
+        }
+
+done:
+        return sentinel.ai_next;
+}
+
+/*ARGSUSED*/
+static struct addrinfo *
+_yp_getaddrinfo(name, pai)
+        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(name, target)
+        const char *name;       /* domain 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 ((_resp->options & RES_INIT) == 0 && res_init() == -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(name, target)
+        const char *name;       /* domain 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 ((_resp->options & RES_INIT) == 0 && res_init() == -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(name, domain, target)
+        const char *name, *domain;
+        struct res_target *target;
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char nbuf[MAXDNAME];
+        const char *longname = nbuf;
+        size_t n, d;
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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.
+                 */
+                n = strlen(name);
+                if (n >= MAXDNAME) {
+                        h_errno = NO_RECOVERY;
+                        return (-1);
+                }
+                if (n > 0 && name[--n] == '.') {
+                        strlcpy(nbuf, name, n + 1);
+                } else
+                        longname = name;
+        } else {
+                n = strlen(name);
+                d = strlen(domain);
+                if (n + d + 1 >= MAXDNAME) {
+                        h_errno = NO_RECOVERY;
+                        return (-1);
+                }
+                snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain);
+        }
+        return (res_queryN(longname, target));
+}
diff --git a/src/lib/libc/net/gethostbyname.3 b/src/lib/libc/net/gethostbyname.3
index bac0368296..d90ea55542 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.17 2002/04/30 16:31:42 mpech Exp $
 .\"
 .\" Copyright (c) 1983, 1987, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,17 +31,17 @@
 .\" 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 March 13, 1997
 .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
@@ -50,30 +50,37 @@
 .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 char *addr" "int 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
 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 .
+system.
+.Xr resolv.conf 5
+describes how the particular database is chosen.
 .Bd -literal
 struct  hostent {
         char    *h_name;        /* official name of host */
@@ -90,36 +97,48 @@ 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 zero-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 zero-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 ,
+for example
+.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 +146,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 +156,33 @@ 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 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 +190,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,8 +206,8 @@ 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
@@ -190,52 +216,42 @@ for example, a mail-forwarder may be registered for this domain.
 .El
 .Sh SEE ALSO
 .Xr resolver 3 ,
+.Xr getaddrinfo 3 ,
+.Xr getnameinfo 3 ,
 .Xr hosts 5 ,
+.Xr resolv.conf 5 ,
 .Xr hostname 7 ,
 .Xr named 8
-.Sh CAVEAT
-The
-.Fn gethostent
-function
-is defined, and
-.Fn sethostent
-and
-.Fn endhostent
-are redefined,
-when
-.Xr libc 3
-is built to use only the routines to lookup in
+.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.
+function closes the file.
 .Sh HISTORY
 The
 .Fn herror
-function appeared in 
+function appeared in
 .Bx 4.3 .
 The
 .Fn endhostent ,
@@ -251,4 +267,9 @@ These functions use static data storage;
 if the data is needed for future use, it should be
 copied before any subsequent calls overwrite it.
 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..7cf419fdb1 100644
--- a/src/lib/libc/net/gethostnamadr.c
+++ b/src/lib/libc/net/gethostnamadr.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: gethostnamadr.c,v 1.13 1995/05/21 16:21:14 mycroft Exp $       */
-
 /*-
  * Copyright (c) 1985, 1988, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -54,12 +52,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: gethostnamadr.c,v 1.55 2003/03/04 00:29:17 itojun Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -73,11 +66,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 +90,109 @@ 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(p)
+        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;
+getanswer(answer, anslen, qname, qtype)
+        const querybuf *answer;
         int anslen;
-        int iquery;
+        const char *qname;
+        int qtype;
 {
-        register HEADER *hp;
-        register u_char *cp;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        register const HEADER *hp;
+        register const 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;
+        const u_char *eom;
+        char *bp, **ap, **hap, *ep;
+        int type, class, ancount, qdcount;
+        int haveanswer, had_error;
+        int toobig = 0;
+        char tbuf[MAXDNAME];
+        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 +200,28 @@ 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).
+                 */
+                n = strlen(bp) + 1;             /* for the \0 */
+                host.h_name = bp;
+                bp += n;
+                /* The qname can be abbreviated, but h_name is now absolute. */
+                qname = host.h_name;
         }
         ap = host_aliases;
         *ap = NULL;
@@ -172,104 +230,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)
-                        break;
-                cp += n;
+        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 += sizeof(u_int16_t);
+                cp += INT16SZ;                  /* type */
                 class = _getshort(cp);
-                cp += sizeof(u_int16_t) + sizeof(u_int32_t);
+                cp += INT16SZ + INT32SZ;        /* class, TTL */
                 n = _getshort(cp);
-                cp += sizeof(u_int16_t);
-                if (type == T_CNAME) {
+                cp += INT16SZ;                  /* len */
+                if (type == T_SIG) {
+                        /* XXX - ignore signatures as we don't use them yet */
                         cp += n;
+                        continue;
+                }
+                if (class != C_IN) {
+                        /* XXX - debug? syslog? */
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
                         if (ap >= &host_aliases[MAXALIASES-1])
                                 continue;
+                        n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
+                        if ((n < 0) || !(*name_ok)(tbuf)) {
+                                had_error++;
+                                continue;
+                        }
+                        cp += n;
+                        /* Store alias. */
                         *ap++ = bp;
-                        n = strlen(bp) + 1;
+                        n = strlen(bp) + 1;     /* for the \0 */
                         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;
-                        cp += n;
+                        /* Get canonical name. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
                         host.h_name = bp;
-                        return(&host);
+                        bp += n;
+                        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. */
+                        n = strlen(tbuf) + 1;   /* for the \0 */
+                        if (n > ep - bp) {
+                                had_error++;
+                                continue;
+                        }
+                        strlcpy(bp, tbuf, ep - bp);
+                        tname = bp;
+                        bp += n;
                         continue;
                 }
-                if (haveanswer) {
-                        if (n != host.h_length) {
+                if (type != qtype) {
+                        syslog(LOG_NOTICE|LOG_AUTH,
+               "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
+                               qname, p_class(C_IN), p_type(qtype),
+                               p_type(type));
+                        cp += n;
+                        continue;               /* XXX - had_error++ ? */
+                }
+                switch (type) {
+                case T_PTR:
+                        if (strcasecmp(tname, bp) != 0) {
+                                syslog(LOG_NOTICE|LOG_AUTH,
+                                       AskedForGot, qname, bp);
                                 cp += n;
-                                continue;
+                                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) {
+                                register int nn;
+
                                 host.h_name = bp;
-                                bp += strlen(bp) + 1;
+                                nn = strlen(bp) + 1;    /* for the \0 */
+                                bp += nn;
                         }
-                }
 
-                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) {
+                        n = strlen(qname) + 1;  /* for the \0 */
+                        if (n > ep - bp)
+                                goto try_again;
+                        strlcpy(bp, qname, ep - bp);
+                        host.h_name = bp;
+                        bp += n;
                 }
+                if (_resp->options & RES_USE_INET6)
+                        map_v4v6_hostent(&host, &bp, ep);
+                h_errno = NETDB_SUCCESS;
                 return (&host);
-        } 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(name, hp, buf, buflen, errorp)
+        const char * name;
+        struct hostent * hp;
+        char * buf;
+        int buflen;
+        int * errorp;
+{
+        struct hostent *res;
+
+        res = gethostbyname(name);
+        *errorp = h_errno;
+        if (res == NULL)
+                return NULL;
+        memcpy(hp, res, sizeof *hp); /* XXX not sufficient */
+        return hp;
+}
+
+/*
+ * XXX This is an extremely bogus implementation.
+ */
+struct hostent *
+gethostbyaddr_r(addr, len, af, he, buf, buflen, errorp)
+        const char *addr;       /* XXX should have been def'd as u_char! */
+        int len, af;
+        struct hostent * he;
+        char * buf;
+        int buflen;
+        int * errorp;
+{
+        struct hostent * res;
+
+        res = gethostbyaddr(addr, len, af);
+        *errorp = h_errno;
+        if (res == NULL)
+                return NULL;
+        memcpy(he, res, sizeof *he); /* XXX not sufficient */
+        return he;
 }
 
+/* XXX RFC2133 expects a gethostbyname2_r() -- unimplemented */
+#endif
+
 struct hostent *
 gethostbyname(name)
         const char *name;
 {
-        querybuf buf;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        struct hostent *hp;
+        extern struct hostent *_gethtbyname2();
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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(name, af)
+        const char *name;
+        int af;
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        querybuf *buf;
         register const char *cp;
-        int n, i;
-        extern struct hostent *_gethtbyname(), *_yp_gethtbyname();
+        char *bp, *ep;
+        int n, size, type, i;
+        extern struct hostent *_gethtbyname2(), *_yp_gethtbyname();
         register struct hostent *hp;
         char lookups[MAXDNSLUS];
 
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1)
+                return (_gethtbyname2(name, af));
+
+        switch (af) {
+        case AF_INET:
+                size = INADDRSZ;
+                type = T_A;
+                break;
+        case AF_INET6:
+                size = IN6ADDRSZ;
+                type = T_AAAA;
+                break;
+        default:
+                h_errno = NETDB_INTERNAL;
+                errno = EAFNOSUPPORT;
+                return (NULL);
+        }
+
+        host.h_addrtype = af;
+        host.h_length = size;
+
+        /*
+         * if there aren't any dots, it could be a user-level alias.
+         * this is also done in res_query() since we are not the only
+         * function that looks up host names.
+         */
+        if (!strchr(name, '.') && (cp = __hostalias(name)))
+                name = cp;
+
         /*
          * disallow names consisting only of digits/dots, unless
          * they end in a dot.
@@ -284,116 +563,230 @@ 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(addr, len, af)
+        const char *addr;       /* XXX should have been def'd as u_char! */
+        int len, af;
 {
-        int n, i;
-        querybuf buf;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        const u_char *uaddr = (const u_char *)addr;
+        int n, size, i;
+        querybuf *buf;
         register struct hostent *hp;
-        char qbuf[MAXDNAME];
+        char qbuf[MAXDNAME+1], *qp, *ep;
         extern struct hostent *_gethtbyaddr(), *_yp_gethtbyaddr();
         char lookups[MAXDNSLUS];
+        struct hostent *res;
         
-        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 ((_resp->options & RES_INIT) == 0 && res_init() == -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. */
+                addr += IN6ADDRSZ - INADDRSZ;
+                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) {
+                                errno = EINVAL;
+                                h_errno = NETDB_INTERNAL;
+                                return (NULL);
+                        }
+                        qp += i;
+                }
+                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(addr);
                         break;
 #endif
                 case 'b':
-                        n = res_query(qbuf, C_IN, T_PTR, (char *)&buf, sizeof(buf));
+                        if (af == AF_INET6)
+                                strlcpy(qp, "ip6.arpa", ep - qp);
+                        buf = malloc(sizeof(*buf));
+                        if (!buf)
+                                break;
+                        n = res_query(qbuf, C_IN, T_PTR, buf->buf,
+                            sizeof(buf->buf));
+                        if (n < 0 && af == AF_INET6) {
+                                strlcpy(qp, "ip6.int", ep - qp);
+                                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(addr, 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(addr, len, af);
                         break;
                 }
         }
+        /* XXX h_errno not correct in all cases... */
         return (hp);
 }
 
@@ -420,37 +813,64 @@ _endhtent()
 struct hostent *
 _gethtent()
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
         char *p;
         register char *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[len-1] == '\n')
+                len--;
+        if (len >= sizeof(hostbuf) || len == 0)
+                goto again;
+        p = memcpy(hostbuf, p, len);
+        hostbuf[len] = '\0';
         if (*p == '#')
                 goto again;
-        cp = strpbrk(p, "#\n");
-        if (cp == NULL)
-                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)
+                goto again;
+        if (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,70 +879,77 @@ 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;
+        const char *name;
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        extern struct hostent *_gethtbyname2();
+        struct hostent *hp;
+
+        if (_resp->options & RES_USE_INET6) {
+                hp = _gethtbyname2(name, AF_INET6);
+                if (hp)
+                        return (hp);
+        }
+        return (_gethtbyname2(name, AF_INET));
+}
+
+struct hostent *
+_gethtbyname2(name, af)
+        const char *name;
+        int af;
 {
         register struct hostent *p;
         register 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)
+_gethtbyaddr(addr, len, af)
         const char *addr;
-        int len, type;
+        int len, af;
 {
         register 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 && !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)
@@ -537,21 +964,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 +1019,29 @@ nextline:
                         *cp++ = '\0';
         }
 done:
+        if (host.h_name == NULL)
+                return (NULL);
         *q = NULL;
         *hap = NULL;
         return (&host);
 }
 
 struct hostent *
-_yp_gethtbyaddr(addr, len, type)
+_yp_gethtbyaddr(addr)
         const char *addr;
-        int len, type;
 {
         struct hostent *hp = (struct hostent *)NULL;
         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",
+            ((unsigned)addr[0] & 0xff), ((unsigned)addr[1] & 0xff),
+            ((unsigned)addr[2] & 0xff), ((unsigned)addr[3] & 0xff));
         if (__ypcurrent)
                 free(__ypcurrent);
         __ypcurrent = NULL;
@@ -636,6 +1062,8 @@ _yp_gethtbyname(name)
         static char *__ypcurrent;
         int __ypcurrentlen, r;
 
+        if (strlen(name) >= MAXHOSTNAMELEN)
+                return (NULL);
         if (!__ypdomain) {
                 if (_yp_check(&__ypdomain) == 0)
                         return (hp);
@@ -645,10 +1073,108 @@ _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(src, dst)
+        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(hp, bpp, ep)
+        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()
+{
+        return (_gethtent());
+}
+
+#ifdef RESOLVSORT
+static void
+addrsort(ap, num)
+        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..03064689cd
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.3
@@ -0,0 +1,159 @@
+.\"     $OpenBSD: getifaddrs.3,v 1.9 2003/03/06 04:07:37 david Exp $
+.\"     BSDI    getifaddrs.3,v 2.5 2000/02/23 14:51:59 dab Exp
+.\"
+.\" Copyright (c) 1995, 1999
+.\"     Berkeley Software Design, Inc.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.Dd October 12, 1995
+.Dt GETIFADDRS 3
+.Os
+.Sh NAME
+.Nm getifaddrs
+.Nd get interface addresses
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <sys/socket.h>
+.Fd #include <ifaddrs.h>
+.Ft int
+.Fn getifaddrs "struct ifaddrs **ifap"
+.Ft void
+.Fn freeifaddrs "struct ifaddrs *ifap"
+.Sh DESCRIPTION
+The
+.Fn getifaddrs
+function stores a reference to a linked list of the network interfaces
+on the local machine in the memory referenced by
+.Fa ifap .
+The list consists of
+.Nm ifaddrs
+structures, as defined in the include file
+.Aq Pa ifaddrs.h .
+The
+.Nm ifaddrs
+structure contains at least the following entries:
+.Bd -literal
+    struct ifaddrs   *ifa_next;         /* Pointer to next struct */
+    char             *ifa_name;         /* Interface name */
+    u_int             ifa_flags;        /* Interface flags */
+    struct sockaddr  *ifa_addr;         /* Interface address */
+    struct sockaddr  *ifa_netmask;      /* Interface netmask */
+    struct sockaddr  *ifa_broadaddr;    /* Interface broadcast address */
+    struct sockaddr  *ifa_dstaddr;      /* P2P interface destination */
+    void             *ifa_data;         /* Address specific data */
+.Ed
+.Pp
+.Bl -tag -width Ds
+.It Fa ifa_next
+Contains a pointer to the next structure on the list.
+This field is set to
+.Dv NULL
+in last structure on the list.
+.It Fa ifa_name
+Contains the interface name.
+.It Fa ifa_flags
+Contains the interface flags, as set by
+.Xr ifconfig 8 .
+.It Fa ifa_addr
+References either the address of the interface or the link level
+address of the interface, if one exists, otherwise it is
+.Dv NULL .
+(The
+.Fa sa_family
+field of the
+.Fa ifa_addr
+field should be consulted to determine the format of the
+.Fa ifa_addr
+address.)
+.It Fa ifa_netmask
+References the netmask associated with
+.Fa ifa_addr ,
+if one is set, otherwise it is
+.Dv NULL .
+.It Fa ifa_broadaddr
+This field, which should only be referenced for non-P2P interfaces,
+references the broadcast address associated with
+.Fa ifa_addr ,
+if one exists, otherwise it is
+.Dv NULL .
+.It Fa ifa_dstaddr
+References the destination address on a P2P interface,
+if one exists, otherwise it is
+.Dv NULL .
+.It Fa ifa_data
+References address family specific data.
+For
+.Dv AF_LINK
+addresses it contains a pointer to the
+.Li struct if_data
+(as defined in include file
+.Aq Pa net/if.h )
+which contains various interface attributes and statistics.
+For all other address families, it contains a pointer to the
+.Li struct ifa_data
+(as defined in include file
+.Aq Pa net/if.h )
+which contains per-address interface statistics.
+.El
+.Pp
+The data returned by
+.Fn getifaddrs
+is dynamically allocated and should be freed using
+.Fn freeifaddrs
+when no longer needed.
+.Sh RETURN VALUES
+Upon successful completion, a value of 0 is returned.
+Otherwise, a value of \-1 is returned and
+.Va errno
+is set to indicate the error.
+.Sh ERRORS
+The
+.Fn getifaddrs
+may fail and set
+.Va errno
+for any of the errors specified for the library routines
+.Xr ioctl 2 ,
+.Xr socket 2 ,
+.Xr malloc 3 ,
+or
+.Xr sysctl 3 .
+.Sh 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 .
+.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 is supplied on
+.Ox
+since
+.Ox 2.7 .
diff --git a/src/lib/libc/net/getifaddrs.c b/src/lib/libc/net/getifaddrs.c
new file mode 100644
index 0000000000..0db89f6c19
--- /dev/null
+++ b/src/lib/libc/net/getifaddrs.c
@@ -0,0 +1,277 @@
+/*      $OpenBSD: getifaddrs.c,v 1.9 2002/08/09 06:12:25 itojun Exp $   */
+
+/*
+ * Copyright (c) 1995, 1999
+ *      Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      BSDI getifaddrs.c,v 2.12 2000/02/23 14:51:59 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <sys/param.h>
+#include <net/route.h>
+#include <sys/sysctl.h>
+#include <net/if_dl.h>
+
+#include <errno.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define SALIGN  (sizeof(long) - 1)
+#define SA_RLEN(sa)     ((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : (SALIGN + 1))
+
+int
+getifaddrs(struct ifaddrs **pif)
+{
+        int icnt = 1;
+        int dcnt = 0;
+        int ncnt = 0;
+        int mib[6];
+        size_t needed;
+        char *buf;
+        char *next;
+        struct ifaddrs *cif = 0;
+        char *p, *p0;
+        struct rt_msghdr *rtm;
+        struct if_msghdr *ifm;
+        struct ifa_msghdr *ifam;
+        struct sockaddr_dl *dl;
+        struct sockaddr *sa;
+        u_short index = 0;
+        size_t len, alen;
+        struct ifaddrs *ifa, *ift;
+        int i;
+        char *data;
+        char *names;
+
+        mib[0] = CTL_NET;
+        mib[1] = PF_ROUTE;
+        mib[2] = 0;             /* protocol */
+        mib[3] = 0;             /* wildcard address family */
+        mib[4] = NET_RT_IFLIST;
+        mib[5] = 0;             /* no flags */
+        if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+                return (-1);
+        if ((buf = malloc(needed)) == NULL)
+                return (-1);
+        if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
+                free(buf);
+                return (-1);
+        }
+
+        for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
+                rtm = (struct rt_msghdr *)next;
+                if (rtm->rtm_version != RTM_VERSION)
+                        continue;
+                switch (rtm->rtm_type) {
+                case RTM_IFINFO:
+                        ifm = (struct if_msghdr *)rtm;
+                        if (ifm->ifm_addrs & RTA_IFP) {
+                                index = ifm->ifm_index;
+                                ++icnt;
+                                dl = (struct sockaddr_dl *)(ifm + 1);
+                                dcnt += SA_RLEN((struct sockaddr *)dl) +
+                                        ALIGNBYTES;
+                                dcnt += sizeof(ifm->ifm_data);
+                                ncnt += dl->sdl_nlen + 1;
+                        } else
+                                index = 0;
+                        break;
+
+                case RTM_NEWADDR:
+                        ifam = (struct ifa_msghdr *)rtm;
+                        if (index && ifam->ifam_index != index)
+                                abort();        /* XXX abort illegal in library */
+
+#define RTA_MASKS       (RTA_NETMASK | RTA_IFA | RTA_BRD)
+                        if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
+                                break;
+                        p = (char *)(ifam + 1);
+                        ++icnt;
+                        /* Scan to look for length of address */
+                        alen = 0;
+                        for (p0 = p, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_IFA) {
+                                        alen = len;
+                                        break;
+                                }
+                                p += len;
+                        }
+                        for (p = p0, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_NETMASK && sa->sa_len == 0)
+                                        dcnt += alen;
+                                else
+                                        dcnt += len;
+                                p += len;
+                        }
+                        break;
+                }
+        }
+
+        if (icnt + dcnt + ncnt == 1) {
+                *pif = NULL;
+                free(buf);
+                return (0);
+        }
+        data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
+        if (data == NULL) {
+                free(buf);
+                return(-1);
+        }
+
+        ifa = (struct ifaddrs *)data;
+        data += sizeof(struct ifaddrs) * icnt;
+        names = data + dcnt;
+
+        memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
+        ift = ifa;
+
+        index = 0;
+        for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
+                rtm = (struct rt_msghdr *)next;
+                if (rtm->rtm_version != RTM_VERSION)
+                        continue;
+                switch (rtm->rtm_type) {
+                case RTM_IFINFO:
+                        ifm = (struct if_msghdr *)rtm;
+                        if (ifm->ifm_addrs & RTA_IFP) {
+                                index = ifm->ifm_index;
+                                dl = (struct sockaddr_dl *)(ifm + 1);
+
+                                cif = ift;
+                                ift->ifa_name = names;
+                                ift->ifa_flags = (int)ifm->ifm_flags;
+                                memcpy(names, dl->sdl_data, dl->sdl_nlen);
+                                names[dl->sdl_nlen] = 0;
+                                names += dl->sdl_nlen + 1;
+
+                                ift->ifa_addr = (struct sockaddr *)data;
+                                memcpy(data, dl,
+                                    ((struct sockaddr *)dl)->sa_len);
+                                data += SA_RLEN((struct sockaddr *)dl);
+
+                                /* ifm_data needs to be aligned */
+                                ift->ifa_data = data = (void *)ALIGN(data);
+                                memcpy(data, &ifm->ifm_data, sizeof(ifm->ifm_data));
+                                data += sizeof(ifm->ifm_data);
+
+                                ift = (ift->ifa_next = ift + 1);
+                        } else
+                                index = 0;
+                        break;
+
+                case RTM_NEWADDR:
+                        ifam = (struct ifa_msghdr *)rtm;
+                        if (index && ifam->ifam_index != index)
+                                abort();        /* XXX abort illegal in library */
+
+                        if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
+                                break;
+                        ift->ifa_name = cif->ifa_name;
+                        ift->ifa_flags = cif->ifa_flags;
+                        ift->ifa_data = NULL;
+                        p = (char *)(ifam + 1);
+                        /* Scan to look for length of address */
+                        alen = 0;
+                        for (p0 = p, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                if (i == RTAX_IFA) {
+                                        alen = len;
+                                        break;
+                                }
+                                p += len;
+                        }
+                        for (p = p0, i = 0; i < RTAX_MAX; i++) {
+                                if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
+                                    == 0)
+                                        continue;
+                                sa = (struct sockaddr *)p;
+                                len = SA_RLEN(sa);
+                                switch (i) {
+                                case RTAX_IFA:
+                                        ift->ifa_addr = (struct sockaddr *)data;
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+
+                                case RTAX_NETMASK:
+                                        ift->ifa_netmask =
+                                            (struct sockaddr *)data;
+                                        if (sa->sa_len == 0) {
+                                                memset(data, 0, alen);
+                                                data += alen;
+                                                break;
+                                        }
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+
+                                case RTAX_BRD:
+                                        ift->ifa_broadaddr =
+                                            (struct sockaddr *)data;
+                                        memcpy(data, p, len);
+                                        data += len;
+                                        break;
+                                }
+                                p += len;
+                        }
+
+
+                        ift = (ift->ifa_next = ift + 1);
+                        break;
+                }
+        }
+
+        free(buf);
+        if (--ift >= ifa) {
+                ift->ifa_next = NULL;
+                *pif = ifa;
+        } else {
+                *pif = NULL;
+                free(ifa);
+        }
+        return (0);
+}
+
+void
+freeifaddrs(struct ifaddrs *ifp)
+{
+        free(ifp);
+}
diff --git a/src/lib/libc/net/getnameinfo.3 b/src/lib/libc/net/getnameinfo.3
new file mode 100644
index 0000000000..24fb89d838
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.3
@@ -0,0 +1,297 @@
+.\"     $OpenBSD: getnameinfo.3,v 1.19 2003/05/03 20:05:07 jmc Exp $
+.\"     $KAME: getnameinfo.3,v 1.20 2001/01/05 13:37:37 itojun Exp $
+.\"
+.\" Copyright (c) 1983, 1987, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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: @(#)gethostbyname.3       8.4 (Berkeley) 5/25/95
+.\"
+.Dd May 25, 1995
+.Dt GETNAMEINFO 3
+.Os
+.\"
+.Sh NAME
+.Nm getnameinfo
+.Nd address-to-nodename translation in protocol-independent manner
+.\"
+.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 defined for protocol-independent address-to-nodename translation.
+Its functionality is a reverse conversion of
+.Xr getaddrinfo 3 ,
+and implements similar functionality to
+.Xr gethostbyaddr 3
+and
+.Xr getservbyport 3
+in a more sophisticated manner.
+.Pp
+This function looks up an IP address and port number provided by the
+caller in the DNS and system-specific database, and returns text
+strings for both in buffers provided by the caller.
+The function indicates successful completion by a zero return value;
+a non-zero return value indicates failure.
+.Pp
+The first argument,
+.Fa sa ,
+points to either a
+.Li sockaddr_in
+structure (for IPv4) or a
+.Li sockaddr_in6
+structure (for IPv6) that holds the IP address and port number.
+The
+.Fa salen
+argument gives the length of the
+.Li sockaddr_in
+or
+.Li sockaddr_in6
+structure.
+.Pp
+The function returns the nodename associated with the IP address in
+the buffer pointed to by the
+.Fa host
+argument.
+The caller provides the size of this buffer via the
+.Fa hostlen
+argument.
+The service name associated with the port number is returned in the buffer
+pointed to by
+.Fa serv ,
+and the
+.Fa servlen
+argument gives the length of this buffer.
+The caller specifies not to return either string by providing a zero
+value for the
+.Fa hostlen
+or
+.Fa servlen
+arguments.
+Otherwise, the caller must provide buffers large enough to hold the
+nodename and the service name, including the terminating null characters.
+.Pp
+Unfortunately most systems do not provide constants that specify the
+maximum size of either a fully-qualified domain name or a service name.
+Therefore to aid the application in allocating buffers for these two
+returned strings the following constants are defined in
+.Aq Pa netdb.h :
+.Bd -literal -offset
+#define NI_MAXHOST    MAXHOSTNAMELEN
+#define NI_MAXSERV    32
+.Ed
+.Pp
+The first value is actually defined as the constant
+.Dv MAXDNAME
+in recent versions of BIND's
+.Aq Pa arpa/nameser.h
+header (older versions of BIND define this constant to be 256)
+and the second is a guess based on the services listed in the current
+Assigned Numbers RFC.
+.Pp
+The final argument is a
+.Fa flag
+that changes the default actions of this function.
+By default the fully-qualified domain name (FQDN) for the host is
+looked up in the DNS and returned.
+If the flag bit
+.Dv NI_NOFQDN
+is set, only the nodename portion of the FQDN is returned for local hosts.
+.Pp
+If the
+.Fa flag
+bit
+.Dv NI_NUMERICHOST
+is set, or if the host's name cannot be located in the DNS,
+the numeric form of the host's address is returned instead of its name
+.Po
+e.g., by calling
+.Fn inet_ntop
+instead of
+.Fn gethostbyaddr
+.Pc .
+If the
+.Fa flag
+bit
+.Dv NI_NAMEREQD
+is set, an error is returned if the host's name cannot be located in the DNS.
+.Pp
+If the flag bit
+.Dv NI_NUMERICSERV
+is set, the numeric form of the service address is returned
+.Pq e.g., its port number
+instead of its name.
+The two
+.Dv NI_NUMERICxxx
+flags are required to support the
+.Fl n
+flag that many commands provide.
+.Pp
+A fifth flag bit,
+.Dv NI_DGRAM ,
+specifies that the service is a datagram service, and causes
+.Fn getservbyport
+to be called with a second argument of
+.Qq udp
+instead of its default of
+.Qq tcp .
+This is required for the few ports (512-514)
+that have different services for UDP and TCP.
+.Pp
+These
+.Dv NI_xxx
+flags are defined in
+.Aq Pa netdb.h .
+.\"
+.Ss Extension for scoped IPv6 address
+The implementation allows experimental numeric IPv6 address notation with
+scope identifier.
+IPv6 link-local address will appear as a string like
+.Dq Li fe80::1%ne0 .
+Refer to
+.Xr getaddrinfo 3
+for the notation.
+.\"
+.Sh EXAMPLES
+The following code tries to get a numeric hostname, and service name,
+for given socket address.
+Observe that there is no hardcoded reference to a particular address family.
+.Bd -literal -offset indent
+struct sockaddr *sa;    /* input */
+char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+
+if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), sbuf,
+    sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
+        errx(1, "could not get numeric hostname");
+        /*NOTREACHED*/
+}
+printf("host=%s, serv=%s\en", hbuf, sbuf);
+.Ed
+.Pp
+The following version checks if the socket address has reverse address mapping.
+.Bd -literal -offset indent
+struct sockaddr *sa;    /* input */
+char hbuf[NI_MAXHOST];
+
+if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), NULL, 0,
+    NI_NAMEREQD)) {
+        errx(1, "could not resolve hostname");
+        /*NOTREACHED*/
+}
+printf("host=%s\en", hbuf);
+.Ed
+.\"
+.Sh DIAGNOSTICS
+The function indicates successful completion by a zero return value;
+a non-zero return value indicates failure.
+Error codes are as below:
+.Bl -tag -width Er
+.It Dv EAI_AGAIN
+The name could not be resolved at this time.
+Future attempts may succeed.
+.It Dv EAI_BADFLAGS
+The flags had an invalid value.
+.It Dv EAI_FAIL
+A non-recoverable error occurred.
+.It Dv EAI_FAMILY
+The address family was not recognized or the address length was invalid
+for the specified family.
+.It Dv EAI_MEMORY
+There was a memory allocation failure.
+.It Dv EAI_NONAME
+The name does not resolve for the supplied parameters.
+.Dv NI_NAMEREQD
+is set and the host's name cannot be located,
+or both nodename and servname were null.
+.It Dv EAI_SYSTEM
+A system error occurred.
+The error code can be found in errno.
+.El
+.\"
+.Sh SEE ALSO
+.Xr getaddrinfo 3 ,
+.Xr gethostbyaddr 3 ,
+.Xr getservbyport 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 RFC2553
+.%D March 1999
+.Re
+.Rs
+.%A Tatsuya Jinmei
+.%A Atsushi Onoe
+.%T "An Extension of Format for IPv6 Scoped Addresses"
+.%R internet draft
+.%N draft-ietf-ipngwg-scopedaddr-format-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 HISTORY
+The implementation first appeared in WIDE Hydrangea IPv6 protocol stack kit.
+.\"
+.Sh STANDARDS
+The
+.Fn getnameinfo
+function is defined in IEEE POSIX 1003.1g draft specification,
+and documented in
+.Dq Basic Socket Interface Extensions for IPv6
+.Pq RFC2553 .
+.\"
+.Sh BUGS
+The current implementation is not thread-safe.
+.Pp
+The text was shamelessly copied from RFC2553.
+.Pp
+.Ox
+intentionally uses a different
+.Dv NI_MAXHOST
+value from what RFC2553 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..d3a9678cbd
--- /dev/null
+++ b/src/lib/libc/net/getnameinfo.c
@@ -0,0 +1,368 @@
+/*      $OpenBSD: getnameinfo.c,v 1.26 2003/01/28 04:58:00 marc 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
+
+int
+getnameinfo(sa, salen, host, hostlen, serv, servlen, flags)
+        const struct sockaddr *sa;
+        socklen_t salen;
+        char *host;
+        size_t hostlen;
+        char *serv;
+        size_t servlen;
+        int flags;
+{
+        const struct afd *afd;
+        struct servent *sp;
+        struct hostent *hp;
+        u_short port;
+        int family, i;
+        const char *addr;
+        u_int32_t v4a;
+        int h_error;
+        char numserv[512];
+        char numaddr[512];
+        _THREAD_PRIVATE_MUTEX(serv_mutex);
+
+        if (sa == NULL)
+                return EAI_FAIL;
+
+        if (sa->sa_len != salen)
+                return EAI_FAIL;
+        
+        family = sa->sa_family;
+        for (i = 0; afdl[i].a_af; i++)
+                if (afdl[i].a_af == family) {
+                        afd = &afdl[i];
+                        goto found;
+                }
+        return EAI_FAMILY;
+
+ found:
+        if (salen != afd->a_socklen)
+                return EAI_FAIL;
+
+        /* network byte order */
+        port = ((const struct sockinet *)sa)->si_port;
+        addr = (const char *)sa + afd->a_off;
+
+        if (serv == NULL || servlen == 0) {
+                /*
+                 * do nothing in this case.
+                 * in case you are wondering if "&&" is more correct than
+                 * "||" here: rfc2553bis-03 says that serv == NULL OR
+                 * servlen == 0 means that the caller does not want the result.
+                 */
+        } else {
+                if (flags & NI_NUMERICSERV)
+                        sp = NULL;
+                else {
+                        _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                        sp = getservbyport(port,
+                            (flags & NI_DGRAM) ? "udp" : "tcp");
+                        _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+                }
+                if (sp) {
+                        if (strlen(sp->s_name) + 1 > servlen)
+                                return EAI_MEMORY;
+                        strlcpy(serv, sp->s_name, servlen);
+                } else {
+                        snprintf(numserv, sizeof(numserv), "%u", ntohs(port));
+                        if (strlen(numserv) + 1 > servlen)
+                                return EAI_MEMORY;
+                        strlcpy(serv, numserv, servlen);
+                }
+        }
+
+        switch (sa->sa_family) {
+        case AF_INET:
+                v4a = (u_int32_t)
+                    ntohl(((const struct sockaddr_in *)sa)->sin_addr.s_addr);
+                if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+                        flags |= NI_NUMERICHOST;
+                v4a >>= IN_CLASSA_NSHIFT;
+                if (v4a == 0)
+                        flags |= NI_NUMERICHOST;                        
+                break;
+#ifdef INET6
+        case AF_INET6:
+            {
+                const struct sockaddr_in6 *sin6;
+                sin6 = (const struct sockaddr_in6 *)sa;
+                switch (sin6->sin6_addr.s6_addr[0]) {
+                case 0x00:
+                        if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
+                                ;
+                        else if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
+                                ;
+                        else
+                                flags |= NI_NUMERICHOST;
+                        break;
+                default:
+                        if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
+                                flags |= NI_NUMERICHOST;
+                        }
+                        else if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
+                                flags |= NI_NUMERICHOST;
+                        break;
+                }
+            }
+                break;
+#endif
+        }
+        if (host == NULL || hostlen == 0) {
+                /*
+                 * do nothing in this case.
+                 * in case you are wondering if "&&" is more correct than
+                 * "||" here: rfc2553bis-03 says that host == NULL or
+                 * hostlen == 0 means that the caller does not want the result.
+                 */
+        } else if (flags & NI_NUMERICHOST) {
+                int numaddrlen;
+
+                /* NUMERICHOST and NAMEREQD conflicts with each other */
+                if (flags & NI_NAMEREQD)
+                        return EAI_NONAME;
+
+                switch(afd->a_af) {
+#ifdef INET6
+                case AF_INET6:
+                {
+                        int error;
+
+                        if ((error = ip6_parsenumeric(sa, addr, host,
+                                                      hostlen, flags)) != 0)
+                                return(error);
+                        break;
+                }
+#endif
+                default:
+                        if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+                            == NULL)
+                                return EAI_SYSTEM;
+                        numaddrlen = strlen(numaddr);
+                        if (numaddrlen + 1 > hostlen) /* don't forget terminator */
+                                return EAI_MEMORY;
+                        strlcpy(host, numaddr, hostlen);
+                        break;
+                }
+        } else {
+                _THREAD_PRIVATE_MUTEX_LOCK(serv_mutex);
+                hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
+                _THREAD_PRIVATE_MUTEX_UNLOCK(serv_mutex);
+                h_error = h_errno;
+
+                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(sa, addr, host, hostlen, flags)
+        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(sa6, buf, bufsiz, flags)
+        const struct sockaddr_in6 *sa6;
+        char *buf;
+        size_t bufsiz;
+        int flags;
+{
+        unsigned int ifindex;
+        const struct in6_addr *a6;
+        int n;
+
+        ifindex = (unsigned int)sa6->sin6_scope_id;
+        a6 = &sa6->sin6_addr;
+
+#ifdef notdef
+        if ((flags & NI_NUMERICSCOPE) != 0) {
+                n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
+                if (n < 0 || n >= bufsiz)
+                        return -1;
+                else
+                        return n;
+        }
+#endif
+
+        /* if_indextoname() does not take buffer size.  not a good api... */
+        if ((IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) &&
+            bufsiz >= IF_NAMESIZE) {
+                char *p = if_indextoname(ifindex, buf);
+                if (p) {
+                        return(strlen(p));
+                }
+        }
+
+        /* last resort */
+        n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
+        if (n < 0 || n >= bufsiz)
+                return -1;
+        else
+                return n;
+}
+#endif /* INET6 */
diff --git a/src/lib/libc/net/getnetbyaddr.c b/src/lib/libc/net/getnetbyaddr.c
index c193860e36..925d1d5895 100644
--- a/src/lib/libc/net/getnetbyaddr.c
+++ b/src/lib/libc/net/getnetbyaddr.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getnetbyaddr.c,v 1.4 1995/02/25 06:20:30 cgd Exp $     */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getnetbyaddr.c,v 1.5 1997/07/09 01:08:28 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
@@ -46,14 +40,14 @@ static char rcsid[] = "$NetBSD: getnetbyaddr.c,v 1.4 1995/02/25 06:20:30 cgd Exp
 extern int _net_stayopen;
 
 struct netent *
-getnetbyaddr(net, type)
-        register long net;
+_getnetbyaddr(net, type)
+        register in_addr_t net;
         register int type;
 {
         register 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..4e39cf6860 100644
--- a/src/lib/libc/net/getnetbyname.c
+++ b/src/lib/libc/net/getnetbyname.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getnetbyname.c,v 1.4 1995/02/25 06:20:31 cgd Exp $     */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getnetbyname.c,v 1.5 1997/07/09 01:08:29 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
@@ -47,18 +41,18 @@ static char rcsid[] = "$NetBSD: getnetbyname.c,v 1.4 1995/02/25 06:20:31 cgd Exp
 extern int _net_stayopen;
 
 struct netent *
-getnetbyname(name)
+_getnetbyname(name)
         register const char *name;
 {
         register struct netent *p;
         register 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..0c401c74ff 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.11 2000/12/24 00:30:56 aaron Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,11 +31,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 March 13, 1997
 .Dt GETNETENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getnetent ,
 .Nm getnetbyaddr ,
@@ -46,31 +44,30 @@
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct netent *
-.Fn getnetent 
+.Fn getnetent "void"
 .Ft struct netent *
 .Fn getnetbyname "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 +76,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 zero-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 +120,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 +134,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..8f618a1d5e 100644
--- a/src/lib/libc/net/getnetent.c
+++ b/src/lib/libc/net/getnetent.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getnetent.c,v 1.4 1995/02/25 06:20:33 cgd Exp $        */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getnetent.c,v 1.8 1998/03/16 05:06:57 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -81,22 +75,27 @@ endnetent()
 struct netent *
 getnetent()
 {
-        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 +115,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..1be874209f
--- /dev/null
+++ b/src/lib/libc/net/getnetnamadr.c
@@ -0,0 +1,411 @@
+/*      $OpenBSD: getnetnamadr.c,v 1.21 2003/04/05 00:43:19 tdeval 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Jason Downs for the
+ *      OpenBSD system.
+ * 4. Neither the name(s) of the author(s) nor the name OpenBSD
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * 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. 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[] = "@(#)getnetbyaddr.c      8.1 (Berkeley) 6/4/93";
+static char sccsid_[] = "from getnetnamadr.c    1.4 (Coimbra) 93/06/03";
+static char rcsid[] = "$From: getnetnamadr.c,v 8.7 1996/08/05 08:31:35 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: getnetnamadr.c,v 1.21 2003/04/05 00:43:19 tdeval 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>
+#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(answer, anslen, net_i)
+        querybuf *answer;
+        int anslen;
+        int net_i;
+{
+
+        register HEADER *hp;
+        register u_char *cp;
+        register 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(net, net_type)
+        register in_addr_t net;
+        register 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 ((_resp->options & RES_INIT) == 0 && res_init() == -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(net)
+        register 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 ((_resp->options & RES_INIT) == 0 && res_init() == -1)
+                return (_getnetbyname(net));
+
+        bcopy(_resp->lookups, lookups, sizeof lookups);
+        if (lookups[0] == '\0')
+                strlcpy(lookups, "bf", sizeof lookups);
+
+        for (i = 0; i < MAXDNSLUS && lookups[i]; i++) {
+                switch (lookups[i]) {
+#ifdef YP
+                case 'y':
+                        /* There is no YP support. */
+                        break;
+#endif  /* YP */
+                case 'b':
+                        strlcpy(qbuf, net, sizeof qbuf);
+                        buf = malloc(sizeof(*buf));
+                        if (buf == NULL)
+                                break;
+                        anslen = res_search(qbuf, C_IN, T_PTR, buf->buf,
+                            sizeof(buf->buf));
+                        if (anslen < 0) {
+                                free(buf);
+#ifdef DEBUG
+                                if (_resp->options & RES_DEBUG)
+                                        printf("res_query failed\n");
+#endif
+                                break;
+                        }
+                        net_entry = getnetanswer(buf, anslen, BYNAME);
+                        free(buf);
+                        if (net_entry != NULL)
+                                return (net_entry);
+                        break;
+                case 'f':
+                        net_entry = _getnetbyname(net);
+                        if (net_entry != NULL)
+                                return (net_entry);
+                        break;
+                }
+        }
+
+        /* Nothing matched. */
+        return (NULL);
+}
diff --git a/src/lib/libc/net/getproto.c b/src/lib/libc/net/getproto.c
index 49c09b0806..474d8d9427 100644
--- a/src/lib/libc/net/getproto.c
+++ b/src/lib/libc/net/getproto.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getproto.c,v 1.4 1995/02/25 06:20:33 cgd Exp $ */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getproto.c,v 1.3 1997/07/09 01:08:31 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
@@ -52,7 +46,7 @@ getprotobynumber(proto)
         register struct protoent *p;
 
         setprotoent(_proto_stayopen);
-        while (p = getprotoent())
+        while ((p = getprotoent()))
                 if (p->p_proto == proto)
                         break;
         if (!_proto_stayopen)
diff --git a/src/lib/libc/net/getprotoent.3 b/src/lib/libc/net/getprotoent.3
index 8d607199ef..1f95529532 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.8 2000/12/24 00:30:56 aaron Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,11 +31,9 @@
 .\" 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
 .Dt GETPROTOENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getprotoent ,
 .Nm getprotobynumber ,
@@ -46,24 +44,23 @@
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct protoent *
-.Fn getprotoent 
+.Fn getprotoent "void"
 .Ft struct protoent *
 .Fn getprotobyname "char *name"
 .Ft struct protoent *
 .Fn getprotobynumber "int proto"
+.Ft void
 .Fn setprotoent "int stayopen"
-.Fn endprotoent 
+.Ft void
+.Fn endprotoent "void"
 .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,47 +76,40 @@ 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 zero-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 net 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.
 .Sh RETURN VALUES
-Null pointer
-(0) returned on
+Null pointer (0) returned on
 .Dv EOF
 or error.
 .Sh FILES
@@ -136,11 +126,9 @@ The
 .Fn setprotoent ,
 and
 .Fn endprotoent
-functions appeared in 
+functions appeared in
 .Bx 4.2 .
 .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.
+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.
diff --git a/src/lib/libc/net/getprotoent.c b/src/lib/libc/net/getprotoent.c
index 1179b9029b..2f8b267611 100644
--- a/src/lib/libc/net/getprotoent.c
+++ b/src/lib/libc/net/getprotoent.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getprotoent.c,v 1.4 1995/02/25 06:20:35 cgd Exp $      */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getprotoent.c,v 1.4 1999/09/03 16:23:18 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -80,20 +74,25 @@ endprotoent()
 struct protoent *
 getprotoent()
 {
-        char *p;
-        register char *cp, **q;
+        char *p, *cp, **q, *endp;
+        long l;
+        size_t len;
 
         if (protof == NULL && (protof = fopen(_PATH_PROTOCOLS, "r" )) == NULL)
                 return (NULL);
 again:
-        if ((p = fgets(line, BUFSIZ, protof)) == NULL)
+        if ((p = fgetln(protof, &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';
         proto.p_name = p;
         cp = strpbrk(p, " \t");
         if (cp == NULL)
@@ -104,7 +103,10 @@ again:
         p = strpbrk(cp, " \t");
         if (p != NULL)
                 *p++ = '\0';
-        proto.p_proto = atoi(cp);
+        l = strtol(cp, &endp, 10);
+        if (endp == cp || *endp != '\0' || l < 0 || l >= INT_MAX)
+                goto again;
+        proto.p_proto = l;
         q = proto.p_aliases = proto_aliases;
         if (p != NULL) {
                 cp = p;
diff --git a/src/lib/libc/net/getprotoname.c b/src/lib/libc/net/getprotoname.c
index 4f8cf21c3f..7a4e5fede5 100644
--- a/src/lib/libc/net/getprotoname.c
+++ b/src/lib/libc/net/getprotoname.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getprotoname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $     */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getprotoname.c,v 1.3 1997/07/09 01:08:32 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
@@ -54,7 +48,7 @@ getprotobyname(name)
         register char **cp;
 
         setprotoent(_proto_stayopen);
-        while (p = getprotoent()) {
+        while ((p = getprotoent())) {
                 if (strcmp(p->p_name, name) == 0)
                         break;
                 for (cp = p->p_aliases; *cp != 0; cp++)
diff --git a/src/lib/libc/net/getrrsetbyname.3 b/src/lib/libc/net/getrrsetbyname.3
new file mode 100644
index 0000000000..5ff45cbbe3
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.3
@@ -0,0 +1,166 @@
+.\" $OpenBSD: getrrsetbyname.3,v 1.10 2003/05/01 19:04:02 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 October 18, 2000
+.Dt GETRRSETBYNAME 3
+.Os
+.Sh NAME
+.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 int
+.Fn freerrset "struct rrsetinfo **rrset"
+.Sh DESCRIPTION
+.Fn getrrsetbyname
+gets a set of resource records associated with a
+.Fa hostname ,
+.Fa class
+and
+.Fa type .
+.Fa hostname
+is a pointer a to null-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
+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 rrset
+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 -compact
+.It Dv ERRSET_NONAME
+the name does not exist
+.It Dv ERRSET_NODATA
+the name exists, but does not have data of the desired type
+.It Dv ERRSET_NOMEMORY
+memory could not be allocated
+.It Dv ERRSET_INVAL
+a parameter is invalid
+.It Dv ERRSET_FAIL
+other failure
+.El
+.Sh SEE ALSO
+.Xr resolver 3 ,
+.Xr resolv.conf 5 ,
+.Xr named 8
+.Sh AUTHORS
+Jakob Schlyter
+.Aq jakob@openbsd.org
+.Sh HISTORY
+.Fn getrrsetbyname
+first appeared in
+.Ox 3.0 .
+The API first appeared in ISC BIND version 9.
+.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.
+.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).
diff --git a/src/lib/libc/net/getrrsetbyname.c b/src/lib/libc/net/getrrsetbyname.c
new file mode 100644
index 0000000000..f00ac2b021
--- /dev/null
+++ b/src/lib/libc/net/getrrsetbyname.c
@@ -0,0 +1,512 @@
+/* $OpenBSD: getrrsetbyname.c,v 1.7 2003/03/07 07:34:14 itojun Exp $ */
+
+/*
+ * Copyright (c) 2001 Jakob Schlyter. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions Copyright (c) 1999-2001 Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "thread_private.h"
+
+#define ANSWER_BUFFER_SIZE 1024*64
+
+struct dns_query {
+        char                    *name;
+        u_int16_t               type;
+        u_int16_t               class;
+        struct dns_query        *next;
+};
+
+struct dns_rr {
+        char                    *name;
+        u_int16_t               type;
+        u_int16_t               class;
+        u_int16_t               ttl;
+        u_int16_t               size;
+        void                    *rdata;
+        struct dns_rr           *next;
+};
+
+struct dns_response {
+        HEADER                  header;
+        struct dns_query        *query;
+        struct dns_rr           *answer;
+        struct dns_rr           *authority;
+        struct dns_rr           *additional;
+};
+
+static struct dns_response *parse_dns_response(const u_char *, int);
+static struct dns_query *parse_dns_qsection(const u_char *, int,
+    const u_char **, int);
+static struct dns_rr *parse_dns_rrsection(const u_char *, int, const u_char **,
+    int);
+
+static void free_dns_query(struct dns_query *);
+static void free_dns_rr(struct dns_rr *);
+static void free_dns_response(struct dns_response *);
+
+static int count_dns_rr(struct dns_rr *, u_int16_t, u_int16_t);
+
+int
+getrrsetbyname(const char *hostname, unsigned int rdclass,
+    unsigned int rdtype, unsigned int flags,
+    struct rrsetinfo **res)
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int result;
+        struct rrsetinfo *rrset = NULL;
+        struct dns_response *response;
+        struct dns_rr *rr;
+        struct rdatainfo *rdata;
+        int length;
+        unsigned int index_ans, index_sig;
+        u_char answer[ANSWER_BUFFER_SIZE];
+
+        /* check for invalid class and type */
+        if (rdclass > 0xffff || rdtype > 0xffff) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* don't allow queries of class or type ANY */
+        if (rdclass == 0xff || rdtype == 0xff) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* don't allow flags yet, unimplemented */
+        if (flags) {
+                result = ERRSET_INVAL;
+                goto fail;
+        }
+
+        /* initialize resolver */
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+#ifdef DEBUG
+        _resp->options |= RES_DEBUG;
+#endif /* DEBUG */
+
+#ifdef RES_USE_DNSSEC
+        /* turn on DNSSEC if EDNS0 is configured */
+        if (_resp->options & RES_USE_EDNS0)
+                _resp->options |= RES_USE_DNSSEC;
+#endif /* RES_USE_DNSEC */
+
+        /* make query */
+        length = res_query(hostname, (signed int) rdclass, (signed int) rdtype,
+            answer, sizeof(answer));
+        if (length < 0) {
+                switch(h_errno) {
+                case HOST_NOT_FOUND:
+                        result = ERRSET_NONAME;
+                        goto fail;
+                case NO_DATA:
+                        result = ERRSET_NODATA;
+                        goto fail;
+                default:
+                        result = ERRSET_FAIL;
+                        goto fail;
+                }
+        }
+
+        /* parse result */
+        response = parse_dns_response(answer, length);
+        if (response == NULL) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+        if (response->header.qdcount != 1) {
+                result = ERRSET_FAIL;
+                goto fail;
+        }
+
+        /* initialize rrset */
+        rrset = calloc(1, sizeof(struct rrsetinfo));
+        if (rrset == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+        rrset->rri_rdclass = response->query->class;
+        rrset->rri_rdtype = response->query->type;
+        rrset->rri_ttl = response->answer->ttl;
+        rrset->rri_nrdatas = response->header.ancount;
+
+        /* check for authenticated data */
+        if (response->header.ad == 1)
+                rrset->rri_flags |= RRSET_VALIDATED;
+
+        /* copy name from answer section */
+        length = strlen(response->answer->name);
+        rrset->rri_name = malloc(length + 1);
+        if (rrset->rri_name == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+        strlcpy(rrset->rri_name, response->answer->name, length + 1);
+
+        /* count answers */
+        rrset->rri_nrdatas = count_dns_rr(response->answer, rrset->rri_rdclass,
+            rrset->rri_rdtype);
+        rrset->rri_nsigs = count_dns_rr(response->answer, rrset->rri_rdclass,
+            T_SIG);
+
+        /* allocate memory for answers */
+        rrset->rri_rdatas = calloc(rrset->rri_nrdatas,
+            sizeof(struct rdatainfo));
+        if (rrset->rri_rdatas == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+
+        /* allocate memory for signatures */
+        rrset->rri_sigs = calloc(rrset->rri_nsigs, sizeof(struct rdatainfo));
+        if (rrset->rri_sigs == NULL) {
+                result = ERRSET_NOMEMORY;
+                goto fail;
+        }
+
+        /* copy answers & signatures */
+        for (rr = response->answer, index_ans = 0, index_sig = 0;
+            rr; rr = rr->next) {
+
+                rdata = NULL;
+
+                if (rr->class == rrset->rri_rdclass &&
+                    rr->type  == rrset->rri_rdtype)
+                        rdata = &rrset->rri_rdatas[index_ans++];
+
+                if (rr->class == rrset->rri_rdclass &&
+                    rr->type  == T_SIG)
+                        rdata = &rrset->rri_sigs[index_sig++];
+
+                if (rdata) {
+                        rdata->rdi_length = rr->size;
+                        rdata->rdi_data   = malloc(rr->size);
+
+                        if (rdata->rdi_data == NULL) {
+                                result = ERRSET_NOMEMORY;
+                                goto fail;
+                        }
+                        memcpy(rdata->rdi_data, rr->rdata, rr->size);
+                }
+        }
+
+        *res = rrset;
+        return (ERRSET_SUCCESS);
+
+fail:
+        if (rrset != NULL)
+                freerrset(rrset);
+        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..16602cc3a6 100644
--- a/src/lib/libc/net/getservbyname.c
+++ b/src/lib/libc/net/getservbyname.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getservbyname.c,v 1.4 1995/02/25 06:20:36 cgd Exp $    */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,27 +32,30 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getservbyname.c,v 1.5 2000/01/06 08:24:17 d Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
 #include <string.h>
+#include "thread_private.h"
 
 extern int _serv_stayopen;
 
+_THREAD_PRIVATE_MUTEX(getservbyname_r);
+
 struct servent *
-getservbyname(name, proto)
+getservbyname_r(name, proto, se, buf, buflen)
         const char *name, *proto;
+        struct servent *se;
+        char *buf;
+        int buflen;
 {
         register struct servent *p;
         register char **cp;
 
+        _THREAD_PRIVATE_MUTEX_LOCK(getservbyname_r);
         setservent(_serv_stayopen);
-        while (p = getservent()) {
+        while ((p = getservent())) {
                 if (strcmp(name, p->s_name) == 0)
                         goto gotname;
                 for (cp = p->s_aliases; *cp; cp++)
@@ -67,5 +68,20 @@ gotname:
         }
         if (!_serv_stayopen)
                 endservent();
+        _THREAD_PRIVATE_MUTEX_UNLOCK(getservbyname_r);
         return (p);
 }
+
+struct servent *getservbyname(name, proto)
+        const char *name, *proto;
+{
+        _THREAD_PRIVATE_KEY(getservbyname);
+        static char buf[4096];
+        char *bufp = (char*)_THREAD_PRIVATE(getservbyname, buf, NULL);
+
+        if (bufp == NULL)
+                return (NULL);
+        return getservbyname_r(name, proto, (struct servent*) bufp, 
+                bufp + sizeof(struct servent), 
+                sizeof buf - sizeof(struct servent) );
+}
diff --git a/src/lib/libc/net/getservbyport.c b/src/lib/libc/net/getservbyport.c
index c34790737b..4b063760d2 100644
--- a/src/lib/libc/net/getservbyport.c
+++ b/src/lib/libc/net/getservbyport.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getservbyport.c,v 1.4 1995/02/25 06:20:37 cgd Exp $    */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getservbyport.c,v 1.3 1997/07/09 01:08:35 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <netdb.h>
@@ -54,7 +48,7 @@ getservbyport(port, proto)
         register struct servent *p;
 
         setservent(_serv_stayopen);
-        while (p = getservent()) {
+        while ((p = getservent())) {
                 if (p->s_port != port)
                         continue;
                 if (proto == 0 || strcmp(p->s_proto, proto) == 0)
diff --git a/src/lib/libc/net/getservent.3 b/src/lib/libc/net/getservent.3
index 9e0656be00..85e0d65352 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.11 2000/12/24 00:30:56 aaron Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,11 +31,9 @@
 .\" 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
 .Dt GETSERVENT 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm getservent ,
 .Nm getservbyport ,
@@ -46,26 +44,23 @@
 .Sh SYNOPSIS
 .Fd #include <netdb.h>
 .Ft struct servent *
-.Fn getservent 
+.Fn getservent "void"
 .Ft struct servent *
 .Fn getservbyname "char *name" "char *proto"
 .Ft struct servent *
-.Fn getservbyport "int port" proto
+.Fn getservbyport "int port" "char *proto"
 .Ft void
 .Fn setservent "int stayopen"
 .Ft void
-.Fn endservent void
+.Fn endservent "void"
 .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,59 +76,50 @@ 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 zero-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 net 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
 .Sh FILES
 .Bl -tag -width /etc/services -compact
 .It Pa /etc/services
 .El
 .Sh DIAGNOSTICS
-Null pointer
-(0) returned on
+Null pointer (0) returned on
 .Dv EOF
 or error.
 .Sh SEE ALSO
@@ -147,11 +133,9 @@ The
 .Fn setservent ,
 and
 .Fn endservent
-functions appeared in 
+functions appeared in
 .Bx 4.2 .
 .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.
+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.
diff --git a/src/lib/libc/net/getservent.c b/src/lib/libc/net/getservent.c
index 316891450e..ff6bf1e57f 100644
--- a/src/lib/libc/net/getservent.c
+++ b/src/lib/libc/net/getservent.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: getservent.c,v 1.4 1995/02/25 06:20:38 cgd Exp $       */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: getservent.c,v 1.5 1999/09/03 16:23:19 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -80,20 +74,25 @@ endservent()
 struct servent *
 getservent()
 {
-        char *p;
-        register char *cp, **q;
+        char *p, *cp, **q, *endp;
+        long l;
+        size_t len;
 
         if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL)
                 return (NULL);
 again:
-        if ((p = fgets(line, BUFSIZ, servf)) == NULL)
+        if ((p = fgetln(servf, &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';
         serv.s_name = p;
         p = strpbrk(p, " \t");
         if (p == NULL)
@@ -105,7 +104,10 @@ again:
         if (cp == NULL)
                 goto again;
         *cp++ = '\0';
-        serv.s_port = htons((u_short)atoi(p));
+        l = strtol(p, &endp, 10);
+        if (endp == p || *endp != '\0' || l < 0 || l > USHRT_MAX)
+                goto again;
+        serv.s_port = htons((in_port_t)l);
         serv.s_proto = cp;
         q = serv.s_aliases = serv_aliases;
         cp = strpbrk(cp, " \t");
diff --git a/src/lib/libc/net/herror.c b/src/lib/libc/net/herror.c
index 41adbf1055..737bb115a7 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.4 1997/03/13 19:07:28 downsj 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -56,26 +58,27 @@
 #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 ";
+static char rcsid[] = "$From: herror.c,v 8.3 1996/08/05 08:31:35 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: herror.c,v 1.5 1995/02/25 06:20:39 cgd Exp $";
+static char rcsid[] = "$OpenBSD: herror.c,v 1.4 1997/03/13 19:07:28 downsj 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 *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]) };
+int     h_nerr = { sizeof h_errlist / sizeof h_errlist[0] };
 
 extern int      h_errno;
 
@@ -98,8 +101,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 +109,13 @@ herror(s)
         writev(STDERR_FILENO, iov, (v - iov) + 1);
 }
 
-char *
+const char *
 hstrerror(err)
         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..73b7432731 100644
--- a/src/lib/libc/net/htonl.c
+++ b/src/lib/libc/net/htonl.c
@@ -1,29 +1,25 @@
-/*      $NetBSD: htonl.c,v 1.5 1995/04/28 23:25:14 jtc 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
+static char *rcsid = "$OpenBSD: htonl.c,v 1.4 1996/12/12 03:19:55 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef htonl
 
-unsigned long
+u_int32_t
 htonl(x)
-        unsigned long x;
+        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..ded70712ea 100644
--- a/src/lib/libc/net/htons.c
+++ b/src/lib/libc/net/htons.c
@@ -1,26 +1,23 @@
-/*      $NetBSD: htons.c,v 1.5 1995/04/28 23:25:19 jtc 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
+static char *rcsid = "$OpenBSD: htons.c,v 1.7 2002/02/19 19:39:36 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
 
 #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..85269c3769
--- /dev/null
+++ b/src/lib/libc/net/if_indextoname.3
@@ -0,0 +1,140 @@
+.\"     $OpenBSD: if_indextoname.3,v 1.5 2002/03/07 22:41:12 millert Exp $
+.\" Copyright (c) 1983, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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: @(#)rcmd.3        8.1 (Berkeley) 6/4/93
+.\"
+.Dd May 21, 1998
+.Dt IF_NAMETOINDEX 3
+.Os
+.Sh NAME
+.Nm if_nametoindex ,
+.Nm if_indextoname ,
+.Nm if_nameindex ,
+.Nm if_freenameindex
+.Nd convert interface index to name, and vice versa
+.Sh SYNOPSIS
+.Fd #include <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 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,
+.Dv NULL
+is returned.
+.Pp
+.Fn if_nameindex
+returns an array of
+.Fa if_nameindex
+structures.
+.Fa if_nametoindex
+is also defined in
+.Aq Pa net/if.h ,
+and is as follows:
+.Bd -literal -offset
+struct if_nameindex {
+    unsigned int   if_index;  /* 1, 2, ... */
+    char          *if_name;   /* null terminated name: "le0", ... */
+};
+.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
+.Pp
+R. Gilligan, S.  Thomson, J. Bound, and W. Stevens,
+``Basic Socket Interface Extensions for IPv6,'' RFC2553, March 1999.
+.Sh STANDARDS
+These functions are defined in ``Basic Socket Interface Extensions for IPv6''
+.Pq RFC2533 .
diff --git a/src/lib/libc/net/if_indextoname.c b/src/lib/libc/net/if_indextoname.c
new file mode 100644
index 0000000000..f99e52e387
--- /dev/null
+++ b/src/lib/libc/net/if_indextoname.c
@@ -0,0 +1,86 @@
+/*      $OpenBSD: if_indextoname.c,v 1.9 2002/03/07 22:40:23 millert Exp $      */
+/*      $KAME: if_indextoname.c,v 1.6 2000/11/07 22:33:25 jinmei Exp $  */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      BSDI Id: if_indextoname.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * From RFC 2533:
+ *
+ * The second function maps an interface index into its corresponding
+ * name.
+ *
+ *    #include <net/if.h>
+ *
+ *    char  *if_indextoname(unsigned int ifindex, char *ifname);
+ *
+ * The ifname argument must point to a buffer of at least IF_NAMESIZE
+ * bytes into which the interface name corresponding to the specified
+ * index is returned.  (IF_NAMESIZE is also defined in <net/if.h> and
+ * its value includes a terminating null byte at the end of the
+ * interface name.) This pointer is also the return value of the
+ * function.  If there is no interface corresponding to the specified
+ * index, NULL is returned, and errno is set to ENXIO, if there was a
+ * system error (such as running out of memory), if_indextoname returns
+ * NULL and errno would be set to the proper value (e.g., ENOMEM).
+ */
+
+char *
+if_indextoname(unsigned int ifindex, char *ifname)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        int error = 0;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(NULL);   /* getifaddrs properly set errno */
+
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK &&
+                    ifindex == ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index)
+                        break;
+        }
+
+        if (ifa == NULL) {
+                error = ENXIO;
+                ifname = NULL;
+        }
+        else
+                strlcpy(ifname, ifa->ifa_name, IFNAMSIZ);
+
+        freeifaddrs(ifaddrs);
+
+        errno = error;
+        return(ifname);
+}
diff --git a/src/lib/libc/net/if_nameindex.c b/src/lib/libc/net/if_nameindex.c
new file mode 100644
index 0000000000..3675a2a450
--- /dev/null
+++ b/src/lib/libc/net/if_nameindex.c
@@ -0,0 +1,140 @@
+/*      $OpenBSD: if_nameindex.c,v 1.9 2002/03/07 22:40:23 millert Exp $        */
+/*      $KAME: if_nameindex.c,v 1.7 2000/11/24 08:17:20 itojun Exp $    */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      BSDI Id: if_nameindex.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * From RFC 2553:
+ *
+ * 4.3 Return All Interface Names and Indexes
+ *
+ *    The if_nameindex structure holds the information about a single
+ *    interface and is defined as a result of including the <net/if.h>
+ *    header.
+ *
+ *       struct if_nameindex {
+ *         unsigned int   if_index;
+ *         char          *if_name;
+ *       };
+ *
+ *    The final function returns an array of if_nameindex structures, one
+ *    structure per interface.
+ *
+ *       struct if_nameindex  *if_nameindex(void);
+ *
+ *    The end of the array of structures is indicated by a structure with
+ *    an if_index of 0 and an if_name of NULL.  The function returns a NULL
+ *    pointer upon an error, and would set errno to the appropriate value.
+ *
+ *    The memory used for this array of structures along with the interface
+ *    names pointed to by the if_name members is obtained dynamically.
+ *    This memory is freed by the next function.
+ *
+ * 4.4.  Free Memory
+ *
+ *    The following function frees the dynamic memory that was allocated by
+ *    if_nameindex().
+ *
+ *        #include <net/if.h>
+ *
+ *        void  if_freenameindex(struct if_nameindex *ptr);
+ *
+ *    The argument to this function must be a pointer that was returned by
+ *    if_nameindex().
+ */
+
+struct if_nameindex *
+if_nameindex(void)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        unsigned int ni;
+        size_t nbytes;
+        struct if_nameindex *ifni, *ifni2;
+        char *cp;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(NULL);
+
+        /*
+         * First, find out how many interfaces there are, and how
+         * much space we need for the string names.
+         */
+        ni = 0;
+        nbytes = 0;
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK) {
+                        nbytes += strlen(ifa->ifa_name) + 1;
+                        ni++;
+                }
+        }
+
+        /*
+         * Next, allocate a chunk of memory, use the first part
+         * for the array of structures, and the last part for
+         * the strings.
+         */
+        cp = malloc((ni + 1) * sizeof(struct if_nameindex) + nbytes);
+        ifni = (struct if_nameindex *)cp;
+        if (ifni == NULL)
+                goto out;
+        cp += (ni + 1) * sizeof(struct if_nameindex);
+
+        /*
+         * Now just loop through the list of interfaces again,
+         * filling in the if_nameindex array and making copies
+         * of all the strings.
+         */
+        ifni2 = ifni;
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK) {
+                        ifni2->if_index =
+                            ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index;
+                        ifni2->if_name = cp;
+                        nbytes = strlen(ifa->ifa_name) + 1;
+                        memcpy(cp, ifa->ifa_name, nbytes);
+                        ifni2++;
+                        cp += nbytes;
+                }
+        }
+        /*
+         * Finally, don't forget to terminate the array.
+         */
+        ifni2->if_index = 0;
+        ifni2->if_name = NULL;
+out:
+        freeifaddrs(ifaddrs);
+        return(ifni);
+}
diff --git a/src/lib/libc/net/if_nametoindex.c b/src/lib/libc/net/if_nametoindex.c
new file mode 100644
index 0000000000..8bd792b949
--- /dev/null
+++ b/src/lib/libc/net/if_nametoindex.c
@@ -0,0 +1,81 @@
+/*      $OpenBSD: if_nametoindex.c,v 1.8 2002/03/07 22:40:23 millert Exp $      */
+/*      $KAME: if_nametoindex.c,v 1.5 2000/11/24 08:04:40 itojun Exp $  */
+
+/*-
+ * Copyright (c) 1997, 2000
+ *      Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      BSDI Id: if_nametoindex.c,v 2.3 2000/04/17 22:38:05 dab Exp
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <ifaddrs.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * From RFC 2553:
+ *
+ * 4.1 Name-to-Index
+ *
+ *
+ *    The first function maps an interface name into its corresponding
+ *    index.
+ *
+ *       #include <net/if.h>
+ *
+ *       unsigned int  if_nametoindex(const char *ifname);
+ *
+ *    If the specified interface name does not exist, the return value is
+ *    0, and errno is set to ENXIO.  If there was a system error (such as
+ *    running out of memory), the return value is 0 and errno is set to the
+ *    proper value (e.g., ENOMEM).
+ */
+
+unsigned int
+if_nametoindex(const char *ifname)
+{
+        struct ifaddrs *ifaddrs, *ifa;
+        unsigned int ni;
+
+        if (getifaddrs(&ifaddrs) < 0)
+                return(0);
+
+        ni = 0;
+
+        for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr &&
+                    ifa->ifa_addr->sa_family == AF_LINK &&
+                    strcmp(ifa->ifa_name, ifname) == 0) {
+                        ni = ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index;
+                        break;
+                }
+        }
+
+        freeifaddrs(ifaddrs);
+        if (!ni)
+                errno = ENXIO;
+        return(ni);
+}
diff --git a/src/lib/libc/net/inet.3 b/src/lib/libc/net/inet.3
index 49bac97e96..b15c478aef 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.15 2003/05/01 19:17:37 jmc 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.
@@ -33,36 +34,43 @@
 .\"
 .\"     @(#)inet.3      8.1 (Berkeley) 6/4/93
 .\"
-.Dd June 4, 1993
+.Dd June 18, 1997
 .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 "unsigned long net" "unsigned long 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" "size_t size"
+.Ft int
+.Fn inet_pton "int af" "const char *src" "void *dst"
 .Sh DESCRIPTION
 The routines
 .Fn inet_aton ,
@@ -74,11 +82,26 @@ numbers expressed in the Internet standard
 .Ql \&.
 notation.
 The
+.Fn inet_pton
+function converts a presentation format address (that is, printable form
+as held in a character string) to network format (usually a
+.Li struct in_addr
+or some other internal binary representation, in network byte order).
+It returns 1 if the address was valid for the specified address family, or
+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 +109,32 @@ 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
+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,7 +146,7 @@ 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
+.Sh INTERNET ADDRESSES (IP VERSION 4)
 Values specified using the
 .Ql \&.
 notation take one
@@ -122,28 +160,27 @@ 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
+.Tn Intel 386, 486
+and
+.Tn 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 .
@@ -155,12 +192,89 @@ rearrangement.
 All numbers supplied as
 .Dq parts
 in a
-.Ql  \&.
+.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 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 [RFC1884 2.2]:
+.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 +284,66 @@ 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
+.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_option_space.3 b/src/lib/libc/net/inet6_option_space.3
new file mode 100644
index 0000000000..5150b191bd
--- /dev/null
+++ b/src/lib/libc/net/inet6_option_space.3
@@ -0,0 +1,448 @@
+.\"     $OpenBSD: inet6_option_space.3,v 1.10 2003/05/01 19:17:37 jmc Exp $
+.\"     $KAME: inet6_option_space.3,v 1.7 2000/05/17 14:32:13 itojun Exp $
+.\"
+.\" Copyright (c) 1983, 1987, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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.
+.\"
+.Dd December 10, 1999
+.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 Options manipulation
+.\"
+.Sh SYNOPSIS
+.Fd #include <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
+.\"
+Building and parsing the Hop-by-Hop and Destination options is
+complicated due to alignment constraints, padding and
+ancillary data manipulation.
+RFC2292 defines a set of functions to help the application.
+The function prototypes for
+these functions are all in the
+.Aq Pa netinet/in.h
+header.
+.\"
+.Ss inet6_option_space
+.Fn inet6_option_space
+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 padding at the end
+.Po
+to make its size a multiple of 8 bytes
+.Pc .
+The argument is the size of the structure defining the option,
+which must include any pad bytes at the beginning
+.Po
+the value
+.Li y
+in the alignment term
+.Dq Li xn + y
+.Pc ,
+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, this 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.
+This is of little consequence, since it is assumed that most
+Hop-by-Hop option headers and Destination option headers carry only
+one option
+.Pq appendix B of [RFC-2460] .
+.\"
+.Ss inet6_option_init
+.Fn inet6_option_init
+is called once per ancillary data object that will
+contain either Hop-by-Hop or Destination options.
+It returns
+.Li 0
+on success or
+.Li -1
+on an error.
+.Pp
+.Fa bp
+is a pointer to previously allocated space that will contain the
+ancillary data object.
+It must be large enough to contain all the
+individual options to be added by later calls to
+.Fn inet6_option_append
+and
+.Fn inet6_option_alloc .
+.Pp
+.Fa cmsgp
+is a pointer to a pointer to a
+.Li cmsghdr
+structure.
+.Fa *cmsgp
+is initialized by this function to point to the
+.Li cmsghdr
+structure constructed by this function in the buffer pointed to by
+.Fa bp .
+.Pp
+.Fa type
+is either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS .
+This
+.Fa type
+is stored in the
+.Li cmsg_type
+member of the
+.Li cmsghdr
+structure pointed to by
+.Fa *cmsgp .
+.\"
+.Ss inet6_option_append
+This function appends a Hop-by-Hop option or a Destination option
+into an ancillary data object that has been initialized by
+.Fn inet6_option_init .
+This function returns
+.Li 0
+if it succeeds or
+.Li -1
+on an error.
+.Pp
+.Fa cmsg
+is a pointer to the
+.Li cmsghdr
+structure that must have been
+initialized by
+.Fn inet6_option_init .
+.Pp
+.Fa typep
+is a pointer to the 8-bit option type.
+It is assumed that this
+field is immediately followed by the 8-bit option data length field,
+which is then followed immediately by the option data.
+The caller
+initializes these three fields
+.Pq the type-length-value, or TLV
+before calling this function.
+.Pp
+The option type must have a value from
+.Li 2
+to
+.Li 255 ,
+inclusive.
+.Po
+.Li 0
+and
+.Li 1
+are reserved for the
+.Li Pad1
+and
+.Li PadN
+options, respectively.
+.Pc
+.Pp
+The option data length must have a value between
+.Li 0
+and
+.Li 255 ,
+inclusive, and is the length of the option data that follows.
+.Pp
+.Fa multx
+is the value
+.Li x
+in the alignment term
+.Dq Li xn + y .
+It must have a value of
+.Li 1 ,
+.Li 2 ,
+.Li 4 ,
+or
+.Li 8 .
+.Pp
+.Fa plusy
+is the value
+.Li y
+in the alignment term
+.Dq Li xn + y .
+It must have a value between
+.Li 0
+and
+.Li 7 ,
+inclusive.
+.\"
+.Ss inet6_option_alloc
+This function appends a Hop-by-Hop option or a Destination option
+into an ancillary data object that has been initialized by
+.Fn inet6_option_init .
+This function returns a pointer to the 8-bit
+option type field that starts the option on success, or
+.Dv NULL
+on an error.
+.Pp
+The difference between this function and
+.Fn 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.
+.Pp
+.Fa cmsg
+is a pointer to the
+.Li cmsghdr
+structure that must have been
+initialized by
+.Fn inet6_option_init .
+.Pp
+.Fa datalen
+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
+.Fa multx
+is the value
+.Li x
+in the alignment term
+.Dq Li xn + y .
+It must have a value of
+.Li 1 ,
+.Li 2 ,
+.Li 4 ,
+or
+.Li 8 .
+.Pp
+.Fa plusy
+is the value
+.Li y
+in the alignment term
+.Dq Li xn + y .
+It must have a value between
+.Li 0
+and
+.Li 7 ,
+inclusive.
+.\"
+.Ss inet6_option_next
+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
+.Li 0
+and
+.Fa *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
+.Li -1
+and
+.Fa *tptrp
+is
+.Dv NULL .
+If an error occurs, the return value is
+.Li -1
+and
+.Fa *tptrp
+is not
+.Dv NULL .
+.Pp
+.Fa cmsg
+is a pointer to
+.Li cmsghdr
+structure of which
+.Li cmsg_level
+equals
+.Dv IPPROTO_IPV6
+and
+.Li cmsg_type
+equals either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS .
+.Pp
+.Fa tptrp
+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.
+The first time this function is
+called for a given ancillary data object,
+.Fa *tptrp
+must be set to
+.Dv NULL .
+.Pp
+Each time this function returns success,
+.Fa *tptrp
+points to the 8-bit
+option type field for the next option to be processed.
+.\"
+.Ss inet6_option_find
+This function is similar to the previously described
+.Fn 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.
+.Fa cmsg
+is a
+pointer to
+.Li cmsghdr
+structure of which
+.Li cmsg_level
+equals
+.Dv IPPROTO_IPV6
+and
+.Li cmsg_type
+equals either
+.Dv IPV6_HOPOPTS
+or
+.Dv IPV6_DSTOPTS .
+.Pp
+.Fa tptrp
+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.
+The first time this function is
+called for a given ancillary data object,
+.Fa *tptrp
+must be set to
+.Dv NULL .
+.Pp
+This function starts searching for an option of the specified type
+beginning after the value of
+.Fa *tptrp .
+If an option of the specified
+type is located, this function returns
+.Li 0
+and
+.Fa *tptrp
+points to the 8-
+bit option type field for the option of the specified type.
+If an
+option of the specified type is not located, the return value is
+.Li -1
+and
+.Fa *tptrp
+is
+.Dv NULL .
+If an error occurs, the return value is
+.Li -1
+and
+.Fa *tptrp
+is not
+.Dv NULL .
+.\"
+.Sh DIAGNOSTICS
+.Fn inet6_option_init
+and
+.Fn inet6_option_append
+return
+.Li 0
+on success or
+.Li -1
+on an error.
+.Pp
+.Fn inet6_option_alloc
+returns
+.Dv NULL
+on an error.
+.Pp
+On errors,
+.Fn inet6_option_next
+and
+.Fn inet6_option_find
+return
+.Li -1
+setting
+.Fa *tptrp
+to non
+.Dv NULL
+value.
+.\"
+.Sh EXAMPLES
+RFC2292 gives comprehensive examples in chapter 6.
+.\"
+.Sh SEE ALSO
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%T "Advanced Sockets API for IPv6"
+.%N RFC2292
+.%D February 1998
+.Re
+.Rs
+.%A S. Deering
+.%A R. Hinden
+.%T "Internet Protocol, Version 6 (IPv6) Specification"
+.%N RFC2460
+.%D December 1998
+.Re
+.\"
+.Sh HISTORY
+The implementation first appeared in KAME advanced networking kit.
+.\"
+.Sh STANDARDS
+The functions
+are documented in
+.Dq Advanced Sockets API for IPv6
+.Pq RFC2292 .
+.\"
+.Sh BUGS
+The text was shamelessly copied from RFC2292.
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..06a56715b5
--- /dev/null
+++ b/src/lib/libc/net/inet6_rthdr_space.3
@@ -0,0 +1,321 @@
+.\"     $OpenBSD: inet6_rthdr_space.3,v 1.10 2003/05/01 19:17:37 jmc Exp $
+.\"     $KAME: inet6_rthdr_space.3,v 1.8 2000/05/17 14:30:15 itojun Exp $
+.\"
+.\" Copyright (c) 1983, 1987, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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.
+.\"
+.Dd December 10, 1999
+.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
+.Fd #include <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
+RFC2292 IPv6 advanced API defines eight
+functions that the application calls to build and examine a Routing
+header.
+Four functions build a Routing header:
+.Bl -hang
+.It Fn inet6_rthdr_space
+return #bytes required for ancillary data
+.It Fn inet6_rthdr_init
+initialize ancillary data for Routing header
+.It Fn inet6_rthdr_add
+add IPv6 address & flags to Routing header
+.It Fn inet6_rthdr_lasthop
+specify the flags for the final hop
+.El
+.Pp
+Four functions deal with a returned Routing header:
+.Bl -hang
+.It Fn inet6_rthdr_reverse
+reverse a Routing header
+.It Fn inet6_rthdr_segments
+return #segments in a Routing header
+.It Fn inet6_rthdr_getaddr
+fetch one address from a Routing header
+.It Fn inet6_rthdr_getflags
+fetch one flag from a Routing header
+.El
+.Pp
+The function prototypes for these functions are all in the
+.Aq Pa netinet/in.h
+header.
+.\"
+.Ss inet6_rthdr_space
+This function returns the number of bytes required to hold a Routing
+header of the specified
+.Fa type
+containing the specified number of
+.Fa segments
+.Pq addresses .
+For an IPv6 Type 0 Routing header, the number
+of segments must be between 1 and 23, inclusive.
+The return value
+includes the size of the cmsghdr structure that precedes the Routing
+header, and any required padding.
+.Pp
+If the return value is 0, then either the type of the Routing header
+is not supported by this implementation or the number of segments is
+invalid for this type of Routing header.
+.Pp
+Note: This function returns the size but does not allocate the space
+required for the ancillary data.
+This allows an application to
+allocate a larger buffer, if other ancillary data objects are
+desired, since all the ancillary data objects must be specified to
+.Xr sendmsg 2
+as a single
+.Li msg_control
+buffer.
+.\"
+.Ss inet6_rthdr_init
+This function initializes the buffer pointed to by
+.Fa bp
+to contain a
+.Li cmsghdr
+structure followed by a Routing header of the specified
+.Fa type .
+The
+.Li cmsg_len
+member of the
+.Li cmsghdr
+structure is initialized to the
+size of the structure plus the amount of space required by the
+Routing header.
+The
+.Li cmsg_level
+and
+.Li cmsg_type
+members are also initialized as required.
+.Pp
+The caller must allocate the buffer and its size can be determined by
+calling
+.Fn inet6_rthdr_space .
+.Pp
+Upon success the return value is the pointer to the
+.Li cmsghdr
+structure, and this is then used as the first argument to the next
+two functions.
+Upon an error the return value is
+.Dv NULL .
+.\"
+.Ss inet6_rthdr_add
+This function adds the address pointed to by
+.Fa addr
+to the end of the
+Routing header being constructed and sets the type of this hop to the
+value of
+.Fa flags .
+For an IPv6 Type 0 Routing header,
+.Fa flags
+must be
+either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT .
+.Pp
+If successful, the
+.Li cmsg_len
+member of the
+.Li cmsghdr
+structure is
+updated to account for the new address in the Routing header and the
+return value of the function is 0.
+Upon an error the return value of
+the function is -1.
+.\"
+.Ss inet6_rthdr_lasthop
+This function specifies the Strict/Loose flag for the final hop of a
+Routing header.
+For an IPv6 Type 0 Routing header,
+.Fa flags
+must be either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT .
+.Pp
+The return value of the function is 0 upon success, or -1 upon an error.
+.Pp
+Notice that a Routing header specifying
+.Li N
+intermediate nodes requires
+.Li N+1
+Strict/Loose flags.
+This requires
+.Li N
+calls to
+.Fn inet6_rthdr_add
+followed by one call to
+.Fn inet6_rthdr_lasthop .
+.\"
+.Ss inet6_rthdr_reverse
+This function takes a Routing header that was received as ancillary
+data
+.Po
+pointed to by the first argument,
+.Fa in
+.Pc
+and writes a new Routing
+header that sends datagrams along the reverse of that route.
+Both
+arguments are allowed to point to the same buffer
+.Pq that is, the reversal can occur in place .
+.Pp
+The return value of the function is 0 on success, or -1 upon an
+error.
+.\"
+.Ss inet6_rthdr_segments
+This function returns the number of segments
+.Pq addresses
+contained in
+the Routing header described by
+.Fa cmsg .
+On success the return value is
+between 1 and 23, inclusive.
+The return value of the function is -1 upon an error.
+.\"
+.Ss inet6_rthdr_getaddr
+This function returns a pointer to the IPv6 address specified by
+.Fa index
+(which must have a value between 1 and the value returned by
+.Fn inet6_rthdr_segments )
+in the Routing header described by
+.Fa cmsg .
+An
+application should first call
+.Fn inet6_rthdr_segments
+to obtain the number of segments in the Routing header.
+.Pp
+Upon an error the return value of the function is
+.Dv NULL .
+.\"
+.Ss inet6_rthdr_getflags
+This function returns the flags value specified by
+.Fa index
+(which must
+have a value between 0 and the value returned by
+.Fn inet6_rthdr_segments )
+in the Routing header described by
+.Fa cmsg .
+For an IPv6 Type 0 Routing header the return value will be either
+.Dv IPV6_RTHDR_LOOSE
+or
+.Dv IPV6_RTHDR_STRICT .
+.Pp
+Upon an error the return value of the function is -1.
+.Pp
+Note: Addresses are indexed starting at 1, and flags starting at 0,
+to maintain consistency with the terminology and figures in RFC2460.
+.\"
+.Sh DIAGNOSTICS
+.Fn inet6_rthdr_space
+returns 0 on errors.
+.Pp
+.Fn inet6_rthdr_add ,
+.Fn inet6_rthdr_lasthop
+and
+.Fn inet6_rthdr_reverse
+return 0 on success, and returns -1 on error.
+.Pp
+.Fn inet6_rthdr_init
+and
+.Fn inet6_rthdr_getaddr
+return
+.Dv NULL
+on error.
+.Pp
+.Fn inet6_rthdr_segments
+and
+.Fn inet6_rthdr_getflags
+return -1 on error.
+.\"
+.Sh EXAMPLES
+RFC2292 gives comprehensive examples in chapter 8.
+.\"
+.Sh SEE ALSO
+.Rs
+.%A W. Stevens
+.%A M. Thomas
+.%T "Advanced Sockets API for IPv6"
+.%N RFC2292
+.%D February 1998
+.Re
+.Rs
+.%A S. Deering
+.%A R. Hinden
+.%T "Internet Protocol, Version 6 (IPv6) Specification"
+.%N RFC2460
+.%D December 1998
+.Re
+.\"
+.Sh HISTORY
+The implementation first appeared in KAME advanced networking kit.
+.\"
+.Sh STANDARDS
+The functions
+are documented in
+.Dq Advanced Sockets API for IPv6
+.Pq RFC2292 .
+.\"
+.Sh BUGS
+The text was shamelessly copied from RFC2292.
+.Pp
+.Fn inet6_rthdr_reverse
+is not implemented yet.
diff --git a/src/lib/libc/net/inet_addr.c b/src/lib/libc/net/inet_addr.c
index b5b9d8302f..6203ccdaac 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.6 1999/05/03 22:31:14 yanick 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -31,16 +33,38 @@
  * LIABILITY, OR TORT (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";
+static char rcsid[] = "$From: inet_addr.c,v 8.5 1996/08/05 08:31:35 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: inet_addr.c,v 1.5 1995/02/25 06:20:41 cgd Exp $";
+static char rcsid[] = "$OpenBSD: inet_addr.c,v 1.6 1999/05/03 22:31:14 yanick 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,7 +74,7 @@ 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
+in_addr_t
 inet_addr(cp)
         register const char *cp;
 {
@@ -73,56 +97,58 @@ inet_aton(cp, addr)
         register const char *cp;
         struct in_addr *addr;
 {
-        register u_long val;
+        register in_addr_t val;
         register int base, n;
         register char c;
         u_int parts[4];
         register 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 +157,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..6aed18699b 100644
--- a/src/lib/libc/net/inet_lnaof.c
+++ b/src/lib/libc/net/inet_lnaof.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: inet_lnaof.c,v 1.4 1995/02/25 06:20:42 cgd Exp $       */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: inet_lnaof.c,v 1.3 1997/04/05 21:13:11 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -50,11 +44,11 @@ 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
+in_addr_t
 inet_lnaof(in)
         struct in_addr in;
 {
-        register u_long i = ntohl(in.s_addr);
+        register 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..196a589e4c 100644
--- a/src/lib/libc/net/inet_makeaddr.c
+++ b/src/lib/libc/net/inet_makeaddr.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: inet_makeaddr.c,v 1.4 1995/02/25 06:20:42 cgd Exp $    */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: inet_makeaddr.c,v 1.3 1997/04/05 21:13:12 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -51,9 +45,9 @@ static char rcsid[] = "$NetBSD: inet_makeaddr.c,v 1.4 1995/02/25 06:20:42 cgd Ex
  */
 struct in_addr
 inet_makeaddr(net, host)
-        u_long net, host;
+        in_addr_t net, 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..c14fa52e38
--- /dev/null
+++ b/src/lib/libc/net/inet_net.3
@@ -0,0 +1,181 @@
+.\"     $OpenBSD: inet_net.3,v 1.10 2003/05/01 19:17:37 jmc Exp $
+.\"     $NetBSD: inet_net.3,v 1.1 1997/06/18 02:25:27 lukem Exp $
+.\"
+.\" Copyright (c) 1997 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to The NetBSD Foundation
+.\" by Luke Mewburn.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"        This product includes software developed by the NetBSD
+.\"        Foundation, Inc. and its contributors.
+.\" 4. Neither the name of The NetBSD Foundation nor the names of its
+.\"    contributors may be used to endorse or promote products derived
+.\"    from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+.\" ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+.\" TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+.\" PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+.\" LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+.\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+.\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+.\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+.\" POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd June 18, 1997
+.Dt INET_NET 3
+.Os
+.Sh NAME
+.Nm inet_net_ntop ,
+.Nm inet_net_pton
+.Nd Internet network number manipulation routines
+.Sh SYNOPSIS
+.Fd #include <sys/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:
+.Bl -tag -width 10.1.2.3/24
+.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 suplied
+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 an internet 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..18eea6bb6d
--- /dev/null
+++ b/src/lib/libc/net/inet_net_ntop.c
@@ -0,0 +1,153 @@
+/*      $OpenBSD: inet_net_ntop.c,v 1.3 2002/08/19 03:01:54 itojun 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static const char rcsid[] = "$From: inet_net_ntop.c,v 8.2 1996/08/08 06:54:44 vixie Exp $";
+#else
+static const char rcsid[] = "$OpenBSD: inet_net_ntop.c,v 1.3 2002/08/19 03:01:54 itojun Exp $";
+#endif
+#endif
+
+#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(af, src, bits, dst, size)
+        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(src, bits, dst, size)
+        const u_char *src;
+        int bits;
+        char *dst;
+        size_t size;
+{
+        char *odst = dst;
+        char *t;
+        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..3c72efac6b
--- /dev/null
+++ b/src/lib/libc/net/inet_net_pton.c
@@ -0,0 +1,206 @@
+/*      $OpenBSD: inet_net_pton.c,v 1.3 2003/04/25 19:40:25 henning 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static const char rcsid[] = "$From: inet_net_pton.c,v 8.3 1996/11/11 06:36:52 vixie Exp $";
+#else
+static const char rcsid[] = "$OpenBSD: inet_net_pton.c,v 1.3 2003/04/25 19:40:25 henning Exp $";
+#endif
+#endif
+
+#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(af, src, dst, size)
+        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(src, dst, size)
+        const char *src;
+        u_char *dst;
+        size_t size;
+{
+        static const char
+                xdigits[] = "0123456789abcdef",
+                digits[] = "0123456789";
+        int n, ch, tmp, dirty, bits;
+        const u_char *odst = dst;
+
+        ch = *src++;
+        if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
+            && isascii(src[1]) && isxdigit(src[1])) {
+                /* Hexadecimal: Eat nybble string. */
+                if (size <= 0)
+                        goto emsgsize;
+                *dst = 0, dirty = 0;
+                src++;  /* skip x or X. */
+                while ((ch = *src++) != '\0' &&
+                       isascii(ch) && isxdigit(ch)) {
+                        if (isupper(ch))
+                                ch = tolower(ch);
+                        n = strchr(xdigits, ch) - xdigits;
+                        assert(n >= 0 && n <= 15);
+                        *dst |= n;
+                        if (!dirty++)
+                                *dst <<= 4;
+                        else if (size-- > 0)
+                                *++dst = 0, dirty = 0;
+                        else
+                                goto emsgsize;
+                }
+                if (dirty)
+                        size--;
+        } else if (isascii(ch) && isdigit(ch)) {
+                /* Decimal: eat dotted digit string. */
+                for (;;) {
+                        tmp = 0;
+                        do {
+                                n = strchr(digits, ch) - digits;
+                                assert(n >= 0 && n <= 9);
+                                tmp *= 10;
+                                tmp += n;
+                                if (tmp > 255)
+                                        goto enoent;
+                        } while ((ch = *src++) != '\0' &&
+                                 isascii(ch) && isdigit(ch));
+                        if (size-- <= 0)
+                                goto emsgsize;
+                        *dst++ = (u_char) tmp;
+                        if (ch == '\0' || ch == '/')
+                                break;
+                        if (ch != '.')
+                                goto enoent;
+                        ch = *src++;
+                        if (!isascii(ch) || !isdigit(ch))
+                                goto enoent;
+                }
+        } else
+                goto enoent;
+
+        bits = -1;
+        if (ch == '/' && isascii(src[0]) && isdigit(src[0]) && dst > odst) {
+                /* CIDR width specifier.  Nothing can follow it. */
+                ch = *src++;    /* Skip over the /. */
+                bits = 0;
+                do {
+                        n = strchr(digits, ch) - digits;
+                        assert(n >= 0 && n <= 9);
+                        bits *= 10;
+                        bits += n;
+                } while ((ch = *src++) != '\0' &&
+                         isascii(ch) && isdigit(ch));
+                if (ch != '\0')
+                        goto enoent;
+                if (bits > 32)
+                        goto emsgsize;
+        }
+
+        /* Firey death and destruction unless we prefetched EOS. */
+        if (ch != '\0')
+                goto enoent;
+
+        /* If nothing was written to the destination, we found no address. */
+        if (dst == odst)
+                goto enoent;
+        /* If no CIDR spec was given, infer width from net class. */
+        if (bits == -1) {
+                if (*odst >= 240)       /* Class E */
+                        bits = 32;
+                else if (*odst >= 224)  /* Class D */
+                        bits = 4;
+                else if (*odst >= 192)  /* Class C */
+                        bits = 24;
+                else if (*odst >= 128)  /* Class B */
+                        bits = 16;
+                else                    /* Class A */
+                        bits = 8;
+                /* If imputed mask is narrower than specified octets, widen. */
+                if (bits < ((dst - odst) * 8))
+                        bits = (dst - odst) * 8;
+        }
+        /* Extend network to cover the actual mask. */
+        while (bits > ((dst - odst) * 8)) {
+                if (size-- <= 0)
+                        goto emsgsize;
+                *dst++ = '\0';
+        }
+        return (bits);
+
+ enoent:
+        errno = ENOENT;
+        return (-1);
+
+ emsgsize:
+        errno = EMSGSIZE;
+        return (-1);
+}
diff --git a/src/lib/libc/net/inet_neta.c b/src/lib/libc/net/inet_neta.c
new file mode 100644
index 0000000000..6960bcd0b5
--- /dev/null
+++ b/src/lib/libc/net/inet_neta.c
@@ -0,0 +1,91 @@
+/*      $OpenBSD: inet_neta.c,v 1.4 2002/08/19 03:01:54 itojun 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static const char rcsid[] = "$Id: inet_neta.c,v 1.4 2002/08/19 03:01:54 itojun Exp $";
+#else
+static const char rcsid[] = "$OpenBSD: inet_neta.c,v 1.4 2002/08/19 03:01:54 itojun Exp $";
+#endif
+#endif
+
+#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(src, dst, size)
+        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..f3b9c01697 100644
--- a/src/lib/libc/net/inet_netof.c
+++ b/src/lib/libc/net/inet_netof.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: inet_netof.c,v 1.4 1995/02/25 06:20:43 cgd Exp $       */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: inet_netof.c,v 1.3 1997/04/05 21:13:13 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -49,11 +43,11 @@ 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
+in_addr_t
 inet_netof(in)
         struct in_addr in;
 {
-        register u_long i = ntohl(in.s_addr);
+        register 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..8a9a555d62 100644
--- a/src/lib/libc/net/inet_network.c
+++ b/src/lib/libc/net/inet_network.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: inet_network.c,v 1.4 1995/02/25 06:20:45 cgd Exp $     */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: inet_network.c,v 1.7 1997/07/09 01:08:37 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -51,13 +45,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
+in_addr_t
 inet_network(cp)
         register const char *cp;
 {
-        register u_long val, base, n;
+        register in_addr_t val, base, n;
         register char c;
-        u_long parts[4], *pp = parts;
+        in_addr_t parts[4], *pp = parts;
         register int i;
 
 again:
@@ -66,7 +60,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 +74,7 @@ again:
                 break;
         }
         if (*cp == '.') {
-                if (pp >= parts + 4)
+                if (pp >= parts + 3)
                         return (INADDR_NONE);
                 *pp++ = val, cp++;
                 goto again;
@@ -89,11 +83,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..377184f366 100644
--- a/src/lib/libc/net/inet_ntoa.c
+++ b/src/lib/libc/net/inet_ntoa.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: inet_ntoa.c,v 1.4 1995/02/25 06:20:46 cgd Exp $        */
-
 /*
  * Copyright (c) 1983, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: inet_ntoa.c,v 1.3 2002/06/27 10:14:01 itojun Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 /*
@@ -60,6 +54,6 @@ inet_ntoa(in)
         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..adce61c1d4
--- /dev/null
+++ b/src/lib/libc/net/inet_ntop.c
@@ -0,0 +1,213 @@
+/*      $OpenBSD: inet_ntop.c,v 1.5 2002/08/23 16:27:31 itojun 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char rcsid[] = "$From: inet_ntop.c,v 8.7 1996/08/05 08:41:18 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: inet_ntop.c,v 1.5 2002/08/23 16:27:31 itojun 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 <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(af, src, dst, size)
+        int af;
+        const void *src;
+        char *dst;
+        size_t size;
+{
+        switch (af) {
+        case AF_INET:
+                return (inet_ntop4(src, dst, size));
+        case AF_INET6:
+                return (inet_ntop6(src, dst, size));
+        default:
+                errno = EAFNOSUPPORT;
+                return (NULL);
+        }
+        /* NOTREACHED */
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *      format an IPv4 address, more or less like inet_ntoa()
+ * return:
+ *      `dst' (as a const)
+ * notes:
+ *      (1) uses no statics
+ *      (2) takes a u_char* not an in_addr as input
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(src, dst, size)
+        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(src, dst, size)
+        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..b04ef05c31
--- /dev/null
+++ b/src/lib/libc/net/inet_pton.c
@@ -0,0 +1,222 @@
+/*      $OpenBSD: inet_pton.c,v 1.4 2002/02/16 21:27:23 millert 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char rcsid[] = "$From: inet_pton.c,v 8.7 1996/08/05 08:31:35 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: inet_pton.c,v 1.4 2002/02/16 21:27:23 millert 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 <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(af, src, dst)
+        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(src, dst)
+        const char *src;
+        u_char *dst;
+{
+        static const char digits[] = "0123456789";
+        int saw_digit, octets, ch;
+        u_char tmp[INADDRSZ], *tp;
+
+        saw_digit = 0;
+        octets = 0;
+        *(tp = tmp) = 0;
+        while ((ch = *src++) != '\0') {
+                const char *pch;
+
+                if ((pch = strchr(digits, ch)) != NULL) {
+                        u_int new = *tp * 10 + (pch - digits);
+
+                        if (new > 255)
+                                return (0);
+                        if (! saw_digit) {
+                                if (++octets > 4)
+                                        return (0);
+                                saw_digit = 1;
+                        }
+                        *tp = new;
+                } else if (ch == '.' && saw_digit) {
+                        if (octets == 4)
+                                return (0);
+                        *++tp = 0;
+                        saw_digit = 0;
+                } else
+                        return (0);
+        }
+        if (octets < 4)
+                return (0);
+
+        memcpy(dst, tmp, INADDRSZ);
+        return (1);
+}
+
+/* int
+ * inet_pton6(src, dst)
+ *      convert presentation level address to network order binary form.
+ * return:
+ *      1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *      (1) does not touch `dst' unless it's returning 1.
+ *      (2) :: in a full address is silently ignored.
+ * credit:
+ *      inspired by Mark Andrews.
+ * author:
+ *      Paul Vixie, 1996.
+ */
+static int
+inet_pton6(src, dst)
+        const char *src;
+        u_char *dst;
+{
+        static const char xdigits_l[] = "0123456789abcdef",
+                          xdigits_u[] = "0123456789ABCDEF";
+        u_char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
+        const char *xdigits, *curtok;
+        int ch, saw_xdigit;
+        u_int val;
+
+        memset((tp = tmp), '\0', IN6ADDRSZ);
+        endp = tp + IN6ADDRSZ;
+        colonp = NULL;
+        /* Leading :: requires some special handling. */
+        if (*src == ':')
+                if (*++src != ':')
+                        return (0);
+        curtok = src;
+        saw_xdigit = 0;
+        val = 0;
+        while ((ch = *src++) != '\0') {
+                const char *pch;
+
+                if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+                        pch = strchr((xdigits = xdigits_u), ch);
+                if (pch != NULL) {
+                        val <<= 4;
+                        val |= (pch - xdigits);
+                        if (val > 0xffff)
+                                return (0);
+                        saw_xdigit = 1;
+                        continue;
+                }
+                if (ch == ':') {
+                        curtok = src;
+                        if (!saw_xdigit) {
+                                if (colonp)
+                                        return (0);
+                                colonp = tp;
+                                continue;
+                        } else if (*src == '\0') {
+                                return (0);
+                        }
+                        if (tp + INT16SZ > endp)
+                                return (0);
+                        *tp++ = (u_char) (val >> 8) & 0xff;
+                        *tp++ = (u_char) val & 0xff;
+                        saw_xdigit = 0;
+                        val = 0;
+                        continue;
+                }
+                if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
+                    inet_pton4(curtok, tp) > 0) {
+                        tp += INADDRSZ;
+                        saw_xdigit = 0;
+                        break;  /* '\0' was seen by inet_pton4(). */
+                }
+                return (0);
+        }
+        if (saw_xdigit) {
+                if (tp + INT16SZ > endp)
+                        return (0);
+                *tp++ = (u_char) (val >> 8) & 0xff;
+                *tp++ = (u_char) val & 0xff;
+        }
+        if (colonp != NULL) {
+                /*
+                 * Since some memmove()'s erroneously fail to handle
+                 * overlapping regions, we'll do the shift by hand.
+                 */
+                const int n = tp - colonp;
+                int i;
+
+                for (i = 1; i <= n; i++) {
+                        endp[- i] = colonp[n - i];
+                        colonp[n - i] = 0;
+                }
+                tp = endp;
+        }
+        if (tp != endp)
+                return (0);
+        memcpy(dst, tmp, IN6ADDRSZ);
+        return (1);
+}
diff --git a/src/lib/libc/net/ip6opt.c b/src/lib/libc/net/ip6opt.c
new file mode 100644
index 0000000000..cbd49f0c22
--- /dev/null
+++ b/src/lib/libc/net/ip6opt.c
@@ -0,0 +1,388 @@
+/*      $OpenBSD: ip6opt.c,v 1.1 1999/12/11 08:09:11 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.
+ */
+
+#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(nbytes)
+        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(bp, cmsgp, type)
+        void *bp;
+        struct cmsghdr **cmsgp;
+        int type;
+{
+        register 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(cmsg, typep, multx, plusy)
+        struct cmsghdr *cmsg;
+        const u_int8_t *typep;
+        int multx;
+        int plusy;
+{
+        int padlen, optlen, off;
+        register u_char *bp = (u_char *)cmsg + cmsg->cmsg_len;
+        struct ip6_ext *eh = (struct ip6_ext *)CMSG_DATA(cmsg);
+
+        /* argument validation */
+        if (multx != 1 && multx != 2 && multx != 4 && multx != 8)
+                return(-1);
+        if (plusy < 0 || plusy > 7)
+                return(-1);
+        if (typep[0] > 255)
+                return(-1);
+
+        /*
+         * If this is the first option, allocate space for the
+         * first 2 bytes(for next header and length fields) of
+         * the option header.
+         */
+        if (bp == (u_char *)eh) {
+                bp += 2;
+                cmsg->cmsg_len += 2;
+        }
+
+        /* calculate pad length before the option. */
+        off = bp - (u_char *)eh;
+        padlen = (((off % multx) + (multx - 1)) & ~(multx - 1)) -
+                (off % multx);
+        padlen += plusy;
+        padlen %= multx;        /* keep the pad as short as possible */
+        /* insert padding */
+        inet6_insert_padopt(bp, padlen);
+        cmsg->cmsg_len += padlen;
+        bp += padlen;
+
+        /* copy the option */
+        if (typep[0] == IP6OPT_PAD1)
+                optlen = 1;
+        else
+                optlen = typep[1] + 2;
+        memcpy(bp, typep, optlen);
+        bp += optlen;
+        cmsg->cmsg_len += optlen;
+
+        /* calculate pad length after the option and insert the padding */
+        off = bp - (u_char *)eh;
+        padlen = ((off + 7) & ~7) - off;
+        inet6_insert_padopt(bp, padlen);
+        bp += padlen;
+        cmsg->cmsg_len += padlen;
+
+        /* update the length field of the ip6 option header */
+        eh->ip6e_len = ((bp - (u_char *)eh) >> 3) - 1;
+
+        return(0);
+}
+
+/*
+ * This function appends a Hop-by-Hop option or a Destination option
+ * into an ancillary data object that has been initialized by
+ * inet6_option_init().  This function returns a pointer to the 8-bit
+ * option type field that starts the option on success, or NULL on an
+ * error.
+ * The difference between this function and inet6_option_append() is
+ * that the latter copies the contents of a previously built option into
+ * the ancillary data object while the current function returns a
+ * pointer to the space in the data object where the option's TLV must
+ * then be built by the caller.
+ * 
+ */
+u_int8_t *
+inet6_option_alloc(cmsg, datalen, multx, plusy)
+        struct cmsghdr *cmsg;
+        int datalen;
+        int multx;
+        int plusy;
+{
+        int padlen, off;
+        register 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(cmsg, tptrp)
+        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(cmsg, tptrp, type)
+        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(opt, lim)
+        u_int8_t *opt, *lim;
+{
+        int optlen;
+
+        if (*opt == IP6OPT_PAD1)
+                optlen = 1;
+        else {
+                /* is there enough space to store type and len? */
+                if (opt + 2 > lim)
+                        return(0);
+                optlen = *(opt + 1) + 2;
+        }
+        if (opt + optlen <= lim)
+                return(optlen);
+
+        return(0);
+}
+
+static void
+inet6_insert_padopt(u_char *p, int len)
+{
+        switch(len) {
+         case 0:
+                 return;
+         case 1:
+                 p[0] = IP6OPT_PAD1;
+                 return;
+         default:
+                 p[0] = IP6OPT_PADN;
+                 p[1] = len - 2; 
+                 memset(&p[2], 0, len - 2);
+                 return;
+        }
+}
diff --git a/src/lib/libc/net/ipx.3 b/src/lib/libc/net/ipx.3
new file mode 100644
index 0000000000..670f174d8b
--- /dev/null
+++ b/src/lib/libc/net/ipx.3
@@ -0,0 +1,127 @@
+.\"     $OpenBSD: ipx.3,v 1.9 2003/05/01 19:17:37 jmc Exp $
+.\"
+.\" Copyright (c) 1986, 1991, 1993
+.\"     The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. 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.
+.\"
+.Dd June 4, 1993
+.Dt IPX 3
+.Os
+.Sh NAME
+.Nm ipx_addr ,
+.Nm ipx_ntoa
+.Nd IPX address conversion routines
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <netipx/ipx.h>
+.Ft struct ipx_addr
+.Fn ipx_addr "const char *cp"
+.Ft char *
+.Fn ipx_ntoa "struct ipx_addr ipx"
+.Sh DESCRIPTION
+The routine
+.Fn ipx_addr
+interprets character strings representing
+.Tn IPX
+addresses, returning binary information suitable
+for use in system calls.
+The routine
+.Fn ipx_ntoa
+takes
+.Tn IPX
+addresses and returns
+.Tn ASCII
+strings representing the address in a
+notation in common use:
+.Bd -filled -offset indent
+<network number>.<host number>.<port number>
+.Ed
+.Pp
+Trailing zero fields are suppressed, and each number is printed in hexadecimal,
+in a format suitable for input to
+.Fn ipx_addr .
+Any fields lacking super-decimal digits will have a
+trailing
+.Sq H
+appended.
+.Pp
+An effort has been made to ensure that
+.Fn ipx_addr
+be compatible with most formats in common use.
+It will first separate an address into 1 to 3 fields using a single delimiter
+chosen from
+period
+.Pq Ql \&. ,
+colon
+.Pq Ql \&: ,
+or pound-sign
+.Pq Ql # .
+Each field is then examined for byte separators (colon or period).
+If there are byte separators, each subfield separated is taken to be
+a small hexadecimal number, and the entirety is taken as a network-byte-ordered
+quantity to be zero extended in the high-network-order bytes.
+Next, the field is inspected for hyphens, in which case
+the field is assumed to be a number in decimal notation
+with hyphens separating the millenia.
+Next, the field is assumed to be a number:
+It is interpreted
+as hexadecimal if there is a leading
+.Ql 0x
+(as in C),
+a trailing
+.Sq H
+(as in Mesa), or there are any super-decimal digits present.
+It is interpreted as octal if there is a leading
+.Ql 0
+and there are no super-octal digits.
+Otherwise, it is converted as a decimal number.
+.Sh RETURN VALUES
+None.
+(See
+.Sx BUGS . )
+.Sh SEE ALSO
+.Xr ns 4 ,
+.Xr hosts 5 ,
+.Xr networks 5
+.Sh HISTORY
+The precursor
+.Fn ns_addr
+and
+.Fn ns_ntoa
+functions appeared in
+.Bx 4.3 .
+.Sh BUGS
+The string returned by
+.Fn ipx_ntoa
+resides in a static memory area.
+The function
+.Fn ipx_addr
+should diagnose improperly formed input, and there should be an unambiguous
+way to recognize this.
diff --git a/src/lib/libc/net/ipx_addr.c b/src/lib/libc/net/ipx_addr.c
new file mode 100644
index 0000000000..0d225e281b
--- /dev/null
+++ b/src/lib/libc/net/ipx_addr.c
@@ -0,0 +1,228 @@
+/*
+ * 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.
+ *
+ * from @(#)ipx_addr.c
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: ipx_addr.c,v 1.5 2001/06/27 00:58:55 lebel Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <netipx/ipx.h>
+#include <stdio.h>
+#include <string.h>
+
+static struct ipx_addr addr, zero_addr;
+
+static void Field(), cvtbase();
+
+struct ipx_addr 
+ipx_addr(name)
+        const char *name;
+{
+        char separator;
+        char *hostname, *socketname, *cp;
+        char buf[50];
+
+        strlcpy(buf, name, sizeof(buf));
+
+        /*
+         * First, figure out what he intends as a field separtor.
+         * Despite the way this routine is written, the prefered
+         * form  2-272.AA001234H.01777, i.e. XDE standard.
+         * Great efforts are made to insure backward compatibility.
+         */
+        if ((hostname = strchr(buf, '#')))
+                separator = '#';
+        else {
+                hostname = strchr(buf, '.');
+                if ((cp = strchr(buf, ':')) &&
+                    ((hostname && cp < hostname) || (hostname == 0))) {
+                        hostname = cp;
+                        separator = ':';
+                } else
+                        separator = '.';
+        }
+        if (hostname)
+                *hostname++ = 0;
+
+        addr = zero_addr;
+        Field(buf, addr.ipx_net.c_net, 4);
+        if (hostname == 0)
+                return (addr);  /* No separator means net only */
+
+        socketname = strchr(hostname, separator);
+        if (socketname) {
+                *socketname++ = 0;
+                Field(socketname, (u_char *)&addr.ipx_port, 2);
+        }
+
+        Field(hostname, addr.ipx_host.c_host, 6);
+
+        return (addr);
+}
+
+static void
+Field(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/ipx_ntoa.c b/src/lib/libc/net/ipx_ntoa.c
new file mode 100644
index 0000000000..598c94d599
--- /dev/null
+++ b/src/lib/libc/net/ipx_ntoa.c
@@ -0,0 +1,58 @@
+/*
+ * 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)
+static char rcsid[] = "$OpenBSD: ipx_ntoa.c,v 1.3 2002/05/24 21:22:37 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <netipx/ipx.h>
+#include <stdio.h>
+
+char *
+ipx_ntoa(addr)
+        struct ipx_addr addr;
+{
+        static char obuf[] = "xxxx.xx:xx:xx:xx:xx:xx.uuuuu";
+
+        snprintf(obuf, sizeof obuf, "%8xH.%02x:%02x:%02x:%02x:%02x:%02x.%u",
+                ntohl(addr.ipx_net.l_net),
+                addr.ipx_host.c_host[0],
+                addr.ipx_host.c_host[1],
+                addr.ipx_host.c_host[2],
+                addr.ipx_host.c_host[3],
+                addr.ipx_host.c_host[4],
+                addr.ipx_host.c_host[5],
+                ntohs(addr.ipx_port));
+        return (obuf);
+}
diff --git a/src/lib/libc/net/iso_addr.3 b/src/lib/libc/net/iso_addr.3
index 95c136e5fc..8655a63973 100644
--- a/src/lib/libc/net/iso_addr.3
+++ b/src/lib/libc/net/iso_addr.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: iso_addr.3,v 1.2 1995/02/25 06:20:46 cgd Exp $
+.\"     $OpenBSD: iso_addr.3,v 1.4 1999/07/05 06:08:05 aaron Exp $
 .\"
 .\" Copyright (c) 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,15 +31,13 @@
 .\" 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
+.Nd "network address conversion routines for Open System Interconnection"
 .Sh SYNOPSIS
 .Fd #include <sys/types.h>
 .Fd #include <netiso/iso.h>
@@ -62,7 +60,7 @@ addresses and returns
 .Tn ASCII
 strings representing NSAPs (network service
 access points) in a
-notation inverse to that accepted by 
+notation inverse to that accepted by
 .Fn iso_addr .
 .Pp
 Unfortunately, no universal standard exists for representing
@@ -90,7 +88,8 @@ to have its higher order bits filled with zeros.
 .Fn iso_ntoa
 always returns a null terminated string.
 .Fn iso_addr
-always returns a pointer to a struct iso_addr.
+always returns a pointer to a
+.Li struct iso_addr .
 (See
 .Sx BUGS . )
 .Sh SEE ALSO
@@ -100,7 +99,7 @@ The
 .Fn iso_addr
 and
 .Fn iso_ntoa
-functions appeared in 
+functions appeared in
 .Bx 4.3 Reno .
 .Sh BUGS
 The returned values
diff --git a/src/lib/libc/net/iso_addr.c b/src/lib/libc/net/iso_addr.c
index c26ec1a64a..01561e395b 100644
--- a/src/lib/libc/net/iso_addr.c
+++ b/src/lib/libc/net/iso_addr.c
@@ -1,5 +1,3 @@
-/*      $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.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: iso_addr.c,v 1.2 1996/08/19 08:29:23 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
diff --git a/src/lib/libc/net/linkaddr.3 b/src/lib/libc/net/link_addr.3
index 1a2af9b30d..29c2449f77 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.7 2000/04/18 03:01:32 aaron Exp $
 .\"
 .\" Copyright (c) 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -34,11 +34,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
 .Dt LINK_ADDR 3
-.Os BSD 4.4
+.Os
 .Sh NAME
 .Nm link_addr ,
 .Nm link_ntoa
@@ -52,12 +50,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 +72,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,24 +90,25 @@ 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 null-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
 reside in a static memory area.
@@ -121,7 +119,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..fb522f3233 100644
--- a/src/lib/libc/net/linkaddr.c
+++ b/src/lib/libc/net/linkaddr.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: linkaddr.c,v 1.5 1995/02/25 06:20:49 cgd Exp $ */
-
 /*-
  * Copyright (c) 1990, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: linkaddr.c,v 1.2 1996/08/19 08:29:27 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
diff --git a/src/lib/libc/net/net_addrcmp.3 b/src/lib/libc/net/net_addrcmp.3
new file mode 100644
index 0000000000..f1ce4c8cd1
--- /dev/null
+++ b/src/lib/libc/net/net_addrcmp.3
@@ -0,0 +1,91 @@
+.\"     $OpenBSD: net_addrcmp.3,v 1.3 2001/08/07 06:53:27 deraadt Exp $
+.\"
+.\" Copyright (c) 1999 Theo de Raadt
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd July 3, 1999
+.Dt NET_ADDRCMP 3
+.Os
+.Sh NAME
+.Nm net_addrcmp
+.Nd compare socket address structures
+.Sh SYNOPSIS
+.Fd #include <netdb.h>
+.Ft int
+.Fn net_addrcmp "struct sockaddr *sa1" "struct sockaddr *sa2"
+.Sh DESCRIPTION
+The
+.Fn net_addrcmp
+function compares two socket address structures,
+.Fa sa1
+and
+.Fa sa2 .
+.Sh RETURN VALUES
+If
+.Fa sa1
+and
+.Fa sa2
+are for the same address,
+.Fn net_addrcmp
+returns 0.
+.Pp
+The
+.Fa sa_len
+fields are compared first.
+If they do not match,
+.Fn net_addrcmp
+returns \-1 or 1 if
+.Li sa1->sa_len
+is less than or greater than
+.Li sa2->sa_len ,
+respectively.
+.Pp
+Next, the
+.Fa sa_family
+members are compared.
+If they do not match,
+.Fn net_addrcmp
+returns \-1 or 1 if
+.Li sa1->sa_family
+is less than or greater than
+.Li sa2->sa_family ,
+respectively.
+.Pp
+Lastly, if each socket address structure's
+.Fa sa_len
+and
+.Fa sa_family
+fields match,
+the protocol-specific data (the
+.Fa sa_data
+field) is compared.
+If there's a match, both
+.Fa sa1
+and
+.Fa sa2
+must refer to the same address, and 0 is returned; otherwise, a value >0
+or <0 is returned.
+.Sh HISTORY
+A
+.Fn net_addrcmp
+function was added in
+.Ox 2.5 .
diff --git a/src/lib/libc/net/net_addrcmp.c b/src/lib/libc/net/net_addrcmp.c
new file mode 100644
index 0000000000..c77a2fda48
--- /dev/null
+++ b/src/lib/libc/net/net_addrcmp.c
@@ -0,0 +1,68 @@
+/*
+ * 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 <netns/ns.h>
+#include <string.h>
+
+int
+net_addrcmp(sa1, sa2)
+        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_NS:
+                return (memcmp(&((struct sockaddr_ns *)sa1)->sns_addr,
+                    &((struct sockaddr_ns *)sa2)->sns_addr,
+                    sizeof(struct ns_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
index f89b4fe042..883b079db2 100644
--- a/src/lib/libc/net/ns.3
+++ b/src/lib/libc/net/ns.3
@@ -1,4 +1,4 @@
-.\"     $NetBSD: ns.3,v 1.3 1995/02/25 06:20:50 cgd Exp $
+.\"     $OpenBSD: ns.3,v 1.8 2003/05/01 19:17:37 jmc Exp $
 .\"
 .\" Copyright (c) 1986, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,11 +31,9 @@
 .\" 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
+.Os
 .Sh NAME
 .Nm ns_addr ,
 .Nm ns_ntoa
@@ -45,7 +43,7 @@ address conversion routines
 .Sh SYNOPSIS
 .Fd #include <sys/types.h>
 .Fd #include <netns/ns.h>
-.Ft struct ns_addr 
+.Ft struct ns_addr
 .Fn ns_addr "char *cp"
 .Ft char *
 .Fn ns_ntoa "struct ns_addr ns"
@@ -69,27 +67,27 @@ notation in common use in the Xerox Development Environment:
 .Ed
 .Pp
 Trailing zero fields are suppressed, and each number is printed in hexadecimal,
-in a format suitable for input to 
+in a format suitable for input to
 .Fn ns_addr .
 Any fields lacking super-decimal digits will have a
 trailing
-.Ql H
+.Sq H
 appended.
 .Pp
 Unfortunately, no universal standard exists for representing
 .Tn XNS
 addresses.
-An effort has been made to insure that
+An effort has been made to ensure 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 \&. ,
+.Pq Ql \&. ,
 colon
-.Ql \&:
+.Pq Ql \&: ,
 or pound-sign
-.Ql \&# .
+.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
@@ -103,24 +101,25 @@ as hexadecimal if there is a leading
 .Ql 0x
 (as in C),
 a trailing
-.Ql H
+.Sq H
 (as in Mesa), or there are any super-decimal digits present.
-It is interpreted as octal is there is a leading
+It is interpreted as octal if there is a leading
 .Ql 0
 and there are no super-octal digits.
 Otherwise, it is converted as a decimal number.
 .Sh RETURN VALUES
-None. (See
+None.
+(See
 .Sx BUGS . )
 .Sh SEE ALSO
 .Xr hosts 5 ,
-.Xr networks 5 ,
+.Xr networks 5
 .Sh HISTORY
 The
 .Fn ns_addr
 and
 .Fn ns_toa
-functions appeared in 
+functions appeared in
 .Bx 4.3 .
 .Sh BUGS
 The string returned by
diff --git a/src/lib/libc/net/ns_addr.c b/src/lib/libc/net/ns_addr.c
index f75ddb23b7..0d1b45858f 100644
--- a/src/lib/libc/net/ns_addr.c
+++ b/src/lib/libc/net/ns_addr.c
@@ -1,5 +1,3 @@
-/*      $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.
@@ -37,11 +35,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: ns_addr.c,v 1.7 2002/02/16 21:27:23 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -51,7 +45,8 @@ static char rcsid[] = "$NetBSD: ns_addr.c,v 1.5 1995/02/25 06:20:51 cgd Exp $";
 
 static struct ns_addr addr, zero_addr;
 
-static void Field(), cvtbase();
+static void Field(char *, u_int8_t *, int);
+static void cvtbase(long, int, int[], int, u_int8_t[], int);
 
 struct ns_addr 
 ns_addr(name)
@@ -61,16 +56,15 @@ ns_addr(name)
         char *hostname, *socketname, *cp;
         char buf[50];
 
-        (void)strncpy(buf, name, sizeof(buf) - 1);
-        buf[sizeof(buf) - 1] = '\0';
+        strlcpy(buf, name, sizeof(buf));
 
         /*
          * First, figure out what he intends as a field separtor.
          * Despite the way this routine is written, the prefered
          * form  2-272.AA001234H.01777, i.e. XDE standard.
-         * Great efforts are made to insure backward compatability.
+         * Great efforts are made to insure backward compatibility.
          */
-        if (hostname = strchr(buf, '#'))
+        if ((hostname = strchr(buf, '#')))
                 separator = '#';
         else {
                 hostname = strchr(buf, '.');
@@ -95,7 +89,7 @@ ns_addr(name)
                 Field(socketname, (u_char *)&addr.x_port, 2);
         }
 
-        Field(hostname, addr.x_host.c_host, 6);
+        Field(hostname, (u_char *)addr.x_host.c_host, 6);
 
         return (addr);
 }
diff --git a/src/lib/libc/net/ns_ntoa.c b/src/lib/libc/net/ns_ntoa.c
index ad3265399b..35d4f28aca 100644
--- a/src/lib/libc/net/ns_ntoa.c
+++ b/src/lib/libc/net/ns_ntoa.c
@@ -1,5 +1,3 @@
-/*      $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.
@@ -34,73 +32,79 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: ns_ntoa.c,v 1.11 2003/04/05 00:44:42 tdeval Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
 #include <netns/ns.h>
 #include <stdio.h>
 
+static char *spectHex(char *);
+
 char *
-ns_ntoa(addr)
-        struct ns_addr addr;
+ns_ntoa(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;
+        union { union ns_net net_e; u_int32_t long_e; } net;
+        in_port_t port = htons(addr.x_port);
+        char *cp, *cp2;
+        u_char *up = addr.x_host.c_host;
         u_char *uplim = up + 6;
-        static char *spectHex();
+        size_t rem;
 
         net.net_e = addr.x_net;
-        sprintf(obuf, "%lx", ntohl(net.long_e));
+        snprintf(obuf, sizeof obuf, "%x", ntohl(net.long_e));
         cp = spectHex(obuf);
+        rem = sizeof(obuf) - (cp - obuf);
         cp2 = cp + 1;
-        while (*up==0 && up < uplim) up++;
+        while (*up==0 && up < uplim)
+                up++;
         if (up == uplim) {
                 if (port) {
-                        sprintf(cp, ".0");
+                        snprintf(cp, rem, ".0");
                         cp += 2;
+                        rem -= 2;
                 }
         } else {
-                sprintf(cp, ".%x", *up++);
+                snprintf(cp, rem, ".%x", *up++);
                 while (up < uplim) {
-                        while (*cp) cp++;
-                        sprintf(cp, "%02x", *up++);
+                        while (*cp) {
+                                cp++;
+                                rem--;
+                        }
+                        snprintf(cp, rem, "%02x", *up++);
                 }
                 cp = spectHex(cp2);
+                rem = sizeof(obuf) - (cp - obuf);
         }
         if (port) {
-                sprintf(cp, ".%x", port);
+                snprintf(cp, rem, ".%x", port);
                 spectHex(cp + 1);
         }
         return (obuf);
 }
 
 static char *
-spectHex(p0)
-        char *p0;
+spectHex(char *p0)
 {
-        int ok = 0;
-        int nonzero = 0;
-        register char *p = p0;
-        for (; *p; p++) switch (*p) {
+        int ok = 0, nonzero = 0;
+        char *p = p0;
 
-        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;
+        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;
         }
-        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..22a5f8d66e
--- /dev/null
+++ b/src/lib/libc/net/nsap_addr.c
@@ -0,0 +1,109 @@
+/*      $OpenBSD: nsap_addr.c,v 1.4 1997/07/09 01:08:45 millert 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char rcsid[] = "$From: nsap_addr.c,v 8.3 1996/08/05 08:31:35 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: nsap_addr.c,v 1.4 1997/07/09 01:08:45 millert 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/nameser.h>
+#include <ctype.h>
+#include <resolv.h>
+
+static char
+xtob(c)
+        register int c;
+{
+        return (c - (((c >= '0') && (c <= '9')) ? '0' : '7'));
+}
+
+u_int
+inet_nsap_addr(ascii, binary, maxlen)
+        const char *ascii;
+        u_char *binary;
+        int maxlen;
+{
+        register 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 = toupper(c);
+                if (isxdigit(c)) {
+                        nib = xtob(c);
+                        if ((c = *ascii++)) {
+                                c = 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(binlen, binary, ascii)
+        int binlen;
+        register const u_char *binary;
+        register char *ascii;
+{
+        register 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..7d3e227e60 100644
--- a/src/lib/libc/net/ntohl.c
+++ b/src/lib/libc/net/ntohl.c
@@ -1,29 +1,25 @@
-/*      $NetBSD: ntohl.c,v 1.5 1995/04/28 23:25:21 jtc 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
+static char *rcsid = "$OpenBSD: ntohl.c,v 1.4 1996/12/12 03:19:56 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <machine/endian.h>
 
 #undef ntohl
 
-unsigned long
+u_int32_t
 ntohl(x)
-        unsigned long x;
+        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..4c3ab33f31 100644
--- a/src/lib/libc/net/ntohs.c
+++ b/src/lib/libc/net/ntohs.c
@@ -1,26 +1,23 @@
-/*      $NetBSD: ntohs.c,v 1.5 1995/04/28 23:25:23 jtc 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
+static char *rcsid = "$OpenBSD: ntohs.c,v 1.7 2002/02/19 19:39:36 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
 
 #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..62f370efad 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.25 2002/09/25 17:30:02 deraadt Exp $
 .\"
 .\" Copyright (c) 1983, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,38 +31,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
 .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 +104,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 +121,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 +144,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 +191,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 +203,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 +223,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..1f2e02c989 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.
  *
@@ -16,6 +15,7 @@
  *    must display the following acknowledgement:
  *      This product includes software developed by the University of
  *      California, Berkeley and its contributors.
+ *      This product includes software developed by Theo de Raadt.
  * 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.
@@ -34,11 +34,7 @@
  */
 
 #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
+static char *rcsid = "$OpenBSD: rcmd.c,v 1.45 2002/12/15 13:27:06 henning Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -57,35 +53,90 @@ 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>
+#include <netgroup.h>
 
-int     __ivaliduser __P((FILE *, u_long, const char *, const char *));
-static int __icheckhost __P((u_long, const char *));
+int     __ivaliduser(FILE *, in_addr_t, const char *, const char *);
+int     __ivaliduser_sa(FILE *, struct sockaddr *, socklen_t,
+            const char *, const char *);
+static int __icheckhost(struct sockaddr *, socklen_t, const char *);
+static char *__gethostloop(struct sockaddr *, socklen_t);
 
 int
 rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
         char **ahost;
-        u_short rport;
+        in_port_t rport;
+        const char *locuser, *remuser, *cmd;
+        int *fd2p;
+{
+        return rcmd_af(ahost, rport, locuser, remuser, cmd, fd2p, AF_INET);
+}
+
+int
+rcmd_af(ahost, rport, locuser, remuser, cmd, fd2p, af)
+        char **ahost;
+        in_port_t rport;
         const char *locuser, *remuser, *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;
+
+        /* 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);
+        oldmask = 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 +144,86 @@ 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;
+                        char hbuf[NI_MAXHOST];
+#ifdef NI_WITHSCOPEID
+                        const int niflags = NI_NUMERICHOST | NI_WITHSCOPEID;
+#else
+                        const int niflags = NI_NUMERICHOST;
+#endif
 
-                        (void)fprintf(stderr, "connect to address %s: ",
-                            inet_ntoa(sin.sin_addr));
+                        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;
+                }
+                if (refused && timo <= 16) {
+                        (void)sleep(timo);
+                        timo *= 2;
+                        r = res;
+                        refused = 0;
                         continue;
                 }
-                (void)fprintf(stderr, "%s: %s\n", hp->h_name, strerror(errno));
-                sigsetmask(oldmask);
+                (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)
+                        goto bad;
                 listen(s2, 1);
                 (void)snprintf(num, sizeof(num), "%d", lport);
                 if (write(s, num, strlen(num)+1) != strlen(num)+1) {
@@ -150,12 +233,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,6 +251,23 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                         goto bad;
                 }
                 s3 = accept(s2, (struct sockaddr *)&from, &len);
+                /*
+                 * 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);
                 if (s3 < 0) {
                         (void)fprintf(stderr,
@@ -175,13 +276,20 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
                         goto bad;
                 }
                 *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,47 +308,20 @@ 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);
+        sigprocmask(SIG_SETMASK, &oldmask, NULL);
         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;
 
@@ -249,21 +330,24 @@ 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)
+        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 (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)
+        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);
 }
 
@@ -278,10 +362,28 @@ ruserok(rhost, superuser, ruser, luser)
  */
 int
 iruserok(raddr, superuser, ruser, luser)
-        u_long raddr;
+        u_int32_t raddr;
         int superuser;
         const char *ruser, *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(raddr, rlen, superuser, ruser, luser)
+        const void *raddr;
+        int rlen;
+        int superuser;
+        const char *ruser, *luser;
+{
+        struct sockaddr *sa;
         register char *cp;
         struct stat sbuf;
         struct passwd *pwd;
@@ -290,11 +392,12 @@ iruserok(raddr, superuser, ruser, luser)
         int first;
         char pbuf[MAXPATHLEN];
 
+        sa = (struct sockaddr *)raddr;
         first = 1;
         hostf = superuser ? NULL : fopen(_PATH_HEQUIV, "r");
 again:
         if (hostf) {
-                if (__ivaliduser(hostf, raddr, luser, ruser) == 0) {
+                if (__ivaliduser_sa(hostf, sa, rlen, luser, ruser) == 0) {
                         (void)fclose(hostf);
                         return (0);
                 }
@@ -304,8 +407,7 @@ again:
                 first = 0;
                 if ((pwd = getpwnam(luser)) == NULL)
                         return (-1);
-                (void)strcpy(pbuf, pwd->pw_dir);
-                (void)strcat(pbuf, "/.rhosts");
+                snprintf(pbuf, sizeof pbuf, "%s/.rhosts", pwd->pw_dir);
 
                 /*
                  * Change effective uid while opening .rhosts.  If root and
@@ -333,7 +435,7 @@ again:
                 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";
+                        cp = ".rhosts writable by other than owner";
                 /* If there were any problems, quit. */
                 if (cp) {
                         __rcmd_errstr = cp;
@@ -352,41 +454,63 @@ again:
  * Returns 0 if ok, -1 if not ok.
  */
 int
-__ivaliduser(hostf, raddr, luser, ruser)
+__ivaliduser(hostf, raddrl, luser, ruser)
+        FILE *hostf;
+        in_addr_t raddrl;
+        const char *luser, *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(hostf, raddr, salen, luser, ruser)
         FILE *hostf;
-        u_long raddr;
+        struct sockaddr *raddr;
+        socklen_t salen;
         const char *luser, *ruser;
 {
         register char *user, *p;
-        int ch;
-        char buf[MAXHOSTNAMELEN + 128];         /* host + login */
+        char *buf;
         const char *auser, *ahost;
         int hostok, userok;
-        char rhost[MAXHOSTNAMELEN];
-        struct hostent *hp;
+        char *rhost = (char *)-1;
         char domain[MAXHOSTNAMELEN];
+        size_t buflen;
 
         getdomainname(domain, sizeof(domain));
 
-        while (fgets(buf, sizeof(buf), hostf)) {
+        while ((buf = fgetln(hostf, &buflen))) {
                 p = buf;
-                /* Skip lines that are too long. */
-                if (strchr(p, '\n') == NULL) {
-                        while ((ch = getc(hostf)) != '\n' && ch != EOF);
+                if (*p == '#')
                         continue;
-                }
-                while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0') {
+                while (*p != '\n' && *p != ' ' && *p != '\t' && p < buf + buflen) {
+                        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 == ' ' || *p == '\t')
+                        while ((*p == ' ' || *p == '\t') && p < buf + buflen)
                                 p++;
+                        if (p >= buf + buflen)
+                                continue;
                         user = p;
                         while (*p != '\n' && *p != ' ' &&
-                            *p != '\t' && *p != '\0')
+                            *p != '\t' && p < buf + buflen) {
+                                if (!isprint(*p))
+                                        goto bail;
                                 p++;
+                        }
                 } else
                         user = p;
                 *p = '\0';
@@ -397,27 +521,29 @@ __ivaliduser(hostf, raddr, luser, ruser)
                 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 (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 '@':
-                                hostok = innetgr(&ahost[2], rhost, NULL,
-                                                 domain);
+                                if (rhost == (char *)-1)
+                                        rhost = __gethostloop(raddr, salen);
+                                hostok = 0;
+                                if (rhost)
+                                        hostok = innetgr(&ahost[2], rhost,
+                                            NULL, domain);
                                 break;
-
                         default:
-                                hostok = __icheckhost(raddr, &ahost[1]);
+                                hostok = __icheckhost(raddr, salen, &ahost[1]);
                                 break;
                         }
                 else if (ahost[0] == '-')
@@ -425,18 +551,20 @@ __ivaliduser(hostf, raddr, luser, ruser)
                         case '\0':
                                 hostok = -1;
                                 break;
-
                         case '@':
-                                hostok = -innetgr(&ahost[2], rhost, NULL,
-                                                  domain);
+                                if (rhost == (char *)-1)
+                                        rhost = __gethostloop(raddr, salen);
+                                hostok = 0;
+                                if (rhost)
+                                        hostok = -innetgr(&ahost[2], rhost,
+                                            NULL, domain);
                                 break;
-
                         default:
-                                hostok = -__icheckhost(raddr, &ahost[1]);
+                                hostok = -__icheckhost(raddr, salen, &ahost[1]);
                                 break;
                         }
                 else
-                        hostok = __icheckhost(raddr, ahost);
+                        hostok = __icheckhost(raddr, salen, ahost);
 
 
                 if (auser[0] == '+')
@@ -444,14 +572,12 @@ __ivaliduser(hostf, raddr, luser, ruser)
                         case '\0':
                                 userok = 1;
                                 break;
-
                         case '@':
                                 userok = innetgr(&auser[2], NULL, ruser,
-                                                 domain);
+                                    domain);
                                 break;
-
                         default:
-                                userok = strcmp(ruser, &auser[1]) == 0;
+                                userok = strcmp(ruser, &auser[1]) ? 0 : 1;
                                 break;
                         }
                 else if (auser[0] == '-')
@@ -459,59 +585,149 @@ __ivaliduser(hostf, raddr, luser, ruser)
                         case '\0':
                                 userok = -1;
                                 break;
-
                         case '@':
                                 userok = -innetgr(&auser[2], NULL, ruser,
-                                                  domain);
+                                    domain);
                                 break;
-
                         default:
-                                userok = -(strcmp(ruser, &auser[1]) == 0);
+                                userok = strcmp(ruser, &auser[1]) ? 0 : -1;
                                 break;
                         }
                 else
-                        userok = strcmp(ruser, auser) == 0;
+                        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;
+                if (userok <= -1 || hostok <= -1)
+                        return (-1);
 
                 /* Check if we got a valid pair */
-                if (hostok == 1 && userok == 1)
-                        return 0;
+                if (hostok >= 1 && userok >= 1)
+                        return (0);
         }
-        return -1;
+bail:
+        return (-1);
 }
 
 /*
- * Returns "true" if match, 0 if no match.
+ * 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.
+ *
+ * NI_WITHSCOPEID is useful for comparing sin6_scope_id portion
+ * if af == AF_INET6.
  */
 static int
-__icheckhost(raddr, lhost)
-        u_long raddr;
+__icheckhost(raddr, salen, lhost)
+        struct sockaddr *raddr;
+        socklen_t salen;
         const char *lhost;
 {
-        register struct hostent *hp;
-        register u_long laddr;
-        register char **pp;
+        struct addrinfo hints, *res, *r;
+        char h1[NI_MAXHOST], h2[NI_MAXHOST];
+        int error;
+#ifdef NI_WITHSCOPEID
+        const int niflags = NI_NUMERICHOST | NI_WITHSCOPEID;
+#else
+        const int niflags = NI_NUMERICHOST;
+#endif
 
-        /* Try for raw ip address first. */
-        if (isdigit(*lhost) && (long)(laddr = inet_addr(lhost)) != -1)
-                return (raddr == laddr);
+        h1[0] = '\0';
+        if (getnameinfo(raddr, salen, h1, sizeof(h1), NULL, 0,
+            niflags) != 0)
+                return (0);
 
-        /* Better be a hostname. */
-        if ((hp = gethostbyname(lhost)) == NULL)
+        /* 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);
 
-        /* Spin through ip addresses. */
-        for (pp = hp->h_addr_list; *pp; ++pp)
-                if (!bcmp(&raddr, *pp, sizeof(u_long)))
+        /*
+         * 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.
+ *
+ * NI_WITHSCOPEID is useful for comparing sin6_scope_id portion
+ * if af == AF_INET6.
+ */
+static char *
+__gethostloop(raddr, salen)
+        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;
+#ifdef NI_WITHSCOPEID
+        const int niflags = NI_NUMERICHOST | NI_WITHSCOPEID;
+#else
+        const int niflags = NI_NUMERICHOST;
+#endif
+
+        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/string/index.3 b/src/lib/libc/net/rcmdsh.3
index 847b03628b..e993d2c9d5 100644
--- a/src/lib/libc/string/index.3
+++ b/src/lib/libc/net/rcmdsh.3
@@ -1,8 +1,8 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\"     $OpenBSD: rcmdsh.3,v 1.9 2003/05/05 22:13:03 millert Exp $
+.\"
+.\" Copyright (c) 1983, 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:
@@ -31,53 +31,70 @@
 .\" 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 May 5, 2003
+.Dt RCMDSH 3
 .Os
 .Sh NAME
-.Nm index
-.Nd locate character in string
+.Nm rcmdsh
+.Nd return a stream to a remote command without superuser
 .Sh SYNOPSIS
-.Fd #include <string.h>
-.Ft char *
-.Fn index "const char *s" "int c"
+.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 index
-function
-locates the first character matching
-.Fa c
-(converted to a
-.Em char )
-in the null-terminated string
-.Fa s .
-.Sh RETURN VALUES
-The character
-.Fa c
-is returned if it is found; otherwise
-.Dv NULL
-is returned.
-If
-.Fa c
-is '\e0',
-.Fn index
-locates the terminating '\e0'.
+.Fn rcmdsh
+function is used by normal users to execute a command on a remote machine
+using an authentication scheme based on reserved port numbers using
+.Xr rsh 1
+or the value of
+.Fa rshprog
+(if non-null).
+.Fa rshprog
+may be a fully-qualified path, a non-qualified command, or a command containing
+space-separated command line arguments.
+.Pp
+The
+.Fn rcmdsh
+function looks up the host
+.Fa *ahost
+using
+.Xr gethostbyname 3 ,
+returning \-1 if the host does not exist.
+Otherwise
+.Fa *ahost
+is set to the standard name of the host and a connection is established to
+a server residing at the well-known Internet port
+.Li shell/tcp
+(or whatever port is used by
+.Fa rshprog ) .
+The parameter
+.Fa inport
+is ignored; it is only included to provide an interface similar to
+.Xr rcmd 3 .
+.Pp
+If the connection succeeds, a socket in the
+.Tn UNIX
+domain of type
+.Dv SOCK_STREAM
+is returned to the caller, and given to the remote
+command as stdin and stdout, and stderr.
+.Sh DIAGNOSTICS
+The
+.Fn rcmdsh
+function returns a valid socket descriptor on success.
+It returns \-1 on error and prints a diagnostic message on the standard error.
 .Sh SEE ALSO
-.Xr 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 rsh 1 ,
+.Xr socketpair 2 ,
+.Xr rcmd 3 ,
+.Xr rshd 8
+.Sh BUGS
+If
+.Xr rsh 1
+encounters an error, a file descriptor is still returned instead of \-1.
 .Sh HISTORY
-A
-.Fn index
-function appeared in 
-.At v6 .
+The
+.Fn rcmdsh
+function first appeared in
+.Ox 2.0 .
diff --git a/src/lib/libc/net/rcmdsh.c b/src/lib/libc/net/rcmdsh.c
new file mode 100644
index 0000000000..2a2a5d77fe
--- /dev/null
+++ b/src/lib/libc/net/rcmdsh.c
@@ -0,0 +1,192 @@
+/*      $OpenBSD: rcmdsh.c,v 1.8 2003/05/05 22:13:03 millert 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>.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: rcmdsh.c,v 1.8 2003/05/05 22:13:03 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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(ahost, rport, locuser, remuser, cmd, rshprog)
+        char **ahost;
+        int rport;
+        const char *locuser, *remuser, *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 = gethostbyname(*ahost)) == NULL) {
+                        herror(*ahost);
+                        return(-1);
+                }
+                *ahost = hp->h_name;
+        }
+
+        /* Get a socketpair we'll use for stdin and stdout. */
+        if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sp) < 0) {
+                perror("rcmdsh: socketpair");
+                return(-1);
+        }
+
+        cpid = fork();
+        if (cpid < 0) {
+                perror("rcmdsh: fork failed");
+                return(-1);
+        } else if (cpid == 0) {
+                /*
+                 * Child.  We use sp[1] to be stdin/stdout, and close sp[0].
+                 */
+                (void) close(sp[0]);
+                if (dup2(sp[1], 0) < 0 || dup2(0, 1) < 0) {
+                        perror("rcmdsh: dup2 failed");
+                        _exit(255);
+                }
+                /* Fork again to lose parent. */
+                cpid = fork();
+                if (cpid < 0) {
+                        perror("rcmdsh: fork to lose parent failed");
+                        _exit(255);
+                }
+                if (cpid > 0)
+                        _exit(0);
+
+                /* In grandchild here.  Become local user for rshprog. */
+                if (setuid(pw->pw_uid)) {
+                        (void) fprintf(stderr, "rcmdsh: setuid(%u): %s\n",
+                                       pw->pw_uid, strerror(errno));
+                        _exit(255);
+                }
+
+                /*
+                 * If remote host is "localhost" and local and remote user
+                 * are the same, avoid running remote shell for efficiency.
+                 */
+                if (!strcmp(*ahost, "localhost") && !strcmp(locuser, remuser)) {
+                        char *argv[4];
+                        if (pw->pw_shell[0] == '\0')
+                                rshprog = _PATH_BSHELL;
+                        else
+                                rshprog = pw->pw_shell;
+                        p = strrchr(rshprog, '/');
+                        argv[0] = p ? p + 1 : rshprog;
+                        argv[1] = "-c";
+                        argv[2] = (char *)cmd;
+                        argv[3] = NULL;
+                        execvp(rshprog, argv);
+                } else if ((p = strchr(rshprog, ' ')) == NULL) {
+                        /* simple case */
+                        char *argv[6];
+                        p = strrchr(rshprog, '/');
+                        argv[0] = p ? p + 1 : rshprog;
+                        argv[1] = "-l";
+                        argv[2] = (char *)remuser;
+                        argv[3] = *ahost;
+                        argv[4] = (char *)cmd;
+                        argv[5] = NULL;
+                        execvp(rshprog, argv);
+                } else {
+                        /* must pull args out of rshprog and dyn alloc argv */
+                        char **argv, **ap;
+                        int n;
+                        for (n = 7; (p = strchr(++p, ' ')) != NULL; n++)
+                                continue;
+                        rshprog = strdup(rshprog);
+                        ap = argv = malloc(sizeof(char *) * n);
+                        if (rshprog == NULL || argv == NULL) {
+                                perror("rcmdsh");
+                                _exit(255);
+                        }
+                        while ((p = strsep(&rshprog, " ")) != NULL) {
+                                if (*p == '\0')
+                                        continue;
+                                *ap++ = p;
+                        }
+                        if (ap != argv)         /* all spaces?!? */
+                                rshprog = argv[0];
+                        if ((p = strrchr(argv[0], '/')) != NULL)
+                                argv[0] = p + 1;
+                        *ap++ = "-l";
+                        *ap++ = (char *)remuser;
+                        *ap++ = *ahost;
+                        *ap++ = (char *)cmd;
+                        *ap++ = NULL;
+                        execvp(rshprog, argv);
+                }
+                (void) fprintf(stderr, "rcmdsh: execvp %s failed: %s\n",
+                               rshprog, strerror(errno));
+                _exit(255);
+        } else {
+                /* Parent. close sp[1], return sp[0]. */
+                (void) close(sp[1]);
+                /* Reap child. */
+                (void) wait(NULL);
+                return(sp[0]);
+        }
+        /* NOTREACHED */
+}
diff --git a/src/lib/libc/net/recv.c b/src/lib/libc/net/recv.c
index 44296378cb..d209a07213 100644
--- a/src/lib/libc/net/recv.c
+++ b/src/lib/libc/net/recv.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: recv.c,v 1.6 1995/02/25 06:20:54 cgd Exp $     */
-
 /*
  * Copyright (c) 1988, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: recv.c,v 1.2 1996/08/19 08:29:40 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
diff --git a/src/lib/libc/net/res_comp.c b/src/lib/libc/net/res_comp.c
index 9d7bbecdda..25e196b2cf 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.10 2002/02/19 19:39:36 millert 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -56,19 +58,25 @@
 #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 ";
+static char rcsid[] = "$From: res_comp.c,v 8.11 1996/12/02 09:17:22 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_comp.c,v 1.6 1995/02/25 06:20:55 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_comp.c,v 1.10 2002/02/19 19:39:36 millert 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 +85,27 @@ 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.
  */
+int
 dn_expand(msg, eomorig, comp_dn, exp_dn, length)
         const u_char *msg, *eomorig, *comp_dn;
-        u_char *exp_dn;
+        char *exp_dn;
         int length;
 {
-        register u_char *cp, *dn;
+        register const u_char *cp;
+        register char *dn;
         register int n, c;
-        u_char *eom;
+        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 +120,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,8 +169,9 @@ 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.
  */
+int
 dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
-        const u_char *exp_dn;
+        const char *exp_dn;
         u_char *comp_dn, **dnptrs, **lastdnptr;
         int length;
 {
@@ -170,6 +183,7 @@ dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
         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 +249,14 @@ dn_comp(exp_dn, comp_dn, length, dnptrs, lastdnptr)
 /*
  * Skip over a compressed domain name. Return the size or -1.
  */
+int
 __dn_skipname(comp_dn, eom)
         const u_char *comp_dn, *eom;
 {
-        register u_char *cp;
+        register const u_char *cp;
         register int n;
 
-        cp = (u_char *)comp_dn;
+        cp = comp_dn;
         while (cp < eom && (n = *cp++)) {
                 /*
                  * check for indirection
@@ -259,10 +274,19 @@ __dn_skipname(comp_dn, eom)
                 break;
         }
         if (cp > eom)
-                return -1;
+                return (-1);
         return (cp - comp_dn);
 }
 
+static int
+mklower(ch)
+        register 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.
@@ -281,7 +305,7 @@ dn_find(exp_dn, msg, dnptrs, lastdnptr)
         for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
                 dn = exp_dn;
                 sp = cp = *cpp;
-                while (n = *cp++) {
+                while ((n = *cp++)) {
                         /*
                          * check for indirection
                          */
@@ -292,7 +316,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 +325,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,16 +341,124 @@ 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 periodchar(c) ((c) == PERIOD)
+#define asterchar(c) ((c) == 0x2a)
+#define alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) \
+                   || ((c) >= 0x61 && (c) <= 0x7a))
+#define digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
+
+#define borderchar(c) (alphachar(c) || digitchar(c))
+#define middlechar(c) (borderchar(c) || hyphenchar(c))
+#define domainchar(c) ((c) > 0x20 && (c) < 0x7f)
+
+int
+res_hnok(dn)
+        const char *dn;
+{
+        int pch = PERIOD, ch = *dn++;
 
-u_short
+        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(dn)
+        const char *dn;
+{
+        if (asterchar(dn[0])) {
+                if (periodchar(dn[1]))
+                        return (res_hnok(dn+2));
+                if (dn[1] == '\0')
+                        return (1);
+        }
+        return (res_hnok(dn));
+}
+
+/*
+ * SOA RNAMEs and RP RNAMEs can have any printable character in their first
+ * label, but the rest of the name has to look like a host name.
+ */
+int
+res_mailok(dn)
+        const char *dn;
+{
+        int ch, escaped = 0;
+
+        /* "." is a valid missing representation */
+        if (*dn == '\0')
+                return(1);
+
+        /* otherwise <label>.<hostname> */
+        while ((ch = *dn++) != '\0') {
+                if (!domainchar(ch))
+                        return (0);
+                if (!escaped && periodchar(ch))
+                        break;
+                if (escaped)
+                        escaped = 0;
+                else if (bslashchar(ch))
+                        escaped = 1;
+        }
+        if (periodchar(ch))
+                return (res_hnok(dn));
+        return(0);
+}
+
+/*
+ * This function is quite liberal, since RFC 1034's character sets are only
+ * recommendations.
+ */
+int
+res_dnok(dn)
+        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(msgp)
-        register u_char *msgp;
+        register const u_char *msgp;
 {
         register u_int16_t u;
 
@@ -333,9 +466,21 @@ _getshort(msgp)
         return (u);
 }
 
+#ifdef NeXT
+/*
+ * nExt machines have some funky library conventions, which we must maintain.
+ */
+u_int16_t
+res_getshort(msgp)
+        register const u_char *msgp;
+{
+        return (_getshort(msgp));
+}
+#endif
+
 u_int32_t
 _getlong(msgp)
-        register u_char *msgp;
+        register const u_char *msgp;
 {
         register u_int32_t u;
 
@@ -344,13 +489,7 @@ _getlong(msgp)
 }
 
 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(s, 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..b0d19c36bb
--- /dev/null
+++ b/src/lib/libc/net/res_data.c
@@ -0,0 +1,117 @@
+/*      $OpenBSD: res_data.c,v 1.1 1997/03/13 19:07:36 downsj 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. 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.
+ * -
+ * 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 rcsid[] = "$From: res_data.c,v 8.2 1996/08/05 08:31:35 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: res_data.c,v 1.1 1997/03/13 19:07:36 downsj Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#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..b39e9a3b14 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.16 2003/03/04 00:29:17 itojun 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:
@@ -50,174 +52,194 @@
  * 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";
+static char rcsid[] = "$From: res_debug.c,v 8.19 1996/11/26 10:11:23 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_debug.c,v 1.7 1995/02/25 06:20:56 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_debug.c,v 1.16 2003/03/04 00:29:17 itojun 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",
-};
+#include "thread_private.h"
 
-char *_res_resultcodes[] = {
-        "NOERROR",
-        "FORMERR",
-        "SERVFAIL",
-        "NXDOMAIN",
-        "NOTIMP",
-        "REFUSED",
-        "6",
-        "7",
-        "8",
-        "9",
-        "10",
-        "11",
-        "12",
-        "13",
-        "14",
-        "NOCHANGE",
-};
+extern const char *_res_opcodes[];
+extern const char *_res_resultcodes[];
 
-static char retbuf[16];
+static const char *loc_ntoal(const u_char *binary, char *ascii, int ascii_len);
 
-static char *
+/* XXX: we should use getservbyport() instead. */
+static const char *
 dewks(wks)
         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 *
+/* XXX: we should use getprotobynumber() instead. */
+static const char *
 deproto(protonum)
         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;
+static const u_char *
+do_rrset(msg, len, cp, cnt, pflag, file, hs)
+        int cnt, pflag, len;
+        const u_char *cp, *msg;
+        const char *hs;
         FILE *file;
 {
+        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);
 }
 
+void
 __p_query(msg)
-        char *msg;
+        const u_char *msg;
 {
         __fp_query(msg, stdout);
 }
@@ -231,15 +253,14 @@ __fp_resstat(statp, file)
         struct __res_state *statp;
         FILE *file;
 {
-        int bit;
+        register 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 +269,152 @@ __fp_resstat(statp, file)
  * This is intended to be primarily a debugging routine.
  */
 void
-__fp_query(msg,file)
-        char *msg;
+__fp_nquery(msg, len, file)
+        const u_char *msg;
+        int len;
         FILE *file;
 {
-        register char *cp;
-        register HEADER *hp;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        register const u_char *cp, *endMark;
+        register const HEADER *hp;
         register int n;
 
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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;
+void
+__fp_query(msg, file)
+        const u_char *msg;
+        FILE *file;
+{
+        fp_nquery(msg, PACKETSZ, file);
+}
+
+const u_char *
+__p_cdnname(cp, msg, len, file)
+        const u_char *cp, *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 +423,96 @@ p_cdname(cp, msg, file)
         return (cp + n);
 }
 
-char *
-p_fqname(cp, msg, file)
-        char *cp, *msg;
+const u_char *
+__p_cdname(cp, msg, file)
+        const u_char *cp, *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(cp, msg, msglen, name, namelen)
+        const u_char *cp, *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(cp, msg, file)
+        const u_char *cp, *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;
+const u_char *
+__p_rr(cp, msg, file)
+        const u_char *cp, *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 ((_resp->options & RES_INIT) == 0 && res_init() == -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 +523,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 +553,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 +760,83 @@ 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:
+                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 +850,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 +859,210 @@ 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];
+/*
+ * 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}
+};
 
 /*
- * Return a string for the type
+ * 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.)
  */
-char *
-__p_type(type)
-        int type;
-{
-        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");
+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
-        case T_UNSPEC:
-                return("UNSPEC");
+        {T_UNSPEC,      "UNSPEC",       "unspecified data (nonstandard)"},
 #endif /* ALLOW_T_UNSPEC */
+        {T_ANY,         "ANY",          "\"any\""},
+        {0,             NULL,           NULL}
+};
 
-        default:
-                (void)sprintf(nbuf, "%d", type);
-                return(nbuf);
+int
+__sym_ston(syms, name, success)
+        const struct res_sym *syms;
+        char *name;
+        int *success;
+{
+        for (; syms->name != 0; syms++) {
+                if (strcasecmp (name, syms->name) == 0) {
+                        if (success)
+                                *success = 1;
+                        return (syms->number);
+                }
+        }
+        if (success)
+                *success = 0;
+        return (syms->number);          /* The default value. */
+}
+
+const char *
+__sym_ntos(syms, number, success)
+        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);
+}
+
+
+const char *
+__sym_ntop(syms, number, success)
+        const struct res_sym *syms;
+        int number;
+        int *success;
+{
+        static char unname[20];
+
+        for (; syms->name != 0; syms++) {
+                if (number == syms->number) {
+                        if (success)
+                                *success = 1;
+                        return (syms->humanname);
+                }
         }
+        snprintf(unname, sizeof unname, "%d", number);
+        if (success)
+                *success = 0;
+        return (unname);
+}
+
+/*
+ * Return a string for the type
+ */
+const char *
+__p_type(type)
+        int type;
+{
+        return (__sym_ntos (__p_type_syms, type, (int *)0));
 }
 
 /*
  * Return a mnemonic for class
  */
-char *
+const char *
 __p_class(class)
         int class;
 {
-
-        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);
-        }
+        return (__sym_ntos (__p_class_syms, class, (int *)0));
 }
 
 /*
  * Return a mnemonic for an option
  */
-static char *
-p_option(option)
-        u_int32_t option;
+const char *
+__p_option(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)
+const char *
+p_time(value)
         u_int32_t value;
 {
+        static char nbuf[40];
+        char *ebuf;
         int secs, mins, hours, days;
         register 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 +1076,490 @@ __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 - nbuf || 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 - nbuf || 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 - nbuf || 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 - nbuf || tmp < 0)
+                        goto full;
+        }
+        return (nbuf);
+full:
+        p = nbuf + sizeof(nbuf) - 4;
+        *p++ = '.';
+        *p++ = '.';
+        *p++ = '.';
+        *p++ = '\0';
+        return (nbuf);
+}
+
+/*
+ * routines to convert between on-the-wire RR format and zone file format.
+ * Does not contain conversion to/from decimal degrees; divide or multiply
+ * by 60*60*1000 for that.
+ */
+
+static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000,
+                                      1000000,10000000,100000000,1000000000};
+
+/* takes an XeY precision/size value, returns a string representation. */
+static const char *
+precsize_ntoa(prec)
+        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(strptr)
+        char **strptr;
+{
+        unsigned int mval = 0, cmval = 0;
+        u_int8_t retval = 0;
+        register char *cp;
+        register int exponent;
+        register 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(latlonstrptr,which)
+        char **latlonstrptr;
+        int *which;
+{
+        register 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(ascii, binary)
+        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);
         }
-        return(nbuf);
+
+        /* 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(binary, ascii)
+        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(binary, ascii, ascii_len)
+        const u_char *binary;
+        char *ascii;
+        int ascii_len;
+{
+        static char *error = "?";
+        register 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(name)
+        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 (secs)
+        unsigned long 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_init.c b/src/lib/libc/net/res_init.c
index 33cc8d39f1..a1d69f57b5 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.28 2003/01/28 04:58:00 marc 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -53,80 +55,181 @@
  * --Copyright--
  */
 
+#ifndef INET6
+#define INET6
+#endif
+
 #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 ";
+static char rcsid[] = "$From: res_init.c,v 8.7 1996/09/28 06:51:07 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_init.c,v 1.8 1995/06/03 22:33:36 mycroft Exp $";
+static char rcsid[] = "$OpenBSD: res_init.c,v 1.28 2003/01/28 04:58:00 marc Exp $";
 #endif
 #endif /* LIBC_SCCS and not lint */
 
+#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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef INET6
+#include <netdb.h>
+#endif /* INET6 */
+
+#include "thread_private.h"
+
+/*-------------------------------------- info about "sortlist" --------------
+ * Marc Majka           1994/04/16
+ * Allan Nathanson      1994/10/29 (BIND 4.9.3.x)
+ *
+ * NetInfo resolver configuration directory support.
+ *
+ * Allow a NetInfo directory to be created in the hierarchy which
+ * contains the same information as the resolver configuration file.
+ *
+ * - The local domain name is stored as the value of the "domain" property.
+ * - The Internet address(es) of the name server(s) are stored as values
+ *   of the "nameserver" property.
+ * - The name server addresses are stored as values of the "nameserver"
+ *   property.
+ * - The search list for host-name lookup is stored as values of the
+ *   "search" property.
+ * - The sortlist comprised of IP address netmask pairs are stored as
+ *   values of the "sortlist" property. The IP address and optional netmask
+ *   should be separated by a slash (/) or ampersand (&) character.
+ * - Internal resolver variables can be set from the value of the "options"
+ *   property.
+ */
+
+static void res_setoptions(char *, char *);
 
-static void res_setoptions __P((char *, char *));
-static u_int32_t net_mask __P((struct in_addr));
+#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.
  */
+volatile struct _thread_private_key_struct __THREAD_KEY_NAME(_res) = {
+        PTHREAD_ONCE_INIT, 0
+};
 
-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 _res
+# if defined(__BIND_RES_TEXT)
+        = { RES_TIMEOUT, }      /* Motorola, et al. */
+# endif
+        ;
+#ifdef INET6
+volatile struct _thread_private_key_struct __THREAD_KEY_NAME(_res_ext) = {
+        PTHREAD_ONCE_INIT, 0
 };
 
+struct __res_state_ext _res_ext;
+#endif /* INET6 */
+
 /*
  * 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
  */
+int
 res_init()
 {
+        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
         register FILE *fp;
-        register char *cp, **pp, *net;
+        register char *cp, **pp;
         register int n;
-        char buf[BUFSIZ], buf2[BUFSIZ];
+        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
+
+        /*
+         * 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 +239,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 +261,29 @@ res_init()
                 *pp++ = 0;
         }
 
+#define MATCH(line, name) \
+        (!strncmp(line, name, sizeof(name) - 1) && \
+        (line[sizeof(name) - 1] == ' ' || \
+         line[sizeof(name) - 1] == '\t'))
+
         if ((fp = fopen(_PATH_RESCONF, "r")) != NULL) {
-            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 or zero length */
+                if (len >= sizeof(buf) || len == 0)
+                    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;
                 /* 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 +291,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 +309,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 +325,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 +333,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 +361,273 @@ 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) {
+#ifdef INET6
+                    char *q;
+                    struct addrinfo hints, *res;
+                    char pbuf[NI_MAXSERV];
+#else
+                    struct in_addr a;
+#endif /* INET6 */
 
                     cp = buf + sizeof("nameserver") - 1;
                     while (*cp == ' ' || *cp == '\t')
                         cp++;
+#ifdef INET6
+                    if ((*cp == '\0') || (*cp == '\n'))
+                        continue;
+                    for (q = cp; *q; q++) {
+                        if (isspace(*q)) {
+                            *q = '\0';
+                            break;
+                        }
+                    }
+                    memset(&hints, 0, sizeof(hints));
+                    hints.ai_flags = AI_NUMERICHOST;
+                    hints.ai_socktype = SOCK_DGRAM;
+                    snprintf(pbuf, sizeof(pbuf), "%u", NAMESERVER_PORT);
+                    res = NULL;
+                    if (getaddrinfo(cp, pbuf, &hints, &res) == 0 &&
+                            res->ai_next == NULL) {
+                        if (res->ai_addrlen <= sizeof(_res_extp->nsaddr_list[nserv])) {
+                            memcpy(&_res_extp->nsaddr_list[nserv], res->ai_addr,
+                                res->ai_addrlen);
+                        } else {
+                            memset(&_res_extp->nsaddr_list[nserv], 0,
+                                sizeof(_res_extp->nsaddr_list[nserv]));
+                        }
+                        if (res->ai_addrlen <= sizeof(_resp->nsaddr_list[nserv])) {
+                            memcpy(&_resp->nsaddr_list[nserv], res->ai_addr,
+                                res->ai_addrlen);
+                        } else {
+                            memset(&_resp->nsaddr_list[nserv], 0,
+                                sizeof(_resp->nsaddr_list[nserv]));
+                        }
+                        nserv++;
+                    }
+                    if (res)
+                        freeaddrinfo(res);
+#else /* INET6 */
                     if ((*cp != '\0') && (*cp != '\n') && inet_aton(cp, &a)) {
-                        _res.nsaddr_list[nserv].sin_len = sizeof(struct sockaddr_in);
-                        _res.nsaddr_list[nserv].sin_family = AF_INET;
-                        _res.nsaddr_list[nserv].sin_port =
+                        _resp->nsaddr_list[nserv].sin_addr = a;
+                        _resp->nsaddr_list[nserv].sin_family = AF_INET;
+                        _resp->nsaddr_list[nserv].sin_port =
                                 htons(NAMESERVER_PORT);
-                        _res.nsaddr_list[nserv].sin_addr = a;
+                        _resp->nsaddr_list[nserv].sin_len =
+                                sizeof(struct sockaddr_in);
                         nserv++;
                     }
+#endif /* INET6 */
                     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;
+                                }
+                                /*FALLTHRU*/
+                            default:
+                                m = sizeof(struct in6_addr) * NBBY;
+                                break;
+                            }
+                            if (m >= 0) {
+                                for (i = 0; i < sizeof(struct in6_addr); i++) {
+                                    if (m <= 0) {
+                                        *u = 0;
+                                    } else {
+                                        m -= NBBY;
+                                        *u = (u_char)~0;
+                                        if (m < 0)
+                                            *u <<= -m;
+                                    }
+                                    u++;
+                                }
+                            }
+                            nsort++;
+                        }
+#endif /* INET6 */
+                        *cp = n;
                     }
                     continue;
                 }
-                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;
 {
+        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 {
                         /* XXX - print a warning here? */
                 }
@@ -380,6 +637,8 @@ 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;
@@ -388,7 +647,8 @@ net_mask(in)		/* XXX - should really use system's version of this */
 
         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..bb8f1f0725 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.13 2003/01/28 04:58:00 marc 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -56,98 +58,115 @@
 #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 ";
+static char rcsid[] = "$From: res_mkquery.c,v 8.5 1996/08/27 08:33:28 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_mkquery.c,v 1.5 1995/02/25 06:20:58 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_mkquery.c,v 1.13 2003/01/28 04:58:00 marc 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.
  */
+/* ARGSUSED */
+int
 res_mkquery(op, dname, class, type, data, datalen, newrr_in, buf, buflen)
         int op;                 /* opcode of query */
-        const char *dname;              /* domain name */
+        const char *dname;      /* domain name */
         int class, type;        /* class and type of query */
-        const char *data;               /* resource record data */
+        const u_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 */
+        const u_char *newrr_in; /* new rr for modify or append */
+        u_char *buf;            /* buffer to put query */
         int buflen;             /* size of buffer */
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
         register HEADER *hp;
-        register char *cp;
+        register u_char *cp, *ep;
         register int n;
-        struct rrec *newrr = (struct rrec *) newrr_in;
-        char *dnptrs[10], **dpp, **lastdnptr;
+        u_char *dnptrs[20], **dpp, **lastdnptr;
 
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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 +174,73 @@ 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(n0, buf, buflen, anslen)
+        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);
+        register HEADER *hp;
+        register 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..1e949e8efa 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.20 2003/01/28 04:58:00 marc 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -56,23 +58,28 @@
 #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 ";
+static char rcsid[] = "$From: res_query.c,v 8.9 1996/09/22 00:13:28 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_query.c,v 1.9 1995/02/25 06:58:58 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_query.c,v 1.20 2003/01/28 04:58:00 marc 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 +87,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 +98,79 @@ 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.
  */
+int
 res_query(name, class, type, answer, anslen)
-        char *name;             /* domain name */
+        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 buffer */
 {
-        char buf[MAXPACKET];
-        HEADER *hp;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        u_char buf[MAXPACKET];
+        register HEADER *hp = (HEADER *) answer;
         int n;
 
-        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
+        hp->rcode = NOERROR;    /* default */
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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, sizeof(buf));
+        if (n > 0 && ((_resp->options & RES_USE_EDNS0) ||
+            (_resp->options & RES_USE_DNSSEC))) {
+                n = res_opt(n, buf, sizeof(buf), anslen);
+        }
 
         if (n <= 0) {
 #ifdef DEBUG
-                if (_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, 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,9 +181,7 @@ 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)
@@ -173,28 +190,30 @@ res_search(name, class, type, answer, anslen)
         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;
+        register 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 ((_resp->options & RES_INIT) == 0 && res_init() == -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 +221,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 +235,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 +273,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 +301,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 +314,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 +323,26 @@ 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.
  */
+int
 res_querydomain(name, domain, class, type, answer, anslen)
-        char *name, *domain;
+        const char *name, *domain;
         int class, type;        /* class and type of query */
         u_char *answer;         /* buffer to put answer */
         int anslen;             /* size of answer */
 {
-        char nbuf[2*MAXDNAME+2];
-        char *longname = nbuf;
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        char nbuf[MAXDNAME*2+1+1];
+        const char *longname = nbuf;
         int n;
 
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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 +356,52 @@ 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)
+const char *
+hostalias(name)
         register const char *name;
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
         register 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..c739e4a952
--- /dev/null
+++ b/src/lib/libc/net/res_random.c
@@ -0,0 +1,229 @@
+/* $OpenBSD: res_random.c,v 1.12 2002/06/27 10:14:02 itojun Exp $ */
+
+/*
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * All rights reserved.
+ *
+ * Theo de Raadt <deraadt@openbsd.org> came up with the idea of using
+ * such a mathematical system to generate more random (yet non-repeating)
+ * ids to solve the resolver/named problem.  But Niels designed the
+ * actual system based on the constraints.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 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.
+ */
+
+/* 
+ * seed = random 15bit
+ * n = prime, g0 = generator to n,
+ * j = random so that gcd(j,n-1) == 1
+ * g = g0^j mod n will be a generator again.
+ *
+ * X[0] = random seed.
+ * X[n] = a*X[n-1]+b mod m is a Linear Congruential Generator
+ * with a = 7^(even random) mod m, 
+ *      b = random with gcd(b,m) == 1
+ *      m = 31104 and a maximal period of m-1.
+ *
+ * The transaction id is determined by:
+ * id[n] = seed xor (g^X[n] mod n)
+ *
+ * Effectivly the id is restricted to the lower 15 bits, thus
+ * yielding two different cycles by toggling the msb on and off.
+ * This avoids reuse issues caused by reseeding.
+ *
+ * The 16 bit space is very small and brute force attempts are
+ * entirly feasible, we skip a random number of transaction ids
+ * so that an attacker will not get sequential ids.
+ */
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <resolv.h>
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define RU_OUT  180             /* Time after wich will be reseeded */
+#define RU_MAX  30000           /* Uniq cycle, avoid blackjack prediction */
+#define RU_GEN  2               /* Starting generator */
+#define RU_N    32749           /* RU_N-1 = 2*2*3*2729 */
+#define RU_AGEN 7               /* determine ru_a as RU_AGEN^(2*rand) */
+#define RU_M    31104           /* RU_M = 2^7*3^5 - don't change */
+
+#define PFAC_N 3
+const static u_int16_t pfacts[PFAC_N] = {
+        2, 
+        3,
+        2729
+};
+
+static u_int16_t ru_x;
+static u_int16_t ru_seed, ru_seed2;
+static u_int16_t ru_a, ru_b;
+static u_int16_t ru_g;
+static u_int16_t ru_counter = 0;
+static u_int16_t ru_msb = 0;
+static long ru_reseed;
+static u_int32_t tmp;                /* Storage for unused random */
+static struct timeval tv;
+
+static u_int16_t pmod(u_int16_t, u_int16_t, u_int16_t);
+static void res_initid(void);
+
+/*
+ * Do a fast modular exponation, returned value will be in the range
+ * of 0 - (mod-1)
+ */
+
+static u_int16_t
+pmod(u_int16_t gen, u_int16_t exp, u_int16_t mod)
+{
+        u_int16_t s, t, u;
+
+        s = 1;
+        t = gen;
+        u = exp;
+
+        while (u) {
+                if (u & 1)
+                        s = (s*t) % mod;
+                u >>= 1;
+                t = (t*t) % mod;
+        }
+        return (s);
+}
+
+/* 
+ * Initializes the seed and chooses a suitable generator. Also toggles 
+ * the msb flag. The msb flag is used to generate two distinct
+ * cycles of random numbers and thus avoiding reuse of ids.
+ *
+ * This function is called from res_randomid() when needed, an 
+ * application does not have to worry about it.
+ */
+static void 
+res_initid()
+{
+        u_int16_t j, i;
+        int noprime = 1;
+
+        tmp = arc4random();
+        ru_x = (tmp & 0xFFFF) % RU_M;
+
+        /* 15 bits of random seed */
+        ru_seed = (tmp >> 16) & 0x7FFF;
+        tmp = arc4random();
+        ru_seed2 = tmp & 0x7FFF;
+
+        tmp = arc4random();
+
+        /* Determine the LCG we use */
+        ru_b = (tmp & 0xfffe) | 1;
+        ru_a = pmod(RU_AGEN, (tmp >> 16) & 0xfffe, RU_M);
+        while (ru_b % 3 == 0)
+          ru_b += 2;
+        
+        tmp = arc4random();
+        j = tmp % RU_N;
+        tmp = tmp >> 16;
+
+        /* 
+         * Do a fast gcd(j,RU_N-1), so we can find a j with
+         * gcd(j, RU_N-1) == 1, giving a new generator for
+         * RU_GEN^j mod RU_N
+         */
+
+        while (noprime) {
+                for (i=0; i<PFAC_N; i++)
+                        if (j%pfacts[i] == 0)
+                                break;
+
+                if (i>=PFAC_N)
+                        noprime = 0;
+                else 
+                        j = (j+1) % RU_N;
+        }
+
+        ru_g = pmod(RU_GEN,j,RU_N);
+        ru_counter = 0;
+
+        gettimeofday(&tv, NULL);
+        ru_reseed = tv.tv_sec + RU_OUT;
+        ru_msb = ru_msb == 0x8000 ? 0 : 0x8000; 
+}
+
+u_int
+res_randomid()
+{
+        int i, n;
+
+        gettimeofday(&tv, NULL);
+        if (ru_counter >= RU_MAX || tv.tv_sec > ru_reseed)
+                res_initid();
+
+        if (!tmp)
+                tmp = arc4random();
+
+        /* Skip a random number of ids */
+        n = tmp & 0x7; tmp = tmp >> 3;
+        if (ru_counter + n >= RU_MAX)
+                res_initid();
+
+        for (i=0; i<=n; i++)
+                /* Linear Congruential Generator */
+                ru_x = (ru_a*ru_x + ru_b) % RU_M;
+
+        ru_counter += i;
+
+        return (ru_seed ^ pmod(ru_g,ru_seed2 ^ ru_x,RU_N)) | ru_msb;
+}
+
+#if 0
+void
+main(int argc, char **argv)
+{
+        int i, n;
+        u_int16_t wert;
+
+        res_initid();
+
+        printf("Generator: %u\n", ru_g);
+        printf("Seed: %u\n", ru_seed);
+        printf("Reseed at %ld\n", ru_reseed);
+        printf("Ru_X: %u\n", ru_x);
+        printf("Ru_A: %u\n", ru_a);
+        printf("Ru_B: %u\n", ru_b);
+
+        n = atoi(argv[1]);
+        for (i=0;i<n;i++) {
+                wert = res_randomid();
+                printf("%06d\n", wert);
+        }
+}
+#endif
+
diff --git a/src/lib/libc/net/res_send.c b/src/lib/libc/net/res_send.c
index e608358180..9e2c2e7169 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.14 2003/03/04 00:19:24 itojun 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:
@@ -14,12 +16,12 @@
  *    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.
+ *      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
@@ -53,19 +55,31 @@
  * --Copyright--
  */
 
+#ifndef INET6
+#define INET6
+#endif
+
 #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 ";
+static char rcsid[] = "$From: res_send.c,v 8.12 1996/10/08 04:51:06 vixie Exp $";
 #else
-static char rcsid[] = "$NetBSD: res_send.c,v 1.4 1995/02/25 06:21:01 cgd Exp $";
+static char rcsid[] = "$OpenBSD: res_send.c,v 1.14 2003/03/04 00:19:24 itojun Exp $";
 #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,16 +87,24 @@ 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 <netdb.h>
 #include <errno.h>
 #include <resolv.h>
-#include <unistd.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;
+static int connected = 0;       /* is the socket connected */
+static int vc = 0;      /* is the socket a virtual ciruit? */
+static int af = 0;              /* address family of socket */
 
 #ifndef FD_SET
+/* XXX - should be in portability.h */
 #define NFDBITS         32
 #define FD_SETSIZE      32
 #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
@@ -91,121 +113,403 @@ static struct sockaddr no_addr;
 #define FD_ZERO(p)      bzero((char *)(p), sizeof(*(p)))
 #endif
 
-res_send(buf, buflen, answer, anslen)
-        const char *buf;
-        int buflen;
-        char *answer;
-        int anslen;
+#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, string, error, address)
+        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|NI_WITHSCOPEID) != 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, string, error)
+        FILE *file;
+        char *string;
+        int error;
+    {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+        int save = errno;
+
+        if (_resp->options & RES_DEBUG) {
+                fprintf(file, "res_send: %s: %s\n",
+                        string, strerror(error));
+        }
+        errno = save;
+    }
+#endif
+
+static res_send_qhook Qhook = NULL;
+static res_send_rhook Rhook = NULL;
+
+void
+res_send_setqhook(hook)
+        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(hook)
+        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(n)
+        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
-        if (!(_res.options & RES_INIT))
-                if (res_init() == -1) {
-                        return(-1);
+
+/* 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(inp)
+        const struct sockaddr_in *inp;
+{
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+#ifdef INET6
+        const struct sockaddr_in6 *in6p = (const struct sockaddr_in6 *)inp;
+        const struct sockaddr_in6 *srv6;
+#endif
+        const struct sockaddr_in *srv;
+        int ns, ret;
+
+        ret = 0;
+        switch (inp->sin_family) {
+#ifdef INET6
+        case AF_INET6:
+                for (ns = 0; ns < _resp->nscount; ns++) {
+                        srv6 = (struct sockaddr_in6 *)get_nsaddr(ns);
+                        if (srv6->sin6_family == in6p->sin6_family &&
+                            srv6->sin6_port == in6p->sin6_port &&
+                            srv6->sin6_scope_id == in6p->sin6_scope_id &&
+                            (IN6_IS_ADDR_UNSPECIFIED(&srv6->sin6_addr) ||
+                             IN6_ARE_ADDR_EQUAL(&srv6->sin6_addr,
+                                 &in6p->sin6_addr))) {
+                                ret++;
+                                break;
+                        }
                 }
-        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(name, type, class, buf, eom)
+        const char *name;
+        register int type, class;
+        const u_char *buf, *eom;
+{
+        register const u_char *cp = buf + HFIXEDSZ;
+        int qdcount = ntohs(((HEADER*)buf)->qdcount);
+
+        while (qdcount-- > 0) {
+                char tname[MAXDNAME+1];
+                register 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(buf1, eom1, buf2, eom2)
+        const u_char *buf1, *eom1;
+        const u_char *buf2, *eom2;
+{
+        register 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];
+                register 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(buf, buflen, ans, anssiz)
+        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;
+        register int n;
+        u_int badns;    /* XXX NSMAX can't exceed #/bits in this var */
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -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 | NI_WITHSCOPEID) == 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 +521,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,33 +554,72 @@ 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 timeval timeout;
+                        fd_set *dsmaskp;
+                        struct sockaddr_storage from;
+                        socklen_t fromlen;
+
+                        if ((s < 0) || vc || (af != nsap->sa_family)) {
+                                if (vc)
+                                        res_close();
+                                af = nsap->sa_family;
+                                s = socket(af, SOCK_DGRAM, 0);
                                 if (s < 0) {
+#if !CAN_RECONNECT
+ bad_dg_sock:
+#endif
                                         terrno = errno;
-#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
@@ -294,31 +634,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 +663,221 @@ 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.tv_sec = (_resp->retrans << try);
                         if (try > 0)
-                                timeout.tv_sec /= _res.nscount;
+                                timeout.tv_sec /= _resp->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);
+    wait:
+                        dsmaskp = (fd_set *)calloc(howmany(s+1, NFDBITS),
+                                                   sizeof(fd_mask));
+                        if (dsmaskp == NULL) {
+                                res_close();
+                                goto next_ns;
+                        }
+                        FD_SET(s, dsmaskp);
+                        n = select(s+1, dsmaskp, (fd_set *)NULL,
+                                   (fd_set *)NULL, &timeout);
+                        free(dsmaskp);
                         if (n < 0) {
-#ifdef DEBUG
-                                if (_res.options & RES_DEBUG)
-                                        perror("select");
-#endif
-                                continue;
+                                if (errno == EINTR)
+                                        goto wait;
+                                Perror(stderr, "select", 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 +889,14 @@ wait:
  *
  * This routine is not expected to be user visible.
  */
-_res_close()
+void
+res_close()
 {
-        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..4d5402ed2d 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.15 2001/04/03 20:09:08 aaron Exp $
 .\"
 .\" Copyright (c) 1985, 1991, 1993
 .\"     The Regents of the University of California.  All rights reserved.
@@ -31,11 +31,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
 .Dt RESOLVER 3
-.Os BSD 4.3
+.Os
 .Sh NAME
 .Nm res_query ,
 .Nm res_search ,
@@ -50,6 +48,7 @@
 .Fd #include <netinet/in.h>
 .Fd #include <arpa/nameser.h>
 .Fd #include <resolv.h>
+.Ft int
 .Fo res_query
 .Fa "char *dname"
 .Fa "int class"
@@ -57,6 +56,7 @@
 .Fa "u_char *answer"
 .Fa "int anslen"
 .Fc
+.Ft int
 .Fo res_search
 .Fa "char *dname"
 .Fa "int class"
@@ -64,6 +64,7 @@
 .Fa "u_char *answer"
 .Fa "int anslen"
 .Fc
+.Ft int
 .Fo res_mkquery
 .Fa "int op"
 .Fa "char *dname"
@@ -75,13 +76,16 @@
 .Fa "char *buf"
 .Fa "int buflen"
 .Fc
+.Ft int
 .Fo res_send
 .Fa "char *msg"
 .Fa "int msglen"
 .Fa "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"
@@ -89,6 +93,7 @@
 .Fa "char **dnptrs"
 .Fa "char **lastdnptr"
 .Fc
+.Ft int
 .Fo dn_expand
 .Fa "u_char *msg"
 .Fa "u_char *eomorig"
@@ -97,22 +102,22 @@
 .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 +142,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 +169,20 @@ 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 .
 .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,7 +220,7 @@ 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
@@ -224,8 +232,7 @@ 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 +243,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 +255,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 +280,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
 is
-.Dv NULL, names are not compressed.
+.Dv NULL ,
+names are not compressed.
 If
 .Fa lastdnptr
 is
@@ -304,8 +305,7 @@ 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
 The compressed name is contained in a query or reply message;
@@ -319,20 +319,21 @@ 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
+configuration file
 see
 .Xr resolv.conf 5 .
 .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 RFC1535 ,
 .%T RFC974
 .Rs
 .%T "Name Server Operations Guide for BIND"
@@ -340,5 +341,5 @@ see
 .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..c807adfb83
--- /dev/null
+++ b/src/lib/libc/net/rresvport.c
@@ -0,0 +1,118 @@
+/*
+ * 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. 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.
+ *      This product includes software developed by Theo de Raadt.
+ * 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 *rcsid = "$OpenBSD: rresvport.c,v 1.5 2000/01/26 03:43:20 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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(alport)
+        int *alport;
+{
+        return rresvport_af(alport, AF_INET);
+}
+
+
+int
+rresvport_af(alport, 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..7a87b322d1
--- /dev/null
+++ b/src/lib/libc/net/rthdr.c
@@ -0,0 +1,310 @@
+/*      $OpenBSD: rthdr.c,v 1.3 2002/06/27 10:14:02 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.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+
+#include <string.h>
+#include <stdio.h>
+
+size_t
+inet6_rthdr_space(type, seg)
+    int type, seg;
+{
+    switch(type) {
+     case IPV6_RTHDR_TYPE_0:
+         if (seg < 1 || seg > 23)
+             return(0);
+         return(CMSG_SPACE(sizeof(struct in6_addr) * (seg - 1)
+                           + sizeof(struct ip6_rthdr0)));
+     default:
+#ifdef DEBUG
+         fprintf(stderr, "inet6_rthdr_space: unknown type(%d)\n", type);
+#endif 
+         return(0);
+    }
+}
+
+struct cmsghdr *
+inet6_rthdr_init(bp, type)
+    void *bp;
+    int type;
+{
+    register struct cmsghdr *ch = (struct cmsghdr *)bp;
+    register 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) - sizeof(struct in6_addr));
+         bzero(rthdr, sizeof(struct ip6_rthdr0));
+         rthdr->ip6r_type = IPV6_RTHDR_TYPE_0;
+         return(ch);
+     default:
+#ifdef DEBUG
+         fprintf(stderr, "inet6_rthdr_init: unknown type(%d)\n", type);
+#endif 
+         return(NULL);
+    }
+}
+
+int
+inet6_rthdr_add(cmsg, addr, flags)
+    struct cmsghdr *cmsg;
+    const struct in6_addr *addr;
+    u_int flags;
+{
+    register 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 && flags != IPV6_RTHDR_STRICT) {
+#ifdef DEBUG
+             fprintf(stderr, "inet6_rthdr_add: unsupported flag(%u)\n", flags);
+#endif 
+             return(-1);
+         }
+         if (rt0->ip6r0_segleft == 23) {
+#ifdef DEBUG
+             fprintf(stderr, "inet6_rthdr_add: segment overflow\n");
+#endif 
+             return(-1);
+         }
+         if (flags == IPV6_RTHDR_STRICT) {
+             int c, b;
+             c = rt0->ip6r0_segleft / 8;
+             b = rt0->ip6r0_segleft % 8;
+             rt0->ip6r0_slmap[c] |= (1 << (7 - b));
+         }
+         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:
+#ifdef DEBUG
+         fprintf(stderr, "inet6_rthdr_add: unknown type(%u)\n",
+                 rthdr->ip6r_type);
+#endif 
+         return(-1);
+    }
+
+    return(0);
+}
+
+int
+inet6_rthdr_lasthop(cmsg, flags)
+    struct cmsghdr *cmsg;
+    unsigned int flags;
+{
+    register 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 && flags != IPV6_RTHDR_STRICT) {
+#ifdef DEBUG
+             fprintf(stderr, "inet6_rthdr_lasthop: unsupported flag(%u)\n", flags);
+#endif 
+             return(-1);
+         }
+         if (rt0->ip6r0_segleft > 23) {
+#ifdef DEBUG
+             fprintf(stderr, "inet6_rthdr_add: segment overflow\n");
+#endif 
+             return(-1);
+         }
+         if (flags == IPV6_RTHDR_STRICT) {
+             int c, b;
+             c = rt0->ip6r0_segleft / 8;
+             b = rt0->ip6r0_segleft % 8;
+             rt0->ip6r0_slmap[c] |= (1 << (7 - b));
+         }
+         break;
+     }
+     default:
+#ifdef DEBUG
+         fprintf(stderr, "inet6_rthdr_lasthop: unknown type(%u)\n",
+                 rthdr->ip6r_type);
+#endif 
+         return(-1);
+    }
+
+    return(0);
+}
+
+#if 0
+int
+inet6_rthdr_reverse(in, out)
+    const struct cmsghdr *in;
+    struct cmsghdr *out;
+{
+#ifdef DEBUG
+    fprintf(stderr, "inet6_rthdr_reverse: not implemented yet\n");
+#endif 
+    return -1;
+}
+#endif
+
+int
+inet6_rthdr_segments(cmsg)
+    const struct cmsghdr *cmsg;
+{
+    register 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) {
+#ifdef DEBUG
+            fprintf(stderr, "inet6_rthdr_segments: invalid size(%u)\n",
+                rt0->ip6r0_len);
+#endif 
+            return -1;
+        }
+
+        return (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+      }
+
+    default:
+#ifdef DEBUG
+        fprintf(stderr, "inet6_rthdr_segments: unknown type(%u)\n",
+            rthdr->ip6r_type);
+#endif 
+        return -1;
+    }
+}
+
+struct in6_addr *
+inet6_rthdr_getaddr(cmsg, index)
+    struct cmsghdr *cmsg;
+    int index;
+{
+    register 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) {
+#ifdef DEBUG
+            fprintf(stderr, "inet6_rthdr_getaddr: invalid size(%u)\n",
+                rt0->ip6r0_len);
+#endif 
+            return NULL;
+        }
+        naddr = (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+        if (index <= 0 || naddr < index) {
+#ifdef DEBUG
+            fprintf(stderr, "inet6_rthdr_getaddr: invalid index(%d)\n", index);
+#endif 
+            return NULL;
+        }
+        return &rt0->ip6r0_addr[index - 1];
+      }
+
+    default:
+#ifdef DEBUG
+        fprintf(stderr, "inet6_rthdr_getaddr: unknown type(%u)\n",
+            rthdr->ip6r_type);
+#endif 
+        return NULL;
+    }
+}
+
+int
+inet6_rthdr_getflags(cmsg, index)
+    const struct cmsghdr *cmsg;
+    int index;
+{
+    register 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) {
+#ifdef DEBUG
+            fprintf(stderr, "inet6_rthdr_getflags: invalid size(%u)\n",
+                rt0->ip6r0_len);
+#endif 
+            return -1;
+        }
+        naddr = (rt0->ip6r0_len * 8) / sizeof(struct in6_addr);
+        if (index < 0 || naddr < index) {
+#ifdef DEBUG
+            fprintf(stderr, "inet6_rthdr_getflags: invalid index(%d)\n", index);
+#endif 
+            return -1;
+        }
+        if (rt0->ip6r0_slmap[index / 8] & (0x80 >> (index % 8)))
+            return IPV6_RTHDR_STRICT;
+        else
+            return IPV6_RTHDR_LOOSE;
+      }
+
+    default:
+#ifdef DEBUG
+        fprintf(stderr, "inet6_rthdr_getflags: unknown type(%u)\n",
+            rthdr->ip6r_type);
+#endif 
+        return -1;
+    }
+}
diff --git a/src/lib/libc/net/send.c b/src/lib/libc/net/send.c
index 88f3550ec6..8495931ca3 100644
--- a/src/lib/libc/net/send.c
+++ b/src/lib/libc/net/send.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: send.c,v 1.6 1995/02/25 06:21:02 cgd Exp $     */
-
 /*
  * Copyright (c) 1988, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: send.c,v 1.2 1996/08/19 08:29:52 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
diff --git a/src/lib/libc/net/sethostent.c b/src/lib/libc/net/sethostent.c
index 00f6499695..40a5a80962 100644
--- a/src/lib/libc/net/sethostent.c
+++ b/src/lib/libc/net/sethostent.c
@@ -1,5 +1,3 @@
-/*      $NetBSD: sethostent.c,v 1.4 1995/02/25 06:21:03 cgd Exp $       */
-
 /*
  * Copyright (c) 1985, 1993
  *      The Regents of the University of California.  All rights reserved.
@@ -34,11 +32,7 @@
  */
 
 #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
+static char rcsid[] = "$OpenBSD: sethostent.c,v 1.5 2003/01/28 04:58:00 marc Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -47,16 +41,25 @@ static char rcsid[] = "$NetBSD: sethostent.c,v 1.4 1995/02/25 06:21:03 cgd Exp $
 #include <netdb.h>
 #include <resolv.h>
 
+#include "thread_private.h"
+
 void
 sethostent(stayopen)
+        int stayopen;
 {
+        struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
+
+        if ((_resp->options & RES_INIT) == 0 && res_init() == -1)
+                return;
         if (stayopen)
-                _res.options |= RES_STAYOPEN | RES_USEVC;
+                _resp->options |= RES_STAYOPEN | RES_USEVC;
 }
 
 void
 endhostent()
 {
-        _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..bfbbdcb7f4 100644
--- a/src/lib/libc/stdlib/Makefile.inc
+++ b/src/lib/libc/stdlib/Makefile.inc
@@ -1,24 +1,28 @@
-#       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 $
+#       $OpenBDS: Makefile.inc,v 1.6 1996/08/21 03:47:21 tholo Exp $
 
 # stdlib sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/stdlib ${.CURDIR}/stdlib
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/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 \
+SRCS+=  a64l.c abort.c atexit.c atoi.c atof.c atol.c atoll.c bsearch.c \
+        calloc.c cfree.c exit.c ecvt.c gcvt.c getenv.c getopt.c getopt_long.c \
+        getsubopt.c heapsort.c l64a.c lsearch.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
+        setenv.c strtod.c strtol.c strtoll.c strtoul.c strtoull.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
 
 .if   (${MACHINE_ARCH} == "m68k")
 SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
 .elif (${MACHINE_ARCH} == "i386")
 SRCS+=  abs.S div.S labs.S ldiv.S
+LSRCS+= abs.c div.c labs.c ldiv.c
 .elif (${MACHINE_ARCH} == "ns32k")
 SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
 .elif (${MACHINE_ARCH} == "tahoe")
 SRCS+=  abs.S div.c labs.c ldiv.c
+LSRCS+= abs.c
 .elif (${MACHINE_ARCH} == "vax")
 SRCS+=  abs.c div.c labs.c ldiv.c
 .elif (${MACHINE_ARCH} == "alpha")
@@ -28,18 +32,36 @@ SRCS+=	abs.c div.c labs.c ldiv.c
 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_ARCH} == "vax") || (${MACHINE_ARCH} == "m68k")
+SRCS+=  insque.S remque.S
+.else
+SRCS+=  insque.c remque.c
+.endif
+
+MAN+=   a64l.3 abort.3 abs.3 alloca.3 atexit.3 atof.3 atoi.3 atol.3 atoll.3 \
+        bsearch.3 div.3 ecvt.3 exit.3 getenv.3 getopt.3 getopt_long.3 \
+        getsubopt.3 insque.3 labs.3 ldiv.3 lsearch.3 malloc.3 memory.3 qabs.3 \
+        qdiv.3 qsort.3 radixsort.3 rand48.3 rand.3 random.3 realpath.3 \
+        strtod.3 strtol.3 strtoul.3 system.3 tsearch.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+=insque.3 remque.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+=strtol.3 strtoll.3 strtol.3 strtoq.3
+MLINKS+=strtoul.3 strtoull.3 strtoul.3 strtouq.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/_rand48.c b/src/lib/libc/stdlib/_rand48.c
index 83ade4645a..fed7372f68 100644
--- a/src/lib/libc/stdlib/_rand48.c
+++ b/src/lib/libc/stdlib/_rand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: _rand48.c,v 1.2 1996/08/19 08:33:19 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 unsigned short __rand48_seed[3] = {
diff --git a/src/lib/libc/stdlib/a64l.3 b/src/lib/libc/stdlib/a64l.3
new file mode 100644
index 0000000000..6b9fd23154
--- /dev/null
+++ b/src/lib/libc/stdlib/a64l.3
@@ -0,0 +1,144 @@
+.\" Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+.\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+.\" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+.\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+.\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+.\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+.\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+.\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\" $OpenBSD: a64l.3,v 1.6 2003/05/10 06:48:30 jmc Exp $
+.\"
+.Dd August 17, 1997
+.Dt A64L 3
+.Os
+.Sh NAME
+.Nm a64l ,
+.Nm l64a
+.Nd convert between 32-bit integer and radix-64 ASCII string
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft long
+.Fn a64l "const char *s"
+.Ft char *
+.Fn l64a "long l"
+.Sh DESCRIPTION
+The
+.Fn a64l
+and
+.Fn l64a
+functions are used to maintain numbers stored in radix-64
+.Tn ASCII
+characters.
+This is a notation by which 32-bit integers
+can be represented by up to six characters; each character represents a
+.Dq digit
+in a radix-64 notation.
+.Pp
+The characters used to represent digits are
+.Ql \&.
+for 0,
+.Ql /
+for 1,
+.Ql 0
+through
+.Ql 9
+for 2-11,
+.Ql A
+through
+.Ql Z
+for 12-37, and
+.Ql a
+through
+.Ql z
+for 38-63.
+.Pp
+The
+.Fn a64l
+function takes a pointer to a null-terminated radix-64 representation
+and returns a corresponding 32-bit value.
+If the string pointed to by
+.Fa s
+contains more than six characters,
+.Fn a64l
+will use the first six.
+.Fn a64l
+scans the character string from left to right, decoding
+each character as a 6-bit radix-64 number.
+If a long integer is
+larger than 32 bits, the return value will be sign-extended.
+.Pp
+.Fn l64a
+takes a long integer argument
+.Fa l
+and returns a pointer to the corresponding radix-64 representation.
+.Sh RETURN VALUES
+On success,
+.Fn a64l
+returns a 32-bit representation of
+.Fa s .
+If
+.Fa s
+is a null pointer or if it contains digits other than those described above,
+.Fn a64l
+returns \-1 and sets the global variable
+.Va errno
+to
+.Er EINVAL .
+.Pp
+On success,
+.Fn l64a
+returns a pointer to a string containing the radix-64 representation of
+.Fa l .
+If
+.Fa l
+is 0,
+.Fn l64a
+returns a pointer to the empty string.
+If
+.Fa l
+is negative,
+.Fn l64a
+returns a null pointer and sets the global variable
+.Va errno
+to
+.Er EINVAL .
+.Sh WARNINGS
+The value returned by
+.Fn l64a
+is a pointer into a static buffer, the contents of which
+will be overwritten by subsequent calls.
+.Pp
+The value returned by
+.Fn a64l
+may be incorrect if the value is too large; for that reason, only strings
+that resulted from a call to
+.Fn l64a
+should be used to call
+.Fn a64l .
+.Pp
+If a long integer is larger than 32 bits, only the low-order
+32 bits are used.
+.Sh STANDARDS
+The
+.Fn a64l
+and
+.Fn l64a
+functions conform to
+.St -xpg4.2 .
diff --git a/src/lib/libc/stdlib/a64l.c b/src/lib/libc/stdlib/a64l.c
index 03fc77e034..a68f0a6dcd 100644
--- a/src/lib/libc/stdlib/a64l.c
+++ b/src/lib/libc/stdlib/a64l.c
@@ -4,8 +4,11 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: a64l.c,v 1.3 1995/05/11 23:04:47 jtc Exp $";
-#endif
+static char *rcsid = "$OpenBSD: a64l.c,v 1.3 1997/08/17 22:58:34 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <errno.h>
+#include <stdlib.h>
 
 long
 a64l(s)
@@ -14,21 +17,30 @@ a64l(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..743d42dd8a 100644
--- a/src/lib/libc/stdlib/abort.3
+++ b/src/lib/libc/stdlib/abort.3
@@ -33,8 +33,7 @@
 .\" 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.6 2000/04/20 13:50:01 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt ABORT 3
@@ -49,23 +48,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..a833a1a8b7 100644
--- a/src/lib/libc/stdlib/abort.c
+++ b/src/lib/libc/stdlib/abort.c
@@ -32,26 +32,43 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: abort.c,v 1.11 2002/11/05 22:19:55 marc 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()
 {
+        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) {
+                while (p != NULL && p->next != NULL)
+                        p = p->next;
+                if (p != NULL && p->fns[0] != NULL) {
+                        cleanup_called = 1;
+                        (*p->fns[0])();
+                }
+        }
+
         (void)kill(getpid(), SIGABRT);
 
         /*
@@ -59,7 +76,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);
 }
diff --git a/src/lib/libc/stdlib/abs.3 b/src/lib/libc/stdlib/abs.3
index 4748d89e77..0f7c097ade 100644
--- a/src/lib/libc/stdlib/abs.3
+++ b/src/lib/libc/stdlib/abs.3
@@ -33,8 +33,7 @@
 .\" 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.5 2000/04/20 13:50:01 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt ABS 3
@@ -49,21 +48,17 @@
 .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 labs 3 ,
 .Xr math 3
 .Sh STANDARDS
 The
diff --git a/src/lib/libc/stdlib/abs.c b/src/lib/libc/stdlib/abs.c
index 64468e0224..7c79e4073c 100644
--- a/src/lib/libc/stdlib/abs.c
+++ b/src/lib/libc/stdlib/abs.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: abs.c,v 1.2 1996/08/19 08:33:21 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/alloca.3 b/src/lib/libc/stdlib/alloca.3
index dcb97ab11c..431443a6e6 100644
--- a/src/lib/libc/stdlib/alloca.3
+++ b/src/lib/libc/stdlib/alloca.3
@@ -29,12 +29,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.9 2001/12/06 04:21:27 deraadt Exp $
 .\"
 .Dd May 2, 1991
 .Dt ALLOCA 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm alloca
 .Nd memory allocator
@@ -45,35 +44,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..5d79ede649 100644
--- a/src/lib/libc/stdlib/atexit.3
+++ b/src/lib/libc/stdlib/atexit.3
@@ -33,8 +33,7 @@
 .\" 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.4 2000/04/20 13:50:01 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt ATEXIT 3
@@ -49,13 +48,12 @@
 .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,
@@ -73,6 +71,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..98564d0dd3 100644
--- a/src/lib/libc/stdlib/atexit.c
+++ b/src/lib/libc/stdlib/atexit.c
@@ -1,68 +1,135 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
+/*
+ * 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 $";
+static char *rcsid = "$OpenBSD: atexit.c,v 1.7 2002/09/14 22:03:14 dhartmei Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#include <sys/types.h>
+#include <sys/mman.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include "atexit.h"
 
+int __atexit_invalid = 1;
 struct atexit *__atexit;
 
 /*
+ * Function pointers are stored in a linked list of pages. The list
+ * is initially empty, and pages are allocated on demand. The first
+ * function pointer in the first allocated page (the last one in
+ * the linked list) is reserved for the cleanup function.
+ *
+ * Outside the following two functions, all pages are mprotect()'ed
+ * to prevent unintentional/malicious corruption.
+ *
+ * The free(malloc(1)) is a workaround causing malloc_init() to
+ * ensure that malloc.c gets the first mmap() call for its sbrk()
+ * games.
+ */
+
+/*
  * Register a function to be performed at exit.
  */
 int
 atexit(fn)
         void (*fn)();
 {
-        static struct atexit __atexit0; /* one guaranteed table */
-        register struct atexit *p;
+        register struct atexit *p = __atexit;
+        register int pgsize = getpagesize();
 
-        if ((p = __atexit) == NULL)
-                __atexit = p = &__atexit0;
-        else if (p->ind >= ATEXIT_SIZE) {
-                if ((p = malloc(sizeof(*p))) == NULL)
+        if (pgsize < sizeof(*p))
+                return (-1);
+        if (p != NULL) {
+                if (p->ind + 1 >= p->max)
+                        p = NULL;
+                else if (mprotect(p, pgsize, PROT_READ | PROT_WRITE))
+                        return (-1);
+        }
+        if (p == NULL) {
+                if (__atexit_invalid) {
+                        free(malloc(1));
+                        __atexit_invalid = 0;
+                }
+                p = mmap(NULL, pgsize, PROT_READ | PROT_WRITE,
+                    MAP_ANON | MAP_PRIVATE, -1, 0);
+                if (p == MAP_FAILED)
                         return (-1);
-                p->ind = 0;
+                if (__atexit == NULL) {
+                        p->fns[0] = NULL;
+                        p->ind = 1;
+                } else
+                        p->ind = 0;
+                p->max = (pgsize - ((char *)&p->fns[0] - (char *)p)) /
+                    sizeof(p->fns[0]);
                 p->next = __atexit;
                 __atexit = p;
         }
         p->fns[p->ind++] = fn;
+        if (mprotect(p, pgsize, PROT_READ))
+                return (-1);
         return (0);
 }
+
+/*
+ * Register the cleanup function
+ */
+void
+__atexit_register_cleanup(fn)
+        void (*fn)();
+{
+        register struct atexit *p = __atexit;
+        register int pgsize = getpagesize();
+
+        if (pgsize < sizeof(*p))
+                return;
+        while (p != NULL && p->next != NULL)
+                p = p->next;
+        if (p == NULL) {
+                if (__atexit_invalid) {
+                        free(malloc(1));
+                        __atexit_invalid = 0;
+                }
+                p = mmap(NULL, pgsize, PROT_READ | PROT_WRITE,
+                    MAP_ANON | MAP_PRIVATE, -1, 0);
+                if (p == MAP_FAILED)
+                        return;
+                p->ind = 1;
+                p->max = (pgsize - ((char *)&p->fns[0] - (char *)p)) /
+                    sizeof(p->fns[0]);
+                p->next = NULL;
+                __atexit = p;
+        } else {
+                if (mprotect(p, pgsize, PROT_READ | PROT_WRITE))
+                    return;
+        }
+        p->fns[0] = fn;
+        mprotect(p, pgsize, PROT_READ);
+}
diff --git a/src/lib/libc/stdlib/atexit.h b/src/lib/libc/stdlib/atexit.h
index 8b756e8fe2..28bf3a7f27 100644
--- a/src/lib/libc/stdlib/atexit.h
+++ b/src/lib/libc/stdlib/atexit.h
@@ -1,46 +1,41 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
+/*      $OpenBSD: atexit.h,v 1.5 2002/08/30 07:58:07 dhartmei 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 */
+        void (*fns[1])();               /* the table itself */
 };
 
+extern int __atexit_invalid;
 extern struct atexit *__atexit;         /* points to head of LIFO stack */
diff --git a/src/lib/libc/stdlib/atof.3 b/src/lib/libc/stdlib/atof.3
index 53e04f71c5..0bd85dbe82 100644
--- a/src/lib/libc/stdlib/atof.3
+++ b/src/lib/libc/stdlib/atof.3
@@ -33,8 +33,7 @@
 .\" 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.3 1999/06/29 18:36:18 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt ATOF 3
@@ -52,9 +51,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..30bac19899 100644
--- a/src/lib/libc/stdlib/atof.c
+++ b/src/lib/libc/stdlib/atof.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: atof.c,v 1.2 1996/08/19 08:33:24 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/atoi.3 b/src/lib/libc/stdlib/atoi.3
index 219ba73c00..69b94be70c 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
@@ -33,10 +33,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.5 2000/04/20 13:50:01 aaron Exp $
 .\"
-.Dd June 29, 1991
+.Dd June 4, 1993
 .Dt ATOI 3
 .Os
 .Sh NAME
@@ -52,16 +51,27 @@ 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
+.Sh CAVEATS
+.Nm
+does no overflow checking, handles unsigned numbers poorly,
+and handles strings containing trailing extra characters
+(like
+.Dq "123abc" Ns )
+poorly.
+Careful use of
+.Xr strtol 3
+and
+.Xr strtoul 3
+can alleviate these problems.
 .Sh SEE ALSO
 .Xr atof 3 ,
 .Xr atol 3 ,
diff --git a/src/lib/libc/stdlib/atoi.c b/src/lib/libc/stdlib/atoi.c
index df7845f90c..a74d6e1351 100644
--- a/src/lib/libc/stdlib/atoi.c
+++ b/src/lib/libc/stdlib/atoi.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: atoi.c,v 1.2 1996/08/19 08:33:24 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/atol.3 b/src/lib/libc/stdlib/atol.3
index 86e3d324a3..cd276a571f 100644
--- a/src/lib/libc/stdlib/atol.3
+++ b/src/lib/libc/stdlib/atol.3
@@ -33,8 +33,7 @@
 .\" 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.5 2002/11/21 20:54:09 millert Exp $
 .\"
 .Dd June 29, 1991
 .Dt ATOL 3
@@ -52,9 +51,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 +63,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..528a932214 100644
--- a/src/lib/libc/stdlib/atol.c
+++ b/src/lib/libc/stdlib/atol.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: atol.c,v 1.2 1996/08/19 08:33:26 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/calloc.3 b/src/lib/libc/stdlib/atoll.3
index d0754b46a0..8be46407c3 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
@@ -33,39 +33,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.2 2002/11/21 20:54:09 millert Exp $
 .\"
 .Dd June 29, 1991
-.Dt CALLOC 3
+.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 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/atoll.c b/src/lib/libc/stdlib/atoll.c
new file mode 100644
index 0000000000..63a5b35cd4
--- /dev/null
+++ b/src/lib/libc/stdlib/atoll.c
@@ -0,0 +1,45 @@
+/*
+ * 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 *rcsid = "$OpenBSD: atoll.c,v 1.1 2002/11/21 20:51:20 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdlib.h>
+
+long long
+atoll(str)
+        const char *str;
+{
+        return(strtoll(str, (char **)NULL, 10));
+}
diff --git a/src/lib/libc/stdlib/bsearch.3 b/src/lib/libc/stdlib/bsearch.3
index 1622c96c6b..9bb9d4ece4 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
@@ -33,10 +33,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.5 2000/04/20 13:50:01 aaron Exp $
 .\"
-.Dd June 29, 1991
+.Dd April 19, 1994
 .Dt BSEARCH 3
 .Os
 .Sh NAME
@@ -51,12 +50,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 +63,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 +80,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..1903202b6c 100644
--- a/src/lib/libc/stdlib/bsearch.c
+++ b/src/lib/libc/stdlib/bsearch.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: bsearch.c,v 1.3 2002/02/16 21:27:24 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
@@ -60,7 +59,7 @@ bsearch(key, base0, nmemb, size, compar)
         const void *base0;
         size_t nmemb;
         register size_t size;
-        register int (*compar) __P((const void *, const void *));
+        register int (*compar)(const void *, const void *);
 {
         register const char *base = base0;
         register int lim, cmp;
diff --git a/src/lib/libc/stdlib/calloc.c b/src/lib/libc/stdlib/calloc.c
index 3353fab052..c75b256d14 100644
--- a/src/lib/libc/stdlib/calloc.c
+++ b/src/lib/libc/stdlib/calloc.c
@@ -32,12 +32,13 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: calloc.c,v 1.7 2002/07/31 09:19:04 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
+#include <errno.h>
 
 void *
 calloc(num, size)
@@ -46,8 +47,13 @@ calloc(num, size)
 {
         register void *p;
 
+        if (num && size && SIZE_T_MAX / num < size) {
+                errno = ENOMEM;
+                return NULL;
+        }
         size *= num;
-        if (p = malloc(size))
-                memset(p, '\0', size);
+        p = malloc(size);
+        if (p)
+                memset(p, 0, size);
         return(p);
 }
diff --git a/src/lib/libc/stdlib/cfree.c b/src/lib/libc/stdlib/cfree.c
new file mode 100644
index 0000000000..3af32039a9
--- /dev/null
+++ b/src/lib/libc/stdlib/cfree.c
@@ -0,0 +1,49 @@
+/*      $OpenBSD: cfree.c,v 1.1 1996/08/21 03:47:22 tholo 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by SigmaSoft, Th.  Lockert.
+ * 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 ``AS IS'' AND ANY EXPRESS OR IMPLIED 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: cfree.c,v 1.1 1996/08/21 03:47:22 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/cdefs.h>
+
+#ifdef __indr_reference
+__indr_reference(free, cfree);
+#else
+
+void
+cfree(p)
+        void *p;
+{
+    free(p);
+}
+#endif
diff --git a/src/lib/libc/stdlib/div.3 b/src/lib/libc/stdlib/div.3
index a4730694a5..1f651d7fd3 100644
--- a/src/lib/libc/stdlib/div.3
+++ b/src/lib/libc/stdlib/div.3
@@ -31,8 +31,7 @@
 .\" 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.5 2000/04/20 13:50:02 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt DIV 3
@@ -47,24 +46,22 @@
 .Sh DESCRIPTION
 The
 .Fn div
-function
-computes the value
-.Fa num/denom
+function computes the value
+.Fa num Ns No / 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 ldiv 3 ,
-.Xr qdiv 3 ,
-.Xr math 3
+.Xr math 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..c1fae29008 100644
--- a/src/lib/libc/stdlib/div.c
+++ b/src/lib/libc/stdlib/div.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: div.c,v 1.2 1996/08/19 08:33:29 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>             /* div_t */
diff --git a/src/lib/libc/stdlib/drand48.c b/src/lib/libc/stdlib/drand48.c
index ae1a8634dc..02886d5b62 100644
--- a/src/lib/libc/stdlib/drand48.c
+++ b/src/lib/libc/stdlib/drand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: drand48.c,v 1.2 1996/08/19 08:33:29 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/ecvt.3 b/src/lib/libc/stdlib/ecvt.3
new file mode 100644
index 0000000000..64559ec09e
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.3
@@ -0,0 +1,172 @@
+.\" $OpenBSD
+.\"
+.\" Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+.\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+.\" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+.\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+.\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+.\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+.\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+.\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd December 1, 2002
+.Dt ECVT 3
+.Os
+.Sh NAME
+.Nm ecvt ,
+.Nm fcvt ,
+.Nm gcvt
+.Nd convert double to
+.Tn ASCII
+string
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Ft char *
+.Fn ecvt "double value" "int ndigit" "int *decpt" "int *sign"
+.Ft char *
+.Fn fcvt "double value" "int ndigit" "int *decpt" "int *sign"
+.Ft char *
+.Fn gcvt "double value" "int ndigit" "char *buf"
+.Sh DESCRIPTION
+.Bf -symbolic
+These functions are provided for compatibility with legacy code.
+New code should use the
+.Xr snprintf 3
+function for improved safety and portability.
+.Ef
+.Pp
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions convert the double precision floating-point number
+.Fa value
+to a NUL-terminated
+.Tn ASCII
+string.
+.Pp
+The
+.Fn ecvt
+function converts
+.Fa value
+to a NUL-terminated string of exactly
+.Fa ndigit
+digits and returns a pointer to that string.
+The result is padded with zeroes from left to right as needed.
+There are no leading zeroes unless
+.Fa value
+itself is 0.
+The least significant digit is rounded in an implementation-dependent manner.
+The position of the decimal point relative to the beginning of the string
+is stored in
+.Fa decpt .
+A negative value indicates that the decimal point is located
+to the left of the returned digits (this occurs when there is no
+whole number component to
+.Fa value ) .
+If
+.Fa value
+is zero, it is unspecified whether the integer pointed to by
+.Fa decpt
+will be 0 or 1.
+The decimal point itself is not included in the returned string.
+If the sign of the result is negative, the integer pointed to by
+.Fa sign
+is non-zero; otherwise, it is 0.
+.Pp
+If the converted value is out of range or is not representable,
+the contents of the returned string are unspecified.
+.Pp
+The
+.Fn fcvt
+function is identical to
+.Fn ecvt
+with the exception that
+.Fa ndigit
+specifies the number of digits after the decimal point (zero-padded as
+needed).
+.Pp
+The
+.Fn gcvt
+function converts
+.Fa value
+to a NUL-terminated string similar to the %g
+.Xr printf 3
+format specifier and stores the result in
+.Fa buf .
+It produces
+.Fa ndigit
+significant digits similar to the %f
+.Xr printf 3
+format specifier where possible.
+If
+.Fa ndigit
+does allow sufficient precision, the result is stored in
+exponential notation similar to the %e
+.Xr printf 3
+format specifier.
+If
+.Fa value
+is less than zero,
+.Fa buf
+will be prefixed with a minus sign.
+A decimal point is included in the returned string if
+.Fa value
+is not a whole number.
+Unlike the
+.Fn ecvt
+and
+.Fn fcvt
+functions,
+.Fa buf
+is not zero-padded.
+.Sh RETURN VALUES
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions return a NUL-terminated string representation of
+.Fa value .
+.Sh WARNINGS
+The
+.Fn ecvt
+and
+.Fn fcvt
+functions return a pointer to internal storage space that will be
+overwritten by subsequent calls to either function.
+.Pp
+The maximum possible precision of the return value is limited by the
+precision of a double and may not be the same on all architectures.
+.Pp
+The
+.Xr snprintf 3
+function is preferred over these functions for new code.
+.Sh SEE ALSO
+.Xr printf 3 ,
+.Xr strtod 3
+.Sh STANDARDS
+The
+.Fn ecvt ,
+.Fn fcvt
+and
+.Fn gcvt
+functions conform to
+.St -susv3 .
diff --git a/src/lib/libc/stdlib/ecvt.c b/src/lib/libc/stdlib/ecvt.c
new file mode 100644
index 0000000000..7460407c84
--- /dev/null
+++ b/src/lib/libc/stdlib/ecvt.c
@@ -0,0 +1,110 @@
+/*      $OpenBSD: ecvt.c,v 1.1 2002/12/02 15:38:54 millert Exp $        */
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: ecvt.c,v 1.1 2002/12/02 15:38:54 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char *__dtoa(double, int, int, int *, int *, char **);
+static char *__cvt(double, int, int *, int *, int, int);
+
+static char *
+__cvt(double value, int ndigit, int *decpt, int *sign, int fmode, int pad)
+{
+        static char *s;
+        char *p, *rve;
+        size_t siz;
+
+        if (ndigit == 0) {
+                *sign = value < 0.0;
+                *decpt = 0;
+                return ("");
+        }
+
+        if (s) {
+                free(s);
+                s = NULL;
+        }
+
+        if (ndigit < 0)
+                siz = -ndigit + 1;
+        else
+                siz = ndigit + 1;
+
+
+        /* __dtoa() doesn't allocate space for 0 so we do it by hand */
+        if (value == 0.0) {
+                *decpt = 1 - fmode;     /* 1 for 'e', 0 for 'f' */
+                *sign = 0;
+                if ((rve = s = (char *)malloc(siz)) == NULL)
+                        return(NULL);
+                *rve++ = '0';
+                *rve = '\0';
+        } else {
+                p = __dtoa(value, fmode + 2, ndigit, decpt, sign, &rve);
+                if (*decpt == 9999) {
+                        /* Nan or Infinity */
+                        *decpt = 0;
+                        return(p);
+                }
+                /* make a local copy and adjust rve to be in terms of s */
+                if (pad && fmode)
+                        siz += *decpt;
+                if ((s = (char *)malloc(siz)) == NULL)
+                        return(NULL);
+                (void) strlcpy(s, p, siz);
+                rve = s + (rve - p);
+        }
+
+        /* Add trailing zeros (unless we got NaN or Inf) */
+        if (pad && *decpt != 9999) {
+                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..b92dacffcc 100644
--- a/src/lib/libc/stdlib/erand48.c
+++ b/src/lib/libc/stdlib/erand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: erand48.c,v 1.2 1996/08/19 08:33:29 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 double
diff --git a/src/lib/libc/stdlib/exit.3 b/src/lib/libc/stdlib/exit.3
index adb81ffcb4..fb499e0946 100644
--- a/src/lib/libc/stdlib/exit.3
+++ b/src/lib/libc/stdlib/exit.3
@@ -33,8 +33,7 @@
 .\" 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.8 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd June 29, 1991
 .Dt EXIT 3
@@ -47,8 +46,9 @@
 .Ft void
 .Fn exit "int status"
 .Sh DESCRIPTION
-.Fn Exit
-terminates a process.
+The
+.Fn exit
+function terminates a process.
 .Pp
 Before termination it performs the following functions in the
 order listed:
@@ -66,19 +66,28 @@ Unlink all files created with the
 .Xr tmpfile 3
 function.
 .El
+.Pp
+Following this,
+.Fn exit
+calls
+.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.
+function never returns.
 .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
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/exit.c b/src/lib/libc/stdlib/exit.c
index b1412f42bb..e22bd5178e 100644
--- a/src/lib/libc/stdlib/exit.c
+++ b/src/lib/libc/stdlib/exit.c
@@ -32,15 +32,24 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: exit.c,v 1.8 2002/09/14 22:03:14 dhartmei 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.
@@ -49,13 +58,20 @@ void
 exit(status)
         int status;
 {
-        register struct atexit *p;
-        register int n;
+        register struct atexit *p, *q;
+        register int n, pgsize = getpagesize();
 
-        for (p = __atexit; p; p = p->next)
-                for (n = p->ind; --n >= 0;)
-                        (*p->fns[n])();
-        if (__cleanup)
-                (*__cleanup)();
+        if (!__atexit_invalid) {
+                p = __atexit;
+                while (p != NULL) {
+                        for (n = p->ind; --n >= 0;)
+                                if (p->fns[n] != NULL)
+                                        (*p->fns[n])();
+                        q = p;
+                        p = p->next;
+                        munmap(q, pgsize);
+                }
+        }
+        /* cleanup, if registered, was called through fns[0] in the last page */
         _exit(status);
 }
diff --git a/src/lib/libc/stdlib/free.3 b/src/lib/libc/stdlib/free.3
deleted file mode 100644
index 3d0131d7de..0000000000
--- a/src/lib/libc/stdlib/free.3
+++ /dev/null
@@ -1,82 +0,0 @@
-.\" Copyright (c) 1991 The Regents of the University of California.
-.\" All rights reserved.
-.\"
-.\" This code is derived from software contributed to Berkeley by
-.\" the American National Standards Committee X3, on Information
-.\" Processing Systems.
-.\"
-.\" Redistribution and use in source and binary forms, with or without
-.\" modification, are permitted provided that the following conditions
-.\" are met:
-.\" 1. Redistributions of source code must retain the above copyright
-.\"    notice, this list of conditions and the following disclaimer.
-.\" 2. Redistributions in binary form must reproduce the above copyright
-.\"    notice, this list of conditions and the following disclaimer in the
-.\"    documentation and/or other materials provided with the distribution.
-.\" 3. 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: @(#)free.3        5.2 (Berkeley) 6/29/91
-.\"     $Id: free.3,v 1.1.1.1 1995/10/18 08:42:17 deraadt Exp $
-.\"
-.Dd June 29, 1991
-.Dt FREE 3
-.Os
-.Sh NAME
-.Nm free
-.Nd free up memory allocated with malloc, calloc or realloc
-.Sh SYNOPSIS
-.Fd #include <stdlib.h>
-.Ft void
-.Fn free "void *ptr"
-.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.
-.Sh RETURN VALUES
-The
-.Fn free
-function returns no value.
-.Sh SEE ALSO
-.Xr calloc 3 ,
-.Xr malloc 3 ,
-.Xr realloc 3
-.Sh STANDARDS
-The
-.Fn free
-function conforms to
-.St -ansiC .
diff --git a/src/lib/libc/stdlib/gcvt.c b/src/lib/libc/stdlib/gcvt.c
new file mode 100644
index 0000000000..240c4db5b0
--- /dev/null
+++ b/src/lib/libc/stdlib/gcvt.c
@@ -0,0 +1,106 @@
+/*      $OpenBSD: gcvt.c,v 1.3 2003/05/09 20:01:43 millert Exp $        */
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: gcvt.c,v 1.3 2003/05/09 20:01:43 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char *__dtoa(double, int, int, int *, int *, char **);
+
+char *
+gcvt(double value, int ndigit, char *buf)
+{
+        char *digits, *dst, *src;
+        int i, decpt, sign;
+
+        if (ndigit == 0) {
+                buf[0] = '\0';
+                return (buf);
+        }
+
+        digits = __dtoa(value, 2, ndigit, &decpt, &sign, NULL);
+        if (decpt == 9999) {
+                /* Infinity or NaN, assume buffer is at least ndigit long. */
+                strlcpy(buf, digits, ndigit + 1);
+                return (buf);
+        }
+
+        dst = buf;
+        if (sign)
+                *dst++ = '-';
+
+        if (decpt < 0 || decpt > ndigit) {
+                /* exponential format */
+                if (--decpt < 0) {
+                        sign = 1;
+                        decpt = -decpt;
+                } else
+                        sign = 0;
+                for (src = digits; *src != '\0'; )
+                        *dst++ = *src++;
+                *dst++ = 'e';
+                if (sign)
+                        *dst++ = '-';
+                else
+                        *dst++ = '+';
+                if (decpt < 10) {
+                        *dst++ = '0';
+                        *dst++ = '0' + decpt;
+                        *dst = '\0';
+                } else {
+                        /* XXX - optimize */
+                        for (sign = decpt, i = 0; (sign /= 10) != 0; i++)
+                                sign /= 10;
+                        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') {
+                        *dst++ = '.';           /* XXX - locale-specific (LC_NUMERIC) */
+                        for (i = decpt; digits[i] != '\0'; i++) {
+                                *dst++ = digits[i];
+                        }
+                }
+                *dst = '\0';
+        }
+        return (buf);
+}
diff --git a/src/lib/libc/stdlib/getenv.3 b/src/lib/libc/stdlib/getenv.3
index 411eb35da4..b2aa0080d6 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
@@ -33,10 +33,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.7 2000/04/20 13:50:02 aaron Exp $
 .\"
-.Dd June 29, 1991
+.Dd December 11, 1993
 .Dt GETENV 3
 .Os
 .Sh NAME
@@ -56,59 +55,51 @@
 .Ft void
 .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 arguments
+.Fa name
 and
-.Ar value
-may be appended and prepended, 
-respectively,
-with an equal sign
+.Fa value
+may be appended and prepended, respectively, with an equal sign
 .Dq Li \&= .
 .Pp
 The
 .Fn getenv
 function obtains the current value of the environment variable,
-.Ar name .
+.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:
+function takes an argument of the form
+.Ar name Ns No = Ns Ar value
+and is equivalent to:
 .Bd -literal -offset indent
 setenv(name, value, 1);
 .Ed
 .Pp
 The
 .Fn unsetenv
-function
-deletes all instances of the variable name pointed to by
+function deletes all instances of the variable name pointed to by
 .Fa name
 from the list.
 .Sh RETURN VALUES
@@ -118,10 +109,13 @@ and
 .Fn putenv
 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
+.Bl -tag -width [ENOMEM]
 .It Bq Er ENOMEM
 The function
 .Fn setenv
diff --git a/src/lib/libc/stdlib/getenv.c b/src/lib/libc/stdlib/getenv.c
index 09d47f2149..934f10928f 100644
--- a/src/lib/libc/stdlib/getenv.c
+++ b/src/lib/libc/stdlib/getenv.c
@@ -1,6 +1,6 @@
 /*
- * 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
@@ -32,26 +32,13 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: getenv.c,v 1.5 2002/12/10 22:44:12 mickey 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 *offset);
 
 /*
  * __findenv --
@@ -63,20 +50,39 @@ getenv(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 *offset)
 {
         extern char **environ;
-        register int len;
-        register char **P, *C;
+        register int len, i;
+        register const char *np;
+        register char **p, *cp;
+
+        if (name == NULL || environ == NULL)
+                return (NULL);
+        for (np = name; *np && *np != '='; ++np)
+                ;
+        len = np - name;
+        for (p = environ; (cp = *p) != NULL; ++p) {
+                for (np = name, i = len; i && *cp; i--)
+                        if (*cp++ != *np++)
+                                break;
+                if (i == 0 && *cp++ == '=') {
+                        *offset = p - environ;
+                        return (cp);
+                }
+        }
+        return (NULL);
+}
+
+/*
+ * getenv --
+ *      Returns ptr to value associated with name, if any, else NULL.
+ */
+char *
+getenv(name)
+        const char *name;
+{
+        int offset;
 
-        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);
+        return (__findenv(name, &offset));
 }
diff --git a/src/lib/libc/stdlib/getopt.3 b/src/lib/libc/stdlib/getopt.3
index f843881afd..d25b497035 100644
--- a/src/lib/libc/stdlib/getopt.3
+++ b/src/lib/libc/stdlib/getopt.3
@@ -29,11 +29,11 @@
 .\" 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.22 2003/05/10 06:48:30 jmc Exp $
 .\"
-.Dd April 19, 1994
+.Dd December 8, 2002
 .Dt GETOPT 3
-.Os BSD 4.3
+.Os
 .Sh NAME
 .Nm getopt
 .Nd get option character from command line argument list
@@ -51,30 +51,28 @@ The
 .Fn getopt
 function incrementally parses a command line argument list
 .Fa argv
-and returns the next
-.Em known
-option character.
+and returns the next known option character.
 An option character is
-.Em known
+.Dq known
 if it has been specified in the string of accepted option characters,
 .Fa optstring .
 .Pp
 The option string
 .Fa optstring
-may contain the following elements: individual characters, and
+may contain the following elements: individual characters and
 characters followed by a colon to indicate an option argument
 is to follow.
 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.
 .Pp
 On return from
 .Fn getopt ,
@@ -89,12 +87,10 @@ to
 .Fn getopt .
 The variable
 .Va optopt
-saves the last
-.Em known
-option character returned by
+saves the last known option character returned by
 .Fn getopt .
 .Pp
-The variable
+The variables
 .Va opterr
 and
 .Va optind
@@ -119,10 +115,7 @@ 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 --
@@ -133,49 +126,36 @@ 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 ? .
+If
+.Fa optstring
+has a leading
+.Sq \:
+then a missing option argument causes
+.Sq \:
+to be returned instead of
+.Sq ? .
 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
+function returns \-1 when the argument list is exhausted.
+.Sh EXAMPLES
 .Bd -literal -compact
-extern char *optarg;
-extern int optind;
 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;
@@ -189,31 +169,69 @@ while ((ch = getopt(argc, argv, "bf:")) != -1)
         case '?':
         default:
                 usage();
+        }
 }
 argc -= optind;
 argv += optind;
 .Ed
+.Sh SEE ALSO
+.Xr getopt 1 ,
+.Xr getopt_long 3 ,
+.Xr getsubopt 3
+.Sh DIAGNOSTICS
+If the
+.Fn getopt
+function encounters a character not found in the string
+.Va 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
+.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
+.Ql - ;
+this is reasonable but reduces the amount of error checking possible.
+.Sh EXTENSIONS
+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 HISTORY
 The
 .Fn getopt
-function appeared
+function appeared in
 .Bx 4.3 .
 .Sh BUGS
 The
 .Fn getopt
 function was once specified to return
-.Dv EOF 
+.Dv EOF
 instead of \-1.
 This was changed by
 .St -p1003.2-92
-to decouple 
+to decouple
 .Fn getopt
-from 
+from
 .Pa <stdio.h> .
 .Pp
 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,15 +239,25 @@ 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 ,
+which assigns different meaning to an
+.Fa optstring
+that begins with a
+.Ql - .
 By default, a single dash causes
 .Fn getopt
 to return \-1.
-This is, we believe, compatible with System V.
 .Pp
 It is also possible to handle digits as option letters.
 This allows
@@ -242,18 +270,19 @@ It is provided for backward compatibility
 .Em only .
 The following code fragment works in most cases.
 .Bd -literal -offset indent
-int length;
+int ch;
+long length;
 char *p;
 
-while ((c = getopt(argc, argv, "0123456789")) != -1)
-        switch (c) {
+while ((ch = getopt(argc, argv, "0123456789")) != -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);
+                        length = ch - '0';
                 else
-                        length = atoi(argv[optind] + 1);
+                        length = strtol(argv[optind] + 1, NULL, 10);
                 break;
         }
 }
diff --git a/src/lib/libc/stdlib/getopt.c b/src/lib/libc/stdlib/getopt.c
index 63c5e6a479..fc0f8c1bc7 100644
--- a/src/lib/libc/stdlib/getopt.c
+++ b/src/lib/libc/stdlib/getopt.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: getopt.c,v 1.4 2002/12/08 22:57:14 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdio.h>
@@ -64,6 +63,9 @@ getopt(nargc, nargv, ostr)
         static char *place = EMSG;              /* option letter processing */
         char *oli;                              /* option letter list index */
 
+        if (ostr == NULL)
+                return (-1);
+
         if (optreset || !*place) {              /* update scanning pointer */
                 optreset = 0;
                 if (optind >= nargc || *(place = nargv[optind]) != '-') {
diff --git a/src/lib/libc/stdlib/getopt_long.3 b/src/lib/libc/stdlib/getopt_long.3
new file mode 100644
index 0000000000..2589bd7b03
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.3
@@ -0,0 +1,373 @@
+.\"     $OpenBSD: getopt_long.3,v 1.6 2003/05/10 06:48:30 jmc 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. 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.
+.\"
+.\"     @(#)getopt.3    8.5 (Berkeley) 4/27/95
+.\"
+.Dd April 1, 2000
+.Dt GETOPT_LONG 3
+.Os
+.Sh NAME
+.Nm getopt_long ,
+.Nm getopt_long_only
+.Nd get long options from command line argument list
+.Sh SYNOPSIS
+.Fd #include <getopt.h>
+.Vt extern char *optarg;
+.Vt extern int optind;
+.Vt extern int optopt;
+.Vt extern int opterr;
+.Vt extern int optreset;
+.Ft int
+.Fn getopt_long "int argc" "char * const *argv" "const char *optstring" "const struct option *longopts" "int *index"
+.Ft int
+.Fn getopt_long_only "int argc" "char * const *argv" "const char *optstring" "const struct option *longopts" "int *index"
+.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
+myprogram --myoption=somevalue
+.Ed
+.Pp
+When a long option is processed the call to
+.Fn getopt_long
+will return 0.
+For this reason, long option processing without
+shortcuts is not backwards compatible with
+.Xr getopt 3 .
+.Pp
+It is possible to combine these methods, providing for long options
+processing with short option equivalents for some options.
+Less frequently used options would be processed as long options only.
+.Pp
+The
+.Fn getopt_long
+call requires a structure to be initialized describing the long
+options.
+The structure is:
+.Bd -literal
+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:
+.Bl -tag -width "optional_argument"
+.It Li no_argument
+no argument to the option is expect.
+.It Li required_argument
+an argument to the option is required.
+.It Li 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
+The
+.Fn getopt_long_only
+function behaves identically to
+.Fn getopt_long
+with the exception that long options may start with
+.Sq -
+in addition to
+.Sq -- .
+If an option starting with
+.Sq -
+does not match a long option but does match a single-character option,
+the single-character option is returned.
+.Sh RETURN VALUES
+If the
+.Fa flag
+field in
+.Li struct option
+is
+.Dv NULL ,
+.Fn getopt_long
+and
+.Fn getopt_long_only
+return the value specified in the
+.Fa val
+field, which is usually just the corresponding short option.
+If
+.Fa flag
+is not
+.Dv NULL ,
+these functions return 0 and store
+.Fa val
+in the location pointed to by
+.Fa flag .
+These functions return
+.Sq \:
+if there was a missing option argument,
+.Sq ?
+if the user specified an unknown or ambiguous option, and
+\-1 when the argument list has been exhausted.
+.Sh EXAMPLES
+.Bd -literal -compact
+int bflag, ch, fd;
+int daggerset;
+
+/* options descriptor */
+static struct option longopts[] = {
+        { "buffy",      no_argument,            0,              'b' },
+        { "fluoride",   required_argument,      0,              'f' },
+        { "daggerset",  no_argument,            &daggerset,     1 },
+        { 0,            0,                      0,              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;
+        case '?':
+        default:
+                usage();
+}
+argc -= optind;
+argv += optind;
+.Ed
+.Sh IMPLEMENTATION DIFFERENCES
+This section describes differences to the GNU implementation
+found in glibc-2.1.3:
+.Bl -tag -width "xxx"
+.It Li o
+handling of - as first char of option string in presence of
+environment variable POSIXLY_CORRECT:
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+ignores POSIXLY_CORRECT and returns non-options as
+arguments to option '\e1'.
+.It Li OpenBSD
+honors POSIXLY_CORRECT and stops at the first non-option.
+.El
+.It Li o
+handling of - within the option string (not the first character):
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+treats a
+.Ql -
+on the command line as a non-argument.
+.It Li 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 Li o
+handling of :: in options string in presence of POSIXLY_CORRECT:
+.Bl -tag -width "OpenBSD"
+.It Li Both
+GNU and OpenBSD ignore POSIXLY_CORRECT here and take :: to
+mean the preceding option takes an optional argument.
+.El
+.It Li o
+return value in case of missing argument if first character
+(after + or -) in option string is not ':':
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+returns '?'
+.It OpenBSD
+returns ':' (since OpenBSD's getopt does).
+.El
+.It Li o
+handling of --a in getopt:
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+parses this as option '-', option 'a'.
+.It Li OpenBSD
+parses this as '--', and returns \-1 (ignoring the a).
+(Because the original getopt does.)
+.El
+.It Li o
+setting of optopt for long options with flag !=
+.Dv NULL :
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+sets optopt to val.
+.It Li OpenBSD
+sets optopt to 0 (since val would never be returned).
+.El
+.It Li o
+handling of -W with W; in option string in getopt (not getopt_long):
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+causes a segfault.
+.It Li OpenBSD
+no special handling is done;
+.Dq W;
+is interpreted as two separate options, neither of which take an argument.
+.El
+.It Li o
+setting of optarg for long options without an argument that are
+invoked via -W (W; in option string):
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+sets optarg to the option name (the argument of -W).
+.It Li OpenBSD
+sets optarg to
+.Dv NULL
+(the argument of the long option).
+.El
+.It Li o
+handling of -W with an argument that is not (a prefix to) a known
+long option (W; in option string):
+.Bl -tag -width "OpenBSD"
+.It Li GNU
+returns -W with optarg set to the unknown option.
+.It Li OpenBSD
+treats this as an error (unknown option) and returns '?' with
+optopt set to 0 and optarg set to
+.Dv NULL
+(as GNU's man page documents).
+.El
+.It Li o
+The error messages are different.
+.It Li o
+OpenBSD 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 optind relative
+to current positions) are the same, though.
+(We do fewer variable swaps.)
+.El
+.Sh ENVIRONMENT
+.Bl -tag -width POSIXLY_CORRECT
+.It Ev POSIXLY_CORRECT
+If set, option processing stops when the first non-option is found and
+a leading
+.Sq -
+or
+.Sq +
+in the
+.Ar optstring
+is ignored.
+.El
+.Sh SEE ALSO
+.Xr getopt 3
+.Sh HISTORY
+The
+.Fn getopt_long
+and
+.Fn getopt_long_only
+functions first appeared in GNU libiberty.
+This implementation first appeared in
+.Ox 3.3 .
+.Sh BUGS
+The
+.Ar argv
+argument is not really
+.Dv const
+as its elements may be permuted (unless
+.Ev POSIXLY_CORRECT
+is set).
+.Pp
+In a future release, this implementation should completely replace
+.Xr getopt 3 .
diff --git a/src/lib/libc/stdlib/getopt_long.c b/src/lib/libc/stdlib/getopt_long.c
new file mode 100644
index 0000000000..0cdc4d652f
--- /dev/null
+++ b/src/lib/libc/stdlib/getopt_long.c
@@ -0,0 +1,543 @@
+/*      $OpenBSD: getopt_long.c,v 1.11 2002/12/10 17:51:42 millert 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>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *        This product includes software developed by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: getopt_long.c,v 1.11 2002/12/10 17:51:42 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef REPLACE_GETOPT
+int     opterr = 1;             /* if error message should be printed */
+int     optind = 1;             /* index into parent argv vector */
+int     optopt = '?';           /* character checked for validity */
+int     optreset;               /* reset getopt */
+char    *optarg;                /* argument associated with option */
+#endif
+
+#define PRINT_ERROR     ((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE    0x01    /* permute non-options to the end of argv */
+#define FLAG_ALLARGS    0x02    /* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY   0x04    /* operate as getopt_long_only */
+
+/* return values */
+#define BADCH           (int)'?'
+#define BADARG          ((*options == ':') ? (int)':' : (int)'?')
+#define INORDER         (int)1
+
+#define EMSG            ""
+
+static int getopt_internal(int, char * const *, const char *,
+                           const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+                              const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+        int c;
+
+        c = a % b;
+        while (c != 0) {
+                a = b;
+                b = c;
+                c = a % b;
+        }
+
+        return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+        char * const *nargv)
+{
+        int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+        char *swap;
+
+        /*
+         * compute lengths of blocks and number and size of cycles
+         */
+        nnonopts = panonopt_end - panonopt_start;
+        nopts = opt_end - panonopt_end;
+        ncycle = gcd(nnonopts, nopts);
+        cyclelen = (opt_end - panonopt_start) / ncycle;
+
+        for (i = 0; i < ncycle; i++) {
+                cstart = panonopt_end+i;
+                pos = cstart;
+                for (j = 0; j < cyclelen; j++) {
+                        if (pos >= panonopt_end)
+                                pos -= nnonopts;
+                        else
+                                pos += nopts;
+                        swap = nargv[pos];
+                        /* LINTED const cast */
+                        ((char **) nargv)[pos] = nargv[cstart];
+                        /* LINTED const cast */
+                        ((char **)nargv)[cstart] = swap;
+                }
+        }
+}
+
+/*
+ * parse_long_options --
+ *      Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+        const struct option *long_options, int *idx, int short_too)
+{
+        char *current_argv, *has_equal;
+        size_t current_argv_len;
+        int i, match;
+
+        current_argv = place;
+        match = -1;
+
+        optind++;
+
+        if ((has_equal = strchr(current_argv, '=')) != NULL) {
+                /* argument found (--option=arg) */
+                current_argv_len = has_equal - current_argv;
+                has_equal++;
+        } else
+                current_argv_len = strlen(current_argv);
+
+        for (i = 0; long_options[i].name; i++) {
+                /* find matching long option */
+                if (strncmp(current_argv, long_options[i].name,
+                    current_argv_len))
+                        continue;
+
+                if (strlen(long_options[i].name) == current_argv_len) {
+                        /* exact match */
+                        match = i;
+                        break;
+                }
+                /*
+                 * If this is a known short option, don't allow
+                 * a partial match of a single character.
+                 */
+                if (short_too && current_argv_len == 1)
+                        continue;
+
+                if (match == -1)        /* partial match */
+                        match = i;
+                else {
+                        /* ambiguous abbreviation */
+                        if (PRINT_ERROR)
+                                warnx(ambig, (int)current_argv_len,
+                                     current_argv);
+                        optopt = 0;
+                        return (BADCH);
+                }
+        }
+        if (match != -1) {              /* option found */
+                if (long_options[match].has_arg == no_argument
+                    && has_equal) {
+                        if (PRINT_ERROR)
+                                warnx(noarg, (int)current_argv_len,
+                                     current_argv);
+                        /*
+                         * XXX: GNU sets optopt to val regardless of flag
+                         */
+                        if (long_options[match].flag == NULL)
+                                optopt = long_options[match].val;
+                        else
+                                optopt = 0;
+                        return (BADARG);
+                }
+                if (long_options[match].has_arg == required_argument ||
+                    long_options[match].has_arg == optional_argument) {
+                        if (has_equal)
+                                optarg = has_equal;
+                        else if (long_options[match].has_arg ==
+                            required_argument) {
+                                /*
+                                 * optional argument doesn't use next nargv
+                                 */
+                                optarg = nargv[optind++];
+                        }
+                }
+                if ((long_options[match].has_arg == required_argument)
+                    && (optarg == NULL)) {
+                        /*
+                         * Missing argument; leading ':' indicates no error
+                         * should be generated.
+                         */
+                        if (PRINT_ERROR)
+                                warnx(recargstring,
+                                    current_argv);
+                        /*
+                         * XXX: GNU sets optopt to val regardless of flag
+                         */
+                        if (long_options[match].flag == NULL)
+                                optopt = long_options[match].val;
+                        else
+                                optopt = 0;
+                        --optind;
+                        return (BADARG);
+                }
+        } else {                        /* unknown option */
+                if (short_too) {
+                        --optind;
+                        return (-1);
+                }
+                if (PRINT_ERROR)
+                        warnx(illoptstring, current_argv);
+                optopt = 0;
+                return (BADCH);
+        }
+        if (idx)
+                *idx = match;
+        if (long_options[match].flag) {
+                *long_options[match].flag = long_options[match].val;
+                return (0);
+        } else
+                return (long_options[match].val);
+}
+
+/*
+ * getopt_internal --
+ *      Parse argc/argv argument vector.  Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+        const struct option *long_options, int *idx, int flags)
+{
+        char *oli;                              /* option letter list index */
+        int optchar, short_too;
+        static int posixly_correct = -1;
+
+        if (options == NULL)
+                return (-1);
+
+        /*
+         * Disable GNU extensions if POSIXLY_CORRECT is set or options
+         * string begins with a '+'.
+         */
+        if (posixly_correct == -1)
+                posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+        if (posixly_correct || *options == '+')
+                flags &= ~FLAG_PERMUTE;
+        else if (*options == '-')
+                flags |= FLAG_ALLARGS;
+        if (*options == '+' || *options == '-')
+                options++;
+
+        /*
+         * XXX Some GNU programs (like cvs) set optind to 0 instead of
+         * XXX using optreset.  Work around this braindamage.
+         */
+        if (optind == 0)
+                optind = optreset = 1;
+
+        optarg = NULL;
+        if (optreset)
+                nonopt_start = nonopt_end = -1;
+start:
+        if (optreset || !*place) {              /* update scanning pointer */
+                optreset = 0;
+                if (optind >= nargc) {          /* end of argument vector */
+                        place = EMSG;
+                        if (nonopt_end != -1) {
+                                /* do permutation, if we have to */
+                                permute_args(nonopt_start, nonopt_end,
+                                    optind, nargv);
+                                optind -= nonopt_end - nonopt_start;
+                        }
+                        else if (nonopt_start != -1) {
+                                /*
+                                 * If we skipped non-options, set optind
+                                 * to the first of them.
+                                 */
+                                optind = nonopt_start;
+                        }
+                        nonopt_start = nonopt_end = -1;
+                        return (-1);
+                }
+                if (*(place = nargv[optind]) != '-' ||
+                    (place[1] == '\0' && strchr(options, '-') == NULL)) {
+                        place = EMSG;           /* found non-option */
+                        if (flags & FLAG_ALLARGS) {
+                                /*
+                                 * GNU extension:
+                                 * return non-option as argument to option 1
+                                 */
+                                optarg = nargv[optind++];
+                                return (INORDER);
+                        }
+                        if (!(flags & FLAG_PERMUTE)) {
+                                /*
+                                 * If no permutation wanted, stop parsing
+                                 * at first non-option.
+                                 */
+                                return (-1);
+                        }
+                        /* do permutation */
+                        if (nonopt_start == -1)
+                                nonopt_start = optind;
+                        else if (nonopt_end != -1) {
+                                permute_args(nonopt_start, nonopt_end,
+                                    optind, nargv);
+                                nonopt_start = optind -
+                                    (nonopt_end - nonopt_start);
+                                nonopt_end = -1;
+                        }
+                        optind++;
+                        /* process next argument */
+                        goto start;
+                }
+                if (nonopt_start != -1 && nonopt_end == -1)
+                        nonopt_end = optind;
+
+                /*
+                 * Check for "--" or "--foo" with no long options
+                 * but if place is simply "-" leave it unmolested.
+                 */
+                if (place[1] != '\0' && *++place == '-' &&
+                    (place[1] == '\0' || long_options == NULL)) {
+                        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)':' ||
+            (oli = strchr(options, optchar)) == NULL) {
+                /*
+                 * If the user didn't specify '-' as an option,
+                 * assume it means -1 as POSIX specifies.
+                 */
+                if (optchar == (int)'-')
+                        return (-1);
+                /* option letter unknown or ':' */
+                if (!*place)
+                        ++optind;
+                if (PRINT_ERROR)
+                        warnx(illoptchar, optchar);
+                optopt = optchar;
+                return (BADCH);
+        }
+        if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+                /* -W long-option */
+                if (*place)                     /* no space */
+                        /* NOTHING */;
+                else if (++optind >= nargc) {   /* no arg */
+                        place = EMSG;
+                        if (PRINT_ERROR)
+                                warnx(recargchar, optchar);
+                        optopt = optchar;
+                        return (BADARG);
+                } else                          /* white space */
+                        place = nargv[optind];
+                optchar = parse_long_options(nargv, options, long_options,
+                    idx, 0);
+                place = EMSG;
+                return (optchar);
+        }
+        if (*++oli != ':') {                    /* doesn't take argument */
+                if (!*place)
+                        ++optind;
+        } else {                                /* takes (optional) argument */
+                optarg = NULL;
+                if (*place)                     /* no white space */
+                        optarg = place;
+                /* XXX: disable test for :: if PC? (GNU doesn't) */
+                else if (oli[1] != ':') {       /* arg not optional */
+                        if (++optind >= nargc) {        /* no arg */
+                                place = EMSG;
+                                if (PRINT_ERROR)
+                                        warnx(recargchar, optchar);
+                                optopt = optchar;
+                                return (BADARG);
+                        } else
+                                optarg = nargv[optind];
+                }
+                place = EMSG;
+                ++optind;
+        }
+        /* dump back option letter */
+        return (optchar);
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ *      Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+        /*
+         * We dont' pass FLAG_PERMUTE to getopt_internal() since
+         * the BSD getopt(3) (unlike GNU) has never done this.
+         *
+         * Furthermore, since many privileged programs call getopt()
+         * before dropping privileges it makes sense to keep things
+         * as simple (and bug-free) as possible.
+         */
+        return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+#endif /* REPLACE_GETOPT */
+
+/*
+ * getopt_long --
+ *      Parse argc/argv argument vector.
+ */
+int
+getopt_long(nargc, nargv, options, long_options, idx)
+        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(nargc, nargv, options, long_options, idx)
+        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..e2d8641016
--- /dev/null
+++ b/src/lib/libc/stdlib/getsubopt.3
@@ -0,0 +1,147 @@
+.\" $OpenBSD: getsubopt.3,v 1.6 2003/05/10 06:48:30 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. 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.
+.\"
+.\"     @(#)getsubopt.3 8.1 (Berkeley) 6/9/93
+.\"
+.Dd June 9, 1993
+.Dt GETSUBOPT 3
+.Os
+.Sh NAME
+.Nm getsubopt
+.Nd get sub options from an argument
+.Sh SYNOPSIS
+.Fd #include <stdlib.h>
+.Vt extern char *suboptarg;
+.Ft int
+.Fn getsubopt "char **optionp" "char * const *tokens" "char **valuep"
+.Sh DESCRIPTION
+The
+.Fn getsubopt
+function parses a string containing tokens delimited by one or more
+tab, space or comma
+.Pq Ql \&,
+characters.
+It is intended for use in parsing groups of option arguments provided
+as part of a utility command line.
+.Pp
+The argument
+.Fa optionp
+is a pointer to a pointer to the string.
+The argument
+.Fa tokens
+is a pointer to a null-terminated array of pointers to strings.
+.Pp
+The
+.Fn getsubopt
+function returns the zero-based offset of the pointer in the
+.Fa tokens
+array referencing a string which matches the first token
+in the string, or \-1 if the string contains no tokens or
+.Fa tokens
+does not contain a matching string.
+.Pp
+If the token is of the form
+.Ar name Ns No = 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 null 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 -compact
+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..1667a31d7d
--- /dev/null
+++ b/src/lib/libc/stdlib/getsubopt.c
@@ -0,0 +1,106 @@
+/*      $OpenBSD: getsubopt.c,v 1.1 1997/08/20 04:02:17 millert 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. 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.
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)getsubopt.c 8.1 (Berkeley) 6/4/93";
+#else
+static char rcsid[] = "$OpenBSD: getsubopt.c,v 1.1 1997/08/20 04:02:17 millert Exp $";
+#endif
+#endif /* not lint */
+
+#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(optionp, tokens, valuep)
+        register char **optionp, **valuep;
+        register char * const *tokens;
+{
+        register int cnt;
+        register 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/heapsort.c b/src/lib/libc/stdlib/heapsort.c
index bd998fa357..2770e5b977 100644
--- a/src/lib/libc/stdlib/heapsort.c
+++ b/src/lib/libc/stdlib/heapsort.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: heapsort.c,v 1.3 2002/02/16 21:27:24 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -142,7 +141,7 @@ int
 heapsort(vbase, nmemb, size, compar)
         void *vbase;
         size_t nmemb, size;
-        int (*compar) __P((const void *, const void *));
+        int (*compar)(const void *, const void *);
 {
         register int cnt, i, j, l;
         register char tmp, *tmp1, *tmp2;
diff --git a/src/lib/libc/stdlib/insque.3 b/src/lib/libc/stdlib/insque.3
new file mode 100644
index 0000000000..b87adb87bc
--- /dev/null
+++ b/src/lib/libc/stdlib/insque.3
@@ -0,0 +1,100 @@
+.\"     $OpenBSD: insque.3,v 1.1 2003/05/08 23:26:30 millert Exp $
+.\" Copyright (c) 1993 John Brezak
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"
+.Dd August 12, 1993
+.Dt INSQUE 3
+.Os
+.Sh NAME
+.Nm insque ,
+.Nm remque
+.Nd insert/remove element from a queue
+.Sh SYNOPSIS
+.Fd #include <search.h>
+.Ft void
+.Fn insque "void *elem" "void *pred"
+.Ft void
+.Fn remque "void *elem"
+.Sh DESCRIPTION
+.Bf -symbolic
+These interfaces have been superceded by the
+.Xr queue 3
+macros and are provided for compatibility with legacy code.
+.Ef
+.Pp
+.Fn insque
+and
+.Fn remque
+manipulate queues built from doubly linked lists.
+The queue can be either circular or linear.
+Each element in the queue must be of the following form:
+.Bd -literal
+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.
+.Sh DIAGNOSTICS
+These functions are not atomic unless that machine architecture allows it.
+.Sh SEE ALSO
+.Xr queue 3
+.Sh STANDARDS
+The
+.Fn lsearch 
+and
+.Fn lfind
+functions conform to the
+.St -p1003.1-01
+and 
+.St -xpg4.3 .   
+specifications.
+.Sh HISTORY
+The
+.Fn insque
+and
+.Fn remque
+functions are derived from the insque and remque instructions on a
+.Tn VAX .
diff --git a/src/lib/libc/stdlib/insque.c b/src/lib/libc/stdlib/insque.c
new file mode 100644
index 0000000000..549246c71f
--- /dev/null
+++ b/src/lib/libc/stdlib/insque.c
@@ -0,0 +1,52 @@
+/*      $OpenBSD: insque.c,v 1.1 2003/05/08 23:26:30 millert 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: insque.c,v 1.1 2003/05/08 23:26:30 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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..99cddb71e5 100644
--- a/src/lib/libc/stdlib/jrand48.c
+++ b/src/lib/libc/stdlib/jrand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: jrand48.c,v 1.2 1996/08/19 08:33:33 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 long
diff --git a/src/lib/libc/stdlib/l64a.c b/src/lib/libc/stdlib/l64a.c
index 3069b31bf6..4e99391254 100644
--- a/src/lib/libc/stdlib/l64a.c
+++ b/src/lib/libc/stdlib/l64a.c
@@ -4,13 +4,14 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$NetBSD: l64a.c,v 1.4 1995/05/11 23:04:52 jtc Exp $";
-#endif
+static char *rcsid = "$OpenBSD: l64a.c,v 1.3 1997/08/17 22:58:34 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
 
+#include <errno.h>
 #include <stdlib.h>
 
 char *
-l64a (value)
+l64a(value)
         long value;
 {
         static char buf[8];
@@ -18,8 +19,10 @@ l64a (value)
         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 +42,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..fe39ca24dc 100644
--- a/src/lib/libc/stdlib/labs.3
+++ b/src/lib/libc/stdlib/labs.3
@@ -33,8 +33,7 @@
 .\" 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.5 2000/04/20 13:50:02 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt LABS 3
@@ -49,19 +48,17 @@
 .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 j .
 .Sh SEE ALSO
 .Xr abs 3 ,
-.Xr floor 3 ,
 .Xr cabs 3 ,
+.Xr floor 3 ,
 .Xr math 3
 .Sh STANDARDS
 The
 .Fn labs
-function
-conforms to
+function conforms to
 .St -ansiC .
 .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..f20e2c29be 100644
--- a/src/lib/libc/stdlib/labs.c
+++ b/src/lib/libc/stdlib/labs.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: labs.c,v 1.2 1996/08/19 08:33:34 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/lcong48.c b/src/lib/libc/stdlib/lcong48.c
index 965d46b17a..44bd74e48a 100644
--- a/src/lib/libc/stdlib/lcong48.c
+++ b/src/lib/libc/stdlib/lcong48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: lcong48.c,v 1.2 1996/08/19 08:33:35 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/ldiv.3 b/src/lib/libc/stdlib/ldiv.3
index a7b5ccf878..b5301b1b21 100644
--- a/src/lib/libc/stdlib/ldiv.3
+++ b/src/lib/libc/stdlib/ldiv.3
@@ -33,8 +33,7 @@
 .\" 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.5 2000/04/20 13:50:02 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt LDIV 3
@@ -49,24 +48,22 @@
 .Sh DESCRIPTION
 The
 .Fn ldiv
-function
-computes the value
-.Ar num/denom
+function computes the value
+.Fa num Ns No / 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 math 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..908c2bf0aa 100644
--- a/src/lib/libc/stdlib/ldiv.c
+++ b/src/lib/libc/stdlib/ldiv.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: ldiv.c,v 1.2 1996/08/19 08:33:35 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>             /* ldiv_t */
diff --git a/src/lib/libc/stdlib/lrand48.c b/src/lib/libc/stdlib/lrand48.c
index 8e7f26237f..6b7524a51b 100644
--- a/src/lib/libc/stdlib/lrand48.c
+++ b/src/lib/libc/stdlib/lrand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: lrand48.c,v 1.2 1996/08/19 08:33:36 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/realloc.3 b/src/lib/libc/stdlib/lsearch.3
index 66f09b2081..3e17d131e4 100644
--- a/src/lib/libc/stdlib/realloc.3
+++ b/src/lib/libc/stdlib/lsearch.3
@@ -1,5 +1,5 @@
-.\" Copyright (c) 1991 The Regents of the University of California.
-.\" All rights reserved.
+.\" 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
@@ -29,72 +29,79 @@
 .\" 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 $
+.\"     @(#)lsearch.3   8.1 (Berkeley) 6/4/93
 .\"
-.Dd May 2, 1991
-.Dt REALLOC 3
+.Dd June 4, 1993
+.Dt LSEARCH 3
 .Os
 .Sh NAME
-.Nm realloc
-.Nd reallocation of memory function
+.Nm lsearch ,
+.Nm lfind
+.Nd linear searching routines
 .Sh SYNOPSIS
-.Fd #include <stdlib.h>
-.Ft void *
-.Fn realloc "void *ptr" "size_t size"
+.Ft char *
+.Fn lsearch "const void *key" "const void *base" "size_t *nelp" "size_t width" "int (*compar)(void *, void *)"
+.Ft char *
+.Fn lfind "const void *key" "const void *base" "size_t *nelp" "size_t width" "int (*compar)(void *, void *)"
 .Sh DESCRIPTION
+The functions
+.Fn lsearch ,
+and
+.Fn lfind
+provide basic linear searching functionality.
+.Pp
+.Fa base
+is the pointer to the beginning of an array.
+The argument
+.Fa nelp
+is the current number of elements in the array, where each element
+is
+.Fa width
+bytes long.
 The
-.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.
+.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 realloc
-function returns either a null pointer or a pointer
-to the possibly moved allocated space.
+.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 alloca 3 ,
-.Xr calloc 3 ,
-.Xr free 3 ,
-.Xr malloc 3 ,
+.Xr bsearch 3 ,
+.Xr db 3
 .Sh STANDARDS
 The
-.Fn realloc
-function conforms to
-.St -ansiC .
+.Fn lsearch
+and
+.Fn lfind
+functions conform to the
+.St -p1003.1-01
+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..ba0aad3cfc
--- /dev/null
+++ b/src/lib/libc/stdlib/lsearch.c
@@ -0,0 +1,90 @@
+/*
+ * 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. 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[] = "@(#)lsearch.c   8.1 (Berkeley) 6/4/93";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+#include <search.h>
+
+typedef int (*cmp_fn_t)(const void *, const void *);
+static void *linear_base(const void *, const void *, size_t *, size_t,
+    cmp_fn_t, int);
+
+void *
+lsearch(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar)
+{
+
+        return(linear_base(key, base, nelp, width, compar, 1));
+}
+
+void *
+lfind(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar)
+{
+        return(linear_base(key, base, nelp, width, compar, 0));
+}
+
+static void *
+linear_base(const void *key, const void *base, size_t *nelp, size_t width,
+        cmp_fn_t compar, int add_flag)
+{
+        const char *element, *end;
+
+        end = (const char *)base + *nelp * width;
+        for (element = base; element < end; element += width)
+                if (!compar(key, element))              /* key found */
+                        return((void *)element);
+
+        if (!add_flag)                                  /* key not found */
+                return(NULL);
+
+        /*
+         * The UNIX System User's Manual, 1986 edition claims that
+         * a NULL pointer is returned by lsearch with errno set
+         * appropriately, if there is not enough room in the table
+         * to add a new item.  This can't be done as none of these
+         * routines have any method of determining the size of the
+         * table.  This comment isn't in the 1986-87 System V
+         * manual.
+         */
+        ++*nelp;
+        memcpy((void *)end, key, width);
+        return((void *)end);
+}
diff --git a/src/lib/libc/stdlib/malloc.3 b/src/lib/libc/stdlib/malloc.3
index 3bbf2bf65e..4e31ad4355 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
@@ -33,19 +34,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.25 2003/01/21 19:59:09 jmc Exp $
 .\"
-.Dd June 29, 1991
+.Dd August 27, 1996
 .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 +73,347 @@ 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
+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.
+.Pp
+The
+.Fn free
+function causes the space pointed to by
+.Fa ptr
+to be deallocated, that is, at least made available for further allocation,
+but if possible, it will passed back to the kernel with
+.Xr sbrk 2 .
+If
+.Fa ptr
+is a null pointer, no action occurs.
+.Pp
+A
+.Fn cfree
+function is also provided for compatibility with old systems and other
+.Nm malloc
+libraries; it is simply an alias for
+.Fn free .
+.Pp
+The
+.Fn realloc
+function changes the size of the object pointed to by
+.Fa ptr
+to
+.Fa size
+bytes and returns a pointer to the (possibly moved) object.
+The contents of the object are unchanged up to the lesser
+of the new and old sizes.
+If the new size is larger, the value of the newly allocated portion
+of the object is indeterminate and uninitialized.
+If
+.Fa ptr
+is a null pointer, the
+.Fn realloc
+function behaves like the
+.Fn malloc
+function for the specified size.
+If the space cannot be allocated, the object
+pointed to by
+.Fa ptr
+is unchanged.
+If
+.Fa size
+is zero and
+.Fa ptr
+is not a null pointer, the object it points to is freed and a new zero size
+object is returned.
+.Pp
+When using
+.Fn realloc
+one must be careful to avoid the following idiom:
+.Pp
+.Bd -literal -offset indent
+if ((p = realloc(p, nsize)) == NULL)
+        return NULL;
+.Ed
+.Pp
+In most cases, this will 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
+if ((p2 = realloc(p, nsize)) == NULL) {
+        if (p)
+                free(p);
+        p = NULL;
+        return NULL;
+}
+p = p2;
+.Ed
+.Pp
+Malloc will first look for a symbolic link called
+.Pa /etc/malloc.conf
+and next check the environment for a variable called
+.Ev MALLOC_OPTIONS
+and finally for the global variable
+.Va malloc_options
+and scan them for flags in that order.
+Flags are single letters, uppercase means on, lowercase means off.
+.Bl -tag -width indent
+.It Cm A
+.Dq Abort .
+.Fn malloc
+will coredump the process, rather than tolerate failure.
+This is a very handy debugging aid, since the core file will represent the
+time of failure, rather than when the null pointer was accessed.
+.Pp
+.It Cm D
+.Dq Dump .
+.Fn malloc
+will dump statistics in a file called
+.Pa malloc.out
+at exit.
+This option requires the library to have been compiled with -DMALLOC_STATS in
+order to have any effect.
+.Pp
+.It Cm J
+.Dq Junk .
+Fill some junk into the area allocated.
+Currently junk is bytes of 0xd0; this is pronounced
+.Dq Duh .
+\&:-)
+.Pp
+.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.
+.Pp
+.It Cm N
+Do not output warning messages when encountering possible corruption
+or bad pointers.
+.Pp
+.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.
+.Pp
+.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
+.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.
+.Pp
+.It Cm <
+.Dq Half the cache size .
+Reduce the size of the cache by a factor of two.
+.Pp
+.It Cm >
+.Dq Double the cache size .
+Double the size of the cache by a factor of two.
+.El
+.Pp
+So to set a systemwide reduction of cache size and coredumps on problems
+one would:
+.Li ln -s 'A<' /etc/malloc.conf
+.Pp
+The
+.Cm J
+and
+.Cm Z
+flags are mostly for testing and debugging.
+If a program changes behavior if either of these options are used,
+it is buggy.
+.Pp
+The default cache size is 16 pages.
+.Sh ENVIRONMENT
+See above.
 .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 DIAGNOSTICS
+If
+.Fn malloc ,
+.Fn calloc ,
+.Fn realloc ,
+or
+.Fn free
+detect an error or warning condition,
+a message will be printed to file descriptor
+2 (not using stdio).
+Errors will always result in the process being
+.Xr abort 3 'ed.
+If the
+.Cm A
+option has been specified, warnings will also
+.Xr abort 3
+the process.
+.Pp
+Here is a brief description of the error messages and what they mean:
+.Bl -tag -width Fl
+.It Dq (ES): mumble mumble mumble
+.Fn malloc
+has been compiled with
+.Dv \&-DEXTRA_SANITY
+and something looks fishy in there.
+Consult sources and/or wizards.
+.It Dq allocation failed
+If the
+.Cm A
+option is specified it is an error for
+.Fn malloc ,
+.Fn calloc ,
+or
+.Fn realloc
+to return
+.Dv NULL .
+.It Dq mmap(2) failed, check limits.
+This is a rather weird condition that is most likely to indicate a
+seriously overloaded system or a
+.Xr ulimit 1
+restriction.
+.It Dq freelist is destroyed.
+.Fn malloc Ns 's
+internal freelist has been stomped on.
+.El
+.Pp
+Here is a brief description of the warning messages and what they mean:
+.Bl -tag -width Fl
+.It Dq chunk/page is already free.
+A pointer to a free chunk is attempted freed again.
+.It Dq junk pointer, too high to make sense.
+The pointer doesn't make sense.
+It's above the area of memory that
+.Fn malloc
+knows something about.
+This could be a pointer from some
+.Xr mmap 2 'ed
+memory.
+.It Dq junk pointer, too low to make sense.
+The pointer doesn't make sense.
+It's below the area of memory that
+.Fn malloc
+knows something about.
+This pointer probably came from your data or bss segments.
+.It Dq malloc() has never been called.
+Nothing has ever been allocated, yet something is being freed or
+realloc'ed.
+.It Dq modified (chunk-/page-) pointer.
+The pointer passed to free or realloc has been modified.
+.It Dq pointer to wrong page.
+The pointer that
+.Fn malloc
+is trying to free is not pointing to
+a sensible page.
+.It Dq recursive call.
+An attempt was made to call recursively into these functions, i.e., from a
+signal handler.
+This behavior is not supported.
+In particular, signal handlers should
+.Em not
+use any of the
+.Fn malloc
+functions nor utilize any other functions which may call
+.Fn malloc
+(e.g.,
+.Xr stdio 3
+routines).
+.It Dq unknown char in MALLOC_OPTIONS
+We found something we didn't understand.
+.El
+.Sh FILES
+.Bl -tag -width "/etc/malloc.conf"
+.It Pa /etc/malloc.conf
+symbolic link to filename containing option flags
+.El
 .Sh SEE ALSO
 .Xr brk 2 ,
-.Xr getpagesize 2 ,
-.Xr free 3 ,
-.Xr calloc 3 ,
 .Xr alloca 3 ,
-.Xr realloc 3 ,
+.Xr getpagesize 3 ,
 .Xr memory 3
+.Pa /usr/share/doc/papers/malloc.ascii.gz
 .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 present implementation of
+.Fn malloc
+started out as a filesystem on a drum
+attached to a 20-bit binary challenged computer built with discrete germanium
+transistors, and it has since graduated to handle primary storage rather than
+secondary.
+.Pp
+The main difference from other
+.Fn malloc
+implementations are believed to be that
+the free pages are not accessed until allocated.
+Most
+.Fn malloc
+implementations will store a data structure containing a,
+possibly double-, linked list in the free chunks of memory, used to tie
+all the free memory together.
+That is a quite suboptimal thing to do.
+Every time the free-list is traversed, all the otherwise unused, and very
+likely paged out, pages get faulted into primary memory, just to see what
+lies after them in the list.
+.Pp
+On systems which are paging, this can make a factor five in difference on the
+page-faults of a process.
diff --git a/src/lib/libc/stdlib/malloc.c b/src/lib/libc/stdlib/malloc.c
index 3c57fad024..c8aef635d4 100644
--- a/src/lib/libc/stdlib/malloc.c
+++ b/src/lib/libc/stdlib/malloc.c
@@ -1,421 +1,1287 @@
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
+ * ----------------------------------------------------------------------------
+ * "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
+ * ----------------------------------------------------------------------------
  */
 
 #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 $";
+static char rcsid[] = "$OpenBSD: malloc.c,v 1.54 2003/01/14 02:27:16 millert 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.
+ * Defining MALLOC_EXTRA_SANITY will enable extra checks which are
+ * related to internal conditions and consistency in malloc.c. This has
+ * a noticeable runtime performance hit, and generally will not do you
+ * any good unless you fiddle with the internals of malloc or want
+ * to catch random pointer corruption as early as possible.
+ */
+#ifndef MALLOC_EXTRA_SANITY
+#undef MALLOC_EXTRA_SANITY
+#endif
+
+/*
+ * Defining MALLOC_STATS will enable you to call malloc_dump() and set
+ * the [dD] options in the MALLOC_OPTIONS environment variable.
+ * It has no run-time performance hit, but does pull in stdio...
+ */
+#ifndef MALLOC_STATS
+#undef MALLOC_STATS
+#endif
+
+/*
+ * What to use for Junk.  This is the byte value we use to fill with
+ * when the 'J' option is enabled.
  */
+#define SOME_JUNK       0xd0            /* as in "Duh" :-) */
 
 #include <sys/types.h>
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <errno.h>
+
+#include "thread_private.h"
 
-#define NULL 0
+/*
+ * The basic parameters you can tweak.
+ *
+ * malloc_pageshift     pagesize = 1 << malloc_pageshift
+ *                      It's probably best if this is the native
+ *                      page size, but it shouldn't have to be.
+ *
+ * malloc_minsize       minimum size of an allocation in bytes.
+ *                      If this is too small it's too much work
+ *                      to manage them.  This is also the smallest
+ *                      unit of alignment used for the storage
+ *                      returned by malloc/realloc.
+ *
+ */
 
-static void morecore();
-static int findbucket();
+#if defined(__OpenBSD__) && defined(__sparc__)
+#   define    malloc_pageshift  13U
+#endif /* __OpenBSD__ */
 
 /*
- * 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.
+ * No user serviceable parts behind this point.
+ *
+ * This structure describes a page worth of chunks.
  */
-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 */
-#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
+
+struct pginfo {
+    struct pginfo       *next;  /* next on the free list */
+    void                *page;  /* Pointer to the page */
+    u_short             size;   /* size of this page's chunks */
+    u_short             shift;  /* How far to shift for this size chunks */
+    u_short             free;   /* How many free chunks */
+    u_short             total;  /* How many chunk */
+    u_long              bits[1]; /* Which chunks are free */
 };
 
-#define MAGIC           0xef            /* magic # on accounting info */
-#define RMAGIC          0x5555          /* magic # on range info */
+/*
+ * This structure describes a number of free pages.
+ */
+
+struct pgfree {
+    struct pgfree       *next;  /* next run of free pages */
+    struct pgfree       *prev;  /* prev run of free pages */
+    void                *page;  /* pointer to free pages */
+    void                *end;   /* pointer to end of free pages */
+    u_long              size;   /* number of bytes free */
+};
 
-#ifdef RCHECK
-#define RSLOP           sizeof (u_short)
+/*
+ * How many bits per u_long in the bitmap.
+ * Change only if not 8 bits/byte
+ */
+#define MALLOC_BITS     (8*sizeof(u_long))
+
+/*
+ * Magic values to put in the page_directory
+ */
+#define MALLOC_NOT_MINE ((struct pginfo*) 0)
+#define MALLOC_FREE     ((struct pginfo*) 1)
+#define MALLOC_FIRST    ((struct pginfo*) 2)
+#define MALLOC_FOLLOW   ((struct pginfo*) 3)
+#define MALLOC_MAGIC    ((struct pginfo*) 4)
+
+#ifndef malloc_pageshift
+#define malloc_pageshift                (PGSHIFT)
+#endif
+
+#ifndef malloc_minsize
+#define malloc_minsize                  16U
+#endif
+
+#ifndef malloc_pageshift
+#error  "malloc_pageshift undefined"
+#endif
+
+#if !defined(malloc_pagesize)
+#define malloc_pagesize                 (1UL<<malloc_pageshift)
+#endif
+
+#if ((1UL<<malloc_pageshift) != malloc_pagesize)
+#error  "(1UL<<malloc_pageshift) != malloc_pagesize"
+#endif
+
+#ifndef malloc_maxsize
+#define malloc_maxsize                  ((malloc_pagesize)>>1)
+#endif
+
+/* A mask for the offset inside a page.  */
+#define malloc_pagemask ((malloc_pagesize)-1)
+
+#define pageround(foo) (((foo) + (malloc_pagemask))&(~(malloc_pagemask)))
+#define ptr2index(foo) (((u_long)(foo) >> malloc_pageshift)-malloc_origo)
+
+/* fd of /dev/zero */
+#ifdef USE_DEV_ZERO
+static int fdzero;
+#define MMAP_FD fdzero
+#define INIT_MMAP() \
+        { if ((fdzero=open("/dev/zero", O_RDWR, 0000)) == -1) \
+            wrterror("open of /dev/zero"); }
 #else
-#define RSLOP           0
+#define MMAP_FD (-1)
+#define INIT_MMAP()
 #endif
 
+/* Set when initialization has been done */
+static unsigned int malloc_started;
+
+/* Number of free pages we cache */
+static unsigned int malloc_cache = 16;
+
+/* The offset from pagenumber to index into the page directory */
+static u_long malloc_origo;
+
+/* The last index in the page directory we care about */
+static u_long last_index;
+
+/* Pointer to page directory. Allocated "as if with" malloc */
+static struct   pginfo **page_dir;
+
+/* How many slots in the page directory */
+static size_t   malloc_ninfo;
+
+/* Free pages line up here */
+static struct pgfree free_list;
+
+/* Abort(), user doesn't handle problems.  */
+static int malloc_abort;
+
+/* Are we trying to die ?  */
+static int suicide;
+
+#ifdef MALLOC_STATS
+/* dump statistics */
+static int malloc_stats;
+#endif
+
+/* avoid outputting warnings?  */
+static int malloc_silent;
+
+/* always realloc ?  */
+static int malloc_realloc;
+
+#if defined(__FreeBSD__) || (defined(__OpenBSD__) && defined(MADV_FREE))
+/* pass the kernel a hint on free pages ?  */
+static int malloc_hint;
+#endif
+
+/* xmalloc behaviour ?  */
+static int malloc_xmalloc;
+
+/* zero fill ?  */
+static int malloc_zero;
+
+/* junk fill ?  */
+static int malloc_junk;
+
+#ifdef __FreeBSD__
+/* utrace ?  */
+static int malloc_utrace;
+
+struct ut { void *p; size_t s; void *r; };
+
+void utrace(struct ut *, int);
+
+#define UTRACE(a, b, c) \
+        if (malloc_utrace) \
+                {struct ut u; u.p=a; u.s = b; u.r=c; utrace(&u, sizeof u);}
+#else /* !__FreeBSD__ */
+#define UTRACE(a,b,c)
+#endif
+
+/* my last break. */
+static void *malloc_brk;
+
+/* one location cache for free-list holders */
+static struct pgfree *px;
+
+/* compile-time options */
+char *malloc_options;
+
+/* Name of the current public function */
+static char *malloc_func;
+
+/* Macro for mmap */
+#define MMAP(size) \
+        mmap((void *)0, (size), PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, \
+            MMAP_FD, (off_t)0);
+
 /*
- * 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.
+ * Necessary function declarations
  */
-#define NBUCKETS 30
-static  union overhead *nextf[NBUCKETS];
-extern  char *sbrk();
+static int extend_pgdir(u_long index);
+static void *imalloc(size_t size);
+static void ifree(void *ptr);
+static void *irealloc(void *ptr, size_t size);
+static void *malloc_bytes(size_t size);
+
+#ifdef MALLOC_STATS
+void
+malloc_dump(fd)
+    FILE *fd;
+{
+    struct pginfo **pd;
+    struct pgfree *pf;
+    int j;
+
+    pd = page_dir;
+
+    /* print out all the pages */
+    for(j=0;j<=last_index;j++) {
+        fprintf(fd, "%08lx %5d ", (j+malloc_origo) << malloc_pageshift, j);
+        if (pd[j] == MALLOC_NOT_MINE) {
+            for(j++;j<=last_index && pd[j] == MALLOC_NOT_MINE;j++)
+                ;
+            j--;
+            fprintf(fd, ".. %5d not mine\n",    j);
+        } else if (pd[j] == MALLOC_FREE) {
+            for(j++;j<=last_index && pd[j] == MALLOC_FREE;j++)
+                ;
+            j--;
+            fprintf(fd, ".. %5d free\n", j);
+        } else if (pd[j] == MALLOC_FIRST) {
+            for(j++;j<=last_index && pd[j] == MALLOC_FOLLOW;j++)
+                ;
+            j--;
+            fprintf(fd, ".. %5d in use\n", j);
+        } else if (pd[j] < MALLOC_MAGIC) {
+            fprintf(fd, "(%p)\n", pd[j]);
+        } else {
+            fprintf(fd, "%p %d (of %d) x %d @ %p --> %p\n",
+                pd[j], pd[j]->free, pd[j]->total,
+                pd[j]->size, pd[j]->page, pd[j]->next);
+        }
+    }
+
+    for(pf=free_list.next; pf; pf=pf->next) {
+        fprintf(fd, "Free: @%p [%p...%p[ %ld ->%p <-%p\n",
+                pf, pf->page, pf->end, pf->size, pf->prev, pf->next);
+        if (pf == pf->next) {
+                fprintf(fd, "Free_list loops.\n");
+                break;
+        }
+    }
+
+    /* print out various info */
+    fprintf(fd, "Minsize\t%d\n", malloc_minsize);
+    fprintf(fd, "Maxsize\t%d\n", malloc_maxsize);
+    fprintf(fd, "Pagesize\t%lu\n", (u_long)malloc_pagesize);
+    fprintf(fd, "Pageshift\t%d\n", malloc_pageshift);
+    fprintf(fd, "FirstPage\t%ld\n", malloc_origo);
+    fprintf(fd, "LastPage\t%ld %lx\n", last_index+malloc_pageshift,
+        (last_index + malloc_pageshift) << malloc_pageshift);
+    fprintf(fd, "Break\t%ld\n", (u_long)sbrk(0) >> malloc_pageshift);
+}
+#endif /* MALLOC_STATS */
+
+extern char *__progname;
+
+static void
+wrterror(p)
+    char *p;
+{
+    char *q = " error: ";
+    struct iovec iov[4];
+
+    iov[0].iov_base = __progname;
+    iov[0].iov_len = strlen(__progname);
+    iov[1].iov_base = malloc_func;
+    iov[1].iov_len = strlen(malloc_func);
+    iov[2].iov_base = q;
+    iov[2].iov_len = strlen(q);
+    iov[3].iov_base = p;
+    iov[3].iov_len = strlen(p);
+    writev(STDERR_FILENO, iov, 4);
+
+    suicide = 1;
+#ifdef MALLOC_STATS
+    if (malloc_stats)
+        malloc_dump(stderr);
+#endif /* MALLOC_STATS */
+    abort();
+}
+
+static void
+wrtwarning(p)
+    char *p;
+{
+    char *q = " warning: ";
+    struct iovec iov[4];
+
+    if (malloc_abort)
+        wrterror(p);
+    else if (malloc_silent)
+        return;
+
+    iov[0].iov_base = __progname;
+    iov[0].iov_len = strlen(__progname);
+    iov[1].iov_base = malloc_func;
+    iov[1].iov_len = strlen(malloc_func);
+    iov[2].iov_base = q;
+    iov[2].iov_len = strlen(q);
+    iov[3].iov_base = p;
+    iov[3].iov_len = strlen(p);
+    writev(STDERR_FILENO, iov, 4);
+}
+
+#ifdef MALLOC_STATS
+static void
+malloc_exit()
+{
+    FILE *fd = fopen("malloc.out", "a");
+    char *q = "malloc() warning: Couldn't dump stats.\n";
+    if (fd) {
+        malloc_dump(fd);
+        fclose(fd);
+    } else
+        write(STDERR_FILENO, q, strlen(q));
+}
+#endif /* MALLOC_STATS */
 
-static  int pagesz;                     /* page size */
-static  int pagebucket;                 /* page size bucket */
 
-#ifdef MSTATS
 /*
- * nmalloc[i] is the difference between the number of mallocs and frees
- * for a given block size.
+ * Allocate a number of pages from the OS
  */
-static  u_int nmalloc[NBUCKETS];
-#include <stdio.h>
-#endif
+static void *
+map_pages(pages)
+    size_t pages;
+{
+    caddr_t result, tail;
 
-#if defined(DEBUG) || defined(RCHECK)
-#define ASSERT(p)   if (!(p)) botch("p")
-#include <stdio.h>
-static
-botch(s)
-        char *s;
+    result = (caddr_t)pageround((u_long)sbrk(0));
+    pages <<= malloc_pageshift;
+    if (pages > SIZE_T_MAX - (size_t)result) {
+#ifdef MALLOC_EXTRA_SANITY
+        wrterror("(ES): overflow in map_pages fails\n");
+#endif /* MALLOC_EXTRA_SANITY */
+        return 0;
+    }
+    tail = result + pages;
+
+    if (brk(tail)) {
+#ifdef MALLOC_EXTRA_SANITY
+        wrterror("(ES): map_pages fails\n");
+#endif /* MALLOC_EXTRA_SANITY */
+        return 0;
+    }
+
+    last_index = ptr2index(tail) - 1;
+    malloc_brk = tail;
+
+    if ((last_index+1) >= malloc_ninfo && !extend_pgdir(last_index))
+        return 0;
+
+    return result;
+}
+
+/*
+ * Extend page directory
+ */
+static int
+extend_pgdir(index)
+    u_long index;
 {
-        fprintf(stderr, "\r\nassertion botched: %s\r\n", s);
-        (void) fflush(stderr);          /* just in case user buffered it */
-        abort();
+    struct  pginfo **new, **old;
+    size_t i, oldlen;
+
+    /* Make it this many pages */
+    i = index * sizeof *page_dir;
+    i /= malloc_pagesize;
+    i += 2;
+
+    /* remember the old mapping size */
+    oldlen = malloc_ninfo * sizeof *page_dir;
+
+    /*
+     * NOTE: we allocate new pages and copy the directory rather than tempt
+     * fate by trying to "grow" the region.. There is nothing to prevent
+     * us from accidently re-mapping space that's been allocated by our caller
+     * via dlopen() or other mmap().
+     *
+     * The copy problem is not too bad, as there is 4K of page index per
+     * 4MB of malloc arena.
+     *
+     * We can totally avoid the copy if we open a file descriptor to associate
+     * the anon mappings with.  Then, when we remap the pages at the new
+     * address, the old pages will be "magically" remapped..  But this means
+     * keeping open a "secret" file descriptor.....
+     */
+
+    /* Get new pages */
+    new = (struct pginfo**) MMAP(i * malloc_pagesize);
+    if (new == MAP_FAILED)
+        return 0;
+
+    /* Copy the old stuff */
+    memcpy(new, page_dir,
+            malloc_ninfo * sizeof *page_dir);
+
+    /* register the new size */
+    malloc_ninfo = i * malloc_pagesize / sizeof *page_dir;
+
+    /* swap the pointers */
+    old = page_dir;
+    page_dir = new;
+
+    /* Now free the old stuff */
+    munmap(old, oldlen);
+    return 1;
 }
-#else
-#define ASSERT(p)
-#endif
 
-void *
-malloc(nbytes)
-        size_t nbytes;
+/*
+ * Initialize the world
+ */
+static void
+malloc_init ()
 {
-        register union overhead *op;
-        register long bucket, n;
-        register unsigned amt;
+    char *p, b[64];
+    int i, j;
+    int save_errno = errno;
 
-        /*
-         * First time malloc is called, setup page size and
-         * align break pointer so all data will be page aligned.
-         */
-        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);
-                }
-                bucket = 0;
-                amt = 8;
-                while (pagesz > amt) {
-                        amt <<= 1;
-                        bucket++;
-                }
-                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.
-         */
-        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;
+    _MALLOC_LOCK_INIT();
+
+    INIT_MMAP();
+
+#ifdef MALLOC_EXTRA_SANITY
+    malloc_junk = 1;
+#endif /* MALLOC_EXTRA_SANITY */
+
+    for (i = 0; i < 3; i++) {
+        if (i == 0) {
+            j = readlink("/etc/malloc.conf", b, sizeof b - 1);
+            if (j <= 0)
+                continue;
+            b[j] = '\0';
+            p = b;
+        } else if (i == 1) {
+            if (issetugid() == 0)
+                p = getenv("MALLOC_OPTIONS");
+            else
+                continue;
+        } else if (i == 2) {
+            p = malloc_options;
         }
-        while (nbytes > amt + n) {
-                amt <<= 1;
-                if (amt == 0)
-                        return (NULL);
-                bucket++;
+        for (; p && *p; p++) {
+            switch (*p) {
+                case '>': malloc_cache   <<= 1; break;
+                case '<': malloc_cache   >>= 1; break;
+                case 'a': malloc_abort   = 0; break;
+                case 'A': malloc_abort   = 1; break;
+#ifdef MALLOC_STATS
+                case 'd': malloc_stats   = 0; break;
+                case 'D': malloc_stats   = 1; break;
+#endif /* MALLOC_STATS */
+#if defined(__FreeBSD__) || (defined(__OpenBSD__) && defined(MADV_FREE))
+                case 'h': malloc_hint    = 0; break;
+                case 'H': malloc_hint    = 1; break;
+#endif /* __FreeBSD__ */
+                case 'r': malloc_realloc = 0; break;
+                case 'R': malloc_realloc = 1; break;
+                case 'j': malloc_junk    = 0; break;
+                case 'J': malloc_junk    = 1; break;
+                case 'n': malloc_silent  = 0; break;
+                case 'N': malloc_silent  = 1; break;
+#ifdef __FreeBSD__
+                case 'u': malloc_utrace  = 0; break;
+                case 'U': malloc_utrace  = 1; break;
+#endif /* __FreeBSD__ */
+                case 'x': malloc_xmalloc = 0; break;
+                case 'X': malloc_xmalloc = 1; break;
+                case 'z': malloc_zero    = 0; break;
+                case 'Z': malloc_zero    = 1; break;
+                default:
+                    j = malloc_abort;
+                    malloc_abort = 0;
+                    wrtwarning("unknown char in MALLOC_OPTIONS\n");
+                    malloc_abort = j;
+                    break;
+            }
         }
-        /*
-         * If nothing in hash bucket right now,
-         * request more memory from the system.
-         */
-        if ((op = nextf[bucket]) == NULL) {
-                morecore(bucket);
-                if ((op = nextf[bucket]) == NULL)
-                        return (NULL);
+    }
+
+    UTRACE(0, 0, 0);
+
+    /*
+     * We want junk in the entire allocation, and zero only in the part
+     * the user asked for.
+     */
+    if (malloc_zero)
+        malloc_junk=1;
+
+#ifdef MALLOC_STATS
+    if (malloc_stats && (atexit(malloc_exit) == -1))
+                wrtwarning("atexit(2) failed.  Will not be able to dump malloc stats on exit.\n");
+#endif /* MALLOC_STATS */
+
+    /* Allocate one page for the page directory */
+    page_dir = (struct pginfo **) MMAP(malloc_pagesize);
+
+    if (page_dir == MAP_FAILED)
+        wrterror("mmap(2) failed, check limits.\n");
+
+    /*
+     * We need a maximum of malloc_pageshift buckets, steal these from the
+     * front of the page_directory;
+     */
+    malloc_origo = ((u_long)pageround((u_long)sbrk(0))) >> malloc_pageshift;
+    malloc_origo -= malloc_pageshift;
+
+    malloc_ninfo = malloc_pagesize / sizeof *page_dir;
+
+    /* Been here, done that */
+    malloc_started++;
+
+    /* Recalculate the cache size in bytes, and make sure it's nonzero */
+
+    if (!malloc_cache)
+        malloc_cache++;
+
+    malloc_cache <<= malloc_pageshift;
+
+    /*
+     * This is a nice hack from Kaleb Keithly (kaleb@x.org).
+     * We can sbrk(2) further back when we keep this on a low address.
+     */
+    px = (struct pgfree *) imalloc (sizeof *px);
+    errno = save_errno;
+}
+
+/*
+ * Allocate a number of complete pages
+ */
+static void *
+malloc_pages(size)
+    size_t size;
+{
+    void *p, *delay_free = 0;
+    int i;
+    struct pgfree *pf;
+    u_long index;
+
+    size = pageround(size);
+
+    p = 0;
+    /* Look for free pages before asking for more */
+    for(pf = free_list.next; pf; pf = pf->next) {
+
+#ifdef MALLOC_EXTRA_SANITY
+        if (pf->size & malloc_pagemask)
+            wrterror("(ES): junk length entry on free_list\n");
+        if (!pf->size)
+            wrterror("(ES): zero length entry on free_list\n");
+        if (pf->page == pf->end)
+            wrterror("(ES): zero entry on free_list\n");
+        if (pf->page > pf->end)
+            wrterror("(ES): sick entry on free_list\n");
+        if ((void*)pf->page >= (void*)sbrk(0))
+            wrterror("(ES): entry on free_list past brk\n");
+        if (page_dir[ptr2index(pf->page)] != MALLOC_FREE)
+            wrterror("(ES): non-free first page on free-list\n");
+        if (page_dir[ptr2index(pf->end)-1] != MALLOC_FREE)
+            wrterror("(ES): non-free last page on free-list\n");
+#endif /* MALLOC_EXTRA_SANITY */
+
+        if (pf->size < size)
+            continue;
+
+        if (pf->size == size) {
+            p = pf->page;
+            if (pf->next)
+                    pf->next->prev = pf->prev;
+            pf->prev->next = pf->next;
+            delay_free = pf;
+            break;
         }
-        /* remove from linked list */
-        nextf[bucket] = op->ov_next;
-        op->ov_magic = MAGIC;
-        op->ov_index = bucket;
-#ifdef MSTATS
-        nmalloc[bucket]++;
-#endif
-#ifdef RCHECK
-        /*
-         * Record allocated size of block and
-         * bound space with magic numbers.
-         */
-        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));
+
+        p = pf->page;
+        pf->page = (char *)pf->page + size;
+        pf->size -= size;
+        break;
+    }
+
+#ifdef MALLOC_EXTRA_SANITY
+    if (p && page_dir[ptr2index(p)] != MALLOC_FREE)
+        wrterror("(ES): allocated non-free page on free-list\n");
+#endif /* MALLOC_EXTRA_SANITY */
+
+    size >>= malloc_pageshift;
+
+    /* Map new pages */
+    if (!p)
+        p = map_pages(size);
+
+    if (p) {
+
+        index = ptr2index(p);
+        page_dir[index] = MALLOC_FIRST;
+        for (i=1;i<size;i++)
+            page_dir[index+i] = MALLOC_FOLLOW;
+
+        if (malloc_junk)
+            memset(p, SOME_JUNK, size << malloc_pageshift);
+    }
+
+    if (delay_free) {
+        if (!px)
+            px = delay_free;
+        else
+            ifree(delay_free);
+    }
+
+    return p;
 }
 
 /*
- * Allocate more memory to the indicated bucket.
+ * Allocate a page of fragments
  */
-static void
-morecore(bucket)
-        int bucket;
+
+static __inline__ int
+malloc_make_chunks(bits)
+    int bits;
 {
-        register union overhead *op;
-        register long sz;               /* size of desired block */
-        long amt;                       /* amount to allocate */
-        int nblks;                      /* how many blocks we get */
+    struct  pginfo *bp;
+    void *pp;
+    int i, k, l;
 
-        /*
-         * 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;
+    /* Allocate a new bucket */
+    pp = malloc_pages((size_t)malloc_pagesize);
+    if (!pp)
+        return 0;
+
+    /* Find length of admin structure */
+    l = sizeof *bp - sizeof(u_long);
+    l += sizeof(u_long) *
+        (((malloc_pagesize >> bits)+MALLOC_BITS-1) / MALLOC_BITS);
+
+    /* Don't waste more than two chunks on this */
+    /*
+     * If we are to allocate a memory protected page for the malloc(0)
+     * case (when bits=0), it must be from a different page than the
+     * pginfo page.
+     * --> Treat it like the big chunk alloc, get a second data page.
+     */
+    if (bits != 0 && (1UL<<(bits)) <= l+l) {
+        bp = (struct  pginfo *)pp;
+    } else {
+        bp = (struct  pginfo *)imalloc(l);
+        if (!bp) {
+            ifree(pp);
+            return 0;
         }
-        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);
-        }
+    }
+
+    /* memory protect the page allocated in the malloc(0) case */
+    if (bits == 0) {
+
+        bp->size = 0;
+        bp->shift = 1;
+        i = malloc_minsize-1;
+        while (i >>= 1)
+            bp->shift++;
+        bp->total = bp->free = malloc_pagesize >> bp->shift;
+        bp->page = pp;
+
+        k = mprotect(pp, malloc_pagesize, PROT_NONE);
+        if (k < 0) {
+            ifree(pp);
+            ifree(bp);
+            return 0;
+        }
+    } else {
+        bp->size = (1UL<<bits);
+        bp->shift = bits;
+        bp->total = bp->free = malloc_pagesize >> bits;
+        bp->page = pp;
+    }
+
+    /* set all valid bits in the bitmap */
+    k = bp->total;
+    i = 0;
+
+    /* Do a bunch at a time */
+    for(;k-i >= MALLOC_BITS; i += MALLOC_BITS)
+        bp->bits[i / MALLOC_BITS] = ~0UL;
+
+    for(; i < k; i++)
+        bp->bits[i/MALLOC_BITS] |= 1UL<<(i%MALLOC_BITS);
+
+    if (bp == bp->page) {
+        /* Mark the ones we stole for ourselves */
+        for(i=0;l > 0;i++) {
+            bp->bits[i/MALLOC_BITS] &= ~(1UL<<(i%MALLOC_BITS));
+            bp->free--;
+            bp->total--;
+            l -= (1 << bits);
+        }
+    }
+
+    /* MALLOC_LOCK */
+
+    page_dir[ptr2index(pp)] = bp;
+
+    bp->next = page_dir[bits];
+    page_dir[bits] = bp;
+
+    /* MALLOC_UNLOCK */
+
+    return 1;
 }
 
-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]--;
-#endif
+/*
+ * Allocate a fragment
+ */
+static void *
+malloc_bytes(size)
+    size_t size;
+{
+    int i,j;
+    u_long u;
+    struct  pginfo *bp;
+    int k;
+    u_long *lp;
+
+    /* Don't bother with anything less than this */
+    /* unless we have a malloc(0) requests */
+    if (size != 0 && size < malloc_minsize)
+        size = malloc_minsize;
+
+    /* Find the right bucket */
+    if (size == 0)
+        j=0;
+    else {
+        j = 1;
+        i = size-1;
+        while (i >>= 1)
+            j++;
+    }
+
+    /* If it's empty, make a page more of that size chunks */
+    if (!page_dir[j] && !malloc_make_chunks(j))
+        return 0;
+
+    bp = page_dir[j];
+
+    /* Find first word of bitmap which isn't empty */
+    for (lp = bp->bits; !*lp; lp++)
+        ;
+
+    /* Find that bit, and tweak it */
+    u = 1;
+    k = 0;
+    while (!(*lp & u)) {
+        u += u;
+        k++;
+    }
+    *lp ^= u;
+
+    /* If there are no more free, remove from free-list */
+    if (!--bp->free) {
+        page_dir[j] = bp->next;
+        bp->next = 0;
+    }
+
+    /* Adjust to the real offset of that chunk */
+    k += (lp-bp->bits)*MALLOC_BITS;
+    k <<= bp->shift;
+
+    if (malloc_junk && bp->size != 0)
+        memset((char *)bp->page + k, SOME_JUNK, bp->size);
+
+    return (u_char *)bp->page + k;
 }
 
 /*
- * 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 piece of memory
  */
-int realloc_srchlen = 4;        /* 4 should be plenty, -1 =>'s whole list */
+static void *
+imalloc(size)
+    size_t size;
+{
+    void *result;
 
-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;
+    if (!malloc_started)
+        malloc_init();
+
+    if (suicide)
+        abort();
+
+    if ((size + malloc_pagesize) < size)       /* Check for overflow */
+        result = 0;
+    else if (size <= malloc_maxsize)
+        result =  malloc_bytes(size);
+    else
+        result =  malloc_pages(size);
+
+    if (malloc_abort && !result)
+        wrterror("allocation failed.\n");
+
+    if (malloc_zero && result)
+        memset(result, 0, size);
+
+    return result;
+}
+
+/*
+ * Change the size of an allocation.
+ */
+static void *
+irealloc(ptr, size)
+    void *ptr;
+    size_t size;
+{
+    void *p;
+    u_long osize, index;
+    struct pginfo **mp;
+    int i;
+
+    if (suicide)
+        abort();
+
+    if (!malloc_started) {
+        wrtwarning("malloc() has never been called.\n");
+        return 0;
+    }
+
+    index = ptr2index(ptr);
+
+    if (index < malloc_pageshift) {
+        wrtwarning("junk pointer, too low to make sense.\n");
+        return 0;
+    }
+
+    if (index > last_index) {
+        wrtwarning("junk pointer, too high to make sense.\n");
+        return 0;
+    }
+
+    mp = &page_dir[index];
+
+    if (*mp == MALLOC_FIRST) {                  /* Page allocation */
+
+        /* Check the pointer */
+        if ((u_long)ptr & malloc_pagemask) {
+            wrtwarning("modified (page-) pointer.\n");
+            return 0;
         }
-        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;
-                }
-                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);
+
+        /* Find the size in bytes */
+        for (osize = malloc_pagesize; *++mp == MALLOC_FOLLOW;)
+            osize += malloc_pagesize;
+
+        if (!malloc_realloc &&                  /* Unless we have to, */
+          size <= osize &&                      /* .. or are too small, */
+          size > (osize - malloc_pagesize)) {   /* .. or can free a page, */
+            if (malloc_junk)
+                memset((char *)ptr + size, SOME_JUNK, osize-size);
+            return ptr;                         /* ..don't do anything else. */
+        }
+
+    } else if (*mp >= MALLOC_MAGIC) {           /* Chunk allocation */
+
+        /* Check the pointer for sane values */
+        if ((u_long)ptr & ((1UL<<((*mp)->shift))-1)) {
+            wrtwarning("modified (chunk-) pointer.\n");
+            return 0;
+        }
+
+        /* Find the chunk index in the page */
+        i = ((u_long)ptr & malloc_pagemask) >> (*mp)->shift;
+
+        /* Verify that it isn't a free chunk already */
+        if ((*mp)->bits[i/MALLOC_BITS] & (1UL<<(i%MALLOC_BITS))) {
+            wrtwarning("chunk is already free.\n");
+            return 0;
+        }
+
+        osize = (*mp)->size;
+
+        if (!malloc_realloc &&          /* Unless we have to, */
+          size <= osize &&              /* ..or are too small, */
+          (size > osize/2 ||            /* ..or could use a smaller size, */
+          osize == malloc_minsize)) {   /* ..(if there is one) */
+            if (malloc_junk)
+                memset((char *)ptr + size, SOME_JUNK, osize-size);
+            return ptr;                 /* ..don't do anything else. */
+        }
+
+    } else {
+        wrtwarning("pointer to wrong page.\n");
+        return 0;
+    }
+
+    p = imalloc(size);
+
+    if (p) {
+        /* copy the lesser of the two sizes, and free the old one */
+        /* Don't move from/to 0 sized region !!! */
+        if (osize != 0 && size != 0) {
+            if (osize < size)
+                memcpy(p, ptr, osize);
+            else
+                memcpy(p, ptr, size);
         }
-        if ((res = malloc(nbytes)) == NULL)
-                return (NULL);
-        if (cp != res)          /* common optimization if "compacting" */
-                bcopy(cp, res, (nbytes < onb) ? nbytes : onb);
-        return (res);
+        ifree(ptr);
+    }
+    return p;
 }
 
 /*
- * 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.
+ * Free a sequence of pages
  */
-static
-findbucket(freep, srchlen)
-        union overhead *freep;
-        int srchlen;
+
+static __inline__ void
+free_pages(ptr, index, info)
+    void *ptr;
+    int index;
+    struct pginfo *info;
 {
-        register union overhead *p;
-        register int i, j;
-
-        for (i = 0; i < NBUCKETS; i++) {
-                j = 0;
-                for (p = nextf[i]; p && j != srchlen; p = p->ov_next) {
-                        if (p == freep)
-                                return (i);
-                        j++;
-                }
+    int i;
+    struct pgfree *pf, *pt=0;
+    u_long l;
+    void *tail;
+
+    if (info == MALLOC_FREE) {
+        wrtwarning("page is already free.\n");
+        return;
+    }
+
+    if (info != MALLOC_FIRST) {
+        wrtwarning("pointer to wrong page.\n");
+        return;
+    }
+
+    if ((u_long)ptr & malloc_pagemask) {
+        wrtwarning("modified (page-) pointer.\n");
+        return;
+    }
+
+    /* Count how many pages and mark them free at the same time */
+    page_dir[index] = MALLOC_FREE;
+    for (i = 1; page_dir[index+i] == MALLOC_FOLLOW; i++)
+        page_dir[index + i] = MALLOC_FREE;
+
+    l = i << malloc_pageshift;
+
+    if (malloc_junk)
+        memset(ptr, SOME_JUNK, l);
+
+#if defined(__FreeBSD__) || (defined(__OpenBSD__) && defined(MADV_FREE))
+    if (malloc_hint)
+        madvise(ptr, l, MADV_FREE);
+#endif
+
+    tail = (char *)ptr+l;
+
+    /* add to free-list */
+    if (!px)
+        px = imalloc(sizeof *px);       /* This cannot fail... */
+    px->page = ptr;
+    px->end =  tail;
+    px->size = l;
+    if (!free_list.next) {
+
+        /* Nothing on free list, put this at head */
+        px->next = free_list.next;
+        px->prev = &free_list;
+        free_list.next = px;
+        pf = px;
+        px = 0;
+
+    } else {
+
+        /* Find the right spot, leave pf pointing to the modified entry. */
+        tail = (char *)ptr+l;
+
+        for(pf = free_list.next; pf->end < ptr && pf->next; pf = pf->next)
+            ; /* Race ahead here */
+
+        if (pf->page > tail) {
+            /* Insert before entry */
+            px->next = pf;
+            px->prev = pf->prev;
+            pf->prev = px;
+            px->prev->next = px;
+            pf = px;
+            px = 0;
+        } else if (pf->end == ptr ) {
+            /* Append to the previous entry */
+            pf->end = (char *)pf->end + l;
+            pf->size += l;
+            if (pf->next && pf->end == pf->next->page ) {
+                /* And collapse the next too. */
+                pt = pf->next;
+                pf->end = pt->end;
+                pf->size += pt->size;
+                pf->next = pt->next;
+                if (pf->next)
+                    pf->next->prev = pf;
+            }
+        } else if (pf->page == tail) {
+            /* Prepend to entry */
+            pf->size += l;
+            pf->page = ptr;
+        } else if (!pf->next) {
+            /* Append at tail of chain */
+            px->next = 0;
+            px->prev = pf;
+            pf->next = px;
+            pf = px;
+            px = 0;
+        } else {
+            wrterror("freelist is destroyed.\n");
         }
-        return (-1);
+    }
+
+    /* Return something to OS ? */
+    if (!pf->next &&                            /* If we're the last one, */
+      pf->size > malloc_cache &&                /* ..and the cache is full, */
+      pf->end == malloc_brk &&                  /* ..and none behind us, */
+      malloc_brk == sbrk(0)) {                  /* ..and it's OK to do... */
+
+        /*
+         * Keep the cache intact.  Notice that the '>' above guarantees that
+         * the pf will always have at least one page afterwards.
+         */
+        pf->end = (char *)pf->page + malloc_cache;
+        pf->size = malloc_cache;
+
+        brk(pf->end);
+        malloc_brk = pf->end;
+
+        index = ptr2index(pf->end);
+
+        for(i=index;i <= last_index;)
+            page_dir[i++] = MALLOC_NOT_MINE;
+
+        last_index = index - 1;
+
+        /* XXX: We could realloc/shrink the pagedir here I guess. */
+    }
+    if (pt)
+        ifree(pt);
 }
 
-#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.
+ * Free a chunk, and possibly the page it's on, if the page becomes empty.
  */
-mstats(s)
-        char *s;
+
+/* ARGSUSED */
+static __inline__ void
+free_bytes(ptr, index, info)
+    void *ptr;
+    int index;
+    struct pginfo *info;
 {
-        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);
+    int i;
+    struct pginfo **mp;
+    void *vp;
+
+    /* Find the chunk number on the page */
+    i = ((u_long)ptr & malloc_pagemask) >> info->shift;
+
+    if ((u_long)ptr & ((1UL<<(info->shift))-1)) {
+        wrtwarning("modified (chunk-) pointer.\n");
+        return;
+    }
+
+    if (info->bits[i/MALLOC_BITS] & (1UL<<(i%MALLOC_BITS))) {
+        wrtwarning("chunk is already free.\n");
+        return;
+    }
+
+    if (malloc_junk && info->size != 0)
+        memset(ptr, SOME_JUNK, info->size);
+
+    info->bits[i/MALLOC_BITS] |= 1UL<<(i%MALLOC_BITS);
+    info->free++;
+
+    if (info->size != 0)
+        mp = page_dir + info->shift;
+    else
+        mp = page_dir;
+
+    if (info->free == 1) {
+
+        /* Page became non-full */
+
+        /* Insert in address order */
+        while (*mp && (*mp)->next && (*mp)->next->page < info->page)
+            mp = &(*mp)->next;
+        info->next = *mp;
+        *mp = info;
+        return;
+    }
+
+    if (info->free != info->total)
+        return;
+
+    /* Find & remove this page in the queue */
+    while (*mp != info) {
+        mp = &((*mp)->next);
+#ifdef MALLOC_EXTRA_SANITY
+        if (!*mp)
+                wrterror("(ES): Not on queue\n");
+#endif /* MALLOC_EXTRA_SANITY */
+    }
+    *mp = info->next;
+
+    /* Free the page & the info structure if need be */
+    page_dir[ptr2index(info->page)] = MALLOC_FIRST;
+
+    /* If the page was mprotected, unprotect it before releasing it */
+    if (info->size == 0) {
+        mprotect(info->page, malloc_pagesize, PROT_READ|PROT_WRITE);
+        /* Do we have to care if mprotect succeeds here ? */
+    }
+
+    vp = info->page;            /* Order is important ! */
+    if(vp != (void*)info)
+        ifree(info);
+    ifree(vp);
+}
+
+static void
+ifree(ptr)
+    void *ptr;
+{
+    struct pginfo *info;
+    int index;
+
+    /* This is legal */
+    if (!ptr)
+        return;
+
+    if (!malloc_started) {
+        wrtwarning("malloc() has never been called.\n");
+        return;
+    }
+
+    /* If we're already sinking, don't make matters any worse. */
+    if (suicide)
+        return;
+
+    index = ptr2index(ptr);
+
+    if (index < malloc_pageshift) {
+        wrtwarning("junk pointer, too low to make sense.\n");
+        return;
+    }
+
+    if (index > last_index) {
+        wrtwarning("junk pointer, too high to make sense.\n");
+        return;
+    }
+
+    info = page_dir[index];
+
+    if (info < MALLOC_MAGIC)
+        free_pages(ptr, index, info);
+    else
+        free_bytes(ptr, index, info);
+    return;
+}
+
+/*
+ * These are the public exported interface routines.
+ */
+
+static int malloc_active;
+
+void *
+malloc(size_t size)
+{
+    register void *r;
+
+    malloc_func = " in malloc():";
+    _MALLOC_LOCK();
+    if (malloc_active++) {
+        wrtwarning("recursive call.\n");
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        return (0);
+    }
+    r = imalloc(size);
+    UTRACE(0, size, r);
+    malloc_active--;
+    _MALLOC_UNLOCK();
+    if (malloc_xmalloc && !r)
+        wrterror("out of memory.\n");
+    return (r);
+}
+
+void
+free(void *ptr)
+{
+    malloc_func = " in free():";
+    _MALLOC_LOCK();
+    if (malloc_active++) {
+        wrtwarning("recursive call.\n");
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        return;
+    }
+    ifree(ptr);
+    UTRACE(ptr, 0, 0);
+    malloc_active--;
+    _MALLOC_UNLOCK();
+    return;
+}
+
+void *
+realloc(void *ptr, size_t size)
+{
+    register void *r;
+
+    malloc_func = " in realloc():";
+    _MALLOC_LOCK();
+    if (malloc_active++) {
+        wrtwarning("recursive call.\n");
+        malloc_active--;
+        _MALLOC_UNLOCK();
+        return (0);
+    }
+    if (!ptr) {
+        r = imalloc(size);
+    } else {
+        r = irealloc(ptr, size);
+    }
+    UTRACE(ptr, size, r);
+    malloc_active--;
+    _MALLOC_UNLOCK();
+    if (malloc_xmalloc && !r)
+        wrterror("out of memory.\n");
+    return (r);
 }
-#endif
diff --git a/src/lib/libc/stdlib/memory.3 b/src/lib/libc/stdlib/memory.3
index 735252c837..959a173a03 100644
--- a/src/lib/libc/stdlib/memory.3
+++ b/src/lib/libc/stdlib/memory.3
@@ -29,12 +29,11 @@
 .\" 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: memory.3,v 1.5 2000/04/20 13:50:02 aaron Exp $
 .\"
 .Dd May 2, 1991
 .Dt MEMORY 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm malloc ,
 .Nm free ,
@@ -56,16 +55,15 @@
 .Fn alloca "size_t size"
 .Sh DESCRIPTION
 These functions allocate and free memory for the calling process.
-They are described in the
-individual manual pages.
+They are described in the individual man pages.
 .Sh SEE ALSO
+.Xr alloca 3 ,
 .Xr calloc 3 ,
 .Xr free 3 ,
 .Xr malloc 3 ,
-.Xr realloc 3 ,
-.Xr alloca 3 ,
+.Xr realloc 3
 .Sh STANDARDS
 These functions, with the exception of
-.Fn alloca
+.Fn alloca ,
 conform to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/merge.c b/src/lib/libc/stdlib/merge.c
index 381fdc0830..4ae6488af2 100644
--- a/src/lib/libc/stdlib/merge.c
+++ b/src/lib/libc/stdlib/merge.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: merge.c,v 1.5 2002/02/17 19:42:24 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 /*
@@ -59,8 +58,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 *)
@@ -100,7 +99,7 @@ mergesort(base, nmemb, size, cmp)
         void *base;
         size_t nmemb;
         register size_t size;
-        int (*cmp) __P((const void *, const void *));
+        int (*cmp)(const void *, const void *);
 {
         register int i, sense;
         int big, iflag;
@@ -148,7 +147,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 +168,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;
@@ -258,7 +257,7 @@ COPY:	    			b = t;
 void
 setup(list1, list2, n, size, cmp)
         size_t n, size;
-        int (*cmp) __P((const void *, const void *));
+        int (*cmp)(const void *, const void *);
         u_char *list1, *list2;
 {
         int i, length, size2, tmp, sense;
@@ -333,7 +332,7 @@ static void
 insertionsort(a, n, size, cmp)
         u_char *a;
         size_t n, size;
-        int (*cmp) __P((const void *, const void *));
+        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..cd34260b5c 100644
--- a/src/lib/libc/stdlib/mrand48.c
+++ b/src/lib/libc/stdlib/mrand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: mrand48.c,v 1.2 1996/08/19 08:33:39 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/multibyte.c b/src/lib/libc/stdlib/multibyte.c
index fe1cd5781b..6f08bbe342 100644
--- a/src/lib/libc/stdlib/multibyte.c
+++ b/src/lib/libc/stdlib/multibyte.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: multibyte.c,v 1.3 2002/02/19 19:39:37 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
@@ -74,13 +73,7 @@ mbtowc(pwc, s, n)
 
 /*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;
diff --git a/src/lib/libc/stdlib/nrand48.c b/src/lib/libc/stdlib/nrand48.c
index 63f839cb05..b1ec2cebb1 100644
--- a/src/lib/libc/stdlib/nrand48.c
+++ b/src/lib/libc/stdlib/nrand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: nrand48.c,v 1.2 1996/08/19 08:33:40 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 long
diff --git a/src/lib/libc/stdlib/putenv.c b/src/lib/libc/stdlib/putenv.c
index 2194c2c608..d8c4886d4b 100644
--- a/src/lib/libc/stdlib/putenv.c
+++ b/src/lib/libc/stdlib/putenv.c
@@ -1,6 +1,6 @@
 /*-
- * 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
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: putenv.c,v 1.2 1996/08/10 05:03:00 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
@@ -43,17 +42,17 @@ int
 putenv(str)
         const char *str;
 {
-        register char *p, *equal;
+        char *p, *equal;
         int rval;
 
-        if (!(p = strdup(str)))
-                return(1);
-        if (!(equal = strchr(p, '='))) {
+        if ((p = strdup(str)) == NULL)
+                return (-1);
+        if ((equal = strchr(p, '=')) == NULL) {
                 (void)free(p);
-                return(1);
+                return (-1);
         }
         *equal = '\0';
         rval = setenv(p, equal + 1, 1);
         (void)free(p);
-        return(rval);
+        return (rval);
 }
diff --git a/src/lib/libc/stdlib/qabs.3 b/src/lib/libc/stdlib/qabs.3
index cb1e052191..ef0307ab25 100644
--- a/src/lib/libc/stdlib/qabs.3
+++ b/src/lib/libc/stdlib/qabs.3
@@ -33,8 +33,7 @@
 .\" 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.5 2000/04/20 13:50:02 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt QABS 3
@@ -49,14 +48,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 floor 3 ,
+.Xr labs 3 ,
 .Xr math 3
 .Sh BUGS
 The absolute value of the most negative integer remains negative.
diff --git a/src/lib/libc/stdlib/qabs.c b/src/lib/libc/stdlib/qabs.c
index 9c51a8baa9..ccc42cbec6 100644
--- a/src/lib/libc/stdlib/qabs.c
+++ b/src/lib/libc/stdlib/qabs.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: qabs.c,v 1.2 1996/08/19 08:33:40 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
diff --git a/src/lib/libc/stdlib/qdiv.3 b/src/lib/libc/stdlib/qdiv.3
index 0efcfc96ef..4db47d9b4a 100644
--- a/src/lib/libc/stdlib/qdiv.3
+++ b/src/lib/libc/stdlib/qdiv.3
@@ -33,8 +33,7 @@
 .\" 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.4 2000/12/24 00:31:00 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt QDIV 3
@@ -49,17 +48,16 @@
 .Sh DESCRIPTION
 The
 .Fn qdiv
-function
-computes the value
-.Ar num/denom
+function computes the value
+.Fa num Ns No / 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 ldiv 3 ,
diff --git a/src/lib/libc/stdlib/qdiv.c b/src/lib/libc/stdlib/qdiv.c
index 8f8e3f89c4..07e84cd649 100644
--- a/src/lib/libc/stdlib/qdiv.c
+++ b/src/lib/libc/stdlib/qdiv.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: qdiv.c,v 1.2 1996/08/19 08:33:41 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>             /* qdiv_t */
diff --git a/src/lib/libc/stdlib/qsort.3 b/src/lib/libc/stdlib/qsort.3
index eb122cde12..a0561cadbe 100644
--- a/src/lib/libc/stdlib/qsort.3
+++ b/src/lib/libc/stdlib/qsort.3
@@ -33,14 +33,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.10 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd June 4, 1993
 .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 +73,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 +107,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
+This implementation of
 .Fn qsort
-is that it uses almost no additional memory; while
-.Fn qsort
-does not allocate memory, it is implemented using recursion.
+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,20 +162,21 @@ 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.
@@ -185,7 +185,7 @@ were unable to allocate memory.
 Previous versions of
 .Fn qsort
 did not permit the comparison routine itself to call
-.Fn qsort 3 .
+.Fn qsort .
 This is no longer true.
 .Sh SEE ALSO
 .Xr sort 1 ,
@@ -229,6 +229,5 @@ This is no longer true.
 .Sh STANDARDS
 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..9b8bb5801b 100644
--- a/src/lib/libc/stdlib/qsort.c
+++ b/src/lib/libc/stdlib/qsort.c
@@ -32,15 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: qsort.c,v 1.7 2002/02/17 19:42:24 millert 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 (*)());
+static __inline void     swapfunc(char *, char *, int, int);
 
 #define min(a, b)       (a) < (b) ? a : b
 
@@ -61,12 +60,12 @@ 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
+static __inline void
 swapfunc(a, b, n, swaptype)
         char *a, *b;
         int n, swaptype;
 {
-        if(swaptype <= 1) 
+        if (swaptype <= 1) 
                 swapcode(long, a, b, n)
         else
                 swapcode(char, a, b, n)
@@ -82,7 +81,7 @@ swapfunc(a, b, n, swaptype)
 
 #define vecswap(a, b, n)        if ((n) > 0) swapfunc(a, b, n, swaptype)
 
-static inline char *
+static __inline char *
 med3(a, b, c, cmp)
         char *a, *b, *c;
         int (*cmp)();
@@ -93,27 +92,28 @@ med3(a, b, c, cmp)
 }
 
 void
-qsort(a, n, es, cmp)
-        void *a;
+qsort(aa, n, es, cmp)
+        void *aa;
         size_t n, es;
         int (*cmp)();
 {
         char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
         int d, r, swaptype, swap_cnt;
+        register 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,9 +123,9 @@ 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) {
@@ -151,14 +151,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..f70990fa8e 100644
--- a/src/lib/libc/stdlib/radixsort.3
+++ b/src/lib/libc/stdlib/radixsort.3
@@ -29,8 +29,7 @@
 .\" 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.7 2001/08/06 10:42:26 mpech Exp $
 .\"
 .Dd January 27, 1994
 .Dt RADIXSORT 3
@@ -42,16 +41,15 @@
 .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
@@ -63,26 +61,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
+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
@@ -107,7 +103,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 +118,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 +152,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..e03b479715 100644
--- a/src/lib/libc/stdlib/radixsort.c
+++ b/src/lib/libc/stdlib/radixsort.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: radixsort.c,v 1.5 2002/02/17 19:42:24 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 /*
@@ -61,11 +60,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. */
@@ -295,7 +294,7 @@ r_sort_b(a, ta, n, i, tr, endch)
         }
 }
                 
-static inline void
+static __inline void
 simplesort(a, n, b, tr, endch)  /* insertion sort */
         register const u_char **a;
         int n, b;
diff --git a/src/lib/libc/stdlib/rand.3 b/src/lib/libc/stdlib/rand.3
index a0e7740e66..8899c2e104 100644
--- a/src/lib/libc/stdlib/rand.3
+++ b/src/lib/libc/stdlib/rand.3
@@ -33,8 +33,7 @@
 .\" 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.8 2001/05/13 23:38:02 millert Exp $
 .\"
 .Dd June 29, 1991
 .Dt RAND 3
@@ -46,12 +45,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 +75,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..bb180886c0 100644
--- a/src/lib/libc/stdlib/rand.c
+++ b/src/lib/libc/stdlib/rand.c
@@ -32,24 +32,34 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: rand.c,v 1.6 1998/12/07 21:47:22 millert 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(seed)
+u_int *seed;
+{
+
+        *seed = *seed * 1103515245 + 12345;
+        return (*seed % ((u_int)RAND_MAX + 1));
+}
 
 int
 rand()
 {
-        return ((next = next * 1103515245 + 12345) % ((u_int)RAND_MAX + 1));
+
+        return (rand_r(&next));
 }
 
 void
 srand(seed)
 u_int seed;
 {
+
         next = seed;
 }
diff --git a/src/lib/libc/stdlib/rand48.3 b/src/lib/libc/stdlib/rand48.3
index 5a772c9a8c..6b0831ead7 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,7 +9,7 @@
 .\" 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.9 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd October 8, 1993
 .Dt RAND48 3
@@ -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
+.Xr random 3 .
+.Sh AUTHORS
 Martin Birgmeier
 .Sh SEE ALSO
+.Xr arc4random 3 ,
 .Xr rand 3 ,
-.Xr random 3 .
+.Xr random 3
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..b98917a442 100644
--- a/src/lib/libc/stdlib/random.3
+++ b/src/lib/libc/stdlib/random.3
@@ -29,97 +29,106 @@
 .\" 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.15 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd April 19, 1991
 .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 the
+.Xr arandom 4
+random number device which returns good random numbers,
+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 +152,10 @@ 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 AUTHORS
+.An Earl T. Cohen
 .Sh DIAGNOSTICS
 If
 .Fn initstate
@@ -157,10 +164,26 @@ 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 BUGS
 About 2/3 the speed of
diff --git a/src/lib/libc/stdlib/random.c b/src/lib/libc/stdlib/random.c
index 469b6d976a..49a5ed1c3e 100644
--- a/src/lib/libc/stdlib/random.c
+++ b/src/lib/libc/stdlib/random.c
@@ -32,12 +32,16 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: random.c,v 1.11 2003/02/28 21:27:44 millert 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 +59,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 +138,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 +162,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 +175,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:
@@ -191,17 +195,28 @@ static long *end_ptr = &randtbl[DEG_3 + 1];
  */
 void
 srandom(x)
-        u_int x;
+        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 +225,65 @@ srandom(x)
 }
 
 /*
+ * srandomdev:
+ *
+ * Many programs choose the seed value in a totally predictable manner.
+ * This often causes problems.  We seed the generator using the much more
+ * secure arandom(4) interface.  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()
+{
+        int fd, i, mib[2], n;
+        size_t len;
+
+        if (rand_type == TYPE_0)
+                len = sizeof(state[0]);
+        else
+                len = rand_deg * sizeof(state[0]);
+
+        /*
+         * To get seed data, first try reading from /dev/arandom.
+         * If that fails, try the KERN_ARND sysctl() (one int at a time).
+         * As a last resort, call srandom().
+         */
+        if ((fd = open("/dev/arandom", O_RDONLY, 0)) != -1 &&
+            read(fd, (void *) state, len) == (ssize_t) len) {
+                close(fd);
+        } else {
+                if (fd != -1)
+                        close(fd);
+                mib[0] = CTL_KERN;
+                mib[1] = KERN_ARND;
+                n = len / sizeof(int);
+                len = sizeof(int);
+                for (i = 0; i < n; i++) {
+                        if (sysctl(mib, 2, (char *)((int *)state + i), &len,
+                            NULL, 0) == -1)
+                                break;
+                }
+                if (i != n) {
+                        struct timeval tv;
+                        u_int junk;
+
+                        /* XXX - this could be better */
+                        gettimeofday(&tv, NULL);
+                        srandom(getpid() ^ tv.tv_sec ^ tv.tv_usec ^ junk);
+                        return;
+                }
+        }
+
+        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
@@ -232,19 +306,16 @@ 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 */
+        size_t n;                       /* # bytes of state info */
 {
-        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 +337,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)
@@ -293,11 +364,11 @@ initstate(seed, arg_state, n)
  */
 char *
 setstate(arg_state)
-        char *arg_state;
+        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 +386,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) {
@@ -347,7 +417,7 @@ setstate(arg_state)
 long
 random()
 {
-        long i;
+        int32_t i;
 
         if (rand_type == TYPE_0)
                 i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
@@ -360,5 +430,5 @@ random()
                 } else if (++rptr >= end_ptr)
                         rptr = state;
         }
-        return(i);
+        return((long)i);
 }
diff --git a/src/lib/libc/stdlib/realpath.3 b/src/lib/libc/stdlib/realpath.3
index 9d8b1ff2ce..56fbea9ede 100644
--- a/src/lib/libc/stdlib/realpath.3
+++ b/src/lib/libc/stdlib/realpath.3
@@ -32,10 +32,9 @@
 .\" 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.8 2001/04/23 15:30:25 aaron Exp $
 .\"
-.Dd "February 16, 1994"
+.Dd February 16, 1994
 .Dt REALPATH 3
 .Os
 .Sh NAME
@@ -57,8 +56,7 @@ and
 .Pa /../
 in
 .Fa pathname ,
-and copies the resulting absolute pathname into
-the memory referenced by
+and copies the resulting absolute pathname into the memory referenced by
 .Fa resolvedname .
 The
 .Fa resolvedname
@@ -68,7 +66,7 @@ refer to a buffer capable of storing at least
 .Dv MAXPATHLEN
 characters.
 .Pp
-The 
+The
 .Fn realpath
 function will resolve both absolute and relative paths
 and return the absolute pathname corresponding to
@@ -82,14 +80,14 @@ is called.
 The
 .Fn realpath
 function returns
-.Fa resolved_name
+.Fa resolvedname
 on success.
 If an error occurs,
 .Fn realpath
 returns
 .Dv NULL ,
 and
-.Fa resolved_name
+.Fa resolvedname
 contains the pathname which caused the problem.
 .Sh ERRORS
 The function
@@ -102,7 +100,7 @@ for any of the errors specified for the library functions
 .Xr fchdir 2 ,
 .Xr lstat 2 ,
 .Xr open 2 ,
-.Xr readlink 2
+.Xr readlink 2 ,
 and
 .Xr getcwd 3 .
 .Sh CAVEATS
@@ -114,10 +112,10 @@ The
 version always returns absolute pathnames,
 whereas the Solaris implementation will,
 under certain circumstances, return a relative
-.Fa resolved_path
+.Fa resolvedname
 when given a relative
 .Fa pathname .
-.Sh "SEE ALSO"
+.Sh SEE ALSO
 .Xr getcwd 3
 .Sh HISTORY
 The
diff --git a/src/lib/libc/stdlib/realpath.c b/src/lib/libc/stdlib/realpath.c
index e349b7e068..71063394d1 100644
--- a/src/lib/libc/stdlib/realpath.c
+++ b/src/lib/libc/stdlib/realpath.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: realpath.c,v 1.8 2003/04/04 22:47:43 hin Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
@@ -63,13 +62,18 @@ realpath(path, resolved)
         struct stat sb;
         int fd, n, rootd, serrno;
         char *p, *q, wbuf[MAXPATHLEN];
+        int symlinks = 0;
 
         /* Save the starting point. */
         if ((fd = open(".", O_RDONLY)) < 0) {
-                (void)strcpy(resolved, ".");
+                (void)strlcpy(resolved, ".", MAXPATHLEN);
                 return (NULL);
         }
 
+        /* Convert "." -> "" to optimize away a needless lstat() and chdir() */
+        if (path[0] == '.' && path[1] == '\0')
+                path = "";
+
         /*
          * Find the dirname and basename from the path to be resolved.
          * Change directory to the dirname component.
@@ -78,8 +82,7 @@ realpath(path, resolved)
          *     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';
+        strlcpy(resolved, path, MAXPATHLEN);
 loop:
         q = strrchr(resolved, '/');
         if (q != NULL) {
@@ -99,9 +102,13 @@ loop:
                 p = resolved;
 
         /* Deal with the last component. */
-        if (lstat(p, &sb) == 0) {
+        if (*p != '\0' && lstat(p, &sb) == 0) {
                 if (S_ISLNK(sb.st_mode)) {
-                        n = readlink(p, resolved, MAXPATHLEN);
+                        if (++symlinks > MAXSYMLINKS) {
+                                errno = ELOOP;
+                                goto err1;
+                        }
+                        n = readlink(p, resolved, MAXPATHLEN-1);
                         if (n < 0)
                                 goto err1;
                         resolved[n] = '\0';
@@ -118,7 +125,7 @@ loop:
          * Save the last component name and get the full pathname of
          * the current directory.
          */
-        (void)strcpy(wbuf, p);
+        (void)strlcpy(wbuf, p, sizeof wbuf);
         if (getcwd(resolved, MAXPATHLEN) == 0)
                 goto err1;
 
@@ -137,8 +144,8 @@ loop:
                         goto err1;
                 }
                 if (rootd == 0)
-                        (void)strcat(resolved, "/");
-                (void)strcat(resolved, wbuf);
+                        strlcat(resolved, "/", MAXPATHLEN);
+                strlcat(resolved, wbuf, MAXPATHLEN);
         }
 
         /* Go back to where we came from. */
diff --git a/src/lib/libc/stdlib/remque.c b/src/lib/libc/stdlib/remque.c
new file mode 100644
index 0000000000..f4c5769a8c
--- /dev/null
+++ b/src/lib/libc/stdlib/remque.c
@@ -0,0 +1,48 @@
+/*      $OpenBSD: remque.c,v 1.1 2003/05/08 23:26:30 millert 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.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: remque.c,v 1.1 2003/05/08 23:26:30 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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..c4dcd0ead8 100644
--- a/src/lib/libc/stdlib/seed48.c
+++ b/src/lib/libc/stdlib/seed48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: seed48.c,v 1.2 1996/08/19 08:33:48 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/setenv.c b/src/lib/libc/stdlib/setenv.c
index a36669888d..044f01b1c9 100644
--- a/src/lib/libc/stdlib/setenv.c
+++ b/src/lib/libc/stdlib/setenv.c
@@ -32,13 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: setenv.c,v 1.5 2002/12/10 22:44:13 mickey Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdlib.h>
 #include <string.h>
 
+char *__findenv(const char *name, int *offset);
+
 /*
  * setenv --
  *      Set the value of the environmental variable "name" to be
@@ -54,7 +55,6 @@ setenv(name, value, rewrite)
         static int alloced;                     /* if allocated space before */
         register char *C;
         int l_value, offset;
-        char *__findenv();
 
         if (*value == '=')                      /* no `=' in value */
                 ++value;
@@ -63,7 +63,8 @@ setenv(name, value, rewrite)
                 if (!rewrite)
                         return (0);
                 if (strlen(C) >= l_value) {     /* old larger; copy over */
-                        while (*C++ = *value++);
+                        while ((*C++ = *value++))
+                                ;
                         return (0);
                 }
         } else {                                        /* create new slot */
@@ -72,10 +73,11 @@ setenv(name, value, rewrite)
 
                 for (P = environ, cnt = 0; *P; ++P, ++cnt);
                 if (alloced) {                  /* just increase size */
-                        environ = (char **)realloc((char *)environ,
+                        P = (char **)realloc((void *)environ,
                             (size_t)(sizeof(char *) * (cnt + 2)));
-                        if (!environ)
+                        if (!P)
                                 return (-1);
+                        environ = P;
                 }
                 else {                          /* get new space */
                         alloced = 1;            /* copy old entries into it */
@@ -95,7 +97,7 @@ setenv(name, value, rewrite)
                 return (-1);
         for (C = environ[offset]; (*C = *name++) && *C != '='; ++C)
                 ;
-        for (*C++ = '='; *C++ = *value++; )
+        for (*C++ = '='; (*C++ = *value++); )
                 ;
         return (0);
 }
diff --git a/src/lib/libc/stdlib/srand48.c b/src/lib/libc/stdlib/srand48.c
index daf733f93e..fcff8a172e 100644
--- a/src/lib/libc/stdlib/srand48.c
+++ b/src/lib/libc/stdlib/srand48.c
@@ -11,6 +11,10 @@
  * to anyone/anything when using this software.
  */
 
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: srand48.c,v 1.2 1996/08/19 08:33:49 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
+
 #include "rand48.h"
 
 extern unsigned short __rand48_seed[3];
diff --git a/src/lib/libc/stdlib/strtod.3 b/src/lib/libc/stdlib/strtod.3
index 0b7f973857..4e04f6738e 100644
--- a/src/lib/libc/stdlib/strtod.3
+++ b/src/lib/libc/stdlib/strtod.3
@@ -33,8 +33,7 @@
 .\" 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.7 2000/04/20 13:50:03 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRTOD 3
@@ -51,20 +50,25 @@ string to double
 .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.
 .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
@@ -88,18 +92,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 +113,5 @@ Overflow or underflow occurred.
 .Sh STANDARDS
 The
 .Fn strtod
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/stdlib/strtod.c b/src/lib/libc/stdlib/strtod.c
index b13fa128f5..17d26a1dc3 100644
--- a/src/lib/libc/stdlib/strtod.c
+++ b/src/lib/libc/stdlib/strtod.c
@@ -90,12 +90,13 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strtod.c,v 1.16 2002/12/02 15:38:54 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \
-    defined(__mips__) || defined(__ns32k__) || defined(__alpha__)
-#include <machine/endian.h>
+    defined(__mips__) || defined(__ns32k__) || defined(__alpha__) || \
+    defined(__powerpc__) || defined(__m88k__) || defined(__hppa__)
+#include <sys/types.h>
 #if BYTE_ORDER == BIG_ENDIAN
 #define IEEE_BIG_ENDIAN
 #else
@@ -103,7 +104,16 @@ static char *rcsid = "$Id: strtod.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
 #endif
 #endif
 
-#ifdef vax
+#ifdef __arm32__
+/*
+ * Although the CPU is little endian the FP has different
+ * byte and word endianness. The byte order is still little endian
+ * but the word order is big endian.
+ */
+#define IEEE_BIG_ENDIAN
+#endif
+
+#ifdef __vax__
 #define VAX
 #endif
 
@@ -143,7 +153,6 @@ extern void *MALLOC(size_t);
 #include "errno.h"
 
 #ifdef Bad_float_h
-#undef __STDC__
 #ifdef IEEE_BIG_ENDIAN
 #define IEEE_ARITHMETIC
 #endif
@@ -212,19 +221,24 @@ Exactly one of IEEE_LITTLE_ENDIAN IEEE_BIG_ENDIAN, VAX, or
 IBM should be defined.
 #endif
 
+typedef union {
+        double d;
+        ULong ul[2];
+} _double;
+#define value(x) ((x).d)
 #ifdef IEEE_LITTLE_ENDIAN
-#define word0(x) ((ULong *)&x)[1]
-#define word1(x) ((ULong *)&x)[0]
+#define word0(x) ((x).ul[1])
+#define word1(x) ((x).ul[0])
 #else
-#define word0(x) ((ULong *)&x)[0]
-#define word1(x) ((ULong *)&x)[1]
+#define word0(x) ((x).ul[0])
+#define word1(x) ((x).ul[1])
 #endif
 
 /* The following definition of Storeinc is appropriate for MIPS processors.
  * An alternative that might be better on some machines is
  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
  */
-#if defined(IEEE_LITTLE_ENDIAN) + defined(VAX)
+#if defined(IEEE_LITTLE_ENDIAN) + defined(VAX) + defined(__arm32__)
 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
 ((unsigned short *)a)[0] = (unsigned short)c, a++)
 #else
@@ -380,7 +394,7 @@ Balloc
         int x;
         Bigint *rv;
 
-        if (rv = freelist[k]) {
+        if ((rv = freelist[k])) {
                 freelist[k] = rv->next;
                 }
         else {
@@ -628,7 +642,7 @@ mult
         xc0 = c->x;
 #ifdef Pack_32
         for(; xb < xbe; xb++, xc0++) {
-                if (y = *xb & 0xffff) {
+                if ((y = *xb & 0xffff)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -642,7 +656,7 @@ mult
                                 while(x < xae);
                         *xc = carry;
                         }
-                if (y = *xb >> 16) {
+                if ((y = *xb >> 16)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -693,7 +707,7 @@ pow5mult
         int i;
         static int p05[3] = { 5, 25, 125 };
 
-        if (i = k & 3)
+        if ((i = k & 3))
                 b = multadd(b, p05[i-1], 0);
 
         if (!(k >>= 2))
@@ -756,7 +770,7 @@ lshift
                         z = *x++ >> k1;
                         }
                         while(x < xe);
-                if (*x1 = z)
+                if ((*x1 = z))
                         ++n1;
                 }
 #else
@@ -899,14 +913,16 @@ diff
  static double
 ulp
 #ifdef KR_headers
-        (x) double x;
+        (_x) double _x;
 #else
-        (double x)
+        (double _x)
 #endif
 {
+        _double x;
         register Long L;
-        double a;
+        _double a;
 
+        value(x) = _x;
         L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
 #ifndef Sudden_Underflow
         if (L > 0) {
@@ -931,7 +947,7 @@ ulp
                         }
                 }
 #endif
-        return a;
+        return value(a);
         }
 
  static double
@@ -944,7 +960,7 @@ b2d
 {
         ULong *xa, *xa0, w, y, z;
         int k;
-        double d;
+        _double d;
 #ifdef VAX
         ULong d0, d1;
 #else
@@ -1001,22 +1017,27 @@ b2d
 #undef d0
 #undef d1
 #endif
-        return d;
+        return value(d);
         }
 
  static Bigint *
 d2b
 #ifdef KR_headers
-        (d, e, bits) double d; int *e, *bits;
+        (_d, e, bits) double d; int *e, *bits;
 #else
-        (double d, int *e, int *bits)
+        (double _d, int *e, int *bits)
 #endif
 {
         Bigint *b;
         int de, i, k;
         ULong *x, y, z;
+        _double d;
 #ifdef VAX
         ULong d0, d1;
+#endif
+
+        value(d) = _d;
+#ifdef VAX
         d0 = word0(d) >> 16 | word0(d) << 16;
         d1 = word1(d) >> 16 | word1(d) << 16;
 #else
@@ -1141,11 +1162,11 @@ ratio
         (Bigint *a, Bigint *b)
 #endif
 {
-        double da, db;
+        _double da, db;
         int k, ka, kb;
 
-        da = b2d(a, &ka);
-        db = b2d(b, &kb);
+        value(da) = b2d(a, &ka);
+        value(db) = b2d(b, &kb);
 #ifdef Pack_32
         k = ka - kb + 32*(a->wds - b->wds);
 #else
@@ -1171,7 +1192,7 @@ ratio
                 word0(db) += k*Exp_msk1;
                 }
 #endif
-        return da / db;
+        return value(da) / value(db);
         }
 
 static CONST double
@@ -1211,7 +1232,8 @@ strtod
         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;
+        double aadj, aadj1, adj;
+        _double rv, rv0;
         Long L;
         ULong y, z;
         Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
@@ -1223,10 +1245,10 @@ strtod
 #endif
 
         sign = nz0 = nz = 0;
-        rv = 0.;
+        value(rv) = 0.;
 
 
-        for(s = s00; isspace(*s); s++)
+        for(s = s00; isspace((unsigned char) *s); s++)
                 ;
 
         if (*s == '-') {
@@ -1340,9 +1362,9 @@ strtod
         if (!nd0)
                 nd0 = nd;
         k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
-        rv = y;
+        value(rv) = y;
         if (k > 9)
-                rv = tens[k - 9] * rv + z;
+                value(rv) = tens[k - 9] * value(rv) + z;
         bd0 = 0;
         if (nd <= DBL_DIG
 #ifndef RND_PRODQUOT
@@ -1356,7 +1378,8 @@ strtod
 #ifdef VAX
                                 goto vax_ovfl_check;
 #else
-                                /* rv = */ rounded_product(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
                                 goto ret;
 #endif
                                 }
@@ -1366,27 +1389,30 @@ strtod
                                  * this for larger i values.
                                  */
                                 e -= i;
-                                rv *= tens[i];
+                                value(rv) *= tens[i];
 #ifdef VAX
                                 /* VAX exponent range is so narrow we must
                                  * worry about overflow here...
                                  */
  vax_ovfl_check:
                                 word0(rv) -= P*Exp_msk1;
-                                /* rv = */ rounded_product(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
                                 if ((word0(rv) & Exp_mask)
                                  > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
                                         goto ovfl;
                                 word0(rv) += P*Exp_msk1;
 #else
-                                /* rv = */ rounded_product(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
 #endif
                                 goto ret;
                                 }
                         }
 #ifndef Inaccurate_Divide
                 else if (e >= -Ten_pmax) {
-                        /* rv = */ rounded_quotient(rv, tens[-e]);
+                        /* value(rv) = */ rounded_quotient(value(rv),
+                            tens[-e]);
                         goto ret;
                         }
 #endif
@@ -1397,13 +1423,13 @@ strtod
 
         if (e1 > 0) {
                 if (i = e1 & 15)
-                        rv *= tens[i];
+                        value(rv) *= tens[i];
                 if (e1 &= ~15) {
                         if (e1 > DBL_MAX_10_EXP) {
  ovfl:
                                 errno = ERANGE;
-#ifdef __STDC__
-                                rv = HUGE_VAL;
+#ifndef Bad_float_h
+                                value(rv) = HUGE_VAL;
 #else
                                 /* Can't trust HUGE_VAL */
 #ifdef IEEE_Arith
@@ -1421,10 +1447,10 @@ strtod
                         if (e1 >>= 4) {
                                 for(j = 0; e1 > 1; j++, e1 >>= 1)
                                         if (e1 & 1)
-                                                rv *= bigtens[j];
+                                                value(rv) *= bigtens[j];
                         /* The last multiplication could overflow. */
                                 word0(rv) -= P*Exp_msk1;
-                                rv *= bigtens[j];
+                                value(rv) *= bigtens[j];
                                 if ((z = word0(rv) & Exp_mask)
                                  > Exp_msk1*(DBL_MAX_EXP+Bias-P))
                                         goto ovfl;
@@ -1443,23 +1469,23 @@ strtod
         else if (e1 < 0) {
                 e1 = -e1;
                 if (i = e1 & 15)
-                        rv /= tens[i];
+                        value(rv) /= tens[i];
                 if (e1 &= ~15) {
                         e1 >>= 4;
                         if (e1 >= 1 << n_bigtens)
                                 goto undfl;
                         for(j = 0; e1 > 1; j++, e1 >>= 1)
                                 if (e1 & 1)
-                                        rv *= tinytens[j];
+                                        value(rv) *= tinytens[j];
                         /* The last multiplication could underflow. */
-                        rv0 = rv;
-                        rv *= tinytens[j];
-                        if (!rv) {
-                                rv = 2.*rv0;
-                                rv *= tinytens[j];
-                                if (!rv) {
+                        value(rv0) = value(rv);
+                        value(rv) *= tinytens[j];
+                        if (!value(rv)) {
+                                value(rv) = 2.*value(rv0);
+                                value(rv) *= tinytens[j];
+                                if (!value(rv)) {
  undfl:
-                                        rv = 0.;
+                                        value(rv) = 0.;
                                         errno = ERANGE;
                                         if (bd0)
                                                 goto retfree;
@@ -1483,7 +1509,7 @@ strtod
         for(;;) {
                 bd = Balloc(bd0->k);
                 Bcopy(bd, bd0);
-                bb = d2b(rv, &bbe, &bbbits);    /* rv = bb * 2^bbe */
+                bb = d2b(value(rv), &bbe, &bbbits);     /* rv = bb * 2^bbe */
                 bs = i2b(1);
 
                 if (e >= 0) {
@@ -1595,12 +1621,12 @@ strtod
                                 break;
 #endif
                         if (dsign)
-                                rv += ulp(rv);
+                                value(rv) += ulp(value(rv));
 #ifndef ROUND_BIASED
                         else {
-                                rv -= ulp(rv);
+                                value(rv) -= ulp(value(rv));
 #ifndef Sudden_Underflow
-                                if (!rv)
+                                if (!value(rv))
                                         goto undfl;
 #endif
                                 }
@@ -1651,10 +1677,10 @@ strtod
                 /* Check for overflow */
 
                 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
-                        rv0 = rv;
+                        value(rv0) = value(rv);
                         word0(rv) -= P*Exp_msk1;
-                        adj = aadj1 * ulp(rv);
-                        rv += adj;
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
                         if ((word0(rv) & Exp_mask) >=
                                         Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
                                 if (word0(rv0) == Big0 && word1(rv0) == Big1)
@@ -1669,10 +1695,10 @@ strtod
                 else {
 #ifdef Sudden_Underflow
                         if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
-                                rv0 = rv;
+                                value(rv0) = value(rv);
                                 word0(rv) += P*Exp_msk1;
-                                adj = aadj1 * ulp(rv);
-                                rv += adj;
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
 #ifdef IBM
                                 if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
 #else
@@ -1690,8 +1716,8 @@ strtod
                                         word0(rv) -= P*Exp_msk1;
                                 }
                         else {
-                                adj = aadj1 * ulp(rv);
-                                rv += adj;
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
                                 }
 #else
                         /* Compute adj so that the IEEE rounding rules will
@@ -1706,8 +1732,8 @@ strtod
                                 if (!dsign)
                                         aadj1 = -aadj1;
                                 }
-                        adj = aadj1 * ulp(rv);
-                        rv += adj;
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
 #endif
                         }
                 z = word0(rv) & Exp_mask;
@@ -1738,7 +1764,7 @@ strtod
  ret:
         if (se)
                 *se = (char *)s;
-        return sign ? -rv : rv;
+        return sign ? -value(rv) : value(rv);
         }
 
  static int
@@ -1884,10 +1910,10 @@ quorem
  char *
 __dtoa
 #ifdef KR_headers
-        (d, mode, ndigits, decpt, sign, rve)
-        double d; int mode, ndigits, *decpt, *sign; char **rve;
+        (_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)
+        (double _d, int mode, int ndigits, int *decpt, int *sign, char **rve)
 #endif
 {
  /*     Arguments ndigits, decpt, sign are similar to those
@@ -1933,11 +1959,13 @@ __dtoa
         ULong x;
 #endif
         Bigint *b, *b1, *delta, *mlo, *mhi, *S;
-        double d2, ds, eps;
+        double ds;
         char *s, *s0;
         static Bigint *result;
         static int result_k;
+        _double d, d2, eps;
 
+        value(d) = _d;
         if (result) {
                 result->k = result_k;
                 result->maxwds = 1 << result_k;
@@ -1964,7 +1992,7 @@ __dtoa
                 *decpt = 9999;
                 s =
 #ifdef IEEE_Arith
-                        !word1(d) && !(word0(d) & 0xfffff) ? "Infinity" :
+                        !word1(d) && !(word0(d) & 0xfffff) ? ndigits < 8 ? "Inf" : "Infinity" :
 #endif
                                 "NaN";
                 if (rve)
@@ -1977,9 +2005,9 @@ __dtoa
                 }
 #endif
 #ifdef IBM
-        d += 0; /* normalize */
+        value(d) += 0; /* normalize */
 #endif
-        if (!d) {
+        if (!value(d)) {
                 *decpt = 1;
                 s = "0";
                 if (rve)
@@ -1987,18 +2015,18 @@ __dtoa
                 return s;
                 }
 
-        b = d2b(d, &be, &bbits);
+        b = d2b(value(d), &be, &bbits);
 #ifdef Sudden_Underflow
         i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
 #else
         if (i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) {
 #endif
-                d2 = d;
+                value(d2) = value(d);
                 word0(d2) &= Frac_mask1;
                 word0(d2) |= Exp_11;
 #ifdef IBM
                 if (j = 11 - hi0bits(word0(d2) & Frac_mask))
-                        d2 /= 1 << j;
+                        value(d2) /= 1 << j;
 #endif
 
                 /* log(x)       ~=~ log(1.5) + (x-1.5)/1.5
@@ -2037,19 +2065,20 @@ __dtoa
                 i = bbits + be + (Bias + (P-1) - 1);
                 x = i > 32  ? word0(d) << 64 - i | word1(d) >> i - 32
                             : word1(d) << 32 - i;
-                d2 = x;
+                value(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;
+        ds = (value(d2)-1.5)*0.289529654602168 + 0.1760912590558 +
+            i*0.301029995663981;
         k = (int)ds;
         if (ds < 0. && ds != k)
                 k--;    /* want k = floor(ds) */
         k_check = 1;
         if (k >= 0 && k <= Ten_pmax) {
-                if (d < tens[k])
+                if (value(d) < tens[k])
                         k--;
                 k_check = 0;
                 }
@@ -2116,7 +2145,7 @@ __dtoa
                 /* Try to get by with floating-point arithmetic. */
 
                 i = 0;
-                d2 = d;
+                value(d2) = value(d);
                 k0 = k;
                 ilim0 = ilim;
                 ieps = 2; /* conservative */
@@ -2126,7 +2155,7 @@ __dtoa
                         if (j & Bletch) {
                                 /* prevent overflows */
                                 j &= Bletch - 1;
-                                d /= bigtens[n_bigtens-1];
+                                value(d) /= bigtens[n_bigtens-1];
                                 ieps++;
                                 }
                         for(; j; j >>= 1, i++)
@@ -2134,32 +2163,32 @@ __dtoa
                                         ieps++;
                                         ds *= bigtens[i];
                                         }
-                        d /= ds;
+                        value(d) /= ds;
                         }
                 else if (j1 = -k) {
-                        d *= tens[j1 & 0xf];
+                        value(d) *= tens[j1 & 0xf];
                         for(j = j1 >> 4; j; j >>= 1, i++)
                                 if (j & 1) {
                                         ieps++;
-                                        d *= bigtens[i];
+                                        value(d) *= bigtens[i];
                                         }
                         }
-                if (k_check && d < 1. && ilim > 0) {
+                if (k_check && value(d) < 1. && ilim > 0) {
                         if (ilim1 <= 0)
                                 goto fast_failed;
                         ilim = ilim1;
                         k--;
-                        d *= 10.;
+                        value(d) *= 10.;
                         ieps++;
                         }
-                eps = ieps*d + 7.;
+                value(eps) = ieps*value(d) + 7.;
                 word0(eps) -= (P-1)*Exp_msk1;
                 if (ilim == 0) {
                         S = mhi = 0;
-                        d -= 5.;
-                        if (d > eps)
+                        value(d) -= 5.;
+                        if (value(d) > value(eps))
                                 goto one_digit;
-                        if (d < -eps)
+                        if (value(d) < -value(eps))
                                 goto no_digits;
                         goto fast_failed;
                         }
@@ -2168,33 +2197,33 @@ __dtoa
                         /* Use Steele & White method of only
                          * generating digits needed.
                          */
-                        eps = 0.5/tens[ilim-1] - eps;
+                        value(eps) = 0.5/tens[ilim-1] - value(eps);
                         for(i = 0;;) {
-                                L = d;
-                                d -= L;
+                                L = value(d);
+                                value(d) -= L;
                                 *s++ = '0' + (int)L;
-                                if (d < eps)
+                                if (value(d) < value(eps))
                                         goto ret1;
-                                if (1. - d < eps)
+                                if (1. - value(d) < value(eps))
                                         goto bump_up;
                                 if (++i >= ilim)
                                         break;
-                                eps *= 10.;
-                                d *= 10.;
+                                value(eps) *= 10.;
+                                value(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;
+                        value(eps) *= tens[ilim-1];
+                        for(i = 1;; i++, value(d) *= 10.) {
+                                L = value(d);
+                                value(d) -= L;
                                 *s++ = '0' + (int)L;
                                 if (i == ilim) {
-                                        if (d > 0.5 + eps)
+                                        if (value(d) > 0.5 + value(eps))
                                                 goto bump_up;
-                                        else if (d < 0.5 - eps) {
+                                        else if (value(d) < 0.5 - value(eps)) {
                                                 while(*--s == '0');
                                                 s++;
                                                 goto ret1;
@@ -2207,7 +2236,7 @@ __dtoa
 #endif
  fast_failed:
                 s = s0;
-                d = d2;
+                value(d) = value(d2);
                 k = k0;
                 ilim = ilim0;
                 }
@@ -2219,24 +2248,24 @@ __dtoa
                 ds = tens[k];
                 if (ndigits < 0 && ilim <= 0) {
                         S = mhi = 0;
-                        if (ilim < 0 || d <= 5*ds)
+                        if (ilim < 0 || value(d) <= 5*ds)
                                 goto no_digits;
                         goto one_digit;
                         }
                 for(i = 1;; i++) {
-                        L = d / ds;
-                        d -= L*ds;
+                        L = value(d) / ds;
+                        value(d) -= L*ds;
 #ifdef Check_FLT_ROUNDS
                         /* If FLT_ROUNDS == 2, L will usually be high by 1 */
-                        if (d < 0) {
+                        if (value(d) < 0) {
                                 L--;
-                                d += ds;
+                                value(d) += ds;
                                 }
 #endif
                         *s++ = '0' + (int)L;
                         if (i == ilim) {
-                                d += d;
-                                if (d > ds || d == ds && L & 1) {
+                                value(d) += value(d);
+                                if (value(d) > ds || value(d) == ds && L & 1) {
  bump_up:
                                         while(*--s == '9')
                                                 if (s == s0) {
@@ -2248,7 +2277,7 @@ __dtoa
                                         }
                                 break;
                                 }
-                        if (!(d *= 10.))
+                        if (!(value(d) *= 10.))
                                 break;
                         }
                 goto ret1;
diff --git a/src/lib/libc/stdlib/strtol.3 b/src/lib/libc/stdlib/strtol.3
index 808ba90165..b37f2cd725 100644
--- a/src/lib/libc/stdlib/strtol.3
+++ b/src/lib/libc/stdlib/strtol.3
@@ -33,49 +33,57 @@
 .\" 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.12 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd June 25, 1992
 .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 strtoq
+.Nd "convert string value to a long or long long integer"
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
 .Fd #include <limits.h>
 .Ft long
-.Fn strtol "char *nptr" "char **endptr" "int base"
-
+.Fn strtol "const char *nptr" "char **endptr" "int base"
+.Pp
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft long long
+.Fn strtoll "const char *nptr" "char **endptr" "int base"
+.Pp
 .Fd #include <sys/types.h>
 .Fd #include <stdlib.h>
 .Fd #include <limits.h>
 .Ft quad_t
-.Fn strtoq "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 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 +93,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 a
-.Em long
+.Li long
 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 +116,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 .
@@ -133,8 +138,7 @@ on return, the entire string was valid.)
 .Sh RETURN VALUES
 The
 .Fn strtol
-function
-returns the result of the conversion,
+function returns the result of the conversion,
 unless the value would underflow or overflow.
 If an underflow occurs,
 .Fn strtol
@@ -148,6 +152,76 @@ In both cases,
 .Va errno
 is set to
 .Er ERANGE .
+.Pp
+The
+.Fn strtoll
+function has identical return values except that
+.Dv LLONG_MIN
+and
+.Dv LLONG_MAX
+are used to indicate underflow and overflow respectively.
+.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 +231,21 @@ 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 strtoul 3
 .Sh STANDARDS
 The
 .Fn strtol
-function
-conforms to
-.St -ansiC .
+and
+.Fn strtoll
+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..e4ad557fd5 100644
--- a/src/lib/libc/stdlib/strtol.c
+++ b/src/lib/libc/stdlib/strtol.c
@@ -32,13 +32,12 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strtol.c,v 1.4 1996/08/19 08:33:51 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
-#include <limits.h>
 #include <ctype.h>
 #include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 
@@ -54,25 +53,28 @@ strtol(nptr, endptr, base)
         char **endptr;
         register int base;
 {
-        register const char *s = nptr;
-        register unsigned long acc;
+        register const char *s;
+        register long acc, cutoff;
         register int c;
-        register unsigned long cutoff;
-        register int neg = 0, any, cutlim;
+        register 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 +101,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 +120,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..b0eb6d198c 100644
--- a/src/lib/libc/stdlib/strtoq.c
+++ b/src/lib/libc/stdlib/strtoll.c
@@ -32,33 +32,32 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strtoq.c    5.1 (Berkeley) 6/26/92";
+static const char rcsid[] = "$OpenBSD: strtoll.c,v 1.1 2002/06/29 00:20:11 millert Exp $";
 #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)
+long long
+strtoll(nptr, endptr, base)
         const char *nptr;
         char **endptr;
-        register int base;
+        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 +66,7 @@ strtoq(nptr, endptr, base)
          */
         s = nptr;
         do {
-                c = *s++;
+                c = (unsigned char) *s++;
         } while (isspace(c));
         if (c == '-') {
                 neg = 1;
@@ -93,7 +92,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 +103,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 +122,45 @@ 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(nptr, endptr, base)
+        const char *nptr;
+        char **endptr;
+        int base;
+{
+
+        return ((quad_t)strtoll(nptr, endptr, base);
+}
+#endif
diff --git a/src/lib/libc/stdlib/strtoul.3 b/src/lib/libc/stdlib/strtoul.3
index db551b0141..39de7e0656 100644
--- a/src/lib/libc/stdlib/strtoul.3
+++ b/src/lib/libc/stdlib/strtoul.3
@@ -33,21 +33,27 @@
 .\" 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.14 2003/05/10 06:48:30 jmc Exp $
 .\"
 .Dd June 25, 1992
 .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 strtouq
+.Nd "convert a string to an unsigned long or unsigned long long integer"
 .Sh SYNOPSIS
 .Fd #include <stdlib.h>
 .Fd #include <limits.h>
 .Ft unsigned long
 .Fn strtoul "const char *nptr" "char **endptr" "int base"
-
+.Pp
+.Fd #include <stdlib.h>
+.Fd #include <limits.h>
+.Ft unsigned long long
+.Fn strtoull "const char *nptr" "char **endptr" "int base"
+.Pp
 .Fd #include <sys/types.h>
 .Fd #include <stdlib.h>
 .Fd #include <limits.h>
@@ -56,26 +62,34 @@
 .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 a
-.Em u_quad_t
+to an
+.Li unsigned long long
 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 +99,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 +122,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 .
@@ -134,12 +144,18 @@ 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,
-the negation of the result of the conversion,
-unless the original (non-negated) value would overflow;
-in the latter case,
+function returns the result of the conversion,
+unless the value would overflow, in which case
+.Dv ULONG_MAX
+is returned and
+.Va errno
+is set to
+.Er ERANGE .
+If there was a leading minus sign,
+.Fn strtoul
+returns the (unsigned) negation of the absolute value of the number, unless
+the absolute value would overflow.
+In this case,
 .Fn strtoul
 returns
 .Dv ULONG_MAX
@@ -147,18 +163,73 @@ and sets the global variable
 .Va errno
 to
 .Er ERANGE .
+.Pp
+The
+.Fn strtoull
+function has identical return values except that
+.Dv ULLONG_MAX
+is used to indicate overflow.
+.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 .
+and
+.Fn strtoull
+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..d3b363fa04 100644
--- a/src/lib/libc/stdlib/strtoul.c
+++ b/src/lib/libc/stdlib/strtoul.c
@@ -32,13 +32,12 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strtoul.c,v 1.4 1996/08/19 08:33:52 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
-#include <limits.h>
 #include <ctype.h>
 #include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 
 /*
@@ -53,23 +52,26 @@ strtoul(nptr, endptr, base)
         char **endptr;
         register int base;
 {
-        register const char *s = nptr;
-        register unsigned long acc;
+        register const char *s;
+        register unsigned long acc, cutoff;
         register int c;
-        register unsigned long cutoff;
-        register int neg = 0, any, cutlim;
+        register 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 +80,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 +92,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..7b4dd56c01 100644
--- a/src/lib/libc/stdlib/strtouq.c
+++ b/src/lib/libc/stdlib/strtoull.c
@@ -32,40 +32,39 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strtouq.c   5.1 (Berkeley) 6/26/92";
+static const char rcsid[] = "$OpenBSD: strtoull.c,v 1.1 2002/06/29 00:20:11 millert Exp $";
 #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)
+unsigned long long
+strtoull(nptr, endptr, base)
         const char *nptr;
         char **endptr;
-        register int base;
+        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 +82,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 +94,35 @@ 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(nptr, endptr, base)
+        const char *nptr;
+        char **endptr;
+        int base;
+{
+
+        return ((u_quad_t)strtoull(nptr, endptr, base);
+}
+#endif
diff --git a/src/lib/libc/stdlib/system.3 b/src/lib/libc/stdlib/system.3
index 520f51db0a..83c6de80e3 100644
--- a/src/lib/libc/stdlib/system.3
+++ b/src/lib/libc/stdlib/system.3
@@ -33,8 +33,7 @@
 .\" 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.8 2000/10/06 04:17:51 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt SYSTEM 3
@@ -49,8 +48,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 +62,42 @@ 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 .
+.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..636a9ebdff 100644
--- a/src/lib/libc/stdlib/system.c
+++ b/src/lib/libc/stdlib/system.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: system.c,v 1.5 2002/05/26 09:29:02 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -51,20 +50,24 @@ system(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 +75,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..5c3b8c17f5
--- /dev/null
+++ b/src/lib/libc/stdlib/tfind.c
@@ -0,0 +1,41 @@
+/*
+ * 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(vkey, vrootp, compar)
+        const void      *vkey;          /* key to be found */
+        void            *const *vrootp; /* address of the tree root */
+        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..b000a0a8b1
--- /dev/null
+++ b/src/lib/libc/stdlib/tsearch.3
@@ -0,0 +1,127 @@
+.\" Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+.\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+.\" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+.\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+.\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+.\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+.\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+.\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\"     $OpenBSD: tsearch.3,v 1.9 2000/08/09 15:51:21 aaron Exp $
+.\"
+.Dd June 15, 1997
+.Dt TSEARCH 3
+.Os
+.Sh NAME
+.Nm tsearch ,
+.Nm tfind ,
+.Nm tdelete ,
+.Nm twalk
+.Nd manipulate binary search trees
+.Sh SYNOPSIS
+.Fd #include <search.h>
+.Ft void *
+.Fn tdelete "const void *key" "void **rootp" "int (*compar) (const void *, const void *)"
+.Ft void *
+.Fn tfind "const void *key" "void * const *rootp" "int (*compar) (const void *, const void *)"
+.Ft void *
+.Fn tsearch "const void *key" "void **rootp" "int (*compar) (const void *, const void *)"
+.Ft void
+.Fn twalk "const void *root" "void (*action) (const void *, VISIT, int)"
+.Sh DESCRIPTION
+The
+.Fn tdelete ,
+.Fn tfind ,
+.Fn tsearch ,
+and
+.Fn twalk
+functions manage binary search trees based on algorithms T and D
+from Knuth (6.2.2).
+The comparison function passed in by
+the user has the same style of return values as
+.Xr strcmp 3 .
+.Pp
+.Fn tfind
+searches for the datum matched by the argument
+.Fa key
+in the binary tree rooted at
+.Fa rootp ,
+returning a pointer to the datum if it is found and
+.Dv NULL
+if it is not.
+.Pp
+.Fn tsearch
+is identical to
+.Fn tfind
+except that if no match is found,
+.Fa key
+is inserted into the tree and a pointer to it is returned.
+If
+.Fa rootp
+points to a null value a new binary search tree is created.
+.Pp
+.Fn tdelete
+deletes a node from the specified binary search tree and returns
+a pointer to the parent of the node to be deleted.
+It takes the same arguments as
+.Fn tfind
+and
+.Fn tsearch .
+If the node to be deleted is the root of the binary search tree,
+.Fa rootp
+will be adjusted.
+.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 SEE ALSO
+.Xr bsearch 3 ,
+.Xr lsearch 3
+.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.
diff --git a/src/lib/libc/stdlib/tsearch.c b/src/lib/libc/stdlib/tsearch.c
new file mode 100644
index 0000000000..0ad5866172
--- /dev/null
+++ b/src/lib/libc/stdlib/tsearch.c
@@ -0,0 +1,126 @@
+/*
+ * 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(vkey, vrootp, compar)
+        const void      *vkey;          /* key to be located */
+        void            **vrootp;       /* address of tree root */
+        int             (*compar)(const void *, const void *);
+{
+    register 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(vkey, vrootp, compar)
+        const void      *vkey;          /* key to be deleted */
+        void            **vrootp;       /* address of the root of tree */
+        int             (*compar)(const void *, const void *);
+{
+    node **rootp = (node **)vrootp;
+    char *key = (char *)vkey;
+    node *p;
+    register node *q;
+    register 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;
+        }
+    }
+    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(root, action, level)
+        register node   *root;          /* Root of the tree to be walked */
+        register void   (*action)();    /* Function to be called at each node */
+        register 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(vroot, action)
+        const void      *vroot;         /* Root of the tree to be walked */
+        void            (*action)(const void *, VISIT, int);
+{
+    node *root = (node *)vroot;
+
+    if (root != (node *)0 && action != (void(*)())0)
+        trecurse(root, action, 0);
+}
diff --git a/src/lib/libc/string/Makefile.inc b/src/lib/libc/string/Makefile.inc
index 2b7ce63a63..26e2bc10f2 100644
--- a/src/lib/libc/string/Makefile.inc
+++ b/src/lib/libc/string/Makefile.inc
@@ -1,23 +1,22 @@
-#       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.12 2003/02/20 03:20:09 deraadt Exp $
 
 # string sources
-.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/string ${.CURDIR}/string
+.PATH: ${LIBCSRCDIR}/arch/${MACHINE_ARCH}/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_r.c strlcat.c strmode.c strsignal.c strtok.c strxfrm.c \
         __strerror.c __strsignal.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_ARCH}/string/Makefile.inc"
 
 # if no machine specific memmove(3), build one out of bcopy(3).
 .if empty(SRCS:Mmemmove.S)
@@ -27,6 +26,11 @@ memmove.o: bcopy.c
         @${LD} -x -r ${.TARGET}
         @mv a.out ${.TARGET}
 
+memmove.go: bcopy.c
+        ${CC} -g -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
 memmove.po: bcopy.c
         ${CC} -DMEMMOVE ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
         @${LD} -X -r ${.TARGET}
@@ -48,6 +52,11 @@ memcpy.o: bcopy.c
         @${LD} -x -r ${.TARGET}
         @mv a.out ${.TARGET}
 
+memcpy.go: bcopy.c
+        ${CC} -g -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
 memcpy.po: bcopy.c
         ${CC} -DMEMCOPY ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
         @${LD} -X -r ${.TARGET}
@@ -67,6 +76,11 @@ strchr.o: index.c
         @${LD} -x -r ${.TARGET}
         @mv a.out ${.TARGET}
 
+strchr.go: index.c
+        ${CC} -g -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
 strchr.po: index.c
         ${CC} -DSTRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
         @${LD} -X -r ${.TARGET}
@@ -85,6 +99,11 @@ strrchr.o: rindex.c
         @${LD} -x -r ${.TARGET}
         @mv a.out ${.TARGET}
 
+strrchr.go: rindex.c
+        ${CC} -g -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c ${.ALLSRC} -o ${.TARGET}
+        @${LD} -x -r ${.TARGET}
+        @mv a.out ${.TARGET}
+
 strrchr.po: rindex.c
         ${CC} -DSTRRCHR ${CFLAGS} ${CPPFLAGS} -c -p ${.ALLSRC} -o ${.TARGET}
         @${LD} -X -r ${.TARGET}
@@ -95,14 +114,39 @@ strrchr.so: rindex.c
             -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
 
 MLINKS+=bm.3 bm_comp.3 bm.3 bm_exec.3 bm.3 bm_free.3
+MLINKS+=strchr.3 index.3
+MLINKS+=strrchr.3 rindex.3
 MLINKS+=strcasecmp.3 strncasecmp.3
 MLINKS+=strcat.3 strncat.3
 MLINKS+=strcmp.3 strncmp.3
 MLINKS+=strcpy.3 strncpy.3
+MLINKS+=strlcpy.3 strlcat.3
+MLINKS+=strtok.3 strtok_r.3
+MLINKS+=strerror.3 strerror_r.3
diff --git a/src/lib/libc/string/__strerror.c b/src/lib/libc/string/__strerror.c
index cd604906db..7301a7bc84 100644
--- a/src/lib/libc/string/__strerror.c
+++ b/src/lib/libc/string/__strerror.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: __strerror.c,v 1.9 2003/03/13 15:47:33 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #ifdef NLS
@@ -46,9 +45,27 @@ static char *rcsid = "$Id: __strerror.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt Ex
 #define sys_errlist     _sys_errlist
 #define sys_nerr        _sys_nerr
 
+#include <errno.h>
+#include <limits.h>
 #include <stdio.h>
 #include <string.h>
 
+static char *
+itoa(num)
+        int num;
+{
+        static char buffer[11];
+        char *p;
+
+        p = buffer + 4;
+        while (num >= 10) {
+                *--p = (num % 10) + '0';
+                num /= 10;
+        }
+        *p = (num % 10) + '0';
+        return p;
+}
+
 /*
  * Since perror() is not allowed to change the contents of strerror()'s
  * static buffer, both functions supply their own buffers to the
@@ -60,32 +77,37 @@ __strerror(num, buf)
         int num;
         char *buf;
 {
-#define UPREFIX "Unknown error: %u"
+#define UPREFIX "Unknown error: "
         register unsigned int errnum;
-
 #ifdef NLS
-        nl_catd catd ;
+        int save_errno;
+        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])); 
+                strlcpy(buf, catgets(catd, 1, errnum,
+                    (char *)sys_errlist[errnum]), NL_TEXTMAX);
 #else
                 return(sys_errlist[errnum]);
 #endif
         } else {
 #ifdef NLS
-                sprintf(buf, catgets(catd, 1, 0xffff, UPREFIX), errnum);
+                strlcpy(buf, catgets(catd, 1, 0xffff, UPREFIX), NL_TEXTMAX);
 #else
-                sprintf(buf, UPREFIX, errnum);
+                strlcpy(buf, UPREFIX, NL_TEXTMAX);
 #endif
+                strlcat(buf, itoa(errnum), NL_TEXTMAX);
+                errno = EINVAL;
         }
 
 #ifdef NLS
+        save_errno = errno;
         catclose(catd);
+        errno = save_errno;
 #endif
 
         return buf;
diff --git a/src/lib/libc/string/__strsignal.c b/src/lib/libc/string/__strsignal.c
index 1937e2d608..2616872232 100644
--- a/src/lib/libc/string/__strsignal.c
+++ b/src/lib/libc/string/__strsignal.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: __strsignal.c,v 1.7 2003/03/13 15:47:33 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #ifdef NLS
@@ -46,15 +45,31 @@ static char *rcsid = "$Id: __strsignal.c,v 1.1.1.1 1995/10/18 08:42:20 deraadt E
 #define sys_siglist     _sys_siglist
 
 #include <stdio.h>
+#include <limits.h>
 #include <signal.h>
 #include <string.h>
 
+static char *itoa(num)
+        int num;
+{
+        static char buffer[11];
+        char *p;
+
+        p = buffer + 4;
+        while (num >= 10) {
+                *--p = (num % 10) + '0';
+                num /= 10;
+        }
+        *p = (num % 10) + '0';
+        return p;
+}
+
 char *
 __strsignal(num, buf)
         int num;
         char *buf;
 {
-#define UPREFIX "Unknown signal: %u"
+#define UPREFIX "Unknown signal: "
         register unsigned int signum;
 
 #ifdef NLS
@@ -65,17 +80,18 @@ __strsignal(num, buf)
         signum = num;                           /* convert to unsigned */
         if (signum < NSIG) {
 #ifdef NLS
-                strcpy(buf, catgets(catd, 2, signum,
-                    (char *)sys_siglist[signum])); 
+                strlcpy(buf, catgets(catd, 2, signum,
+                    (char *)sys_siglist[signum]), NL_TEXTMAX);
 #else
                 return((char *)sys_siglist[signum]);
 #endif
         } else {
 #ifdef NLS
-                sprintf(buf, catgets(catd, 1, 0xffff, UPREFIX), signum);
+                strlcpy(buf, catgets(catd, 1, 0xffff, UPREFIX), NL_TEXTMAX);
 #else
-                sprintf(buf, UPREFIX, signum);
+                strlcpy(buf, UPREFIX, NL_TEXTMAX);
 #endif
+                strlcat(buf, itoa(signum), NL_TEXTMAX);
         }
 
 #ifdef NLS
diff --git a/src/lib/libc/string/bcmp.3 b/src/lib/libc/string/bcmp.3
index 118c55c579..d880c1e6f0 100644
--- a/src/lib/libc/string/bcmp.3
+++ b/src/lib/libc/string/bcmp.3
@@ -31,12 +31,11 @@
 .\" 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.5 2000/04/21 15:24:18 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt BCMP 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm bcmp
 .Nd compare byte string
@@ -47,8 +46,7 @@
 .Sh DESCRIPTION
 The
 .Fn bcmp
-function
-compares byte string
+function compares byte string
 .Fa b1
 against byte string
 .Fa b2 ,
@@ -68,5 +66,5 @@ The strings may overlap.
 .Sh HISTORY
 A
 .Fn bcmp
-function first appeared in 
+function first appeared in
 .Bx 4.2 .
diff --git a/src/lib/libc/string/bcmp.c b/src/lib/libc/string/bcmp.c
index 2cc38baee3..4ed00975a4 100644
--- a/src/lib/libc/string/bcmp.c
+++ b/src/lib/libc/string/bcmp.c
@@ -32,15 +32,19 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: bcmp.c,v 1.4 1996/08/19 08:33:57 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * bcmp -- vax cmpc3 instruction
  */
+int
 bcmp(b1, b2, length)
         const void *b1, *b2;
         register size_t length;
diff --git a/src/lib/libc/string/bcopy.3 b/src/lib/libc/string/bcopy.3
index 6db3812caf..12bd248abf 100644
--- a/src/lib/libc/string/bcopy.3
+++ b/src/lib/libc/string/bcopy.3
@@ -32,12 +32,11 @@
 .\" 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.6 2003/04/07 18:53:58 deraadt Exp $
 .\"
 .Dd April 19, 1991
 .Dt BCOPY 3
-.Os BSD 4.2
+.Os
 .Sh NAME
 .Nm bcopy
 .Nd copy byte string
@@ -48,8 +47,7 @@
 .Sh DESCRIPTION
 The
 .Fn bcopy
-function
-copies
+function copies
 .Fa len
 bytes from string
 .Fa src
@@ -64,9 +62,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
 .Fn bcopy
-function appeared in 
+function appeared in
 .Bx 4.2 .
diff --git a/src/lib/libc/string/bcopy.c b/src/lib/libc/string/bcopy.c
index 92feed66ea..023a3b2db2 100644
--- a/src/lib/libc/string/bcopy.c
+++ b/src/lib/libc/string/bcopy.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: bcopy.c,v 1.2 1996/08/19 08:33:58 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/bm.3 b/src/lib/libc/string/bm.3
index 2264a6a1c4..7138ee4271 100644
--- a/src/lib/libc/string/bm.3
+++ b/src/lib/libc/string/bm.3
@@ -32,83 +32,84 @@
 .\" 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.6 2001/06/23 14:42:12 deraadt 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 June 29, 1999
+.Dt BM 3
+.Os
+.Sh NAME
+.Nm bm_comp ,
+.Nm bm_exec ,
+.Nm bm_free
+.Nd Boyer-Moore string search
+.Sh SYNOPSIS
+.Fd #include <sys/types.h>
+.Fd #include <bm.h>
+.Ft bm_pat *
+.Fn bm_comp "u_char *pattern" "size_t patlen" "u_char freq[256]"
+.Ft u_char *
+.Fn bm_exec "bm_pat *pdesc" "u_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
diff --git a/src/lib/libc/string/bm.c b/src/lib/libc/string/bm.c
index 68eac22ecc..b191d340f6 100644
--- a/src/lib/libc/string/bm.c
+++ b/src/lib/libc/string/bm.c
@@ -34,10 +34,9 @@
  * 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 */
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: bm.c,v 1.3 1996/08/19 08:33:59 tholo Exp $";
+#endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 
diff --git a/src/lib/libc/string/bstring.3 b/src/lib/libc/string/bstring.3
index 12fcfb0cc1..85283321c8 100644
--- a/src/lib/libc/string/bstring.3
+++ b/src/lib/libc/string/bstring.3
@@ -31,8 +31,7 @@
 .\" 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.4 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt BSTRING 3
@@ -45,7 +44,7 @@
 .Nm memchr ,
 .Nm memcmp ,
 .Nm memcpy ,
-.Nm memmove,
+.Nm memmove ,
 .Nm memset
 .Nd byte string operations
 .Sh SYNOPSIS
@@ -97,14 +96,15 @@ and
 conform to
 .St -ansiC .
 .Sh HISTORY
-The functions
+The
 .Fn bzero
 and
 .Fn memccpy
-appeared in
-.Bx 4.3 ;
-the functions
-.Fn bcmp ,
-.Fn bcopy ,
-appeared in
+functions appeared in
+.Bx 4.3 .
+The
+.Fn bcmp
+and
+.Fn bcopy
+functions appeared in
 .Bx 4.2 .
diff --git a/src/lib/libc/string/bzero.3 b/src/lib/libc/string/bzero.3
index 4f0141e051..a735d5ef3f 100644
--- a/src/lib/libc/string/bzero.3
+++ b/src/lib/libc/string/bzero.3
@@ -31,12 +31,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.5 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt BZERO 3
-.Os BSD 4.3
+.Os
 .Sh NAME
 .Nm bzero
 .Nd write zeroes to a byte string
@@ -47,8 +46,7 @@
 .Sh DESCRIPTION
 The
 .Fn bzero
-function
-writes
+function writes
 .Fa len
 zero bytes to the string
 .Fa b .
@@ -63,6 +61,5 @@ does nothing.
 .Sh HISTORY
 A
 .Fn bzero
-function
-appeared in 
+function appeared in
 .Bx 4.3 .
diff --git a/src/lib/libc/string/bzero.c b/src/lib/libc/string/bzero.c
index 4865e396ef..3e660a307f 100644
--- a/src/lib/libc/string/bzero.c
+++ b/src/lib/libc/string/bzero.c
@@ -32,11 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: bzero.c,v 1.3 1996/08/19 08:34:00 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * bzero -- vax movc5 instruction
diff --git a/src/lib/libc/string/ffs.3 b/src/lib/libc/string/ffs.3
index 6464bea2b1..dc7a20741e 100644
--- a/src/lib/libc/string/ffs.3
+++ b/src/lib/libc/string/ffs.3
@@ -31,8 +31,7 @@
 .\" 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.3 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt FFS 3
@@ -47,12 +46,10 @@
 .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
diff --git a/src/lib/libc/string/ffs.c b/src/lib/libc/string/ffs.c
index 42bc87ddea..887ce437d4 100644
--- a/src/lib/libc/string/ffs.c
+++ b/src/lib/libc/string/ffs.c
@@ -1,42 +1,19 @@
-/*-
- * 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.5 2000/07/02 03:10:38 mickey Exp $  */
+
+/*
+ * Public domain.
+ * Written by Dale Rahn.
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: ffs.c,v 1.5 2000/07/02 03:10:38 mickey Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * ffs -- vax ffs instruction
@@ -46,10 +23,27 @@ ffs(mask)
         register int mask;
 {
         register int bit;
+        register 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..8e4b146493 100644
--- a/src/lib/libc/string/index.c
+++ b/src/lib/libc/string/index.c
@@ -32,19 +32,17 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: index.c,v 1.3 2002/07/24 04:16:01 millert 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..007fa44274 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.7 2003/04/07 18:53:58 deraadt 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
@@ -29,14 +31,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 June 9, 1993
 .Dt MEMCCPY 3
 .Os
 .Sh NAME
 .Nm memccpy
+.Nd copy string until character found
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft void *
@@ -44,14 +46,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 +63,15 @@ 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
+.Bx 4.4 .
diff --git a/src/lib/libc/string/memccpy.c b/src/lib/libc/string/memccpy.c
index 3a1d7bcca1..020e6e5679 100644
--- a/src/lib/libc/string/memccpy.c
+++ b/src/lib/libc/string/memccpy.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: memccpy.c,v 1.3 1997/08/20 04:09:39 millert 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
@@ -32,8 +34,11 @@
  */
 
 #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 $";
+#if 0
+static char sccsid[] = "@(#)memccpy.c   8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: memccpy.c,v 1.3 1997/08/20 04:09:39 millert Exp $";
+#endif
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/memchr.3 b/src/lib/libc/string/memchr.3
index 265711e3b5..632c440b5b 100644
--- a/src/lib/libc/string/memchr.3
+++ b/src/lib/libc/string/memchr.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: memchr.3,v 1.5 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt MEMCHR 3
@@ -49,23 +48,21 @@
 .Sh DESCRIPTION
 The
 .Fn memchr
-function
-locates the first occurrence of
+function locates the first occurrence of
 .Fa c
-(converted to an unsigned char)
+(converted to an
+.Li unsigned char )
 in string
 .Fa b .
 .Sh RETURN VALUES
 The
 .Fn memchr
-function
-returns a pointer to the byte located,
-or NULL if no such byte exists within
+function returns 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 ,
@@ -77,6 +74,5 @@ bytes.
 .Sh STANDARDS
 The
 .Fn memchr
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/memchr.c b/src/lib/libc/string/memchr.c
index 61652c6bb1..d605d4734f 100644
--- a/src/lib/libc/string/memchr.c
+++ b/src/lib/libc/string/memchr.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: memchr.c,v 1.4 2001/09/07 08:09:31 espie Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
@@ -44,14 +43,14 @@ static char *rcsid = "$Id: memchr.c,v 1.1.1.1 1995/10/18 08:42:21 deraadt Exp $"
 void *
 memchr(s, c, n)
         const void *s;
-        register unsigned char c;
-        register size_t n;
+        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..db4fef364b 100644
--- a/src/lib/libc/string/memcmp.3
+++ b/src/lib/libc/string/memcmp.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: memcmp.3,v 1.4 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt MEMCMP 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn memcmp
-function
-compares byte string
+function compares byte string
 .Fa b1
 against byte string
 .Fa b2 .
@@ -60,10 +58,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 ,
@@ -78,6 +77,5 @@ Zero-length strings are always identical.
 .Sh STANDARDS
 The
 .Fn memcmp
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/memcmp.c b/src/lib/libc/string/memcmp.c
index 23d2ab2393..5ce33e2998 100644
--- a/src/lib/libc/string/memcmp.c
+++ b/src/lib/libc/string/memcmp.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: memcmp.c,v 1.2 1996/08/19 08:34:05 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/memcpy.3 b/src/lib/libc/string/memcpy.3
index 3f4bb643c9..46168a103b 100644
--- a/src/lib/libc/string/memcpy.3
+++ b/src/lib/libc/string/memcpy.3
@@ -33,8 +33,7 @@
 .\" 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 $
+.\"     $OpenBSD: memcpy.3,v 1.4 2003/04/07 18:53:58 deraadt Exp $
 .\"
 .Dd June 29, 1991
 .Dt MEMCPY 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn memcpy
-function
-copies
+function copies
 .Fa len
 bytes from string
 .Fa src
@@ -59,19 +57,18 @@ to string
 .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
 .Sh STANDARDS
 The
 .Fn memcpy
-function
-conforms to
+function conforms to
 .St -ansiC .
 .Sh BUGS
 In this implementation
diff --git a/src/lib/libc/string/memmove.3 b/src/lib/libc/string/memmove.3
index 24422e7971..41d42f78e0 100644
--- a/src/lib/libc/string/memmove.3
+++ b/src/lib/libc/string/memmove.3
@@ -33,8 +33,7 @@
 .\" 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 $
+.\"     $OpenBSD: memmove.3,v 1.4 2003/04/07 18:53:58 deraadt Exp $
 .\"
 .Dd June 29, 1991
 .Dt MEMMOVE 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn memmove
-function
-copies
+function copies
 .Fa len
 bytes from string
 .Fa src
@@ -67,10 +65,10 @@ function returns the original value of
 .Xr bcopy 3 ,
 .Xr memccpy 3 ,
 .Xr memcpy 3 ,
-.Xr strcpy 3
+.Xr strcpy 3 ,
+.Xr strlcpy 3
 .Sh STANDARDS
 The
 .Fn memmove
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/memset.3 b/src/lib/libc/string/memset.3
index 1afc052182..9da14983c7 100644
--- a/src/lib/libc/string/memset.3
+++ b/src/lib/libc/string/memset.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: memset.3,v 1.4 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt MEMSET 3
@@ -49,12 +48,18 @@
 .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 ,
@@ -62,6 +67,5 @@ bytes of value
 .Sh STANDARDS
 The
 .Fn memset
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/memset.c b/src/lib/libc/string/memset.c
index 117de2e80b..c3373a21a9 100644
--- a/src/lib/libc/string/memset.c
+++ b/src/lib/libc/string/memset.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: memset.c,v 1.2 1996/08/19 08:34:07 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/rindex.3 b/src/lib/libc/string/rindex.3
deleted file mode 100644
index b13b3513e0..0000000000
--- a/src/lib/libc/string/rindex.3
+++ /dev/null
@@ -1,81 +0,0 @@
-.\" Copyright (c) 1990, 1991 The Regents of the University of California.
-.\" All rights reserved.
-.\"
-.\" This code is derived from software contributed to Berkeley by
-.\" Chris Torek.
-.\" Redistribution and use in source and binary forms, with or without
-.\" modification, are permitted provided that the following conditions
-.\" are met:
-.\" 1. Redistributions of source code must retain the above copyright
-.\"    notice, this list of conditions and the following disclaimer.
-.\" 2. Redistributions in binary form must reproduce the above copyright
-.\"    notice, this list of conditions and the following disclaimer in the
-.\"    documentation and/or other materials provided with the distribution.
-.\" 3. 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: @(#)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
-.Os
-.Sh NAME
-.Nm rindex
-.Nd locate character in string
-.Sh SYNOPSIS
-.Fd #include <string.h>
-.Ft char *
-.Fn rindex "const char *s" "int c"
-.Sh DESCRIPTION
-The
-.Fn rindex
-function
-locates the last character
-matching
-.Fa c
-(converted to a
-.Em char )
-in the null-terminated 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 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
-.Sh HISTORY
-A
-.Fn rindex
-function appeared in 
-.At v6 .
diff --git a/src/lib/libc/string/rindex.c b/src/lib/libc/string/rindex.c
index 1b84c92072..7c7c94ae81 100644
--- a/src/lib/libc/string/rindex.c
+++ b/src/lib/libc/string/rindex.c
@@ -32,19 +32,17 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: rindex.c,v 1.3 2002/07/24 04:16:01 millert 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;
 
diff --git a/src/lib/libc/string/strcasecmp.3 b/src/lib/libc/string/strcasecmp.3
index 46e9010e4f..cd9be07c61 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.7 2003/05/10 06:40:44 jmc 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.
@@ -31,14 +33,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 June 9, 1993
 .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 +53,12 @@ The
 .Fn strcasecmp
 and
 .Fn strncasecmp
-functions
-compare the null-terminated strings
+functions compare the null-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 +69,6 @@ The comparison is done using unsigned characters, so that
 is greater than
 .Ql \e0 .
 .Pp
-The
 .Fn strncasecmp
 compares at most
 .Fa len
@@ -84,5 +84,5 @@ The
 .Fn strcasecmp
 and
 .Fn strncasecmp
-functions are
-.Ud .
+functions first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strcasecmp.c b/src/lib/libc/string/strcasecmp.c
index 79bd0081e3..1f487524aa 100644
--- a/src/lib/libc/string/strcasecmp.c
+++ b/src/lib/libc/string/strcasecmp.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strcasecmp.c,v 1.3 1997/08/20 04:13:57 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
@@ -31,13 +33,16 @@
  * SUCH DAMAGE.
  */
 
+#include <string.h>
+
 #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 $";
+#if 0
+static char sccsid[] = "@(#)strcasecmp.c        8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: strcasecmp.c,v 1.3 1997/08/20 04:13:57 millert Exp $";
+#endif
 #endif /* LIBC_SCCS and not lint */
 
-#include <string.h>
-
 typedef unsigned char u_char;
 
 /*
diff --git a/src/lib/libc/string/strcat.3 b/src/lib/libc/string/strcat.3
index 5357d65754..e9e5163bd3 100644
--- a/src/lib/libc/string/strcat.3
+++ b/src/lib/libc/string/strcat.3
@@ -33,14 +33,14 @@
 .\" 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 $
+.\"     $OpenBSD: strcat.3,v 1.8 2000/04/21 15:24:19 aaron Exp $
 .\"
-.Dd June 29, 1991
+.Dd July 8, 1997
 .Dt STRCAT 3
 .Os
 .Sh NAME
-.Nm strcat
+.Nm strcat ,
+.Nm strncat
 .Nd concatenate strings
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -53,8 +53,7 @@ The
 .Fn strcat
 and
 .Fn strncat
-functions
-append a copy of the null-terminated string
+functions append a copy of the null-terminated string
 .Fa append
 to the end of the null-terminated string
 .Fa s ,
@@ -66,29 +65,71 @@ 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
+.Dq Li 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
+.Dq Li input
+to
+.Dq Li buf
+as will fit.
+It then appends as many characters from 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 strlcat 3 ,
+.Xr strlcpy 3
 .Sh STANDARDS
 The
 .Fn strcat
 and
 .Fn strncat
-functions
-conform to
+functions conform to
 .St -ansiC .
diff --git a/src/lib/libc/string/strcat.c b/src/lib/libc/string/strcat.c
index e741b84f03..374a2b7464 100644
--- a/src/lib/libc/string/strcat.c
+++ b/src/lib/libc/string/strcat.c
@@ -32,11 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strcat.c,v 1.4 1996/08/19 08:34:10 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 char *
 strcat(s, append)
@@ -46,6 +49,6 @@ strcat(s, 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..1333a305d6 100644
--- a/src/lib/libc/string/strchr.3
+++ b/src/lib/libc/string/strchr.3
@@ -33,29 +33,29 @@
 .\" 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 $
+.\"     $OpenBSD: strchr.3,v 1.7 2000/04/21 15:24:19 aaron Exp $
 .\"
 .Dd June 29, 1991
 .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,16 +63,31 @@ 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 ,
@@ -83,6 +98,9 @@ if the character does not appear in the string.
 .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.
diff --git a/src/lib/libc/string/strcmp.3 b/src/lib/libc/string/strcmp.3
index fecaa85410..0482604eae 100644
--- a/src/lib/libc/string/strcmp.3
+++ b/src/lib/libc/string/strcmp.3
@@ -33,14 +33,14 @@
 .\" 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 $
+.\"     $OpenBSD: strcmp.3,v 1.6 2003/05/10 06:40:44 jmc Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRCMP 3
 .Os
 .Sh NAME
-.Nm strcmp
+.Nm strcmp ,
+.Nm strncmp
 .Nd compare strings
 .Sh SYNOPSIS
 .Fd #include <string.h>
@@ -53,8 +53,7 @@ The
 .Fn strcmp
 and
 .Fn strncmp
-functions
-lexicographically compare the null-terminated strings
+functions lexicographically compare the null-terminated strings
 .Fa s1
 and
 .Fa s2 .
@@ -64,7 +63,7 @@ The
 and
 .Fn strncmp
 return an integer greater than, equal to, or less than 0, according
-as the string
+to whether the string
 .Fa s1
 is greater than, equal to, or less than the string
 .Fa s2 .
@@ -73,9 +72,8 @@ The comparison is done using unsigned characters, so that
 is greater than
 .Ql \e0 .
 .Pp
-The
 .Fn strncmp
-compares not more than
+compares at most
 .Fa len
 characters.
 .Sh SEE ALSO
@@ -89,6 +87,5 @@ The
 .Fn strcmp
 and
 .Fn strncmp
-functions
-conform to
+functions conform to
 .St -ansiC .
diff --git a/src/lib/libc/string/strcmp.c b/src/lib/libc/string/strcmp.c
index ae19e2e26e..9a5b208323 100644
--- a/src/lib/libc/string/strcmp.c
+++ b/src/lib/libc/string/strcmp.c
@@ -35,11 +35,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strcmp.c,v 1.3 1996/08/19 08:34:12 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 /*
  * Compare strings.
diff --git a/src/lib/libc/string/strcoll.3 b/src/lib/libc/string/strcoll.3
index 12f73f98f2..62086c79ac 100644
--- a/src/lib/libc/string/strcoll.3
+++ b/src/lib/libc/string/strcoll.3
@@ -33,8 +33,7 @@
 .\" 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.4 2003/05/10 06:40:44 jmc Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRCOLL 3
@@ -49,14 +48,13 @@
 .Sh DESCRIPTION
 The
 .Fn strcoll
-function
-lexicographically compares the null-terminated strings
+function lexicographically compares the null-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 +68,5 @@ is greater than, equal to, or less than
 .Sh STANDARDS
 The
 .Fn strcoll
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strcoll.c b/src/lib/libc/string/strcoll.c
index 86c742cba9..dca0b10d25 100644
--- a/src/lib/libc/string/strcoll.c
+++ b/src/lib/libc/string/strcoll.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strcoll.c,v 1.2 1996/08/19 08:34:13 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strcpy.3 b/src/lib/libc/string/strcpy.3
index 1ca12c2707..d3c095916b 100644
--- a/src/lib/libc/string/strcpy.3
+++ b/src/lib/libc/string/strcpy.3
@@ -33,14 +33,14 @@
 .\" 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 $
+.\"     $OpenBSD: strcpy.3,v 1.11 2002/05/13 17:04:43 millert Exp $
 .\"
 .Dd June 29, 1991
 .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 +53,7 @@ The
 .Fn strcpy
 and
 .Fn strncpy
-functions
-copy the string
+functions copy the string
 .Fa src
 to
 .Fa dst
@@ -62,7 +61,6 @@ to
 .Ql \e0
 character).
 .Pp
-The
 .Fn strncpy
 copies not more than
 .Fa len
@@ -78,45 +76,79 @@ 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
+null terminate
+.Va chararray
+because the source string is >= the length parameter.
+.Fn strncpy
+.Em only
+null 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 null terminates the result.
+Because
+.Fn strncpy
+does
+.Em not
+guarantee to null terminate the string itself, we must do this 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 strlcpy 3
 .Sh STANDARDS
 The
 .Fn strcpy
 and
 .Fn strncpy
-functions
-conform to
+functions conform to
 .St -ansiC .
diff --git a/src/lib/libc/string/strcpy.c b/src/lib/libc/string/strcpy.c
index 669bfde23e..76b063fc10 100644
--- a/src/lib/libc/string/strcpy.c
+++ b/src/lib/libc/string/strcpy.c
@@ -32,11 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strcpy.c,v 1.4 1996/08/19 08:34:14 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 char *
 strcpy(to, from)
@@ -45,6 +48,6 @@ strcpy(to, 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..37e8f163f1 100644
--- a/src/lib/libc/string/strcspn.3
+++ b/src/lib/libc/string/strcspn.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: strcspn.3,v 1.5 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRCSPN 3
@@ -49,27 +48,36 @@
 .Sh DESCRIPTION
 The
 .Fn strcspn
-function
-spans the initial part of the null-terminated string
+function spans the initial part of the null-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
 .Sh SEE ALSO
-.Xr index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strpbrk 3 ,
 .Xr strrchr 3 ,
@@ -80,6 +88,5 @@ returns the number of characters spanned.
 .Sh STANDARDS
 The
 .Fn strcspn
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strcspn.c b/src/lib/libc/string/strcspn.c
index acb4d2a3af..f7261564a7 100644
--- a/src/lib/libc/string/strcspn.c
+++ b/src/lib/libc/string/strcspn.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strcspn.c,v 1.2 1996/08/19 08:34:15 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strdup.3 b/src/lib/libc/string/strdup.3
index 925cbf3d46..a0dc705f66 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.11 2003/04/07 18:53:58 deraadt 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
@@ -29,10 +31,9 @@
 .\" 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 June 9, 1993
 .Dt STRDUP 3
 .Os
 .Sh NAME
@@ -41,25 +42,47 @@
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft char *
-.Fn strdup "const char *str"
+.Fn strdup "const char *s"
 .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
+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 null-terminated string
+.Qq foobar :
+.Bd -literal -offset indent
+char *p;
+
+if ((p = strdup("foobar")) == NULL) {
+        fprintf(stderr, "Out of memory.\en");
+        exit(1);
+}
+.Ed
+.Sh ERRORS
+The
+.Fn strdup
+function may fail and set the external variable
+.Va errno
+for any of the errors specified for the library function
+.Xr malloc 3 .
 .Sh SEE ALSO
 .Xr free 3 ,
 .Xr malloc 3 ,
-.Xt strcpy 3 ,
-.Xt strlen 3
+.Xr strcpy 3 ,
+.Xr strlcpy 3 ,
+.Xr strlen 3
 .Sh HISTORY
 The
 .Fn strdup
-function
-.Ud .
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strdup.c b/src/lib/libc/string/strdup.c
index 27ede44110..be7f7ad094 100644
--- a/src/lib/libc/string/strdup.c
+++ b/src/lib/libc/string/strdup.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strdup.c,v 1.3 1997/08/20 04:18:52 millert 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
@@ -32,10 +34,16 @@
  */
 
 #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 $";
+#if 0
+static char sccsid[] = "@(#)strdup.c    8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: strdup.c,v 1.3 1997/08/20 04:18:52 millert Exp $";
+#endif
 #endif /* LIBC_SCCS and not lint */
 
+#include <sys/types.h>
+
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -43,12 +51,12 @@ char *
 strdup(str)
         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..05cb7e9d9c 100644
--- a/src/lib/libc/string/strerror.3
+++ b/src/lib/libc/string/strerror.3
@@ -33,12 +33,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.5 2002/11/21 20:45:05 marc Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRERROR 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm strerror
 .Nd get error message string
@@ -46,15 +45,35 @@
 .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.
+string affiliated with the specified error number
+.Fa errnum .
+The returned string contains a maximum of
+.Dv NL_TEXTMAX
+characters, including the trailing NUL.
 .Pp
 The array pointed to is not to be modified by the 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 given buffer
+.Fa strerrbuf .
+If the error message is larger then
+.Fa buflen
+the message will be truncated to fit within buflen and
+.Er ERANGE
+is returned.
+.Fn strerror_r
+returns zero upon successful completion.
+An error number is returned, otherwise.
 .Sh SEE ALSO
 .Xr intro 2 ,
 .Xr perror 3 ,
@@ -64,3 +83,7 @@ The
 .Fn strerror
 function conforms to
 .St -ansiC .
+The
+.Fn strerror_r
+function conforms to
+.St -p1003.1 .
diff --git a/src/lib/libc/string/strerror.c b/src/lib/libc/string/strerror.c
index c3f5ab5d98..b884a67df3 100644
--- a/src/lib/libc/string/strerror.c
+++ b/src/lib/libc/string/strerror.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strerror.c,v 1.3 2002/02/16 21:27:24 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
@@ -45,7 +44,7 @@ static char *rcsid = "$Id: strerror.c,v 1.1.1.1 1995/10/18 08:42:22 deraadt Exp
  * internal function __strerror().
  */
 
-extern char *__strerror __P((int, char *));
+extern char *__strerror(int, char *);
 
 char *
 strerror(num)
diff --git a/src/lib/libc/string/strerror_r.c b/src/lib/libc/string/strerror_r.c
new file mode 100644
index 0000000000..aab6db5303
--- /dev/null
+++ b/src/lib/libc/string/strerror_r.c
@@ -0,0 +1,30 @@
+/* $OpenBSD: strerror_r.c,v 1.1 2002/11/21 20:45:05 marc Exp $ */
+/* Public Domain <marc@snafu.org> */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strerror_r.c,v 1.1 2002/11/21 20:45:05 marc Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <errno.h>
+#include <limits.h>
+#include <string.h>
+
+extern char *__strerror(int, char *);
+
+int
+strerror_r(int errnum, char *strerrbuf, size_t buflen)
+{
+        int save_errno;
+        int ret_errno;
+        char buf[NL_TEXTMAX];
+
+        save_errno = errno;
+        errno = 0;
+        __strerror(errnum, buf);
+        if (strlcpy(strerrbuf, buf, buflen) >= buflen)
+                errno = ERANGE;
+        ret_errno = errno;
+        errno = save_errno;
+
+        return (ret_errno);
+}
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..7a67b96b53 100644
--- a/src/lib/libc/string/string.3
+++ b/src/lib/libc/string/string.3
@@ -31,27 +31,28 @@
 .\" 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.8 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd April 19, 1991
 .Dt STRING 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm strcat ,
+.Nm strlcat ,
 .Nm strncat ,
 .Nm strchr ,
 .Nm strrchr ,
 .Nm strcmp ,
 .Nm strncmp ,
-.Nm strcasecmp,
+.Nm strcasecmp ,
 .Nm strncasecmp ,
 .Nm strcpy ,
+.Nm strlcpy ,
 .Nm strncpy ,
 .Nm strerror ,
 .Nm strlen ,
 .Nm strpbrk ,
-.Nm strsep,
+.Nm strsep ,
 .Nm strspn ,
 .Nm strcspn ,
 .Nm strstr ,
@@ -62,7 +63,9 @@
 .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 +83,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,7 +108,7 @@
 .Fn rindex "const char *s" "int c"
 .Sh DESCRIPTION
 The string functions
-functions manipulate strings terminated by a
+manipulate strings terminated by a
 null byte.
 .Pp
 See the specific manual pages for more information.
@@ -115,23 +120,25 @@ 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 +152,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..16c59b2759
--- /dev/null
+++ b/src/lib/libc/string/strlcat.c
@@ -0,0 +1,59 @@
+/*      $OpenBSD: strlcat.c,v 1.10 2003/04/12 21:56:39 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 TODD C. MILLER DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL TODD C. MILLER 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 *rcsid = "$OpenBSD: strlcat.c,v 1.10 2003/04/12 21:56:39 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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)
+{
+        register char *d = dst;
+        register const char *s = src;
+        register 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..b6c58b5a75
--- /dev/null
+++ b/src/lib/libc/string/strlcpy.3
@@ -0,0 +1,179 @@
+.\" $OpenBSD: strlcpy.3,v 1.15 2003/04/12 21:56:39 millert 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 TODD C. MILLER DISCLAIMS ALL
+.\" WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL TODD C. MILLER BE LIABLE
+.\" FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+.\" OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+.\" CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd June 22, 1998
+.Dt STRLCPY 3
+.Os
+.Sh NAME
+.Nm strlcpy ,
+.Nm strlcat
+.Nd size-bounded string copying and concatenation
+.Sh SYNOPSIS
+.Fd #include <string.h>
+.Ft size_t
+.Fn strlcpy "char *dst" "const char *src" "size_t size"
+.Ft size_t
+.Fn strlcat "char *dst" "const char *src" "size_t size"
+.Sh DESCRIPTION
+The
+.Fn strlcpy
+and
+.Fn strlcat
+functions copy and concatenate strings respectively.
+They are designed
+to be safer, more consistent, and less error prone replacements for
+.Xr strncpy 3
+and
+.Xr strncat 3 .
+Unlike those functions,
+.Fn strlcpy
+and
+.Fn strlcat
+take the full size of the buffer (not just the length) and guarantee to
+NUL-terminate the result (as long as
+.Fa size
+is larger than 0 or, in the case of
+.Fn strlcat ,
+as long as there is at least one byte free in
+.Fa dst ) .
+Note that you should include a byte for the NUL 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 we know how many characters we copied the first time, we can
+speed things 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
diff --git a/src/lib/libc/string/strlcpy.c b/src/lib/libc/string/strlcpy.c
new file mode 100644
index 0000000000..8da97768c0
--- /dev/null
+++ b/src/lib/libc/string/strlcpy.c
@@ -0,0 +1,55 @@
+/*      $OpenBSD: strlcpy.c,v 1.7 2003/04/12 21:56:39 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 TODD C. MILLER DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL TODD C. MILLER 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 *rcsid = "$OpenBSD: strlcpy.c,v 1.7 2003/04/12 21:56:39 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#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)
+{
+        register char *d = dst;
+        register const char *s = src;
+        register size_t n = siz;
+
+        /* Copy as many bytes as will fit */
+        if (n != 0 && --n != 0) {
+                do {
+                        if ((*d++ = *s++) == 0)
+                                break;
+                } while (--n != 0);
+        }
+
+        /* 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..759e724056 100644
--- a/src/lib/libc/string/strlen.3
+++ b/src/lib/libc/string/strlen.3
@@ -33,15 +33,14 @@
 .\" 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 $
+.\"     $OpenBSD: strlen.3,v 1.4 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRLEN 3
 .Os
 .Sh NAME
 .Nm strlen
-.Nd find length of string
+.Nd find length of a string
 .Sh SYNOPSIS
 .Fd #include <string.h>
 .Ft size_t
@@ -49,23 +48,18 @@
 .Sh DESCRIPTION
 The
 .Fn strlen
-function
-computes the length of the string
+function computes the length of the string
 .Fa s .
 .Sh RETURN VALUES
 The
 .Fn strlen
-function
-returns
-the number of characters that precede the
-terminating
-.Dv NUL
+function returns the number of characters that precede the terminating
+.Tn NUL
 character.
 .Sh SEE ALSO
 .Xr string 3
 .Sh STANDARDS
 The
 .Fn strlen
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strlen.c b/src/lib/libc/string/strlen.c
index d23aadafc0..ab006e04c2 100644
--- a/src/lib/libc/string/strlen.c
+++ b/src/lib/libc/string/strlen.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strlen.c,v 1.4 2001/07/29 21:15:23 millert 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
@@ -32,19 +34,23 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strlen.c,v 1.4 2001/07/29 21:15:23 millert 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;
 {
-        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..36452bfd95 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.9 2003/04/02 19:00:26 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
@@ -29,10 +31,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 July 28, 1994
 .Dt STRMODE 3
 .Os
 .Sh NAME
@@ -45,15 +46,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 null byte.
 .Pp
 The first character is the inode type, and will be one of the following:
 .Pp
@@ -69,9 +68,11 @@ directory
 .It l
 symbolic link
 .It p
-fifo
+FIFO
 .It s
 socket
+.It w
+whiteout
 .It ?
 unknown inode type
 .El
@@ -80,46 +81,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 +141,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 +159,5 @@ always returns 0.
 .Sh HISTORY
 The
 .Fn strmode
-function
-.Ud .
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strmode.c b/src/lib/libc/string/strmode.c
index 441fc76e90..5e7f15e857 100644
--- a/src/lib/libc/string/strmode.c
+++ b/src/lib/libc/string/strmode.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strmode.c,v 1.3 1997/06/13 13:57:20 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
@@ -70,6 +69,11 @@ strmode(mode, p)
                 *p++ = 'p';
                 break;
 #endif
+#ifdef S_IFWHT
+        case S_IFWHT:                   /* whiteout */
+                *p++ = 'w';
+                break;
+#endif
         default:                        /* unknown */
                 *p++ = '?';
                 break;
diff --git a/src/lib/libc/string/strncat.c b/src/lib/libc/string/strncat.c
index 3d96452af4..27ae2ba324 100644
--- a/src/lib/libc/string/strncat.c
+++ b/src/lib/libc/string/strncat.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strncat.c,v 1.2 1996/08/19 08:34:21 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strncmp.c b/src/lib/libc/string/strncmp.c
index 0638d4dcf2..0224957f8b 100644
--- a/src/lib/libc/string/strncmp.c
+++ b/src/lib/libc/string/strncmp.c
@@ -32,11 +32,14 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strncmp.c,v 1.3 1996/08/19 08:34:21 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#ifndef _KERNEL
 #include <string.h>
+#else
+#include <lib/libkern/libkern.h>
+#endif
 
 int
 strncmp(s1, s2, n)
diff --git a/src/lib/libc/string/strncpy.c b/src/lib/libc/string/strncpy.c
index 5215311b75..01bc8a872e 100644
--- a/src/lib/libc/string/strncpy.c
+++ b/src/lib/libc/string/strncpy.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strncpy.c,v 1.2 1996/08/19 08:34:22 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strpbrk.3 b/src/lib/libc/string/strpbrk.3
index 8578546c05..52bf13b924 100644
--- a/src/lib/libc/string/strpbrk.3
+++ b/src/lib/libc/string/strpbrk.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: strpbrk.3,v 1.5 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRPBRK 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn strpbrk
-function
-locates in the null-terminated string
+function locates in the null-terminated string
 .Fa s
 the first occurrence of any character in the string
 .Fa charset
@@ -58,13 +56,12 @@ 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 ,
@@ -75,6 +72,5 @@ returns NULL.
 .Sh STANDARDS
 The
 .Fn strpbrk
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strpbrk.c b/src/lib/libc/string/strpbrk.c
index f1d542a525..748a3a8c94 100644
--- a/src/lib/libc/string/strpbrk.c
+++ b/src/lib/libc/string/strpbrk.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strpbrk.c,v 1.2 1996/08/19 08:34:23 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strrchr.3 b/src/lib/libc/string/strrchr.3
index 1d98cbff24..394fc2aad3 100644
--- a/src/lib/libc/string/strrchr.3
+++ b/src/lib/libc/string/strrchr.3
@@ -33,28 +33,31 @@
 .\" 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 $
+.\"     $OpenBSD: strrchr.3,v 1.6 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .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,20 +65,31 @@ 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 ,
@@ -86,6 +100,9 @@ does not occur anywhere in
 .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.
diff --git a/src/lib/libc/string/strsep.3 b/src/lib/libc/string/strsep.3
index 21aa7376f2..848dab1eb3 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.10 2001/11/21 14:32:45 deraadt 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:
@@ -31,10 +34,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 June 9, 1993
 .Dt STRSEP 3
 .Os
 .Sh NAME
@@ -43,27 +45,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 +85,32 @@ 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 is intended as a replacement for the
+.Fn strtok
+function.
+While the
+.Fn strtok
+function should be preferred for portability reasons (it conforms to
+.St -ansiC )
+it is unable to handle empty fields, i.e., detect fields delimited by
+two adjacent delimiter characters, or to be used for more than a single
+string at a time.
+The
+.Fn strsep
+function first appeared in
+.Bx 4.4 .
diff --git a/src/lib/libc/string/strsep.c b/src/lib/libc/string/strsep.c
index 69be7fe046..b69b715fc5 100644
--- a/src/lib/libc/string/strsep.c
+++ b/src/lib/libc/string/strsep.c
@@ -1,6 +1,8 @@
+/*      $OpenBSD: strsep.c,v 1.3 1997/08/20 04:28:14 millert 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
@@ -31,15 +33,19 @@
  * SUCH DAMAGE.
  */
 
+#include <string.h>
+#include <stdio.h>
+
 #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 $";
+#if 0
+static char sccsid[] = "@(#)strsep.c    8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: strsep.c,v 1.3 1997/08/20 04:28:14 millert Exp $";
+#endif
 #endif /* LIBC_SCCS and not lint */
 
-#include <string.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,7 +53,7 @@ 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)
diff --git a/src/lib/libc/string/strsignal.3 b/src/lib/libc/string/strsignal.3
index 3287fef53e..83b3775f4e 100644
--- a/src/lib/libc/string/strsignal.3
+++ b/src/lib/libc/string/strsignal.3
@@ -33,12 +33,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.3 1999/05/23 14:11:03 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRSIGNAL 3
-.Os BSD 4
+.Os
 .Sh NAME
 .Nm strsignal
 .Nd get signal description string
diff --git a/src/lib/libc/string/strsignal.c b/src/lib/libc/string/strsignal.c
index ec4a267edf..90118f70f9 100644
--- a/src/lib/libc/string/strsignal.c
+++ b/src/lib/libc/string/strsignal.c
@@ -32,14 +32,13 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strsignal.c,v 1.3 2002/02/16 21:27:24 millert 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)
diff --git a/src/lib/libc/string/strspn.3 b/src/lib/libc/string/strspn.3
index 4de03aa58b..ca965aeb18 100644
--- a/src/lib/libc/string/strspn.3
+++ b/src/lib/libc/string/strspn.3
@@ -33,8 +33,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 $
+.\"     $OpenBSD: strspn.3,v 1.6 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRSPN 3
@@ -48,9 +47,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 null-terminated string
 .Fa s
 as long as the characters from
 .Fa s
@@ -59,12 +57,23 @@ 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 ,
@@ -75,6 +84,5 @@ returns the number of characters spanned.
 .Sh STANDARDS
 The
 .Fn strspn
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strspn.c b/src/lib/libc/string/strspn.c
index 6224b25c2a..41940f9190 100644
--- a/src/lib/libc/string/strspn.c
+++ b/src/lib/libc/string/strspn.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strspn.c,v 1.2 1996/08/19 08:34:26 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strstr.3 b/src/lib/libc/string/strstr.3
index 24fdf540ed..10beea42ca 100644
--- a/src/lib/libc/string/strstr.3
+++ b/src/lib/libc/string/strstr.3
@@ -33,8 +33,7 @@
 .\" 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 $
+.\"     $OpenBSD: strstr.3,v 1.5 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRSTR 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn strstr
-function
-locates the first occurrence of the null-terminated string
+function locates the first occurrence of the null-terminated string
 .Fa little
 in the null-terminated string
 .Fa big .
@@ -65,15 +63,14 @@ if
 occurs nowhere in
 .Fa big ,
 .Fn strstr
-returns NULL;
+returns
+.Dv NULL ;
 otherwise
 .Fn strstr
 returns a pointer to the first character of the first occurrence of
 .Fa little .
 .Sh SEE ALSO
-.Xr index 3 ,
 .Xr memchr 3 ,
-.Xr rindex 3 ,
 .Xr strchr 3 ,
 .Xr strcspn 3 ,
 .Xr strpbrk 3 ,
@@ -84,6 +81,5 @@ returns a pointer to the first character of the first occurrence of
 .Sh STANDARDS
 The
 .Fn strstr
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strstr.c b/src/lib/libc/string/strstr.c
index 1ed59e357b..763c7e29d7 100644
--- a/src/lib/libc/string/strstr.c
+++ b/src/lib/libc/string/strstr.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strstr.c,v 1.2 1996/08/19 08:34:27 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/strtok.3 b/src/lib/libc/string/strtok.3
index 644bd10aed..b8dad8eff0 100644
--- a/src/lib/libc/string/strtok.3
+++ b/src/lib/libc/string/strtok.3
@@ -33,29 +33,30 @@
 .\" 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 $
+.\"     $OpenBSD: strtok.3,v 1.15 2001/08/06 10:42:26 mpech Exp $
 .\"
 .Dd June 29, 1991
 .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 null-terminated string,
 .Fa str .
 These tokens are separated in the string by at least one of the
 characters in
@@ -71,17 +72,65 @@ 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
+The
+.Fn strtok
+and
+.Fn strtok_r
+functions return a pointer to the beginning of each subsequent token
+in the string, after replacing the separator character itself with an
+.Tn ASCII NUL
 character.
 When no more tokens remain, a null pointer is returned.
+.Pp
+Since
+.Fn strtok
+and
+.Fn strtok_r
+modify the string,
+.Fa str
+should not point to an area in the initialized data segment.
+.Sh EXAMPLES
+The following will construct an array of pointers to each individual word in
+the string
+.Va s :
+.Bd -literal -offset indent
+#define MAXTOKENS       128
+
+char s[512], *p, *tokens[MAXTOKENS];
+char *last;
+int i = 0;
+
+snprintf(s, sizeof(s), "cat dog horse cow");
+
+for ((p = strtok_r(s, " ", &last)); p;
+    (p = strtok_r(NULL, " ", &last)), i++) {
+        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 ,
@@ -92,21 +141,16 @@ When no more tokens remain, a null pointer is returned.
 .Sh STANDARDS
 The
 .Fn strtok
-function
-conforms to
+function conforms to
 .St -ansiC .
 .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..d925dc75d0 100644
--- a/src/lib/libc/string/strtok.c
+++ b/src/lib/libc/string/strtok.c
@@ -32,8 +32,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strtok.c,v 1.3 1999/11/09 11:19:46 art Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
@@ -43,13 +42,23 @@ strtok(s, delim)
         register char *s;
         register const char *delim;
 {
+        static char *last;
+
+        return strtok_r(s, delim, &last);
+}
+
+char *
+strtok_r(s, delim, last)
+        register char *s;
+        register const char *delim;
+        char **last;
+{
         register char *spanp;
         register int c, sc;
         char *tok;
-        static char *last;
 
 
-        if (s == NULL && (s = last) == NULL)
+        if (s == NULL && (s = *last) == NULL)
                 return (NULL);
 
         /*
@@ -63,7 +72,7 @@ cont:
         }
 
         if (c == 0) {           /* no non-delimiter characters */
-                last = NULL;
+                *last = NULL;
                 return (NULL);
         }
         tok = s - 1;
@@ -81,7 +90,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..1e5338993a 100644
--- a/src/lib/libc/string/strxfrm.3
+++ b/src/lib/libc/string/strxfrm.3
@@ -33,8 +33,7 @@
 .\" 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.3 2000/04/21 15:24:20 aaron Exp $
 .\"
 .Dd June 29, 1991
 .Dt STRXFRM 3
@@ -49,8 +48,7 @@
 .Sh DESCRIPTION
 The
 .Fn strxfrm
-function
-does something horrible (see
+function does something horrible (see
 .Tn ANSI
 standard).
 In this implementation it just copies.
@@ -64,6 +62,5 @@ In this implementation it just copies.
 .Sh STANDARDS
 The
 .Fn strxfrm
-function
-conforms to
+function conforms to
 .St -ansiC .
diff --git a/src/lib/libc/string/strxfrm.c b/src/lib/libc/string/strxfrm.c
index d9df77b957..6b258edecc 100644
--- a/src/lib/libc/string/strxfrm.c
+++ b/src/lib/libc/string/strxfrm.c
@@ -35,8 +35,7 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: strxfrm.c,v 1.2 1996/08/19 08:34:29 tholo Exp $";
 #endif /* LIBC_SCCS and not lint */
 
 #include <string.h>
diff --git a/src/lib/libc/string/swab.3 b/src/lib/libc/string/swab.3
index 133c487bbd..628eb6b15f 100644
--- a/src/lib/libc/string/swab.3
+++ b/src/lib/libc/string/swab.3
@@ -29,8 +29,7 @@
 .\" 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.4 2000/01/03 22:52:59 aaron Exp $
 .\"
 .Dd May 1, 1991
 .Dt SWAB 3
@@ -39,7 +38,7 @@
 .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,7 +54,7 @@ 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
diff --git a/src/lib/libc/string/swab.c b/src/lib/libc/string/swab.c
index f33fc53bd6..311cf13a53 100644
--- a/src/lib/libc/string/swab.c
+++ b/src/lib/libc/string/swab.c
@@ -35,11 +35,10 @@
  */
 
 #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 $";
+static char *rcsid = "$OpenBSD: swab.c,v 1.3 1998/02/10 02:19:48 deraadt Exp $";
 #endif /* LIBC_SCCS and not lint */
 
-#include <string.h>
+#include <unistd.h>
 
 void
 swab(from, to, len)