undns 0.4.0a

data/ext/undns/typed_hashtable.h

@@ -0,0 +1,158 @@
+/*
+ * 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 _typed_hashtable_h
+#define _typed_hashtable_h
+#include "hashtable.h"
+
+#define DECLARE_TYPED_HASHTABLE(type, pr)                                         \
+struct pr##hashtable_struct;                                                      \
+typedef struct pr##hashtable_struct *pr##_hashtable;                              \
+/*@unused@*/                                                                      \
+static __inline void                                                              \
+pr##_ht_delete(/*@only@*/ pr##_hashtable d, boolean pro) {                        \
+  ht_delete((hashtable)d, pro);                                                   \
+}                                                                                 \
+typedef unsigned int (*pr##_hash_fn)(const type *k);                              \
+typedef boolean (*pr##_iseq_fn)(const type *k1, const type *k2);                  \
+typedef type *(*pr##_ht_constructor_cb)(const type *k1);                          \
+typedef boolean (*pr##_ht_iterator_cb)(const type *keyval, void *user);           \
+typedef boolean (*pr##_ht_iterator_pair_cb)(const type *keyval, const type *keyval2);           \
+typedef boolean (*pr##_ht_iterator_cb_nc)(type *keyval, void *user);           \
+typedef boolean (*pr##_ht_delete_if_cb)(type *keyval, void *user);           \
+/* would be type *keyval, but c++ is unhappy about contravariance */              \
+typedef void (*pr##_ht_delete_cb)(void *keyval);                                  \
+/*@unused@*/                                                                      \
+static __inline pr##_hashtable                                                    \
+pr##_ht_new(unsigned int s,                                                       \
+            pr##_hash_fn hash, pr##_iseq_fn iseq,                                 \
+            pr##_ht_delete_cb freek) {                                            \
+  return((pr##_hashtable)ht_new(s, (hash_cb)hash, (isequal_cb)iseq,               \
+                                (delete_cb)freek));                               \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline void                                                              \
+pr##_ht_insert(pr##_hashtable h, /*@owned@*/ type *k) {                           \
+  ht_insert((hashtable)h, k);                                                     \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline boolean                                                           \
+pr##_ht_remove(pr##_hashtable h, type *k) {                                       \
+  return ht_remove((hashtable)h, k);                                              \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline unsigned int                                                      \
+pr##_ht_delete_if(pr##_hashtable h, pr##_ht_delete_if_cb c, /*@null@*/ void *a) { \
+  return ht_delete_if((hashtable)h, (ht_delete_if_cb)c, a);                       \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline /*@null@*/ /*@dependent@*/ type *                                 \
+pr##_ht_lookup(pr##_hashtable h, /*@out@*/ const type *k) {                       \
+   /*out = not neccessarily defined */                                            \
+  return((type *)ht_lookup((hashtable)h,k));                                      \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline /*@dependent@*/ type *                                            \
+pr##_ht_lookup_nofail(pr##_hashtable h,                                           \
+                         const type *key,                                         \
+                         type *(*constructor)(const type*k)) {                    \
+  return((type *)ht_lookup_nofail((hashtable)h, key, (ht_constructor_cb)constructor));    \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline boolean                                                           \
+pr##_ht_iterate(pr##_hashtable h,                                                 \
+                pr##_ht_iterator_cb cb,                                          \
+                void *user) {                                                     \
+  return(ht_iterate((hashtable)h,(ht_iterator_cb)cb,user));                       \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline boolean                                                           \
+pr##_ht_iterate_pairs(pr##_hashtable h, unsigned int nThreads, unsigned int chunkSize,   \
+                pr##_ht_iterator_pair_cb cb) {                                          \
+  return(ht_iterate_pairs((hashtable)h,nThreads,chunkSize,(ht_iterator_pair_cb)cb));                       \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline boolean                                                           \
+pr##_ht_iterate_nc(pr##_hashtable h,                                                 \
+                pr##_ht_iterator_cb_nc cb,                                          \
+                void *user) {                                                     \
+  return(ht_iterate((hashtable)h,(ht_iterator_cb)cb,user));                       \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline unsigned long                                                     \
+pr##_ht_count(pr##_hashtable h) {                                                 \
+return(ht_count((hashtable)h));                                                   \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline void                                                              \
+pr##_ht_occupancyjgr(const pr##_hashtable h, const char *fname) {                 \
+  ht_occupancyjgr((const hashtable)h, fname);                                     \
+}                                                                                 \
+                                                                                  \
+/*@unused@*/                                                                      \
+static __inline void                                                              \
+pr##_ht_free_entry(pr##_hashtable ht, type *keyval) {                             \
+  ht_free_entry((hashtable)ht, keyval);                                           \
+}
+
+#define DECLARE_TYPED_HASHTABLE_K(type, keytype, pr)                              \
+DECLARE_TYPED_HASHTABLE(type, pr);                                                \
+typedef unsigned int (*pr##_hash_k_fn)(const keytype *k);                         \
+typedef boolean (*pr##_iseq_k_fn)(const keytype *k1, const keytype *k2);          \
+/*@unused@*/                                                                      \
+static __inline /*@null@*/ /*@dependent@*/ type *                                 \
+pr##_ht_lookup_k(pr##_hashtable h, const keytype *k) {                            \
+  return((type *)ht_lookup((hashtable)h,k));                                      \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline /*@dependent@*/ type *                                            \
+pr##_ht_lookup_nofail_k(pr##_hashtable h,                                         \
+                         const keytype *key,                                      \
+                         type *(*constructor)(const type*k)) {                    \
+  return((type *)ht_lookup_nofail((hashtable)h, key, (ht_constructor_cb)constructor));    \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline /*@dependent@*/ type *                                            \
+pr##_ht_lookup_nofail_kk(pr##_hashtable h,                                        \
+                         const keytype *key,                                      \
+                         type *(*constructor)(const keytype*k)) {                 \
+  return((type *)ht_lookup_nofail((hashtable)h, key, (ht_constructor_cb)constructor));    \
+}                                                                                 \
+/*@unused@*/                                                                      \
+static __inline pr##_hashtable                                                    \
+pr##_ht_new_k(unsigned int s,                                                     \
+            pr##_hash_k_fn hash, pr##_iseq_k_fn iseq,                             \
+            /*@null@*/ pr##_ht_delete_cb freek) {                                 \
+  return((pr##_hashtable)ht_new(s, (hash_cb)hash, (isequal_cb)iseq,               \
+                                (delete_cb)freek));                               \
+}                                                                                 \
+
+
+
+#endif

data/ext/undns/typed_queue.h

@@ -0,0 +1,112 @@
+/*
+ * 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 _typed_queue_h
+#define _typed_queue_h
+#include "queue.h"
+
+#define DECLARE_TYPED_QUEUE(type, pr)                               \
+struct pr##queue_struct;                                            \
+typedef struct pr##queue_struct *pr##_queue;                        \
+struct pr##queue_element_struct;                                            \
+typedef struct pr##queue_element_struct *pr##_q_element;                        \
+/*@unused@*/                                                        \
+static __inline void                                                \
+pr##_q_delete(/*@only@*/ pr##_queue d) {                            \
+  q_delete((queue)d);                                               \
+}                                                                   \
+                                                                    \
+/*@unused@*/                                                        \
+static __inline pr##_queue                                          \
+pr##_q_new(/*@null@*/ int (*cmp)(const type *v1,                    \
+                      const type *v2),                              \
+           /*@null@*/ void (*relse)(void *)) {                      \
+  return((pr##_queue)q_new((q_comparator)cmp, relse));              \
+}                                                                   \
+                                                                    \
+/*@unused@*/                                                        \
+static __inline pr##_q_element                                      \
+pr##_q_insert(pr##_queue h, /*@owned@*/ type *k) {                  \
+  return((pr##_q_element)q_insert((queue)h, k));                    \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline pr##_q_element                                      \
+pr##_q_insert_fromdir(pr##_queue h, /*@owned@*/ type *k, boolean go_backwards) {                  \
+  return((pr##_q_element)q_insert_fromdir((queue)h, k, go_backwards));                    \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline void                                                \
+pr##_q_append(pr##_queue h, /*@owned@*/ type *k) {                  \
+  q_append((queue)h, k);                                            \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline boolean                                             \
+pr##_q_remove(pr##_queue h, type *k) {                              \
+  return(q_remove((queue)h, k));                                    \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline void                                                \
+pr##_q_expunge(pr##_queue h, pr##_q_element k) {                    \
+  return(q_expunge((queue)h, (q_element)k));                        \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline /*@null@*/ type *                                   \
+pr##_q_pop(pr##_queue h) {                                          \
+  return((type *)q_pop((queue)h));                                  \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline /*@null@*/ /*@dependent@*/ type *                   \
+pr##_q_top(pr##_queue h) {                                          \
+  return((type *)q_top((queue)h));                                  \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline boolean                                             \
+pr##_q_iterate(pr##_queue h,                                        \
+                boolean (*cb)(const type *keyval, void *user),      \
+                void *user) {                                       \
+  return(q_iterate((queue)h,(q_iterator)cb,user));                  \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline boolean                                             \
+pr##_q_iterate_nonconst(pr##_queue h,                               \
+                boolean (*cb)(type *keyval, void *user),            \
+                void *user) {                                       \
+  return(q_iterate((queue)h,(q_iterator)cb,user));                  \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline void *                                              \
+pr##_q_find(pr##_queue q, const type *findme) {                     \
+  return(q_find((queue)q,(const void *)findme));                    \
+}                                                                   \
+/*@unused@*/                                                        \
+static __inline unsigned long                                       \
+pr##_q_length(pr##_queue h) {                                       \
+  return(q_length((queue)h));                                       \
+}                                                                   
+#endif

data/ext/undns/xmalloc.c

@@ -0,0 +1,153 @@
+/* xmalloc.c -- malloc with out of memory checking
+   Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 99 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if __STDC__
+# define VOID void
+#else
+# define VOID char
+#endif
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#if ENABLE_NLS
+# include <libintl.h>
+# define _(Text) gettext (Text)
+#else
+# define textdomain(Domain)
+# define _(Text) Text
+#endif
+
+/* nspring: /usr/include/error.h, but perhaps I'm 
+   expected to distribute this?  (was "") */
+#ifdef __LCLINT__
+/*@exits@*/ 
+extern void error (int status, int errnum, const char *format, ...);
+#else
+#ifdef HAVE_ERROR_H
+#include <error.h>
+#endif
+#endif
+
+
+
+#ifndef EXIT_FAILURE
+# define EXIT_FAILURE 1
+#endif
+
+/* Prototypes for functions defined here.  */
+#if defined (__STDC__) && __STDC__
+static VOID *fixup_null_alloc (size_t n);
+VOID *xmalloc (size_t n);
+VOID *xcalloc (size_t n, size_t s);
+VOID *xrealloc (VOID *p, size_t n);
+char *xstrdup (const char *p);
+#endif
+
+
+/* Exit value when the requested amount of memory is not available.
+   The caller may set it to some other value.  */
+/*@-exportlocal@*/
+int xmalloc_exit_failure = EXIT_FAILURE;
+/*@+exportlocal@*/
+
+/* this is in error.h */
+#ifndef HAVE_ERROR_H
+#if __STDC__ && (HAVE_VPRINTF || HAVE_DOPRNT)
+void error (int, int, const char *, ...);
+#else
+void error ();
+#endif
+#endif
+
+static VOID *
+fixup_null_alloc (n)
+     size_t n;
+{
+  VOID *p;
+
+  p = 0;
+  if (n == 0)
+    p = malloc ((size_t) 1);
+  if (p == 0)
+    error (xmalloc_exit_failure, 0, _("Memory exhausted"));
+  return p;
+}
+
+/* Allocate N bytes of memory dynamically, with error checking.  */
+
+VOID *
+xmalloc (n)
+     size_t n;
+{
+  VOID *p;
+
+  p = malloc (n);
+  if (p == 0)
+    p = fixup_null_alloc (n);
+  return p;
+}
+
+/* Allocate memory for N elements of S bytes, with error checking.  */
+
+VOID *
+xcalloc (n, s)
+     size_t n, s;
+{
+  VOID *p;
+
+  p = calloc (n, s);
+  if (p == 0)
+    p = fixup_null_alloc (n);
+  return p;
+}
+
+/* Change the size of an allocated block of memory P to N bytes,
+   with error checking.
+   If P is NULL, run xmalloc.  */
+
+VOID *
+xrealloc (p, n)
+     VOID *p;
+     size_t n;
+{
+  if (p == 0)
+    return xmalloc (n);
+  p = realloc (p, n);
+  if (p == 0)
+    p = fixup_null_alloc (n);
+  return p;
+}
+
+/* Make a copy of a string in a newly allocated block of memory. */
+
+char *
+xstrdup (str)
+     const char *str;
+{
+  VOID *p;
+
+  p = xmalloc (strlen (str) + 1);
+  strcpy (p, str);
+  return p;
+}

data/ext/undns/xmalloc.h

@@ -0,0 +1,14 @@
+#include <stdio.h> /* size_t? */
+#if __STDC__
+# define VOID void
+#else
+# define VOID char
+#endif
+
+/* like the versions without the x, only never return NULL */
+/*@only@*/ /*@out@*/ /*@notnull@*/ 
+VOID *xmalloc (size_t n);
+
+VOID *xcalloc (size_t n, size_t s);
+VOID *xrealloc (VOID *p, size_t n);
+char *xstrdup (const char *p);

data/lib/undns.rb

@@ -0,0 +1,5 @@
+require 'undns/undns'
+
+module Undns
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: undns
+version: !ruby/object:Gem::Version
+  version: 0.4.0a
+platform: ruby
+authors:
+- Neil Spring
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-04 00:00:00.000000000 Z
+dependencies: []
+description: Undns parses router host names to extract geographic location and other
+  apparent information within the name.  It was initially developed as part of the
+  Rocketfuel project at the University of Washington.
+email: nspring@cs.umd.edu
+executables:
+- undns_decode
+extensions:
+- ext/undns/extconf.rb
+extra_rdoc_files: []
+files:
+- bin/undns_decode
+- ext/undns/buffer.c
+- ext/undns/buffer.h
+- ext/undns/config.h
+- ext/undns/conventions.c
+- ext/undns/conventions.h
+- ext/undns/conventlex.c
+- ext/undns/earth.c
+- ext/undns/earth.h
+- ext/undns/exception.h
+- ext/undns/extconf.rb
+- ext/undns/filetest.c
+- ext/undns/filetest.h
+- ext/undns/hashes.c
+- ext/undns/hashes.h
+- ext/undns/hashtable.c
+- ext/undns/hashtable.h
+- ext/undns/my_ruby.h
+- ext/undns/nscommon.h
+- ext/undns/originAS.c
+- ext/undns/originAS.h
+- ext/undns/progress.c
+- ext/undns/progress.h
+- ext/undns/queue.c
+- ext/undns/queue.h
+- ext/undns/radix.c
+- ext/undns/radix.h
+- ext/undns/ruleset.c
+- ext/undns/ruleset.h
+- ext/undns/swig-undns_wrap-rb.c
+- ext/undns/typed_hashtable.h
+- ext/undns/typed_queue.h
+- ext/undns/xmalloc.c
+- ext/undns/xmalloc.h
+- lib/undns.rb
+homepage: http://www.scriptroute.org/
+licenses:
+- GPL
+metadata: {}
+post_install_message: 'Now run: undns_decode [router name]'
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Undns client in ruby
+test_files: []
+has_rdoc: