undns 0.4.0a

data/ext/undns/earth.c

@@ -0,0 +1,180 @@
+#define _GNU_SOURCE
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+
+#ifdef HAVE_GNUREGEX_H
+#include <gnuregex.h>
+#else
+#include <regex.h>
+#endif
+
+#include "xmalloc.h"
+#include "nscommon.h"
+#include "typed_hashtable.h"
+
+struct location_table_entry {
+  char *place;
+  float latitude;
+  float longitude;
+};
+
+static unsigned int hash_lte(const struct location_table_entry *sbs) {
+  unsigned int ret;
+  const char *p;
+  for(ret=0, p=sbs->place; p!= NULL && *p!='\0'; p++)
+    ret += (unsigned int) *p;
+  return ret;
+}
+
+static boolean isequal_lte(const struct location_table_entry *sbs1,
+                          const struct location_table_entry *sbs2) {
+  return( strcmp(sbs1->place, sbs2->place) == 0 );
+}
+
+DECLARE_TYPED_HASHTABLE(struct location_table_entry, lte);
+
+lte_hashtable loctable;
+
+/* load geo/LocationTable, which is a "'d place name, followed
+   by decimal latitude and longitude, may be negative (west or south) */
+void init_earth(const char *LocationTableFilename) {
+  FILE *ltfp = fopen(LocationTableFilename, "r");
+  char regex[] = "^\"([^\"]+)\" *(-?[0-9\\.]+) *(-?[0-9\\.]+)"; 
+  char linebuf[255];
+  if(ltfp == NULL) {
+    printf("Unable to load %s as location table\n", 
+           LocationTableFilename);
+    return;
+  }
+#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 = 
+      re_compile_pattern(regex, strlen(regex), &rpbuf);
+    if (errstr != NULL) {
+      fprintf(stderr, "error in compiling regular expression: %s\n",
+              errstr);
+      return;
+    }
+  }
+  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) {
+      char *err = malloc(256);
+      err[255]='\0';
+      regerror(error, &rpbuf, err, 255);
+      fprintf(stderr, "error in compiling regular expression '%s': %s\n", regex, err);
+      free(err);
+      return;
+    }
+  }
+#endif
+  /* todo - free lte's (not that it matters) */
+  loctable = lte_ht_new(200, hash_lte, isequal_lte, NULL);
+
+  while(fgets(linebuf,255,ltfp)) {
+    NEWPTRX(struct location_table_entry, newlte);
+#ifdef DEPRECATED_GNU_REGEX
+    int matchedchars = re_match(&rpbuf, linebuf, strlen(linebuf), 0, &regs);
+    if (matchedchars <= 0) {
+      /* may be unnecessary to print this out to stderr. */
+      fprintf(stderr, "init_earth: Couldn't parse line: %s", linebuf);
+      free(newlte);
+      continue;
+    }
+    newlte->place = malloc(regs.end[1] - regs.start[1] + 1);
+    strncpy(newlte->place, linebuf+regs.start[1], regs.end[1]-regs.start[1]);
+    newlte->place[ regs.end[1] - regs.start[1] ] = '\0';
+    if(lte_ht_lookup(loctable, newlte) == NULL) {
+      newlte->latitude = atof(linebuf+regs.start[2]);
+      newlte->longitude = atof(linebuf+regs.start[3]);
+      lte_ht_insert(loctable, newlte);
+    } else {
+      free(newlte->place);
+      free(newlte);
+    }
+#else
+    int reg_ret = regexec(&rpbuf, linebuf, REGS_LEN, regs, 0);
+    if(reg_ret == REG_NOMATCH) {
+      fprintf(stderr, "init_earth: Couldn't parse line: %s", linebuf);
+      free(newlte);
+      continue;
+    }
+    newlte->place = malloc(regs[1].rm_eo - regs[1].rm_so + 1);
+    strncpy(newlte->place, linebuf+regs[1].rm_so, regs[1].rm_eo-regs[1].rm_so);
+    newlte->place[ regs[1].rm_eo - regs[1].rm_so ] = '\0';
+    if(lte_ht_lookup(loctable, newlte) == NULL) {
+      newlte->latitude = atof(linebuf+regs[2].rm_so);
+      newlte->longitude = atof(linebuf+regs[3].rm_so);
+      lte_ht_insert(loctable, newlte);
+    } else {
+      free(newlte->place);
+      free(newlte);
+    }
+#endif
+  }
+}
+
+#define PIOVER ((double)0.017453293)
+/* in meters: */
+#define RADIUS (6367000)
+/* meters per second through glass */
+/* according to http://www.play-hookey.com/optics/fiber5.html */
+#define SOL (200000000) 
+
+/* calculate distance between places.  replace +'s in
+   place names with spaces for lookup. */
+double min_latency_seconds(const char *place1, const char *place2) {
+  struct location_table_entry lookup1;
+  struct location_table_entry lookup2;
+  struct location_table_entry *found1, *found2;
+  char *p;
+
+  assert(loctable != NULL);
+
+  lookup1.place = strdup(place1);
+  lookup2.place = strdup(place2);
+  assert(lookup1.place != NULL);
+  assert(lookup2.place != NULL);
+
+  for(p=lookup1.place; *p!='\0'; p++) if(*p=='+') *p = ' ';
+  for(p=lookup2.place; *p!='\0'; p++) if(*p=='+') *p = ' ';
+  
+  found1 = lte_ht_lookup(loctable, &lookup1);
+  found2 = lte_ht_lookup(loctable, &lookup2);
+
+  free(lookup1.place);
+  free(lookup2.place);
+
+  if(found1 != NULL && found2 != NULL ) {
+    double lat1 = found1->latitude * PIOVER;
+    double lat2 = found2->latitude * PIOVER;
+    double lon1 = found1->longitude * PIOVER;
+    double lon2 = found2->longitude * PIOVER;
+    double sindlat = sin(( lat2 - lat1)/2.0);
+    double sindlon = sin(( lon2 - lon1)/2.0);
+    double a = sindlat * sindlat + cos(lat1) * cos(lat2) * sindlon * sindlon;
+    double c = 2.0 * atan2(sqrt(a), sqrt(1.0-a)) ;
+      double d = RADIUS * c;
+      // fprintf(stderr, "min_latency_seconds returning %5.3f\n", d/(double)SOL);
+      return (d / (double)SOL);
+  }
+  return(-1.0);
+
+
+}
+

data/ext/undns/earth.h

@@ -0,0 +1,4 @@
+/* (c) neil spring 2002 */
+
+void init_earth(const char *LocationTableFilename);
+double min_latency_seconds(const char *place1, const char *place2);

data/ext/undns/exception.h

@@ -0,0 +1,12 @@
+
+/* wouldn't ordinarily use exceptions, but it seemed 
+   useful for integration with the scripting languages.
+   These routines define the signature, exception.c is 
+   only linked when requisite symbols aren't provided 
+   by swig/the interpreter.
+*/
+void clear_exception(void);
+void throw_exception(const char *msg);
+const char *check_exception(void);
+
+#define throw_void(m)  { throw_exception(m); return; }

data/ext/undns/extconf.rb

@@ -0,0 +1,44 @@
+require "mkmf"
+
+# this file is responsible for building a makefile that
+# eventually builds the undns.so or undns.dylib extension.
+
+puts "hello"
+
+$defs.push("-DHAVE_CONFIG_H")
+# if have_library('pthread', 'pthread_cond_init') then
+        $defs.push("-DHAVE_LIBPTHREAD")
+# end
+have_header('gnuregex.h')
+have_header('stdint.h')
+have_header('unistd.h')
+have_header('error.h')
+have_header('sys/types.h')
+have_header('sys/time.h')
+have_header('ruby/io.h')
+have_func('snprintf')
+$defs.push('-DPKGDATADIR=\"$(RUBYCOMMONDIR)\"')
+$defs.push('-DONIG_ESCAPE_REGEX_T_COLLISION')  # deep in there is a typedef
+
+# create_header('config.h')
+
+# CONFIG["DLDFLAGS"].gsub!(/multiply_definedsuppress/, 'multiply_defined suppress')
+# CONFIG["LIBRUBY_DLDFLAGS"].gsub!(/multiply_definedsuppress/, 'multiply_defined suppress')
+
+create_makefile('undns')
+
+# since I develop on the busted mac; this fragment from
+# Phusion Passenger.
+if RUBY_PLATFORM =~ /darwin/
+  # The OS X Clang 503.0.38 update (circa March 15 2014)
+  # broke /usr/bin/ruby's mkmf. mkmf inserts
+  # -multiply_definedsuppress into the Makefile, but that
+  # flag is no longer supported by Clang. We remove this
+  # manually.
+  makefile = File.read("Makefile")
+  makefile.sub!(/-multiply_definedsuppress/, "")
+  File.open("Makefile", "w") do |f|
+    f.write(makefile)
+    end
+end
+

data/ext/undns/filetest.c

@@ -0,0 +1,90 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include "filetest.h"
+
+boolean fileExists(const char *filename) {
+  struct stat s; 
+  if(stat(filename,&s)== 0) {
+    if(S_ISREG(s.st_mode)) {
+      return TRUE;
+      /*     } else {
+             printf("%s is not a regular file\n", filename); */
+    }
+  } 
+  return FALSE;
+}
+boolean fileIsNewerThan(const char *filename, struct timeval *tv) {
+  struct stat s; 
+  if(stat(filename,&s)== 0) {
+    // mac defines mtimespec, which is more precise, but doesn't 
+    // appear universal.
+    if(s.st_mtime >= tv->tv_sec) { 
+      return TRUE;
+    }
+  } 
+  return FALSE;
+}
+
+boolean dirExists(const char *dirname) {
+  struct stat s; 
+  if(stat(dirname,&s)== 0) {
+    if(S_ISDIR(s.st_mode)) {
+      return TRUE;
+      /* } else {
+         printf("%s is not a directory\n", dirname); */
+    }
+  } 
+  return FALSE;
+}
+
+/* acts like execvp, with code inspired by it */
+/* mustfree */
+/*@null@*/
+char *searchPath(/*@null@*/ const char *path,	
+                 /*@notnull@ */ const char *find_me)
+{
+	char *buf;
+	const char *p;
+	int len, pathlen;
+    if (path == NULL) return NULL;
+	/* if (strchr(find_me, '/') != NULL) { */
+	if (find_me[0] == '/' || find_me[0] == '.') {
+		return (strdup_ordie(find_me));
+	}
+	pathlen = strlen(path);
+	len = strlen(find_me) + 1;
+	buf = malloc_ordie(pathlen + len + 1);
+	memcpy(buf + pathlen + 1, find_me, len);
+	buf[pathlen] = '/';
+
+	for (p = path; p != NULL; path = p, path++) {
+		char *startp;
+		p = strchr(path, ':');
+		if (p == NULL) {
+			/* not found; p should point to the null char at the end */
+			startp =
+				memcpy(buf + pathlen - strlen(path), path, strlen(path));
+		} else if (p == path) {
+			/* double colon in a path apparently means try here */
+			startp = &buf[pathlen + 1];
+		} else {
+			/* copy the part between the colons to the buffer */
+			startp = memcpy(buf + pathlen - (p - path), path, p - path);
+		}
+		if (fileExists(startp) != 0) {
+			char *ret = strdup_ordie(startp);
+			free(buf);
+			return (ret);
+		}
+	}
+	free(buf);
+	return (NULL);
+}

data/ext/undns/filetest.h

@@ -0,0 +1,7 @@
+#include "nscommon.h"
+
+boolean fileExists(const char *filename);
+boolean fileIsNewerThan(const char *filename, struct timeval *tv);
+boolean dirExists(const char *filename);
+char *searchPath(/*@null@*/ const char *path,	
+                 /*@notnull@ */ const char *find_me);

data/ext/undns/hashes.c

@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "nscommon.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h> 
+#include <sys/socket.h> /* AF_INET */
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+#include "hashes.h"
+
+unsigned int mac_hash(const void *key) {
+  unsigned int retval; // this is a pretty damn useless hash.
+  const macaddress *mac1 = key;
+  retval=(unsigned int)(*mac1*1109); // prime.
+  return(retval);
+}
+
+// * uses key as a pointer * 
+unsigned int ip_hash(const void *key) {
+  const unsigned long *addr = key;
+  return(*addr*12917);
+}
+
+// * uses key as an integer *
+unsigned int port_hash(const void *key) {
+  return((unsigned int)key);
+}
+
+unsigned int string_hash(const char *obj) {
+  unsigned int h= 0;  // seed with the server.
+  unsigned int i;
+  assert(obj!=NULL);
+  for(i=0; i<256 && obj[i]!='\0'; i++){
+    h*=307;
+    h+=(unsigned int) obj[i];
+  }
+  return h;
+}
+unsigned int pstring_hash(const hash_cptr *key) {
+  return(string_hash(*key));
+}
+
+boolean mac_isequal(const void *v1, const void *v2) {
+  const macaddress *mac1 = v1;
+  const macaddress *mac2 = v2;
+  return((*mac1==*mac2) ? TRUE : FALSE);
+}
+boolean ip_isequal(const void *v1, const void *v2) {
+  const unsigned long *addr1 = v1;
+  const unsigned long *addr2 = v2;
+  return((*addr1==*addr2) ? TRUE : FALSE);
+}
+boolean port_isequal(const void *key1, const void *key2) {
+  return((key1==key2) ? TRUE : FALSE);
+}
+boolean string_isequal(const char *v1, const char *v2) {
+  return( (strcmp(v1,v2)==0) ? TRUE : FALSE);
+}
+boolean pstring_isequal(const hash_cptr *v1, const hash_cptr *v2) {
+  return(string_isequal(*v1, *v2));
+}
+
+boolean sockaddr_in_isequal(const struct sockaddr_in *v1, const struct sockaddr_in *v2) {
+  assert(v1->sin_family == AF_INET);
+  assert(v2->sin_family == AF_INET);
+  return ( v1->sin_port == v2->sin_port && memcmp(&v1->sin_addr, &v2->sin_addr, sizeof(struct in_addr)) == 0);
+}
+
+unsigned int sockaddr_in_hash(const struct sockaddr_in *v) {
+  return(v->sin_addr.s_addr*12917 + v->sin_port);
+}