Merge branch 'perl'

diff --combined src/database.c
index 648434565110f571461769ce8d2173a594c67d33,58e1c00bf234d09b8302b20c14caf6fe53f3140e..c41ce46aa7e5020bc2f3c28f9ca5ca9f5082db22
--- 1/src/database.c
--- 2/src/database.c
+++ b/src/database.c
@@@ -62,33 -62,16 +62,33 @@@ struct loc_database 
        struct loc_stringpool* pool;
  };
  
 +#define MAX_STACK_DEPTH 256
 +
 +struct loc_node_stack {
 +      off_t offset;
 +      int i; // Is this node 0 or 1?
 +      int depth;
 +};
 +
  struct loc_database_enumerator {
        struct loc_ctx* ctx;
        struct loc_database* db;
 +      enum loc_database_enumerator_mode mode;
        int refcount;
  
        // Search string
        char* string;
 +      char country_code[3];
 +      uint32_t asn;
  
        // Index of the AS we are looking at
        unsigned int as_index;
 +
 +      // Network state
 +      struct in6_addr network_address;
 +      struct loc_node_stack network_stack[MAX_STACK_DEPTH];
 +      int network_stack_depth;
 +      unsigned int* networks_visited;
  };
  
  static int loc_database_read_magic(struct loc_database* db, FILE* f) {
@@@ -323,7 -306,8 +323,8 @@@ static void loc_database_free(struct lo
                        ERROR(db->ctx, "Could not unmap network nodes section: %s\n", strerror(errno));
        }
  
-       loc_stringpool_unref(db->pool);
+       if (db->pool)
+               loc_stringpool_unref(db->pool);
  
        loc_unref(db->ctx);
        free(db);
@@@ -571,8 -555,7 +572,8 @@@ LOC_EXPORT int loc_database_lookup_from
  
  // Enumerator
  
 -LOC_EXPORT int loc_database_enumerator_new(struct loc_database_enumerator** enumerator, struct loc_database* db) {
 +LOC_EXPORT int loc_database_enumerator_new(struct loc_database_enumerator** enumerator,
 +              struct loc_database* db, enum loc_database_enumerator_mode mode) {
        struct loc_database_enumerator* e = calloc(1, sizeof(*e));
        if (!e)
                return -ENOMEM;
@@@ -580,14 -563,8 +581,14 @@@
        // Reference context
        e->ctx = loc_ref(db->ctx);
        e->db = loc_database_ref(db);
 +      e->mode = mode;
        e->refcount = 1;
  
 +      // Initialise graph search
 +      //e->network_stack[++e->network_stack_depth] = 0;
 +      e->network_stack_depth = 1;
 +      e->networks_visited = calloc(db->network_nodes_count, sizeof(*e->networks_visited));
 +
        DEBUG(e->ctx, "Database enumerator object allocated at %p\n", e);
  
        *enumerator = e;
@@@ -610,9 -587,6 +611,9 @@@ static void loc_database_enumerator_fre
        if (enumerator->string)
                free(enumerator->string);
  
 +      // Free network search
 +      free(enumerator->networks_visited);
 +
        free(enumerator);
  }
  
@@@ -637,185 -611,31 +638,185 @@@ LOC_EXPORT int loc_database_enumerator_
        return 0;
  }
  
 -LOC_EXPORT struct loc_as* loc_database_enumerator_next_as(struct loc_database_enumerator* enumerator) {
 +LOC_EXPORT int loc_database_enumerator_set_country_code(struct loc_database_enumerator* enumerator, const char* country_code) {
 +      // Set empty country code
 +      if (!country_code || !*country_code) {
 +              *enumerator->country_code = '\0';
 +              return 0;
 +      }
 +
 +      // Country codes must be two characters
 +      if (strlen(country_code) != 2)
 +              return -EINVAL;
 +
 +      for (unsigned int i = 0; i < 3; i++) {
 +              enumerator->country_code[i] = country_code[i];
 +      }
 +
 +      return 0;
 +}
 +
 +LOC_EXPORT int loc_database_enumerator_set_asn(
 +              struct loc_database_enumerator* enumerator, unsigned int asn) {
 +      enumerator->asn = asn;
 +
 +      return 0;
 +}
 +
 +LOC_EXPORT int loc_database_enumerator_next_as(
 +              struct loc_database_enumerator* enumerator, struct loc_as** as) {
 +      *as = NULL;
 +
 +      // Do not do anything if not in AS mode
 +      if (enumerator->mode != LOC_DB_ENUMERATE_ASES)
 +              return 0;
 +
        struct loc_database* db = enumerator->db;
 -      struct loc_as* as;
  
        while (enumerator->as_index < db->as_count) {
                // Fetch the next AS
 -              int r = loc_database_fetch_as(db, &as, enumerator->as_index++);
 +              int r = loc_database_fetch_as(db, as, enumerator->as_index++);
                if (r)
 -                      return NULL;
 +                      return r;
  
 -              r = loc_as_match_string(as, enumerator->string);
 +              r = loc_as_match_string(*as, enumerator->string);
                if (r == 1) {
                        DEBUG(enumerator->ctx, "AS%d (%s) matches %s\n",
 -                              loc_as_get_number(as), loc_as_get_name(as), enumerator->string);
 +                              loc_as_get_number(*as), loc_as_get_name(*as), enumerator->string);
  
 -                      return as;
 +                      return 0;
                }
  
                // No match
 -              loc_as_unref(as);
 +              loc_as_unref(*as);
 +              *as = NULL;
        }
  
        // Reset the index
        enumerator->as_index = 0;
  
        // We have searched through all of them
 -      return NULL;
 +      return 0;
 +}
 +
 +static int loc_database_enumerator_stack_push_node(
 +              struct loc_database_enumerator* e, off_t offset, int i, int depth) {
 +      // Do not add empty nodes
 +      if (!offset)
 +              return 0;
 +
 +      // Check if there is any space left on the stack
 +      if (e->network_stack_depth >= MAX_STACK_DEPTH) {
 +              ERROR(e->ctx, "Maximum stack size reached: %d\n", e->network_stack_depth);
 +              return -1;
 +      }
 +
 +      // Increase stack size
 +      int s = ++e->network_stack_depth;
 +
 +      DEBUG(e->ctx, "Added node %jd to stack (%d)\n", offset, depth);
 +
 +      e->network_stack[s].offset = offset;
 +      e->network_stack[s].i = i;
 +      e->network_stack[s].depth = depth;
 +
 +      return 0;
 +}
 +
 +LOC_EXPORT int loc_database_enumerator_next_network(
 +              struct loc_database_enumerator* enumerator, struct loc_network** network) {
 +      // Reset network
 +      *network = NULL;
 +
 +      // Do not do anything if not in network mode
 +      if (enumerator->mode != LOC_DB_ENUMERATE_NETWORKS)
 +              return 0;
 +
 +      int r;
 +
 +      DEBUG(enumerator->ctx, "Called with a stack of %u nodes\n",
 +              enumerator->network_stack_depth);
 +
 +      // Perform DFS
 +      while (enumerator->network_stack_depth > 0) {
 +              DEBUG(enumerator->ctx, "Stack depth: %u\n", enumerator->network_stack_depth);
 +
 +              // Get object from top of the stack
 +              struct loc_node_stack* node = &enumerator->network_stack[enumerator->network_stack_depth];
 +
 +              // Remove the node from the stack if we have already visited it
 +              if (enumerator->networks_visited[node->offset]) {
 +                      enumerator->network_stack_depth--;
 +                      continue;
 +              }
 +
 +              // Mark the bits on the path correctly
 +              in6_addr_set_bit(&enumerator->network_address,
 +                      (node->depth > 0) ? node->depth - 1 : 0, node->i);
 +
 +              DEBUG(enumerator->ctx, "Looking at node %jd\n", node->offset);
 +              enumerator->networks_visited[node->offset]++;
 +
 +              // Pop node from top of the stack
 +              struct loc_database_network_node_v0* n =
 +                      enumerator->db->network_nodes_v0 + node->offset;
 +
 +              // Add edges to stack
 +              r = loc_database_enumerator_stack_push_node(enumerator,
 +                      be32toh(n->one), 1, node->depth + 1);
 +
 +              if (r)
 +                      return r;
 +
 +              r = loc_database_enumerator_stack_push_node(enumerator,
 +                      be32toh(n->zero), 0, node->depth + 1);
 +
 +              if (r)
 +                      return r;
 +
 +              // Check if this node is a leaf and has a network object
 +              if (__loc_database_node_is_leaf(n)) {
 +                      off_t network_index = be32toh(n->network);
 +
 +                      DEBUG(enumerator->ctx, "Node has a network at %jd\n", network_index);
 +
 +                      // Fetch the network object
 +                      r = loc_database_fetch_network(enumerator->db, network,
 +                              &enumerator->network_address, node->depth, network_index);
 +
 +                      // Break on any errors
 +                      if (r)
 +                              return r;
 +
 +                      // Check if we are interested in this network
 +
 +                      // Skip if the country code does not match
 +                      if (enumerator->country_code &&
 +                                      !loc_network_match_country_code(*network, enumerator->country_code)) {
 +                              loc_network_unref(*network);
 +                              *network = NULL;
 +
 +                              continue;
 +                      }
 +
 +                      // Skip if the ASN does not match
 +                      if (enumerator->asn &&
 +                                      !loc_network_match_asn(*network, enumerator->asn)) {
 +                              loc_network_unref(*network);
 +                              *network = NULL;
 +
 +                              continue;
 +                      }
 +
 +                      return 0;
 +              }
 +      }
 +
 +      // Reached the end of the search
 +
 +      // Mark all nodes as non-visited
 +      for (unsigned int i = 0; i < enumerator->db->network_nodes_count; i++)
 +              enumerator->networks_visited[i] = 0;
 +
 +      return 0;
  }