ipc/sync_socket_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/sync_socket.h"
   6
   7 #include <stdio.h>
   8 #include <sstream>
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/location.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/threading/thread.h"
  15 #include "ipc/ipc_test_base.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 #if defined(OS_POSIX)
  19 #include "base/file_descriptor_posix.h"
  20 #endif
  21
  22 // IPC messages for testing ----------------------------------------------------
  23
  24 #define IPC_MESSAGE_IMPL
  25 #include "ipc/ipc_message_macros.h"
  26
  27 #define IPC_MESSAGE_START TestMsgStart
  28
  29 // Message class to pass a base::SyncSocket::Handle to another process.  This
  30 // is not as easy as it sounds, because of the differences in transferring
  31 // Windows HANDLEs versus posix file descriptors.
  32 #if defined(OS_WIN)
  33 IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::SyncSocket::Handle)
  34 #elif defined(OS_POSIX)
  35 IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::FileDescriptor)
  36 #endif
  37
  38 // Message class to pass a response to the server.
  39 IPC_MESSAGE_CONTROL1(MsgClassResponse, std::string)
  40
  41 // Message class to tell the server to shut down.
  42 IPC_MESSAGE_CONTROL0(MsgClassShutdown)
  43
  44 // -----------------------------------------------------------------------------
  45
  46 namespace {
  47
  48 const char kHelloString[] = "Hello, SyncSocket Client";
  49 const size_t kHelloStringLength = arraysize(kHelloString);
  50
  51 // The SyncSocket server listener class processes two sorts of
  52 // messages from the client.
  53 class SyncSocketServerListener : public IPC::Listener {
  54  public:
  55   SyncSocketServerListener() : chan_(NULL) {
  56   }
  57
  58   void Init(IPC::Channel* chan) {
  59     chan_ = chan;
  60   }
  61
  62   bool OnMessageReceived(const IPC::Message& msg) override {
  63     if (msg.routing_id() == MSG_ROUTING_CONTROL) {
  64       IPC_BEGIN_MESSAGE_MAP(SyncSocketServerListener, msg)
  65         IPC_MESSAGE_HANDLER(MsgClassSetHandle, OnMsgClassSetHandle)
  66         IPC_MESSAGE_HANDLER(MsgClassShutdown, OnMsgClassShutdown)
  67       IPC_END_MESSAGE_MAP()
  68     }
  69     return true;
  70   }
  71
  72  private:
  73   // This sort of message is sent first, causing the transfer of
  74   // the handle for the SyncSocket.  This message sends a buffer
  75   // on the SyncSocket and then sends a response to the client.
  76 #if defined(OS_WIN)
  77   void OnMsgClassSetHandle(const base::SyncSocket::Handle handle) {
  78     SetHandle(handle);
  79   }
  80 #elif defined(OS_POSIX)
  81   void OnMsgClassSetHandle(const base::FileDescriptor& fd_struct) {
  82     SetHandle(fd_struct.fd);
  83   }
  84 #else
  85 # error "What platform?"
  86 #endif  // defined(OS_WIN)
  87
  88   void SetHandle(base::SyncSocket::Handle handle) {
  89     base::SyncSocket sync_socket(handle);
  90     EXPECT_EQ(sync_socket.Send(kHelloString, kHelloStringLength),
  91               kHelloStringLength);
  92     IPC::Message* msg = new MsgClassResponse(kHelloString);
  93     EXPECT_TRUE(chan_->Send(msg));
  94   }
  95
  96   // When the client responds, it sends back a shutdown message,
  97   // which causes the message loop to exit.
  98   void OnMsgClassShutdown() {
  99     base::MessageLoop::current()->Quit();
 100   }
 101
 102   IPC::Channel* chan_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(SyncSocketServerListener);
 105 };
 106
 107 // Runs the fuzzing server child mode. Returns when the preset number of
 108 // messages have been received.
 109 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SyncSocketServerClient) {
 110   base::MessageLoopForIO main_message_loop;
 111   SyncSocketServerListener listener;
 112   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
 113       IPCTestBase::GetChannelName("SyncSocketServerClient"), &listener,
 114       nullptr));
 115   EXPECT_TRUE(channel->Connect());
 116   listener.Init(channel.get());
 117   base::MessageLoop::current()->Run();
 118   return 0;
 119 }
 120
 121 // The SyncSocket client listener only processes one sort of message,
 122 // a response from the server.
 123 class SyncSocketClientListener : public IPC::Listener {
 124  public:
 125   SyncSocketClientListener() {
 126   }
 127
 128   void Init(base::SyncSocket* socket, IPC::Channel* chan) {
 129     socket_ = socket;
 130     chan_ = chan;
 131   }
 132
 133   bool OnMessageReceived(const IPC::Message& msg) override {
 134     if (msg.routing_id() == MSG_ROUTING_CONTROL) {
 135       IPC_BEGIN_MESSAGE_MAP(SyncSocketClientListener, msg)
 136         IPC_MESSAGE_HANDLER(MsgClassResponse, OnMsgClassResponse)
 137       IPC_END_MESSAGE_MAP()
 138     }
 139     return true;
 140   }
 141
 142  private:
 143   // When a response is received from the server, it sends the same
 144   // string as was written on the SyncSocket.  These are compared
 145   // and a shutdown message is sent back to the server.
 146   void OnMsgClassResponse(const std::string& str) {
 147     // We rely on the order of sync_socket.Send() and chan_->Send() in
 148     // the SyncSocketServerListener object.
 149     EXPECT_EQ(kHelloStringLength, socket_->Peek());
 150     char buf[kHelloStringLength];
 151     socket_->Receive(static_cast<void*>(buf), kHelloStringLength);
 152     EXPECT_EQ(strcmp(str.c_str(), buf), 0);
 153     // After receiving from the socket there should be no bytes left.
 154     EXPECT_EQ(0U, socket_->Peek());
 155     IPC::Message* msg = new MsgClassShutdown();
 156     EXPECT_TRUE(chan_->Send(msg));
 157     base::MessageLoop::current()->Quit();
 158   }
 159
 160   base::SyncSocket* socket_;
 161   IPC::Channel* chan_;
 162
 163   DISALLOW_COPY_AND_ASSIGN(SyncSocketClientListener);
 164 };
 165
 166 class SyncSocketTest : public IPCTestBase {
 167 };
 168
 169 TEST_F(SyncSocketTest, SanityTest) {
 170   Init("SyncSocketServerClient");
 171
 172   SyncSocketClientListener listener;
 173   CreateChannel(&listener);
 174   ASSERT_TRUE(StartClient());
 175   // Create a pair of SyncSockets.
 176   base::SyncSocket pair[2];
 177   base::SyncSocket::CreatePair(&pair[0], &pair[1]);
 178   // Immediately after creation there should be no pending bytes.
 179   EXPECT_EQ(0U, pair[0].Peek());
 180   EXPECT_EQ(0U, pair[1].Peek());
 181   base::SyncSocket::Handle target_handle;
 182   // Connect the channel and listener.
 183   ASSERT_TRUE(ConnectChannel());
 184   listener.Init(&pair[0], channel());
 185 #if defined(OS_WIN)
 186   // On windows we need to duplicate the handle into the server process.
 187   BOOL retval = DuplicateHandle(GetCurrentProcess(), pair[1].handle(),
 188                                 client_process().Handle(), &target_handle,
 189                                 0, FALSE, DUPLICATE_SAME_ACCESS);
 190   EXPECT_TRUE(retval);
 191   // Set up a message to pass the handle to the server.
 192   IPC::Message* msg = new MsgClassSetHandle(target_handle);
 193 #else
 194   target_handle = pair[1].handle();
 195   // Set up a message to pass the handle to the server.
 196   base::FileDescriptor filedesc(target_handle, false);
 197   IPC::Message* msg = new MsgClassSetHandle(filedesc);
 198 #endif  // defined(OS_WIN)
 199   EXPECT_TRUE(sender()->Send(msg));
 200   // Use the current thread as the I/O thread.
 201   base::MessageLoop::current()->Run();
 202   // Shut down.
 203   pair[0].Close();
 204   pair[1].Close();
 205   EXPECT_TRUE(WaitForClientShutdown());
 206   DestroyChannel();
 207 }
 208
 209 // A blocking read operation that will block the thread until it receives
 210 // |length| bytes of packets or Shutdown() is called on another thread.
 211 static void BlockingRead(base::SyncSocket* socket, char* buf,
 212                          size_t length, size_t* received) {
 213   DCHECK(buf != NULL);
 214   // Notify the parent thread that we're up and running.
 215   socket->Send(kHelloString, kHelloStringLength);
 216   *received = socket->Receive(buf, length);
 217 }
 218
 219 // Tests that we can safely end a blocking Receive operation on one thread
 220 // from another thread by disconnecting (but not closing) the socket.
 221 TEST_F(SyncSocketTest, DisconnectTest) {
 222   base::CancelableSyncSocket pair[2];
 223   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 224
 225   base::Thread worker("BlockingThread");
 226   worker.Start();
 227
 228   // Try to do a blocking read from one of the sockets on the worker thread.
 229   char buf[0xff];
 230   size_t received = 1U;  // Initialize to an unexpected value.
 231   worker.task_runner()->PostTask(
 232       FROM_HERE,
 233       base::Bind(&BlockingRead, &pair[0], &buf[0], arraysize(buf), &received));
 234
 235   // Wait for the worker thread to say hello.
 236   char hello[kHelloStringLength] = {0};
 237   pair[1].Receive(&hello[0], sizeof(hello));
 238   EXPECT_EQ(0, strcmp(hello, kHelloString));
 239   // Give the worker a chance to start Receive().
 240   base::PlatformThread::YieldCurrentThread();
 241
 242   // Now shut down the socket that the thread is issuing a blocking read on
 243   // which should cause Receive to return with an error.
 244   pair[0].Shutdown();
 245
 246   worker.Stop();
 247
 248   EXPECT_EQ(0U, received);
 249 }
 250
 251 // Tests that read is a blocking operation.
 252 TEST_F(SyncSocketTest, BlockingReceiveTest) {
 253   base::CancelableSyncSocket pair[2];
 254   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 255
 256   base::Thread worker("BlockingThread");
 257   worker.Start();
 258
 259   // Try to do a blocking read from one of the sockets on the worker thread.
 260   char buf[kHelloStringLength] = {0};
 261   size_t received = 1U;  // Initialize to an unexpected value.
 262   worker.task_runner()->PostTask(FROM_HERE,
 263                                  base::Bind(&BlockingRead, &pair[0], &buf[0],
 264                                             kHelloStringLength, &received));
 265
 266   // Wait for the worker thread to say hello.
 267   char hello[kHelloStringLength] = {0};
 268   pair[1].Receive(&hello[0], sizeof(hello));
 269   EXPECT_EQ(0, strcmp(hello, kHelloString));
 270   // Give the worker a chance to start Receive().
 271   base::PlatformThread::YieldCurrentThread();
 272
 273   // Send a message to the socket on the blocking thead, it should free the
 274   // socket from Receive().
 275   pair[1].Send(kHelloString, kHelloStringLength);
 276   worker.Stop();
 277
 278   // Verify the socket has received the message.
 279   EXPECT_TRUE(strcmp(buf, kHelloString) == 0);
 280   EXPECT_EQ(kHelloStringLength, received);
 281 }
 282
 283 // Tests that the write operation is non-blocking and returns immediately
 284 // when there is insufficient space in the socket's buffer.
 285 TEST_F(SyncSocketTest, NonBlockingWriteTest) {
 286   base::CancelableSyncSocket pair[2];
 287   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 288
 289   // Fill up the buffer for one of the socket, Send() should not block the
 290   // thread even when the buffer is full.
 291   while (pair[0].Send(kHelloString, kHelloStringLength) != 0) {}
 292
 293   // Data should be avialble on another socket.
 294   size_t bytes_in_buffer = pair[1].Peek();
 295   EXPECT_NE(bytes_in_buffer, 0U);
 296
 297   // No more data can be written to the buffer since socket has been full,
 298   // verify that the amount of avialble data on another socket is unchanged.
 299   EXPECT_EQ(0U, pair[0].Send(kHelloString, kHelloStringLength));
 300   EXPECT_EQ(bytes_in_buffer, pair[1].Peek());
 301
 302   // Read from another socket to free some space for a new write.
 303   char hello[kHelloStringLength] = {0};
 304   pair[1].Receive(&hello[0], sizeof(hello));
 305
 306   // Should be able to write more data to the buffer now.
 307   EXPECT_EQ(kHelloStringLength, pair[0].Send(kHelloString, kHelloStringLength));
 308 }
 309
 310 }  // namespace