SocketRequestor::SocketError);
}
+// A helper function to impose a read timeout for the server socket
+// in order to avoid deadlock when the client side has a bug and doesn't
+// send expected data.
+// It returns true when the timeout is set successfully; otherwise false.
+bool
+setRecvTimo(int s) {
+ const struct timeval timeo = { 10, 0 }; // 10sec, arbitrary choice
+ if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo)) == 0) {
+ return (true);
+ }
+ if (errno == ENOPROTOOPT) { // deviant OS, give up using it.
+ return (false);
+ }
+ isc_throw(isc::Unexpected, "set RCVTIMEO failed: " << strerror(errno));
+}
+
// Helper test class that creates a randomly named domain socket
// Upon init, it will only reserve the name (and place an empty file in its
// place).
void
cleanup() {
unlink(path_);
- free(path_);
+ if (path_ != NULL) {
+ free(path_);
+ path_ = NULL;
+ }
if (fd_ != -1) {
close(fd_);
fd_ = -1;
return (path_);
}
- // create socket, fork, and serve if child (child will exit when done)
- void run(const std::vector<int>& data) {
- try {
- create();
- const int child_pid = fork();
- if (child_pid == 0) {
- serve(data);
- exit(0);
- } else {
- // parent does not need fd anymore
- close(fd_);
- fd_ = -1;
- }
- } catch (const std::exception&) {
- cleanup();
- throw;
+ // create socket, fork, and serve if child (child will exit when done).
+ // If the underlying system doesn't allow to set read timeout, tell the
+ // caller that via a false return value so that the caller can avoid
+ // performing tests that could result in a dead lock.
+ bool run(const std::vector<std::pair<std::string, int> >& data) {
+ create();
+ const bool timo_ok = setRecvTimo(fd_);
+ const int child_pid = fork();
+ if (child_pid == 0) {
+ serve(data);
+ exit(0);
+ } else {
+ // parent does not need fd anymore
+ close(fd_);
+ fd_ = -1;
}
+ return (timo_ok);
}
private:
// Actually create the socket and listen on it
// NOTE: client_fd could leak on exception. This should be cleaned up.
// See the note about SocketSessionReceiver in socket_request.cc.
void
- serve(const std::vector<int>& data) {
+ serve(const std::vector<std::pair<std::string, int> > data) {
const int client_fd = accept(fd_, NULL, NULL);
if (client_fd == -1) {
- isc_throw(Exception, "Error in accept(): " << strerror(errno));
+ isc_throw(Unexpected, "Error in accept(): " << strerror(errno));
+ }
+ if (!setRecvTimo(client_fd)) {
+ // In the loop below we do blocking read. To avoid deadlock
+ // when the parent is buggy we'll skip it unless we can
+ // set a read timeout on the socket.
+ return;
}
- BOOST_FOREACH(int cur_data, data) {
+ typedef std::pair<std::string, int> DataPair;
+ BOOST_FOREACH(DataPair cur_data, data) {
+ char buf[5];
+ memset(buf, 0, 5);
+ if (isc::util::io::read_data(client_fd, buf, 4) != 4) {
+ isc_throw(Unexpected, "unable to receive socket token");
+ }
+ if (cur_data.first != buf) {
+ isc_throw(Unexpected, "socket token mismatch: expected="
+ << cur_data.first << ", actual=" << buf);
+ }
+
bool result;
- if (cur_data == -1) {
+ if (cur_data.second == -1) {
// send 'CREATOR_SOCKET_UNAVAILABLE'
result = isc::util::io::write_data(client_fd, "0\n", 2);
- } else if (cur_data == -2) {
+ } else if (cur_data.second == -2) {
// send 'CREATOR_SOCKET_OK' first
result = isc::util::io::write_data(client_fd, "1\n", 2);
if (result) {
// send 'CREATOR_SOCKET_OK' first
result = isc::util::io::write_data(client_fd, "1\n", 2);
if (result) {
- if (isc::util::io::send_fd(client_fd, cur_data) != 0) {
+ if (isc::util::io::send_fd(client_fd,
+ cur_data.second) != 0) {
result = false;
}
}
TEST_F(SocketRequestorTest, testSocketPassing) {
TestSocket ts;
- std::vector<int> data;
- data.push_back(1);
- data.push_back(2);
- data.push_back(3);
- data.push_back(1);
- data.push_back(-1);
- data.push_back(-2);
- ts.run(data);
-
- // 1 should be ok
- addAnswer("foo", ts.getPath());
- SocketRequestor::SocketID socket_id = doRequest();
- ASSERT_EQ("foo", socket_id.second);
- ASSERT_EQ(0, close(socket_id.first));
-
- // 2 should be ok too
- addAnswer("bar", ts.getPath());
- socket_id = doRequest();
- ASSERT_EQ("bar", socket_id.second);
- ASSERT_EQ(0, close(socket_id.first));
-
- // 3 should be ok too (reuse earlier token)
- addAnswer("foo", ts.getPath());
- socket_id = doRequest();
- ASSERT_EQ("foo", socket_id.second);
- ASSERT_EQ(0, close(socket_id.first));
+ std::vector<std::pair<std::string, int> > data;
+ data.push_back(std::pair<std::string, int>("foo\n", 1));
+ data.push_back(std::pair<std::string, int>("bar\n", 2));
+ data.push_back(std::pair<std::string, int>("foo\n", 3));
+ data.push_back(std::pair<std::string, int>("foo\n", 1));
+ data.push_back(std::pair<std::string, int>("foo\n", -1));
+ data.push_back(std::pair<std::string, int>("foo\n", -2));
+
+ // run() returns true iff we can specify read timeout so we avoid a
+ // deadlock. Unless there's a bug the test should succeed even without the
+ // timeout, but we don't want to make the test hang up in case with an
+ // unexpected bug, so we'd rather skip most of the tests in that case.
+ const bool timo_ok = ts.run(data);
+ SocketRequestor::SocketID socket_id;
+ if (timo_ok) {
+ // 1 should be ok
+ addAnswer("foo", ts.getPath());
+ socket_id = doRequest();
+ ASSERT_EQ("foo", socket_id.second);
+ ASSERT_EQ(0, close(socket_id.first));
+
+ // 2 should be ok too
+ addAnswer("bar", ts.getPath());
+ socket_id = doRequest();
+ ASSERT_EQ("bar", socket_id.second);
+ ASSERT_EQ(0, close(socket_id.first));
+
+ // 3 should be ok too (reuse earlier token)
+ addAnswer("foo", ts.getPath());
+ socket_id = doRequest();
+ ASSERT_EQ("foo", socket_id.second);
+ ASSERT_EQ(0, close(socket_id.first));
+ }
// Create a second socket server, to test that multiple different
// domains sockets would work as well (even though we don't actually
// use that feature)
TestSocket ts2;
- std::vector<int> data2;
- data2.push_back(1);
- ts2.run(data2);
- // 1 should be ok
- addAnswer("foo", ts2.getPath());
- socket_id = doRequest();
- ASSERT_EQ("foo", socket_id.second);
- ASSERT_EQ(0, close(socket_id.first));
-
- // Now use first socket again
- addAnswer("foo", ts.getPath());
- socket_id = doRequest();
- ASSERT_EQ("foo", socket_id.second);
- ASSERT_EQ(0, close(socket_id.first));
-
- // -1 is a "normal" error
- addAnswer("foo", ts.getPath());
- ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
+ std::vector<std::pair<std::string, int> > data2;
+ data2.push_back(std::pair<std::string, int>("foo\n", 1));
+ const bool timo_ok2 = ts2.run(data2);
+
+ if (timo_ok2) {
+ // 1 should be ok
+ addAnswer("foo", ts2.getPath());
+ socket_id = doRequest();
+ ASSERT_EQ("foo", socket_id.second);
+ ASSERT_EQ(0, close(socket_id.first));
+ }
- // -2 is an unexpected error. After this point it's not guaranteed the
- // connection works as intended.
- addAnswer("foo", ts.getPath());
- ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
+ if (timo_ok) {
+ // Now use first socket again
+ addAnswer("foo", ts.getPath());
+ socket_id = doRequest();
+ ASSERT_EQ("foo", socket_id.second);
+ ASSERT_EQ(0, close(socket_id.first));
+
+ // -1 is a "normal" error
+ addAnswer("foo", ts.getPath());
+ ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
+
+ // -2 is an unexpected error. After this point it's not guaranteed the
+ // connection works as intended.
+ addAnswer("foo", ts.getPath());
+ ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
+ }
+#if 0
// Vector is of first socket is now empty, so the socket should be gone
addAnswer("foo", ts.getPath());
ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
// gone
addAnswer("foo", ts2.getPath());
ASSERT_THROW(doRequest(), SocketRequestor::SocketError);
+#endif
}
}
projects / thirdparty / kea.git / commitdiff
