CoveringNetworks

brute.go

@@ -108,6 +108,24 @@ func (b *bruteRanger) CoveredNetworks(network net.IPNet) ([]RangerEntry, error)
 	return results, nil
 }
 
+// Covering returns the list of RangerEntry(s) the given ipnet
+// is covered. It's like ContainingNetworks() for ipnet.
+func (b *bruteRanger) CoveringNetworks(network net.IPNet) ([]RangerEntry, error) {
+	entries, err := b.getEntriesByVersion(network.IP)
+	if err != nil {
+		return nil, err
+	}
+	var results []RangerEntry
+	testNetwork := rnet.NewNetwork(network)
+	for _, entry := range entries {
+		entryNetwork := rnet.NewNetwork(entry.Network())
+		if entryNetwork.Covers(testNetwork) {
+			results = append(results, entry)
+		}
+	}
+	return results, nil
+}
+
 // Len returns number of networks in ranger.
 func (b *bruteRanger) Len() int {
 	return len(b.ipV4Entries) + len(b.ipV6Entries)

brute_test.go

@@ -175,3 +175,33 @@ func TestCoveredNetworks(t *testing.T) {
 		})
 	}
 }
+
+func TestCoveringNetworks(t *testing.T) {
+	for _, tc := range coveringNetworkTests {
+		t.Run(tc.name, func(t *testing.T) {
+			ranger := newBruteRanger()
+			for _, insert := range tc.inserts {
+				_, network, _ := net.ParseCIDR(insert)
+				err := ranger.Insert(NewBasicRangerEntry(*network))
+				assert.NoError(t, err)
+			}
+			var expectedEntries []string
+			for _, network := range tc.networks {
+				expectedEntries = append(expectedEntries, network)
+			}
+			sort.Strings(expectedEntries)
+			_, snet, _ := net.ParseCIDR(tc.search)
+			networks, err := ranger.CoveringNetworks(*snet)
+			assert.NoError(t, err)
+
+			var results []string
+			for _, result := range networks {
+				net := result.Network()
+				results = append(results, net.String())
+			}
+			sort.Strings(results)
+
+			assert.Equal(t, expectedEntries, results)
+		})
+	}
+}

cidranger.go

@@ -89,6 +89,7 @@ type Ranger interface {
 	Contains(ip net.IP) (bool, error)
 	ContainingNetworks(ip net.IP) ([]RangerEntry, error)
 	CoveredNetworks(network net.IPNet) ([]RangerEntry, error)
+	CoveringNetworks(network net.IPNet) ([]RangerEntry, error)
 	Len() int
 }
 

cidranger_test.go

@@ -30,6 +30,10 @@ func TestCoveredNetworksAgainstBaseIPv4(t *testing.T) {
 	testCoversNetworksAgainstBase(t, 100000, randomIPNetGenFactory(ipV4AWSRangesIPNets))
 }
 
+func TestCoveringNetworksAgainstBaseIPv4(t *testing.T) {
+	testCoveringNetworksAgainstBase(t, 100000, randomIPNetGenFactory(ipV4AWSRangesIPNets))
+}
+
 // IPv6 spans an extremely large address space (2^128), randomly generated IPs
 // will often fall outside of the test ranges (AWS public CIDR blocks), so it
 // it more meaningful for testing to run from a curated list of IPv6 IPs.
@@ -45,6 +49,10 @@ func TestCoveredNetworksAgainstBaseIPv6(t *testing.T) {
 	testCoversNetworksAgainstBase(t, 100000, randomIPNetGenFactory(ipV6AWSRangesIPNets))
 }
 
+func TestCoveringNetworksAgainstBaseIPv6(t *testing.T) {
+	testCoveringNetworksAgainstBase(t, 100000, randomIPNetGenFactory(ipV6AWSRangesIPNets))
+}
+
 func testContainsAgainstBase(t *testing.T, iterations int, ipGen ipGenerator) {
 	if testing.Short() {
 		t.Skip("Skipping memory test in `-short` mode")
@@ -120,6 +128,32 @@ func testCoversNetworksAgainstBase(t *testing.T, iterations int, netGen networkG
 	}
 }
 
+func testCoveringNetworksAgainstBase(t *testing.T, iterations int, netGen networkGenerator) {
+	if testing.Short() {
+		t.Skip("Skipping memory test in `-short` mode")
+	}
+	rangers := []Ranger{NewPCTrieRanger()}
+	baseRanger := newBruteRanger()
+	for _, ranger := range rangers {
+		configureRangerWithAWSRanges(t, ranger)
+	}
+	configureRangerWithAWSRanges(t, baseRanger)
+
+	for i := 0; i < iterations; i++ {
+		network := netGen()
+		expected, err := baseRanger.CoveringNetworks(network.IPNet)
+		assert.NoError(t, err)
+		for _, ranger := range rangers {
+			actual, err := ranger.CoveringNetworks(network.IPNet)
+			assert.NoError(t, err)
+			assert.Equal(t, len(expected), len(actual))
+			for _, network := range actual {
+				assert.Contains(t, expected, network)
+			}
+		}
+	}
+}
+
 /*
  ******************************************************************
  Benchmarks.

go.mod

@@ -1,8 +1,9 @@
-module github.com/yl2chen/cidranger
+module github.com/Ramzeth/cidranger
 
-go 1.13
+go 1.17
 
 require (
-	github.com/stretchr/testify v1.6.1
-	gopkg.in/yaml.v2 v2.2.2 // indirect
+	github.com/davecgh/go-spew v1.1.0
+	github.com/pmezard/go-difflib v1.0.0
+	github.com/stretchr/testify v1.2.1
 )

go.sum

@@ -3,13 +3,13 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/yl2chen/cidranger v1.0.2 h1:lbOWZVCG1tCRX4u24kuM1Tb4nHqWkDxwLdoS+SevawU=
+github.com/yl2chen/cidranger v1.0.2/go.mod h1:9U1yz7WPYDwf0vpNWFaeRh0bjwz5RVgRy/9UEQfHl0g=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

net/ip.go

@@ -209,7 +209,7 @@ func (n Network) Contains(nn NetworkNumber) bool {
 	return true
 }
 
-// Contains returns true if Network covers o, false otherwise
+// Covers returns true if Network covers o, false otherwise
 func (n Network) Covers(o Network) bool {
 	if len(n.Number) != len(o.Number) {
 		return false

trie.go

@@ -124,6 +124,13 @@ func (p *prefixTrie) CoveredNetworks(network net.IPNet) ([]RangerEntry, error) {
 	return p.coveredNetworks(net)
 }
 
+// Covering returns the list of RangerEntry(s) the given ipnet
+// is covered by. It's like ContainingNetworks() for ipnet.
+func (p *prefixTrie) CoveringNetworks(network net.IPNet) ([]RangerEntry, error) {
+	net := rnet.NewNetwork(network)
+	return p.coveringNetworks(net)
+}
+
 // Len returns number of networks in ranger.
 func (p *prefixTrie) Len() int {
 	return p.size
@@ -217,6 +224,38 @@ func (p *prefixTrie) coveredNetworks(network rnet.Network) ([]RangerEntry, error
 	return results, nil
 }
 
+func (p *prefixTrie) coveringNetworks(network rnet.Network) ([]RangerEntry, error) {
+	var results []RangerEntry
+	if !p.network.Covers(network) {
+		return results, nil
+	}
+	if p.hasEntry() {
+		results = []RangerEntry{p.entry}
+	}
+	if p.targetBitPosition() < 0 {
+		return results, nil
+	}
+	bit, err := p.targetBitFromIP(network.Number)
+	if err != nil {
+		return nil, err
+	}
+	child := p.children[bit]
+	if child != nil {
+		ranges, err := child.coveringNetworks(network)
+		if err != nil {
+			return nil, err
+		}
+		if len(ranges) > 0 {
+			if len(results) > 0 {
+				results = append(results, ranges...)
+			} else {
+				results = ranges
+			}
+		}
+	}
+	return results, nil
+}
+
 func (p *prefixTrie) insert(network rnet.Network, entry RangerEntry) (bool, error) {
 	if p.network.Equal(network) {
 		sizeIncreased := p.entry == nil

trie_test.go

@@ -397,15 +397,15 @@ func TestPrefixTrieContainingNetworks(t *testing.T) {
 	}
 }
 
-type coveredNetworkTest struct {
+type networkTest struct {
 	version  rnet.IPVersion
 	inserts  []string
 	search   string
 	networks []string
 	name     string
 }
 
-var coveredNetworkTests = []coveredNetworkTest{
+var coveredNetworkTests = []networkTest{
 	{
 		rnet.IPv4,
 		[]string{"192.168.0.0/24"},
@@ -469,6 +469,70 @@ var coveredNetworkTests = []coveredNetworkTest{
 	},
 }
 
+var coveringNetworkTests = []networkTest{
+	{
+		rnet.IPv4,
+		[]string{"192.168.0.0/16"},
+		"192.168.0.0/24",
+		[]string{"192.168.0.0/16"},
+		"basic covering networks",
+	},
+	{
+		rnet.IPv4,
+		[]string{"10.1.0.0/16"},
+		"192.168.0.0/24",
+		nil,
+		"nothing",
+	},
+	{
+		rnet.IPv4,
+		[]string{"192.168.0.0/16", "192.168.0.0/24"},
+		"192.168.0.0/25",
+		[]string{"192.168.0.0/16", "192.168.0.0/24"},
+		"multiple networks",
+	},
+	{
+		rnet.IPv4,
+		[]string{"192.168.0.0/16", "192.168.0.0/24", "192.168.0.0/25"},
+		"192.168.0.1/32",
+		[]string{"192.168.0.0/16", "192.168.0.0/24", "192.168.0.0/25"},
+		"multiple networks 2",
+	},
+	{
+		rnet.IPv4,
+		[]string{"192.168.0.0/16"},
+		"192.168.1.1/32",
+		[]string{"192.168.0.0/16"},
+		"leaf",
+	},
+	{
+		rnet.IPv4,
+		[]string{"0.0.0.0/0", "192.168.1.1/32"},
+		"192.168.0.0/16",
+		[]string{"0.0.0.0/0"},
+		"leaf with root",
+	},
+	{
+		rnet.IPv4,
+		[]string{
+			"0.0.0.0/0", "192.168.0.0/24", "192.168.1.1/32",
+			"10.1.0.0/16", "10.1.1.0/24",
+		},
+		"192.168.0.0/16",
+		[]string{"0.0.0.0/0"},
+		"path not taken",
+	},
+	{
+		rnet.IPv4,
+		[]string{
+			"192.168.0.0/16",
+		},
+		"192.168.0.0/15",
+		nil,
+		"only masks different",
+	},
+}
+
 func TestPrefixTrieCoveredNetworks(t *testing.T) {
 	for _, tc := range coveredNetworkTests {
 		t.Run(tc.name, func(t *testing.T) {
@@ -492,6 +556,29 @@ func TestPrefixTrieCoveredNetworks(t *testing.T) {
 	}
 }
 
+func TestPrefixTrieCoveringNetworks(t *testing.T) {
+	for _, tc := range coveringNetworkTests {
+		t.Run(tc.name, func(t *testing.T) {
+			trie := newPrefixTree(tc.version)
+			for _, insert := range tc.inserts {
+				_, network, _ := net.ParseCIDR(insert)
+				err := trie.Insert(NewBasicRangerEntry(*network))
+				assert.NoError(t, err)
+			}
+			var expectedEntries []RangerEntry
+			for _, network := range tc.networks {
+				_, net, _ := net.ParseCIDR(network)
+				expectedEntries = append(expectedEntries,
+					NewBasicRangerEntry(*net))
+			}
+			_, snet, _ := net.ParseCIDR(tc.search)
+			networks, err := trie.CoveringNetworks(*snet)
+			assert.NoError(t, err)
+			assert.Equal(t, expectedEntries, networks)
+		})
+	}
+}
+
 func TestTrieMemUsage(t *testing.T) {
 	if testing.Short() {
 		t.Skip("Skipping memory test in `-short` mode")

version.go

@@ -61,6 +61,14 @@ func (v *versionedRanger) CoveredNetworks(network net.IPNet) ([]RangerEntry, err
 	return ranger.CoveredNetworks(network)
 }
 
+func (v *versionedRanger) CoveringNetworks(network net.IPNet) ([]RangerEntry, error) {
+	ranger, err := v.getRangerForIP(network.IP)
+	if err != nil {
+		return nil, err
+	}
+	return ranger.CoveringNetworks(network)
+}
+
 // Len returns number of networks in ranger.
 func (v *versionedRanger) Len() int {
 	return v.ipV4Ranger.Len() + v.ipV6Ranger.Len()