rpatricia 0.04

data/patricia.h

@@ -0,0 +1,147 @@
+/*
+ * $Id: patricia.h,v 1.6 2005/12/07 20:53:01 dplonka Exp $
+ * Dave Plonka <plonka@doit.wisc.edu>
+ *
+ * This product includes software developed by the University of Michigan,
+ * Merit Network, Inc., and their contributors. 
+ *
+ * This file had been called "radix.h" in the MRT sources.
+ *
+ * I renamed it to "patricia.h" since it's not an implementation of a general
+ * radix trie.  Also, pulled in various requirements from "mrt.h" and added
+ * some other things it could be used as a standalone API.
+ */
+
+#ifndef _PATRICIA_H
+#define _PATRICIA_H
+
+/* typedef unsigned int u_int; */
+typedef void (*void_fn_t)();
+/* { from defs.h */
+#define prefix_touchar(prefix) ((u_char *)&(prefix)->add.sin)
+#define MAXLINE 1024
+#define BIT_TEST(f, b)  ((f) & (b))
+/* } */
+
+#define addroute make_and_lookup
+
+#include <sys/types.h> /* for u_* definitions (on FreeBSD 5) */
+
+#include <errno.h> /* for EAFNOSUPPORT */
+#ifndef EAFNOSUPPORT
+#  defined EAFNOSUPPORT WSAEAFNOSUPPORT
+#  include <winsock.h>
+#else
+#  include <netinet/in.h> /* for struct in_addr */
+#endif
+
+#include <sys/socket.h> /* for AF_INET */
+
+/* { from mrt.h */
+
+typedef struct _prefix4_t {
+    u_short family;		/* AF_INET | AF_INET6 */
+    u_short bitlen;		/* same as mask? */
+    int ref_count;		/* reference count */
+    struct in_addr sin;
+} prefix4_t;
+
+typedef struct _prefix_t {
+    u_short family;		/* AF_INET | AF_INET6 */
+    u_short bitlen;		/* same as mask? */
+    int ref_count;		/* reference count */
+    union {
+		struct in_addr sin;
+#ifdef HAVE_IPV6
+		struct in6_addr sin6;
+#endif /* IPV6 */
+    } add;
+} prefix_t;
+
+/* } */
+
+typedef struct _patricia_node_t {
+   u_int bit;			/* flag if this node used */
+   prefix_t *prefix;		/* who we are in patricia tree */
+   struct _patricia_node_t *l, *r;	/* left and right children */
+   struct _patricia_node_t *parent;/* may be used */
+   void *data;			/* pointer to data */
+   void	*user;		/* pointer to usr data (ex. route flap info) */
+} patricia_node_t;
+
+typedef struct _patricia_tree_t {
+   patricia_node_t 	*head;
+   u_int		maxbits;	/* for IP, 32 bit addresses */
+   int num_active_node;		/* for debug purpose */
+} patricia_tree_t;
+
+
+patricia_node_t *patricia_search_exact (patricia_tree_t *patricia, prefix_t *prefix);
+patricia_node_t *patricia_search_best (patricia_tree_t *patricia, prefix_t *prefix);
+patricia_node_t * patricia_search_best2 (patricia_tree_t *patricia, prefix_t *prefix, 
+				   int inclusive);
+patricia_node_t *patricia_lookup (patricia_tree_t *patricia, prefix_t *prefix);
+void patricia_remove (patricia_tree_t *patricia, patricia_node_t *node);
+patricia_tree_t *New_Patricia (int maxbits);
+void Clear_Patricia (patricia_tree_t *patricia, void_fn_t func);
+void Destroy_Patricia (patricia_tree_t *patricia, void_fn_t func);
+void patricia_process (patricia_tree_t *patricia, void_fn_t func);
+
+/* { from demo.c */
+
+prefix_t *
+ascii2prefix (int family, char *string);
+
+patricia_node_t *
+make_and_lookup (patricia_tree_t *tree, char *string);
+
+/* } */
+
+#define PATRICIA_MAXBITS 128
+#define PATRICIA_NBIT(x)        (0x80 >> ((x) & 0x7f))
+#define PATRICIA_NBYTE(x)       ((x) >> 3)
+
+#define PATRICIA_DATA_GET(node, type) (type *)((node)->data)
+#define PATRICIA_DATA_SET(node, value) ((node)->data = (void *)(value))
+
+#define PATRICIA_WALK(Xhead, Xnode) \
+    do { \
+        patricia_node_t *Xstack[PATRICIA_MAXBITS+1]; \
+        patricia_node_t **Xsp = Xstack; \
+        patricia_node_t *Xrn = (Xhead); \
+        while ((Xnode = Xrn)) { \
+            if (Xnode->prefix)
+
+#define PATRICIA_WALK_ALL(Xhead, Xnode) \
+do { \
+        patricia_node_t *Xstack[PATRICIA_MAXBITS+1]; \
+        patricia_node_t **Xsp = Xstack; \
+        patricia_node_t *Xrn = (Xhead); \
+        while ((Xnode = Xrn)) { \
+	    if (1)
+
+#define PATRICIA_WALK_BREAK { \
+	    if (Xsp != Xstack) { \
+		Xrn = *(--Xsp); \
+	     } else { \
+		Xrn = (patricia_node_t *) 0; \
+	    } \
+	    continue; }
+
+#define PATRICIA_WALK_END \
+            if (Xrn->l) { \
+                if (Xrn->r) { \
+                    *Xsp++ = Xrn->r; \
+                } \
+                Xrn = Xrn->l; \
+            } else if (Xrn->r) { \
+                Xrn = Xrn->r; \
+            } else if (Xsp != Xstack) { \
+                Xrn = *(--Xsp); \
+            } else { \
+                Xrn = (patricia_node_t *) 0; \
+            } \
+        } \
+    } while (0)
+
+#endif /* _PATRICIA_H */

data/rpatricia.c

@@ -0,0 +1,225 @@
+/*
+ *   rpatricia.c - Ruby wrapper of Net::Patricia
+ *   Tatsuya Mori <mori.tatsuya@gmail.com>
+ */
+
+#include "ruby.h"
+#include <stdio.h> /* printf */
+#include <stdlib.h>
+#include "patricia.h"
+
+VALUE cPatricia;
+
+void dummy(void) {}
+
+static VALUE
+p_destroy (VALUE self)
+{
+  patricia_tree_t *tree;
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  Destroy_Patricia(tree, free);
+  return Qtrue;
+}
+
+VALUE
+p_add (int argc, VALUE *argv, VALUE self)
+{
+  int str_len;
+  char *user_data;
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  prefix_t *prefix;
+
+  if (argc > 2 || argc < 1) 
+    return Qnil;
+
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  prefix = ascii2prefix(AF_INET, STR2CSTR(argv[0]));
+  node = patricia_lookup(tree, prefix);
+  Deref_Prefix(prefix);
+
+  if (argc == 2) {
+    user_data = STR2CSTR(argv[1]);
+    str_len = strlen(user_data);
+    node->data = (char *) malloc((str_len + 1) * sizeof(char));
+    sprintf((char *)node->data, user_data);
+  } else {
+    node->data = (char *) malloc(sizeof(char));
+    sprintf((char *)node->data, "");
+  }
+  return Data_Wrap_Struct(cPatricia, 0, 0, node);
+}
+
+static VALUE
+p_remove (VALUE self, VALUE r_key)
+{
+  char *c_key;
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  prefix_t *prefix;
+
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  c_key = STR2CSTR(r_key);
+  prefix = ascii2prefix (AF_INET, c_key);
+  node = patricia_search_exact(tree, prefix);
+  Deref_Prefix (prefix);
+
+  if (node) {
+    patricia_remove (tree, node);
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE
+p_match (VALUE self, VALUE r_key)
+{
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  prefix_t *prefix;
+  
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  prefix = ascii2prefix (AF_INET, STR2CSTR(r_key));
+  node = patricia_search_best(tree, prefix);
+  Deref_Prefix (prefix);
+
+  if (node)
+    return Data_Wrap_Struct(cPatricia, 0, 0, node);
+  else 
+    return Qfalse;
+
+}
+
+static VALUE
+p_match_exact (VALUE self, VALUE r_key)
+{
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  prefix_t *prefix;
+
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  prefix = ascii2prefix (AF_INET, STR2CSTR(r_key));
+  node = patricia_search_exact(tree, prefix);
+  Deref_Prefix (prefix);
+
+  if (node)
+    return Data_Wrap_Struct(cPatricia, 0, 0, node);
+  else 
+    return Qfalse;
+}
+
+static VALUE
+p_num_nodes (VALUE self)
+{
+  int n;
+  patricia_tree_t *tree;
+
+  Data_Get_Struct(self, patricia_tree_t, tree);
+  n = patricia_walk_inorder(tree->head, dummy);
+
+  return INT2NUM(n);
+}
+
+static VALUE
+p_print_nodes (VALUE self)
+{
+  int n;
+  char buff[32];
+  patricia_tree_t *tree;
+  patricia_node_t *node;
+  Data_Get_Struct(self, patricia_tree_t, tree);
+
+  PATRICIA_WALK(tree->head, node) {
+    prefix_toa2x(node->prefix, buff, 1);
+    printf("node: %s\n", buff);
+  } PATRICIA_WALK_END;
+  return Qtrue;
+}
+
+static VALUE
+p_data (VALUE self)
+{
+  patricia_node_t *node;
+  Data_Get_Struct(self, patricia_node_t, node);
+  return rb_str_new2((char *)node->data);
+}
+
+static VALUE
+p_network (VALUE self)
+{
+  char buff[32];
+  patricia_node_t *node;
+  Data_Get_Struct(self, patricia_node_t, node);
+  prefix_toa2x (node->prefix, buff, 0);
+  return rb_str_new2(buff);
+}
+
+static VALUE
+p_prefix (VALUE self)
+{
+  char buff[32];
+  patricia_node_t *node;
+  Data_Get_Struct(self, patricia_node_t, node);
+  prefix_toa2 (node->prefix, buff);
+  return rb_str_new2(buff);
+}
+
+static VALUE
+p_prefixlen (VALUE self)
+{
+  patricia_node_t *node;
+  Data_Get_Struct(self, patricia_node_t, node);
+  return INT2NUM(node->prefix->bitlen);
+}
+
+static VALUE
+p_new (VALUE self) 
+{
+  patricia_tree_t *tree;
+  tree = New_Patricia(32); /* assuming only IPv4 */
+  return Data_Wrap_Struct(cPatricia, 0, 0, tree);
+}
+
+void
+Init_rpatricia (void)
+{
+  cPatricia = rb_define_class("Patricia", rb_cObject);
+
+  /* create new Patricia object */
+  rb_define_singleton_method(cPatricia, "new", p_new, 0);
+
+  /*---------- methods to tree ----------*/
+  /* add string */
+  rb_define_method(cPatricia, "add", p_add, -1);
+  rb_define_method(cPatricia, "add_node", p_add, -1);
+
+  /* match prefix */
+  rb_define_method(cPatricia, "match_best", p_match, 1); 
+  rb_define_method(cPatricia, "search_best", p_match, 1); 
+
+  /* exact match  */
+  rb_define_method(cPatricia, "match_exact", p_match_exact, 1); 
+  rb_define_method(cPatricia, "search_exact", p_match_exact, 1); 
+
+  /* removal */
+  rb_define_method(cPatricia, "remove", p_remove, 1); 
+  rb_define_method(cPatricia, "remove_node", p_remove, 1); 
+
+  /* derivatives of climb */
+  rb_define_method(cPatricia, "num_nodes", p_num_nodes, 0);
+  rb_define_method(cPatricia, "show_nodes", p_print_nodes, 0); 
+
+  /* destroy tree */
+  rb_define_method(cPatricia, "destroy", p_destroy, 0); 
+  rb_define_method(cPatricia, "clear", p_destroy, 0); 
+
+  /*---------- methods to node ----------*/
+  rb_define_method(cPatricia, "data", p_data, 0);
+  rb_define_method(cPatricia, "show_data", p_data, 0);
+  rb_define_method(cPatricia, "network", p_network, 0);
+  rb_define_method(cPatricia, "prefix", p_prefix, 0);
+  rb_define_method(cPatricia, "prefixlen", p_prefixlen, 0);
+  //  rb_define_method(cPatricia, "family", p_family, 0); 
+
+}

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: rpatricia
+version: !ruby/object:Gem::Version 
+  version: "0.04"
+platform: ruby
+authors: 
+- Tatsuya Mori
+- Eric Wong
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-12 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: |-
+  This is a ruby wrapper of Net::Patricia, which has been developed by
+  Dave Plonka. The original Net::Patricia and its C API are available
+  from:
+  http://net.doit.wisc.edu/~plonka/Net-Patricia/
+  
+  Net::Patricia is a module for fast IP address/prefix lookups.
+  I have modified some interfaces for the Ruby wrapper version.
+email: normalperson@yhbt.net
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Changes
+- README
+- TODO
+- copyright
+- credits.txt
+- extconf.rb
+- patricia.c
+- patricia.h
+- rpatricia.c
+has_rdoc: true
+homepage: http://www.goto.info.waseda.ac.jp/~tatsuya/rpatricia/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: module for fast IP address/prefix lookups
+test_files: []
+