BIND 10 trac2765, updated. d0506dcfcf7798859931851c3eb90956dd4bb03c [2765] Implemented the logic which opens fallback a socket.
BIND 10 source code commits
bind10-changes at lists.isc.org
Tue Nov 26 17:37:28 UTC 2013
The branch, trac2765 has been updated
via d0506dcfcf7798859931851c3eb90956dd4bb03c (commit)
via 09811212553870d80e7958fb1161146a99e2d216 (commit)
via 4507742b539d4b992b184d3aefdc005264871973 (commit)
via 67e3af3c8a57868712f85d86d47e1936ee834628 (commit)
via 721815f9c773352c738b5bcf3a7e88bb9ad4cbf8 (commit)
from 4e225668a62a8fde0edb28a2938d968989f3cbc4 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit d0506dcfcf7798859931851c3eb90956dd4bb03c
Author: Marcin Siodelski <marcin at isc.org>
Date: Tue Nov 26 18:37:02 2013 +0100
[2765] Implemented the logic which opens fallback a socket.
commit 09811212553870d80e7958fb1161146a99e2d216
Author: Marcin Siodelski <marcin at isc.org>
Date: Tue Nov 26 18:36:09 2013 +0100
[2765] Moved the PktFilter test fixture class to the common class.
commit 4507742b539d4b992b184d3aefdc005264871973
Author: Marcin Siodelski <marcin at isc.org>
Date: Tue Nov 26 14:19:50 2013 +0100
[2765] Added stub implementation for the function to open fallback socket.
commit 67e3af3c8a57868712f85d86d47e1936ee834628
Author: Marcin Siodelski <marcin at isc.org>
Date: Tue Nov 26 14:18:55 2013 +0100
[2765] Initialize and uninitialize fallback socket in the LPF tests.
commit 721815f9c773352c738b5bcf3a7e88bb9ad4cbf8
Author: Marcin Siodelski <marcin at isc.org>
Date: Tue Nov 26 13:24:31 2013 +0100
[2765] Fixed failing unit tests for the raw sockets using LPF.
-----------------------------------------------------------------------
Summary of changes:
src/lib/dhcp/Makefile.am | 2 +-
src/lib/dhcp/pkt_filter.cc | 51 +++++++++
src/lib/dhcp/pkt_filter.h | 24 ++++
src/lib/dhcp/pkt_filter_lpf.cc | 13 ++-
src/lib/dhcp/tests/Makefile.am | 2 +
src/lib/dhcp/tests/pkt_filter_inet_unittest.cc | 114 ++++--------------
src/lib/dhcp/tests/pkt_filter_lpf_unittest.cc | 100 +++++-----------
src/lib/dhcp/tests/pkt_filter_test_utils.cc | 112 ++++++++++++++++++
src/lib/dhcp/tests/pkt_filter_test_utils.h | 146 ++++++++++++++++++++++++
src/lib/dhcp/tests/pkt_filter_unittest.cc | 65 +++++++++++
10 files changed, 463 insertions(+), 166 deletions(-)
create mode 100644 src/lib/dhcp/pkt_filter.cc
create mode 100644 src/lib/dhcp/tests/pkt_filter_test_utils.cc
create mode 100644 src/lib/dhcp/tests/pkt_filter_test_utils.h
create mode 100644 src/lib/dhcp/tests/pkt_filter_unittest.cc
-----------------------------------------------------------------------
diff --git a/src/lib/dhcp/Makefile.am b/src/lib/dhcp/Makefile.am
index 7a3a559..eb9309a 100644
--- a/src/lib/dhcp/Makefile.am
+++ b/src/lib/dhcp/Makefile.am
@@ -41,7 +41,7 @@ libb10_dhcp___la_SOURCES += option_string.cc option_string.h
libb10_dhcp___la_SOURCES += protocol_util.cc protocol_util.h
libb10_dhcp___la_SOURCES += pkt6.cc pkt6.h
libb10_dhcp___la_SOURCES += pkt4.cc pkt4.h
-libb10_dhcp___la_SOURCES += pkt_filter.h
+libb10_dhcp___la_SOURCES += pkt_filter.h pkt_filter.cc
libb10_dhcp___la_SOURCES += pkt_filter_inet.cc pkt_filter_inet.h
if OS_LINUX
diff --git a/src/lib/dhcp/pkt_filter.cc b/src/lib/dhcp/pkt_filter.cc
new file mode 100644
index 0000000..92834bf
--- /dev/null
+++ b/src/lib/dhcp/pkt_filter.cc
@@ -0,0 +1,51 @@
+// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <dhcp/iface_mgr.h>
+#include <dhcp/pkt_filter.h>
+
+namespace isc {
+namespace dhcp {
+
+int
+PktFilter::openFallbackSocket(const isc::asiolink::IOAddress& addr,
+ const uint16_t port) {
+ // Create socket.
+ int sock = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sock < 0) {
+ isc_throw(SocketConfigError, "failed to create fallback socket for address "
+ << addr.toText() << ", port " << port);
+ }
+ // Bind the socket to a specified address and port.
+ struct sockaddr_in addr4;
+ memset(&addr4, 0, sizeof(addr4));
+ addr4.sin_family = AF_INET;
+ addr4.sin_addr.s_addr = htonl(addr);
+ addr4.sin_port = htons(port);
+
+ if (bind(sock, reinterpret_cast<struct sockaddr*>(&addr4), sizeof(addr4)) < 0) {
+ // Remember to close the socket if we failed to bind it.
+ close(sock);
+ isc_throw(SocketConfigError, "failed to bind fallback socket to address "
+ << addr.toText() << ", port " << port << " - is another DHCP "
+ "server running?");
+ }
+ // Successfully created and bound a fallback socket. Return a descriptor.
+ return (sock);
+}
+
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
diff --git a/src/lib/dhcp/pkt_filter.h b/src/lib/dhcp/pkt_filter.h
index f2a028d..1636abd 100644
--- a/src/lib/dhcp/pkt_filter.h
+++ b/src/lib/dhcp/pkt_filter.h
@@ -110,6 +110,30 @@ public:
/// @return result of sending the packet. It is 0 if successful.
virtual int send(const Iface& iface, uint16_t sockfd,
const Pkt4Ptr& pkt) = 0;
+
+protected:
+
+ /// @brief Default implementation to open a fallback socket.
+ ///
+ /// This method provides a means to open a fallback socket and bind it
+ /// to a given IPv4 address and UDP port. This function may be used by the
+ /// derived classes to create a fallback socket. It can be overriden
+ /// in the derived classes if it happens to be insufficient on some
+ /// environments.
+ ///
+ /// The fallback socket is meant to be opened together with the other socket
+ /// (a.k.a. primary socket) used to receive and handle DHCPv4 traffic. The
+ /// traffic received through the fallback should be dropped. The reasoning
+ /// behind opening the fallback socket is explained in the documentation of
+ /// @s isc::dhcp::SocketInfo structure.
+ ///
+ /// @param addr An IPv4 address to bind the socket to.
+ /// @param port A port number to bind socket to.
+ ///
+ /// @return A fallback socket descriptor. This descriptor should be assigned
+ /// to the @c fallbackfd_ field of the @c isc::dhcp::SocketInfo structure.
+ virtual int openFallbackSocket(const isc::asiolink::IOAddress& addr,
+ const uint16_t port);
};
/// Pointer to a PktFilter object.
diff --git a/src/lib/dhcp/pkt_filter_lpf.cc b/src/lib/dhcp/pkt_filter_lpf.cc
index 7faa341..81d53f2 100644
--- a/src/lib/dhcp/pkt_filter_lpf.cc
+++ b/src/lib/dhcp/pkt_filter_lpf.cc
@@ -230,9 +230,16 @@ PktFilterLPF::send(const Iface& iface, uint16_t sockfd, const Pkt4Ptr& pkt) {
OutputBuffer buf(14);
- HWAddrPtr hwaddr(new HWAddr(iface.getMac(), iface.getMacLen(),
- iface.getHWType()));
- pkt->setLocalHWAddr(hwaddr);
+ // Some interfaces may have no HW address - e.g. loopback interface.
+ // For these interfaces the HW address length is 0. If this is the case,
+ // then we will rely on the functions which construct the IP/UDP headers
+ // to provide a default HW addres. Otherwise, create the HW address
+ // object using the HW address of the interface.
+ if (iface.getMacLen() > 0) {
+ HWAddrPtr hwaddr(new HWAddr(iface.getMac(), iface.getMacLen(),
+ iface.getHWType()));
+ pkt->setLocalHWAddr(hwaddr);
+ }
// Ethernet frame header.
diff --git a/src/lib/dhcp/tests/Makefile.am b/src/lib/dhcp/tests/Makefile.am
index 79bfde7..19678dd 100644
--- a/src/lib/dhcp/tests/Makefile.am
+++ b/src/lib/dhcp/tests/Makefile.am
@@ -48,7 +48,9 @@ libdhcp___unittests_SOURCES += option_string_unittest.cc
libdhcp___unittests_SOURCES += option_vendor_unittest.cc
libdhcp___unittests_SOURCES += pkt4_unittest.cc
libdhcp___unittests_SOURCES += pkt6_unittest.cc
+libdhcp___unittests_SOURCES += pkt_filter_unittest.cc
libdhcp___unittests_SOURCES += pkt_filter_inet_unittest.cc
+libdhcp___unittests_SOURCES += pkt_filter_test_utils.h pkt_filter_test_utils.cc
if OS_LINUX
libdhcp___unittests_SOURCES += pkt_filter_lpf_unittest.cc
diff --git a/src/lib/dhcp/tests/pkt_filter_inet_unittest.cc b/src/lib/dhcp/tests/pkt_filter_inet_unittest.cc
index 81ac0e7..bce89ad 100644
--- a/src/lib/dhcp/tests/pkt_filter_inet_unittest.cc
+++ b/src/lib/dhcp/tests/pkt_filter_inet_unittest.cc
@@ -17,6 +17,7 @@
#include <dhcp/iface_mgr.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt_filter_inet.h>
+#include <dhcp/tests/pkt_filter_test_utils.h>
#include <gtest/gtest.h>
@@ -32,63 +33,12 @@ const uint16_t PORT = 10067;
/// Size of the buffer holding received packets.
const size_t RECV_BUF_SIZE = 2048;
-/// This class handles has simple algorithm checking
-/// presence of loopback interface and initializing
-/// its index.
-class PktFilterInetTest : public ::testing::Test {
+// Test fixture class inherits from the class common for all packet
+// filter tests.
+class PktFilterInetTest : public isc::dhcp::test::PktFilterTest {
public:
-
- /// @brief Constructor
- ///
- /// This constructor initializes socket_ member to a negative value.
- /// Explcit initialization is performed here because some of the
- /// tests do not initialize this value. In such cases, destructor
- /// could invoke close() on uninitialized socket descriptor which
- /// would result in errors being reported by Valgrind.
- PktFilterInetTest()
- : socket_(-1) {
- // Initialize ifname_ and ifindex_.
- loInit();
- }
-
- /// @brief Destructor
- ///
- /// Closes open socket (if any).
- ~PktFilterInetTest() {
- // Cleanup after each test. This guarantees
- // that the socket does not hang after a test.
- if (socket_ >= 0) {
- close(socket_);
- }
+ PktFilterInetTest() : PktFilterTest(PORT) {
}
-
- /// @brief Detect loopback interface.
- ///
- /// @todo this function will be removed once cross-OS interface
- /// detection is implemented
- void loInit() {
- if (if_nametoindex("lo") > 0) {
- ifname_ = "lo";
- ifindex_ = if_nametoindex("lo");
-
- } else if (if_nametoindex("lo0") > 0) {
- ifname_ = "lo0";
- ifindex_ = if_nametoindex("lo0");
-
- } else {
- std::cout << "Failed to detect loopback interface. Neither "
- << "lo nor lo0 worked. Giving up." << std::endl;
- FAIL();
-
-
-
- }
- }
-
- std::string ifname_; ///< Loopback interface name
- uint16_t ifindex_; ///< Loopback interface index.
- int socket_; ///< Socket descriptor.
-
};
// This test verifies that the PktFilterInet class reports its lack
@@ -112,29 +62,14 @@ TEST_F(PktFilterInetTest, openSocket) {
// Try to open socket.
PktFilterInet pkt_filter;
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- // Check that socket has been opened.
- ASSERT_GE(socket_, 0);
-
- // Verify that the socket belongs to AF_INET family.
- sockaddr_in sock_address;
- socklen_t sock_address_len = sizeof(sock_address);
- ASSERT_EQ(0, getsockname(socket_, reinterpret_cast<sockaddr*>(&sock_address),
- &sock_address_len));
- EXPECT_EQ(AF_INET, sock_address.sin_family);
-
- // Verify that the socket is bound the appropriate address.
- const std::string bind_addr(inet_ntoa(sock_address.sin_addr));
- EXPECT_EQ("127.0.0.1", bind_addr);
-
- // Verify that the socket is bound to appropriate port.
- EXPECT_EQ(PORT, ntohs(sock_address.sin_port));
-
- // Verify that the socket has SOCK_DGRAM type.
- int sock_type;
- socklen_t sock_type_len = sizeof(sock_type);
- ASSERT_EQ(0, getsockopt(socket_, SOL_SOCKET, SO_TYPE, &sock_type, &sock_type_len));
- EXPECT_EQ(SOCK_DGRAM, sock_type);
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT,
+ false, false);
+ // For the packet filter in use, the fallback socket shouldn't be opened.
+ // Fallback is typically opened for raw sockets.
+ EXPECT_LT(sock_info_.fallbackfd_, 0);
+
+ // Test the primary socket.
+ testDgramSocket(sock_info_.sockfd_);
}
// This test verifies that the packet is correctly sent over the INET
@@ -170,27 +105,27 @@ TEST_F(PktFilterInetTest, send) {
// Open socket. We don't check that the socket has appropriate
// options and family set because we have checked that in the
// openSocket test already.
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- ASSERT_GE(socket_, 0);
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT, false, false);
+ ASSERT_GE(sock_info_.sockfd_, 0);
// Send the packet over the socket.
- ASSERT_NO_THROW(pkt_filter.send(iface, socket_, pkt));
+ ASSERT_NO_THROW(pkt_filter.send(iface, sock_info_.sockfd_, pkt));
// Read the data from socket.
fd_set readfds;
FD_ZERO(&readfds);
- FD_SET(socket_, &readfds);
-
+ FD_SET(sock_info_.sockfd_, &readfds);
+
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
- int result = select(socket_ + 1, &readfds, NULL, NULL, &timeout);
+ int result = select(sock_info_.sockfd_ + 1, &readfds, NULL, NULL, &timeout);
// We should receive some data from loopback interface.
ASSERT_GT(result, 0);
// Get the actual data.
uint8_t rcv_buf[RECV_BUF_SIZE];
- result = recv(socket_, rcv_buf, RECV_BUF_SIZE, 0);
+ result = recv(sock_info_.sockfd_, rcv_buf, RECV_BUF_SIZE, 0);
ASSERT_GT(result, 0);
// Create the DHCPv4 packet from the received data.
@@ -249,15 +184,14 @@ TEST_F(PktFilterInetTest, receive) {
// Open socket. We don't check that the socket has appropriate
// options and family set because we have checked that in the
// openSocket test already.
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- ASSERT_GE(socket_, 0);
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT, false, false);
+ ASSERT_GE(sock_info_.sockfd_, 0);
// Send the packet over the socket.
- ASSERT_NO_THROW(pkt_filter.send(iface, socket_, pkt));
+ ASSERT_NO_THROW(pkt_filter.send(iface, sock_info_.sockfd_, pkt));
// Receive the packet.
- SocketInfo socket_info(IOAddress("127.0.0.1"), PORT, socket_);
- Pkt4Ptr rcvd_pkt = pkt_filter.receive(iface, socket_info);
+ Pkt4Ptr rcvd_pkt = pkt_filter.receive(iface, sock_info_);
// Check that the packet has been correctly received.
ASSERT_TRUE(rcvd_pkt);
diff --git a/src/lib/dhcp/tests/pkt_filter_lpf_unittest.cc b/src/lib/dhcp/tests/pkt_filter_lpf_unittest.cc
index 1b5fc4b..dd5d7f8 100644
--- a/src/lib/dhcp/tests/pkt_filter_lpf_unittest.cc
+++ b/src/lib/dhcp/tests/pkt_filter_lpf_unittest.cc
@@ -18,6 +18,7 @@
#include <dhcp/pkt4.h>
#include <dhcp/pkt_filter_lpf.h>
#include <dhcp/protocol_util.h>
+#include <dhcp/tests/pkt_filter_test_utils.h>
#include <util/buffer.h>
#include <gtest/gtest.h>
@@ -36,63 +37,12 @@ const uint16_t PORT = 10067;
/// Size of the buffer holding received packets.
const size_t RECV_BUF_SIZE = 2048;
-/// This class handles has simple algorithm checking
-/// presence of loopback interface and initializing
-/// its index.
-class PktFilterLPFTest : public ::testing::Test {
+// Test fixture class inherits from the class common for all packet
+// filter tests.
+class PktFilterLPFTest : public isc::dhcp::test::PktFilterTest {
public:
-
- /// @brief Constructor
- ///
- /// This constructor initializes socket_ member to a negative value.
- /// Explcit initialization is performed here because some of the
- /// tests do not initialize this value. In such cases, destructor
- /// could invoke close() on uninitialized socket descriptor which
- /// would result in errors being reported by Valgrind.
- PktFilterLPFTest()
- : socket_(-1) {
- // Initialize ifname_ and ifindex_.
- loInit();
- }
-
- /// @brief Destructor
- ///
- /// Closes open socket (if any).
- ~PktFilterLPFTest() {
- // Cleanup after each test. This guarantees
- // that the socket does not hang after a test.
- if (socket_ >= 0) {
- close(socket_);
- }
- }
-
- /// @brief Detect loopback interface.
- ///
- /// @todo this function will be removed once cross-OS interface
- /// detection is implemented
- void loInit() {
- if (if_nametoindex("lo") > 0) {
- ifname_ = "lo";
- ifindex_ = if_nametoindex("lo");
-
- } else if (if_nametoindex("lo0") > 0) {
- ifname_ = "lo0";
- ifindex_ = if_nametoindex("lo0");
-
- } else {
- std::cout << "Failed to detect loopback interface. Neither "
- << "lo nor lo0 worked. Giving up." << std::endl;
- FAIL();
-
-
-
- }
+ PktFilterLPFTest() : PktFilterTest(PORT) {
}
-
- std::string ifname_; ///< Loopback interface name
- uint16_t ifindex_; ///< Loopback interface index.
- int socket_; ///< Socket descriptor.
-
};
// This test verifies that the PktFilterLPF class reports its capability
@@ -124,14 +74,18 @@ TEST_F(PktFilterLPFTest, DISABLED_openSocket) {
// Try to open socket.
PktFilterLPF pkt_filter;
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- // Check that socket has been opened.
- ASSERT_GE(socket_, 0);
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT, false, false);
+
+ // Check that the primary socket has been opened.
+ ASSERT_GE(sock_info_.sockfd_, 0);
+ // Check that the fallback socket has been opened too.
+ ASSERT_GE(sock_info_.fallbackfd_, 0);
// Verify that the socket belongs to AF_PACKET family.
sockaddr_ll sock_address;
socklen_t sock_address_len = sizeof(sock_address);
- ASSERT_EQ(0, getsockname(socket_, reinterpret_cast<sockaddr*>(&sock_address),
+ ASSERT_EQ(0, getsockname(sock_info_.sockfd_,
+ reinterpret_cast<sockaddr*>(&sock_address),
&sock_address_len));
EXPECT_EQ(AF_PACKET, sock_address.sll_family);
@@ -141,7 +95,8 @@ TEST_F(PktFilterLPFTest, DISABLED_openSocket) {
// Verify that the socket has SOCK_RAW type.
int sock_type;
socklen_t sock_type_len = sizeof(sock_type);
- ASSERT_EQ(0, getsockopt(socket_, SOL_SOCKET, SO_TYPE, &sock_type, &sock_type_len));
+ ASSERT_EQ(0, getsockopt(sock_info_.sockfd_, SOL_SOCKET, SO_TYPE,
+ &sock_type, &sock_type_len));
EXPECT_EQ(SOCK_RAW, sock_type);
}
@@ -183,27 +138,29 @@ TEST_F(PktFilterLPFTest, DISABLED_send) {
// Open socket. We don't check that the socket has appropriate
// options and family set because we have checked that in the
// openSocket test already.
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- ASSERT_GE(socket_, 0);
+
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT, false, false);
+
+ ASSERT_GE(sock_info_.sockfd_, 0);
// Send the packet over the socket.
- ASSERT_NO_THROW(pkt_filter.send(iface, socket_, pkt));
+ ASSERT_NO_THROW(pkt_filter.send(iface, sock_info_.sockfd_, pkt));
// Read the data from socket.
fd_set readfds;
FD_ZERO(&readfds);
- FD_SET(socket_, &readfds);
-
+ FD_SET(sock_info_.sockfd_, &readfds);
+
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
- int result = select(socket_ + 1, &readfds, NULL, NULL, &timeout);
+ int result = select(sock_info_.sockfd_ + 1, &readfds, NULL, NULL, &timeout);
// We should receive some data from loopback interface.
ASSERT_GT(result, 0);
// Get the actual data.
uint8_t rcv_buf[RECV_BUF_SIZE];
- result = recv(socket_, rcv_buf, RECV_BUF_SIZE, 0);
+ result = recv(sock_info_.sockfd_, rcv_buf, RECV_BUF_SIZE, 0);
ASSERT_GT(result, 0);
Pkt4Ptr dummy_pkt = Pkt4Ptr(new Pkt4(DHCPDISCOVER, 0));
@@ -273,15 +230,14 @@ TEST_F(PktFilterLPFTest, DISABLED_receive) {
// Open socket. We don't check that the socket has appropriate
// options and family set because we have checked that in the
// openSocket test already.
- socket_ = pkt_filter.openSocket(iface, addr, PORT, false, false).sockfd_;
- ASSERT_GE(socket_, 0);
+ sock_info_ = pkt_filter.openSocket(iface, addr, PORT, false, false);
+ ASSERT_GE(sock_info_.sockfd_, 0);
// Send the packet over the socket.
- ASSERT_NO_THROW(pkt_filter.send(iface, socket_, pkt));
+ ASSERT_NO_THROW(pkt_filter.send(iface, sock_info_.sockfd_, pkt));
// Receive the packet.
- SocketInfo socket_info(socket_, IOAddress("127.0.0.1"), PORT);
- Pkt4Ptr rcvd_pkt = pkt_filter.receive(iface, socket_info);
+ Pkt4Ptr rcvd_pkt = pkt_filter.receive(iface, sock_info_);
// Check that the packet has been correctly received.
ASSERT_TRUE(rcvd_pkt);
diff --git a/src/lib/dhcp/tests/pkt_filter_test_utils.cc b/src/lib/dhcp/tests/pkt_filter_test_utils.cc
new file mode 100644
index 0000000..8a62623
--- /dev/null
+++ b/src/lib/dhcp/tests/pkt_filter_test_utils.cc
@@ -0,0 +1,112 @@
+// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+
+#include <dhcp/pkt4.h>
+#include <dhcp/tests/pkt_filter_test_utils.h>
+
+namespace isc {
+namespace dhcp {
+namespace test {
+
+PktFilterTest::PktFilterTest(const uint16_t port)
+ : port_(port),
+ sock_info_(isc::asiolink::IOAddress("127.0.0.1"), port, -1, -1) {
+ // Initialize ifname_ and ifindex_.
+ loInit();
+}
+
+PktFilterTest::~PktFilterTest() {
+ // Cleanup after each test. This guarantees
+ // that the sockets do not hang after a test.
+ if (sock_info_.sockfd_ >= 0) {
+ close(sock_info_.sockfd_);
+ }
+ if (sock_info_.fallbackfd_ >=0) {
+ close(sock_info_.fallbackfd_);
+ }
+}
+
+void
+PktFilterTest::loInit() {
+ if (if_nametoindex("lo") > 0) {
+ ifname_ = "lo";
+ ifindex_ = if_nametoindex("lo");
+
+ } else if (if_nametoindex("lo0") > 0) {
+ ifname_ = "lo0";
+ ifindex_ = if_nametoindex("lo0");
+
+ } else {
+ std::cout << "Failed to detect loopback interface. Neither "
+ << "lo nor lo0 worked. Giving up." << std::endl;
+ FAIL();
+
+ }
+}
+
+void
+PktFilterTest::testDgramSocket(const int sock) const {
+ // Check that socket has been opened.
+ ASSERT_GE(sock, 0);
+
+ // Verify that the socket belongs to AF_INET family.
+ sockaddr_in sock_address;
+ socklen_t sock_address_len = sizeof(sock_address);
+ ASSERT_EQ(0, getsockname(sock,
+ reinterpret_cast<sockaddr*>(&sock_address),
+ &sock_address_len));
+ EXPECT_EQ(AF_INET, sock_address.sin_family);
+
+ // Verify that the socket is bound the appropriate address.
+ const std::string bind_addr(inet_ntoa(sock_address.sin_addr));
+ EXPECT_EQ("127.0.0.1", bind_addr);
+
+ // Verify that the socket is bound to appropriate port.
+ EXPECT_EQ(port_, ntohs(sock_address.sin_port));
+
+ // Verify that the socket has SOCK_DGRAM type.
+ int sock_type;
+ socklen_t sock_type_len = sizeof(sock_type);
+ ASSERT_EQ(0, getsockopt(sock, SOL_SOCKET, SO_TYPE,
+ &sock_type, &sock_type_len));
+ EXPECT_EQ(SOCK_DGRAM, sock_type);
+}
+
+bool
+PktFilterStub::isDirectResponseSupported() const {
+ return (true);
+}
+
+SocketInfo
+PktFilterStub::openSocket(const Iface&,
+ const isc::asiolink::IOAddress& addr,
+ const uint16_t port, const bool, const bool) {
+ return (SocketInfo(addr, port, 0));
+}
+
+Pkt4Ptr
+PktFilterStub::receive(const Iface&, const SocketInfo&) {
+ return Pkt4Ptr();
+}
+
+int
+PktFilterStub::send(const Iface&, uint16_t, const Pkt4Ptr&) {
+ return (0);
+}
+
+
+} // end of isc::dhcp::test namespace
+} // end of isc::dhcp namespace
+} // end of isc namespace
diff --git a/src/lib/dhcp/tests/pkt_filter_test_utils.h b/src/lib/dhcp/tests/pkt_filter_test_utils.h
new file mode 100644
index 0000000..dacec5c
--- /dev/null
+++ b/src/lib/dhcp/tests/pkt_filter_test_utils.h
@@ -0,0 +1,146 @@
+// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef PKT_FILTER_TEST_UTILS_H
+#define PKT_FILTER_TEST_UTILS_H
+
+#include <asiolink/io_address.h>
+#include <dhcp/iface_mgr.h>
+#include <dhcp/pkt_filter.h>
+#include <gtest/gtest.h>
+
+namespace isc {
+namespace dhcp {
+namespace test {
+
+/// @brief Test fixture class for testing classes derived from PktFilter class.
+///
+/// This class implements a simple algorithm checking presence of the loopback
+/// interface and initializing its index. It assumes that the loopback interface
+/// name is one of 'lo' or 'lo0'. If none of those interfaces is found, the
+/// constructor will report a failure.
+///
+/// @todo The interface detection algorithm should be more generic. This will
+/// be possible once the cross-OS interface detection is implemented.
+class PktFilterTest : public ::testing::Test {
+public:
+
+ /// @brief Constructor
+ ///
+ /// This constructor initializes sock_info_ structure to a default value.
+ /// The socket descriptors should be set to a negative value to indicate
+ /// that no socket has been opened. Specific tests will reinitialize this
+ /// structure with the values of the open sockets. For non-negative socket
+ /// descriptors, the class destructor will close associated sockets.
+ PktFilterTest(const uint16_t port);
+
+ /// @brief Destructor
+ ///
+ /// Closes open sockets (if any).
+ virtual ~PktFilterTest();
+
+ /// @brief Detect loopback interface.
+ ///
+ /// @todo this function will be removed once cross-OS interface
+ /// detection is implemented
+ void loInit();
+
+ /// @brief Test that the datagram socket is opened correctly.
+ ///
+ /// This function is used by multiple tests.
+ ///
+ /// @param sock A descriptor of the open socket.
+ void testDgramSocket(const int sock) const;
+
+ std::string ifname_; ///< Loopback interface name
+ uint16_t ifindex_; ///< Loopback interface index.
+ uint16_t port_; ///< A port number used for the test.
+ isc::dhcp::SocketInfo sock_info_; ///< A structure holding socket information.
+
+};
+
+/// @brief A stub implementation of the PktFilter class.
+///
+/// This class implements abstract methods of the @c isc::dhcp::test::PktFilter
+/// class. It is used by unit tests, which test protected methods of the
+/// @c isc::dhcp::test::PktFilter class. The implemented abstract methods are
+/// no-op.
+class PktFilterStub : public PktFilter {
+public:
+
+ /// @brief Checks if the direct DHCPv4 response is supported.
+ ///
+ /// This function checks if the direct response capability is supported,
+ /// i.e. if the server can respond to the client which doesn't have an
+ /// address yet. For this dummy class, the true is alaways returned.
+ ///
+ /// @return always true.
+ virtual bool isDirectResponseSupported() const;
+
+ /// @brief Simulate opening of the socket.
+ ///
+ /// This function simulates openinga primary socket. In reality, it doesn't
+ /// open a socket but the socket descriptor returned in the SocketInfo
+ /// structure is always set to 0.
+ ///
+ /// @param iface An interface descriptor.
+ /// @param addr Address on the interface to be used to send packets.
+ /// @param port Port number to bind socket to.
+ /// @param receive_bcast A flag which indicates if socket should be
+ /// configured to receive broadcast packets (if true).
+ /// @param send_bcast A flag which indicates if the socket should be
+ /// configured to send broadcast packets (if true).
+ ///
+ /// @note All parameters are ignored.
+ ///
+ /// @return A SocketInfo structure with the socket descriptor set to 0. The
+ /// fallback socket descriptor is set to a negative value.
+ virtual SocketInfo openSocket(const Iface& iface,
+ const isc::asiolink::IOAddress& addr,
+ const uint16_t port, const bool, const bool);
+
+ /// @brief Simulate reception of the DHCPv4 message.
+ ///
+ /// @param iface An interface to be used to receive DHCPv4 message.
+ /// @param sock_info A descriptor of the primary and fallback sockets.
+ ///
+ /// @note All parameters are ignored.
+ ///
+ /// @return always a NULL object.
+ virtual Pkt4Ptr receive(const Iface& iface, const SocketInfo& sock_info);
+
+ /// @brief Simulates sending a DHCPv4 message.
+ ///
+ /// This function does nothing.
+ ///
+ /// @param iface An interface to be used to send DHCPv4 message.
+ /// @param port A port used to send a message.
+ /// @param pkt A DHCPv4 to be sent.
+ ///
+ /// @note All parameters are ignored.
+ ///
+ /// @return 0.
+ virtual int send(const Iface& iface, uint16_t port, const Pkt4Ptr& pkt);
+
+ // Change the scope of the protected function so as they can be unit tested.
+ using PktFilter::openFallbackSocket;
+
+};
+
+
+}; // end of isc::dhcp::test namespace
+}; // end of isc::dhcp namespace
+}; // end of isc namespace
+
+#endif // PKT_FILTER_TEST_UTILS_H
diff --git a/src/lib/dhcp/tests/pkt_filter_unittest.cc b/src/lib/dhcp/tests/pkt_filter_unittest.cc
new file mode 100644
index 0000000..ab7f55a
--- /dev/null
+++ b/src/lib/dhcp/tests/pkt_filter_unittest.cc
@@ -0,0 +1,65 @@
+// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <asiolink/io_address.h>
+#include <dhcp/iface_mgr.h>
+#include <dhcp/tests/pkt_filter_test_utils.h>
+#include <gtest/gtest.h>
+
+using namespace isc::asiolink;
+using namespace isc::dhcp;
+using namespace isc::dhcp::test;
+
+namespace {
+
+/// Port number used by tests.
+const uint16_t PORT = 10067;
+
+class PktFilterBaseClassTest : public isc::dhcp::test::PktFilterTest {
+public:
+ /// @brief Constructor
+ ///
+ /// Does nothing but setting up the UDP port for the test.
+ PktFilterBaseClassTest() : PktFilterTest(PORT) {
+ }
+};
+
+// This test verifies that the fallback socket is successfuly opened and
+// bound using the protected function of the PktFilter class.
+TEST_F(PktFilterBaseClassTest, openFallbackSocket) {
+ // Open socket using the function under test. Note that, we don't have to
+ // close the socket on our own because the test fixture constructor
+ // will handle it.
+ PktFilterStub pkt_filter;
+ ASSERT_NO_THROW(sock_info_.fallbackfd_ =
+ pkt_filter.openFallbackSocket(IOAddress("127.0.0.1"), PORT)
+ );
+ // Test that the socket has been successfully created.
+ testDgramSocket(sock_info_.fallbackfd_);
+
+ // Now that we have the socket open, let's try to open another one. This
+ // should cause a binding error.
+ int another_sock;
+ EXPECT_THROW(another_sock =
+ pkt_filter.openFallbackSocket(IOAddress("127.0.0.1"), PORT),
+ isc::dhcp::SocketConfigError);
+ // Hard to believe we managed to open another socket. But if so, we have
+ // to close it to prevent a resource leak.
+ if (another_sock >= 0) {
+ close(another_sock);
+ }
+}
+
+} // anonymous namespace
More information about the bind10-changes
mailing list