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 "ppapi/tests/test_tcp_server_socket_private.h" 6 7 #include <cstdio> 8 #include <vector> 9 10 #include "ppapi/cpp/pass_ref.h" 11 #include "ppapi/cpp/private/net_address_private.h" 12 #include "ppapi/cpp/private/tcp_server_socket_private.h" 13 #include "ppapi/cpp/private/tcp_socket_private.h" 14 #include "ppapi/tests/test_utils.h" 15 #include "ppapi/tests/testing_instance.h" 16 17 using pp::NetAddressPrivate; 18 using pp::TCPServerSocketPrivate; 19 using pp::TCPSocketPrivate; 20 21 namespace { 22 23 const uint16_t kPortScanFrom = 1024; 24 const uint16_t kPortScanTo = 4096; 25 26 } // namespace 27 28 REGISTER_TEST_CASE(TCPServerSocketPrivate); 29 30 TestTCPServerSocketPrivate::TestTCPServerSocketPrivate( 31 TestingInstance* instance) : TestCase(instance) { 32 } 33 34 bool TestTCPServerSocketPrivate::Init() { 35 bool tcp_server_socket_private_is_available = 36 TCPServerSocketPrivate::IsAvailable(); 37 if (!tcp_server_socket_private_is_available) { 38 instance_->AppendError( 39 "PPB_TCPServerSocket_Private interface not available"); 40 } 41 42 bool tcp_socket_private_is_available = TCPSocketPrivate::IsAvailable(); 43 if (!tcp_socket_private_is_available) 44 instance_->AppendError("PPB_TCPSocket_Private interface not available"); 45 46 bool net_address_private_is_available = NetAddressPrivate::IsAvailable(); 47 if (!net_address_private_is_available) 48 instance_->AppendError("PPB_NetAddress_Private interface not available"); 49 50 bool init_host_port = GetLocalHostPort(instance_->pp_instance(), 51 &host_, &port_); 52 if (!init_host_port) 53 instance_->AppendError("Can't init host and port"); 54 55 return tcp_server_socket_private_is_available && 56 tcp_socket_private_is_available && 57 net_address_private_is_available && 58 init_host_port && 59 CheckTestingInterface() && 60 EnsureRunningOverHTTP(); 61 } 62 63 void TestTCPServerSocketPrivate::RunTests(const std::string& filter) { 64 RUN_CALLBACK_TEST(TestTCPServerSocketPrivate, Listen, filter); 65 RUN_CALLBACK_TEST(TestTCPServerSocketPrivate, Backlog, filter); 66 } 67 68 std::string TestTCPServerSocketPrivate::GetLocalAddress( 69 PP_NetAddress_Private* address) { 70 TCPSocketPrivate socket(instance_); 71 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 72 callback.WaitForResult( 73 socket.Connect(host_.c_str(), port_, callback.GetCallback())); 74 CHECK_CALLBACK_BEHAVIOR(callback); 75 ASSERT_EQ(PP_OK, callback.result()); 76 ASSERT_TRUE(socket.GetLocalAddress(address)); 77 socket.Disconnect(); 78 PASS(); 79 } 80 81 std::string TestTCPServerSocketPrivate::SyncRead(TCPSocketPrivate* socket, 82 char* buffer, 83 size_t num_bytes) { 84 while (num_bytes > 0) { 85 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 86 callback.WaitForResult( 87 socket->Read(buffer, num_bytes, callback.GetCallback())); 88 CHECK_CALLBACK_BEHAVIOR(callback); 89 ASSERT_TRUE(callback.result() >= 0); 90 buffer += callback.result(); 91 num_bytes -= callback.result(); 92 } 93 PASS(); 94 } 95 96 std::string TestTCPServerSocketPrivate::SyncWrite(TCPSocketPrivate* socket, 97 const char* buffer, 98 size_t num_bytes) { 99 while (num_bytes > 0) { 100 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 101 callback.WaitForResult( 102 socket->Write(buffer, num_bytes, callback.GetCallback())); 103 CHECK_CALLBACK_BEHAVIOR(callback); 104 ASSERT_TRUE(callback.result() >= 0); 105 buffer += callback.result(); 106 num_bytes -= callback.result(); 107 } 108 PASS(); 109 } 110 111 std::string TestTCPServerSocketPrivate::SyncConnect( 112 TCPSocketPrivate* socket, 113 PP_NetAddress_Private* address) { 114 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 115 callback.WaitForResult( 116 socket->ConnectWithNetAddress(address, callback.GetCallback())); 117 CHECK_CALLBACK_BEHAVIOR(callback); 118 ASSERT_EQ(PP_OK, callback.result()); 119 PASS(); 120 } 121 122 void TestTCPServerSocketPrivate::ForceConnect(TCPSocketPrivate* socket, 123 PP_NetAddress_Private* address) { 124 std::string error_message; 125 do { 126 error_message = SyncConnect(socket, address); 127 } while (!error_message.empty()); 128 } 129 130 std::string TestTCPServerSocketPrivate::SyncListen( 131 TCPServerSocketPrivate* socket, 132 PP_NetAddress_Private* address, 133 int32_t backlog) { 134 PP_NetAddress_Private base_address; 135 ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address)); 136 if (!NetAddressPrivate::ReplacePort(base_address, 0, address)) 137 return ReportError("PPB_NetAddress_Private::ReplacePort", 0); 138 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 139 callback.WaitForResult( 140 socket->Listen(address, backlog, callback.GetCallback())); 141 CHECK_CALLBACK_BEHAVIOR(callback); 142 ASSERT_EQ(PP_OK, callback.result()); 143 int32_t rv = socket->GetLocalAddress(address); 144 ASSERT_EQ(PP_OK, rv); 145 ASSERT_TRUE(NetAddressPrivate::GetPort(*address) != 0); 146 PASS(); 147 } 148 149 std::string TestTCPServerSocketPrivate::TestListen() { 150 static const int kBacklog = 2; 151 152 TCPServerSocketPrivate server_socket(instance_); 153 PP_NetAddress_Private address; 154 ASSERT_SUBTEST_SUCCESS(SyncListen(&server_socket, &address, kBacklog)); 155 156 // We can't use a blocking callback for Accept, because it will wait forever 157 // for the client to connect, since the client connects after. 158 TestCompletionCallback accept_callback(instance_->pp_instance(), PP_REQUIRED); 159 // We need to make sure there's a message loop to run accept_callback on. 160 pp::MessageLoop current_thread_loop(pp::MessageLoop::GetCurrent()); 161 if (current_thread_loop.is_null() && testing_interface_->IsOutOfProcess()) { 162 current_thread_loop = pp::MessageLoop(instance_); 163 current_thread_loop.AttachToCurrentThread(); 164 } 165 166 PP_Resource resource; 167 int32_t accept_rv = server_socket.Accept(&resource, 168 accept_callback.GetCallback()); 169 170 TCPSocketPrivate client_socket(instance_); 171 ForceConnect(&client_socket, &address); 172 173 accept_callback.WaitForResult(accept_rv); 174 CHECK_CALLBACK_BEHAVIOR(accept_callback); 175 ASSERT_EQ(PP_OK, accept_callback.result()); 176 177 ASSERT_TRUE(resource != 0); 178 TCPSocketPrivate accepted_socket(pp::PassRef(), resource); 179 180 const char kSentByte = 'a'; 181 ASSERT_SUBTEST_SUCCESS(SyncWrite(&client_socket, 182 &kSentByte, 183 sizeof(kSentByte))); 184 185 char received_byte; 186 ASSERT_SUBTEST_SUCCESS(SyncRead(&accepted_socket, 187 &received_byte, 188 sizeof(received_byte))); 189 ASSERT_EQ(kSentByte, received_byte); 190 191 accepted_socket.Disconnect(); 192 client_socket.Disconnect(); 193 server_socket.StopListening(); 194 195 PASS(); 196 } 197 198 std::string TestTCPServerSocketPrivate::TestBacklog() { 199 static const size_t kBacklog = 5; 200 201 TCPServerSocketPrivate server_socket(instance_); 202 PP_NetAddress_Private address; 203 ASSERT_SUBTEST_SUCCESS(SyncListen(&server_socket, &address, 2 * kBacklog)); 204 205 std::vector<TCPSocketPrivate*> client_sockets(kBacklog); 206 std::vector<TestCompletionCallback*> connect_callbacks(kBacklog); 207 std::vector<int32_t> connect_rv(kBacklog); 208 for (size_t i = 0; i < kBacklog; ++i) { 209 client_sockets[i] = new TCPSocketPrivate(instance_); 210 connect_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(), 211 callback_type()); 212 connect_rv[i] = client_sockets[i]->ConnectWithNetAddress( 213 &address, 214 connect_callbacks[i]->GetCallback()); 215 } 216 217 std::vector<PP_Resource> resources(kBacklog); 218 std::vector<TCPSocketPrivate*> accepted_sockets(kBacklog); 219 for (size_t i = 0; i < kBacklog; ++i) { 220 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 221 callback.WaitForResult( 222 server_socket.Accept(&resources[i], callback.GetCallback())); 223 CHECK_CALLBACK_BEHAVIOR(callback); 224 ASSERT_EQ(PP_OK, callback.result()); 225 226 ASSERT_TRUE(resources[i] != 0); 227 accepted_sockets[i] = new TCPSocketPrivate(pp::PassRef(), resources[i]); 228 } 229 230 for (size_t i = 0; i < kBacklog; ++i) { 231 connect_callbacks[i]->WaitForResult(connect_rv[i]); 232 CHECK_CALLBACK_BEHAVIOR(*connect_callbacks[i]); 233 ASSERT_EQ(PP_OK, connect_callbacks[i]->result()); 234 } 235 236 for (size_t i = 0; i < kBacklog; ++i) { 237 const char byte = 'a' + i; 238 ASSERT_SUBTEST_SUCCESS(SyncWrite(client_sockets[i], &byte, sizeof(byte))); 239 } 240 241 bool byte_received[kBacklog] = {}; 242 for (size_t i = 0; i < kBacklog; ++i) { 243 char byte; 244 ASSERT_SUBTEST_SUCCESS(SyncRead(accepted_sockets[i], &byte, sizeof(byte))); 245 const size_t index = byte - 'a'; 246 ASSERT_FALSE(byte_received[index]); 247 byte_received[index] = true; 248 } 249 250 for (size_t i = 0; i < kBacklog; ++i) { 251 client_sockets[i]->Disconnect(); 252 delete client_sockets[i]; 253 delete connect_callbacks[i]; 254 accepted_sockets[i]->Disconnect(); 255 delete accepted_sockets[i]; 256 } 257 258 server_socket.StopListening(); 259 PASS(); 260 } 261
