ipc/sync_socket_unittest.cc - chromium/src - Git at Google

 // Copyright 2012 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <stddef.h>
 #include <stdio.h>

 #include <memory>
 #include <sstream>
 #include <string>

 #include "base/functional/bind.h"
 #include "base/location.h"
 #include "base/memory/raw_ptr.h"
 #include "base/run_loop.h"
 #include "base/sync_socket.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "ipc/ipc_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"

 #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 #include "base/file_descriptor_posix.h"
 #endif

 // IPC messages for testing ----------------------------------------------------

 #define IPC_MESSAGE_IMPL
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_start.h"

 #define IPC_MESSAGE_START TestMsgStart

 // Message class to pass a base::SyncSocket::Handle to another process.  This
 // is not as easy as it sounds, because of the differences in transferring
 // Windows HANDLEs versus posix file descriptors.
 #if BUILDFLAG(IS_WIN)
 IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::SyncSocket::Handle)
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::FileDescriptor)
 #endif

 // Message class to pass a response to the server.
 IPC_MESSAGE_CONTROL1(MsgClassResponse, std::string)

 // Message class to tell the server to shut down.
 IPC_MESSAGE_CONTROL0(MsgClassShutdown)

 // -----------------------------------------------------------------------------

 namespace {

 const char kHelloString[] = "Hello, SyncSocket Client";
 const size_t kHelloStringLength = std::size(kHelloString);

 // The SyncSocket server listener class processes two sorts of
 // messages from the client.
 class SyncSocketServerListener : public IPC::Listener {
  public:
   SyncSocketServerListener() : chan_(nullptr) {}

   SyncSocketServerListener(const SyncSocketServerListener&) = delete;
   SyncSocketServerListener& operator=(const SyncSocketServerListener&) = delete;

   void Init(IPC::Channel* chan) {
     chan_ = chan;
   }

   bool OnMessageReceived(const IPC::Message& msg) override {
     if (msg.routing_id() == MSG_ROUTING_CONTROL) {
       IPC_BEGIN_MESSAGE_MAP(SyncSocketServerListener, msg)
         IPC_MESSAGE_HANDLER(MsgClassSetHandle, OnMsgClassSetHandle)
         IPC_MESSAGE_HANDLER(MsgClassShutdown, OnMsgClassShutdown)
       IPC_END_MESSAGE_MAP()
     }
     return true;
   }

  private:
   // This sort of message is sent first, causing the transfer of
   // the handle for the SyncSocket.  This message sends a buffer
   // on the SyncSocket and then sends a response to the client.
 #if BUILDFLAG(IS_WIN)
   void OnMsgClassSetHandle(const base::SyncSocket::Handle handle) {
     SetHandle(handle);
   }
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
   void OnMsgClassSetHandle(const base::FileDescriptor& fd_struct) {
     SetHandle(fd_struct.fd);
   }
 #else
 # error "What platform?"
 #endif  // BUILDFLAG(IS_WIN)

   void SetHandle(base::SyncSocket::Handle handle) {
     base::SyncSocket sync_socket(handle);
     EXPECT_EQ(sync_socket.Send(kHelloString, kHelloStringLength),
               kHelloStringLength);
     IPC::Message* msg = new MsgClassResponse(kHelloString);
     EXPECT_TRUE(chan_->Send(msg));
   }

   // When the client responds, it sends back a shutdown message,
   // which causes the message loop to exit.
   void OnMsgClassShutdown() { base::RunLoop::QuitCurrentWhenIdleDeprecated(); }

   raw_ptr<IPC::Channel> chan_;
 };

 // Runs the fuzzing server child mode. Returns when the preset number of
 // messages have been received.
 DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SyncSocketServerClient) {
   SyncSocketServerListener listener;
   Connect(&listener);
   listener.Init(channel());
   base::RunLoop().Run();
   Close();
 }

 // The SyncSocket client listener only processes one sort of message,
 // a response from the server.
 class SyncSocketClientListener : public IPC::Listener {
  public:
   SyncSocketClientListener() = default;

   SyncSocketClientListener(const SyncSocketClientListener&) = delete;
   SyncSocketClientListener& operator=(const SyncSocketClientListener&) = delete;

   void Init(base::SyncSocket* socket, IPC::Channel* chan) {
     socket_ = socket;
     chan_ = chan;
   }

   bool OnMessageReceived(const IPC::Message& msg) override {
     if (msg.routing_id() == MSG_ROUTING_CONTROL) {
       IPC_BEGIN_MESSAGE_MAP(SyncSocketClientListener, msg)
         IPC_MESSAGE_HANDLER(MsgClassResponse, OnMsgClassResponse)
       IPC_END_MESSAGE_MAP()
     }
     return true;
   }

  private:
   // When a response is received from the server, it sends the same
   // string as was written on the SyncSocket.  These are compared
   // and a shutdown message is sent back to the server.
   void OnMsgClassResponse(const std::string& str) {
     // We rely on the order of sync_socket.Send() and chan_->Send() in
     // the SyncSocketServerListener object.
     EXPECT_EQ(kHelloStringLength, socket_->Peek());
     char buf[kHelloStringLength];
     socket_->Receive(static_cast<void*>(buf), kHelloStringLength);
     EXPECT_EQ(strcmp(str.c_str(), buf), 0);
     // After receiving from the socket there should be no bytes left.
     EXPECT_EQ(0U, socket_->Peek());
     IPC::Message* msg = new MsgClassShutdown();
     EXPECT_TRUE(chan_->Send(msg));
     base::RunLoop::QuitCurrentWhenIdleDeprecated();
   }

   raw_ptr<base::SyncSocket> socket_;
   raw_ptr<IPC::Channel> chan_;
 };

 using SyncSocketTest = IPCChannelMojoTestBase;

 TEST_F(SyncSocketTest, SanityTest) {
   Init("SyncSocketServerClient");

   SyncSocketClientListener listener;
   CreateChannel(&listener);
   // Create a pair of SyncSockets.
   base::SyncSocket pair[2];
   base::SyncSocket::CreatePair(&pair[0], &pair[1]);
   // Immediately after creation there should be no pending bytes.
   EXPECT_EQ(0U, pair[0].Peek());
   EXPECT_EQ(0U, pair[1].Peek());
   base::SyncSocket::Handle target_handle;
   // Connect the channel and listener.
   ASSERT_TRUE(ConnectChannel());
   listener.Init(&pair[0], channel());
 #if BUILDFLAG(IS_WIN)
   // On windows we need to duplicate the handle into the server process.
   BOOL retval = DuplicateHandle(GetCurrentProcess(), pair[1].handle(),
                                 client_process().Handle(), &target_handle,
                                 0, FALSE, DUPLICATE_SAME_ACCESS);
   EXPECT_TRUE(retval);
   // Set up a message to pass the handle to the server.
   IPC::Message* msg = new MsgClassSetHandle(target_handle);
 #else
   target_handle = pair[1].handle();
   // Set up a message to pass the handle to the server.
   base::FileDescriptor filedesc(target_handle, false);
   IPC::Message* msg = new MsgClassSetHandle(filedesc);
 #endif  // BUILDFLAG(IS_WIN)
   EXPECT_TRUE(sender()->Send(msg));
   // Use the current thread as the I/O thread.
   base::RunLoop().Run();
   // Shut down.
   pair[0].Close();
   pair[1].Close();
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }

 // A blocking read operation that will block the thread until it receives
 // |length| bytes of packets or Shutdown() is called on another thread.
 static void BlockingRead(base::SyncSocket* socket, char* buf,
                          size_t length, size_t* received) {
   DCHECK_NE(buf, nullptr);
   // Notify the parent thread that we're up and running.
   socket->Send(kHelloString, kHelloStringLength);
   *received = socket->Receive(buf, length);
 }

 // Tests that we can safely end a blocking Receive operation on one thread
 // from another thread by disconnecting (but not closing) the socket.
 TEST_F(SyncSocketTest, DisconnectTest) {
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

   base::Thread worker("BlockingThread");
   worker.Start();

   // Try to do a blocking read from one of the sockets on the worker thread.
   char buf[0xff];
   size_t received = 1U;  // Initialize to an unexpected value.
   worker.task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&BlockingRead, &pair[0], &buf[0],
                                 std::size(buf), &received));

   // Wait for the worker thread to say hello.
   char hello[kHelloStringLength] = {0};
   pair[1].Receive(&hello[0], sizeof(hello));
   EXPECT_EQ(0, strcmp(hello, kHelloString));
   // Give the worker a chance to start Receive().
   base::PlatformThread::YieldCurrentThread();

   // Now shut down the socket that the thread is issuing a blocking read on
   // which should cause Receive to return with an error.
   pair[0].Shutdown();

   worker.Stop();

   EXPECT_EQ(0U, received);
 }

 // Tests that read is a blocking operation.
 TEST_F(SyncSocketTest, BlockingReceiveTest) {
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

   base::Thread worker("BlockingThread");
   worker.Start();

   // Try to do a blocking read from one of the sockets on the worker thread.
   char buf[kHelloStringLength] = {0};
   size_t received = 1U;  // Initialize to an unexpected value.
   worker.task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&BlockingRead, &pair[0], &buf[0],
                                 kHelloStringLength, &received));

   // Wait for the worker thread to say hello.
   char hello[kHelloStringLength] = {0};
   pair[1].Receive(&hello[0], sizeof(hello));
   EXPECT_EQ(0, strcmp(hello, kHelloString));
   // Give the worker a chance to start Receive().
   base::PlatformThread::YieldCurrentThread();

   // Send a message to the socket on the blocking thead, it should free the
   // socket from Receive().
   pair[1].Send(kHelloString, kHelloStringLength);
   worker.Stop();

   // Verify the socket has received the message.
   EXPECT_TRUE(strcmp(buf, kHelloString) == 0);
   EXPECT_EQ(kHelloStringLength, received);
 }

 // Tests that the write operation is non-blocking and returns immediately
 // when there is insufficient space in the socket's buffer.
 TEST_F(SyncSocketTest, NonBlockingWriteTest) {
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

   // Fill up the buffer for one of the socket, Send() should not block the
   // thread even when the buffer is full.
   while (pair[0].Send(kHelloString, kHelloStringLength) != 0) {}

   // Data should be avialble on another socket.
   size_t bytes_in_buffer = pair[1].Peek();
   EXPECT_NE(bytes_in_buffer, 0U);

   // No more data can be written to the buffer since socket has been full,
   // verify that the amount of avialble data on another socket is unchanged.
   EXPECT_EQ(0U, pair[0].Send(kHelloString, kHelloStringLength));
   EXPECT_EQ(bytes_in_buffer, pair[1].Peek());

   // Read from another socket to free some space for a new write.
   char hello[kHelloStringLength] = {0};
   pair[1].Receive(&hello[0], sizeof(hello));

   // Should be able to write more data to the buffer now.
   EXPECT_EQ(kHelloStringLength, pair[0].Send(kHelloString, kHelloStringLength));
 }

 }  // namespace
	// Copyright 2012 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <stddef.h>
	#include <stdio.h>

	#include <memory>
	#include <sstream>
	#include <string>

	#include "base/functional/bind.h"
	#include "base/location.h"
	#include "base/memory/raw_ptr.h"
	#include "base/run_loop.h"
	#include "base/sync_socket.h"
	#include "base/task/single_thread_task_runner.h"
	#include "base/threading/thread.h"
	#include "build/build_config.h"
	#include "ipc/ipc_test_base.h"
	#include "testing/gtest/include/gtest/gtest.h"

	#if BUILDFLAG(IS_POSIX) \|\| BUILDFLAG(IS_FUCHSIA)
	#include "base/file_descriptor_posix.h"
	#endif

	// IPC messages for testing ----------------------------------------------------

	#define IPC_MESSAGE_IMPL
	#include "ipc/ipc_message_macros.h"
	#include "ipc/ipc_message_start.h"

	#define IPC_MESSAGE_START TestMsgStart

	// Message class to pass a base::SyncSocket::Handle to another process. This
	// is not as easy as it sounds, because of the differences in transferring
	// Windows HANDLEs versus posix file descriptors.
	#if BUILDFLAG(IS_WIN)
	IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::SyncSocket::Handle)
	#elif BUILDFLAG(IS_POSIX) \|\| BUILDFLAG(IS_FUCHSIA)
	IPC_MESSAGE_CONTROL1(MsgClassSetHandle, base::FileDescriptor)
	#endif

	// Message class to pass a response to the server.
	IPC_MESSAGE_CONTROL1(MsgClassResponse, std::string)

	// Message class to tell the server to shut down.
	IPC_MESSAGE_CONTROL0(MsgClassShutdown)

	// -----------------------------------------------------------------------------

	namespace {

	const char kHelloString[] = "Hello, SyncSocket Client";
	const size_t kHelloStringLength = std::size(kHelloString);

	// The SyncSocket server listener class processes two sorts of
	// messages from the client.
	class SyncSocketServerListener : public IPC::Listener {
	public:
	SyncSocketServerListener() : chan_(nullptr) {}

	SyncSocketServerListener(const SyncSocketServerListener&) = delete;
	SyncSocketServerListener& operator=(const SyncSocketServerListener&) = delete;

	void Init(IPC::Channel* chan) {
	chan_ = chan;
	}

	bool OnMessageReceived(const IPC::Message& msg) override {
	if (msg.routing_id() == MSG_ROUTING_CONTROL) {
	IPC_BEGIN_MESSAGE_MAP(SyncSocketServerListener, msg)
	IPC_MESSAGE_HANDLER(MsgClassSetHandle, OnMsgClassSetHandle)
	IPC_MESSAGE_HANDLER(MsgClassShutdown, OnMsgClassShutdown)
	IPC_END_MESSAGE_MAP()
	}
	return true;
	}

	private:
	// This sort of message is sent first, causing the transfer of
	// the handle for the SyncSocket. This message sends a buffer
	// on the SyncSocket and then sends a response to the client.
	#if BUILDFLAG(IS_WIN)
	void OnMsgClassSetHandle(const base::SyncSocket::Handle handle) {
	SetHandle(handle);
	}
	#elif BUILDFLAG(IS_POSIX) \|\| BUILDFLAG(IS_FUCHSIA)
	void OnMsgClassSetHandle(const base::FileDescriptor& fd_struct) {
	SetHandle(fd_struct.fd);
	}
	#else
	# error "What platform?"
	#endif // BUILDFLAG(IS_WIN)

	void SetHandle(base::SyncSocket::Handle handle) {
	base::SyncSocket sync_socket(handle);
	EXPECT_EQ(sync_socket.Send(kHelloString, kHelloStringLength),
	kHelloStringLength);
	IPC::Message* msg = new MsgClassResponse(kHelloString);
	EXPECT_TRUE(chan_->Send(msg));
	}

	// When the client responds, it sends back a shutdown message,
	// which causes the message loop to exit.
	void OnMsgClassShutdown() { base::RunLoop::QuitCurrentWhenIdleDeprecated(); }

	raw_ptr<IPC::Channel> chan_;
	};

	// Runs the fuzzing server child mode. Returns when the preset number of
	// messages have been received.
	DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SyncSocketServerClient) {
	SyncSocketServerListener listener;
	Connect(&listener);
	listener.Init(channel());
	base::RunLoop().Run();
	Close();
	}

	// The SyncSocket client listener only processes one sort of message,
	// a response from the server.
	class SyncSocketClientListener : public IPC::Listener {
	public:
	SyncSocketClientListener() = default;

	SyncSocketClientListener(const SyncSocketClientListener&) = delete;
	SyncSocketClientListener& operator=(const SyncSocketClientListener&) = delete;

	void Init(base::SyncSocket* socket, IPC::Channel* chan) {
	socket_ = socket;
	chan_ = chan;
	}

	bool OnMessageReceived(const IPC::Message& msg) override {
	if (msg.routing_id() == MSG_ROUTING_CONTROL) {
	IPC_BEGIN_MESSAGE_MAP(SyncSocketClientListener, msg)
	IPC_MESSAGE_HANDLER(MsgClassResponse, OnMsgClassResponse)
	IPC_END_MESSAGE_MAP()
	}
	return true;
	}

	private:
	// When a response is received from the server, it sends the same
	// string as was written on the SyncSocket. These are compared
	// and a shutdown message is sent back to the server.
	void OnMsgClassResponse(const std::string& str) {
	// We rely on the order of sync_socket.Send() and chan_->Send() in
	// the SyncSocketServerListener object.
	EXPECT_EQ(kHelloStringLength, socket_->Peek());
	char buf[kHelloStringLength];
	socket_->Receive(static_cast<void*>(buf), kHelloStringLength);
	EXPECT_EQ(strcmp(str.c_str(), buf), 0);
	// After receiving from the socket there should be no bytes left.
	EXPECT_EQ(0U, socket_->Peek());
	IPC::Message* msg = new MsgClassShutdown();
	EXPECT_TRUE(chan_->Send(msg));
	base::RunLoop::QuitCurrentWhenIdleDeprecated();
	}

	raw_ptr<base::SyncSocket> socket_;
	raw_ptr<IPC::Channel> chan_;
	};

	using SyncSocketTest = IPCChannelMojoTestBase;

	TEST_F(SyncSocketTest, SanityTest) {
	Init("SyncSocketServerClient");

	SyncSocketClientListener listener;
	CreateChannel(&listener);
	// Create a pair of SyncSockets.
	base::SyncSocket pair[2];
	base::SyncSocket::CreatePair(&pair[0], &pair[1]);
	// Immediately after creation there should be no pending bytes.
	EXPECT_EQ(0U, pair[0].Peek());
	EXPECT_EQ(0U, pair[1].Peek());
	base::SyncSocket::Handle target_handle;
	// Connect the channel and listener.
	ASSERT_TRUE(ConnectChannel());
	listener.Init(&pair[0], channel());
	#if BUILDFLAG(IS_WIN)
	// On windows we need to duplicate the handle into the server process.
	BOOL retval = DuplicateHandle(GetCurrentProcess(), pair[1].handle(),
	client_process().Handle(), &target_handle,
	0, FALSE, DUPLICATE_SAME_ACCESS);
	EXPECT_TRUE(retval);
	// Set up a message to pass the handle to the server.
	IPC::Message* msg = new MsgClassSetHandle(target_handle);
	#else
	target_handle = pair[1].handle();
	// Set up a message to pass the handle to the server.
	base::FileDescriptor filedesc(target_handle, false);
	IPC::Message* msg = new MsgClassSetHandle(filedesc);
	#endif // BUILDFLAG(IS_WIN)
	EXPECT_TRUE(sender()->Send(msg));
	// Use the current thread as the I/O thread.
	base::RunLoop().Run();
	// Shut down.
	pair[0].Close();
	pair[1].Close();
	EXPECT_TRUE(WaitForClientShutdown());
	DestroyChannel();
	}

	// A blocking read operation that will block the thread until it receives
	// \|length\| bytes of packets or Shutdown() is called on another thread.
	static void BlockingRead(base::SyncSocket* socket, char* buf,
	size_t length, size_t* received) {
	DCHECK_NE(buf, nullptr);
	// Notify the parent thread that we're up and running.
	socket->Send(kHelloString, kHelloStringLength);
	*received = socket->Receive(buf, length);
	}

	// Tests that we can safely end a blocking Receive operation on one thread
	// from another thread by disconnecting (but not closing) the socket.
	TEST_F(SyncSocketTest, DisconnectTest) {
	base::CancelableSyncSocket pair[2];
	ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

	base::Thread worker("BlockingThread");
	worker.Start();

	// Try to do a blocking read from one of the sockets on the worker thread.
	char buf[0xff];
	size_t received = 1U; // Initialize to an unexpected value.
	worker.task_runner()->PostTask(
	FROM_HERE, base::BindOnce(&BlockingRead, &pair[0], &buf[0],
	std::size(buf), &received));

	// Wait for the worker thread to say hello.
	char hello[kHelloStringLength] = {0};
	pair[1].Receive(&hello[0], sizeof(hello));
	EXPECT_EQ(0, strcmp(hello, kHelloString));
	// Give the worker a chance to start Receive().
	base::PlatformThread::YieldCurrentThread();

	// Now shut down the socket that the thread is issuing a blocking read on
	// which should cause Receive to return with an error.
	pair[0].Shutdown();

	worker.Stop();

	EXPECT_EQ(0U, received);
	}

	// Tests that read is a blocking operation.
	TEST_F(SyncSocketTest, BlockingReceiveTest) {
	base::CancelableSyncSocket pair[2];
	ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

	base::Thread worker("BlockingThread");
	worker.Start();

	// Try to do a blocking read from one of the sockets on the worker thread.
	char buf[kHelloStringLength] = {0};
	size_t received = 1U; // Initialize to an unexpected value.
	worker.task_runner()->PostTask(
	FROM_HERE, base::BindOnce(&BlockingRead, &pair[0], &buf[0],
	kHelloStringLength, &received));

	// Wait for the worker thread to say hello.
	char hello[kHelloStringLength] = {0};
	pair[1].Receive(&hello[0], sizeof(hello));
	EXPECT_EQ(0, strcmp(hello, kHelloString));
	// Give the worker a chance to start Receive().
	base::PlatformThread::YieldCurrentThread();

	// Send a message to the socket on the blocking thead, it should free the
	// socket from Receive().
	pair[1].Send(kHelloString, kHelloStringLength);
	worker.Stop();

	// Verify the socket has received the message.
	EXPECT_TRUE(strcmp(buf, kHelloString) == 0);
	EXPECT_EQ(kHelloStringLength, received);
	}

	// Tests that the write operation is non-blocking and returns immediately
	// when there is insufficient space in the socket's buffer.
	TEST_F(SyncSocketTest, NonBlockingWriteTest) {
	base::CancelableSyncSocket pair[2];
	ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));

	// Fill up the buffer for one of the socket, Send() should not block the
	// thread even when the buffer is full.
	while (pair[0].Send(kHelloString, kHelloStringLength) != 0) {}

	// Data should be avialble on another socket.
	size_t bytes_in_buffer = pair[1].Peek();
	EXPECT_NE(bytes_in_buffer, 0U);

	// No more data can be written to the buffer since socket has been full,
	// verify that the amount of avialble data on another socket is unchanged.
	EXPECT_EQ(0U, pair[0].Send(kHelloString, kHelloStringLength));
	EXPECT_EQ(bytes_in_buffer, pair[1].Peek());

	// Read from another socket to free some space for a new write.
	char hello[kHelloStringLength] = {0};
	pair[1].Receive(&hello[0], sizeof(hello));

	// Should be able to write more data to the buffer now.
	EXPECT_EQ(kHelloStringLength, pair[0].Send(kHelloString, kHelloStringLength));
	}

	} // namespace