Changeset 9549

Timestamp:

Nov 24, 2009, 1:59:51 AM (8 years ago)

Author:

charles

Message:

(trunk libT) jch's patches 0001 through 0004 for ticket #2576, IPv6 support for DHT (BEP #32)

Location:

trunk

Files:

• libtransmission/announcer.c (modified) (1 diff)
• libtransmission/peer-msgs.c (modified) (1 diff)
• libtransmission/torrent.c (modified) (1 diff)
• libtransmission/torrent.h (modified) (1 diff)
• libtransmission/tr-dht.c (modified) (22 diffs)
• libtransmission/tr-dht.h (modified) (1 diff)
• third-party/dht/CHANGES (modified) (1 diff)
• third-party/dht/README (modified) (4 diffs)
• third-party/dht/dht-example.c (modified) (12 diffs)
• third-party/dht/dht.c (modified) (109 diffs)
• third-party/dht/dht.h (modified) (1 diff)

trunk/libtransmission/announcer.c

@@ -1651 +1651 @@
     while(( tor = tr_torrentNext( announcer->session, tor ))) {
         if( tor->dhtAnnounceAt <= now ) {
-            int rc = 1;
-            if( tor->isRunning && tr_torrentAllowsDHT(tor) )
-                rc = tr_dhtAnnounce(tor, 1);
-            if(rc == 0)
-                /* The DHT is not ready yet.  Try again soon. */
-                tor->dhtAnnounceAt = now + 5 + tr_cryptoWeakRandInt( 5 );
-            else
-                /* We should announce at least once every 30 minutes. */
-                tor->dhtAnnounceAt = now + 25 * 60 + tr_cryptoWeakRandInt( 3 * 60 );
+            if( tor->isRunning && tr_torrentAllowsDHT(tor) ) {
+                int rc;
+                rc = tr_dhtAnnounce(tor, AF_INET, 1);
+                if(rc == 0)
+                    /* The DHT is not ready yet.  Try again soon. */
+                    tor->dhtAnnounceAt = now + 5 + tr_cryptoWeakRandInt( 5 );
+                else
+                    /* We should announce at least once every 30 minutes. */
+                    tor->dhtAnnounceAt =
+                        now + 25 * 60 + tr_cryptoWeakRandInt( 3 * 60 );
+            }
+        }
+
+        if( tor->dhtAnnounce6At <= now ) {
+            if( tor->isRunning && tr_torrentAllowsDHT(tor) ) {
+                int rc;
+                rc = tr_dhtAnnounce(tor, AF_INET6, 1);
+                if(rc == 0)
+                    tor->dhtAnnounce6At = now + 5 + tr_cryptoWeakRandInt( 5 );
+                else
+                    tor->dhtAnnounce6At =
+                        now + 25 * 60 + tr_cryptoWeakRandInt( 3 * 60 );
+            }
         }
     }

trunk/libtransmission/peer-msgs.c

@@ -2129 +2129 @@
 
     if(tr_peerIoSupportsDHT(peer->io)) {
-        /* We don't have an IPv6 DHT yet.
-         * According to BEP-32, we can't send PORT over IPv6. */
+        /* Only send PORT over IPv6 when the IPv6 DHT is running (BEP-32). */
         const struct tr_address *addr = tr_peerIoGetAddress( peer->io, NULL );
-        if( addr->type == TR_AF_INET ) {
+        if( addr->type == TR_AF_INET || tr_globalIPv6() ) {
             protocolSendPort( m, tr_dhtPort( torrent->session ) );
         }

trunk/libtransmission/torrent.c

@@ -1320 +1320 @@
         tr_announcerTorrentStarted( tor );
         tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt( 20 );
+        tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt( 20 );
         tr_peerMgrStartTorrent( tor );
     }

trunk/libtransmission/torrent.h

@@ -182 +182 @@
 
     time_t                     dhtAnnounceAt;
+    time_t                     dhtAnnounce6At;
     tr_bool                    dhtAnnounceInProgress;
+    tr_bool                    dhtAnnounce6InProgress;
 
     uint64_t                   downloadedCur;

trunk/libtransmission/tr-dht.c

@@ -31 +31 @@
 #include <sys/types.h>
 #include <sys/socket.h> /* socket(), bind() */
+#include <netdb.h>
 #include <unistd.h> /* close() */
 
@@ -51 +52 @@
 #include "version.h"
 
-static int dht_socket;
-static struct event dht_event;
+static int dht_socket = -1, dht6_socket = -1;
+static struct event dht_event, dht6_event;
 static tr_port dht_port;
 static unsigned char myid[20];
@@ -62 +63 @@
     tr_session *session;
     uint8_t *nodes;
-    size_t len;
+    uint8_t *nodes6;
+    size_t len, len6;
 };
+
+static int
+bootstrap_done( tr_session *session, int af )
+{
+    int status;
+
+    if(af == 0)
+        return
+            bootstrap_done(session, AF_INET) &&
+            bootstrap_done(session, AF_INET6);
+
+    status = tr_dhtStatus(session, af, NULL);
+    return status == TR_DHT_STOPPED || status >= TR_DHT_FIREWALLED;
+}
+
+static void
+nap( int roughly )
+{
+    struct timeval tv;
+    tr_timevalSet( &tv, roughly / 2 + tr_cryptoWeakRandInt( roughly ),
+                   tr_cryptoWeakRandInt( 1000000 ) );
+    select( 0, NULL, NULL, NULL, &tv );
+}
+
+static int
+bootstrap_af(tr_session *session)
+{
+    if( bootstrap_done(session, AF_INET6) )
+        return AF_INET;
+    else if ( bootstrap_done(session, AF_INET) )
+        return AF_INET6;
+    else
+        return 0;
+}
+
+static void
+bootstrap_from_name( const char *name, short int port, int af )
+{
+    struct addrinfo hints, *info, *infop;
+    char pp[10];
+    int rc;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_socktype = SOCK_DGRAM;
+    hints.ai_family = af;
+    /* No, just passing p + 1 to gai won't work. */
+    snprintf(pp, 10, "%d", port);
+
+    rc = getaddrinfo(name, pp, &hints, &info);
+    if(rc != 0) {
+        tr_nerr("DHT", "%s:%s: %s", name, pp, gai_strerror(rc));
+        return;
+    }
+
+    infop = info;
+    while(infop) {
+        dht_ping_node(infop->ai_addr, infop->ai_addrlen);
+
+        nap(15);
+
+        if(bootstrap_done(session, af))
+            break;
+        infop = infop->ai_next;
+    }
+    freeaddrinfo(info);
+}
 
 static void
@@ -69 +137 @@
 {
     struct bootstrap_closure *cl = closure;
-    size_t i;
+    int i;
+    int num = cl->len / 6, num6 = cl->len6 / 18;
 
     if(session != cl->session)
         return;
 
-    for(i = 0; i < cl->len; i += 6)
-    {
-        struct timeval tv;
-        tr_port port;
-        struct tr_address addr;
-        int status;
-
-        memset(&addr, 0, sizeof(addr));
-        addr.type = TR_AF_INET;
-        memcpy(&addr.addr.addr4, &cl->nodes[i], 4);
-        memcpy(&port, &cl->nodes[i + 4], 2);
-        port = ntohs(port);
-        /* There's no race here -- if we uninit between the test and the
-           AddNode, the AddNode will be ignored. */
-        status = tr_dhtStatus(cl->session, NULL);
-        if(status == TR_DHT_STOPPED || status >= TR_DHT_FIREWALLED)
+    if(cl->len > 0)
+        tr_ninf( "DHT", "Bootstrapping from %d nodes", num );
+
+    if(cl->len6 > 0)
+        tr_ninf( "DHT", "Bootstrapping from %d IPv6 nodes", num6 );
+
+
+    for(i = 0; i < MAX(num, num6); i++) {
+        if( i < num && !bootstrap_done(cl->session, AF_INET) ) {
+            tr_port port;
+            struct tr_address addr;
+
+            memset(&addr, 0, sizeof(addr));
+            addr.type = TR_AF_INET;
+            memcpy(&addr.addr.addr4, &cl->nodes[i * 6], 4);
+            memcpy(&port, &cl->nodes[i * 6 + 4], 2);
+            port = ntohs(port);
+            tr_dhtAddNode(cl->session, &addr, port, 1);
+        }
+        if( i < num6 && !bootstrap_done(cl->session, AF_INET6) ) {
+            tr_port port;
+            struct tr_address addr;
+
+            memset(&addr, 0, sizeof(addr));
+            addr.type = TR_AF_INET6;
+            memcpy(&addr.addr.addr6, &cl->nodes6[i * 18], 16);
+            memcpy(&port, &cl->nodes6[i * 18 + 16], 2);
+            port = ntohs(port);
+            tr_dhtAddNode(cl->session, &addr, port, 1);
+        }
+
+        /* Our DHT code is able to take up to 9 nodes in a row without
+           dropping any.  After that, it takes some time to split buckets.
+           So ping the first 8 nodes quickly, then slow down. */
+        if(i < 8)
+            nap(2);
+        else
+            nap(15);
+
+        if(bootstrap_done( session, 0 ))
             break;
-        tr_dhtAddNode(cl->session, &addr, port, 1);
-        tr_timevalSet( &tv, 2 + tr_cryptoWeakRandInt( 5 ), tr_cryptoWeakRandInt( 1000000 ) );
-        select( 0, NULL, NULL, NULL, &tv );
-    }
-    tr_free( cl->nodes );
+    }
+
+    if(!bootstrap_done(cl->session, 0)) {
+        char *bootstrap_file;
+        FILE *f = NULL;
+
+        bootstrap_file =
+            tr_buildPath(cl->session->configDir, "dht.bootstrap", NULL);
+
+        if(bootstrap_file)
+            f = fopen(bootstrap_file, "r");
+        if(f) {
+            tr_ninf("DHT", "Attempting manual bootstrap");
+            while(1) {
+                char buf[201];
+                char *p;
+                int port = 0;
+
+                p = fgets(buf, 200, f);
+                if( p == NULL )
+                    break;
+
+                p = memchr(buf, ' ', strlen(buf));
+                if(p != NULL)
+                    port = atoi(p + 1);
+                if(p == NULL || port <= 0 || port >= 0x10000) {
+                    tr_nerr("DHT", "Couldn't parse %s", buf);
+                    continue;
+                }
+
+                *p = '\0';
+
+                bootstrap_from_name( buf, port, bootstrap_af(session) );
+
+                if(bootstrap_done(cl->session, 0))
+                    break;
+            }
+        }
+    }
+
+    /* We really don't want to abuse our bootstrap nodes.
+       Be glacially slow. */
+    if(!bootstrap_done(cl->session, 0))
+        nap(30);
+
+    if(!bootstrap_done(cl->session, 0)) {
+        tr_ninf("DHT", "Attempting bootstrap from dht.transmissionbt.com");
+        bootstrap_from_name( "dht.transmissionbt.com", 6881,
+                             bootstrap_af(session) );
+    }
+
+    if( cl->nodes )
+        tr_free( cl->nodes );
+    if( cl->nodes6 )
+        tr_free( cl->nodes6 );
     tr_free( closure );
     tr_ndbg( "DHT", "Finished bootstrapping" );
 }
 
+/* BEP-32 has a rather nice explanation of why we need to bind to one
+   IPv6 address, if I may say so myself. */
+
+static int
+rebind_ipv6(int force)
+{
+    struct sockaddr_in6 sin6;
+    const unsigned char *ipv6 = tr_globalIPv6();
+    static unsigned char *last_bound = NULL;
+    int rc;
+
+    if(dht6_socket < 0)
+        return 0;
+
+    if(!force &&
+       ((ipv6 == NULL && last_bound == NULL) ||
+        (ipv6 != NULL && last_bound != NULL &&
+         memcmp(ipv6, last_bound, 16) == 0)))
+        return 0;
+
+    memset(&sin6, 0, sizeof(sin6));
+    sin6.sin6_family = AF_INET6;
+    if(ipv6)
+        memcpy(&sin6.sin6_addr, ipv6, 16);
+    sin6.sin6_port = htons(dht_port);
+    rc = bind(dht6_socket, (struct sockaddr*)&sin6, sizeof(sin6));
+
+    if(last_bound)
+        free(last_bound);
+    last_bound = NULL;
+
+    if(rc >= 0 && ipv6) {
+        last_bound = malloc(16);
+        if(last_bound)
+            memcpy(last_bound, ipv6, 16);
+    }
+    return rc;
+}
+
 int
-tr_dhtInit(tr_session *ss, tr_address * tr_addr)
+tr_dhtInit(tr_session *ss, const tr_address * tr_addr)
 {
     struct sockaddr_in sin;
@@ -108 +290 @@
     tr_bool have_id = FALSE;
     char * dat_file;
-    uint8_t * nodes = NULL;
+    uint8_t * nodes = NULL, * nodes6 = NULL;
     const uint8_t * raw;
-    size_t len;
+    size_t len, len6;
     char v[5];
+    struct bootstrap_closure * cl;
 
     if( session ) /* already initialized */
@@ -128 +311 @@
     memset(&sin, 0, sizeof(sin));
     sin.sin_family = AF_INET;
-    memcpy(&(sin.sin_addr), &(tr_addr->addr.addr4), sizeof (struct in_addr));
+    memcpy(&sin.sin_addr, &tr_addr->addr.addr4, sizeof (struct in_addr));
     sin.sin_port = htons(dht_port);
     rc = bind(dht_socket, (struct sockaddr*)&sin, sizeof(sin));
@@ -134 +317 @@
         goto fail;
 
+    if(tr_globalIPv6()) {
+        dht6_socket = socket(PF_INET6, SOCK_DGRAM, 0);
+        if(dht6_socket < 0)
+            goto fail;
+
+        rebind_ipv6(1);
+
+    }
+
     if( getenv( "TR_DHT_VERBOSE" ) != NULL )
         dht_debug = stderr;
@@ -141 +333 @@
     tr_free( dat_file );
     if(rc == 0) {
-        if(( have_id = tr_bencDictFindRaw( &benc, "id", &raw, &len ) && len==20 ))
+        have_id = tr_bencDictFindRaw(&benc, "id", &raw, &len);
+        if( have_id && len==20 )
             memcpy( myid, raw, len );
-        if( tr_bencDictFindRaw( &benc, "nodes", &raw, &len ) && !(len%6) ) {
-            nodes = tr_memdup( raw, len );
-            tr_ninf( "DHT", "Bootstrapping from %d old nodes", (int)(len/6) );
+        if( dht_socket >= 0 &&
+            tr_bencDictFindRaw( &benc, "nodes", &raw, &len ) && !(len%6) ) {
+                nodes = tr_memdup( raw, len );
+        }
+        if( dht6_socket > 0 &&
+            tr_bencDictFindRaw( &benc, "nodes6", &raw, &len6 ) && !(len6%18) ) {
+            nodes6 = tr_memdup( raw, len6 );
         }
         tr_bencFree( &benc );
     }
+
+    if(nodes == NULL)
+        len = 0;
+    if(nodes6 == NULL)
+        len6 = 0;
 
     if( have_id )
@@ -163 +365 @@
     v[2] = (SVN_REVISION_NUM >> 8) & 0xFF;
     v[3] = SVN_REVISION_NUM & 0xFF;
-    rc = dht_init( dht_socket, myid, (const unsigned char*)v );
+    rc = dht_init( dht_socket, dht6_socket, myid, (const unsigned char*)v );
     if(rc < 0)
         goto fail;
@@ -169 +371 @@
     session = ss;
 
-    if(nodes) {
-        struct bootstrap_closure * cl = tr_new( struct bootstrap_closure, 1 );
-        cl->session = session;
-        cl->nodes = nodes;
-        cl->len = len;
-        tr_threadNew( dht_bootstrap, cl );
-    }
+    cl = tr_new( struct bootstrap_closure, 1 );
+    cl->session = session;
+    cl->nodes = nodes;
+    cl->nodes6 = nodes6;
+    cl->len = len;
+    cl->len6 = len6;
+    tr_threadNew( dht_bootstrap, cl );
 
     event_set( &dht_event, dht_socket, EV_READ, event_callback, NULL );
+    event_set( &dht6_event, dht6_socket, EV_READ, event_callback, NULL );
     tr_timerAdd( &dht_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
+    tr_timerAdd( &dht6_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
 
     tr_ndbg( "DHT", "DHT initialized" );
@@ -188 +392 @@
         const int save = errno;
         close(dht_socket);
-        dht_socket = -1;
+        if( dht6_socket >= 0 )
+            close(dht6_socket);
+        dht_socket = dht6_socket = -1;
         session = NULL;
         tr_ndbg( "DHT", "DHT initialization failed (errno = %d)", save );
@@ -206 +412 @@
 
     event_del(&dht_event);
+    event_del(&dht6_event);
 
     /* Since we only save known good nodes, avoid erasing older data if we
        don't know enough nodes. */
-    if(tr_dhtStatus(ss, NULL) < TR_DHT_FIREWALLED)
+    if(tr_dhtStatus(ss, AF_INET, NULL) < TR_DHT_FIREWALLED)
         tr_ninf( "DHT", "Not saving nodes, DHT not ready" );
     else {
         tr_benc benc;
         struct sockaddr_in sins[300];
-        char compact[300 * 6];
+        struct sockaddr_in6 sins6[300];
+        char compact[300 * 6], compact6[300 * 18];
         char *dat_file;
-        int i;
-        int n = dht_get_nodes(sins, 300);
-        int j = 0;
-
-        tr_ninf( "DHT", "Saving %d nodes", n );
-        for( i=0; i<n; ++i ) {
+        int i, j, num = 300, num6 = 300;
+        int n = dht_get_nodes(sins, &num, sins6, &num6);
+
+        tr_ninf( "DHT", "Saving %d (%d + %d) nodes", n, num, num6 );
+
+        j = 0;
+        for( i=0; i<num; ++i ) {
             memcpy( compact + j, &sins[i].sin_addr, 4 );
             memcpy( compact + j + 4, &sins[i].sin_port, 2 );
             j += 6;
         }
-        tr_bencInitDict( &benc, 2 );
+        j = 0;
+        for( i=0; i<num6; ++i ) {
+            memcpy( compact6 + j, &sins6[i].sin6_addr, 16 );
+            memcpy( compact6 + j + 16, &sins6[i].sin6_port, 2 );
+            j += 18;
+        }
+        tr_bencInitDict( &benc, 3 );
         tr_bencDictAddRaw( &benc, "id", myid, 20 );
-        tr_bencDictAddRaw( &benc, "nodes", compact, j );
+        if(num > 0)
+            tr_bencDictAddRaw( &benc, "nodes", compact, num * 6 );
+        if(num6 > 0)
+            tr_bencDictAddRaw( &benc, "nodes6", compact6, num6 * 18 );
         dat_file = tr_buildPath( ss->configDir, "dht.dat", NULL );
         tr_bencToFile( &benc, TR_FMT_BENC, dat_file );
@@ -235 +453 @@
     }
 
-    dht_uninit( dht_socket, 0 );
+    dht_uninit( 1 );
     tr_netCloseSocket( dht_socket );
+    if(dht6_socket > 0)
+        tr_netCloseSocket( dht6_socket );
 
     tr_ndbg("DHT", "Done uninitializing DHT");
@@ -244 +464 @@
 
 tr_bool
-tr_dhtEnabled( const tr_session * ss )
+tr_dhtEnabled( tr_session * ss )
 {
     return ss && ( ss == session );
@@ -251 +471 @@
 struct getstatus_closure
 {
+    int af;
     sig_atomic_t status;
     sig_atomic_t count;
@@ -256 +477 @@
 
 static void
-getstatus( void * closure )
-{
-    struct getstatus_closure * ret = closure;
+getstatus( void * cl )
+{
+    struct getstatus_closure * closure = cl;
     int good, dubious, incoming;
 
-    dht_nodes( &good, &dubious, NULL, &incoming );
-
-    ret->count = good + dubious;
+    dht_nodes( closure->af, &good, &dubious, NULL, &incoming );
+
+    closure->count = good + dubious;
 
     if( good < 4 || good + dubious <= 8 )
-        ret->status = TR_DHT_BROKEN;
+        closure->status = TR_DHT_BROKEN;
     else if( good < 40 )
-        ret->status = TR_DHT_POOR;
+        closure->status = TR_DHT_POOR;
     else if( incoming < 8 )
-        ret->status = TR_DHT_FIREWALLED;
+        closure->status = TR_DHT_FIREWALLED;
     else
-        ret->status = TR_DHT_GOOD;
+        closure->status = TR_DHT_GOOD;
 }
 
 int
-tr_dhtStatus( tr_session * ss, int * nodes_return )
-{
-    struct getstatus_closure ret = { -1, - 1 };
+tr_dhtStatus( tr_session * ss, int af, int * nodes_return )
+{
+    struct getstatus_closure closure = { af, -1, -1 };
 
     if( !tr_dhtEnabled( ss ) )
         return TR_DHT_STOPPED;
 
-    tr_runInEventThread( ss, getstatus, &ret );
-    while( ret.status < 0 )
+    if(dht_socket < 0 && dht6_socket < 0)
+        return TR_DHT_STOPPED;
+
+    if(af == AF_INET && dht_socket < 0)
+        return TR_DHT_STOPPED;
+
+    if(af == AF_INET6 && dht6_socket < 0)
+        return TR_DHT_STOPPED;
+
+    tr_runInEventThread( ss, getstatus, &closure );
+    while( closure.status < 0 )
         tr_wait( 10 /*msec*/ );
 
     if( nodes_return )
-        *nodes_return = ret.count;
-
-    return ret.status;
+        *nodes_return = closure.count;
+
+    return closure.status;
 }
 
 tr_port
-tr_dhtPort( const tr_session *ss )
+tr_dhtPort( tr_session *ss )
 {
     return tr_dhtEnabled( ss ) ? dht_port : 0;
@@ -305 +535 @@
                tr_bool            bootstrap )
 {
-    struct sockaddr_in sin;
+    int af = address->type == TR_AF_INET ? AF_INET : AF_INET6;
 
     if( !tr_dhtEnabled( ss ) )
         return 0;
 
-    if( address->type != TR_AF_INET )
-        return 0;
-
     /* Since we don't want to abuse our bootstrap nodes,
      * we don't ping them if the DHT is in a good state. */
+
     if(bootstrap) {
-        if(tr_dhtStatus(ss, NULL) >= TR_DHT_FIREWALLED)
+        if(tr_dhtStatus(ss, af, NULL) >= TR_DHT_FIREWALLED)
             return 0;
     }
 
-    memset(&sin, 0, sizeof(sin));
-    sin.sin_family = AF_INET;
-    memcpy(&sin.sin_addr, &address->addr.addr4, 4);
-    sin.sin_port = htons(port);
-    dht_ping_node(dht_socket, &sin);
-
-    return 1;
+    if( address->type == TR_AF_INET ) {
+        struct sockaddr_in sin;
+        memset(&sin, 0, sizeof(sin));
+        sin.sin_family = AF_INET;
+        memcpy(&sin.sin_addr, &address->addr.addr4, 4);
+        sin.sin_port = htons(port);
+        dht_ping_node((struct sockaddr*)&sin, sizeof(sin));
+        return 1;
+    } else if( address->type == TR_AF_INET6 ) {
+        struct sockaddr_in6 sin6;
+        memset(&sin6, 0, sizeof(sin6));
+        sin6.sin6_family = AF_INET6;
+        memcpy(&sin6.sin6_addr, &address->addr.addr6, 16);
+        sin6.sin6_port = htons(port);
+        dht_ping_node((struct sockaddr*)&sin6, sizeof(sin6));
+        return 1;
+    }
+
+    return 0;
 }
 
@@ -346 +586 @@
           unsigned char *info_hash, void *data, size_t data_len )
 {
-    if( event == DHT_EVENT_VALUES )
-    {
+    if( event == DHT_EVENT_VALUES || event == DHT_EVENT_VALUES6 ) {
         tr_torrent *tor;
         tr_globalLock( session );
@@ -354 +593 @@
         {
             size_t i, n;
-            tr_pex * pex = tr_peerMgrCompactToPex(data, data_len, NULL, 0, &n);
+            tr_pex * pex;
+            if( event == DHT_EVENT_VALUES )
+                pex = tr_peerMgrCompactToPex(data, data_len, NULL, 0, &n);
+            else
+                pex = tr_peerMgrCompact6ToPex(data, data_len, NULL, 0, &n);
             for( i=0; i<n; ++i )
                 tr_peerMgrAddPex( tor, TR_PEER_FROM_DHT, pex+i );
             tr_free(pex);
-            tr_torinf(tor, "Learned %d peers from DHT", (int)n);
+            tr_torinf(tor, "Learned %d%s peers from DHT",
+                      (int)n,
+                      event == DHT_EVENT_VALUES6 ? " IPv6" : "");
         }
         tr_globalUnlock( session );
-    }
-    else if( event == DHT_EVENT_SEARCH_DONE )
-    {
+    } else if( event == DHT_EVENT_SEARCH_DONE ||
+               event == DHT_EVENT_SEARCH_DONE6) {
         tr_torrent * tor = tr_torrentFindFromHash( session, info_hash );
         if( tor ) {
-            tr_torinf(tor, "DHT announce done");
-            tor->dhtAnnounceInProgress = 0;
+            if( event == DHT_EVENT_SEARCH_DONE ) {
+                tr_torinf(tor, "DHT announce done");
+                tor->dhtAnnounceInProgress = 0;
+            } else {
+                tr_torinf(tor, "IPv6 DHT announce done");
+                tor->dhtAnnounce6InProgress = 0;
+            }
         }
     }
@@ -373 +622 @@
 
 int
-tr_dhtAnnounce(tr_torrent *tor, tr_bool announce)
-{
-    int rc, status, numnodes;
+tr_dhtAnnounce(tr_torrent *tor, int af, tr_bool announce)
+{
+    int rc, status, numnodes, ret = 0;
 
     if( !tr_torrentAllowsDHT( tor ) )
         return -1;
 
-    status = tr_dhtStatus( tor->session, &numnodes );
-    if(status < TR_DHT_POOR ) {
-        tr_tordbg(tor, "DHT not ready (%s, %d nodes)",
+    status = tr_dhtStatus( tor->session, af, &numnodes );
+    if(status >= TR_DHT_POOR ) {
+        rc = dht_search( tor->info.hash,
+                         announce ? tr_sessionGetPeerPort(session) : 0,
+                         af, callback, NULL);
+        if( rc >= 1 ) {
+            tr_torinf(tor, "Starting%s DHT announce (%s, %d nodes)",
+                      af == AF_INET6 ? " IPv6" : "",
+                      tr_dhtPrintableStatus(status), numnodes);
+            if(af == AF_INET)
+                tor->dhtAnnounceInProgress = TRUE;
+            else
+                tor->dhtAnnounce6InProgress = TRUE;
+            ret = 1;
+        } else {
+            tr_torerr(tor, "%sDHT announce failed, errno = %d (%s, %d nodes)",
+                      af == AF_INET6 ? "IPv6 " : "",
+                      errno, tr_dhtPrintableStatus(status), numnodes);
+        }
+    } else {
+        tr_tordbg(tor, "%sDHT not ready (%s, %d nodes)",
+                  af == AF_INET6 ? "IPv6 " : "",
                   tr_dhtPrintableStatus(status), numnodes);
-        return 0;
-    }
-
-    rc = dht_search( dht_socket, tor->info.hash,
-                     announce ? tr_sessionGetPeerPort(session) : 0,
-                     callback, NULL);
-
-    if( rc >= 1 ) {
-        tr_torinf(tor, "Starting DHT announce (%s, %d nodes)",
-                  tr_dhtPrintableStatus(status), numnodes);
-        tor->dhtAnnounceInProgress = TRUE;
-    } else {
-        tr_torerr(tor, "DHT announce failed, errno = %d (%s, %d nodes)",
-                  errno, tr_dhtPrintableStatus(status), numnodes);
-    }
-
-    return 1;
+    }
+
+    return ret;
 }
 
@@ -406 +660 @@
 event_callback(int s, short type, void *ignore UNUSED )
 {
+    struct event *event = (s == dht_socket) ? &dht_event : &dht6_event;
     time_t tosleep;
-
-    if( dht_periodic(s, type == EV_READ, &tosleep, callback, NULL) < 0 ) {
+    static int count = 0;
+
+    if( dht_periodic( type == EV_READ, &tosleep, callback, NULL) < 0 ) {
         if(errno == EINTR) {
             tosleep = 0;
@@ -419 +675 @@
     }
 
+    /* Only do this once in a while.  Counting rather than measuring time
+       avoids a system call. */
+    count++;
+    if(count >= 128) {
+        rebind_ipv6(0);
+        count = 0;
+    }
+
     /* Being slightly late is fine,
        and has the added benefit of adding some jitter. */
-    tr_timerAdd( &dht_event, tosleep, tr_cryptoWeakRandInt( 1000000 ) );
+    tr_timerAdd( event, tosleep, tr_cryptoWeakRandInt( 1000000 ) );
 }
 

trunk/libtransmission/tr-dht.h

@@ -27 +27 @@
 #define TR_DHT_GOOD 4
 
-int  tr_dhtInit( tr_session *, tr_address * );
+int  tr_dhtInit( tr_session *, const tr_address * );
 void tr_dhtUninit( tr_session * );
-tr_bool tr_dhtEnabled( const tr_session * );
-tr_port tr_dhtPort ( const tr_session * );
-int tr_dhtStatus( tr_session *, int * setme_nodeCount );
+tr_bool tr_dhtEnabled( tr_session * );
+tr_port tr_dhtPort ( tr_session * );
+int tr_dhtStatus( tr_session *, int af, int * setme_nodeCount );
 const char *tr_dhtPrintableStatus(int status);
 int tr_dhtAddNode( tr_session *, const tr_address *, tr_port, tr_bool bootstrap );
-int tr_dhtAnnounce( tr_torrent *, tr_bool announce );
+int tr_dhtAnnounce( tr_torrent *, int af, tr_bool announce );

trunk/third-party/dht/CHANGES

@@ +1 @@
+22 November 2009: dht-0.11
+
+  * Implemented IPv6 support (BEP-32).
+  * Fixed a bug which could cause us to never mark a search as finished.
+  * Fixed a bug that could cause us to send incomplete lists in response to
+    find_nodes.
+  * Limit the number of hashes that we're willing to track.
+  * Made bucket maintenance slightly more aggressive.
+  * Produce on-the-wire error messages to give a hint to the other side.
+  * Added a bunch of options to dht-example to make it useful as
+    a bootstrap node.
+  * Send version "JC\0\0" when using dht-example.
+
 18 October 2009: dht-0.10
 

trunk/third-party/dht/README

@@ -20 +20 @@
 
 This must be called before using the library.  You pass it a bound IPv4
-datagram socket, and your node id, a 20-octet array that should be globally
-unique.
+datagram socket, a bound IPv6 datagram socket, and your node id, a 20-octet
+array that should be globally unique.
+
+If you're on a multi-homed host, you should bind the sockets to one of your
+addresses.
 
 Node ids must be well distributed, so you cannot just use your Bittorrent
@@ -28 +31 @@
 idea to keep the id stable, so you may want to store it in stable storage
 at client shutdown.
+
  
 * dht_uninit
@@ -148 +152 @@
 
 The callback function is called with 5 arguments.  Closure is simply the
-value that you passed to dht_periodic.  Event is one of DHT_EVENT_VALUES,
-which indicates that we have new values, or DHT_EVENT_SEARCH_DONE, which
-indicates that a search has completed.  In either case, info_hash is set to
-the info-hash of the search.
+value that you passed to dht_periodic.  Event is one of DHT_EVENT_VALUES or
+DHT_EVENT_VALUES6, which indicates that we have new values, or
+DHT_EVENT_SEARCH_DONE or DHT_EVENT_SEARCH_DONE6, which indicates that
+a search has completed.  In either case, info_hash is set to the info-hash
+of the search.
 
 In the case of DHT_EVENT_VALUES, data is a list of nodes in ``compact''
-format -- 6 bytes per node, 4 for the IP address and 2 for the port.  It's
-length in bytes is in data_len.
+format -- 6 or 18 bytes per node.  Its length in bytes is in data_len.
 
 * dht_hash
@@ -187 +191 @@
 keep both pieces.
 
-IPv6 support is deliberately not included: designing a double-stack
-distributed hash table raises some tricky issues, and doing it naively may
-break connectivity for everyone.
 
                                         Juliusz Chroboczek

trunk/third-party/dht/dht-example.c

@@ -21 +21 @@
 
 #define MAX_BOOTSTRAP_NODES 20
-static struct sockaddr_in bootstrap_nodes[MAX_BOOTSTRAP_NODES];
+static struct sockaddr_storage bootstrap_nodes[MAX_BOOTSTRAP_NODES];
 static int num_bootstrap_nodes = 0;
 
@@ -93 +93 @@
 {
     int i, rc, fd;
-    int s, port;
+    int s = -1, s6 = -1, port;
     int have_id = 0;
     unsigned char myid[20];
     time_t tosleep = 0;
+    char *id_file = "dht-example.id";
+    int opt;
+    int quiet = 0, ipv4 = 1, ipv6 = 1;
+    struct sockaddr_in sin;
+    struct sockaddr_in6 sin6;
+
+    memset(&sin, 0, sizeof(sin));
+    sin.sin_family = AF_INET;
+
+    memset(&sin6, 0, sizeof(sin6));
+    sin6.sin6_family = AF_INET6;
+
+
+
+    while(1) {
+        opt = getopt(argc, argv, "q46b:i:");
+        if(opt < 0)
+            break;
+
+        switch(opt) {
+        case 'q': quiet = 1; break;
+        case '4': ipv6 = 0; break;
+        case '6': ipv4 = 0; break;
+        case 'b': {
+            char buf[16];
+            int rc;
+            rc = inet_pton(AF_INET, optarg, buf);
+            if(rc == 1) {
+                memcpy(&sin.sin_addr, buf, 4);
+                break;
+            }
+            rc = inet_pton(AF_INET6, optarg, buf);
+            if(rc == 1) {
+                memcpy(&sin6.sin6_addr, buf, 16);
+                break;
+            }
+            goto usage;
+        }
+            break;
+        case 'i':
+            id_file = optarg;
+            break;
+        default:
+            goto usage;
+        }
+    }
 
     /* Ids need to be distributed evenly, so you cannot just use your
        bittorrent id.  Either generate it randomly, or take the SHA-1 of
        something. */
-    fd = open("dht-example.id", O_RDONLY);
+    fd = open(id_file, O_RDONLY);
     if(fd >= 0) {
         rc = read(fd, myid, 20);
@@ -109 +155 @@
     }
     
+    fd = open("/dev/urandom", O_RDONLY);
+    if(fd < 0) {
+        perror("open(random)");
+        exit(1);
+    }
+
     if(!have_id) {
-        fd = open("/dev/urandom", O_RDONLY);
-        if(fd < 0) {
-            perror("open(random)");
-            exit(1);
-        }
+        int ofd;
+
         rc = read(fd, myid, 20);
         if(rc < 0) {
@@ -123 +172 @@
         close(fd);
 
-        fd = open("dht-example.id", O_WRONLY | O_CREAT | O_TRUNC, 0666);
-        if(fd >= 0) {
-            rc = write(fd, myid, 20);
+        ofd = open(id_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+        if(ofd >= 0) {
+            rc = write(ofd, myid, 20);
             if(rc < 20)
-                unlink("dht-example.id");
-            close(fd);
-        }
-    }
+                unlink(id_file);
+            close(ofd);
+        }
+    }
+
+    {
+        unsigned seed;
+        read(fd, &seed, sizeof(seed));
+        srandom(seed);
+    }
+
+    close(fd);
 
     if(argc < 2)
         goto usage;
 
-    i = 1;
+    i = optind;
 
     if(argc < i + 1)
@@ -147 +204 @@
         struct addrinfo hints, *info, *infop;
         memset(&hints, 0, sizeof(hints));
-        hints.ai_family = AF_INET;
         hints.ai_socktype = SOCK_DGRAM;
-        rc = getaddrinfo(argv[i], NULL, &hints, &info);
+        if(!ipv6)
+            hints.ai_family = AF_INET;
+        else if(!ipv4)
+            hints.ai_family = AF_INET6;
+        else
+            hints.ai_family = 0;
+        rc = getaddrinfo(argv[i], argv[i + 1], &hints, &info);
         if(rc != 0) {
             fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rc));
@@ -161 +223 @@
         infop = info;
         while(infop) {
-            if(infop->ai_addr->sa_family == AF_INET) {
-                struct sockaddr_in sin;
-                memcpy(&sin, infop->ai_addr, infop->ai_addrlen);
-                sin.sin_port = htons(atoi(argv[i]));
-                bootstrap_nodes[num_bootstrap_nodes] = sin;
-                num_bootstrap_nodes++;
-            }
+            memcpy(&bootstrap_nodes[num_bootstrap_nodes],
+                   infop->ai_addr, infop->ai_addrlen);
             infop = infop->ai_next;
+            num_bootstrap_nodes++;
         }
         freeaddrinfo(info);
@@ -177 +235 @@
     /* If you set dht_debug to a stream, every action taken by the DHT will
        be logged. */
-    dht_debug = stdout;
-
-    /* We need an IPv4 socket, bound to a stable port.  Rumour has it that
-       uTorrent works better when it is the same as your Bittorrent port. */
-    s = socket(PF_INET, SOCK_DGRAM, 0);
-    if(s < 0) {
-        perror("socket");
+    if(!quiet)
+        dht_debug = stdout;
+
+    /* We need an IPv4 and an IPv6 socket, bound to a stable port.  Rumour
+       has it that uTorrent works better when it is the same as your
+       Bittorrent port. */
+    if(ipv4) {
+        s = socket(PF_INET, SOCK_DGRAM, 0);
+        if(s < 0) {
+            perror("socket(IPv4)");
+        }
+    }
+
+    if(ipv6) {
+        s6 = socket(PF_INET6, SOCK_DGRAM, 0);
+        if(s6 < 0) {
+            perror("socket(IPv6)");
+        }
+    }
+
+    if(s < 0 && s6 < 0) {
+        fprintf(stderr, "Eek!");
         exit(1);
     }
 
-    {
-        struct sockaddr_in sin;
-        memset(&sin, 0, sizeof(sin));
-        sin.sin_family = AF_INET;
+
+    if(s >= 0) {
         sin.sin_port = htons(port);
         rc = bind(s, (struct sockaddr*)&sin, sizeof(sin));
         if(rc < 0) {
-            perror("bind");
+            perror("bind(IPv4)");
             exit(1);
         }
     }
 
+    if(s6 >= 0) {
+        int rc;
+        int val = 1;
+
+        rc = setsockopt(s6, IPPROTO_IPV6, IPV6_V6ONLY,
+                        (char *)&val, sizeof(val));
+        if(rc < 0) {
+            perror("setsockopt(IPV6_V6ONLY)");
+            exit(1);
+        }
+
+        /* BEP-32 mandates that we should bind this socket to one of our
+           global IPv6 addresses.  In this simple example, this only
+           happens if the user used the -b flag. */
+
+        sin6.sin6_port = htons(port);
+        rc = bind(s6, (struct sockaddr*)&sin6, sizeof(sin6));
+        if(rc < 0) {
+            perror("bind(IPv6)");
+            exit(1);
+        }
+    }
+
     /* Init the dht.  This sets the socket into non-blocking mode. */
-    rc = dht_init(s, myid, NULL);
+    rc = dht_init(s, s6, myid, (unsigned char*)"JC\0\0");
     if(rc < 0) {
         perror("dht_init");
@@ -218 +312 @@
        dht_insert_node.  If the ids are incorrect, the DHT will recover. */
     for(i = 0; i < num_bootstrap_nodes; i++) {
-        dht_ping_node(s, &bootstrap_nodes[i]);
+        dht_ping_node((struct sockaddr*)&bootstrap_nodes[i],
+                      sizeof(bootstrap_nodes[i]));
         usleep(random() % 100000);
     }
@@ -229 +324 @@
 
         FD_ZERO(&readfds);
-        FD_SET(s, &readfds);
-        rc = select(s + 1, &readfds, NULL, NULL, &tv);
+        if(s >= 0)
+            FD_SET(s, &readfds);
+        if(s6 >= 0)
+            FD_SET(s6, &readfds);
+        rc = select(s > s6 ? s + 1 : s6 + 1, &readfds, NULL, NULL, &tv);
         if(rc < 0) {
             if(errno != EINTR) {
@@ -241 +339 @@
             break;
 
-        rc = dht_periodic(s, rc > 0, &tosleep, callback, NULL);
+        rc = dht_periodic(rc > 0, &tosleep, callback, NULL);
         if(rc < 0) {
             if(errno == EINTR) {
@@ -254 +352 @@
 
         /* This is how you trigger a search for a torrent hash.  If port
-           (the third argument) is non-zero, it also performs an announce.
+           (the second argument) is non-zero, it also performs an announce.
            Since peers expire announced data after 30 minutes, it's a good
            idea to reannounce every 28 minutes or so. */
         if(searching) {
-            dht_search(s, hash, 0, callback, NULL);
+            if(s >= 0)
+                dht_search(hash, 0, AF_INET, callback, NULL);
+            if(s6 >= 0)
+                dht_search(hash, 0, AF_INET6, callback, NULL);
             searching = 0;
         }
@@ -270 +371 @@
 
     {
-        struct sockaddr_in sins[500];
+        struct sockaddr_in sin[500];
+        struct sockaddr_in6 sin6[500];
+        int num = 500, num6 = 500;
         int i;
-        i = dht_get_nodes(sins, 500);
-        printf("Found %d good nodes.\n", i);
-    }
-
-    dht_uninit(s, 1);
+        i = dht_get_nodes(sin, &num, sin6, &num6);
+        printf("Found %d (%d + %d) good nodes.\n", i, num, num6);
+    }
+
+    dht_uninit(1);
     return 0;
     
  usage:
-    fprintf(stderr, "Foo!\n");
+    printf("Usage: dht-example [-q] [-4] [-6] [-i filename] [-b address]...\n"
+           "                   port [address port]...\n");
     exit(1);
 }

trunk/third-party/dht/dht.c

@@ -58 +58 @@
 
 /* We set sin_family to 0 to mark unused slots. */
-#if AF_INET == 0
+#if AF_INET == 0 || AF_INET6 == 0
 #error You lose
 #endif
@@ -81 +81 @@
 struct node {
     unsigned char id[20];
-    struct sockaddr_in sin;
+    struct sockaddr_storage ss;
+    int sslen;
     time_t time;                /* time of last message received */
     time_t reply_time;          /* time of last correct reply received */
@@ -90 +91 @@
 
 struct bucket {
+    int af;
     unsigned char first[20];
     int count;                  /* number of nodes */
     int time;                   /* time of last reply in this bucket */
     struct node *nodes;
-    struct sockaddr_in cached;  /* the address of a likely candidate */
+    struct sockaddr_storage cached;  /* the address of a likely candidate */
+    int cachedlen;
     struct bucket *next;
 };
@@ -100 +103 @@
 struct search_node {
     unsigned char id[20];
-    struct sockaddr_in sin;
+    struct sockaddr_storage ss;
+    int sslen;
     time_t request_time;        /* the time of the last unanswered request */
     time_t reply_time;          /* the time of the last reply */
@@ -117 +121 @@
 struct search {
     unsigned short tid;
+    int af;
     time_t step_time;           /* the time of the last search_step */
     unsigned char id[20];
@@ -128 +133 @@
 struct peer {
     time_t time;
-    unsigned char ip[4];
+    unsigned char ip[16];
+    unsigned short len;
     unsigned short port;
 };
@@ -137 +143 @@
 #endif
 
+/* The maximum number of hashes we're willing to track. */
+#ifndef DHT_MAX_HASHES
+#define DHT_MAX_HASHES 16384
+#endif
+
 /* The maximum number of searches we keep data about. */
 #ifndef DHT_MAX_SEARCHES
@@ -149 +160 @@
 struct storage {
     unsigned char id[20];
-    int numpeers;
-    int maxpeers;
+    int numpeers, maxpeers;
     struct peer *peers;
     struct storage *next;
 };
 
-static int send_ping(int s, struct sockaddr *sa, int salen,
+static int send_ping(struct sockaddr *sa, int salen,
                      const unsigned char *tid, int tid_len);
-static int send_pong(int s, struct sockaddr *sa, int salen,
+static int send_pong(struct sockaddr *sa, int salen,
                      const unsigned char *tid, int tid_len);
-static int send_find_node(int s, struct sockaddr *sa, int salen,
+static int send_find_node(struct sockaddr *sa, int salen,
                           const unsigned char *tid, int tid_len,
-                          const unsigned char *target, int confirm);
-static int send_nodes_peers(int s, struct sockaddr *sa, int salen,
+                          const unsigned char *target, int want, int confirm);
+static int send_nodes_peers(struct sockaddr *sa, int salen,
                             const unsigned char *tid, int tid_len,
                             const unsigned char *nodes, int nodes_len,
-                            struct peer *peers1, int numpeers1,
-                            struct peer *peers2, int numpeers2,
+                            const unsigned char *nodes6, int nodes6_len,
+                            int af, struct storage *st,
                             const unsigned char *token, int token_len);
-static int send_closest_nodes(int s, struct sockaddr *sa, int salen,
+static int send_closest_nodes(struct sockaddr *sa, int salen,
                               const unsigned char *tid, int tid_len,
-                              const unsigned char *id,
-                              struct peer *peers1, int numpeers1,
-                              struct peer *peers2, int numpeers2,
+                              const unsigned char *id, int want,
+                              int af, struct storage *st,
                               const unsigned char *token, int token_len);
-static int send_get_peers(int s, struct sockaddr *sa, int salen,
+static int send_get_peers(struct sockaddr *sa, int salen,
                           unsigned char *tid, int tid_len,
-                          unsigned char *infohash, int confirm);
-static int send_announce_peer(int s, struct sockaddr *sa, int salen,
+                          unsigned char *infohash, int want, int confirm);
+static int send_announce_peer(struct sockaddr *sa, int salen,
                               unsigned char *tid, int tid_len,
                               unsigned char *infohas, unsigned short port,
                               unsigned char *token, int token_len, int confirm);
-int send_peer_announced(int s, struct sockaddr *sa, int salen,
-                        unsigned char *tid, int tid_len);
-
-#define REPLY 0
-#define PING 1
-#define FIND_NODE 2
-#define GET_PEERS 3
-#define ANNOUNCE_PEER 4
+static int send_peer_announced(struct sockaddr *sa, int salen,
+                               unsigned char *tid, int tid_len);
+static int send_error(struct sockaddr *sa, int salen,
+                      unsigned char *tid, int tid_len,
+                      int code, const char *message);
+
+#define ERROR 0
+#define REPLY 1
+#define PING 2
+#define FIND_NODE 3
+#define GET_PEERS 4
+#define ANNOUNCE_PEER 5
+
+#define WANT4 1
+#define WANT6 2
+
 static int parse_message(const unsigned char *buf, int buflen,
                          unsigned char *tid_return, int *tid_len,
@@ -197 +214 @@
                          unsigned char *token_return, int *token_len,
                          unsigned char *nodes_return, int *nodes_len,
-                         const unsigned char *values_return, int *values_len);
+                         unsigned char *nodes6_return, int *nodes6_len,
+                         unsigned char *values_return, int *values_len,
+                         unsigned char *values6_return, int *values6_len,
+                         int *want_return);
 
 static const unsigned char zeroes[20] = {0};
@@ -205 +225 @@
     0xFF, 0xFF, 0xFF, 0xFF
 };
+
+static int dht_socket = -1;
+static int dht_socket6 = -1;
+
 static time_t search_time;
 static time_t confirm_nodes_time;
@@ -216 +240 @@
 
 static struct bucket *buckets = NULL;
+static struct bucket *buckets6 = NULL;
 static struct storage *storage;
+static int numstorage;
 
 static struct search *searches = NULL;
@@ -227 +253 @@
 #define DHT_MAX_BLACKLISTED 10
 #endif
-static struct sockaddr_in blacklist[DHT_MAX_BLACKLISTED];
+static struct sockaddr_storage blacklist[DHT_MAX_BLACKLISTED];
 int next_blacklisted;
 
 static struct timeval now;
-static time_t mybucket_grow_time;
+static time_t mybucket_grow_time, mybucket6_grow_time;
 static time_t expire_stuff_time;
 
@@ -356 +382 @@
 
 static struct bucket *
-find_bucket(unsigned const char *id)
-{
-    struct bucket *b = buckets;
+find_bucket(unsigned const char *id, int af)
+{
+    struct bucket *b = af == AF_INET ? buckets : buckets6;
+
+    if(b == NULL)
+        return NULL;
 
     while(1) {
@@ -372 +401 @@
 previous_bucket(struct bucket *b)
 {
-    struct bucket *p = buckets;
+    struct bucket *p = b->af == AF_INET ? buckets : buckets6;
 
     if(b == p)
@@ -388 +417 @@
 /* Every bucket contains an unordered list of nodes. */
 static struct node *
-find_node(const unsigned char *id)
-{
-    struct bucket *b = find_bucket(id);
+find_node(const unsigned char *id, int af)
+{
+    struct bucket *b = find_bucket(id, af);
     struct node *n;
 
     if(b == NULL)
         return NULL;
+
     n = b->nodes;
     while(n) {
@@ -459 +489 @@
         id_return[i] = random() & 0xFF;
     return 1;
-}    
+}
 
 /* Insert a new node into a bucket. */
@@ -465 +495 @@
 insert_node(struct node *node)
 {
-    struct bucket *b = find_bucket(node->id);
+    struct bucket *b = find_bucket(node->id, node->ss.ss_family);
+
+    if(b == NULL)
+        return NULL;
 
     node->next = b->nodes;
@@ -509 +542 @@
 /* Every bucket caches the address of a likely node.  Ping it. */
 static int
-send_cached_ping(int s, struct bucket *b)
-{
+send_cached_ping(struct bucket *b)
+{
+    unsigned char tid[4];
     int rc;
     /* We set family to 0 when there's no cached node. */
-    if(b->cached.sin_family == AF_INET) {
-        unsigned char tid[4];
-        debugf("Sending ping to cached node.\n");
-        make_tid(tid, "pn", 0);
-        rc = send_ping(s, (struct sockaddr*)&b->cached,
-                       sizeof(struct sockaddr_in),
-                       tid, 4);
-        b->cached.sin_family = 0;
-        return rc;
-    }
-    return 0;
+    if(b->cached.ss_family == 0)
+        return 0;
+
+    debugf("Sending ping to cached node.\n");
+    make_tid(tid, "pn", 0);
+    rc = send_ping((struct sockaddr*)&b->cached, b->cachedlen, tid, 4);
+    b->cached.ss_family = 0;
+    b->cachedlen = 0;
+    return rc;
 }
 
 /* Split a bucket into two equal parts. */
 static struct bucket *
-split_bucket(int s, struct bucket *b)
+split_bucket(struct bucket *b)
 {
     struct bucket *new;
@@ -543 +575 @@
         return NULL;
 
-    send_cached_ping(s, b);
+    new->af = b->af;
+
+    send_cached_ping(b);
 
     memcpy(new->first, new_id, 20);
@@ -564 +598 @@
 /* Called whenever we send a request to a node. */
 static void
-pinged(int s, struct node *n, struct bucket *b)
+pinged(struct node *n, struct bucket *b)
 {
     n->pinged++;
     n->pinged_time = now.tv_sec;
     if(n->pinged >= 3)
-        send_cached_ping(s, b ? b : find_bucket(n->id));
+        send_cached_ping(b ? b : find_bucket(n->id, n->ss.ss_family));
 }
 
@@ -575 +609 @@
    the node sent a message, 2 if it sent us a reply. */
 static struct node *
-new_node(int s, const unsigned char *id, struct sockaddr_in *sin,
-         int confirm)
-{
-    struct bucket *b = find_bucket(id);
+new_node(const unsigned char *id, struct sockaddr *sa, int salen, int confirm)
+{
+    struct bucket *b = find_bucket(id, sa->sa_family);
     struct node *n;
-    int mybucket = in_bucket(myid, b);
+    int mybucket, split;
+
+    if(b == NULL)
+        return NULL;
 
     if(id_cmp(id, myid) == 0)
         return NULL;
+
+    mybucket = in_bucket(myid, b);
 
     if(confirm == 2)
@@ -593 +631 @@
             if(confirm || n->time < now.tv_sec - 15 * 60) {
                 /* Known node.  Update stuff. */
-                n->sin = *sin;
+                memcpy((struct sockaddr*)&n->ss, sa, salen);
                 if(confirm)
                     n->time = now.tv_sec;
@@ -612 +650 @@
         if(n->pinged >= 3 && n->pinged_time < now.tv_sec - 15) {
             memcpy(n->id, id, 20);
-            n->sin = *sin;
+            memcpy((struct sockaddr*)&n->ss, sa, salen);
             n->time = confirm ? now.tv_sec : 0;
             n->reply_time = confirm >= 2 ? now.tv_sec : 0;
             n->pinged_time = 0;
             n->pinged = 0;
-            if(mybucket)
-                mybucket_grow_time = now.tv_sec;
+            if(mybucket) {
+                if(sa->sa_family == AF_INET)
+                    mybucket_grow_time = now.tv_sec;
+                else
+                    mybucket6_grow_time = now.tv_sec;
+            }
             return n;
         }
@@ -639 +681 @@
                     debugf("Sending ping to dubious node.\n");
                     make_tid(tid, "pn", 0);
-                    send_ping(s,
-                              (struct sockaddr*)&n->sin,
-                              sizeof(struct sockaddr_in),
+                    send_ping((struct sockaddr*)&n->ss, n->sslen,
                               tid, 4);
                     n->pinged++;
@@ -651 +691 @@
         }
 
-        /* If there's only one bucket, split even if there remain doubtful
-           nodes.  This violates the spec, but it speeds up bootstrapping. */
-        if(mybucket && (!dubious || buckets->next == NULL)) {
+        split = 0;
+        if(mybucket) {
+            if(!dubious)
+                split = 1;
+            /* If there's only one bucket, split eagerly.  This is
+               incorrect unless there's more than 8 nodes in the DHT. */
+            else if(b->af == AF_INET && buckets->next == NULL)
+                split = 1;
+            else if(b->af == AF_INET6 && buckets6->next == NULL)
+                split = 1;
+        }
+
+        if(split) {
             debugf("Splitting.\n");
-            b = split_bucket(s, b);
-            mybucket_grow_time = now.tv_sec;
-            return new_node(s, id, sin, confirm);
+            b = split_bucket(b);
+            if(sa->sa_family == AF_INET)
+                mybucket_grow_time = now.tv_sec;
+            else
+                mybucket6_grow_time = now.tv_sec;
+            return new_node(id, sa, salen, confirm);
         }
 
         /* No space for this node.  Cache it away for later. */
-        if(confirm || b->cached.sin_family == 0)
-            b->cached = *sin;
+        if(confirm || b->cached.ss_family == 0) {
+            memcpy(&b->cached, sa, salen);
+            b->cachedlen = salen;
+        }
 
         return NULL;
@@ -672 +727 @@
         return NULL;
     memcpy(n->id, id, 20);
-    n->sin = *sin;
+    memcpy(&n->ss, sa, salen);
+    n->sslen = salen;
     n->time = confirm ? now.tv_sec : 0;
     n->reply_time = confirm >= 2 ? now.tv_sec : 0;
@@ -678 +734 @@
     b->nodes = n;
     b->count++;
-    if(mybucket)
-        mybucket_grow_time = now.tv_sec;
+    if(mybucket) {
+        if(sa->sa_family == AF_INET)
+            mybucket_grow_time = now.tv_sec;
+        else
+            mybucket6_grow_time = now.tv_sec;
+    }
     return n;
 }
@@ -687 +747 @@
    recover as soon as we find better ones. */
 static int
-expire_buckets(int s)
-{
-    struct bucket *b = buckets;
-
+expire_buckets(struct bucket *b)
+{
     while(b) {
         struct node *n, *p;
@@ -716 +774 @@
 
         if(changed)
-            send_cached_ping(s, b);
+            send_cached_ping(b);
 
         b = b->next;
@@ -730 +788 @@
 
 static struct search *
-find_search(unsigned short tid)
+find_search(unsigned short tid, int af)
 {
     struct search *sr = searches;
     while(sr) {
-        if(sr->tid == tid)
+        if(sr->tid == tid && sr->af == af)
             return sr;
         sr = sr->next;
@@ -746 +804 @@
 
 static int
-insert_search_node(unsigned char *id, struct sockaddr_in *sin,
+insert_search_node(unsigned char *id,
+                   struct sockaddr *sa, int salen,
                    struct search *sr, int replied,
                    unsigned char *token, int token_len)
@@ -752 +811 @@
     struct search_node *n;
     int i, j;
+
+    if(sa->sa_family != sr->af) {
+        debugf("Attempted to insert node in the wrong family.\n");
+        return 0;
+    }
 
     for(i = 0; i < sr->numnodes; i++) {
@@ -778 +842 @@
 
 found:
-    n->sin = *sin;
+    memcpy(&n->ss, sa, salen);
+    n->sslen = salen;
 
     if(replied) {
@@ -830 +895 @@
 /* This must always return 0 or 1, never -1, not even on failure (see below). */
 static int
-search_send_get_peers(int s, struct search *sr, struct search_node *n)
+search_send_get_peers(struct search *sr, struct search_node *n)
 {
     struct node *node;
@@ -850 +915 @@
     debugf("Sending get_peers.\n");
     make_tid(tid, "gp", sr->tid);
-    send_get_peers(s, (struct sockaddr*)&n->sin,
-                   sizeof(struct sockaddr_in), tid, 4, sr->id,
+    send_get_peers((struct sockaddr*)&n->ss, n->sslen, tid, 4, sr->id, -1,
                    n->reply_time >= now.tv_sec - 15);
     n->pinged++;
@@ -857 +921 @@
     /* If the node happens to be in our main routing table, mark it
        as pinged. */
-    node = find_node(n->id);
-    if(node) pinged(s, node, NULL);
+    node = find_node(n->id, n->ss.ss_family);
+    if(node) pinged(node, NULL);
     return 1;
 }
@@ -865 +929 @@
    further requests. */
 static void
-search_step(int s, struct search *sr, dht_callback *callback, void *closure)
+search_step(struct search *sr, dht_callback *callback, void *closure)
 {
     int i, j;
@@ -905 +969 @@
                     debugf("Sending announce_peer.\n");
                     make_tid(tid, "ap", sr->tid);
-                    send_announce_peer(s,
-                                       (struct sockaddr*)&n->sin,
-                                       sizeof(struct sockaddr_in),
+                    send_announce_peer((struct sockaddr*)&n->ss,
+                                       sizeof(struct sockaddr_storage),
                                        tid, 4, sr->id, sr->port,
                                        n->token, n->token_len,
@@ -913 +976 @@
                     n->pinged++;
                     n->request_time = now.tv_sec;
-                    node = find_node(n->id);
-                    if(node) pinged(s, node, NULL);
+                    node = find_node(n->id, n->ss.ss_family);
+                    if(node) pinged(node, NULL);
                 }
                 j++;
@@ -930 +993 @@
     j = 0;
     for(i = 0; i < sr->numnodes; i++) {
-        j += search_send_get_peers(s, sr, &sr->nodes[i]);
+        j += search_send_get_peers(sr, &sr->nodes[i]);
         if(j >= 3)
             break;
@@ -940 +1003 @@
     sr->done = 1;
     if(callback)
-        (*callback)(closure, DHT_EVENT_SEARCH_DONE, sr->id, NULL, 0);
+        (*callback)(closure,
+                    sr->af == AF_INET ?
+                    DHT_EVENT_SEARCH_DONE : DHT_EVENT_SEARCH_DONE6,
+                    sr->id, NULL, 0);
     sr->step_time = now.tv_sec;
 }
@@ -984 +1050 @@
     n = b->nodes;
     while(n) {
-        insert_search_node(n->id, &n->sin, sr, 0, NULL, 0);
+        insert_search_node(n->id, (struct sockaddr*)&n->ss, n->sslen,
+                           sr, 0, NULL, 0);
         n = n->next;
     }
@@ -991 +1058 @@
 /* Start a search.  If port is non-zero, perform an announce when the
    search is complete. */
-int 
-dht_search(int s, const unsigned char *id, int port,
+int
+dht_search(const unsigned char *id, int port, int af,
            dht_callback *callback, void *closure)
 {
     struct search *sr;
-    struct bucket *b;
+    struct bucket *b = find_bucket(id, af);
+
+    if(b == NULL) {
+        errno = EAFNOSUPPORT;
+        return -1;
+    }
 
     sr = searches;
     while(sr) {
-        if(id_cmp(sr->id, id) == 0)
+        if(sr->af == af && id_cmp(sr->id, id) == 0)
             break;
         sr = sr->next;
@@ -1030 +1102 @@
             return -1;
         }
+        sr->af = af;
         sr->tid = search_id++;
         sr->step_time = 0;
@@ -1039 +1112 @@
     sr->port = port;
 
-    b = find_bucket(id);
     insert_search_bucket(b, sr);
 
@@ -1050 +1122 @@
     }
     if(sr->numnodes < SEARCH_NODES)
-        insert_search_bucket(find_bucket(myid), sr);
-
-    search_step(s, sr, callback, closure);
+        insert_search_bucket(find_bucket(myid, af), sr);
+
+    search_step(sr, callback, closure);
     search_time = now.tv_sec;
     return 1;
@@ -1074 +1146 @@
 
 static int
-storage_store(const unsigned char *id, const unsigned char *ip,
-              unsigned short port)
-{
-    int i;
+storage_store(const unsigned char *id, struct sockaddr *sa)
+{
+    int i, len;
     struct storage *st = storage;
+    unsigned char *ip;
+    unsigned short port;
 
     st = find_storage(id);
 
     if(st == NULL) {
+        if(numstorage >= DHT_MAX_HASHES)
+            return -1;
         st = calloc(1, sizeof(struct storage));
         if(st == NULL) return -1;
@@ -1088 +1163 @@
         st->next = storage;
         storage = st;
+        numstorage++;
+    }
+
+    if(sa->sa_family == AF_INET) {
+        struct sockaddr_in *sin = (struct sockaddr_in*)sa;
+        ip = (unsigned char*)&sin->sin_addr;
+        len = 4;
+        port = ntohs(sin->sin_port);
+    } else if(sa->sa_family == AF_INET6) {
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)sa;
+        ip = (unsigned char*)&sin6->sin6_addr;
+        len = 16;
+        port = ntohs(sin6->sin6_port);
     }
 
     for(i = 0; i < st->numpeers; i++) {
-        if(st->peers[i].port == port && memcmp(st->peers[i].ip, ip, 4) == 0)
+        if(st->peers[i].port == port && st->peers[i].len == len &&
+           memcmp(st->peers[i].ip, ip, len) == 0)
             break;
     }
+
     if(i < st->numpeers) {
         /* Already there, only need to refresh */
@@ -1104 +1194 @@
             struct peer *new_peers;
             int n;
-            if(st->maxpeers > DHT_MAX_PEERS / 2)
+            if(st->maxpeers >= DHT_MAX_PEERS)
                 return 0;
             n = st->maxpeers == 0 ? 2 : 2 * st->maxpeers;
+            n = MIN(n, DHT_MAX_PEERS);
             new_peers = realloc(st->peers, n * sizeof(struct peer));
             if(new_peers == NULL)
@@ -1115 +1206 @@
         p = &st->peers[st->numpeers++];
         p->time = now.tv_sec;
-        memcpy(p->ip, ip, 4);
+        p->len = len;
+        memcpy(p->ip, ip, len);
         p->port = port;
         return 1;
@@ -1148 +1240 @@
             else
                 st = storage;
+            numstorage--;
+            if(numstorage < 0) {
+                debugf("Eek... numstorage became negative.\n");
+                numstorage = 0;
+            }
         } else {
             previous = st;
@@ -1158 +1255 @@
 /* We've just found out that a node is buggy. */
 static void
-broken_node(int s, const unsigned char *id, struct sockaddr_in *sin)
+broken_node(const unsigned char *id, struct sockaddr *sa, int salen)
 {
     int i;
@@ -1168 +1265 @@
         struct search *sr;
         /* Make the node easy to discard. */
-        n = find_node(id);
+        n = find_node(id, sa->sa_family);
         if(n) {
             n->pinged = 3;
-            pinged(s, n, NULL);
+            pinged(n, NULL);
         }
         /* Discard it from any searches in progress. */
@@ -1183 +1280 @@
     }
     /* And make sure we don't hear from it again. */
-    blacklist[next_blacklisted] = *sin;
+    memcpy(&blacklist[next_blacklisted], sa, salen);
     next_blacklisted = (next_blacklisted + 1) % DHT_MAX_BLACKLISTED;
 }
@@ -1208 +1305 @@
 
 static void
-make_token(const unsigned char *ipv4, unsigned short port, int old,
-           unsigned char *token_return)
-{
+make_token(struct sockaddr *sa, int old, unsigned char *token_return)
+{
+    void *ip;
+    int iplen;
+    unsigned short port;
+
+    if(sa->sa_family == AF_INET) {
+        struct sockaddr_in *sin = (struct sockaddr_in*)sa;
+        ip = &sin->sin_addr;
+        iplen = 4;
+        port = htons(sin->sin_port);
+    } else if(sa->sa_family == AF_INET6) {
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)sa;
+        ip = &sin6->sin6_addr;
+        iplen = 16;
+        port = htons(sin6->sin6_port);
+    } else {
+        abort();
+    }
+
     dht_hash(token_return, TOKEN_SIZE,
              old ? oldsecret : secret, sizeof(secret),
-             ipv4, 4,
-             (unsigned char*)&port, 2);
+             ip, iplen, (unsigned char*)&port, 2);
 }
 static int
-token_match(unsigned char *token, int token_len,
-            const unsigned char *ipv4, unsigned short port)
+token_match(unsigned char *token, int token_len, struct sockaddr *sa)
 {
     unsigned char t[TOKEN_SIZE];
     if(token_len != TOKEN_SIZE)
         return 0;
-    make_token(ipv4, port, 0, t);
+    make_token(sa, 0, t);
     if(memcmp(t, token, TOKEN_SIZE) == 0)
         return 1;
-    make_token(ipv4, port, 1, t);
+    make_token(sa, 1, t);
     if(memcmp(t, token, TOKEN_SIZE) == 0)
         return 1;
@@ -1233 +1345 @@
 
 int
-dht_nodes(int *good_return, int *dubious_return, int *cached_return,
+dht_nodes(int af, int *good_return, int *dubious_return, int *cached_return,
           int *incoming_return)
 {
     int good = 0, dubious = 0, cached = 0, incoming = 0;
-    struct bucket *b = buckets;
+    struct bucket *b = af == AF_INET ? buckets : buckets6;
+
     while(b) {
         struct node *n = b->nodes;
@@ -1250 +1363 @@
             n = n->next;
         }
-        if(b->cached.sin_family == AF_INET)
+        if(b->cached.ss_family > 0)
             cached++;
         b = b->next;
@@ -1264 +1377 @@
     return good + dubious;
 }
-                
+
+static void
+dump_bucket(FILE *f, struct bucket *b)
+{
+    struct node *n = b->nodes;
+    fprintf(f, "Bucket ");
+    print_hex(f, b->first, 20);
+    fprintf(f, " count %d age %d%s%s:\n",
+            b->count, (int)(now.tv_sec - b->time),
+            in_bucket(myid, b) ? " (mine)" : "",
+            b->cached.ss_family ? " (cached)" : "");
+    while(n) {
+        char buf[512];
+        unsigned short port;
+        fprintf(f, "    Node ");
+        print_hex(f, n->id, 20);
+        if(n->ss.ss_family == AF_INET) {
+            struct sockaddr_in *sin = (struct sockaddr_in*)&n->ss;
+            inet_ntop(AF_INET, &sin->sin_addr, buf, 512);
+            port = ntohs(sin->sin_port);
+        } else if(n->ss.ss_family == AF_INET6) {
+            struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&n->ss;
+            inet_ntop(AF_INET6, &sin6->sin6_addr, buf, 512);
+            port = ntohs(sin6->sin6_port);
+        } else {
+            snprintf(buf, 512, "unknown(%d)", n->ss.ss_family);
+            port = 0;
+        }
+
+        if(n->ss.ss_family == AF_INET6)
+            fprintf(f, " [%s]:%d ", buf, port);
+        else
+            fprintf(f, " %s:%d ", buf, port);
+        if(n->time != n->reply_time)
+            fprintf(f, "age %ld, %ld",
+                    (long)(now.tv_sec - n->time),
+                    (long)(now.tv_sec - n->reply_time));
+        else
+            fprintf(f, "age %ld", (long)(now.tv_sec - n->time));
+        if(n->pinged)
+            fprintf(f, " (%d)", n->pinged);
+        if(node_good(n))
+            fprintf(f, " (good)");
+        fprintf(f, "\n");
+        n = n->next;
+    }
+
+}
 
 void
@@ -1270 +1430 @@
 {
     int i;
-    struct bucket *b = buckets;
+    struct bucket *b;
     struct storage *st = storage;
     struct search *sr = searches;
@@ -1277 +1437 @@
     print_hex(f, myid, 20);
     fprintf(f, "\n");
+
+    b = buckets;
     while(b) {
-        struct node *n = b->nodes;
-        fprintf(f, "Bucket ");
-        print_hex(f, b->first, 20);
-        fprintf(f, " count %d age %d%s%s:\n",
-               b->count, (int)(now.tv_sec - b->time),
-               in_bucket(myid, b) ? " (mine)" : "",
-               b->cached.sin_family ? " (cached)" : "");
-        while(n) {
-            char buf[512];
-            fprintf(f, "    Node ");
-            print_hex(f, n->id, 20);
-            inet_ntop(AF_INET, &n->sin.sin_addr, buf, 512);
-            fprintf(f, " %s:%d ", buf, ntohs(n->sin.sin_port));
-            if(n->time != n->reply_time)
-                fprintf(f, "age %ld, %ld",
-                       (long)(now.tv_sec - n->time),
-                       (long)(now.tv_sec - n->reply_time));
-            else
-                fprintf(f, "age %ld", (long)(now.tv_sec - n->time));
-            if(n->pinged)
-                fprintf(f, " (%d)", n->pinged);
-            if(node_good(n))
-                fprintf(f, " (good)");
-            fprintf(f, "\n");
-            n = n->next;
-        }
+        dump_bucket(f, b);
         b = b->next;
     }
+
+    fprintf(f, "\n");
+
+    b = buckets6;
+    while(b) {
+        dump_bucket(f, b);
+        b = b->next;
+    }
+
     while(sr) {
-        fprintf(f, "\nSearch id ");
+        fprintf(f, "\nSearch%s id ", sr->af == AF_INET6 ? " (IPv6)" : "");
         print_hex(f, sr->id, 20);
         fprintf(f, " age %d%s\n", (int)(now.tv_sec - sr->step_time),
@@ -1322 +1468 @@
                 fprintf(f, " (%d)", n->pinged);
             fprintf(f, "%s%s.\n",
-                   find_node(n->id) ? " (known)" : "",
-                   n->replied ? " (replied)" : "");
+                    find_node(n->id, AF_INET) ? " (known)" : "",
+                    n->replied ? " (replied)" : "");
         }
         sr = sr->next;
     }
 
-    
     while(st) {
         fprintf(f, "\nStorage ");
@@ -1334 +1479 @@
         fprintf(f, " %d/%d nodes:", st->numpeers, st->maxpeers);
         for(i = 0; i < st->numpeers; i++) {
-            char buf[20];
-            inet_ntop(AF_INET, st->peers[i].ip, buf, 20);
+            char buf[100];
+            if(st->peers[i].len == 4) {
+                inet_ntop(AF_INET, st->peers[i].ip, buf, 100);
+            } else if(st->peers[i].len == 16) {
+                buf[0] = '[';
+                inet_ntop(AF_INET6, st->peers[i].ip, buf + 1, 98);
+                strcat(buf, "]");
+            } else {
+                strcpy(buf, "???");
+            }
             fprintf(f, " %s:%u (%ld)",
                     buf, st->peers[i].port,
@@ -1342 +1495 @@
         st = st->next;
     }
-    
+
     fprintf(f, "\n\n");
     fflush(f);
@@ -1348 +1501 @@
 
 int
-dht_init(int s, const unsigned char *id, const unsigned char *v)
+dht_init(int s, int s6, const unsigned char *id, const unsigned char *v)
 {
     int rc;
 
-    if(buckets) {
+    if(dht_socket >= 0 || dht_socket6 >= 0 || buckets || buckets6) {
         errno = EBUSY;
         return -1;
     }
 
-    buckets = calloc(sizeof(struct bucket), 1);
-    if(buckets == NULL)
-        return -1;
-
     searches = NULL;
     numsearches = 0;
 
     storage = NULL;
-
-    rc = fcntl(s, F_GETFL, 0);
-    if(rc < 0)
-        goto fail;
-
-    rc = fcntl(s, F_SETFL, (rc | O_NONBLOCK));
-    if(rc < 0)
-        goto fail;
+    numstorage = 0;
+
+    if(s >= 0) {
+        buckets = calloc(sizeof(struct bucket), 1);
+        if(buckets == NULL)
+            return -1;
+        buckets->af = AF_INET;
+
+        rc = fcntl(s, F_GETFL, 0);
+        if(rc < 0)
+            goto fail;
+
+        rc = fcntl(s, F_SETFL, (rc | O_NONBLOCK));
+        if(rc < 0)
+            goto fail;
+    }
+
+    if(s6 >= 0) {
+        buckets6 = calloc(sizeof(struct bucket), 1);
+        if(buckets6 == NULL)
+            return -1;
+        buckets6->af = AF_INET6;
+
+        rc = fcntl(s6, F_GETFL, 0);
+        if(rc < 0)
+            goto fail;
+
+        rc = fcntl(s6, F_SETFL, (rc | O_NONBLOCK));
+        if(rc < 0)
+            goto fail;
+    }
 
     memcpy(myid, id, 20);
@@ -1386 +1558 @@
 
     mybucket_grow_time = now.tv_sec;
+    mybucket6_grow_time = now.tv_sec;
     confirm_nodes_time = now.tv_sec + random() % 3;
 
@@ -1401 +1574 @@
         goto fail;
 
-    expire_buckets(s);
+    dht_socket = s;
+    dht_socket6 = s6;
+
+    expire_buckets(buckets);
+    expire_buckets(buckets6);
 
     return 1;
@@ -1412 +1589 @@
 
 int
-dht_uninit(int s, int dofree)
-{
+dht_uninit(int dofree)
+{
+    if(dht_socket < 0) {
+        errno = EINVAL;
+        return -1;
+    }
+
     if(!dofree)
         return 1;
@@ -1462 +1644 @@
 }
 
+static int
+neighbourhood_maintenance(int af)
+{
+    unsigned char id[20];
+    struct bucket *b = find_bucket(myid, af);
+    struct bucket *q;
+    struct node *n;
+
+    if(b == NULL)
+        return -1;
+
+    memcpy(id, myid, 20);
+    id[19] = random() & 0xFF;
+    q = b;
+    if(q->next && (q->count == 0 || (random() & 7) == 0))
+        q = b->next;
+    if(q->count == 0 || (random() & 7) == 0) {
+        struct bucket *r;
+        r = previous_bucket(b);
+        if(r && r->count > 0)
+            q = r;
+    }
+
+    if(q) {
+        int want = dht_socket >= 0 && dht_socket6 >= 0 ? (WANT4 | WANT6) : -1;
+        n = random_node(q);
+        if(n) {
+            unsigned char tid[4];
+            debugf("Sending find_node for%s neighborhood maintenance.\n",
+                   af == AF_INET6 ? " IPv6" : "");
+            make_tid(tid, "fn", 0);
+            send_find_node((struct sockaddr*)&n->ss, n->sslen,
+                           tid, 4, id, want,
+                           n->reply_time >= now.tv_sec - 15);
+            pinged(n, q);
+        }
+    }
+    return 1;
+}
+
+static int
+bucket_maintenance(int af)
+{
+    struct bucket *b;
+
+    b = af == AF_INET ? buckets : buckets6;
+
+    while(b) {
+        struct bucket *q;
+        if(b->time < now.tv_sec - 600) {
+            /* This bucket hasn't seen any positive confirmation for a long
+               time.  Pick a random id in this bucket's range, and send
+               a request to a random node. */
+            unsigned char id[20];
+            struct node *n;
+            int rc;
+
+            rc = bucket_random(b, id);
+            if(rc < 0)
+                memcpy(id, b->first, 20);
+
+            q = b;
+            /* If the bucket is empty, we try to fill it from a neighbour.
+               We also sometimes do it gratuitiously to recover from
+               buckets full of broken nodes. */
+            if(q->next && (q->count == 0 || (random() & 7) == 0))
+                q = b->next;
+            if(q->count == 0 || (random() & 7) == 0) {
+                struct bucket *r;
+                r = previous_bucket(b);
+                if(r && r->count > 0)
+                    q = r;
+            }
+
+            if(q) {
+                n = random_node(q);
+                if(n) {
+                    unsigned char tid[4];
+                    int want = -1;
+
+                    if(dht_socket >= 0 && dht_socket6 >= 0) {
+                        struct bucket *otherbucket;
+                        otherbucket =
+                            find_bucket(id, af == AF_INET ? AF_INET6 : AF_INET);
+                        if(otherbucket && otherbucket->count < 8)
+                            /* The corresponding bucket in the other family
+                               is emptyish -- querying both is useful. */
+                            want = WANT4 | WANT6;
+                        else if(random() % 37 == 0)
+                            /* Most of the time, this just adds overhead.
+                               However, it might help stitch back one of
+                               the DHTs after a network collapse, so query
+                               both, but only very occasionally. */
+                            want = WANT4 | WANT6;
+                    }
+
+                    debugf("Sending find_node for%s bucket maintenance.\n",
+                           af == AF_INET6 ? " IPv6" : "");
+                    make_tid(tid, "fn", 0);
+                    send_find_node((struct sockaddr*)&n->ss, n->sslen,
+                                   tid, 4, id, want,
+                                   n->reply_time >= now.tv_sec - 15);
+                    pinged(n, q);
+                    /* In order to avoid sending queries back-to-back,
+                       give up for now and reschedule us soon. */
+                    return 1;
+                }
+            }
+        }
+        b = b->next;
+    }
+    return 0;
+}
+
 int
-dht_periodic(int s, int available, time_t *tosleep,
+dht_periodic(int available, time_t *tosleep,
              dht_callback *callback, void *closure)
 {
+    int i;
+
     gettimeofday(&now, NULL);
 
     if(available) {
-        int rc, i, message;
+        int rc, message;
         unsigned char tid[16], id[20], info_hash[20], target[20];
-        unsigned char buf[1536], nodes[256], token[128];
+        unsigned char buf[1536], nodes[256], nodes6[1024], token[128];
         int tid_len = 16, token_len = 128;
-        int nodes_len = 256;
+        int nodes_len = 256, nodes6_len = 1024;
         unsigned short port;
-        unsigned char values[2048];
-        int values_len = 2048;
-        struct sockaddr_in source;
-        socklen_t source_len = sizeof(struct sockaddr_in);
+        unsigned char values[2048], values6[2048];
+        int values_len = 2048, values6_len = 2048;
+        int want, want4, want6;
+        struct sockaddr_storage source_storage;
+        struct sockaddr *source = (struct sockaddr*)&source_storage;
+        socklen_t sourcelen = sizeof(source_storage);
         unsigned short ttid;
 
-        rc = recvfrom(s, buf, 1536, 0,
-                      (struct sockaddr*)&source, &source_len);
-        if(rc < 0) {
-            if(errno == EAGAIN)
-                goto dontread;
-            else
-                return rc;
-        }
-
-        if(source_len != sizeof(struct sockaddr_in)) {
-            /* Hmm... somebody gave us an IPv6 socket. */
-            errno = EINVAL;
-            return -1;
-        }
+        rc = -1;
+        if(dht_socket >= 0) {
+            rc = recvfrom(dht_socket, buf, 1536, 0, source, &sourcelen);
+            if(rc < 0 && errno != EAGAIN) {
+                    return rc;
+            }
+        }
+        if(dht_socket6 >= 0 && rc < 0) {
+            rc = recvfrom(dht_socket6, buf, 1536, 0,
+                          source, &sourcelen);
+            if(rc < 0 && errno != EAGAIN) {
+                    return rc;
+            }
+        }
+
+        if(rc < 0 || sourcelen > sizeof(struct sockaddr_storage))
+            goto dontread;
 
         for(i = 0; i < DHT_MAX_BLACKLISTED; i++) {
-            if(blacklist[i].sin_family == AF_INET &&
-               blacklist[i].sin_port == source.sin_port &&
-               memcmp(&blacklist[i].sin_addr, &source.sin_addr, 4) == 0) {
+            if(memcmp(&blacklist[i], source, sourcelen) == 0) {
                 debugf("Received packet from blacklisted node.\n");
                 goto dontread;
@@ -1518 +1819 @@
         message = parse_message(buf, rc, tid, &tid_len, id, info_hash,
                                 target, &port, token, &token_len,
-                                nodes, &nodes_len, values, &values_len);
-        if(id_cmp(id, zeroes) == 0) {
-            debugf("Message with no id: ");
+                                nodes, &nodes_len, nodes6, &nodes6_len,
+                                values, &values_len, values6, &values6_len,
+                                &want);
+
+        if(message < 0 || message == ERROR || id_cmp(id, zeroes) == 0) {
+            debugf("Unparseable message: ");
             debug_printable(buf, rc);
             debugf("\n");
@@ -1537 +1841 @@
                 goto dontread;
             }
+        }
+
+        if(want > 0) {
+            want4 = (want & WANT4);
+            want6 = (want & WANT6);
+        } else {
+            want4 = source->sa_family == AF_INET;
+            want6 = source->sa_family == AF_INET6;
         }
 
@@ -1548 +1860 @@
                    time-out all our searches that go through this node.
                    Kill it. */
-                broken_node(s, id, &source);
+                broken_node(id, source, sourcelen);
                 goto dontread;
             }
             if(tid_match(tid, "pn", NULL)) {
                 debugf("Pong!\n");
-                new_node(s, id, &source, 2);
+                new_node(id, source, sourcelen, 2);
             } else if(tid_match(tid, "fn", NULL) ||
                       tid_match(tid, "gp", NULL)) {
@@ -1560 +1872 @@
                 if(tid_match(tid, "gp", &ttid)) {
                     gp = 1;
-                    sr = find_search(ttid);
+                    sr = find_search(ttid, source->sa_family);
                 }
-                debugf("Nodes found (%d)%s!\n", nodes_len / 26,
+                debugf("Nodes found (%d+%d)%s!\n", nodes_len/26, nodes6_len/38,
                        gp ? " for get_peers" : "");
-                if(nodes_len % 26 != 0) {
+                if(nodes_len % 26 != 0 || nodes6_len % 38 != 0) {
                     debugf("Unexpected length for node info!\n");
-                    broken_node(s, id, &source);
+                    broken_node(id, source, sourcelen);
                 } else if(gp && sr == NULL) {
                     debugf("Unknown search!\n");
-                    new_node(s, id, &source, 1);
+                    new_node(id, source, sourcelen, 1);
                 } else {
                     int i;
-                    new_node(s, id, &source, 2);
+                    new_node(id, source, sourcelen, 2);
                     for(i = 0; i < nodes_len / 26; i++) {
                         unsigned char *ni = nodes + i * 26;
@@ -1582 +1894 @@
                         memcpy(&sin.sin_addr, ni + 20, 4);
                         memcpy(&sin.sin_port, ni + 24, 2);
-                        new_node(s, ni, &sin, 0);
-                        if(sr) {
-                            insert_search_node(ni, &sin, sr, 0, NULL, 0);
+                        new_node(ni, (struct sockaddr*)&sin, sizeof(sin), 0);
+                        if(sr && sr->af == AF_INET) {
+                            insert_search_node(ni,
+                                               (struct sockaddr*)&sin,
+                                               sizeof(sin),
+                                               sr, 0, NULL, 0);
+                        }
+                    }
+                    for(i = 0; i < nodes6_len / 38; i++) {
+                        unsigned char *ni = nodes6 + i * 38;
+                        struct sockaddr_in6 sin6;
+                        if(id_cmp(ni, myid) == 0)
+                            continue;
+                        memset(&sin6, 0, sizeof(sin6));
+                        sin6.sin6_family = AF_INET6;
+                        memcpy(&sin6.sin6_addr, ni + 20, 16);
+                        memcpy(&sin6.sin6_port, ni + 36, 2);
+                        new_node(ni, (struct sockaddr*)&sin6, sizeof(sin6), 0);
+                        if(sr && sr->af == AF_INET6) {
+                            insert_search_node(ni,
+                                               (struct sockaddr*)&sin6,
+                                               sizeof(sin6),
+                                               sr, 0, NULL, 0);
                         }
                     }
@@ -1591 +1923 @@
                            requests in flight has decreased.  Let's push
                            another request. */
-                        search_send_get_peers(s, sr, NULL);
+                        search_send_get_peers(sr, NULL);
                 }
                 if(sr) {
-                    insert_search_node(id, &source, sr,
+                    insert_search_node(id, source, sourcelen, sr,
                                        1, token, token_len);
-                    if(values_len > 0) {
-                        debugf("Got values (%d)!\n", values_len / 6);
+                    if(values_len > 0 || values6_len > 0) {
+                        debugf("Got values (%d+%d)!\n",
+                               values_len / 6, values6_len / 18);
                         if(callback) {
-                            (*callback)(closure, DHT_EVENT_VALUES,
-                                        sr->id, (void*)values, values_len);
+                            if(values_len > 0)
+                                (*callback)(closure, DHT_EVENT_VALUES, sr->id,
+                                            (void*)values, values_len);
+
+                            if(values6_len > 0)
+                                (*callback)(closure, DHT_EVENT_VALUES6, sr->id,
+                                            (void*)values6, values6_len);
                         }
                     }
@@ -1607 +1945 @@
                 struct search *sr;
                 debugf("Got reply to announce_peer.\n");
-                sr = find_search(ttid);
+                sr = find_search(ttid, source->sa_family);
                 if(!sr) {
                     debugf("Unknown search!\n");
-                    new_node(s, id, &source, 1);
+                    new_node(id, source, sourcelen, 1);
                 } else {
                     int i;
-                    new_node(s, id, &source, 2);
+                    new_node(id, source, sourcelen, 2);
                     for(i = 0; i < sr->numnodes; i++)
                         if(id_cmp(sr->nodes[i].id, id) == 0) {
@@ -1623 +1961 @@
                         }
                     /* See comment for gp above. */
-                    search_send_get_peers(s, sr, NULL);
+                    search_send_get_peers(sr, NULL);
                 }
             } else {
@@ -1633 +1971 @@
         case PING:
             debugf("Ping (%d)!\n", tid_len);
-            new_node(s, id, &source, 1);
+            new_node(id, source, sourcelen, 1);
             debugf("Sending pong.\n");
-            send_pong(s, (struct sockaddr*)&source, sizeof(source),
-                      tid, tid_len);
+            send_pong(source, sourcelen, tid, tid_len);
             break;
         case FIND_NODE:
             debugf("Find node!\n");
-            new_node(s, id, &source, 1);
-            debugf("Sending closest nodes.\n");
-            send_closest_nodes(s, (struct sockaddr*)&source, sizeof(source),
-                               tid, tid_len, target,
-                               NULL, 0, NULL, 0, NULL, 0);
+            new_node(id, source, sourcelen, 1);
+            debugf("Sending closest nodes (%d).\n", want);
+            send_closest_nodes(source, sourcelen,
+                               tid, tid_len, target, want,
+                               0, NULL, NULL, 0);
             break;
         case GET_PEERS:
             debugf("Get_peers!\n");
-            new_node(s, id, &source, 1);
+            new_node(id, source, sourcelen, 1);
             if(id_cmp(info_hash, zeroes) == 0) {
                 debugf("Eek!  Got get_peers with no info_hash.\n");
+                send_error(source, sourcelen, tid, tid_len,
+                           203, "Get_peers with no info_hash");
                 break;
             } else {
                 struct storage *st = find_storage(info_hash);
                 unsigned char token[TOKEN_SIZE];
-                make_token((unsigned char*)&source.sin_addr,
-                           ntohs(source.sin_port),
-                           0, token);
+                make_token(source, 0, token);
                 if(st && st->numpeers > 0) {
-                    int i0, n0, n1;
-                    i0 = random() % st->numpeers;
-                    /* We treat peers as a circular list, and choose 50
-                       peers starting at i0. */
-                    n0 = MIN(st->numpeers - i0, 50);
-                    n1 = n0 >= 50 ? 0 : MIN(50, i0);
-                    debugf("Sending found peers (%d).\n", n0 + n1);
-                    /* According to the spec, we should not be sending any
-                       nodes in this case.  However, this avoids breaking
-                       searches if data is stored at the wrong place, and
-                       is also what libtorrent and uTorrent do. */
-                    send_closest_nodes(s, (struct sockaddr*)&source,
-                                       sizeof(source), tid, tid_len,
-                                       info_hash,
-                                       st->peers + i0, n0,
-                                       st->peers, n1,
-                                       token, TOKEN_SIZE);
+                     debugf("Sending found%s peers.\n",
+                            source->sa_family == AF_INET6 ? " IPv6" : "");
+                     send_closest_nodes(source, sourcelen,
+                                        tid, tid_len,
+                                        info_hash, want,
+                                        source->sa_family, st,
+                                        token, TOKEN_SIZE);
                 } else {
                     debugf("Sending nodes for get_peers.\n");
-                    send_closest_nodes(s, (struct sockaddr*)&source,
-                                       sizeof(source),
-                                       tid, tid_len, info_hash,
-                                       NULL, 0, NULL, 0,
-                                       token, TOKEN_SIZE);
+                    send_closest_nodes(source, sourcelen,
+                                       tid, tid_len, info_hash, want,
+                                       0, NULL, token, TOKEN_SIZE);
                 }
             }
@@ -1688 +2013 @@
         case ANNOUNCE_PEER:
             debugf("Announce peer!\n");
-            new_node(s, id, &source, 1);
+            new_node(id, source, sourcelen, 1);
             if(id_cmp(info_hash, zeroes) == 0) {
                 debugf("Announce_peer with no info_hash.\n");
+                send_error(source, sourcelen, tid, tid_len,
+                           203, "Announce_peer with no info_hash");
                 break;
             }
-            if(!token_match(token, token_len,
-                            (unsigned char*)&source.sin_addr,
-                            ntohs(source.sin_port))) {
+            if(!token_match(token, token_len, source)) {
                 debugf("Incorrect token for announce_peer.\n");
+                send_error(source, sourcelen, tid, tid_len,
+                           203, "Announce_peer with wrong token");
                 break;
             }
             if(port == 0) {
                 debugf("Announce_peer with forbidden port %d.\n", port);
+                send_error(source, sourcelen, tid, tid_len,
+                           203, "Announce_peer with forbidden port number");
                 break;
             }
-            storage_store(info_hash,
-                          (unsigned char*)&source.sin_addr, port);
+            storage_store(info_hash, source);
+            /* Note that if storage_store failed, we lie to the requestor.
+               This is to prevent them from backtracking, and hence
+               polluting the DHT. */
             debugf("Sending peer announced.\n");
-            send_peer_announced(s, (struct sockaddr*)&source,
-                                sizeof(source), tid, tid_len);
+            send_peer_announced(source, sourcelen, tid, tid_len);
         }
     }
@@ -1716 +2046 @@
 
     if(now.tv_sec >= expire_stuff_time) {
-        expire_buckets(s);
+        expire_buckets(buckets);
+        expire_buckets(buckets6);
         expire_storage();
         expire_searches();
@@ -1726 +2057 @@
         while(sr) {
             if(!sr->done && sr->step_time + 5 <= now.tv_sec) {
-                search_step(s, sr, callback, closure);
+                search_step(sr, callback, closure);
             }
             sr = sr->next;
         }
-                   
+
         search_time = 0;
 
@@ -1745 +2076 @@
 
     if(now.tv_sec >= confirm_nodes_time) {
-        struct bucket *b;
         int soon = 0;
-        b = buckets;
-        while(!soon && b) {
-            struct bucket *q;
-            if(b->time < now.tv_sec - 900) {
-                /* This bucket hasn't seen any activity for a long
-                   time.  Pick a random id in this bucket's range, and
-                   send a request to a random node. */
-                unsigned char id[20];
-                struct node *n;
-                int rc;
-                
-                rc = bucket_random(b, id);
-                if(rc < 0)
-                    memcpy(id, b->first, 20);
-                
-                q = b;
-                /* If the bucket is empty, we try to fill it from
-                   a neighbour.  We also sometimes do it gratuitiously
-                   to recover from buckets full of broken nodes. */
-                if(q->next && (q->count == 0 || random() % 7 == 0))
-                    q = b->next;
-                if(q->count == 0 || random() % 7 == 0) {
-                    struct bucket *r;
-                    r = previous_bucket(b);
-                    if(r && r->count > 0)
-                        q = r;
-                }
-
-                if(q) {
-                    n = random_node(q);
-                    if(n) {
-                        unsigned char tid[4];
-                        debugf("Sending find_node "
-                               "for bucket maintenance.\n");
-                        make_tid(tid, "fn", 0);
-                        send_find_node(s, (struct sockaddr*)&n->sin,
-                                       sizeof(struct sockaddr_in),
-                                       tid, 4, id,
-                                       n->reply_time >= now.tv_sec - 15);
-                        pinged(s, n, q);
-                        /* In order to avoid sending queries back-to-back,
-                           give up for now and reschedule us soon. */
-                        soon = 1;
-                    }
-                }
-            }
-            b = b->next;
-        }
-
-        if(!soon && mybucket_grow_time >= now.tv_sec - 150) {
-            /* We've seen updates to our own bucket recently.  Try to
-               improve our neighbourship. */
-            unsigned char id[20];
-            struct bucket *b, *q;
-            struct node *n;
-            
-            memcpy(id, myid, 20);
-            id[19] = random() % 0xFF;
-            b = find_bucket(myid);
-            q = b;
-            if(q->next && (q->count == 0 || random() % 7 == 0))
-                q = b->next;
-            if(q->count == 0 || random() % 7 == 0) {
-                struct bucket *r;
-                r = previous_bucket(b);
-                if(r && r->count > 0)
-                    q = r;
-            }
-
-            if(q) {
-                n = random_node(q);
-                if(n) {
-                    unsigned char tid[4];
-                    debugf("Sending find_node "
-                           "for neighborhood maintenance.\n");
-                    make_tid(tid, "fn", 0);
-                    send_find_node(s, (struct sockaddr*)&n->sin,
-                                   sizeof(struct sockaddr_in),
-                                   tid, 4, id,
-                                   n->reply_time >= now.tv_sec - 15);
-                    pinged(s, n, q);
-                }
-            }
-            soon = 1;
-        }
-
-        /* In order to maintain all buckets' age within 900 seconds, worst
-           case is roughly 40 seconds, assuming the table is 22 bits deep.
+
+        soon |= bucket_maintenance(AF_INET);
+        soon |= bucket_maintenance(AF_INET6);
+
+        if(!soon) {
+            if(mybucket_grow_time >= now.tv_sec - 150)
+                soon |= neighbourhood_maintenance(AF_INET);
+            if(mybucket6_grow_time >= now.tv_sec - 150)
+                soon |= neighbourhood_maintenance(AF_INET6);
+        }
+
+        /* In order to maintain all buckets' age within 600 seconds, worst
+           case is roughly 27 seconds, assuming the table is 22 bits deep.
            We want to keep a margin for neighborhood maintenance, so keep
-           this within 30 seconds. */
+           this within 25 seconds. */
         if(soon)
-            confirm_nodes_time = now.tv_sec + 10 + random() % 20;
+            confirm_nodes_time = now.tv_sec + 5 + random() % 20;
         else
             confirm_nodes_time = now.tv_sec + 60 + random() % 120;
@@ -1854 +2109 @@
             *tosleep = search_time - now.tv_sec;
     }
-    
-    return find_bucket(myid)->count > 2;
+
+    return 1;
 }
 
 int
-dht_get_nodes(struct sockaddr_in *sins, int num)
-{
-    int i;
+dht_get_nodes(struct sockaddr_in *sin, int *num,
+              struct sockaddr_in6 *sin6, int *num6)
+{
+    int i, j;
     struct bucket *b;
     struct node *n;
@@ -1869 +2125 @@
     /* For restoring to work without discarding too many nodes, the list
        must start with the contents of our bucket. */
-    b = find_bucket(myid);
+    b = find_bucket(myid, AF_INET);
+    if(b == NULL)
+        goto no_ipv4;
+
     n = b->nodes;
-    while(n && i < num) {
+    while(n && i < *num) {
         if(node_good(n)) {
-            sins[i] = n->sin;
+            sin[i] = *(struct sockaddr_in*)&n->ss;
             i++;
         }
@@ -1880 +2139 @@
 
     b = buckets;
-    while(b && i < num) {
+    while(b && i < *num) {
         if(!in_bucket(myid, b)) {
             n = b->nodes;
-            while(n && i < num) {
+            while(n && i < *num) {
                 if(node_good(n)) {
-                    sins[i] = n->sin;
+                    sin[i] = *(struct sockaddr_in*)&n->ss;
                     i++;
                 }
@@ -1893 +2152 @@
         b = b->next;
     }
-    return i;
+
+ no_ipv4:
+
+    j = 0;
+
+    b = find_bucket(myid, AF_INET6);
+    if(b == NULL)
+        goto no_ipv6;
+
+    n = b->nodes;
+    while(n && j < *num6) {
+        if(node_good(n)) {
+            sin6[j] = *(struct sockaddr_in6*)&n->ss;
+            j++;
+        }
+        n = n->next;
+    }
+
+    b = buckets6;
+    while(b && j < *num6) {
+        if(!in_bucket(myid, b)) {
+            n = b->nodes;
+            while(n && j < *num6) {
+                if(node_good(n)) {
+                    sin6[j] = *(struct sockaddr_in6*)&n->ss;
+                    j++;
+                }
+                n = n->next;
+            }
+        }
+        b = b->next;
+    }
+
+ no_ipv6:
+
+    *num = i;
+    *num6 = j;
+    return i + j;
 }
 
 int
-dht_insert_node(int s, const unsigned char *id, struct sockaddr_in *sin)
+dht_insert_node(const unsigned char *id, struct sockaddr *sa, int salen)
 {
     struct node *n;
-    n = new_node(s, id, sin, 0);
+
+    if(sa->sa_family != AF_INET) {
+        errno = EAFNOSUPPORT;
+        return -1;
+    }
+
+    n = new_node(id, (struct sockaddr*)sa, salen, 0);
     return !!n;
 }
 
 int
-dht_ping_node(int s, struct sockaddr_in *sin)
+dht_ping_node(struct sockaddr *sa, int salen)
 {
     unsigned char tid[4];
+
     debugf("Sending ping.\n");
     make_tid(tid, "pn", 0);
-    return send_ping(s, (struct sockaddr*)sin, sizeof(struct sockaddr_in),
-                     tid, 4);
+    return send_ping(sa, salen, tid, 4);
 }
 
@@ -1934 +2236 @@
     }
 
+static int
+dht_send(const void *buf, size_t len, int flags,
+         const struct sockaddr *sa, int salen)
+{
+    int s;
+
+    if(salen == 0)
+        abort();
+
+    if(sa->sa_family == AF_INET)
+        s = dht_socket;
+    else if(sa->sa_family == AF_INET6)
+        s = dht_socket6;
+    else
+        s = -1;
+
+    if(s < 0) {
+        errno = EAFNOSUPPORT;
+        return -1;
+    }
+
+    return sendto(s, buf, len, flags, sa, salen);
+}
+
 int
-send_ping(int s, struct sockaddr *sa, int salen,
+send_ping(struct sockaddr *sa, int salen,
           const unsigned char *tid, int tid_len)
 {
@@ -1947 +2273 @@
     ADD_V(buf, i, 512);
     rc = snprintf(buf + i, 512 - i, "1:y1:qe"); INC(i, rc, 512);
-    return sendto(s, buf, i, 0, sa, salen);
+    return dht_send(buf, i, 0, sa, salen);
 
  fail:
@@ -1955 +2281 @@
 
 int
-send_pong(int s, struct sockaddr *sa, int salen,
+send_pong(struct sockaddr *sa, int salen,
           const unsigned char *tid, int tid_len)
 {
@@ -1966 +2292 @@
     ADD_V(buf, i, 512);
     rc = snprintf(buf + i, 512 - i, "1:y1:re"); INC(i, rc, 512);
-    return sendto(s, buf, i, 0, sa, salen);
+    return dht_send(buf, i, 0, sa, salen);
 
  fail:
@@ -1974 +2300 @@
 
 int
-send_find_node(int s, struct sockaddr *sa, int salen,
+send_find_node(struct sockaddr *sa, int salen,
                const unsigned char *tid, int tid_len,
-               const unsigned char *target, int confirm)
+               const unsigned char *target, int want, int confirm)
 {
     char buf[512];
@@ -1984 +2310 @@
     rc = snprintf(buf + i, 512 - i, "6:target20:"); INC(i, rc, 512);
     COPY(buf, i, target, 20, 512);
+    if(want > 0) {
+        rc = snprintf(buf + i, 512 - i, "4:wantl%s%se",
+                      (want & WANT4) ? "2:n4" : "",
+                      (want & WANT6) ? "2:n6" : "");
+        INC(i, rc, 512);
+    }
     rc = snprintf(buf + i, 512 - i, "e1:q9:find_node1:t%d:", tid_len);
     INC(i, rc, 512);
@@ -1989 +2321 @@
     ADD_V(buf, i, 512);
     rc = snprintf(buf + i, 512 - i, "1:y1:qe"); INC(i, rc, 512);
-    return sendto(s, buf, i, confirm ? MSG_CONFIRM : 0, sa, salen);
+    return dht_send(buf, i, confirm ? MSG_CONFIRM : 0, sa, salen);
 
  fail:
@@ -1997 +2329 @@
 
 int
-send_nodes_peers(int s, struct sockaddr *sa, int salen,
+send_nodes_peers(struct sockaddr *sa, int salen,
                  const unsigned char *tid, int tid_len,
                  const unsigned char *nodes, int nodes_len,
-                 struct peer *peers1, int numpeers1,
-                 struct peer *peers2, int numpeers2,
+                 const unsigned char *nodes6, int nodes6_len,
+                 int af, struct storage *st,
                  const unsigned char *token, int token_len)
 {
     char buf[2048];
-    int i = 0, rc, j;
+    int i = 0, rc, j0, j, k, len;
+
     rc = snprintf(buf + i, 2048 - i, "d1:rd2:id20:"); INC(i, rc, 2048);
     COPY(buf, i, myid, 20, 2048);
@@ -2018 +2351 @@
         COPY(buf, i, nodes, nodes_len, 2048);
     }
-    for(j = 0; j < numpeers1; j++) {
-        unsigned short swapped = htons(peers1[j].port);
-        rc = snprintf(buf + i, 2048 - i, "6:"); INC(i, rc, 2048);
-        COPY(buf, i, peers1[j].ip, 4, 2048);
-        COPY(buf, i, &swapped, 2, 2048);
-    }
-    for(j = 0; j < numpeers2; j++) {
-        unsigned short swapped = htons(peers2[j].port);
-        rc = snprintf(buf + i, 2048 - i, "6:"); INC(i, rc, 2048);
-        COPY(buf, i, peers2[j].ip, 4, 2048);
-        COPY(buf, i, &swapped, 2, 2048);
-    }
+    if(nodes6_len > 0) {
+         rc = snprintf(buf + i, 2048 - i, "6:nodes6%d:", nodes6_len);
+         INC(i, rc, 2048);
+         COPY(buf, i, nodes6, nodes6_len, 2048);
+    }
+
+    if(st && st->numpeers > 0) {
+        /* We treat the storage as a circular list, and serve a randomly
+           chosen slice.  In order to make sure we fit within 1024 octets,
+           we limit ourselves to 50 peers. */
+
+        len = af == AF_INET ? 4 : 16;
+        j0 = random() % st->numpeers;
+        j = j0;
+        k = 0;
+
+        rc = snprintf(buf + i, 2048 - i, "6:valuesl"); INC(i, rc, 2048);
+        do {
+            if(st->peers[j].len == len) {
+                unsigned short swapped;
+                swapped = htons(st->peers[j].port);
+                rc = snprintf(buf + i, 2048 - i, "%d:", len + 2);
+                INC(i, rc, 2048);
+                COPY(buf, i, st->peers[j].ip, len, 2048);
+                COPY(buf, i, &swapped, 2, 2048);
+                k++;
+            }
+            j = (j + 1) % st->numpeers;
+        } while(j != j0 && k < 50);
+        rc = snprintf(buf + i, 2048 - i, "e"); INC(i, rc, 2048);
+    }
+
     rc = snprintf(buf + i, 2048 - i, "e1:t%d:", tid_len); INC(i, rc, 2048);
     COPY(buf, i, tid, tid_len, 2048);
@@ -2035 +2388 @@
     rc = snprintf(buf + i, 2048 - i, "1:y1:re"); INC(i, rc, 2048);
 
-    return sendto(s, buf, i, 0, sa, salen);
+    return dht_send(buf, i, 0, sa, salen);
 
  fail:
@@ -2046 +2399 @@
                     const unsigned char *id, struct node *n)
 {
-    int i;
+    int i, size;
+
+    if(n->ss.ss_family == AF_INET)
+        size = 26;
+    else if(n->ss.ss_family == AF_INET6)
+        size = 38;
+    else
+        abort();
+
     for(i = 0; i< numnodes; i++) {
-        if(id_cmp(nodes + 26 * i, id) == 0)
+        if(id_cmp(n->id, nodes + size * i) == 0)
             return numnodes;
-        if(xorcmp(n->id, nodes + 26 * i, id) < 0)
+        if(xorcmp(n->id, nodes + size * i, id) < 0)
             break;
     }
@@ -2061 +2422 @@
 
     if(i < numnodes - 1)
-        memmove(nodes + 26 * (i + 1), nodes + 26 * i, 26 * (numnodes - i - 1));
-
-    memcpy(nodes + 26 * i, n->id, 20);
-    memcpy(nodes + 26 * i + 20, &n->sin.sin_addr, 4);
-    memcpy(nodes + 26 * i + 24, &n->sin.sin_port, 2);
+        memmove(nodes + size * (i + 1), nodes + size * i,
+                size * (numnodes - i - 1));
+
+    if(n->ss.ss_family == AF_INET) {
+        struct sockaddr_in *sin = (struct sockaddr_in*)&n->ss;
+        memcpy(nodes + size * i, n->id, 20);
+        memcpy(nodes + size * i + 20, &sin->sin_addr, 4);
+        memcpy(nodes + size * i + 24, &sin->sin_port, 2);
+    } else if(n->ss.ss_family == AF_INET6) {
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&n->ss;
+        memcpy(nodes + size * i, n->id, 20);
+        memcpy(nodes + size * i + 20, &sin6->sin6_addr, 16);
+        memcpy(nodes + size * i + 36, &sin6->sin6_port, 2);
+    } else {
+        abort();
+    }
 
     return numnodes;
@@ -2084 +2456 @@
 
 int
-send_closest_nodes(int s, struct sockaddr *sa, int salen,
+send_closest_nodes(struct sockaddr *sa, int salen,
                    const unsigned char *tid, int tid_len,
-                   const unsigned char *id,
-                   struct peer *peers1, int numpeers1,
-                   struct peer *peers2, int numpeers2,
+                   const unsigned char *id, int want,
+                   int af, struct storage *st,
                    const unsigned char *token, int token_len)
 {
     unsigned char nodes[8 * 26];
-    int numnodes = 0;
+    unsigned char nodes6[8 * 38];
+    int numnodes = 0, numnodes6 = 0;
     struct bucket *b;
 
-    b = find_bucket(id);
-    numnodes = buffer_closest_nodes(nodes, numnodes, id, b);
-    if(b->next)
-        numnodes = buffer_closest_nodes(nodes, numnodes, id, b->next);
-    b = previous_bucket(b);
-    if(b)
-        numnodes = buffer_closest_nodes(nodes, numnodes, id, b);
-
-    return send_nodes_peers(s, sa, salen, tid, tid_len,
+    if(want < 0)
+        want = sa->sa_family == AF_INET ? WANT4 : WANT6;
+
+    if((want & WANT4)) {
+        b = find_bucket(id, AF_INET);
+        if(b) {
+            numnodes = buffer_closest_nodes(nodes, numnodes, id, b);
+            if(b->next)
+                numnodes = buffer_closest_nodes(nodes, numnodes, id, b->next);
+            b = previous_bucket(b);
+            if(b)
+                numnodes = buffer_closest_nodes(nodes, numnodes, id, b);
+        }
+    }
+
+    if((want & WANT6)) {
+        b = find_bucket(id, AF_INET6);
+        if(b) {
+            numnodes6 = buffer_closest_nodes(nodes6, numnodes6, id, b);
+            if(b->next)
+                numnodes6 =
+                    buffer_closest_nodes(nodes6, numnodes6, id, b->next);
+            b = previous_bucket(b);
+            if(b)
+                numnodes6 = buffer_closest_nodes(nodes6, numnodes6, id, b);
+        }
+    }
+    debugf("  (%d+%d nodes.)\n", numnodes, numnodes6);
+
+    return send_nodes_peers(sa, salen, tid, tid_len,
                             nodes, numnodes * 26,
-                            peers1, numpeers1, peers2, numpeers2,
-                            token, token_len);
+                            nodes6, numnodes6 * 38,
+                            af, st, token, token_len);
 }
 
 int
-send_get_peers(int s, struct sockaddr *sa, int salen,
+send_get_peers(struct sockaddr *sa, int salen,
                unsigned char *tid, int tid_len, unsigned char *infohash,
-               int confirm)
+               int want, int confirm)
 {
     char buf[512];
@@ -2121 +2514 @@
     rc = snprintf(buf + i, 512 - i, "9:info_hash20:"); INC(i, rc, 512);
     COPY(buf, i, infohash, 20, 512);
+    if(want > 0) {
+        rc = snprintf(buf + i, 512 - i, "4:wantl%s%se",
+                      (want & WANT4) ? "2:n4" : "",
+                      (want & WANT6) ? "2:n6" : "");
+        INC(i, rc, 512);
+    }
     rc = snprintf(buf + i, 512 - i, "e1:q9:get_peers1:t%d:", tid_len);
     INC(i, rc, 512);
@@ -2126 +2525 @@
     ADD_V(buf, i, 512);
     rc = snprintf(buf + i, 512 - i, "1:y1:qe"); INC(i, rc, 512);
-    return sendto(s, buf, i, confirm ? MSG_CONFIRM : 0, sa, salen);
+    return dht_send(buf, i, confirm ? MSG_CONFIRM : 0, sa, salen);
 
  fail:
@@ -2134 +2533 @@
 
 int
-send_announce_peer(int s, struct sockaddr *sa, int salen,
+send_announce_peer(struct sockaddr *sa, int salen,
                    unsigned char *tid, int tid_len,
                    unsigned char *infohash, unsigned short port,
@@ -2156 +2555 @@
     rc = snprintf(buf + i, 512 - i, "1:y1:qe"); INC(i, rc, 512);
 
-    return sendto(s, buf, i, confirm ? 0 : MSG_CONFIRM, sa, salen);
+    return dht_send(buf, i, confirm ? 0 : MSG_CONFIRM, sa, salen);
 
  fail:
@@ -2163 +2562 @@
 }
 
-int
-send_peer_announced(int s, struct sockaddr *sa, int salen,
+static int
+send_peer_announced(struct sockaddr *sa, int salen,
                     unsigned char *tid, int tid_len)
 {
@@ -2175 +2574 @@
     INC(i, rc, 512);
     COPY(buf, i, tid, tid_len, 512);
-    ADD_V(buf, i, 2048);
-    rc = snprintf(buf + i, 2048 - i, "1:y1:re"); INC(i, rc, 2048);
-    return sendto(s, buf, i, 0, sa, salen);
+    ADD_V(buf, i, 512);
+    rc = snprintf(buf + i, 512 - i, "1:y1:re"); INC(i, rc, 512);
+    return dht_send(buf, i, 0, sa, salen);
+
+ fail:
+    errno = ENOSPC;
+    return -1;
+}
+
+static int
+send_error(struct sockaddr *sa, int salen,
+           unsigned char *tid, int tid_len,
+           int code, const char *message)
+{
+    char buf[512];
+    int i = 0, rc;
+
+    rc = snprintf(buf + i, 512 - i, "d1:eli%de%d:",
+                  code, (int)strlen(message));
+    INC(i, rc, 512);
+    COPY(buf, i, message, (int)strlen(message), 512);
+    rc = snprintf(buf + i, 512 - i, "e1:t%d:", tid_len); INC(i, rc, 512);
+    COPY(buf, i, tid, tid_len, 512);
+    ADD_V(buf, i, 512);
+    rc = snprintf(buf + i, 512 - i, "1:y1:ee"); INC(i, rc, 512);
+    return dht_send(buf, i, 0, sa, salen);
 
  fail:
@@ -2217 +2639 @@
               unsigned char *token_return, int *token_len,
               unsigned char *nodes_return, int *nodes_len,
-              const unsigned char *values_return, int *values_len)
+              unsigned char *nodes6_return, int *nodes6_len,
+              unsigned char *values_return, int *values_len,
+              unsigned char *values6_return, int *values6_len,
+              int *want_return)
 {
     const unsigned char *p;
@@ -2293 +2718 @@
             *token_len = 0;
     }
-        
-    if(nodes_return) {
+
+    if(nodes_len) {
         p = memmem(buf, buflen, "5:nodes", 7);
         if(p) {
@@ -2310 +2735 @@
     }
 
-    if(values_return) {
+    if(nodes6_len) {
+        p = memmem(buf, buflen, "6:nodes6", 8);
+        if(p) {
+            long l;
+            char *q;
+            l = strtol((char*)p + 8, &q, 10);
+            if(q && *q == ':' && l > 0 && l < *nodes6_len) {
+                CHECK(q + 1, l);
+                memcpy(nodes6_return, q + 1, l);
+                *nodes6_len = l;
+            } else
+                *nodes6_len = 0;
+        } else
+            *nodes6_len = 0;
+    }
+
+    if(values_len || values6_len) {
         p = memmem(buf, buflen, "6:valuesl", 9);
         if(p) {
             int i = p - buf + 9;
-            int j = 0;
+            int j = 0, j6 = 0;
             while(1) {
                 long l;
@@ -2321 +2762 @@
                 if(q && *q == ':' && l > 0) {
                     CHECK(q + 1, l);
-                    if(j + l > *values_len)
-                        break;
-                    i = q + 1 + l - (char*)buf;
-                    /* BEP 32 allows heterogeneous values -- ignore IPv6 */
-                    if(l != 6) {
-                        debugf("Received weird value -- %d bytes.\n",
-                               (int)l);
-                        continue;
+                    if(l == 6) {
+                        if(j + l > *values_len)
+                            continue;
+                        i = q + 1 + l - (char*)buf;
+                        memcpy((char*)values_return + j, q + 1, l);
+                        j += l;
+                    } else if(l == 18) {
+                        if(j6 + l > *values6_len)
+                            continue;
+                        i = q + 1 + l - (char*)buf;
+                        memcpy((char*)values6_return + j6, q + 1, l);
+                        j6 += l;
+                    } else {
+                        debugf("Received weird value -- %d bytes.\n", (int)l);
+                        i = q + 1 + l - (char*)buf;
                     }
-                    memcpy((char*)values_return + j, q + 1, l);
-                    j += l;
                 } else {
                     break;
@@ -2338 +2784 @@
             if(i >= buflen || buf[i] != 'e')
                 debugf("eek... unexpected end for values.\n");
-            *values_len = j;
+            if(values_len)
+                *values_len = j;
+            if(values6_len)
+                *values6_len = j6;
         } else {
             *values_len = 0;
+            *values6_len = 0;
+        }
+    }
+
+    if(want_return) {
+        p = memmem(buf, buflen, "4:wantl", 7);
+        if(p) {
+            int i = p - buf + 7;
+            *want_return = 0;
+            while(buf[i] > '0' && buf[i] <= '9' && buf[i + 1] == ':' &&
+                  i + 2 + buf[i] - '0' < buflen) {
+                CHECK(buf + i + 2, buf[i] - '0');
+                if(buf[i] == '2' && memcmp(buf + i + 2, "n4", 2) == 0)
+                    *want_return |= WANT4;
+                else if(buf[i] == '2' && memcmp(buf + i + 2, "n6", 2) == 0)
+                    *want_return |= WANT6;
+                else
+                    debugf("eek... unexpected want flag (%c)\n", buf[i]);
+                i += 2 + buf[i] - '0';
+            }
+            if(i >= buflen || buf[i] != 'e')
+                debugf("eek... unexpected end for want.\n");
+        } else {
+            *want_return = -1;
         }
     }
 
 #undef CHECK
-                
+
     if(memmem(buf, buflen, "1:y1:r", 6))
         return REPLY;
+    if(memmem(buf, buflen, "1:y1:e", 6))
+        return ERROR;
     if(!memmem(buf, buflen, "1:y1:q", 6))
         return -1;

trunk/third-party/dht/dht.h

@@ -28 +28 @@
 #define DHT_EVENT_NONE 0
 #define DHT_EVENT_VALUES 1
-#define DHT_EVENT_SEARCH_DONE 2
+#define DHT_EVENT_VALUES6 2
+#define DHT_EVENT_SEARCH_DONE 3
+#define DHT_EVENT_SEARCH_DONE6 4
 
 extern FILE *dht_debug;
 
-int dht_init(int s, const unsigned char *id, const unsigned char *v);
-int dht_insert_node(int s, const unsigned char *id, struct sockaddr_in *sin);
-int dht_ping_node(int s, struct sockaddr_in *sin);
-int dht_periodic(int s, int available, time_t *tosleep,
+int dht_init(int s, int s6, const unsigned char *id, const unsigned char *v);
+int dht_insert_node(const unsigned char *id, struct sockaddr *sa, int salen);
+int dht_ping_node(struct sockaddr *sa, int salen);
+int dht_periodic(int available, time_t *tosleep,
                  dht_callback *callback, void *closure);
-int dht_search(int s, const unsigned char *id, int port,
+int dht_search(const unsigned char *id, int port, int af,
                dht_callback *callback, void *closure);
-int dht_nodes(int *good_return, int *dubious_return, int *cached_return,
+int dht_nodes(int af,
+              int *good_return, int *dubious_return, int *cached_return,
               int *incoming_return);
 void dht_dump_tables(FILE *f);
-int dht_get_nodes(struct sockaddr_in *sins, int num);
-int dht_uninit(int s, int dofree);
+int dht_get_nodes(struct sockaddr_in *sin, int *num,
+                  struct sockaddr_in6 *sin6, int *num6);
+int dht_uninit(int dofree);
 
 /* This must be provided by the user. */