geoip2_c 0.3.0 → 0.3.1

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

@@ -0,0 +1,23 @@
+include $(top_srcdir)/common.mk
+
+all-local:
+		cd libtap && $(MAKE) $(AM_MAKEFLAGS) all
+clean-local:
+		cd libtap && $(MAKE) $(AM_MAKEFLAGS) clean
+
+AM_LDFLAGS = $(top_builddir)/src/libmaxminddb.la
+
+noinst_LTLIBRARIES = libmmdbtest.la
+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 \
+	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
+
+threads_t_CFLAGS = $(CFLAGS) -pthread
+
+TESTS = $(check_PROGRAMS) compile_c++_t.pl mmdblookup_t.pl
+
+LDADD = libmmdbtest.la libtap/libtap.a

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

@@ -0,0 +1,66 @@
+// This test currently does not work on Windows as nftw is
+// not available.
+#define _XOPEN_SOURCE 500
+#include <ftw.h>
+
+#include <libgen.h>
+#include <unistd.h>
+
+#include "maxminddb_test_helper.h"
+
+int test_read(const char *path, const struct stat *UNUSED(
+                  sbuf), int flags, struct FTW *UNUSED(ftw))
+{
+    // Check if path is a regular file)
+    if (flags != FTW_F) {
+        return 0;
+    }
+
+    MMDB_s *mmdb = (MMDB_s *)calloc(1, sizeof(MMDB_s));
+
+    if (NULL == mmdb) {
+        BAIL_OUT("could not allocate memory for our MMDB_s struct");
+    }
+
+    int status = MMDB_open(path, MMDB_MODE_MMAP, mmdb);
+
+    if (status != MMDB_SUCCESS) {
+        ok(1, "received error when opening %s", path);
+        return 0;
+    }
+
+    int gai_error, mmdb_error;
+    MMDB_lookup_string(mmdb, "1.1.1.1", &gai_error, &mmdb_error);
+    if (gai_error != 0) {
+        BAIL_OUT("could not parse IP address");
+    }
+
+    cmp_ok(mmdb_error, "!=", MMDB_SUCCESS, "opening %s returned an error",
+           path);
+
+    MMDB_close(mmdb);
+    free(mmdb);
+    return 0;
+}
+
+int main(void)
+{
+    char *test_db_dir;
+#ifdef _WIN32
+    test_db_dir = "./t/maxmind-db/bad-data";
+#else
+    char cwd[500];
+    char *UNUSED(tmp) = getcwd(cwd, 500);
+
+    if (strcmp(basename(cwd), "t") == 0) {
+        test_db_dir = "./maxmind-db/bad-data";
+    } else {
+        test_db_dir = "./t/maxmind-db/bad-data";
+    }
+#endif
+    plan(NO_PLAN);
+    if (nftw(test_db_dir, test_read, 10, FTW_PHYS) != 0) {
+        BAIL_OUT("nftw failed");
+    }
+    done_testing();
+}

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

@@ -0,0 +1,53 @@
+#include "maxminddb_test_helper.h"
+
+void run_tests(int mode, const char *mode_desc)
+{
+    const char *filename = "MaxMind-DB-test-broken-pointers-24.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.16";
+        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_INVALID_DATA_ERROR,
+            "MMDB_get_value returns MMDB_INVALID_DATA_ERROR for bad pointer in data section");
+
+        MMDB_entry_data_list_s *entry_data_list;
+        status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
+
+        cmp_ok(
+            status, "==", MMDB_INVALID_DATA_ERROR,
+            "MMDB_get_entry_data_list returns MMDB_INVALID_DATA_ERROR for bad pointer in data section");
+
+        MMDB_free_entry_data_list(entry_data_list);
+    }
+
+    {
+        const char *ip = "1.1.1.32";
+
+        int gai_error, mmdb_error;
+        MMDB_lookup_result_s UNUSED(result) =
+            MMDB_lookup_string(mmdb, ip, &gai_error, &mmdb_error);
+
+        cmp_ok(
+            mmdb_error, "==", MMDB_CORRUPT_SEARCH_TREE_ERROR,
+            "MMDB_lookup_string sets mmdb_error to MMDB_CORRUPT_SEARCH_TREE_ERROR when a search tree record points outside the data section");
+    }
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&run_tests);
+    done_testing();
+}

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

@@ -0,0 +1,172 @@
+#include "maxminddb_test_helper.h"
+
+/* 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;
+static const char *Current_Mode_Description;
+
+void test_one_result(MMDB_s *mmdb, MMDB_lookup_result_s result,
+                     const char *ip, const char *expect,
+                     const char *function, const char *filename,
+                     const char *mode_desc)
+{
+    int is_ok = ok(result.found_entry,
+                   "got a result for an IP in the database - %s - %s - %s - %s",
+                   function, ip, filename, mode_desc);
+
+    if (!is_ok) {
+        return;
+    }
+
+    MMDB_entry_data_s data =
+        data_ok(&result, MMDB_DATA_TYPE_UTF8_STRING, "result{ip}", "ip", NULL);
+
+    char *string = strndup(data.utf8_string, data.data_size);
+
+    char *real_expect;
+    if (mmdb->metadata.ip_version == 4 || strncmp(expect, "::", 2) == 0) {
+        real_expect = strndup(expect, strlen(expect));
+    } else {
+        // When looking up IPv4 addresses in a mixed DB the result will be
+        // something like "::1.2.3.4", not just "1.2.3.4".
+        int maxlen = strlen(expect) + 3;
+        real_expect = malloc(maxlen);
+        snprintf(real_expect, maxlen, "::%s", expect);
+    }
+
+    is(string, real_expect,
+       "found expected result for ip key - %s - %s - %s - %s", function, ip,
+       filename, mode_desc);
+
+    free(real_expect);
+    free(string);
+}
+
+void test_one_ip(MMDB_s *mmdb, const char *ip, const char *expect,
+                 const char *filename, const char *mode_desc)
+{
+    MMDB_lookup_result_s result =
+        lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+    test_one_result(mmdb, result, ip, expect, "MMDB_lookup_string", filename,
+                    mode_desc);
+
+    result = lookup_sockaddr_ok(mmdb, ip, filename, mode_desc);
+    test_one_result(mmdb, result, ip, expect, "MMDB_lookup_addrinfo", filename,
+                    mode_desc);
+}
+
+void run_ipX_tests(const char *filename, const char **missing_ips,
+                   int missing_ips_length, const char *pairs[][2],
+                   int pairs_rows)
+{
+    const char *path = test_database_path(filename);
+    int mode = Current_Mode;
+    const char *mode_desc = Current_Mode_Description;
+
+    MMDB_s *mmdb = open_ok(path, mode, mode_desc);
+    free((void *)path);
+
+    char desc_suffix[500];
+    snprintf(desc_suffix, 500, "%s - %s", filename, mode_desc);
+
+    for (int i = 0; i < missing_ips_length; i++) {
+        const char *ip = missing_ips[i];
+
+        MMDB_lookup_result_s result =
+            lookup_string_ok(mmdb, ip, filename, mode_desc);
+
+        ok(
+            !result.found_entry,
+            "no result entry struct returned for IP address not in the database (string lookup) - %s - %s - %s",
+            ip, filename, mode_desc);
+
+        result = lookup_sockaddr_ok(mmdb, ip, filename, mode_desc);
+
+        ok(
+            !result.found_entry,
+            "no result entry struct returned for IP address not in the database (ipv4 lookup) - %s - %s - %s",
+            ip, filename, mode_desc);
+    }
+
+    for (int i = 0; i < pairs_rows; i += 1) {
+        const char *ip_to_lookup = pairs[i][0];
+        const char *expect = pairs[i][1];
+
+        test_one_ip(mmdb, ip_to_lookup, expect, filename, mode_desc);
+    }
+
+    MMDB_close(mmdb);
+    free(mmdb);
+}
+
+void run_ipv4_tests(int UNUSED(
+                        record_size), const char *filename, const char *UNUSED(
+                        ignored))
+{
+    const char *pairs[9][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" },
+    };
+
+    const char *missing[1] = { "2.3.4.5" };
+    run_ipX_tests(filename, missing, 1, pairs, 9);
+}
+
+void run_ipv6_tests(int UNUSED(
+                        record_size), const char *filename, const char *UNUSED(
+                        ignored))
+{
+    const char *pairs[9][2] = {
+        { "::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"      },
+    };
+
+    const char *missing[2] = { "2.3.4.5", "::abcd" };
+    run_ipX_tests(filename, missing, 2, pairs, 9);
+}
+
+void all_record_sizes(int mode, const char *description)
+{
+    const char *ipv4_filename_fmts[] = {
+        "MaxMind-DB-test-ipv4-%i.mmdb",
+        "MaxMind-DB-test-mixed-%i.mmdb"
+    };
+
+    Current_Mode = mode;
+    Current_Mode_Description = description;
+
+    for (int i = 0; i < 2; i++) {
+        for_all_record_sizes(ipv4_filename_fmts[i], &run_ipv4_tests);
+    }
+
+    const char *ipv6_filename_fmts[] = {
+        "MaxMind-DB-test-ipv6-%i.mmdb",
+        "MaxMind-DB-test-mixed-%i.mmdb"
+    };
+
+    for (int i = 0; i < 2; i++) {
+        for_all_record_sizes(ipv6_filename_fmts[i], &run_ipv6_tests);
+    }
+}
+
+int main(void)
+{
+    plan(NO_PLAN);
+    for_all_modes(&all_record_sizes);
+    done_testing();
+}

data/ext/geoip2/libmaxminddb/t/compile_c++_t.pl

@@ -0,0 +1,107 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+use Cwd qw( abs_path );
+use FindBin qw( $Bin );
+
+eval <<'EOF';
+use Test::More 0.88;
+use File::Temp qw( tempdir );
+use IPC::Run3 qw( run3 );
+EOF
+
+if ($@) {
+    print
+        "1..0 # skip all tests skipped - these tests need the Test::More 0.88, File::Temp, and IPC::Run3 modules:\n";
+    print "$@";
+    exit 0;
+}
+
+my $test_db = "$Bin/maxmind-db/test-data/GeoIP2-City-Test.mmdb";
+
+my $cpp_code = <<"EOF";
+#include <maxminddb.h>
+
+int main(int argc, char *argv[])
+{
+    const char *fname = "$test_db";
+    MMDB_s mmdb;
+    return MMDB_open(fname, MMDB_MODE_MMAP, &mmdb);
+}
+EOF
+
+my $tempdir = tempdir(CLEANUP => 1 );
+
+my $file = "$tempdir/open.cpp";
+open my $fh, '>', $file or die $!;
+print {$fh} $cpp_code or die $!;
+close $fh or die $!;
+
+my $exe = "$tempdir/open";
+
+my $include_dir = abs_path("$Bin/../include");
+my $lib_dir = abs_path("$Bin/../src/.libs");
+
+my $cxx = $ENV{CXX} || 'c++';
+_test_cmd(
+    [ $cxx, $file, "-I$include_dir", "-L$lib_dir", "-lmaxminddb", "-o$exe" ],
+    qr/^$/,
+    q{},
+    0,
+    'compile C++ program which links against libmaxminddb',
+);
+
+# DYLD_LIBRARY_PATH is for Mac OS X
+$ENV{LD_LIBRARY_PATH} = $ENV{DYLD_LIBRARY_PATH} = $lib_dir;
+
+_test_cmd(
+    [$exe],
+    qr/^$/,
+    q{},
+    0,
+    'compiled C++ program executes without errors'
+);
+
+done_testing();
+
+sub _test_cmd {
+    my $cmd          = shift;
+    my $expect_stdout = shift;
+    my $expect_stderr = shift;
+    my $expect_status = shift;
+    my $desc          = shift;
+
+    my $stdout;
+    my $stderr;
+    run3(
+        $cmd,
+        \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 @{$cmd}"
+        );
+    }
+
+    if ( ref $expect_stderr ) {
+        like( $stderr, $expect_stderr, "stderr for @{$cmd}" );
+    }
+    else {
+        is( $stderr, $expect_stderr, "stderr for @{$cmd}" );
+    }
+
+    is(
+        $exit_status, $expect_status,
+        "exit status was $expect_status for @{$cmd}"
+    );
+}