| OLD | NEW |
|---|
| (Empty) |
| 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/basictypes.h" | |
| 6 #include "sandbox/src/crosscall_client.h" | |
| 7 #include "sandbox/src/crosscall_server.h" | |
| 8 #include "sandbox/src/sharedmem_ipc_client.h" | |
| 9 #include "sandbox/src/sharedmem_ipc_server.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 | |
| 12 namespace sandbox { | |
| 13 | |
| 14 // Helper function to make the fake shared memory with some | |
| 15 // basic elements initialized. | |
| 16 IPCControl* MakeChannels(size_t channel_size, size_t total_shared_size, | |
| 17 size_t* base_start) { | |
| 18 // Allocate memory | |
| 19 char* mem = new char[total_shared_size]; | |
| 20 memset(mem, 0, total_shared_size); | |
| 21 // Calculate how many channels we can fit in the shared memory. | |
| 22 total_shared_size -= offsetof(IPCControl, channels); | |
| 23 size_t channel_count = | |
| 24 total_shared_size / (sizeof(ChannelControl) + channel_size); | |
| 25 // Calculate the start of the first channel. | |
| 26 *base_start = (sizeof(ChannelControl)* channel_count) + | |
| 27 offsetof(IPCControl, channels); | |
| 28 // Setup client structure. | |
| 29 IPCControl* client_control = reinterpret_cast<IPCControl*>(mem); | |
| 30 client_control->channels_count = channel_count; | |
| 31 return client_control; | |
| 32 } | |
| 33 | |
| 34 enum TestFixMode { | |
| 35 FIX_NO_EVENTS, | |
| 36 FIX_PONG_READY, | |
| 37 FIX_PONG_NOT_READY | |
| 38 }; | |
| 39 | |
| 40 void FixChannels(IPCControl* client_control, size_t base_start, | |
| 41 size_t channel_size, TestFixMode mode) { | |
| 42 for (size_t ix = 0; ix != client_control->channels_count; ++ix) { | |
| 43 ChannelControl& channel = client_control->channels[ix]; | |
| 44 channel.channel_base = base_start; | |
| 45 channel.state = kFreeChannel; | |
| 46 if (mode != FIX_NO_EVENTS) { | |
| 47 BOOL signaled = (FIX_PONG_READY == mode)? TRUE : FALSE; | |
| 48 channel.ping_event = ::CreateEventW(NULL, FALSE, FALSE, NULL); | |
| 49 channel.pong_event = ::CreateEventW(NULL, FALSE, signaled, NULL); | |
| 50 } | |
| 51 base_start += channel_size; | |
| 52 } | |
| 53 } | |
| 54 | |
| 55 void CloseChannelEvents(IPCControl* client_control) { | |
| 56 for (size_t ix = 0; ix != client_control->channels_count; ++ix) { | |
| 57 ChannelControl& channel = client_control->channels[ix]; | |
| 58 ::CloseHandle(channel.ping_event); | |
| 59 ::CloseHandle(channel.pong_event); | |
| 60 } | |
| 61 } | |
| 62 | |
| 63 TEST(IPCTest, ChannelMaker) { | |
| 64 // Test that our testing rig is computing offsets properly. We should have | |
| 65 // 5 channnels and the offset to the first channel is 108 bytes in 32 bits | |
| 66 // and 216 in 64 bits. | |
| 67 size_t channel_start = 0; | |
| 68 IPCControl* client_control = MakeChannels(12 * 64, 4096, &channel_start); | |
| 69 ASSERT_TRUE(NULL != client_control); | |
| 70 EXPECT_EQ(5, client_control->channels_count); | |
| 71 #if defined(_WIN64) | |
| 72 EXPECT_EQ(216, channel_start); | |
| 73 #else | |
| 74 EXPECT_EQ(108, channel_start); | |
| 75 #endif | |
| 76 delete[] reinterpret_cast<char*>(client_control); | |
| 77 } | |
| 78 | |
| 79 TEST(IPCTest, ClientLockUnlock) { | |
| 80 // Make 7 channels of kIPCChannelSize (1kb) each. Test that we lock and | |
| 81 // unlock channels properly. | |
| 82 size_t base_start = 0; | |
| 83 IPCControl* client_control = | |
| 84 MakeChannels(kIPCChannelSize, 4096 * 2, &base_start); | |
| 85 FixChannels(client_control, base_start, kIPCChannelSize, FIX_NO_EVENTS); | |
| 86 | |
| 87 char* mem = reinterpret_cast<char*>(client_control); | |
| 88 SharedMemIPCClient client(mem); | |
| 89 | |
| 90 // Test that we lock the first 3 channels in sequence. | |
| 91 void* buff0 = client.GetBuffer(); | |
| 92 EXPECT_TRUE(mem + client_control->channels[0].channel_base == buff0); | |
| 93 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 94 EXPECT_EQ(kFreeChannel, client_control->channels[1].state); | |
| 95 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 96 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 97 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 98 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 99 | |
| 100 void* buff1 = client.GetBuffer(); | |
| 101 EXPECT_TRUE(mem + client_control->channels[1].channel_base == buff1); | |
| 102 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 103 EXPECT_EQ(kBusyChannel, client_control->channels[1].state); | |
| 104 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 105 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 106 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 107 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 108 | |
| 109 void* buff2 = client.GetBuffer(); | |
| 110 EXPECT_TRUE(mem + client_control->channels[2].channel_base == buff2); | |
| 111 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 112 EXPECT_EQ(kBusyChannel, client_control->channels[1].state); | |
| 113 EXPECT_EQ(kBusyChannel, client_control->channels[2].state); | |
| 114 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 115 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 116 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 117 | |
| 118 // Test that we unlock and re-lock the right channel. | |
| 119 client.FreeBuffer(buff1); | |
| 120 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 121 EXPECT_EQ(kFreeChannel, client_control->channels[1].state); | |
| 122 EXPECT_EQ(kBusyChannel, client_control->channels[2].state); | |
| 123 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 124 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 125 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 126 | |
| 127 void* buff2b = client.GetBuffer(); | |
| 128 EXPECT_TRUE(mem + client_control->channels[1].channel_base == buff2b); | |
| 129 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 130 EXPECT_EQ(kBusyChannel, client_control->channels[1].state); | |
| 131 EXPECT_EQ(kBusyChannel, client_control->channels[2].state); | |
| 132 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 133 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 134 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 135 | |
| 136 client.FreeBuffer(buff0); | |
| 137 EXPECT_EQ(kFreeChannel, client_control->channels[0].state); | |
| 138 EXPECT_EQ(kBusyChannel, client_control->channels[1].state); | |
| 139 EXPECT_EQ(kBusyChannel, client_control->channels[2].state); | |
| 140 EXPECT_EQ(kFreeChannel, client_control->channels[3].state); | |
| 141 EXPECT_EQ(kFreeChannel, client_control->channels[4].state); | |
| 142 EXPECT_EQ(kFreeChannel, client_control->channels[5].state); | |
| 143 | |
| 144 delete[] reinterpret_cast<char*>(client_control); | |
| 145 } | |
| 146 | |
| 147 TEST(IPCTest, CrossCallStrPacking) { | |
| 148 // This test tries the CrossCall object with null and non-null string | |
| 149 // combination of parameters, integer types and verifies that the unpacker | |
| 150 // can read them properly. | |
| 151 size_t base_start = 0; | |
| 152 IPCControl* client_control = | |
| 153 MakeChannels(kIPCChannelSize, 4096 * 4, &base_start); | |
| 154 client_control->server_alive = HANDLE(1); | |
| 155 FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_READY); | |
| 156 | |
| 157 char* mem = reinterpret_cast<char*>(client_control); | |
| 158 SharedMemIPCClient client(mem); | |
| 159 | |
| 160 CrossCallReturn answer; | |
| 161 uint32 tag1 = 666; | |
| 162 const wchar_t text[] = L"98765 - 43210"; | |
| 163 std::wstring copied_text; | |
| 164 CrossCallParamsEx* actual_params; | |
| 165 | |
| 166 CrossCall(client, tag1, text, &answer); | |
| 167 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 168 EXPECT_EQ(1, actual_params->GetParamsCount()); | |
| 169 EXPECT_EQ(tag1, actual_params->GetTag()); | |
| 170 EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text)); | |
| 171 EXPECT_STREQ(text, copied_text.c_str()); | |
| 172 | |
| 173 // Check with an empty string. | |
| 174 uint32 tag2 = 777; | |
| 175 const wchar_t* null_text = NULL; | |
| 176 CrossCall(client, tag2, null_text, &answer); | |
| 177 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 178 EXPECT_EQ(1, actual_params->GetParamsCount()); | |
| 179 EXPECT_EQ(tag2, actual_params->GetTag()); | |
| 180 uint32 param_size = 1; | |
| 181 ArgType type = INVALID_TYPE; | |
| 182 void* param_addr = actual_params->GetRawParameter(0, ¶m_size, &type); | |
| 183 EXPECT_TRUE(NULL != param_addr); | |
| 184 EXPECT_EQ(0, param_size); | |
| 185 EXPECT_EQ(WCHAR_TYPE, type); | |
| 186 EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text)); | |
| 187 | |
| 188 uint32 tag3 = 888; | |
| 189 param_size = 1; | |
| 190 copied_text.clear(); | |
| 191 | |
| 192 // Check with an empty string and a non-empty string. | |
| 193 CrossCall(client, tag3, null_text, text, &answer); | |
| 194 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 195 EXPECT_EQ(2, actual_params->GetParamsCount()); | |
| 196 EXPECT_EQ(tag3, actual_params->GetTag()); | |
| 197 type = INVALID_TYPE; | |
| 198 param_addr = actual_params->GetRawParameter(0, ¶m_size, &type); | |
| 199 EXPECT_TRUE(NULL != param_addr); | |
| 200 EXPECT_EQ(0, param_size); | |
| 201 EXPECT_EQ(WCHAR_TYPE, type); | |
| 202 EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text)); | |
| 203 EXPECT_TRUE(actual_params->GetParameterStr(1, &copied_text)); | |
| 204 EXPECT_STREQ(text, copied_text.c_str()); | |
| 205 | |
| 206 param_size = 1; | |
| 207 std::wstring copied_text_p0, copied_text_p2; | |
| 208 | |
| 209 const wchar_t text2[] = L"AeFG"; | |
| 210 CrossCall(client, tag1, text2, null_text, text, &answer); | |
| 211 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 212 EXPECT_EQ(3, actual_params->GetParamsCount()); | |
| 213 EXPECT_EQ(tag1, actual_params->GetTag()); | |
| 214 EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text_p0)); | |
| 215 EXPECT_STREQ(text2, copied_text_p0.c_str()); | |
| 216 EXPECT_TRUE(actual_params->GetParameterStr(2, &copied_text_p2)); | |
| 217 EXPECT_STREQ(text, copied_text_p2.c_str()); | |
| 218 type = INVALID_TYPE; | |
| 219 param_addr = actual_params->GetRawParameter(1, ¶m_size, &type); | |
| 220 EXPECT_TRUE(NULL != param_addr); | |
| 221 EXPECT_EQ(0, param_size); | |
| 222 EXPECT_EQ(WCHAR_TYPE, type); | |
| 223 | |
| 224 CloseChannelEvents(client_control); | |
| 225 delete[] reinterpret_cast<char*>(client_control); | |
| 226 } | |
| 227 | |
| 228 TEST(IPCTest, CrossCallIntPacking) { | |
| 229 // Check handling for regular 32 bit integers used in Windows. | |
| 230 size_t base_start = 0; | |
| 231 IPCControl* client_control = | |
| 232 MakeChannels(kIPCChannelSize, 4096 * 4, &base_start); | |
| 233 client_control->server_alive = HANDLE(1); | |
| 234 FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_READY); | |
| 235 | |
| 236 uint32 tag1 = 999; | |
| 237 uint32 tag2 = 111; | |
| 238 const wchar_t text[] = L"godzilla"; | |
| 239 CrossCallParamsEx* actual_params; | |
| 240 | |
| 241 char* mem = reinterpret_cast<char*>(client_control); | |
| 242 SharedMemIPCClient client(mem); | |
| 243 | |
| 244 CrossCallReturn answer; | |
| 245 DWORD dw = 0xE6578; | |
| 246 CrossCall(client, tag2, dw, &answer); | |
| 247 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 248 EXPECT_EQ(1, actual_params->GetParamsCount()); | |
| 249 EXPECT_EQ(tag2, actual_params->GetTag()); | |
| 250 ArgType type = INVALID_TYPE; | |
| 251 uint32 param_size = 1; | |
| 252 void* param_addr = actual_params->GetRawParameter(0, ¶m_size, &type); | |
| 253 ASSERT_EQ(sizeof(dw), param_size); | |
| 254 EXPECT_EQ(ULONG_TYPE, type); | |
| 255 ASSERT_TRUE(NULL != param_addr); | |
| 256 EXPECT_EQ(0, memcmp(&dw, param_addr, param_size)); | |
| 257 | |
| 258 // Check handling for windows HANDLES. | |
| 259 HANDLE h = HANDLE(0x70000500); | |
| 260 CrossCall(client, tag1, text, h, &answer); | |
| 261 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 262 EXPECT_EQ(2, actual_params->GetParamsCount()); | |
| 263 EXPECT_EQ(tag1, actual_params->GetTag()); | |
| 264 type = INVALID_TYPE; | |
| 265 param_addr = actual_params->GetRawParameter(1, ¶m_size, &type); | |
| 266 ASSERT_EQ(sizeof(h), param_size); | |
| 267 EXPECT_EQ(VOIDPTR_TYPE, type); | |
| 268 ASSERT_TRUE(NULL != param_addr); | |
| 269 EXPECT_EQ(0, memcmp(&h, param_addr, param_size)); | |
| 270 | |
| 271 // Check combination of 32 and 64 bits. | |
| 272 CrossCall(client, tag2, h, dw, h, &answer); | |
| 273 actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer()); | |
| 274 EXPECT_EQ(3, actual_params->GetParamsCount()); | |
| 275 EXPECT_EQ(tag2, actual_params->GetTag()); | |
| 276 type = INVALID_TYPE; | |
| 277 param_addr = actual_params->GetRawParameter(0, ¶m_size, &type); | |
| 278 ASSERT_EQ(sizeof(h), param_size); | |
| 279 EXPECT_EQ(VOIDPTR_TYPE, type); | |
| 280 ASSERT_TRUE(NULL != param_addr); | |
| 281 EXPECT_EQ(0, memcmp(&h, param_addr, param_size)); | |
| 282 type = INVALID_TYPE; | |
| 283 param_addr = actual_params->GetRawParameter(1, ¶m_size, &type); | |
| 284 ASSERT_EQ(sizeof(dw), param_size); | |
| 285 EXPECT_EQ(ULONG_TYPE, type); | |
| 286 ASSERT_TRUE(NULL != param_addr); | |
| 287 EXPECT_EQ(0, memcmp(&dw, param_addr, param_size)); | |
| 288 type = INVALID_TYPE; | |
| 289 param_addr = actual_params->GetRawParameter(2, ¶m_size, &type); | |
| 290 ASSERT_EQ(sizeof(h), param_size); | |
| 291 EXPECT_EQ(VOIDPTR_TYPE, type); | |
| 292 ASSERT_TRUE(NULL != param_addr); | |
| 293 EXPECT_EQ(0, memcmp(&h, param_addr, param_size)); | |
| 294 | |
| 295 CloseChannelEvents(client_control); | |
| 296 delete[] reinterpret_cast<char*>(client_control); | |
| 297 } | |
| 298 | |
| 299 TEST(IPCTest, CrossCallValidation) { | |
| 300 // First a sanity test with a well formed parameter object. | |
| 301 unsigned long value = 124816; | |
| 302 const uint32 kTag = 33; | |
| 303 const uint32 kBufferSize = 256; | |
| 304 ActualCallParams<1, kBufferSize> params_1(kTag); | |
| 305 params_1.CopyParamIn(0, &value, sizeof(value), false, ULONG_TYPE); | |
| 306 void* buffer = const_cast<void*>(params_1.GetBuffer()); | |
| 307 | |
| 308 uint32 out_size = 0; | |
| 309 CrossCallParamsEx* ccp = 0; | |
| 310 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, params_1.GetSize(), | |
| 311 &out_size); | |
| 312 ASSERT_TRUE(NULL != ccp); | |
| 313 EXPECT_TRUE(ccp->GetBuffer() != buffer); | |
| 314 EXPECT_EQ(kTag, ccp->GetTag()); | |
| 315 EXPECT_EQ(1, ccp->GetParamsCount()); | |
| 316 delete[] (reinterpret_cast<char*>(ccp)); | |
| 317 | |
| 318 #if defined(NDEBUG) | |
| 319 // Test hat we handle integer overflow on the number of params | |
| 320 // correctly. We use a test-only ctor for ActualCallParams that | |
| 321 // allows to create malformed cross-call buffers. | |
| 322 const int32 kPtrDiffSz = sizeof(ptrdiff_t); | |
| 323 for (int32 ix = -1; ix != 3; ++ix) { | |
| 324 uint32 fake_num_params = (kuint32max / kPtrDiffSz) + ix; | |
| 325 ActualCallParams<1, kBufferSize> params_2(kTag, fake_num_params); | |
| 326 params_2.CopyParamIn(0, &value, sizeof(value), false, ULONG_TYPE); | |
| 327 buffer = const_cast<void*>(params_2.GetBuffer()); | |
| 328 | |
| 329 EXPECT_TRUE(NULL != buffer); | |
| 330 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, params_1.GetSize(), | |
| 331 &out_size); | |
| 332 // If the buffer is malformed the return is NULL. | |
| 333 EXPECT_TRUE(NULL == ccp); | |
| 334 } | |
| 335 #endif // defined(NDEBUG) | |
| 336 | |
| 337 ActualCallParams<1, kBufferSize> params_3(kTag, 1); | |
| 338 params_3.CopyParamIn(0, &value, sizeof(value), false, ULONG_TYPE); | |
| 339 buffer = const_cast<void*>(params_3.GetBuffer()); | |
| 340 EXPECT_TRUE(NULL != buffer); | |
| 341 | |
| 342 uint32 correct_size = params_3.OverrideSize(1); | |
| 343 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, kBufferSize, &out_size); | |
| 344 EXPECT_TRUE(NULL == ccp); | |
| 345 | |
| 346 // The correct_size is 8 bytes aligned. | |
| 347 params_3.OverrideSize(correct_size - 7); | |
| 348 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, kBufferSize, &out_size); | |
| 349 EXPECT_TRUE(NULL == ccp); | |
| 350 | |
| 351 params_3.OverrideSize(correct_size); | |
| 352 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, kBufferSize, &out_size); | |
| 353 EXPECT_TRUE(NULL != ccp); | |
| 354 | |
| 355 // Make sure that two parameters work as expected. | |
| 356 ActualCallParams<2, kBufferSize> params_4(kTag, 2); | |
| 357 params_4.CopyParamIn(0, &value, sizeof(value), false, ULONG_TYPE); | |
| 358 params_4.CopyParamIn(1, buffer, sizeof(buffer), false, VOIDPTR_TYPE); | |
| 359 buffer = const_cast<void*>(params_4.GetBuffer()); | |
| 360 EXPECT_TRUE(NULL != buffer); | |
| 361 | |
| 362 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, kBufferSize, &out_size); | |
| 363 EXPECT_TRUE(NULL != ccp); | |
| 364 | |
| 365 #if defined(_WIN64) | |
| 366 correct_size = params_4.OverrideSize(1); | |
| 367 params_4.OverrideSize(correct_size - 1); | |
| 368 ccp = CrossCallParamsEx::CreateFromBuffer(buffer, kBufferSize, &out_size); | |
| 369 EXPECT_TRUE(NULL == ccp); | |
| 370 #endif | |
| 371 } | |
| 372 | |
| 373 // This structure is passed to the mock server threads to simulate | |
| 374 // the server side IPC so it has the required kernel objects. | |
| 375 struct ServerEvents { | |
| 376 HANDLE ping; | |
| 377 HANDLE pong; | |
| 378 volatile LONG* state; | |
| 379 HANDLE mutex; | |
| 380 }; | |
| 381 | |
| 382 // This is the server thread that quicky answers an IPC and exits. | |
| 383 DWORD WINAPI QuickResponseServer(PVOID param) { | |
| 384 ServerEvents* events = reinterpret_cast<ServerEvents*>(param); | |
| 385 DWORD wait_result = 0; | |
| 386 wait_result = ::WaitForSingleObject(events->ping, INFINITE); | |
| 387 ::InterlockedExchange(events->state, kAckChannel); | |
| 388 ::SetEvent(events->pong); | |
| 389 return wait_result; | |
| 390 } | |
| 391 | |
| 392 class CrossCallParamsMock : public CrossCallParams { | |
| 393 public: | |
| 394 CrossCallParamsMock(uint32 tag, uint32 params_count) | |
| 395 : CrossCallParams(tag, params_count) { | |
| 396 } | |
| 397 private: | |
| 398 void* params[4]; | |
| 399 }; | |
| 400 | |
| 401 void FakeOkAnswerInChannel(void* channel) { | |
| 402 CrossCallReturn* answer = reinterpret_cast<CrossCallReturn*>(channel); | |
| 403 answer->call_outcome = SBOX_ALL_OK; | |
| 404 } | |
| 405 | |
| 406 // Create two threads that will quickly answer IPCs; the first one | |
| 407 // using channel 1 (channel 0 is busy) and one using channel 0. No time-out | |
| 408 // should occur. | |
| 409 TEST(IPCTest, ClientFastServer) { | |
| 410 const size_t channel_size = kIPCChannelSize; | |
| 411 size_t base_start = 0; | |
| 412 IPCControl* client_control = | |
| 413 MakeChannels(channel_size, 4096 * 2, &base_start); | |
| 414 FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_NOT_READY); | |
| 415 client_control->server_alive = ::CreateMutex(NULL, FALSE, NULL); | |
| 416 | |
| 417 char* mem = reinterpret_cast<char*>(client_control); | |
| 418 SharedMemIPCClient client(mem); | |
| 419 | |
| 420 ServerEvents events = {0}; | |
| 421 events.ping = client_control->channels[1].ping_event; | |
| 422 events.pong = client_control->channels[1].pong_event; | |
| 423 events.state = &client_control->channels[1].state; | |
| 424 | |
| 425 HANDLE t1 = ::CreateThread(NULL, 0, QuickResponseServer, &events, 0, NULL); | |
| 426 ASSERT_TRUE(NULL != t1); | |
| 427 ::CloseHandle(t1); | |
| 428 | |
| 429 void* buff0 = client.GetBuffer(); | |
| 430 EXPECT_TRUE(mem + client_control->channels[0].channel_base == buff0); | |
| 431 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 432 EXPECT_EQ(kFreeChannel, client_control->channels[1].state); | |
| 433 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 434 | |
| 435 void* buff1 = client.GetBuffer(); | |
| 436 EXPECT_TRUE(mem + client_control->channels[1].channel_base == buff1); | |
| 437 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 438 EXPECT_EQ(kBusyChannel, client_control->channels[1].state); | |
| 439 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 440 | |
| 441 EXPECT_EQ(0, client_control->channels[1].ipc_tag); | |
| 442 | |
| 443 uint32 tag = 7654; | |
| 444 CrossCallReturn answer; | |
| 445 CrossCallParamsMock* params1 = new(buff1) CrossCallParamsMock(tag, 1); | |
| 446 FakeOkAnswerInChannel(buff1); | |
| 447 | |
| 448 ResultCode result = client.DoCall(params1, &answer); | |
| 449 if (SBOX_ERROR_CHANNEL_ERROR != result) | |
| 450 client.FreeBuffer(buff1); | |
| 451 | |
| 452 EXPECT_TRUE(SBOX_ALL_OK == result); | |
| 453 EXPECT_EQ(tag, client_control->channels[1].ipc_tag); | |
| 454 EXPECT_EQ(kBusyChannel, client_control->channels[0].state); | |
| 455 EXPECT_EQ(kFreeChannel, client_control->channels[1].state); | |
| 456 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 457 | |
| 458 HANDLE t2 = ::CreateThread(NULL, 0, QuickResponseServer, &events, 0, NULL); | |
| 459 ASSERT_TRUE(NULL != t2); | |
| 460 ::CloseHandle(t2); | |
| 461 | |
| 462 client.FreeBuffer(buff0); | |
| 463 events.ping = client_control->channels[0].ping_event; | |
| 464 events.pong = client_control->channels[0].pong_event; | |
| 465 events.state = &client_control->channels[0].state; | |
| 466 | |
| 467 tag = 4567; | |
| 468 CrossCallParamsMock* params2 = new(buff0) CrossCallParamsMock(tag, 1); | |
| 469 FakeOkAnswerInChannel(buff0); | |
| 470 | |
| 471 result = client.DoCall(params2, &answer); | |
| 472 if (SBOX_ERROR_CHANNEL_ERROR != result) | |
| 473 client.FreeBuffer(buff0); | |
| 474 | |
| 475 EXPECT_TRUE(SBOX_ALL_OK == result); | |
| 476 EXPECT_EQ(tag, client_control->channels[0].ipc_tag); | |
| 477 EXPECT_EQ(kFreeChannel, client_control->channels[0].state); | |
| 478 EXPECT_EQ(kFreeChannel, client_control->channels[1].state); | |
| 479 EXPECT_EQ(kFreeChannel, client_control->channels[2].state); | |
| 480 | |
| 481 CloseChannelEvents(client_control); | |
| 482 ::CloseHandle(client_control->server_alive); | |
| 483 | |
| 484 delete[] reinterpret_cast<char*>(client_control); | |
| 485 } | |
| 486 | |
| 487 // This is the server thread that very slowly answers an IPC and exits. Note | |
| 488 // that the pong event needs to be signaled twice. | |
| 489 DWORD WINAPI SlowResponseServer(PVOID param) { | |
| 490 ServerEvents* events = reinterpret_cast<ServerEvents*>(param); | |
| 491 DWORD wait_result = 0; | |
| 492 wait_result = ::WaitForSingleObject(events->ping, INFINITE); | |
| 493 ::Sleep(kIPCWaitTimeOut1 + kIPCWaitTimeOut2 + 200); | |
| 494 ::InterlockedExchange(events->state, kAckChannel); | |
| 495 ::SetEvent(events->pong); | |
| 496 return wait_result; | |
| 497 } | |
| 498 | |
| 499 // This thread's job is to keep the mutex locked. | |
| 500 DWORD WINAPI MainServerThread(PVOID param) { | |
| 501 ServerEvents* events = reinterpret_cast<ServerEvents*>(param); | |
| 502 DWORD wait_result = 0; | |
| 503 wait_result = ::WaitForSingleObject(events->mutex, INFINITE); | |
| 504 Sleep(kIPCWaitTimeOut1 * 20); | |
| 505 return wait_result; | |
| 506 } | |
| 507 | |
| 508 // Creates a server thread that answers the IPC so slow that is guaranteed to | |
| 509 // trigger the time-out code path in the client. A second thread is created | |
| 510 // to hold locked the server_alive mutex: this signals the client that the | |
| 511 // server is not dead and it retries the wait. | |
| 512 TEST(IPCTest, ClientSlowServer) { | |
| 513 size_t base_start = 0; | |
| 514 IPCControl* client_control = | |
| 515 MakeChannels(kIPCChannelSize, 4096*2, &base_start); | |
| 516 FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_NOT_READY); | |
| 517 client_control->server_alive = ::CreateMutex(NULL, FALSE, NULL); | |
| 518 | |
| 519 char* mem = reinterpret_cast<char*>(client_control); | |
| 520 SharedMemIPCClient client(mem); | |
| 521 | |
| 522 ServerEvents events = {0}; | |
| 523 events.ping = client_control->channels[0].ping_event; | |
| 524 events.pong = client_control->channels[0].pong_event; | |
| 525 events.state = &client_control->channels[0].state; | |
| 526 | |
| 527 HANDLE t1 = ::CreateThread(NULL, 0, SlowResponseServer, &events, 0, NULL); | |
| 528 ASSERT_TRUE(NULL != t1); | |
| 529 ::CloseHandle(t1); | |
| 530 | |
| 531 ServerEvents events2 = {0}; | |
| 532 events2.pong = events.pong; | |
| 533 events2.mutex = client_control->server_alive; | |
| 534 | |
| 535 HANDLE t2 = ::CreateThread(NULL, 0, MainServerThread, &events2, 0, NULL); | |
| 536 ASSERT_TRUE(NULL != t2); | |
| 537 ::CloseHandle(t2); | |
| 538 | |
| 539 ::Sleep(1); | |
| 540 | |
| 541 void* buff0 = client.GetBuffer(); | |
| 542 uint32 tag = 4321; | |
| 543 CrossCallReturn answer; | |
| 544 CrossCallParamsMock* params1 = new(buff0) CrossCallParamsMock(tag, 1); | |
| 545 FakeOkAnswerInChannel(buff0); | |
| 546 | |
| 547 ResultCode result = client.DoCall(params1, &answer); | |
| 548 if (SBOX_ERROR_CHANNEL_ERROR != result) | |
| 549 client.FreeBuffer(buff0); | |
| 550 | |
| 551 EXPECT_TRUE(SBOX_ALL_OK == result); | |
| 552 EXPECT_EQ(tag, client_control->channels[0].ipc_tag); | |
| 553 EXPECT_EQ(kFreeChannel, client_control->channels[0].state); | |
| 554 | |
| 555 CloseChannelEvents(client_control); | |
| 556 ::CloseHandle(client_control->server_alive); | |
| 557 delete[] reinterpret_cast<char*>(client_control); | |
| 558 } | |
| 559 | |
| 560 // This test-only IPC dispatcher has two handlers with the same signature | |
| 561 // but only CallOneHandler should be used. | |
| 562 class UnitTestIPCDispatcher : public Dispatcher { | |
| 563 public: | |
| 564 enum { | |
| 565 CALL_ONE_TAG = 78, | |
| 566 CALL_TWO_TAG = 87 | |
| 567 }; | |
| 568 | |
| 569 UnitTestIPCDispatcher(); | |
| 570 ~UnitTestIPCDispatcher() {}; | |
| 571 | |
| 572 virtual bool SetupService(InterceptionManager* manager, int service) { | |
| 573 return true; | |
| 574 } | |
| 575 | |
| 576 private: | |
| 577 bool CallOneHandler(IPCInfo* ipc, HANDLE p1, DWORD p2) { | |
| 578 ipc->return_info.extended[0].handle = p1; | |
| 579 ipc->return_info.extended[1].unsigned_int = p2; | |
| 580 return true; | |
| 581 } | |
| 582 | |
| 583 bool CallTwoHandler(IPCInfo* ipc, HANDLE p1, DWORD p2) { | |
| 584 return true; | |
| 585 } | |
| 586 }; | |
| 587 | |
| 588 UnitTestIPCDispatcher::UnitTestIPCDispatcher() { | |
| 589 static const IPCCall call_one = { | |
| 590 {CALL_ONE_TAG, VOIDPTR_TYPE, ULONG_TYPE}, | |
| 591 reinterpret_cast<CallbackGeneric>( | |
| 592 &UnitTestIPCDispatcher::CallOneHandler) | |
| 593 }; | |
| 594 static const IPCCall call_two = { | |
| 595 {CALL_TWO_TAG, VOIDPTR_TYPE, ULONG_TYPE}, | |
| 596 reinterpret_cast<CallbackGeneric>( | |
| 597 &UnitTestIPCDispatcher::CallTwoHandler) | |
| 598 }; | |
| 599 ipc_calls_.push_back(call_one); | |
| 600 ipc_calls_.push_back(call_two); | |
| 601 } | |
| 602 | |
| 603 // This test does most of the shared memory IPC client-server roundtrip | |
| 604 // and tests the packing, unpacking and call dispatching. | |
| 605 TEST(IPCTest, SharedMemServerTests) { | |
| 606 size_t base_start = 0; | |
| 607 IPCControl* client_control = | |
| 608 MakeChannels(kIPCChannelSize, 4096, &base_start); | |
| 609 client_control->server_alive = HANDLE(1); | |
| 610 FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_READY); | |
| 611 | |
| 612 char* mem = reinterpret_cast<char*>(client_control); | |
| 613 SharedMemIPCClient client(mem); | |
| 614 | |
| 615 CrossCallReturn answer; | |
| 616 HANDLE bar = HANDLE(191919); | |
| 617 DWORD foo = 6767676; | |
| 618 CrossCall(client, UnitTestIPCDispatcher::CALL_ONE_TAG, bar, foo, &answer); | |
| 619 void* buff = client.GetBuffer(); | |
| 620 ASSERT_TRUE(NULL != buff); | |
| 621 | |
| 622 UnitTestIPCDispatcher dispatcher; | |
| 623 // Since we are directly calling InvokeCallback, most of this structure | |
| 624 // can be set to NULL. | |
| 625 sandbox::SharedMemIPCServer::ServerControl srv_control = { | |
| 626 NULL, NULL, kIPCChannelSize, NULL, | |
| 627 reinterpret_cast<char*>(client_control), | |
| 628 NULL, &dispatcher, {0} }; | |
| 629 | |
| 630 sandbox::CrossCallReturn call_return = {0}; | |
| 631 EXPECT_TRUE(SharedMemIPCServer::InvokeCallback(&srv_control, buff, | |
| 632 &call_return)); | |
| 633 EXPECT_EQ(SBOX_ALL_OK, call_return.call_outcome); | |
| 634 EXPECT_TRUE(bar == call_return.extended[0].handle); | |
| 635 EXPECT_EQ(foo, call_return.extended[1].unsigned_int); | |
| 636 | |
| 637 CloseChannelEvents(client_control); | |
| 638 delete[] reinterpret_cast<char*>(client_control); | |
| 639 } | |
| 640 | |
| 641 } // namespace sandbox | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10689170:
Move the Windows sandbox to sandbox/win (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src