jbates@chromium.org | 0fc8736 | 2012-03-08 05:42:56 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 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 "build/build_config.h" |
| 6 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 7 | #if defined(OS_POSIX) |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 8 | #if defined(OS_MACOSX) |
| 9 | extern "C" { |
| 10 | #include <sandbox.h> |
kerrnel | f8e810e | 2016-04-13 01:39:06 +0900 | [diff] [blame] | 11 | }; |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 12 | #endif |
| 13 | #include <fcntl.h> |
avi | 42ebda4 | 2015-12-22 11:39:04 +0900 | [diff] [blame] | 14 | #include <stddef.h> |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 15 | #include <sys/socket.h> |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 16 | #include <sys/stat.h> |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 17 | #include <unistd.h> |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 18 | |
danakj | c3fb6c5 | 2016-04-23 13:21:09 +0900 | [diff] [blame] | 19 | #include <memory> |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 20 | #include <queue> |
| 21 | |
| 22 | #include "base/callback.h" |
erg@google.com | e6ffcb5 | 2010-08-18 03:38:24 +0900 | [diff] [blame] | 23 | #include "base/file_descriptor_posix.h" |
skyostil | e468e66 | 2015-05-12 20:29:21 +0900 | [diff] [blame] | 24 | #include "base/location.h" |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 25 | #include "base/pickle.h" |
| 26 | #include "base/posix/eintr_wrapper.h" |
fdoray | 284aae5 | 2016-06-23 04:56:16 +0900 | [diff] [blame] | 27 | #include "base/run_loop.h" |
skyostil | e468e66 | 2015-05-12 20:29:21 +0900 | [diff] [blame] | 28 | #include "base/single_thread_task_runner.h" |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 29 | #include "base/synchronization/waitable_event.h" |
rockot | 37e7fa4 | 2016-07-20 13:28:32 +0900 | [diff] [blame^] | 30 | #include "base/threading/thread_task_runner_handle.h" |
morrita | 33a3590 | 2015-01-15 06:17:06 +0900 | [diff] [blame] | 31 | #include "ipc/ipc_message_attachment_set.h" |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 32 | #include "ipc/ipc_message_utils.h" |
| 33 | #include "ipc/ipc_test_base.h" |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 34 | |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 35 | #if defined(OS_POSIX) |
| 36 | #include "base/macros.h" |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 37 | #endif |
| 38 | |
kerrnel | f8e810e | 2016-04-13 01:39:06 +0900 | [diff] [blame] | 39 | #if defined(OS_MACOSX) |
| 40 | #include "sandbox/mac/seatbelt.h" |
| 41 | #endif |
| 42 | |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 43 | namespace { |
| 44 | |
yusukes | df3387d | 2015-05-07 04:45:45 +0900 | [diff] [blame] | 45 | const unsigned kNumFDsToSend = 7; // per message |
| 46 | const unsigned kNumMessages = 20; |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 47 | const char* kDevZeroPath = "/dev/zero"; |
| 48 | |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 49 | #if defined(OS_POSIX) |
anujk.sharma | f56be5d | 2015-01-22 14:39:37 +0900 | [diff] [blame] | 50 | static_assert(kNumFDsToSend == |
| 51 | IPC::MessageAttachmentSet::kMaxDescriptorsPerMessage, |
| 52 | "The number of FDs to send must be kMaxDescriptorsPerMessage."); |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 53 | #endif |
| 54 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 55 | class MyChannelDescriptorListenerBase : public IPC::Listener { |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 56 | public: |
dcheng | ef7721a | 2014-10-22 11:29:52 +0900 | [diff] [blame] | 57 | bool OnMessageReceived(const IPC::Message& message) override { |
brettw | f314620 | 2015-06-03 13:29:25 +0900 | [diff] [blame] | 58 | base::PickleIterator iter(message); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 59 | base::FileDescriptor descriptor; |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 60 | while (IPC::ParamTraits<base::FileDescriptor>::Read( |
| 61 | &message, &iter, &descriptor)) { |
| 62 | HandleFD(descriptor.fd); |
| 63 | } |
jam@chromium.org | 8a2c784 | 2010-12-24 15:19:28 +0900 | [diff] [blame] | 64 | return true; |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 65 | } |
| 66 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 67 | protected: |
| 68 | virtual void HandleFD(int fd) = 0; |
| 69 | }; |
| 70 | |
| 71 | class MyChannelDescriptorListener : public MyChannelDescriptorListenerBase { |
| 72 | public: |
| 73 | explicit MyChannelDescriptorListener(ino_t expected_inode_num) |
| 74 | : MyChannelDescriptorListenerBase(), |
| 75 | expected_inode_num_(expected_inode_num), |
| 76 | num_fds_received_(0) { |
hubbe@chromium.org | 1b503fc | 2013-10-11 06:12:14 +0900 | [diff] [blame] | 77 | } |
| 78 | |
benwells@chromium.org | 6ecd712 | 2013-10-11 13:22:34 +0900 | [diff] [blame] | 79 | bool GotExpectedNumberOfDescriptors() const { |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 80 | return num_fds_received_ == kNumFDsToSend * kNumMessages; |
hubbe@chromium.org | 1b503fc | 2013-10-11 06:12:14 +0900 | [diff] [blame] | 81 | } |
| 82 | |
dcheng | ef7721a | 2014-10-22 11:29:52 +0900 | [diff] [blame] | 83 | void OnChannelError() override { |
ki.stfu | ad02964 | 2015-10-13 02:26:00 +0900 | [diff] [blame] | 84 | base::MessageLoop::current()->QuitWhenIdle(); |
dcheng | 9b01d24 | 2014-10-22 03:02:42 +0900 | [diff] [blame] | 85 | } |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 86 | |
| 87 | protected: |
dcheng | ef7721a | 2014-10-22 11:29:52 +0900 | [diff] [blame] | 88 | void HandleFD(int fd) override { |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 89 | ASSERT_GE(fd, 0); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 90 | // Check that we can read from the FD. |
| 91 | char buf; |
| 92 | ssize_t amt_read = read(fd, &buf, 1); |
| 93 | ASSERT_EQ(amt_read, 1); |
| 94 | ASSERT_EQ(buf, 0); // /dev/zero always reads 0 bytes. |
| 95 | |
| 96 | struct stat st; |
| 97 | ASSERT_EQ(fstat(fd, &st), 0); |
| 98 | |
| 99 | ASSERT_EQ(close(fd), 0); |
| 100 | |
| 101 | // Compare inode numbers to check that the file sent over the wire is |
| 102 | // actually the one expected. |
| 103 | ASSERT_EQ(expected_inode_num_, st.st_ino); |
| 104 | |
| 105 | ++num_fds_received_; |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 106 | if (num_fds_received_ == kNumFDsToSend * kNumMessages) |
ki.stfu | ad02964 | 2015-10-13 02:26:00 +0900 | [diff] [blame] | 107 | base::MessageLoop::current()->QuitWhenIdle(); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 108 | } |
| 109 | |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 110 | private: |
| 111 | ino_t expected_inode_num_; |
| 112 | unsigned num_fds_received_; |
| 113 | }; |
| 114 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 115 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 116 | class IPCSendFdsTest : public IPCTestBase { |
| 117 | protected: |
| 118 | void RunServer() { |
| 119 | // Set up IPC channel and start client. |
| 120 | MyChannelDescriptorListener listener(-1); |
| 121 | CreateChannel(&listener); |
| 122 | ASSERT_TRUE(ConnectChannel()); |
| 123 | ASSERT_TRUE(StartClient()); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 124 | |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 125 | for (unsigned i = 0; i < kNumMessages; ++i) { |
bbudge@chromium.org | ab4c6bc | 2013-11-05 07:28:12 +0900 | [diff] [blame] | 126 | IPC::Message* message = |
| 127 | new IPC::Message(0, 3, IPC::Message::PRIORITY_NORMAL); |
yusukes | f8a5011 | 2015-01-06 15:56:34 +0900 | [diff] [blame] | 128 | for (unsigned j = 0; j < kNumFDsToSend; ++j) { |
| 129 | const int fd = open(kDevZeroPath, O_RDONLY); |
| 130 | ASSERT_GE(fd, 0); |
| 131 | base::FileDescriptor descriptor(fd, true); |
| 132 | IPC::ParamTraits<base::FileDescriptor>::Write(message, descriptor); |
| 133 | } |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 134 | ASSERT_TRUE(sender()->Send(message)); |
| 135 | } |
| 136 | |
| 137 | // Run message loop. |
fdoray | 284aae5 | 2016-06-23 04:56:16 +0900 | [diff] [blame] | 138 | base::RunLoop().Run(); |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 139 | |
| 140 | // Close the channel so the client's OnChannelError() gets fired. |
| 141 | channel()->Close(); |
| 142 | |
| 143 | EXPECT_TRUE(WaitForClientShutdown()); |
| 144 | DestroyChannel(); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 145 | } |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 146 | }; |
| 147 | |
amistry | 87fc78f | 2016-05-05 14:12:09 +0900 | [diff] [blame] | 148 | TEST_F(IPCSendFdsTest, DescriptorTest) { |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 149 | Init("SendFdsClient"); |
| 150 | RunServer(); |
| 151 | } |
| 152 | |
| 153 | int SendFdsClientCommon(const std::string& test_client_name, |
| 154 | ino_t expected_inode_num) { |
xhwang@chromium.org | 0b2c2a5 | 2013-05-01 05:55:03 +0900 | [diff] [blame] | 155 | base::MessageLoopForIO main_message_loop; |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 156 | MyChannelDescriptorListener listener(expected_inode_num); |
| 157 | |
| 158 | // Set up IPC channel. |
danakj | c3fb6c5 | 2016-04-23 13:21:09 +0900 | [diff] [blame] | 159 | std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient( |
rockot | 37e7fa4 | 2016-07-20 13:28:32 +0900 | [diff] [blame^] | 160 | IPCTestBase::GetChannelName(test_client_name), &listener, |
| 161 | main_message_loop.task_runner())); |
morrita@chromium.org | 2ced004 | 2014-05-30 12:58:59 +0900 | [diff] [blame] | 162 | CHECK(channel->Connect()); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 163 | |
| 164 | // Run message loop. |
fdoray | 284aae5 | 2016-06-23 04:56:16 +0900 | [diff] [blame] | 165 | base::RunLoop().Run(); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 166 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 167 | // Verify that the message loop was exited due to getting the correct number |
| 168 | // of descriptors, and not because of the channel closing unexpectedly. |
dmaclach@chromium.org | 63b5df7 | 2010-12-09 10:12:20 +0900 | [diff] [blame] | 169 | CHECK(listener.GotExpectedNumberOfDescriptors()); |
| 170 | |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 171 | return 0; |
| 172 | } |
| 173 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 174 | MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsClient) { |
| 175 | struct stat st; |
| 176 | int fd = open(kDevZeroPath, O_RDONLY); |
| 177 | fstat(fd, &st); |
mark@chromium.org | fa5a0f9 | 2013-12-03 23:10:59 +0900 | [diff] [blame] | 178 | EXPECT_GE(IGNORE_EINTR(close(fd)), 0); |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 179 | return SendFdsClientCommon("SendFdsClient", st.st_ino); |
| 180 | } |
viettrungluu@chromium.org | 7d86af2 | 2013-01-12 00:13:37 +0900 | [diff] [blame] | 181 | |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 182 | #if defined(OS_MACOSX) |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 183 | // Test that FDs are correctly sent to a sandboxed process. |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 184 | // TODO(port): Make this test cross-platform. |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 185 | TEST_F(IPCSendFdsTest, DescriptorTestSandboxed) { |
| 186 | Init("SendFdsSandboxedClient"); |
| 187 | RunServer(); |
| 188 | } |
| 189 | |
| 190 | MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsSandboxedClient) { |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 191 | struct stat st; |
| 192 | const int fd = open(kDevZeroPath, O_RDONLY); |
| 193 | fstat(fd, &st); |
mark@chromium.org | fa5a0f9 | 2013-12-03 23:10:59 +0900 | [diff] [blame] | 194 | if (IGNORE_EINTR(close(fd)) < 0) |
thakis@chromium.org | 5dab748 | 2010-10-04 09:34:04 +0900 | [diff] [blame] | 195 | return -1; |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 196 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 197 | // Enable the sandbox. |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 198 | char* error_buff = NULL; |
kerrnel | f8e810e | 2016-04-13 01:39:06 +0900 | [diff] [blame] | 199 | int error = sandbox::Seatbelt::Init(kSBXProfilePureComputation, SANDBOX_NAMED, |
| 200 | &error_buff); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 201 | bool success = (error == 0 && error_buff == NULL); |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 202 | if (!success) |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 203 | return -1; |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 204 | |
kerrnel | f8e810e | 2016-04-13 01:39:06 +0900 | [diff] [blame] | 205 | sandbox::Seatbelt::FreeError(error_buff); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 206 | |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 207 | // Make sure sandbox is really enabled. |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 208 | if (open(kDevZeroPath, O_RDONLY) != -1) { |
| 209 | LOG(ERROR) << "Sandbox wasn't properly enabled"; |
| 210 | return -1; |
| 211 | } |
| 212 | |
| 213 | // See if we can receive a file descriptor. |
viettrungluu@chromium.org | 0015594 | 2013-01-26 06:51:35 +0900 | [diff] [blame] | 214 | return SendFdsClientCommon("SendFdsSandboxedClient", st.st_ino); |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 215 | } |
| 216 | #endif // defined(OS_MACOSX) |
| 217 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 218 | |
| 219 | class MyCBListener : public MyChannelDescriptorListenerBase { |
| 220 | public: |
| 221 | MyCBListener(base::Callback<void(int)> cb, int fds_to_send) |
| 222 | : MyChannelDescriptorListenerBase(), |
| 223 | cb_(cb) { |
| 224 | } |
| 225 | |
| 226 | protected: |
dcheng | ef7721a | 2014-10-22 11:29:52 +0900 | [diff] [blame] | 227 | void HandleFD(int fd) override { cb_.Run(fd); } |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 228 | private: |
| 229 | base::Callback<void(int)> cb_; |
| 230 | }; |
| 231 | |
| 232 | std::pair<int, int> make_socket_pair() { |
| 233 | int pipe_fds[2]; |
| 234 | CHECK_EQ(0, HANDLE_EINTR(socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds))); |
| 235 | return std::pair<int, int>(pipe_fds[0], pipe_fds[1]); |
| 236 | } |
| 237 | |
| 238 | static void null_cb(int unused_fd) { |
| 239 | NOTREACHED(); |
| 240 | } |
| 241 | |
| 242 | class PipeChannelHelper { |
| 243 | public: |
| 244 | PipeChannelHelper(base::Thread* in_thread, |
| 245 | base::Thread* out_thread, |
| 246 | base::Callback<void(int)> cb, |
| 247 | int fds_to_send) : |
| 248 | in_thread_(in_thread), |
| 249 | out_thread_(out_thread), |
| 250 | cb_listener_(cb, fds_to_send), |
| 251 | null_listener_(base::Bind(&null_cb), 0) { |
| 252 | } |
| 253 | |
| 254 | void Init() { |
| 255 | IPC::ChannelHandle in_handle("IN"); |
rockot | 37e7fa4 | 2016-07-20 13:28:32 +0900 | [diff] [blame^] | 256 | in = IPC::Channel::CreateServer( |
| 257 | in_handle, &null_listener_, in_thread_->task_runner()); |
morrita | 13e514d | 2014-10-21 08:53:25 +0900 | [diff] [blame] | 258 | IPC::ChannelHandle out_handle( |
| 259 | "OUT", base::FileDescriptor(in->TakeClientFileDescriptor())); |
rockot | 37e7fa4 | 2016-07-20 13:28:32 +0900 | [diff] [blame^] | 260 | out = IPC::Channel::CreateClient( |
| 261 | out_handle, &cb_listener_, out_thread_->task_runner()); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 262 | // PostTask the connect calls to make sure the callbacks happens |
| 263 | // on the right threads. |
skyostil | e468e66 | 2015-05-12 20:29:21 +0900 | [diff] [blame] | 264 | in_thread_->task_runner()->PostTask( |
| 265 | FROM_HERE, base::Bind(&PipeChannelHelper::Connect, in.get())); |
| 266 | out_thread_->task_runner()->PostTask( |
| 267 | FROM_HERE, base::Bind(&PipeChannelHelper::Connect, out.get())); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 268 | } |
| 269 | |
danakj | c3fb6c5 | 2016-04-23 13:21:09 +0900 | [diff] [blame] | 270 | static void DestroyChannel(std::unique_ptr<IPC::Channel>* c, |
| 271 | base::WaitableEvent* event) { |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 272 | c->reset(0); |
| 273 | event->Signal(); |
| 274 | } |
| 275 | |
| 276 | ~PipeChannelHelper() { |
gab | c1aebcf | 2016-06-02 05:34:06 +0900 | [diff] [blame] | 277 | base::WaitableEvent a(base::WaitableEvent::ResetPolicy::MANUAL, |
| 278 | base::WaitableEvent::InitialState::NOT_SIGNALED); |
| 279 | base::WaitableEvent b(base::WaitableEvent::ResetPolicy::MANUAL, |
| 280 | base::WaitableEvent::InitialState::NOT_SIGNALED); |
skyostil | e468e66 | 2015-05-12 20:29:21 +0900 | [diff] [blame] | 281 | in_thread_->task_runner()->PostTask( |
| 282 | FROM_HERE, base::Bind(&PipeChannelHelper::DestroyChannel, &in, &a)); |
| 283 | out_thread_->task_runner()->PostTask( |
| 284 | FROM_HERE, base::Bind(&PipeChannelHelper::DestroyChannel, &out, &b)); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 285 | a.Wait(); |
| 286 | b.Wait(); |
| 287 | } |
| 288 | |
| 289 | static void Connect(IPC::Channel *channel) { |
| 290 | EXPECT_TRUE(channel->Connect()); |
| 291 | } |
| 292 | |
| 293 | void Send(int fd) { |
| 294 | CHECK_EQ(base::MessageLoop::current(), in_thread_->message_loop()); |
| 295 | |
| 296 | ASSERT_GE(fd, 0); |
| 297 | base::FileDescriptor descriptor(fd, true); |
| 298 | |
bbudge@chromium.org | ab4c6bc | 2013-11-05 07:28:12 +0900 | [diff] [blame] | 299 | IPC::Message* message = |
| 300 | new IPC::Message(0, 3, IPC::Message::PRIORITY_NORMAL); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 301 | IPC::ParamTraits<base::FileDescriptor>::Write(message, descriptor); |
| 302 | ASSERT_TRUE(in->Send(message)); |
| 303 | } |
| 304 | |
| 305 | private: |
danakj | c3fb6c5 | 2016-04-23 13:21:09 +0900 | [diff] [blame] | 306 | std::unique_ptr<IPC::Channel> in, out; |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 307 | base::Thread* in_thread_; |
| 308 | base::Thread* out_thread_; |
| 309 | MyCBListener cb_listener_; |
| 310 | MyCBListener null_listener_; |
| 311 | }; |
| 312 | |
| 313 | // This test is meant to provoke a kernel bug on OSX, and to prove |
| 314 | // that the workaround for it is working. It sets up two pipes and three |
| 315 | // threads, the producer thread creates socketpairs and sends one of the fds |
| 316 | // over pipe1 to the middleman thread. The middleman thread simply takes the fd |
| 317 | // sends it over pipe2 to the consumer thread. The consumer thread writes a byte |
| 318 | // to each fd it receives and then closes the pipe. The producer thread reads |
| 319 | // the bytes back from each pair of pipes and make sure that everything worked. |
| 320 | // This feedback mechanism makes sure that not too many file descriptors are |
| 321 | // in flight at the same time. For more info on the bug, see: |
| 322 | // http://crbug.com/298276 |
| 323 | class IPCMultiSendingFdsTest : public testing::Test { |
| 324 | public: |
gab | c1aebcf | 2016-06-02 05:34:06 +0900 | [diff] [blame] | 325 | IPCMultiSendingFdsTest() |
| 326 | : received_(base::WaitableEvent::ResetPolicy::MANUAL, |
| 327 | base::WaitableEvent::InitialState::NOT_SIGNALED) {} |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 328 | |
| 329 | void Producer(PipeChannelHelper* dest, |
| 330 | base::Thread* t, |
| 331 | int pipes_to_send) { |
| 332 | for (int i = 0; i < pipes_to_send; i++) { |
| 333 | received_.Reset(); |
| 334 | std::pair<int, int> pipe_fds = make_socket_pair(); |
skyostil | e468e66 | 2015-05-12 20:29:21 +0900 | [diff] [blame] | 335 | t->task_runner()->PostTask( |
| 336 | FROM_HERE, base::Bind(&PipeChannelHelper::Send, |
| 337 | base::Unretained(dest), pipe_fds.second)); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 338 | char tmp = 'x'; |
| 339 | CHECK_EQ(1, HANDLE_EINTR(write(pipe_fds.first, &tmp, 1))); |
mark@chromium.org | fa5a0f9 | 2013-12-03 23:10:59 +0900 | [diff] [blame] | 340 | CHECK_EQ(0, IGNORE_EINTR(close(pipe_fds.first))); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 341 | received_.Wait(); |
| 342 | } |
| 343 | } |
| 344 | |
| 345 | void ConsumerHandleFD(int fd) { |
| 346 | char tmp = 'y'; |
| 347 | CHECK_EQ(1, HANDLE_EINTR(read(fd, &tmp, 1))); |
| 348 | CHECK_EQ(tmp, 'x'); |
mark@chromium.org | fa5a0f9 | 2013-12-03 23:10:59 +0900 | [diff] [blame] | 349 | CHECK_EQ(0, IGNORE_EINTR(close(fd))); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 350 | received_.Signal(); |
| 351 | } |
| 352 | |
| 353 | base::Thread* CreateThread(const char* name) { |
| 354 | base::Thread* ret = new base::Thread(name); |
| 355 | base::Thread::Options options; |
| 356 | options.message_loop_type = base::MessageLoop::TYPE_IO; |
| 357 | ret->StartWithOptions(options); |
| 358 | return ret; |
| 359 | } |
| 360 | |
| 361 | void Run() { |
| 362 | // On my mac, this test fails roughly 35 times per |
| 363 | // million sends with low load, but much more with high load. |
| 364 | // Unless the workaround is in place. With 10000 sends, we |
| 365 | // should see at least a 3% failure rate. |
| 366 | const int pipes_to_send = 20000; |
danakj | c3fb6c5 | 2016-04-23 13:21:09 +0900 | [diff] [blame] | 367 | std::unique_ptr<base::Thread> producer(CreateThread("producer")); |
| 368 | std::unique_ptr<base::Thread> middleman(CreateThread("middleman")); |
| 369 | std::unique_ptr<base::Thread> consumer(CreateThread("consumer")); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 370 | PipeChannelHelper pipe1( |
| 371 | middleman.get(), |
| 372 | consumer.get(), |
| 373 | base::Bind(&IPCMultiSendingFdsTest::ConsumerHandleFD, |
| 374 | base::Unretained(this)), |
| 375 | pipes_to_send); |
| 376 | PipeChannelHelper pipe2( |
| 377 | producer.get(), |
| 378 | middleman.get(), |
| 379 | base::Bind(&PipeChannelHelper::Send, base::Unretained(&pipe1)), |
| 380 | pipes_to_send); |
| 381 | pipe1.Init(); |
| 382 | pipe2.Init(); |
| 383 | Producer(&pipe2, producer.get(), pipes_to_send); |
| 384 | } |
| 385 | |
| 386 | private: |
| 387 | base::WaitableEvent received_; |
| 388 | }; |
| 389 | |
| 390 | TEST_F(IPCMultiSendingFdsTest, StressTest) { |
| 391 | Run(); |
| 392 | } |
| 393 | |
viettrungluu@chromium.org | 7ca1913 | 2013-01-12 05:56:22 +0900 | [diff] [blame] | 394 | } // namespace |
| 395 | |
agl@chromium.org | 1c6dcf2 | 2009-07-23 08:57:21 +0900 | [diff] [blame] | 396 | #endif // defined(OS_POSIX) |