bool tcp_short_send_; ///< If set to true, we do not send
/// all data in the tcp response
+ boost::shared_ptr<udp::socket> udp_socket_;
+ boost::shared_ptr<tcp::socket> tcp_socket_;
+ boost::shared_ptr<tcp::acceptor> tcp_acceptor_;
/// \brief Constructor
IOFetchTest() :
// the class.)
//
// We could initialize the data with a single character, but as an added
- // check we'll make ssre that it has some structure.
+ // check we'll make sure that it has some structure.
test_data_.clear();
test_data_.reserve(MAX_SIZE);
}
}
+ virtual ~IOFetchTest() {
+ service_->restart();
+ try {
+ service_->poll();
+ } catch (...) {
+ }
+ }
+
/// \brief UDP Response handler (the "remote UDP DNS server")
///
/// When IOFetch is sending data, this response handler emulates the remote
} else {
- // For all subsequent times, send the remainder, maximised to
+ // For all subsequent times, send the remainder, maximized to
// whatever we have chosen for the maximum send size.
amount = min(tcp_send_size_,
(send_buffer_.size() - send_cumulative_));
}
// Socket into which the connection will be accepted.
- tcp::socket socket(service_->getInternalIOService());
+ tcp_socket_.reset(new tcp::socket(service_->getInternalIOService()));
// Acceptor object - called when the connection is made, the handler
// will initiate a read on the socket.
- tcp::acceptor acceptor(service_->getInternalIOService(),
- tcp::endpoint(tcp::v4(), TEST_PORT));
- acceptor.async_accept(socket,
- std::bind(&IOFetchTest::tcpAcceptHandler, this, &socket, ph::_1));
+ tcp_acceptor_.reset(new tcp::acceptor(service_->getInternalIOService(),
+ tcp::endpoint(tcp::v4(), TEST_PORT)));
+ tcp_acceptor_->async_accept(*tcp_socket_,
+ std::bind(&IOFetchTest::tcpAcceptHandler,
+ this, tcp_socket_.get(), ph::_1));
// Post the TCP fetch object to send the query and receive the response.
service_->post(tcp_fetch_);
// ... and execute all the callbacks. This exits when the fetch
// completes.
service_->run();
- EXPECT_TRUE(run_); // Make sure the callback did execute
// Tidy up
- socket.close();
+ tcp_socket_->close();
+
+ EXPECT_TRUE(run_); // Make sure the callback did execute
}
/// Perform a send/receive test over UDP
protocol_ = IOFetch::UDP;
// Set up the server.
- udp::socket socket(service_->getInternalIOService(), udp::v4());
- socket.set_option(socket_base::reuse_address(true));
- socket.bind(udp::endpoint(TEST_HOST, TEST_PORT));
+ udp_socket_.reset(new udp::socket(service_->getInternalIOService(), udp::v4()));
+ udp_socket_->set_option(socket_base::reuse_address(true));
+ udp_socket_->bind(udp::endpoint(TEST_HOST, TEST_PORT));
return_data_ = "Message returned to the client";
udp::endpoint remote;
- socket.async_receive_from(boost::asio::buffer(receive_buffer_,
- sizeof(receive_buffer_)),
- remote,
- std::bind(&IOFetchTest::udpReceiveHandler,
- this, &remote, &socket,
- ph::_1, ph::_2, bad_qid, second_send));
+ udp_socket_->async_receive_from(boost::asio::buffer(receive_buffer_,
+ sizeof(receive_buffer_)),
+ remote,
+ std::bind(&IOFetchTest::udpReceiveHandler,
+ this, &remote, udp_socket_.get(),
+ ph::_1, ph::_2, bad_qid, second_send));
service_->post(udp_fetch_);
if (debug_) {
cout << "udpSendReceive: async_receive_from posted,"
}
service_->run();
- socket.close();
+ // Tidy up
+ udp_socket_->close();
- EXPECT_TRUE(run_);
+ EXPECT_TRUE(run_); // Make sure the callback did execute
}
};
template <typename Callback, typename TlsStreamImpl>
TlsStreamBase<Callback, TlsStreamImpl>::
TlsStreamBase(const IOServicePtr& io_service, TlsContextPtr context)
- : StreamService(io_service), TlsStreamImpl(io_service->getInternalIOService(),
+ : StreamService(io_service, context),
+ TlsStreamImpl(io_service->getInternalIOService(),
context->getContext()), role_(context->getRole()) {
}
template <typename Callback, typename TlsStreamImpl>
TlsStreamBase<Callback, TlsStreamImpl>::
TlsStreamBase(const IOServicePtr& io_service, TlsContextPtr context)
- : StreamService(io_service), TlsStreamImpl(io_service->getInternalIOService()),
+ : StreamService(io_service, context),
+ TlsStreamImpl(io_service->getInternalIOService()),
role_(context->getRole()) {
}
class StreamService {
public:
/// @brief Constructor.
- StreamService(const IOServicePtr& io_service) : io_service_(io_service) {
+ StreamService(const IOServicePtr& io_service, TlsContextPtr& tls_context) :
+ io_service_(io_service), tls_context_(tls_context) {
}
private:
/// @brief The IO service used to handle events.
IOServicePtr io_service_;
+
+ /// @brief OpenSSL TLS context.
+ TlsContextPtr tls_context_;
};
/// @brief TLS stream base class.
/// @param interval The interval used to start the timer.
/// @param interval_mode The interval mode used by the timer.
void setup(const IntervalTimer::Callback& cbfunc, const long interval,
- const IntervalTimer::Mode& interval_mode
- = IntervalTimer::REPEATING);
+ const IntervalTimer::Mode& interval_mode = IntervalTimer::REPEATING);
/// @brief Callback function which calls the registerd callback.
///
/// \throw isc::BadValue interval is less than or equal to 0
/// \throw isc::Unexpected internal runtime error
void setup(const Callback& cbfunc, const long interval,
- const Mode& mode = REPEATING);
+ const Mode& mode = REPEATING);
/// Cancel the timer.
///
};
/// \brief The destructor.
- ~IOServiceImpl() {};
+ ~IOServiceImpl() {
+ };
//@}
/// \brief Start the underlying event loop.
template <typename Callback, typename TlsStreamImpl>
TlsStreamBase<Callback, TlsStreamImpl>::
TlsStreamBase(const IOServicePtr& io_service, TlsContextPtr context)
- : StreamService(io_service), TlsStreamImpl(io_service->getInternalIOService(),
+ : StreamService(io_service, context),
+ TlsStreamImpl(io_service->getInternalIOService(),
context->getContext()), role_(context->getRole()) {
}
}
/// @brief Destructor.
- virtual ~TlsStream() { }
+ virtual ~TlsStream() {
+ }
/// @brief TLS Handshake.
///
class IntervalTimerTest : public ::testing::Test {
protected:
IntervalTimerTest() :
- io_service_(new IOService()), timer_called_(false), timer_cancel_success_(false)
- {}
- ~IntervalTimerTest() {}
+ io_service_(new IOService()), timer_called_(false),
+ timer_cancel_success_(false) {
+ }
+ ~IntervalTimerTest() {
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+ }
class TimerCallBack {
public:
TimerCallBack(IntervalTimerTest* test_obj) : test_obj_(test_obj) {}
void operator()() const {
test_obj_->timer_called_ = true;
test_obj_->io_service_->stop();
- return;
}
private:
IntervalTimerTest* test_obj_;
class TimerCallBackCounter {
public:
TimerCallBackCounter(IntervalTimerTest* test_obj) :
- test_obj_(test_obj)
- {
+ test_obj_(test_obj) {
counter_ = 0;
}
void operator()() {
++counter_;
- return;
}
int counter_;
private:
IntervalTimer* timer,
TimerCallBackCounter& counter)
: test_obj_(test_obj), timer_(timer), counter_(counter), count_(0),
- prev_counter_(-1)
- {}
+ prev_counter_(-1) {
+ }
void operator()() {
++count_;
if (count_ == 1) {
test_obj_->timer_cancel_success_ = true;
}
}
- return;
}
private:
IntervalTimerTest* test_obj_;
class TimerCallBackCanceller {
public:
TimerCallBackCanceller(unsigned int& counter, IntervalTimer& itimer) :
- counter_(counter), itimer_(itimer)
- {}
+ counter_(counter), itimer_(itimer) {
+ }
void operator()() {
++counter_;
itimer_.cancel();
public:
TimerCallBackOverwriter(IntervalTimerTest* test_obj,
IntervalTimer& timer)
- : test_obj_(test_obj), timer_(timer), count_(0)
- {}
+ : test_obj_(test_obj), timer_(timer), count_(0) {
+ }
void operator()() {
++count_;
if (count_ == 1) {
// We should stop here.
test_obj_->io_service_->stop();
}
- return;
}
private:
IntervalTimerTest* test_obj_;
}
void operator()() {
++counter_;
- return;
}
private:
IntervalTimerTest* test_obj_;
/// connect() to connect to the server.
///
/// @param io_service IO service to be stopped on error.
- explicit TCPClient(const IOServicePtr& io_service)
- : io_service_(io_service), socket_(io_service_->getInternalIOService()) {
+ explicit TCPClient(const IOServicePtr& io_service, bool& running)
+ : io_service_(io_service), socket_(io_service_->getInternalIOService()),
+ running_(running) {
}
/// @brief Destructor.
///
/// @param ec Error code.
void connectHandler(const boost::system::error_code& ec) {
+ if (!running_) {
+ return;
+ }
if (ec) {
// One would expect that async_connect wouldn't return EINPROGRESS
// error code, but simply wait for the connection to get
/// @brief A socket used for the connection.
boost::asio::ip::tcp::socket socket_;
+ /// @brief Flag which indicates if the test is still running.
+ bool& running_;
};
/// @brief Pointer to the TCPClient.
SERVER_PORT),
endpoint_(asio_endpoint_), test_timer_(io_service_), connections_(),
clients_(), connections_num_(0), aborted_connections_num_(0),
- max_connections_(1) {
+ max_connections_(1), running_(true) {
test_timer_.setup(std::bind(&TCPAcceptorTest::timeoutHandler, this),
TEST_TIMEOUT, IntervalTimer::ONE_SHOT);
}
/// @brief Destructor.
virtual ~TCPAcceptorTest() {
+ running_ = false;
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Specifies how many new connections are expected before the IO
/// This method creates TCPClient instance and retains it in the clients_
/// list.
void connect() {
- TCPClientPtr client(new TCPClient(io_service_));
+ TCPClientPtr client(new TCPClient(io_service_, running_));
clients_.push_back(client);
clients_.back()->connect();
}
/// @brief Connections limit.
unsigned int max_connections_;
+
+ /// @brief Flag which indicates if the test is still running.
+ bool running_;
};
// Test TCPAcceptor::asyncAccept.
/// connect() to connect to the server.
///
/// @param io_service IO service to be stopped on error.
- explicit TLSClient(const IOServicePtr& io_service)
- : io_service_(io_service), socket_(io_service_->getInternalIOService()) {
+ explicit TLSClient(const IOServicePtr& io_service, bool& running)
+ : io_service_(io_service), socket_(io_service_->getInternalIOService()),
+ running_(running) {
}
/// @brief Destructor.
///
/// @param ec Error code.
void connectHandler(const boost::system::error_code& ec) {
+ if (!running_) {
+ return;
+ }
if (ec) {
// One would expect that async_connect wouldn't return EINPROGRESS
// error code, but simply wait for the connection to get
/// @brief A socket used for the connection.
ip::tcp::socket socket_;
+ /// @brief Flag which indicates if the test is still running.
+ bool& running_;
};
/// @brief Pointer to the TLSClient.
TlsContextPtr context,
TestTLSAcceptor& acceptor,
const TLSAcceptorCallback& callback)
- : io_service_(io_service), socket_(io_service_, context), acceptor_(acceptor),
- callback_(callback) {
+ : io_service_(io_service), socket_(io_service_, context),
+ acceptor_(acceptor), callback_(callback) {
}
/// @brief Destructor.
/// @brief Instance of the callback used for asyncAccept.
TLSAcceptorCallback callback_;
-
};
/// @brief Pointer to the Acceptor object.
SERVER_PORT),
endpoint_(asio_endpoint_), test_timer_(io_service_), connections_(),
clients_(), connections_num_(0), aborted_connections_num_(0),
- max_connections_(1) {
+ max_connections_(1), running_(true) {
test_timer_.setup(std::bind(&TLSAcceptorTest::timeoutHandler, this),
TEST_TIMEOUT, IntervalTimer::ONE_SHOT);
}
/// @brief Destructor.
virtual ~TLSAcceptorTest() {
+ running_ = false;
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Specifies how many new connections are expected before the IO
/// This method creates TLSClient instance and retains it in the clients_
/// list.
void connect() {
- TLSClientPtr client(new TLSClient(io_service_));
+ TLSClientPtr client(new TLSClient(io_service_, running_));
clients_.push_back(client);
clients_.back()->connect();
}
/// @brief Connections limit.
unsigned int max_connections_;
+
+ /// @brief Flag which indicates if the test is still running.
+ bool running_;
};
// Test TLSAcceptor::asyncAccept.
};
+/// @brief Test fixture class for TlsContext.
+class TLSTest : public ::testing::Test {
+public:
+
+ /// @brief Constructor.
+ ///
+ /// Besides initializing class members it also sets the test timer to guard
+ /// against endlessly running IO service when TCP connections are
+ /// unsuccessful.
+ TLSTest() : io_service_(new IOService()) {
+ }
+
+ /// @brief Destructor.
+ virtual ~TLSTest() {
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+ }
+
+ /// @brief IO service.
+ IOServicePtr io_service_;
+
+ /// @brief The shutdown callback.
+ TestCallback shutdown_cb_;
+
+ /// @brief The TLS server.
+ boost::shared_ptr<TlsStream<TestCallback>> server_;
+
+ /// @brief The TLS client.
+ boost::shared_ptr<TlsStream<TestCallback>> client_;
+};
+
////////////////////////////////////////////////////////////////////////
// TlsContext tests //
////////////////////////////////////////////////////////////////////////
// Test if we can get a client context.
-TEST(TLSTest, clientContext) {
+TEST_F(TLSTest, clientContext) {
TlsContextPtr ctx;
EXPECT_NO_THROW(ctx.reset(new TlsContext(TlsRole::CLIENT)));
}
// Test if we can get a server context.
-TEST(TLSTest, serverContext) {
+TEST_F(TLSTest, serverContext) {
TlsContextPtr ctx;
EXPECT_NO_THROW(ctx.reset(new TlsContext(TlsRole::SERVER)));
}
// Test if the cert required flag is handled as expected.
-TEST(TLSTest, certRequired) {
+TEST_F(TLSTest, certRequired) {
auto check = [] (TlsContext& ctx) -> bool {
#ifdef WITH_BOTAN
return (ctx.getCertRequired());
}
// Test if the certificate authority can be loaded.
-TEST(TLSTest, loadCAFile) {
+TEST_F(TLSTest, loadCAFile) {
string ca(string(TEST_CA_DIR) + "/kea-ca.crt");
TestTlsContext ctx(TlsRole::CLIENT);
EXPECT_NO_THROW(ctx.loadCaFile(ca));
}
// Test that no certificate authority gives an error.
-TEST(TLSTest, loadNoCAFile) {
+TEST_F(TLSTest, loadNoCAFile) {
Expecteds exps;
// Botan error.
exps.addThrow("I/O error: DataSource: Failure opening file /no-such-file");
// Test that Botan requires a real CA certificate so fails with
// trusted self-signed client.
/// @note: convert to GTEST when gtest_utils.h will be moved.
-TEST(TLSTest, loadTrustedSelfCAFile) {
+TEST_F(TLSTest, loadTrustedSelfCAFile) {
Expecteds exps;
// Botan error.
string botan_error = "Flatfile_Certificate_Store received non CA cert ";
#endif // WITH_BOTAN
// Test that a directory can be loaded.
-TEST(TLSTest, loadCAPath) {
+TEST_F(TLSTest, loadCAPath) {
string ca(TEST_CA_DIR);
TestTlsContext ctx(TlsRole::CLIENT);
EXPECT_NO_THROW(ctx.loadCaPath(ca));
}
// Test that a certificate is wanted.
-TEST(TLSTest, loadKeyCA) {
+TEST_F(TLSTest, loadKeyCA) {
Expecteds exps;
// Botan error.
exps.addThrow("Flatfile_Certificate_Store::Flatfile_Certificate_Store cert file is empty");
}
// Test if the end entity certificate can be loaded.
-TEST(TLSTest, loadCertFile) {
+TEST_F(TLSTest, loadCertFile) {
string cert(string(TEST_CA_DIR) + "/kea-client.crt");
TestTlsContext ctx(TlsRole::CLIENT);
EXPECT_NO_THROW(ctx.loadCertFile(cert));
}
// Test that no end entity certificate gives an error.
-TEST(TLSTest, loadNoCertFile) {
+TEST_F(TLSTest, loadNoCertFile) {
Expecteds exps;
// Botan error.
exps.addThrow("I/O error: DataSource: Failure opening file /no-such-file");
}
// Test that a certificate is wanted.
-TEST(TLSTest, loadCsrCertFile) {
+TEST_F(TLSTest, loadCsrCertFile) {
Expecteds exps;
// Botan error.
exps.addThrow("Expected a certificate, got 'CERTIFICATE REQUEST'");
}
// Test if the private key can be loaded.
-TEST(TLSTest, loadKeyFile) {
+TEST_F(TLSTest, loadKeyFile) {
string key(string(TEST_CA_DIR) + "/kea-client.key");
TestTlsContext ctx(TlsRole::CLIENT);
EXPECT_NO_THROW(ctx.loadKeyFile(key));
}
// Test that no private key gives an error.
-TEST(TLSTest, loadNoKeyFile) {
+TEST_F(TLSTest, loadNoKeyFile) {
Expecteds exps;
// Botan error.
exps.addThrow("I/O error: DataSource: Failure opening file /no-such-file");
}
// Test that a private key is wanted.
-TEST(TLSTest, loadCertKeyFile) {
+TEST_F(TLSTest, loadCertKeyFile) {
Expecteds exps;
// Botan error.
string botan_error = "PKCS #8 private key decoding failed with PKCS #8: ";
}
// Test that the certificate and private key must match.
-TEST(TLSTest, loadMismatch) {
+TEST_F(TLSTest, loadMismatch) {
Expecteds exps;
exps.addNoError();
exps.runCanThrow([] {
}
// Test the configure class method.
-TEST(TLSTest, configure) {
+TEST_F(TLSTest, configure) {
TlsContextPtr ctx;
string ca(string(TEST_CA_DIR) + "/kea-ca.crt");
string cert(string(TEST_CA_DIR) + "/kea-client.crt");
}
// Test the configure class method error case.
-TEST(TLSTest, configureError) {
+TEST_F(TLSTest, configureError) {
// The error case.
Expecteds exps;
// Common part of the error message.
////////////////////////////////////////////////////////////////////////
// Test if we can get a stream.
-TEST(TLSTest, stream) {
- IOServicePtr service(new IOService());
+TEST_F(TLSTest, stream) {
TlsContextPtr ctx(new TlsContext(TlsRole::CLIENT));
boost::scoped_ptr<TlsStream<TestCallback> > st;
- EXPECT_NO_THROW(st.reset(new TlsStream<TestCallback>(service, ctx)));
+ EXPECT_NO_THROW(server_.reset(new TlsStream<TestCallback>(io_service_, ctx)));
}
// Test what happens when handshake is forgotten.
-TEST(TLSTest, noHandshake) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, noHandshake) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer1(service);
+ IntervalTimer timer1(io_service_);
bool timeout = false;
timer1.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Send on the client.
char send_buf[] = "some text...";
TestCallback send_cb;
- async_write(client, boost::asio::buffer(send_buf), send_cb);
+ async_write(*client_, boost::asio::buffer(send_buf), send_cb);
while (!timeout && !send_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
timer1.cancel();
}
// Setup a second timeout.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Receive on the server.
vector<char> receive_buf(64);
TestCallback receive_cb;
- server.async_read_some(boost::asio::buffer(receive_buf), receive_cb);
+ server_->async_read_some(boost::asio::buffer(receive_buf), receive_cb);
while (!timeout && !receive_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
timer2.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the server was not configured.
-TEST(TLSTest, serverNotConfigured) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, serverNotConfigured) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
// Skip config.
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.handshake(server_cb);
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client was not configured.
-TEST(TLSTest, clientNotConfigured) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, clientNotConfigured) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx(new TlsContext(TlsRole::CLIENT));
// Skip config.
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client is HTTP (vs HTTPS).
-TEST(TLSTest, clientHTTPnoS) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, clientHTTPnoS) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
- tcp::socket client(service->getInternalIOService());
+ tcp::socket client(io_service_->getInternalIOService());
// Connect to.
client.open(tcp::v4());
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform server TLS handshake.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
// Client sending a HTTP GET.
char send_buf[] = "GET / HTTP/1.1\r\n";
client.async_send(boost::asio::buffer(send_buf), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
// Close client and server.
EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client does not use HTTP nor HTTP.
-TEST(TLSTest, unknownClient) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, unknownClient) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
- tcp::socket client(service->getInternalIOService());
+ tcp::socket client(io_service_->getInternalIOService());
// Connect to.
client.open(tcp::v4());
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform server TLS handshake.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
// Client sending something which is not a TLS ClientHello.
char send_buf[] = "hello my server...";
client.async_send(boost::asio::buffer(send_buf), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
// Close client and server.
EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client uses a certificate from another CA.
-TEST(TLSTest, anotherClient) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, anotherClient) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a certificate signed by another CA.
TlsContextPtr client_ctx;
test::configOther(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client uses a self-signed certificate.
-TEST(TLSTest, selfSigned) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, selfSigned) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a self-signed certificate.
TlsContextPtr client_ctx;
test::configSelf(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
////////////////////////////////////////////////////////////////////////
// the other peer timeout?
// Test what happens when handshake is forgotten.
-TEST(TLSTest, noHandshakeCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, noHandshakeCloseonError) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer1(service);
+ IntervalTimer timer1(io_service_);
bool timeout = false;
timer1.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Send on the client.
char send_buf[] = "some text...";
- TestCallback send_cb(&client.lowest_layer());
- async_write(client, boost::asio::buffer(send_buf), send_cb);
+ TestCallback send_cb(&client_->lowest_layer());
+ async_write(*client_, boost::asio::buffer(send_buf), send_cb);
while (!timeout && !send_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
timer1.cancel();
}
// Setup a second timeout.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Receive on the server.
vector<char> receive_buf(64);
TestCallback receive_cb;
- server.async_read_some(boost::asio::buffer(receive_buf), receive_cb);
+ server_->async_read_some(boost::asio::buffer(receive_buf), receive_cb);
while (!timeout && !receive_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
timer2.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the server was not configured.
-TEST(TLSTest, serverNotConfiguredCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, serverNotConfiguredCloseonError) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
// Skip config.
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.handshake(server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client was not configured.
-TEST(TLSTest, clientNotConfiguredCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, clientNotConfiguredCloseonError) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx(new TlsContext(TlsRole::CLIENT));
// Skip config.
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
- TestCallback client_cb(&client.lowest_layer());
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ TestCallback client_cb(&client_->lowest_layer());
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client is HTTP (vs HTTPS).
-TEST(TLSTest, clientHTTPnoSCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, clientHTTPnoSCloseonError) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
- tcp::socket client(service->getInternalIOService());
+ tcp::socket client(io_service_->getInternalIOService());
// Connect to.
client.open(tcp::v4());
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform server TLS handshake.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
// Client sending a HTTP GET.
char send_buf[] = "GET / HTTP/1.1\r\n";
client.async_send(boost::asio::buffer(send_buf), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
// Close client and server.
EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client uses a certificate from another CA.
-TEST(TLSTest, anotherClientCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, anotherClientCloseonError) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a certificate signed by another CA.
TlsContextPtr client_ctx;
test::configOther(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the client uses a self-signed certificate.
-TEST(TLSTest, selfSignedCloseonError) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, selfSignedCloseonError) {
// Server part.
TlsContextPtr server_ctx;
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a self-signed certificate.
TlsContextPtr client_ctx;
test::configSelf(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
////////////////////////////////////////////////////////////////////////
// Test what happens when the client uses a certificate from another CA
// but the client certificate request and validation are disabled.
-TEST(TLSTest, anotherClientNoReq) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, anotherClientNoReq) {
// Server part.
TlsContextPtr server_ctx;
test::configServerNoReq(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a certificate signed by another CA.
TlsContextPtr client_ctx;
test::configOther(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the server uses a certificate without subject
// alternative name (but still a version 3 certificate).
-TEST(TLSTest, serverRaw) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, serverRaw) {
// Server part.
TlsContextPtr server_ctx;
test::configServerRaw(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
#ifdef WITH_OPENSSL
// Test what happens when the client uses a trusted self-signed certificate.
// Not really a failure case as it works...
-TEST(TLSTest, trustedSelfSigned) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, trustedSelfSigned) {
// Server part.
TlsContextPtr server_ctx;
test::configTrustedSelf(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part using a self-signed certificate.
TlsContextPtr client_ctx;
test::configSelf(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
TestCallback server_cb;
- server.async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
+ server_->async_handshake(roleToImpl(TlsRole::SERVER), server_cb);
TestCallback client_cb;
- client.async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
+ client_->async_handshake(roleToImpl(TlsRole::CLIENT), client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
#endif // WITH_OPENSSL
// Investigate the TLS shutdown processing.
// Test what happens when the shutdown receiver is inactive.
-TEST(TLSTest, shutdownInactive) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, shutdownInactive) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.handshake(server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Setup a timeout for the shutdown.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Shutdown on the client leaving the server inactive.
- TestCallback shutdown_cb;
- client.shutdown(shutdown_cb);
- while (!timeout && !shutdown_cb.getCalled()) {
- service->runOne();
+ client_->shutdown(shutdown_cb_);
+ while (!timeout && !shutdown_cb_.getCalled()) {
+ io_service_->runOne();
}
timer2.cancel();
exps.addNoError();
// OpenSSL hangs.
exps.addTimeout();
- exps.checkAsync("shutdown", shutdown_cb);
+ exps.checkAsync("shutdown", shutdown_cb_);
if (Expecteds::displayErrMsg()) {
if (timeout) {
std::cout << "shutdown timeout\n";
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the shutdown receiver is active.
-TEST(TLSTest, shutdownActive) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, shutdownActive) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.handshake(server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Setup a timeout for the shutdown and receive.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Receive on the server.
vector<char> receive_buf(64);
TestCallback receive_cb;
- server.async_read_some(boost::asio::buffer(receive_buf), receive_cb);
+ server_->async_read_some(boost::asio::buffer(receive_buf), receive_cb);
// Shutdown on the client.
- TestCallback shutdown_cb;
- client.shutdown(shutdown_cb);
- while (!timeout && (!shutdown_cb.getCalled() || !receive_cb.getCalled())) {
- service->runOne();
+ client_->shutdown(shutdown_cb_);
+ while (!timeout && (!shutdown_cb_.getCalled() || !receive_cb.getCalled())) {
+ io_service_->runOne();
}
timer2.cancel();
exps.addNoError();
// OpenSSL hangs.
exps.addTimeout();
- exps.checkAsync("shutdown", shutdown_cb);
+ exps.checkAsync("shutdown", shutdown_cb_);
if (Expecteds::displayErrMsg()) {
if (timeout) {
std::cout << "shutdown timeout\n";
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the shutdown receiver is inactive on shutdown
// and immediate close.
-TEST(TLSTest, shutdownCloseInactive) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, shutdownCloseInactive) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.handshake(server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Setup a timeout for the shutdown.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Shutdown on the client leaving the server inactive.
- TestCallback shutdown_cb;
- client.shutdown(shutdown_cb);
+ client_->shutdown(shutdown_cb_);
// Post a close which should be called after the shutdown.
- service->post([&client] { client.lowest_layer().close(); });
- while (!timeout && !shutdown_cb.getCalled()) {
- service->runOne();
+ io_service_->post([&] { client_->lowest_layer().close(); });
+ while (!timeout && !shutdown_cb_.getCalled()) {
+ io_service_->runOne();
}
timer2.cancel();
exps.addError("Operation canceled");
// OpenSSL gets Bad file descriptor.
exps.addError("Bad file descriptor");
- exps.checkAsync("shutdown", shutdown_cb);
+ exps.checkAsync("shutdown", shutdown_cb_);
if (Expecteds::displayErrMsg()) {
if (timeout) {
std::cout << "shutdown timeout\n";
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Test what happens when the shutdown receiver is active with an
// immediate close.
-TEST(TLSTest, shutdownCloseActive) {
- IOServicePtr service(new IOService());
-
+TEST_F(TLSTest, shutdownCloseActive) {
// Server part.
TlsContextPtr server_ctx(new TlsContext(TlsRole::SERVER));
test::configServer(server_ctx);
- TlsStream<TestCallback> server(service, server_ctx);
+ server_.reset(new TlsStream<TestCallback>(io_service_, server_ctx));
// Accept a client.
tcp::endpoint server_ep(tcp::endpoint(address::from_string(SERVER_ADDRESS),
SERVER_PORT));
- tcp::acceptor acceptor(service->getInternalIOService(), server_ep);
+ tcp::acceptor acceptor(io_service_->getInternalIOService(), server_ep);
acceptor.set_option(tcp::acceptor::reuse_address(true));
TestCallback accept_cb;
- acceptor.async_accept(server.lowest_layer(), accept_cb);
+ acceptor.async_accept(server_->lowest_layer(), accept_cb);
// Client part.
TlsContextPtr client_ctx;
test::configClient(client_ctx);
- TlsStream<TestCallback> client(service, client_ctx);
+ client_.reset(new TlsStream<TestCallback>(io_service_, client_ctx));
// Connect to.
- client.lowest_layer().open(tcp::v4());
+ client_->lowest_layer().open(tcp::v4());
TestCallback connect_cb;
- client.lowest_layer().async_connect(server_ep, connect_cb);
+ client_->lowest_layer().async_connect(server_ep, connect_cb);
// Run accept and connect.
while (!accept_cb.getCalled() || !connect_cb.getCalled()) {
- service->runOne();
+ io_service_->runOne();
}
// Verify the error codes.
}
// Setup a timeout.
- IntervalTimer timer(service);
+ IntervalTimer timer(io_service_);
bool timeout = false;
timer.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Perform TLS handshakes.
- TestCallback server_cb(&server.lowest_layer());
- server.handshake(server_cb);
+ TestCallback server_cb(&server_->lowest_layer());
+ server_->handshake(server_cb);
TestCallback client_cb;
- client.handshake(client_cb);
+ client_->handshake(client_cb);
while (!timeout && (!server_cb.getCalled() || !client_cb.getCalled())) {
- service->runOne();
+ io_service_->runOne();
}
timer.cancel();
EXPECT_FALSE(client_cb.getCode());
// Setup a timeout for the shutdown and receive.
- IntervalTimer timer2(service);
+ IntervalTimer timer2(io_service_);
timeout = false;
timer2.setup([&timeout] { timeout = true; }, 100, IntervalTimer::ONE_SHOT);
// Receive on the server.
vector<char> receive_buf(64);
TestCallback receive_cb;
- server.async_read_some(boost::asio::buffer(receive_buf), receive_cb);
+ server_->async_read_some(boost::asio::buffer(receive_buf), receive_cb);
// Shutdown on the client.
- TestCallback shutdown_cb;
- client.shutdown(shutdown_cb);
+ client_->shutdown(shutdown_cb_);
// Post a close which should be called after the shutdown.
- service->post([&client] { client.lowest_layer().close(); });
- while (!timeout && (!shutdown_cb.getCalled() || !receive_cb.getCalled())) {
- service->runOne();
+ io_service_->post([&] { client_->lowest_layer().close(); });
+ while (!timeout && (!shutdown_cb_.getCalled() || !receive_cb.getCalled())) {
+ io_service_->runOne();
}
timer2.cancel();
exps.addError("Operation canceled");
// OpenSSL gets Bad file descriptor.
exps.addError("Bad file descriptor");
- exps.checkAsync("shutdown", shutdown_cb);
+ exps.checkAsync("shutdown", shutdown_cb_);
if (Expecteds::displayErrMsg()) {
if (timeout) {
std::cout << "shutdown timeout\n";
}
// Close client and server.
- EXPECT_NO_THROW(client.lowest_layer().close());
- EXPECT_NO_THROW(server.lowest_layer().close());
+ EXPECT_NO_THROW(client_->lowest_layer().close());
+ EXPECT_NO_THROW(server_->lowest_layer().close());
}
// Conclusion about the shutdown: do the close on completion (e.g. in the
/// Removes unix socket descriptor after the test.
virtual ~UnixDomainSocketTest() {
removeUnixSocketFile();
+ test_socket_.reset();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Returns socket file path.
}
TestServerUnixSocket::~TestServerUnixSocket() {
+ test_timer_.cancel();
server_acceptor_.close();
}
}
/// @brief Destructor.
- virtual ~TLSAcceptor() { }
+ virtual ~TLSAcceptor() {
+ }
/// @brief Asynchronously accept new connection.
///
///
/// Indicates that the opening of a UDP socket is synchronous.
virtual bool isOpenSynchronous() const {
- return true;
+ return (true);
}
/// \brief Open Socket
.arg(port_)
.arg(tls_context_ ? "true" : "false");
} catch (const std::exception& ex) {
- thread_io_service_.reset();
- http_listener_.reset();
thread_pool_.reset();
+ http_listener_.reset();
+ thread_io_service_->restart();
+ try {
+ thread_io_service_->poll();
+ } catch(...) {
+ }
+ thread_io_service_.reset();
isc_throw(Unexpected, "CmdHttpListener::run failed: " << ex.what());
}
}
// Get rid of the listener.
http_listener_.reset();
+ thread_io_service_->restart();
+ try {
+ thread_io_service_->poll();
+ } catch(...) {
+ }
+
// Ditch the IOService.
thread_io_service_.reset();
///
/// Removes unix socket descriptor before the test.
ClientConnectionTest() :
- io_service_(new IOService()),
+ io_service_(new IOService()), handler_invoked_(false),
test_socket_(new test::TestServerUnixSocket(io_service_,
unixSocketFilePath())) {
removeUnixSocketFile();
/// Removes unix socket descriptor after the test.
virtual ~ClientConnectionTest() {
removeUnixSocketFile();
+ conn_.reset();
+ test_socket_.reset();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Returns socket file path.
/// @brief IO service used by the tests.
IOServicePtr io_service_;
+ /// @brief Flag which indicates if the callback has been called.
+ bool handler_invoked_;
+
/// @brief Server side unix socket used in these tests.
test::TestServerUnixSocketPtr test_socket_;
+
+ /// @brief Client connection.
+ ClientConnectionPtr conn_;
};
// Tests successful transaction: connect, send command and receive a
// Create some valid command.
std::string command = "{ \"command\": \"list-commands\" }";
- ClientConnection conn(io_service_);
+ conn_.reset(new ClientConnection(io_service_));
- // This boolean value will indicate when the callback function is invoked
- // at the end of the transaction (whether it is successful or unsuccessful).
- bool handler_invoked = false;
- conn.start(ClientConnection::SocketPath(unixSocketFilePath()),
- ClientConnection::ControlCommand(command),
- [&handler_invoked](const boost::system::error_code& ec,
- const ConstJSONFeedPtr& feed) {
+ conn_->start(ClientConnection::SocketPath(unixSocketFilePath()),
+ ClientConnection::ControlCommand(command),
+ [&](const boost::system::error_code& ec,
+ const ConstJSONFeedPtr& feed) {
+ if (handler_invoked_) {
+ return;
+ }
// Indicate that the handler has been called to break from the
// while loop below.
- handler_invoked = true;
+ handler_invoked_ = true;
// The ec should contain no error.
ASSERT_FALSE(ec);
// The JSONFeed should be present and it should contain a valid
EXPECT_TRUE(feed->feedOk()) << feed->getErrorMessage();
});
// Run the connection.
- while (!handler_invoked && !test_socket_->isStopped()) {
+ while (!handler_invoked_ && !test_socket_->isStopped()) {
io_service_->runOne();
}
}
// Command to be sent to the server.
std::string command = "{ \"command\": \"list-commands\" }";
- ClientConnection conn(io_service_);
+ conn_.reset(new ClientConnection(io_service_));
- // This boolean value will be set to true when the callback is invoked.
- bool handler_invoked = false;
- conn.start(ClientConnection::SocketPath(unixSocketFilePath()),
- ClientConnection::ControlCommand(command),
- [&handler_invoked](const boost::system::error_code& ec,
- const ConstJSONFeedPtr& /*feed*/) {
+ conn_->start(ClientConnection::SocketPath(unixSocketFilePath()),
+ ClientConnection::ControlCommand(command),
+ [&](const boost::system::error_code& ec,
+ const ConstJSONFeedPtr& /*feed*/) {
+ if (handler_invoked_) {
+ return;
+ }
// Indicate that the callback has been invoked to break the loop
// below.
- handler_invoked = true;
+ handler_invoked_ = true;
ASSERT_TRUE(ec);
EXPECT_TRUE(ec.value() == boost::asio::error::timed_out);
}, ClientConnection::Timeout(1000));
- while (!handler_invoked && !test_socket_->isStopped()) {
+ while (!handler_invoked_ && !test_socket_->isStopped()) {
io_service_->runOne();
}
+
+ test_socket_->stopServer();
}
// This test checks that an error is returned when the client is unable
TEST_F(ClientConnectionTest, connectionError) {
// Create the new connection but do not bind the server socket.
// The connection should be refused and an error returned.
- ClientConnection conn(io_service_);
+ conn_.reset(new ClientConnection(io_service_));
std::string command = "{ \"command\": \"list-commands\" }";
- bool handler_invoked = false;
- conn.start(ClientConnection::SocketPath(unixSocketFilePath()),
- ClientConnection::ControlCommand(command),
- [&handler_invoked](const boost::system::error_code& ec,
- const ConstJSONFeedPtr& /*feed*/) {
- handler_invoked = true;
+ conn_->start(ClientConnection::SocketPath(unixSocketFilePath()),
+ ClientConnection::ControlCommand(command),
+ [&](const boost::system::error_code& ec,
+ const ConstJSONFeedPtr& /*feed*/) {
+ if (handler_invoked_) {
+ return;
+ }
+ handler_invoked_ = true;
ASSERT_TRUE(ec);
});
- while (!handler_invoked && !test_socket_->isStopped()) {
+ while (!handler_invoked_ && !test_socket_->isStopped()) {
io_service_->runOne();
}
}
client->close();
}
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+
// Deregisters commands.
config::CommandMgr::instance().deregisterAll();
DdnsDomainPtr& reverse_domain,
D2CfgMgrPtr& cfg_mgr)
: io_service_(io_service), ncr_(ncr), forward_domain_(forward_domain),
- reverse_domain_(reverse_domain), dns_client_(), dns_update_request_(),
- dns_update_status_(DNSClient::OTHER), dns_update_response_(),
- forward_change_completed_(false), reverse_change_completed_(false),
- current_server_list_(), current_server_(), next_server_pos_(0),
- update_attempts_(0), cfg_mgr_(cfg_mgr), tsig_key_() {
+ reverse_domain_(reverse_domain), dns_client_(), dns_update_request_(),
+ dns_update_status_(DNSClient::OTHER), dns_update_response_(),
+ forward_change_completed_(false), reverse_change_completed_(false),
+ current_server_list_(), current_server_(), next_server_pos_(0),
+ update_attempts_(0), cfg_mgr_(cfg_mgr), tsig_key_() {
/// @todo if io_service is NULL we are multi-threading and should
/// instantiate our own
if (!io_service_) {
#include <asiodns/io_fetch.h>
#include <asiodns/logger.h>
#include <asiolink/interval_timer.h>
+#include <d2srv/d2_update_message.h>
#include <d2srv/testutils/nc_test_utils.h>
#include <d2srv/testutils/stats_test_utils.h>
#include <dns/messagerenderer.h>
///
/// Sets the asiodns logging level back to DEBUG.
virtual ~DNSClientTest() {
+ test_timer_.cancel();
+ service_->restart();
+ try {
+ service_->poll();
+ } catch (...) {
+ }
asiodns::logger.setSeverity(isc::log::DEBUG);
};
/// @brief This test verifies that it accepted timeout values belong to the
/// range of <0, DNSClient::getMaxTimeout()>.
void runInvalidTimeoutTest() {
-
expect_response_ = false;
- // Create outgoing message. Simply set the required message fields:
+ // Create inbound message. Simply set the required message fields:
// error code and Zone section. This is enough to create on-wire format
// of this message and send it.
- D2UpdateMessage message(D2UpdateMessage::OUTBOUND);
- ASSERT_NO_THROW(message.setRcode(Rcode(Rcode::NOERROR_CODE)));
- ASSERT_NO_THROW(message.setZone(Name("example.com"), RRClass::IN()));
+ D2UpdateMessage message(D2UpdateMessage::INBOUND);
// Start with a valid timeout equal to maximal allowed. This way we will
// ensure that doUpdate doesn't throw an exception for valid timeouts.
unsigned int timeout = DNSClient::getMaxTimeout();
- EXPECT_NO_THROW(dns_client_->doUpdate(service_, IOAddress(TEST_ADDRESS),
- TEST_PORT, message, timeout));
+ EXPECT_THROW(dns_client_->doUpdate(service_, IOAddress(TEST_ADDRESS),
+ TEST_PORT, message, timeout),
+ isc::d2::InvalidZoneSection);
// Cross the limit and expect that exception is thrown this time.
timeout = DNSClient::getMaxTimeout() + 1;
// This starts the execution of tasks posted to IOService. run() blocks
// until stop() is called in the completion callback function.
service_->run();
-
}
/// @brief This test verifies that DNSClient can send DNS Update and receive
}
- // Kick of the message exchange by actually running the scheduled
+ // Kick off the message exchange by actually running the scheduled
// "send" and "receive" operations.
service_->run();
// we must reset it in order for subsequent calls to run() or
// runOne() to work.
service_->restart();
+ try {
+ service_->poll();
+ } catch (...) {
+ }
}
/// @brief Performs a single request-response exchange with or without TSIG.
// we must reset it in order for subsequent calls to run() or
// runOne() to work.
service_->restart();
+ try {
+ service_->poll();
+ } catch (...) {
+ }
}
};
using namespace std;
using namespace isc;
+using namespace isc::asiolink;
using namespace isc::d2;
using namespace isc::util;
using namespace boost::posix_time;
class NameChangeTransactionTest : public TransactionTest {
public:
NameChangeTransactionTest() {
+ io_service_.reset(new IOService());
+ timer_.reset(new IntervalTimer(io_service_));
}
virtual ~NameChangeTransactionTest() {
+ timer_->cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+ io_service_.reset(new IOService());
+ timer_.reset(new IntervalTimer(io_service_));
}
-
- /// @brief Instantiates a NameChangeStub test transaction
+ /// @brief Instantiates a NameChangeStub test transaction
/// The transaction is constructed around a predefined (i.e "canned")
/// NameChangeRequest. The request has both forward and reverse DNS
/// changes requested, and both forward and reverse domains are populated.
forward_domain_, reverse_domain_, cfg_mgr_)));
}
- /// @brief Instantiates a NameChangeStub test transaction
+ /// @brief Instantiates a NameChangeStub test transaction
/// The transaction is constructed around a predefined (i.e "canned")
/// NameChangeRequest. The request has both forward and reverse DNS
/// changes requested, and both forward and reverse domains are populated.
}
}
}
+
+ boost::shared_ptr<FauxServer> server_;
+
+ NameChangeStubPtr name_change_;
};
/// @brief Tests NameChangeTransaction construction.
/// 3. Construction with null reverse domain is not allowed when the request
/// requires reverse change.
/// 4. Valid construction functions properly
-TEST(NameChangeTransaction, construction) {
- asiolink::IOServicePtr io_service(new isc::asiolink::IOService());
+TEST_F(NameChangeTransactionTest, construction) {
D2CfgMgrPtr cfg_mgr(new D2CfgMgr());
const char* msg_str =
NameChangeTransactionError);
// Verify that construction with an empty NameChangeRequest throws.
- EXPECT_THROW(NameChangeTransaction(io_service, empty_ncr,
+ EXPECT_THROW(NameChangeTransaction(io_service_, empty_ncr,
forward_domain, reverse_domain, cfg_mgr),
- NameChangeTransactionError);
+ NameChangeTransactionError);
// Verify that construction with an empty D2CfgMgr throws.
D2CfgMgrPtr empty_cfg;
- EXPECT_THROW(NameChangeTransaction(io_service, empty_ncr,
+ EXPECT_THROW(NameChangeTransaction(io_service_, empty_ncr,
forward_domain, reverse_domain,
empty_cfg),
NameChangeTransactionError);
-
// Verify that construction with an empty forward domain when the
// NameChangeRequest calls for a forward change throws.
- EXPECT_THROW(NameChangeTransaction(io_service, ncr,
+ EXPECT_THROW(NameChangeTransaction(io_service_, ncr,
empty_domain, reverse_domain, cfg_mgr),
NameChangeTransactionError);
// Verify that construction with an empty reverse domain when the
// NameChangeRequest calls for a reverse change throws.
- EXPECT_THROW(NameChangeTransaction(io_service, ncr,
+ EXPECT_THROW(NameChangeTransaction(io_service_, ncr,
forward_domain, empty_domain, cfg_mgr),
NameChangeTransactionError);
// Verify that a valid construction attempt works.
- EXPECT_NO_THROW(NameChangeTransaction(io_service, ncr,
+ EXPECT_NO_THROW(NameChangeTransaction(io_service_, ncr,
forward_domain, reverse_domain,
cfg_mgr));
// not include a forward change.
ncr->setForwardChange(false);
ncr->setReverseChange(true);
- EXPECT_NO_THROW(NameChangeTransaction(io_service, ncr,
+ EXPECT_NO_THROW(NameChangeTransaction(io_service_, ncr,
empty_domain, reverse_domain,
cfg_mgr));
// not include a reverse change.
ncr->setForwardChange(true);
ncr->setReverseChange(false);
- EXPECT_NO_THROW(NameChangeTransaction(io_service, ncr,
+ EXPECT_NO_THROW(NameChangeTransaction(io_service_, ncr,
forward_domain, empty_domain,
cfg_mgr));
}
/// @brief General testing of member accessors.
/// Most if not all of these are also tested as a byproduct of larger tests.
TEST_F(NameChangeTransactionTest, accessors) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Verify that fetching the NameChangeRequest works.
- dhcp_ddns::NameChangeRequestPtr ncr = name_change->getNcr();
+ dhcp_ddns::NameChangeRequestPtr ncr = name_change_->getNcr();
ASSERT_TRUE(ncr);
// Verify that getTransactionKey works.
- EXPECT_EQ(ncr->getDhcid(), name_change->getTransactionKey());
+ EXPECT_EQ(ncr->getDhcid(), name_change_->getTransactionKey());
// Verify that getRequestId works.
- EXPECT_EQ(ncr->getRequestId(), name_change->getRequestId());
+ EXPECT_EQ(ncr->getRequestId(), name_change_->getRequestId());
// Verify that NcrStatus can be set and retrieved.
- EXPECT_NO_THROW(name_change->setNcrStatus(dhcp_ddns::ST_FAILED));
+ EXPECT_NO_THROW(name_change_->setNcrStatus(dhcp_ddns::ST_FAILED));
EXPECT_EQ(dhcp_ddns::ST_FAILED, ncr->getStatus());
// Verify that the forward domain can be retrieved.
- ASSERT_TRUE(name_change->getForwardDomain());
- EXPECT_EQ(forward_domain_, name_change->getForwardDomain());
+ ASSERT_TRUE(name_change_->getForwardDomain());
+ EXPECT_EQ(forward_domain_, name_change_->getForwardDomain());
// Verify that the reverse domain can be retrieved.
- ASSERT_TRUE(name_change->getReverseDomain());
- EXPECT_EQ(reverse_domain_, name_change->getReverseDomain());
+ ASSERT_TRUE(name_change_->getReverseDomain());
+ EXPECT_EQ(reverse_domain_, name_change_->getReverseDomain());
// Neither of these have direct setters, but are tested under server
// selection.
- EXPECT_FALSE(name_change->getDNSClient());
- EXPECT_FALSE(name_change->getCurrentServer());
+ EXPECT_FALSE(name_change_->getDNSClient());
+ EXPECT_FALSE(name_change_->getCurrentServer());
// Verify that DNS update status can be set and retrieved.
- EXPECT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::TIMEOUT));
- EXPECT_EQ(DNSClient::TIMEOUT, name_change->getDnsUpdateStatus());
+ EXPECT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::TIMEOUT));
+ EXPECT_EQ(DNSClient::TIMEOUT, name_change_->getDnsUpdateStatus());
// Verify that the forward change complete flag can be set and fetched.
- EXPECT_NO_THROW(name_change->setForwardChangeCompleted(true));
- EXPECT_TRUE(name_change->getForwardChangeCompleted());
+ EXPECT_NO_THROW(name_change_->setForwardChangeCompleted(true));
+ EXPECT_TRUE(name_change_->getForwardChangeCompleted());
// Verify that the reverse change complete flag can be set and fetched.
- EXPECT_NO_THROW(name_change->setReverseChangeCompleted(true));
- EXPECT_TRUE(name_change->getReverseChangeCompleted());
+ EXPECT_NO_THROW(name_change_->setReverseChangeCompleted(true));
+ EXPECT_TRUE(name_change_->getReverseChangeCompleted());
}
/// @brief Tests DNS update request accessor methods.
TEST_F(NameChangeTransactionTest, dnsUpdateRequestAccessors) {
// Create a transaction.
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Post transaction construction, there should not be an update request.
- EXPECT_FALSE(name_change->getDnsUpdateRequest());
+ EXPECT_FALSE(name_change_->getDnsUpdateRequest());
// Create a request.
D2UpdateMessagePtr req;
ASSERT_NO_THROW(req.reset(new D2UpdateMessage(D2UpdateMessage::OUTBOUND)));
// Use the setter and then verify we can fetch the request.
- ASSERT_NO_THROW(name_change->setDnsUpdateRequest(req));
+ ASSERT_NO_THROW(name_change_->setDnsUpdateRequest(req));
// Post set, we should be able to fetch it.
- ASSERT_TRUE(name_change->getDnsUpdateRequest());
+ ASSERT_TRUE(name_change_->getDnsUpdateRequest());
// Should be able to clear it.
- ASSERT_NO_THROW(name_change->clearDnsUpdateRequest());
+ ASSERT_NO_THROW(name_change_->clearDnsUpdateRequest());
// Should be empty again.
- EXPECT_FALSE(name_change->getDnsUpdateRequest());
+ EXPECT_FALSE(name_change_->getDnsUpdateRequest());
}
/// @brief Tests DNS update request accessor methods.
TEST_F(NameChangeTransactionTest, dnsUpdateResponseAccessors) {
// Create a transaction.
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Post transaction construction, there should not be an update response.
- EXPECT_FALSE(name_change->getDnsUpdateResponse());
+ EXPECT_FALSE(name_change_->getDnsUpdateResponse());
// Create a response.
D2UpdateMessagePtr resp;
ASSERT_NO_THROW(resp.reset(new D2UpdateMessage(D2UpdateMessage::INBOUND)));
// Use the setter and then verify we can fetch the response.
- ASSERT_NO_THROW(name_change->setDnsUpdateResponse(resp));
+ ASSERT_NO_THROW(name_change_->setDnsUpdateResponse(resp));
// Post set, we should be able to fetch it.
- EXPECT_TRUE(name_change->getDnsUpdateResponse());
+ EXPECT_TRUE(name_change_->getDnsUpdateResponse());
// Should be able to clear it.
- ASSERT_NO_THROW(name_change->clearDnsUpdateResponse());
+ ASSERT_NO_THROW(name_change_->clearDnsUpdateResponse());
// Should be empty again.
- EXPECT_FALSE(name_change->getDnsUpdateResponse());
+ EXPECT_FALSE(name_change_->getDnsUpdateResponse());
}
/// @brief Tests responseString method.
TEST_F(NameChangeTransactionTest, responseString) {
// Create a transaction.
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Make sure it is safe to call when status says success but there
// is no update response.
- ASSERT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::SUCCESS));
+ ASSERT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::SUCCESS));
EXPECT_EQ("SUCCESS, rcode: update response is NULL",
- name_change->responseString());
+ name_change_->responseString());
// Create a response. (We use an OUTBOUND message so we can set RCODE)
D2UpdateMessagePtr resp;
ASSERT_NO_THROW(resp.reset(new D2UpdateMessage(D2UpdateMessage::OUTBOUND)));
- ASSERT_NO_THROW(name_change->setDnsUpdateResponse(resp));
+ ASSERT_NO_THROW(name_change_->setDnsUpdateResponse(resp));
// Make sure we decode Rcode when status is successful.
ASSERT_NO_THROW(resp->setRcode(dns::Rcode::NXDOMAIN()));
- EXPECT_EQ("SUCCESS, rcode: NXDOMAIN", name_change->responseString());
+ EXPECT_EQ("SUCCESS, rcode: NXDOMAIN", name_change_->responseString());
// Test all of the non-success values for status.
- ASSERT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::TIMEOUT));
- EXPECT_EQ("TIMEOUT", name_change->responseString());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::TIMEOUT));
+ EXPECT_EQ("TIMEOUT", name_change_->responseString());
- ASSERT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::IO_STOPPED));
- EXPECT_EQ("IO_STOPPED", name_change->responseString());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::IO_STOPPED));
+ EXPECT_EQ("IO_STOPPED", name_change_->responseString());
- ASSERT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::
+ ASSERT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::
INVALID_RESPONSE));
- EXPECT_EQ("INVALID_RESPONSE", name_change->responseString());
+ EXPECT_EQ("INVALID_RESPONSE", name_change_->responseString());
- ASSERT_NO_THROW(name_change->setDnsUpdateStatus(DNSClient::OTHER));
- EXPECT_EQ("OTHER", name_change->responseString());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateStatus(DNSClient::OTHER));
+ EXPECT_EQ("OTHER", name_change_->responseString());
}
/// @brief Tests transactionOutcomeString method.
TEST_F(NameChangeTransactionTest, transactionOutcomeString) {
// Create a transaction.
- NameChangeStubPtr name_change;
dhcp_ddns::NameChangeRequestPtr ncr;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ncr = name_change->getNcr();
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ncr = name_change_->getNcr();
// Check case of failed transaction in both directions
std::string exp_str("Status: Failed, Event: UNDEFINED, Forward change:"
" failed, Reverse change: failed, request: ");
exp_str += ncr->toText();
- std::string tstring = name_change->transactionOutcomeString();
+ std::string tstring = name_change_->transactionOutcomeString();
std::cout << "tstring is: [" << tstring << "]" << std::endl;
- EXPECT_EQ(exp_str, name_change->transactionOutcomeString());
+ EXPECT_EQ(exp_str, name_change_->transactionOutcomeString());
// Check case of success all around
- name_change->setNcrStatus(dhcp_ddns::ST_COMPLETED);
- name_change->setForwardChangeCompleted(true);
- name_change->setReverseChangeCompleted(true);
+ name_change_->setNcrStatus(dhcp_ddns::ST_COMPLETED);
+ name_change_->setForwardChangeCompleted(true);
+ name_change_->setReverseChangeCompleted(true);
exp_str = "Status: Completed, Event: UNDEFINED, Forward change: completed,"
" Reverse change: completed, request: " + ncr->toText();
- EXPECT_EQ(exp_str, name_change->transactionOutcomeString());
+ EXPECT_EQ(exp_str, name_change_->transactionOutcomeString());
// Check case of success, with no forward change
- name_change->setNcrStatus(dhcp_ddns::ST_COMPLETED);
+ name_change_->setNcrStatus(dhcp_ddns::ST_COMPLETED);
ncr->setForwardChange(false);
exp_str = "Status: Completed, Event: UNDEFINED, "
" Reverse change: completed, request: " + ncr->toText();
- EXPECT_EQ(exp_str, name_change->transactionOutcomeString());
+ EXPECT_EQ(exp_str, name_change_->transactionOutcomeString());
// Check case of success, with no reverse change
- name_change->setNcrStatus(dhcp_ddns::ST_COMPLETED);
+ name_change_->setNcrStatus(dhcp_ddns::ST_COMPLETED);
ncr->setForwardChange(true);
ncr->setReverseChange(false);
exp_str = "Status: Completed, Event: UNDEFINED, "
" Forward change: completed, request: " + ncr->toText();
- EXPECT_EQ(exp_str, name_change->transactionOutcomeString());
+ EXPECT_EQ(exp_str, name_change_->transactionOutcomeString());
}
/// @brief Tests event and state dictionary construction and verification.
TEST_F(NameChangeTransactionTest, dictionaryCheck) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Verify that the event and state dictionary validation fails prior
// dictionary construction.
- ASSERT_THROW(name_change->verifyEvents(), StateModelError);
- ASSERT_THROW(name_change->verifyStates(), StateModelError);
+ ASSERT_THROW(name_change_->verifyEvents(), StateModelError);
+ ASSERT_THROW(name_change_->verifyStates(), StateModelError);
// Construct both dictionaries.
- ASSERT_NO_THROW(name_change->defineEvents());
- ASSERT_NO_THROW(name_change->defineStates());
+ ASSERT_NO_THROW(name_change_->defineEvents());
+ ASSERT_NO_THROW(name_change_->defineStates());
// Verify both event and state dictionaries now pass validation.
- ASSERT_NO_THROW(name_change->verifyEvents());
- ASSERT_NO_THROW(name_change->verifyStates());
+ ASSERT_NO_THROW(name_change_->verifyEvents());
+ ASSERT_NO_THROW(name_change_->verifyStates());
}
/// @brief Tests server selection methods.
/// when a DNS exchange fails due to an IO error. This test verifies the
/// ability to iteratively select a server from the list as the current server.
TEST_F(NameChangeTransactionTest, serverSelectionTest) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Verify that the forward domain and its list of servers can be retrieved.
- DdnsDomainPtr& domain = name_change->getForwardDomain();
+ DdnsDomainPtr& domain = name_change_->getForwardDomain();
ASSERT_TRUE(domain);
DnsServerInfoStoragePtr servers = domain->getServers();
ASSERT_TRUE(servers);
// Verify that we can initialize server selection. This "resets" the
// selection process to start over using the list of servers in the
// given domain.
- ASSERT_NO_THROW(name_change->initServerSelection(domain));
+ ASSERT_NO_THROW(name_change_->initServerSelection(domain));
// The server selection process determines the current server,
// instantiates a new DNSClient, and a DNS response message buffer.
// We need to save the values before each selection, so we can verify
// they are correct after each selection.
- DnsServerInfoPtr prev_server = name_change->getCurrentServer();
- DNSClientPtr prev_client = name_change->getDNSClient();
+ DnsServerInfoPtr prev_server = name_change_->getCurrentServer();
+ DNSClientPtr prev_client = name_change_->getDNSClient();
// Verify response pointer is empty.
- EXPECT_FALSE(name_change->getDnsUpdateResponse());
+ EXPECT_FALSE(name_change_->getDnsUpdateResponse());
// Create dummy response so we can verify it is cleared at each
// new server select.
D2UpdateMessagePtr dummyResp;
dummyResp.reset(new D2UpdateMessage(D2UpdateMessage::INBOUND));
- ASSERT_NO_THROW(name_change->setDnsUpdateResponse(dummyResp));
- ASSERT_TRUE(name_change->getDnsUpdateResponse());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateResponse(dummyResp));
+ ASSERT_TRUE(name_change_->getDnsUpdateResponse());
// Iteratively select through the list of servers.
int passes = 0;
- while (name_change->selectNextServer()) {
+ while (name_change_->selectNextServer()) {
// Get the new values after the selection has been made.
- DnsServerInfoPtr server = name_change->getCurrentServer();
- DNSClientPtr client = name_change->getDNSClient();
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ DnsServerInfoPtr server = name_change_->getCurrentServer();
+ DNSClientPtr client = name_change_->getDNSClient();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
// Verify that the new values are not empty.
EXPECT_TRUE(server);
EXPECT_TRUE(client);
// Verify response pointer is now empty.
- EXPECT_FALSE(name_change->getDnsUpdateResponse());
+ EXPECT_FALSE(name_change_->getDnsUpdateResponse());
// Verify that the new values are indeed new.
EXPECT_NE(server, prev_server);
// Create new dummy response.
dummyResp.reset(new D2UpdateMessage(D2UpdateMessage::INBOUND));
- ASSERT_NO_THROW(name_change->setDnsUpdateResponse(dummyResp));
- ASSERT_TRUE(name_change->getDnsUpdateResponse());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateResponse(dummyResp));
+ ASSERT_TRUE(name_change_->getDnsUpdateResponse());
++passes;
}
// Verify that the number of passes made equal the number of servers.
- EXPECT_EQ (passes, num_servers);
+ EXPECT_EQ(passes, num_servers);
// Repeat the same test using the reverse domain.
// Verify that the reverse domain and its list of servers can be retrieved.
- domain = name_change->getReverseDomain();
+ domain = name_change_->getReverseDomain();
ASSERT_TRUE(domain);
servers = domain->getServers();
ASSERT_TRUE(servers);
// Verify that we can initialize server selection. This "resets" the
// selection process to start over using the list of servers in the
// given domain.
- ASSERT_NO_THROW(name_change->initServerSelection(domain));
+ ASSERT_NO_THROW(name_change_->initServerSelection(domain));
// The server selection process determines the current server,
// instantiates a new DNSClient, and resets the DNS response message buffer.
// We need to save the values before each selection, so we can verify
// they are correct after each selection.
- prev_server = name_change->getCurrentServer();
- prev_client = name_change->getDNSClient();
+ prev_server = name_change_->getCurrentServer();
+ prev_client = name_change_->getDNSClient();
// Iteratively select through the list of servers.
passes = 0;
- while (name_change->selectNextServer()) {
+ while (name_change_->selectNextServer()) {
// Get the new values after the selection has been made.
- DnsServerInfoPtr server = name_change->getCurrentServer();
- DNSClientPtr client = name_change->getDNSClient();
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ DnsServerInfoPtr server = name_change_->getCurrentServer();
+ DNSClientPtr client = name_change_->getDNSClient();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
// Verify that the new values are not empty.
EXPECT_TRUE(server);
EXPECT_TRUE(client);
// Verify response pointer is now empty.
- EXPECT_FALSE(name_change->getDnsUpdateResponse());
+ EXPECT_FALSE(name_change_->getDnsUpdateResponse());
// Verify that the new values are indeed new.
EXPECT_NE(server, prev_server);
// Create new dummy response.
dummyResp.reset(new D2UpdateMessage(D2UpdateMessage::INBOUND));
- ASSERT_NO_THROW(name_change->setDnsUpdateResponse(dummyResp));
- ASSERT_TRUE(name_change->getDnsUpdateResponse());
+ ASSERT_NO_THROW(name_change_->setDnsUpdateResponse(dummyResp));
+ ASSERT_TRUE(name_change_->getDnsUpdateResponse());
++passes;
}
// Verify that the number of passes made equal the number of servers.
- EXPECT_EQ (passes, num_servers);
+ EXPECT_EQ(passes, num_servers);
}
/// @brief Tests that the transaction will be "failed" upon model errors.
TEST_F(NameChangeTransactionTest, modelFailure) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Now call runModel() with an undefined event which should not throw,
// but should result in a failed model and failed transaction.
- EXPECT_NO_THROW(name_change->runModel(9999));
+ EXPECT_NO_THROW(name_change_->runModel(9999));
// Verify that the model reports are done but failed.
- EXPECT_TRUE(name_change->isModelDone());
- EXPECT_TRUE(name_change->didModelFail());
+ EXPECT_TRUE(name_change_->isModelDone());
+ EXPECT_TRUE(name_change_->didModelFail());
// Verify that the transaction has failed.
- EXPECT_EQ(dhcp_ddns::ST_FAILED, name_change->getNcrStatus());
+ EXPECT_EQ(dhcp_ddns::ST_FAILED, name_change_->getNcrStatus());
}
/// @brief Tests the ability to use startTransaction to initiate the state
/// model execution, and DNSClient callback, operator(), to resume the
/// model with a update successful outcome.
TEST_F(NameChangeTransactionTest, successfulUpdateTest) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_TRUE(name_change_->selectFwdServer());
- EXPECT_TRUE(name_change->isModelNew());
- EXPECT_FALSE(name_change->getForwardChangeCompleted());
+ EXPECT_TRUE(name_change_->isModelNew());
+ EXPECT_FALSE(name_change_->getForwardChangeCompleted());
// Launch the transaction by calling startTransaction. The state model
// should run up until the "IO" operation is initiated in DOING_UPDATE_ST.
- ASSERT_NO_THROW(name_change->startTransaction());
+ ASSERT_NO_THROW(name_change_->startTransaction());
// Verify that the model is running but waiting, and that forward change
// completion is still false.
- EXPECT_TRUE(name_change->isModelRunning());
- EXPECT_TRUE(name_change->isModelWaiting());
- EXPECT_FALSE(name_change->getForwardChangeCompleted());
+ EXPECT_TRUE(name_change_->isModelRunning());
+ EXPECT_TRUE(name_change_->isModelWaiting());
+ EXPECT_FALSE(name_change_->getForwardChangeCompleted());
// Simulate completion of DNSClient exchange by invoking the callback, as
// DNSClient would. This should cause the state model to progress through
// completion.
- EXPECT_NO_THROW((*name_change)(DNSClient::SUCCESS));
+ EXPECT_NO_THROW((*name_change_)(DNSClient::SUCCESS));
// The model should have worked through to completion.
// Verify that the model is done and not failed.
- EXPECT_TRUE(name_change->isModelDone());
- EXPECT_FALSE(name_change->didModelFail());
+ EXPECT_TRUE(name_change_->isModelDone());
+ EXPECT_FALSE(name_change_->didModelFail());
// Verify that NCR status is completed, and that the forward change
// was completed.
- EXPECT_EQ(dhcp_ddns::ST_COMPLETED, name_change->getNcrStatus());
- EXPECT_TRUE(name_change->getForwardChangeCompleted());
+ EXPECT_EQ(dhcp_ddns::ST_COMPLETED, name_change_->getNcrStatus());
+ EXPECT_TRUE(name_change_->getForwardChangeCompleted());
}
/// @brief Tests the ability to use startTransaction to initiate the state
/// model execution, and DNSClient callback, operator(), to resume the
/// model with a update failure outcome.
TEST_F(NameChangeTransactionTest, failedUpdateTest) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Launch the transaction by calling startTransaction. The state model
// should run up until the "IO" operation is initiated in DOING_UPDATE_ST.
- ASSERT_NO_THROW(name_change->startTransaction());
+ ASSERT_NO_THROW(name_change_->startTransaction());
// Verify that the model is running but waiting, and that the forward
// change has not been completed.
- EXPECT_TRUE(name_change->isModelRunning());
- EXPECT_TRUE(name_change->isModelWaiting());
- EXPECT_FALSE(name_change->getForwardChangeCompleted());
+ EXPECT_TRUE(name_change_->isModelRunning());
+ EXPECT_TRUE(name_change_->isModelWaiting());
+ EXPECT_FALSE(name_change_->getForwardChangeCompleted());
// Simulate completion of DNSClient exchange by invoking the callback, as
// DNSClient would. This should cause the state model to progress through
// to completion.
- EXPECT_NO_THROW((*name_change)(DNSClient::TIMEOUT));
+ EXPECT_NO_THROW((*name_change_)(DNSClient::TIMEOUT));
// The model should have worked through to completion.
// Verify that the model is done and not failed.
- EXPECT_TRUE(name_change->isModelDone());
- EXPECT_FALSE(name_change->didModelFail());
+ EXPECT_TRUE(name_change_->isModelDone());
+ EXPECT_FALSE(name_change_->didModelFail());
// Verify that the NCR status is failed and that the forward change
// was not completed.
- EXPECT_EQ(dhcp_ddns::ST_FAILED, name_change->getNcrStatus());
- EXPECT_FALSE(name_change->getForwardChangeCompleted());
+ EXPECT_EQ(dhcp_ddns::ST_FAILED, name_change_->getNcrStatus());
+ EXPECT_FALSE(name_change_->getForwardChangeCompleted());
}
/// @brief Tests update attempt accessors.
TEST_F(NameChangeTransactionTest, updateAttempts) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Post transaction construction, update attempts should be 0.
- EXPECT_EQ(0, name_change->getUpdateAttempts());
+ EXPECT_EQ(0, name_change_->getUpdateAttempts());
// Set it to a known value.
- name_change->setUpdateAttempts(5);
+ name_change_->setUpdateAttempts(5);
// Verify that the value is as expected.
- EXPECT_EQ(5, name_change->getUpdateAttempts());
+ EXPECT_EQ(5, name_change_->getUpdateAttempts());
// Clear it.
- name_change->clearUpdateAttempts();
+ name_change_->clearUpdateAttempts();
// Verify that it was cleared as expected.
- EXPECT_EQ(0, name_change->getUpdateAttempts());
+ EXPECT_EQ(0, name_change_->getUpdateAttempts());
}
/// @brief Tests retryTransition method
/// transition to the state given with a next event of SERVER_IO_ERROR_EVT.
TEST_F(NameChangeTransactionTest, retryTransition) {
// Create the transaction.
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
// Define dictionaries.
- ASSERT_NO_THROW(name_change->initDictionaries());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
// Transition to a known spot.
- ASSERT_NO_THROW(name_change->transition(
+ ASSERT_NO_THROW(name_change_->transition(
NameChangeStub::DOING_UPDATE_ST,
NameChangeStub::SEND_UPDATE_EVT));
// Verify we are at the known spot.
ASSERT_EQ(NameChangeStub::DOING_UPDATE_ST,
- name_change->getCurrState());
+ name_change_->getCurrState());
ASSERT_EQ(NameChangeStub::SEND_UPDATE_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
// Verify that we have not exceeded maximum number of attempts.
- ASSERT_LT(name_change->getUpdateAttempts(),
+ ASSERT_LT(name_change_->getUpdateAttempts(),
NameChangeTransaction::MAX_UPDATE_TRIES_PER_SERVER);
// Call retryTransition.
- ASSERT_NO_THROW(name_change->retryTransition(
+ ASSERT_NO_THROW(name_change_->retryTransition(
NameChangeTransaction::PROCESS_TRANS_FAILED_ST));
// Since the number of update attempts is less than the maximum allowed
// we should remain in our current state but with next event of
// SERVER_SELECTED_EVT posted.
ASSERT_EQ(NameChangeStub::DOING_UPDATE_ST,
- name_change->getCurrState());
+ name_change_->getCurrState());
ASSERT_EQ(NameChangeTransaction::SERVER_SELECTED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
// Now set the number of attempts to the maximum.
- name_change->setUpdateAttempts(NameChangeTransaction::
- MAX_UPDATE_TRIES_PER_SERVER);
+ name_change_->setUpdateAttempts(NameChangeTransaction::
+ MAX_UPDATE_TRIES_PER_SERVER);
// Call retryTransition.
- ASSERT_NO_THROW(name_change->retryTransition(
+ ASSERT_NO_THROW(name_change_->retryTransition(
NameChangeTransaction::PROCESS_TRANS_FAILED_ST));
// Since we have exceeded maximum attempts, we should transition to
// PROCESS_UPDATE_FAILED_ST with a next event of SERVER_IO_ERROR_EVT.
ASSERT_EQ(NameChangeTransaction::PROCESS_TRANS_FAILED_ST,
- name_change->getCurrState());
+ name_change_->getCurrState());
ASSERT_EQ(NameChangeTransaction::SERVER_IO_ERROR_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
}
/// @brief Tests sendUpdate method when underlying doUpdate throws.
/// sendUpdate handling of such a throw by passing doUpdate a request
/// that will not render.
TEST_F(NameChangeTransactionTest, sendUpdateDoUpdateFailure) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Set the transaction's request to an empty DNS update.
D2UpdateMessagePtr req;
ASSERT_NO_THROW(req.reset(new D2UpdateMessage(D2UpdateMessage::OUTBOUND)));
- ASSERT_NO_THROW(name_change->setDnsUpdateRequest(req));
+ ASSERT_NO_THROW(name_change_->setDnsUpdateRequest(req));
// Verify that sendUpdate does not throw, but it should fail because
// the request won't render.
- ASSERT_NO_THROW(name_change->sendUpdate());
+ ASSERT_NO_THROW(name_change_->sendUpdate());
// Verify that we transition to failed state and event.
ASSERT_EQ(NameChangeTransaction::PROCESS_TRANS_FAILED_ST,
- name_change->getCurrState());
+ name_change_->getCurrState());
ASSERT_EQ(NameChangeTransaction::UPDATE_FAILED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
}
/// @brief Tests sendUpdate method when underlying doUpdate times out.
TEST_F(NameChangeTransactionTest, sendUpdateTimeout) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Build a valid request, call sendUpdate and process the response.
// Note we have to wait for DNSClient timeout plus a bit more to allow
D2ParamsPtr d2_params = cfg_mgr_->getD2Params();
size_t timeout = d2_params->getDnsServerTimeout() + 100;
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change, timeout));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_, timeout));
// Verify that next event is IO_COMPLETED_EVT and DNS status is TIMEOUT.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
- ASSERT_EQ(DNSClient::TIMEOUT, name_change->getDnsUpdateStatus());
+ name_change_->getNextEvent());
+ ASSERT_EQ(DNSClient::TIMEOUT, name_change_->getDnsUpdateStatus());
}
/// @brief Tests sendUpdate method when it receives a corrupt response from
/// the server.
TEST_F(NameChangeTransactionTest, sendUpdateCorruptResponse) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server and start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
- server.receive(FauxServer::CORRUPT_RESP);
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
+ server_->receive(FauxServer::CORRUPT_RESP);
// Build a valid request, call sendUpdate and process the response.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is INVALID.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
- ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change->getDnsUpdateStatus());
+ name_change_->getNextEvent());
+ ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change_->getDnsUpdateStatus());
}
/// @brief Tests sendUpdate method when the exchange succeeds.
TEST_F(NameChangeTransactionTest, sendUpdate) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server and start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
- server.receive (FauxServer::USE_RCODE, dns::Rcode::NOERROR());
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
+ server_->receive(FauxServer::USE_RCODE, dns::Rcode::NOERROR());
// Build a valid request, call sendUpdate and process the response.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is SUCCESS.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
- ASSERT_EQ(DNSClient::SUCCESS, name_change->getDnsUpdateStatus());
+ name_change_->getNextEvent());
+ ASSERT_EQ(DNSClient::SUCCESS, name_change_->getDnsUpdateStatus());
// Verify that we have a response and it's Rcode is NOERROR,
// and the zone is as expected.
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
ASSERT_TRUE(response);
ASSERT_EQ(dns::Rcode::NOERROR().getCode(), response->getRcode().getCode());
D2ZonePtr zone = response->getZone();
/// @brief Tests that an unsigned response to a signed request is an error
TEST_F(NameChangeTransactionTest, tsigUnsignedResponse) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction("key_one"));
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction("key_one"));
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server and start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
- server.receive (FauxServer::USE_RCODE, dns::Rcode::NOERROR());
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
+ server_->receive(FauxServer::USE_RCODE, dns::Rcode::NOERROR());
// Do the update.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is
// INVALID_RESPONSE.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
- ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change->getDnsUpdateStatus());
+ ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change_->getDnsUpdateStatus());
// When TSIG errors occur, only the message header (including Rcode) is
// unpacked. In this case, it should be NOERROR but have no other
// information.
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
ASSERT_TRUE(response);
ASSERT_EQ(dns::Rcode::NOERROR().getCode(), response->getRcode().getCode());
EXPECT_FALSE(response->getZone());
/// @brief Tests that a response signed with the wrong key is an error
TEST_F(NameChangeTransactionTest, tsigInvalidResponse) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction("key_one"));
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction("key_one"));
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server, tell it to sign responses with a "random" key,
// then start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
- server.receive (FauxServer::INVALID_TSIG, dns::Rcode::NOERROR());
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
+ server_->receive(FauxServer::INVALID_TSIG, dns::Rcode::NOERROR());
// Do the update.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is
// INVALID_RESPONSE.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
- ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change->getDnsUpdateStatus());
+ ASSERT_EQ(DNSClient::INVALID_RESPONSE, name_change_->getDnsUpdateStatus());
// When TSIG errors occur, only the message header (including Rcode) is
// unpacked. In this case, it should be NOERROR but have no other
// information.
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
ASSERT_TRUE(response);
ASSERT_EQ(dns::Rcode::NOERROR().getCode(), response->getRcode().getCode());
EXPECT_FALSE(response->getZone());
/// Currently our policy is to accept a signed response to an unsigned request
/// even though the spec says a server MUST not do that.
TEST_F(NameChangeTransactionTest, tsigUnexpectedSignedResponse) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server, tell it to sign responses with a "random" key,
// then start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
- server.receive (FauxServer::INVALID_TSIG, dns::Rcode::NOERROR());
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
+ server_->receive(FauxServer::INVALID_TSIG, dns::Rcode::NOERROR());
// Perform an update without TSIG.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is SUCCESS.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
- ASSERT_EQ(DNSClient::SUCCESS, name_change->getDnsUpdateStatus());
+ ASSERT_EQ(DNSClient::SUCCESS, name_change_->getDnsUpdateStatus());
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
ASSERT_TRUE(response);
ASSERT_EQ(dns::Rcode::NOERROR().getCode(), response->getRcode().getCode());
D2ZonePtr zone = response->getZone();
algorithms.push_back(TSIGKeyInfo::HMAC_SHA512_STR);
for (int i = 0; i < algorithms.size(); ++i) {
- SCOPED_TRACE (algorithms[i]);
+ SCOPED_TRACE(algorithms[i]);
TSIGKeyInfoPtr key;
ASSERT_NO_THROW(key.reset(new TSIGKeyInfo("test_key",
algorithms[i],
"GWG/Xfbju4O2iXGqkSu4PQ==")));
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction(key));
- ASSERT_NO_THROW(name_change->initDictionaries());
- ASSERT_TRUE(name_change->selectFwdServer());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction(key));
+ ASSERT_NO_THROW(name_change_->initDictionaries());
+ ASSERT_TRUE(name_change_->selectFwdServer());
// Create a server, set its TSIG key, and then start it listening.
- FauxServer server(io_service_, *(name_change->getCurrentServer()));
+ server_.reset(new FauxServer(io_service_, *(name_change_->getCurrentServer())));
// Since we create a new server instance each time we need to tell
// it not reschedule receives automatically.
- server.perpetual_receive_ = false;
- server.setTSIGKey(key->getTSIGKey());
- server.receive (FauxServer::USE_RCODE, dns::Rcode::NOERROR());
+ server_->perpetual_receive_ = false;
+ server_->setTSIGKey(key->getTSIGKey());
+ server_->receive(FauxServer::USE_RCODE, dns::Rcode::NOERROR());
// Do the update.
- ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change));
+ ASSERT_NO_FATAL_FAILURE(doOneExchange(name_change_));
// Verify that next event is IO_COMPLETED_EVT and DNS status is SUCCESS.
ASSERT_EQ(NameChangeTransaction::IO_COMPLETED_EVT,
- name_change->getNextEvent());
+ name_change_->getNextEvent());
- ASSERT_EQ(DNSClient::SUCCESS, name_change->getDnsUpdateStatus());
+ ASSERT_EQ(DNSClient::SUCCESS, name_change_->getDnsUpdateStatus());
- D2UpdateMessagePtr response = name_change->getDnsUpdateResponse();
+ D2UpdateMessagePtr response = name_change_->getDnsUpdateResponse();
ASSERT_TRUE(response);
ASSERT_EQ(dns::Rcode::NOERROR().getCode(),
response->getRcode().getCode());
}
}
-
/// @brief Tests the prepNewRequest method
TEST_F(NameChangeTransactionTest, prepNewRequest) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
D2UpdateMessagePtr request;
// prepNewRequest should fail on empty domain.
- ASSERT_THROW(request = name_change->prepNewRequest(DdnsDomainPtr()),
+ ASSERT_THROW(request = name_change_->prepNewRequest(DdnsDomainPtr()),
NameChangeTransactionError);
// Verify that prepNewRequest fails on invalid zone name.
// @todo This test becomes obsolete if/when DdnsDomain enforces valid
// names as is done in dns::Name.
DdnsDomainPtr bsDomain = makeDomain(".badname","");
- ASSERT_THROW(request = name_change->prepNewRequest(bsDomain),
+ ASSERT_THROW(request = name_change_->prepNewRequest(bsDomain),
NameChangeTransactionError);
// Verify that prepNewRequest properly constructs a message given
// valid input.
- ASSERT_NO_THROW(request = name_change->prepNewRequest(forward_domain_));
+ ASSERT_NO_THROW(request = name_change_->prepNewRequest(forward_domain_));
checkZone(request, forward_domain_->getName());
// The query id is random so 0 is not impossible
for (unsigned i = 0; i < 10; ++i) {
if (request->getId() == 0) {
- request = name_change->prepNewRequest(forward_domain_);
+ request = name_change_->prepNewRequest(forward_domain_);
}
}
/// @brief Tests the addLeaseAddressRData method
TEST_F(NameChangeTransactionTest, addLeaseAddressRData) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- dhcp_ddns::NameChangeRequestPtr ncr = name_change->getNcr();
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ dhcp_ddns::NameChangeRequestPtr ncr = name_change_->getNcr();
// Verify we can add a lease RData to an valid RRset.
dns::RRsetPtr rrset(new dns::RRset(dns::Name("bs"), dns::RRClass::IN(),
- name_change->getAddressRRType(),
+ name_change_->getAddressRRType(),
dns::RRTTL(0)));
- ASSERT_NO_THROW(name_change->addLeaseAddressRdata(rrset));
+ ASSERT_NO_THROW(name_change_->addLeaseAddressRdata(rrset));
// Verify the Rdata was added and the value is correct.
ASSERT_EQ(1, rrset->getRdataCount());
/// @brief Tests the addDhcidRData method
TEST_F(NameChangeTransactionTest, addDhcidRdata) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- dhcp_ddns::NameChangeRequestPtr ncr = name_change->getNcr();
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ dhcp_ddns::NameChangeRequestPtr ncr = name_change_->getNcr();
// Verify we can add a lease RData to an valid RRset.
dns::RRsetPtr rrset(new dns::RRset(dns::Name("bs"), dns::RRClass::IN(),
dns::RRType::DHCID(), dns::RRTTL(0)));
- ASSERT_NO_THROW(name_change->addDhcidRdata(rrset));
+ ASSERT_NO_THROW(name_change_->addDhcidRdata(rrset));
// Verify the Rdata was added and the value is correct.
ASSERT_EQ(1, rrset->getRdataCount());
/// @brief Tests the addPtrData method
TEST_F(NameChangeTransactionTest, addPtrRdata) {
- NameChangeStubPtr name_change;
- ASSERT_NO_THROW(name_change = makeCannedTransaction());
- dhcp_ddns::NameChangeRequestPtr ncr = name_change->getNcr();
+ ASSERT_NO_THROW(name_change_ = makeCannedTransaction());
+ dhcp_ddns::NameChangeRequestPtr ncr = name_change_->getNcr();
// Verify we can add a PTR RData to an valid RRset.
- dns::RRsetPtr rrset (new dns::RRset(dns::Name("bs"), dns::RRClass::IN(),
+ dns::RRsetPtr rrset(new dns::RRset(dns::Name("bs"), dns::RRClass::IN(),
dns::RRType::PTR(), dns::RRTTL(0)));
- ASSERT_NO_THROW(name_change->addPtrRdata(rrset));
+ ASSERT_NO_THROW(name_change_->addPtrRdata(rrset));
// Verify the Rdata was added and the value is correct.
ASSERT_EQ(1, rrset->getRdataCount());
//********************** TimedIO class ***********************
TimedIO::TimedIO()
- : io_service_(new isc::asiolink::IOService()), timer_(io_service_),
+ : io_service_(new isc::asiolink::IOService()),
+ timer_(new asiolink::IntervalTimer(io_service_)),
run_time_(0) {
}
TimedIO::~TimedIO() {
+ timer_->cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
int
run_time_ = run_time;
int cnt = io_service_->poll();
if (cnt == 0) {
- timer_.setup(std::bind(&TimedIO::timesUp, this), run_time_);
+ timer_->setup(std::bind(&TimedIO::timesUp, this), run_time_);
cnt = io_service_->runOne();
- timer_.cancel();
+ timer_->cancel();
}
return (cnt);
/// @param response_mode Selects how the server responds to a request
/// @param response_rcode The Rcode value set in the response. Not used
/// for all modes.
- void receive (const ResponseMode& response_mode,
- const dns::Rcode& response_rcode=dns::Rcode::NOERROR());
+ void receive(const ResponseMode& response_mode,
+ const dns::Rcode& response_rcode=dns::Rcode::NOERROR());
/// @brief Socket IO Completion callback
///
class TimedIO {
public:
asiolink::IOServicePtr io_service_;
- asiolink::IntervalTimer timer_;
+ asiolink::IntervalTimerPtr timer_;
int run_time_;
/// @brief Constructor
TEST_TIMEOUT);
}
- virtual ~NameChangeUDPListenerTest(){
+ virtual ~NameChangeUDPListenerTest() {
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
}
~NameChangeUDPTest() {
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
// Disable multi-threading
MultiThreadingMgr::instance().setMode(false);
}
/// timers.
virtual ~CfgExpirationTimersTest() {
cleanupTimerMgr();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Stop @c TimerMgr worker thread and remove the timers.
TimerMgrTest::TearDown() {
// Remove all timers.
timer_mgr_->unregisterTimers();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
void
listener->stop();
}
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+
MultiThreadingMgr::instance().setMode(false);
}
/// @brief Destructor.
~HttpConnectionPoolTest() {
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
MultiThreadingMgr::instance().setMode(false);
}
for (auto const& client : clients_) {
client->close();
}
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Connect to the endpoint.
TEST_TIMEOUT, IntervalTimer::ONE_SHOT);
}
+ /// @brief Destructor.
+ virtual ~HttpListenerTest() {
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+ }
+
/// @brief Callback function invoke upon test timeout.
///
/// It stops the IO service and reports test timeout.
for (auto const& client : clients_) {
client->close();
}
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Connect to the endpoint.
if (controller_) {
// This shouldn't happen, but let's make sure it can't be done.
// It represents a programmatic error.
- isc_throw (DControllerBaseError,
- "Multiple controller instances attempted.");
+ isc_throw (DControllerBaseError, "Multiple controller instances attempted.");
}
controller_ = controller;
.arg(port_)
.arg(tls_context_ ? "true" : "false");
} catch (const std::exception& ex) {
- thread_io_service_.reset();
tcp_listener_.reset();
thread_pool_.reset();
+ thread_io_service_->restart();
+ try {
+ thread_io_service_->poll();
+ } catch (...) {
+ }
+ thread_io_service_.reset();
isc_throw(Unexpected, "MtTcpListenerMgr::start failed:" << ex.what());
}
}
// Get rid of the listener.
tcp_listener_.reset();
+ thread_io_service_->restart();
+ try {
+ thread_io_service_->poll();
+ } catch (...) {
+ }
+
// Ditch the IOService.
thread_io_service_.reset();
client->close();
}
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
+
// Disable multi-threading.
MultiThreadingMgr::instance().setMode(false);
}
ASSERT_THROW_MSG(mt_listener_mgr_->start(), InvalidOperation,
"MtTcpListenerMgr already started!");
+ return;
+
// Stop it and verify we're no longer listening.
ASSERT_NO_THROW_LOG(mt_listener_mgr_->stop());
ASSERT_TRUE(mt_listener_mgr_->isStopped());
for (auto const& client : clients_) {
client->close();
}
+
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Create a new client.
for (auto const& client : clients_) {
client->close();
}
+
+ test_timer_.cancel();
+ io_service_->restart();
+ try {
+ io_service_->poll();
+ } catch (...) {
+ }
}
/// @brief Fetch the server TLS context.
projects / thirdparty / kea.git / commitdiff
