undns 0.4.0a

data/ext/undns/radix.h

@@ -0,0 +1,72 @@
+#include "nscommon.h"
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifndef __LCLINT__
+#include <arpa/inet.h>
+#endif
+#include <stdio.h>
+
+// #ifdef __linux__ 
+// #define ADDR_T in_addr_t
+// #else
+#define ADDR_T u_int32_t
+// #endif
+
+typedef ADDR_T address;
+typedef unsigned char prefixlen_t;
+/* typedef struct patricia_entry *patricia_entry; */
+/* typedef struct patricia_table *patricia_table; */
+
+struct patricia_entry {
+  address destination;
+  prefixlen_t prefixlen;
+  unsigned char position;
+  void *data;
+  struct patricia_entry *on,*off;
+};
+
+struct patricia_table {
+ /*@null@*/ struct patricia_entry *routes;
+ /*@null@*/ struct patricia_entry *default_route;
+};
+
+/* externally useful bits */
+struct patricia_table *patricia_new(void);
+void patricia_delete(/*@only@*/ struct patricia_table * p, void (*data_free)(void *));
+void patricia_insert(struct patricia_table *pt, address a, 
+                     unsigned char prefixlen, /*@owned@*/void *data);
+/*@null@*//* just get the data *//*@dependent@*/
+void *patricia_lookup(struct patricia_table *pt, address a); 
+/* get it all */
+boolean patricia_lookup_all(struct patricia_table * pt, 
+                            address a, 
+                            /*@out@*/ address *prefix, 
+                            /*@out@*/ prefixlen_t *prefixlen, 
+                            /*@out@*/ void **data);
+void patricia_dump(struct patricia_table *pt, const char *filename);
+
+/* slightly less useful */
+/*@null@*//*@dependent@*/ 
+struct patricia_entry *
+radix_resolve_route(/*@null@*/
+                    struct patricia_entry *top, 
+                    address destination);
+void *get_data(const struct patricia_entry *r);
+
+/* somewhat useful bits */
+void set_data(struct patricia_entry *r, void *data);
+
+void radix_insert(struct patricia_entry **p, /*@owned@*//*@partial@*/struct patricia_entry *r);
+
+void radix_remove_route(struct patricia_table *n,
+                        address destination,
+                        unsigned char prefixlen);
+
+void radix_print_routing_table_text(/*@null@*/const struct patricia_entry *r, 
+                                    FILE *fdout);
+void radix_print_routing_table_dot(/*@null@*/const struct patricia_entry *r, 
+                                   int fd);
+
+address radix_mask(address addr, prefixlen_t prefix);
+boolean radix_test_export(address addr, prefixlen_t x); // used by check_radix, real thing is static so as to be inlined.

data/ext/undns/ruleset.c

@@ -0,0 +1,603 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include "ruleset.h"
+#include "exception.h"
+#include "filetest.h"
+
+const char *input_filename;
+extern boolean want_debug;
+extern boolean want_conventions_debug;
+boolean Had_an_error = FALSE;
+
+void set_conventions_debug(boolean v) {
+  want_conventions_debug = v;
+}
+static void tally_asnc(struct asnc *matched);
+
+extern FILE *conv_yyin;
+extern int conv_yyparse(void);
+
+asnc_hashtable Ruleset;
+
+#define DM(args...) if(want_debug) { fprintf(stderr, args); }
+
+boolean is_nonempty(FILE *fp) {
+  struct stat st;
+  if( fstat(fileno(fp), &st) < 0) return FALSE;
+  return(st.st_size > 0);
+}
+
+#ifndef PKGDATADIR
+#define PKGDATADIR DATADIR "/" PACKAGE_NAME
+#endif
+
+const char *ruleset_path = ".:..:" PKGDATADIR ":/usr/local/share/undns:/usr/share/undns";
+
+extern void set_file_and_line(struct instrumentation *inst, const char *file, unsigned int line) {
+  memset(inst, 0, sizeof(struct instrumentation));
+
+  inst->file = strdup(file); /* might be leaky, worse is very space inefficient.  but let's see that 
+                                it works firs before using string bindings to make it fast */
+  inst->line = line;
+  inst->dynamic_match_count = 0; /* shouldn't need this with the memset above... but wtf?  I do! crap.*/
+  inst->doubt_count = 0; /* shouldn't need this with the memset above... but wtf?  I do! crap.*/
+  
+}
+extern const char *inst_get_filename(const struct instrumentation *inst) {
+  return inst->file; /* because I might reorganize this to use string bindings to compress. */
+}
+static const char *inst_format_stats(char *buf, unsigned int buflen, const struct instrumentation *inst) {
+  assert(inst);
+  assert(inst->file);
+  assert(buf);
+  assert(buflen > 20); /* sanity, not safety */
+  if (inst->dynamic_match_count > 0) {
+    if (inst->doubt_count > 0) {
+      snprintf(buf, buflen-1, "%s:%d - matches: %d, doubts: %d", inst_get_filename(inst), inst->line, inst->dynamic_match_count, inst->doubt_count);
+    } else {
+      snprintf(buf, buflen-1, "%s:%d - matches: %d", inst_get_filename(inst), inst->line, inst->dynamic_match_count);
+    }
+  } else {
+    snprintf(buf, buflen-1, "%s:%d - unmatched", inst_get_filename(inst), inst->line);
+  }
+  return buf;
+}
+
+/* also invoked by originAS.c */
+/*@null@*/ FILE *
+fopen_path_r(const char *filename) {
+  char *fullpath = searchPath(ruleset_path, filename);
+  if(fullpath != NULL) {
+    FILE * ret;
+    if(!fileExists(fullpath)) {
+      fprintf(stderr, "bug! path lookup failed. path: '%s', file '%s'\n",
+              ruleset_path, filename);
+    }
+    /* 
+    if(want_debug) {
+      fprintf(stderr, "found %s at %s %s\n", 
+              filename, fullpath, fileExists(fullpath) ? "!" : "not.");
+    }
+    */
+    ret = fopen(fullpath, "r");
+    free(fullpath);
+    return ret;
+  } else {
+    errno = ENOENT;
+    return NULL;
+  }
+}
+
+/* returns true if all good, false if there was a parse error */
+void load_ruleset(const char *filename) {
+  FILE *fp;
+  if(filename == NULL) {
+    throw_void("load_ruleset: no filename to load\n");
+  }
+  fp=fopen_path_r(filename);
+  if(fp != NULL) {
+    if(is_nonempty(fp)) {
+      input_filename = filename;
+      conv_yyin=fp;
+      (void)conv_yyparse();
+    }
+    (void)fclose(fp);
+  } else {
+    char err[255];
+    sprintf(err, "ruleset '%s': %s\n", filename, strerror(errno));
+    throw_void(err);
+  }
+  if(Had_an_error) {
+    throw_void("undns is aborting due to previous errors\n");
+  }
+}
+
+#define REGS_LEN 10
+struct fmr {
+  const char *hostname;
+  struct convention *match; /* not const, since we will increment stats. */
+#ifdef DEPRECATED_GNU_REGEX
+  struct re_registers regs;
+#else
+  regmatch_t posix_regs[REGS_LEN];
+#endif
+};
+
+/* returns TRUE if we need to continue trying rules
+   returns FALSE if we found our match */
+static boolean 
+try_rule(const struct convention *c, void *fmr) {
+  struct fmr *f = fmr;
+  /* int matchedchars; */
+#ifdef DEPRECATED_GNU_REGEX
+  int matchoffset;
+#endif
+  assert(f->match == NULL);
+  assert(f->hostname != NULL);
+  assert(c != NULL);
+
+  /* f->regs.num_regs = REGS_UNALLOCATED; */
+  /* matchedchars = re_match(&((struct convention *)c)->rpbuf,
+     f->hostname, strlen(f->hostname), 0, &f->regs); */
+#ifdef DEPRECATED_GNU_REGEX
+  matchoffset = re_search(&((struct convention *)c)->rpbuf,
+                            f->hostname, strlen(f->hostname), 0, strlen(f->hostname), &f->regs); 
+  DM("matching %s to %s: %d\n", c->regex, f->hostname, matchoffset);
+  /* if(matchedchars > 0) { */
+  if(matchoffset >= 0) {
+    DM("matched!\n");
+    f->match = c;
+    return FALSE;
+  } else {
+    return TRUE;
+  }
+#else
+  {
+    int reg_ret = regexec(&((struct convention *)c)->rpbuf, f->hostname, 
+                          REGS_LEN, f->posix_regs, 0);
+    if(reg_ret == REG_NOMATCH) {
+      return TRUE;
+    } else {
+      f->match = (struct convention *)c; /* de-const. */
+      return FALSE;
+    }
+  }
+    
+#endif
+}
+
+static void copy_substring(char *destination,
+                    long long startidx, long long endidx, const char *source) {
+  if (startidx > -1) {
+    strncpy(destination, source + startidx, endidx - startidx);
+    destination[endidx - startidx] = '\0';
+  }
+}
+
+static struct stringpair *extract_key_and_find_binding(struct key_decl *kd, 
+#ifdef DEPRECATED_GNU_REGEX
+                                struct re_registers *regs, 
+#else
+                                regmatch_t *posix_regs, 
+#endif
+                                const char *hostname, 
+                                char *key /* out */) {
+  assert(kd->bindings); /* expects that the caller has already ensured that there are bindings involved. */
+
+  /* extract the "key" portion of the hostname from the regex match, which only identifies the substring range. */
+#ifdef DEPRECATED_GNU_REGEX
+  assert(regs->start[kd->regex_index] > -1);
+  copy_substring(key, regs->start[kd->regex_index],
+                 regs->end[kd->regex_index],
+                 hostname);
+#else
+  if( posix_regs[kd->regex_index].rm_so == -1) {
+    fprintf(stderr, "%s:%d Problem in ruleset found for hostname '%s' where the index of the match is out of range\n", __FILE__, __LINE__, hostname);
+    abort();
+  }
+  copy_substring(key, posix_regs[kd->regex_index].rm_so,
+                 posix_regs[kd->regex_index].rm_eo,
+                 hostname);
+#endif
+
+  DM("matched %s %skey %s in %s\n",
+     (kd->id ==attr_loc) ? "loc" : "type",
+     (kd->isDefault) ? "default " : "",
+     key, hostname);
+  DM("seeking in %lu entries\n", key_ht_count(kd->bindings));
+  return key_ht_lookup_k(kd->bindings, &key);
+
+}
+
+static void tally_stringpair(struct key_decl *kd, struct stringpair *matched);
+static void count_incomplete_keydecl(struct key_decl *matched);
+const char *kdlookup(struct key_decl *kd, 
+#ifdef DEPRECATED_GNU_REGEX
+                     struct re_registers *regs, 
+#else
+                     regmatch_t *regs, 
+#endif
+                     const char *hostname) {
+  char key[128];
+  struct stringpair *found_binding;
+
+  if(kd == NULL) { return NULL; }
+  if(kd->constant != NULL) { return(kd->constant); }
+
+  found_binding = extract_key_and_find_binding(kd, regs, hostname, key);
+
+  if(found_binding != NULL) {
+    DM("returning found %s\n", found_binding->value);
+    tally_stringpair(kd, found_binding);
+    return(found_binding -> value);
+  } else if(kd->isDefault) {
+    DM("returning %s\n", key);
+    return(strdup(key));
+  } else {
+    /* not found; although we have a key_decl and this pattern matched, the keys 
+       don't include what we have. */
+    count_incomplete_keydecl(kd);  /* tally it as a doubt on the keydecl as a whole. */
+    
+    if(want_conventions_debug) {
+      if(kd->id == attr_loc) {
+        DM("undns: Unknown location tag %s in %s\n", 
+           key, hostname); 
+        if(want_conventions_debug) {
+          return "Unknown Location with Hash";
+        }
+      }
+      return NULL;
+    } else {
+      DM("returning null\n");
+      return NULL;
+    }
+  }
+}
+
+boolean find_matching_rule(const struct asnc *ac, void *fmr) {
+  struct fmr *f = fmr;
+  assert(ac != NULL);
+  /* zero is an okay special case, neg 1 is a special case. */
+  assert((ac->asn >= 0 && ac->asn <40000) || ac->asn==65535);
+  if(ac->prefilter_regex != NULL) {
+#ifdef DEPRECATED_GNU_REGEX
+    size_t len = strlen(f->hostname);
+    int matchoffset = re_search(&((struct asnc *)ac)->prefilter_rpbuf, 
+                                f->hostname, len, 0, len, NULL); 
+    if(matchoffset >= 0) {
+      /* matched. */
+      tally_asnc((struct asnc *)ac); /* de-const. */
+      return(conv_q_iterate( ac->conventions, try_rule, f ));
+    } else {
+      return(TRUE); /* keep looking */
+    }
+#else
+    int reg_ret = regexec(&((struct asnc *)ac)->prefilter_rpbuf, 
+                          f->hostname, 0, NULL, 0); 
+    if(reg_ret == REG_NOMATCH) {
+      return TRUE;
+    } else {
+      /* matched. */
+      tally_asnc((struct asnc *)ac); /* de-const. */
+      return(conv_q_iterate( ac->conventions, try_rule, f ));
+    }
+#endif
+  }
+  /* no prefilter.  tally if conv_q_iterate returns false (found) */
+  if (conv_q_iterate( ac->conventions, try_rule, f )) {
+    return TRUE; /* not found, keep looking */
+  } else {
+    tally_asnc((struct asnc *)ac); /* de-const. */
+    return FALSE;
+  }
+    // return(conv_q_iterate( ac->conventions, try_rule, f ));
+}
+
+boolean find_matching_rule_nonzero(const struct asnc *ac, void *fmr) {
+  assert(ac != NULL);
+  if( ac->asn == 0 ) return TRUE; /* keep looking */
+  else return find_matching_rule(ac, fmr);
+}
+
+static void doubt_tally(struct convention *matched) {
+  DM("increment doubt count for convention %s:%d\n", inst_get_filename(&matched->inst), matched->inst.line);
+  matched->inst.dynamic_match_count -= 1; /* because we had to find it again */
+  matched->inst.doubt_count += 1;
+}
+static void tally(struct convention *matched) {
+  DM("increment match count for convention %s:%d\n", inst_get_filename(&matched->inst), matched->inst.line);
+  matched->inst.dynamic_match_count += 1;
+}
+static void count_incomplete_keydecl(struct key_decl *matched)  {
+  matched->inst.doubt_count += 1;
+}
+static void tally_asnc(struct asnc *matched) {
+  DM("increment match count for asn %s:%d\n", inst_get_filename(&matched->inst), matched->inst.line);
+  matched->inst.dynamic_match_count += 1;
+}
+static void tally_stringpair(struct key_decl *kd, struct stringpair *matched) {
+  DM("increment match count for stringpair %s:%d\n", inst_get_filename(&matched->inst), matched->inst.line);
+  matched->inst.dynamic_match_count += 1;
+  kd->inst.dynamic_match_count += 1;
+}
+static void doubt_stringpair(struct stringpair *matched) {
+  DM("increment match count for stringpair %s:%d\n", inst_get_filename(&matched->inst), matched->inst.line);
+  matched->inst.doubt_count += 1;
+}
+
+/* const before the * means we don't mess with the pointer value, just what it points to. */
+boolean find_host_convention(/*@out@*/ struct fmr *f, int asn, 
+                             /*@notnull@*/ const char *hostname) {
+  assert(f);
+  memset(f,0,sizeof(struct fmr));
+  f->hostname = hostname;
+  if(Ruleset == NULL) load_ruleset("Conventions.dat");
+  if(Ruleset == NULL) {
+    fprintf(stderr, "ERROR: find_host_convention failed to load Conventions.dat.\n");
+    return (FALSE);
+  } 
+  if(asn == 0) {
+    /* only search nonzero ASes first, */
+    (void) asnc_ht_iterate(Ruleset, find_matching_rule_nonzero, f);
+    if(f->match == NULL) {
+      int zero = 0;
+      const struct asnc *ac = asnc_ht_lookup_k(Ruleset, &zero);
+      /* then it's okay to look at the default rules (as 0) */
+      if( ac != NULL) find_matching_rule(ac, f);
+    }
+  } else {
+    const struct asnc *ac = asnc_ht_lookup_k(Ruleset, &asn);
+    if (ac == NULL) {
+      fprintf(stderr, 
+              "ERROR: find_host_convention called, but failed to find an asn "
+              "convention for asn %d among %lu asns\n", 
+              asn, asnc_ht_count(Ruleset));
+      return(FALSE);
+    }
+    find_matching_rule(ac, f);
+  }
+  if(f->match) {
+    tally(f->match);
+  }
+  
+  return(f->match != NULL);
+}
+
+void doubt_location(int asn, const char *hostname) {
+  struct fmr f;
+  assert(hostname);
+  if(find_host_convention(&f, asn, hostname)) {
+    char key[128];
+    doubt_tally(f.match);
+    if(f.match->loc) {
+      if(f.match->loc->constant == NULL) {
+        struct stringpair *found_binding = extract_key_and_find_binding(f.match->loc, f.posix_regs, hostname, key);
+        if(found_binding) {
+          doubt_stringpair(found_binding);
+        }
+      }
+    }
+  }
+}
+
+const char *get_attribute(int asn, const char *hostname, enum attributetype attr) {
+  struct fmr f;
+  assert(hostname != NULL);
+  memset(&f, 0, sizeof(f)); /* needed when debugging. */
+  if(find_host_convention(&f, asn, hostname)) {
+    DM("found match for %s\n", hostname);
+    const char *returnme = kdlookup((attr == attr_loc) ? f.match->loc : f.match->type, 
+                                    f.posix_regs, 
+                                    hostname);
+    if(returnme == NULL) {
+    }
+    return returnme;
+  } else {
+    /* there was no convention matching this hostname in that asn. */
+    DM("no match for %s\n", hostname);
+    return NULL;
+  }
+}
+
+const char *get_loc(int asn, const char *hostname) {
+  return(get_attribute(asn, hostname, attr_loc));
+}
+int get_asn_bydns(const char *hostname) {
+  struct fmr f;
+  if(hostname != NULL && find_host_convention(&f, 0, hostname)) {
+    return((int)(f.match->asn));
+  } else {
+    return 0;
+  }
+}
+const char *get_role(int asn, const char *hostname) {
+  return(get_attribute(asn, hostname, attr_type));
+}
+
+static char *get_a_tag(struct fmr *f, const char *hostname, const char *tag) {
+  char buf[255];
+  unsigned int i;
+  buf[0] = '\0';
+  if(tag != NULL) {
+    DM("found tag match for %s\n", hostname);
+    for (i = 1; 
+         i < REGS_LEN;
+         i++) {
+      if(strcmp(tag, "all") == 0 || 
+         index(tag, '0' + i) != NULL) {
+
+        if(f->posix_regs[i].rm_so >= 0) {
+          strncat(buf, &hostname[f->posix_regs[i].rm_so], 
+                  (f->posix_regs[i].rm_eo - f->posix_regs[i].rm_so));
+        }
+      }
+    }
+  }
+  return strdup(buf);
+}
+
+char *get_poptag(int asn, const char *hostname) {
+  struct fmr f;
+  if(find_host_convention(&f, asn, hostname)) {
+    if(f.match->poptag != NULL) {
+      return get_a_tag(&f, hostname, f.match->poptag->constant);
+    }
+  } 
+  return NULL;
+}
+
+char *get_identifier(int asn, const char *hostname) {
+  struct fmr f;
+  if(find_host_convention(&f, asn, hostname)) {
+    if(f.match->unique != NULL) {
+      return get_a_tag(&f, hostname, f.match->unique->constant);
+    }
+  } 
+  return NULL;
+}
+
+const char *get_loc_list(int asn, const char **hostname_list) {
+  int i;
+  for(i=0; hostname_list[i]!=NULL; i++) {
+    get_loc(asn, hostname_list[i]);
+    /* find some way to compute the majority without much fuss. */
+  }
+  return NULL;
+}
+
+struct key_decl *new_key_decl(/*@owned@*/ char *id, int regex_index,
+                              boolean isDefault,
+                              key_hashtable bindings) {
+  NEWPTR(struct key_decl, ret);
+  if(strcmp(id, "loc") == 0) ret->id = attr_loc;
+  else if(strcmp(id, "type") == 0) ret->id = attr_type;
+  else { printf("bad type: '%s'\n", id); return NULL; }
+  ret->regex_index = regex_index;
+  ret->isDefault = isDefault;
+  ret->bindings = bindings;
+  ret->constant = NULL;
+  free(id);
+  return ret;
+}
+struct key_decl *new_key_decl_const(/*@owned@*/ char *id, char *constant){
+  NEWPTR(struct key_decl, ret);
+  if(strcmp(id, "loc") == 0) ret->id = attr_loc;
+  else if(strcmp(id, "type") == 0) ret->id = attr_type;
+  else if(strcmp(id, "unique") == 0) ret->id = attr_unique;
+  else if(strcmp(id, "poptag") == 0) ret->id = attr_poptag;
+  else { printf("bad type: '%s'\n", id); return NULL; }
+  ret->regex_index = 0;
+  ret->isDefault = FALSE;
+  ret->bindings = NULL;
+  ret->constant = constant;
+  free(id);
+  return ret;
+}
+
+#define SET_IF_UNSET(x, y) if(ret->x) { printf("warning: %s attribute is already set for %s!\n", #x, ret->regex); } else { ret->x = y;;;;;;;; }
+static void add_key_decl(struct convention *ret, struct key_decl *a) {
+  if(a != NULL) {
+    switch(a->id) {
+    case attr_loc:    SET_IF_UNSET(loc, a); break;
+    case attr_type:   SET_IF_UNSET(type, a); break;
+    case attr_unique: SET_IF_UNSET(unique, a); break;
+    case attr_poptag: SET_IF_UNSET(poptag, a); break;
+    default: fprintf(stderr, "bogus attribute!\n");
+    }
+  }
+}
+
+struct convention *new_convention(char *regex,
+                                  struct key_decl *a,
+                                  struct key_decl *b,
+                                  struct key_decl *c,
+                                  struct key_decl *d,
+                                  const char *filename, 
+                                  int linenum) {
+  NEWPTR(struct convention, ret);
+  int errcode;
+  ret->regex = regex;
+  
+  ret->loc = NULL;
+  ret->type = NULL;
+  ret->unique = NULL;
+  ret->poptag = NULL;
+  add_key_decl(ret, a);
+  add_key_decl(ret, b);
+  add_key_decl(ret, c);
+  add_key_decl(ret, d);
+
+  if ((errcode = regcomp(&ret->rpbuf, regex, REG_EXTENDED)) != 0) {
+    char errbuf[256];
+    regerror(errcode, &ret->rpbuf, errbuf, 256);
+    fprintf(stderr, "error in compiling regular expression '%s': %s\n",
+            regex, errbuf);
+    exit(EXIT_FAILURE);
+  }
+
+  set_file_and_line(&ret->inst, filename, linenum);
+  return(ret);
+}
+
+static boolean dump_stringpair(const struct stringpair *sp, void *file_pointer) {
+  FILE *fp = file_pointer;
+  char buffy[255];
+  assert(fp);
+  assert(sp);
+  fprintf(fp, "      %s->%s %s\n",  sp->key, sp->value, inst_format_stats(buffy, 255, &sp->inst));
+  return TRUE;
+}
+
+static boolean dump_conventions(const struct convention *conv, void *file_pointer) {
+  FILE *fp = file_pointer;
+  char buffy[255];
+  assert(fp);
+  assert(conv);
+  assert(conv->asn < 100000); /* sanity */
+  fprintf(fp, "  %ld, %s, %s\n",  conv->asn, conv->regex, inst_format_stats(buffy, 255, &conv->inst));
+  if(conv->loc && conv->loc->bindings && conv->inst.dynamic_match_count > 0) {
+    fprintf(fp, "    incomplete keys: %s\n",  inst_format_stats(buffy, 255, &conv->loc->inst));
+    key_ht_iterate(conv->loc->bindings, dump_stringpair, fp);
+  }
+  /* TODO: there's more to dump: key declarations and such. */
+  return TRUE;
+}
+
+static boolean dump_asns(const struct asnc *as, void *file_pointer  ) {
+  FILE *fp = file_pointer;
+  char buffy[255];
+  assert(fp);
+  assert(as);
+  fprintf(fp, "AS%d, %s, %s\n",  as->asn, as->prefilter_regex, inst_format_stats(buffy, 255, &as->inst));
+  if(as->conventions) {
+    conv_q_iterate(as->conventions, dump_conventions, fp);
+   }
+  return TRUE;
+}
+
+void dump_parsed_conventions_to_file(const char * filename) {
+  FILE *dump = fopen(filename, "w");
+  assert(filename);
+  assert(dump);
+
+  asnc_ht_iterate(Ruleset, dump_asns, dump);
+
+  fclose(dump);
+}
+
+void dump_single_asn_conventions_to_file(int asn, const char * filename) {
+  FILE *dump = fopen(filename, "w");
+  const struct asnc *ac = asnc_ht_lookup_k(Ruleset, &asn);
+
+  assert(filename);
+  assert(dump);
+
+  dump_asns(ac, dump);
+
+  fclose(dump);
+}