cidrmergerb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa2864f0fa01c1ad5efb023dd31341ae702e5bd0
+  data.tar.gz: 025f66ca2d5806b2b06897c6647781e81814d4cc
+SHA512:
+  metadata.gz: 568ae27b383f662a0445f398a95b973fcf8a121896a0b0cdc1b42f60060c9879ddce7182eed7d34fd2c8708b29bd07207ced35d6dbd939156bcd13abbd0ea005
+  data.tar.gz: c5428103188e353dc4d164c89f25f2daa7ae45d6d5325f3b9de3f7d49464ace3ad9cad5571cfbd60bc445dd9d3167b1043026e3ff0c7a2d53e13c4c09d0bb9bd

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+ext/cidrmergerb/libcidrmerge.o
+ext/cidrmergerb/libcidrmerge.so

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cidrmergerb.gemspec
+gemspec

data/README.md

@@ -0,0 +1,23 @@
+# Cidrmergerb
+
+CIDR Optimize toolkit -- wrapping for Daniele's cidr optimization awesome library
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cidrmergerb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cidrmergerb
+
+## Usage
+
+Cidrmergerb.optimize(cidrs) #=> optimized cidrs

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc "clean shared library"
+task :clean_library do
+  FileUtils.cd(File.join(File.dirname(__FILE__), 'ext/cidrmergerb'))
+  %x{make clean}
+end
+
+task :default => [:clean_library, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cidrmergerb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cidrmergerb.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cidrmergerb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cidrmergerb"
+  spec.version       = Cidrmergerb::VERSION
+  spec.authors       = ["Newell Zhu"]
+  spec.email         = ["newell.zhu@kingaxis.com"]
+
+  spec.summary       = %q{CIDR Merge toolkit -- Wrapping for Daniele's CIDR Optimization library.}
+  spec.description   = %q{CIDR Merge toolkit -- Wrapping for Daniele's CIDR Optimization library.}
+  spec.homepage      = "https://github.com/kingaxis/cidrmergerb"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "ffi", '~> 1.9', '>= 1.9.10'
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/ffi/Makefile

@@ -0,0 +1,28 @@
+#Compiler command
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Linux)
+  CC=gcc
+  LIBRARY_FLAGS=-shared -lc -ldl -Wl,-soname,liboptimize.so.1
+endif
+ifeq ($(UNAME_S),Darwin)
+  CC=g++
+  LIBRARY_FLAGS=-shared
+endif
+
+CC_FLAGS=-O3 -fPIC -g -c -Wall -W
+CC_FLAGS+= -ansi -pedantic
+STD_DEFINES=-D OPTIMIZED_SORT -D INLINE -D CHAR_PREFIX
+
+all:			libcidrmerge.so.1.5.3
+
+libcidrmerge.o :	libcidrmerge.c cidrmerge.h
+			gcc ${STD_DEFINES} ${DEBUG_DEFINES} ${CC_FLAGS} -c libcidrmerge.c
+
+libcidrmerge.so.1.5.3 :	libcidrmerge.o
+			${CC} ${LIBRARY_FLAGS} -o libcidrmerge.so libcidrmerge.o
+
+clean :
+	rm -f *.o core
+	rm -f libcidrmerge.so
+	rm -f timestamp.out gmon.out
+

data/ffi/cidrmerge.h

@@ -0,0 +1,153 @@
+/*
+    Copyright 2004-2008 Daniele Depetrini
+    Author: 	Daniele Depetrini (depetrini@libero.it)
+    Version: 1.5.3
+    Date:	07/07/08
+
+    This file is part of cidrmerge.
+
+    CIDRMerge is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    CIDRMerge is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with cidrmerge; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef CIDRMERGE
+#define CIDRMERGE
+
+#include <stdio.h>
+
+#ifdef UNIX_IO
+	#include <unistd.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <fcntl.h>
+
+	#define STREAM int
+	#define STDIN 0
+	#define STDOUT 1
+	#define STDERR 2
+
+	#define READ(f,b,n) read(f,b,n)
+	#define WRITE(f,b,n) write(f,b,n)
+	#define OPEN(name) open(name,O_RDONLY)
+	#define CLOSE(f) close(f)
+	#define N_EOF(f,ret) (ret==0)
+
+#else
+
+	#define STREAM FILE *
+	#define STDIN (stdin)
+	#define STDOUT (stdout)
+	#define STDERR (stderr)
+
+	#define READ(f,b,n) fread(b,1,n,f)
+	#define WRITE(f,b,n) fwrite(b,1,n,f)
+	#define OPEN(name) fopen(name,"r")
+	#define CLOSE(f) fclose(f)
+	#define N_EOF(f,ret) feof(f)
+
+#endif
+
+#ifdef TIMESTAMP
+#include <sys/time.h>
+#include <time.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#define MAXLINE 1023
+#define BUFFER 8192*8
+
+/* Allocate BUCKET array entries per time */
+#define BUCKET 100000
+#define MAXCIDR 23
+
+/*Special prefix values.
+Important: INVALID_PREFIX must be < EXPANDED_PREFIX.
+EXPANDED_PREFIX + 32 must be < 255
+*/
+#define INVALID_PREFIX 200
+#define EXPANDED_PREFIX 220
+
+#define MASK1 0xff000000
+#define MASK2 0xff0000
+#define MASK3 0xff00
+#define MASK4 0xff
+
+#ifndef MAXINT
+#define MAXINT 0xffffffff
+#endif
+
+/* timestamping precision definitions */
+#define PRECISION (1000)
+#define PRECISION_INV (1000000/PRECISION)
+#define PRECISION_STRING "milliseconds"
+
+struct entry
+{
+	uint32_t network;
+	#ifdef CHAR_PREFIX
+	unsigned char prefix;
+	#else
+	uint32_t prefix;
+	#endif
+};
+
+static uint32_t prefix_table[]= 	{
+												0x0,0x80000000,0xc0000000,0xe0000000,0xf0000000,0xf8000000,0xfc000000,0xfe000000,0xff000000,0xff800000,
+												0xffc00000,0xffe00000,0xfff00000,0xfff80000,0xfffc0000,0xfffe0000,0xffff0000,0xffff8000,0xffffc000,
+												0xffffe000,0xfffff000,0xfffff800,0xfffffc00,0xfffffe00,0xffffff00,0xffffff80,0xffffffc0,0xffffffe0,
+												0xfffffff0,0xfffffff8,0xfffffffc,0xfffffffe,0xffffffff
+											};
+
+/*#define TONETMASK(PREFIX) (((PREFIX)==0)?(0):(MAXINT<<(32-(PREFIX))))*/
+#define TONETMASK(PREFIX) prefix_table[PREFIX]
+
+/*
+	Function execute the reduction of entry array addr.It returns the number of entries in the final array.
+	PARAM: addr array: contains entries to be optimized
+	PARAM: len: number of entries into addr array.
+	PARAM: do_sort: if 0, sort will NOT be perfomed. Be carefull: optimizing a non-sorted input will produce unpredictable results
+	NOTE3: resulting array may contains entries with prefix bigger than EXPANDED_PREFIX. Those are logical pointers: expanded_list[entry.network] (array returned by apply_whitelist function) is the starting position and the leght is entry.prefix- EXPANDED_PREFIX
+*/
+unsigned int optimize(struct entry *addr,unsigned int len,int do_sort);
+
+/*
+	Remove from array *entry_list occurence of array white.
+	Returns number of element into output array expanded_list (that can be reassigned to allow array extension).
+	Function allocate more memory if needed. It does NOT deallocate any if the result is smaller.
+	PARAM: *entry_list: pointer to input/output param entry list.
+	PARAM: **expanded_list: pointer to output param entry list, used to store expanded networks.
+	PARAM: *white: white list entry array
+	PARAM: len1: number of entry into entry_list in input
+	PARAM: len2: number of entry into white_list in input
+ 	PARAM: size_expanded: return paramether that contains memory size of the output expanded_list array
+	PARAM: do_sort: if 0, sort will NOT be perfomed on both entry_list and white. Be carefull: optimizing a non-sorted input will produce unpredictable results
+	NOTE1: both arrays entry_list and white have to be sorted with sort_entries() function BEFORE calling this.function OR paramether do_sort needs to be set to non zero. Unpredictable results if not
+	NOTE2: resulting array may contains entries with INVALID_PREFIX value prefix. This means entry is invalid and it doesn't have to be taken into account.
+	NOTE3: resulting array may contains entries with prefix bigger than EXPANDED_PREFIX. Those are logical pointers: expanded_list[entry.network] is the starting position and the leght is entry.prefix- EXPANDED_PREFIX
+	NOTE4: resulning array is ordered apart from invalid entries (the ones with INVALID_PREFIX value in prefix)
+*/
+unsigned int apply_whitelist(struct entry *addr,struct entry **expanded_list,struct entry *white,unsigned int len1,unsigned int len2,unsigned int *size_expanded,int do_sort);
+
+/*
+	Execute entries sorting using quicksort.
+	PARAM: addr array: contains entries to be sorted
+	PARAM: len: number of entries into addr array.
+*/
+void sort_entries(struct entry *addr,unsigned int len);
+
+#endif

data/ffi/libcidrmerge.c

@@ -0,0 +1,529 @@
+/*
+    Copyright 2004-2008 Daniele Depetrini
+    Author: 	Daniele Depetrini (depetrini@libero.it)
+    Version: 1.5.3
+    Date:  06/07/08
+
+    This file is part of CIDRMerge.
+
+    CIDRMerge is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    CIDRMerge is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with CIDRMerge; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include "cidrmerge.h"
+
+#ifdef LIBRARY_DEBUG
+#include <stdarg.h>
+
+/* Using those functions from cidrmerge.c for debugging purposes only */
+void print_address(STREAM file,uint32_t net, unsigned char pref);
+void print_addresses(STREAM f,struct entry *addr,int size,struct entry *expanded,int level);
+
+void print_debug(STREAM f,char *buf,char *fmt,...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	sprintf(buf,fmt,ap);
+	WRITE(f,buf,strlen(buf));
+	va_end(ap);
+}
+
+#endif
+/*
+	Exectute one entry comparation. a1 is bigger than a2 if:
+	- a1.network is bigger than a2.network
+	- a1.network is equal to a2.network but a1.prefix is bigger than a2.prefix
+	PARAM: a1 first entry
+	PARAM: a2 second entry
+	RETURN VALUE: it returns -1 if a1<a2, 0 if a1=a2 and 1 if a1>a2
+*/
+#ifndef OPTIMIZED_SORT
+typedef int(*cmp_type)(const void *,const void*);
+
+static int cmp_entry(struct entry *a1, struct entry *a2)
+{
+	if ((*a1).network<(*a2).network)
+	{
+		return -1;
+	}
+	if ((*a1).network>(*a2).network)
+	{
+		return 1;
+	}
+/* Network are ==, so we compare netmasks*/
+	if ((*a1).prefix<(*a2).prefix)
+	{
+		return -1;
+	}
+	if ((*a1).prefix>(*a2).prefix)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+#endif
+
+/*
+	Please see cidrmerge.h
+*/
+void sort_entries(struct entry *addr,unsigned int len)
+{
+	#ifndef OPTIMIZED_SORT
+	/*standard C quicksort*/
+	qsort(addr,len,sizeof(struct entry),(cmp_type)cmp_entry);
+	#else
+	/*Optimized quicksort. Thanks to Michael Tokarev*/
+	#include "optimized-sort.h"
+	#define cmp_entry(a1,a2) (((a1)->network<(a2)->network) || (((a1)->network==(a2)->network) && ((a1)->prefix<(a2)->prefix)))
+
+	if (len>1)
+	{
+		/*sprintf(debug_buf,"SORT: addr[0] %d len %d\n",addr[0].network,len);*/
+		QSORT(struct entry,addr,len,cmp_entry);
+	}
+	#endif
+}
+
+#ifdef INLINE
+__inline
+#endif
+static void expand(struct entry **expanded_list,struct entry to_expand,struct entry *white,unsigned int len_white,unsigned int n,unsigned int *current_position,unsigned int *size_expanded)
+{
+	int first=*current_position,last=*current_position+n-1;
+	unsigned int first_conflict,last_conflict,i;
+	struct entry tmp_small,tmp_big;
+	struct entry *result=*expanded_list;
+	#ifdef LIBRARY_DEBUG
+	char debug_buf[MAXLINE];
+	#endif
+
+	*current_position+=n;
+
+	if (*current_position>*size_expanded)
+	{
+		/* we need to increase expanded_list array size */
+		#ifdef LIBRARY_DEBUG
+		print_debug(STDOUT,debug_buf,"BEFORE realloc: size_expanded: %u, MEM: %u\n", *size_expanded,(*size_expanded)*sizeof(struct entry));
+		#endif
+
+		*size_expanded+=BUCKET;
+		#ifdef LIBRARY_DEBUG
+		print_debug(STDOUT,debug_buf,"AFTER realloc size_expanded: %u,MEM: %u\n", *size_expanded,(*size_expanded)*sizeof(struct entry));
+		#endif
+
+		result=*expanded_list=realloc(*expanded_list,(*size_expanded)*sizeof(struct entry));
+		if (result==NULL)
+		{
+			fprintf(stderr,"Error reallocating %lu bytes\n",(unsigned long)(*size_expanded)*sizeof(struct entry));
+			exit(1);
+		}
+	}
+
+	#ifdef LIBRARY_DEBUG
+	print_debug(STDOUT,debug_buf,"\nTO EXPAND n %u:\n",n);
+	print_address(STDOUT,to_expand.network,to_expand.prefix);
+
+	print_debug(STDOUT,debug_buf,"START WHITE len_white %u:\n",len_white);
+	print_addresses(STDOUT,white,len_white,NULL,0);
+	print_debug(STDOUT,debug_buf,"END   WHITE\n");
+	#endif
+
+	while (first<=last)
+	{
+		tmp_small.prefix=tmp_big.prefix=to_expand.prefix+1;
+		tmp_small.network=to_expand.network; 										/*last network bit set to 0 */
+		tmp_big.network=to_expand.network+(0x1<<(32-tmp_small.prefix)); 	/*last network bit set to 1 */
+
+		if ( (white[0].network & TONETMASK(tmp_small.prefix) ) == tmp_small.network )
+		{
+			/* conflicting whith tmp_small. */
+			i=1;
+			/* search for first conflicting position with tmp_big (it cant be the first) */
+			while((i<len_white) && !( (white[i].network & TONETMASK(tmp_big.prefix) ) == tmp_big.network ))
+			{
+				i++;
+			}
+			first_conflict=i;
+			/* search for last conflicting position with tmp_big*/
+			while((i<len_white) && ( (white[i].network & TONETMASK(tmp_big.prefix) ) == tmp_big.network ))
+			{
+				i++;
+			}
+			last_conflict=i;
+			/* check if there is at least one conflicting with tmp_big network into whitelist */
+			if (first_conflict!=len_white)
+			{
+				if (white[first_conflict].prefix!=tmp_big.prefix)
+				{
+
+					#ifdef LIBRARY_DEBUG
+					print_debug(STDOUT,debug_buf,"RE-CONFLICT BIG first %u last %u\n",first_conflict,last_conflict);
+					print_address(STDOUT,tmp_big.network,tmp_big.prefix);
+					#endif
+
+					result[last].network=*current_position;
+					result[last].prefix=EXPANDED_PREFIX+white[first_conflict].prefix-tmp_big.prefix;
+
+					expand(expanded_list,tmp_big,&white[first_conflict],last_conflict-first_conflict,white[first_conflict].prefix-tmp_big.prefix,current_position,size_expanded);
+				}
+				else
+				{
+					#ifdef LIBRARY_DEBUG
+					print_debug(STDOUT,debug_buf,"INVALIDATING BIG POSITION %u\n",last);
+					#endif
+					result[last].prefix=INVALID_PREFIX;
+				}
+			}
+			else
+			{
+				#ifdef LIBRARY_DEBUG
+				print_debug(STDOUT,debug_buf,"VALID BIG position %u:\n",last);
+				print_address(STDOUT,tmp_big.network,tmp_big.prefix);
+				#endif
+				result[last].network=tmp_big.network;
+				result[last].prefix=tmp_big.prefix;
+			}
+			to_expand.network=tmp_small.network;
+			to_expand.prefix=tmp_small.prefix;
+			last--;
+		}
+		else
+		{
+			/* conflicting with tmp_big */
+			i=1;
+			/* search for first conflicting position with tmp_small (it cant be the first)*/
+			while((i<len_white) && !( (white[i].network & TONETMASK(tmp_small.prefix) ) == tmp_small.network ))
+			{
+				i++;
+			}
+			first_conflict=i;
+			/* search for last conflicting position with tmp_small*/
+			while((i<len_white) && ( (white[i].network & TONETMASK(tmp_small.prefix) ) == tmp_small.network ))
+			{
+				i++;
+			}
+			last_conflict=i;
+
+			/* check if there is at least one conflicting with tmp_small network into whitelist */
+			if (first_conflict!=len_white)
+			{
+				if (white[first_conflict].prefix!=tmp_small.prefix)
+				{
+					#ifdef LIBRARY_DEBUG
+					print_debug(STDOUT,debug_buf,"RE-CONFLICT LOW first %u last %u\n",first_conflict,last_conflict);
+					print_address(STDOUT,tmp_small.network,tmp_small.prefix);
+					#endif
+
+					result[first].network=*current_position;
+					result[first].prefix=EXPANDED_PREFIX+white[first_conflict].prefix-tmp_small.prefix;
+
+					expand(expanded_list,tmp_small,&white[first_conflict],last_conflict-first_conflict,white[first_conflict].prefix-tmp_small.prefix,current_position,size_expanded);
+				}
+				else
+				{
+					#ifdef LIBRARY_DEBUG
+					print_debug(STDOUT,debug_buf,"INVALIDATING LOW POSITION %u\n",first);
+					#endif
+					result[first].prefix=INVALID_PREFIX;
+				}
+			}
+			else
+			{
+				#ifdef LIBRARY_DEBUG
+				print_debug(STDOUT,debug_buf,"VALID LOW position %u:\n",first);
+				print_address(STDOUT,tmp_small.network,tmp_small.prefix);
+				#endif
+
+				result[first].network=tmp_small.network;
+				result[first].prefix=tmp_small.prefix;
+			}
+			to_expand.network=tmp_big.network;
+			to_expand.prefix=tmp_big.prefix;
+			first++;
+		}
+
+		#ifdef LIBRARY_DEBUG
+		print_debug(STDOUT,debug_buf,"first %d last %d\n",first,last);
+		#endif
+	}
+
+	#ifdef LIBRARY_DEBUG
+	print_debug(STDOUT,debug_buf,"EXPAND END. Local position %d, current position %u:\n",n,*current_position);
+	print_debug(STDOUT,debug_buf,"\n");
+	#endif
+}
+
+/*
+	Please see cidrmerge.h
+*/
+unsigned int apply_whitelist(struct entry *addr,struct entry **expanded_list,struct entry *white,unsigned int len1,unsigned int len2,unsigned int *size_expanded,int do_sort)
+{
+	unsigned int i1,i2,invalid,tmp,expanded_index=0;
+	uint32_t supermask;
+	struct entry tmp_entry;
+	#ifdef LIBRARY_DEBUG
+	char debug_buf[MAXLINE];
+	unsigned int step=0;
+	print_debug(STDOUT,debug_buf,"START apply_whitelist\n");
+	#endif
+
+
+	if (do_sort)
+	{
+		#ifdef LIBRARY_DEBUG
+		print_debug(STDOUT,debug_buf,"Sorting entries\n");
+		#endif
+		sort_entries(addr,len1);
+		sort_entries(white,len2);
+	}
+
+	i1=i2=0;
+	while ((i1<len1)&&(i2<len2))
+	{
+		#ifdef LIBRARY_DEBUG
+		print_debug(STDOUT,debug_buf,"STEP=%u I1=%d I2=%d\n",step++,i1,i2);
+		#endif
+		#ifdef LIBRARY_DEBUG_FULL
+		print_addresses(STDOUT,addr,len1,NULL,0);
+		#endif
+
+		supermask=TONETMASK(addr[i1].prefix)&TONETMASK(white[i2].prefix);
+
+		if ((addr[i1].prefix<=32)&&(addr[i1].network&supermask)==(white[i2].network&supermask))
+		{
+			#ifdef LIBRARY_DEBUG
+			print_debug(STDOUT,debug_buf,"CONFLICT\n");
+			print_address(STDOUT,addr[i1].network,addr[i1].prefix);
+			print_address(STDOUT,white[i2].network,white[i2].prefix);
+			#endif
+			if (addr[i1].prefix<white[i2].prefix)
+			{
+				/*we have to expand the network*/
+
+				/*invalidate all addr[i1] subnetworks */
+				invalid=i1+1;
+				while ((invalid<len1)&&(addr[invalid].network&supermask)==(white[i2].network&supermask))
+				{
+					/*address is already present in the expanded network, just drop it*/
+					#ifdef LIBRARY_DEBUG
+					print_debug(STDOUT,debug_buf,"INVALIDATING ");
+					print_address(STDOUT,addr[invalid].network,addr[invalid].prefix);
+					#endif
+					addr[invalid].prefix=INVALID_PREFIX;
+
+					invalid++;
+				}
+
+				invalid-=i1+1; /*invalid represents the number of invalidated positions*/
+
+				#ifdef LIBRARY_DEBUG
+				print_debug(STDOUT,debug_buf,"INVALID %u LEN1 %u\n",invalid,len1);
+				#endif
+
+				tmp=i2;
+				i2+=1;
+				while ( (i2<len2) && ((addr[i1].network&supermask)==(white[i2].network&supermask)) )
+				{
+					i2++;
+				}
+
+				#ifdef LIBRARY_DEBUG
+				print_debug(STDOUT,debug_buf,"EXPAND expanded_index %u whitelist elements: %u num expand %d\n",expanded_index,i2-tmp,white[tmp].prefix-addr[i1].prefix);
+				#endif
+
+				tmp_entry.network=addr[i1].network;
+				tmp_entry.prefix=addr[i1].prefix;
+
+				addr[i1].prefix=EXPANDED_PREFIX+white[tmp].prefix-addr[i1].prefix;
+				addr[i1].network=expanded_index;
+				/* expanded positions are clean and optimized */
+				expand(expanded_list,tmp_entry,&(white[tmp]),i2-tmp,white[tmp].prefix-tmp_entry.prefix,&expanded_index,size_expanded);
+
+				i1+=invalid+1;
+
+				#ifdef LIBRARY_DEBUG
+				print_debug(STDOUT,debug_buf,"END MAIN EXPAND expanded_index %u i1: %u i2: %u\n",expanded_index,i1,i2);
+				#endif
+
+			}
+			else
+			{
+				/*just invalidating entry i1*/
+				#ifdef LIBRARY_DEBUG
+				printf ("INVALIDATING ");
+				print_address(STDOUT,addr[i1].network,addr[i1].prefix);
+				#endif
+				addr[i1].prefix=INVALID_PREFIX;
+				i1++;
+			}
+
+		}
+		else if ((addr[i1].prefix==INVALID_PREFIX)||(addr[i1].network&supermask)<=(white[i2].network&supermask))
+		{
+			i1++;
+		}
+		else
+		{
+			i2++;
+		}
+	}
+	#ifdef LIBRARY_DEBUG
+	print_debug(STDOUT,debug_buf,"END apply_whitelist\n");
+	#endif
+	return expanded_index;
+}
+
+/*
+	Please see cidrmerge.h
+*/
+unsigned int optimize(struct entry *addr,unsigned int len,int do_sort)
+{
+	unsigned int i,cur;
+	unsigned int tmp_net;
+	#ifdef LIBRARY_DEBUG
+	char debug_buf[MAXLINE];
+	unsigned int step=0;
+
+	print_debug(STDOUT,debug_buf,"START optimize\n");
+	#endif
+
+	i=0;   /*pointer to last valid position*/
+	cur=1; /*pointer to next addr to analize*/
+
+	if (len <= 1)
+	{
+		/* empty or sigle element array is optimized by definition.*/
+		return len;
+	}
+
+	if (do_sort)
+	{
+		sort_entries(addr,len);
+	}
+
+	/*Find first valid address and move it to first position*/
+	while ((addr[0].prefix==INVALID_PREFIX) && (cur<len))
+	{
+		#ifdef LIBRARY_DEBUG
+		printf ("SEARCH FIRST I: %d CUR: %d\n",i,cur);
+		#endif
+		if (addr[cur].prefix!=INVALID_PREFIX)
+		{
+			addr[0].network=addr[cur].network;
+			addr[0].prefix=addr[cur].prefix;
+			addr[cur].prefix=INVALID_PREFIX;
+		}
+		cur++;
+	}
+
+	while (cur<len)
+	{
+		#ifdef LIBRARY_DEBUG
+		printf ("STEP: %u I: %d CUR: %d\n",step++,i,cur);
+		#endif
+		#ifdef LIBRARY_DEBUG_FULL
+		print_addresses(STDOUT,addr,len,NULL,0);
+		#endif
+
+		/*check for expanded networks, they can never conflicts*/
+		if (addr[cur].prefix>=EXPANDED_PREFIX)
+		{
+			#ifdef LIBRARY_DEBUG
+			printf ("COPY EXPANDED I: %d CUR: %d\n",i,cur);
+			#endif
+			i++;
+			addr[i].network=addr[cur].network;
+			addr[i].prefix=addr[cur].prefix;
+			cur++;
+			while ((addr[i].prefix>=EXPANDED_PREFIX) && (cur<len))
+			{
+				#ifdef LIBRARY_DEBUG
+				printf ("COPY ADDR[CUR] FOR EXPANDED I: %d CUR: %d\n",i,cur);
+				#endif
+				if (addr[cur].prefix!=INVALID_PREFIX)
+				{
+					i++;
+					if (cur != i)
+					{
+						addr[i].network=addr[cur].network;
+						addr[i].prefix=addr[cur].prefix;
+						addr[cur].prefix=INVALID_PREFIX;
+					}
+				}
+				cur++;
+			}
+		}
+		else
+		{
+			/*If this test will fail we just skip addr[cur]*/
+			if ((addr[cur].prefix<=32)&&((addr[cur].network&TONETMASK(addr[i].prefix))!=addr[i].network))
+			{
+				tmp_net=TONETMASK(addr[i].prefix-1);
+
+				if ( (addr[i].prefix==addr[cur].prefix) && ( (addr[i].network&tmp_net) == (addr[cur].network&tmp_net) ) )
+				{
+					#ifdef LIBRARY_DEBUG
+					printf ("COLLAPSE I: %d CUR: %d\n",i,cur);
+					#endif
+
+					if (i>0)
+					{
+						addr[cur].prefix=addr[i].prefix-1;
+						addr[cur].network&=tmp_net;
+						i--;
+					}
+					else
+					{
+						addr[i].prefix=addr[i].prefix-1;
+						addr[i].network&=tmp_net;
+						cur++;
+					}
+				}
+				else
+				{
+					i++;
+
+					addr[i].network=addr[cur].network;
+					addr[i].prefix=addr[cur].prefix;
+
+					cur++;
+				}
+			}
+			else
+			{
+				#ifdef LIBRARY_DEBUG
+				printf ("SKIP CUR: %d\n",cur);
+				#endif
+
+				cur++;
+			}
+		}
+	}
+
+	#ifdef LIBRARY_DEBUG
+	print_debug(STDOUT,debug_buf,"END optimize\n");
+	#endif
+
+	if (addr[i].prefix!=INVALID_PREFIX)
+	{
+		return i+1;
+	}
+	else
+	{
+		return i;
+	}
+}
+

data/ffi/optimized-sort.h

@@ -0,0 +1,292 @@
+/* $Id: optimized-sort.h,v 1.1 2008/06/07 22:30:24 depetrini Exp $
+ * Adopted from GNU glibc by Mjt.
+ * See stdlib/qsort.c in glibc */
+
+/* Copyright (C) 1991, 1992, 1996, 1997, 1999 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* in-line qsort implementation.  Differs from traditional qsort() routine
+ * in that it is a macro, not a function, and instead of passing an address
+ * of a comparision routine to the function, it is possible to inline
+ * comparision routine, thus speed up sorting alot.
+ *
+ * Usage:
+ *  #include "iqsort.h"
+ *  #define islt(a,b) (strcmp((*a),(*b))<0)
+ *  char *arr[];
+ *  int n;
+ *  QSORT(char*, arr, n, islt);
+ *
+ * The "prototype" and 4 arguments are:
+ *  QSORT(TYPE,BASE,NELT,ISLT)
+ *  1) type of each element, TYPE,
+ *  2) address of the beginning of the array, of type TYPE*,
+ *  3) number of elements in the array, and
+ *  4) comparision routine.
+ * Array pointer and number of elements are referenced only once.
+ * This is similar to a call
+ *  qsort(BASE,NELT,sizeof(TYPE),ISLT)
+ * with the difference in last parameter.
+ * Note the islt macro/routine (it receives pointers to two elements):
+ * the only condition of interest is whenever one element is less than
+ * another, no other conditions (greather than, equal to etc) are tested.
+ * So, for example, to define integer sort, use:
+ *  #define islt(a,b) ((*a)<(*b))
+ *  QSORT(int, arr, n, islt)
+ *
+ * The macro could be used to implement a sorting function (see examples
+ * below), or to implement the sorting algorithm inline.  That is, either
+ * create a sorting function and use it whenever you want to sort something,
+ * or use QSORT() macro directly instead a call to such routine.  Note that
+ * the macro expands to quite some code (compiled size of int qsort on x86
+ * is about 700..800 bytes).
+ *
+ * Using this macro directly it isn't possible to implement traditional
+ * qsort() routine, because the macro assumes sizeof(element) == sizeof(TYPE),
+ * while qsort() allows element size to be different.
+ *
+ * Several ready-to-use examples:
+ *
+ * Sorting array of integers:
+ * void int_qsort(int *arr, unsigned n) {
+ * #define int_lt(a,b) ((*a)<(*b))
+ *   QSORT(int, arr, n, int_lt);
+ * }
+ *
+ * Sorting array of string pointers:
+ * void str_qsort(char *arr[], unsigned n) {
+ * #define str_lt(a,b) (strcmp((*a),(*b)) < 0)
+ *   QSORT(char*, arr, n, str_lt);
+ * }
+ *
+ * Sorting array of structures:
+ *
+ * struct elt {
+ *   int key;
+ *   ...
+ * };
+ * void elt_qsort(struct elt *arr, unsigned n) {
+ * #define elt_lt(a,b) ((a)->key < (b)->key)
+ *  QSORT(struct elt, arr, n, elt_lt);
+ * }
+ *
+ * And so on.
+ */
+
+/* Swap two items pointed to by A and B using temporary buffer t. */
+#define _QSORT_SWAP(a, b, t) ((void)((t = *a), (*a = *b), (*b = t)))
+
+/* Discontinue quicksort algorithm when partition gets below this size.
+   This particular magic number was chosen to work best on a Sun 4/260. */
+#define _QSORT_MAX_THRESH 4
+
+/* Stack node declarations used to store unfulfilled partition obligations
+ * (inlined in QSORT).
+typedef struct {
+  QSORT_TYPE *_lo, *_hi;
+} qsort_stack_node;
+ */
+
+/* The next 4 #defines implement a very fast in-line stack abstraction. */
+/* The stack needs log (total_elements) entries (we could even subtract
+   log(MAX_THRESH)).  Since total_elements has type unsigned, we get as
+   upper bound for log (total_elements):
+   bits per byte (CHAR_BIT) * sizeof(unsigned).  */
+#define _QSORT_STACK_SIZE	(8 * sizeof(unsigned))
+#define _QSORT_PUSH(top, low, high)	\
+	(((top->_lo = (low)), (top->_hi = (high)), ++top))
+#define	_QSORT_POP(low, high, top)	\
+	((--top, (low = top->_lo), (high = top->_hi)))
+#define	_QSORT_STACK_NOT_EMPTY	(_stack < _top)
+
+
+/* Order size using quicksort.  This implementation incorporates
+   four optimizations discussed in Sedgewick:
+
+   1. Non-recursive, using an explicit stack of pointer that store the
+      next array partition to sort.  To save time, this maximum amount
+      of space required to store an array of SIZE_MAX is allocated on the
+      stack.  Assuming a 32-bit (64 bit) integer for size_t, this needs
+      only 32 * sizeof(stack_node) == 256 bytes (for 64 bit: 1024 bytes).
+      Pretty cheap, actually.
+
+   2. Chose the pivot element using a median-of-three decision tree.
+      This reduces the probability of selecting a bad pivot value and
+      eliminates certain extraneous comparisons.
+
+   3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
+      insertion sort to order the MAX_THRESH items within each partition.
+      This is a big win, since insertion sort is faster for small, mostly
+      sorted array segments.
+
+   4. The larger of the two sub-partitions is always pushed onto the
+      stack first, with the algorithm then concentrating on the
+      smaller partition.  This *guarantees* no more than log (total_elems)
+      stack size is needed (actually O(1) in this case)!  */
+
+/* The main code starts here... */
+#define QSORT(QSORT_TYPE,QSORT_BASE,QSORT_NELT,QSORT_LT)		\
+{									\
+  QSORT_TYPE *const _base = (QSORT_BASE);				\
+  const unsigned _elems = (QSORT_NELT);					\
+  QSORT_TYPE _hold;							\
+									\
+  /* Don't declare two variables of type QSORT_TYPE in a single		\
+   * statement: eg `TYPE a, b;', in case if TYPE is a pointer,		\
+   * expands to `type* a, b;' wich isn't what we want.			\
+   */									\
+									\
+  if (_elems > _QSORT_MAX_THRESH) {					\
+    QSORT_TYPE *_lo = _base;						\
+    QSORT_TYPE *_hi = _lo + _elems - 1;					\
+    struct {								\
+      QSORT_TYPE *_hi; QSORT_TYPE *_lo;					\
+    } _stack[_QSORT_STACK_SIZE], *_top = _stack + 1;			\
+									\
+    while (_QSORT_STACK_NOT_EMPTY) {					\
+      QSORT_TYPE *_left_ptr; QSORT_TYPE *_right_ptr;			\
+									\
+      /* Select median value from among LO, MID, and HI. Rearrange	\
+         LO and HI so the three values are sorted. This lowers the	\
+         probability of picking a pathological pivot value and		\
+         skips a comparison for both the LEFT_PTR and RIGHT_PTR in	\
+         the while loops. */						\
+									\
+      QSORT_TYPE *_mid = _lo + ((_hi - _lo) >> 1);			\
+									\
+      if (QSORT_LT (_mid, _lo))						\
+        _QSORT_SWAP (_mid, _lo, _hold);					\
+      if (QSORT_LT (_hi, _mid))						\
+        _QSORT_SWAP (_mid, _hi, _hold);					\
+      else								\
+        goto _jump_over;						\
+      if (QSORT_LT (_mid, _lo))						\
+        _QSORT_SWAP (_mid, _lo, _hold);					\
+  _jump_over:;								\
+									\
+      _left_ptr  = _lo + 1;						\
+      _right_ptr = _hi - 1;						\
+									\
+      /* Here's the famous ``collapse the walls'' section of quicksort.	\
+         Gotta like those tight inner loops!  They are the main reason	\
+         that this algorithm runs much faster than others. */		\
+      do {								\
+        while (QSORT_LT (_left_ptr, _mid))				\
+         ++_left_ptr;							\
+									\
+        while (QSORT_LT (_mid, _right_ptr))				\
+          --_right_ptr;							\
+									\
+        if (_left_ptr < _right_ptr) {					\
+          _QSORT_SWAP (_left_ptr, _right_ptr, _hold);			\
+          if (_mid == _left_ptr)					\
+            _mid = _right_ptr;						\
+          else if (_mid == _right_ptr)					\
+            _mid = _left_ptr;						\
+          ++_left_ptr;							\
+          --_right_ptr;							\
+        }								\
+        else if (_left_ptr == _right_ptr) {				\
+          ++_left_ptr;							\
+          --_right_ptr;							\
+          break;							\
+        }								\
+      } while (_left_ptr <= _right_ptr);				\
+									\
+     /* Set up pointers for next iteration.  First determine whether	\
+        left and right partitions are below the threshold size.  If so,	\
+        ignore one or both.  Otherwise, push the larger partition's	\
+        bounds on the stack and continue sorting the smaller one. */	\
+									\
+      if (_right_ptr - _lo <= _QSORT_MAX_THRESH) {			\
+        if (_hi - _left_ptr <= _QSORT_MAX_THRESH)			\
+          /* Ignore both small partitions. */				\
+          _QSORT_POP (_lo, _hi, _top);					\
+        else								\
+          /* Ignore small left partition. */				\
+          _lo = _left_ptr;						\
+      }									\
+      else if (_hi - _left_ptr <= _QSORT_MAX_THRESH)			\
+        /* Ignore small right partition. */				\
+        _hi = _right_ptr;						\
+      else if (_right_ptr - _lo > _hi - _left_ptr) {			\
+        /* Push larger left partition indices. */			\
+        _QSORT_PUSH (_top, _lo, _right_ptr);				\
+        _lo = _left_ptr;						\
+      }									\
+      else {								\
+        /* Push larger right partition indices. */			\
+        _QSORT_PUSH (_top, _left_ptr, _hi);				\
+        _hi = _right_ptr;						\
+      }									\
+    }									\
+  }									\
+									\
+  /* Once the BASE array is partially sorted by quicksort the rest	\
+     is completely sorted using insertion sort, since this is efficient	\
+     for partitions below MAX_THRESH size. BASE points to the		\
+     beginning of the array to sort, and END_PTR points at the very	\
+     last element in the array (*not* one beyond it!). */		\
+									\
+  {									\
+    QSORT_TYPE *const _end_ptr = _base + _elems - 1;			\
+    QSORT_TYPE *_tmp_ptr = _base;					\
+    register QSORT_TYPE *_run_ptr;					\
+    QSORT_TYPE *_thresh;						\
+									\
+    _thresh = _base + _QSORT_MAX_THRESH;				\
+    if (_thresh > _end_ptr)						\
+      _thresh = _end_ptr;						\
+									\
+    /* Find smallest element in first threshold and place it at the	\
+       array's beginning.  This is the smallest array element,		\
+       and the operation speeds up insertion sort's inner loop. */	\
+									\
+    for (_run_ptr = _tmp_ptr + 1; _run_ptr <= _thresh; ++_run_ptr)	\
+      if (QSORT_LT (_run_ptr, _tmp_ptr))				\
+        _tmp_ptr = _run_ptr;						\
+									\
+    if (_tmp_ptr != _base)						\
+      _QSORT_SWAP (_tmp_ptr, _base, _hold);				\
+									\
+    /* Insertion sort, running from left-hand-side			\
+     * up to right-hand-side.  */					\
+									\
+    _run_ptr = _base + 1;						\
+    while (++_run_ptr <= _end_ptr) {					\
+      _tmp_ptr = _run_ptr - 1;						\
+      while (QSORT_LT (_run_ptr, _tmp_ptr))				\
+        --_tmp_ptr;							\
+									\
+      ++_tmp_ptr;							\
+      if (_tmp_ptr != _run_ptr) {					\
+        QSORT_TYPE *_trav = _run_ptr + 1;				\
+        while (--_trav >= _run_ptr) {					\
+          QSORT_TYPE *_hi; QSORT_TYPE *_lo;				\
+          _hold = *_trav;						\
+									\
+          for (_hi = _lo = _trav; --_lo >= _tmp_ptr; _hi = _lo)		\
+            *_hi = *_lo;						\
+          *_hi = _hold;							\
+        }								\
+      }									\
+    }									\
+  }									\
+									\
+}

data/lib/cidrmergerb/ext.rb

@@ -0,0 +1,29 @@
+require 'ffi'
+require 'fileutils'
+
+SHARED_LIBRARY_FOLDER = File.join(File.dirname(__FILE__), '../../ffi')
+SHARED_LIBRARY_NAME = File.join(SHARED_LIBRARY_FOLDER, 'libcidrmerge.so')
+
+unless File.exist?(SHARED_LIBRARY_NAME)
+  FileUtils.cd(SHARED_LIBRARY_FOLDER)
+  %x{make}
+  fail "compile shared library fail, try to compile it by manual" if $?.exitstatus < 0
+end
+
+module Cidrmergerb
+  class Ext
+    extend FFI::Library
+    ffi_lib SHARED_LIBRARY_NAME
+
+    class Entry < FFI::ManagedStruct
+      layout :network => :uint,
+             :prefix => :uchar
+
+      def self.release(ptr)
+        Cidrmergerb::Ext.free_object(ptr)
+      end
+    end
+
+    attach_function :optimize, [ :pointer, :uint, :int ], :uint
+  end
+end

data/lib/cidrmergerb/version.rb

@@ -0,0 +1,3 @@
+module Cidrmergerb
+  VERSION = "0.1.0"
+end

data/lib/cidrmergerb.rb

@@ -0,0 +1,61 @@
+require "cidrmergerb/version"
+require 'cidrmergerb/ext'
+require 'ipaddr'
+require 'ffi'
+
+module Cidrmergerb
+
+  class << self
+    def optimize(cidrs)
+      pointer = build_pointer_to_cidrs(cidrs)
+      optimize_length = Cidrmergerb::Ext.optimize(pointer, cidrs.length, 1)
+
+      structs = wrap_with_struct(pointer, Cidrmergerb::Ext::Entry, optimize_length)
+      structs.map { |struct| strcut_to_cidr(struct) }
+    end
+
+    private
+    def build_pointer_to_cidrs(cidrs)
+      cidrs.select! {|cidr| cidr_valid?(cidr) }
+
+      pointer = alloc_memory(Cidrmergerb::Ext::Entry, cidrs.length)
+      entries = wrap_with_struct(pointer, Cidrmergerb::Ext::Entry, cidrs.length)
+
+      cidrs.each_with_index do |cidr, index|
+        ip, netmask = cidr.split('/')
+        entries[index][:network] = IPAddr.new(ip).to_i
+        entries[index][:prefix] = netmask.to_i
+      end
+
+      pointer
+    end
+
+    def cidr_valid?(cidr)
+      ip, netmask = cidr.split('/')
+      ipaddr = IPAddr.new(ip)
+      ipaddr && netmask.to_i.between?(1, 32)
+    rescue IPAddr::InvalidAddressError => e
+      false
+    end
+
+    def remove_invalid(cidrs)
+      cidrs.map do |cidr|
+        ip, netmask = cidr.split('/')
+      end
+    end
+
+    def alloc_memory(type, size)
+      FFI::MemoryPointer.new type, size, false
+    end
+
+    def wrap_with_struct(pointer, struct_type, length)
+      length.times.collect do |i|
+        struct_type.new(pointer + i * struct_type.size)
+      end
+    end
+
+    def strcut_to_cidr(struct)
+      "#{IPAddr.new(struct[:network], Socket::AF_INET).to_s}/#{struct[:prefix]}"
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: cidrmergerb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Newell Zhu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: CIDR Merge toolkit -- Wrapping for Daniele's CIDR Optimization library.
+email:
+- newell.zhu@kingaxis.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cidrmergerb.gemspec
+- ffi/Makefile
+- ffi/cidrmerge.h
+- ffi/libcidrmerge.c
+- ffi/optimized-sort.h
+- lib/cidrmergerb.rb
+- lib/cidrmergerb/ext.rb
+- lib/cidrmergerb/version.rb
+homepage: https://github.com/kingaxis/cidrmergerb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: CIDR Merge toolkit -- Wrapping for Daniele's CIDR Optimization library.
+test_files: []