sandbox/win/src/ipc_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/basictypes.h"
   6 #include "sandbox/win/src/crosscall_client.h"
   7 #include "sandbox/win/src/crosscall_server.h"
   8 #include "sandbox/win/src/sharedmem_ipc_client.h"
   9 #include "sandbox/win/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, &param_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, &param_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, &param_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, &param_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, &param_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, &param_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, &param_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, &param_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