database: Free mmapped countries section

[people/ms/libloc.git] / src / database.c

diff --git a/src/database.c b/src/database.c
index ef4f505b6717a917fb239fedc7f5c07a99023e61..b92a803d5d3db9a8be49049ee803d7a06f6180e2 100644 (file)
--- a/src/database.c
+++ b/src/database.c
@@ -250,11 +250,11 @@ static int loc_database_read_signature(struct loc_database* db,
                char** dst, char* src, size_t length) {
        // Check for a plausible signature length
        if (length > LOC_SIGNATURE_MAX_LENGTH) {
-               ERROR(db->ctx, "Signature too long: %ld\n", length);
+               ERROR(db->ctx, "Signature too long: %zu\n", length);
                return -EINVAL;
        }
 
-       DEBUG(db->ctx, "Reading signature of %ld bytes\n", length);
+       DEBUG(db->ctx, "Reading signature of %zu bytes\n", length);
 
        // Allocate space
        *dst = malloc(length);
@@ -446,6 +446,13 @@ static void loc_database_free(struct loc_database* db) {
                        ERROR(db->ctx, "Could not unmap network nodes section: %s\n", strerror(errno));
        }
 
+       // Remove mapped countries section
+       if (db->countries_v1) {
+               r = munmap(db->countries_v1, db->countries_count * sizeof(*db->countries_v1));
+               if (r)
+                       ERROR(db->ctx, "Could not unmap countries section: %s\n", strerror(errno));
+       }
+
        if (db->pool)
                loc_stringpool_unref(db->pool);
 
@@ -776,8 +783,7 @@ static int __loc_database_lookup_handle_leaf(struct loc_database* db, const stru
        }
 
        // Check if the given IP address is inside the network
-       r = loc_network_match_address(*network, address);
-       if (r) {
+       if (!loc_network_match_address(*network, address)) {
                DEBUG(db->ctx, "Searched address is not part of the network\n");
 
                loc_network_unref(*network);
@@ -1191,7 +1197,7 @@ static int __loc_database_enumerator_next_network(
                struct loc_database_enumerator* enumerator, struct loc_network** network, int filter) {
        // Return top element from the stack
        while (1) {
-               *network = loc_network_list_pop(enumerator->stack);
+               *network = loc_network_list_pop_first(enumerator->stack);
 
                // Stack is empty
                if (!*network)
@@ -1305,8 +1311,12 @@ static int __loc_database_enumerator_next_network_flattened(
        while (1) {
                // Fetch the next network in line
                r = __loc_database_enumerator_next_network(enumerator, &subnet, 0);
-               if (r)
-                       goto END;
+               if (r) {
+                       loc_network_unref(subnet);
+                       loc_network_list_unref(subnets);
+
+                       return r;
+               }
 
                // End if we did not receive another subnet
                if (!subnet)
@@ -1315,8 +1325,12 @@ static int __loc_database_enumerator_next_network_flattened(
                // Collect all subnets in a list
                if (loc_network_is_subnet(*network, subnet)) {
                        r = loc_network_list_push(subnets, subnet);
-                       if (r)
-                               goto END;
+                       if (r) {
+                               loc_network_unref(subnet);
+                               loc_network_list_unref(subnets);
+
+                               return r;
+                       }
 
                        loc_network_unref(subnet);
                        continue;
@@ -1324,8 +1338,12 @@ static int __loc_database_enumerator_next_network_flattened(
 
                // If this is not a subnet, we push it back onto the stack and break
                r = loc_network_list_push(enumerator->stack, subnet);
-               if (r)
-                       goto END;
+               if (r) {
+                       loc_network_unref(subnet);
+                       loc_network_list_unref(subnets);
+
+                       return r;
+               }
 
                loc_network_unref(subnet);
                break;
@@ -1343,29 +1361,36 @@ static int __loc_database_enumerator_next_network_flattened(
        // If the network has any subnets, we will break it into smaller parts
        // without the subnets.
        struct loc_network_list* excluded = loc_network_exclude_list(*network, subnets);
-       if (!excluded || loc_network_list_empty(excluded)) {
-               r = 1;
-               goto END;
+       if (!excluded) {
+               loc_network_list_unref(subnets);
+               return -1;
        }
 
-       // Replace network with the first one
-       loc_network_unref(*network);
-
-       *network = loc_network_list_pop_first(excluded);
+       // Merge subnets onto the stack
+       r = loc_network_list_merge(enumerator->stack, subnets);
+       if (r) {
+               loc_network_list_unref(subnets);
+               loc_network_list_unref(excluded);
 
-       // Push the rest onto the stack
-       loc_network_list_reverse(excluded);
-       loc_network_list_merge(enumerator->stack, excluded);
+               return r;
+       }
 
-       loc_network_list_unref(excluded);
+       // Push excluded list onto the stack
+       r = loc_network_list_merge(enumerator->stack, excluded);
+       if (r) {
+               loc_network_list_unref(subnets);
+               loc_network_list_unref(excluded);
 
-END:
-       if (subnet)
-               loc_network_unref(subnet);
+               return r;
+       }
 
        loc_network_list_unref(subnets);
+       loc_network_list_unref(excluded);
 
-       return r;
+       // Drop the network and restart the whole process again to pick the next network
+       loc_network_unref(*network);
+
+       return __loc_database_enumerator_next_network_flattened(enumerator, network);
 }
 
 LOC_EXPORT int loc_database_enumerator_next_network(