geoip2_c 0.3.2 → 0.3.3

data/ext/geoip2/libmaxminddb/src/maxminddb.c

@@ -1,6 +1,7 @@
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
+#include "data-pool.h"
 #include "maxminddb.h"
 #include "maxminddb-compat-util.h"
 #include <assert.h>
@@ -130,6 +131,9 @@ typedef struct record_info_s {
 /* This is 128kb */
 #define METADATA_BLOCK_MAX_SIZE 131072
 
+// 64 leads us to allocating 4 KiB on a 64bit system.
+#define MMDB_POOL_INIT_SIZE 64
+
 /* *INDENT-OFF* */
 /* --prototypes automatically generated by dev-bin/regen-prototypes.pl - don't remove this comment */
 LOCAL int map_file(MMDB_s *const mmdb);
@@ -176,8 +180,10 @@ LOCAL int decode_one(MMDB_s *mmdb, uint32_t offset,
 LOCAL int get_ext_type(int raw_ext_type);
 LOCAL uint32_t get_ptr_from(uint8_t ctrl, uint8_t const *const ptr,
                             int ptr_size);
-LOCAL int get_entry_data_list(MMDB_s *mmdb, uint32_t offset,
+LOCAL int get_entry_data_list(MMDB_s *mmdb,
+                              uint32_t offset,
                               MMDB_entry_data_list_s *const entry_data_list,
+                              MMDB_data_pool_s *const pool,
                               int depth);
 LOCAL float get_ieee754_float(const uint8_t *restrict p);
 LOCAL double get_ieee754_double(const uint8_t *restrict p);
@@ -186,7 +192,6 @@ LOCAL uint32_t get_uint24(const uint8_t *p);
 LOCAL uint32_t get_uint16(const uint8_t *p);
 LOCAL uint64_t get_uintX(const uint8_t *p, int length);
 LOCAL int32_t get_sintX(const uint8_t *p, int length);
-LOCAL MMDB_entry_data_list_s *new_entry_data_list(void);
 LOCAL void free_mmdb_struct(MMDB_s *const mmdb);
 LOCAL void free_languages_metadata(MMDB_s *mmdb);
 LOCAL void free_descriptions_metadata(MMDB_s *mmdb);
@@ -241,7 +246,7 @@ int MMDB_open(const char *const filename, uint32_t flags, MMDB_s *const mmdb)
     }
     mmdb->flags = flags;
 
-    if (MMDB_SUCCESS != (status = map_file(mmdb)) ) {
+    if (MMDB_SUCCESS != (status = map_file(mmdb))) {
         goto cleanup;
     }
 
@@ -297,6 +302,15 @@ int MMDB_open(const char *const filename, uint32_t flags, MMDB_s *const mmdb)
     mmdb->ipv4_start_node.node_value = 0;
     mmdb->ipv4_start_node.netmask = 0;
 
+    // We do this immediately as otherwise there is a race to set
+    // ipv4_start_node.node_value and ipv4_start_node.netmask.
+    if (mmdb->metadata.ip_version == 6) {
+        status = find_ipv4_start_node(mmdb);
+        if (status != MMDB_SUCCESS) {
+            goto cleanup;
+        }
+    }
+
  cleanup:
     if (MMDB_SUCCESS != status) {
         int saved_errno = errno;
@@ -361,7 +375,11 @@ LOCAL int map_file(MMDB_s *const mmdb)
     ssize_t size;
     int status = MMDB_SUCCESS;
 
-    int fd = open(mmdb->filename, O_RDONLY);
+    int flags = O_RDONLY;
+#ifdef O_CLOEXEC
+    flags |= O_CLOEXEC;
+#endif
+    int fd = open(mmdb->filename, flags);
     struct stat s;
     if (fd < 0 || fstat(fd, &s)) {
         status = MMDB_FILE_OPEN_ERROR;
@@ -1634,15 +1652,33 @@ int MMDB_get_metadata_as_entry_data_list(
 int MMDB_get_entry_data_list(
     MMDB_entry_s *start, MMDB_entry_data_list_s **const entry_data_list)
 {
-    *entry_data_list = new_entry_data_list();
-    if (NULL == *entry_data_list) {
+    MMDB_data_pool_s *const pool = data_pool_new(MMDB_POOL_INIT_SIZE);
+    if (!pool) {
+        return MMDB_OUT_OF_MEMORY_ERROR;
+    }
+
+    MMDB_entry_data_list_s *const list = data_pool_alloc(pool);
+    if (!list) {
+        data_pool_destroy(pool);
+        return MMDB_OUT_OF_MEMORY_ERROR;
+    }
+
+    int const status = get_entry_data_list(start->mmdb, start->offset, list,
+                                           pool, 0);
+
+    *entry_data_list = data_pool_to_list(pool);
+    if (!*entry_data_list) {
+        data_pool_destroy(pool);
         return MMDB_OUT_OF_MEMORY_ERROR;
     }
-    return get_entry_data_list(start->mmdb, start->offset, *entry_data_list, 0);
+
+    return status;
 }
 
-LOCAL int get_entry_data_list(MMDB_s *mmdb, uint32_t offset,
+LOCAL int get_entry_data_list(MMDB_s *mmdb,
+                              uint32_t offset,
                               MMDB_entry_data_list_s *const entry_data_list,
+                              MMDB_data_pool_s *const pool,
                               int depth)
 {
     if (depth >= MAXIMUM_DATA_STRUCTURE_DEPTH) {
@@ -1672,7 +1708,7 @@ LOCAL int get_entry_data_list(MMDB_s *mmdb, uint32_t offset,
 
                 int status =
                     get_entry_data_list(mmdb, last_offset, entry_data_list,
-                                        depth);
+                                        pool, depth);
                 if (MMDB_SUCCESS != status) {
                     DEBUG_MSG("get_entry_data_list on pointer failed.");
                     return status;
@@ -1685,26 +1721,22 @@ LOCAL int get_entry_data_list(MMDB_s *mmdb, uint32_t offset,
         {
             uint32_t array_size = entry_data_list->entry_data.data_size;
             uint32_t array_offset = entry_data_list->entry_data.offset_to_next;
-            MMDB_entry_data_list_s *previous = entry_data_list;
             while (array_size-- > 0) {
-                MMDB_entry_data_list_s *entry_data_list_to = previous->next =
-                                                                 new_entry_data_list();
-                if (NULL == entry_data_list_to) {
+                MMDB_entry_data_list_s *entry_data_list_to =
+                    data_pool_alloc(pool);
+                if (!entry_data_list_to) {
                     return MMDB_OUT_OF_MEMORY_ERROR;
                 }
 
                 int status =
                     get_entry_data_list(mmdb, array_offset, entry_data_list_to,
-                                        depth);
+                                        pool, depth);
                 if (MMDB_SUCCESS != status) {
                     DEBUG_MSG("get_entry_data_list on array element failed.");
                     return status;
                 }
 
                 array_offset = entry_data_list_to->entry_data.offset_to_next;
-                while (previous->next) {
-                    previous = previous->next;
-                }
             }
             entry_data_list->entry_data.offset_to_next = array_offset;
 
@@ -1715,45 +1747,33 @@ LOCAL int get_entry_data_list(MMDB_s *mmdb, uint32_t offset,
             uint32_t size = entry_data_list->entry_data.data_size;
 
             offset = entry_data_list->entry_data.offset_to_next;
-            MMDB_entry_data_list_s *previous = entry_data_list;
             while (size-- > 0) {
-                MMDB_entry_data_list_s *entry_data_list_to = previous->next =
-                                                                 new_entry_data_list();
-                if (NULL == entry_data_list_to) {
+                MMDB_entry_data_list_s *list_key = data_pool_alloc(pool);
+                if (!list_key) {
                     return MMDB_OUT_OF_MEMORY_ERROR;
                 }
 
                 int status =
-                    get_entry_data_list(mmdb, offset, entry_data_list_to,
-                                        depth);
+                    get_entry_data_list(mmdb, offset, list_key, pool, depth);
                 if (MMDB_SUCCESS != status) {
                     DEBUG_MSG("get_entry_data_list on map key failed.");
                     return status;
                 }
 
-                while (previous->next) {
-                    previous = previous->next;
-                }
-
-                offset = entry_data_list_to->entry_data.offset_to_next;
-                entry_data_list_to = previous->next =
-                                         new_entry_data_list();
+                offset = list_key->entry_data.offset_to_next;
 
-                if (NULL == entry_data_list_to) {
+                MMDB_entry_data_list_s *list_value = data_pool_alloc(pool);
+                if (!list_value) {
                     return MMDB_OUT_OF_MEMORY_ERROR;
                 }
 
-                status = get_entry_data_list(mmdb, offset, entry_data_list_to,
+                status = get_entry_data_list(mmdb, offset, list_value, pool,
                                              depth);
                 if (MMDB_SUCCESS != status) {
                     DEBUG_MSG("get_entry_data_list on map element failed.");
                     return status;
                 }
-
-                while (previous->next) {
-                    previous = previous->next;
-                }
-                offset = entry_data_list_to->entry_data.offset_to_next;
+                offset = list_value->entry_data.offset_to_next;
             }
             entry_data_list->entry_data.offset_to_next = offset;
         }
@@ -1832,22 +1852,12 @@ LOCAL int32_t get_sintX(const uint8_t *p, int length)
     return (int32_t)get_uintX(p, length);
 }
 
-LOCAL MMDB_entry_data_list_s *new_entry_data_list(void)
-{
-    /* We need calloc here in order to ensure that the ->next pointer in the
-     * struct doesn't point to some random address. */
-    return calloc(1, sizeof(MMDB_entry_data_list_s));
-}
-
 void MMDB_free_entry_data_list(MMDB_entry_data_list_s *const entry_data_list)
 {
     if (entry_data_list == NULL) {
         return;
     }
-    if (entry_data_list->next) {
-        MMDB_free_entry_data_list(entry_data_list->next);
-    }
-    free(entry_data_list);
+    data_pool_destroy(entry_data_list->pool);
 }
 
 void MMDB_close(MMDB_s *const mmdb)

data/ext/geoip2/libmaxminddb/t/Makefile.am

@@ -12,12 +12,16 @@ libmmdbtest_la_SOURCES = maxminddb_test_helper.c
 
 check_PROGRAMS = \
 	bad_pointers_t bad_databases_t basic_lookup_t data_entry_list_t \
-    data_types_t dump_t get_value_t get_value_pointer_bug_t \
+    data-pool-t data_types_t dump_t get_value_t get_value_pointer_bug_t \
 	ipv4_start_cache_t ipv6_lookup_in_ipv4_t metadata_t metadata_pointers_t \
 	no_map_get_value_t read_node_t threads_t version_t
 
+data_pool_t_CFLAGS = $(CFLAGS) -I$(top_srcdir)/src
+data_pool_t_LDFLAGS = $(AM_LDFLAGS) -lm
+data_pool_t_SOURCES = data-pool-t.c ../src/data-pool.c
+
 threads_t_CFLAGS = $(CFLAGS) -pthread
 
-TESTS = $(check_PROGRAMS) compile_c++_t.pl mmdblookup_t.pl
+TESTS = $(check_PROGRAMS) compile_c++_t.pl external_symbols_t.pl mmdblookup_t.pl
 
 LDADD = libmmdbtest.la libtap/libtap.a

data/ext/geoip2/libmaxminddb/t/bad_databases_t.c

@@ -26,6 +26,7 @@ int test_read(const char *path, const struct stat *UNUSED(
 
     if (status != MMDB_SUCCESS) {
         ok(1, "received error when opening %s", path);
+        free(mmdb);
         return 0;
     }
 

data/ext/geoip2/libmaxminddb/t/basic_lookup_t.c

@@ -1,5 +1,7 @@
 #include "maxminddb_test_helper.h"
 
+static void test_big_lookup(void);
+
 /* These globals are gross but it's the easiest way to mix calling
  * for_all_modes() and for_all_record_sizes() */
 static int Current_Mode;
@@ -164,9 +166,42 @@ void all_record_sizes(int mode, const char *description)
     }
 }
 
+static void test_big_lookup(void)
+{
+    const char *const db_filename = "GeoIP2-Precision-Enterprise-Test.mmdb";
+    const char *const db_path = test_database_path(db_filename);
+    ok(db_path != NULL, "got database path");
+
+    MMDB_s * const mmdb = open_ok(db_path, MMDB_MODE_MMAP, "mmap mode");
+    ok(mmdb != NULL, "opened MMDB");
+    free((char *)db_path);
+
+    int gai_err = 0, mmdb_err = 0;
+    const char *const ip_address = "81.2.69.160";
+    MMDB_lookup_result_s result = MMDB_lookup_string(mmdb, ip_address, &gai_err,
+                                                     &mmdb_err);
+    ok(gai_err == 0, "no getaddrinfo error");
+    ok(mmdb_err == MMDB_SUCCESS, "no error from maxminddb library");
+    ok(result.found_entry, "found IP");
+
+    MMDB_entry_data_list_s *entry_data_list = NULL;
+    ok(
+        MMDB_get_entry_data_list(&result.entry,
+                                 &entry_data_list) == MMDB_SUCCESS,
+        "successfully looked up entry data list"
+        );
+    ok(entry_data_list != NULL, "got an entry_data_list");
+
+    MMDB_free_entry_data_list(entry_data_list);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
 int main(void)
 {
     plan(NO_PLAN);
     for_all_modes(&all_record_sizes);
+    test_big_lookup();
     done_testing();
 }

data/ext/geoip2/libmaxminddb/t/data-pool-t.c

@@ -0,0 +1,374 @@
+#include <assert.h>
+#include <data-pool.h>
+#include <inttypes.h>
+#include "libtap/tap.h"
+#include <math.h>
+#include "maxminddb_test_helper.h"
+
+static void test_data_pool_new(void);
+static void test_data_pool_destroy(void);
+static void test_data_pool_alloc(void);
+static void test_data_pool_to_list(void);
+static bool create_and_check_list(size_t const,
+                                  size_t const);
+static void check_block_count(MMDB_entry_data_list_s const *const,
+                              size_t const);
+
+int main(void)
+{
+    plan(NO_PLAN);
+    test_data_pool_new();
+    test_data_pool_destroy();
+    test_data_pool_alloc();
+    test_data_pool_to_list();
+    done_testing();
+}
+
+static void test_data_pool_new(void)
+{
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(0);
+        ok(!pool, "size 0 is not valid");
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(SIZE_MAX - 10);
+        ok(!pool, "very large size is not valid");
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(512);
+        ok(pool != NULL, "size 512 is valid");
+        cmp_ok(pool->size, "==", 512, "size is 512");
+        cmp_ok(pool->used, "==", 0, "used size is 0");
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_destroy(void)
+{
+    {
+        data_pool_destroy(NULL);
+    }
+
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(512);
+        ok(pool != NULL, "created pool");
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_alloc(void)
+{
+    {
+        MMDB_data_pool_s *const pool = data_pool_new(1);
+        ok(pool != NULL, "created pool");
+        cmp_ok(pool->used, "==", 0, "used size starts at 0");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "allocated first entry");
+        // Arbitrary so that we can recognize it.
+        entry1->entry_data.offset = (uint32_t)123;
+
+        cmp_ok(pool->size, "==", 1, "size is still 1");
+        cmp_ok(pool->used, "==", 1, "used size is 1 after taking one");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got another entry");
+        ok(entry1 != entry2, "second entry is different from first entry");
+
+        cmp_ok(pool->size, "==", 2, "size is 2 (new block)");
+        cmp_ok(pool->used, "==", 1, "used size is 1 in current block");
+
+        ok(entry1->entry_data.offset == 123,
+           "accessing the original entry's memory is ok");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 10;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *entry1 = NULL;
+        for (size_t i = 0; i < initial_size; i++) {
+            MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+            ok(entry != NULL, "got an entry");
+            // Give each a unique number so we can check it.
+            entry->entry_data.offset = (uint32_t)i;
+            if (i == 0) {
+                entry1 = entry;
+            }
+        }
+
+        cmp_ok(pool->size, "==", initial_size, "size is the initial size");
+        cmp_ok(pool->used, "==", initial_size, "used size is as expected");
+
+        MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+        ok(entry != NULL, "got an entry");
+        entry->entry_data.offset = (uint32_t)initial_size;
+
+        cmp_ok(pool->size, "==", initial_size * 2,
+               "size is the initial size*2");
+        cmp_ok(pool->used, "==", 1, "used size is as expected");
+
+        MMDB_entry_data_list_s *const list = data_pool_to_list(pool);
+
+        MMDB_entry_data_list_s *element = list;
+        for (size_t i = 0; i < initial_size + 1; i++) {
+            ok(
+                element->entry_data.offset == (uint32_t)i,
+                "found offset %" PRIu32 ", should have %zu",
+                element->entry_data.offset,
+                i
+                );
+            element = element->next;
+        }
+
+        ok(entry1->entry_data.offset == (uint32_t)0,
+           "accessing entry1's original memory is ok after growing the pool");
+
+        data_pool_destroy(pool);
+    }
+}
+
+static void test_data_pool_to_list(void)
+{
+    {
+        size_t const initial_size = 16;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const list_one_element
+            = data_pool_to_list(pool);
+        ok(list_one_element != NULL, "got a list");
+        ok(list_one_element == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_one_element->next == NULL, "list is one element in size");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got another entry");
+
+        MMDB_entry_data_list_s *const list_two_elements
+            = data_pool_to_list(pool);
+        ok(list_two_elements != NULL, "got a list");
+        ok(list_two_elements == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_two_elements->next != NULL, "list has a second element");
+
+        MMDB_entry_data_list_s *const second_element = list_two_elements->next;
+        ok(second_element == entry2,
+           "second item in list is second we retrieved");
+        ok(second_element->next == NULL, "list ends with the second element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 1;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const list_one_element
+            = data_pool_to_list(pool);
+        ok(list_one_element != NULL, "got a list");
+        ok(list_one_element == entry1,
+           "list's first element is the first we retrieved");
+        ok(list_one_element->next == NULL, "list ends with this element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        size_t const initial_size = 2;
+        MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+        ok(pool != NULL, "created pool");
+
+        MMDB_entry_data_list_s *const entry1 = data_pool_alloc(pool);
+        ok(entry1 != NULL, "got an entry");
+
+        MMDB_entry_data_list_s *const entry2 = data_pool_alloc(pool);
+        ok(entry2 != NULL, "got an entry");
+        ok(entry1 != entry2, "second entry is different from the first");
+
+        MMDB_entry_data_list_s *const list_element1 = data_pool_to_list(pool);
+        ok(list_element1 != NULL, "got a list");
+        ok(list_element1 == entry1,
+           "list's first element is the first we retrieved");
+
+        MMDB_entry_data_list_s *const list_element2 = list_element1->next;
+        ok(list_element2 == entry2,
+           "second element is the second we retrieved");
+        ok(list_element2->next == NULL, "list ends with this element");
+
+        data_pool_destroy(pool);
+    }
+
+    {
+        diag("starting test: fill one block save for one spot");
+        ok(
+            create_and_check_list(3, 2),
+            "fill one block save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill one block");
+        ok(
+            create_and_check_list(3, 3),
+            "fill one block"
+            );
+    }
+
+    {
+        diag("starting test: fill one block and use one spot in the next block");
+        ok(
+            create_and_check_list(3, 3 + 1),
+            "fill one block and use one spot in the next block"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks save for one spot");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 - 1),
+            "fill two blocks save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2),
+            "fill two blocks"
+            );
+    }
+
+    {
+        diag("starting test: fill two blocks and use one spot in the next");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 1),
+            "fill two blocks and use one spot in the next"
+            );
+    }
+
+    {
+        diag("starting test: fill three blocks save for one spot");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 3 * 2 * 2 - 1),
+            "fill three blocks save for one spot"
+            );
+    }
+
+    {
+        diag("starting test: fill three blocks");
+        ok(
+            create_and_check_list(3, 3 + 3 * 2 + 3 * 2 * 2),
+            "fill three blocks"
+            );
+    }
+
+    // It would be nice to have a larger number of these, but it's expensive to
+    // run many. We currently hardcode what this will be anyway, so varying
+    // this is not very interesting.
+    size_t const initial_sizes[] = { 1, 2, 32, 64, 128, 256 };
+
+    size_t const max_element_count = 4096;
+
+    for (size_t i = 0; i < sizeof(initial_sizes) / sizeof(initial_sizes[0]);
+         i++) {
+        size_t const initial_size = initial_sizes[i];
+
+        for (size_t element_count = 0; element_count < max_element_count;
+             element_count++) {
+            assert(create_and_check_list(initial_size, element_count));
+        }
+    }
+}
+
+// Use assert() rather than libtap as libtap is significantly slower and we run
+// this frequently.
+static bool create_and_check_list(size_t const initial_size,
+                                  size_t const element_count)
+{
+    MMDB_data_pool_s *const pool = data_pool_new(initial_size);
+    assert(pool != NULL);
+
+    assert(pool->used == 0);
+
+    // Hold on to the pointers as we initially see them so that we can check
+    // they are still valid after building the list.
+    MMDB_entry_data_list_s **const entry_array
+        = calloc(element_count, sizeof(MMDB_entry_data_list_s *));
+    assert(entry_array != NULL);
+
+    for (size_t i = 0; i < element_count; i++) {
+        MMDB_entry_data_list_s *const entry = data_pool_alloc(pool);
+        assert(entry != NULL);
+
+        entry->entry_data.offset = (uint32_t)i;
+
+        entry_array[i] = entry;
+    }
+
+    MMDB_entry_data_list_s *const list = data_pool_to_list(pool);
+
+    if (element_count == 0) {
+        assert(list == NULL);
+        data_pool_destroy(pool);
+        free(entry_array);
+        return true;
+    }
+
+    assert(list != NULL);
+
+    MMDB_entry_data_list_s *element = list;
+    for (size_t i = 0; i < element_count; i++) {
+        assert(element->entry_data.offset == (uint32_t)i);
+
+        assert(element == entry_array[i]);
+
+        element = element->next;
+    }
+    assert(element == NULL);
+
+    check_block_count(list, initial_size);
+
+    data_pool_destroy(pool);
+    free(entry_array);
+    return true;
+}
+
+// Use assert() rather than libtap as libtap is significantly slower and we run
+// this frequently.
+static void check_block_count(MMDB_entry_data_list_s const *const list,
+                              size_t const initial_size)
+{
+    size_t got_block_count = 0;
+    size_t got_element_count = 0;
+
+    MMDB_entry_data_list_s const *element = list;
+    while (element) {
+        got_element_count++;
+
+        if (element->pool) {
+            got_block_count++;
+        }
+
+        element = element->next;
+    }
+
+    // Because <number of elements> = <initial size> * 2^(number of blocks)
+    double const a = ceil((double)got_element_count / (double)initial_size);
+    double const b = log2(a);
+    size_t const expected_block_count = ((size_t)b) + 1;
+
+    assert(got_block_count == expected_block_count);
+}