BIND 10 trac3274, updated. 290530e1c74db41d9dbf5e3dd733699345e7df2b [3274] Client classification for v6 implemented in CfgMgr
BIND 10 source code commits
bind10-changes at lists.isc.org
Mon Feb 3 20:43:17 UTC 2014
The branch, trac3274 has been updated
via 290530e1c74db41d9dbf5e3dd733699345e7df2b (commit)
via 683c49b997b39ca4a064e21a11acbafc2ca7a4de (commit)
via 1d945d79ff509a3df1485d0155eed206bbab8d53 (commit)
via bc216c2cf0f9b78f94e17acef5ece0ea94250b6c (commit)
via 9c9ec6cd3c40f59b7550051106dfcd7ec66b0c42 (commit)
via b7c33a05cd6ec3b6e25eb3a94b41e3f720e3f8e5 (commit)
from 393abcf8b1661495eb8ace6da2521a0885e43067 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 290530e1c74db41d9dbf5e3dd733699345e7df2b
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 21:42:55 2014 +0100
[3274] Client classification for v6 implemented in CfgMgr
commit 683c49b997b39ca4a064e21a11acbafc2ca7a4de
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 21:15:23 2014 +0100
[3274] Client classification logic for IPv4 implemented.
commit 1d945d79ff509a3df1485d0155eed206bbab8d53
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 20:33:33 2014 +0100
[3274] Subnets are now able to store client class information.
commit bc216c2cf0f9b78f94e17acef5ece0ea94250b6c
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 19:53:14 2014 +0100
[3274] ClientClass added, Classes renamed to ClientClasses
commit 9c9ec6cd3c40f59b7550051106dfcd7ec66b0c42
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 19:03:27 2014 +0100
[3274] Added Classes parameter to getSubnet{4,6} methods.
commit b7c33a05cd6ec3b6e25eb3a94b41e3f720e3f8e5
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Feb 3 18:50:24 2014 +0100
[3274] Added dhcp/classify.h
-----------------------------------------------------------------------
Summary of changes:
src/bin/dhcp4/dhcp4_srv.cc | 5 +-
src/bin/dhcp4/tests/config_parser_unittest.cc | 65 ++++--
src/bin/dhcp6/dhcp6_srv.cc | 16 +-
src/bin/dhcp6/tests/config_parser_unittest.cc | 69 ++++---
src/lib/dhcp/classify.h | 67 ++++++
src/lib/dhcp/pkt4.h | 6 +-
src/lib/dhcp/pkt6.h | 6 +-
src/lib/dhcpsrv/cfgmgr.cc | 36 +++-
src/lib/dhcpsrv/cfgmgr.h | 13 +-
src/lib/dhcpsrv/subnet.cc | 15 ++
src/lib/dhcpsrv/subnet.h | 28 +++
src/lib/dhcpsrv/tests/cfgmgr_unittest.cc | 274 +++++++++++++++++++++----
src/lib/dhcpsrv/tests/subnet_unittest.cc | 76 +++++++
13 files changed, 566 insertions(+), 110 deletions(-)
create mode 100644 src/lib/dhcp/classify.h
-----------------------------------------------------------------------
diff --git a/src/bin/dhcp4/dhcp4_srv.cc b/src/bin/dhcp4/dhcp4_srv.cc
index 5fc5598..ddc65ee 100644
--- a/src/bin/dhcp4/dhcp4_srv.cc
+++ b/src/bin/dhcp4/dhcp4_srv.cc
@@ -1508,11 +1508,12 @@ Dhcpv4Srv::selectSubnet(const Pkt4Ptr& question) {
if (relay != notset) {
// Yes: Use relay address to select subnet
- subnet = CfgMgr::instance().getSubnet4(relay);
+ subnet = CfgMgr::instance().getSubnet4(relay, question->classes_);
} else {
// No: Use client's address to select subnet
- subnet = CfgMgr::instance().getSubnet4(question->getRemoteAddr());
+ subnet = CfgMgr::instance().getSubnet4(question->getRemoteAddr(),
+ question->classes_);
}
/// @todo Implement getSubnet4(interface-name)
diff --git a/src/bin/dhcp4/tests/config_parser_unittest.cc b/src/bin/dhcp4/tests/config_parser_unittest.cc
index 63291ba..6df9d21 100644
--- a/src/bin/dhcp4/tests/config_parser_unittest.cc
+++ b/src/bin/dhcp4/tests/config_parser_unittest.cc
@@ -24,6 +24,7 @@
#include <dhcp/option_custom.h>
#include <dhcp/option_int.h>
#include <dhcp/docsis3_option_defs.h>
+#include <dhcp/classify.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/cfgmgr.h>
#include <hooks/hooks_manager.h>
@@ -231,7 +232,8 @@ public:
getOptionFromSubnet(const IOAddress& subnet_address,
const uint16_t option_code,
const uint16_t expected_options_count = 1) {
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(subnet_address);
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(subnet_address,
+ classify_);
if (!subnet) {
/// @todo replace toText() with the use of operator <<.
ADD_FAILURE() << "A subnet for the specified address "
@@ -454,9 +456,10 @@ public:
}
- boost::scoped_ptr<Dhcpv4Srv> srv_; // DHCP4 server under test
- int rcode_; // Return code from element parsing
- ConstElementPtr comment_; // Reason for parse fail
+ boost::scoped_ptr<Dhcpv4Srv> srv_; ///< DHCP4 server under test
+ int rcode_; ///< Return code from element parsing
+ ConstElementPtr comment_; ///< Reason for parse fail
+ isc::dhcp::ClientClasses classify_; ///< used in client classification
};
// Goal of this test is a verification if a very simple config update
@@ -531,7 +534,8 @@ TEST_F(Dhcp4ParserTest, subnetGlobalDefaults) {
// Now check if the configuration was indeed handled and we have
// expected pool configured.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1000, subnet->getT1());
EXPECT_EQ(2000, subnet->getT2());
@@ -749,7 +753,8 @@ TEST_F(Dhcp4ParserTest, nextServerGlobal) {
// Now check if the configuration was indeed handled and we have
// expected pool configured.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ("1.2.3.4", subnet->getSiaddr().toText());
}
@@ -778,7 +783,8 @@ TEST_F(Dhcp4ParserTest, nextServerSubnet) {
// Now check if the configuration was indeed handled and we have
// expected pool configured.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ("1.2.3.4", subnet->getSiaddr().toText());
}
@@ -865,7 +871,8 @@ TEST_F(Dhcp4ParserTest, nextServerOverride) {
// Now check if the configuration was indeed handled and we have
// expected pool configured.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ("1.2.3.4", subnet->getSiaddr().toText());
}
@@ -935,7 +942,8 @@ TEST_F(Dhcp4ParserTest, subnetLocal) {
// returned value should be 0 (configuration success)
checkResult(status, 0);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1, subnet->getT1());
EXPECT_EQ(2, subnet->getT2());
@@ -987,7 +995,8 @@ TEST_F(Dhcp4ParserTest, poolPrefixLen) {
// returned value must be 0 (configuration accepted)
checkResult(status, 0);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1000, subnet->getT1());
EXPECT_EQ(2000, subnet->getT2());
@@ -1524,7 +1533,8 @@ TEST_F(Dhcp4ParserTest, optionDataDefaults) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp4");
ASSERT_EQ(2, options->size());
@@ -1608,7 +1618,8 @@ TEST_F(Dhcp4ParserTest, optionDataTwoSpaces) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the space dhcp4.
Subnet::OptionDescriptor desc1 = subnet->getOptionDescriptor("dhcp4", 56);
@@ -1758,7 +1769,8 @@ TEST_F(Dhcp4ParserTest, optionDataEncapsulate) {
checkResult(status, 0);
// Get the subnet.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
// We should have one option available.
@@ -1826,7 +1838,8 @@ TEST_F(Dhcp4ParserTest, optionDataInSingleSubnet) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.24"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.24"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp4");
ASSERT_EQ(2, options->size());
@@ -1978,7 +1991,8 @@ TEST_F(Dhcp4ParserTest, optionDataInMultipleSubnets) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet4Ptr subnet1 = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.100"));
+ Subnet4Ptr subnet1 = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.100"),
+ classify_);
ASSERT_TRUE(subnet1);
Subnet::OptionContainerPtr options1 = subnet1->getOptionDescriptors("dhcp4");
ASSERT_EQ(1, options1->size());
@@ -2002,7 +2016,8 @@ TEST_F(Dhcp4ParserTest, optionDataInMultipleSubnets) {
testOption(*range1.first, 56, foo_expected, sizeof(foo_expected));
// Test another subnet in the same way.
- Subnet4Ptr subnet2 = CfgMgr::instance().getSubnet4(IOAddress("192.0.3.102"));
+ Subnet4Ptr subnet2 = CfgMgr::instance().getSubnet4(IOAddress("192.0.3.102"),
+ classify_);
ASSERT_TRUE(subnet2);
Subnet::OptionContainerPtr options2 = subnet2->getOptionDescriptors("dhcp4");
ASSERT_EQ(1, options2->size());
@@ -2081,7 +2096,8 @@ TEST_F(Dhcp4ParserTest, optionDataLowerCase) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp4");
ASSERT_EQ(1, options->size());
@@ -2125,7 +2141,8 @@ TEST_F(Dhcp4ParserTest, stdOptionData) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options =
subnet->getOptionDescriptors("dhcp4");
@@ -2327,7 +2344,8 @@ TEST_F(Dhcp4ParserTest, stdOptionDataEncapsulate) {
checkResult(status, 0);
// Get the subnet.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
// We should have one option available.
@@ -2409,7 +2427,8 @@ TEST_F(Dhcp4ParserTest, vendorOptionsHex) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the vendor space 4491
@@ -2468,7 +2487,8 @@ TEST_F(Dhcp4ParserTest, vendorOptionsCsv) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.5"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the vendor space 4491
@@ -2827,7 +2847,8 @@ TEST_F(Dhcp4ParserTest, subnetRelayInfo) {
// returned value should be 0 (configuration success)
checkResult(status, 0);
- Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"));
+ Subnet4Ptr subnet = CfgMgr::instance().getSubnet4(IOAddress("192.0.2.200"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ("192.0.2.123", subnet->relay_.addr_.toText());
}
diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 7cdd2c9..b3ef42d 100644
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -863,10 +863,12 @@ Dhcpv6Srv::selectSubnet(const Pkt6Ptr& question) {
// This is a direct (non-relayed) message
// Try to find a subnet if received packet from a directly connected client
- subnet = CfgMgr::instance().getSubnet6(question->getIface());
+ subnet = CfgMgr::instance().getSubnet6(question->getIface(),
+ question->classes_);
if (!subnet) {
// If no subnet was found, try to find it based on remote address
- subnet = CfgMgr::instance().getSubnet6(question->getRemoteAddr());
+ subnet = CfgMgr::instance().getSubnet6(question->getRemoteAddr(),
+ question->classes_);
}
} else {
@@ -874,17 +876,19 @@ Dhcpv6Srv::selectSubnet(const Pkt6Ptr& question) {
OptionPtr interface_id = question->getAnyRelayOption(D6O_INTERFACE_ID,
Pkt6::RELAY_GET_FIRST);
if (interface_id) {
- subnet = CfgMgr::instance().getSubnet6(interface_id);
+ subnet = CfgMgr::instance().getSubnet6(interface_id,
+ question->classes_);
}
if (!subnet) {
- // If no interface-id was specified (or not configured on server), let's
- // try address matching
+ // If no interface-id was specified (or not configured on server),
+ // let's try address matching
IOAddress link_addr = question->relay_info_.back().linkaddr_;
// if relay filled in link_addr field, then let's use it
if (link_addr != IOAddress("::")) {
- subnet = CfgMgr::instance().getSubnet6(link_addr);
+ subnet = CfgMgr::instance().getSubnet6(link_addr,
+ question->classes_);
}
}
}
diff --git a/src/bin/dhcp6/tests/config_parser_unittest.cc b/src/bin/dhcp6/tests/config_parser_unittest.cc
index 63ddcd0..147a85e 100644
--- a/src/bin/dhcp6/tests/config_parser_unittest.cc
+++ b/src/bin/dhcp6/tests/config_parser_unittest.cc
@@ -244,7 +244,8 @@ public:
getOptionFromSubnet(const IOAddress& subnet_address,
const uint16_t option_code,
const uint16_t expected_options_count = 1) {
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(subnet_address);
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(subnet_address,
+ classify_);
if (!subnet) {
/// @todo replace toText() with the use of operator <<.
ADD_FAILURE() << "A subnet for the specified address "
@@ -475,6 +476,7 @@ public:
ConstElementPtr comment_; ///< Comment (see @ref isc::config::parseAnswer)
string valid_iface_; ///< Valid network interface name (present in system)
string bogus_iface_; ///< invalid network interface name (not in system)
+ isc::dhcp::ClientClasses classify_; ///< used in client classification
};
// Goal of this test is a verification if a very simple config update
@@ -554,7 +556,8 @@ TEST_F(Dhcp6ParserTest, subnetGlobalDefaults) {
// Now check if the configuration was indeed handled and we have
// expected pool configured.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1000, subnet->getT1());
EXPECT_EQ(2000, subnet->getT2());
@@ -772,7 +775,8 @@ TEST_F(Dhcp6ParserTest, subnetLocal) {
comment_ = parseAnswer(rcode_, status);
EXPECT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1, subnet->getT1());
EXPECT_EQ(2, subnet->getT2());
@@ -808,7 +812,8 @@ TEST_F(Dhcp6ParserTest, subnetInterface) {
comment_ = parseAnswer(rcode_, status);
EXPECT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(valid_iface_, subnet->getIface());
}
@@ -841,7 +846,8 @@ TEST_F(Dhcp6ParserTest, subnetInterfaceBogus) {
comment_ = parseAnswer(rcode_, status);
EXPECT_EQ(1, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
EXPECT_FALSE(subnet);
}
@@ -906,13 +912,13 @@ TEST_F(Dhcp6ParserTest, subnetInterfaceId) {
// Try to get a subnet based on bogus interface-id option
OptionBuffer tmp(bogus_interface_id.begin(), bogus_interface_id.end());
OptionPtr ifaceid(new Option(Option::V6, D6O_INTERFACE_ID, tmp));
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(ifaceid);
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(ifaceid, classify_);
EXPECT_FALSE(subnet);
// Now try to get subnet for valid interface-id value
tmp = OptionBuffer(valid_interface_id.begin(), valid_interface_id.end());
ifaceid.reset(new Option(Option::V6, D6O_INTERFACE_ID, tmp));
- subnet = CfgMgr::instance().getSubnet6(ifaceid);
+ subnet = CfgMgr::instance().getSubnet6(ifaceid, classify_);
ASSERT_TRUE(subnet);
EXPECT_TRUE(ifaceid->equal(subnet->getInterfaceId()));
}
@@ -1025,7 +1031,8 @@ TEST_F(Dhcp6ParserTest, poolPrefixLen) {
comment_ = parseAnswer(rcode_, x);
EXPECT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ(1000, subnet->getT1());
EXPECT_EQ(2000, subnet->getT2());
@@ -1068,9 +1075,8 @@ TEST_F(Dhcp6ParserTest, pdPoolBasics) {
EXPECT_EQ(0, rcode_);
// Test that we can retrieve the subnet.
- Subnet6Ptr subnet = CfgMgr::
- instance().getSubnet6(IOAddress("2001:db8:1::5"));
-
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// Fetch the collection of PD pools. It should have 1 entry.
@@ -1143,8 +1149,8 @@ TEST_F(Dhcp6ParserTest, pdPoolList) {
EXPECT_EQ(0, rcode_);
// Test that we can retrieve the subnet.
- Subnet6Ptr subnet = CfgMgr::
- instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// Fetch the collection of NA pools. It should have 1 entry.
@@ -1201,8 +1207,8 @@ TEST_F(Dhcp6ParserTest, subnetAndPrefixDelegated) {
EXPECT_EQ(0, rcode_);
// Test that we can retrieve the subnet.
- Subnet6Ptr subnet = CfgMgr::
- instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
@@ -1846,7 +1852,8 @@ TEST_F(Dhcp6ParserTest, optionDataDefaults) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp6");
ASSERT_EQ(2, options->size());
@@ -1938,7 +1945,8 @@ TEST_F(Dhcp6ParserTest, optionDataTwoSpaces) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the space dhcp6.
Subnet::OptionDescriptor desc1 = subnet->getOptionDescriptor("dhcp6", 38);
@@ -2089,7 +2097,8 @@ TEST_F(Dhcp6ParserTest, optionDataEncapsulate) {
checkResult(status, 0);
// Get the subnet.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// We should have one option available.
@@ -2153,7 +2162,8 @@ TEST_F(Dhcp6ParserTest, optionDataInMultipleSubnets) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet6Ptr subnet1 = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet1 = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet1);
Subnet::OptionContainerPtr options1 = subnet1->getOptionDescriptors("dhcp6");
ASSERT_EQ(1, options1->size());
@@ -2178,7 +2188,8 @@ TEST_F(Dhcp6ParserTest, optionDataInMultipleSubnets) {
sizeof(subid_expected));
// Test another subnet in the same way.
- Subnet6Ptr subnet2 = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:2::4"));
+ Subnet6Ptr subnet2 = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:2::4"),
+ classify_);
ASSERT_TRUE(subnet2);
Subnet::OptionContainerPtr options2 = subnet2->getOptionDescriptors("dhcp6");
ASSERT_EQ(1, options2->size());
@@ -2348,7 +2359,8 @@ TEST_F(Dhcp6ParserTest, optionDataLowerCase) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp6");
ASSERT_EQ(1, options->size());
@@ -2392,7 +2404,8 @@ TEST_F(Dhcp6ParserTest, stdOptionData) {
comment_ = parseAnswer(rcode_, x);
ASSERT_EQ(0, rcode_);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
Subnet::OptionContainerPtr options = subnet->getOptionDescriptors("dhcp6");
ASSERT_EQ(1, options->size());
@@ -2467,7 +2480,8 @@ TEST_F(Dhcp6ParserTest, vendorOptionsHex) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the vendor space 4491
@@ -2526,7 +2540,8 @@ TEST_F(Dhcp6ParserTest, vendorOptionsCsv) {
checkResult(status, 0);
// Options should be now available for the subnet.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// Try to get the option from the vendor space 4491
@@ -2660,7 +2675,8 @@ TEST_F(Dhcp6ParserTest, stdOptionDataEncapsulate) {
checkResult(status, 0);
// Get the subnet.
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::5"),
+ classify_);
ASSERT_TRUE(subnet);
// We should have one option available.
@@ -2949,7 +2965,8 @@ TEST_F(Dhcp6ParserTest, subnetRelayInfo) {
// returned value should be 0 (configuration success)
checkResult(status, 0);
- Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::1"));
+ Subnet6Ptr subnet = CfgMgr::instance().getSubnet6(IOAddress("2001:db8:1::1"),
+ classify_);
ASSERT_TRUE(subnet);
EXPECT_EQ("2001:db8:1::abcd", subnet->relay_.addr_.toText());
}
diff --git a/src/lib/dhcp/classify.h b/src/lib/dhcp/classify.h
new file mode 100644
index 0000000..75945c5
--- /dev/null
+++ b/src/lib/dhcp/classify.h
@@ -0,0 +1,67 @@
+// Copyright (C) 2014 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+
+#ifndef CLASSIFY_H
+#define CLASSIFY_H
+
+#include <set>
+#include <string>
+
+/// @file classify.h
+///
+/// @brief Defines basic elements of client classification.
+///
+/// This file defines common elements used for client classification.
+/// It is simple for now, but the complexity involved in client
+/// classification is expected to grow significantly.
+///
+/// @todo This file should be moved to dhcpsrv eventually as the classification
+/// is server side concept. That is not possible yet, as the Pkt4 and Pkt6
+/// classes have server-side implementation, even though they reside in the
+/// dhcp directory.
+
+namespace isc {
+
+namespace dhcp {
+
+ /// Definition of a single class.
+ typedef std::string ClientClass;
+
+ /// Container for storing client classes
+ ///
+ /// Depending on how you look at it, this is either a little more than just
+ /// a set of strings or a client classifier that performs access control.
+ /// For now, it is a simple access list that may contain zero or more
+ /// class names. It is expected to grow in complexity once support for
+ /// client classes becomes more feature rich.
+ class ClientClasses : public std::set<ClientClass> {
+ public:
+ /// @brief returns if class X belongs to the defined classes
+ ///
+ /// @param x client class to be checked
+ /// @return true if X belongs to the classes
+ bool
+ contains(const ClientClass& x) const {
+ const_iterator it = find(x);
+ return (it != end());
+ }
+ };
+
+};
+
+};
+
+#endif /* CLASSIFY_H */
diff --git a/src/lib/dhcp/pkt4.h b/src/lib/dhcp/pkt4.h
index 485d28a..510ee8e 100644
--- a/src/lib/dhcp/pkt4.h
+++ b/src/lib/dhcp/pkt4.h
@@ -20,6 +20,7 @@
#include <util/buffer.h>
#include <dhcp/option.h>
#include <dhcp/hwaddr.h>
+#include <dhcp/classify.h>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp>
@@ -53,9 +54,6 @@ public:
/// to check whether client requested broadcast response.
const static uint16_t FLAG_BROADCAST_MASK = 0x8000;
- /// Container for storing client classes
- typedef std::set<std::string> Classes;
-
/// Constructor, used in replying to a message.
///
/// @param msg_type type of message (e.g. DHCPDISOVER=1)
@@ -583,7 +581,7 @@ public:
/// existing classes. Having it public also solves the problem of returned
/// reference lifetime. It is preferred to use @ref inClass and @ref addClass
/// should be used to operate on this field.
- Classes classes_;
+ ClientClasses classes_;
private:
diff --git a/src/lib/dhcp/pkt6.h b/src/lib/dhcp/pkt6.h
index db80fb9..8e51474 100644
--- a/src/lib/dhcp/pkt6.h
+++ b/src/lib/dhcp/pkt6.h
@@ -17,6 +17,7 @@
#include <asiolink/io_address.h>
#include <dhcp/option.h>
+#include <dhcp/classify.h>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_array.hpp>
@@ -48,9 +49,6 @@ public:
TCP = 1 // there are TCP DHCPv6 packets (bulk leasequery, failover)
};
- /// Container for storing client classes
- typedef std::set<std::string> Classes;
-
/// @brief defines relay search pattern
///
/// Defines order in which options are searched in a message that
@@ -457,7 +455,7 @@ public:
///
/// This field is public, so code can iterate over existing classes.
/// Having it public also solves the problem of returned reference lifetime.
- Classes classes_;
+ ClientClasses classes_;
protected:
/// Builds on wire packet for TCP transmission.
diff --git a/src/lib/dhcpsrv/cfgmgr.cc b/src/lib/dhcpsrv/cfgmgr.cc
index 6f008f1..3d2e87b 100644
--- a/src/lib/dhcpsrv/cfgmgr.cc
+++ b/src/lib/dhcpsrv/cfgmgr.cc
@@ -122,7 +122,8 @@ CfgMgr::getOptionDef(const std::string& option_space,
}
Subnet6Ptr
-CfgMgr::getSubnet6(const std::string& iface) {
+CfgMgr::getSubnet6(const std::string& iface,
+ const isc::dhcp::ClientClasses& classes) {
if (!iface.length()) {
return (Subnet6Ptr());
@@ -131,6 +132,12 @@ CfgMgr::getSubnet6(const std::string& iface) {
// If there is more than one, we need to choose the proper one
for (Subnet6Collection::iterator subnet = subnets6_.begin();
subnet != subnets6_.end(); ++subnet) {
+
+ // If client is rejected because of not meeting client class criteria...
+ if (!(*subnet)->clientSupported(classes)) {
+ continue;
+ }
+
if (iface == (*subnet)->getIface()) {
LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
DHCPSRV_CFGMGR_SUBNET6_IFACE)
@@ -142,7 +149,8 @@ CfgMgr::getSubnet6(const std::string& iface) {
}
Subnet6Ptr
-CfgMgr::getSubnet6(const isc::asiolink::IOAddress& hint) {
+CfgMgr::getSubnet6(const isc::asiolink::IOAddress& hint,
+ const isc::dhcp::ClientClasses& classes) {
// If there's only one subnet configured, let's just use it
// The idea is to keep small deployments easy. In a small network - one
@@ -163,6 +171,11 @@ CfgMgr::getSubnet6(const isc::asiolink::IOAddress& hint) {
for (Subnet6Collection::iterator subnet = subnets6_.begin();
subnet != subnets6_.end(); ++subnet) {
+ // If client is rejected because of not meeting client class criteria...
+ if (!(*subnet)->clientSupported(classes)) {
+ continue;
+ }
+
if ((*subnet)->inRange(hint)) {
LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
DHCPSRV_CFGMGR_SUBNET6)
@@ -177,7 +190,8 @@ CfgMgr::getSubnet6(const isc::asiolink::IOAddress& hint) {
return (Subnet6Ptr());
}
-Subnet6Ptr CfgMgr::getSubnet6(OptionPtr iface_id_option) {
+Subnet6Ptr CfgMgr::getSubnet6(OptionPtr iface_id_option,
+ const isc::dhcp::ClientClasses& classes) {
if (!iface_id_option) {
return (Subnet6Ptr());
}
@@ -186,6 +200,12 @@ Subnet6Ptr CfgMgr::getSubnet6(OptionPtr iface_id_option) {
// defined, check if the interface-id is equal to what we are looking for
for (Subnet6Collection::iterator subnet = subnets6_.begin();
subnet != subnets6_.end(); ++subnet) {
+
+ // If client is rejected because of not meeting client class criteria...
+ if (!(*subnet)->clientSupported(classes)) {
+ continue;
+ }
+
if ( (*subnet)->getInterfaceId() &&
((*subnet)->getInterfaceId()->equal(iface_id_option))) {
LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
@@ -207,7 +227,8 @@ void CfgMgr::addSubnet6(const Subnet6Ptr& subnet) {
}
Subnet4Ptr
-CfgMgr::getSubnet4(const isc::asiolink::IOAddress& hint) {
+CfgMgr::getSubnet4(const isc::asiolink::IOAddress& hint,
+ const isc::dhcp::ClientClasses& classes) {
// If there's only one subnet configured, let's just use it
// The idea is to keep small deployments easy. In a small network - one
@@ -227,6 +248,13 @@ CfgMgr::getSubnet4(const isc::asiolink::IOAddress& hint) {
// If there is more than one, we need to choose the proper one
for (Subnet4Collection::iterator subnet = subnets4_.begin();
subnet != subnets4_.end(); ++subnet) {
+
+ // If client is rejected because of not meeting client class criteria...
+ if (!(*subnet)->clientSupported(classes)) {
+ continue;
+ }
+
+ // Let's check if the client belongs to the given subnet
if ((*subnet)->inRange(hint)) {
LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
DHCPSRV_CFGMGR_SUBNET4)
diff --git a/src/lib/dhcpsrv/cfgmgr.h b/src/lib/dhcpsrv/cfgmgr.h
index fcec8bf..1f548dc 100644
--- a/src/lib/dhcpsrv/cfgmgr.h
+++ b/src/lib/dhcpsrv/cfgmgr.h
@@ -19,6 +19,7 @@
#include <dhcp/option.h>
#include <dhcp/option_definition.h>
#include <dhcp/option_space.h>
+#include <dhcp/classify.h>
#include <dhcpsrv/d2_client.h>
#include <dhcpsrv/option_space_container.h>
#include <dhcpsrv/pool.h>
@@ -168,7 +169,8 @@ public:
/// @param hint an address that belongs to a searched subnet
///
/// @return a subnet object (or NULL if no suitable match was fount)
- Subnet6Ptr getSubnet6(const isc::asiolink::IOAddress& hint);
+ Subnet6Ptr getSubnet6(const isc::asiolink::IOAddress& hint,
+ const isc::dhcp::ClientClasses& classes);
/// @brief get IPv6 subnet by interface name
///
@@ -177,7 +179,8 @@ public:
/// user as reachable over specified network interface.
/// @param iface_name interface name
/// @return a subnet object (or NULL if no suitable match was fount)
- Subnet6Ptr getSubnet6(const std::string& iface_name);
+ Subnet6Ptr getSubnet6(const std::string& iface_name,
+ const isc::dhcp::ClientClasses& classes);
/// @brief get IPv6 subnet by interface-id
///
@@ -186,7 +189,8 @@ public:
/// @param interface_id content of interface-id option returned by a relay
///
/// @return a subnet object
- Subnet6Ptr getSubnet6(OptionPtr interface_id);
+ Subnet6Ptr getSubnet6(OptionPtr interface_id,
+ const isc::dhcp::ClientClasses& classes);
/// @brief adds an IPv6 subnet
///
@@ -244,7 +248,8 @@ public:
/// @param hint an address that belongs to a searched subnet
///
/// @return a subnet object
- Subnet4Ptr getSubnet4(const isc::asiolink::IOAddress& hint);
+ Subnet4Ptr getSubnet4(const isc::asiolink::IOAddress& hint,
+ const isc::dhcp::ClientClasses& classes);
/// @brief adds a subnet4
void addSubnet4(const Subnet4Ptr& subnet);
diff --git a/src/lib/dhcpsrv/subnet.cc b/src/lib/dhcpsrv/subnet.cc
index 7e56dbb..f5e9a7c 100644
--- a/src/lib/dhcpsrv/subnet.cc
+++ b/src/lib/dhcpsrv/subnet.cc
@@ -76,6 +76,21 @@ Subnet::setRelay(const isc::dhcp::Subnet::RelayInfo& relay) {
relay_ = relay;
}
+bool
+Subnet::clientSupported(const isc::dhcp::ClientClasses& classes) const {
+ if (white_list_.empty()) {
+ return (true); // There is no class defined for this subnet, so we do
+ // support everyone.
+ }
+
+ return (classes.contains(white_list_));
+}
+
+void
+Subnet::allowClientClass(const isc::dhcp::ClientClass& class_name) {
+ white_list_ = class_name;
+}
+
void
Subnet::delOptions() {
option_spaces_.clearItems();
diff --git a/src/lib/dhcpsrv/subnet.h b/src/lib/dhcpsrv/subnet.h
index c223bab..fc59e9a 100644
--- a/src/lib/dhcpsrv/subnet.h
+++ b/src/lib/dhcpsrv/subnet.h
@@ -24,6 +24,7 @@
#include <asiolink/io_address.h>
#include <dhcp/option.h>
+#include <dhcp/classify.h>
#include <dhcpsrv/key_from_key.h>
#include <dhcpsrv/option_space_container.h>
#include <dhcpsrv/pool.h>
@@ -422,6 +423,26 @@ public:
/// subnet object disappears.
RelayInfo relay_;
+ /// @brief checks whether this subnet supports client that belongs to
+ /// specified classes.
+ ///
+ /// This method checks whether a client that belongs to given classes can
+ /// use this subnet. For example, if this class is reserved for client
+ /// class "foo" and the client belongs to classes "foo", "bar" and "baz",
+ /// it is supported. On the other hand, client belonging to classes
+ /// "foobar" and "zyxxy" is not supported.
+ ///
+ /// @param client_classes list of all classes the client belongs to
+ /// @return true if client can be supported, false otherwise
+ bool
+ clientSupported(const isc::dhcp::ClientClasses& client_classes) const;
+
+ /// @brief adds class class_name to the list of supported classes
+ ///
+ /// @param class_name client class to be supported by this subnet
+ void
+ allowClientClass(const isc::dhcp::ClientClass& class_name);
+
protected:
/// @brief Returns all pools (non-const variant)
///
@@ -548,6 +569,13 @@ protected:
/// @brief Name of the network interface (if connected directly)
std::string iface_;
+ /// @brief optional definition of a client class
+ ///
+ /// If defined, only clients belonging to that class will be allowed to use
+ /// this particular subnet. The default value for this is "", which means
+ /// that any client is allowed, regardless of its class.
+ ClientClass white_list_;
+
private:
/// A collection of option spaces grouping option descriptors.
diff --git a/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc b/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
index 8c3d2ea..31db594 100644
--- a/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
@@ -184,6 +184,9 @@ public:
CfgMgr::instance().deleteSubnets6();
CfgMgr::instance().deleteOptionDefs();
}
+
+ /// used in client classification (or just empty container for other tests)
+ isc::dhcp::ClientClasses classify_;
};
// This test verifies that multiple option definitions can be added
@@ -349,7 +352,7 @@ TEST_F(CfgMgrTest, addOptionDefNegative) {
}
// This test verifies if the configuration manager is able to hold and return
-// valid leases
+// valid subnets.
TEST_F(CfgMgrTest, subnet4) {
CfgMgr& cfg_mgr = CfgMgr::instance();
@@ -358,30 +361,222 @@ TEST_F(CfgMgrTest, subnet4) {
Subnet4Ptr subnet3(new Subnet4(IOAddress("192.0.2.128"), 26, 1, 2, 3));
// There shouldn't be any subnet configured at this stage
- EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.0")));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.0"), classify_));
cfg_mgr.addSubnet4(subnet1);
// Now we have only one subnet, any request will be served from it
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.63")));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.63"),
+ classify_));
// Now we add more subnets and check that both old and new subnets
// are accessible.
cfg_mgr.addSubnet4(subnet2);
cfg_mgr.addSubnet4(subnet3);
- EXPECT_EQ(subnet3, cfg_mgr.getSubnet4(IOAddress("192.0.2.191")));
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.15")));
- EXPECT_EQ(subnet2, cfg_mgr.getSubnet4(IOAddress("192.0.2.85")));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet4(IOAddress("192.0.2.191"), classify_));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.15"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet4(IOAddress("192.0.2.85"), classify_));
// Try to find an address that does not belong to any subnet
- EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.192")));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.192"), classify_));
// Check that deletion of the subnets works.
cfg_mgr.deleteSubnets4();
- EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.191")));
- EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.15")));
- EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.85")));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.191"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.15"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.85"), classify_));
+}
+
+// This test verifies if the configuration manager is able to hold subnets with
+// their classifier information and return proper subnets, based on those
+// classes.
+TEST_F(CfgMgrTest, classifySubnet4) {
+ CfgMgr& cfg_mgr = CfgMgr::instance();
+
+ // Let's configure 3 subnets
+ Subnet4Ptr subnet1(new Subnet4(IOAddress("192.0.2.0"), 26, 1, 2, 3));
+ Subnet4Ptr subnet2(new Subnet4(IOAddress("192.0.2.64"), 26, 1, 2, 3));
+ Subnet4Ptr subnet3(new Subnet4(IOAddress("192.0.2.128"), 26, 1, 2, 3));
+
+ cfg_mgr.addSubnet4(subnet1);
+ cfg_mgr.addSubnet4(subnet2);
+ cfg_mgr.addSubnet4(subnet3);
+
+ // Let's sanity check that we can use that configuration.
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.5"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet4(IOAddress("192.0.2.70"), classify_));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet4(IOAddress("192.0.2.130"), classify_));
+
+ // Client now belongs to bar class.
+ classify_.insert("bar");
+
+ // There are no class restrictions defined, so everything should work
+ // as before
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet4(IOAddress("192.0.2.5"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet4(IOAddress("192.0.2.70"), classify_));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet4(IOAddress("192.0.2.130"), classify_));
+
+ // Now let's add client class restrictions.
+ subnet1->allowClientClass("foo"); // Serve here only clients from foo class
+ subnet2->allowClientClass("bar"); // Serve here only clients from bar class
+ subnet3->allowClientClass("baz"); // Serve here only clients from baz class
+
+ // The same check as above should result in client being served only in
+ // bar class, i.e. subnet2
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.5"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet4(IOAddress("192.0.2.70"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.130"), classify_));
+
+ // Now let's check that client with wrong class is not supported
+ classify_.clear();
+ classify_.insert("some_other_class");
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.5"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.70"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.130"), classify_));
+
+ // Finally, let's check that client without any classes is not supported
+ classify_.clear();
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.5"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.70"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet4(IOAddress("192.0.2.130"), classify_));
+}
+
+// This test verifies if the configuration manager is able to hold and return
+// valid leases
+TEST_F(CfgMgrTest, classifySubnet6) {
+ CfgMgr& cfg_mgr = CfgMgr::instance();
+
+ // Let's configure 3 subnets
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet3(new Subnet6(IOAddress("4000::"), 48, 1, 2, 3, 4));
+
+ cfg_mgr.addSubnet6(subnet1);
+ cfg_mgr.addSubnet6(subnet2);
+ cfg_mgr.addSubnet6(subnet3);
+
+ // Let's sanity check that we can use that configuration.
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::345"), classify_));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(IOAddress("4000::567"), classify_));
+
+ // Client now belongs to bar class.
+ classify_.insert("bar");
+
+ // There are no class restrictions defined, so everything should work
+ // as before
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::345"), classify_));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(IOAddress("4000::567"), classify_));
+
+ // Now let's add client class restrictions.
+ subnet1->allowClientClass("foo"); // Serve here only clients from foo class
+ subnet2->allowClientClass("bar"); // Serve here only clients from bar class
+ subnet3->allowClientClass("baz"); // Serve here only clients from baz class
+
+ // The same check as above should result in client being served only in
+ // bar class, i.e. subnet2
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::345"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("4000::567"), classify_));
+
+ // Now let's check that client with wrong class is not supported
+ classify_.clear();
+ classify_.insert("some_other_class");
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("3000::345"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("4000::567"), classify_));
+
+ // Finally, let's check that client without any classes is not supported
+ classify_.clear();
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("3000::345"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("4000::567"), classify_));
+}
+
+// This test verifies if the configuration manager is able to hold, select
+// and return valid subnets, based on interface names along with client
+// classification.
+TEST_F(CfgMgrTest, classifySubnet6Interface) {
+ CfgMgr& cfg_mgr = CfgMgr::instance();
+
+ // Let's have an odd configuration: 3 shared subnets available on the
+ // same direct link.
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet3(new Subnet6(IOAddress("4000::"), 48, 1, 2, 3, 4));
+ subnet1->setIface("foo");
+ subnet2->setIface("foo");
+ subnet3->setIface("foo");
+ cfg_mgr.addSubnet6(subnet1);
+ cfg_mgr.addSubnet6(subnet2);
+ cfg_mgr.addSubnet6(subnet3);
+
+
+ // Regular client should get the first subnet, because it meets all
+ // criteria (matching interface name, no class restrictions.
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6("foo", classify_));
+
+ // Now let's add class requirements for subnet1
+ subnet1->allowClientClass("alpha");
+
+ // Client should now get the subnet2, because he no longer meets
+ // requirements for subnet1 (belongs to wrong class)
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6("foo", classify_));
+
+ // Now let's add (not matching) classes to the other two subnets
+ subnet2->allowClientClass("beta");
+ subnet3->allowClientClass("gamma");
+
+ // No subnets are suitable, so nothing will be selected
+ EXPECT_FALSE(cfg_mgr.getSubnet6("foo", classify_));
+
+ // Ok, let's add the client to gamme class, so he'll get a subnet
+ classify_.insert("gamma");
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6("foo", classify_));
+}
+
+// This test verifies if the configuration manager is able to hold, select
+// and return valid subnets, based on interface-id option inserted by relay,
+// along with client classification.
+TEST_F(CfgMgrTest, classifySubnet6InterfaceId) {
+ CfgMgr& cfg_mgr = CfgMgr::instance();
+
+ // Let's have an odd configuration: 3 shared subnets available via the
+ // same remote relay with the same interface-id.
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet3(new Subnet6(IOAddress("4000::"), 48, 1, 2, 3, 4));
+ OptionPtr ifaceid = generateInterfaceId("relay1.eth0");
+ subnet1->setInterfaceId(ifaceid);
+ subnet2->setInterfaceId(ifaceid);
+ subnet3->setInterfaceId(ifaceid);
+ cfg_mgr.addSubnet6(subnet1);
+ cfg_mgr.addSubnet6(subnet2);
+ cfg_mgr.addSubnet6(subnet3);
+
+ // Regular client should get the first subnet, because it meets all
+ // criteria (matching interface name, no class restrictions.
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(ifaceid, classify_));
+
+ // Now let's add class requirements for subnet1
+ subnet1->allowClientClass("alpha");
+
+ // Client should now get the subnet2, because he no longer meets
+ // requirements for subnet1 (belongs to wrong class)
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(ifaceid, classify_));
+
+ // Now let's add (not matching) classes to the other two subnets
+ subnet2->allowClientClass("beta");
+ subnet3->allowClientClass("gamma");
+
+ // No subnets are suitable, so nothing will be selected
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid, classify_));
+
+ // Ok, let's add the client to gamme class, so he'll get a subnet
+ classify_.insert("gamma");
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(ifaceid, classify_));
}
// This test verifies if the configuration manager is able to hold and return
@@ -394,29 +589,31 @@ TEST_F(CfgMgrTest, subnet6) {
Subnet6Ptr subnet3(new Subnet6(IOAddress("4000::"), 48, 1, 2, 3, 4));
// There shouldn't be any subnet configured at this stage
- EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::1")));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::1"), classify_));
cfg_mgr.addSubnet6(subnet1);
// Now we have only one subnet, any request will be served from it
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("2000::1")));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("2000::1"), classify_));
// If we have only a single subnet and the request came from a local
// address, let's use that subnet
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("fe80::dead:beef")));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("fe80::dead:beef"),
+ classify_));
cfg_mgr.addSubnet6(subnet2);
cfg_mgr.addSubnet6(subnet3);
- EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(IOAddress("4000::123")));
- EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::dead:beef")));
- EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("5000::1")));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(IOAddress("4000::123"), classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::dead:beef"),
+ classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("5000::1"), classify_));
// Check that deletion of the subnets works.
cfg_mgr.deleteSubnets6();
- EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("200::123")));
- EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("3000::123")));
- EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("4000::123")));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("2000::123"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("3000::123"), classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(IOAddress("4000::123"), classify_));
}
// This test verifies if the configuration manager is able to hold, select
@@ -432,33 +629,34 @@ TEST_F(CfgMgrTest, subnet6Interface) {
subnet3->setIface("foobar");
// There shouldn't be any subnet configured at this stage
- EXPECT_FALSE(cfg_mgr.getSubnet6("foo"));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("foo", classify_));
cfg_mgr.addSubnet6(subnet1);
// Now we have only one subnet, any request will be served from it
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet6("foo"));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6("foo", classify_));
// Check that the interface name is checked even when there is
// only one subnet defined.
- EXPECT_FALSE(cfg_mgr.getSubnet6("bar"));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("bar", classify_));
// If we have only a single subnet and the request came from a local
// address, let's use that subnet
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("fe80::dead:beef")));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("fe80::dead:beef"),
+ classify_));
cfg_mgr.addSubnet6(subnet2);
cfg_mgr.addSubnet6(subnet3);
- EXPECT_EQ(subnet3, cfg_mgr.getSubnet6("foobar"));
- EXPECT_EQ(subnet2, cfg_mgr.getSubnet6("bar"));
- EXPECT_FALSE(cfg_mgr.getSubnet6("xyzzy")); // no such interface
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6("foobar", classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6("bar", classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("xyzzy", classify_)); // no such interface
// Check that deletion of the subnets works.
cfg_mgr.deleteSubnets6();
- EXPECT_FALSE(cfg_mgr.getSubnet6("foo"));
- EXPECT_FALSE(cfg_mgr.getSubnet6("bar"));
- EXPECT_FALSE(cfg_mgr.getSubnet6("foobar"));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("foo", classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("bar", classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6("foobar", classify_));
}
// This test verifies if the configuration manager is able to hold, select
@@ -484,27 +682,27 @@ TEST_F(CfgMgrTest, subnet6InterfaceId) {
subnet3->setInterfaceId(ifaceid3);
// There shouldn't be any subnet configured at this stage
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid1));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid1, classify_));
cfg_mgr.addSubnet6(subnet1);
// If we have only a single subnet and the request came from a local
// address, let's use that subnet
- EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(ifaceid1));
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid2));
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(ifaceid1, classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid2, classify_));
cfg_mgr.addSubnet6(subnet2);
cfg_mgr.addSubnet6(subnet3);
- EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(ifaceid3));
- EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(ifaceid2));
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid_bogus));
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(ifaceid3, classify_));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(ifaceid2, classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid_bogus, classify_));
// Check that deletion of the subnets works.
cfg_mgr.deleteSubnets6();
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid1));
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid2));
- EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid3));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid1, classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid2, classify_));
+ EXPECT_FALSE(cfg_mgr.getSubnet6(ifaceid3, classify_));
}
diff --git a/src/lib/dhcpsrv/tests/subnet_unittest.cc b/src/lib/dhcpsrv/tests/subnet_unittest.cc
index 9392d3c..8e81cc1 100644
--- a/src/lib/dhcpsrv/tests/subnet_unittest.cc
+++ b/src/lib/dhcpsrv/tests/subnet_unittest.cc
@@ -139,6 +139,44 @@ TEST(Subnet4Test, Subnet4_Pool4_checks) {
EXPECT_THROW(subnet->addPool(pool3), BadValue);
}
+// Tests whether Subnet4 object is able to store and process properly
+// information about allowed client classes.
+TEST(Subnet4Test, clientClasses) {
+ // Create the V4 subnet.
+ Subnet4Ptr subnet(new Subnet4(IOAddress("192.0.2.0"), 8, 1, 2, 3));
+
+ // This client does not belong to any class.
+ isc::dhcp::ClientClasses no_class;
+
+ // This client belongs to foo only.
+ isc::dhcp::ClientClasses foo_class;
+ foo_class.insert("foo");
+
+ // This client belongs to bar only. I like that client.
+ isc::dhcp::ClientClasses bar_class;
+ bar_class.insert("bar");
+
+ // This client belongs to foo, bar and baz classes.
+ isc::dhcp::ClientClasses three_classes;
+ three_classes.insert("foo");
+ three_classes.insert("bar");
+ three_classes.insert("baz");
+
+ // No class restrictions defined, any client should be supported
+ EXPECT_TRUE(subnet->clientSupported(no_class));
+ EXPECT_TRUE(subnet->clientSupported(foo_class));
+ EXPECT_TRUE(subnet->clientSupported(bar_class));
+ EXPECT_TRUE(subnet->clientSupported(three_classes));
+
+ // Let's allow only clients belongning to "bar" class.
+ subnet->allowClientClass("bar");
+
+ EXPECT_FALSE(subnet->clientSupported(no_class));
+ EXPECT_FALSE(subnet->clientSupported(foo_class));
+ EXPECT_TRUE(subnet->clientSupported(bar_class));
+ EXPECT_TRUE(subnet->clientSupported(three_classes));
+}
+
TEST(Subnet4Test, addInvalidOption) {
// Create the V4 subnet.
Subnet4Ptr subnet(new Subnet4(IOAddress("192.0.2.0"), 8, 1, 2, 3));
@@ -416,6 +454,44 @@ TEST(Subnet6Test, PoolTypes) {
EXPECT_THROW(subnet->addPool(pool5), BadValue);
}
+// Tests whether Subnet6 object is able to store and process properly
+// information about allowed client classes.
+TEST(Subnet6Test, clientClasses) {
+ // Create the V6 subnet.
+ Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 56, 1, 2, 3, 4));
+
+ // This client does not belong to any class.
+ isc::dhcp::ClientClasses no_class;
+
+ // This client belongs to foo only.
+ isc::dhcp::ClientClasses foo_class;
+ foo_class.insert("foo");
+
+ // This client belongs to bar only. I like that client.
+ isc::dhcp::ClientClasses bar_class;
+ bar_class.insert("bar");
+
+ // This client belongs to foo, bar and baz classes.
+ isc::dhcp::ClientClasses three_classes;
+ three_classes.insert("foo");
+ three_classes.insert("bar");
+ three_classes.insert("baz");
+
+ // No class restrictions defined, any client should be supported
+ EXPECT_TRUE(subnet->clientSupported(no_class));
+ EXPECT_TRUE(subnet->clientSupported(foo_class));
+ EXPECT_TRUE(subnet->clientSupported(bar_class));
+ EXPECT_TRUE(subnet->clientSupported(three_classes));
+
+ // Let's allow only clients belongning to "bar" class.
+ subnet->allowClientClass("bar");
+
+ EXPECT_FALSE(subnet->clientSupported(no_class));
+ EXPECT_FALSE(subnet->clientSupported(foo_class));
+ EXPECT_TRUE(subnet->clientSupported(bar_class));
+ EXPECT_TRUE(subnet->clientSupported(three_classes));
+}
+
TEST(Subnet6Test, Subnet6_Pool6_checks) {
Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 56, 1, 2, 3, 4));
More information about the bind10-changes
mailing list