Add support for sockets that can listen and accept a connection.

ipc/ipc_channel_posix_unittest.cc

+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// These tests are POSIX only.
+
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "base/basictypes.h"
+#include "base/eintr_wrapper.h"
+#include "base/message_loop.h"
+#include "base/scoped_ptr.h"
+#include "base/test/multiprocess_test.h"
+#include "ipc/ipc_channel_posix.h"
+#include "testing/multiprocess_func_list.h"
+
+namespace {
+
+static const int kIPCPosixTestTimeOutInMS = 2000;

[Paweł Hajdan Jr., 2010/12/10 18:48:15]

Please use base/test/test_timeouts.

[dmac, 2010/12/13 18:32:29]

Done. Thanks.. didn't know about those.

+enum {
+  QUIT_MESSAGE = 47
+};
+
+class IPCChannelPosixTestListener : public IPC::Channel::Listener {
+ public:
+  enum STATUS {
+    DISCONNECTED,
+    MESSAGE_RECEIVED,
+    CHANNEL_ERROR,
+    CONNECTED,
+    DENIED,
+    LISTEN_ERROR
+  };
+
+  IPCChannelPosixTestListener() : status_(DISCONNECTED) {}
+  virtual ~IPCChannelPosixTestListener() {}
+  virtual void OnMessageReceived(const IPC::Message& message) {
+    EXPECT_EQ(message.type(), QUIT_MESSAGE);
+    status_ = MESSAGE_RECEIVED;
+    QuitRunLoop();
+  }
+
+  virtual void OnChannelConnected(int32 peer_pid) {
+    status_ = CONNECTED;
+    QuitRunLoop();
+  }
+
+  virtual void OnChannelError()  {
+    status_ = CHANNEL_ERROR;
+    QuitRunLoop();
+  }
+
+  virtual void OnChannelDenied() {
+    status_ = DENIED;
+    QuitRunLoop();
+  }
+
+  virtual void OnChannelListenError() {
+    status_ = LISTEN_ERROR;
+    QuitRunLoop();
+  }
+
+  STATUS status() { return status_; }
+  void QuitRunLoop() {
+    MessageLoopForIO::current()->QuitNow();
+  }
+
+ private:
+  STATUS status_;
+};
+
+}  // namespace
+
+class IPCChannelPosixTest : public base::MultiProcessTest {
+ public:
+  static const char kConnectionSocketTestName[];
+  static void SetUpSocket(IPC::ChannelHandle *handle,
+                          IPC::Channel::Mode mode);
+  static void SpinRunLoop(int milliseconds);
+
+ protected:
+  virtual void SetUp();
+  virtual void TearDown();
+
+private:
+  scoped_ptr<MessageLoopForIO> message_loop_;
+};
+
+const char IPCChannelPosixTest::kConnectionSocketTestName[] =
+    "/var/tmp/chrome_IPCChannelPosixTest__AdvancedConnected";
+
+void IPCChannelPosixTest::SetUp() {
+  MultiProcessTest::SetUp();
+  // Construct a fresh IO Message loop for the duration of each test.
+  message_loop_.reset(new MessageLoopForIO());
+}
+
+void IPCChannelPosixTest::TearDown() {
+  message_loop_.reset(NULL);
+  MultiProcessTest::TearDown();
+}
+
+// Create up a socket and bind and listen to it, or connect it
+// depending on the |mode|.
+void IPCChannelPosixTest::SetUpSocket(IPC::ChannelHandle *handle,
+                                      IPC::Channel::Mode mode) {
+  const std::string& name = handle->name;
+  int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+  ASSERT_GE(socket_fd, 0) << name;
+  ASSERT_GE(fcntl(socket_fd, F_SETFL, O_NONBLOCK), 0);
+  struct sockaddr_un server_address = { 0 };
+  server_address.sun_family = AF_UNIX;
+  memcpy(server_address.sun_path, name.c_str(), name.length() + 1);
+  if (mode == IPC::Channel::MODE_NAMED_SERVER) {
+    // Only one server at a time. Cleanup garbage if it exists.
+    unlink(name.c_str());
+    ASSERT_GE(bind(socket_fd,
+                   reinterpret_cast<struct sockaddr *>(&server_address),
+                   SUN_LEN(&server_address)), 0) << name;
+    ASSERT_GE(listen(socket_fd, SOMAXCONN), 0) << name;
+  } else if (mode == IPC::Channel::MODE_NAMED_CLIENT) {
+    ASSERT_GE(connect(socket_fd,
+                      reinterpret_cast<struct sockaddr *>(&server_address),
+                      SUN_LEN(&server_address)), 0) << name;
+  } else {
+    FAIL() << "Unknown mode " << mode;
+  }
+  handle->socket.fd = socket_fd;
+}
+
+void IPCChannelPosixTest::SpinRunLoop(int milliseconds) {
+  MessageLoopForIO *loop = MessageLoopForIO::current();
+  // Post a quit task so that this loop eventually ends and we don't hang
+  // in the case of a bad test.

[Nico, 2010/12/10 18:08:03]

"Usually, the run loop will quit sooner than that because all tests use a
IPCChannelPosixTestListener which quits the current run loop on any channel
activity."?

Is there some way you can enforce that this method isn't called without this
listener in place?

[dmac, 2010/12/13 18:32:29]

Done.

[dmac, 2010/12/13 18:32:29]

Done. But I don't know of any good way of enforcing it.

+  loop->PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask(), milliseconds);
+  loop->Run();
+}
+
+TEST_F(IPCChannelPosixTest, BasicListen) {
+  // Test creating a socket that is listening.
+  IPC::ChannelHandle handle("/var/tmp/IPCChannelPosixTest::BasicListen");
+  SetUpSocket(&handle, IPC::Channel::MODE_NAMED_SERVER);
+  unlink(handle.name.c_str());
+  IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_SERVER, NULL);
+  ASSERT_TRUE(channel.Connect());
+  ASSERT_TRUE(channel.AcceptsConnections());
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+  channel.ResetToAcceptingConnectionState();
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+}
+
+TEST_F(IPCChannelPosixTest, BasicConnected) {
+  // Test creating a socket that is connected.
+  int pipe_fds[2];
+  ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds), 0);

[Nico, 2010/12/10 18:08:03]

the argument order for ASSERT is expected, actual

[dmac, 2010/12/13 18:32:29]

Yes... which always bugs me ;-) Fixed.

+  std::string socket_name("/var/tmp/IPCChannelPosixTest::BasicConnected");
+  base::FileDescriptor fd(pipe_fds[0], false);
+  IPC::ChannelHandle handle(socket_name, fd);
+  IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_SERVER, NULL);
+  ASSERT_TRUE(channel.Connect());
+  ASSERT_FALSE(channel.AcceptsConnections());
+  channel.Close();
+  ASSERT_TRUE(HANDLE_EINTR(close(pipe_fds[1])) == 0);
+
+  // Make sure that we can use the socket that is created for us by
+  // a standard channel.
+  IPC::Channel channel2(socket_name, IPC::Channel::MODE_SERVER, NULL);
+  ASSERT_TRUE(channel2.Connect());
+  ASSERT_FALSE(channel2.AcceptsConnections());
+}
+
+TEST_F(IPCChannelPosixTest, AdvancedConnected) {
+  // Test creating a connection to an external process.
+  IPCChannelPosixTestListener listener;
+  IPC::ChannelHandle chan_handle(kConnectionSocketTestName);
+  SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
+  IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
+  ASSERT_TRUE(channel.Connect());
+  ASSERT_TRUE(channel.AcceptsConnections());
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
+                                          false);
+  ASSERT_TRUE(handle);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CONNECTED);
+  ASSERT_TRUE(channel.HasAcceptedConnection());
+  IPC::Message* message = new IPC::Message(0, // routing_id
+                                           QUIT_MESSAGE, // message type
+                                           IPC::Message::PRIORITY_NORMAL);
+  channel.Send(message);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  int exit_code = 0;
+  EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
+  EXPECT_EQ(exit_code, 0);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CHANNEL_ERROR);
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+}
+
+TEST_F(IPCChannelPosixTest, ResetState) {
+  // Test creating a connection to an external process. Close the connection,
+  // but continue to listen and make sure another external process can connect
+  // to us.
+  IPCChannelPosixTestListener listener;
+  IPC::ChannelHandle chan_handle(kConnectionSocketTestName);
+  SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
+  IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
+  ASSERT_TRUE(channel.Connect());
+  ASSERT_TRUE(channel.AcceptsConnections());
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
+                                          false);
+  ASSERT_TRUE(handle);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CONNECTED);
+  ASSERT_TRUE(channel.HasAcceptedConnection());
+  channel.ResetToAcceptingConnectionState();
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+
+  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc",
+                                          false);
+  ASSERT_TRUE(handle2);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CONNECTED);
+  ASSERT_TRUE(channel.HasAcceptedConnection());
+  IPC::Message* message = new IPC::Message(0, // routing_id
+                                           QUIT_MESSAGE, // message type
+                                           IPC::Message::PRIORITY_NORMAL);
+  channel.Send(message);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  EXPECT_TRUE(base::KillProcess(handle, 0, false));
+  int exit_code = 0;
+  EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
+  EXPECT_EQ(exit_code, 0);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CHANNEL_ERROR);
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+}
+
+TEST_F(IPCChannelPosixTest, MultiConnection) {
+  // Test setting up a connection to an external process, and then have
+  // another external process attempt to connect to us.
+  IPCChannelPosixTestListener listener;
+  IPC::ChannelHandle chan_handle(kConnectionSocketTestName);
+  SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
+  IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
+  ASSERT_TRUE(channel.Connect());
+  ASSERT_TRUE(channel.AcceptsConnections());
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
+                                          false);
+  ASSERT_TRUE(handle);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CONNECTED);
+  ASSERT_TRUE(channel.HasAcceptedConnection());
+  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc",
+                                           false);
+  ASSERT_TRUE(handle2);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  int exit_code = 0;
+  EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
+  EXPECT_EQ(exit_code, 0);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::DENIED);
+  ASSERT_TRUE(channel.HasAcceptedConnection());
+  IPC::Message* message = new IPC::Message(0, // routing_id
+                                           QUIT_MESSAGE, // message type
+                                           IPC::Message::PRIORITY_NORMAL);
+  channel.Send(message);
+  SpinRunLoop(kIPCPosixTestTimeOutInMS);
+  EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
+  EXPECT_EQ(exit_code, 0);
+  ASSERT_EQ(listener.status(), IPCChannelPosixTestListener::CHANNEL_ERROR);
+  ASSERT_FALSE(channel.HasAcceptedConnection());
+}
+
+// A long running process that connects to us
+MULTIPROCESS_TEST_MAIN(IPCChannelPosixTestConnectionProc) {
+  MessageLoopForIO message_loop;
+  IPCChannelPosixTestListener listener;
+  IPC::ChannelHandle handle(IPCChannelPosixTest::kConnectionSocketTestName);
+  IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
+  IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_CLIENT, &listener);
+  EXPECT_TRUE(channel.Connect());
+  while (true) {

[Paweł Hajdan Jr., 2010/12/10 18:48:15]

Why do we spin the loop multiple times? Can't we do it just once?

[dmac, 2010/12/13 18:32:29]

No, because some of the tests will return a variety of messages before we get to
MESSAGE_RECEIVED. In the cases above where we never get MESSAGE_RECEIVED, we
kill the test. Simplified it a bit though.

[Paweł Hajdan Jr., 2010/12/13 20:48:40]

I still don't understand. It's the test quitting the loop, right?

If so, could you instead spin the loop only once, and check the condition before
quitting it, so we quit it only once?

+    IPCChannelPosixTest::SpinRunLoop(kIPCPosixTestTimeOutInMS);
+    if (listener.status() == IPCChannelPosixTestListener::MESSAGE_RECEIVED) {
+      break;
+    }
+  }
+  return 0;
+}
+
+// Simple external process that shouldn't be able to connect to us.
+MULTIPROCESS_TEST_MAIN(IPCChannelPosixFailConnectionProc) {
+  MessageLoopForIO message_loop;
+  IPCChannelPosixTestListener listener;
+  IPC::ChannelHandle handle(IPCChannelPosixTest::kConnectionSocketTestName);
+  IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
+  IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_CLIENT, &listener);
+
+  // In this case connect may succeed or fail depending on if the packet
+  // actually gets sent at sendmsg. Since we never delay on send, we may not
+  // see the error. However even if connect succeeds, eventually we will get an
+  // error back since the channel will be closed when we attempt to read from
+  // it.
+  bool connected = channel.Connect();
+  if (connected) {
+    IPCChannelPosixTest::SpinRunLoop(kIPCPosixTestTimeOutInMS);
+    EXPECT_EQ(listener.status(), IPCChannelPosixTestListener::CHANNEL_ERROR);
+  } else {
+    EXPECT_EQ(listener.status(), IPCChannelPosixTestListener::DISCONNECTED);
+  }
+  return 0;
+}
+