undns 0.4.0f → 0.4.0h

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a0427aa879826016674018308678c320e467f9c
-  data.tar.gz: e8bcfd6dd560ae8a0b7a34528a6e7d387e9a7598
+  metadata.gz: 0d4a8579ec7c425c5f34a5fd44afbcc9938c253b
+  data.tar.gz: 5587a5805eafb34b46c1060392e3850612df9980
 SHA512:
-  metadata.gz: c0b86b92710a6bd58e686b2398dc4834ca17c38b8df40c990126354b9472c170c764aa42c14b561eae0a750b4c520edb31b6fee2fa98f7e24c89e54b4faabaf9
-  data.tar.gz: df932b28a3a90474baadc01ce6e15cb120173ea823be22ea5fade45dc5c9a4ae6f7e1e18df7cbf2be61a1465c028c0a192d175c64c6c56e10da3f6c867932816
+  metadata.gz: 8644cba6f0761564bdb4435e44e0881bd331e541d49be7856593e59a528cf46e14b3eb4dff94f5c4f8903e1824a3afafcb6fb69eaa0044ac9be565f118039bc9
+  data.tar.gz: 40f2db5a09a506e73e584a247f1615038903c2bec73dc88b8c64a4bd4d81652e14ad1037c7922de71bf75b29d83bbf2d1bdeae0ea698f117a7f7ea7955099f32

data/bin/undns_origin

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'undns'
+
+if ARGV.empty? then
+  puts "usage: '#{$0} address' where address is a v4 or v6 address"
+end
+
+puts Undns.origin_for_address_str(ARGV[0])

data/bin/update_origins6_dat

@@ -0,0 +1,127 @@
+#! /usr/bin/ruby
+
+require 'undns'
+
+ZebraDumpParser = Undns::Path::origins6_dat.gsub(/origins6.dat/, 'zebra-dump-parser.pl')
+unless test(?e, ZebraDumpParser) 
+  $stderr.puts "Expected to find #{ZebraDumpParser}, which is missing"
+  exit 1
+end
+
+
+# TODO: check that bunzip2 exists
+
+puts Undns::Path::origins6_dat
+if test(?s,Undns::Path::origins6_dat) then
+  age = Time.now - File.stat(Undns::Path::origins6_dat).mtime 
+  size = File.stat(Undns::Path::origins6_dat).size 
+  if age > 14000  || size < 30000 then
+    puts "will *update* #{Undns::Path::origins6_dat}"
+  else
+    puts "will *not* update #{Undns::Path::origins6_dat}, which is only #{(age / 3600).to_i} hours old; aborting."
+    puts "remove #{Undns::Path::origins6_dat} if you really want to update."
+    exit
+  end
+else
+  puts "will *create* #{Undns::Path::origins6_dat}"
+end
+
+# early open, in case lack permissions
+o = File.open("%s-new" % Undns::Path::origins6_dat, "w") 
+
+URL = 'http://archive.routeviews.org/route-views6/bgpdata/%4d.%02d/RIBS/rib.%4d%02d%02d.0000.bz2' % [ 
+  Time.now.year, Time.now.month,
+  Time.now.year, Time.now.month, Time.now.day ]
+
+def canonicalize(network)
+  octets = Array.new(4)
+  octets[0], octets[1], octets[2], octets[3], bits = network.split(/[\/\.]/)
+  if bits then
+    # octets = prefix.split('.')
+    bits_that_should_be_zero = (1 << (32-bits.to_i)) - 1
+    if (octets[3].to_i & bits_that_should_be_zero) != 0 then
+      $stderr.puts "bad prefix #{network}"
+    end
+    return network # not as written by ratul; he ensured that there were no stray bits.
+  else
+    # this part as written by Ratul, though not classful, which surprises me.
+    # octets = prefix.split('.')
+    if octets[3] != '0' then
+      if octets[2] != '0' then
+        if octets[1] != '0' then
+          bits = 8
+        else
+          bits = 16
+        end
+      else
+        bits = 24
+      end
+    else
+      $stderr.puts "unexpected."
+    end
+    return "%s/%d" % [ network, bits ]
+  end
+end
+
+# a difficult line, guess which.
+#*  213.200.192.0/18 12.0.1.63                0      0      0 7018 3320 3303 44038 i
+#*  213.200.196.144/29164.128.32.11            0      0      0 3303 ?
+#*  213.200.197.80/30164.128.32.11            0      0      0 3303 ?
+#*  213.200.208.16/29164.128.32.11            0      0      0 3303 ?
+
+# IO.popen('curl %s | bunzip2' % URL).each { |ln|
+started = false
+networkPos = nil
+pathPos = nil
+lastline = nil
+origins = Hash.new { |h,k| h[k] = Array.new }
+i = 0
+
+Kernel::system("mkdir -p /tmp/undns-update-origins-dat")
+IntermediatePath = "/tmp/undns-update-origins-dat/rib.bz2"
+if(!test(?s, IntermediatePath)) then
+  $stderr.puts "downloading #{URL} to #{IntermediatePath}"
+  unless Kernel::system("curl #{URL} -o #{IntermediatePath}") then
+    $stderr.puts "download failed\n"
+    exit 1
+  end
+else
+  age = Time.now - File.stat(IntermediatePath).mtime 
+  size = File.stat(IntermediatePath).size 
+  if age > 3000 || size < 30000000 then    # size check in case was incomplete once.
+    $stderr.puts "re-downloading #{URL} to #{IntermediatePath}"
+    unless Kernel::system("curl #{URL} -o #{IntermediatePath}") then
+      $stderr.puts "download failed\n"
+      exit 1
+    end
+  else
+    $stderr.puts "relying on cached #{IntermediatePath} for #{URL}; remove it if bad."
+  end
+end
+$stderr.puts "converting #{IntermediatePath} via zebra-dump-parser.pl"
+
+last_ln = nil
+last_prefix = nil
+IO.popen("bunzip2 -c #{IntermediatePath} | perl #{ZebraDumpParser}", "r").each { |ln|
+  prefix, origin = ln.split(' ')
+  if last_prefix then
+    if last_prefix != prefix then
+      o.puts last_ln
+    else
+      last_ln = last_ln.chomp + ',' + origin
+    end
+  end
+  last_ln = ln
+  last_prefix = prefix
+}
+
+o.close
+$stderr.puts "%d bytes" % [ File::stat("%s-new" % Undns::Path::origins6_dat).size ]
+
+if(test(?e, Undns::Path::origins6_dat)) then
+  Kernel.system('diff -urb %s %s-new > %s.diff' % [ Undns::Path::origins6_dat, Undns::Path::origins6_dat, Undns::Path::origins6_dat ])
+  Kernel.system('mv %s %s-old' % [ Undns::Path::origins6_dat, Undns::Path::origins6_dat ])
+end
+Kernel.system('mv %s-new %s' % [ Undns::Path::origins6_dat, Undns::Path::origins6_dat ])
+
+

data/ext/undns/earth.c

@@ -11,6 +11,7 @@
 #ifdef DEPRECATED_GNU_REGEX
 #include <gnuregex.h>
 #else
+#include <sys/types.h>
 #include <regex.h>
 #endif
 #else
@@ -50,6 +51,18 @@ void init_earth(const char *LocationTableFilename) {
   FILE *ltfp = fopen(LocationTableFilename, "r");
   char regex[] = "^\"([^\"]+)\" *(-?[0-9\\.]+) *(-?[0-9\\.]+)"; 
   char linebuf[255];
+#ifdef DEPRECATED_GNU_REGEX
+  struct re_pattern_buffer rpbuf;
+  struct re_registers regs;
+#else
+  /* typical */
+#ifndef REGS_LEN
+#define REGS_LEN 10
+#endif
+  regex_t rpbuf;
+  regmatch_t regs[REGS_LEN];
+#endif
+
   if(ltfp == NULL) {
     printf("Unable to load %s as location table\n", 
            LocationTableFilename);
@@ -57,8 +70,6 @@ void init_earth(const char *LocationTableFilename) {
   }
 #ifdef DEPRECATED_GNU_REGEX
   re_syntax_options = RE_SYNTAX_POSIX_EGREP;
-  struct re_registers regs;
-  struct re_pattern_buffer rpbuf;
   memset(&rpbuf, 0, sizeof(struct re_pattern_buffer));
   {
     const char *errstr = 
@@ -71,11 +82,6 @@ void init_earth(const char *LocationTableFilename) {
   }
   regs.num_regs = REGS_UNALLOCATED;
 #else
-  regex_t rpbuf;
-#ifndef REGS_LEN
-#define REGS_LEN 10
-#endif
-  regmatch_t regs[REGS_LEN];
   {
     int error = regcomp(&rpbuf, regex, REG_EXTENDED);
     if(error) {
@@ -114,16 +120,21 @@ void init_earth(const char *LocationTableFilename) {
     }
 #else
     // printf("-- %s", linebuf);
-    memset(regs, 0, sizeof(regs));
+    // memset(regs, 0, sizeof(regs));
     int reg_ret = regexec(&rpbuf, linebuf, REGS_LEN-1, regs, 0);
     if(reg_ret == REG_NOMATCH) {
       fprintf(stderr, "init_earth: Couldn't parse line: %s", linebuf);
       free(newlte);
       continue;
+#ifdef REG_ILLSEQ
+      /* stanza only here while debugging the sys/types
+         needed before regex issue */
+      /* but why remove it. */
     } else if(reg_ret == REG_ILLSEQ) {
       fprintf(stderr, "init_earth: Illegal character sequence in (skipped) line: %s", linebuf);
       free(newlte);
       continue;
+#endif
     } else if(reg_ret != 0) {
       fprintf(stderr, "init_earth: unexpected nonzero return from regexec: %d\n", reg_ret);
       exit(1);

data/ext/undns/hashtable.c

@@ -89,8 +89,6 @@ hashtable ht_new(unsigned int size,
   ht->free_keyval = free_keyval;
 #ifdef _REENTRANT
   (void)pthread_mutexattr_init(&attrib);
-  // (void)pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE_NP);
-  // (void)pthread_mutexattr_setkind(&attrib, PTHREAD_MUTEX_RECURSIVE_NP);
 #ifdef PTHREAD_MUTEX_RECURSIVE_NP
   /* linux only */
   (void)pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE_NP);
@@ -318,9 +316,9 @@ boolean ht_iterate_pairs(hashtable ht, unsigned int nThreads, unsigned int chunk
 boolean ht_iterate_pairs(hashtable ht, unsigned int nThreads, unsigned int chunkSize,
                    boolean (*callback)(const void *keyval, const void *keyval2)) {
   unsigned int threadId;
+  ht_iterate_pairs_pthread_struct * data;
   /* probably should make nThreads be 1 or abort if not 1.... */
   if(ht == NULL) return FALSE;
-  ht_iterate_pairs_pthread_struct * data;
   assert(nThreads<100);
   assert(chunkSize < ht->table_size);
 

data/ext/undns/originAS.c

@@ -13,16 +13,20 @@
 #include "nscommon.h"
 #include "originAS.h"
 #include "radix.h"
+#include "radix6.h"
 #include "exception.h"
 #include "ruleset.h" /* fopen_path_r */
 
 static struct patricia_table *origins;
+static struct patricia6_table *origins6;
+
 static in_addr_t addr_from_octets(unsigned int o1, unsigned int o2, 
                         unsigned int o3, unsigned int o4){
   return (htonl((o1<<24) + (o2<<16) + (o3<<8) + o4));
 }
 
 const char *Origins_In_Use;
+const char *Origins6_In_Use;
 
 void 
 origins_init(const char *origins_dat) {
@@ -54,6 +58,41 @@ origins_init(const char *origins_dat) {
   }
   fclose(in);
 }
+void 
+origins6_init(const char *origins6_dat) {
+  char linebuf[90];
+  // FILE *in = popen("./show_origins.pl | sort -u", "r");
+  const char *filename = (origins6_dat != NULL) ? origins6_dat : "origins6.dat";
+  FILE *in = fopen_path_r(filename, &Origins_In_Use);
+  if(in == NULL) {
+    char buf[255];
+    sprintf(buf, "can't open origins6.dat(%s): %s", filename, strerror(errno));
+    throw_void(buf); 
+  }
+  origins6 = patricia6_new();
+  while(!feof(in) && fgets(linebuf, sizeof(linebuf), in) != NULL) {
+    char addrbuf[61]; 
+    unsigned int len, as;
+    if(sscanf(linebuf, "%60[a-f0-9A-F:]/%u %u",
+              addrbuf, &len, &as) == 3) {
+      struct in6_addr addr;
+      inet_pton(AF_INET6, addrbuf, &addr);
+      // fprintf(stderr, "inserting %s/%d\n", addrbuf, len);
+      patricia6_insert(origins6, addr, len, (void *)as);
+    } else if(sscanf(linebuf, "%60[a-f0-9A-F:]/%u {%u",
+              addrbuf, &len, &as) == 6) {
+      /* pick the first one from a multiple-origins line */
+      struct in6_addr addr;
+      inet_pton(AF_INET6, addrbuf, &addr);
+      patricia6_insert(origins6, addr, len, (void *)as);
+    } else {
+      /* this has never forced me to actually address this issue, it just clouds
+         up the output file. */ 
+      printf("originAS: recoverable error parsing '%s' in origins.dat\n", linebuf);
+    }
+  }
+  fclose(in);
+}
 
 unsigned short origin_for_address(in_addr_t a) {
   if ( origins == NULL ) {
@@ -67,10 +106,29 @@ unsigned short origin_for_address(in_addr_t a) {
   }
 }
 
+unsigned short origin6_for_address(struct in6_addr a) {
+  if ( origins6 == NULL ) {
+    origins6_init(NULL);
+  }
+  if ( origins6 != NULL ) {
+    return((unsigned short)(unsigned int)patricia6_lookup(origins6, a));
+  } else {
+    fprintf(stderr, "Origins6 failed to initialize\n"); /* shouldn't get here. */
+    return(0);
+  }
+}
+
 unsigned short origin_for_address_str(const char *addrstring) {
   struct in_addr a;
+  struct in6_addr a6;
+
+  if(addrstring == NULL) return 0;
   if(inet_aton(addrstring, &a)) {
+    // fprintf(stderr, "parsing %s as v4\n", addrstring);
     return(origin_for_address(a.s_addr));
+  } else if(inet_pton(AF_INET6, addrstring, &a6)) {
+    // fprintf(stderr, "parsing %s as v6\n", addrstring);
+    return(origin6_for_address(a6));
   }
   return 0;
 }
@@ -101,7 +159,7 @@ origins_regression_test(const char *origins_dat) {
   FILE *in;
   char linebuf[60];
   origins_init(origins_dat);
-  in = fopen_path_r(origins_dat, &Origins_In_Use);
+  in = fopen_path_r(origins_dat, NULL);
   while(!feof(in) && fgets(linebuf, sizeof(linebuf), in) != NULL) {
     unsigned int o1, o2, o3, o4, len, as;
     if(sscanf(linebuf, "%u.%u.%u.%u/%u %u",
@@ -111,7 +169,7 @@ origins_regression_test(const char *origins_dat) {
           radix_resolve_route(origins->routes,addr_from_octets(o1,o2,o3,o4+1));
         if((unsigned int)pe->data != as && pe->position <= len) {
           /* not the same and not a more specific */
-          fprintf(stderr, "failed to verify %u == %u on line:\n%s", 
+          fprintf(stderr, "failed to verify %u == %u on line: %s", 
                   as, (unsigned int) pe->data, linebuf);
           if(pe->prefixlen > len) {
             fprintf(stderr, " -- because a more specific was matched. (%u > %u)\n", pe->prefixlen, len);
@@ -134,3 +192,48 @@ origins_regression_test(const char *origins_dat) {
   }
   (void)fclose(in);
 }
+
+void 
+origins6_regression_test(const char *origins6_dat) {
+  FILE *in;
+  char linebuf[60];
+  origins6_init(origins6_dat);
+  in = fopen_path_r(origins6_dat, NULL);
+  while(!feof(in) && fgets(linebuf, sizeof(linebuf), in) != NULL) {
+    char addrbuf[61]; 
+    unsigned int len, as;
+    if(sscanf(linebuf, "%60[a-fA-F0-9:]/%u %u", addrbuf, &len, &as) == 3) {
+      struct in6_addr addr;
+      inet_pton(AF_INET6, addrbuf, &addr);
+      struct patricia6_entry *pe = radix6_resolve_route(origins6->routes,addr);
+      assert(pe);
+      if((unsigned int)pe->data != as && pe->position <= len) {
+        /* not the same and not a more specific */
+        char buf[60];
+        fprintf(stderr, "failed to verify expected AS %u == found %u (%s/%d) on line: %s", 
+                as, (unsigned int) pe->data, 
+                inet_ntop(AF_INET6, &pe->destination, buf, 60), pe->prefixlen, 
+                linebuf);
+        if(pe->prefixlen > len) {
+          fprintf(stderr, " -- because a more specific was matched. (%u > %u)\n", pe->prefixlen, len);
+        } else if(as == 0) {
+          patricia6_dump(origins6, "origins6_regression_failure.dot");
+#if !defined(CHECK_ORIGINS_SHOULD_FAIL) || CHECK_ORIGINS_SHOULD_FAIL == 0
+          abort();
+#else
+          exit(EXIT_SUCCESS);
+#endif
+        } else {
+          /* meh.  inconsistent origins happen. */
+        }
+      }
+      //         unsigned int stored_as = (unsigned int) patricia_lookup(origins, addr_from_octets(o1,o2,o3,o4+1));
+      // if( stored_as != as) {
+      //   fprintf(stderr, "failed to verify %u == %u on line:\n%s", 
+      //           as, stored_as, linebuf);
+      //   abort();
+      // }
+    }
+  } 
+  (void)fclose(in);
+}

data/ext/undns/queue.c

@@ -171,7 +171,7 @@ q_element q_insert_fromdir(queue q, const void *v, boolean scan_backwards) {
           /* <= there should append equal things.  < should prepend equal things */
           iter = iter->next);
       if(iter) { // must insert in middle 
-        newelem = malloc(sizeof(struct queue_element_struct));
+        // newelem = malloc(sizeof(struct queue_element_struct));
         assert(newelem!=NULL);
         newelem->value = v;
         newelem->next = iter;
@@ -238,6 +238,8 @@ static /*@null@*/ const void *q_top_gotlock(const queue q) {
     else
       q->tail=NULL;
     free(freeme);
+  } else {
+    assert(retval == NULL);
   }
   check_invariants(q);
   UNLOCK;

data/ext/undns/radix.c

@@ -24,8 +24,8 @@
    functions */
 static struct patricia_table *current_table;
 extern boolean want_debug;
-boolean really_want_debug = FALSE;
-boolean really_want_protection = FALSE;
+static boolean really_want_debug = FALSE;
+static boolean really_want_protection = FALSE;
 
 #ifdef __ASSERT_VOID_CAST
 /* we can, non-portably, define something that looks like assert and 

data/ext/undns/radix6.c

@@ -0,0 +1,607 @@
+/* Copyright 1999-2002 Eric Hoffman, Neil Spring, 
+   and the University of Washington */
+#define VERBOSE
+#include "radix.h"
+#include "radix6.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#ifdef WIN32
+#include <fcntl.h>
+#include <io.h>
+#else
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include "buffer.h"
+#include "fcntl.h"
+#include <assert.h>
+
+#undef DEBUG_INSERTION
+// #define DEBUG_LOOKUP(x...) fprintf(stderr, x)
+#define DEBUG_LOOKUP(x...) 
+
+/* ugly global variable, which gets updated on entry from new 
+   functions */
+static struct patricia6_table *current_table;
+extern boolean want_debug;
+static boolean really_want_debug = TRUE;      /* means lots of stderr */
+static boolean really_want_protection = TRUE; /* means lookups after insertion. */
+
+#ifdef __ASSERT_VOID_CAST
+/* we can, non-portably, define something that looks like assert and 
+   works like assert, but aldo dumps the table */
+#define radix6_assert(expr) \
+  do { if(!(expr) && current_table != NULL)   \
+         patricia6_dump(current_table, "assert.dot"); \
+       (__ASSERT_VOID_CAST ((expr) ? 0 :					      \
+		       (__assert_fail (__STRING(expr), __FILE__, __LINE__,    \
+                               __ASSERT_FUNCTION), 0))); } while(0) 
+#else 
+#define radix6_assert(expr) assert(expr)
+#endif
+
+
+static char * 
+label_of_dest(address6 dest, prefixlen_t prefix, 
+              /*@out@*//*@returned@*/char *buf);
+static char * 
+label_of_node(const struct patricia6_entry *r, 
+              /*@out@*//*@returned@*/char *buf);
+
+void *get_data6(const struct patricia6_entry *r){
+  return(r->data);
+}
+void set_data6(struct patricia6_entry *r, void *data) {
+  r->data = data;
+}
+
+/* exported for testing */
+address6 
+radix6_mask(address6 addr, prefixlen_t prefix)
+{
+  address6 m = IN6ADDR_ANY_INIT;
+  char *d = (char *)&m;
+  char *s = (char *)&addr;
+  int remaining_prefix = prefix;
+
+  assert(prefix <= 128);
+  if(prefix == (prefixlen_t)0) return m;
+  if(really_want_protection) assert(prefix <= 128);
+
+  while((remaining_prefix-=8) >= 0) {
+    *d++ = *s++;
+  }
+
+  if(remaining_prefix == -8) {
+    // fprintf(stderr, "reached zero\n");
+    return m;
+  }
+  // fprintf(stderr, "is %d\n", remaining_prefix);
+
+  *d = (*s) & ~((1<<(-remaining_prefix)) - 1);
+  return m;
+}
+
+static inline boolean radix6_test(address6 addr, prefixlen_t x);
+static void check_radix6_mask(prefixlen_t len) {
+  int i;
+  address6 m = {{{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,      \
+                   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}};
+  address6 n = radix6_mask(m, len);
+  if(want_debug) {
+    char bufa[60];
+    fprintf(stderr, "mask test /%d = %s\n", len, inet_ntop(AF_INET6, &n, bufa, 60));
+  }
+  for(i=1;i<=len;i++) {
+    if(!radix6_test(n, i)) { fprintf(stderr, "failed mask test %d at %d\n", len, i); exit(1); }
+  }
+  for(;i<=128;i++) {
+    if(radix6_test(n, i)) { fprintf(stderr, "failed mask test %d at %d\n", len, i); exit(1); }
+  }
+}
+
+static unsigned int testmasks[9];
+void radix6_init_testmasks(void) {
+  unsigned int i, p;
+  for(i=1; i<=8; i++) {
+    testmasks[i] = 1 << (8U - i);
+    if(want_debug) fprintf(stderr, "tm[%d] = 0x%x\n", i, testmasks[i]);
+  }
+  testmasks[0] = testmasks[8];
+
+  for(p = 1; p <= 128; p++) {
+    check_radix6_mask(p);
+  }
+}
+static inline boolean radix6_test(address6 addr, prefixlen_t x) {
+  char *s = (char *)&addr;
+  boolean ret = (x == (prefixlen_t)0 || s[(x-1)/8] & testmasks[x%8]);
+
+#if 0 
+  char bufa[60];
+  fprintf(stderr, "radix6_test %s @ %d is %s\n", 
+          inet_ntop(AF_INET6, &addr, bufa, 60 ), x, ret ? "T" : "f");
+#endif
+  
+  return ret;
+}
+
+/*@null@*//*@dependent@*/ 
+static struct patricia6_entry *
+find_route_internal(/*@null@*/struct patricia6_entry *r, 
+                    address6 destination, prefixlen_t prefix)
+{
+  if (!r) return(0);
+  if (memcmp(&r->destination, &destination, sizeof(address6)) == 0 
+      && (r->prefixlen == prefix))
+    return(r);
+  if(r->position <= 128) {
+    if (radix6_test(destination,r->position) != 0) {
+      return(find_route_internal(r->on,destination,prefix));
+    } else {
+      return(find_route_internal(r->off,destination,prefix));
+    }
+  } else {
+    return(NULL);
+  }
+}
+ 
+/*@null@*//*@dependent@*/ 
+struct patricia6_entry *
+radix6_resolve_route(/*@null@*/ struct patricia6_entry * top,
+                    address6 destination) {
+  struct patricia6_entry * here=top;
+  struct patricia6_entry * best=NULL;
+  prefixlen_t length=0;
+  char la[25] __attribute__((unused));
+  
+  DEBUG_LOOKUP("looking for %s: ", label_of_dest(destination, 128, la));
+  while(here){
+    if (here->prefixlen >= length) { 
+      address6 masked = radix6_mask(destination,here->prefixlen);
+      if(memcmp(&masked, &here->destination, sizeof(masked)) == 0){
+        best=here;
+        length=here->prefixlen;
+        DEBUG_LOOKUP("+%s ", label_of_node(here, la));
+      } else {
+        DEBUG_LOOKUP("-%s ", label_of_node(here, la));
+      } 
+    } else {
+      DEBUG_LOOKUP("_%s ", label_of_node(here, la));
+    }
+    if (here->position <= 128) 
+      if( radix6_test(destination,here->position) != 0)
+        here=here->on;
+      else 
+        here=here->off;
+    else 
+      here=NULL;
+  }
+  DEBUG_LOOKUP("result: %s\n", best? label_of_node(best, la): "none");
+  return(best);
+}
+
+static prefixlen_t find_difference(address6 a, address6 b, prefixlen_t maxbits){
+  prefixlen_t difference;
+  if(really_want_protection) assert(maxbits <= 129);
+  for (difference=(prefixlen_t)1;
+       (difference<maxbits &&
+        (radix6_test(a,difference) == 
+         radix6_test(b,difference))); ) {
+
+    difference += 1; /* the post-increment of the for loop can be done here, just to simplify. */
+  }
+#if 0
+      char bufa[60], bufb[60];
+      fprintf(stderr, "diff %d of %d %s %s\n", 
+              difference, maxbits,
+              inet_ntop(AF_INET6, &a, bufa, 60), 
+              inet_ntop(AF_INET6, &b, bufb, 60));
+#endif
+  
+  return(difference);
+}
+#ifdef DEBUG_INSERTION
+static void radix6_insert_debug(struct patricia6_entry * new, const char * as, 
+                               struct patricia6_entry * old) {
+    char buf[50], buf2[50];
+    VERBAL("radix6_insert_debug %s %s %s-%d\n", 
+           label_of_node(new, buf), 
+           as,
+           label_of_node(old, buf2), old->position); 
+}
+#else
+static void radix6_insert_debug(struct patricia6_entry * new __attribute__((unused)), 
+                               const char * as __attribute__((unused)), 
+                               struct patricia6_entry * old __attribute__((unused))) {
+  return;
+}
+#endif
+
+void radix6_insert(struct patricia6_entry **p, 
+                  /*@owned@*//*@partial@*/struct patricia6_entry *new)
+{
+  prefixlen_t difference;
+  struct patricia6_entry * old=*p;
+  int commonprefixlen;
+
+  /* a little piece of mind */
+  if(really_want_protection) {
+    assert(new->position == 0);
+    assert(new->on == NULL);
+    assert(new->off == NULL);
+
+    radix6_assert(old== NULL || old->on == NULL || 
+               (old->on->on == NULL && old->on->off == NULL) ||
+               old->position <= old->on->position);
+    radix6_assert(old== NULL || old->off == NULL|| 
+               (old->off->on == NULL && old->off->off == NULL) ||
+               old->position <= old->off->position);
+  }
+
+  /* an empty table or subtree */
+  if (old == NULL) {
+    new->position = new->prefixlen + 1;
+    *p = new;
+    radix6_insert_debug (new, "in empty table or subtree", new);
+    return;
+  }
+
+  /* a duplicate */
+  if(memcmp(&old->destination, &new->destination, sizeof(address6)) == 0 &&
+     old->prefixlen == new->prefixlen) {
+    /* NON-ROUTING-TABLE behavior: assume oldest, not newest, is right. */
+    char bufa[60];
+    radix6_insert_debug (new, "is duplicate of", old);
+    fprintf(stderr, "warning: discarding duplicate %s/%d\n",  inet_ntop(AF_INET6, &new->destination, bufa, 60), new->prefixlen);
+    new->position = (prefixlen_t)-1; /* flag it for free() ing */
+    return;
+  }
+
+  difference = find_difference(old->destination, new->destination,
+                               min(new->prefixlen, old->prefixlen));
+  commonprefixlen = max((int)0, ((int)old->position)-1);
+
+  /* attempt to handle a strange case:
+     we're inserting something that shouldn't go further down
+     in the tree, because of prefix < position requirements. */
+  if(difference >= old->position &&
+     new->prefixlen <= old->position &&
+     old->position < old->prefixlen) {
+    struct patricia6_entry * *child;
+    new->position = old->position;
+    new->on = old->on;
+    new->off = old->off;
+    old->on = old->off = NULL;
+    *p = new;
+
+    child = (radix6_test(old->destination,new->position)!=0) 
+      ? &new->on : &new->off;
+    radix6_insert_debug (old, "as pushdown of", new);
+    old->position=0;
+    radix6_insert(child, old);
+
+    return;
+  }
+
+  /* if new is contained in old/prefix; at least what old/position */
+  address6 new_masked = radix6_mask(new->destination,commonprefixlen);
+  address6 old_masked = radix6_mask(old->destination,commonprefixlen);
+  if( difference >= old->position || 
+      (memcmp(&new_masked, &old_masked, sizeof(address6)) == 0
+       && new->prefixlen > old->prefixlen )){
+
+    struct patricia6_entry * *child = (radix6_test(new->destination,old->position)!=0) 
+      ? &old->on : &old->off;
+    radix6_insert_debug (new, "as child of", old);
+    radix6_insert(child, new);
+
+    if(new->position == (prefixlen_t)-1) {
+      /* was a duplicate */
+      return;
+    }
+
+    if(really_want_protection)  {
+      if(!(new->position > old->position || 
+                    (new->position >= old->position && 
+                     memcmp(&new->destination, &old->destination, sizeof(address6) == 0)))) {
+        char bufa[60], bufb[60];
+        fprintf(stderr, "diff %d cpl %d np %d op %d %s/%d %s/%d\n", 
+                difference, commonprefixlen, new->position, old->position, 
+                inet_ntop(AF_INET6, &new->destination, bufa, 60),  new->prefixlen,
+                inet_ntop(AF_INET6, &old->destination, bufb, 60),  old->prefixlen);
+        radix6_print_routing_table_dot(old, 2);
+      }
+
+      radix6_assert(new->position > old->position || 
+                    (new->position >= old->position && 
+                     memcmp(&new->destination, &old->destination, sizeof(address6) == 0)));
+      /*
+      fprintf(stderr, "cleared\n");
+      */
+    }
+
+    return;
+  }
+
+  /* if old is contained in new */
+  /* if( (radix6_mask(new->destination,old->prefixlen) == old->destination) 
+     && new->prefixlen > old->prefixlen ){ */ 
+  do {
+    radix6_insert_debug (new, "as parent of", old);
+    if(difference < old->position-1) {
+      if(radix6_test(old->destination, difference) != 
+         radix6_test(new->destination, difference)) {
+        new->position = difference;
+      } else {
+        new->position = difference + 1;
+      }
+    } else {
+      new->position = old->position - 1; 
+    }
+    // new->position = min((int)difference, (int)old->position-1);
+    if(radix6_test(old->destination, new->position)!=0) {
+      new->on = old;
+    } else {
+      new->off = old;
+    }
+    *p = new;
+  } while(0);
+
+  return;
+}
+
+static char * 
+label_of_dest(address6 dest, prefixlen_t prefixlen, /*@out@*//*@returned@*/char *buf) {
+  char minibuf[10];
+  assert(prefixlen <= 128);
+  inet_ntop(AF_INET6, &dest, buf, 44);
+  sprintf(minibuf,"/%u", prefixlen);
+  strcat(buf, minibuf);
+  return(buf);
+}
+
+static char * 
+label_of_node(const struct patricia6_entry *r, 
+              /*@out@*//*@returned@*/char *dest)
+{
+  return(label_of_dest(r->destination, r->prefixlen, dest));
+}
+
+static void 
+print_routing_table_internal(const struct patricia6_entry *r,
+                             buffer b,
+                             unsigned int *max)
+{ 
+  char here[255];
+
+  if (r){
+    if (r->position > *max) *max=r->position;
+    (void)label_of_node(r,here);
+    /*bprintf (b," {rank = same; %d ; \"%s\"}\n",r->position,here);*/
+    bprintf (b," \"%s\" [label = \"{<h> %s | {<off> 0 |bit %d |<on> 1}}\"];\n",
+             here, here, r->position);
+
+    if (r->off){
+      char off[255];
+      bprintf (b,"  \"%s\":off -> \"%s\"[label=\"%d=0\"];\n",
+               here,label_of_node(r->off,off),r->position);
+      print_routing_table_internal(r->off,b,max);
+    }
+    if (r->on){
+      char on[255];
+      bprintf (b,"  \"%s\":on -> \"%s\"[label=\"%d=1\"];\n",
+               here, label_of_node(r->on,on), r->position);
+      print_routing_table_internal(r->on,b,max);
+    }
+  }
+}
+
+void radix6_print_routing_table_dot(const struct patricia6_entry *top, int fd)
+{
+  unsigned max=0;
+  buffer b=create_buffer(100);
+  buffer base=create_buffer(100);
+
+  bprintf (base,"digraph radix {\n");
+  bprintf (base,"  size=\"10,7.5\"; ratio=auto; ordering=out\n");
+  bprintf (base,"  node [shape=record,width=.3,height=.3]\n");
+  if (top) {
+    // char z[90];
+    // eh.     bprintf (b,"  root -> \"%s\";\n",label_of_node(top,z));
+    print_routing_table_internal(top,b,&max);
+  }
+  assert(write(fd,base->contents,(size_t)base->fill)>0);
+  assert(write(fd,b->contents,(size_t)b->fill)>0);
+  assert(write(fd,"}\n",2));
+  free_buffer(b);
+  free_buffer(base);
+}
+
+static void remove_route_internal(struct patricia6_entry * *place,
+                                  address6 destination,
+                                  unsigned int prefixlen)
+{
+  struct patricia6_entry * r=*place;
+  if (r){
+    if ((memcmp(&r->destination, &destination, sizeof(address6)) != 0) || 
+        (r->prefixlen!=prefixlen)){
+      if (radix6_test(destination,r->position) != 0)
+        remove_route_internal(&r->on,destination,prefixlen);
+      else 
+        remove_route_internal(&r->off,destination,prefixlen);
+    } else {
+      /* found it */
+      if (r->on) {
+        struct patricia6_entry * q=r->on;
+        if (r->off) {
+          /* the rotation case*/
+          remove_route_internal(&r->on,q->destination,q->prefixlen);
+          q->position=r->position;
+          q->off=r->off;
+          q->on=r->on;
+        } 
+        *place=q;
+      } else *place=r->off;
+    }
+  }
+}
+
+void radix6_remove_route(struct patricia6_table * n,
+                        address6 destination,
+                        prefixlen_t prefixlen)
+{
+  if(n->routes) /* cheap check keeps lclint happy */
+    remove_route_internal(&n->routes,destination,prefixlen);
+}
+
+static void 
+print_routing_table_text_internal(const struct patricia6_entry *r, 
+                                  FILE *fdout) {
+  if (r){
+    char here[25];
+    fprintf(fdout, " %s via --\n", label_of_node(r,here));
+    print_routing_table_text_internal(r->off,fdout);
+    print_routing_table_text_internal(r->on,fdout);
+  }
+}
+
+void radix6_print_routing_table_text(const struct patricia6_entry *top, 
+                                    FILE *fdout) {
+  fprintf(fdout, "Routing table:\n");
+  if(top)
+    print_routing_table_text_internal(top, fdout);
+}
+
+
+struct patricia6_table * patricia6_new(void){
+  NEWPTR(struct patricia6_table, p);
+  radix6_init_testmasks(); /* can overwrite */
+  p->routes = NULL;
+  p->default_route = NULL;
+  return(p);
+}
+
+static void recursive_delete(struct patricia6_entry *e, 
+                             /*@null@*/ void (*data_free)(void *)) {
+  if(e != NULL) {
+    if(e->on != NULL)     recursive_delete(e->on, data_free);
+    if(e->off != NULL)    recursive_delete(e->off, data_free);
+    if(data_free != NULL) data_free(e->data);
+    free(e);
+  }
+}
+
+void patricia6_delete(struct patricia6_table * p, 
+                     /*@null@*/ void (*data_free)(void *)) {
+  recursive_delete(p->routes, data_free);
+  recursive_delete(p->default_route, data_free);
+  p->routes = NULL;
+  p->default_route = NULL;
+  free(p);
+}
+
+void patricia6_insert(struct patricia6_table * pt, 
+                     address6 a, 
+                     prefixlen_t prefixlen, 
+                     void *data) {
+  /* really try to avoid duplication; I'd rather do that 
+   in the radix6_insert(), but that seems like a pain atm.*/
+  // if(find_route_internal(pt->routes, a, prefixlen) == NULL) {
+  NEWPTR(struct patricia6_entry, pe); /* this allocated memory may be leaked by scriptroute 1/14/07 */
+  current_table = pt; /* icky */
+  assert(pe != NULL);
+  assert(prefixlen <= 128);
+  assert(pt != NULL);
+  pe->destination = a;
+  address6 mask_checked = radix6_mask(a, prefixlen);
+  if(memcmp(&a, &mask_checked, sizeof(address6)) != 0) {
+    VERBAL("dropping errant prefix\n");
+    free(pe);
+    return;
+  }
+  pe->prefixlen = prefixlen;
+  pe->data = data;
+  pe->position = 0;
+  pe->on = NULL;
+  pe->off = NULL;
+  if(really_want_debug) {
+    //      VERBAL("patricia6_insert(pt, 0x%x, %u, (void *)0x%p);\n", a, prefixlen, data);
+  }
+
+  /* perhaps a /0 slipped through. */
+  if(prefixlen == 0) {
+    pt->default_route = pe;
+    return;
+  }
+
+  radix6_insert(&pt->routes, pe);
+
+  /* patricia6_dump(pt, "intst.dot"); */
+
+  /* check that it can be found once inserted. */
+  if(really_want_protection)  {
+    if(find_route_internal(pt->routes, a, prefixlen) == NULL) {
+      char buf[60];
+      fprintf(stderr, "after inserting, couldn't find %s/%d\n",
+              inet_ntop(AF_INET6, &a, buf, 60), prefixlen);
+      radix6_print_routing_table_dot(pt->routes, 2);
+      assert(0);
+    }
+  }
+
+  if(pe->position == (prefixlen_t)-1) {
+    // fprintf(stderr, "freeing duplicate\n");
+    memset(pe, 0, sizeof(*pe));
+    free(pe);
+  }
+
+  //}
+}
+/*@null@*/
+void *patricia6_lookup(struct patricia6_table * pt, address6 a) {
+  struct patricia6_entry * pe;
+  // char buf[256];
+  current_table = pt;
+  pe = radix6_resolve_route(pt->routes, a);
+  if(pe == NULL) {
+    pe = pt->default_route;
+  }
+  if(pe == NULL) {
+    return NULL;
+  } 
+  // printf("foundl %s\n", label_of_node(pe, buf));
+  return(pe->data);
+}
+
+boolean 
+patricia6_lookup_all(struct patricia6_table * pt, 
+                    address6 a, 
+                    /*@out@*/ address6 *prefix, 
+                    /*@out@*/ prefixlen_t *prefixlen, 
+                    /*@out@*/ void **data) {
+  struct patricia6_entry * pe;
+  // char buf[256];
+  current_table = pt;
+  pe = radix6_resolve_route(pt->routes, a);
+  if(pe == NULL) {
+    pe = pt->default_route;
+  }
+  if(pe == NULL) {
+    return FALSE;
+  } 
+  // printf("found %s\n", label_of_node(pe, buf));
+  *prefix = pe->destination;
+  *prefixlen = pe->prefixlen;
+  *data = pe->data;
+  return TRUE;
+}
+
+void patricia6_dump(struct patricia6_table * pt, const char *filename) {
+  int f = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0644);
+  radix6_print_routing_table_dot(pt->routes, f);
+  close(f);
+}