}
wthread_->markReady(WatchedThread::READY);
- FDEventHandlerPtr ev_handler_ = FDEventHandlerFactory::factoryFDEventHandler();
+ FDEventHandlerPtr handler = FDEventHandlerFactory::factoryFDEventHandler();
for (;;) {
- ev_handler_->clear();
- ev_handler_->add(wthread_->getWatchFd(WatchedThread::TERMINATE));
- ev_handler_->add(accept_partner1);
- ev_handler_->add(accept_partner2);
+ handler->clear();
+ handler->add(wthread_->getWatchFd(WatchedThread::TERMINATE));
+ handler->add(accept_partner1);
+ handler->add(accept_partner2);
for (auto const& reader : readers) {
if (!reader.second) {
continue;
}
- ev_handler_->add(reader.first);
+ handler->add(reader.first);
}
- int n = ev_handler_->waitEvent(0, 0);
+ int n = handler->waitEvent(0, 0);
if ((n < 0) && (errno == EINTR)) {
cerr << "interrupted" << endl;
continue;
}
- if (ev_handler_->readReady(wthread_->getWatchFd(WatchedThread::TERMINATE))) {
+ if (handler->readReady(wthread_->getWatchFd(WatchedThread::TERMINATE))) {
break;
}
- if (ev_handler_->readReady(accept_partner1)) {
+ if (handler->readReady(accept_partner1)) {
int fd = accept(accept_partner1, 0, 0);
if (fd < 0) {
cerr << "accept1 failed " << strerror(errno) << endl;
readers[fd] = true;
}
}
- if (ev_handler_->readReady(accept_partner2)) {
+ if (handler->readReady(accept_partner2)) {
int fd = accept(accept_partner2, 0, 0);
if (fd < 0) {
cerr << "accept2 failed " << strerror(errno) << endl;
continue;
}
int fd = reader.first;
- if (ev_handler_->readReady(fd)) {
+ if (handler->readReady(fd)) {
char buf[128];
int cc = read(fd, buf, 128);
if (cc < 0) {
#include <dhcp/iface_mgr_error_handler.h>
#include <dhcp/pkt_filter_inet.h>
#include <dhcp/pkt_filter_inet6.h>
-#include <dhcp/fd_event_handler_factory.h>
#include <exceptions/exceptions.h>
+#include <util/fd_event_handler_factory.h>
#include <util/io/pktinfo_utilities.h>
#include <util/multi_threading_mgr.h>
#include <asiolink/io_address.h>
#include <dhcp/dhcp4.h>
#include <dhcp/dhcp6.h>
-#include <dhcp/fd_event_handler_factory.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <dhcp/packet_queue_mgr4.h>
#include <dhcp/packet_queue_mgr6.h>
#include <dhcp/pkt_filter.h>
#include <dhcp/pkt_filter6.h>
+#include <util/fd_event_handler_factory.h>
#include <util/optional.h>
#include <util/watch_socket.h>
#include <util/watched_thread.h>
#include <mutex>
namespace isc {
-
namespace dhcp {
/// @brief IfaceMgr exception thrown thrown when interface detection fails.
isc::util::WatchedThreadPtr dhcp_receiver_;
/// @brief The FDEventHandler instance.
- FDEventHandlerPtr fd_event_handler_;
+ util::FDEventHandlerPtr fd_event_handler_;
/// @brief The receiver FDEventHandler instance.
- FDEventHandlerPtr receiver_fd_event_handler_;
+ util::FDEventHandlerPtr receiver_fd_event_handler_;
};
} // namespace isc::dhcp
'classify.cc',
'duid.cc',
'duid_factory.cc',
- 'fd_event_handler.cc',
- 'fd_event_handler_factory.cc',
'hwaddr.cc',
'iface_mgr.cc',
iface_mgr,
'pkt_filter_inet6.cc',
pkt_filter_cc,
'protocol_util.cc',
- 'select_event_handler.cc',
include_directories: [include_directories('.')] + INCLUDES,
install: true,
install_dir: LIBDIR,
'docsis3_option_defs.h',
'duid.h',
'duid_factory.h',
- 'fd_event_handler.h',
- 'fd_event_handler_factory.h',
'hwaddr.h',
'iface_mgr.h',
'iface_mgr_error_handler.h',
'pkt_filter_lpf.h',
'pkt_template.h',
'protocol_util.h',
- 'select_event_handler.h',
'socket_info.h',
'std_option_defs.h',
]
'classify_unittest.cc',
'duid_factory_unittest.cc',
'duid_unittest.cc',
- 'fd_event_handler_factory_unittests.cc',
'hwaddr_unittest.cc',
'iface_mgr_unittest.cc',
'libdhcp++_unittest.cc',
'protocol_util_unittest.cc',
'run_unittests.cc',
pkt_filter_xpf_unittest_cc,
- 'select_event_handler_unittests.cc',
dependencies: [GTEST_DEP, CRYPTO_DEP],
cpp_args: [f'-DTEST_DATA_BUILDDIR="@current_build_dir@"'],
include_directories: [include_directories('.')] + INCLUDES,
#include <config.h>
-#include <fd_event_handler.h>
+#include <util/fd_event_handler.h>
namespace isc {
-namespace dhcp {
+namespace util {
FDEventHandler::FDEventHandler(HandlerType type) : type_(type) {
}
return (type_);
}
-} // end of namespace isc::dhcp
+} // end of namespace isc::util
} // end of namespace isc
#include <stdint.h>
namespace isc {
-namespace dhcp {
+namespace util {
/// @brief File descriptor event handler class handles events for registered
/// file descriptors.
/// @brief Shared pointer to an FD event handler.
typedef boost::shared_ptr<FDEventHandler> FDEventHandlerPtr;
-} // namespace isc::dhcp
+} // namespace isc::util
} // namespace isc
#endif // FD_EVENT_HANDLER_H
#include <config.h>
-#include <dhcp/fd_event_handler_factory.h>
-#include <dhcp/select_event_handler.h>
+#include <util/fd_event_handler_factory.h>
+#include <util/select_event_handler.h>
namespace isc {
-namespace dhcp {
+namespace util {
FDEventHandlerPtr FDEventHandlerFactory::factoryFDEventHandler() {
// todo: use configuration to initialize the FDEventHandler.
return (FDEventHandlerPtr(new SelectEventHandler()));
}
-} // end of namespace isc::dhcp
+} // end of namespace isc::util
} // end of namespace isc
#ifndef FD_EVENT_HANDLER_FACTORY_H
#define FD_EVENT_HANDLER_FACTORY_H
-#include <dhcp/fd_event_handler.h>
+#include <util/fd_event_handler.h>
namespace isc {
-namespace dhcp {
+namespace util {
/// @brief File descriptor event handler factory class handles the creation of
/// the FDEventHangler instance according to configuration and OS supported
static FDEventHandlerPtr factoryFDEventHandler();
};
-} // namespace isc::dhcp
+} // namespace isc::util
} // namespace isc
#endif // FD_EVENT_HANDLER_FACTORY_H
'dhcp_space.cc',
'encode/encode.cc',
'encode/utf8.cc',
+ 'fd_event_handler.cc',
+ 'fd_event_handler_factory.cc',
'filesystem.cc',
'labeled_value.cc',
'memory_segment_local.cc',
'pid_file.cc',
'ready_check.cc',
'reconnect_ctl.cc',
+ 'select_event_handler.cc',
'state_model.cc',
'stopwatch.cc',
'stopwatch_impl.cc',
'doubles.h',
'encode/encode.h',
'encode/utf8.h',
+ 'fd_event_handler.h',
+ 'fd_event_handler_factory.h',
'filesystem.h',
'io/fd.h',
'io/pktinfo_utilities.h',
'readwrite_mutex.h',
'ready_check.h',
'reconnect_ctl.h',
+ 'select_event_handler.h',
'staged_value.h',
'state_model.h',
'stopwatch.h',
#include <config.h>
-#include <sys/select.h>
+#include <util/fd_event_handler_factory.h>
namespace isc {
namespace util {
int selectCheck(const int fd_to_check, const unsigned int timeout_sec,
bool read_check, bool write_check) {
- // @todo: implement this using SelectEventHandler
- // @todo: should move to epoll/kqueue?
- if (fd_to_check < 0) {
- return (-1);
- }
- if (fd_to_check >= FD_SETSIZE) {
- return (-1);
- }
- int maxfd = 0;
-
- fd_set read_fds;
- FD_ZERO(&read_fds);
-
- fd_set write_fds;
- FD_ZERO(&write_fds);
-
- maxfd = fd_to_check;
-
- // Add this socket to read set
- FD_SET(fd_to_check, &read_fds);
-
- // Add this socket to write set
- FD_SET(fd_to_check, &write_fds);
-
- struct timeval select_timeout;
- select_timeout.tv_sec = static_cast<time_t>(timeout_sec);
- select_timeout.tv_usec = 0;
-
- fd_set* read_p = 0;
- fd_set* write_p = 0;
-
- if (read_check) {
- read_p = &read_fds;
- }
-
- if (write_check) {
- write_p = &write_fds;
- }
-
- return (select(maxfd + 1, read_p, write_p, 0, &select_timeout));
+ FDEventHandlerPtr handler = FDEventHandlerFactory::factoryFDEventHandler();
+ handler->add(fd_to_check, read_check, write_check);
+ return (handler->waitEvent(timeout_sec, 0));
}
} // end of isc::util namespace
#include <config.h>
#include <exceptions/exceptions.h>
-#include <select_event_handler.h>
+#include <util/select_event_handler.h>
#ifndef FD_COPY
#define FD_COPY(orig, copy) \
#endif
namespace isc {
-namespace dhcp {
+namespace util {
SelectEventHandler::SelectEventHandler() : FDEventHandler(TYPE_SELECT), max_fd_(0) {
clear();
max_fd_ = 0;
}
-} // end of namespace isc::dhcp
+} // end of namespace isc::util
} // end of namespace isc
#ifndef SELECT_EVENT_HANDLER_H
#define SELECT_EVENT_HANDLER_H
-#include <dhcp/fd_event_handler.h>
+#include <util/fd_event_handler.h>
#include <sys/select.h>
namespace isc {
-namespace dhcp {
+namespace util {
/// @brief File descriptor event handler class handles events for registered
/// file descriptors. This class uses the OS select syscall for event handling.
fd_set write_fd_set_data_;
};
-} // namespace isc::dhcp
+} // namespace isc::util;
} // namespace isc
#endif // SELECT_EVENT_HANDLER_H
#include <config.h>
-#include <dhcp/fd_event_handler_factory.h>
#include <exceptions/exceptions.h>
+#include <util/fd_event_handler_factory.h>
#include <gtest/gtest.h>
#include <sys/select.h>
using namespace isc;
-using namespace isc::dhcp;
+using namespace isc::util;
namespace {
#include <config.h>
-#include <dhcp/fd_event_handler.h>
-#include <dhcp/select_event_handler.h>
+#include <exceptions/exceptions.h>
+#include <util/fd_event_handler.h>
+#include <util/select_event_handler.h>
#include <gtest/gtest.h>
+#include <thread>
+
+#include <signal.h>
+
using namespace isc;
-using namespace isc::dhcp;
+using namespace isc::util;
const unsigned char MARKER = 0;
public:
/// @brief Constructor.
FDEventHandlerTest() {
- handler_.reset(new isc::dhcp::FDEventHandlerType);
+ handler_.reset(new FDEventHandlerType);
pipe(pipefd);
}
/// @brief The tested fd event handler.
FDEventHandlerPtr handler_;
- /// @brief The pipe used tor testing read and write operations.
+ /// @brief The pipe used for testing read and write operations.
int pipefd[2];
};
EXPECT_EQ(0, handler_->waitEvent(0, 1000));
+ EXPECT_THROW(handler_->add(-1), BadValue);
+
handler_->add(pipefd[0], true, false);
handler_->add(pipefd[1], false, true);
'dhcp_space_unittest.cc',
'doubles_unittest.cc',
'encode_unittest.cc',
+ 'fd_event_handler_factory_unittests.cc',
'fd_tests.cc',
'filesystem_unittests.cc',
'hash_unittest.cc',
'range_utilities_unittest.cc',
'readwrite_mutex_unittest.cc',
'run_unittests.cc',
+ 'select_event_handler_unittests.cc',
'staged_value_unittest.cc',
'state_model_unittest.cc',
'stopwatch_unittest.cc',