diff --git a/libc/netbsd/resolv/res_cache.c b/libc/netbsd/resolv/res_cache.c
new file mode 100644
index 0000000..210dfdd
--- /dev/null
+++ b/libc/netbsd/resolv/res_cache.c
@@ -0,0 +1,533 @@
+/*
+ * Copyright (C) 2008 The Android Open Source 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:
+ *  * 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 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (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 "resolv_cache.h"
+#include <stdlib.h>
+#include <time.h>
+#include "pthread.h"
+
+/* this code implements a small DNS resolver cache for all gethostbyname* functions
+ *
+ * the cache is shared between all threads of the current process, but the result of
+ * a succesful lookup is always copied to a thread-local variable to honor the persistence
+ * rules of the gethostbyname*() APIs.
+ */
+
+/* the name of an environment variable that will be checked the first time this code is called
+ * if its value is "0", then the resolver cache is disabled.
+ */
+#define  CONFIG_ENV  "BIONIC_DNSCACHE"
+
+/* entries older than CONFIG_SECONDS seconds are always discarded. otherwise we could keep
+ * stale addresses in the cache and be oblivious to DNS server changes
+ */
+#define  CONFIG_SECONDS    (60*10)    /* 10 minutes */
+
+/* maximum number of entries kept in the cache. be frugal, this is the C library
+ * this MUST BE A POWER OF 2
+ */
+#define  CONFIG_MAX_ENTRIES   128
+
+/****************************************************************************/
+/****************************************************************************/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/****************************************************************************/
+/****************************************************************************/
+
+#define  DEBUG  0
+
+#if DEBUG
+#include <fcntl.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+static void
+xlog( const char*  fmt, ... )
+{
+    static int  fd = -2;
+    int         ret;
+
+    if (fd == -2) {
+        do {
+            fd = open( "/data/dns.log", O_CREAT | O_APPEND | O_WRONLY, 0666 );
+        } while (fd < 0 && errno == EINTR);
+    }
+
+    if (fd >= 0) {
+        char  temp[128];
+        va_list  args;
+        va_start(args, fmt);
+        vsnprintf( temp, sizeof(temp), fmt, args);
+        va_end(args);
+
+        do {
+            ret = write( fd, temp, strlen(temp) );
+        } while (ret == -1 && errno == EINTR);
+    }
+}
+#define  XLOG(...)   xlog(__VA_ARGS__)
+#else
+#define  XLOG(...)   ((void)0)
+#endif
+
+
+static time_t
+_time_now( void )
+{
+    struct timeval  tv;
+
+    gettimeofday( &tv, NULL );
+    return tv.tv_sec;
+}
+
+/****************************************************************************/
+/****************************************************************************/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/****************************************************************************/
+/****************************************************************************/
+
+/* used to define the content of _RESOLV_HOSTENT_NONE
+ */
+const struct hostent  _resolv_hostent_none_cst = {
+    NULL,
+    NULL,
+    AF_INET,
+    4,
+    NULL
+};
+
+struct hostent*
+_resolv_hostent_copy( struct hostent*  hp )
+{
+    struct hostent*  dst;
+    int              nn, len;
+    char*            p;
+    int              num_aliases = 0, num_addresses = 0;
+
+    if (hp == NULL)
+        return NULL;
+
+    if (hp == _RESOLV_HOSTENT_NONE)
+        return hp;
+
+    len  = sizeof(*hp);
+    len += strlen(hp->h_name) + 1;
+
+    if (hp->h_aliases != NULL) {
+        for (nn = 0; hp->h_aliases[nn] != NULL; nn++)
+            len += sizeof(char*) + strlen(hp->h_aliases[nn]) + 1;
+        num_aliases = nn;
+    }
+    len += sizeof(char*);
+
+    for (nn = 0; hp->h_addr_list[nn] != NULL; nn++) {
+        len += sizeof(char*) + hp->h_length;
+    }
+    num_addresses = nn;
+    len += sizeof(char*);
+
+    dst = malloc( len );
+    if (dst == NULL)
+        return NULL;
+
+    dst->h_aliases   = (char**)(dst + 1);
+    dst->h_addr_list = dst->h_aliases + num_aliases + 1;
+    dst->h_length    = hp->h_length;
+    dst->h_addrtype  = hp->h_addrtype;
+
+    p = (char*)(dst->h_addr_list + num_addresses + 1);
+
+    /* write the addresses first, to help with alignment issues */
+    for (nn = 0; nn < num_addresses; nn++) {
+        dst->h_addr_list[nn] = p;
+        len = hp->h_length;
+        memcpy( p, hp->h_addr_list[nn], len );
+        p += len;
+    }
+    dst->h_addr_list[nn] = NULL;
+
+    for (nn = 0; nn < num_aliases; nn++) {
+        dst->h_aliases[nn] = p;
+        len = strlen(hp->h_aliases[nn]) + 1;
+        memcpy( p, hp->h_aliases[nn], len );
+        p += len;
+    }
+    dst->h_aliases[nn] = NULL;
+
+    dst->h_name      = p;
+    len = strlen(hp->h_name) + 1;
+    memcpy(p, hp->h_name, len);
+    p += len;
+
+    return dst;
+}
+
+
+void
+_resolv_hostent_free( struct hostent*  hp )
+{
+    if (hp && hp != _RESOLV_HOSTENT_NONE)
+        free(hp);
+}
+
+/****************************************************************************/
+/****************************************************************************/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/****************************************************************************/
+/****************************************************************************/
+
+typedef struct Entry {
+    unsigned int     hash;
+    const char*      name;
+    short            af;
+    short            index;
+    struct Entry*    mru_prev;
+    struct Entry*    mru_next;
+    time_t           when;
+    struct hostent*  hp;
+} Entry;
+
+
+static void
+entry_free( Entry*  e )
+{
+    /* everything is allocated in a single memory block */
+    if (e) {
+        _resolv_hostent_free(e->hp);
+        free(e);
+    }
+}
+
+static void
+entry_init_key( Entry*  e, const char*  name, int  af )
+{
+    unsigned     h = 0;
+    const char*  p = name;
+
+    /* compute hash */
+    p = name;
+    while (*p) {
+        h = h*33 + *p++;
+    }
+    h += af*17;
+
+    e->hash = h;
+    e->name = name;
+    e->af   = (short) af;
+}
+
+
+static __inline__ void
+entry_mru_remove( Entry*  e )
+{
+    e->mru_prev->mru_next = e->mru_next;
+    e->mru_next->mru_prev = e->mru_prev;
+}
+
+static __inline__ void
+entry_mru_add( Entry*  e, Entry*  list )
+{
+    Entry*  first = list->mru_next;
+
+    e->mru_next = first;
+    e->mru_prev = list;
+
+    list->mru_next  = e;
+    first->mru_prev = e;
+}
+
+
+static Entry*
+entry_alloc( const char*  name, int  af, int  index, struct hostent*  hp )
+{
+    Entry*  e;
+    int     num_aliases   = 0;
+    int     num_addresses = 0;
+    char**  aliases;
+    char**  addresses;
+
+    /* compute the length of the memory block that will contain everything */
+    int   len = sizeof(*e) + strlen(name)+1;
+
+    e = malloc(len);
+    if (e == NULL)
+        return e;
+
+    entry_init_key(e, name, af);
+
+    e->mru_next = e->mru_prev = e;
+    e->index    = (short) index;
+    e->when     = _time_now();
+    e->hp       = _resolv_hostent_copy(hp);
+
+    if (e->hp == NULL) {
+        free(e);
+        return NULL;
+    }
+
+    e->name = (char*)(e+1);
+    len     = strlen(name)+1;
+    memcpy( (char*)e->name, name, len );
+    return e;
+}
+
+
+static __inline__ int
+entry_equals( const Entry*  e1, const Entry*  e2 )
+{
+    return e1->hash == e2->hash && e1->af == e2->af && !strcmp( e1->name, e2->name );
+}
+
+/****************************************************************************/
+/****************************************************************************/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/****************************************************************************/
+/****************************************************************************/
+
+#define  MAX_HASH_ENTRIES   (2*CONFIG_MAX_ENTRIES)
+
+typedef struct resolv_cache {
+    int               num_entries;
+    Entry             mru_list;
+    pthread_mutex_t   lock;
+    int               disabled;
+    Entry*            entries[ MAX_HASH_ENTRIES ];      /* hash-table of pointers to entries */
+} Cache;
+
+
+void
+_resolv_cache_destroy( struct resolv_cache*  cache )
+{
+    if (cache != NULL) {
+        int  nn;
+        for (nn = 0; nn < MAX_HASH_ENTRIES; nn++) {
+            entry_free(cache->entries[nn]);
+        }
+        pthread_mutex_destroy(&cache->lock);
+        free(cache);
+    }
+}
+
+
+struct resolv_cache*
+_resolv_cache_create( void )
+{
+    struct resolv_cache*  cache;
+
+    cache = calloc(sizeof(*cache), 1);
+    if (cache) {
+        const char*  env = getenv(CONFIG_ENV);
+
+        if (env && atoi(env) == 0)
+            cache->disabled = 1;
+
+        pthread_mutex_init( &cache->lock, NULL );
+        cache->mru_list.mru_prev = cache->mru_list.mru_next = &cache->mru_list;
+        XLOG("%s: cache=%p %s\n", __FUNCTION__, cache, cache->disabled ? "disabled" : "enabled" );
+    }
+    return cache;
+}
+
+
+static int
+_resolv_cache_find_index( Cache*       cache,
+                          const char*  name,
+                          int          af )
+{
+    Entry  key;
+    int    nn, step, tries;
+
+    entry_init_key( &key, name, af );
+
+    tries = MAX_HASH_ENTRIES;
+    nn    = key.hash % MAX_HASH_ENTRIES;
+    step  = 5;
+
+    while (tries > 0) {
+        Entry*  key2 = cache->entries[nn];
+
+        if (key2 == NULL) {
+            return -(nn + 1);
+        }
+
+        if (entry_equals( &key, key2 ) ) {
+            return nn;
+        }
+
+        nn     = (nn + step) % MAX_HASH_ENTRIES;
+        tries -= 1;
+    }
+    return -(MAX_HASH_ENTRIES+1);
+}
+
+
+static void
+_resolv_cache_remove( struct resolv_cache*  cache,
+                      Entry*                e )
+{
+    XLOG("%s: name='%s' af=%d\n", __FUNCTION__, e->name, e->af);
+    cache->entries[ e->index ] = NULL;  /* remove from hash table */
+    entry_mru_remove( e );
+    entry_free( e );
+    cache->num_entries -= 1;
+}
+
+
+struct hostent*
+_resolv_cache_lookup( struct resolv_cache*  cache,
+                      const char*           name,
+                      int                   af )
+{
+    int               index;
+    struct hostent*   result = NULL;
+
+    if (cache->disabled)
+        return NULL;
+
+    pthread_mutex_lock( &cache->lock );
+
+    XLOG( "%s: cache=%p name='%s' af=%d ", __FUNCTION__, cache, name, af );
+    index = _resolv_cache_find_index( cache, name, af );
+    if (index >= 0) {
+        Entry*  e   = cache->entries[index];
+        time_t  now = _time_now();
+        struct hostent**  pht;
+
+        /* ignore stale entries, they will be discarded in _resolv_cache_add */
+        if ( (unsigned)(now - e->when) >= CONFIG_SECONDS ) {
+            XLOG( " OLD\n" );
+            goto Exit;
+        }
+
+        /* bump up this entry to the top of the MRU list */
+        if (e != cache->mru_list.mru_next) {
+            entry_mru_remove( e );
+            entry_mru_add( e, &cache->mru_list );
+        }
+
+        /* now copy the result into a thread-local variable */
+        pht = __get_res_cache_hostent_p();
+        if (pht == NULL) {
+            XLOG( " NOTLS\n" );  /* shouldn't happen */
+            goto Exit;
+        }
+
+        if (pht[0]) {
+            _resolv_hostent_free( pht[0] );  /* clear previous value */
+            pht[0] = NULL;
+        }
+        result = _resolv_hostent_copy( e->hp );
+        if (result == NULL) {
+            XLOG( " NOMEM\n" );  /* bummer */
+            goto Exit;
+        }
+        XLOG( " OK\n" );
+        pht[0] = result;
+        goto Exit;
+    }
+    XLOG( " KO\n" );
+Exit:
+    pthread_mutex_unlock( &cache->lock );
+    return result;
+}
+
+
+void
+_resolv_cache_add( struct resolv_cache*  cache,
+                   const char*           name,
+                   int                   af,
+                   struct hostent*       hp )
+{
+    Entry*   e;
+    int      index;
+
+    if (cache->disabled)
+        return;
+
+    pthread_mutex_lock( &cache->lock );
+
+    XLOG( "%s: cache=%p name='%s' af=%d\n", __FUNCTION__, cache, name, af);
+
+    /* get rid of the oldest entry if needed */
+    if (cache->num_entries >= CONFIG_MAX_ENTRIES) {
+        Entry*  oldest = cache->mru_list.mru_prev;
+        _resolv_cache_remove( cache, oldest );
+    }
+
+    index = _resolv_cache_find_index( cache, name, af );
+    if (index >= 0) {
+        /* discard stale entry */
+        _resolv_cache_remove( cache, cache->entries[index] );
+    } else {
+        index = -(index+1);
+        if (index >= MAX_HASH_ENTRIES)
+            goto Exit;  /* should not happen */
+    }
+
+    e = entry_alloc( name, af, index, hp );
+    if (e != NULL) {
+        entry_mru_add( e, &cache->mru_list );
+        cache->entries[index] = e;
+        cache->num_entries   += 1;
+    }
+Exit:
+    pthread_mutex_unlock( &cache->lock );
+}
+
+/****************************************************************************/
+/****************************************************************************/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/*****                                                                  *****/
+/****************************************************************************/
+/****************************************************************************/
+
+static struct resolv_cache*  _res_cache;
+static pthread_once_t        _res_cache_once;
+
+static void
+_res_cache_init( void )
+{
+    _res_cache = _resolv_cache_create();
+}
+
+
+struct resolv_cache*
+__get_res_cache( void )
+{
+    pthread_once( &_res_cache_once, _res_cache_init );
+    return _res_cache;
+}