geoip2_c 0.3.4 → 0.4.1

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

@@ -1,158 +0,0 @@
-#!/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

@@ -1,32 +0,0 @@
-#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

@@ -1,157 +0,0 @@
-#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();
-}

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

@@ -1,196 +0,0 @@
-#include "maxminddb_test_helper.h"
-#include <pthread.h>
-
-typedef struct thread_arg {
-    int thread_id;
-    MMDB_s *mmdb;
-    const char *ip_to_lookup;
-} thread_arg_s;
-
-typedef struct test_result {
-    const char *ip_looked_up;
-    int lookup_string_gai_error;
-    int lookup_string_mmdb_error;
-    int found_entry;
-    int get_value_status;
-    int data_type_ok;
-    char *data_value;
-} test_result_s;
-
-void test_one_ip(MMDB_s *mmdb, const char *ip, test_result_s *test_result)
-{
-
-    test_result->ip_looked_up = ip;
-
-    int gai_error = 0;
-    int mmdb_error = 0;
-    MMDB_lookup_result_s result =
-        MMDB_lookup_string(mmdb, ip, &gai_error, &mmdb_error);
-
-    test_result->lookup_string_gai_error = gai_error;
-    if (gai_error) {
-        return;
-    }
-
-    test_result->lookup_string_mmdb_error = mmdb_error;
-    if (mmdb_error) {
-        return;
-    }
-
-    test_result->found_entry = result.found_entry;
-    if (!result.found_entry) {
-        return;
-    }
-
-    MMDB_entry_data_s data;
-    int status = MMDB_get_value(&result.entry, &data, "ip", NULL);
-
-    test_result->get_value_status = status;
-    if (status) {
-        return;
-    }
-
-    test_result->data_type_ok = data.type == MMDB_DATA_TYPE_UTF8_STRING;
-    if (!test_result->data_type_ok) {
-        return;
-    }
-
-    test_result->data_value = strndup(data.utf8_string, data.data_size);
-
-    return;
-}
-
-void *run_one_thread(void *arg)
-{
-    thread_arg_s *thread_arg = (thread_arg_s *)arg;
-
-    MMDB_s *mmdb = thread_arg->mmdb;
-    const char *ip = thread_arg->ip_to_lookup;
-
-    test_result_s *result = malloc(sizeof(test_result_s));
-    test_one_ip(mmdb, ip, result);
-
-    pthread_exit((void *)result);
-}
-
-void process_result(test_result_s *result, const char *expect,
-                    const char *mode_desc)
-{
-    int is_ok;
-    is_ok =
-        ok(!result->lookup_string_gai_error, "no getaddrinfo error for %s - %s",
-           result->ip_looked_up, mode_desc);
-    if (!is_ok) {
-        return;
-    }
-
-    is_ok = ok(!result->lookup_string_mmdb_error, "no mmdb error for %s - %s",
-               result->ip_looked_up, mode_desc);
-    if (!is_ok) {
-        return;
-    }
-
-    is_ok = ok(result->found_entry, "got a result for %s in the database - %s",
-               result->ip_looked_up, mode_desc);
-    if (!is_ok) {
-        return;
-    }
-
-    is_ok =
-        ok(!result->get_value_status,
-           "no error from MMDB_get_value for %s - %s",
-           result->ip_looked_up,
-           mode_desc);
-    if (!is_ok) {
-        return;
-    }
-
-    is_ok = ok(result->data_type_ok,
-               "MMDB_get_value found a utf8_string at 'ip' key for %s - %s",
-               result->ip_looked_up, mode_desc);
-    if (!is_ok) {
-        return;
-    }
-
-    is(result->data_value, expect,
-       "found expected result for 'ip' key for %s - %s",
-       result->ip_looked_up, mode_desc);
-}
-
-void run_ipX_tests(MMDB_s *mmdb, const char *pairs[][2], int pairs_rows,
-                   int mode, const char *mode_desc)
-{
-    pthread_t threads[pairs_rows];
-    struct thread_arg thread_args[pairs_rows];
-
-    for (int i = 0; i < pairs_rows; i += 1) {
-        thread_args[i].thread_id = i;
-        thread_args[i].mmdb = mmdb;
-        thread_args[i].ip_to_lookup = pairs[i][0];
-
-        int error = pthread_create(&threads[i], NULL, run_one_thread,
-                                   &thread_args[i]);
-        if (error) {
-            BAIL_OUT("pthread_create failed");
-        }
-    }
-
-    for (int i = 0; i < pairs_rows; i += 1) {
-        void *thread_return;
-        int error = pthread_join(threads[i], &thread_return);
-        if (error) {
-            BAIL_OUT("pthread_join failed");
-        }
-
-        test_result_s *test_result = (test_result_s *)thread_return;
-        if (NULL != test_result) {
-            process_result(test_result, pairs[i][1], mode_desc);
-            if (test_result->data_type_ok) {
-                free(test_result->data_value);
-            }
-            free(test_result);
-        }
-    }
-}
-
-void run_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 char *pairs[18][2] = {
-        { "1.1.1.1",       "::1.1.1.1"     },
-        { "1.1.1.2",       "::1.1.1.2"     },
-        { "1.1.1.3",       "::1.1.1.2"     },
-        { "1.1.1.7",       "::1.1.1.4"     },
-        { "1.1.1.9",       "::1.1.1.8"     },
-        { "1.1.1.15",      "::1.1.1.8"     },
-        { "1.1.1.17",      "::1.1.1.16"    },
-        { "1.1.1.31",      "::1.1.1.16"    },
-        { "1.1.1.32",      "::1.1.1.32"    },
-        { "::1:ffff:ffff", "::1:ffff:ffff" },
-        { "::2:0:0",       "::2:0:0"       },
-        { "::2:0:1a",      "::2:0:0"       },
-        { "::2:0:40",      "::2:0:40"      },
-        { "::2:0:4f",      "::2:0:40"      },
-        { "::2:0:50",      "::2:0:50"      },
-        { "::2:0:52",      "::2:0:50"      },
-        { "::2:0:58",      "::2:0:58"      },
-        { "::2:0:59",      "::2:0:58"      },
-    };
-
-    run_ipX_tests(mmdb, pairs, 18, mode, mode_desc);
-
-    MMDB_close(mmdb);
-    free(mmdb);
-}
-
-int main(void)
-{
-    plan(NO_PLAN);
-    for_all_modes(&run_tests);
-    done_testing();
-    pthread_exit(NULL);
-}

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

@@ -1,10 +0,0 @@
-#include "maxminddb_test_helper.h"
-
-int main(void)
-{
-    const char *version = MMDB_lib_version();
-    if (ok((version != NULL), "MMDB_lib_version exists")) {
-        is(version, PACKAGE_VERSION, "version is " PACKAGE_VERSION);
-    }
-    done_testing();
-}