geoip2_c 0.3.2 → 0.3.3

data/ext/geoip2/libmaxminddb/configure.ac

@@ -2,7 +2,7 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ([2.63])
-AC_INIT([libmaxminddb], [1.2.1], [support@maxmind.com])
+AC_INIT([libmaxminddb], [1.3.2], [support@maxmind.com])
 AC_CONFIG_SRCDIR([include/maxminddb.h])
 AC_CONFIG_HEADERS([config.h include/maxminddb_config.h])
 
@@ -63,9 +63,11 @@ AC_CHECK_HEADERS([arpa/inet.h assert.h fcntl.h inttypes.h libgen.h math.h netdb.
 # so we only run them on non MinGW-Systems. For MinGW we also need to link
 # against ws2_32.
 AC_CANONICAL_HOST
+is_windows=false
 case $host_os in
         mingw*)
                 LDFLAGS="-lws2_32"
+                is_windows=true
         ;;
         *)
                 AC_TYPE_OFF_T
@@ -77,6 +79,7 @@ case $host_os in
         ;;
 esac
 
+AM_CONDITIONAL([WINDOWS], [test x$is_windows = xtrue])
 
 # This check is backwards in order to make life easier for people writing
 # extensions in other languages that link to this library. If they want to
@@ -94,15 +97,12 @@ AC_CHECK_TYPE(
 
 AC_CHECK_TYPES([boolean])
 
-AC_CHECK_FUNC(
-        [open_memstream],
-        [AC_DEFINE([HAVE_OPEN_MEMSTREAM], [1], [Has an open_memstream() function])])
+AC_CHECK_FUNCS([clock_gettime open_memstream])
 
 AC_C_BIGENDIAN(
         [AC_DEFINE([MMDB_LITTLE_ENDIAN], [0], [System is big-endian])],
         [AC_DEFINE([MMDB_LITTLE_ENDIAN], [1], [System is little-endian])])
 
-AC_FUNC_MALLOC
 AC_FUNC_MMAP
 
 AC_SEARCH_LIBS([fabs], [m])

data/ext/geoip2/libmaxminddb/dev-bin/ppa-release.sh

@@ -4,7 +4,7 @@ set -e
 set -x
 set -u
 
-DISTS=( wily trusty precise )
+DISTS=( artful zesty xenial trusty precise )
 
 VERSION=$(perl -MFile::Slurp::Tiny=read_file -MDateTime <<EOF
 use v5.16;
@@ -27,11 +27,11 @@ pushd "$SRCDIR"
 git merge "$VERSION"
 
 for dist in "${DISTS[@]}"; do
-    git clean -xfd
-    git reset HEAD --hard
-
     dch -v "$VERSION-0+maxmind1~$dist" -D "$dist" -u low "New upstream release."
     gbp buildpackage -S --git-ignore-new
+
+    git clean -xfd
+    git reset HEAD --hard
 done
 
 read -e -p "Release to PPA? (y/n)" SHOULD_RELEASE
@@ -41,9 +41,12 @@ if [ "$SHOULD_RELEASE" != "y" ]; then
     exit 1
 fi
 
+# Upload to launchpad
 dput ppa:maxmind/ppa ../*source.changes
 
-popd
+# Make the changelog up to date in git
+
+dch -v "$VERSION-0+maxmind1" -D "${DISTS[0]}" -u low "New upstream release."
 
 git add debian/changelog
 git commit -m "Update debian/changelog for $VERSION"

data/ext/geoip2/libmaxminddb/dev-bin/release.sh

@@ -47,6 +47,13 @@ if [ -n "$(git status --porcelain)" ]; then
     git commit -m "Bumped version to $version"
 fi
 
+./bootstrap
+./configure
+make
+make check
+make clean
+make safedist
+
 if [ ! -d .gh-pages ]; then
     echo "Checking out gh-pages in .gh-pages"
     git clone -b gh-pages git@github.com:maxmind/libmaxminddb.git .gh-pages

data/ext/geoip2/libmaxminddb/dev-bin/valgrind-all.pl

@@ -1,5 +1,10 @@
 #!/usr/bin/env perl
 
+# Note to run this you will probably want to build with ./configure
+# --disable-shared. You don't want to valgrind the libtool script.
+#
+# Also make sure you compile the tests first (`make check').
+
 use strict;
 use warnings;
 
@@ -11,11 +16,13 @@ my $top_dir = "$Bin/..";
 
 my $output;
 
-my @tests = glob "$top_dir/t/.libs/lt-*_t";
+my @tests;
+push @tests, glob "$top_dir/t/*_t";
+push @tests, glob "$top_dir/t/*-t";
 
 my @mmdblookup = (
     "$top_dir/bin/mmdblookup",
-    '--file', "$top_dir/maxmind-db/test-data/MaxMind-DB-test-decoder.mmdb",
+    '--file', "$top_dir/t/maxmind-db/test-data/MaxMind-DB-test-decoder.mmdb",
     '--ip',
 );
 
@@ -31,7 +38,7 @@ my @cmds = (
 for my $cmd (@cmds) {
     my $output;
     run3(
-        [ qw( valgrind --leak-check=full -- ), @{$cmd} ],
+        [ qw( valgrind -v --leak-check=full --show-leak-kinds=all -- ), @{$cmd} ],
         \undef,
         \$output,
         \$output,

data/ext/geoip2/libmaxminddb/include/maxminddb.h

@@ -5,8 +5,16 @@ extern "C" {
 #ifndef MAXMINDDB_H
 #define MAXMINDDB_H
 
+/* Request POSIX.1-2008. However, we want to remain compatible with
+ * POSIX.1-2001 (since we have been historically and see no reason to drop
+ * compatibility). By requesting POSIX.1-2008, we can conditionally use
+ * features provided by that standard if the implementation provides it. We can
+ * check for what the implementation provides by checking the _POSIX_VERSION
+ * macro after including unistd.h. If a feature is in POSIX.1-2008 but not
+ * POSIX.1-2001, check that macro before using the feature (or check for the
+ * feature directly if possible). */
 #ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 200112L
+#define _POSIX_C_SOURCE 200809L
 #endif
 
 #include "maxminddb_config.h"
@@ -20,7 +28,7 @@ extern "C" {
 #include <winsock2.h>
 #include <ws2tcpip.h>
 /* libmaxminddb package version from configure */
-#define PACKAGE_VERSION "1.2.1"
+#define PACKAGE_VERSION "1.3.2"
 
 typedef ADDRESS_FAMILY sa_family_t;
 
@@ -135,6 +143,7 @@ typedef struct MMDB_entry_data_s {
 typedef struct MMDB_entry_data_list_s {
     MMDB_entry_data_s entry_data;
     struct MMDB_entry_data_list_s *next;
+    void *pool;
 } MMDB_entry_data_list_s;
 
 typedef struct MMDB_description_s {

data/ext/geoip2/libmaxminddb/projects/VS12/libmaxminddb.vcxproj

@@ -20,9 +20,11 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\src\maxminddb.c" />
+    <ClCompile Include="..\..\src\data-pool.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\include\maxminddb.h" />
+    <ClInclude Include="..\..\src\data-pool.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="README" />
@@ -138,4 +140,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

data/ext/geoip2/libmaxminddb/projects/VS12/libmaxminddb.vcxproj.filters

@@ -14,13 +14,19 @@
     <ClCompile Include="..\..\src\maxminddb.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\data-pool.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\include\maxminddb.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\data-pool.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="README" />
   </ItemGroup>
-</Project>
+</Project>

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

@@ -2,8 +2,24 @@ include $(top_srcdir)/common.mk
 
 lib_LTLIBRARIES = libmaxminddb.la
 
-libmaxminddb_la_SOURCES = maxminddb.c maxminddb-compat-util.h
-libmaxminddb_la_LDFLAGS = -version-info 0:7:0
+libmaxminddb_la_SOURCES = maxminddb.c maxminddb-compat-util.h \
+	data-pool.c data-pool.h
+libmaxminddb_la_LDFLAGS = -version-info 0:7:0 -export-symbols-regex '^MMDB_.*'
 include_HEADERS = $(top_srcdir)/include/maxminddb.h
 
 pkgconfig_DATA = libmaxminddb.pc
+
+TESTS = test-data-pool
+
+check_PROGRAMS = test-data-pool
+
+test_data_pool_SOURCES = data-pool.c data-pool.h
+test_data_pool_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/t -DTEST_DATA_POOL
+test_data_pool_LDADD = $(top_srcdir)/t/libmmdbtest.la \
+	$(top_srcdir)/t/libtap/libtap.a
+
+$(top_srcdir)/t/libmmdbtest.la:
+	$(MAKE) -C $(top_srcdir)/t libmmdbtest.la
+
+$(top_srcdir)/t/libtap/libtap.a:
+	$(MAKE) -C $(top_srcdir)/t/libtap libtap.a

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

@@ -0,0 +1,180 @@
+#include "data-pool.h"
+#include "maxminddb.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+static bool can_multiply(size_t const, size_t const, size_t const);
+
+// Allocate an MMDB_data_pool_s. It initially has space for size
+// MMDB_entry_data_list_s structs.
+MMDB_data_pool_s *data_pool_new(size_t const size)
+{
+    MMDB_data_pool_s *const pool = calloc(1, sizeof(MMDB_data_pool_s));
+    if (!pool) {
+        return NULL;
+    }
+
+    if (size == 0 ||
+        !can_multiply(SIZE_MAX, size, sizeof(MMDB_entry_data_list_s))) {
+        data_pool_destroy(pool);
+        return NULL;
+    }
+    pool->size = size;
+    pool->blocks[0] = calloc(pool->size, sizeof(MMDB_entry_data_list_s));
+    if (!pool->blocks[0]) {
+        data_pool_destroy(pool);
+        return NULL;
+    }
+    pool->blocks[0]->pool = pool;
+
+    pool->sizes[0] = size;
+
+    pool->block = pool->blocks[0];
+
+    return pool;
+}
+
+// Determine if we can multiply m*n. We can do this if the result will be below
+// the given max. max will typically be SIZE_MAX.
+//
+// We want to know if we'll wrap around.
+static bool can_multiply(size_t const max, size_t const m, size_t const n)
+{
+    if (m == 0) {
+        return false;
+    }
+
+    return n <= max / m;
+}
+
+// Clean up the data pool.
+void data_pool_destroy(MMDB_data_pool_s *const pool)
+{
+    if (!pool) {
+        return;
+    }
+
+    for (size_t i = 0; i <= pool->index; i++) {
+        free(pool->blocks[i]);
+    }
+
+    free(pool);
+}
+
+// Claim a new struct from the pool. Doing this may cause the pool's size to
+// grow.
+MMDB_entry_data_list_s *data_pool_alloc(MMDB_data_pool_s *const pool)
+{
+    if (!pool) {
+        return NULL;
+    }
+
+    if (pool->used < pool->size) {
+        MMDB_entry_data_list_s *const element = pool->block + pool->used;
+        pool->used++;
+        return element;
+    }
+
+    // Take it from a new block of memory.
+
+    size_t const new_index = pool->index + 1;
+    if (new_index == DATA_POOL_NUM_BLOCKS) {
+        // See the comment about not growing this on DATA_POOL_NUM_BLOCKS.
+        return NULL;
+    }
+
+    if (!can_multiply(SIZE_MAX, pool->size, 2)) {
+        return NULL;
+    }
+    size_t const new_size = pool->size * 2;
+
+    if (!can_multiply(SIZE_MAX, new_size, sizeof(MMDB_entry_data_list_s))) {
+        return NULL;
+    }
+    pool->blocks[new_index] = calloc(new_size, sizeof(MMDB_entry_data_list_s));
+    if (!pool->blocks[new_index]) {
+        return NULL;
+    }
+
+    // We don't need to set this, but it's useful for introspection in tests.
+    pool->blocks[new_index]->pool = pool;
+
+    pool->index = new_index;
+    pool->block = pool->blocks[pool->index];
+
+    pool->size = new_size;
+    pool->sizes[pool->index] = pool->size;
+
+    MMDB_entry_data_list_s *const element = pool->block;
+    pool->used = 1;
+    return element;
+}
+
+// Turn the structs in the array-like pool into a linked list.
+//
+// Before calling this function, the list isn't linked up.
+MMDB_entry_data_list_s *data_pool_to_list(MMDB_data_pool_s *const pool)
+{
+    if (!pool) {
+        return NULL;
+    }
+
+    if (pool->index == 0 && pool->used == 0) {
+        return NULL;
+    }
+
+    for (size_t i = 0; i <= pool->index; i++) {
+        MMDB_entry_data_list_s *const block = pool->blocks[i];
+
+        size_t size = pool->sizes[i];
+        if (i == pool->index) {
+            size = pool->used;
+        }
+
+        for (size_t j = 0; j < size - 1; j++) {
+            MMDB_entry_data_list_s *const cur = block + j;
+            cur->next = block + j + 1;
+        }
+
+        if (i < pool->index) {
+            MMDB_entry_data_list_s *const last = block + size - 1;
+            last->next = pool->blocks[i + 1];
+        }
+    }
+
+    return pool->blocks[0];
+}
+
+#ifdef TEST_DATA_POOL
+
+#include <libtap/tap.h>
+#include <maxminddb_test_helper.h>
+
+static void test_can_multiply(void);
+
+int main(void)
+{
+    plan(NO_PLAN);
+    test_can_multiply();
+    done_testing();
+}
+
+static void test_can_multiply(void)
+{
+    {
+        ok(can_multiply(SIZE_MAX, 1, SIZE_MAX), "1*SIZE_MAX is ok");
+    }
+
+    {
+        ok(!can_multiply(SIZE_MAX, 2, SIZE_MAX), "2*SIZE_MAX is not ok");
+    }
+
+    {
+        ok(can_multiply(SIZE_MAX, 10240, sizeof(MMDB_entry_data_list_s)),
+           "1024 entry_data_list_s's are okay");
+    }
+}
+
+#endif

data/ext/geoip2/libmaxminddb/src/data-pool.h

@@ -0,0 +1,52 @@
+#ifndef DATA_POOL_H
+#define DATA_POOL_H
+
+#include "maxminddb.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// This should be large enough that we never need to grow the array of pointers
+// to blocks. 32 is enough. Even starting out of with size 1 (1 struct), the
+// 32nd element alone will provide 2**32 structs as we exponentially increase
+// the number in each block. Being confident that we do not have to grow the
+// array lets us avoid writing code to do that. That code would be risky as it
+// would rarely be hit and likely not be well tested.
+#define DATA_POOL_NUM_BLOCKS 32
+
+// A pool of memory for MMDB_entry_data_list_s structs. This is so we can
+// allocate multiple up front rather than one at a time for performance
+// reasons.
+//
+// The order you add elements to it (by calling data_pool_alloc()) ends up as
+// the order of the list.
+//
+// The memory only grows. There is no support for releasing an element you take
+// back to the pool.
+typedef struct MMDB_data_pool_s {
+    // Index of the current block we're allocating out of.
+    size_t index;
+
+    // The size of the current block, counting by structs.
+    size_t size;
+
+    // How many used in the current block, counting by structs.
+    size_t used;
+
+    // The current block we're allocating out of.
+    MMDB_entry_data_list_s *block;
+
+    // The size of each block.
+    size_t sizes[DATA_POOL_NUM_BLOCKS];
+
+    // An array of pointers to blocks of memory holding space for list
+    // elements.
+    MMDB_entry_data_list_s *blocks[DATA_POOL_NUM_BLOCKS];
+} MMDB_data_pool_s;
+
+MMDB_data_pool_s *data_pool_new(size_t const);
+void data_pool_destroy(MMDB_data_pool_s *const);
+MMDB_entry_data_list_s *data_pool_alloc(MMDB_data_pool_s *const);
+MMDB_entry_data_list_s *data_pool_to_list(MMDB_data_pool_s *const);
+
+#endif