1 // Copyright 2013 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 "components/nacl/loader/nacl_ipc_adapter.h" 6 7 #include <string.h> 8 9 #include "base/memory/scoped_ptr.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/message_loop/message_loop_proxy.h" 12 #include "base/threading/platform_thread.h" 13 #include "base/threading/simple_thread.h" 14 #include "ipc/ipc_test_sink.h" 15 #include "native_client/src/trusted/desc/nacl_desc_custom.h" 16 #include "native_client/src/trusted/service_runtime/include/sys/fcntl.h" 17 #include "ppapi/c/ppb_file_io.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 20 namespace { 21 22 class NaClIPCAdapterTest : public testing::Test { 23 public: 24 NaClIPCAdapterTest() {} 25 26 // testing::Test implementation. 27 virtual void SetUp() OVERRIDE { 28 sink_ = new IPC::TestSink; 29 30 // Takes ownership of the sink_ pointer. Note we provide the current message 31 // loop instead of using a real IO thread. This should work OK since we do 32 // not need real IPC for the tests. 33 adapter_ = new NaClIPCAdapter(scoped_ptr<IPC::Channel>(sink_), 34 base::MessageLoopProxy::current().get()); 35 } 36 virtual void TearDown() OVERRIDE { 37 sink_ = NULL; // This pointer is actually owned by the IPCAdapter. 38 adapter_ = NULL; 39 // The adapter destructor has to post a task to destroy the Channel on the 40 // IO thread. For the purposes of the test, we just need to make sure that 41 // task gets run, or it will appear as a leak. 42 message_loop_.RunUntilIdle(); 43 } 44 45 protected: 46 int BlockingReceive(void* buf, size_t buf_size) { 47 NaClImcMsgIoVec iov = {buf, buf_size}; 48 NaClImcTypedMsgHdr msg = {&iov, 1}; 49 return adapter_->BlockingReceive(&msg); 50 } 51 52 int Send(void* buf, size_t buf_size) { 53 NaClImcMsgIoVec iov = {buf, buf_size}; 54 NaClImcTypedMsgHdr msg = {&iov, 1}; 55 return adapter_->Send(&msg); 56 } 57 58 base::MessageLoop message_loop_; 59 60 scoped_refptr<NaClIPCAdapter> adapter_; 61 62 // Messages sent from nacl to the adapter end up here. Note that we create 63 // this pointer and pass ownership of it to the IPC adapter, who will keep 64 // it alive as long as the adapter is alive. This means that when the 65 // adapter goes away, this pointer will become invalid. 66 // 67 // In real life the adapter needs to take ownership so the channel can be 68 // destroyed on the right thread. 69 IPC::TestSink* sink_; 70 }; 71 72 } // namespace 73 74 // Tests a simple message getting rewritten sent from native code to NaCl. 75 TEST_F(NaClIPCAdapterTest, SimpleReceiveRewriting) { 76 int routing_id = 0x89898989; 77 uint32 type = 0x55555555; 78 IPC::Message input(routing_id, type, IPC::Message::PRIORITY_NORMAL); 79 uint32 flags = input.flags(); 80 81 int value = 0x12345678; 82 input.WriteInt(value); 83 adapter_->OnMessageReceived(input); 84 85 // Buffer just need to be big enough for our message with one int. 86 const int kBufSize = 64; 87 char buf[kBufSize]; 88 89 int bytes_read = BlockingReceive(buf, kBufSize); 90 EXPECT_EQ(sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int), 91 static_cast<size_t>(bytes_read)); 92 93 const NaClIPCAdapter::NaClMessageHeader* output_header = 94 reinterpret_cast<const NaClIPCAdapter::NaClMessageHeader*>(buf); 95 EXPECT_EQ(sizeof(int), output_header->payload_size); 96 EXPECT_EQ(routing_id, output_header->routing); 97 EXPECT_EQ(type, output_header->type); 98 EXPECT_EQ(flags, output_header->flags); 99 EXPECT_EQ(0u, output_header->num_fds); 100 EXPECT_EQ(0u, output_header->pad); 101 102 // Validate the payload. 103 EXPECT_EQ(value, 104 *reinterpret_cast<const int*>(&buf[ 105 sizeof(NaClIPCAdapter::NaClMessageHeader)])); 106 } 107 108 // Tests a simple message getting rewritten sent from NaCl to native code. 109 TEST_F(NaClIPCAdapterTest, SendRewriting) { 110 int routing_id = 0x89898989; 111 uint32 type = 0x55555555; 112 int value = 0x12345678; 113 114 // Send a message with one int inside it. 115 const int buf_size = sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int); 116 char buf[buf_size] = {0}; 117 118 NaClIPCAdapter::NaClMessageHeader* header = 119 reinterpret_cast<NaClIPCAdapter::NaClMessageHeader*>(buf); 120 header->payload_size = sizeof(int); 121 header->routing = routing_id; 122 header->type = type; 123 header->flags = 0; 124 header->num_fds = 0; 125 *reinterpret_cast<int*>( 126 &buf[sizeof(NaClIPCAdapter::NaClMessageHeader)]) = value; 127 128 int result = Send(buf, buf_size); 129 EXPECT_EQ(buf_size, result); 130 131 // Check that the message came out the other end in the test sink 132 // (messages are posted, so we have to pump). 133 message_loop_.RunUntilIdle(); 134 ASSERT_EQ(1u, sink_->message_count()); 135 const IPC::Message* msg = sink_->GetMessageAt(0); 136 137 EXPECT_EQ(sizeof(int), msg->payload_size()); 138 EXPECT_EQ(header->routing, msg->routing_id()); 139 EXPECT_EQ(header->type, msg->type()); 140 141 // Now test the partial send case. We should be able to break the message 142 // into two parts and it should still work. 143 sink_->ClearMessages(); 144 int first_chunk_size = 7; 145 result = Send(buf, first_chunk_size); 146 EXPECT_EQ(first_chunk_size, result); 147 148 // First partial send should not have made any messages. 149 message_loop_.RunUntilIdle(); 150 ASSERT_EQ(0u, sink_->message_count()); 151 152 // Second partial send should do the same. 153 int second_chunk_size = 2; 154 result = Send(&buf[first_chunk_size], second_chunk_size); 155 EXPECT_EQ(second_chunk_size, result); 156 message_loop_.RunUntilIdle(); 157 ASSERT_EQ(0u, sink_->message_count()); 158 159 // Send the rest of the message in a third chunk. 160 int third_chunk_size = buf_size - first_chunk_size - second_chunk_size; 161 result = Send(&buf[first_chunk_size + second_chunk_size], 162 third_chunk_size); 163 EXPECT_EQ(third_chunk_size, result); 164 165 // Last send should have generated one message. 166 message_loop_.RunUntilIdle(); 167 ASSERT_EQ(1u, sink_->message_count()); 168 msg = sink_->GetMessageAt(0); 169 EXPECT_EQ(sizeof(int), msg->payload_size()); 170 EXPECT_EQ(header->routing, msg->routing_id()); 171 EXPECT_EQ(header->type, msg->type()); 172 } 173 174 // Tests when a buffer is too small to receive the entire message. 175 TEST_F(NaClIPCAdapterTest, PartialReceive) { 176 int routing_id_1 = 0x89898989; 177 uint32 type_1 = 0x55555555; 178 IPC::Message input_1(routing_id_1, type_1, IPC::Message::PRIORITY_NORMAL); 179 int value_1 = 0x12121212; 180 input_1.WriteInt(value_1); 181 adapter_->OnMessageReceived(input_1); 182 183 int routing_id_2 = 0x90909090; 184 uint32 type_2 = 0x66666666; 185 IPC::Message input_2(routing_id_2, type_2, IPC::Message::PRIORITY_NORMAL); 186 int value_2 = 0x23232323; 187 input_2.WriteInt(value_2); 188 adapter_->OnMessageReceived(input_2); 189 190 const int kBufSize = 64; 191 char buf[kBufSize]; 192 193 // Read part of the first message. 194 int bytes_requested = 7; 195 int bytes_read = BlockingReceive(buf, bytes_requested); 196 ASSERT_EQ(bytes_requested, bytes_read); 197 198 // Read the rest, this should give us the rest of the first message only. 199 bytes_read += BlockingReceive(&buf[bytes_requested], 200 kBufSize - bytes_requested); 201 EXPECT_EQ(sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int), 202 static_cast<size_t>(bytes_read)); 203 204 // Make sure we got the right message. 205 const NaClIPCAdapter::NaClMessageHeader* output_header = 206 reinterpret_cast<const NaClIPCAdapter::NaClMessageHeader*>(buf); 207 EXPECT_EQ(sizeof(int), output_header->payload_size); 208 EXPECT_EQ(routing_id_1, output_header->routing); 209 EXPECT_EQ(type_1, output_header->type); 210 211 // Read the second message to make sure we went on to it. 212 bytes_read = BlockingReceive(buf, kBufSize); 213 EXPECT_EQ(sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int), 214 static_cast<size_t>(bytes_read)); 215 output_header = 216 reinterpret_cast<const NaClIPCAdapter::NaClMessageHeader*>(buf); 217 EXPECT_EQ(sizeof(int), output_header->payload_size); 218 EXPECT_EQ(routing_id_2, output_header->routing); 219 EXPECT_EQ(type_2, output_header->type); 220 } 221 222 // Tests sending messages that are too large. We test sends that are too 223 // small implicitly here and in the success case because in that case it 224 // succeeds and buffers the data. 225 TEST_F(NaClIPCAdapterTest, SendOverflow) { 226 int routing_id = 0x89898989; 227 uint32 type = 0x55555555; 228 int value = 0x12345678; 229 230 // Make a message with one int inside it. Reserve some extra space so 231 // we can test what happens when we send too much data. 232 const int buf_size = sizeof(NaClIPCAdapter::NaClMessageHeader) + sizeof(int); 233 const int big_buf_size = buf_size + 4; 234 char buf[big_buf_size] = {0}; 235 236 NaClIPCAdapter::NaClMessageHeader* header = 237 reinterpret_cast<NaClIPCAdapter::NaClMessageHeader*>(buf); 238 header->payload_size = sizeof(int); 239 header->routing = routing_id; 240 header->type = type; 241 header->flags = 0; 242 header->num_fds = 0; 243 *reinterpret_cast<int*>( 244 &buf[sizeof(NaClIPCAdapter::NaClMessageHeader)]) = value; 245 246 // Send too much data and make sure that the send fails. 247 int result = Send(buf, big_buf_size); 248 EXPECT_EQ(-1, result); 249 message_loop_.RunUntilIdle(); 250 ASSERT_EQ(0u, sink_->message_count()); 251 252 // Send too much data in two chunks and make sure that the send fails. 253 int first_chunk_size = 7; 254 result = Send(buf, first_chunk_size); 255 EXPECT_EQ(first_chunk_size, result); 256 257 // First partial send should not have made any messages. 258 message_loop_.RunUntilIdle(); 259 ASSERT_EQ(0u, sink_->message_count()); 260 261 int second_chunk_size = big_buf_size - first_chunk_size; 262 result = Send(&buf[first_chunk_size], second_chunk_size); 263 EXPECT_EQ(-1, result); 264 message_loop_.RunUntilIdle(); 265 ASSERT_EQ(0u, sink_->message_count()); 266 } 267 268 // Tests that when the IPC channel reports an error, that waiting reads are 269 // unblocked and return a -1 error code. 270 TEST_F(NaClIPCAdapterTest, ReadWithChannelError) { 271 // Have a background thread that waits a bit and calls the channel error 272 // handler. This should wake up any waiting threads and immediately return 273 // -1. There is an inherent race condition in that we can't be sure if the 274 // other thread is actually waiting when this happens. This is OK, since the 275 // behavior (which we also explicitly test later) is to return -1 if the 276 // channel has already had an error when you start waiting. 277 class MyThread : public base::SimpleThread { 278 public: 279 explicit MyThread(NaClIPCAdapter* adapter) 280 : SimpleThread("NaClIPCAdapterThread"), 281 adapter_(adapter) {} 282 virtual void Run() OVERRIDE { 283 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1)); 284 adapter_->OnChannelError(); 285 } 286 private: 287 scoped_refptr<NaClIPCAdapter> adapter_; 288 }; 289 MyThread thread(adapter_.get()); 290 291 // IMPORTANT: do not return early from here down (including ASSERT_*) because 292 // the thread needs to joined or it will assert. 293 thread.Start(); 294 295 // Request data. This will normally (modulo races) block until data is 296 // received or there is an error, and the thread above will wake us up 297 // after 1s. 298 const int kBufSize = 64; 299 char buf[kBufSize]; 300 int result = BlockingReceive(buf, kBufSize); 301 EXPECT_EQ(-1, result); 302 303 // Test the "previously had an error" case. BlockingReceive should return 304 // immediately if there was an error. 305 result = BlockingReceive(buf, kBufSize); 306 EXPECT_EQ(-1, result); 307 308 thread.Join(); 309 } 310 311 // Tests that TranslatePepperFileOpenFlags translates pepper read/write open 312 // flags into NaCl open flags correctly. 313 TEST_F(NaClIPCAdapterTest, TranslatePepperFileReadWriteOpenFlags) { 314 EXPECT_EQ(NACL_ABI_O_RDONLY, 315 TranslatePepperFileReadWriteOpenFlagsForTesting(PP_FILEOPENFLAG_READ)); 316 EXPECT_EQ(NACL_ABI_O_WRONLY, 317 TranslatePepperFileReadWriteOpenFlagsForTesting(PP_FILEOPENFLAG_WRITE)); 318 EXPECT_EQ(NACL_ABI_O_WRONLY | NACL_ABI_O_APPEND, 319 TranslatePepperFileReadWriteOpenFlagsForTesting( 320 PP_FILEOPENFLAG_APPEND)); 321 EXPECT_EQ(NACL_ABI_O_RDWR, 322 TranslatePepperFileReadWriteOpenFlagsForTesting( 323 PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_WRITE)); 324 EXPECT_EQ(NACL_ABI_O_WRONLY | NACL_ABI_O_APPEND, 325 TranslatePepperFileReadWriteOpenFlagsForTesting( 326 PP_FILEOPENFLAG_APPEND)); 327 EXPECT_EQ(NACL_ABI_O_RDWR | NACL_ABI_O_APPEND, 328 TranslatePepperFileReadWriteOpenFlagsForTesting( 329 PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_APPEND)); 330 331 // Flags other than PP_FILEOPENFLAG_READ, PP_FILEOPENFLAG_WRITE, and 332 // PP_FILEOPENFLAG_APPEND are discarded. 333 EXPECT_EQ(NACL_ABI_O_WRONLY, 334 TranslatePepperFileReadWriteOpenFlagsForTesting( 335 PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE)); 336 EXPECT_EQ(NACL_ABI_O_WRONLY, 337 TranslatePepperFileReadWriteOpenFlagsForTesting( 338 PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_TRUNCATE)); 339 EXPECT_EQ(NACL_ABI_O_WRONLY, 340 TranslatePepperFileReadWriteOpenFlagsForTesting( 341 PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE)); 342 343 // If none of PP_FILEOPENFLAG_READ, PP_FILEOPENFLAG_WRITE, and 344 // PP_FILEOPENFLAG_APPEND are set, the result should fall back to 345 // NACL_ABI_O_READONLY. 346 EXPECT_EQ(NACL_ABI_O_RDONLY, 347 TranslatePepperFileReadWriteOpenFlagsForTesting(0)); 348 EXPECT_EQ(NACL_ABI_O_RDONLY, 349 TranslatePepperFileReadWriteOpenFlagsForTesting( 350 PP_FILEOPENFLAG_CREATE)); 351 EXPECT_EQ(NACL_ABI_O_RDONLY, 352 TranslatePepperFileReadWriteOpenFlagsForTesting( 353 PP_FILEOPENFLAG_TRUNCATE)); 354 EXPECT_EQ(NACL_ABI_O_RDONLY, 355 TranslatePepperFileReadWriteOpenFlagsForTesting( 356 PP_FILEOPENFLAG_EXCLUSIVE)); 357 } 358
