Solution to Mobile IPv6 routing

This article outlines an algorithm for solving routing on IPv6 mobile IP networks: treating the internet as a 48-dimensional hypercube, and using zeroconf to find your local neighbours.

Could someone _please_ double-check this: these are my notes, and i would like to know if this is correct. i think it even works with broadcast, with a bit of tweaking.

basically, you use divide-and-conquer, by having routing on EVERY machine, not just gateways.

using zeroconf, you find out who is in your area - they get allocated unique IPv6 addresses (hooray). this is really important (the unique bit).

you then have 48 bit-buckets (32 for IPv4), and for every bit which matches in YOUR ip address, you drop them into that bit bucket:

        buckets = {}
        for i in range(48):
                buckets[i] = []

 
         for (other_ip, interface) in zeroconf_neighbourhood():
                xor_addresses = my_ip ^ other_ip
                for i in range(48):
                        if xor_addresses & (1<

 
 then - routing is _incredibly_ simple:

 
 
        if packet_ip == my_ip:
                return deliver_it(packet, my_interface)

 
         xor_addresses = my_ip ^ packet_ip
        bits_match = 0
        best_route = None
        for i in range(48):
                for (route_ip, route_interface) in buckets[i]:
                        count_bits = count_bits(packet_ip ^ route_ip)
                        if count_bits > bits_match:
                                best_route= (route_ip, route_interface)

 
         if best_route:
                route_ip, route_interface = best_route
                return deliver_it(packet, interface)

 
         return None # drop the packet.


 
 sending to the nearest destination is automatic.  no hop-count needed.
you always pass the packet to a location which has less bit-difference
from you.

 
 this is the n-cube algorithm.

 
 comments, please.