// Copyright (C) 2011-2022 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http://mozilla.org/MPL/2.0/. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace isc; using namespace isc::dhcp; using namespace isc::data; using namespace isc::asiolink; using namespace isc::cb; using namespace isc::config; using namespace isc::dhcp::test; using namespace isc::util; namespace { const char* CONFIGS[] = { // Configuration 0: // - 1 subnet: 10.254.226.0/25 // - used for recorded traffic (see PktCaptures::captureRelayedDiscover) "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ { " " \"pools\": [ { \"pool\": \"10.254.226.0/25\" } ]," " \"subnet\": \"10.254.226.0/24\", " " \"rebind-timer\": 2000, " " \"renew-timer\": 1000, " " \"valid-lifetime\": 4000," " \"interface\": \"eth0\" " " } ]," "\"valid-lifetime\": 4000 }", // Configuration 1: // - 1 subnet: 192.0.2.0/24 // - MySQL Host Data Source configured "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"hosts-database\": {" " \"type\": \"mysql\"," " \"name\": \"keatest\"," " \"user\": \"keatest\"," " \"password\": \"keatest\"" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ { " " \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ]," " \"subnet\": \"192.0.2.0/24\", " " \"rebind-timer\": 2000, " " \"renew-timer\": 1000, " " \"valid-lifetime\": 4000," " \"interface\": \"eth0\" " " } ]," "\"valid-lifetime\": 4000 }", // Configuration 2: // - 1 subnet, 2 global options (one forced with always-send) "{" " \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " " \"rebind-timer\": 2000, " " \"renew-timer\": 1000, " " \"valid-lifetime\": 4000, " " \"subnet4\": [ {" " \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\"" " } ], " " \"option-data\": [" " {" " \"name\": \"default-ip-ttl\", " " \"data\": \"FF\", " " \"csv-format\": false" " }, " " {" " \"name\": \"ip-forwarding\", " " \"data\": \"false\", " " \"always-send\": true" " }" " ]" "}", // Configuration 3: // - one subnet, with one pool // - user-contexts defined in both subnet and pool "{" " \"subnet4\": [ { " " \"pools\": [ { \"pool\": \"10.254.226.0/25\"," " \"user-context\": { \"value\": 42 } } ]," " \"subnet\": \"10.254.226.0/24\", " " \"user-context\": {" " \"secure\": false" " }" " } ]," "\"valid-lifetime\": 4000 }", }; // Convenience function for comparing option buffer to an expected string value // @param exp_string expected string value // @param buffer OptionBuffer whose contents are to be tested void checkStringInBuffer( const std::string& exp_string, const OptionBuffer& buffer) { std::string buffer_string(buffer.begin(), buffer.end()); EXPECT_EQ(exp_string, std::string(buffer_string.c_str())); } // This test verifies that the destination address of the response // message is set to giaddr, when giaddr is set to non-zero address // in the received message. TEST_F(Dhcpv4SrvTest, adjustIfaceDataRelay) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create the instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Set the giaddr to non-zero address and hops to non-zero value // as if it was relayed. req->setGiaddr(IOAddress("192.0.1.1")); req->setHops(2); // Set ciaddr to zero. This simulates the client which applies // for the new lease. req->setCiaddr(IOAddress("0.0.0.0")); // Clear broadcast flag. req->setFlags(0x0000); // Set local address, port and interface. req->setLocalAddr(IOAddress("192.0.2.5")); req->setLocalPort(1001); req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote port (it will be used in the next test). req->setRemotePort(1234); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); resp->setYiaddr(IOAddress("192.0.1.100")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set hops value for the response. resp->setHops(req->getHops()); // This function never throws. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Now the destination address should be relay's address. EXPECT_EQ("192.0.1.1", resp->getRemoteAddr().toText()); // The query has been relayed, so the response must be sent to the port 67. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getRemotePort()); // Local address should be the address assigned to interface eth1. EXPECT_EQ("192.0.2.5", resp->getLocalAddr().toText()); // The local port is always DHCPv4 server port 67. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // We will send response over the same interface which was used to receive // query. EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); // Let's do another test and set other fields: ciaddr and // flags. By doing it, we want to make sure that the relay // address will take precedence. req->setGiaddr(IOAddress("192.0.1.50")); req->setCiaddr(IOAddress("192.0.1.11")); req->setFlags(Pkt4::FLAG_BROADCAST_MASK); resp->setYiaddr(IOAddress("192.0.1.100")); // Clear remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set the client and server ports. srv_.client_port_ = 1234; srv_.server_port_ = 2345; ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Response should be sent back to the relay address. EXPECT_EQ("192.0.1.50", resp->getRemoteAddr().toText()); // Remote port was enforced to the client port. EXPECT_EQ(srv_.client_port_, resp->getRemotePort()); // Local port was enforced to the server port. EXPECT_EQ(srv_.server_port_, resp->getLocalPort()); } // This test verifies that the remote port is adjusted when // the query carries a relay port RAI sub-option. TEST_F(Dhcpv4SrvTest, adjustIfaceDataRelayPort) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create the instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Set the giaddr to non-zero address and hops to non-zero value // as if it was relayed. req->setGiaddr(IOAddress("192.0.1.1")); req->setHops(2); // Set ciaddr to zero. This simulates the client which applies // for the new lease. req->setCiaddr(IOAddress("0.0.0.0")); // Clear broadcast flag. req->setFlags(0x0000); // Set local address, port and interface. req->setLocalAddr(IOAddress("192.0.2.5")); req->setLocalPort(1001); req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote port. req->setRemotePort(1234); // Add a RAI relay-port sub-option (the only difference with the previous test). OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_AGENT_OPTIONS); ASSERT_TRUE(rai_def); OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4)); ASSERT_TRUE(rai); req->addOption(rai); OptionPtr relay_port(new Option(Option::V4, RAI_OPTION_RELAY_PORT)); ASSERT_TRUE(relay_port); rai->addOption(relay_port); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); resp->setYiaddr(IOAddress("192.0.1.100")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set hops value for the response. resp->setHops(req->getHops()); // Set the remote port to 67 as we know it will be updated. resp->setRemotePort(67); // This function never throws. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Now the destination address should be relay's address. EXPECT_EQ("192.0.1.1", resp->getRemoteAddr().toText()); // The query has been relayed, so the response should be sent to the // port 67, but here there is a relay port RAI so another value is used. EXPECT_EQ(1234, resp->getRemotePort()); // Local address should be the address assigned to interface eth1. EXPECT_EQ("192.0.2.5", resp->getLocalAddr().toText()); // The local port is always DHCPv4 server port 67. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // We will send response over the same interface which was used to receive // query. EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); } // This test verifies that it is possible to configure the server to use // routing information to determine the right outbound interface to sent // responses to a relayed client. TEST_F(Dhcpv4SrvTest, adjustIfaceDataUseRouting) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create configuration for interfaces. It includes the outbound-interface // setting which indicates that the responses aren't necessarily sent // over the same interface via which a request has been received, but routing // information is used to determine this interface. CfgMgr::instance().clear(); CfgIfacePtr cfg_iface = CfgMgr::instance().getStagingCfg()->getCfgIface(); cfg_iface->useSocketType(AF_INET, CfgIface::SOCKET_UDP); cfg_iface->use(AF_INET, "eth0"); cfg_iface->use(AF_INET, "eth1"); cfg_iface->setOutboundIface(CfgIface::USE_ROUTING); CfgMgr::instance().commit();; // Create the instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Set the giaddr to non-zero address and hops to non-zero value // as if it was relayed. req->setGiaddr(IOAddress("192.0.1.1")); req->setHops(2); // Set ciaddr to zero. This simulates the client which applies // for the new lease. req->setCiaddr(IOAddress("0.0.0.0")); // Clear broadcast flag. req->setFlags(0x0000); // Set local address, port and interface. req->setLocalAddr(IOAddress("192.0.2.5")); req->setLocalPort(1001); req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); resp->setYiaddr(IOAddress("192.0.1.100")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set hops value for the response. resp->setHops(req->getHops()); // This function never throws. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Now the destination address should be relay's address. EXPECT_EQ("192.0.1.1", resp->getRemoteAddr().toText()); // The query has been relayed, so the response must be sent to the port 67. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getRemotePort()); // The local port is always DHCPv4 server port 67. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // No specific interface is selected as outbound interface and no specific // local address is provided. The IfaceMgr will figure out which interface to use. EXPECT_TRUE(resp->getLocalAddr().isV4Zero()); EXPECT_FALSE(resp->indexSet()); // Fixed in #5515 so now the interface name is never empty. EXPECT_FALSE(resp->getIface().empty()); // Another test verifies that setting outbound interface to same as inbound will // cause the server to set interface and local address as expected. cfg_iface = CfgMgr::instance().getStagingCfg()->getCfgIface(); cfg_iface->useSocketType(AF_INET, CfgIface::SOCKET_UDP); cfg_iface->use(AF_INET, "eth0"); cfg_iface->use(AF_INET, "eth1"); cfg_iface->setOutboundIface(CfgIface::SAME_AS_INBOUND); CfgMgr::instance().commit(); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); EXPECT_EQ("192.0.2.5", resp->getLocalAddr().toText()); EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); } // This test verifies that the destination address of the response // message is set to source address when the testing mode is enabled. // Relayed message: not testing mode was tested in adjustIfaceDataRelay. TEST_F(Dhcpv4SrvTest, adjustRemoteAddressRelaySendToSourceTestingModeEnabled) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create the instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Set the giaddr to non-zero address and hops to non-zero value // as if it was relayed. req->setGiaddr(IOAddress("192.0.1.1")); req->setHops(2); // Set ciaddr to zero. This simulates the client which applies // for the new lease. req->setCiaddr(IOAddress("0.0.0.0")); // Clear broadcast flag. req->setFlags(0x0000); // Set local address, port and interface. req->setLocalAddr(IOAddress("192.0.2.5")); req->setLocalPort(1001); req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote address and port. req->setRemoteAddr(IOAddress("192.0.2.1")); req->setRemotePort(1234); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); resp->setYiaddr(IOAddress("192.0.1.100")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set hops value for the response. resp->setHops(req->getHops()); // Set the testing mode. srv_.setSendResponsesToSource(true); // This function never throws. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Now the destination address should be source address. EXPECT_EQ("192.0.2.1", resp->getRemoteAddr().toText()); } // This test verifies that the destination address of the response message // is set to ciaddr when giaddr is set to zero and the ciaddr is set to // non-zero address in the received message. This is the case when the // client is in Renew or Rebind state. TEST_F(Dhcpv4SrvTest, adjustIfaceDataRenew) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Set ciaddr to non-zero address. The response should be sent to this // address as the client is in renewing or rebinding state (it is fully // configured). req->setCiaddr(IOAddress("192.0.1.15")); // Let's configure broadcast flag. It should be ignored because // we are responding directly to the client having an address // and trying to extend his lease. Broadcast flag is only used // when new lease is acquired and server must make a decision // whether to unicast the response to the acquired address or // broadcast it. req->setFlags(Pkt4::FLAG_BROADCAST_MASK); // This is a direct message, so the hops should be cleared. req->setHops(0); // Set local unicast address as if we are renewing a lease. req->setLocalAddr(IOAddress("192.0.2.1")); // Request is received on the DHCPv4 server port. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent over the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Let's extend the lease for the client in such a way that // it will actually get different address. The response // should not be sent to this address but rather to ciaddr // as client still have ciaddr configured. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Copy hops value from the query. resp->setHops(req->getHops()); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that server responds to ciaddr EXPECT_EQ("192.0.1.15", resp->getRemoteAddr().toText()); // The query was non-relayed, so the response should be sent to a DHCPv4 // client port 68. EXPECT_EQ(DHCP4_CLIENT_PORT, resp->getRemotePort()); // The response should be sent from the unicast address on which the // query has been received. EXPECT_EQ("192.0.2.1", resp->getLocalAddr().toText()); // The response should be sent from the DHCPv4 server port. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // The interface data should match the data in the query. EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); } // This test verifies that the destination address of the response message // is set to source address when the testing mode is enabled. // Renew: not testing mode was tested in adjustIfaceDataRenew. TEST_F(Dhcpv4SrvTest, adjustRemoteAddressRenewSendToSourceTestingModeEnabled) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Set ciaddr to non-zero address. The response should be sent to this // address as the client is in renewing or rebinding state (it is fully // configured). req->setCiaddr(IOAddress("192.0.1.15")); // Let's configure broadcast flag. It should be ignored because // we are responding directly to the client having an address // and trying to extend his lease. Broadcast flag is only used // when new lease is acquired and server must make a decision // whether to unicast the response to the acquired address or // broadcast it. req->setFlags(Pkt4::FLAG_BROADCAST_MASK); // This is a direct message, so the hops should be cleared. req->setHops(0); // Set local unicast address as if we are renewing a lease. req->setLocalAddr(IOAddress("192.0.2.1")); // Request is received on the DHCPv4 server port. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent over the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote address. req->setRemoteAddr(IOAddress("192.0.2.1")); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Let's extend the lease for the client in such a way that // it will actually get different address. The response // should not be sent to this address but rather to ciaddr // as client still have ciaddr configured. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Copy hops value from the query. resp->setHops(req->getHops()); // Set the testing mode. srv_.setSendResponsesToSource(true); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that server responds to source address. EXPECT_EQ("192.0.2.1", resp->getRemoteAddr().toText()); } // This test verifies that the destination address of the response message // is set correctly when giaddr and ciaddr is zeroed in the received message // and the new lease is acquired. The lease address is carried in the // response message in the yiaddr field. In this case destination address // of the response should be set to yiaddr if server supports direct responses // to the client which doesn't have an address yet or broadcast if the server // doesn't support direct responses. TEST_F(Dhcpv4SrvTest, adjustIfaceDataSelect) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Clear client address as it hasn't got any address configured yet. req->setCiaddr(IOAddress("0.0.0.0")); // Let's clear the broadcast flag. req->setFlags(0); // This is a non-relayed message, so let's clear hops count. req->setHops(0); // The query is sent to the broadcast address in the Select state. req->setLocalAddr(IOAddress("255.255.255.255")); // The query has been received on the DHCPv4 server port 67. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent via the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Assign some new address for this client. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Copy hops count. resp->setHops(req->getHops()); // We want to test the case, when the server (packet filter) doesn't support // direct responses to the client which doesn't have an address yet. In // case, the server should send its response to the broadcast address. // We can control whether the current packet filter returns that its support // direct responses or not. test_config.setDirectResponse(false); // When running unit tests, the IfaceMgr is using the default Packet // Filtering class, PktFilterInet. This class does not support direct // responses to clients without address assigned. When giaddr and ciaddr // are zero and client has just got new lease, the assigned address is // carried in yiaddr. In order to send this address to the client, // server must broadcast its response. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that the response is sent to broadcast address as the // server doesn't have capability to respond directly. EXPECT_EQ("255.255.255.255", resp->getRemoteAddr().toText()); // Although the query has been sent to the broadcast address, the // server should select a unicast address on the particular interface // as a source address for the response. EXPECT_EQ("192.0.2.3", resp->getLocalAddr().toText()); // The response should be sent from the DHCPv4 server port. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // The response should be sent via the same interface through which // query has been received. EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); // We also want to test the case when the server has capability to // respond directly to the client which is not configured. Server // makes decision whether it responds directly or broadcast its // response based on the capability reported by IfaceMgr. We can // control whether the current packet filter returns that it supports // direct responses or not. test_config.setDirectResponse(true); // Now we expect that the server will send its response to the // address assigned for the client. ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); EXPECT_EQ("192.0.1.13", resp->getRemoteAddr().toText()); } // This test verifies that the destination address of the response message // is set to source address when the testing mode is enabled. // Select cases: not testing mode were tested in adjustIfaceDataSelect. TEST_F(Dhcpv4SrvTest, adjustRemoteAddressSelectSendToSourceTestingModeEnabled) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Clear client address as it hasn't got any address configured yet. req->setCiaddr(IOAddress("0.0.0.0")); // Let's clear the broadcast flag. req->setFlags(0); // This is a non-relayed message, so let's clear hops count. req->setHops(0); // The query is sent to the broadcast address in the Select state. req->setLocalAddr(IOAddress("255.255.255.255")); // The query has been received on the DHCPv4 server port 67. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent via the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote address. req->setRemoteAddr(IOAddress("192.0.2.1")); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Assign some new address for this client. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Copy hops count. resp->setHops(req->getHops()); // Disable direct responses. test_config.setDirectResponse(false); // Set the testing mode. srv_.setSendResponsesToSource(true); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that server responds to source address. EXPECT_EQ("192.0.2.1", resp->getRemoteAddr().toText()); // Enable direct responses. test_config.setDirectResponse(true); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that server still responds to source address. EXPECT_EQ("192.0.2.1", resp->getRemoteAddr().toText()); } // This test verifies that the destination address of the response message // is set to broadcast address when client set broadcast flag in its // query. Client sets this flag to indicate that it can't receive direct // responses from the server when it doesn't have its interface configured. // Server must respect broadcast flag. TEST_F(Dhcpv4SrvTest, adjustIfaceDataBroadcast) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Clear client address as it hasn't got any address configured yet. req->setCiaddr(IOAddress("0.0.0.0")); // The query is sent to the broadcast address in the Select state. req->setLocalAddr(IOAddress("255.255.255.255")); // The query has been received on the DHCPv4 server port 67. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent via the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Let's set the broadcast flag. req->setFlags(Pkt4::FLAG_BROADCAST_MASK); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Assign some new address for this client. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Server must respond to broadcast address when client desired that // by setting the broadcast flag in its request. EXPECT_EQ("255.255.255.255", resp->getRemoteAddr().toText()); // Although the query has been sent to the broadcast address, the // server should select a unicast address on the particular interface // as a source address for the response. EXPECT_EQ("192.0.2.3", resp->getLocalAddr().toText()); // The response should be sent from the DHCPv4 server port. EXPECT_EQ(DHCP4_SERVER_PORT, resp->getLocalPort()); // The response should be sent via the same interface through which // query has been received. EXPECT_EQ("eth1", resp->getIface()); EXPECT_EQ(ETH1_INDEX, resp->getIndex()); } // This test verifies that the destination address of the response message // is set to source address when the testing mode is enabled. // Broadcast case: not testing mode was tested in adjustIfaceDataBroadcast. TEST_F(Dhcpv4SrvTest, adjustRemoteAddressBroadcastSendToSourceTestingModeEnabled) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Create instance of the incoming packet. boost::shared_ptr req(new Pkt4(DHCPDISCOVER, 1234)); // Clear giaddr to simulate direct packet. req->setGiaddr(IOAddress("0.0.0.0")); // Clear client address as it hasn't got any address configured yet. req->setCiaddr(IOAddress("0.0.0.0")); // The query is sent to the broadcast address in the Select state. req->setLocalAddr(IOAddress("255.255.255.255")); // The query has been received on the DHCPv4 server port 67. req->setLocalPort(DHCP4_SERVER_PORT); // Set the interface. The response should be sent via the same interface. req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Set remote address. req->setRemoteAddr(IOAddress("192.0.2.1")); // Let's set the broadcast flag. req->setFlags(Pkt4::FLAG_BROADCAST_MASK); // Create the exchange using the req. Dhcpv4Exchange ex = createExchange(req); Pkt4Ptr resp = ex.getResponse(); // Assign some new address for this client. resp->setYiaddr(IOAddress("192.0.1.13")); // Clear the remote address. resp->setRemoteAddr(IOAddress("0.0.0.0")); // Set the testing mode. srv_.setSendResponsesToSource(true); ASSERT_NO_THROW(srv_.adjustIfaceData(ex)); // Check that server responds to source address. EXPECT_EQ("192.0.2.1", resp->getRemoteAddr().toText()); } // This test verifies that the mandatory to copy fields and options // are really copied into the response. TEST_F(Dhcpv4SrvTest, initResponse) { Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); // Set fields which must be copied query->setIface("foo"); query->setIndex(111); query->setHops(5); const HWAddr& hw = HWAddr::fromText("11:22:33:44:55:66:77:88", 10); HWAddrPtr hw_addr(new HWAddr(hw)); query->setHWAddr(hw_addr); query->setGiaddr(IOAddress("10.10.10.10")); const HWAddr& src_hw = HWAddr::fromText("e4:ce:8f:12:34:56"); HWAddrPtr src_hw_addr(new HWAddr(src_hw)); query->setLocalHWAddr(src_hw_addr); const HWAddr& dst_hw = HWAddr::fromText("e8:ab:cd:78:9a:bc"); HWAddrPtr dst_hw_addr(new HWAddr(dst_hw)); query->setRemoteHWAddr(dst_hw_addr); query->setFlags(BOOTP_BROADCAST); // Add options which must be copied // client-id echo is optional // rai echo is done in relayAgentInfoEcho // Do subnet selection option OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_SUBNET_SELECTION); ASSERT_TRUE(sbnsel_def); OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4)); ASSERT_TRUE(sbnsel); sbnsel->writeAddress(IOAddress("192.0.2.3")); query->addOption(sbnsel); // Create exchange and get Response Dhcpv4Exchange ex = createExchange(query); Pkt4Ptr response = ex.getResponse(); ASSERT_TRUE(response); // Check fields EXPECT_EQ("foo", response->getIface()); EXPECT_EQ(111, response->getIndex()); EXPECT_TRUE(response->getSiaddr().isV4Zero()); EXPECT_TRUE(response->getCiaddr().isV4Zero()); EXPECT_EQ(5, response->getHops()); EXPECT_TRUE(hw == *response->getHWAddr()); EXPECT_EQ(IOAddress("10.10.10.10"), response->getGiaddr()); EXPECT_TRUE(src_hw == *response->getLocalHWAddr()); EXPECT_TRUE(dst_hw == *response->getRemoteHWAddr()); EXPECT_TRUE(BOOTP_BROADCAST == response->getFlags()); // Check options (i.e., subnet selection option) OptionPtr resp_sbnsel = response->getOption(DHO_SUBNET_SELECTION); ASSERT_TRUE(resp_sbnsel); OptionCustomPtr resp_custom = boost::dynamic_pointer_cast(resp_sbnsel); ASSERT_TRUE(resp_custom); IOAddress subnet_addr("0.0.0.0"); ASSERT_NO_THROW(subnet_addr = resp_custom->readAddress()); EXPECT_EQ(IOAddress("192.0.2.3"), subnet_addr); } // This test verifies that the server identifier option is appended to // a specified DHCPv4 message and the server identifier is correct. TEST_F(Dhcpv4SrvTest, appendServerID) { Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); Dhcpv4Exchange ex = createExchange(query); Pkt4Ptr response = ex.getResponse(); // Set a local address. It is required by the function under test // to create the Server Identifier option. query->setLocalAddr(IOAddress("192.0.3.1")); // Append the Server Identifier. ASSERT_NO_THROW(NakedDhcpv4Srv::appendServerID(ex)); // Make sure that the option has been added. OptionPtr opt = response->getOption(DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(opt); Option4AddrLstPtr opt_server_id = boost::dynamic_pointer_cast(opt); ASSERT_TRUE(opt_server_id); // The option is represented as a list of IPv4 addresses but with // only one address added. Option4AddrLst::AddressContainer addrs = opt_server_id->getAddresses(); ASSERT_EQ(1, addrs.size()); // This address should match the local address of the packet. EXPECT_EQ("192.0.3.1", addrs[0].toText()); } // Sanity check. Verifies that both Dhcpv4Srv and its derived // class NakedDhcpv4Srv can be instantiated and destroyed. TEST_F(Dhcpv4SrvTest, basic) { // Check that the base class can be instantiated boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new Dhcpv4Srv(DHCP4_SERVER_PORT + 10000, false, false))); srv.reset(); // We have to close open sockets because further in this test we will // call the Dhcpv4Srv constructor again. This constructor will try to // set the appropriate packet filter class for IfaceMgr. This requires // that all sockets are closed. IfaceMgr::instance().closeSockets(); // Check that the derived class can be instantiated boost::scoped_ptr naked_srv; ASSERT_NO_THROW( naked_srv.reset(new NakedDhcpv4Srv(DHCP4_SERVER_PORT + 10000))); // Close sockets again for the next test. IfaceMgr::instance().closeSockets(); ASSERT_NO_THROW(naked_srv.reset(new NakedDhcpv4Srv(0))); } // This test verifies the test_send_responses_to_source_ is false by default // and sets by the KEA_TEST_SEND_RESPONSES_TO_SOURCE environment variable. TEST_F(Dhcpv4SrvTest, testSendResponsesToSource) { ASSERT_FALSE(std::getenv("KEA_TEST_SEND_RESPONSES_TO_SOURCE")); boost::scoped_ptr naked_srv; ASSERT_NO_THROW( naked_srv.reset(new NakedDhcpv4Srv(DHCP4_SERVER_PORT + 10000))); EXPECT_FALSE(naked_srv->getSendResponsesToSource()); ::setenv("KEA_TEST_SEND_RESPONSES_TO_SOURCE", "ENABLED", 1); // Do not use ASSERT as we want unsetenv to be always called. EXPECT_NO_THROW( naked_srv.reset(new NakedDhcpv4Srv(DHCP4_SERVER_PORT + 10000))); EXPECT_TRUE(naked_srv->getSendResponsesToSource()); ::unsetenv("KEA_TEST_SEND_RESPONSES_TO_SOURCE"); } // Verifies that DISCOVER message can be processed correctly, // that the OFFER message generated in response is valid and // contains necessary options. // // Note: this test focuses on the packet correctness. There // are other tests that verify correctness of the allocation // engine. See DiscoverBasic, DiscoverHint, DiscoverNoClientId // and DiscoverInvalidHint. TEST_F(Dhcpv4SrvTest, processDiscover) { testDiscoverRequest(DHCPDISCOVER); } // Verifies that REQUEST message can be processed correctly, // that the OFFER message generated in response is valid and // contains necessary options. // // Note: this test focuses on the packet correctness. There // are other tests that verify correctness of the allocation // engine. See DiscoverBasic, DiscoverHint, DiscoverNoClientId // and DiscoverInvalidHint. TEST_F(Dhcpv4SrvTest, processRequest) { testDiscoverRequest(DHCPREQUEST); } // Verifies that DHCPDISCOVERs are sanity checked correctly. // 1. They must have either hardware address or client id // 2. They must not have server id TEST_F(Dhcpv4SrvTest, sanityCheckDiscover) { NakedDhcpv4Srv srv; Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1234)); // Should throw, no hardware address or client id ASSERT_THROW_MSG(srv.processDiscover(pkt), RFCViolation, "Missing or useless client-id and no HW address" " provided in message DHCPDISCOVER"); // Add a hardware address. This should not throw. std::vector data = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr(new HWAddr(data, HTYPE_ETHER)); pkt->setHWAddr(hwaddr); ASSERT_NO_THROW(srv.processDiscover(pkt)); // Now let's make a new pkt with client-id only, it should not throw. pkt.reset(new Pkt4(DHCPDISCOVER, 1234)); pkt->addOption(generateClientId()); ASSERT_NO_THROW(srv.processDiscover(pkt)); // Now let's add a server-id. This should throw. OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(server_id_def); OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4)); server_id->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(server_id); EXPECT_THROW_MSG(srv.processDiscover(pkt), RFCViolation, "Server-id option was not expected," " but received in message DHCPDISCOVER"); } // Verifies that DHCPREQEUSTs are sanity checked correctly. // 1. They must have either hardware address or client id // 2. They must have a requested address // 3. They may or may not have a server id TEST_F(Dhcpv4SrvTest, sanityCheckRequest) { NakedDhcpv4Srv srv; Pkt4Ptr pkt(new Pkt4(DHCPREQUEST, 1234)); // Should throw, no hardware address or client id ASSERT_THROW_MSG(srv.processRequest(pkt), RFCViolation, "Missing or useless client-id and no HW address" " provided in message DHCPREQUEST"); // Add a hardware address. Should not throw. std::vector data = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr(new HWAddr(data, HTYPE_ETHER)); pkt->setHWAddr(hwaddr); EXPECT_NO_THROW(srv.processRequest(pkt)); // Now let's add a requested address. This should not throw. OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_REQUESTED_ADDRESS); ASSERT_TRUE(req_addr_def); OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4)); req_addr->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processRequest(pkt)); // Now let's make a new pkt with client-id only and an address, it should not throw. pkt.reset(new Pkt4(DHCPREQUEST, 1234)); pkt->addOption(generateClientId()); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processRequest(pkt)); // Now let's add a server-id. This should not throw. OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(server_id_def); OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4)); server_id->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(server_id); EXPECT_NO_THROW(srv.processRequest(pkt)); } // Verifies that DHCPDECLINEs are sanity checked correctly. // 1. They must have either hardware address or client id // 2. They must have a requested address // 3. They may or may not have a server id TEST_F(Dhcpv4SrvTest, sanityCheckDecline) { NakedDhcpv4Srv srv; Pkt4Ptr pkt(new Pkt4(DHCPDECLINE, 1234)); // Should throw, no hardware address or client id ASSERT_THROW_MSG(srv.processDecline(pkt), RFCViolation, "Missing or useless client-id and no HW address" " provided in message DHCPDECLINE"); // Add a hardware address. Should throw because of missing address. std::vector data = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr(new HWAddr(data, HTYPE_ETHER)); pkt->setHWAddr(hwaddr); ASSERT_THROW_MSG(srv.processDecline(pkt), RFCViolation, "Mandatory 'Requested IP address' option missing in DHCPDECLINE" " sent from [hwtype=1 00:fe:fe:fe:fe:fe], cid=[no info], tid=0x4d2"); // Now let's add a requested address. This should not throw. OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_REQUESTED_ADDRESS); ASSERT_TRUE(req_addr_def); OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4)); req_addr->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processDecline(pkt)); // Now let's make a new pkt with client-id only and an address, it should not throw. pkt.reset(new Pkt4(DHCPDECLINE, 1234)); pkt->addOption(generateClientId()); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processDecline(pkt)); // Now let's add a server-id. This should not throw. OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(server_id_def); OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4)); server_id->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(server_id); EXPECT_NO_THROW(srv.processDecline(pkt)); } // Verifies that DHCPRELEASEs are sanity checked correctly. // 1. They must have either hardware address or client id // 2. They may or may not have a server id TEST_F(Dhcpv4SrvTest, sanityCheckRelease) { NakedDhcpv4Srv srv; Pkt4Ptr pkt(new Pkt4(DHCPRELEASE, 1234)); // Should throw, no hardware address or client id ASSERT_THROW_MSG(srv.processRelease(pkt), RFCViolation, "Missing or useless client-id and no HW address" " provided in message DHCPRELEASE"); // Add a hardware address. Should not throw. std::vector data = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr(new HWAddr(data, HTYPE_ETHER)); pkt->setHWAddr(hwaddr); EXPECT_NO_THROW(srv.processRelease(pkt)); // Make a new pkt with client-id only. Should not throw. pkt.reset(new Pkt4(DHCPRELEASE, 1234)); pkt->addOption(generateClientId()); ASSERT_NO_THROW(srv.processRelease(pkt)); // Now let's add a server-id. This should not throw. OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(server_id_def); OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4)); server_id->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(server_id); EXPECT_NO_THROW(srv.processRelease(pkt)); } // Verifies that DHCPINFORMs are sanity checked correctly. // 1. They must have either hardware address or client id // 2. They may or may not have requested address // 3. They may or may not have a server id TEST_F(Dhcpv4SrvTest, sanityCheckInform) { NakedDhcpv4Srv srv; Pkt4Ptr pkt(new Pkt4(DHCPINFORM, 1234)); // Should throw, no hardware address or client id ASSERT_THROW_MSG(srv.processInform(pkt), RFCViolation, "Missing or useless client-id and no HW address" " provided in message DHCPINFORM"); // Add a hardware address. Should not throw. std::vector data = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr(new HWAddr(data, HTYPE_ETHER)); pkt->setHWAddr(hwaddr); ASSERT_NO_THROW(srv.processInform(pkt)); // Now let's add a requested address. This should not throw. OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_REQUESTED_ADDRESS); ASSERT_TRUE(req_addr_def); OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4)); req_addr->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processInform(pkt)); // Now let's make a new pkt with client-id only and an address, it should not throw. pkt.reset(new Pkt4(DHCPINFORM, 1234)); pkt->addOption(generateClientId()); pkt->addOption(req_addr); ASSERT_NO_THROW(srv.processInform(pkt)); // Now let's add a server-id. This should not throw. OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER); ASSERT_TRUE(server_id_def); OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4)); server_id->writeAddress(IOAddress("192.0.2.3")); pkt->addOption(server_id); EXPECT_NO_THROW(srv.processInform(pkt)); } // This test verifies that incoming DISCOVER can be handled properly, that an // OFFER is generated, that the response has an address and that address // really belongs to the configured pool. // // constructed very simple DISCOVER message with: // - client-id option // // expected returned OFFER message: // - copy of client-id // - server-id // - offered address TEST_F(Dhcpv4SrvTest, DiscoverBasic) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(offer, subnet_, true, true); // Check identifiers checkServerId(offer, srv->getServerID()); checkClientId(offer, clientid); } // This test verifies that OFFERs return expected valid lifetimes. TEST_F(Dhcpv4SrvTest, DiscoverValidLifetime) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); // Recreate subnet Triplet unspecified; Triplet valid_lft(500, 1000, 1500); subnet_.reset(new Subnet4(IOAddress("192.0.2.0"), 24, unspecified, unspecified, valid_lft)); pool_ = Pool4Ptr(new Pool4(IOAddress("192.0.2.100"), IOAddress("192.0.2.110"))); subnet_->addPool(pool_); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(subnet_); CfgMgr::instance().commit(); // Struct for describing an individual lifetime test scenario struct LifetimeTest { // logged test description std::string description_; // lifetime hint (0 means not send dhcp-lease-time option) uint32_t hint; // expected returned value uint32_t expected; }; // Test scenarios std::vector tests = { { "default valid lifetime", 0, 1000 }, { "specified valid lifetime", 1001, 1001 }, { "too small valid lifetime", 100, 500 }, { "too large valid lifetime", 2000, 1500 } }; // Iterate over the test scenarios. for (auto test : tests) { SCOPED_TRACE(test.description_); // Create a discover packet to use Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Add dhcp-lease-time option. if (test.hint) { OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, test.hint)); dis->addOption(opt); } // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Check that address was returned from proper range, that its lease // lifetime is correct and has the expected value. checkAddressParams(offer, subnet_, false, false, test.expected); // Check identifiers checkServerId(offer, srv->getServerID()); checkClientId(offer, clientid); } } // Check that option 58 and 59 are only included if they were specified // (and calculate-tee-times = false) and the values are sane: // T2 is less than valid lft; T1 is less than T2 (if given) or valid // lft if T2 is not given. TEST_F(Dhcpv4SrvTest, DiscoverTimers) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); // Recreate subnet Triplet unspecified; Triplet valid_lft(1000); subnet_.reset(new Subnet4(IOAddress("192.0.2.0"), 24, unspecified, unspecified, valid_lft)); pool_ = Pool4Ptr(new Pool4(IOAddress("192.0.2.100"), IOAddress("192.0.2.110"))); subnet_->addPool(pool_); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(subnet_); CfgMgr::instance().commit(); // Struct for describing an individual timer test scenario struct TimerTest { // logged test description std::string description_; // configured value for subnet's T1 Triplet cfg_t1_; // configured value for subnet's T1 Triplet cfg_t2_; // True if Offer should contain Subnet's T1 value bool exp_t1_; // True if Offer should contain Subnet's T2 value bool exp_t2_; }; // Convenience constants bool T1 = true; bool T2 = true; // Test scenarios std::vector tests = { { "T1:unspecified, T2:unspecified", unspecified, unspecified, // Client should neither. !T1, !T2 }, { "T1 unspecified, T2 < VALID", unspecified, valid_lft - 1, // Client should only get T2. !T1, T2 }, { "T1:unspecified, T2 = VALID", unspecified, valid_lft, // Client should get neither. !T1, !T2 }, { "T1:unspecified, T2 > VALID", unspecified, valid_lft + 1, // Client should get neither. !T1, !T2 }, { "T1 < VALID, T2:unspecified", valid_lft - 1, unspecified, // Client should only get T1. T1, !T2 }, { "T1 = VALID, T2:unspecified", valid_lft, unspecified, // Client should get neither. !T1, !T2 }, { "T1 > VALID, T2:unspecified", valid_lft + 1, unspecified, // Client should get neither. !T1, !T2 }, { "T1 < T2 < VALID", valid_lft - 2, valid_lft - 1, // Client should get both. T1, T2 }, { "T1 = T2 < VALID", valid_lft - 1, valid_lft - 1, // Client should only get T2. !T1, T2 }, { "T1 > T2 < VALID", valid_lft - 1, valid_lft - 2, // Client should only get T2. !T1, T2 }, { "T1 = T2 = VALID", valid_lft, valid_lft, // Client should get neither. !T1, !T2 }, { "T1 > VALID < T2, T2 > VALID", valid_lft + 1, valid_lft + 2, // Client should get neither. !T1, !T2 } }; // Create a discover packet to use Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Iterate over the test scenarios. for (auto test = tests.begin(); test != tests.end(); ++test) { { SCOPED_TRACE((*test).description_); // Configure subnet's timer values subnet_->setT1((*test).cfg_t1_); subnet_->setT2((*test).cfg_t2_); // Discover/Offer exchange with the server Pkt4Ptr offer = srv->processDiscover(dis); // Verify we have an offer checkResponse(offer, DHCPOFFER, 1234); // Verify the timers are as expected. checkAddressParams(offer, subnet_, (*test).exp_t1_, (*test).exp_t2_); } } } // Check that option 58 and 59 are included when calculate-tee-times // is enabled, but only when they are not explicitly specified via // renew-timer and rebinding-timer. This test does not check whether // the subnet's for t1-percent and t2-percent are valid, as this is // enforced by parsing and tested elsewhere. TEST_F(Dhcpv4SrvTest, calculateTeeTimers) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); // Recreate subnet Triplet unspecified; Triplet valid_lft(1000); subnet_.reset(new Subnet4(IOAddress("192.0.2.0"), 24, unspecified, unspecified, valid_lft)); pool_ = Pool4Ptr(new Pool4(IOAddress("192.0.2.100"), IOAddress("192.0.2.110"))); subnet_->addPool(pool_); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(subnet_); CfgMgr::instance().commit(); // Struct for describing an individual timer test scenario struct TimerTest { // logged test description std::string description_; // configured value for subnet's T1 Triplet cfg_t1_; // configured value for subnet's T1 Triplet cfg_t2_; // configured value for subnet's t1_percent. double t1_percent_; // configured value for subnet's t2_percent. double t2_percent_; // expected value for T1 in server response. // A value of 0 means server should not have sent T1. uint32_t t1_exp_value_; // expected value for T2 in server response. // A value of 0 means server should not have sent T2. uint32_t t2_exp_value_; }; // Convenience constant uint32_t not_expected = 0; // Test scenarios std::vector tests = { { "T1 and T2 calculated", unspecified, unspecified, 0.4, 0.8, 400, 800 }, { "T1 and T2 specified insane", valid_lft + 1, valid_lft + 2, 0.4, 0.8, not_expected, not_expected }, { "T1 should be calculated, T2 specified", unspecified, valid_lft - 1, 0.4, 0.8, 400, valid_lft - 1 }, { "T1 specified, T2 should be calculated", 299, unspecified, 0.4, 0.8, 299, 800 }, { "T1 specified > T2, T2 should be calculated", valid_lft - 1, unspecified, 0.4, 0.8, not_expected, 800 } }; // Calculation is enabled for all the scenarios. subnet_->setCalculateTeeTimes(true); // Create a discover packet to use Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Iterate over the test scenarios. for (auto test = tests.begin(); test != tests.end(); ++test) { { SCOPED_TRACE((*test).description_); // Configure subnet's timer values subnet_->setT1((*test).cfg_t1_); subnet_->setT2((*test).cfg_t2_); subnet_->setT1Percent((*test).t1_percent_); subnet_->setT2Percent((*test).t2_percent_); // Discover/Offer exchange with the server Pkt4Ptr offer = srv->processDiscover(dis); // Verify we have an offer checkResponse(offer, DHCPOFFER, 1234); // Check T1 timer OptionUint32Ptr opt = boost::dynamic_pointer_cast (offer->getOption(DHO_DHCP_RENEWAL_TIME)); if ((*test).t1_exp_value_ == not_expected) { EXPECT_FALSE(opt) << "T1 present and shouldn't be"; } else { ASSERT_TRUE(opt) << "Required T1 option missing or it has" " an unexpected type"; EXPECT_EQ(opt->getValue(), (*test).t1_exp_value_); } // Check T2 timer opt = boost::dynamic_pointer_cast (offer->getOption(DHO_DHCP_REBINDING_TIME)); if ((*test).t2_exp_value_ == not_expected) { EXPECT_FALSE(opt) << "T2 present and shouldn't be"; } else { ASSERT_TRUE(opt) << "Required T2 option missing or it has" " an unexpected type"; EXPECT_EQ(opt->getValue(), (*test).t2_exp_value_); } } } } // This test verifies that incoming DISCOVER can be handled properly, that an // OFFER is generated, that the response has an address and that address // really belongs to the configured pool. // // constructed very simple DISCOVER message with: // - client-id option // - address set to specific value as hint, but that hint is invalid // // expected returned OFFER message: // - copy of client-id // - server-id // - offered address (!= hint) TEST_F(Dhcpv4SrvTest, DiscoverInvalidHint) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); IOAddress hint("10.1.2.3"); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.107")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setYiaddr(hint); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(offer, subnet_, true, true); EXPECT_NE(offer->getYiaddr(), hint); // Check identifiers checkServerId(offer, srv->getServerID()); checkClientId(offer, clientid); } /// @todo: Add a test that client sends hint that is in pool, but currently /// being used by a different client. // This test checks that the server is offering different addresses to different // clients in OFFERs. Please note that OFFER is not a guarantee that such // an address will be assigned. Had the pool was very small and contained only // 2 addresses, the third client would get the same offer as the first one // and this is a correct behavior. It is REQUEST that will fail for the third // client. OFFER is basically saying "if you send me a request, you will // probably get an address like this" (there are no guarantees). TEST_F(Dhcpv4SrvTest, ManyDiscovers) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); Pkt4Ptr dis1 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); Pkt4Ptr dis2 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 2345)); Pkt4Ptr dis3 = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 3456)); dis1->setRemoteAddr(IOAddress("192.0.2.1")); dis2->setRemoteAddr(IOAddress("192.0.2.2")); dis3->setRemoteAddr(IOAddress("192.0.2.3")); // Assign interfaces dis1->setIface("eth1"); dis1->setIndex(ETH1_INDEX); dis2->setIface("eth1"); dis2->setIndex(ETH1_INDEX); dis3->setIface("eth1"); dis3->setIndex(ETH1_INDEX); // Different client-id sizes OptionPtr clientid1 = generateClientId(4); // length 4 OptionPtr clientid2 = generateClientId(5); // length 5 OptionPtr clientid3 = generateClientId(6); // length 6 dis1->addOption(clientid1); dis2->addOption(clientid2); dis3->addOption(clientid3); // Pass it to the server and get an offer Pkt4Ptr offer1 = srv->processDiscover(dis1); Pkt4Ptr offer2 = srv->processDiscover(dis2); Pkt4Ptr offer3 = srv->processDiscover(dis3); // Check if we get response at all checkResponse(offer1, DHCPOFFER, 1234); checkResponse(offer2, DHCPOFFER, 2345); checkResponse(offer3, DHCPOFFER, 3456); IOAddress addr1 = offer1->getYiaddr(); IOAddress addr2 = offer2->getYiaddr(); IOAddress addr3 = offer3->getYiaddr(); // Check that the assigned address is indeed from the configured pool checkAddressParams(offer1, subnet_, true, true); checkAddressParams(offer2, subnet_, true, true); checkAddressParams(offer3, subnet_, true, true); // Check server-ids checkServerId(offer1, srv->getServerID()); checkServerId(offer2, srv->getServerID()); checkServerId(offer3, srv->getServerID()); checkClientId(offer1, clientid1); checkClientId(offer2, clientid2); checkClientId(offer3, clientid3); // Finally check that the addresses offered are different EXPECT_NE(addr1, addr2); EXPECT_NE(addr2, addr3); EXPECT_NE(addr3, addr1); cout << "Offered address to client1=" << addr1 << endl; cout << "Offered address to client2=" << addr2 << endl; cout << "Offered address to client3=" << addr3 << endl; } // Checks whether echoing back client-id is controllable, i.e. // whether the server obeys echo-client-id and sends (or not) // client-id TEST_F(Dhcpv4SrvTest, discoverEchoClientId) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Pass it to the server and get an offer Pkt4Ptr offer = srv.processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); checkClientId(offer, clientid); ConstSrvConfigPtr cfg = CfgMgr::instance().getCurrentCfg(); const Subnet4Collection* subnets = cfg->getCfgSubnets4()->getAll(); ASSERT_EQ(1, subnets->size()); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(*subnets->begin()); CfgMgr::instance().getStagingCfg()->setEchoClientId(false); CfgMgr::instance().commit(); offer = srv.processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); checkClientId(offer, clientid); } // This test verifies that incoming DISCOVER can reuse an existing lease. TEST_F(Dhcpv4SrvTest, DiscoverCache) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); // Enable lease reuse. subnet_->setCacheThreshold(.1); const IOAddress addr("192.0.2.106"); const uint32_t temp_valid = subnet_->getValid(); const int delta = 100; const time_t temp_timestamp = time(NULL) - delta; // Generate client-id also sets client_id_ member OptionPtr clientid = generateClientId(); // Check that the address we are about to use is indeed in pool ASSERT_TRUE(subnet_->inPool(Lease::TYPE_V4, addr)); // let's create a lease and put it in the LeaseMgr uint8_t hwaddr2_data[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr2(new HWAddr(hwaddr2_data, sizeof(hwaddr2_data), HTYPE_ETHER)); Lease4Ptr used(new Lease4(IOAddress("192.0.2.106"), hwaddr2, &client_id_->getDuid()[0], client_id_->getDuid().size(), temp_valid, temp_timestamp, subnet_->getID())); ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used)); // Check that the lease is really in the database Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr); ASSERT_TRUE(l); // Check that preferred, valid and cltt really set. // Constructed lease looks as if it was assigned 100 seconds ago EXPECT_EQ(l->valid_lft_, temp_valid); EXPECT_EQ(l->cltt_, temp_timestamp); // Let's create a DISCOVER Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress(addr)); dis->addOption(clientid); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); dis->setHWAddr(hwaddr2); // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Check valid lifetime (temp_valid - age) OptionUint32Ptr opt = boost::dynamic_pointer_cast< OptionUint32>(offer->getOption(DHO_DHCP_LEASE_TIME)); ASSERT_TRUE(opt); EXPECT_GE(subnet_->getValid() - delta, opt->getValue()); EXPECT_LE(subnet_->getValid() - delta - 10, opt->getValue()); // Check address EXPECT_EQ(addr, offer->getYiaddr()); // Check T1 opt = boost::dynamic_pointer_cast< OptionUint32>(offer->getOption(DHO_DHCP_RENEWAL_TIME)); ASSERT_TRUE(opt); EXPECT_EQ(opt->getValue(), subnet_->getT1()); // Check T2 opt = boost::dynamic_pointer_cast< OptionUint32>(offer->getOption(DHO_DHCP_REBINDING_TIME)); ASSERT_TRUE(opt); EXPECT_EQ(opt->getValue(), subnet_->getT2()); // Check identifiers checkServerId(offer, srv->getServerID()); checkClientId(offer, clientid); } // Check that option 58 and 59 are not included if they are not specified. TEST_F(Dhcpv4SrvTest, RequestNoTimers) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); Pkt4Ptr req = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234)); req->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); req->addOption(clientid); req->setIface("eth1"); req->setIndex(ETH1_INDEX); // Recreate a subnet but set T1 and T2 to "unspecified". subnet_.reset(new Subnet4(IOAddress("192.0.2.0"), 24, Triplet(), Triplet(), 3000)); pool_ = Pool4Ptr(new Pool4(IOAddress("192.0.2.100"), IOAddress("192.0.2.110"))); subnet_->addPool(pool_); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(subnet_); CfgMgr::instance().commit(); // Pass it to the server and get an ACK. Pkt4Ptr ack = srv->processRequest(req); // Check if we get response at all checkResponse(ack, DHCPACK, 1234); // T1 and T2 timers must not be present. checkAddressParams(ack, subnet_, false, false); // Check identifiers checkServerId(ack, srv->getServerID()); checkClientId(ack, clientid); } // Checks whether echoing back client-id is controllable TEST_F(Dhcpv4SrvTest, requestEchoClientId) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Pass it to the server and get ACK Pkt4Ptr ack = srv.processRequest(dis); // Check if we get response at all checkResponse(ack, DHCPACK, 1234); checkClientId(ack, clientid); ConstSrvConfigPtr cfg = CfgMgr::instance().getCurrentCfg(); const Subnet4Collection* subnets = cfg->getCfgSubnets4()->getAll(); ASSERT_EQ(1, subnets->size()); CfgMgr::instance().clear(); CfgMgr::instance().getStagingCfg()->getCfgSubnets4()->add(*subnets->begin()); CfgMgr::instance().getStagingCfg()->setEchoClientId(false); CfgMgr::instance().commit(); ack = srv.processRequest(dis); // Check if we get response at all checkResponse(ack, DHCPACK, 1234); checkClientId(ack, clientid); } // This test verifies that incoming (positive) REQUEST/Renewing can be handled properly, that a // REPLY is generated, that the response has an address and that address // really belongs to the configured pool and that lease is actually renewed. // // expected: // - returned REPLY message has copy of client-id // - returned REPLY message has server-id // - returned REPLY message has IA that includes IAADDR // - lease is actually renewed in LeaseMgr TEST_F(Dhcpv4SrvTest, RenewBasic) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); const IOAddress addr("192.0.2.106"); const uint32_t temp_valid = 100; const time_t temp_timestamp = time(NULL) - 10; // Generate client-id also sets client_id_ member OptionPtr clientid = generateClientId(); // Check that the address we are about to use is indeed in pool ASSERT_TRUE(subnet_->inPool(Lease::TYPE_V4, addr)); // let's create a lease and put it in the LeaseMgr uint8_t hwaddr2_data[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr2(new HWAddr(hwaddr2_data, sizeof(hwaddr2_data), HTYPE_ETHER)); Lease4Ptr used(new Lease4(IOAddress("192.0.2.106"), hwaddr2, &client_id_->getDuid()[0], client_id_->getDuid().size(), temp_valid, temp_timestamp, subnet_->getID())); ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used)); // Check that the lease is really in the database Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr); ASSERT_TRUE(l); // Check that preferred, valid and cltt really set. // Constructed lease looks as if it was assigned 10 seconds ago EXPECT_EQ(l->valid_lft_, temp_valid); EXPECT_EQ(l->cltt_, temp_timestamp); // Let's create a RENEW Pkt4Ptr req = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234)); req->setRemoteAddr(IOAddress(addr)); req->setYiaddr(addr); req->setCiaddr(addr); // client's address req->setIface("eth0"); req->setIndex(ETH0_INDEX); req->setHWAddr(hwaddr2); req->addOption(clientid); req->addOption(srv->getServerID()); // Pass it to the server and hope for a REPLY Pkt4Ptr ack = srv->processRequest(req); // Check if we get response at all checkResponse(ack, DHCPACK, 1234); EXPECT_EQ(addr, ack->getYiaddr()); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(ack, subnet_, true, true); // Check identifiers checkServerId(ack, srv->getServerID()); checkClientId(ack, clientid); // Check that the lease is really in the database l = checkLease(ack, clientid, req->getHWAddr(), addr); ASSERT_TRUE(l); // Check that preferred, valid and cltt were really updated EXPECT_EQ(l->valid_lft_, subnet_->getValid()); // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors int32_t cltt = static_cast(l->cltt_); int32_t expected = static_cast(time(NULL)); // Equality or difference by 1 between cltt and expected is ok. EXPECT_GE(1, abs(cltt - expected)); Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(addr); EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(lease)); } // Renew*Lifetime common code. namespace { struct ctx { Dhcpv4SrvTest* test; NakedDhcpv4Srv* srv; const IOAddress& addr; const uint32_t temp_valid; const time_t temp_timestamp; OptionPtr clientid; HWAddrPtr hwaddr; Lease4Ptr used; Lease4Ptr l; OptionPtr opt; Pkt4Ptr req; Pkt4Ptr ack; }; void prepare(struct ctx& c) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); // Check that the address we are about to use is indeed in pool ASSERT_TRUE(c.test->subnet_->inPool(Lease::TYPE_V4, c.addr)); // let's create a lease and put it in the LeaseMgr uint8_t hwaddr_data[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; c.hwaddr.reset(new HWAddr(hwaddr_data, sizeof(hwaddr_data), HTYPE_ETHER)); c.used.reset(new Lease4(c.addr, c.hwaddr, &c.test->client_id_->getDuid()[0], c.test->client_id_->getDuid().size(), c.temp_valid, c.temp_timestamp, c.test->subnet_->getID())); ASSERT_TRUE(LeaseMgrFactory::instance().addLease(c.used)); // Check that the lease is really in the database c.l = LeaseMgrFactory::instance().getLease4(c.addr); ASSERT_TRUE(c.l); // Check that valid and cltt really set. // Constructed lease looks as if it was assigned 10 seconds ago EXPECT_EQ(c.l->valid_lft_, c.temp_valid); EXPECT_EQ(c.l->cltt_, c.temp_timestamp); // Set the valid lifetime interval. c.test->subnet_->setValid(Triplet(2000, 3000, 4000)); // Let's create a RENEW c.req.reset(new Pkt4(DHCPREQUEST, 1234)); c.req->setRemoteAddr(IOAddress(c.addr)); c.req->setYiaddr(c.addr); c.req->setCiaddr(c.addr); // client's address c.req->setIface("eth0"); c.req->setIndex(ETH0_INDEX); c.req->setHWAddr(c.hwaddr); c.req->addOption(c.clientid); c.req->addOption(c.srv->getServerID()); if (c.opt) { c.req->addOption(c.opt); } // Pass it to the server and hope for a REPLY c.ack = c.srv->processRequest(c.req); // Check if we get response at all c.test->checkResponse(c.ack, DHCPACK, 1234); EXPECT_EQ(c.addr, c.ack->getYiaddr()); // Check identifiers c.test->checkServerId(c.ack, c.srv->getServerID()); c.test->checkClientId(c.ack, c.clientid); // Check that the lease is really in the database c.l = c.test->checkLease(c.ack, c.clientid, c.req->getHWAddr(), c.addr); ASSERT_TRUE(c.l); } // This test verifies that renewal returns the default valid lifetime // when the client does not specify a value. TEST_F(Dhcpv4SrvTest, RenewDefaultLifetime) { boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); struct ctx c = { this, // test srv.get(), // srv IOAddress("192.0.2.106"), // addr 100, // temp_valid time(NULL) - 10, // temp_timestamp // Generate client-id also sets client_id_ member generateClientId(), // clientid HWAddrPtr(), // hwaddr Lease4Ptr(), // used Lease4Ptr(), // l OptionPtr(), // opt Pkt4Ptr(), // req Pkt4Ptr() // acka }; prepare(c); // There is no valid lifetime hint so the default will be returned. // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(c.ack, subnet_, true, true, subnet_->getValid()); // Check that valid and cltt were really updated EXPECT_EQ(c.l->valid_lft_, subnet_->getValid()); // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors int32_t cltt = static_cast(c.l->cltt_); int32_t expected = static_cast(time(NULL)); // Equality or difference by 1 between cltt and expected is ok. EXPECT_GE(1, abs(cltt - expected)); Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(c.addr); EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(lease)); } // This test verifies that renewal returns the specified valid lifetime // when the client adds an in-bound hint in the DISCOVER. TEST_F(Dhcpv4SrvTest, RenewHintLifetime) { boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); struct ctx c = { this, // test srv.get(), // srv IOAddress("192.0.2.106"), // addr 100, // temp_valid time(NULL) - 10, // temp_timestamp // Generate client-id also sets client_id_ member generateClientId(), // clientid HWAddrPtr(), // hwaddr Lease4Ptr(), // used Lease4Ptr(), // l OptionPtr(), // opt Pkt4Ptr(), // req Pkt4Ptr() // acka }; // Add a dhcp-lease-time with an in-bound valid lifetime hint // which will be returned in the OFFER. uint32_t hint = 3001; c.opt.reset(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, hint)); prepare(c); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(c.ack, subnet_, true, true, hint); // Check that valid and cltt were really updated EXPECT_EQ(c.l->valid_lft_, hint); // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors int32_t cltt = static_cast(c.l->cltt_); int32_t expected = static_cast(time(NULL)); // Equality or difference by 1 between cltt and expected is ok. EXPECT_GE(1, abs(cltt - expected)); Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(c.addr); EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(lease)); } // This test verifies that renewal returns the min valid lifetime // when the client adds a too small hint in the DISCOVER. TEST_F(Dhcpv4SrvTest, RenewMinLifetime) { boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); struct ctx c = { this, // test srv.get(), // srv IOAddress("192.0.2.106"), // addr 100, // temp_valid time(NULL) - 10, // temp_timestamp // Generate client-id also sets client_id_ member generateClientId(), // clientid HWAddrPtr(), // hwaddr Lease4Ptr(), // used Lease4Ptr(), // l OptionPtr(), // opt Pkt4Ptr(), // req Pkt4Ptr() // acka }; // Add a dhcp-lease-time with too small valid lifetime hint. // The min valid lifetime will be returned in the OFFER. c.opt.reset(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 1000)); prepare(c); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly // Note that T2 should be false for a reason which does not matter... checkAddressParams(c.ack, subnet_, true, false, subnet_->getValid().getMin()); // Check that valid and cltt were really updated EXPECT_EQ(c.l->valid_lft_, subnet_->getValid().getMin()); // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors int32_t cltt = static_cast(c.l->cltt_); int32_t expected = static_cast(time(NULL)); // Equality or difference by 1 between cltt and expected is ok. EXPECT_GE(1, abs(cltt - expected)); Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(c.addr); EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(lease)); } // This test verifies that renewal returns the max valid lifetime // when the client adds a too large hint in the DISCOVER. TEST_F(Dhcpv4SrvTest, RenewMaxLifetime) { boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); struct ctx c = { this, // test srv.get(), // srv IOAddress("192.0.2.106"), // addr 100, // temp_valid time(NULL) - 10, // temp_timestamp // Generate client-id also sets client_id_ member generateClientId(), // clientid HWAddrPtr(), // hwaddr Lease4Ptr(), // used Lease4Ptr(), // l OptionPtr(), // opt Pkt4Ptr(), // req Pkt4Ptr() // acka }; // Add a dhcp-lease-time with too large valid lifetime hint. // The max valid lifetime will be returned in the OFFER. c.opt.reset(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 5000)); prepare(c); // Check that address was returned from proper range, that its lease // lifetime is correct, that T1 and T2 are returned properly checkAddressParams(c.ack, subnet_, true, true, subnet_->getValid().getMax()); // Check that valid and cltt were really updated EXPECT_EQ(c.l->valid_lft_, subnet_->getValid().getMax()); // Checking for CLTT is a bit tricky if we want to avoid off by 1 errors int32_t cltt = static_cast(c.l->cltt_); int32_t expected = static_cast(time(NULL)); // Equality or difference by 1 between cltt and expected is ok. EXPECT_GE(1, abs(cltt - expected)); Lease4Ptr lease = LeaseMgrFactory::instance().getLease4(c.addr); EXPECT_TRUE(LeaseMgrFactory::instance().deleteLease(lease)); } } // end of Renew*Lifetime // This test verifies that incoming RENEW can reuse an existing lease. TEST_F(Dhcpv4SrvTest, RenewCache) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); // Enable lease reuse. subnet_->setCacheThreshold(.1); const IOAddress addr("192.0.2.106"); const uint32_t temp_valid = subnet_->getValid(); const int delta = 100; const time_t temp_timestamp = time(NULL) - delta; // Generate client-id also sets client_id_ member OptionPtr clientid = generateClientId(); // Check that the address we are about to use is indeed in pool ASSERT_TRUE(subnet_->inPool(Lease::TYPE_V4, addr)); // let's create a lease and put it in the LeaseMgr uint8_t hwaddr2_data[] = { 0, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe}; HWAddrPtr hwaddr2(new HWAddr(hwaddr2_data, sizeof(hwaddr2_data), HTYPE_ETHER)); Lease4Ptr used(new Lease4(IOAddress("192.0.2.106"), hwaddr2, &client_id_->getDuid()[0], client_id_->getDuid().size(), temp_valid, temp_timestamp, subnet_->getID())); ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used)); // Check that the lease is really in the database Lease4Ptr l = LeaseMgrFactory::instance().getLease4(addr); ASSERT_TRUE(l); // Check that preferred, valid and cltt really set. // Constructed lease looks as if it was assigned 100 seconds ago EXPECT_EQ(l->valid_lft_, temp_valid); EXPECT_EQ(l->cltt_, temp_timestamp); // Let's create a RENEW Pkt4Ptr req = Pkt4Ptr(new Pkt4(DHCPREQUEST, 1234)); req->setRemoteAddr(IOAddress(addr)); req->setYiaddr(addr); req->setCiaddr(addr); // client's address req->setIface("eth0"); req->setIndex(ETH0_INDEX); req->addOption(clientid); req->setHWAddr(hwaddr2); // Pass it to the server and hope for a REPLY Pkt4Ptr ack = srv->processRequest(req); // Check if we get response at all checkResponse(ack, DHCPACK, 1234); // Check valid lifetime (temp_valid - age) OptionUint32Ptr opt = boost::dynamic_pointer_cast< OptionUint32>(ack->getOption(DHO_DHCP_LEASE_TIME)); ASSERT_TRUE(opt); EXPECT_GE(subnet_->getValid() - delta, opt->getValue()); EXPECT_LE(subnet_->getValid() - delta - 10, opt->getValue()); // Check address EXPECT_EQ(addr, ack->getYiaddr()); // Check T1 opt = boost::dynamic_pointer_cast< OptionUint32>(ack->getOption(DHO_DHCP_RENEWAL_TIME)); ASSERT_TRUE(opt); EXPECT_EQ(opt->getValue(), subnet_->getT1()); // Check T2 opt = boost::dynamic_pointer_cast< OptionUint32>(ack->getOption(DHO_DHCP_REBINDING_TIME)); ASSERT_TRUE(opt); EXPECT_EQ(opt->getValue(), subnet_->getT2()); // Check identifiers checkServerId(ack, srv->getServerID()); checkClientId(ack, clientid); // Check that the lease is really in the database Lease4Ptr lease = checkLease(ack, clientid, req->getHWAddr(), addr); ASSERT_TRUE(lease); // Check that the lease was not updated EXPECT_EQ(temp_timestamp, lease->cltt_); } // Exercises Dhcpv4Srv::buildCfgOptionList(). TEST_F(Dhcpv4SrvTest, buildCfgOptionsList) { configureServerIdentifier(); IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); Pkt4Ptr query(new Pkt4(DHCPREQUEST, 1234)); query->addOption(generateClientId()); query->setHWAddr(generateHWAddr(6)); query->setIface("eth0"); query->setIndex(ETH0_INDEX); { SCOPED_TRACE("Pool value"); // Server id should come from subnet2's first pool. buildCfgOptionTest(IOAddress("192.0.2.254"), query, IOAddress("192.0.2.101"), IOAddress("192.0.2.254")); } { SCOPED_TRACE("Subnet value"); // Server id should come from subnet3. buildCfgOptionTest(IOAddress("192.0.3.254"), query, IOAddress("192.0.3.101"), IOAddress("192.0.3.254")); } { SCOPED_TRACE("Shared-network value"); // Server id should come from subnet4's shared-network. buildCfgOptionTest(IOAddress("192.0.4.254"), query, IOAddress("192.0.4.101"), IOAddress("192.0.4.254")); } { SCOPED_TRACE("Client-class value"); Pkt4Ptr query_with_classes(new Pkt4(DHCPREQUEST, 1234)); query_with_classes->addOption(generateClientId()); query_with_classes->setHWAddr(generateHWAddr(6)); query_with_classes->setIface("eth0"); query_with_classes->setIndex(ETH0_INDEX); query_with_classes->addClass("foo"); // Server id should come from subnet5's client-class value. buildCfgOptionTest(IOAddress("192.0.5.254"), query_with_classes, IOAddress("192.0.5.101"), IOAddress("192.0.5.254")); } { SCOPED_TRACE("Global value if client class does not define it"); Pkt4Ptr query_with_classes(new Pkt4(DHCPREQUEST, 1234)); query_with_classes->addOption(generateClientId()); query_with_classes->setHWAddr(generateHWAddr(6)); query_with_classes->setIface("eth0"); query_with_classes->setIndex(ETH0_INDEX); query_with_classes->addClass("bar"); // Server id should be global value as subnet6's client-class does not define it. buildCfgOptionTest(IOAddress("10.0.0.254"), query_with_classes, IOAddress("192.0.6.101"), IOAddress("192.0.6.100")); } { SCOPED_TRACE("Global value if client class does not define any option"); Pkt4Ptr query_with_classes(new Pkt4(DHCPREQUEST, 1234)); query_with_classes->addOption(generateClientId()); query_with_classes->setHWAddr(generateHWAddr(6)); query_with_classes->setIface("eth0"); query_with_classes->setIndex(ETH0_INDEX); query_with_classes->addClass("xyz"); // Server id should be global value as subnet7's client-class does not define any option. buildCfgOptionTest(IOAddress("10.0.0.254"), query_with_classes, IOAddress("192.0.7.101"), IOAddress("192.0.7.100")); } { SCOPED_TRACE("Global value"); // Server id should be global value as lease is from subnet2's second pool. buildCfgOptionTest(IOAddress("10.0.0.254"), query, IOAddress("192.0.2.201"), IOAddress("10.0.0.254")); } } // This test verifies that the logic which matches server identifier in the // received message with server identifiers used by a server works correctly: // - a message with no server identifier is accepted, // - a message with a server identifier which matches one of the server // identifiers used by a server is accepted, // - a message with a server identifier which doesn't match any server // identifier used by a server, is not accepted. TEST_F(Dhcpv4SrvTest, acceptServerId) { configureServerIdentifier(); IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); Pkt4Ptr pkt(new Pkt4(DHCPREQUEST, 1234)); // If no server identifier option is present, the message is always // accepted. EXPECT_TRUE(srv.acceptServerId(pkt)); // Create definition of the server identifier option. OptionDefinition def("server-identifier", DHO_DHCP_SERVER_IDENTIFIER, DHCP4_OPTION_SPACE, "ipv4-address", false); // Add a server identifier option which doesn't match server ids being // used by the server. The accepted server ids are the IPv4 addresses // configured on the interfaces. The 10.1.2.3 is not configured on // any interfaces. OptionCustomPtr other_serverid(new OptionCustom(def, Option::V4)); other_serverid->writeAddress(IOAddress("10.1.2.3")); pkt->addOption(other_serverid); EXPECT_FALSE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on eth1 interface. // A DHCPv4 message holding this server identifier should be accepted. OptionCustomPtr eth1_serverid(new OptionCustom(def, Option::V4)); eth1_serverid->writeAddress(IOAddress("192.0.2.3")); ASSERT_NO_THROW(pkt->addOption(eth1_serverid)); EXPECT_TRUE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on eth0 interface. // A DHCPv4 message holding this server identifier should be accepted. OptionCustomPtr eth0_serverid(new OptionCustom(def, Option::V4)); eth0_serverid->writeAddress(IOAddress("10.0.0.1")); ASSERT_NO_THROW(pkt->addOption(eth0_serverid)); EXPECT_TRUE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on subnet3. // A DHCPv4 message holding this server identifier should be accepted. OptionCustomPtr subnet_serverid(new OptionCustom(def, Option::V4)); subnet_serverid->writeAddress(IOAddress("192.0.3.254")); ASSERT_NO_THROW(pkt->addOption(subnet_serverid)); EXPECT_TRUE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on shared network1. // A DHCPv4 message holding this server identifier should be accepted. OptionCustomPtr network_serverid(new OptionCustom(def, Option::V4)); network_serverid->writeAddress(IOAddress("192.0.4.254")); ASSERT_NO_THROW(pkt->addOption(network_serverid)); EXPECT_TRUE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on client class. // A DHCPv4 message holding this server identifier should be accepted. Pkt4Ptr pkt_with_classes(new Pkt4(DHCPREQUEST, 1234)); OptionCustomPtr class_serverid(new OptionCustom(def, Option::V4)); class_serverid->writeAddress(IOAddress("192.0.5.254")); ASSERT_NO_THROW(pkt_with_classes->addOption(class_serverid)); pkt_with_classes->addClass("foo"); EXPECT_TRUE(srv.acceptServerId(pkt_with_classes)); // Remove the server identifier. ASSERT_NO_THROW(pkt_with_classes->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on global level. // The configured class does not define the server id option. // A DHCPv4 message holding this server identifier should be accepted. Pkt4Ptr pkt_with_classes_option_not_defined(new Pkt4(DHCPREQUEST, 1234)); OptionCustomPtr global_serverid(new OptionCustom(def, Option::V4)); global_serverid->writeAddress(IOAddress("10.0.0.254")); ASSERT_NO_THROW(pkt_with_classes_option_not_defined->addOption(global_serverid)); pkt_with_classes_option_not_defined->addClass("bar"); EXPECT_TRUE(srv.acceptServerId(pkt_with_classes_option_not_defined)); // Remove the server identifier. ASSERT_NO_THROW(pkt_with_classes_option_not_defined->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on global level. // The configured class does not define any option. // A DHCPv4 message holding this server identifier should be accepted. Pkt4Ptr pkt_with_classes_no_options(new Pkt4(DHCPREQUEST, 1234)); ASSERT_NO_THROW(pkt_with_classes_no_options->addOption(global_serverid)); pkt_with_classes_no_options->addClass("xyz"); EXPECT_TRUE(srv.acceptServerId(pkt_with_classes_no_options)); // Remove the server identifier. ASSERT_NO_THROW(pkt_with_classes_no_options->delOption(DHO_DHCP_SERVER_IDENTIFIER)); // Add a server id being an IPv4 address configured on global level. // A DHCPv4 message holding this server identifier should be accepted. ASSERT_NO_THROW(pkt->addOption(global_serverid)); EXPECT_TRUE(srv.acceptServerId(pkt)); // Remove the server identifier. ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER)); OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_AGENT_OPTIONS); OptionBuffer override_server_id_buf(IOAddress("10.0.0.128").toBytes()); // Create RAI option. OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4)); OptionPtr rai_override_server_id(new Option(Option::V4, RAI_OPTION_SERVER_ID_OVERRIDE, override_server_id_buf)); rai->addOption(rai_override_server_id); // Add a server id being an IPv4 address matching RAI sub-option 11 // (RAI_OPTION_SERVER_ID_OVERRIDE). // A DHCPv4 message holding this server identifier should be accepted. Pkt4Ptr pkt_with_override_server_id(new Pkt4(DHCPREQUEST, 1234)); OptionCustomPtr override_serverid(new OptionCustom(def, Option::V4)); override_serverid->writeAddress(IOAddress("10.0.0.128")); ASSERT_NO_THROW(pkt_with_override_server_id->addOption(override_serverid)); ASSERT_NO_THROW(pkt_with_override_server_id->addOption(rai)); EXPECT_TRUE(srv.acceptServerId(pkt_with_override_server_id)); // Remove the server identifier. ASSERT_NO_THROW(pkt_with_override_server_id->delOption(DHO_DHCP_SERVER_IDENTIFIER)); } // @todo: Implement tests for rejecting renewals // This test verifies if the sanityCheck() really checks options presence. TEST_F(Dhcpv4SrvTest, sanityCheck) { boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); Pkt4Ptr pkt = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); pkt->setHWAddr(generateHWAddr(6)); // Server-id is optional for information-request, so EXPECT_NO_THROW(NakedDhcpv4Srv::sanityCheck(pkt, Dhcpv4Srv::OPTIONAL)); // Empty packet, no server-id EXPECT_THROW(NakedDhcpv4Srv::sanityCheck(pkt, Dhcpv4Srv::MANDATORY), RFCViolation); pkt->addOption(srv->getServerID()); // Server-id is mandatory and present = no exception EXPECT_NO_THROW(NakedDhcpv4Srv::sanityCheck(pkt, Dhcpv4Srv::MANDATORY)); // Server-id is forbidden, but present => exception EXPECT_THROW(NakedDhcpv4Srv::sanityCheck(pkt, Dhcpv4Srv::FORBIDDEN), RFCViolation); // There's no client-id and no HWADDR. Server needs something to // identify the client pkt->setHWAddr(generateHWAddr(0)); EXPECT_THROW(NakedDhcpv4Srv::sanityCheck(pkt, Dhcpv4Srv::MANDATORY), RFCViolation); } } // end of anonymous namespace namespace isc { namespace dhcp { namespace test { void Dhcpv4SrvTest::relayAgentInfoEcho() { IfaceMgrTestConfig test_config(true); NakedDhcpv4Srv srv(0); // Use of the captured DHCPDISCOVER packet requires that // subnet 10.254.226.0/24 is in use, because this packet // contains the giaddr which belongs to this subnet and // this giaddr is used to select the subnet configure(CONFIGS[0]); // Let's create a relayed DISCOVER. This particular relayed DISCOVER has // added option 82 (relay agent info) with 3 suboptions. The server // is supposed to echo it back in its response. Pkt4Ptr dis; ASSERT_NO_THROW(dis = PktCaptures::captureRelayedDiscover()); // Simulate that we have received that traffic srv.fakeReceive(dis); // Server will now process to run its normal loop, but instead of calling // IfaceMgr::receive4(), it will read all packets from the list set by // fakeReceive() // In particular, it should call registered buffer4_receive callback. srv.run(); // Check that the server did send a response ASSERT_EQ(1, srv.fake_sent_.size()); // Make sure that we received a response Pkt4Ptr offer = srv.fake_sent_.front(); ASSERT_TRUE(offer); // Get Relay Agent Info from query... OptionPtr rai_query = dis->getOption(DHO_DHCP_AGENT_OPTIONS); ASSERT_TRUE(rai_query); // Get Relay Agent Info from response... OptionPtr rai_response = offer->getOption(DHO_DHCP_AGENT_OPTIONS); ASSERT_TRUE(rai_response); EXPECT_TRUE(rai_response->equals(rai_query)); } void Dhcpv4SrvTest::badRelayAgentInfoEcho() { IfaceMgrTestConfig test_config(true); NakedDhcpv4Srv srv(0); // Use of the captured DHCPDISCOVER packet requires that // subnet 10.254.226.0/24 is in use, because this packet // contains the giaddr which belongs to this subnet and // this giaddr is used to select the subnet configure(CONFIGS[0]); // Let's create a relayed DISCOVER. This particular relayed DISCOVER has // added option 82 (relay agent info) with a sub-option which does not // fit in the option. Unpacking it gave an empty option which is // supposed to not be echoed back in its response. Pkt4Ptr dis; ASSERT_NO_THROW(dis = PktCaptures::captureBadRelayedDiscover()); // Simulate that we have received that traffic srv.fakeReceive(dis); // Server will now process to run its normal loop, but instead of calling // IfaceMgr::receive4(), it will read all packets from the list set by // fakeReceive() // In particular, it should call registered buffer4_receive callback. srv.run(); // Check that the server did send a response ASSERT_EQ(1, srv.fake_sent_.size()); // Make sure that we received a response Pkt4Ptr offer = srv.fake_sent_.front(); ASSERT_TRUE(offer); // Get Relay Agent Info from query... OptionPtr rai_query = dis->getOption(DHO_DHCP_AGENT_OPTIONS); ASSERT_TRUE(rai_query); ASSERT_EQ(2, rai_query->len()); // Get Relay Agent Info from response... OptionPtr rai_response = offer->getOption(DHO_DHCP_AGENT_OPTIONS); ASSERT_FALSE(rai_response); } void Dhcpv4SrvTest::portsClientPort() { IfaceMgrTestConfig test_config(true); NakedDhcpv4Srv srv(0); // By default te client port is supposed to be zero. EXPECT_EQ(0, srv.client_port_); // Use of the captured DHCPDISCOVER packet requires that // subnet 10.254.226.0/24 is in use, because this packet // contains the giaddr which belongs to this subnet and // this giaddr is used to select the subnet configure(CONFIGS[0]); srv.client_port_ = 1234; // Let's create a relayed DISCOVER. This particular relayed DISCOVER has // added option 82 (relay agent info) with 3 suboptions. The server // is supposed to echo it back in its response. Pkt4Ptr dis; ASSERT_NO_THROW(dis = PktCaptures::captureRelayedDiscover()); // Simulate that we have received that traffic srv.fakeReceive(dis); // Server will now process to run its normal loop, but instead of calling // IfaceMgr::receive4(), it will read all packets from the list set by // fakeReceive() // In particular, it should call registered buffer4_receive callback. srv.run(); // Check that the server did send a response ASSERT_EQ(1, srv.fake_sent_.size()); // Make sure that we received a response Pkt4Ptr offer = srv.fake_sent_.front(); ASSERT_TRUE(offer); // Get Relay Agent Info from query... EXPECT_EQ(srv.client_port_, offer->getRemotePort()); } void Dhcpv4SrvTest::portsServerPort() { IfaceMgrTestConfig test_config(true); // Do not use DHCP4_SERVER_PORT here as 0 means don't open sockets. NakedDhcpv4Srv srv(0); EXPECT_EQ(0, srv.server_port_); // Use of the captured DHCPDISCOVER packet requires that // subnet 10.254.226.0/24 is in use, because this packet // contains the giaddr which belongs to this subnet and // this giaddr is used to select the subnet configure(CONFIGS[0]); srv.server_port_ = 1234; // Let's create a relayed DISCOVER. This particular relayed DISCOVER has // added option 82 (relay agent info) with 3 suboptions. The server // is supposed to echo it back in its response. Pkt4Ptr dis; ASSERT_NO_THROW(dis = PktCaptures::captureRelayedDiscover()); // Simulate that we have received that traffic srv.fakeReceive(dis); // Server will now process to run its normal loop, but instead of calling // IfaceMgr::receive4(), it will read all packets from the list set by // fakeReceive() // In particular, it should call registered buffer4_receive callback. srv.run(); // Check that the server did send a response ASSERT_EQ(1, srv.fake_sent_.size()); // Make sure that we received a response Pkt4Ptr offer = srv.fake_sent_.front(); ASSERT_TRUE(offer); // Get Relay Agent Info from query... EXPECT_EQ(srv.server_port_, offer->getLocalPort()); } void Dhcpv4SrvTest::loadConfigFile(const string& path) { CfgMgr::instance().clear(); LibDHCP::clearRuntimeOptionDefs(); IfaceMgrTestConfig test_config(true); // Do not use DHCP4_SERVER_PORT here as 0 means don't open sockets. NakedDhcpv4Srv srv(0); EXPECT_EQ(0, srv.server_port_); ConfigBackendDHCPv4Mgr::instance().registerBackendFactory("mysql", [](const db::DatabaseConnection::ParameterMap&) -> ConfigBackendDHCPv4Ptr { return (ConfigBackendDHCPv4Ptr()); }); ConfigBackendDHCPv4Mgr::instance().registerBackendFactory("postgresql", [](const db::DatabaseConnection::ParameterMap&) -> ConfigBackendDHCPv4Ptr { return (ConfigBackendDHCPv4Ptr()); }); // TimerMgr uses IO service to run asynchronous timers. TimerMgr::instance()->setIOService(srv.getIOService()); // CommandMgr uses IO service to run asynchronous socket operations. CommandMgr::instance().setIOService(srv.getIOService()); // LeaseMgr uses IO service to run asynchronous timers. LeaseMgr::setIOService(srv.getIOService()); // HostMgr uses IO service to run asynchronous timers. HostMgr::setIOService(srv.getIOService()); Parser4Context parser; ConstElementPtr json; ASSERT_NO_THROW(json = parser.parseFile(path, Parser4Context::PARSER_DHCP4)); ASSERT_TRUE(json); // Check the logic next. ConstElementPtr dhcp4 = json->get("Dhcp4"); ASSERT_TRUE(dhcp4); ElementPtr mutable_config = boost::const_pointer_cast(dhcp4); mutable_config->set(string("hooks-libraries"), Element::createList()); ASSERT_NO_THROW(Dhcpv4SrvTest::configure(dhcp4->str(), true, true, true, true)); LeaseMgrFactory::destroy(); HostMgr::create(); TimerMgr::instance()->unregisterTimers(); // Close the command socket (if it exists). CommandMgr::instance().closeCommandSocket(); // Reset CommandMgr IO service. CommandMgr::instance().setIOService(IOServicePtr()); // Reset LeaseMgr IO service. LeaseMgr::setIOService(IOServicePtr()); // Reset HostMgr IO service. HostMgr::setIOService(IOServicePtr()); } void Dhcpv4SrvTest::checkConfigFiles() { IfaceMgrTestConfig test_config(true); string path = CFG_EXAMPLES; vector examples = { "advanced.json", #if defined (HAVE_MYSQL) && defined (HAVE_PGSQL) "all-keys-netconf.json", "all-options.json", #endif "backends.json", "classify.json", "classify2.json", "comments.json", #if defined (HAVE_MYSQL) "config-backend.json", #endif "dhcpv4-over-dhcpv6.json", "global-reservations.json", "ha-load-balancing-primary.json", "hooks.json", "hooks-radius.json", "leases-expiration.json", "multiple-options.json", #if defined (HAVE_MYSQL) "mysql-reservations.json", #endif #if defined (HAVE_PGSQL) "pgsql-reservations.json", #endif "reservations.json", "several-subnets.json", "shared-network.json", "single-subnet.json", "vendor-specific.json", "vivso.json", "with-ddns.json", }; vector files; for (string example : examples) { string file = path + "/" + example; files.push_back(file); } for (const auto& file: files) { string label("Checking configuration from file: "); label += file; SCOPED_TRACE(label); loadConfigFile(file); } } } // end of isc::dhcp::test namespace } // end of isc::dhcp namespace } // end of isc namespace namespace { TEST_F(Dhcpv4SrvTest, relayAgentInfoEcho) { Dhcpv4SrvMTTestGuard guard(*this, false); relayAgentInfoEcho(); } TEST_F(Dhcpv4SrvTest, relayAgentInfoEchoMultiThreading) { Dhcpv4SrvMTTestGuard guard(*this, true); relayAgentInfoEcho(); } TEST_F(Dhcpv4SrvTest, badRelayAgentInfoEcho) { Dhcpv4SrvMTTestGuard guard(*this, false); badRelayAgentInfoEcho(); } TEST_F(Dhcpv4SrvTest, badRelayAgentInfoEchoMultiThreading) { Dhcpv4SrvMTTestGuard guard(*this, true); badRelayAgentInfoEcho(); } TEST_F(Dhcpv4SrvTest, portsClientPort) { Dhcpv4SrvMTTestGuard guard(*this, false); portsClientPort(); } TEST_F(Dhcpv4SrvTest, portsClientPortMultiThreading) { Dhcpv4SrvMTTestGuard guard(*this, true); portsClientPort(); } TEST_F(Dhcpv4SrvTest, portsServerPort) { Dhcpv4SrvMTTestGuard guard(*this, false); portsServerPort(); } TEST_F(Dhcpv4SrvTest, portsServerPortMultiTHreading) { Dhcpv4SrvMTTestGuard guard(*this, true); portsServerPort(); } /// @brief Check that example files from documentation are valid (can be parsed /// and loaded). TEST_F(Dhcpv4SrvTest, checkConfigFiles) { checkConfigFiles(); } /// @todo Implement tests for subnetSelect See tests in dhcp6_srv_unittest.cc: /// selectSubnetAddr, selectSubnetIface, selectSubnetRelayLinkaddr, /// selectSubnetRelayInterfaceId. Note that the concept of interface-id is not /// present in the DHCPv4, so not everything is applicable directly. /// See ticket #3057 // Checks whether the server uses default (0.0.0.0) siaddr value, unless // explicitly specified TEST_F(Dhcpv4SrvTest, siaddrDefault) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); IOAddress hint("192.0.2.107"); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); dis->setYiaddr(hint); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); ASSERT_TRUE(offer); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Verify that it is 0.0.0.0 EXPECT_EQ("0.0.0.0", offer->getSiaddr().toText()); } // Checks whether the server uses specified siaddr value TEST_F(Dhcpv4SrvTest, siaddr) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); boost::scoped_ptr srv; ASSERT_NO_THROW(srv.reset(new NakedDhcpv4Srv(0))); subnet_->setSiaddr(IOAddress("192.0.2.123")); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Pass it to the server and get an offer Pkt4Ptr offer = srv->processDiscover(dis); ASSERT_TRUE(offer); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Verify that its value is proper EXPECT_EQ("192.0.2.123", offer->getSiaddr().toText()); } // Checks if the next-server defined as global value is overridden by subnet // specific value and returned in server messages. There's also similar test for // checking parser only configuration, see Dhcp4ParserTest.nextServerOverride in // config_parser_unittest.cc. This test was extended to other BOOTP fixed fields. TEST_F(Dhcpv4SrvTest, nextServerOverride) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); ConstElementPtr status; string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"next-server\": \"192.0.0.1\", " "\"server-hostname\": \"nohost\", " "\"boot-file-name\": \"nofile\", " "\"subnet4\": [ { " " \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ]," " \"next-server\": \"1.2.3.4\", " " \"server-hostname\": \"some-name.example.org\", " " \"boot-file-name\": \"bootfile.efi\", " " \"subnet\": \"192.0.2.0/24\" } ]," "\"valid-lifetime\": 4000 }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config, true)); EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); CfgMgr::instance().commit(); // check if returned status is OK ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Pass it to the server and get an offer Pkt4Ptr offer = srv.processDiscover(dis); ASSERT_TRUE(offer); EXPECT_EQ(DHCPOFFER, offer->getType()); EXPECT_EQ("1.2.3.4", offer->getSiaddr().toText()); std::string sname("some-name.example.org"); uint8_t sname_buf[Pkt4::MAX_SNAME_LEN]; std::memset(sname_buf, 0, Pkt4::MAX_SNAME_LEN); std::memcpy(sname_buf, sname.c_str(), sname.size()); EXPECT_EQ(0, std::memcmp(sname_buf, &offer->getSname()[0], Pkt4::MAX_SNAME_LEN)); std::string filename("bootfile.efi"); uint8_t filename_buf[Pkt4::MAX_FILE_LEN]; std::memset(filename_buf, 0, Pkt4::MAX_FILE_LEN); std::memcpy(filename_buf, filename.c_str(), filename.size()); EXPECT_EQ(0, std::memcmp(filename_buf, &offer->getFile()[0], Pkt4::MAX_FILE_LEN)); } // Checks if the next-server defined as global value is used in responses // when there is no specific value defined in subnet and returned to the client // properly. There's also similar test for checking parser only configuration, // see Dhcp4ParserTest.nextServerGlobal in config_parser_unittest.cc. TEST_F(Dhcpv4SrvTest, nextServerGlobal) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); ConstElementPtr status; string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"next-server\": \"192.0.0.1\", " "\"server-hostname\": \"some-name.example.org\", " "\"boot-file-name\": \"bootfile.efi\", " "\"subnet4\": [ { " " \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ]," " \"subnet\": \"192.0.2.0/24\" } ]," "\"valid-lifetime\": 4000 }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config, true)); EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); CfgMgr::instance().commit(); // check if returned status is OK ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth1"); dis->setIndex(ETH1_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Pass it to the server and get an offer Pkt4Ptr offer = srv.processDiscover(dis); ASSERT_TRUE(offer); EXPECT_EQ(DHCPOFFER, offer->getType()); EXPECT_EQ("192.0.0.1", offer->getSiaddr().toText()); std::string sname("some-name.example.org"); uint8_t sname_buf[Pkt4::MAX_SNAME_LEN]; std::memset(sname_buf, 0, Pkt4::MAX_SNAME_LEN); std::memcpy(sname_buf, sname.c_str(), sname.size()); EXPECT_EQ(0, std::memcmp(sname_buf, &offer->getSname()[0], Pkt4::MAX_SNAME_LEN)); std::string filename("bootfile.efi"); uint8_t filename_buf[Pkt4::MAX_FILE_LEN]; std::memset(filename_buf, 0, Pkt4::MAX_FILE_LEN); std::memcpy(filename_buf, filename.c_str(), filename.size()); EXPECT_EQ(0, std::memcmp(filename_buf, &offer->getFile()[0], Pkt4::MAX_FILE_LEN)); } // Checks if client packets are classified properly using match expressions. TEST_F(Dhcpv4SrvTest, matchClassification) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // The router class matches incoming packets with foo in a host-name // option (code 12) and sets an ip-forwarding option in the response. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ], " "\"client-classes\": [ " "{ \"name\": \"router\", " " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"true\" } ], " " \"test\": \"option[12].text == 'foo'\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create packets with enough to select the subnet OptionPtr clientid = generateClientId(); Pkt4Ptr query1(new Pkt4(DHCPDISCOVER, 1234)); query1->setRemoteAddr(IOAddress("192.0.2.1")); query1->addOption(clientid); query1->setIface("eth1"); query1->setIndex(ETH1_INDEX); Pkt4Ptr query2(new Pkt4(DHCPDISCOVER, 1234)); query2->setRemoteAddr(IOAddress("192.0.2.1")); query2->addOption(clientid); query2->setIface("eth1"); query2->setIndex(ETH1_INDEX); Pkt4Ptr query3(new Pkt4(DHCPDISCOVER, 1234)); query3->setRemoteAddr(IOAddress("192.0.2.1")); query3->addOption(clientid); query3->setIface("eth1"); query3->setIndex(ETH1_INDEX); // Create and add a PRL option to the first 2 queries OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(DHO_IP_FORWARDING); query1->addOption(prl); query2->addOption(prl); // Create and add a host-name option to the first and last queries OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query1->addOption(hostname); query3->addOption(hostname); // Classify packets srv.classifyPacket(query1); srv.classifyPacket(query2); srv.classifyPacket(query3); // Packets with the exception of the second should be in the router class EXPECT_TRUE(query1->inClass("router")); EXPECT_FALSE(query2->inClass("router")); EXPECT_TRUE(query3->inClass("router")); // Process queries Pkt4Ptr response1 = srv.processDiscover(query1); Pkt4Ptr response2 = srv.processDiscover(query2); Pkt4Ptr response3 = srv.processDiscover(query3); // Classification processing should add an ip-forwarding option OptionPtr opt1 = response1->getOption(DHO_IP_FORWARDING); EXPECT_TRUE(opt1); // But only for the first query: second was not classified OptionPtr opt2 = response2->getOption(DHO_IP_FORWARDING); EXPECT_FALSE(opt2); // But only for the first query: third has no PRL OptionPtr opt3 = response3->getOption(DHO_IP_FORWARDING); EXPECT_FALSE(opt3); } // Checks if client packets are classified properly using match expressions // using option names TEST_F(Dhcpv4SrvTest, matchClassificationOptionName) { NakedDhcpv4Srv srv(0); // The router class matches incoming packets with foo in a host-name string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ], " "\"client-classes\": [ " "{ \"name\": \"router\", " " \"test\": \"option[host-name].text == 'foo'\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Classify packets srv.classifyPacket(query); // The query should be in the router class EXPECT_TRUE(query->inClass("router")); } // Checks if client packets are classified properly using match expressions // using option names and definitions TEST_F(Dhcpv4SrvTest, matchClassificationOptionDef) { NakedDhcpv4Srv srv(0); // The router class matches incoming packets with foo in a defined // option string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ], " "\"client-classes\": [ " "{ \"name\": \"router\", " " \"test\": \"option[my-host-name].text == 'foo'\" } ], " "\"option-def\": [ {" " \"name\": \"my-host-name\", " " \"code\": 250, " " \"type\": \"string\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); // Create and add a my-host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 250, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Classify packets srv.classifyPacket(query); // The query should be in the router class EXPECT_TRUE(query->inClass("router")); } // Checks subnet options have the priority over class options TEST_F(Dhcpv4SrvTest, subnetClassPriority) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // Subnet sets an ip-forwarding option in the response. // The router class matches incoming packets with foo in a host-name // option (code 12) and sets an ip-forwarding option in the response. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\", " " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"false\" } ] } ], " "\"client-classes\": [ " "{ \"name\": \"router\"," " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"true\" } ], " " \"test\": \"option[12].text == 'foo'\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Create and add a PRL option to the query OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(DHO_IP_FORWARDING); query->addOption(prl); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Classify the packet srv.classifyPacket(query); // The packet should be in the router class EXPECT_TRUE(query->inClass("router")); // Process the query Pkt4Ptr response = srv.processDiscover(query); // Processing should add an ip-forwarding option OptionPtr opt = response->getOption(DHO_IP_FORWARDING); ASSERT_TRUE(opt); ASSERT_GT(opt->len(), opt->getHeaderLen()); // Classification sets the value to true/1, subnet to false/0 // Here subnet has the priority EXPECT_EQ(0, opt->getUint8()); } // Checks subnet options have the priority over global options TEST_F(Dhcpv4SrvTest, subnetGlobalPriority) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // Subnet and global set an ip-forwarding option in the response. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\", " " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"false\" } ] } ], " "\"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"true\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Create and add a PRL option to the query OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(DHO_IP_FORWARDING); query->addOption(prl); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Process the query Pkt4Ptr response = srv.processDiscover(query); // Processing should add an ip-forwarding option OptionPtr opt = response->getOption(DHO_IP_FORWARDING); ASSERT_TRUE(opt); ASSERT_GT(opt->len(), opt->getHeaderLen()); // Global sets the value to true/1, subnet to false/0 // Here subnet has the priority EXPECT_EQ(0, opt->getUint8()); } // Checks class options have the priority over global options TEST_F(Dhcpv4SrvTest, classGlobalPriority) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // A global ip-forwarding option is set in the response. // The router class matches incoming packets with foo in a host-name // option (code 12) and sets an ip-forwarding option in the response. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ], " "\"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"false\" } ], " "\"client-classes\": [ " "{ \"name\": \"router\"," " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"true\" } ], " " \"test\": \"option[12].text == 'foo'\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Create and add a PRL option to the query OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(DHO_IP_FORWARDING); query->addOption(prl); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Classify the packet srv.classifyPacket(query); // The packet should be in the router class EXPECT_TRUE(query->inClass("router")); // Process the query Pkt4Ptr response = srv.processDiscover(query); // Processing should add an ip-forwarding option OptionPtr opt = response->getOption(DHO_IP_FORWARDING); ASSERT_TRUE(opt); ASSERT_GT(opt->len(), opt->getHeaderLen()); // Classification sets the value to true/1, global to false/0 // Here class has the priority EXPECT_NE(0, opt->getUint8()); } // Checks class options have the priority over global persistent options TEST_F(Dhcpv4SrvTest, classGlobalPersistency) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // A global ip-forwarding option is set in the response. // The router class matches incoming packets with foo in a host-name // option (code 12) and sets an ip-forwarding option in the response. // Note the persistency flag follows a "OR" semantic so to set // it to false (or to leave the default) has no effect. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ], " "\"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"false\", " " \"always-send\": true } ], " "\"client-classes\": [ " "{ \"name\": \"router\"," " \"option-data\": [" " { \"name\": \"ip-forwarding\", " " \"data\": \"true\", " " \"always-send\": false } ], " " \"test\": \"option[12].text == 'foo'\" } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Do not add a PRL OptionPtr prl = query->getOption(DHO_DHCP_PARAMETER_REQUEST_LIST); EXPECT_FALSE(prl); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Classify the packet srv.classifyPacket(query); // The packet should be in the router class EXPECT_TRUE(query->inClass("router")); // Process the query Pkt4Ptr response = srv.processDiscover(query); // Processing should add an ip-forwarding option OptionPtr opt = response->getOption(DHO_IP_FORWARDING); ASSERT_TRUE(opt); ASSERT_GT(opt->len(), opt->getHeaderLen()); // Classification sets the value to true/1, global to false/0 // Here class has the priority EXPECT_NE(0, opt->getUint8()); } // Checks if the client-class field is indeed used for subnet selection. // Note that packet classification is already checked in Dhcpv4SrvTest // .*Classification above. TEST_F(Dhcpv4SrvTest, clientClassify) { // This test configures 2 subnets. We actually only need the // first one, but since there's still this ugly hack that picks // the pool if there is only one, we must use more than one // subnet. That ugly hack will be removed in #3242, currently // under review. // The second subnet does not play any role here. The client's // IP address belongs to the first subnet, so only that first // subnet is being tested. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ]," " \"client-class\": \"foo\", " " \"subnet\": \"192.0.2.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.3.1 - 192.0.3.100\" } ]," " \"client-class\": \"xyzzy\", " " \"subnet\": \"192.0.3.0/24\" } " "]," "\"valid-lifetime\": 4000 }"; ASSERT_NO_THROW(configure(config, true, false)); // Create a simple packet that we'll use for classification Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setCiaddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // This discover does not belong to foo class, so it will not // be serviced bool drop = false; EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Let's add the packet to bar class and try again. dis->addClass("bar"); // Still not supported, because it belongs to wrong class. EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Let's add it to matching class. dis->addClass("foo"); // This time it should work EXPECT_TRUE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); } // Checks if the client-class field is indeed used for pool selection. TEST_F(Dhcpv4SrvTest, clientPoolClassify) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // This test configures 2 pools. // The second pool does not play any role here. The client's // IP address belongs to the first pool, so only that first // pool is being tested. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { " " \"pool\": \"192.0.2.1 - 192.0.2.100\", " " \"client-class\": \"foo\" }, " " { \"pool\": \"192.0.3.1 - 192.0.3.100\", " " \"client-class\": \"xyzzy\" } ], " " \"subnet\": \"192.0.0.0/16\" } " "]," "\"valid-lifetime\": 4000 }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config, true)); ConstElementPtr status; EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); CfgMgr::instance().commit(); // check if returned status is OK ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); // Create a simple packet that we'll use for classification Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setCiaddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // This discover does not belong to foo class, so it will not // be serviced Pkt4Ptr offer = srv.processDiscover(dis); EXPECT_FALSE(offer); // Let's add the packet to bar class and try again. dis->addClass("bar"); // Still not supported, because it belongs to wrong class. offer = srv.processDiscover(dis); EXPECT_FALSE(offer); // Let's add it to matching class. dis->addClass("foo"); // This time it should work offer = srv.processDiscover(dis); ASSERT_TRUE(offer); EXPECT_EQ(DHCPOFFER, offer->getType()); EXPECT_FALSE(offer->getYiaddr().isV4Zero()); } // Checks if the KNOWN built-in classes is indeed used for pool selection. TEST_F(Dhcpv4SrvTest, clientPoolClassifyKnown) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // This test configures 2 pools. // The first one requires reservation, the second does the opposite. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { " " \"pool\": \"192.0.2.1 - 192.0.2.100\", " " \"client-class\": \"KNOWN\" }, " " { \"pool\": \"192.0.3.1 - 192.0.3.100\", " " \"client-class\": \"UNKNOWN\" } ], " " \"subnet\": \"192.0.0.0/16\" } " "]," "\"valid-lifetime\": 4000 }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config, true)); ConstElementPtr status; EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); CfgMgr::instance().commit(); // check if returned status is OK ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); // Create a simple packet that we'll use for classification Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setCiaddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // First pool requires reservation so the second will be used Pkt4Ptr offer = srv.processDiscover(dis); ASSERT_TRUE(offer); EXPECT_EQ(DHCPOFFER, offer->getType()); EXPECT_EQ("192.0.3.1", offer->getYiaddr().toText()); } // Checks if the UNKNOWN built-in classes is indeed used for pool selection. TEST_F(Dhcpv4SrvTest, clientPoolClassifyUnknown) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // This test configures 2 pools. // The first one requires no reservation, the second does the opposite. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { " " \"pool\": \"192.0.2.1 - 192.0.2.100\", " " \"client-class\": \"UNKNOWN\" }, " " { \"pool\": \"192.0.3.1 - 192.0.3.100\", " " \"client-class\": \"KNOWN\" } ], " " \"subnet\": \"192.0.0.0/16\", " " \"reservations\": [ { " " \"hw-address\": \"00:00:00:11:22:33\", " " \"hostname\": \"foo.bar\" } ] } " "]," "\"valid-lifetime\": 4000 }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config, true)); ConstElementPtr status; EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); CfgMgr::instance().commit(); // check if returned status is OK ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); // Create a simple packet that we'll use for classification Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setCiaddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Set hardware address / identifier const HWAddr& hw = HWAddr::fromText("00:00:00:11:22:33"); HWAddrPtr hw_addr(new HWAddr(hw)); dis->setHWAddr(hw_addr); // First pool requires no reservation so the second will be used Pkt4Ptr offer = srv.processDiscover(dis); ASSERT_TRUE(offer); EXPECT_EQ(DHCPOFFER, offer->getType()); EXPECT_EQ("192.0.3.1", offer->getYiaddr().toText()); } // Verifies private option deferred processing TEST_F(Dhcpv4SrvTest, privateOption) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // Same than option43Class but with private options string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ] }, " "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"valid-lifetime\": 4000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ], " " \"subnet\": \"192.0.2.0/24\" } ]," "\"client-classes\": [ " "{ \"name\": \"private\", " " \"test\": \"option[234].exists\", " " \"option-def\": [ " " { \"code\": 245, " " \"name\": \"privint\", " " \"type\": \"uint32\" } ]," " \"option-data\": [ " " { \"code\": 234, " " \"data\": \"01\" }, " " { \"name\": \"privint\", " " \"data\": \"12345678\" } ] } ] }"; ConstElementPtr json; ASSERT_NO_THROW(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Create and add a private option with code 234 OptionBuffer buf; buf.push_back(0x01); OptionPtr opt1(new Option(Option::V4, 234, buf)); query->addOption(opt1); query->getDeferredOptions().push_back(234); // Create and add a private option with code 245 buf.clear(); buf.push_back(0x87); buf.push_back(0x65); buf.push_back(0x43); buf.push_back(0x21); OptionPtr opt2(new Option(Option::V4, 245, buf)); query->addOption(opt2); query->getDeferredOptions().push_back(245); // Create and add a PRL option to the query OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(234); prl->addValue(245); query->addOption(prl); srv.classifyPacket(query); ASSERT_NO_THROW(srv.deferredUnpack(query)); // Check if the option 245 was re-unpacked opt2 = query->getOption(245); OptionUint32Ptr opt32 = boost::dynamic_pointer_cast(opt2); EXPECT_TRUE(opt32); // Pass it to the server and get an offer Pkt4Ptr offer = srv.processDiscover(query); // Check if we get response at all checkResponse(offer, DHCPOFFER, 1234); // Processing should add an option with code 234 OptionPtr opt = offer->getOption(234); EXPECT_TRUE(opt); // And an option with code 245 opt = offer->getOption(245); ASSERT_TRUE(opt); // Verifies the content opt32 = boost::dynamic_pointer_cast(opt); ASSERT_TRUE(opt32); EXPECT_EQ(12345678, opt32->getValue()); } // Checks effect of persistency (aka always-true) flag on the PRL TEST_F(Dhcpv4SrvTest, prlPersistency) { IfaceMgrTestConfig test_config(true); ASSERT_NO_THROW(configure(CONFIGS[2])); // Create a packet with enough to select the subnet and go through // the DISCOVER processing Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); OptionPtr clientid = generateClientId(); query->addOption(clientid); query->setIface("eth1"); query->setIndex(ETH1_INDEX); // Create and add a PRL option for another option OptionUint8ArrayPtr prl(new OptionUint8Array(Option::V4, DHO_DHCP_PARAMETER_REQUEST_LIST)); ASSERT_TRUE(prl); prl->addValue(DHO_ARP_CACHE_TIMEOUT); query->addOption(prl); // Create and add a host-name option to the query OptionStringPtr hostname(new OptionString(Option::V4, 12, "foo")); ASSERT_TRUE(hostname); query->addOption(hostname); // Let the server process it. Pkt4Ptr response = srv_.processDiscover(query); // Processing should add an ip-forwarding option ASSERT_TRUE(response->getOption(DHO_IP_FORWARDING)); // But no default-ip-ttl ASSERT_FALSE(response->getOption(DHO_DEFAULT_IP_TTL)); // Nor an arp-cache-timeout ASSERT_FALSE(response->getOption(DHO_ARP_CACHE_TIMEOUT)); // Reset PRL adding default-ip-ttl query->delOption(DHO_DHCP_PARAMETER_REQUEST_LIST); prl->addValue(DHO_DEFAULT_IP_TTL); query->addOption(prl); // Let the server process it again. response = srv_.processDiscover(query); // Processing should add an ip-forwarding option ASSERT_TRUE(response->getOption(DHO_IP_FORWARDING)); // and now a default-ip-ttl ASSERT_TRUE(response->getOption(DHO_DEFAULT_IP_TTL)); // and still no arp-cache-timeout ASSERT_FALSE(response->getOption(DHO_ARP_CACHE_TIMEOUT)); } // Checks if relay IP address specified in the relay-info structure in // subnet4 is being used properly. TEST_F(Dhcpv4SrvTest, relayOverride) { // We have 2 subnets defined. Note that both have a relay address // defined. Both are not belonging to the subnets. That is // important, because if the relay belongs to the subnet, there's // no need to specify relay override. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.2 - 192.0.2.100\" } ]," " \"relay\": { " " \"ip-address\": \"192.0.5.1\"" " }," " \"subnet\": \"192.0.2.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.3.1 - 192.0.3.100\" } ]," " \"relay\": { " " \"ip-address\": \"192.0.5.2\"" " }," " \"subnet\": \"192.0.3.0/24\" } " "]," "\"valid-lifetime\": 4000 }"; // Use this config to set up the server ASSERT_NO_THROW(configure(config, true, false)); // Let's get the subnet configuration objects const Subnet4Collection* subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4()->getAll(); ASSERT_EQ(2, subnets->size()); // Let's get them for easy reference Subnet4Ptr subnet1 = *subnets->begin(); Subnet4Ptr subnet2 = *std::next(subnets->begin()); ASSERT_TRUE(subnet1); ASSERT_TRUE(subnet2); // Let's create a packet. Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); dis->setHops(1); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // This is just a sanity check, we're using regular method: ciaddr 192.0.2.1 // belongs to the first subnet, so it is selected dis->setGiaddr(IOAddress("192.0.2.1")); bool drop = false; EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Relay belongs to the second subnet, so it should be selected. dis->setGiaddr(IOAddress("192.0.3.1")); EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Now let's check if the relay override for the first subnets works dis->setGiaddr(IOAddress("192.0.5.1")); EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // The same check for the second subnet... dis->setGiaddr(IOAddress("192.0.5.2")); EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // And finally, let's check if mis-matched relay address will end up // in not selecting a subnet at all dis->setGiaddr(IOAddress("192.0.5.3")); EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Finally, check that the relay override works only with relay address // (GIADDR) and does not affect client address (CIADDR) dis->setGiaddr(IOAddress("0.0.0.0")); dis->setHops(0); dis->setCiaddr(IOAddress("192.0.5.1")); EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); } // Checks if relay IP address specified in the relay-info structure can be // used together with client-classification. TEST_F(Dhcpv4SrvTest, relayOverrideAndClientClass) { // This test configures 2 subnets. They both are on the same link, so they // have the same relay-ip address. Furthermore, the first subnet is // reserved for clients that belong to class "foo". string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.2 - 192.0.2.100\" } ]," " \"client-class\": \"foo\", " " \"relay\": { " " \"ip-address\": \"192.0.5.1\"" " }," " \"subnet\": \"192.0.2.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.3.1 - 192.0.3.100\" } ]," " \"relay\": { " " \"ip-address\": \"192.0.5.1\"" " }," " \"subnet\": \"192.0.3.0/24\" } " "]," "\"valid-lifetime\": 4000 }"; // Use this config to set up the server ASSERT_NO_THROW(configure(config, true, false)); const Subnet4Collection* subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4()->getAll(); ASSERT_EQ(2, subnets->size()); // Let's get them for easy reference Subnet4Ptr subnet1 = *subnets->begin(); Subnet4Ptr subnet2 = *std::next(subnets->begin()); ASSERT_TRUE(subnet1); ASSERT_TRUE(subnet2); // Let's create a packet. Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); dis->setHops(1); dis->setGiaddr(IOAddress("192.0.5.1")); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // This packet does not belong to class foo, so it should be rejected in // subnet[0], even though the relay-ip matches. It should be accepted in // subnet[1], because the subnet matches and there are no class // requirements. bool drop = false; EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Now let's add this packet to class foo and recheck. This time it should // be accepted in the first subnet, because both class and relay-ip match. dis->addClass("foo"); EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); } // Checks if a RAI link selection sub-option works as expected TEST_F(Dhcpv4SrvTest, relayLinkSelect) { // We have 3 subnets defined. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.2 - 192.0.2.100\" } ]," " \"relay\": { " " \"ip-address\": \"192.0.5.1\"" " }," " \"subnet\": \"192.0.2.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.3.1 - 192.0.3.100\" } ]," " \"subnet\": \"192.0.3.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.4.1 - 192.0.4.100\" } ]," " \"client-class\": \"foo\", " " \"subnet\": \"192.0.4.0/24\" } " "]," "\"valid-lifetime\": 4000 }"; // Use this config to set up the server ASSERT_NO_THROW(configure(config, true, false)); // Let's get the subnet configuration objects const Subnet4Collection* subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4()->getAll(); ASSERT_EQ(3, subnets->size()); // Let's get them for easy reference auto subnet_it = subnets->begin(); Subnet4Ptr subnet1 = *subnet_it; ++subnet_it; Subnet4Ptr subnet2 = *subnet_it; ++subnet_it; Subnet4Ptr subnet3 = *subnet_it; ASSERT_TRUE(subnet1); ASSERT_TRUE(subnet2); ASSERT_TRUE(subnet3); // Let's create a packet. Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); dis->setHops(1); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Let's create a Relay Agent Information option OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_AGENT_OPTIONS); ASSERT_TRUE(rai_def); OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4)); ASSERT_TRUE(rai); IOAddress addr("192.0.3.2"); OptionPtr ols(new Option(Option::V4, RAI_OPTION_LINK_SELECTION, addr.toBytes())); ASSERT_TRUE(ols); rai->addOption(ols); // This is just a sanity check, we're using regular method: ciaddr 192.0.3.1 // belongs to the second subnet, so it is selected dis->setGiaddr(IOAddress("192.0.3.1")); bool drop = false; EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Setup a relay override for the first subnet as it has a high precedence dis->setGiaddr(IOAddress("192.0.5.1")); EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Put a RAI to select back the second subnet as it has // the highest precedence dis->addOption(rai); EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Subnet select option has a lower precedence OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_SUBNET_SELECTION); ASSERT_TRUE(sbnsel_def); OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4)); ASSERT_TRUE(sbnsel); sbnsel->writeAddress(IOAddress("192.0.2.3")); dis->addOption(sbnsel); EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // But, when RAI exists without the link selection option, we should // fall back to the subnet selection option. rai->delOption(RAI_OPTION_LINK_SELECTION); dis->delOption(DHO_DHCP_AGENT_OPTIONS); dis->addOption(rai); dis->setGiaddr(IOAddress("192.0.4.1")); EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Check client-classification still applies IOAddress addr_foo("192.0.4.2"); ols.reset(new Option(Option::V4, RAI_OPTION_LINK_SELECTION, addr_foo.toBytes())); dis->delOption(DHO_SUBNET_SELECTION); dis->delOption(DHO_DHCP_AGENT_OPTIONS); rai->addOption(ols); dis->addOption(rai); // Note it shall fail (vs. try the next criterion). EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Add the packet to the class and check again: now it shall succeed dis->addClass("foo"); EXPECT_TRUE(subnet3 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Check it fails with a bad address in the sub-option IOAddress addr_bad("10.0.0.1"); ols.reset(new Option(Option::V4, RAI_OPTION_LINK_SELECTION, addr_bad.toBytes())); rai->delOption(RAI_OPTION_LINK_SELECTION); dis->delOption(DHO_DHCP_AGENT_OPTIONS); rai->addOption(ols); dis->addOption(rai); EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); } // Checks if a subnet selection option works as expected TEST_F(Dhcpv4SrvTest, subnetSelect) { // We have 3 subnets defined. string config = "{ \"interfaces-config\": {" " \"interfaces\": [ \"*\" ]" "}," "\"rebind-timer\": 2000, " "\"renew-timer\": 1000, " "\"subnet4\": [ " "{ \"pools\": [ { \"pool\": \"192.0.2.2 - 192.0.2.100\" } ]," " \"relay\": { " " \"ip-address\": \"192.0.5.1\"" " }," " \"subnet\": \"192.0.2.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.3.1 - 192.0.3.100\" } ]," " \"subnet\": \"192.0.3.0/24\" }, " "{ \"pools\": [ { \"pool\": \"192.0.4.1 - 192.0.4.100\" } ]," " \"client-class\": \"foo\", " " \"subnet\": \"192.0.4.0/24\" } " "]," "\"valid-lifetime\": 4000 }"; // Use this config to set up the server ASSERT_NO_THROW(configure(config, true, false)); // Let's get the subnet configuration objects const Subnet4Collection* subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4()->getAll(); ASSERT_EQ(3, subnets->size()); // Let's get them for easy reference auto subnet_it = subnets->begin(); Subnet4Ptr subnet1 = *subnet_it; ++subnet_it; Subnet4Ptr subnet2 = *subnet_it; ++subnet_it; Subnet4Ptr subnet3 = *subnet_it; ASSERT_TRUE(subnet1); ASSERT_TRUE(subnet2); ASSERT_TRUE(subnet3); // Let's create a packet. Pkt4Ptr dis = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 1234)); dis->setRemoteAddr(IOAddress("192.0.2.1")); dis->setIface("eth0"); dis->setIndex(ETH0_INDEX); dis->setHops(1); OptionPtr clientid = generateClientId(); dis->addOption(clientid); // Let's create a Subnet Selection option OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_SUBNET_SELECTION); ASSERT_TRUE(sbnsel_def); OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4)); ASSERT_TRUE(sbnsel); sbnsel->writeAddress(IOAddress("192.0.3.2")); // This is just a sanity check, we're using regular method: ciaddr 192.0.3.1 // belongs to the second subnet, so it is selected dis->setGiaddr(IOAddress("192.0.3.1")); bool drop = false; EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Setup a relay override for the first subnet as it has a high precedence dis->setGiaddr(IOAddress("192.0.5.1")); EXPECT_TRUE(subnet1 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Put a subnet select option to select back the second subnet as // it has the second highest precedence dis->addOption(sbnsel); EXPECT_TRUE(subnet2 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Check client-classification still applies sbnsel->writeAddress(IOAddress("192.0.4.2")); // Note it shall fail (vs. try the next criterion). EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Add the packet to the class and check again: now it shall succeed dis->addClass("foo"); EXPECT_TRUE(subnet3 == srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); // Check it fails with a bad address in the sub-option sbnsel->writeAddress(IOAddress("10.0.0.1")); EXPECT_FALSE(srv_.selectSubnet(dis, drop)); EXPECT_FALSE(drop); } // This test verifies that the direct message is dropped when it has been // received by the server via an interface for which there is no subnet // configured. It also checks that the message is not dropped (is processed) // when it is relayed or unicast. TEST_F(Dhcpv4SrvTest, acceptDirectRequest) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1234)); // Set Giaddr and local server's unicast address, but don't set hops. // Hops value should not matter. The server will treat the message // with the hops value of 0 and non-zero giaddr as relayed. pkt->setGiaddr(IOAddress("192.0.10.1")); pkt->setRemoteAddr(IOAddress("0.0.0.0")); pkt->setLocalAddr(IOAddress("192.0.2.3")); pkt->setIface("eth1"); pkt->setIndex(ETH1_INDEX); EXPECT_TRUE(srv.accept(pkt)); // Let's set hops and check that the message is still accepted as // a relayed message. pkt->setHops(1); EXPECT_TRUE(srv.accept(pkt)); // Make it a direct message but keep unicast server's address. The // messages sent to unicast address should be accepted as they are // most likely to renew existing leases. The server should respond // to renews so they have to be accepted and processed. pkt->setHops(0); pkt->setGiaddr(IOAddress("0.0.0.0")); EXPECT_TRUE(srv.accept(pkt)); // Direct message is now sent to a broadcast address. The server // should accept this message because it has been received via // eth1 for which there is a subnet configured (see test fixture // class constructor). pkt->setLocalAddr(IOAddress("255.255.255.255")); EXPECT_TRUE(srv.accept(pkt)); // For eth0, there is no subnet configured. Such message is expected // to be silently dropped. pkt->setIface("eth0"); pkt->setIndex(ETH0_INDEX); EXPECT_FALSE(srv.accept(pkt)); // But, if the message is unicast it should be accepted, even though // it has been received via eth0. pkt->setLocalAddr(IOAddress("10.0.0.1")); EXPECT_TRUE(srv.accept(pkt)); // For the DHCPINFORM the ciaddr should be set or at least the source // address. pkt->setType(DHCPINFORM); pkt->setRemoteAddr(IOAddress("10.0.0.101")); EXPECT_TRUE(srv.accept(pkt)); // When neither ciaddr nor source address is present, the packet should // be dropped. pkt->setRemoteAddr(IOAddress("0.0.0.0")); EXPECT_FALSE(srv.accept(pkt)); // When ciaddr is set, the packet should be accepted. pkt->setCiaddr(IOAddress("10.0.0.1")); EXPECT_TRUE(srv.accept(pkt)); } // This test checks that the server rejects a message with invalid type. TEST_F(Dhcpv4SrvTest, acceptMessageType) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); // Specify messages to be accepted by the server. int allowed[] = { DHCPDISCOVER, DHCPREQUEST, DHCPRELEASE, DHCPDECLINE, DHCPINFORM }; size_t allowed_size = sizeof(allowed) / sizeof(allowed[0]); // Check that the server actually accepts these message types. for (size_t i = 0; i < allowed_size; ++i) { EXPECT_TRUE(srv.acceptMessageType(Pkt4Ptr(new Pkt4(allowed[i], 1234)))) << "Test failed for message type " << i; } // Specify messages which server is supposed to drop. int not_allowed[] = { DHCPOFFER, DHCPACK, DHCPNAK, DHCPLEASEQUERY, DHCPLEASEUNASSIGNED, DHCPLEASEUNKNOWN, DHCPLEASEACTIVE, DHCPBULKLEASEQUERY, DHCPLEASEQUERYDONE, }; size_t not_allowed_size = sizeof(not_allowed) / sizeof(not_allowed[0]); // Actually check that the server will drop these messages. for (size_t i = 0; i < not_allowed_size; ++i) { EXPECT_FALSE(srv.acceptMessageType(Pkt4Ptr(new Pkt4(not_allowed[i], 1234)))) << "Test failed for message type " << i; } // Verify that we drop packets with no option 53 // Make a BOOTP packet (i.e. no option 53) std::vector bin; const char* bootp_txt = "01010601002529b629b600000000000000000000000000000ace5001944452fe711700" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000063825363521b010400" "020418020600237453fc48090b0000118b06010401020300ff00000000000000000000" "0000000000000000000000000000000000000000"; isc::util::encode::decodeHex(bootp_txt, bin); Pkt4Ptr pkt(new Pkt4(&bin[0], bin.size())); pkt->unpack(); ASSERT_EQ(DHCP_NOTYPE, pkt->getType()); EXPECT_FALSE(srv.acceptMessageType(Pkt4Ptr(new Pkt4(&bin[0], bin.size())))); // Verify that we drop packets with types >= DHCP_TYPES_EOF // Make Discover with type changed to 0xff std::vector bin2; const char* invalid_msg_type = "010106015d05478d000000000000000000000000000000000afee20120e52ab8151400" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000638253633501ff3707" "0102030407067d3c0a646f63736973332e303a7d7f0000118b7a010102057501010102" "010303010104010105010106010107010f0801100901030a01010b01180c01010d0200" "400e0200100f010110040000000211010014010015013f160101170101180104190104" "1a01041b01201c01021d01081e01201f01102001102101022201012301002401002501" "01260200ff2701012b59020345434d030b45434d3a45524f55544552040d3242523232" "39553430303434430504312e3034060856312e33332e30330707322e332e3052320806" "30303039354209094347333030304443520a074e657467656172fe01083d0fff2ab815" "140003000120e52ab81514390205dc5219010420000002020620e52ab8151409090000" "118b0401020300ff"; bin.clear(); isc::util::encode::decodeHex(invalid_msg_type, bin); pkt.reset(new Pkt4(&bin[0], bin.size())); pkt->unpack(); ASSERT_EQ(0xff, pkt->getType()); EXPECT_FALSE(srv.acceptMessageType(pkt)); } // Test checks whether statistic is bumped up appropriately when Decline // message is received. TEST_F(Dhcpv4SrvTest, statisticsDecline) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], DHCPDECLINE, "pkt4-decline-received"); } // Test checks whether statistic is bumped up appropriately when Offer // message is received (this should never happen in a sane network). TEST_F(Dhcpv4SrvTest, statisticsOfferRcvd) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], DHCPOFFER, "pkt4-offer-received"); } // Test checks whether statistic is bumped up appropriately when Ack // message is received (this should never happen in a sane network). TEST_F(Dhcpv4SrvTest, statisticsAckRcvd) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], DHCPACK, "pkt4-ack-received"); } // Test checks whether statistic is bumped up appropriately when Nak // message is received (this should never happen in a sane network). TEST_F(Dhcpv4SrvTest, statisticsNakRcvd) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], DHCPNAK, "pkt4-nak-received"); } // Test checks whether statistic is bumped up appropriately when Release // message is received. TEST_F(Dhcpv4SrvTest, statisticsReleaseRcvd) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], DHCPRELEASE, "pkt4-release-received"); } // Test checks whether statistic is bumped up appropriately when unknown // message is received. TEST_F(Dhcpv4SrvTest, statisticsUnknownRcvd) { NakedDhcpv4Srv srv(0); pretendReceivingPkt(srv, CONFIGS[0], 200, "pkt4-unknown-received"); // There should also be pkt4-receive-drop stat bumped up using namespace isc::stats; StatsMgr& mgr = StatsMgr::instance(); ObservationPtr drop_stat = mgr.getObservation("pkt4-receive-drop"); // This statistic must be present and must be set to 1. ASSERT_TRUE(drop_stat); EXPECT_EQ(1, drop_stat->getInteger().first); } // This test verifies that the server is able to handle an empty client-id // in incoming client message. TEST_F(Dhcpv4SrvTest, emptyClientId) { IfaceMgrTestConfig test_config(true); Dhcp4Client client; EXPECT_NO_THROW(configure(CONFIGS[0], *client.getServer())); // Tell the client to not send client-id on its own. client.includeClientId(""); // Instead, tell him to send this extra option, which happens to be // an empty client-id. OptionPtr empty_client_id(new Option(Option::V4, DHO_DHCP_CLIENT_IDENTIFIER)); client.addExtraOption(empty_client_id); // Let's check whether the server is able to process this packet without // throwing any exceptions. We don't care whether the server sent any // responses or not. The goal is to check that the server didn't throw // any exceptions. EXPECT_NO_THROW(client.doDORA()); } // This test verifies that the server is able to handle too long client-id // in incoming client message. TEST_F(Dhcpv4SrvTest, tooLongClientId) { IfaceMgrTestConfig test_config(true); Dhcp4Client client; EXPECT_NO_THROW(configure(CONFIGS[0], *client.getServer())); // Tell the client to not send client-id on its own. client.includeClientId(""); // Instead, tell him to send this extra option, which happens to be // an empty client-id. std::vector data(250, 250); OptionPtr long_client_id(new Option(Option::V4, DHO_DHCP_CLIENT_IDENTIFIER, data)); client.addExtraOption(long_client_id); // Let's check whether the server is able to process this packet without // throwing any exceptions. We don't care whether the server sent any // responses or not. The goal is to check that the server didn't throw // any exceptions. EXPECT_NO_THROW(client.doDORA()); } // Checks if user-contexts are parsed properly. TEST_F(Dhcpv4SrvTest, userContext) { IfaceMgrTestConfig test_config(true); NakedDhcpv4Srv srv(0); // This config has one subnet with user-context with one // pool (also with context). Make sure the configuration could be accepted. cout << CONFIGS[3] << endl; EXPECT_NO_THROW(configure(CONFIGS[3])); // Now make sure the data was not lost. ConstSrvConfigPtr cfg = CfgMgr::instance().getCurrentCfg(); const Subnet4Collection* subnets = cfg->getCfgSubnets4()->getAll(); ASSERT_TRUE(subnets); ASSERT_EQ(1, subnets->size()); // Let's get the subnet and check its context. Subnet4Ptr subnet1 = *subnets->begin(); ASSERT_TRUE(subnet1); ASSERT_TRUE(subnet1->getContext()); EXPECT_EQ("{ \"secure\": false }", subnet1->getContext()->str()); // Ok, not get the sole pool in it and check its context, too. PoolCollection pools = subnet1->getPools(Lease::TYPE_V4); ASSERT_EQ(1, pools.size()); ASSERT_TRUE(pools[0]); ASSERT_TRUE(pools[0]->getContext()); EXPECT_EQ("{ \"value\": 42 }", pools[0]->getContext()->str()); } // Verify that fixed fields are set from classes in the same order // as class options. TEST_F(Dhcpv4SrvTest, fixedFieldsInClassOrder) { IfaceMgrTestConfig test_config(true); IfaceMgr::instance().openSockets4(); NakedDhcpv4Srv srv(0); std::string config = R"( { "interfaces-config": { "interfaces": [ "*" ] }, "client-classes": [ { "name":"one", "server-hostname": "server_one", "next-server": "192.0.2.111", "boot-file-name":"one.boot", "option-data": [ { "name": "domain-name", "data": "one.example.com" }] }, { "name":"two", "server-hostname": "server_two", "next-server":"192.0.2.222", "boot-file-name":"two.boot", "option-data": [ { "name": "domain-name", "data": "two.example.com" }] }, { "name":"next-server-only", "next-server":"192.0.2.100" }, { "name":"server-hostname-only", "server-hostname": "server_only" }, { "name":"bootfile-only", "boot-file-name": "only.boot" }], "subnet4": [ { "subnet": "192.0.2.0/24", "pools": [ { "pool": "192.0.2.1 - 192.0.2.100" } ], "reservations": [ { "hw-address": "08:00:27:25:d3:01", "client-classes": [ "one", "two" ] }, { "hw-address": "08:00:27:25:d3:02", "client-classes": [ "two", "one" ] }, { "hw-address": "08:00:27:25:d3:03", "client-classes": [ "server-hostname-only", "bootfile-only", "next-server-only" ] }] }] } )"; ConstElementPtr json; ASSERT_NO_THROW_LOG(json = parseDHCP4(config)); ConstElementPtr status; // Configure the server and make sure the config is accepted EXPECT_NO_THROW(status = configureDhcp4Server(srv, json)); ASSERT_TRUE(status); comment_ = config::parseAnswer(rcode_, status); ASSERT_EQ(0, rcode_); CfgMgr::instance().commit(); struct Scenario { std::string hw_str_; std::string exp_classes_; std::string exp_server_hostname_; std::string exp_next_server_; std::string exp_bootfile_; std::string exp_domain_name_; }; const std::vector scenarios = { { "08:00:27:25:d3:01", "ALL, one, two, KNOWN", "server_one", "192.0.2.111", "one.boot", "one.example.com" }, { "08:00:27:25:d3:02", "ALL, two, one, KNOWN", "server_two", "192.0.2.222", "two.boot", "two.example.com" }, { "08:00:27:25:d3:03", "ALL, server-hostname-only, bootfile-only, next-server-only, KNOWN", "server_only", "192.0.2.100", "only.boot", "" } }; for (auto scenario : scenarios) { SCOPED_TRACE(scenario.hw_str_); { // Build a DISCOVER Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 1234)); query->setRemoteAddr(IOAddress("192.0.2.1")); query->setIface("eth1"); HWAddrPtr hw_addr(new HWAddr(HWAddr::fromText(scenario.hw_str_, 10))); query->setHWAddr(hw_addr); // Process it. Pkt4Ptr response = srv.processDiscover(query); // Make sure class list is as expected. ASSERT_EQ(scenario.exp_classes_, query->getClasses().toText()); // Now check the fixed fields. checkStringInBuffer(scenario.exp_server_hostname_, response->getSname()); EXPECT_EQ(scenario.exp_next_server_, response->getSiaddr().toText()); checkStringInBuffer(scenario.exp_bootfile_, response->getFile()); // Check domain name option. OptionPtr opt = response->getOption(DHO_DOMAIN_NAME); if (scenario.exp_domain_name_.empty()) { ASSERT_FALSE(opt); } else { ASSERT_TRUE(opt); OptionStringPtr opstr = boost::dynamic_pointer_cast(opt); ASSERT_TRUE(opstr); EXPECT_EQ(scenario.exp_domain_name_, opstr->getValue()); } } } } /// @todo: Implement proper tests for MySQL lease/host database, /// see ticket #4214. } // end of anonymous namespace