undns 0.4.0a

data/ext/undns/hashtable.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2002
+ * Neil Spring and the University of Washington.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author(s) may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.  
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _hashtable_h
+#define _hashtable_h
+
+#include "nscommon.h"
+
+NS_BEGIN_DECLS
+
+struct hashtable_struct;
+typedef struct hashtable_struct *hashtable;
+
+void ht_delete(/*@only@*/ hashtable deleteme, boolean show_progress);
+
+typedef unsigned int (*hash_cb)(const void *key);
+typedef boolean (*isequal_cb)(const void *key1, const void *key2);
+typedef void (*delete_cb)(void *key);
+hashtable ht_new(unsigned int size, 
+                 hash_cb hash,
+                 isequal_cb isequal,
+                 /*@null@*/ delete_cb free_keyval);
+void ht_insert(hashtable ht, /*@owned@*/const void *keyval);
+/* true if found and removed */
+boolean ht_remove(hashtable ht, const void *key);
+typedef boolean (*ht_delete_if_cb)(void *keyval, void *user);
+unsigned int ht_delete_if(hashtable ht,
+                          ht_delete_if_cb callback, 
+                          /*@null@*/ void *user);
+void ht_free_entry(hashtable ht, const void *keyval);
+/*@dependent@*/ /*@null@*/ 
+void *ht_lookup(hashtable ht, const void *key);
+
+typedef void * (*ht_constructor_cb)(const void *key);
+/*@dependent@*/ 
+void *ht_lookup_nofail(hashtable ht, 
+                       const void *key,
+                       ht_constructor_cb constructor);
+
+/* returns true if it should continue to be called */
+typedef boolean (*ht_iterator_cb)(const void *keyval, void *user);
+boolean ht_iterate(hashtable ht,
+                   ht_iterator_cb callback, 
+                   void *user);
+
+typedef boolean (*ht_iterator_pair_cb)(const void *keyval, const void *keyval2);
+boolean ht_iterate_pairs(hashtable ht, unsigned int nThreads, unsigned int chunkSize,
+  ht_iterator_pair_cb callback);
+
+/* not-const version of the above; differs only in type. */
+typedef boolean (*ht_iterator_cb_nc)(void *keyval, void *user);
+boolean ht_iterate_nc(hashtable ht,
+                   ht_iterator_cb_nc callback, 
+                   void *user);
+
+unsigned long ht_count(hashtable ht);
+
+void ht_occupancyjgr(const hashtable ht, const char *fname);
+
+/* works if you're storing ints, or if the key is
+   already generated and the first int in the structure */
+unsigned int hash_8byte(const void *k);
+boolean isequal_8byte(const void *ia, const void *ib);
+unsigned int hash_k_int(const int *k);
+boolean isequal_k_int(const int *ia, const int *ib);
+struct in_addr;
+unsigned int hash_k_saddr(const struct in_addr *k);
+boolean isequal_k_saddr(const struct in_addr *ia, const struct in_addr *ib);
+unsigned int hash_k_uint(const unsigned int *k);
+boolean isequal_k_uint(const unsigned int *ia, const unsigned int *ib);
+unsigned int hash_int(const void *k);
+boolean isequal_int(const void *ia, const void *ib);
+unsigned int hash_ushort(const void *k);
+boolean isequal_ushort(const void *ia, const void *ib);
+
+NS_END_DECLS
+#endif

data/ext/undns/my_ruby.h

@@ -0,0 +1,3 @@
+
+/* placeholder */
+#include <ruby.h>

data/ext/undns/nscommon.h

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2002
+ * Neil Spring and the University of Washington.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author(s) may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _NS_COMMON_H
+#define _NS_COMMON_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#ifdef __cplusplus
+# define NS_BEGIN_DECLS extern "C" {
+# define NS_END_DECLS }
+#else
+# define NS_BEGIN_DECLS /* empty */
+# define NS_END_DECLS /* empty */
+#endif
+
+NS_BEGIN_DECLS
+
+#ifdef __LCLINT__
+#define UNUSED(x) /*@unused@*/ ##x
+typedef unsigned char u_int8_t;
+typedef unsigned short u_int16_t;
+typedef	unsigned int u_int32_t;
+typedef	unsigned long long u_int64_t;
+#else
+#define UNUSED(x) x __attribute__((unused))
+#endif
+
+#ifdef __LCLINT__
+#define __STDC__
+char *rindex(const char *s, char c); /* not really true; it's an int */
+/*@dependent@*/char *index(const char *s, char c); /* not really true; it's an int */
+char *strdup(const char *s);  /* probably a good annotation here */
+/*@printflike@*/
+int /*@alt void@*/ snprintf(/*@out@*/char *s, size_t x, const char *fmt, ...);
+#endif
+
+typedef unsigned char boolean;
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
+#ifdef __LCLINT__
+/* lclint doesn't do typeof */
+#define min(x,y) ((x > y) ? x : y)
+#define max(x,y) ((x > y) ? x : y)
+#else
+/* from linux/kernel.h */
+#define min(x,y) ({ \
+        const typeof(x) _xi = (x);       \
+        const typeof(y) _yi = (y);       \
+        (void) (&_xi == &_yi);            \
+        _xi < _yi ? _xi : _yi; })
+#define max(x,y) ({ \
+        const typeof(x) _xa = (x);       \
+        const typeof(y) _ya = (y);       \
+        (void) (&_xa == &_ya);            \
+        _xa > _ya ? _xa : _ya; })
+#endif
+
+#define DEBUG_PRINT(x...) do { } while (0)
+// #define DEBUG_PRINT(x) fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, x);
+#define DEBUG_PRINTL(x) fprintf(stderr, "%s:%d: %s", __FILE__, __LINE__, x);
+
+#ifdef HAVE_STDINT_H
+/* a linux-y thing */
+#include <stdint.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+/* kludgy fix for solaris. cygwin suggests u_int64_t is more portable,
+ solaris suggests the opposite. */
+typedef u_int64_t macaddress;
+
+#ifdef VERBOSE
+#define VERBAL printf
+#else
+#define VERBAL(X...) do { if(want_debug) fprintf(stderr, X); } while(0);
+
+#if defined(__linux__)  && !defined(__cplusplus)
+/*@unused@*/
+static __inline void nullie(/*@unused@*/ const char *fmt __attribute__ ((unused)), ...) {
+  return;
+}
+#else
+#define nullie(x...) do {} while(0)
+#endif
+
+#endif
+
+#include<stdlib.h>
+#include<stdio.h>
+/*@unused@*/
+static __inline /*@out@*/ void *malloc_ordie(size_t len) {
+  void *ret = malloc(len);
+  if(ret == NULL) { 
+    fprintf(stderr, "unable to allocate %d bytes\n", (int)len);
+    abort();
+  }
+  return(ret);
+}
+
+#include <string.h>
+/*@unused@*/
+static __inline char *strdup_ordie(const char *str) /*@*/ {
+  char *ret = strdup(str);
+  if(ret == NULL) { 
+    fprintf(stderr, "unable to duplicate %s\n", str);
+    abort();
+  }
+  return(ret);
+}
+
+#define NEWPTR(type, name) type *name = (type *)malloc_ordie(sizeof(type))
+#define NEWPTRX(type, name) type *name = (type *)malloc_ordie(sizeof(type))
+#define NEWPTRZ(type, name) type *name = (type *)memset(malloc_ordie(sizeof(type)), 0, sizeof(type))
+
+/* means nscommon must be included after sys/time */
+#ifndef timersub
+# define timersub(a, b, result)                   \
+do {                                              \
+  (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;   \
+  (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;\
+  if ((result)->tv_usec < 0) {                    \
+    --(result)->tv_sec;                           \
+    (result)->tv_usec += 1000000;                 \
+  }                                               \
+} while (0)
+#endif
+
+#ifdef HAVE_CHECK_H
+#include <check.h>
+#ifdef HAVE__ck_assert_msg
+/* newer check library, still seems to lack the obvious function. */
+#define fail_expect_int(result,expect,msg) do { \
+  char buf[255]; \
+  int r = result; \
+  sprintf(buf, "%s (got %d, expected %d)", msg, (r), (expect)); \
+  _ck_assert_msg((r)==(expect),__FILE__,__LINE__,buf, NULL);         \
+}while(0)
+#define fail_expect_voidp(result,expect,msg) do { \
+  char buf[255]; \
+  void *r = result; \
+  sprintf(buf, "%s (got %p, expected %p)", msg, (r), (expect)); \
+  _ck_assert_msg((r)==((void *)expect),__FILE__,__LINE__,buf, NULL); \
+} while(0)
+#else
+#define fail_expect_int(result,expect,msg) do { \
+  char buf[255]; \
+  int r = result; \
+  sprintf(buf, "%s (got %d, expected %d)", msg, (r), (expect)); \
+  _fail_unless((r)==(expect),__FILE__,__LINE__,buf); \
+} while(0)
+#define fail_expect_voidp(result,expect,msg) do { \
+  char buf[255]; \
+  void *r = result; \
+  sprintf(buf, "%s (got %p, expected %p)", msg, (r), (expect)); \
+  _fail_unless((r)==((void *)expect),__FILE__,__LINE__,buf); \
+} while(0)
+
+#endif
+#endif
+
+
+NS_END_DECLS
+
+#endif
+/*
+vi:ts=2
+*/

data/ext/undns/originAS.c

@@ -0,0 +1,134 @@
+/* (c) neil spring 2002 */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include "nscommon.h"
+#include "originAS.h"
+#include "radix.h"
+#include "exception.h"
+#include "ruleset.h" /* fopen_path_r */
+
+static struct patricia_table *origins;
+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));
+}
+
+void 
+origins_init(const char *origins_dat) {
+  char linebuf[60];
+  // FILE *in = popen("./show_origins.pl | sort -u", "r");
+  const char *filename = (origins_dat != NULL) ? origins_dat : "origins.dat";
+  FILE *in = fopen_path_r(filename);
+  if(in == NULL) {
+    char buf[255];
+    sprintf(buf, "can't open origins.dat(%s): %s", filename, strerror(errno));
+    throw_void(buf); 
+  }
+  origins = patricia_new();
+  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",
+              &o1, &o2, &o3, &o4, &len, &as) == 6) {
+      patricia_insert(origins, addr_from_octets(o1,o2,o3,o4), len, (void *)as);
+    } else if(sscanf(linebuf, "%u.%u.%u.%u/%u {%u",
+              &o1, &o2, &o3, &o4, &len, &as) == 6) {
+      /* pick the first one from a multiple-origins line */
+      patricia_insert(origins, addr_from_octets(o1,o2,o3,o4), 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 ) {
+    origins_init(NULL);
+  }
+  if ( origins != NULL ) {
+    return((unsigned short)(unsigned int)patricia_lookup(origins, a));
+  } else {
+    fprintf(stderr, "Origins failed to initialize\n"); /* shouldn't get here. */
+    return(0);
+  }
+}
+
+unsigned short origin_for_address_str(const char *addrstring) {
+  struct in_addr a;
+  if(inet_aton(addrstring, &a)) {
+    return(origin_for_address(a.s_addr));
+  }
+  return 0;
+}
+
+boolean origin_prefix_for_address(in_addr_t a, /*@out@*/ unsigned short *as, 
+                                  /*@out@*/ in_addr_t *addr, /*@out@*/ unsigned char *prefixlen) {
+  if ( origins == NULL ) {
+    origins_init(NULL);
+  }
+  if ( origins != NULL ) {
+    void *data;
+    // unsigned short oas;
+    boolean ret = patricia_lookup_all(origins, a, addr, prefixlen, &data);
+    // printf("a=%x *addr=%x, *prefixlen=%d\n", a, *addr, *prefixlen);
+    *as = (unsigned short)(unsigned int)data;
+    // oas = ((unsigned short)(unsigned int)patricia_lookup(origins, a));
+    // assert(oas == *as);
+    return(ret);
+  } else {
+    fprintf(stderr, "Origins failed to initialize\n"); /* shouldn't get here. */
+    return(FALSE);
+  }
+}
+
+
+void 
+origins_regression_test(const char *origins_dat) {
+  FILE *in;
+  char linebuf[60];
+  origins_init(origins_dat);
+  in = fopen_path_r(origins_dat);
+  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",
+              &o1, &o2, &o3, &o4, &len, &as) == 6) {
+      if(len < 32 && o1 < 256 && o2 < 256 && o3 < 256 && o4 < 256) {
+        struct patricia_entry *pe =
+          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", 
+                  as, (unsigned int) pe->data, linebuf);
+          if(pe->prefixlen > len) {
+            fprintf(stderr, " -- because a more specific was matched. (%d > %d)\n", pe->prefixlen, len);
+          } else {
+#if !defined(CHECK_ORIGINS_SHOULD_FAIL) || CHECK_ORIGINS_SHOULD_FAIL == 0
+            abort();
+#else
+            exit(EXIT_SUCCESS);
+#endif
+          }
+        }
+        //         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();
+                // }
+      }
+    } 
+  }
+  fclose(in);
+}