geoip2_c 0.3.0 → 0.3.1

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

@@ -0,0 +1,226 @@
+#include "maxminddb_test_helper.h"
+
+void test_metadata(MMDB_s *mmdb, const char *mode_desc)
+{
+    cmp_ok(mmdb->metadata.node_count, "==", 37, "node_count is 37 - %s",
+           mode_desc);
+    cmp_ok(mmdb->metadata.record_size, "==", 24, "record_size is 24 - %s",
+           mode_desc);
+    cmp_ok(mmdb->metadata.ip_version, "==", 4, "ip_version is 4 - %s",
+           mode_desc);
+    is(mmdb->metadata.database_type, "Test", "database_type is Test - %s",
+       mode_desc);
+    // 2013-07-01T00:00:00Z
+    uint64_t expect_epoch = 1372636800;
+    int is_ok =
+        cmp_ok(mmdb->metadata.build_epoch, ">=", expect_epoch,
+               "build_epoch > %lli", expect_epoch);
+    if (!is_ok) {
+        diag("  epoch is %lli", mmdb->metadata.build_epoch);
+    }
+
+    cmp_ok(mmdb->metadata.binary_format_major_version, "==", 2,
+           "binary_format_major_version is 2 - %s", mode_desc);
+    cmp_ok(mmdb->metadata.binary_format_minor_version, "==", 0,
+           "binary_format_minor_version is 0 - %s", mode_desc);
+
+    cmp_ok(mmdb->metadata.languages.count, "==", 2, "found 2 languages - %s",
+           mode_desc);
+    is(mmdb->metadata.languages.names[0], "en", "first language is en - %s",
+       mode_desc);
+    is(mmdb->metadata.languages.names[1], "zh", "second language is zh - %s",
+       mode_desc);
+
+    cmp_ok(mmdb->metadata.description.count, "==", 2,
+           "found 2 descriptions - %s", mode_desc);
+    for (uint16_t i = 0; i < mmdb->metadata.description.count; i++) {
+        const char *language =
+            mmdb->metadata.description.descriptions[i]->language;
+        const char *description =
+            mmdb->metadata.description.descriptions[i]->description;
+        if (strncmp(language, "en", 2) == 0) {
+            ok(1, "found en description");
+            is(description, "Test Database", "en description");
+        } else if (strncmp(language, "zh", 2) == 0) {
+            ok(1, "found zh description");
+            is(description, "Test Database Chinese", "zh description");
+        } else {
+            ok(0, "found unknown description in unexpected language - %s",
+               language);
+        }
+    }
+
+    cmp_ok(mmdb->full_record_byte_size, "==", 6,
+           "full_record_byte_size is 6 - %s", mode_desc);
+}
+
+MMDB_entry_data_list_s *test_languages_value(MMDB_entry_data_list_s
+                                             *entry_data_list)
+{
+    MMDB_entry_data_list_s *languages = entry_data_list = entry_data_list->next;
+
+    cmp_ok(languages->entry_data.type, "==", MMDB_DATA_TYPE_ARRAY,
+           "'languages' key's value is an array");
+    cmp_ok(languages->entry_data.data_size, "==", 2,
+           "'languages' key's value has 2 elements");
+
+    MMDB_entry_data_list_s *idx0 = entry_data_list = entry_data_list->next;
+    cmp_ok(idx0->entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+           "first array entry is a UTF8_STRING");
+    const char *lang0 = dup_entry_string_or_bail(idx0->entry_data);
+    is(lang0, "en", "first language is en");
+    free((void *)lang0);
+
+    MMDB_entry_data_list_s *idx1 = entry_data_list = entry_data_list->next;
+    cmp_ok(idx1->entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+           "second array entry is a UTF8_STRING");
+    const char *lang1 = dup_entry_string_or_bail(idx1->entry_data);
+    is(lang1, "zh", "second language is zh");
+    free((void *)lang1);
+
+    return entry_data_list;
+}
+
+MMDB_entry_data_list_s *test_description_value(
+    MMDB_entry_data_list_s *entry_data_list)
+{
+    MMDB_entry_data_list_s *description = entry_data_list =
+                                              entry_data_list->next;
+    cmp_ok(description->entry_data.type, "==", MMDB_DATA_TYPE_MAP,
+           "'description' key's value is a map");
+    cmp_ok(description->entry_data.data_size, "==", 2,
+           "'description' key's value has 2 key/value pairs");
+
+    for (int i = 0; i < 2; i++) {
+        MMDB_entry_data_list_s *key = entry_data_list =
+                                          entry_data_list->next;
+        cmp_ok(key->entry_data.type, "==",
+               MMDB_DATA_TYPE_UTF8_STRING,
+               "found a map key in 'map'");
+        const char *key_name = dup_entry_string_or_bail(key->entry_data);
+
+        MMDB_entry_data_list_s *value = entry_data_list =
+                                            entry_data_list->next;
+        cmp_ok(value->entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+               "map value is a UTF8_STRING");
+        const char *description =
+            dup_entry_string_or_bail(value->entry_data);
+
+        if (strcmp(key_name, "en") == 0) {
+            is(description, "Test Database",
+               "en description == 'Test Database'");
+        } else if (strcmp(key_name, "zh") == 0) {
+            is(description, "Test Database Chinese",
+               "zh description == 'Test Database Chinese'");
+        } else {
+            ok(0, "unknown key found in description map - %s", key_name);
+        }
+
+        free((void *)key_name);
+        free((void *)description);
+    }
+
+    return entry_data_list;
+}
+
+void test_metadata_as_data_entry_list(MMDB_s * mmdb,
+                                      const char *mode_desc)
+{
+    MMDB_entry_data_list_s *entry_data_list, *first;
+    int status =
+        MMDB_get_metadata_as_entry_data_list(mmdb, &entry_data_list);
+
+    first = entry_data_list;
+
+    cmp_ok(status, "==", MMDB_SUCCESS, "get metadata as data_entry_list - %s",
+           mode_desc);
+
+    cmp_ok(first->entry_data.data_size, "==", 9,
+           "metadata map has 9 key/value pairs");
+
+    while (1) {
+        MMDB_entry_data_list_s *key = entry_data_list =
+                                          entry_data_list->next;
+
+        if (!key) {
+            break;
+        }
+
+        cmp_ok(key->entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+               "found a map key");
+
+        const char *key_name = dup_entry_string_or_bail(key->entry_data);
+        if (strcmp(key_name, "node_count") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            cmp_ok(value->entry_data.uint32, "==", 37, "node_count == 37");
+        } else if (strcmp(key_name, "record_size") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            cmp_ok(value->entry_data.uint16, "==", 24, "record_size == 24");
+        } else if (strcmp(key_name, "ip_version") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            cmp_ok(value->entry_data.uint16, "==", 4, "ip_version == 4");
+        } else if (strcmp(key_name, "binary_format_major_version") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            cmp_ok(value->entry_data.uint16, "==", 2,
+                   "binary_format_major_version == 2");
+        } else if (strcmp(key_name, "binary_format_minor_version") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            cmp_ok(value->entry_data.uint16, "==", 0,
+                   "binary_format_minor_version == 0");
+        } else if (strcmp(key_name, "build_epoch") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            ok(value->entry_data.uint64 > 1373571901,
+               "build_epoch > 1373571901");
+        } else if (strcmp(key_name, "database_type") == 0) {
+            MMDB_entry_data_list_s *value
+                = entry_data_list = entry_data_list->next;
+            const char *type = dup_entry_string_or_bail(value->entry_data);
+            is(type, "Test", "type == Test");
+            free((void *)type);
+        } else if (strcmp(key_name, "languages") == 0) {
+            entry_data_list = test_languages_value(entry_data_list);
+        } else if (strcmp(key_name, "description") == 0) {
+            entry_data_list = test_description_value(entry_data_list);
+        } else {
+            ok(0, "unknown key found in metadata map - %s",
+               key_name);
+        }
+
+        free((void *)key_name);
+    }
+
+    MMDB_free_entry_data_list(first);
+}
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *file = "MaxMind-DB-test-ipv4-24.mmdb";
+    const char *path = test_database_path(file);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+
+    // All of the remaining tests require an open mmdb
+    if (NULL == mmdb) {
+        diag("could not open %s - skipping remaining tests", path);
+        return;
+    }
+    free((void *)path);
+
+    test_metadata(mmdb, mode_desc);
+    test_metadata_as_data_entry_list(mmdb, mode_desc);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/mmdblookup_t.pl

@@ -0,0 +1,158 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+use FindBin qw( $Bin );
+
+eval <<'EOF';
+use Test::More 0.88;
+use IPC::Run3 qw( run3 );
+EOF
+
+if ($@) {
+    print
+        "1..0 # skip all tests skipped - these tests need the Test::More 0.88, IPC::Run3 and Test::Output modules:\n";
+    print "$@";
+    exit 0;
+}
+
+my $mmdblookup    = "$Bin/../bin/mmdblookup";
+my $test_data_dir = "$Bin/maxmind-db/test-data";
+
+{
+    ok( -x $mmdblookup, 'mmdblookup script is executable' );
+}
+
+for my $arg (qw( -h -? --help )) {
+    _test_stdout(
+        [$arg],
+        qr{mmdblookup --file.+This application accepts the following options:}s,
+        0,
+        "help output from $arg"
+    );
+}
+
+_test_both(
+    [],
+    qr{mmdblookup --file.+This application accepts the following options:}s,
+    qr{ERROR: You must provide a filename with --file},
+    1,
+    "help output with no CLI options"
+);
+
+_test_stderr(
+    [qw( --file foo )],
+    qr{ERROR: You must provide an IP address with --ip},
+    1,
+    'error when no --ip is given'
+);
+
+_test_stdout(
+    [qw( --version )],
+    qr/mmdblookup version \d+\.\d+\.\d+/,
+    0,
+    'output for --version'
+);
+
+_test_stdout(
+    ['--file', "$test_data_dir/GeoIP2-City-Test.mmdb", '--ip', '2.125.160.216'],
+    qr/"en"\s*:\s*"Boxford"/,
+    0,
+    'output for 2.125.160.216'
+);
+
+_test_stdout(
+    ['--file', "$test_data_dir/GeoIP2-City-Test.mmdb", '--ip', '2.125.160.216', '--verbose'],
+    qr/Database metadata.+"en"\s*:\s*"Boxford"/s,
+    0,
+    'verbose output for 2.125.160.216'
+);
+
+_test_stdout(
+    ['--file', "$test_data_dir/GeoIP2-City-Test.mmdb", '--ip', '2.125.160.216', qw( location latitude )],
+    qr/^\s*51\.750000 <double>\s*$/s,
+    0,
+    'output for 2.125.160.216 with lookup path'
+);
+
+_test_stderr(
+    [ qw( --file this/path/better/not/exist.mmdb --ip 1.2.3.4 ) ],
+    qr{Can't open this/path/better/not/exist.mmdb}s,
+    2,
+    'error for file that does not exist'
+);
+
+_test_stderr(
+    ['--file', "$test_data_dir/GeoIP2-City-Test.mmdb", '--ip', 'not-an-ip-address' ],
+    qr{Error from call to getaddrinfo for not-an-ip-address}s,
+    3,
+    'error for bad IP address'
+);
+
+_test_stderr(
+    ['--file', "$test_data_dir/GeoIP2-City-Test.mmdb", '--ip', '10.2.3.4' ],
+    qr{\QCould not find an entry for this IP address (10.2.3.4)}s,
+    6,
+    'error for bad PI address'
+);
+
+done_testing();
+
+sub _test_stdout {
+    my $args          = shift;
+    my $expect_stdout = shift;
+    my $expect_status = shift;
+    my $desc          = shift;
+
+    _test_both( $args, $expect_stdout, q{}, $expect_status, $desc );
+}
+
+sub _test_stderr {
+    my $args          = shift;
+    my $expect_stderr = shift;
+    my $expect_status = shift;
+    my $desc          = shift;
+
+    _test_both( $args, undef, $expect_stderr, $expect_status, $desc );
+}
+
+sub _test_both {
+    my $args          = shift;
+    my $expect_stdout = shift;
+    my $expect_stderr = shift;
+    my $expect_status = shift;
+    my $desc          = shift;
+
+    my $stdout;
+    my $stderr;
+    run3(
+        [ $mmdblookup, @{$args} ],
+        \undef,
+        \$stdout,
+        \$stderr,
+    );
+
+    my $exit_status = $? >> 8;
+
+    # We don't need to retest that the help output shows up for all errors
+    if ( defined $expect_stdout ) {
+        like(
+            $stdout,
+            $expect_stdout,
+            "stdout for mmdblookup @{$args}"
+        );
+    }
+
+    if ( ref $expect_stderr ) {
+        like( $stderr, $expect_stderr, "stderr for mmdblookup @{$args}" );
+    }
+    else {
+        is( $stderr, $expect_stderr, "stderr for mmdblookup @{$args}" );
+    }
+
+    is(
+        $exit_status, $expect_status,
+        "exit status was $expect_status for mmdblookup @{$args}"
+    );
+}

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

@@ -0,0 +1,32 @@
+#include "maxminddb_test_helper.h"
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-string-value-entries.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const char *ip = "1.1.1.1";
+    MMDB_lookup_result_s result =
+        lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+    MMDB_entry_data_s entry_data;
+    int status = MMDB_get_value(&result.entry, &entry_data, NULL);
+
+    cmp_ok(status, "==", MMDB_SUCCESS,
+           "status for MMDB_get_value() is MMDB_SUCCESS");
+    ok(entry_data.has_data, "found a value when varargs list is just NULL");
+    cmp_ok(entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+           "returned entry type is utf8_string");
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

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

@@ -0,0 +1,157 @@
+#include "maxminddb_test_helper.h"
+
+void test_entry_data(MMDB_s *mmdb, MMDB_entry_s *entry, uint32_t node_number,
+                     char * node_record)
+{
+    MMDB_entry_data_s entry_data;
+    int status =
+        MMDB_get_value(entry, &entry_data, "ip",
+                       NULL);
+    cmp_ok(status, "==", MMDB_SUCCESS,
+           "successful data lookup for node");
+    cmp_ok(
+        entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
+        "returned entry type is UTF8_STRING for %s record of node %i",
+        node_record, node_number);
+}
+
+void run_read_node_tests(MMDB_s *mmdb, const uint32_t tests[][5],
+                         int test_count,
+                         uint8_t record_size)
+{
+    for (int i = 0; i < test_count; i++) {
+        uint32_t node_number = tests[i][0];
+        MMDB_search_node_s node;
+        int status = MMDB_read_node(mmdb, node_number, &node);
+        if (MMDB_SUCCESS == status) {
+            cmp_ok(node.left_record, "==", tests[i][1],
+                   "left record for node %i is %i - %i bit DB",
+                   node_number, tests[i][1], record_size);
+            cmp_ok(node.left_record_type, "==", tests[i][2],
+                   "left record type for node %i is %i", node_number,
+                   tests[i][2]);
+            if (node.left_record_type == MMDB_RECORD_TYPE_DATA) {
+                test_entry_data(mmdb, &node.left_record_entry, node_number,
+                                "left");
+            }
+
+            cmp_ok(node.right_record, "==", tests[i][3],
+                   "right record for node %i is %i - %i bit DB",
+                   node_number, tests[i][3], record_size);
+            cmp_ok(node.right_record_type, "==", tests[i][4],
+                   "right record type for node %i is %i", node_number,
+                   tests[i][4]);
+
+            if (node.right_record_type == MMDB_RECORD_TYPE_DATA) {
+                test_entry_data(mmdb, &node.right_record_entry, node_number,
+                                "right");
+            }
+        } else {
+            diag("call to MMDB_read_node for node %i failed - %i bit DB",
+                 node_number,
+                 record_size);
+        }
+    }
+}
+
+void run_24_bit_record_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-mixed-24.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const uint32_t tests[7][5] = {
+        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY },
+        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
+          MMDB_RECORD_TYPE_DATA, },
+        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, }
+    };
+    run_read_node_tests(mmdb, tests, 7, 24);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void run_28_bit_record_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-mixed-28.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const uint32_t tests[7][5] = {
+        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY },
+        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
+          MMDB_RECORD_TYPE_DATA, },
+        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, }
+    };
+    run_read_node_tests(mmdb, tests, 7, 28);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void run_32_bit_record_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-mixed-32.mmdb";
+    const char *path = test_database_path(filename);
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    const uint32_t tests[7][5] = {
+        { 0,   1,   MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY },
+        { 80,  81,  MMDB_RECORD_TYPE_SEARCH_NODE, 197,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 96,  97,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 103, 242, MMDB_RECORD_TYPE_EMPTY,       104,
+          MMDB_RECORD_TYPE_SEARCH_NODE, },
+        { 127, 242, MMDB_RECORD_TYPE_EMPTY,       315,
+          MMDB_RECORD_TYPE_DATA, },
+        { 132, 329, MMDB_RECORD_TYPE_DATA,        242,
+          MMDB_RECORD_TYPE_EMPTY, },
+        { 241, 96,  MMDB_RECORD_TYPE_SEARCH_NODE, 242,
+          MMDB_RECORD_TYPE_EMPTY, }
+    };
+
+    run_read_node_tests(mmdb, tests, 7, 32);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void run_tests(int mode, const char *mode_desc)
+{
+    run_24_bit_record_tests(mode, mode_desc);
+    run_28_bit_record_tests(mode, mode_desc);
+    run_32_bit_record_tests(mode, mode_desc);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}